claude-code-workflow 6.1.4 → 6.2.2

package/ccw/src/tools/{get-modules-by-depth.js → get-modules-by-depth.ts}

@@ -3,6 +3,8 @@
  * 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';
 
@@ -46,12 +48,35 @@ const SYSTEM_EXCLUDES = [
   '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) {
+function parseGitignore(basePath: string): string[] {
   const gitignorePath = join(basePath, '.gitignore');
-  const patterns = [];
+  const patterns: string[] = [];
 
   if (existsSync(gitignorePath)) {
     const content = readFileSync(gitignorePath, 'utf8');
@@ -71,7 +96,7 @@ function parseGitignore(basePath) {
 /**
  * Check if a path should be excluded
  */
-function shouldExclude(name, gitignorePatterns) {
+function shouldExclude(name: string, gitignorePatterns: string[]): boolean {
   // Check system excludes
   if (SYSTEM_EXCLUDES.includes(name)) return true;
 
@@ -91,8 +116,8 @@ function shouldExclude(name, gitignorePatterns) {
 /**
  * Get file types in a directory
  */
-function getFileTypes(dirPath) {
-  const types = new Set();
+function getFileTypes(dirPath: string): string[] {
+  const types = new Set<string>();
   try {
     const entries = readdirSync(dirPath, { withFileTypes: true });
     entries.forEach(entry => {
@@ -110,7 +135,7 @@ function getFileTypes(dirPath) {
 /**
  * Count files in a directory (non-recursive)
  */
-function countFiles(dirPath) {
+function countFiles(dirPath: string): number {
   try {
     const entries = readdirSync(dirPath, { withFileTypes: true });
     return entries.filter(e => e.isFile()).length;
@@ -122,7 +147,13 @@ function countFiles(dirPath) {
 /**
  * Recursively scan directories and collect info
  */
-function scanDirectories(basePath, currentPath, depth, gitignorePatterns, results) {
+function scanDirectories(
+  basePath: string,
+  currentPath: string,
+  depth: number,
+  gitignorePatterns: string[],
+  results: ModuleInfo[]
+): void {
   try {
     const entries = readdirSync(currentPath, { withFileTypes: true });
 
@@ -159,7 +190,7 @@ function scanDirectories(basePath, currentPath, depth, gitignorePatterns, result
 /**
  * Format output as list (default)
  */
-function formatList(results) {
+function formatList(results: ModuleInfo[]): string {
   // Sort by depth descending (deepest first)
   results.sort((a, b) => b.depth - a.depth);
 
@@ -171,7 +202,7 @@ function formatList(results) {
 /**
  * Format output as grouped
  */
-function formatGrouped(results) {
+function formatGrouped(results: ModuleInfo[]): string {
   // Sort by depth descending
   results.sort((a, b) => b.depth - a.depth);
 
@@ -195,12 +226,12 @@ function formatGrouped(results) {
 /**
  * Format output as JSON
  */
-function formatJson(results) {
+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 = {};
+  const modules: Record<number, { path: string; has_claude: boolean }[]> = {};
 
   for (let d = maxDepth; d >= 0; d--) {
     const atDepth = results.filter(r => r.depth === d);
@@ -218,76 +249,13 @@ function formatJson(results) {
   }, 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 = {
+// 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.`,
-  parameters: {
+  inputSchema: {
     type: 'object',
     properties: {
       format: {
@@ -303,6 +271,79 @@ Output formats: list (pipe-delimited), grouped (human-readable), json.`,
       }
     },
     required: []
-  },
-  execute
+  }
 };
+
+// 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/ccw/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 };