Skip to main content

/memory:docs-related-cli

Generate CLI documentation for modules affected by git changes using batched agent execution with automatic tool fallback.

Overview​

The /memory:docs-related-cli command generates documentation only for modules affected by recent git changes, providing faster documentation updates for daily development.

Parameters:

  • --tool <gemini|qwen|codex>: Primary tool (default: gemini)

Execution Flow:

  1. Change Detection → 2. Plan Presentation → 3. Batched Generation → 4. Verification

Features​

  • Changed Module Detection - Uses git diff to identify affected modules
  • Intelligent Batching - Groups modules by depth (4 modules/agent)
  • Automatic Fallback - gemini→qwen→codex on failure
  • Depth Sequential - Process depths N→0, parallel batches within depth
  • Smart Filtering - Auto-detects and skips tests/build/config/docs
  • Single Strategy - Uses single-layer documentation for speed

Usage​

# Generate docs for changed modules
/memory:docs-related-cli

# Use specific tool
/memory:docs-related-cli --tool qwen

Tool Fallback Hierarchy​

--tool gemini  →  [gemini, qwen, codex]  // default
--tool qwen    →  [qwen, gemini, codex]
--tool codex   →  [codex, gemini, qwen]

Execution Flow​

Phase 1: Change Detection & Analysis​

// 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> to extract affected modules.

Smart filter: Auto-detect and skip tests/build/config/docs based on project tech stack.

Fallback: If no changes detected, use recent modules (first 10 by depth).

Phase 2: Plan Presentation​

  • Parse --tool (default: gemini)
  • Refresh code index for accurate change detection
  • Detect changed modules
  • Smart filter modules (auto-detect tech stack, skip tests/build/config)
  • Cache git changes
  • Apply fallback if no changes
  • Construct tool fallback order
  • Present filtered plan with change types
  • Wait for y/n confirmation

Phase 3: Batched Documentation Generation​

let modules_by_depth = group_by_depth(changed_modules);
let tool_order = construct_tool_order(primary_tool);

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 4: Verification​

  • Verify documentation files were created
  • Display statistics
  • Show summary of generated docs

Strategy Selection​

Related Mode uses single strategy:

  • Generates single document per module
  • Faster than full mode's multi-layer approach
  • Suitable for iterative development

Comparison with Full CLI Documentation​

AspectRelated DocsFull Docs
ScopeChanged modules onlyAll project modules
SpeedFast (minutes)Slower (10-30 min)
Use caseDaily developmentMajor refactoring
Strategysingle onlyfull for depth>=3
TriggerAfter commitsAfter major changes
Batching4 modules/agent4 modules/agent
Fallbackgemini→qwen→codexgemini→qwen→codex

Examples​

Basic Usage​

# Document changed modules after commits
/memory:docs-related-cli

# Output:
# Detecting git changes...
# Found 8 changed modules
# Filtered: 3 test modules skipped
# Plan: Generate docs for 5 modules
# Confirm? (y/n): y
#
# Depth 3: [4/4] ✅
# Depth 2: [1/1] ✅
# Summary: 5/5 modules documented

Tool Selection​

# Use Qwen for generation
/memory:docs-related-cli --tool qwen
  • /memory:docs-full-cli - Generate docs for all modules
  • /memory:update-related - Update CLAUDE.md for changed modules
  • /memory:compact - Compact session memory

Notes​

  • Smart filtering automatically skips test/build/config directories
  • Change detection uses git diff to find affected modules
  • Single strategy optimizes for speed in iterative development
  • Tool fallback ensures completion even if primary tool fails
  • Verification confirms all documentation files created successfully