@curdx/flow 1.1.11 → 2.0.0-beta.10

package/commands/spike.md

@@ -1,181 +0,0 @@
----
-name: spike
-description: feasibility experiment — validate an idea with 2-5 small tests, no production code. Output conclusions to STATE.md
-argument-hint: "\"<hypothesis to validate>\""
-allowed-tools: [Read, Write, Edit, Bash, WebSearch, Grep, Glob]
----
-
-# Flow Spike — Feasibility Experiment
-
-@${CLAUDE_PLUGIN_ROOT}/agent-preamble/preamble.md
-
-**A spike is a short-duration experiment**, aimed at answering one technical question: "Can this approach work?" It is not about delivering a feature.
-
-## Typical Scenarios
-
-- "Can Redis Streams replace Kafka?"
-- "How much faster is Bun than Node? Is our scenario a good fit?"
-- "Is this API's rate limit 10 qps?"
-- "Can the new TypeScript const generic solve problem X?"
-
-## Step 1: Clarify the Hypothesis
-
-```bash
-HYPOTHESIS="$ARGUMENTS"
-[ -z "$HYPOTHESIS" ] && { echo "Usage: /curdx-flow:spike \"<hypothesis>\""; exit 1; }
-```
-
-Confirm with the user:
-```
-Hypothesis to validate: <HYPOTHESIS>
-
-My understanding:
-  - What to validate: <...>
-  - Pass criteria: <...>
-  - What if it fails: <...>
-  - Time budget: recommend 30-60 minutes
-
-Continue? (yes / correct me)
-```
-
-Use AskUserQuestion (unless quickMode).
-
-## Step 2: Design 2-5 Small Tests
-
-**Rules**:
-- Each test is independent
-- Minimal code (50 lines max)
-- Explicit pass/fail criteria
-- Do not touch production code
-
-Example (validating Redis Streams performance):
-
-```
-Test 1: Throughput of writing 1000 messages
-  Code: spike/redis-streams-write.ts
-  Expected: >= 10K msg/sec
-  
-Test 2: Consumer group latency
-  Code: spike/redis-streams-consume.ts
-  Expected: P99 < 10ms
-  
-Test 3: Persistence overhead
-  Code: compare AOF vs RDB
-  Expected: AOF write latency increase < 20%
-```
-
-## Step 3: Create the spike directory
-
-```bash
-mkdir -p spike/$(date +%Y-%m-%d)-${HYPOTHESIS_SLUG}
-```
-
-All experimental code lives here. **Absolutely do not touch production code**.
-
-## Step 4: Run the Tests
-
-```bash
-for test in Test 1 2 3:
-    write code
-    run
-    record results
-    if blocked:
-      not "fix bug and continue", but record "blocker X, cannot test"
-```
-
-**context7 is mandatory**: look up all library APIs via context7, do not rely on memory.
-
-## Step 5: Record Results
-
-Create `spike/<date>-<slug>/RESULTS.md`:
-
-```markdown
-# Spike Results: <hypothesis>
-
-Date: YYYY-MM-DD
-Time: actually took N minutes
-
-## Test Matrix
-
-| Test | Expected | Actual | Conclusion |
-|------|-----|------|------|
-| 1 | >=10K msg/sec | 12K msg/sec | ✓ |
-| 2 | P99 < 10ms | P99 = 15ms | ✗ |
-| 3 | < 20% | 8% | ✓ |
-
-## Conclusion
-
-Hypothesis <HYPOTHESIS> is:
-  ☐ Fully correct — recommended for adoption
-  ☑ Partially correct — P99 latency exceeds expectations, needs deeper optimization
-  ☐ Fully incorrect — not recommended
-
-## Key Findings
-
-- <finding 1>
-- <finding 2>
-
-## Recommendation
-
-<how to handle this hypothesis if used in a real spec>
-
-## Open Questions
-
-<edges not yet tested>
-```
-
-## Step 6: Sync to STATE.md (if in a flow project)
-
-```bash
-if [ -f ".flow/STATE.md" ]; then
-    append to STATE.md:
-      ## Spike: <hypothesis> (YYYY-MM-DD)
-      Conclusion: partially correct
-      Details: spike/<date>-<slug>/RESULTS.md
-fi
-```
-
-This way, subsequent spec discussions can reference it.
-
-## Step 7: Cleanup Decision
-
-Ask the user:
-```
-Spike complete. Code is in spike/<date>-<slug>/
-Keep it?
-  [keep]   may reference later
-  [delete] conclusion recorded, code no longer valuable
-  [commit] commit into git as a historical reference
-```
-
-## Output
-
-```
-✓ Spike complete: <hypothesis>
-
-Conclusion:    partially correct (see RESULTS.md)
-Tests:         3 / 3 executed
-Actual time:   47 minutes
-
-Next step suggestions:
-  - Go deeper: /curdx-flow:start <name> "do <specific feature> based on spike results"
-  - Abandon:   recorded to STATE.md, do not adopt this direction
-
-Artifacts:
-  spike/<date>-<slug>/RESULTS.md
-  spike/<date>-<slug>/*.ts (test code)
-```
-
-## Forbidden
-
-- ✗ Mixing spike code into production code (src/)
-- ✗ Spikes exceeding 2 hours (that's not a spike, that's a mini project)
-- ✗ Claiming validation complete without recording results
-- ✗ Using a spike to replace the real spec workflow
-
-## spike vs research phase
-
-- **spike** is **actually running code** to validate a hypothesis
-- **research phase** is **reading docs / thinking** to determine direction
-
-Research thinks approach A is feasible but has concerns → use a spike to verify → write the conclusion back into the "feasibility" section of research.md.

package/commands/status.md

@@ -1,139 +0,0 @@
----
-name: status
-description: view the current state of the CurDX-Flow project (specs, phases, progress)
-argument-hint: "[--all | <spec-name>]"
-allowed-tools: [Read, Bash, Glob]
----
-
-# Project Status
-
-Shows an overview of the current state of the CurDX-Flow project.
-
-## Execution Steps
-
-### Step 1: Confirm the Project
-
-```bash
-if [ ! -d ".flow" ]; then
-    echo "✗ Current directory is not a CurDX-Flow project. Run /curdx-flow:init to initialize."
-    exit 0
-fi
-```
-
-### Step 2: Load Global State
-
-```bash
-# Active spec
-ACTIVE=$(cat .flow/.active-spec 2>/dev/null || echo "(none)")
-
-# Project config
-if [ -f ".flow/config.json" ]; then
-    MODE=$(python3 -c "import json; print(json.load(open('.flow/config.json')).get('mode','standard'))")
-fi
-```
-
-### Step 3: Scan Specs
-
-```bash
-# List all specs
-SPECS=$(ls -1 .flow/specs/ 2>/dev/null)
-
-# List all Epics
-EPICS=$(ls -1 .flow/_epics/ 2>/dev/null)
-```
-
-For each spec, read `.state.json` to get phase and progress:
-
-```bash
-for spec in $SPECS; do
-    STATE_FILE=".flow/specs/$spec/.state.json"
-    if [ -f "$STATE_FILE" ]; then
-        PHASE=$(python3 -c "import json; print(json.load(open('$STATE_FILE')).get('phase','unknown'))")
-        # Can also fetch task_index, total_tasks, etc.
-    fi
-done
-```
-
-### Step 4: Output Format
-
-**Default (no arguments)** — global overview:
-
-```
-📋 CurDX-Flow Project Status
-═══════════════════════════════════════
-
-Project:       my-awesome-app
-Mode:          standard
-Active spec:   auth-system
-
-Spec list:
-  ● auth-system          design          (45% — tasks pending)
-  ○ user-profile         execute         (60% — 12/20 tasks)
-  ✓ onboarding-flow      completed       (archived)
-
-Epic list:
-  ● payment-system       3/5 sub-specs   (in progress)
-
-Recent decisions (STATE.md):
-  D-05: use JWT instead of session cookie (2026-04-15)
-  D-06: bcrypt cost factor = 12 (2026-04-15)
-
-═══════════════════════════════════════
-Next step suggestion: /curdx-flow:tasks   — generate task list for auth-system
-```
-
-**`<spec-name>`** — detail for a specific spec:
-
-```
-📋 Spec: auth-system
-═══════════════════════════════════════
-
-Phase:      design
-Progress:   45%
-Created:    2026-04-12
-
-Completed phases:
-  ✓ research        (research.md, 320 lines)
-  ✓ requirements    (requirements.md, 8 stories)
-  ● design          (design.md, in progress)
-  ○ tasks
-  ○ execute
-
-Related decisions:
-  D-05: use JWT instead of session cookie
-
-.progress.md summary:
-  - Confirmed JWT + refresh token architecture
-  - Researched bcrypt vs argon2, chose bcrypt (team familiarity)
-  - TODO: design token refresh flow
-
-Next step: /curdx-flow:tasks — generate task list
-```
-
-**`--all`** — detailed mode, every spec expanded.
-
-### Step 5: Empty-State Handling
-
-If `.flow/` exists but no specs:
-
-```
-📋 CurDX-Flow Project
-═══════════════════════════════════════
-
-Project:       my-awesome-app (just initialized)
-Mode:          standard
-Active spec:   (none)
-
-No specs yet.
-
-Start your first feature:
-  /curdx-flow:start <name> "<describe what you want to do>"
-
-Example:
-  /curdx-flow:start auth-system "Add JWT authentication to API"
-```
-
-## Notes
-
-- State data is read-only; this command does not modify any files
-- If `.state.json` is corrupted or missing, degrade gracefully (show "state unknown" instead of failing)

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"