claude-code-workflow 6.1.4 → 6.2.1

package/src/tools/get-modules-by-depth.ts

@@ -0,0 +1,349 @@
+/**
+ * Get Modules by Depth Tool
+ * Scan project structure and organize modules by directory depth (deepest first)
+ */
+
+import { z } from 'zod';
+import type { ToolSchema, ToolResult } from '../types/tool.js';
+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'
+];
+
+// Define Zod schema for validation
+const ParamsSchema = z.object({
+  format: z.enum(['list', 'grouped', 'json']).default('list'),
+  path: z.string().default('.'),
+});
+
+type Params = z.infer<typeof ParamsSchema>;
+
+interface ModuleInfo {
+  depth: number;
+  path: string;
+  files: number;
+  types: string[];
+  has_claude: boolean;
+}
+
+interface ToolOutput {
+  format: string;
+  total_modules: number;
+  max_depth: number;
+  output: string;
+}
+
+/**
+ * Parse .gitignore file and return patterns
+ */
+function parseGitignore(basePath: string): string[] {
+  const gitignorePath = join(basePath, '.gitignore');
+  const patterns: string[] = [];
+
+  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: string, gitignorePatterns: string[]): boolean {
+  // 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: string): string[] {
+  const types = new Set<string>();
+  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: string): number {
+  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: string,
+  currentPath: string,
+  depth: number,
+  gitignorePatterns: string[],
+  results: ModuleInfo[]
+): void {
+  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: ModuleInfo[]): string {
+  // 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: ModuleInfo[]): string {
+  // 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: ModuleInfo[]): string {
+  // 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: Record<number, { path: string; has_claude: boolean }[]> = {};
+
+  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);
+}
+
+// Tool schema for MCP
+export const schema: ToolSchema = {
+  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.`,
+  inputSchema: {
+    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: []
+  }
+};
+
+// Handler function
+export async function handler(params: Record<string, unknown>): Promise<ToolResult<ToolOutput>> {
+  const parsed = ParamsSchema.safeParse(params);
+  if (!parsed.success) {
+    return { success: false, error: `Invalid params: ${parsed.error.message}` };
+  }
+
+  const { format, path: targetPath } = parsed.data;
+
+  try {
+    const basePath = resolve(process.cwd(), targetPath);
+
+    if (!existsSync(basePath)) {
+      return { success: false, error: `Directory not found: ${basePath}` };
+    }
+
+    const stat = statSync(basePath);
+    if (!stat.isDirectory()) {
+      return { success: false, error: `Not a directory: ${basePath}` };
+    }
+
+    // Parse gitignore
+    const gitignorePatterns = parseGitignore(basePath);
+
+    // Collect results
+    const results: ModuleInfo[] = [];
+
+    // 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: string;
+    switch (format) {
+      case 'grouped':
+        output = formatGrouped(results);
+        break;
+      case 'json':
+        output = formatJson(results);
+        break;
+      case 'list':
+      default:
+        output = formatList(results);
+        break;
+    }
+
+    return {
+      success: true,
+      result: {
+        format,
+        total_modules: results.length,
+        max_depth: results.length > 0 ? Math.max(...results.map(r => r.depth)) : 0,
+        output
+      }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to scan modules: ${(error as Error).message}`
+    };
+  }
+}

package/src/tools/index.ts

@@ -0,0 +1,370 @@
+/**
+ * Tool Registry - MCP-like tool system for CCW
+ * Provides tool discovery, validation, and execution
+ */
+
+import http from 'http';
+import type { ToolSchema, ToolResult } from '../types/tool.js';
+
+// Import TypeScript migrated tools (schema + handler)
+import * as editFileMod from './edit-file.js';
+import * as writeFileMod from './write-file.js';
+import * as getModulesByDepthMod from './get-modules-by-depth.js';
+import * as classifyFoldersMod from './classify-folders.js';
+import * as detectChangedModulesMod from './detect-changed-modules.js';
+import * as discoverDesignFilesMod from './discover-design-files.js';
+import * as generateModuleDocsMod from './generate-module-docs.js';
+import * as convertTokensToCssMod from './convert-tokens-to-css.js';
+import * as sessionManagerMod from './session-manager.js';
+import * as cliExecutorMod from './cli-executor.js';
+import * as smartSearchMod from './smart-search.js';
+import { executeInitWithProgress } from './smart-search.js';
+// codex_lens removed - functionality integrated into smart_search
+import * as readFileMod from './read-file.js';
+import * as coreMemoryMod from './core-memory.js';
+import type { ProgressInfo } from './codex-lens.js';
+
+// Import legacy JS tools
+import { uiGeneratePreviewTool } from './ui-generate-preview.js';
+import { uiInstantiatePrototypesTool } from './ui-instantiate-prototypes.js';
+import { updateModuleClaudeTool } from './update-module-claude.js';
+
+interface LegacyTool {
+  name: string;
+  description: string;
+  parameters: {
+    type: string;
+    properties: Record<string, unknown>;
+    required?: string[];
+  };
+  execute: (params: Record<string, unknown>) => Promise<unknown>;
+}
+
+// Tool registry
+const tools = new Map<string, LegacyTool>();
+
+// Dashboard notification settings
+const DASHBOARD_PORT = process.env.CCW_PORT || 3456;
+
+/**
+ * Notify dashboard of tool execution events (fire and forget)
+ */
+function notifyDashboard(data: Record<string, unknown>): void {
+  const payload = JSON.stringify({
+    type: 'tool_execution',
+    ...data,
+    timestamp: new Date().toISOString()
+  });
+
+  const req = http.request({
+    hostname: 'localhost',
+    port: Number(DASHBOARD_PORT),
+    path: '/api/hook',
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(payload)
+    }
+  });
+
+  // Fire and forget - log errors only in debug mode
+  req.on('error', (err) => {
+    if (process.env.DEBUG) console.error('[Dashboard] Tool notification failed:', err.message);
+  });
+  req.write(payload);
+  req.end();
+}
+
+/**
+ * Convert new-style tool (schema + handler) to legacy format
+ */
+function toLegacyTool(mod: {
+  schema: ToolSchema;
+  handler: (params: Record<string, unknown>) => Promise<ToolResult<unknown>>;
+}): LegacyTool {
+  return {
+    name: mod.schema.name,
+    description: mod.schema.description,
+    parameters: {
+      type: 'object',
+      properties: mod.schema.inputSchema?.properties || {},
+      required: mod.schema.inputSchema?.required || []
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const result = await mod.handler(params);
+      if (!result.success) {
+        throw new Error(result.error);
+      }
+      return result.result;
+    }
+  };
+}
+
+/**
+ * Register a tool in the registry
+ */
+function registerTool(tool: LegacyTool): void {
+  if (!tool.name || !tool.execute) {
+    throw new Error('Tool must have name and execute function');
+  }
+  tools.set(tool.name, tool);
+}
+
+/**
+ * Get all registered tools
+ */
+export function listTools(): Array<Omit<LegacyTool, 'execute'>> {
+  return Array.from(tools.values()).map(tool => ({
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters
+  }));
+}
+
+/**
+ * Get a specific tool by name
+ */
+export function getTool(name: string): LegacyTool | null {
+  return tools.get(name) || null;
+}
+
+/**
+ * Validate parameters against tool schema
+ */
+function validateParams(tool: LegacyTool, params: Record<string, unknown>): {
+  valid: boolean;
+  errors: string[];
+} {
+  const errors: string[] = [];
+  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] as { type?: string };
+    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
+ */
+export async function executeTool(name: string, params: Record<string, unknown> = {}): Promise<{
+  success: boolean;
+  result?: unknown;
+  error?: string;
+}> {
+  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(', ')}`
+    };
+  }
+
+  // Notify dashboard - execution started
+  notifyDashboard({
+    toolName: name,
+    status: 'started',
+    params: sanitizeParams(params)
+  });
+
+  // Execute tool
+  try {
+    const result = await tool.execute(params);
+
+    // Notify dashboard - execution completed
+    notifyDashboard({
+      toolName: name,
+      status: 'completed',
+      result: sanitizeResult(result)
+    });
+
+    return {
+      success: true,
+      result
+    };
+  } catch (error) {
+    // Notify dashboard - execution failed
+    notifyDashboard({
+      toolName: name,
+      status: 'failed',
+      error: (error as Error).message || 'Tool execution failed'
+    });
+
+    return {
+      success: false,
+      error: (error as Error).message || 'Tool execution failed'
+    };
+  }
+}
+
+/**
+ * Sanitize params for notification (truncate large values)
+ */
+function sanitizeParams(params: Record<string, unknown>): Record<string, unknown> {
+  const sanitized: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (typeof value === 'string' && value.length > 200) {
+      sanitized[key] = value.substring(0, 200) + '...';
+    } else if (typeof value === 'object' && value !== null) {
+      sanitized[key] = '[Object]';
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+
+/**
+ * Sanitize result for notification (truncate large values)
+ */
+function sanitizeResult(result: unknown): unknown {
+  if (result === null || result === undefined) return result;
+  const str = JSON.stringify(result);
+  if (str.length > 500) {
+    return { _truncated: true, preview: str.substring(0, 500) + '...' };
+  }
+  return result;
+}
+
+/**
+ * Execute a tool with progress callback (for init actions)
+ */
+export async function executeToolWithProgress(
+  name: string,
+  params: Record<string, unknown> = {},
+  onProgress?: (progress: ProgressInfo) => void
+): Promise<{
+  success: boolean;
+  result?: unknown;
+  error?: string;
+}> {
+  // For smart_search init, use special progress-aware execution
+  if (name === 'smart_search' && params.action === 'init') {
+    try {
+      // Notify dashboard - execution started
+      notifyDashboard({
+        toolName: name,
+        status: 'started',
+        params: sanitizeParams(params)
+      });
+
+      const result = await executeInitWithProgress(params, onProgress);
+
+      // Notify dashboard - execution completed
+      notifyDashboard({
+        toolName: name,
+        status: 'completed',
+        result: sanitizeResult(result)
+      });
+
+      return {
+        success: result.success,
+        result,
+        error: result.error
+      };
+    } catch (error) {
+      notifyDashboard({
+        toolName: name,
+        status: 'failed',
+        error: (error as Error).message || 'Tool execution failed'
+      });
+
+      return {
+        success: false,
+        error: (error as Error).message || 'Tool execution failed'
+      };
+    }
+  }
+
+  // Fall back to regular execution for other tools
+  return executeTool(name, params);
+}
+
+/**
+ * Get tool schema in MCP-compatible format
+ */
+export function getToolSchema(name: string): ToolSchema | null {
+  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
+ */
+export function getAllToolSchemas(): ToolSchema[] {
+  return Array.from(tools.keys()).map(name => getToolSchema(name)).filter((s): s is ToolSchema => s !== null);
+}
+
+// Register TypeScript migrated tools
+registerTool(toLegacyTool(editFileMod));
+registerTool(toLegacyTool(writeFileMod));
+registerTool(toLegacyTool(getModulesByDepthMod));
+registerTool(toLegacyTool(classifyFoldersMod));
+registerTool(toLegacyTool(detectChangedModulesMod));
+registerTool(toLegacyTool(discoverDesignFilesMod));
+registerTool(toLegacyTool(generateModuleDocsMod));
+registerTool(toLegacyTool(convertTokensToCssMod));
+registerTool(toLegacyTool(sessionManagerMod));
+registerTool(toLegacyTool(cliExecutorMod));
+registerTool(toLegacyTool(smartSearchMod));
+// codex_lens removed - functionality integrated into smart_search
+registerTool(toLegacyTool(readFileMod));
+registerTool(toLegacyTool(coreMemoryMod));
+
+// Register legacy JS tools
+registerTool(uiGeneratePreviewTool);
+registerTool(uiInstantiatePrototypesTool);
+registerTool(updateModuleClaudeTool);
+
+// Export for external tool registration
+export { registerTool };
+
+// Export ToolSchema type
+export type { ToolSchema };