claude-code-workflow 6.3.53 → 7.0.0

package/.claude/commands/memory/docs-related-cli.md

@@ -1,386 +0,0 @@
----
-name: docs-related-cli
-description: Generate/update documentation for git-changed modules using CLI execution with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <15 modules uses direct parallel
-argument-hint: "[--tool <gemini|qwen|codex>]"
----
-
-# Related Documentation Generation - CLI Mode (/memory:docs-related-cli)
-
-## Overview
-
-Orchestrates context-aware documentation generation/update for changed modules using CLI-based execution with batched agents and automatic tool fallback (gemini→qwen→codex).
-
-**Parameters**:
-- `--tool <gemini|qwen|codex>`: Primary tool (default: gemini)
-
-**Execution Flow**:
-1. Change Detection → 2. Plan Presentation → 3. Batched Execution → 4. Verification
-
-## Core Rules
-
-1. **Detect Changes First**: Use git diff to identify affected modules
-2. **Wait for Approval**: Present plan, no execution without user confirmation
-3. **Execution Strategy**:
-   - **<15 modules**: Direct parallel execution (max 4 concurrent per depth, no agent overhead)
-   - **≥15 modules**: Agent batch processing (4 modules/agent, 73% overhead reduction)
-4. **Tool Fallback**: Auto-retry with fallback tools on failure
-5. **Depth Sequential**: Process depths N→0, parallel batches within depth (both modes)
-6. **Related Mode**: Generate/update only changed modules and their parent contexts
-7. **Single Strategy**: Always use `single` strategy (incremental update)
-
-## Tool Fallback Hierarchy
-
-```javascript
---tool gemini  →  [gemini, qwen, codex]  // default
---tool qwen    →  [qwen, gemini, codex]
---tool codex   →  [codex, gemini, qwen]
-```
-
-**Trigger**: Non-zero exit code from generation script
-
-| Tool   | Best For                       | Fallback To    |
-|--------|--------------------------------|----------------|
-| gemini | Documentation, patterns        | qwen → codex   |
-| qwen   | Architecture, system design    | gemini → codex |
-| codex  | Implementation, code quality   | gemini → qwen  |
-
-## Phase 1: Change Detection & Analysis
-
-```javascript
-// Get project metadata
-Bash({command: "pwd && basename \"$(pwd)\" && git rev-parse --show-toplevel 2>/dev/null || pwd", run_in_background: false});
-
-// Detect changed modules
-Bash({command: "ccw tool exec detect_changed_modules '{\"format\":\"list\"}'", run_in_background: false});
-
-// Cache git changes
-Bash({command: "git add -A 2>/dev/null || true", run_in_background: false});
-```
-
-**Parse output** `depth:N|path:<PATH>|change:<TYPE>|type:<code|navigation>` to extract affected modules.
-
-**Smart filter**: Auto-detect and skip tests/build/config/vendor based on project tech stack (Node.js/Python/Go/Rust/etc).
-
-**Fallback**: If no changes detected, use recent modules (first 10 by depth).
-
-## Phase 2: Plan Presentation
-
-**Present filtered plan**:
-```
-Related Documentation Generation Plan:
-  Tool: gemini (fallback: qwen → codex)
-  Changed: 4 modules | Batching: 4 modules/agent
-  Project: myproject
-  Output: .workflow/docs/myproject/
-
-  Will generate/update docs for:
-  - ./src/api/auth (5 files, type: code) [new module]
-  - ./src/api (12 files, type: code) [parent of changed auth/]
-  - ./src (8 files, type: code) [parent context]
-  - . (14 files, type: code) [root level]
-
-  Documentation Strategy:
-  - Strategy: single (all modules - incremental update)
-  - Output: API.md + README.md (code folders), README.md only (navigation folders)
-  - Context: Current dir code + child docs
-
-  Auto-skipped (12 paths):
-  - Tests: ./src/api/auth.test.ts (8 paths)
-  - Config: tsconfig.json (3 paths)
-  - Other: node_modules (1 path)
-
-  Agent allocation:
-  - Depth 3 (1 module): 1 agent [1]
-  - Depth 2 (1 module): 1 agent [1]
-  - Depth 1 (1 module): 1 agent [1]
-  - Depth 0 (1 module): 1 agent [1]
-
-  Estimated time: ~5-10 minutes
-
-  Confirm execution? (y/n)
-```
-
-**Decision logic**:
-- User confirms "y": Proceed with execution
-- User declines "n": Abort, no changes
-- <15 modules: Direct execution
-- ≥15 modules: Agent batch execution
-
-## Phase 3A: Direct Execution (<15 modules)
-
-**Strategy**: Parallel execution within depth (max 4 concurrent), no agent overhead.
-
-**CRITICAL**: All Bash commands use `run_in_background: false` for synchronous execution.
-
-```javascript
-let project_name = detect_project_name();
-
-for (let depth of sorted_depths.reverse()) {  // N → 0
-  let batches = batch_modules(modules_by_depth[depth], 4);
-
-  for (let batch of batches) {
-    let parallel_tasks = batch.map(module => {
-      return async () => {
-        for (let tool of tool_order) {
-          Bash({
-            command: `cd ${module.path} && ccw tool exec generate_module_docs '{"strategy":"single","sourcePath":".","projectName":"${project_name}","tool":"${tool}"}'`,
-            run_in_background: false
-          });
-          if (bash_result.exit_code === 0) {
-            report(`✅ ${module.path} docs generated with ${tool}`);
-            return true;
-          }
-        }
-        report(`❌ FAILED: ${module.path} failed all tools`);
-        return false;
-      };
-    });
-    await Promise.all(parallel_tasks.map(task => task()));
-  }
-}
-```
-
-## Phase 3B: Agent Batch Execution (≥15 modules)
-
-### Batching Strategy
-
-```javascript
-// Batch modules into groups of 4
-function batch_modules(modules, batch_size = 4) {
-  let batches = [];
-  for (let i = 0; i < modules.length; i += batch_size) {
-    batches.push(modules.slice(i, i + batch_size));
-  }
-  return batches;
-}
-// Examples: 10→[4,4,2] | 8→[4,4] | 3→[3]
-```
-
-### Coordinator Orchestration
-
-```javascript
-let modules_by_depth = group_by_depth(changed_modules);
-let tool_order = construct_tool_order(primary_tool);
-let project_name = detect_project_name();
-
-for (let depth of sorted_depths.reverse()) {  // N → 0
-  let batches = batch_modules(modules_by_depth[depth], 4);
-  let worker_tasks = [];
-
-  for (let batch of batches) {
-    worker_tasks.push(
-      Task(
-        subagent_type="memory-bridge",
-        description=`Generate docs for ${batch.length} modules at depth ${depth}`,
-        prompt=generate_batch_worker_prompt(batch, tool_order, depth, project_name, "related")
-      )
-    );
-  }
-
-  await parallel_execute(worker_tasks);  // Batches run in parallel
-}
-```
-
-### Batch Worker Prompt Template
-
-```
-PURPOSE: Generate/update documentation for assigned modules with tool fallback (related mode)
-
-TASK:
-Generate documentation for the following modules based on recent changes. For each module, try tools in order until success.
-
-PROJECT: {{project_name}}
-OUTPUT: .workflow/docs/{{project_name}}/
-
-MODULES:
-{{module_path_1}} (type: {{folder_type_1}})
-{{module_path_2}} (type: {{folder_type_2}})
-{{module_path_3}} (type: {{folder_type_3}})
-{{module_path_4}} (type: {{folder_type_4}})
-
-TOOLS (try in order):
-1. {{tool_1}}
-2. {{tool_2}}
-3. {{tool_3}}
-
-EXECUTION:
-For each module above:
-  1. Try tool 1:
-     Bash({
-       command: `cd "{{module_path}}" && ccw tool exec generate_module_docs '{"strategy":"single","sourcePath":".","projectName":"{{project_name}}","tool":"{{tool_1}}"}'`,
-       run_in_background: false
-     })
-     → Success: Report "✅ {{module_path}} docs generated with {{tool_1}}", proceed to next module
-     → Failure: Try tool 2
-  2. Try tool 2:
-     Bash({
-       command: `cd "{{module_path}}" && ccw tool exec generate_module_docs '{"strategy":"single","sourcePath":".","projectName":"{{project_name}}","tool":"{{tool_2}}"}'`,
-       run_in_background: false
-     })
-     → Success: Report "✅ {{module_path}} docs generated with {{tool_2}}", proceed to next module
-     → Failure: Try tool 3
-  3. Try tool 3:
-     Bash({
-       command: `cd "{{module_path}}" && ccw tool exec generate_module_docs '{"strategy":"single","sourcePath":".","projectName":"{{project_name}}","tool":"{{tool_3}}"}'`,
-       run_in_background: false
-     })
-     → Success: Report "✅ {{module_path}} docs generated with {{tool_3}}", proceed to next module
-     → Failure: Report "❌ FAILED: {{module_path}} failed all tools", proceed to next module
-
-FOLDER TYPE HANDLING:
-  - code: Generate API.md + README.md
-  - navigation: Generate README.md only
-
-REPORTING:
-Report final summary with:
-- Total processed: X modules
-- Successful: Y modules
-- Failed: Z modules
-- Tool usage: {{tool_1}}:X, {{tool_2}}:Y, {{tool_3}}:Z
-```
-
-## Phase 4: Verification
-
-```javascript
-// Check documentation files created/updated
-Bash({command: 'find .workflow/docs -type f -name "*.md" 2>/dev/null | wc -l', run_in_background: false});
-
-// Display recent changes
-Bash({command: 'find .workflow/docs -type f -name "*.md" -mmin -60 2>/dev/null', run_in_background: false});
-```
-
-**Aggregate results**:
-```
-Documentation Generation Summary:
-  Total: 4 | Success: 4 | Failed: 0
-
-  Tool usage:
-  - gemini: 4 modules
-  - qwen: 0 modules (fallback)
-  - codex: 0 modules
-
-  Changes:
-  .workflow/docs/myproject/src/api/auth/API.md      (new)
-  .workflow/docs/myproject/src/api/auth/README.md   (new)
-  .workflow/docs/myproject/src/api/API.md           (updated)
-  .workflow/docs/myproject/src/api/README.md        (updated)
-  .workflow/docs/myproject/src/API.md               (updated)
-  .workflow/docs/myproject/src/README.md            (updated)
-  .workflow/docs/myproject/API.md                   (updated)
-  .workflow/docs/myproject/README.md                (updated)
-```
-
-## Execution Summary
-
-**Module Count Threshold**:
-- **<15 modules**: Coordinator executes Phase 3A (Direct Execution)
-- **≥15 modules**: Coordinator executes Phase 3B (Agent Batch Execution)
-
-**Agent Hierarchy** (for ≥15 modules):
-- **Coordinator**: Handles batch division, spawns worker agents per depth
-- **Worker Agents**: Each processes 4 modules with tool fallback (related mode)
-
-## Error Handling
-
-**Batch Worker**:
-- Tool fallback per module (auto-retry)
-- Batch isolation (failures don't propagate)
-- Clear per-module status reporting
-
-**Coordinator**:
-- No changes: Use fallback (recent 10 modules)
-- User decline: No execution
-- Verification fail: Report incomplete modules
-- Partial failures: Continue execution, report failed modules
-
-**Fallback Triggers**:
-- Non-zero exit code
-- Script timeout
-- Unexpected output
-
-## Output Structure
-
-```
-.workflow/docs/{project_name}/
-├── src/                           # Mirrors source structure
-│   ├── modules/
-│   │   ├── README.md
-│   │   ├── auth/
-│   │   │   ├── API.md             # Updated based on code changes
-│   │   │   └── README.md          # Updated based on code changes
-│   │   └── api/
-│   │       ├── API.md
-│   │       └── README.md
-│   └── utils/
-│       └── README.md
-└── README.md
-```
-
-## Usage Examples
-
-```bash
-# Daily development documentation update
-/memory:docs-related-cli
-
-# After feature work with specific tool
-/memory:docs-related-cli --tool qwen
-
-# Code quality documentation review after implementation
-/memory:docs-related-cli --tool codex
-```
-
-## Key Advantages
-
-**Efficiency**: 30 modules → 8 agents (73% reduction)
-**Resilience**: 3-tier fallback per module
-**Performance**: Parallel batches, no concurrency limits
-**Context-aware**: Updates based on actual git changes
-**Fast**: Only affected modules, not entire project
-**Incremental**: Single strategy for focused updates
-
-## Coordinator Checklist
-
-- Parse `--tool` (default: gemini)
-- Get project metadata (name, root)
-- Detect changed modules via detect_changed_modules.sh
-- **Smart filter modules** (auto-detect tech stack, skip tests/build/config/vendor)
-- Cache git changes
-- Apply fallback if no changes (recent 10 modules)
-- Construct tool fallback order
-- **Present filtered plan** with skip reasons and change types
-- **Wait for y/n confirmation**
-- Determine execution mode:
-  - **<15 modules**: Direct execution (Phase 3A)
-    - For each depth (N→0): Sequential module updates with tool fallback
-  - **≥15 modules**: Agent batch execution (Phase 3B)
-    - For each depth (N→0): Batch modules (4 per batch), spawn batch workers in parallel
-- Wait for depth/batch completion
-- Aggregate results
-- Verification check (documentation files created/updated)
-- Display summary + recent changes
-
-## Comparison with Full Documentation Generation
-
-| Aspect | Related Generation | Full Generation |
-|--------|-------------------|-----------------|
-| **Scope** | Changed modules only | All project modules |
-| **Speed** | Fast (minutes) | Slower (10-30 min) |
-| **Use case** | Daily development | Initial setup, major refactoring |
-| **Strategy** | `single` (all) | `full` (L3) + `single` (L1-2) |
-| **Trigger** | After commits | After setup or major changes |
-| **Batching** | 4 modules/agent | 4 modules/agent |
-| **Fallback** | gemini→qwen→codex | gemini→qwen→codex |
-| **Complexity threshold** | ≤15 modules | ≤20 modules |
-
-## Template Reference
-
-Templates used from `~/.claude/workflows/cli-templates/prompts/documentation/`:
-- `api.txt`: Code API documentation
-- `module-readme.txt`: Module purpose, usage, dependencies
-- `folder-navigation.txt`: Navigation README for folders
-
-## Related Commands
-
-- `/memory:docs-full-cli` - Full project documentation generation
-- `/memory:docs` - Agent-based documentation planning workflow
-- `/memory:update-related` - Update CLAUDE.md for changed modules

package/.claude/commands/memory/load.md

@@ -1,240 +0,0 @@
----
-name: load
-description: Delegate to universal-executor agent to analyze project via Gemini/Qwen CLI and return JSON core content package for task context
-argument-hint: "[--tool gemini|qwen] \"task context description\""
-allowed-tools: Task(*), Bash(*)
-examples:
-  - /memory:load "在当前前端基础上开发用户认证功能"
-  - /memory:load --tool qwen "重构支付模块API"
----
-
-# Memory Load Command (/memory:load)
-
-## 1. Overview
-
-The `memory:load` command **delegates to a universal-executor agent** to analyze the project and return a structured "Core Content Pack". This pack is loaded into the main thread's memory, providing essential context for subsequent agent operations while minimizing token consumption.
-
-**Core Philosophy**:
-- **Agent-Driven**: Fully delegates execution to universal-executor agent
-- **Read-Only Analysis**: Does not modify code, only extracts context
-- **Structured Output**: Returns standardized JSON content package
-- **Memory Optimization**: Package loaded directly into main thread memory
-- **Token Efficiency**: CLI analysis executed within agent to save tokens
-
-## 2. Parameters
-
-- `"task context description"` (Required): Task description to guide context extraction
-  - Example: "在当前前端基础上开发用户认证功能"
-  - Example: "重构支付模块API"
-  - Example: "修复数据库查询性能问题"
-
-- `--tool <gemini|qwen>` (Optional): Specify CLI tool for agent to use (default: gemini)
-  - gemini: Large context window, suitable for complex project analysis
-  - qwen: Alternative to Gemini with similar capabilities
-
-## 3. Agent-Driven Execution Flow
-
-The command fully delegates to **universal-executor agent**, which autonomously:
-
-1. **Analyzes Project Structure**: Executes `get_modules_by_depth.sh` to understand architecture
-2. **Loads Documentation**: Reads CLAUDE.md, README.md and other key docs
-3. **Extracts Keywords**: Derives core keywords from task description
-4. **Discovers Files**: Uses CodexLens MCP or rg/find to locate relevant files
-5. **CLI Deep Analysis**: Executes Gemini/Qwen CLI for deep context analysis
-6. **Generates Content Package**: Returns structured JSON core content package
-
-## 4. Core Content Package Structure
-
-**Output Format** - Loaded into main thread memory for subsequent use:
-
-```json
-{
-  "task_context": "在当前前端基础上开发用户认证功能",
-  "keywords": ["前端", "用户", "认证", "auth", "login"],
-  "project_summary": {
-    "architecture": "TypeScript + React frontend with Vite build system",
-    "tech_stack": ["React", "TypeScript", "Vite", "TailwindCSS"],
-    "key_patterns": [
-      "State management via Context API",
-      "Functional components with Hooks pattern",
-      "API calls encapsulated in custom hooks"
-    ]
-  },
-  "relevant_files": [
-    {
-      "path": "src/components/Auth/LoginForm.tsx",
-      "relevance": "Existing login form component",
-      "priority": "high"
-    },
-    {
-      "path": "src/contexts/AuthContext.tsx",
-      "relevance": "Authentication state management context",
-      "priority": "high"
-    },
-    {
-      "path": "CLAUDE.md",
-      "relevance": "Project development standards",
-      "priority": "high"
-    }
-  ],
-  "integration_points": [
-    "Must integrate with existing AuthContext",
-    "Follow component organization pattern: src/components/[Feature]/",
-    "API calls should use src/hooks/useApi.ts wrapper"
-  ],
-  "constraints": [
-    "Maintain backward compatibility",
-    "Follow TypeScript strict mode",
-    "Use existing UI component library"
-  ]
-}
-```
-
-## 5. Agent Invocation
-
-```javascript
-Task(
-  subagent_type="universal-executor",
-  description="Load project memory: ${task_description}",
-  prompt=`
-## Mission: Load Project Memory Context
-
-**Task**: Load project memory context for: "${task_description}"
-**Mode**: analysis
-**Tool Preference**: ${tool || 'gemini'}
-
-## Execution Steps
-
-### Step 1: Foundation Analysis
-
-1. **Project Structure**
-   \`\`\`bash
-   bash(ccw tool exec get_modules_by_depth '{}')
-   \`\`\`
-
-2. **Core Documentation**
-   \`\`\`javascript
-   Read(CLAUDE.md)
-   Read(README.md)
-   \`\`\`
-
-### Step 2: Keyword Extraction & File Discovery
-
-1. Extract core keywords from task description
-2. Discover relevant files using ripgrep and find:
-   \`\`\`bash
-   # Find files by name
-   find . -name "*{keyword}*" -type f
-
-   # Search content with ripgrep
-   rg "{keyword}" --type ts --type md -C 2
-   rg -l "{keyword}" --type ts --type md  # List files only
-   \`\`\`
-
-### Step 3: Deep Analysis via CLI
-
-Execute Gemini/Qwen CLI for deep analysis (saves main thread tokens):
-
-\`\`\`bash
-ccw cli -p "
-PURPOSE: Extract project core context for task: ${task_description}
-TASK: Analyze project architecture, tech stack, key patterns, relevant files
-MODE: analysis
-CONTEXT: @CLAUDE.md,README.md @${discovered_files}
-EXPECTED: Structured project summary and integration point analysis
-RULES:
-- Focus on task-relevant core information
-- Identify key architecture patterns and technical constraints
-- Extract integration points and development standards
-- Output concise, structured format
-" --tool ${tool} --mode analysis
-\`\`\`
-
-### Step 4: Generate Core Content Package
-
-Generate structured JSON content package (format shown above)
-
-**Required Fields**:
-- task_context: Original task description
-- keywords: Extracted keyword array
-- project_summary: Architecture, tech stack, key patterns
-- relevant_files: File list with path, relevance, priority
-- integration_points: Integration guidance
-- constraints: Development constraints
-
-### Step 5: Return Content Package
-
-Return JSON content package as final output for main thread to load into memory.
-
-## Quality Checklist
-
-Before returning:
-- [ ] Valid JSON format
-- [ ] All required fields complete
-- [ ] relevant_files contains 3-10 files minimum
-- [ ] project_summary accurately reflects architecture
-- [ ] integration_points clearly specify integration paths
-- [ ] keywords accurately extracted (3-8 keywords)
-- [ ] Content concise, avoiding redundancy (< 5KB total)
-
-  `
-)
-```
-
-## 6. Usage Examples
-
-### Example 1: Load Context for New Feature
-
-```bash
-/memory:load "在当前前端基础上开发用户认证功能"
-```
-
-**Agent Execution**:
-1. Analyzes project structure (`get_modules_by_depth.sh`)
-2. Reads CLAUDE.md, README.md
-3. Extracts keywords: ["前端", "用户", "认证", "auth"]
-4. Uses MCP to search relevant files
-5. Executes Gemini CLI for deep analysis
-6. Returns core content package
-
-**Returned Package** (loaded into memory):
-```json
-{
-  "task_context": "在当前前端基础上开发用户认证功能",
-  "keywords": ["前端", "认证", "auth", "login"],
-  "project_summary": { ... },
-  "relevant_files": [ ... ],
-  "integration_points": [ ... ],
-  "constraints": [ ... ]
-}
-```
-
-### Example 2: Using Qwen Tool
-
-```bash
-/memory:load --tool qwen "重构支付模块API"
-```
-
-Agent uses Qwen CLI for analysis, returns same structured package.
-
-### Example 3: Bug Fix Context
-
-```bash
-/memory:load "修复登录验证错误"
-```
-
-Returns core context related to login validation, including test files and validation logic.
-
-### Memory Persistence
-
-- **Session-Scoped**: Content package valid for current session
-- **Subsequent Reference**: All subsequent agents/commands can access
-- **Reload Required**: New sessions need to re-execute /memory:load
-
-## 8. Notes
-
-- **Read-Only**: Does not modify any code, pure analysis
-- **Token Optimization**: CLI analysis executed within agent, saves main thread tokens
-- **Memory Loading**: Returned JSON loaded directly into main thread memory
-- **Subsequent Use**: Other commands/agents can reference this package for development
-- **Session-Level**: Content package valid for current session