claude-code-workflow 6.0.4 → 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/package.json

@@ -24,15 +24,15 @@
     "node": ">=16.0.0"
   },
   "dependencies": {
-    "commander": "^11.0.0",
-    "open": "^9.1.0",
+    "boxen": "^7.1.0",
     "chalk": "^5.3.0",
+    "commander": "^11.0.0",
+    "figlet": "^1.7.0",
     "glob": "^10.3.0",
+    "gradient-string": "^2.0.2",
     "inquirer": "^9.2.0",
-    "ora": "^7.0.0",
-    "figlet": "^1.7.0",
-    "boxen": "^7.1.0",
-    "gradient-string": "^2.0.2"
+    "open": "^9.1.0",
+    "ora": "^7.0.0"
   },
   "files": [
     "bin/",

package/ccw/src/cli.js

@@ -1,10 +1,12 @@
 import { Command } from 'commander';
 import { viewCommand } from './commands/view.js';
 import { serveCommand } from './commands/serve.js';
+import { stopCommand } from './commands/stop.js';
 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';
@@ -68,6 +70,14 @@ export function run(argv) {
     .option('--no-browser', 'Start server without opening browser')
     .action(serveCommand);
 
+  // Stop command
+  program
+    .command('stop')
+    .description('Stop the running CCW dashboard server')
+    .option('--port <port>', 'Server port', '3456')
+    .option('-f, --force', 'Force kill process on the port')
+    .action(stopCommand);
+
   // Install command
   program
     .command('install')
@@ -96,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/stop.js

@@ -0,0 +1,101 @@
+import chalk from 'chalk';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+/**
+ * Find process using a specific port (Windows)
+ * @param {number} port - Port number
+ * @returns {Promise<string|null>} PID or null
+ */
+async function findProcessOnPort(port) {
+  try {
+    const { stdout } = await execAsync(`netstat -ano | findstr :${port} | findstr LISTENING`);
+    const lines = stdout.trim().split('\n');
+    if (lines.length > 0) {
+      const parts = lines[0].trim().split(/\s+/);
+      return parts[parts.length - 1]; // PID is the last column
+    }
+  } catch {
+    // No process found
+  }
+  return null;
+}
+
+/**
+ * Kill process by PID (Windows)
+ * @param {string} pid - Process ID
+ * @returns {Promise<boolean>} Success status
+ */
+async function killProcess(pid) {
+  try {
+    await execAsync(`taskkill /PID ${pid} /F`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Stop command handler - stops the running CCW dashboard server
+ * @param {Object} options - Command options
+ */
+export async function stopCommand(options) {
+  const port = options.port || 3456;
+  const force = options.force || false;
+
+  console.log(chalk.blue.bold('\n  CCW Dashboard\n'));
+  console.log(chalk.gray(`  Checking server on port ${port}...`));
+
+  try {
+    // Try graceful shutdown via API first
+    const healthCheck = await fetch(`http://localhost:${port}/api/health`, {
+      signal: AbortSignal.timeout(2000)
+    }).catch(() => null);
+
+    if (healthCheck && healthCheck.ok) {
+      // CCW server is running - send shutdown signal
+      console.log(chalk.cyan('  CCW server found, sending shutdown signal...'));
+
+      await fetch(`http://localhost:${port}/api/shutdown`, {
+        method: 'POST',
+        signal: AbortSignal.timeout(5000)
+      }).catch(() => null);
+
+      // Wait a moment for shutdown
+      await new Promise(resolve => setTimeout(resolve, 500));
+
+      console.log(chalk.green.bold('\n  Server stopped successfully!\n'));
+      return;
+    }
+
+    // No CCW server responding, check if port is in use
+    const pid = await findProcessOnPort(port);
+
+    if (!pid) {
+      console.log(chalk.yellow(`  No server running on port ${port}\n`));
+      return;
+    }
+
+    // Port is in use by another process
+    console.log(chalk.yellow(`  Port ${port} is in use by process PID: ${pid}`));
+
+    if (force) {
+      console.log(chalk.cyan('  Force killing process...'));
+      const killed = await killProcess(pid);
+
+      if (killed) {
+        console.log(chalk.green.bold('\n  Process killed successfully!\n'));
+      } else {
+        console.log(chalk.red('\n  Failed to kill process. Try running as administrator.\n'));
+      }
+    } else {
+      console.log(chalk.gray(`\n  This is not a CCW server. Use --force to kill it:`));
+      console.log(chalk.white(`  ccw stop --force\n`));
+    }
+
+  } catch (err) {
+    console.error(chalk.red(`\n  Error: ${err.message}\n`));
+  }
+}

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"}\''));
+  }
+}