@curdx/flow 1.1.11 → 2.0.0-beta.2

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>`

package/commands/party.md

@@ -1,241 +0,0 @@
----
-name: party
-description: Party Mode — multiple persona agents independently think about one question at the same time. BMAD-style true multi-agent collaboration.
-argument-hint: "<persona-1> <persona-2> ... \"<question>\""
-allowed-tools: [Read, Task, AskUserQuestion]
----
-
-# Flow Party — Multi-Agent Independent Thinking
-
-Have multiple **persona agents** (Mary/John/Winston, etc.) independently think about the same question at the same time. This is BMAD's true innovation: **not one LLM playing multiple roles, but multiple Task subprocesses each thinking on their own, avoiding opinion convergence**.
-
-## When to use
-
-- Hard decisions needing multiple perspectives (e.g., architecture selection)
-- Spec review (separately reviewed from product / arch / qa)
-- Brainstorming / divergent thinking
-- Finding blind spots (one perspective may see what others cannot)
-
-## When not to use
-
-- Simple questions (overhead is high)
-- Questions with a clear answer (agents will only echo)
-- Execution tasks (use a dedicated executor)
-
-## Step 1: Parse arguments
-
-```bash
-ARGS="$ARGUMENTS"
-
-# Recognize personas (known list)
-PERSONAS=()
-QUESTION=""
-
-# Simple parsing: persona names + a question wrapped in quotes at the end
-# Example: /curdx-flow:party mary john winston "JWT or session?"
-
-# Parsing logic: iterate words, add known persona names to PERSONAS, rest is the question
-KNOWN_PERSONAS="mary john winston amelia rachel oliver serena david emma"
-
-REMAINING=""
-for word in $ARGS; do
-    if echo "$KNOWN_PERSONAS" | grep -qw "$word"; then
-        PERSONAS+=("$word")
-    else
-        REMAINING="$REMAINING $word"
-    fi
-done
-
-# REMAINING is the question (possibly with quotes)
-QUESTION=$(echo "$REMAINING" | sed 's/^[[:space:]]*//;s/^["\x27]//;s/["\x27]$//')
-```
-
-## Step 2: Validate arguments
-
-```bash
-if [ ${#PERSONAS[@]} -lt 2 ]; then
-    echo "✗ Party Mode requires ≥ 2 personas"
-    echo "Available: mary john winston amelia rachel oliver serena david emma"
-    exit 1
-fi
-
-if [ ${#PERSONAS[@]} -gt 5 ]; then
-    echo "⚠ More than 5 personas will make output hard to read. Recommend ≤ 5"
-fi
-
-if [ -z "$QUESTION" ]; then
-    echo "✗ Please provide a question"
-    exit 1
-fi
-```
-
-## Step 3: Build shared context
-
-All personas read the same background:
-
-```bash
-CONTEXT_FILES=()
-[ -f "CLAUDE.md" ] && CONTEXT_FILES+=("CLAUDE.md")
-[ -f ".flow/PROJECT.md" ] && CONTEXT_FILES+=(".flow/PROJECT.md")
-[ -f ".flow/CONTEXT.md" ] && CONTEXT_FILES+=(".flow/CONTEXT.md")
-
-# If there is an active spec, append
-ACTIVE=$(cat .flow/.active-spec 2>/dev/null)
-if [ -n "$ACTIVE" ]; then
-    for f in research.md requirements.md design.md; do
-        [ -f ".flow/specs/$ACTIVE/$f" ] && CONTEXT_FILES+=(".flow/specs/$ACTIVE/$f")
-    done
-fi
-```
-
-## Step 4: Dispatch each persona in parallel
-
-**Key**: call multiple Task tools **in a single message** at the same time (parallel execution).
-This way each persona thinks in an independent context without influencing the others.
-
-```
-# Parallel invocation (in a single message):
-Task(mary):
-  subagent_type: general-purpose
-  description: "Mary thinking about $QUESTION"
-  prompt: |
-    You are Mary (Senior Analyst). Full definition:
-    ${CLAUDE_PLUGIN_ROOT}/agents/persona-mary.md
-    
-    Shared context:
-    $(cat ${CONTEXT_FILES[@]} 2>/dev/null)
-    
-    Question: $QUESTION
-    
-    Answer from Mary's perspective:
-    - First list explicit assumptions
-    - Give 2-3 interpretations from a research / analysis perspective
-    - Clearly state open questions
-    - Provide an initial recommendation (if any)
-    
-    **Forbidden**:
-    - Speaking on behalf of other personas
-    - Claiming "synthesizing John's and Winston's opinions" (you don't know what they said)
-    - Echoing / converging
-    
-    Output a concise view of <200 words.
-
-Task(john):
-  ... [john's prompt]
-
-Task(winston):
-  ... [winston's prompt]
-```
-
-**Parallel execution**: Claude Code's Task tool supports multiple invocations in a single message running in parallel.
-
-## Step 5: Collect results
-
-Each Task returns an independent answer. The main agent (you) aggregates:
-
-```markdown
-## Party Mode Results: <QUESTION>
-
-### Mary (Senior Analyst)
-<Mary's answer>
-
-### John (Product Manager)
-<John's answer>
-
-### Winston (Architect)
-<Winston's answer>
-
-## Perspective comparison
-
-| Dimension | Mary | John | Winston |
-|-----------|------|------|---------|
-| Main concern | ... | ... | ... |
-| Recommended direction | ... | ... | ... |
-| Open questions | ... | ... | ... |
-
-## Points of disagreement
-
-1. Mary and Winston disagree on X: <specifics>
-2. Y raised by John that neither of the others considered: <specifics>
-
-## Consensus
-
-1. Everyone agrees on Z
-
-## Recommendation
-
-Based on multi-perspective synthesis:
-- If you care about A → follow Mary
-- If you care about B → follow Winston
-- Middle-ground option: Y proposed by John
-```
-
-## Step 6: Let the user decide
-
-```
-AskUserQuestion:
-  question: "Having seen the multi-perspective analysis, which direction do you lean toward?"
-  options:
-    - Follow Mary's direction
-    - Follow John's direction
-    - Follow Winston's direction
-    - Synthesis: <specific compromise>
-    - Other (user input)
-```
-
-After the user chooses, write the decision to STATE.md (as D-NN, via /curdx-flow:discuss or manually).
-
-## Typical usage
-
-### Architecture selection
-
-```
-/curdx-flow:party winston mary "JWT vs Session — which is more suitable in this project"
-```
-
-### Spec review
-
-```
-/curdx-flow:party john rachel oliver "are the ACs in requirements.md sufficient"
-```
-
-### Bug approach discussion
-
-```
-/curdx-flow:party david winston "should this crash be fixed at the root cause or wrapped in try-catch"
-```
-
-### UX decision
-
-```
-/curdx-flow:party emma john oliver "how to present login failure error messages"
-```
-
-## Forbidden
-
-- ✗ Dispatching only 1 agent (that's not a Party — just use Task directly)
-- ✗ Agents referencing each other (the point of independent thinking is isolation)
-- ✗ Sequential dispatch (must be parallel Task invocations)
-- ✗ Overly long agent output (each <300 words)
-
-## Why Party Mode has value
-
-### Single LLM playing multiple roles vs. true multi-agent
-
-Single LLM: "As Mary I think X... As Winston I think Y... Synthesizing the two views, Z"
-
-Problems:
-- Opinions have already converged in advance (the LLM generates in one pass; later parts are influenced by earlier ones)
-- "Synthesis" is done by the LLM itself, without real collision
-- Easily becomes "one voice imitating multiple people"
-
-True multi-agent (Party Mode):
-- Mary's context contains only "I am Mary" and the question
-- Winston's context contains only "I am Winston" and the question
-- The two have no idea what the other said
-- The output is truly independent thinking
-- The differences are real differences, not acted out
-
----
-
-_Source: BMAD's Party Mode, implemented in CurDX-Flow via parallel dispatch of Claude Code's Task tool._