all-for-claudecode 2.0.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,21 @@
+{
+  "name": "all-for-claudecode",
+  "owner": {
+    "name": "jhlee0409",
+    "email": "relee6203@gmail.com"
+  },
+  "metadata": {
+    "description": "Automated pipeline for Claude Code — spec → plan → tasks → implement → review → clean",
+    "version": "2.0.0"
+  },
+  "plugins": [
+    {
+      "name": "afc",
+      "source": "./",
+      "description": "Automated pipeline for Claude Code. Automates the full development cycle: spec → plan → tasks → implement → review → clean.",
+      "version": "2.0.0",
+      "category": "automation",
+      "tags": ["pipeline", "automation", "spec", "plan", "implement", "review", "critic-loop"]
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "afc",
+  "version": "2.0.0",
+  "description": "Automated pipeline for Claude Code. Automates the full development cycle: spec → plan → tasks → implement → review → clean.",
+  "author": { "name": "jhlee0409", "email": "relee6203@gmail.com" },
+  "homepage": "https://github.com/jhlee0409/all-for-claudecode",
+  "repository": "https://github.com/jhlee0409/all-for-claudecode",
+  "license": "MIT",
+  "keywords": ["pipeline", "automation", "spec", "plan", "implement", "review", "critic-loop"],
+  "commands": "./commands/",
+  "hooks": "./hooks/hooks.json"
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 jhlee0409
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/MIGRATION.md

@@ -0,0 +1,180 @@
+# Migration Guide
+
+## v2.0 — Rebrand: selfish-pipeline → all-for-claudecode
+
+> All-for-ClaudeCode v2.0 renames the package, plugin prefix, scripts, agents, and state files from `selfish` to `afc`.
+
+### What Changed
+
+| Item | Before (v1.x) | After (v2.0) |
+|------|---------------|--------------|
+| Package name | `selfish-pipeline` | `all-for-claudecode` |
+| Plugin name | `selfish` | `afc` |
+| Command prefix | `/selfish:spec` | `/afc:spec` |
+| Script prefix | `selfish-*.sh` | `afc-*.sh` |
+| Agent names | `selfish-architect`, `selfish-security` | `afc-architect`, `afc-security` |
+| State files | `.selfish-active`, `.selfish-phase`, etc. | `.afc-active`, `.afc-phase`, etc. |
+| Config file | `selfish.config.md` | `afc.config.md` |
+| Git tags | `selfish/pre-auto` | `afc/pre-auto` |
+| CLAUDE.md block | `SELFISH:START` / `SELFISH:END` | `AFC:START` / `AFC:END` |
+| Artifact dir | `.claude/selfish/` | `.claude/afc/` |
+| GitHub repo | `jhlee0409/selfish-pipeline` | `jhlee0409/all-for-claudecode` |
+
+### Migration Steps
+
+#### 1. Uninstall old plugin
+
+```bash
+claude plugin uninstall selfish@selfish-pipeline
+claude plugin marketplace remove jhlee0409/selfish-pipeline
+```
+
+#### 2. Install new plugin
+
+```bash
+npx all-for-claudecode
+```
+
+Or manually:
+
+```bash
+claude plugin marketplace add jhlee0409/all-for-claudecode
+claude plugin install afc@all-for-claudecode --scope user
+```
+
+#### 3. Update CLAUDE.md
+
+Replace the `SELFISH:START` / `SELFISH:END` block in your project's CLAUDE.md:
+
+- Change `<!-- SELFISH:START -->` → `<!-- AFC:START -->`
+- Change `<!-- SELFISH:END -->` → `<!-- AFC:END -->`
+- Change `<!-- SELFISH:VERSION:x.x.x -->` → `<!-- AFC:VERSION:2.0.0 -->`
+- Change `<selfish-pipeline>` → `<afc-pipeline>`
+- Change all `selfish:` command references → `afc:`
+- Change `selfish-architect` / `selfish-security` → `afc-architect` / `afc-security`
+
+Or simply run `/afc:init` to regenerate the block.
+
+#### 4. Rename state files (if pipeline was active)
+
+```bash
+cd .claude
+for f in .selfish-*; do
+  [ -f "$f" ] && mv "$f" "${f/.selfish-/.afc-}"
+done
+[ -d selfish ] && mv selfish afc
+[ -f selfish.config.md ] && mv selfish.config.md afc.config.md
+```
+
+#### 5. Update git tags
+
+```bash
+git tag -d selfish/pre-auto 2>/dev/null
+# Phase tags are cleaned up automatically on pipeline end
+```
+
+---
+
+## v1.0 — Migration: install.sh → Plugin
+
+> A guide for migrating from the `git clone` + `install.sh` approach to the Claude Code plugin system.
+
+## Summary of Changes
+
+| Item | Before | After |
+|------|--------|-------|
+| Installation | `git clone` + `./install.sh` | `/plugin install <url>` |
+| Command separator | `.` (`/afc-legacy.spec`) | `:` (`/afc:spec`) |
+| Command location | `~/.claude/commands/afc-legacy.*.md` | `commands/*.md` inside the plugin |
+| Hook scripts | `<project>/.claude/hooks/*.sh` | `scripts/*.sh` inside the plugin |
+| Hook config | `<project>/.claude/settings.json` | `hooks/hooks.json` inside the plugin |
+| Config file | `.claude/afc.config.md` (unchanged) | `.claude/afc.config.md` (unchanged) |
+
+## Migration Steps
+
+### 1. Clean Up Existing Files
+
+```bash
+# Remove existing command files (user level)
+rm -f ~/.claude/commands/afc-legacy.*.md
+
+# Remove existing hook scripts (project level)
+rm -f .claude/hooks/session-start-context.sh
+rm -f .claude/hooks/pre-compact-checkpoint.sh
+rm -f .claude/hooks/track-afc-changes.sh
+rm -f .claude/hooks/afc-stop-gate.sh
+rm -f .claude/hooks/afc-pipeline-manage.sh
+```
+
+### 2. Remove legacy hooks from settings.json
+
+Remove afc-related hook entries from `.claude/settings.json`.
+Since the plugin registers hooks via its own `hooks.json`, manual configuration in settings.json is no longer needed.
+
+Items to remove (from settings.json):
+- `SessionStart` → `session-start-context.sh`
+- `PreCompact` → `pre-compact-checkpoint.sh`
+- `PostToolUse` → `track-afc-changes.sh`
+- `Stop` → `afc-stop-gate.sh`
+
+> If you have other project-specific hooks in settings.json, keep those as they are.
+
+### 3. Install the Plugin
+
+```bash
+npx all-for-claudecode
+```
+
+Or manually:
+
+```bash
+claude plugin marketplace add jhlee0409/all-for-claudecode
+claude plugin install afc@all-for-claudecode --scope user
+```
+
+The equivalent of `install.sh --commands-only` is the **User** scope; for team sharing, use the **Project** scope.
+
+### 4. Command Name Changes
+
+The separator for all commands has changed from `.` to `:`:
+
+```text
+# Before
+/afc-legacy.auto "feature description"
+/afc-legacy.spec "feature description"
+/afc-legacy.plan
+
+# After
+/afc:auto "feature description"
+/afc:spec "feature description"
+/afc:plan
+```
+
+### 5. Verify Config File
+
+`.claude/afc.config.md` can be **used as-is without any changes**.
+
+For new projects, you can auto-generate it with `/afc:init`.
+
+## What Stays the Same
+
+- `.claude/afc.config.md` file format and path
+- `.afc-*` state file paths
+- `git tag afc/pre-*` safety tags
+- Internal logic of hook scripts
+
+## What Changed (v1.2.2+)
+
+- `specs/{feature}/` → `.claude/afc/specs/{feature}/`
+- `memory/` → `.claude/afc/memory/` (checkpoint, principles, research, decisions)
+
+## FAQ
+
+**Q: Do I need to recreate `.claude/afc.config.md` for existing projects?**
+A: No. The config file format is the same. Use it as-is.
+
+**Q: I'm using this across multiple projects. Do I need to migrate each one?**
+A: You only need to install the plugin once. For each project, just clean up the existing `.claude/hooks/*.sh` files and legacy hook entries in settings.json.
+
+**Q: Can I use the old version and the plugin at the same time?**
+A: This is not recommended. Since the command names differ (`/afc-legacy.spec` vs `/afc:spec`), there are no conflicts, but hooks may get registered twice.

package/README.md

@@ -0,0 +1,216 @@
+# All-for-ClaudeCode
+
+**Claude Code plugin that automates the full development cycle — spec → plan → tasks → implement → review → clean.**
+
+[![npm version](https://img.shields.io/npm/v/all-for-claudecode)](https://www.npmjs.com/package/all-for-claudecode)
+[![license](https://img.shields.io/github/license/jhlee0409/all-for-claudecode)](./LICENSE)
+[![test](https://img.shields.io/badge/tests-161%20passed-brightgreen)](#how-it-works)
+[![hooks](https://img.shields.io/badge/hooks-15%20events-blue)](#15-hook-events)
+[![commands](https://img.shields.io/badge/commands-18-orange)](#18-slash-commands)
+
+> Zero-dependency automation pipeline for Claude Code. One command (`/afc:auto`) runs the entire cycle: write specs, design plans, break into tasks, implement code, review quality, and clean up — all with built-in CI gates and critic loops.
+
+## What is All-for-ClaudeCode?
+
+All-for-ClaudeCode is a **Claude Code plugin** that transforms your development workflow into a fully automated pipeline. Instead of manually prompting Claude through each development phase, you run a single command and the pipeline handles everything — from writing feature specifications to final code review.
+
+- **18 slash commands** for every phase of development
+- **15 hook events** with 3 handler types (shell scripts, LLM prompts, subagents)
+- **5 project presets** for popular stacks (Next.js, React SPA, Express API, Monorepo)
+- **Persistent memory agents** that learn across sessions
+- **Built-in CI gates** that physically prevent skipping quality checks
+
+## Quick Start
+
+### Option A: Inside Claude Code (`/plugin`)
+
+```
+/plugin marketplace add jhlee0409/all-for-claudecode
+/plugin install afc@all-for-claudecode
+```
+
+Or use the interactive UI: type `/plugin` → Manage → Add marketplace → `jhlee0409/all-for-claudecode` → Discover → install **afc**.
+
+### Option B: One-line install (via npx)
+
+```bash
+npx all-for-claudecode
+```
+
+Interactive installer — choose scope (user / project / local) and done.
+
+### Option C: Claude Code CLI
+
+```bash
+claude plugin marketplace add jhlee0409/all-for-claudecode
+claude plugin install afc@all-for-claudecode --scope user
+```
+
+### Then, inside Claude Code:
+
+```
+/afc:init                              # Detect your stack, generate config
+/afc:auto "Add user authentication"    # Run the full pipeline
+```
+
+That's it. The pipeline will:
+1. Write a feature spec with acceptance criteria
+2. Design an implementation plan with file change map
+3. Break the plan into parallelizable tasks
+4. Implement each task with CI verification
+5. Run a code review with security scan
+6. Clean up artifacts and prepare for commit
+
+## Features
+
+### Full Auto Pipeline
+
+```
+/afc:auto "feature description"
+```
+
+Runs all 6 phases automatically with **Critic Loop** quality checks at each gate:
+
+```
+Spec (1/6) → Plan (2/6) → Tasks (3/6) → Implement (4/6) → Review (5/6) → Clean (6/6)
+```
+
+### 18 Slash Commands
+
+**User and model (unrestricted):**
+
+| Command | Description |
+|---|---|
+| `/afc:auto` | Full Auto pipeline — runs all 6 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 security scanning |
+| `/afc:research` | Technical research with persistent storage |
+| `/afc:debug` | Bug diagnosis and fix |
+
+**User-only** (`disable-model-invocation: true`):
+
+| Command | Description |
+|---|---|
+| `/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 |
+
+**Model-only** (`user-invocable: false`):
+
+| Command | Description |
+|---|---|
+| `/afc:tasks` | Break plan into parallelizable tasks |
+| `/afc:analyze` | Verify artifact consistency |
+| `/afc:clarify` | Resolve spec ambiguities |
+
+### 15 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 (AI 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 |
+
+### 3 Hook Handler Types
+
+| Type | Description | Use Case |
+|---|---|---|
+| `command` | Shell script execution (deterministic) | All 15 events |
+| `prompt` | LLM single-turn evaluation (haiku) | TaskCompleted |
+| `agent` | Subagent with file access tools | Stop |
+
+### Persistent Memory Agents
+
+Two custom agents that **learn across sessions**:
+
+| Agent | Role | Memory |
+|---|---|---|
+| `afc-architect` | Architecture analysis — remembers ADR decisions and patterns | `.claude/agent-memory/afc-architect/` |
+| `afc-security` | Security scan — remembers vulnerability patterns and false positives | `.claude/agent-memory/afc-security/` |
+
+### 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 |
+
+## How It Works
+
+```
+┌─────────────────────────────────────────────┐
+│  /afc:auto "Add feature X"              │
+├─────────────────────────────────────────────┤
+│  Phase 1: Spec    → Critic Loop → Gate ✓    │
+│  Phase 2: Plan    → Critic Loop → Gate ✓    │
+│  Phase 3: Tasks   → Critic Loop → Gate ✓    │
+│  Phase 4: Implement → CI Gate → Gate ✓      │
+│  Phase 5: Review  → Security Scan → Gate ✓  │
+│  Phase 6: Clean   → Artifacts removed       │
+├─────────────────────────────────────────────┤
+│  15 hooks run automatically at each step    │
+│  Stop/TaskCompleted gates block if CI fails │
+└─────────────────────────────────────────────┘
+```
+
+## Configuration
+
+Initialize your project:
+
+```bash
+/afc:init
+```
+
+This detects your tech stack and generates `.claude/afc.config.md` with:
+- CI/lint/test commands
+- Architecture style and layers
+- Framework-specific settings
+- Code style conventions
+
+## FAQ
+
+### What is all-for-claudecode?
+A Claude Code plugin that automates the entire development cycle (spec → plan → tasks → implement → review → clean) through 18 slash commands and 15 hook events.
+
+### How does it compare to manual Claude Code workflows?
+Instead of manually prompting each step, all-for-claudecode orchestrates the full cycle with built-in quality gates that physically prevent skipping CI or security checks.
+
+### Does it work with any project?
+Yes. Run `/afc:init` to auto-detect your stack, or use one of the 5 presets (Next.js, React SPA, Express API, Monorepo, or generic template).
+
+### Does it require any dependencies?
+No. Zero runtime dependencies — pure markdown commands + bash hook scripts.
+
+### How do I install it?
+Inside Claude Code, run `/plugin marketplace add jhlee0409/all-for-claudecode` then `/plugin install afc@all-for-claudecode`. Alternatively, run `npx all-for-claudecode` from your terminal for a guided install.
+
+### What Claude Code version is required?
+Claude Code with plugin support (2025+). The plugin uses standard hooks, commands, and agents APIs.
+
+## License
+
+MIT

package/agents/afc-architect.md

@@ -0,0 +1,49 @@
+---
+name: afc-architect
+description: "Architecture analysis agent — remembers ADR decisions and architecture patterns across sessions to provide consistent design guidance."
+tools:
+  - Read
+  - Write
+  - Grep
+  - Glob
+  - Bash
+  - Task
+  - WebSearch
+model: sonnet
+memory: project
+skills:
+  - docs/critic-loop-rules.md
+  - docs/phase-gate-protocol.md
+---
+
+You are an architecture analysis agent for the current project.
+
+## Reference Documents
+
+Before performing analysis, read these shared reference documents:
+- `docs/critic-loop-rules.md` — Critic Loop execution rules
+- `docs/phase-gate-protocol.md` — Phase gate validation protocol
+
+## Memory Usage
+
+At the start of each analysis:
+1. Read your MEMORY.md (at `.claude/agent-memory/afc-architect/MEMORY.md`) to review previous architecture decisions and patterns
+2. Reference prior ADRs when making new recommendations to ensure consistency
+
+At the end of each analysis:
+1. Record new ADR decisions, discovered patterns, or architectural insights to MEMORY.md
+2. Keep entries concise — only stable patterns and confirmed decisions
+3. Remove outdated entries when architecture evolves
+
+## Memory Format
+
+```markdown
+## ADR History
+- {date}: {decision summary} — {rationale}
+
+## Architecture Patterns
+- {pattern}: {where used, why}
+
+## Known Constraints
+- {constraint}: {impact}
+```

package/agents/afc-security.md

@@ -0,0 +1,49 @@
+---
+name: afc-security
+description: "Security scanning agent — remembers vulnerability patterns and project-specific security characteristics across sessions to improve scan precision."
+tools:
+  - Read
+  - Grep
+  - Glob
+  - Bash
+  - Task
+  - WebSearch
+model: sonnet
+memory: project
+isolation: worktree
+skills:
+  - docs/critic-loop-rules.md
+  - docs/phase-gate-protocol.md
+---
+
+You are a security scanning agent for the current project.
+
+## Reference Documents
+
+Before performing scans, read these shared reference documents:
+- `docs/critic-loop-rules.md` — Critic Loop execution rules
+- `docs/phase-gate-protocol.md` — Phase gate validation protocol
+
+## Memory Usage
+
+At the start of each scan:
+1. Read your MEMORY.md (at `.claude/agent-memory/afc-security/MEMORY.md`) to review previously found vulnerability patterns
+2. Check false positive records to avoid repeated false alarms
+
+At the end of each scan:
+1. Record newly discovered vulnerability patterns to MEMORY.md
+2. Record confirmed false positives with reasoning
+3. Note project-specific security characteristics (e.g., input sanitization patterns, auth flows)
+
+## Memory Format
+
+```markdown
+## Vulnerability Patterns
+- {pattern}: {description, files affected, severity}
+
+## False Positives
+- {pattern}: {why it's not a real issue}
+
+## Project Security Profile
+- {characteristic}: {description}
+```

package/bin/cli.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+
+import { createInterface } from "node:readline/promises";
+import { execSync } from "node:child_process";
+import { stdin, stdout, exit } from "node:process";
+
+const GITHUB_REPO = "jhlee0409/all-for-claudecode";
+const MARKETPLACE_NAME = "all-for-claudecode";
+const PLUGIN_NAME = "afc";
+
+const SCOPES = [
+  {
+    key: "1",
+    name: "user",
+    label: "User (all projects for this user)",
+    desc: "~/.claude/settings.json",
+  },
+  {
+    key: "2",
+    name: "project",
+    label: "Project (shared with team, committable)",
+    desc: ".claude/settings.json",
+  },
+  {
+    key: "3",
+    name: "local",
+    label: "Local (this project only, gitignored)",
+    desc: ".claude/settings.local.json",
+  },
+];
+
+function run(cmd) {
+  try {
+    execSync(cmd, { stdio: "inherit" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function main() {
+  console.log();
+  console.log("  All-for-ClaudeCode — Claude Code Plugin Installer");
+  console.log("  ===================================================");
+  console.log();
+
+  // Check claude CLI exists
+  try {
+    execSync("claude --version", { stdio: "pipe" });
+  } catch {
+    console.error("  ✗ Claude Code CLI is not installed.");
+    console.error("    Install it from https://claude.ai/code");
+    exit(1);
+  }
+
+  const rl = createInterface({ input: stdin, output: stdout });
+
+  try {
+    console.log("  Select install scope:\n");
+    for (const s of SCOPES) {
+      console.log(`    ${s.key}) ${s.label}`);
+      console.log(`       → ${s.desc}`);
+    }
+    console.log();
+
+    const answer = await rl.question("  Choose [1/2/3] (default: 1): ");
+    const choice = answer.trim() || "1";
+    const scope = SCOPES.find((s) => s.key === choice);
+
+    if (!scope) {
+      console.error("\n  ✗ Invalid selection.");
+      exit(1);
+    }
+
+    console.log(`\n  → Installing with ${scope.label} scope...\n`);
+
+    // Step 1: Register marketplace
+    console.log("  [1/2] Registering marketplace...");
+    run(`claude plugin marketplace add ${GITHUB_REPO}`);
+
+    // Step 2: Install plugin
+    console.log(`  [2/2] Installing plugin (--scope ${scope.name})...`);
+    const installed = run(
+      `claude plugin install ${PLUGIN_NAME}@${MARKETPLACE_NAME} --scope ${scope.name}`
+    );
+
+    if (!installed) {
+      console.error("\n  ✗ Installation failed. Try manually:");
+      console.error(`    claude plugin marketplace add ${GITHUB_REPO}`);
+      console.error(
+        `    claude plugin install ${PLUGIN_NAME}@${MARKETPLACE_NAME} --scope ${scope.name}`
+      );
+      exit(1);
+    }
+
+    console.log();
+    console.log("  ✓ Installation complete!");
+    console.log();
+    console.log("  Next steps:");
+    console.log("    /afc:init                    Create project config");
+    console.log('    /afc:auto "feature desc"      Run the pipeline');
+    console.log();
+  } finally {
+    rl.close();
+  }
+}
+
+main().catch((err) => {
+  console.error(`\n  ✗ Installation failed: ${err.message}`);
+  exit(1);
+});