CC Plugin Market

Two complementary Claude Code plugins for Spec-Driven Development: reverse-engineer existing code into structured specs + queryable knowledge graph (Spectra), and orchestrate new feature development through 8-mode autonomous workflows (Spec Driver).

Table of Contents

• What's inside
• Quick Start
• Spectra
  • Highlights
  • 🤖 How AI Coding Assistants Use Spectra
• Spec Driver
  • Highlights
• Domain Knowledge Scaffold
• Plugin Installation
• Documentation
• Contributing · License

What's inside

┌──────────────────────────┐    ┌──────────────────────────────┐
│      Spectra              │    │       Spec Driver            │
│  (Reverse Engineer)       │    │  (Forward Orchestrator)      │
│                           │    │                              │
│  Code → Spec + Graph      │    │  Idea → Spec → Plan → Code  │
│  + MCP for AI assistants  │    │  + Per-project overrides     │
└──────────────────────────┘    └──────────────────────────────┘

Quick Start

# 1. Install Spectra CLI globally
npm install -g spectra-cli

# 2. Add the marketplace to Claude Code
claude plugin marketplace add connor-git-yaml/cc-plugin-market

# 3. Install both plugins (user-scope, available across all projects)
claude plugin install spectra@cc-plugin-market --scope user
claude plugin install spec-driver@cc-plugin-market --scope user

# 4. In any project, generate a Spec + Knowledge Graph
cd your-project/
spectra batch --mode reading --html       # ~2-5 min for typical project

# 5. Use Spec Driver for new features (in Claude Code)
/spec-driver:spec-driver-feature  Add OAuth2 login flow

After step 4, AI coding assistants (Claude Code, Cursor, Codex with MCP) can query your codebase architecture via 18 MCP tools (6 graph queries + 3 agent-context + 3 file-navigation + 6 pipeline) — see How AI Coding Assistants Use Spectra below.

Spectra

A hybrid AST + LLM pipeline that reverse-engineers source code into structured Spec documents and builds a persistent knowledge graph of architecture relationships. Multi-language (TS/JS/Python/Go/Java), multi-format export (Markdown / Obsidian Vault / interactive graph.html), MCP-queryable.

Spectra Highlights

• 📝 9-section module specs — AST-extracted intent / interface / data / dependencies / quality / lifecycle / etc. (TS/JS interface 100% AST-extracted)
• 🌐 Knowledge graph schema v2.0 — references / conceptually_related_to / rationale_for edges + multi-node hyperedges
• 🔍 18 MCP tools — graph queries (community / god-nodes / hyperedges / path) + agent context (impact / context / detect_changes with unified {code} error contract + per-call telemetry) + file navigation (token-efficient line-range reads, symbol fuzzy match) + pipeline (prepare / generate / batch / diff / panoramic-query / server_build_info)
• 📊 Interactive graph.html — D3-force visualization with hyperedge convex hulls (self-contained, no server)
• 💰 LLM cost transparency — --dry-run cost preview + --budget N enforcement + tokenUsage in every spec frontmatter
• ⚡ Lightweight modes — --mode reading (skip product docs) / --mode code-only (skip enrichment, still per-module spec-gen LLM) / --mode graph-only (pure AST, zero LLM, no auth)
• 🚧 Technical debt extraction — TODO/FIXME/HACK code comments + design-doc Open Questions
• 🔄 Continuous sync — spectra watch (file watcher) or spectra install (post-commit hook)
• 🌍 Multi-language — TS/JS (ts-morph) + Python (AST + tree-sitter) + Go/Java/Rust (tree-sitter)
• 🎯 Honest uncertainty — [inferred] / [unclear] labels; raw source never sent directly to LLM
• 🔐 Read-only safety — writes limited to specs/, _meta/, drift-logs/

🤖 How AI Coding Assistants Use Spectra

The big idea: Spectra builds a persistent architecture knowledge graph once, then any MCP-aware AI assistant queries it on demand — no re-reading the entire codebase every session.

   ┌─────────────────────┐      Step 1: Build once
   │   Your codebase     │      ───────────────────
   │   (any language)    │      $ spectra batch --html --hyperedges
   └──────────┬──────────┘             ↓
              │
              ▼
   ┌─────────────────────┐
   │  specs/             │      Persistent artifacts:
   │   ├── modules/      │      • 9-section module specs
   │   ├── project/      │      • technical-debt.md
   │   └── _meta/        │      • graph.json (schema v2.0)
   │       ├── graph.json│      • graph.html (D3 interactive)
   │       └── graph.html│      • GRAPH_REPORT.md (communities + god nodes)
   └──────────┬──────────┘
              │            Step 2: AI queries via MCP
              │            ─────────────────────────
              ▼
   ┌────────────────────────────────────────────────┐
   │  Claude Code / Cursor / Codex / Aider / ...    │
   │                                                 │
   │  User: "Where is auth handled?"                 │
   │                                                 │
   │  AI calls MCP graph_query("auth")               │
   │       ↓                                         │
   │  Returns: relevant module specs + dependencies  │
   │       ↓                                         │
   │  AI answers with cited specs + line numbers    │
   └────────────────────────────────────────────────┘

MCP query tools (6 + natural-language Q&A)

Plus the higher-level panoramic-query MCP tool with natural-language operation (Phase 2 F5):

panoramic-query({
  operation: "natural-language",
  question: "What calls storage directly? What's the shortest path from parser to processor?",
  projectRoot: "."
})
// → Returns RAG-style answer with cited spec excerpts + line numbers + graph context

This is AI-for-AI architecture memory: the AI never has to re-read your codebase from scratch.

Why this matters

• Token economics — Querying a 50K-token graph instead of re-reading 500K LOC saves 90%+ tokens per session
• Cross-session memory — _meta/graph.json persists between Claude Code sessions; AI can ask "what changed since last time?"
• Multi-IDE compatible — Same MCP server works for Claude Code, Cursor, Codex, Aider, OpenCode, etc.
• Hook-driven freshness — spectra install --git registers a post-commit hook that rebuilds the graph in the background via spectra batch --mode graph-only (full pure-AST rebuild, zero LLM); AI always queries the latest

Trigger via auto-injection (PreToolUse hook)

When spectra install is active, Claude Code's PreToolUse hook automatically injects relevant architecture summary before the AI runs Grep / Glob searches — so the AI knows the answer is in specs/modules/auth.spec.md before fanning out to read 30 source files.

📚 Full details: docs/spectra-cli-reference.md

Spec Driver

Spec Driver is a Claude Code plugin that serves as an autonomous development orchestrator. Automates the full Spec-Driven Development lifecycle through 14 specialized sub-agents, 6 quality gates, 8 execution modes, and project-level workflow overrides.

Spec Driver Highlights

• 🎼 8 execution modes — feature / implement / story / fix / refactor / resume / sync / doc
• 🔬 Parallel sub-agent dispatch — RESEARCH_GROUP, DESIGN_PREP_GROUP, VERIFY_GROUP run in parallel; auto-fallback to serial
• 🚦 6 quality gates — GATE_RESEARCH / GATE_DESIGN / GATE_ANALYSIS / GATE_TASKS / GATE_IMPLEMENT_MID / GATE_VERIFY
• 🔧 Per-project workflow overrides — .specify/orchestration-overrides.yaml (like ESLint extends or Docker Compose override)
• 🎯 Multi-runtime model compat — Same configs work in Claude (Sonnet/Opus) and Codex (tier-mapped via model_compat.aliases.codex + thinking levels)
• 🛡️ Quality reviews — spec-review (compliance) + quality-review (architecture/readability) + verify (build/lint/test)

Mode selection (TL;DR)

📚 Full details: docs/spec-driver-modes.md — all phases, sub-agents, generated artifacts. 📚 Project-level workflow customization: docs/configuration.md#per-project-orchestration-overrides — override phases / gates / parallelism per project.

v4.0 Breaking Change: The 9 atomic commands (/spec-driver.specify etc.) have been removed. See migration guide.

Domain Knowledge Scaffold

Beyond your own codebase (Spectra) and your dev workflow (Spec Driver), the marketplace ships a third capability: turn external vendor docs into a queryable knowledge base your AI assistant can cite — and distribute it as a plugin so integrators get it out of the box.

Typical end-to-end path: build a vendor KB from public SDK docs → ingest a partner spec (docx) into your project layer → ask your assistant an API question — kb_search answers with cited sources. Full walkthrough with worked examples: Domain Knowledge Scaffold Guide.

Plugin Installation

Prerequisites

• Claude Code CLI installed and authenticated
• Node.js 20.x+

Note: Plugin Marketplace commands are Claude Code specific. For Codex, use the CLI + skill installation flow in the Codex section below.

Add the Marketplace

# GitHub shorthand (recommended)
claude plugin marketplace add connor-git-yaml/cc-plugin-market

# Or use the full HTTPS URL
claude plugin marketplace add https://github.com/connor-git-yaml/cc-plugin-market.git

Both forms register the marketplace under the name cc-plugin-market (defined in .claude-plugin/marketplace.json), which the install commands below reference.

Install Plugins

# Install to current project (recommended — scoped to this project only)
claude plugin install spec-driver@cc-plugin-market --scope project
claude plugin install spectra@cc-plugin-market --scope project

# Or install for current user (available across all projects)
claude plugin install spec-driver@cc-plugin-market --scope user
claude plugin install spectra@cc-plugin-market --scope user

Update / Uninstall

# Refresh marketplace cache then reinstall to upgrade
claude plugin marketplace update cc-plugin-market
claude plugin install spec-driver@cc-plugin-market --scope <scope>

# Uninstall
claude plugin remove spec-driver --scope <scope>
claude plugin remove spectra --scope <scope>

Verify

claude plugin list                                # list installed plugins
/spec-driver:spec-driver-doc                      # test spec-driver
/spectra src/                                     # test spectra

Codex Support

Codex discovers this repository as a plugin marketplace. Installing the plugin registers both the Codex wrapper skills and the plugin's own hooks — no extra installer step:

# Add this repo as a Codex marketplace (local clone or Git URL)
codex plugin marketplace add <path-to-clone-or-git-url>

# Install the plugin (skills + hooks in one step)
codex plugin add spec-driver@cc-plugin-market

# Verify what got registered
codex plugin list

What you get after codex plugin add:

• Skills from the plugin's skills-codex/ directory
• 5 hooks declared in the plugin's hooks/hooks.json, registered with source=plugin (SessionStart, PreToolUse, PostToolUse, and two Stop handlers). ${CLAUDE_PLUGIN_ROOT} is expanded by Codex to the installed plugin cache path.
• Hooks land as trustStatus=untrusted: you must grant hook trust inside Codex once, otherwise they are registered but never execute.

Notes and known limits:

• The WorktreeCreate / WorktreeRemove hooks in the canonical declaration are Claude-only events; Codex drops them silently (no warning). This is expected — they have no Codex equivalent.
• Spectra's MCP tools are configured separately (plugins/spectra/.mcp.json); install the spectra CLI with npm install -g spectra-cli if you want the MCP server available in Codex.

If you do not want to install the plugin — or your Codex build does not support plugins — install just the wrapper skills:

# Spectra CLI + skills
npm install -g spectra-cli
spectra init --target codex             # project-level  (.codex/skills)
spectra init --global --target codex    # global         ($CODEX_HOME/skills)
spectra init --global --target both     # Claude + Codex in one command

# Spec Driver skills (run from repository root)
npm run codex:spec-driver:install                 # project-level
npm run codex:spec-driver:install:global          # global
npm run codex:spec-driver:remove                  # remove

# Equivalent low-level script
bash plugins/spec-driver/scripts/codex-skills.sh install [--global]

Notes:

• Project mode installs to the current git repository root (or the current directory when not in a git repo).
• Codex skills are generated from the current spec-driver-* source skills with a small Codex runtime adapter block; rerun install after upgrading Spec Driver.
• --global additionally merges the Spec Driver hook entries into $CODEX_HOME/hooks.json. This is the fallback registration path only.

The plugin's own hooks/hooks.json and the global $CODEX_HOME/hooks.json are two independent registration sources, and Codex does not de-duplicate between them. Running both paths registers every hook twice — the Stop-hook judge then runs twice per turn and burns its block budget in a single turn.

codex-skills.sh install --global therefore detects an existing native plugin registration and refuses to merge the hook entries (skill installation still completes normally):

[codex-hooks] 已检测到 Codex 原生插件注册（marketplace=...），跳过合并写入以避免同一 hook 被注册两次

• To remove hook entries written by an earlier merger run without touching installed skills: node plugins/spec-driver/scripts/install-codex-hooks.mjs --codex-home "$CODEX_HOME" --remove. Note that codex-skills.sh remove --global also deletes the nine spec-driver-* skill directories under $CODEX_HOME/skills, not just the hook entries.
• To override the guard (only if you have verified your Codex build does not read plugin hooks): append --force-hooks. Doing so on a build that does read them produces duplicates.

Documentation

• 📘 Spectra CLI Reference — full command list, knowledge graph workflows, architecture pipeline diagram
• 📚 Domain Knowledge Scaffold Guide — build a vendor doc KB (scaffold-kb), ship it as a plugin, query via KB MCP tools
• 🎼 Spec Driver Modes — 8 modes detailed, sub-agents, generated artifacts, quality gates
• ⚙️ Configuration — model presets (spec-driver.config.yaml) + project-level orchestration overrides (.specify/orchestration-overrides.yaml)
• 🏛️ Repository Architecture — src/ layout, tech stack, testing, sync contracts
• 🤝 Contributor Guide — full contribution flow
• 📜 Migration Guides — v4.0 atomic skill removal, orchestration overrides
• 📊 SWE-Bench Evaluation Report — honest 150-run 5-cohort comparison; after correcting a one-sided oracle bias, completion rates tie within noise — the real gap is MCP adoption, not quality (runs that called the tools passed 43% vs 12%)

Contributing

Bug reports and pull requests are welcome. Please open an issue first to discuss what you would like to change.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'feat: add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

See docs/contributor-guide.md for full guidelines including the repo:check validation requirements.

License

This project is licensed under the MIT License - see the LICENSE file for details.