claude-code-workflow 6.1.4 → 6.2.1

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

@@ -1,288 +0,0 @@
-/**
- * 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

@@ -1,134 +0,0 @@
-/**
- * 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

@@ -1,266 +0,0 @@
-/**
- * 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
-};