Metadata-Version: 2.4
Name: scs-mcp
Version: 0.5.3
Summary: SCS - AI Capability Compiler. Turn scattered skills into verified, executable pipelines.
Project-URL: Homepage, https://github.com/lonyness/Skill-Compiler-System
Project-URL: Documentation, https://github.com/lonyness/Skill-Compiler-System#readme
Project-URL: Repository, https://github.com/lonyness/Skill-Compiler-System.git
Project-URL: Issues, https://github.com/lonyness/Skill-Compiler-System/issues
Project-URL: Changelog, https://github.com/lonyness/Skill-Compiler-System/releases
Author-email: SCS Team <scs-team@example.com>
License: Apache-2.0
License-File: LICENSE
Keywords: agent,ai,claude-code,cline,compiler,cursor,mcp,skills,windsurf
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: Topic :: Software Development :: Compilers
Requires-Python: >=3.9
Requires-Dist: mcp>=1.0.0
Requires-Dist: pydantic>=2.0.0
Provides-Extra: dev
Requires-Dist: build>=1.0.0; extra == 'dev'
Requires-Dist: pytest>=7.0.0; extra == 'dev'
Requires-Dist: twine>=4.0.0; extra == 'dev'
Description-Content-Type: text/markdown

# SCS — Skill Compiler System

**[中文版](README_CN.md)**

> **Turn scattered skills into reliable workflows**

You've collected many skill files. But when it's time to actually use them:

- *"Which ones do I need for this task?"*
- *"Can they chain together? Or will it break halfway?"*
- *"Why do I have to manually piece them together, with no way to know if it will work?"*

**The core problem**: Skills are defined separately, but they need to work together. Nobody builds the bridges.

---

## What SCS Does for You

SCS is a **compiler**. It doesn't execute your skills — instead, it:

1. **Scans all skills across all agents** — automatically discovers skills from Claude Code, Cursor, Windsurf, Cline, and 40+ platforms
2. **Connects them** — automatically links skills that can work together
3. **Verifies feasibility** — tells you if the workflow will run, where gaps exist
4. **Generates a plan** — gives you a verified execution blueprint you can trust

Think of it like **Terraform Plan** for AI skills: you see a full preview with verification *before* anything runs.

---

## Cross-Platform Skill Discovery

When you call `scs_init()` without specifying a path, SCS automatically scans **all installed agent platforms**:

```
scs_init()
→ Scanning 4 platforms: claude_code, cursor, windsurf, cline
→ Found 2465 skills, 176 artifact types
```

**Important**: SCS discovers skills from all platforms, but each agent can only **invoke** skills in its own skills directory. If the recommended skill comes from another platform, you'll need to:
- Install that agent, or
- Copy the skill to your current agent's skills directory

The execution plan shows which platform each skill comes from, so you know what's available.

---

## One-Click Install

After cloning or downloading SCS, run one command:

```bash
# Install to Claude Code
python -m scs.cli install --agent claude_code --force

# Or install to all supported agents
python -m scs.cli install --all --force
```

Restart your agent and SCS tools are ready.

**What gets installed**:
1. **MCP tools** — 8 SCS tools available in your agent
2. **SCS Router Skill** — automatically injected to your agent's skills directory, guiding when to use SCS

**Supported agents**: Claude Code, Cursor, Windsurf, Cline

---

## Manual Install

If you prefer manual configuration, add to `~/.claude/settings.json`:

```json
{
  "mcpServers": {
    "scs": {
      "command": "python",
      "args": ["-m", "scs.mcp_server"],
      "cwd": "/path/to/SCS",
      "env": { "PYTHONUTF8": "1" }
    }
  }
}
```

Replace `/path/to/SCS` with your SCS directory.

---

## CLI Commands

| Command | What it does |
|---------|-------------|
| `scs install --agent claude_code` | Install to Claude Code |
| `scs install --all --force` | Install to all supported agents |
| `scs config` | Show configuration help |
| `scs path` | Show installation path |

---

## Tool Overview

After installation, your agent will have 8 new tools. You mainly use these 5:

### scs_init — Initialize (call this first)

Scans skills, connects them, generates execution plans.

```
# Scan all agents' skills
scs_init()

# Solve optimal path to a target
scs_init(target="ValidatedPRD", prefer="balanced")
```

### scs_scan — Scan (for large skill sets)

Scans and registers skills, but doesn't generate plans. Use when you have many skills.

```
scs_scan()
→ Scanned and registered 2465 skills
```

### scs_compile — Compile

Generates execution plans from already-scanned skills.

```
scs_compile(target="ValidatedPRD")
→ Compiled, found optimal path
```

### scs_list — List things

```
scs_list(type="dag")       # All execution plans
scs_list(type="skills")    # All skills
scs_list(type="artifacts") # All artifact types
```

### scs_get — Get details

```
scs_get(type="dag", id="plan_xxx")
scs_get(type="skill", id="prd_generator")
```

---

## Typical Workflow

```
# 1. Start fresh
scs_clear()

# 2. Scan and generate plans
scs_init()

# 3. See what was created
scs_list(type="dag")

# 4. Find optimal path to your target
scs_init(target="ValidatedPRD", prefer="balanced")

# 5. Understand why SCS chose this path
scs_diagnostics(plan_id="plan_xxx")
```

---

## Large Skill Set Workflow

When you have 2000+ skills, use the phased approach to avoid timeout:

```
scs_scan()                       # Step 1: Scan (~90s)
scs_list(type="artifacts")       # Step 2: Explore
scs_compile(target="YourTarget") # Step 3: Compile (~30s)
```

---

## Use Cases

SCS covers **8 industries, 176 artifact types**:

| Industry | Example artifacts |
|----------|------------------|
| Software | Requirements doc, source code, test report |
| Legal | Contract, legal opinion, due diligence report |
| Marketing | Marketing plan, brand guidelines, ad copy |
| Finance | Financial report, invoice, ROI analysis |
| HR | Job description, resume, performance review |
| Research | Research paper, literature review, grant application |
| Content | Article, blog post, video script |
| Operations | Service ticket, SOP, incident report |

---

<p align="center">
  <strong>SCS — Compile skills, not chaos.</strong>
</p>