JSPM

  • ESM via JSPM
  • ES Module Entrypoint
  • Export Map
  • Keywords
  • License
  • Repository URL
  • TypeScript Types
  • README
  • Created
  • Published
  • Downloads 57
  • Score
    100M100P100Q69184F
  • License MIT

Claude Code plugin that automates the full dev cycle — spec, plan, implement, review, clean.

Package Exports

    This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (all-for-claudecode) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

    Readme

    all-for-claudecode

    all-for-claudecode

    Claude Code plugin that automates the full development cycle — spec → plan → implement → review → clean.

    npm version npm downloads license test

    One command (/afc:auto) runs the entire cycle. Zero runtime dependencies — pure markdown commands + bash hook scripts.

    Quick Start

    # Option A: Inside Claude Code
/plugin marketplace add jhlee0409/all-for-claudecode
/plugin install afc@all-for-claudecode

# Option B: npx
npx all-for-claudecode

    Then:

    /afc:init                              # Detect your stack, generate config
/afc:auto "Add user authentication"    # Run the full pipeline

    The pipeline will:

    1. Write a feature spec with acceptance criteria
    2. Design an implementation plan with file change map
    3. Implement tasks with CI gates (auto task decomposition + parallel execution)
    4. Run code review with architecture/security agent analysis
    5. Clean up artifacts and prepare for commit

    How It Works

    /afc:auto "Add feature X"

Spec (1/5) → Plan (2/5) → Implement (3/5) → Review (4/5) → Clean (5/5)
  │              │              │                │              │
  │              │              │                │              └─ Artifact cleanup
  │              │              │                └─ 8 perspectives + agent review
  │              │              └─ Auto task decomposition, parallel execution, CI gates
  │              └─ File change map, ADR recording, research persistence
  └─ Acceptance criteria, pre-implementation gates

Hooks run automatically at each step.
CI failure → debug-based RCA (not blind retry).
Critic Loops verify quality at each gate until convergence.

    Slash Commands

    Command Description
    /afc:auto Full Auto pipeline — runs all 5 phases
    /afc:spec Write feature specification with acceptance criteria
    /afc:plan Design implementation plan with file change map
    /afc:implement Execute code implementation with CI gates
    /afc:test Test strategy planning and test writing
    /afc:review Code review with architecture/security scanning
    /afc:research Technical research with persistent storage
    /afc:debug Bug diagnosis and fix
    /afc:init Project setup — detects stack and generates config
    /afc:doctor Diagnose project health and plugin setup
    /afc:architect Architecture analysis (persistent memory)
    /afc:security Security scan (persistent memory, isolated worktree)
    /afc:principles Project principles management
    /afc:checkpoint Save session state
    /afc:resume Restore session state
    /afc:tasks Task decomposition (auto-generated by implement)
    /afc:analyze Verify artifact consistency
    /afc:clarify Resolve spec ambiguities

    Hook Events

    Every hook fires automatically — no configuration needed after install.

    Hook What it does
    SessionStart Restores pipeline state on session resume
    PreCompact Auto-checkpoints before context compression
    PreToolUse Blocks dangerous commands (push --force, reset --hard)
    PostToolUse Tracks file changes + auto-formats code
    SubagentStart Injects pipeline context into subagents
    Stop CI gate (shell) + code completeness check (agent)
    SessionEnd Warns about unfinished pipeline
    PostToolUseFailure Diagnostic hints for known error patterns
    Notification Desktop alerts (macOS/Linux)
    TaskCompleted CI gate (shell) + acceptance criteria verification (LLM)
    SubagentStop Tracks subagent completion in pipeline log
    UserPromptSubmit Injects Phase/Feature context per prompt
    PermissionRequest Auto-allows CI commands during implement/review
    ConfigChange Audits/blocks settings changes during active pipeline
    TeammateIdle Prevents Agent Teams idle during implement/review
    WorktreeCreate Sets up worktree isolation for parallel workers
    WorktreeRemove Cleans up worktree after worker completion

    Handler types: command (shell scripts, all events), prompt (LLM single-turn, TaskCompleted), agent (subagent with tools, Stop).

    Persistent Memory Agents

    Agent Role
    afc-architect Remembers ADR decisions and architecture patterns across sessions. Auto-invoked during Plan (ADR recording) and Review (architecture compliance).
    afc-security Remembers vulnerability patterns and false positives across sessions. Auto-invoked during Review (security scanning). Runs in isolated worktree.
    afc-impl-worker Parallel implementation worker. Receives pre-assigned tasks from orchestrator. Ephemeral (no memory).

    Task Orchestration

    The implement phase automatically selects execution strategy:

    Parallel tasks in phase Mode
    0 Sequential — one task at a time
    1–5 Parallel Batch — concurrent Task() calls
    6+ Swarm — orchestrator pre-assigns tasks to worker agents (max 5)

    Dependencies are tracked via DAG. CI gate + Mini-Review + Auto-Checkpoint run at each phase boundary.

    Project Presets

    Preset Stack
    template Generic (manual config)
    nextjs-fsd Next.js + FSD + Zustand + React Query
    react-spa Vite + React 18 + Zustand + Tailwind
    express-api Express + TypeScript + Prisma + Jest
    monorepo Turborepo + pnpm workspace

    Configuration

    /afc:init

    Detects your tech stack and generates .claude/afc.config.md with CI/lint/test commands, architecture rules, framework settings, and code style conventions.

    FAQ

    Does it work with any project?

    Yes. Run /afc:init to auto-detect your stack, or pick a preset.

    Does it require any dependencies?

    No. Pure markdown commands + bash hook scripts.

    What happens if CI fails during the pipeline?

    Debug-based RCA: traces the error, forms a hypothesis, applies a targeted fix. Halts after 3 failed attempts with full diagnosis.

    Can I run individual phases?

    Yes. Each phase has its own command (/afc:spec, /afc:plan, /afc:implement, /afc:review). /afc:auto runs them all.

    What are Critic Loops?

    Convergence-based quality checks after each phase. They evaluate output against criteria (completeness, feasibility, architecture compliance) and auto-fix issues until stable. 4 verdicts: PASS, FAIL, ESCALATE (asks user), DEFER.

    License

    MIT