claude-code-workflow 6.1.4 → 6.2.2

package/ccw/src/core/routes/files-routes.ts

@@ -0,0 +1,428 @@
+// @ts-nocheck
+/**
+ * Files Routes Module
+ * Handles all file browsing related API endpoints
+ */
+import type { IncomingMessage, ServerResponse } from 'http';
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+
+export interface RouteContext {
+  pathname: string;
+  url: URL;
+  req: IncomingMessage;
+  res: ServerResponse;
+  initialPath: string;
+  handlePostRequest: (req: IncomingMessage, res: ServerResponse, handler: (body: unknown) => Promise<any>) => void;
+  broadcastToClients: (data: unknown) => void;
+}
+
+// ========================================
+// Constants
+// ========================================
+
+// Directories to always exclude from file tree
+const EXPLORER_EXCLUDE_DIRS = [
+  '.git', '__pycache__', 'node_modules', '.venv', 'venv', 'env',
+  'dist', 'build', '.cache', '.pytest_cache', '.mypy_cache',
+  'coverage', '.nyc_output', 'logs', 'tmp', 'temp', '.next',
+  '.nuxt', '.output', '.turbo', '.parcel-cache'
+];
+
+// File extensions to language mapping for syntax highlighting
+const EXT_TO_LANGUAGE = {
+  '.js': 'javascript',
+  '.jsx': 'javascript',
+  '.ts': 'typescript',
+  '.tsx': 'typescript',
+  '.py': 'python',
+  '.rb': 'ruby',
+  '.java': 'java',
+  '.go': 'go',
+  '.rs': 'rust',
+  '.c': 'c',
+  '.cpp': 'cpp',
+  '.h': 'c',
+  '.hpp': 'cpp',
+  '.cs': 'csharp',
+  '.php': 'php',
+  '.swift': 'swift',
+  '.kt': 'kotlin',
+  '.scala': 'scala',
+  '.sh': 'bash',
+  '.bash': 'bash',
+  '.zsh': 'bash',
+  '.ps1': 'powershell',
+  '.sql': 'sql',
+  '.html': 'html',
+  '.htm': 'html',
+  '.css': 'css',
+  '.scss': 'scss',
+  '.sass': 'sass',
+  '.less': 'less',
+  '.json': 'json',
+  '.xml': 'xml',
+  '.yaml': 'yaml',
+  '.yml': 'yaml',
+  '.toml': 'toml',
+  '.ini': 'ini',
+  '.cfg': 'ini',
+  '.conf': 'nginx',
+  '.md': 'markdown',
+  '.markdown': 'markdown',
+  '.txt': 'plaintext',
+  '.log': 'plaintext',
+  '.env': 'bash',
+  '.dockerfile': 'dockerfile',
+  '.vue': 'html',
+  '.svelte': 'html'
+};
+
+// ========================================
+// Helper Functions
+// ========================================
+
+/**
+ * Parse .gitignore file and return patterns
+ * @param {string} gitignorePath - Path to .gitignore file
+ * @returns {string[]} Array of gitignore patterns
+ */
+function parseGitignore(gitignorePath) {
+  try {
+    if (!existsSync(gitignorePath)) return [];
+    const content = readFileSync(gitignorePath, 'utf8');
+    return content
+      .split('\n')
+      .map(line => line.trim())
+      .filter(line => line && !line.startsWith('#'));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Check if a file/directory should be ignored based on gitignore patterns
+ * Simple pattern matching (supports basic glob patterns)
+ * @param {string} name - File or directory name
+ * @param {string[]} patterns - Gitignore patterns
+ * @param {boolean} isDirectory - Whether the entry is a directory
+ * @returns {boolean}
+ */
+function shouldIgnore(name, patterns, isDirectory) {
+  // Always exclude certain directories
+  if (isDirectory && EXPLORER_EXCLUDE_DIRS.includes(name)) {
+    return true;
+  }
+
+  // Skip hidden files/directories (starting with .)
+  if (name.startsWith('.') && name !== '.claude' && name !== '.workflow') {
+    return true;
+  }
+
+  for (const pattern of patterns) {
+    let p = pattern;
+
+    // Handle negation patterns (we skip them for simplicity)
+    if (p.startsWith('!')) continue;
+
+    // Handle directory-only patterns
+    if (p.endsWith('/')) {
+      if (!isDirectory) continue;
+      p = p.slice(0, -1);
+    }
+
+    // Simple pattern matching
+    if (p === name) return true;
+
+    // Handle wildcard patterns
+    if (p.includes('*')) {
+      const regex = new RegExp('^' + p.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
+      if (regex.test(name)) return true;
+    }
+
+    // Handle extension patterns like *.log
+    if (p.startsWith('*.')) {
+      const ext = p.slice(1);
+      if (name.endsWith(ext)) return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * List directory files with .gitignore filtering
+ * @param {string} dirPath - Directory path to list
+ * @returns {Promise<Object>}
+ */
+async function listDirectoryFiles(dirPath) {
+  try {
+    // Normalize path
+    let normalizedPath = dirPath.replace(/\\/g, '/');
+    if (normalizedPath.match(/^\/[a-zA-Z]\//)) {
+      normalizedPath = normalizedPath.charAt(1).toUpperCase() + ':' + normalizedPath.slice(2);
+    }
+
+    if (!existsSync(normalizedPath)) {
+      return { error: 'Directory not found', files: [] };
+    }
+
+    if (!statSync(normalizedPath).isDirectory()) {
+      return { error: 'Not a directory', files: [] };
+    }
+
+    // Parse .gitignore patterns
+    const gitignorePath = join(normalizedPath, '.gitignore');
+    const gitignorePatterns = parseGitignore(gitignorePath);
+
+    // Read directory entries
+    const entries = readdirSync(normalizedPath, { withFileTypes: true });
+
+    const files = [];
+    for (const entry of entries) {
+      const isDirectory = entry.isDirectory();
+
+      // Check if should be ignored
+      if (shouldIgnore(entry.name, gitignorePatterns, isDirectory)) {
+        continue;
+      }
+
+      const entryPath = join(normalizedPath, entry.name);
+      const fileInfo = {
+        name: entry.name,
+        type: isDirectory ? 'directory' : 'file',
+        path: entryPath.replace(/\\/g, '/')
+      };
+
+      // Check if directory has CLAUDE.md
+      if (isDirectory) {
+        const claudeMdPath = join(entryPath, 'CLAUDE.md');
+        fileInfo.hasClaudeMd = existsSync(claudeMdPath);
+      }
+
+      files.push(fileInfo);
+    }
+
+    // Sort: directories first, then alphabetically
+    files.sort((a, b) => {
+      if (a.type === 'directory' && b.type !== 'directory') return -1;
+      if (a.type !== 'directory' && b.type === 'directory') return 1;
+      return a.name.localeCompare(b.name);
+    });
+
+    return {
+      path: normalizedPath.replace(/\\/g, '/'),
+      files,
+      gitignorePatterns
+    };
+  } catch (error: unknown) {
+    console.error('Error listing directory:', error);
+    return { error: (error as Error).message, files: [] };
+  }
+}
+
+/**
+ * Get file content for preview
+ * @param {string} filePath - Path to file
+ * @returns {Promise<Object>}
+ */
+async function getFileContent(filePath) {
+  try {
+    // Normalize path
+    let normalizedPath = filePath.replace(/\\/g, '/');
+    if (normalizedPath.match(/^\/[a-zA-Z]\//)) {
+      normalizedPath = normalizedPath.charAt(1).toUpperCase() + ':' + normalizedPath.slice(2);
+    }
+
+    if (!existsSync(normalizedPath)) {
+      return { error: 'File not found' };
+    }
+
+    const stats = statSync(normalizedPath);
+    if (stats.isDirectory()) {
+      return { error: 'Cannot read directory' };
+    }
+
+    // Check file size (limit to 1MB for preview)
+    if (stats.size > 1024 * 1024) {
+      return { error: 'File too large for preview (max 1MB)', size: stats.size };
+    }
+
+    // Read file content
+    const content = readFileSync(normalizedPath, 'utf8');
+    const ext = normalizedPath.substring(normalizedPath.lastIndexOf('.')).toLowerCase();
+    const language = EXT_TO_LANGUAGE[ext] || 'plaintext';
+    const isMarkdown = ext === '.md' || ext === '.markdown';
+    const fileName = normalizedPath.split('/').pop();
+
+    return {
+      content,
+      language,
+      isMarkdown,
+      fileName,
+      path: normalizedPath,
+      size: stats.size,
+      lines: content.split('\n').length
+    };
+  } catch (error: unknown) {
+    console.error('Error reading file:', error);
+    return { error: (error as Error).message };
+  }
+}
+
+/**
+ * Trigger update-module-claude tool (async execution)
+ * @param {string} targetPath - Directory path to update
+ * @param {string} tool - CLI tool to use (gemini, qwen, codex, claude)
+ * @param {string} strategy - Update strategy (single-layer, multi-layer)
+ * @returns {Promise<Object>}
+ */
+async function triggerUpdateClaudeMd(targetPath, tool, strategy) {
+  const { spawn } = await import('child_process');
+
+  // Normalize path
+  let normalizedPath = targetPath.replace(/\\/g, '/');
+  if (normalizedPath.match(/^\/[a-zA-Z]\//)) {
+    normalizedPath = normalizedPath.charAt(1).toUpperCase() + ':' + normalizedPath.slice(2);
+  }
+
+  if (!existsSync(normalizedPath)) {
+    return { error: 'Directory not found' };
+  }
+
+  if (!statSync(normalizedPath).isDirectory()) {
+    return { error: 'Not a directory' };
+  }
+
+  // Build ccw tool command with JSON parameters
+  const params = JSON.stringify({
+    strategy,
+    path: normalizedPath,
+    tool
+  });
+
+  console.log(`[Explorer] Running async: ccw tool exec update_module_claude with ${tool} (${strategy})`);
+
+  return new Promise((resolve) => {
+    const isWindows = process.platform === 'win32';
+
+    // Spawn the process
+    const child = spawn('ccw', ['tool', 'exec', 'update_module_claude', params], {
+      cwd: normalizedPath,
+      shell: isWindows,
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        // Parse the JSON output from the tool
+        let result;
+        try {
+          result = JSON.parse(stdout);
+        } catch {
+          result = { output: stdout };
+        }
+
+        if (result.success === false || result.error) {
+          resolve({
+            success: false,
+            error: result.error || result.message || 'Update failed',
+            output: stdout
+          });
+        } else {
+          resolve({
+            success: true,
+            message: result.message || `CLAUDE.md updated successfully using ${tool} (${strategy})`,
+            output: stdout,
+            path: normalizedPath
+          });
+        }
+      } else {
+        resolve({
+          success: false,
+          error: stderr || `Process exited with code ${code}`,
+          output: stdout + stderr
+        });
+      }
+    });
+
+    child.on('error', (error) => {
+      console.error('Error spawning process:', error);
+      resolve({
+        success: false,
+        error: (error as Error).message,
+        output: ''
+      });
+    });
+
+    // Timeout after 5 minutes
+    setTimeout(() => {
+      child.kill();
+      resolve({
+        success: false,
+        error: 'Timeout: Process took longer than 5 minutes',
+        output: stdout
+      });
+    }, 300000);
+  });
+}
+
+// ========================================
+// Route Handler
+// ========================================
+
+/**
+ * Handle files routes
+ * @returns true if route was handled, false otherwise
+ */
+export async function handleFilesRoutes(ctx: RouteContext): Promise<boolean> {
+  const { pathname, url, req, res, initialPath, handlePostRequest } = ctx;
+
+  // API: List directory files with .gitignore filtering (Explorer view)
+  if (pathname === '/api/files') {
+    const dirPath = url.searchParams.get('path') || initialPath;
+    const filesData = await listDirectoryFiles(dirPath);
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(filesData));
+    return true;
+  }
+
+  // API: Get file content for preview (Explorer view)
+  if (pathname === '/api/file-content') {
+    const filePath = url.searchParams.get('path');
+    if (!filePath) {
+      res.writeHead(400, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'File path is required' }));
+      return true;
+    }
+    const fileData = await getFileContent(filePath);
+    res.writeHead(fileData.error ? 404 : 200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(fileData));
+    return true;
+  }
+
+  // API: Update CLAUDE.md using CLI tools (Explorer view)
+  if (pathname === '/api/update-claude-md' && req.method === 'POST') {
+    handlePostRequest(req, res, async (body) => {
+      const { path: targetPath, tool = 'gemini', strategy = 'single-layer' } = body;
+      if (!targetPath) {
+        return { error: 'path is required', status: 400 };
+      }
+      return await triggerUpdateClaudeMd(targetPath, tool, strategy);
+    });
+    return true;
+  }
+
+  return false;
+}

package/ccw/src/core/routes/graph-routes.md

@@ -0,0 +1,164 @@
+# Graph Routes API Documentation
+
+## Overview
+The Graph Routes module provides REST API endpoints for querying and visualizing code structure data from CodexLens indices. It exposes symbols and their relationships as graph nodes and edges.
+
+## Endpoints
+
+### GET /api/graph/nodes
+Query all symbols from the CodexLens SQLite database and return them as graph nodes.
+
+**Query Parameters:**
+- `path` (optional): Project path. Defaults to server's initial path.
+
+**Response:**
+```json
+{
+  "nodes": [
+    {
+      "id": "src/file.ts:functionName:10",
+      "name": "functionName",
+      "type": "FUNCTION",
+      "file": "src/file.ts",
+      "line": 10
+    }
+  ]
+}
+```
+
+**Node Types:**
+- `FUNCTION`: Functions and procedures
+- `CLASS`: Classes, interfaces, and type definitions
+- `METHOD`: Class methods
+- `VARIABLE`: Variables and constants
+- `MODULE`: Module-level definitions
+
+---
+
+### GET /api/graph/edges
+Query all code relationships from the CodexLens SQLite database and return them as graph edges.
+
+**Query Parameters:**
+- `path` (optional): Project path. Defaults to server's initial path.
+
+**Response:**
+```json
+{
+  "edges": [
+    {
+      "source": "src/file.ts:caller:10",
+      "target": "module.callee",
+      "type": "CALLS",
+      "sourceLine": 10,
+      "sourceFile": "src/file.ts"
+    }
+  ]
+}
+```
+
+**Edge Types:**
+- `CALLS`: Function/method invocations
+- `IMPORTS`: Import/require relationships
+- `INHERITS`: Class inheritance
+
+---
+
+### GET /api/graph/impact
+Get impact analysis for a symbol - determines what code is affected if this symbol changes.
+
+**Query Parameters:**
+- `path` (optional): Project path. Defaults to server's initial path.
+- `symbol` (required): Symbol ID in format `file:name:line`
+
+**Response:**
+```json
+{
+  "directDependents": [
+    "src/other.ts:caller:20",
+    "src/another.ts:user:35"
+  ],
+  "affectedFiles": [
+    "src/other.ts",
+    "src/another.ts"
+  ]
+}
+```
+
+---
+
+## Implementation Details
+
+### PathMapper
+Maps source code paths to CodexLens index database paths following the storage structure:
+- Windows: `D:\path\to\project` → `~/.codexlens/indexes/D/path/to/project/_index.db`
+- Unix: `/home/user/project` → `~/.codexlens/indexes/home/user/project/_index.db`
+
+### Database Schema
+Queries two main tables:
+1. **symbols** - Code symbol definitions
+   - `id`, `file_id`, `name`, `kind`, `start_line`, `end_line`
+2. **code_relationships** - Inter-symbol dependencies
+   - `id`, `source_symbol_id`, `target_qualified_name`, `relationship_type`, `source_line`, `target_file`
+
+### Error Handling
+- Returns empty arrays (`[]`) if index database doesn't exist
+- Returns 500 with error message on database query failures
+- Returns 400 if required parameters are missing
+
+### Type Mappings
+
+**Symbol Kinds → Node Types:**
+```typescript
+{
+  'function' → 'FUNCTION',
+  'class' → 'CLASS',
+  'method' → 'METHOD',
+  'variable' → 'VARIABLE',
+  'module' → 'MODULE',
+  'interface' → 'CLASS',
+  'type' → 'CLASS'
+}
+```
+
+**Relationship Types → Edge Types:**
+```typescript
+{
+  'call' → 'CALLS',
+  'import' → 'IMPORTS',
+  'inherits' → 'INHERITS',
+  'uses' → 'CALLS'
+}
+```
+
+---
+
+## Usage Examples
+
+### Fetch All Nodes
+```bash
+curl "http://localhost:3000/api/graph/nodes?path=/path/to/project"
+```
+
+### Fetch All Edges
+```bash
+curl "http://localhost:3000/api/graph/edges?path=/path/to/project"
+```
+
+### Analyze Impact
+```bash
+curl "http://localhost:3000/api/graph/impact?path=/path/to/project&symbol=src/file.ts:functionName:10"
+```
+
+---
+
+## Integration with CodexLens
+
+This module requires:
+1. CodexLens to be installed and initialized (`/api/codexlens/init`)
+2. Project to be indexed (creates `_index.db` files)
+3. better-sqlite3 package for direct database access
+
+## Dependencies
+- `better-sqlite3`: Direct SQLite database access
+- `codex-lens`: Python package providing the indexing infrastructure
+- `path`, `fs`, `os`: Node.js built-in modules for file system operations