claude-code-workflow 6.1.4 → 6.2.1

package/ccw/src/tools/get-modules-by-depth.js

@@ -1,308 +0,0 @@
-/**
- * Get Modules by Depth Tool
- * Scan project structure and organize modules by directory depth (deepest first)
- */
-
-import { readdirSync, statSync, existsSync, readFileSync } from 'fs';
-import { join, resolve, relative, extname } from 'path';
-
-// System/cache directories to always exclude
-const SYSTEM_EXCLUDES = [
-  // Version control and IDE
-  '.git', '.gitignore', '.gitmodules', '.gitattributes',
-  '.svn', '.hg', '.bzr',
-  '.history', '.vscode', '.idea', '.vs', '.vscode-test',
-  '.sublime-text', '.atom',
-  // Python
-  '__pycache__', '.pytest_cache', '.mypy_cache', '.tox',
-  '.coverage', 'htmlcov', '.nox', '.venv', 'venv', 'env',
-  '.egg-info', '.eggs', '.wheel',
-  'site-packages', '.python-version',
-  // Node.js/JavaScript
-  'node_modules', '.npm', '.yarn', '.pnpm', 'yarn-error.log',
-  '.nyc_output', 'coverage', '.next', '.nuxt',
-  '.cache', '.parcel-cache', '.vite', 'dist', 'build',
-  '.turbo', '.vercel', '.netlify',
-  // Build/compile outputs
-  'out', 'output', '_site', 'public',
-  '.output', '.generated', 'generated', 'gen',
-  'bin', 'obj', 'Debug', 'Release',
-  // Testing
-  'test-results', 'junit.xml', 'test_results',
-  'cypress', 'playwright-report', '.playwright',
-  // Logs and temp files
-  'logs', 'log', 'tmp', 'temp', '.tmp', '.temp',
-  // Documentation build outputs
-  '_book', 'docs/_build', 'site', 'gh-pages',
-  '.docusaurus', '.vuepress', '.gitbook',
-  // Cloud and deployment
-  '.serverless', '.terraform',
-  '.aws', '.azure', '.gcp',
-  // Mobile development
-  '.gradle', '.expo', '.metro',
-  'DerivedData',
-  // Game development
-  'Library', 'Temp', 'ProjectSettings',
-  'MemoryCaptures', 'UserSettings'
-];
-
-/**
- * Parse .gitignore file and return patterns
- */
-function parseGitignore(basePath) {
-  const gitignorePath = join(basePath, '.gitignore');
-  const patterns = [];
-
-  if (existsSync(gitignorePath)) {
-    const content = readFileSync(gitignorePath, 'utf8');
-    content.split('\n').forEach(line => {
-      line = line.trim();
-      // Skip empty lines and comments
-      if (!line || line.startsWith('#')) return;
-      // Remove trailing slash
-      line = line.replace(/\/$/, '');
-      patterns.push(line);
-    });
-  }
-
-  return patterns;
-}
-
-/**
- * Check if a path should be excluded
- */
-function shouldExclude(name, gitignorePatterns) {
-  // Check system excludes
-  if (SYSTEM_EXCLUDES.includes(name)) return true;
-
-  // Check gitignore patterns (simple matching)
-  for (const pattern of gitignorePatterns) {
-    if (name === pattern) return true;
-    // Simple wildcard matching
-    if (pattern.includes('*')) {
-      const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
-      if (regex.test(name)) return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Get file types in a 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 errors
-  }
-  return Array.from(types);
-}
-
-/**
- * Count files in a directory (non-recursive)
- */
-function countFiles(dirPath) {
-  try {
-    const entries = readdirSync(dirPath, { withFileTypes: true });
-    return entries.filter(e => e.isFile()).length;
-  } catch (e) {
-    return 0;
-  }
-}
-
-/**
- * Recursively scan directories and collect info
- */
-function scanDirectories(basePath, currentPath, depth, gitignorePatterns, results) {
-  try {
-    const entries = readdirSync(currentPath, { withFileTypes: true });
-
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      if (shouldExclude(entry.name, gitignorePatterns)) continue;
-
-      const fullPath = join(currentPath, entry.name);
-      const relPath = './' + relative(basePath, fullPath).replace(/\\/g, '/');
-      const fileCount = countFiles(fullPath);
-
-      // Only include directories with files
-      if (fileCount > 0) {
-        const types = getFileTypes(fullPath);
-        const hasClaude = existsSync(join(fullPath, 'CLAUDE.md'));
-
-        results.push({
-          depth: depth + 1,
-          path: relPath,
-          files: fileCount,
-          types,
-          has_claude: hasClaude
-        });
-      }
-
-      // Recurse into subdirectories
-      scanDirectories(basePath, fullPath, depth + 1, gitignorePatterns, results);
-    }
-  } catch (e) {
-    // Ignore permission errors, etc.
-  }
-}
-
-/**
- * Format output as list (default)
- */
-function formatList(results) {
-  // Sort by depth descending (deepest first)
-  results.sort((a, b) => b.depth - a.depth);
-
-  return results.map(r =>
-    `depth:${r.depth}|path:${r.path}|files:${r.files}|types:[${r.types.join(',')}]|has_claude:${r.has_claude ? 'yes' : 'no'}`
-  ).join('\n');
-}
-
-/**
- * Format output as grouped
- */
-function formatGrouped(results) {
-  // Sort by depth descending
-  results.sort((a, b) => b.depth - a.depth);
-
-  const maxDepth = results.length > 0 ? Math.max(...results.map(r => r.depth)) : 0;
-  const lines = ['Modules by depth (deepest first):'];
-
-  for (let d = maxDepth; d >= 0; 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}`);
-      });
-    }
-  }
-
-  return lines.join('\n');
-}
-
-/**
- * Format output as JSON
- */
-function formatJson(results) {
-  // Sort by depth descending
-  results.sort((a, b) => b.depth - a.depth);
-
-  const maxDepth = results.length > 0 ? Math.max(...results.map(r => r.depth)) : 0;
-  const modules = {};
-
-  for (let d = maxDepth; d >= 0; d--) {
-    const atDepth = results.filter(r => r.depth === d);
-    if (atDepth.length > 0) {
-      modules[d] = atDepth.map(r => ({
-        path: r.path,
-        has_claude: r.has_claude
-      }));
-    }
-  }
-
-  return JSON.stringify({
-    max_depth: maxDepth,
-    modules
-  }, null, 2);
-}
-
-/**
- * Main execute function
- */
-async function execute(params) {
-  const { format = 'list', path: targetPath = '.' } = params;
-
-  const basePath = resolve(process.cwd(), targetPath);
-
-  if (!existsSync(basePath)) {
-    throw new Error(`Directory not found: ${basePath}`);
-  }
-
-  const stat = statSync(basePath);
-  if (!stat.isDirectory()) {
-    throw new Error(`Not a directory: ${basePath}`);
-  }
-
-  // Parse gitignore
-  const gitignorePatterns = parseGitignore(basePath);
-
-  // Collect results
-  const results = [];
-
-  // Check root directory
-  const rootFileCount = countFiles(basePath);
-  if (rootFileCount > 0) {
-    results.push({
-      depth: 0,
-      path: '.',
-      files: rootFileCount,
-      types: getFileTypes(basePath),
-      has_claude: existsSync(join(basePath, 'CLAUDE.md'))
-    });
-  }
-
-  // Scan subdirectories
-  scanDirectories(basePath, basePath, 0, gitignorePatterns, results);
-
-  // Format output
-  let output;
-  switch (format) {
-    case 'grouped':
-      output = formatGrouped(results);
-      break;
-    case 'json':
-      output = formatJson(results);
-      break;
-    case 'list':
-    default:
-      output = formatList(results);
-      break;
-  }
-
-  return {
-    format,
-    total_modules: results.length,
-    max_depth: results.length > 0 ? Math.max(...results.map(r => r.depth)) : 0,
-    output
-  };
-}
-
-/**
- * Tool Definition
- */
-export const getModulesByDepthTool = {
-  name: 'get_modules_by_depth',
-  description: `Scan project structure and organize modules by directory depth (deepest first).
-Respects .gitignore patterns and excludes common system directories.
-Output formats: list (pipe-delimited), grouped (human-readable), json.`,
-  parameters: {
-    type: 'object',
-    properties: {
-      format: {
-        type: 'string',
-        enum: ['list', 'grouped', 'json'],
-        description: 'Output format (default: list)',
-        default: 'list'
-      },
-      path: {
-        type: 'string',
-        description: 'Target directory path (default: current directory)',
-        default: '.'
-      }
-    },
-    required: []
-  },
-  execute
-};

package/ccw/src/tools/index.js

@@ -1,176 +0,0 @@
-/**
- * Tool Registry - MCP-like tool system for CCW
- * Provides tool discovery, validation, and execution
- */
-
-import { editFileTool } from './edit-file.js';
-import { getModulesByDepthTool } from './get-modules-by-depth.js';
-import { classifyFoldersTool } from './classify-folders.js';
-import { detectChangedModulesTool } from './detect-changed-modules.js';
-import { discoverDesignFilesTool } from './discover-design-files.js';
-import { generateModuleDocsTool } from './generate-module-docs.js';
-import { uiGeneratePreviewTool } from './ui-generate-preview.js';
-import { uiInstantiatePrototypesTool } from './ui-instantiate-prototypes.js';
-import { updateModuleClaudeTool } from './update-module-claude.js';
-import { convertTokensToCssTool } from './convert-tokens-to-css.js';
-
-// Tool registry - add new tools here
-const tools = new Map();
-
-/**
- * Register a tool in the registry
- * @param {Object} tool - Tool definition
- */
-function registerTool(tool) {
-  if (!tool.name || !tool.execute) {
-    throw new Error('Tool must have name and execute function');
-  }
-  tools.set(tool.name, tool);
-}
-
-/**
- * Get all registered tools
- * @returns {Array<Object>} - Array of tool definitions (without execute function)
- */
-export function listTools() {
-  return Array.from(tools.values()).map(tool => ({
-    name: tool.name,
-    description: tool.description,
-    parameters: tool.parameters
-  }));
-}
-
-/**
- * Get a specific tool by name
- * @param {string} name - Tool name
- * @returns {Object|null} - Tool definition or null
- */
-export function getTool(name) {
-  return tools.get(name) || null;
-}
-
-/**
- * Validate parameters against tool schema
- * @param {Object} tool - Tool definition
- * @param {Object} params - Parameters to validate
- * @returns {{valid: boolean, errors: string[]}}
- */
-function validateParams(tool, params) {
-  const errors = [];
-  const schema = tool.parameters;
-
-  if (!schema || !schema.properties) {
-    return { valid: true, errors: [] };
-  }
-
-  // Check required parameters
-  const required = schema.required || [];
-  for (const req of required) {
-    if (params[req] === undefined || params[req] === null) {
-      errors.push(`Missing required parameter: ${req}`);
-    }
-  }
-
-  // Type validation
-  for (const [key, value] of Object.entries(params)) {
-    const propSchema = schema.properties[key];
-    if (!propSchema) {
-      continue; // Allow extra params
-    }
-
-    if (propSchema.type === 'string' && typeof value !== 'string') {
-      errors.push(`Parameter '${key}' must be a string`);
-    }
-    if (propSchema.type === 'boolean' && typeof value !== 'boolean') {
-      errors.push(`Parameter '${key}' must be a boolean`);
-    }
-    if (propSchema.type === 'number' && typeof value !== 'number') {
-      errors.push(`Parameter '${key}' must be a number`);
-    }
-  }
-
-  return { valid: errors.length === 0, errors };
-}
-
-/**
- * Execute a tool with given parameters
- * @param {string} name - Tool name
- * @param {Object} params - Tool parameters
- * @returns {Promise<{success: boolean, result?: any, error?: string}>}
- */
-export async function executeTool(name, params = {}) {
-  const tool = tools.get(name);
-
-  if (!tool) {
-    return {
-      success: false,
-      error: `Tool not found: ${name}`
-    };
-  }
-
-  // Validate parameters
-  const validation = validateParams(tool, params);
-  if (!validation.valid) {
-    return {
-      success: false,
-      error: `Parameter validation failed: ${validation.errors.join(', ')}`
-    };
-  }
-
-  // Execute tool
-  try {
-    const result = await tool.execute(params);
-    return {
-      success: true,
-      result
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error.message || 'Tool execution failed'
-    };
-  }
-}
-
-/**
- * Get tool schema in MCP-compatible format
- * @param {string} name - Tool name
- * @returns {Object|null} - Tool schema or null
- */
-export function getToolSchema(name) {
-  const tool = tools.get(name);
-  if (!tool) return null;
-
-  return {
-    name: tool.name,
-    description: tool.description,
-    inputSchema: {
-      type: 'object',
-      properties: tool.parameters?.properties || {},
-      required: tool.parameters?.required || []
-    }
-  };
-}
-
-/**
- * Get all tool schemas in MCP-compatible format
- * @returns {Array<Object>} - Array of tool schemas
- */
-export function getAllToolSchemas() {
-  return Array.from(tools.keys()).map(name => getToolSchema(name));
-}
-
-// Register built-in tools
-registerTool(editFileTool);
-registerTool(getModulesByDepthTool);
-registerTool(classifyFoldersTool);
-registerTool(detectChangedModulesTool);
-registerTool(discoverDesignFilesTool);
-registerTool(generateModuleDocsTool);
-registerTool(uiGeneratePreviewTool);
-registerTool(uiInstantiatePrototypesTool);
-registerTool(updateModuleClaudeTool);
-registerTool(convertTokensToCssTool);
-
-// Export for external tool registration
-export { registerTool };

package/ccw/src/utils/browser-launcher.js

@@ -1,60 +0,0 @@
-import open from 'open';
-import { platform } from 'os';
-import { resolve } from 'path';
-
-/**
- * Launch a URL or file in the default browser
- * Cross-platform compatible (Windows/macOS/Linux)
- * @param {string} urlOrPath - HTTP URL or path to HTML file
- * @returns {Promise<void>}
- */
-export async function launchBrowser(urlOrPath) {
-  // Check if it's already a URL (http:// or https://)
-  if (urlOrPath.startsWith('http://') || urlOrPath.startsWith('https://')) {
-    try {
-      await open(urlOrPath);
-      return;
-    } catch (error) {
-      throw new Error(`Failed to open browser: ${error.message}`);
-    }
-  }
-
-  // It's a file path - convert to file:// URL
-  const absolutePath = resolve(urlOrPath);
-
-  // Construct file:// URL based on platform
-  let url;
-  if (platform() === 'win32') {
-    // Windows: file:///C:/path/to/file.html
-    url = `file:///${absolutePath.replace(/\\/g, '/')}`;
-  } else {
-    // Unix: file:///path/to/file.html
-    url = `file://${absolutePath}`;
-  }
-
-  try {
-    // Use the 'open' package which handles cross-platform browser launching
-    await open(url);
-  } catch (error) {
-    // Fallback: try opening the file path directly
-    try {
-      await open(absolutePath);
-    } catch (fallbackError) {
-      throw new Error(`Failed to open browser: ${error.message}`);
-    }
-  }
-}
-
-/**
- * Check if we're running in a headless/CI environment
- * @returns {boolean}
- */
-export function isHeadlessEnvironment() {
-  return !!(
-    process.env.CI ||
-    process.env.CONTINUOUS_INTEGRATION ||
-    process.env.GITHUB_ACTIONS ||
-    process.env.GITLAB_CI ||
-    process.env.JENKINS_URL
-  );
-}

package/ccw/src/utils/file-utils.js

@@ -1,48 +0,0 @@
-import { readFileSync, existsSync, writeFileSync } from 'fs';
-import { join } from 'path';
-
-/**
- * Safely read a JSON file
- * @param {string} filePath - Path to JSON file
- * @returns {Object|null} - Parsed JSON or null on error
- */
-export function readJsonFile(filePath) {
-  if (!existsSync(filePath)) return null;
-  try {
-    return JSON.parse(readFileSync(filePath, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Safely read a text file
- * @param {string} filePath - Path to text file
- * @returns {string|null} - File contents or null on error
- */
-export function readTextFile(filePath) {
-  if (!existsSync(filePath)) return null;
-  try {
-    return readFileSync(filePath, 'utf8');
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Write content to a file
- * @param {string} filePath - Path to file
- * @param {string} content - Content to write
- */
-export function writeTextFile(filePath, content) {
-  writeFileSync(filePath, content, 'utf8');
-}
-
-/**
- * Check if a path exists
- * @param {string} filePath - Path to check
- * @returns {boolean}
- */
-export function pathExists(filePath) {
-  return existsSync(filePath);
-}