@curdx/flow 1.1.11 → 2.0.0-beta.10

package/commands/discuss.md

@@ -1,162 +0,0 @@
----
-name: discuss
-description: Pre-implementation discussion — capture the user's key decisions (D-NN) for the spec, written to .progress.md and STATE.md. Stop the AI from "silently assuming".
-argument-hint: "[spec-name]"
-allowed-tools: [Read, Write, Edit, AskUserQuestion, Bash]
----
-
-# Flow Discuss — Decision Locking
-
-Before implementation, align with the user on **key decisions** (D-NN format) so the downstream implementer does not have to guess user preferences.
-
-## When to use
-
-- design is done but before tasks (freeze decisions into tasks)
-- before implementation (give executor explicit guidance)
-- user wants to adjust direction halfway through a spec (add decisions)
-
-## Step 1: Prerequisites
-
-```bash
-SPEC_NAME="${ARGUMENTS:-$(cat .flow/.active-spec 2>/dev/null)}"
-[ -z "$SPEC_NAME" ] && { echo "❌ No active spec"; exit 1; }
-
-DIR=".flow/specs/$SPEC_NAME"
-[ ! -f "$DIR/design.md" ] && { echo "❌ Missing design.md. Run /curdx-flow:design first"; exit 1; }
-```
-
-## Step 2: Identify open decisions
-
-Read the open questions in design.md + requirements.md:
-
-```bash
-# Find open-questions sections in design / requirements
-sed -n '/## Open Questions/,/^##/p' "$DIR/design.md" 2>/dev/null
-sed -n '/## Open Questions/,/^##/p' "$DIR/requirements.md" 2>/dev/null
-```
-
-Also scan unresolved TODO / FIXME:
-
-```bash
-grep -i "TBD\|TODO\|pending\|FIXME" "$DIR/"*.md
-```
-
-## Step 3: Interactive questioning (key)
-
-For each open decision, capture the user's choice via AskUserQuestion:
-
-```
-AskUserQuestion:
-  Question: "How to store user data"
-  Options:
-    - A: PostgreSQL (relational, already used in the project)
-    - B: MongoDB (flexible schema, needs a new dependency)
-    - C: Do not decide yet (defer to actual implementation)
-```
-
-**Forbidden**:
-- The agent guesses the answer itself
-- Merging multiple open questions into one ask (user can't answer all)
-
-**Supported**:
-- User picks "C: do not decide yet" → record as `D-NN: deferred, decide at implementation time`
-- User wants to add rationale → append to the D-NN rationale
-- User proposes a new direction (not in the options) → record and tag "user-originated"
-
-## Step 4: Assign D-NN
-
-Read existing STATE.md to get the largest D number:
-
-```python
-import re
-content = open('.flow/STATE.md').read()
-existing = re.findall(r'D-(\d+)', content)
-next_n = max([int(x) for x in existing] + [0]) + 1
-```
-
-For each new decision:
-- Project-level impact (e.g., "the whole project uses PostgreSQL") → D-NN (append to STATE.md)
-- Spec-level impact (e.g., "this spec uses bcrypt cost 12") → append to the spec's .progress.md
-
-## Step 5: Append to STATE.md
-
-```markdown
-## New decisions (append to the Decisions section of .flow/STATE.md)
-
-- **D-07** | 2026-04-19 | auth-system spec decides to use JWT + Redis blocklist | supports cross-domain SPA; token revocation via Redis
-- **D-08** | 2026-04-19 | All user data uses PostgreSQL | already used in the project; avoid introducing a new dependency
-```
-
-**Append only, never modify existing D-NN.** (Once a decision is locked, do not change it.)
-
-## Step 6: Append to .progress.md
-
-```markdown
-# .flow/specs/$SPEC_NAME/.progress.md
-
-## Decisions Made Here (from /curdx-flow:discuss YYYY-MM-DD)
-
-- **D-07**: JWT + Redis blocklist
-  - Project-level → synced to STATE.md
-- **D-08**: PostgreSQL for user data
-  - Project-level → synced to STATE.md
-- **D-local-01**: bcrypt cost factor 12 (spec-level)
-  - Rationale: balance performance (100ms) and security
-  - No need to sync to STATE.md
-```
-
-Project-level use the global D-NN numbering; spec-level use `D-local-NN` without taking a global number.
-
-## Step 7: Update tasks.md references (if already generated)
-
-If tasks.md already exists, append `_Decisions: D-NN` reference to each task (so the executor knows which decision the task must follow).
-
-If tasks.md has not been generated, a later `/curdx-flow:tasks` will generate based on these decisions.
-
-## Step 8: Output to user
-
-```
-✓ Discuss complete: $SPEC_NAME
-
-Captured decisions:
-  Project-level (D-NN):
-    • D-07: JWT + Redis blocklist
-    • D-08: PostgreSQL for user data
-  
-  Spec-level (D-local-NN):
-    • D-local-01: bcrypt cost factor 12
-
-Written to:
-  • .flow/STATE.md (D-07, D-08)
-  • .flow/specs/$SPEC_NAME/.progress.md (all)
-
-These decisions will be honored by flow-executor during subsequent execution without re-asking.
-
-Next steps:
-  - If tasks.md is already generated → /curdx-flow:implement
-  - If not → /curdx-flow:tasks (will automatically reference these decisions)
-```
-
-## Forbidden
-
-- ✗ Agent guessing the user's choice
-- ✗ Asking open questions in bulk (must use AskUserQuestion one by one)
-- ✗ Modifying existing D-NN (append only)
-- ✗ Putting spec-level decisions in STATE.md (only project-level)
-
-## Principles
-
-### Discuss ≠ clarifying requirements
-
-- **Discuss**: design exists; now decide execution details (e.g., "which DB")
-- **Clarifying requirements**: should be done in the requirements phase
-
-If discuss reveals that the requirements themselves are unclear → return to /curdx-flow:requirements.
-
-### A decision is a contract
-
-Once a D-NN is written to STATE.md, all subsequent related code must reference the D-NN. To violate it, explicit challenge is required:
-
-```
-Comment or PR description: "Challenge D-07: using session rather than JWT here because X"
-```

package/commands/doctor.md

@@ -1,124 +0,0 @@
----
-name: doctor
-description: Check the dependency health and project configuration of CurDX-Flow
-argument-hint: "[--verbose]"
-allowed-tools: [Bash, Read]
----
-
-# CurDX-Flow Health Check
-
-Quickly confirm: **Are all the MCPs up? Are the recommended plugins installed? Is the project config valid?**
-
-## Steps
-
-### Step 1: MCP status
-
-```bash
-claude mcp list 2>/dev/null
-```
-
-Expected (auto-injected by CurDX-Flow's plugin.json):
-
-- ✓ `context7` — documentation queries
-- ✓ `sequential-thinking` — structured thinking
-- ✓ `chrome-devtools` — browser QA
-
-If missing, output:
-- `❌ <name> not started. Possible causes: npx connection failed, Node.js < 18, or corrupted npm cache.`
-- Hint: `claude mcp list` to view details, or restart Claude Code.
-
-### Step 2: Plugin status
-
-```bash
-claude plugin list 2>/dev/null
-```
-
-**Required**:
-- `curdx-flow` — this plugin
-
-**Recommended**:
-- `pua` (tanweai/pua) — anti-giving-up
-- `claude-mem` (thedotmack/claude-mem) — auto memory
-- `frontend-design` — UI design
-
-If a recommended plugin is missing, output:
-```
-⚠ <name> is not installed. Run /curdx-flow:install-deps to install, or run in degraded mode.
-Degradation impact:
-  - pua missing → no pressure escalation; rely on the three red lines in the preamble
-  - claude-mem missing → no auto memory; only explicit state in .flow/STATE.md
-  - frontend-design missing → UI falls back to default Tailwind + shadcn
-```
-
-### Step 3: Project status
-
-Check whether `.flow/` exists:
-
-```bash
-if [ -d ".flow" ]; then
-    echo "✓ .flow/ directory exists"
-else
-    echo "⚠ .flow/ directory does not exist. Run /curdx-flow:init to initialize."
-fi
-```
-
-If present, check:
-- `.flow/config.json` — valid JSON?
-- `.flow/PROJECT.md` — has content (not template placeholder)?
-- `.flow/STATE.md` — readable?
-- `.flow/.active-spec` — does the corresponding specs/<name>/ exist?
-
-### Step 4: CLAUDE.md check
-
-```bash
-if [ -f "CLAUDE.md" ]; then
-    echo "✓ Project-level CLAUDE.md exists"
-else
-    echo "ℹ Project has no CLAUDE.md. The Karpathy baseline is still injected via the InstructionsLoaded hook."
-fi
-```
-
-### Step 5: Write diagnostic report (optional --verbose)
-
-In verbose mode, output a full diagnosis, including:
-- Node.js version (`node --version`)
-- Claude Code version (`claude --version`)
-- Plugin data directory: `${CLAUDE_PLUGIN_DATA}`
-- Last dependency check date: `${CLAUDE_PLUGIN_DATA}/.deps-checked`
-
-## Output format
-
-```
-🏥 CurDX-Flow Health Check
-═══════════════════════════════════════
-
-MCP Servers:
-  ✓ context7              (auto-installed)
-  ✓ sequential-thinking   (auto-installed)
-  ✓ chrome-devtools       (auto-installed)
-
-Plugins:
-  ✓ curdx-flow            v0.1.0
-  ✓ pua                   v3.2.1
-  ⚠ claude-mem            not installed  → /curdx-flow:install-deps
-  ✓ frontend-design       v1.x
-
-Project:
-  ✓ .flow/                initialized
-  ✓ config.json           valid (mode: standard)
-  ⚠ PROJECT.md            still the template (please fill in the project vision)
-  ℹ No active spec        run /curdx-flow:start to launch the first one
-
-═══════════════════════════════════════
-Summary: 1 warning, 0 errors. Run /curdx-flow:install-deps to clear the warning.
-```
-
-## Exit status
-
-- 0 errors → fully healthy
-- Warnings only → usable, but recommended to address
-- Errors present → must be fixed before continuing
-
-## Error recovery
-
-For each issue found, provide a concrete recovery command rather than just "check the config".

package/commands/index.md

@@ -1,261 +0,0 @@
----
-name: index
-description: Codebase index — scan brownfield projects and generate a module/component/API index. Provides the foundation for subsequent /curdx-flow:research.
-argument-hint: "[--force]"
-allowed-tools: [Read, Write, Bash, Grep, Glob]
----
-
-# Flow Index — Codebase Scan and Index
-
-Generate an index for **brownfield projects** (existing code) so that flow-researcher and flow-architect can quickly acquire project-structure information.
-
-## Applicable Scenarios
-
-- Taking over an existing project — run `/curdx-flow:index` first to build understanding
-- Large monorepo requiring indexes of subpackages
-- Want to add a new feature to the current project — index before researching
-
-## Not Applicable
-
-- Greenfield projects (empty codebase)
-- Micro projects (< 20 files)
-
-## Step 1: Preflight
-
-```bash
-[ ! -d ".flow" ] && { echo "❌ Not a CurDX-Flow project. Run /curdx-flow:init first"; exit 1; }
-
-INDEX_FILE=".flow/codebase-index.md"
-
-# If one exists and --force is not set, ask
-if [ -f "$INDEX_FILE" ] && [ "$ARGUMENTS" != "--force" ]; then
-    echo "ℹ Index already exists: $INDEX_FILE"
-    # AskUserQuestion: overwrite / incremental / cancel
-fi
-```
-
-## Step 2: Detect Project Type
-
-```bash
-# Identify project language + build tool
-if [ -f "package.json" ]; then
-    PROJECT_TYPE="node"
-    FRAMEWORK=$(grep -E "(react|vue|next|nuxt|svelte)" package.json | head -3)
-elif [ -f "requirements.txt" ] || [ -f "pyproject.toml" ]; then
-    PROJECT_TYPE="python"
-elif [ -f "Cargo.toml" ]; then
-    PROJECT_TYPE="rust"
-elif [ -f "go.mod" ]; then
-    PROJECT_TYPE="go"
-fi
-```
-
-## Step 3: Scan Directory Structure
-
-```bash
-# Top-level directories
-DIRS=$(ls -d */ 2>/dev/null | grep -vE "(node_modules|dist|build|\.git|\.next)")
-
-# File statistics
-TOTAL_FILES=$(find . -type f -not -path "*/node_modules/*" -not -path "*/.git/*" | wc -l)
-SRC_FILES=$(find src/ -type f 2>/dev/null | wc -l)
-```
-
-## Step 4: Identify Modules
-
-Use Grep + Glob to find module boundaries:
-
-```bash
-# TypeScript / JavaScript: find export default + public API
-# Python: find __init__.py
-# Rust: find mod.rs / lib.rs
-# Go: find package declaration
-
-# Typical pattern (Node project):
-Glob: src/**/index.{ts,tsx,js}
-Grep: "^export (default|const|function|class)" in index files
-```
-
-## Step 5: Identify Components / Services / APIs
-
-```bash
-# UI components
-Glob: src/**/*.{tsx,jsx,vue,svelte}
-
-# API endpoints
-Grep: "router\.\(get\|post\|put\|delete\)" or "app\.(get|post)" or "@app.route"
-
-# DB models
-Grep: "@Entity\|Schema\|Model\|prisma\."
-
-# Services
-Glob: src/**/*Service.{ts,js}
-```
-
-## Step 6: Build the Index Markdown
-
-```markdown
-# Codebase Index: <project name>
-
-Generated: YYYY-MM-DD
-Project type: Node (TypeScript + React)
-Total files: 234 (189 under src/)
-
-## Directory Structure
-
-```
-src/
-├── auth/          ← authentication module
-├── user/          ← user management
-├── orders/        ← orders
-├── ui/            ← shared UI components
-├── api/           ← API routes
-├── db/            ← DB layer
-└── utils/         ← utility functions
-```
-
-## Module List
-
-### Module: auth
-- Path: src/auth/
-- Entry: src/auth/index.ts
-- Exports:
-  - `login(email, password)` - log in
-  - `logout(token)` - log out
-  - `refreshToken(token)` - refresh
-- Dependencies: bcrypt, jsonwebtoken
-- Tests: src/auth/*.test.ts (15 tests)
-
-### Module: user
-- Path: src/user/
-- Entry: src/user/index.ts
-- Exports:
-  - `getUser(id)` - fetch user
-  - `updateProfile(id, data)` - update profile
-- Dependencies: prisma
-- Tests: src/user/*.test.ts (8 tests)
-
-### Module: orders
-...
-
-## UI Component List
-
-### Shared components (src/ui/)
-
-- `<Button>` - src/ui/Button.tsx
-- `<Input>` - src/ui/Input.tsx
-- `<Card>` - src/ui/Card.tsx
-- ...
-
-### Page components (src/pages/)
-
-- `LoginPage` - src/pages/Login.tsx
-- `DashboardPage` - src/pages/Dashboard.tsx
-- ...
-
-## API Endpoints
-
-### /auth
-- POST /auth/login → src/api/auth.ts:login
-- POST /auth/logout → src/api/auth.ts:logout
-- POST /auth/refresh → src/api/auth.ts:refresh
-
-### /users
-- GET /users/me → src/api/users.ts:getCurrent
-- PUT /users/me → src/api/users.ts:update
-- ...
-
-## DB Models
-
-- `User` - src/db/models/User.ts
-- `Order` - src/db/models/Order.ts
-- ...
-
-## Tech Stack
-
-- **Runtime**: Node 20 + TypeScript 5
-- **Framework**: Next.js 14 (App Router)
-- **UI**: React 18 + Tailwind + shadcn/ui
-- **DB**: PostgreSQL + Prisma
-- **Auth**: JWT + bcrypt
-- **Testing**: Vitest + Playwright
-
-## Commands
-
-From package.json:
-- `npm run dev` - dev server (localhost:3000)
-- `npm test` - tests
-- `npm run build` - production build
-- `npm run lint` - ESLint
-
-## Conventions
-
-- File naming: PascalCase for components, camelCase for utilities
-- Tests: `*.test.ts` adjacent to source file
-- Types: standalone `types.ts` or inline interface
-- Exports: each module's `index.ts` as the public API
-
-## Hot Files (most modified recently)
-
-- src/auth/login.ts (12 commits in the past 30 days)
-- src/ui/Button.tsx (8 commits)
-- ...
-
-## Tech Debt / TODO
-
-Scan for `// TODO:` / `// FIXME:`:
-- src/auth/refresh.ts:28 - "TODO: add rate limiting"
-- src/api/orders.ts:45 - "FIXME: handle concurrent updates"
-- ...
-```
-
-## Step 7: Save + Update .state
-
-```bash
-# Write
-echo "$INDEX_CONTENT" > "$INDEX_FILE"
-
-# If .flow/config.json exists, record the index time
-python3 -c "
-import json
-c = json.load(open('.flow/config.json'))
-c.setdefault('codebase_index', {})['last_updated'] = '$(date +%Y-%m-%d)'
-json.dump(c, open('.flow/config.json','w'), indent=2, ensure_ascii=False)
-"
-```
-
-## Step 8: Output
-
-```
-✓ Codebase index complete
-
-File: .flow/codebase-index.md (~N lines)
-
-Statistics:
-  Modules: M
-  UI components: K
-  API endpoints: L
-  DB models: J
-
-You can now:
-- Agents will read this index as context during /curdx-flow:research
-- When running /curdx-flow:start for a new feature, reference this index first to find reusable modules
-- View it manually to understand the project structure
-
-Suggestion:
-- Rerun after major code changes: /curdx-flow:index --force
-- No need to run on every change (30-day stability is OK)
-```
-
-## Notes
-
-- The index is **not full documentation**, it is a **quick guide**. Details still live in the source code.
-- Large project scans may take 1-2 minutes
-- Does not scan node_modules / dist / build / .git
-- Exclusion list configurable (future enhancement)
-
-## Error Recovery
-
-- Project too large (10K+ files) → index by module
-- Project type cannot be identified → provide a template for the user to fill in manually
-- Some paths have permission issues → skip and continue with the rest

package/commands/install-deps.md

@@ -1,128 +0,0 @@
----
-name: install-deps
-description: Interactively install CurDX-Flow's recommended plugin dependencies (pua / claude-mem / frontend-design)
-argument-hint: "[--all | --skip-prompt]"
-allowed-tools: [Bash, AskUserQuestion]
----
-
-# One-Shot Install of Recommended Plugins
-
-CurDX-Flow auto-installs 3 MCPs via `plugin.json.mcpServers`:
-- ✓ context7 — docs lookup
-- ✓ sequential-thinking — structured thinking
-- ✓ chrome-devtools — browser QA
-
-This command interactively installs 3 recommended **plugins** (they are not MCPs and must be installed separately):
-
-| Plugin | Purpose | Official/Community |
-|--------|---------|--------------------|
-| **pua** (tanweai/pua) | Prevent AI from giving up; enforces the three red lines | Community |
-| **claude-mem** (thedotmack/claude-mem) | Automatic cross-session memory | Community |
-| **frontend-design** | UI design skill | Anthropic official |
-
-## Execution Steps
-
-### Step 1: Network Check
-
-```bash
-if ! ping -c 1 -W 2 github.com >/dev/null 2>&1; then
-  echo "⚠️ Network unreachable, cannot install plugins from the marketplace."
-  echo "CurDX-Flow will run in degraded mode (MCPs remain available)."
-  exit 0
-fi
-```
-
-### Step 2: Detect Current Installation Status
-
-```bash
-INSTALLED=$(claude plugin list 2>/dev/null || echo "")
-```
-
-Parse out which are installed and which are not.
-
-### Step 3: Ask the User
-
-If the `--all` argument is present, skip asking and install everything. Otherwise use AskUserQuestion:
-
-**Question**: Which recommended plugins to install?
-
-**Options** (list only those not installed):
-- **all** — Install all (recommended)
-- **recommended** — Install pua + claude-mem + frontend-design
-- **custom** — Pick manually (follow up with a multi-select question)
-- **skip** — Skip (the core MCPs are already enough)
-
-If the user picks `custom`, use a second AskUserQuestion to let them multi-select which to install.
-
-### Step 4: Run Installation
-
-Based on the selection (install only those not yet installed):
-
-#### pua
-
-```bash
-claude plugin marketplace add tanweai/pua
-claude plugin install pua@pua-skills --scope user
-```
-
-#### claude-mem
-
-```bash
-claude plugin marketplace add thedotmack/claude-mem
-claude plugin install claude-mem --scope user
-```
-
-#### frontend-design
-
-Anthropic's official plugin is typically in the default marketplace:
-
-```bash
-# If the default marketplace is enabled
-claude plugin install frontend-design --scope user
-```
-
-On failure, tell the user:
-> frontend-design must be installed from the official marketplace. Inside Claude Code run:
-> `/plugin`, then search for "frontend-design" in the Discover panel.
-
-### Step 5: Update Marker
-
-```bash
-DATA_DIR="${CLAUDE_PLUGIN_DATA:-$HOME/.claude/plugins/data/curdx-flow}"
-mkdir -p "$DATA_DIR"
-echo "$(date +%Y-%m-%d)" > "$DATA_DIR/.deps-checked"
-```
-
-Prevents the SessionStart hook from continuing to remind.
-
-### Step 6: Verify and Report
-
-```bash
-claude plugin list 2>/dev/null | grep -E "pua|claude-mem|frontend-design"
-```
-
-Print the installation summary:
-
-```
-Install report:
-  ✓ pua             (v3.2.1)
-  ✓ claude-mem      (v12.3.0)
-  ⚠ frontend-design (requires manual install via /plugin)
-
-Next steps:
-  /curdx-flow:doctor      — full health check
-  /curdx-flow:init        — initialize project (if not yet initialized)
-```
-
-## Error Handling
-
-- `claude plugin marketplace add` failure → report the specific error (usually network/permissions)
-- `claude plugin install` failure → ask the user to run the command manually
-- User interruption → keep what is already installed, resume on the next run
-- Installed but needs updating → suggest `claude plugin update <name>`
-
-## Notes
-
-- This command only **installs**, it does not **configure**. See each plugin's own docs for configuration.
-- Installation is **global** (scope=user), shared across all projects.
-- Uninstall: `claude plugin uninstall <name>`