claude-code-workflow 6.0.4 → 6.1.0

package/ccw/src/tools/detect-changed-modules.js

@@ -0,0 +1,288 @@
+/**
+ * Detect Changed Modules Tool
+ * Find modules affected by git changes or recent modifications
+ */
+
+import { readdirSync, statSync, existsSync, readFileSync } from 'fs';
+import { join, resolve, dirname, extname, relative } from 'path';
+import { execSync } from 'child_process';
+
+// Source file extensions to track
+const SOURCE_EXTENSIONS = [
+  '.md', '.js', '.ts', '.jsx', '.tsx',
+  '.py', '.go', '.rs', '.java', '.cpp', '.c', '.h',
+  '.sh', '.ps1', '.json', '.yaml', '.yml'
+];
+
+// Directories to exclude
+const EXCLUDE_DIRS = [
+  '.git', '__pycache__', 'node_modules', '.venv', 'venv', 'env',
+  'dist', 'build', '.cache', '.pytest_cache', '.mypy_cache',
+  'coverage', '.nyc_output', 'logs', 'tmp', 'temp'
+];
+
+/**
+ * Check if git is available and we're in a repo
+ */
+function isGitRepo(basePath) {
+  try {
+    execSync('git rev-parse --git-dir', { cwd: basePath, stdio: 'pipe' });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Get changed files from git
+ */
+function getGitChangedFiles(basePath) {
+  try {
+    // Get staged + unstaged changes
+    let output = execSync('git diff --name-only HEAD 2>/dev/null', {
+      cwd: basePath,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+
+    const cachedOutput = execSync('git diff --name-only --cached 2>/dev/null', {
+      cwd: basePath,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+
+    if (cachedOutput) {
+      output = output ? `${output}\n${cachedOutput}` : cachedOutput;
+    }
+
+    // If no working changes, check last commit
+    if (!output) {
+      output = execSync('git diff --name-only HEAD~1 HEAD 2>/dev/null', {
+        cwd: basePath,
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe']
+      }).trim();
+    }
+
+    return output ? output.split('\n').filter(f => f.trim()) : [];
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * Find recently modified files (fallback when no git changes)
+ */
+function findRecentlyModified(basePath, hoursAgo = 24) {
+  const results = [];
+  const cutoffTime = Date.now() - (hoursAgo * 60 * 60 * 1000);
+
+  function scan(dirPath) {
+    try {
+      const entries = readdirSync(dirPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (EXCLUDE_DIRS.includes(entry.name)) continue;
+          scan(join(dirPath, entry.name));
+        } else if (entry.isFile()) {
+          const ext = extname(entry.name).toLowerCase();
+          if (!SOURCE_EXTENSIONS.includes(ext)) continue;
+
+          const fullPath = join(dirPath, entry.name);
+          try {
+            const stat = statSync(fullPath);
+            if (stat.mtimeMs > cutoffTime) {
+              results.push(relative(basePath, fullPath));
+            }
+          } catch (e) {
+            // Skip files we can't stat
+          }
+        }
+      }
+    } catch (e) {
+      // Ignore permission errors
+    }
+  }
+
+  scan(basePath);
+  return results;
+}
+
+/**
+ * Extract unique parent directories from file list
+ */
+function extractDirectories(files, basePath) {
+  const dirs = new Set();
+
+  for (const file of files) {
+    const dir = dirname(file);
+    if (dir === '.' || dir === '') {
+      dirs.add('.');
+    } else {
+      dirs.add('./' + dir.replace(/\\/g, '/'));
+    }
+  }
+
+  return Array.from(dirs).sort();
+}
+
+/**
+ * Count files in directory
+ */
+function countFiles(dirPath) {
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    return entries.filter(e => e.isFile()).length;
+  } catch (e) {
+    return 0;
+  }
+}
+
+/**
+ * Get file types in directory
+ */
+function getFileTypes(dirPath) {
+  const types = new Set();
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    entries.forEach(entry => {
+      if (entry.isFile()) {
+        const ext = extname(entry.name).slice(1);
+        if (ext) types.add(ext);
+      }
+    });
+  } catch (e) {
+    // Ignore
+  }
+  return Array.from(types);
+}
+
+/**
+ * Main execute function
+ */
+async function execute(params) {
+  const { format = 'paths', path: targetPath = '.' } = params;
+
+  const basePath = resolve(process.cwd(), targetPath);
+
+  if (!existsSync(basePath)) {
+    throw new Error(`Directory not found: ${basePath}`);
+  }
+
+  // Get changed files
+  let changedFiles = [];
+  let changeSource = 'none';
+
+  if (isGitRepo(basePath)) {
+    changedFiles = getGitChangedFiles(basePath);
+    changeSource = changedFiles.length > 0 ? 'git' : 'none';
+  }
+
+  // Fallback to recently modified files
+  if (changedFiles.length === 0) {
+    changedFiles = findRecentlyModified(basePath);
+    changeSource = changedFiles.length > 0 ? 'mtime' : 'none';
+  }
+
+  // Extract affected directories
+  const affectedDirs = extractDirectories(changedFiles, basePath);
+
+  // Format output
+  let output;
+  const results = [];
+
+  for (const dir of affectedDirs) {
+    const fullPath = dir === '.' ? basePath : resolve(basePath, dir);
+    if (!existsSync(fullPath) || !statSync(fullPath).isDirectory()) continue;
+
+    const fileCount = countFiles(fullPath);
+    const types = getFileTypes(fullPath);
+    const depth = dir === '.' ? 0 : (dir.match(/\//g) || []).length;
+    const hasClaude = existsSync(join(fullPath, 'CLAUDE.md'));
+
+    results.push({
+      depth,
+      path: dir,
+      files: fileCount,
+      types,
+      has_claude: hasClaude
+    });
+  }
+
+  switch (format) {
+    case 'list':
+      output = results.map(r =>
+        `depth:${r.depth}|path:${r.path}|files:${r.files}|types:[${r.types.join(',')}]|has_claude:${r.has_claude ? 'yes' : 'no'}|status:changed`
+      ).join('\n');
+      break;
+
+    case 'grouped':
+      const maxDepth = results.length > 0 ? Math.max(...results.map(r => r.depth)) : 0;
+      const lines = ['Affected modules by changes:'];
+
+      for (let d = 0; d <= maxDepth; d++) {
+        const atDepth = results.filter(r => r.depth === d);
+        if (atDepth.length > 0) {
+          lines.push(`  Depth ${d}:`);
+          atDepth.forEach(r => {
+            const claudeIndicator = r.has_claude ? ' [OK]' : '';
+            lines.push(`    - ${r.path}${claudeIndicator} (changed)`);
+          });
+        }
+      }
+
+      if (results.length === 0) {
+        lines.push('  No recent changes detected');
+      }
+
+      output = lines.join('\n');
+      break;
+
+    case 'paths':
+    default:
+      output = affectedDirs.join('\n');
+      break;
+  }
+
+  return {
+    format,
+    change_source: changeSource,
+    changed_files_count: changedFiles.length,
+    affected_modules_count: results.length,
+    results,
+    output
+  };
+}
+
+/**
+ * Tool Definition
+ */
+export const detectChangedModulesTool = {
+  name: 'detect_changed_modules',
+  description: `Detect modules affected by git changes or recent file modifications.
+Features:
+- Git-aware: detects staged, unstaged, or last commit changes
+- Fallback: finds files modified in last 24 hours
+- Respects .gitignore patterns
+
+Output formats: list, grouped, paths (default)`,
+  parameters: {
+    type: 'object',
+    properties: {
+      format: {
+        type: 'string',
+        enum: ['list', 'grouped', 'paths'],
+        description: 'Output format (default: paths)',
+        default: 'paths'
+      },
+      path: {
+        type: 'string',
+        description: 'Target directory path (default: current directory)',
+        default: '.'
+      }
+    },
+    required: []
+  },
+  execute
+};

package/ccw/src/tools/discover-design-files.js

@@ -0,0 +1,134 @@
+/**
+ * Discover Design Files Tool
+ * Find CSS/JS/HTML design-related files and output JSON
+ */
+
+import { readdirSync, statSync, existsSync, writeFileSync } from 'fs';
+import { join, resolve, relative, extname } from 'path';
+
+// Directories to exclude
+const EXCLUDE_DIRS = [
+  'node_modules', 'dist', '.git', 'build', 'coverage',
+  '.cache', '.next', '.nuxt', '__pycache__', '.venv'
+];
+
+// File type patterns
+const FILE_PATTERNS = {
+  css: ['.css', '.scss', '.sass', '.less', '.styl'],
+  js: ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs', '.vue', '.svelte'],
+  html: ['.html', '.htm']
+};
+
+/**
+ * Find files matching extensions recursively
+ */
+function findFiles(basePath, extensions) {
+  const results = [];
+
+  function scan(dirPath) {
+    try {
+      const entries = readdirSync(dirPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (EXCLUDE_DIRS.includes(entry.name)) continue;
+          scan(join(dirPath, entry.name));
+        } else if (entry.isFile()) {
+          const ext = extname(entry.name).toLowerCase();
+          if (extensions.includes(ext)) {
+            results.push(relative(basePath, join(dirPath, entry.name)).replace(/\\/g, '/'));
+          }
+        }
+      }
+    } catch (e) {
+      // Ignore permission errors
+    }
+  }
+
+  scan(basePath);
+  return results.sort();
+}
+
+/**
+ * Main execute function
+ */
+async function execute(params) {
+  const { sourceDir = '.', outputPath } = params;
+
+  const basePath = resolve(process.cwd(), sourceDir);
+
+  if (!existsSync(basePath)) {
+    throw new Error(`Directory not found: ${basePath}`);
+  }
+
+  if (!statSync(basePath).isDirectory()) {
+    throw new Error(`Not a directory: ${basePath}`);
+  }
+
+  // Find files by type
+  const cssFiles = findFiles(basePath, FILE_PATTERNS.css);
+  const jsFiles = findFiles(basePath, FILE_PATTERNS.js);
+  const htmlFiles = findFiles(basePath, FILE_PATTERNS.html);
+
+  // Build result
+  const result = {
+    discovery_time: new Date().toISOString(),
+    source_directory: basePath,
+    file_types: {
+      css: {
+        count: cssFiles.length,
+        files: cssFiles
+      },
+      js: {
+        count: jsFiles.length,
+        files: jsFiles
+      },
+      html: {
+        count: htmlFiles.length,
+        files: htmlFiles
+      }
+    },
+    total_files: cssFiles.length + jsFiles.length + htmlFiles.length
+  };
+
+  // Write to file if outputPath specified
+  if (outputPath) {
+    const outPath = resolve(process.cwd(), outputPath);
+    writeFileSync(outPath, JSON.stringify(result, null, 2), 'utf8');
+  }
+
+  return {
+    css_count: cssFiles.length,
+    js_count: jsFiles.length,
+    html_count: htmlFiles.length,
+    total_files: result.total_files,
+    output_path: outputPath || null,
+    result
+  };
+}
+
+/**
+ * Tool Definition
+ */
+export const discoverDesignFilesTool = {
+  name: 'discover_design_files',
+  description: `Discover CSS/JS/HTML design-related files in a directory.
+Scans recursively and excludes common build/cache directories.
+Returns JSON with file discovery results.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      sourceDir: {
+        type: 'string',
+        description: 'Source directory to scan (default: current directory)',
+        default: '.'
+      },
+      outputPath: {
+        type: 'string',
+        description: 'Optional path to write JSON output file'
+      }
+    },
+    required: []
+  },
+  execute
+};

package/ccw/src/tools/edit-file.js

@@ -0,0 +1,266 @@
+/**
+ * Edit File Tool - AI-focused file editing
+ * Two complementary modes:
+ * - update: Content-driven text replacement (AI primary use)
+ * - line: Position-driven line operations (precise control)
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { resolve, isAbsolute } from 'path';
+
+/**
+ * Resolve file path and read content
+ * @param {string} filePath - Path to file
+ * @returns {{resolvedPath: string, content: string}}
+ */
+function readFile(filePath) {
+  const resolvedPath = isAbsolute(filePath) ? filePath : resolve(process.cwd(), filePath);
+
+  if (!existsSync(resolvedPath)) {
+    throw new Error(`File not found: ${resolvedPath}`);
+  }
+
+  try {
+    const content = readFileSync(resolvedPath, 'utf8');
+    return { resolvedPath, content };
+  } catch (error) {
+    throw new Error(`Failed to read file: ${error.message}`);
+  }
+}
+
+/**
+ * Write content to file
+ * @param {string} filePath - Path to file
+ * @param {string} content - Content to write
+ */
+function writeFile(filePath, content) {
+  try {
+    writeFileSync(filePath, content, 'utf8');
+  } catch (error) {
+    throw new Error(`Failed to write file: ${error.message}`);
+  }
+}
+
+/**
+ * Mode: update - Simple text replacement
+ * Auto-adapts line endings (CRLF/LF)
+ */
+function executeUpdateMode(content, params) {
+  const { oldText, newText, replaceAll } = params;
+
+  if (!oldText) throw new Error('Parameter "oldText" is required for update mode');
+  if (newText === undefined) throw new Error('Parameter "newText" is required for update mode');
+
+  // Detect original line ending
+  const hasCRLF = content.includes('\r\n');
+
+  // Normalize to LF for matching
+  const normalize = (str) => str.replace(/\r\n/g, '\n');
+  const normalizedContent = normalize(content);
+  const normalizedOld = normalize(oldText);
+  const normalizedNew = normalize(newText);
+
+  let newContent = normalizedContent;
+  let status = 'not found';
+  let replacements = 0;
+
+  if (newContent.includes(normalizedOld)) {
+    if (replaceAll) {
+      const parts = newContent.split(normalizedOld);
+      replacements = parts.length - 1;
+      newContent = parts.join(normalizedNew);
+      status = 'replaced_all';
+    } else {
+      newContent = newContent.replace(normalizedOld, normalizedNew);
+      status = 'replaced';
+      replacements = 1;
+    }
+  }
+
+  // Restore original line ending
+  if (hasCRLF) {
+    newContent = newContent.replace(/\n/g, '\r\n');
+  }
+
+  return {
+    content: newContent,
+    modified: content !== newContent,
+    status,
+    replacements,
+    message:
+      status === 'replaced_all'
+        ? `Text replaced successfully (${replacements} occurrences)`
+        : status === 'replaced'
+          ? 'Text replaced successfully'
+          : 'oldText not found in file'
+  };
+}
+
+/**
+ * Mode: line - Line-based operations
+ * Operations: insert_before, insert_after, replace, delete
+ */
+function executeLineMode(content, params) {
+  const { operation, line, text, end_line } = params;
+
+  if (!operation) throw new Error('Parameter "operation" is required for line mode');
+  if (line === undefined) throw new Error('Parameter "line" is required for line mode');
+
+  // Detect original line ending and normalize for processing
+  const hasCRLF = content.includes('\r\n');
+  const normalizedContent = hasCRLF ? content.replace(/\r\n/g, '\n') : content;
+
+  const lines = normalizedContent.split('\n');
+  const lineIndex = line - 1; // Convert to 0-based
+
+  if (lineIndex < 0 || lineIndex >= lines.length) {
+    throw new Error(`Line ${line} out of range (1-${lines.length})`);
+  }
+
+  let newLines = [...lines];
+  let message = '';
+
+  switch (operation) {
+    case 'insert_before':
+      if (text === undefined) throw new Error('Parameter "text" is required for insert_before');
+      newLines.splice(lineIndex, 0, text);
+      message = `Inserted before line ${line}`;
+      break;
+
+    case 'insert_after':
+      if (text === undefined) throw new Error('Parameter "text" is required for insert_after');
+      newLines.splice(lineIndex + 1, 0, text);
+      message = `Inserted after line ${line}`;
+      break;
+
+    case 'replace':
+      if (text === undefined) throw new Error('Parameter "text" is required for replace');
+      const endIdx = end_line ? end_line - 1 : lineIndex;
+      if (endIdx < lineIndex || endIdx >= lines.length) {
+        throw new Error(`end_line ${end_line} is invalid`);
+      }
+      const deleteCount = endIdx - lineIndex + 1;
+      newLines.splice(lineIndex, deleteCount, text);
+      message = end_line ? `Replaced lines ${line}-${end_line}` : `Replaced line ${line}`;
+      break;
+
+    case 'delete':
+      const endDelete = end_line ? end_line - 1 : lineIndex;
+      if (endDelete < lineIndex || endDelete >= lines.length) {
+        throw new Error(`end_line ${end_line} is invalid`);
+      }
+      const count = endDelete - lineIndex + 1;
+      newLines.splice(lineIndex, count);
+      message = end_line ? `Deleted lines ${line}-${end_line}` : `Deleted line ${line}`;
+      break;
+
+    default:
+      throw new Error(`Unknown operation: ${operation}. Valid: insert_before, insert_after, replace, delete`);
+  }
+
+  let newContent = newLines.join('\n');
+
+  // Restore original line endings
+  if (hasCRLF) {
+    newContent = newContent.replace(/\n/g, '\r\n');
+  }
+
+  return {
+    content: newContent,
+    modified: content !== newContent,
+    operation,
+    line,
+    end_line,
+    message
+  };
+}
+
+/**
+ * Main execute function - routes to appropriate mode
+ */
+async function execute(params) {
+  const { path: filePath, mode = 'update' } = params;
+
+  if (!filePath) throw new Error('Parameter "path" is required');
+
+  const { resolvedPath, content } = readFile(filePath);
+
+  let result;
+  switch (mode) {
+    case 'update':
+      result = executeUpdateMode(content, params);
+      break;
+    case 'line':
+      result = executeLineMode(content, params);
+      break;
+    default:
+      throw new Error(`Unknown mode: ${mode}. Valid modes: update, line`);
+  }
+
+  // Write if modified
+  if (result.modified) {
+    writeFile(resolvedPath, result.content);
+  }
+
+  // Remove content from result (don't return file content)
+  const { content: _, ...output } = result;
+  return output;
+}
+
+/**
+ * Edit File Tool Definition
+ */
+export const editFileTool = {
+  name: 'edit_file',
+  description: `Update file with two modes:
+- update: Replace oldText with newText (default)
+- line: Position-driven line operations`,
+  parameters: {
+    type: 'object',
+    properties: {
+      path: {
+        type: 'string',
+        description: 'Path to the file to modify'
+      },
+      mode: {
+        type: 'string',
+        enum: ['update', 'line'],
+        description: 'Edit mode (default: update)',
+        default: 'update'
+      },
+      // Update mode params
+      oldText: {
+        type: 'string',
+        description: '[update mode] Text to find and replace'
+      },
+      newText: {
+        type: 'string',
+        description: '[update mode] Replacement text'
+      },
+      replaceAll: {
+        type: 'boolean',
+        description: '[update mode] Replace all occurrences of oldText (default: false)'
+      },
+      // Line mode params
+      operation: {
+        type: 'string',
+        enum: ['insert_before', 'insert_after', 'replace', 'delete'],
+        description: '[line mode] Line operation type'
+      },
+      line: {
+        type: 'number',
+        description: '[line mode] Line number (1-based)'
+      },
+      end_line: {
+        type: 'number',
+        description: '[line mode] End line for range operations'
+      },
+      text: {
+        type: 'string',
+        description: '[line mode] Text for insert/replace operations'
+      }
+    },
+    required: ['path']
+  },
+  execute
+};