claude-code-workflow 6.0.5 → 6.1.0

package/.claude/workflows/context-search-strategy.md

@@ -1,77 +1,77 @@
----
-name: context-search-strategy
-description: Strategic guidelines for context search commands
-type: search-guideline
----
-
-# Context Search Strategy
-
-## ⚡ Execution Environment
-
-**CRITICAL**: All commands execute in **Bash environment** (Git Bash on Windows)
-
-**❌ Forbidden**: Windows commands (`findstr`, `dir`, `where`) - Use Bash (`grep`, `find`, `cat`)
-
-## ⚡ Core Search Tools
-
-**Skill()**: FASTEST way to get context - use FIRST if SKILL exists. Three types: (1) `workflow-progress` for WFS sessions (2) tech SKILLs for stack docs (3) `{project-name}` for project docs
-**codebase-retrieval**: Semantic file discovery via Gemini CLI with all files analysis
-**rg (ripgrep)**: Fast content search with regex support
-**find**: File/directory location by name patterns
-**grep**: Built-in pattern matching (fallback when rg unavailable)
-**get_modules_by_depth.sh**: Program architecture analysis (MANDATORY before planning)
-
-## 📋 Tool Selection Matrix
-
-| Need | Tool | Use Case |
-|------|------|----------|
-| **Workflow history** | Skill(workflow-progress) | WFS sessions lessons/conflicts - `/memory:workflow-skill-memory` |
-| **Tech stack docs** | Skill({tech-name}) | Stack APIs/guides - `/memory:tech-research` |
-| **Project docs** | Skill({project-name}) | Project modules/architecture - `/memory:skill-memory` |
-| **Semantic discovery** | codebase-retrieval | Find files relevant to task/feature context |
-| **Pattern matching** | rg | Search code content with regex |
-| **File name lookup** | find | Locate files by name patterns |
-| **Architecture** | get_modules_by_depth.sh | Understand program structure |
-
-## 🔧 Quick Command Reference
-
-```bash
-# SKILL Packages (FIRST PRIORITY - fastest context loading)
-Skill(command: "workflow-progress")  # Workflow: WFS sessions history, lessons, conflicts
-Skill(command: "react-dev")          # Tech: React APIs, patterns, best practices
-Skill(command: "claude_dms3")        # Project: Project modules, architecture, examples
-
-# Semantic File Discovery (codebase-retrieval)
-cd [directory] && gemini -p "
-PURPOSE: Discover files relevant to task/feature
-TASK: List all files related to [task/feature description]
-MODE: analysis
-CONTEXT: @**/*
-EXPECTED: Relevant file paths with relevance explanation
-RULES: Focus on direct relevance to task requirements
-"
-
-# Program Architecture (MANDATORY before planning)
-~/.claude/scripts/get_modules_by_depth.sh
-
-# Content Search (rg preferred)
-rg "pattern" --type js -n        # Search JS files with line numbers
-rg -i "case-insensitive"         # Ignore case
-rg -C 3 "context"                # Show 3 lines before/after
-
-# File Search
-find . -name "*.ts" -type f      # Find TypeScript files
-find . -path "*/node_modules" -prune -o -name "*.js" -print
-
-# Workflow Examples
-rg "IMPL-\d+" .workflow/ --type json                    # Find task IDs
-find .workflow/ -name "*.json" -path "*/.task/*"        # Locate task files
-rg "status.*pending" .workflow/.task/                   # Find pending tasks
-```
-
-## ⚡ Performance Tips
-
-- **rg > grep** for content search
-- **Use --type filters** to limit file types
-- **Exclude dirs**: `--glob '!node_modules'`
-- **Use -F** for literal strings (no regex)
+---
+name: context-search-strategy
+description: Strategic guidelines for context search commands
+type: search-guideline
+---
+
+# Context Search Strategy
+
+## ⚡ Execution Environment
+
+**CRITICAL**: All commands execute in **Bash environment** (Git Bash on Windows)
+
+**❌ Forbidden**: Windows commands (`findstr`, `dir`, `where`) - Use Bash (`grep`, `find`, `cat`)
+
+## ⚡ Core Search Tools
+
+**Skill()**: FASTEST way to get context - use FIRST if SKILL exists. Three types: (1) `workflow-progress` for WFS sessions (2) tech SKILLs for stack docs (3) `{project-name}` for project docs
+**codebase-retrieval**: Semantic file discovery via Gemini CLI with all files analysis
+**rg (ripgrep)**: Fast content search with regex support
+**find**: File/directory location by name patterns
+**grep**: Built-in pattern matching (fallback when rg unavailable)
+**get_modules_by_depth.sh**: Program architecture analysis (MANDATORY before planning)
+
+## 📋 Tool Selection Matrix
+
+| Need | Tool | Use Case |
+|------|------|----------|
+| **Workflow history** | Skill(workflow-progress) | WFS sessions lessons/conflicts - `/memory:workflow-skill-memory` |
+| **Tech stack docs** | Skill({tech-name}) | Stack APIs/guides - `/memory:tech-research` |
+| **Project docs** | Skill({project-name}) | Project modules/architecture - `/memory:skill-memory` |
+| **Semantic discovery** | codebase-retrieval | Find files relevant to task/feature context |
+| **Pattern matching** | rg | Search code content with regex |
+| **File name lookup** | find | Locate files by name patterns |
+| **Architecture** | get_modules_by_depth.sh | Understand program structure |
+
+## 🔧 Quick Command Reference
+
+```bash
+# SKILL Packages (FIRST PRIORITY - fastest context loading)
+Skill(command: "workflow-progress")  # Workflow: WFS sessions history, lessons, conflicts
+Skill(command: "react-dev")          # Tech: React APIs, patterns, best practices
+Skill(command: "claude_dms3")        # Project: Project modules, architecture, examples
+
+# Semantic File Discovery (codebase-retrieval)
+cd [directory] && gemini -p "
+PURPOSE: Discover files relevant to task/feature
+TASK: List all files related to [task/feature description]
+MODE: analysis
+CONTEXT: @**/*
+EXPECTED: Relevant file paths with relevance explanation
+RULES: Focus on direct relevance to task requirements
+"
+
+# Program Architecture (MANDATORY before planning)
+ccw tool exec get_modules_by_depth '{}'
+
+# Content Search (rg preferred)
+rg "pattern" --type js -n        # Search JS files with line numbers
+rg -i "case-insensitive"         # Ignore case
+rg -C 3 "context"                # Show 3 lines before/after
+
+# File Search
+find . -name "*.ts" -type f      # Find TypeScript files
+find . -path "*/node_modules" -prune -o -name "*.js" -print
+
+# Workflow Examples
+rg "IMPL-\d+" .workflow/ --type json                    # Find task IDs
+find .workflow/ -name "*.json" -path "*/.task/*"        # Locate task files
+rg "status.*pending" .workflow/.task/                   # Find pending tasks
+```
+
+## ⚡ Performance Tips
+
+- **rg > grep** for content search
+- **Use --type filters** to limit file types
+- **Exclude dirs**: `--glob '!node_modules'`
+- **Use -F** for literal strings (no regex)

package/.claude/workflows/tool-strategy.md

@@ -1,71 +1,90 @@
-# Tool Strategy
-
-## ⚡ Exa Triggering Mechanisms
-
-**Auto-Trigger**:
-- User mentions "exa-code" or code-related queries → `mcp__exa__get_code_context_exa`
-- Need current web information → `mcp__exa__web_search_exa`
-
-**Manual Trigger**:
-- Complex API research → Exa Code Context
-- Real-time information needs → Exa Web Search
-
-## ⚡ Bash Text Processing (sed/awk)
-
-**When to Use**: Edit tool fails 2+ times on same file
-
-### sed Quick Reference
-
-```bash
-# Replace first occurrence per line
-sed 's/old/new/' file.txt
-
-# Replace all occurrences (global)
-sed 's/old/new/g' file.txt
-
-# In-place edit (modify file directly)
-sed -i 's/old/new/g' file.txt
-
-# Delete lines matching pattern
-sed '/pattern/d' file.txt
-
-# Insert line before match
-sed '/pattern/i\new line' file.txt
-
-# Insert line after match
-sed '/pattern/a\new line' file.txt
-
-# Replace on specific line number
-sed '5s/old/new/' file.txt
-
-# Multi-line replacement (escape newlines)
-sed ':a;N;$!ba;s/old\npattern/new\ntext/g' file.txt
-```
-
-### awk Quick Reference
-
-```bash
-# Print specific column
-awk '{print $1}' file.txt
-
-# Print lines matching pattern
-awk '/pattern/' file.txt
-
-# Replace field value
-awk '{$2="new"; print}' file.txt
-
-# Conditional replacement
-awk '/pattern/{gsub(/old/,"new")}1' file.txt
-
-# Insert line after match
-awk '/pattern/{print; print "new line"; next}1' file.txt
-
-# Multi-field operations
-awk -F',' '{print $1, $3}' file.csv
-```
-
-### Fallback Strategy
-
-1. **Edit fails 2+ times** → Try sed for simple replacements
-2. **sed fails** → Try awk for complex patterns
-3. **awk fails** → Use Write to recreate file
+# Tool Strategy
+
+## ⚡ Exa Triggering Mechanisms
+
+**Auto-Trigger**:
+- User mentions "exa-code" or code-related queries → `mcp__exa__get_code_context_exa`
+- Need current web information → `mcp__exa__web_search_exa`
+
+**Manual Trigger**:
+- Complex API research → Exa Code Context
+- Real-time information needs → Exa Web Search
+
+## ⚡ CCW edit_file Tool (AI-Powered Editing)
+
+**When to Use**: Edit tool fails 2+ times on same file
+
+### update Mode (Default)
+
+**Best for**: Code block replacements, function rewrites, multi-line changes
+
+```bash
+ccw tool exec edit_file '{
+  "path": "file.py",
+  "oldText": "def old():\n    pass",
+  "newText": "def new():\n    return True"
+}'
+```
+
+**Features**:
+- ✅ Exact text matching (precise and predictable)
+- ✅ Auto line ending adaptation (CRLF/LF)
+- ✅ Simple `oldText` → `newText` replacement
+- ✅ No special markers needed
+
+### line Mode (Precise Line Operations)
+
+**Best for**: Config files, line insertions/deletions, precise line number control
+
+```bash
+# Insert after specific line
+ccw tool exec edit_file '{
+  "path": "config.txt",
+  "mode": "line",
+  "operation": "insert_after",
+  "line": 10,
+  "text": "new config line"
+}'
+
+# Delete line range
+ccw tool exec edit_file '{
+  "path": "log.txt",
+  "mode": "line",
+  "operation": "delete",
+  "line": 5,
+  "end_line": 8
+}'
+
+# Replace specific line
+ccw tool exec edit_file '{
+  "path": "script.sh",
+  "mode": "line",
+  "operation": "replace",
+  "line": 3,
+  "text": "#!/bin/bash"
+}'
+```
+
+**Operations**:
+- `insert_before`: Insert text before specified line
+- `insert_after`: Insert text after specified line
+- `replace`: Replace line or line range
+- `delete`: Delete line or line range
+
+### Mode Selection Guide
+
+| Scenario | Mode | Reason |
+|----------|------|--------|
+| Code refactoring | update | Content-driven replacement |
+| Function rewrite | update | Simple oldText/newText |
+| Config line change | line | Precise line number control |
+| Insert at specific position | line | Exact line number needed |
+| Delete line range | line | Line-based operation |
+
+### Fallback Strategy
+
+1. **Edit fails 1+ times** → Use `ccw tool exec edit_file` (update mode)
+2. **update mode fails** → Try line mode with precise line numbers
+3. **All fails** → Use Write to recreate file
+
+**Default mode**: update (exact matching with line ending adaptation)

package/.claude/workflows/workflow-architecture.md

@@ -433,7 +433,7 @@ The `[FLOW_CONTROL]` marker indicates that a task or prompt contains flow contro
   "step": "load_context",
   "action": "Load project context and patterns",
   "commands": [
-    "bash(~/.claude/scripts/get_modules_by_depth.sh)",
+    "bash(ccw tool exec get_modules_by_depth '{}')",
     "Read(CLAUDE.md)"
   ],
   "output_to": "project_structure",

package/ccw/src/cli.js

@@ -6,6 +6,7 @@ import { installCommand } from './commands/install.js';
 import { uninstallCommand } from './commands/uninstall.js';
 import { upgradeCommand } from './commands/upgrade.js';
 import { listCommand } from './commands/list.js';
+import { toolCommand } from './commands/tool.js';
 import { readFileSync, existsSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
@@ -105,5 +106,11 @@ export function run(argv) {
     .description('List all installed Claude Code Workflow instances')
     .action(listCommand);
 
+  // Tool command
+  program
+    .command('tool [subcommand] [args] [json]')
+    .description('Execute CCW tools')
+    .action((subcommand, args, json) => toolCommand(subcommand, args, { json }));
+
   program.parse(argv);
 }

package/ccw/src/commands/tool.js

@@ -0,0 +1,181 @@
+/**
+ * Tool Command - Execute and manage CCW tools
+ */
+
+import chalk from 'chalk';
+import { listTools, executeTool, getTool, getAllToolSchemas } from '../tools/index.js';
+
+/**
+ * List all available tools
+ */
+async function listAction() {
+  const tools = listTools();
+
+  if (tools.length === 0) {
+    console.log(chalk.yellow('No tools registered'));
+    return;
+  }
+
+  console.log(chalk.bold.cyan('\nAvailable Tools:\n'));
+
+  for (const tool of tools) {
+    console.log(chalk.bold.white(`  ${tool.name}`));
+    console.log(chalk.gray(`    ${tool.description}`));
+
+    if (tool.parameters?.properties) {
+      const props = tool.parameters.properties;
+      const required = tool.parameters.required || [];
+
+      console.log(chalk.gray('    Parameters:'));
+      for (const [name, schema] of Object.entries(props)) {
+        const req = required.includes(name) ? chalk.red('*') : '';
+        const defaultVal = schema.default !== undefined ? chalk.gray(` (default: ${schema.default})`) : '';
+        console.log(chalk.gray(`      - ${name}${req}: ${schema.description}${defaultVal}`));
+      }
+    }
+    console.log();
+  }
+}
+
+/**
+ * Show tool schema in MCP-compatible JSON format
+ */
+async function schemaAction(options) {
+  const { name } = options;
+
+  if (name) {
+    const tool = getTool(name);
+    if (!tool) {
+      console.error(chalk.red(`Tool not found: ${name}`));
+      process.exit(1);
+    }
+
+    const schema = {
+      name: tool.name,
+      description: tool.description,
+      inputSchema: {
+        type: 'object',
+        properties: tool.parameters?.properties || {},
+        required: tool.parameters?.required || []
+      }
+    };
+    console.log(JSON.stringify(schema, null, 2));
+  } else {
+    const schemas = getAllToolSchemas();
+    console.log(JSON.stringify({ tools: schemas }, null, 2));
+  }
+}
+
+/**
+ * Read from stdin if available
+ */
+async function readStdin() {
+  // Check if stdin is a TTY (interactive terminal)
+  if (process.stdin.isTTY) {
+    return null;
+  }
+
+  return new Promise((resolve, reject) => {
+    let data = '';
+
+    process.stdin.setEncoding('utf8');
+
+    process.stdin.on('readable', () => {
+      let chunk;
+      while ((chunk = process.stdin.read()) !== null) {
+        data += chunk;
+      }
+    });
+
+    process.stdin.on('end', () => {
+      resolve(data.trim() || null);
+    });
+
+    process.stdin.on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Execute a tool with given parameters
+ */
+async function execAction(toolName, jsonInput, options) {
+  if (!toolName) {
+    console.error(chalk.red('Tool name is required'));
+    console.error(chalk.gray('Usage: ccw tool exec <tool-name> \'{"param": "value"}\''));
+    process.exit(1);
+  }
+
+  const tool = getTool(toolName);
+  if (!tool) {
+    console.error(chalk.red(`Tool not found: ${toolName}`));
+    console.error(chalk.gray('Use "ccw tool list" to see available tools'));
+    process.exit(1);
+  }
+
+  // Parse JSON input (default format)
+  let params = {};
+
+  if (jsonInput) {
+    try {
+      params = JSON.parse(jsonInput);
+    } catch (error) {
+      console.error(chalk.red(`Invalid JSON: ${error.message}`));
+      process.exit(1);
+    }
+  }
+
+  // Check for stdin input (for piped commands)
+  const stdinData = await readStdin();
+  if (stdinData) {
+    // If tool has an 'input' parameter, use it
+    // Otherwise, try to parse stdin as JSON and merge with params
+    if (tool.parameters?.properties?.input) {
+      params.input = stdinData;
+    } else {
+      try {
+        const stdinJson = JSON.parse(stdinData);
+        params = { ...stdinJson, ...params };
+      } catch {
+        // If not JSON, store as 'input' anyway
+        params.input = stdinData;
+      }
+    }
+  }
+
+  // Execute tool
+  const result = await executeTool(toolName, params);
+
+  // Always output JSON
+  console.log(JSON.stringify(result, null, 2));
+}
+
+/**
+ * Tool command entry point
+ */
+export async function toolCommand(subcommand, args, options) {
+  // Handle subcommands
+  switch (subcommand) {
+    case 'list':
+      await listAction();
+      break;
+    case 'schema':
+      await schemaAction({ name: args });
+      break;
+    case 'exec':
+      await execAction(args, options.json, options);
+      break;
+    default:
+      console.log(chalk.bold.cyan('\nCCW Tool System\n'));
+      console.log('Subcommands:');
+      console.log(chalk.gray('  list              List all available tools'));
+      console.log(chalk.gray('  schema [name]     Show tool schema (JSON)'));
+      console.log(chalk.gray('  exec <name>       Execute a tool'));
+      console.log();
+      console.log('Examples:');
+      console.log(chalk.gray('  ccw tool list'));
+      console.log(chalk.gray('  ccw tool schema edit_file'));
+      console.log(chalk.gray('  ccw tool exec edit_file \'{"path":"file.txt","oldText":"old","newText":"new"}\''));
+  }
+}

package/ccw/src/core/dashboard-generator.js

@@ -8,10 +8,22 @@ const __dirname = dirname(__filename);
 // Bundled template paths
 const UNIFIED_TEMPLATE = join(__dirname, '../templates/dashboard.html');
 const JS_FILE = join(__dirname, '../templates/dashboard.js');
-const CSS_FILE = join(__dirname, '../templates/dashboard.css');
+const MODULE_CSS_DIR = join(__dirname, '../templates/dashboard-css');
 const WORKFLOW_TEMPLATE = join(__dirname, '../templates/workflow-dashboard.html');
 const REVIEW_TEMPLATE = join(__dirname, '../templates/review-cycle-dashboard.html');
 
+// Modular CSS files in load order
+const MODULE_CSS_FILES = [
+  '01-base.css',
+  '02-session.css',
+  '03-tasks.css',
+  '04-lite-tasks.css',
+  '05-context.css',
+  '06-cards.css',
+  '07-managers.css',
+  '08-review.css'
+];
+
 const MODULE_FILES = [
   'utils.js',
   'state.js',
@@ -63,8 +75,11 @@ export async function generateDashboard(data) {
 function generateFromUnifiedTemplate(data) {
   let html = readFileSync(UNIFIED_TEMPLATE, 'utf8');
 
-  // Read CSS file
-  let cssContent = existsSync(CSS_FILE) ? readFileSync(CSS_FILE, 'utf8') : '';
+  // Read and concatenate modular CSS files in load order
+  let cssContent = MODULE_CSS_FILES.map(file => {
+    const filePath = join(MODULE_CSS_DIR, file);
+    return existsSync(filePath) ? readFileSync(filePath, 'utf8') : '';
+  }).join('\n\n');
 
   // Read JS content
   let jsContent = '';

package/ccw/src/core/lite-scanner.js

@@ -54,20 +54,36 @@ function scanLiteDir(dir, type) {
 }
 
 /**
- * Load plan.json from session directory
+ * Load plan.json or fix-plan.json from session directory
  * @param {string} sessionPath - Session directory path
  * @returns {Object|null} - Plan data or null
  */
 function loadPlanJson(sessionPath) {
+  // Try fix-plan.json first (for lite-fix), then plan.json (for lite-plan)
+  const fixPlanPath = join(sessionPath, 'fix-plan.json');
   const planPath = join(sessionPath, 'plan.json');
-  if (!existsSync(planPath)) return null;
 
-  try {
-    const content = readFileSync(planPath, 'utf8');
-    return JSON.parse(content);
-  } catch {
-    return null;
+  // Try fix-plan.json first
+  if (existsSync(fixPlanPath)) {
+    try {
+      const content = readFileSync(fixPlanPath, 'utf8');
+      return JSON.parse(content);
+    } catch {
+      // Continue to try plan.json
+    }
   }
+
+  // Fallback to plan.json
+  if (existsSync(planPath)) {
+    try {
+      const content = readFileSync(planPath, 'utf8');
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+
+  return null;
 }
 
 /**
@@ -91,6 +107,7 @@ function loadTaskJsons(sessionPath) {
           f.startsWith('IMPL-') ||
           f.startsWith('TASK-') ||
           f.startsWith('task-') ||
+          f.startsWith('diagnosis-') ||
           /^T\d+\.json$/i.test(f)
         ))
         .map(f => {
@@ -109,12 +126,18 @@ function loadTaskJsons(sessionPath) {
     }
   }
 
-  // Method 2: Check plan.json for embedded tasks array
+  // Method 2: Check plan.json or fix-plan.json for embedded tasks array
   if (tasks.length === 0) {
+    // Try fix-plan.json first (for lite-fix), then plan.json (for lite-plan)
+    const fixPlanPath = join(sessionPath, 'fix-plan.json');
     const planPath = join(sessionPath, 'plan.json');
-    if (existsSync(planPath)) {
+
+    const planFile = existsSync(fixPlanPath) ? fixPlanPath :
+                     existsSync(planPath) ? planPath : null;
+
+    if (planFile) {
       try {
-        const plan = JSON.parse(readFileSync(planPath, 'utf8'));
+        const plan = JSON.parse(readFileSync(planFile, 'utf8'));
         if (Array.isArray(plan.tasks)) {
           tasks = plan.tasks.map(t => normalizeTask(t));
         }
@@ -124,13 +147,14 @@ function loadTaskJsons(sessionPath) {
     }
   }
 
-  // Method 3: Check for task-*.json files in session root
+  // Method 3: Check for task-*.json and diagnosis-*.json files in session root
   if (tasks.length === 0) {
     try {
       const rootTasks = readdirSync(sessionPath)
         .filter(f => f.endsWith('.json') && (
           f.startsWith('task-') ||
           f.startsWith('TASK-') ||
+          f.startsWith('diagnosis-') ||
           /^T\d+\.json$/i.test(f)
         ))
         .map(f => {