claude-code-workflow 6.0.5 → 6.1.1

package/ccw/src/commands/tool.js

@@ -0,0 +1,217 @@
+/**
+ * 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);
+    });
+  });
+}
+
+/**
+ * Smart JSON parser with Windows path handling
+ */
+function parseJsonWithPathFix(jsonString) {
+  try {
+    // Try normal parse first
+    return JSON.parse(jsonString);
+  } catch (firstError) {
+    // If parsing fails, try to fix Windows paths
+    try {
+      // Pattern: "path": "X:\..." or "path":"X:\..."
+      const fixedJson = jsonString.replace(
+        /("(?:path|file|target|source|dest|destination)":\s*")([A-Za-z]:[^"]+)"/g,
+        (match, prefix, path) => {
+          // Convert backslashes to forward slashes (universal)
+          const fixedPath = path.replace(/\\/g, '/');
+          return `${prefix}${fixedPath}"`;
+        }
+      );
+      
+      return JSON.parse(fixedJson);
+    } catch (secondError) {
+      // If still fails, throw original error with helpful message
+      const errorMsg = firstError.message;
+      const hint = errorMsg.includes('escaped character') || errorMsg.includes('position')
+        ? '\n\n' + chalk.yellow('Hint: Windows paths in JSON need forward slashes or double backslashes:') +
+          '\n  ' + chalk.green('✓ "D:/Claude_dms3/file.md"') +
+          '\n  ' + chalk.green('✓ "D:\\\\Claude_dms3\\\\file.md"') +
+          '\n  ' + chalk.red('✗ "D:\\Claude_dms3\\file.md"')
+        : '';
+      
+      throw new Error(errorMsg + hint);
+    }
+  }
+}
+
+/**
+ * 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 = parseJsonWithPathFix(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 => {