@curdx/flow 1.1.11 → 2.0.0-beta.2

package/commands/switch.md

@@ -1,95 +0,0 @@
----
-name: switch
-description: switch the active spec (updates .flow/.active-spec)
-argument-hint: "<spec-name>"
-allowed-tools: [Read, Write, Bash]
----
-
-# Switch Active Spec
-
-Switch between multiple specs. The active spec is the default target for commands like `/curdx-flow:research`, `/curdx-flow:requirements`, etc.
-
-## Step 1: Preflight Check
-
-```bash
-[ ! -d ".flow" ] && { echo "❌ Not a CurDX-Flow project. Run /curdx-flow:init first"; exit 1; }
-
-SPEC_NAME="$ARGUMENTS"
-if [ -z "$SPEC_NAME" ]; then
-    # No arguments → list all specs and prompt
-    echo "Current spec list:"
-    if [ -d ".flow/specs" ]; then
-        for spec in .flow/specs/*/; do
-            name=$(basename "$spec")
-            active=""
-            [ "$name" = "$(cat .flow/.active-spec 2>/dev/null)" ] && active=" ← currently active"
-            
-            # Read phase
-            phase=$(python3 -c "import json; print(json.load(open('$spec/.state.json')).get('phase','?'))" 2>/dev/null || echo "?")
-            echo "  • $name  (phase: $phase)$active"
-        done
-    fi
-    echo ""
-    echo "Usage: /curdx-flow:switch <spec-name>"
-    exit 0
-fi
-```
-
-## Step 2: Verify Target Spec Exists
-
-```bash
-SPEC_DIR=".flow/specs/$SPEC_NAME"
-if [ ! -d "$SPEC_DIR" ]; then
-    echo "❌ Spec does not exist: $SPEC_NAME"
-    echo ""
-    echo "Existing specs:"
-    ls .flow/specs/ 2>/dev/null || echo "  (none)"
-    echo ""
-    echo "Create a new spec: /curdx-flow:start $SPEC_NAME \"<goal>\""
-    exit 1
-fi
-```
-
-## Step 3: Perform the Switch
-
-```bash
-# Save old one for reference
-OLD_ACTIVE=$(cat .flow/.active-spec 2>/dev/null || echo "(none)")
-
-# Update
-echo "$SPEC_NAME" > .flow/.active-spec
-
-echo "✓ Active spec: $OLD_ACTIVE → $SPEC_NAME"
-```
-
-## Step 4: Display New Spec Status
-
-```python
-import json, os
-s = json.load(open(f"$SPEC_DIR/.state.json"))
-
-print(f"\n📋 {s['spec_name']}")
-print(f"   Goal:         {s.get('goal','(undefined)')}")
-print(f"   Current phase: {s['phase']}")
-
-# Phase progress bar
-phases = ["research","requirements","design","tasks","execute","verify","ship"]
-ph_status = s.get('phase_status', {})
-bar = []
-for p in phases:
-    st = ph_status.get(p, 'not_started')
-    bar.append({"completed":"✓","in_progress":"●","not_started":"○","failed":"✗","skipped":"—"}.get(st,"?"))
-print(f"   Progress:     {' → '.join(bar)}")
-print(f"                 {' → '.join(phases)}")
-
-# Suggest next step
-for p in phases:
-    if ph_status.get(p, 'not_started') in ("not_started","in_progress"):
-        print(f"\n   Suggested next step: /curdx-flow:{p}")
-        break
-```
-
-## Error Recovery
-
-- `.flow/.active-spec` permission error → check write permissions on `.flow/`
-- .state.json corrupted → prompt `/curdx-flow:start <name>` to rebuild

package/commands/tasks.md

@@ -1,189 +0,0 @@
----
-name: tasks
-description: run the task decomposition phase — dispatch the flow-planner agent to decompose along POC-First 5 Phases and perform multi-source coverage audit. Produces tasks.md
-argument-hint: "[spec-name] [--fine | --coarse]"
-allowed-tools: [Read, Write, Bash, Task]
----
-
-# Task Decomposition Phase
-
-Dispatch the `flow-planner` agent to decompose the design into an auto-verifiable task list.
-
-## Step 1: Parse Arguments
-
-```bash
-# Support --fine / --coarse to override project default
-TASK_SIZE="fine"
-ARGS="$ARGUMENTS"
-case "$ARGS" in
-    *--coarse*) TASK_SIZE="coarse" ;;
-    *--fine*)   TASK_SIZE="fine"   ;;
-    *)
-        # Read default from .flow/config.json
-        TASK_SIZE=$(python3 -c "
-import json
-try:
-    c = json.load(open('.flow/config.json'))
-    print(c.get('specs',{}).get('default_task_size','fine'))
-except: print('fine')
-")
-        ;;
-esac
-
-SPEC_NAME="$(echo "$ARGS" | sed 's/--[a-z]*//g' | xargs)"
-[ -z "$SPEC_NAME" ] && SPEC_NAME=$(cat .flow/.active-spec 2>/dev/null)
-```
-
-## Step 2: Preflight Check
-
-```bash
-DIR=".flow/specs/$SPEC_NAME"
-for f in research.md requirements.md design.md; do
-    [ ! -f "$DIR/$f" ] && { echo "❌ Missing $f"; exit 1; }
-done
-```
-
-## Step 3: Detect Project Commands (for planner reference)
-
-```bash
-# Collect actual project commands
-PKG_MGR="npm"; TEST_CMD=""; LINT_CMD=""; BUILD_CMD=""
-if [ -f "package.json" ]; then
-    command -v pnpm >/dev/null && [ -f "pnpm-lock.yaml" ] && PKG_MGR="pnpm"
-    command -v bun  >/dev/null && [ -f "bun.lockb" ]     && PKG_MGR="bun"
-    command -v yarn >/dev/null && [ -f "yarn.lock" ]     && PKG_MGR="yarn"
-    
-    # Parse scripts
-    TEST_CMD=$(python3 -c "import json; print(json.load(open('package.json')).get('scripts',{}).get('test',''))" 2>/dev/null)
-    LINT_CMD=$(python3 -c "import json; print(json.load(open('package.json')).get('scripts',{}).get('lint',''))" 2>/dev/null)
-    BUILD_CMD=$(python3 -c "import json; print(json.load(open('package.json')).get('scripts',{}).get('build',''))" 2>/dev/null)
-fi
-
-cat > "/tmp/flow-cmds.txt" <<EOF
-Package Manager: $PKG_MGR
-Test:  ${TEST_CMD:-<no test script>}
-Lint:  ${LINT_CMD:-<no lint script>}
-Build: ${BUILD_CMD:-<no build script>}
-EOF
-```
-
-## Step 4: Update State + Dispatch
-
-```python
-import json
-p = f'.flow/specs/{SPEC_NAME}/.state.json'
-s = json.load(open(p))
-s.setdefault('phase_status',{})['tasks']='in_progress'
-s['phase']='tasks'
-s['task_size'] = TASK_SIZE  # 'fine' or 'coarse'
-json.dump(s, open(p,'w'), indent=2, ensure_ascii=False)
-```
-
-Dispatch Task:
-
-```
-Task:
-  subagent_type: general-purpose
-  description: "task decomposition $SPEC_NAME"
-  prompt: |
-    You are the flow-planner agent. Full definition at:
-    ${CLAUDE_PLUGIN_ROOT}/agents/flow-planner.md
-    
-    Prerequisites (must read):
-    - .flow/specs/$SPEC_NAME/research.md
-    - .flow/specs/$SPEC_NAME/requirements.md
-    - .flow/specs/$SPEC_NAME/design.md
-    - .flow/STATE.md
-    - .flow/CONTEXT.md
-    
-    Template:
-    ${CLAUDE_PLUGIN_ROOT}/templates/tasks.md.tmpl
-    
-    Knowledge base:
-    - ${CLAUDE_PLUGIN_ROOT}/knowledge/poc-first-workflow.md (**must read**)
-    
-    Project-detected commands (use these, do not assume):
-    ---
-    $(cat /tmp/flow-cmds.txt)
-    ---
-    
-    Task size: $TASK_SIZE (fine=40-60 tasks, coarse=10-20 tasks)
-    
-    Output:
-    .flow/specs/$SPEC_NAME/tasks.md
-    
-    Mandatory requirements:
-    1. Decompose along POC-First 5 Phases (Phase 1-5)
-    2. Each task has 5 fields: Do / Files / Done-when / Verify / Commit
-    3. Verify **must be an automated command** (no "manual testing")
-    4. At least 1 [VERIFY] checkpoint per Phase
-    5. Mark independent tasks with [P]
-    6. Must end with a **coverage audit table**:
-       - Which tasks correspond to each FR?
-       - Which tasks correspond to each AC?
-       - Which tasks correspond to each AD?
-       - Uncovered items must state the reason
-    
-    Success criteria:
-    - Task count matches task_size requirement
-    - All Verify values are executable commands
-    - Coverage audit table complete
-    - Commit messages follow conventional format
-    
-    Forbidden:
-    - Writing TODO or "manual" in Verify field
-    - Assuming project commands (use the ones detected above)
-    - Skipping FRs for "simplicity"
-    
-    When done, return a brief: task count, Phase distribution, coverage audit result.
-```
-
-## Step 5: Coverage Audit Verification
-
-```bash
-TASKS=".flow/specs/$SPEC_NAME/tasks.md"
-
-# Check that the coverage audit table exists
-grep -q "coverage audit" "$TASKS" || echo "✗ Missing coverage audit table"
-
-# Check that every task has Verify
-# Rough: within 10 lines after each "- [ ]" there should be "Verify:"
-TASKS_COUNT=$(grep -c "^- \[ \] \*\*" "$TASKS" || echo 0)
-VERIFY_COUNT=$(grep -c "^\s*\*\*Verify\*\*:" "$TASKS" || echo 0)
-
-if [ "$VERIFY_COUNT" -lt "$TASKS_COUNT" ]; then
-    echo "⚠ Task count $TASKS_COUNT vs Verify count $VERIFY_COUNT (some tasks may be missing the Verify field)"
-fi
-
-# Check for forbidden words
-if grep -iE "(manual|manual test|todo|tbd)" "$TASKS" > /dev/null; then
-    echo "✗ tasks.md contains forbidden words (manual/TODO/TBD); check the Verify field"
-fi
-```
-
-## Step 6: Output
-
-```
-✓ tasks phase complete
-
-File:         .flow/specs/$SPEC_NAME/tasks.md
-Task size:    $TASK_SIZE
-Total tasks:  N
-Phase distribution:
-  POC:        X
-  Refactor:   Y
-  Testing:    Z
-  Quality:    W
-  PR:         V
-
-Coverage audit: FR / AC / AD all ✓
-
-⚠ Phase 2 (Execution Engine) not yet released. tasks.md can be executed manually in order.
-   The /curdx-flow:implement command will be available in the next version.
-```
-
-## Error Recovery
-
-- design.md missing or status is not completed → return to /curdx-flow:design
-- Agent missed some FRs → rerun or manually append tasks at the end of tasks.md
-- Verify contains the word "manual" → rerun and explicitly state "all Verify must be automated"

package/commands/triage.md

@@ -1,160 +0,0 @@
----
-name: triage
-description: Epic decomposition — slice a big goal vertically by user value, generate dependency graph + multiple sub-specs. Dispatches flow-triage-analyst.
-argument-hint: "\"<epic goal>\" [--specs=<N>]"
-allowed-tools: [Read, Write, Bash, Task, WebSearch]
----
-
-# Flow Triage — Epic Decomposition
-
-@${CLAUDE_PLUGIN_ROOT}/knowledge/epic-decomposition.md
-
-Break down a big goal (needs 4+ sub-specs to complete) into an Epic of vertical slices.
-
-## When to Use
-
-- Goal is clearly more than 2 weeks of work
-- Involves multiple "independently usable" features
-- At `/curdx-flow:start`, you realize the goal is too big — switch to `/curdx-flow:triage`
-
-## When Not to Use
-
-- Goal fits in 1-2 weeks → use `/curdx-flow:start`
-- Emergency fix → use `/curdx-flow:fast`
-- Exploratory validation → use `/curdx-flow:spike`
-
-## Step 1: Preflight Check
-
-```bash
-[ ! -d ".flow" ] && { echo "❌ Not a CurDX-Flow project"; exit 1; }
-
-GOAL="$ARGUMENTS"
-# Extract --specs argument
-TARGET_SPECS=""
-case "$GOAL" in
-    *--specs=*)
-        TARGET_SPECS=$(echo "$GOAL" | grep -oE -- '--specs=[0-9]+' | cut -d= -f2)
-        GOAL=$(echo "$GOAL" | sed 's/--specs=[0-9]*//g' | xargs)
-        ;;
-esac
-
-[ -z "$GOAL" ] && { echo "Usage: /curdx-flow:triage \"<epic goal>\""; exit 1; }
-```
-
-## Step 2: Generate Epic Name
-
-Derive a kebab-case name from the goal, or ask the user:
-
-```python
-# Rough inference
-slug = re.sub(r'\s+', '-', goal.lower())
-slug = re.sub(r'[^a-z0-9-]', '', slug)[:40]
-# e.g.: "add payment system" → "payment-system"
-# May need AskUserQuestion to confirm
-```
-
-## Step 3: Create Epic Directory
-
-```bash
-EPIC_DIR=".flow/_epics/$EPIC_NAME"
-mkdir -p "$EPIC_DIR"
-```
-
-## Step 4: Dispatch flow-triage-analyst
-
-```
-Task:
-  subagent_type: general-purpose
-  description: "Epic decomposition: $EPIC_NAME"
-  prompt: |
-    You are the flow-triage-analyst agent. Full definition:
-    ${CLAUDE_PLUGIN_ROOT}/agents/flow-triage-analyst.md
-    
-    Knowledge base (must read):
-    ${CLAUDE_PLUGIN_ROOT}/knowledge/epic-decomposition.md
-    
-    Input:
-    - Epic goal: "$GOAL"
-    - Epic name: $EPIC_NAME
-    - Suggested sub-spec count: ${TARGET_SPECS:-auto (4-8)}
-    - Project context: .flow/PROJECT.md + .flow/CONTEXT.md + .flow/STATE.md
-    
-    Mandatory workflow:
-    1. sequential-thinking >= 5 rounds to understand the goal
-    2. context7 to validate the key technologies involved
-    3. claude-mem to retrieve history
-    4. sequential-thinking 5+ rounds to brainstorm decomposition
-    5. Vertical slice by user value (not by technical layer)
-    6. Define shared interfaces (freeze)
-    7. Identify dependencies (hard/soft/parallel)
-    8. Generate epic.md + sub-spec skeletons
-    
-    Output files:
-    - .flow/_epics/$EPIC_NAME/epic.md  (Epic master document)
-    - .flow/_epics/$EPIC_NAME/.epic-state.json
-    - .flow/specs/<sub-1>/.state.json
-    - .flow/specs/<sub-2>/.state.json
-    - ...(skeleton for each sub-spec)
-    
-    Success criteria:
-    - Sub-spec count: 4-8
-    - Each sub-spec has independent user value
-    - Dependency graph is clear (mermaid)
-    - Shared interfaces frozen (TypeScript types)
-    - Out of Scope is explicit
-    
-    When done, return a brief:
-    - Sub-spec list (name + one-sentence description)
-    - Dependency graph
-    - Recommended execution order
-    - Estimated total duration
-```
-
-## Step 5: Validate Output
-
-```bash
-EPIC_FILE="$EPIC_DIR/epic.md"
-[ ! -f "$EPIC_FILE" ] && { echo "❌ Epic document not generated"; exit 1; }
-
-# Count sub-specs
-SUB_COUNT=$(grep -c "^### Spec [0-9]" "$EPIC_FILE" || echo 0)
-[ $SUB_COUNT -lt 3 ] && echo "⚠ Fewer than 3 sub-specs; may not be decomposed enough"
-[ $SUB_COUNT -gt 10 ] && echo "⚠ More than 10 sub-specs; granularity may be too fine"
-
-# Check mermaid graph
-grep -q "mermaid" "$EPIC_FILE" || echo "✗ No mermaid dependency graph found"
-
-# Check shared interfaces
-grep -q "shared interface" "$EPIC_FILE" || echo "✗ Shared interfaces not defined"
-```
-
-## Step 6: Show Results to User
-
-```
-✓ Epic decomposition complete: $EPIC_NAME
-
-Files:
-  .flow/_epics/$EPIC_NAME/epic.md
-  .flow/_epics/$EPIC_NAME/.epic-state.json
-
-Sub-specs: $SUB_COUNT (skeletons created)
-
-Dependency graph: see epic.md
-
-Recommended execution order:
-  Week 1: /curdx-flow:switch <sub-1> → /curdx-flow:spec → /curdx-flow:implement
-  Week 2: /curdx-flow:switch <sub-2> (parallel with sub-3 if independent)
-  Week 3: /curdx-flow:switch <sub-4> (depends on sub-1 being done)
-  ...
-
-Next steps:
-  1. Review .flow/_epics/$EPIC_NAME/epic.md to confirm the decomposition is reasonable
-  2. First sub-spec: /curdx-flow:switch <sub-1-name>
-  3. Then proceed with the normal /curdx-flow:spec → /curdx-flow:implement flow
-```
-
-## Error Recovery
-
-- triage-analyst fails → the goal may be too abstract; refine the description manually and rerun
-- Too many/too few sub-specs → use `--specs=N` to force a count
-- Incomplete interface definitions → go back to epic.md and add interfaces manually, or rerun the agent to fill them in