claude-code-workflow 6.1.4 → 6.2.2

package/ccw/src/tools/classify-folders.ts

@@ -0,0 +1,245 @@
+/**
+ * Classify Folders Tool
+ * Categorize folders by type for documentation generation
+ * Types: code (API.md + README.md), navigation (README.md only), skip (empty)
+ */
+
+import { z } from 'zod';
+import type { ToolSchema, ToolResult } from '../types/tool.js';
+import { readdirSync, statSync, existsSync } from 'fs';
+import { join, resolve, extname } from 'path';
+
+// Code file extensions
+const CODE_EXTENSIONS = [
+  '.ts', '.tsx', '.js', '.jsx',
+  '.py', '.go', '.java', '.rs',
+  '.c', '.cpp', '.cs', '.rb',
+  '.php', '.swift', '.kt'
+];
+
+// Define Zod schema for validation
+const ParamsSchema = z.object({
+  input: z.string().optional(),
+  path: z.string().optional(),
+}).refine(data => data.input || data.path, {
+  message: 'Either "input" or "path" parameter is required'
+});
+
+type Params = z.infer<typeof ParamsSchema>;
+
+interface FolderClassification {
+  type: 'code' | 'navigation' | 'skip';
+  codeFiles: number;
+  subdirs: number;
+}
+
+interface ClassificationResult {
+  path: string;
+  type: 'code' | 'navigation' | 'skip';
+  code_files: number;
+  subdirs: number;
+}
+
+interface ToolOutput {
+  total: number;
+  by_type: {
+    code: number;
+    navigation: number;
+    skip: number;
+  };
+  results: ClassificationResult[];
+  output: string;
+}
+
+/**
+ * Count code files in a directory (non-recursive)
+ */
+function countCodeFiles(dirPath: string): number {
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    return entries.filter(e => {
+      if (!e.isFile()) return false;
+      const ext = extname(e.name).toLowerCase();
+      return CODE_EXTENSIONS.includes(ext);
+    }).length;
+  } catch (e) {
+    return 0;
+  }
+}
+
+/**
+ * Count subdirectories in a directory
+ */
+function countSubdirs(dirPath: string): number {
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    return entries.filter(e => e.isDirectory() && !e.name.startsWith('.')).length;
+  } catch (e) {
+    return 0;
+  }
+}
+
+/**
+ * Determine folder type
+ */
+function classifyFolder(dirPath: string): FolderClassification {
+  const codeFiles = countCodeFiles(dirPath);
+  const subdirs = countSubdirs(dirPath);
+
+  if (codeFiles > 0) {
+    return { type: 'code', codeFiles, subdirs }; // Generates API.md + README.md
+  } else if (subdirs > 0) {
+    return { type: 'navigation', codeFiles, subdirs }; // README.md only
+  } else {
+    return { type: 'skip', codeFiles, subdirs }; // Empty or no relevant content
+  }
+}
+
+/**
+ * Parse input from get_modules_by_depth format
+ * Format: depth:N|path:./path|files:N|types:[ext,ext]|has_claude:yes/no
+ */
+function parseModuleInput(line: string): Record<string, string> {
+  const parts: Record<string, string> = {};
+  line.split('|').forEach(part => {
+    const [key, value] = part.split(':');
+    if (key && value !== undefined) {
+      parts[key] = value;
+    }
+  });
+  return parts;
+}
+
+// Tool schema for MCP
+export const schema: ToolSchema = {
+  name: 'classify_folders',
+  description: `Classify folders by type for documentation generation.
+Types:
+- code: Contains code files (generates API.md + README.md)
+- navigation: Contains subdirectories only (generates README.md only)
+- skip: Empty or no relevant content
+
+Input: Either piped output from get_modules_by_depth or a single directory path.`,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      input: {
+        type: 'string',
+        description: 'Piped input from get_modules_by_depth (one module per line)'
+      },
+      path: {
+        type: 'string',
+        description: 'Single directory path to classify'
+      }
+    },
+    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 { input, path: targetPath } = parsed.data;
+
+  const results: ClassificationResult[] = [];
+
+  try {
+    // Mode 1: Process piped input from get_modules_by_depth
+    if (input) {
+      let lines: string[];
+
+      // Check if input is JSON (from ccw tool exec output)
+      if (input.trim().startsWith('{')) {
+        try {
+          const jsonInput = JSON.parse(input);
+          // Handle output from get_modules_by_depth tool (wrapped in result)
+          const output = jsonInput.result?.output || jsonInput.output;
+          if (output) {
+            lines = output.split('\n');
+          } else {
+            lines = [input];
+          }
+        } catch {
+          // Not JSON, treat as line-delimited text
+          lines = input.split('\n');
+        }
+      } else {
+        lines = input.split('\n');
+      }
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+
+        const parsed = parseModuleInput(line);
+        const folderPath = parsed.path;
+
+        if (!folderPath) continue;
+
+        const basePath = targetPath ? resolve(process.cwd(), targetPath) : process.cwd();
+        const fullPath = resolve(basePath, folderPath);
+
+        if (!existsSync(fullPath) || !statSync(fullPath).isDirectory()) {
+          continue;
+        }
+
+        const classification = classifyFolder(fullPath);
+
+        results.push({
+          path: folderPath,
+          type: classification.type,
+          code_files: classification.codeFiles,
+          subdirs: classification.subdirs
+        });
+      }
+    }
+    // Mode 2: Classify a single directory
+    else if (targetPath) {
+      const fullPath = resolve(process.cwd(), targetPath);
+
+      if (!existsSync(fullPath)) {
+        return { success: false, error: `Directory not found: ${fullPath}` };
+      }
+
+      if (!statSync(fullPath).isDirectory()) {
+        return { success: false, error: `Not a directory: ${fullPath}` };
+      }
+
+      const classification = classifyFolder(fullPath);
+
+      results.push({
+        path: targetPath,
+        type: classification.type,
+        code_files: classification.codeFiles,
+        subdirs: classification.subdirs
+      });
+    }
+
+    // Format output
+    const output = results.map(r =>
+      `${r.path}|${r.type}|code:${r.code_files}|dirs:${r.subdirs}`
+    ).join('\n');
+
+    return {
+      success: true,
+      result: {
+        total: results.length,
+        by_type: {
+          code: results.filter(r => r.type === 'code').length,
+          navigation: results.filter(r => r.type === 'navigation').length,
+          skip: results.filter(r => r.type === 'skip').length
+        },
+        results,
+        output
+      }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to classify folders: ${(error as Error).message}`
+    };
+  }
+}

package/ccw/src/tools/cli-config-manager.ts

@@ -0,0 +1,268 @@
+/**
+ * CLI Configuration Manager
+ * Handles loading, saving, and managing CLI tool configurations
+ * Stores config in centralized storage (~/.ccw/projects/{id}/config/)
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { StoragePaths, ensureStorageDir } from '../config/storage-paths.js';
+
+// ========== Types ==========
+
+export interface CliToolConfig {
+  enabled: boolean;
+  primaryModel: string;      // For CLI endpoint calls (ccw cli -p)
+  secondaryModel: string;    // For internal calls (llm_enhancer, generate_module_docs)
+}
+
+export interface CliConfig {
+  version: number;
+  tools: Record<string, CliToolConfig>;
+}
+
+export type CliToolName = 'gemini' | 'qwen' | 'codex';
+
+// ========== Constants ==========
+
+export const PREDEFINED_MODELS: Record<CliToolName, string[]> = {
+  gemini: ['gemini-2.5-pro', 'gemini-2.5-flash', 'gemini-2.0-flash', 'gemini-1.5-pro', 'gemini-1.5-flash'],
+  qwen: ['coder-model', 'vision-model', 'qwen2.5-coder-32b'],
+  codex: ['gpt-5.2', 'gpt-4.1', 'o4-mini', 'o3']
+};
+
+export const DEFAULT_CONFIG: CliConfig = {
+  version: 1,
+  tools: {
+    gemini: {
+      enabled: true,
+      primaryModel: 'gemini-2.5-pro',
+      secondaryModel: 'gemini-2.5-flash'
+    },
+    qwen: {
+      enabled: true,
+      primaryModel: 'coder-model',
+      secondaryModel: 'coder-model'
+    },
+    codex: {
+      enabled: true,
+      primaryModel: 'gpt-5.2',
+      secondaryModel: 'gpt-5.2'
+    }
+  }
+};
+
+// ========== Helper Functions ==========
+
+function getConfigPath(baseDir: string): string {
+  return StoragePaths.project(baseDir).cliConfig;
+}
+
+function ensureConfigDirForProject(baseDir: string): void {
+  const configDir = StoragePaths.project(baseDir).config;
+  ensureStorageDir(configDir);
+}
+
+function isValidToolName(tool: string): tool is CliToolName {
+  return ['gemini', 'qwen', 'codex'].includes(tool);
+}
+
+function validateConfig(config: unknown): config is CliConfig {
+  if (!config || typeof config !== 'object') return false;
+  const c = config as Record<string, unknown>;
+
+  if (typeof c.version !== 'number') return false;
+  if (!c.tools || typeof c.tools !== 'object') return false;
+
+  const tools = c.tools as Record<string, unknown>;
+  for (const toolName of ['gemini', 'qwen', 'codex']) {
+    const tool = tools[toolName];
+    if (!tool || typeof tool !== 'object') return false;
+
+    const t = tool as Record<string, unknown>;
+    if (typeof t.enabled !== 'boolean') return false;
+    if (typeof t.primaryModel !== 'string') return false;
+    if (typeof t.secondaryModel !== 'string') return false;
+  }
+
+  return true;
+}
+
+function mergeWithDefaults(config: Partial<CliConfig>): CliConfig {
+  const result: CliConfig = {
+    version: config.version ?? DEFAULT_CONFIG.version,
+    tools: { ...DEFAULT_CONFIG.tools }
+  };
+
+  if (config.tools) {
+    for (const toolName of Object.keys(config.tools)) {
+      if (isValidToolName(toolName) && config.tools[toolName]) {
+        result.tools[toolName] = {
+          ...DEFAULT_CONFIG.tools[toolName],
+          ...config.tools[toolName]
+        };
+      }
+    }
+  }
+
+  return result;
+}
+
+// ========== Main Functions ==========
+
+/**
+ * Load CLI configuration from .workflow/cli-config.json
+ * Returns default config if file doesn't exist or is invalid
+ */
+export function loadCliConfig(baseDir: string): CliConfig {
+  const configPath = getConfigPath(baseDir);
+
+  try {
+    if (!fs.existsSync(configPath)) {
+      return { ...DEFAULT_CONFIG };
+    }
+
+    const content = fs.readFileSync(configPath, 'utf-8');
+    const parsed = JSON.parse(content);
+
+    if (validateConfig(parsed)) {
+      return mergeWithDefaults(parsed);
+    }
+
+    // Invalid config, return defaults
+    console.warn('[cli-config] Invalid config file, using defaults');
+    return { ...DEFAULT_CONFIG };
+  } catch (err) {
+    console.error('[cli-config] Error loading config:', err);
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+/**
+ * Save CLI configuration to .workflow/cli-config.json
+ */
+export function saveCliConfig(baseDir: string, config: CliConfig): void {
+  ensureConfigDirForProject(baseDir);
+  const configPath = getConfigPath(baseDir);
+
+  try {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+  } catch (err) {
+    console.error('[cli-config] Error saving config:', err);
+    throw new Error(`Failed to save CLI config: ${err}`);
+  }
+}
+
+/**
+ * Get configuration for a specific tool
+ */
+export function getToolConfig(baseDir: string, tool: string): CliToolConfig {
+  if (!isValidToolName(tool)) {
+    throw new Error(`Invalid tool name: ${tool}`);
+  }
+
+  const config = loadCliConfig(baseDir);
+  return config.tools[tool] || DEFAULT_CONFIG.tools[tool];
+}
+
+/**
+ * Update configuration for a specific tool
+ * Returns the updated tool config
+ */
+export function updateToolConfig(
+  baseDir: string,
+  tool: string,
+  updates: Partial<CliToolConfig>
+): CliToolConfig {
+  if (!isValidToolName(tool)) {
+    throw new Error(`Invalid tool name: ${tool}`);
+  }
+
+  const config = loadCliConfig(baseDir);
+  const currentToolConfig = config.tools[tool] || DEFAULT_CONFIG.tools[tool];
+
+  // Apply updates
+  const updatedToolConfig: CliToolConfig = {
+    enabled: updates.enabled !== undefined ? updates.enabled : currentToolConfig.enabled,
+    primaryModel: updates.primaryModel || currentToolConfig.primaryModel,
+    secondaryModel: updates.secondaryModel || currentToolConfig.secondaryModel
+  };
+
+  // Save updated config
+  config.tools[tool] = updatedToolConfig;
+  saveCliConfig(baseDir, config);
+
+  return updatedToolConfig;
+}
+
+/**
+ * Enable a CLI tool
+ */
+export function enableTool(baseDir: string, tool: string): CliToolConfig {
+  return updateToolConfig(baseDir, tool, { enabled: true });
+}
+
+/**
+ * Disable a CLI tool
+ */
+export function disableTool(baseDir: string, tool: string): CliToolConfig {
+  return updateToolConfig(baseDir, tool, { enabled: false });
+}
+
+/**
+ * Check if a tool is enabled
+ */
+export function isToolEnabled(baseDir: string, tool: string): boolean {
+  try {
+    const config = getToolConfig(baseDir, tool);
+    return config.enabled;
+  } catch {
+    return true; // Default to enabled if error
+  }
+}
+
+/**
+ * Get primary model for a tool
+ */
+export function getPrimaryModel(baseDir: string, tool: string): string {
+  try {
+    const config = getToolConfig(baseDir, tool);
+    return config.primaryModel;
+  } catch {
+    return isValidToolName(tool) ? DEFAULT_CONFIG.tools[tool].primaryModel : 'gemini-2.5-pro';
+  }
+}
+
+/**
+ * Get secondary model for a tool (used for internal calls)
+ */
+export function getSecondaryModel(baseDir: string, tool: string): string {
+  try {
+    const config = getToolConfig(baseDir, tool);
+    return config.secondaryModel;
+  } catch {
+    return isValidToolName(tool) ? DEFAULT_CONFIG.tools[tool].secondaryModel : 'gemini-2.5-flash';
+  }
+}
+
+/**
+ * Get all predefined models for a tool
+ */
+export function getPredefinedModels(tool: string): string[] {
+  if (!isValidToolName(tool)) {
+    return [];
+  }
+  return [...PREDEFINED_MODELS[tool]];
+}
+
+/**
+ * Get full config response for API (includes predefined models)
+ */
+export function getFullConfigResponse(baseDir: string): {
+  config: CliConfig;
+  predefinedModels: Record<string, string[]>;
+} {
+  return {
+    config: loadCliConfig(baseDir),
+    predefinedModels: { ...PREDEFINED_MODELS }
+  };
+}