claude-code-workflow 6.1.4 → 6.2.2

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

@@ -0,0 +1,599 @@
+// @ts-nocheck
+/**
+ * Skills Routes Module
+ * Handles all Skills-related API endpoints
+ */
+import type { IncomingMessage, ServerResponse } from 'http';
+import { readFileSync, existsSync, readdirSync, statSync, unlinkSync, promises as fsPromises } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { executeCliTool } from '../../tools/cli-executor.js';
+
+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;
+}
+
+// ========== Skills Helper Functions ==========
+
+/**
+ * Parse skill frontmatter (YAML header)
+ * @param {string} content - Skill file content
+ * @returns {Object} Parsed frontmatter and content
+ */
+function parseSkillFrontmatter(content) {
+  const result = {
+    name: '',
+    description: '',
+    version: null,
+    allowedTools: [],
+    content: ''
+  };
+
+  // Check for YAML frontmatter
+  if (content.startsWith('---')) {
+    const endIndex = content.indexOf('---', 3);
+    if (endIndex > 0) {
+      const frontmatter = content.substring(3, endIndex).trim();
+      result.content = content.substring(endIndex + 3).trim();
+
+      // Parse frontmatter lines
+      const lines = frontmatter.split('\n');
+      for (const line of lines) {
+        const colonIndex = line.indexOf(':');
+        if (colonIndex > 0) {
+          const key = line.substring(0, colonIndex).trim().toLowerCase();
+          const value = line.substring(colonIndex + 1).trim();
+
+          if (key === 'name') {
+            result.name = value.replace(/^["']|["']$/g, '');
+          } else if (key === 'description') {
+            result.description = value.replace(/^["']|["']$/g, '');
+          } else if (key === 'version') {
+            result.version = value.replace(/^["']|["']$/g, '');
+          } else if (key === 'allowed-tools' || key === 'allowedtools') {
+            // Parse as comma-separated or YAML array
+            result.allowedTools = value.replace(/^\[|\]$/g, '').split(',').map(t => t.trim()).filter(Boolean);
+          }
+        }
+      }
+    }
+  } else {
+    result.content = content;
+  }
+
+  return result;
+}
+
+/**
+ * Get list of supporting files for a skill
+ * @param {string} skillDir
+ * @returns {string[]}
+ */
+function getSupportingFiles(skillDir) {
+  const files = [];
+  try {
+    const entries = readdirSync(skillDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name !== 'SKILL.md') {
+        if (entry.isFile()) {
+          files.push(entry.name);
+        } else if (entry.isDirectory()) {
+          files.push(entry.name + '/');
+        }
+      }
+    }
+  } catch (e) {
+    // Ignore errors
+  }
+  return files;
+}
+
+/**
+ * Get skills configuration from project and user directories
+ * @param {string} projectPath
+ * @returns {Object}
+ */
+function getSkillsConfig(projectPath) {
+  const result = {
+    projectSkills: [],
+    userSkills: []
+  };
+
+  try {
+    // Project skills: .claude/skills/
+    const projectSkillsDir = join(projectPath, '.claude', 'skills');
+    if (existsSync(projectSkillsDir)) {
+      const skills = readdirSync(projectSkillsDir, { withFileTypes: true });
+      for (const skill of skills) {
+        if (skill.isDirectory()) {
+          const skillMdPath = join(projectSkillsDir, skill.name, 'SKILL.md');
+          if (existsSync(skillMdPath)) {
+            const content = readFileSync(skillMdPath, 'utf8');
+            const parsed = parseSkillFrontmatter(content);
+
+            // Get supporting files
+            const skillDir = join(projectSkillsDir, skill.name);
+            const supportingFiles = getSupportingFiles(skillDir);
+
+            result.projectSkills.push({
+              name: parsed.name || skill.name,
+              description: parsed.description,
+              version: parsed.version,
+              allowedTools: parsed.allowedTools,
+              location: 'project',
+              path: skillDir,
+              supportingFiles
+            });
+          }
+        }
+      }
+    }
+
+    // User skills: ~/.claude/skills/
+    const userSkillsDir = join(homedir(), '.claude', 'skills');
+    if (existsSync(userSkillsDir)) {
+      const skills = readdirSync(userSkillsDir, { withFileTypes: true });
+      for (const skill of skills) {
+        if (skill.isDirectory()) {
+          const skillMdPath = join(userSkillsDir, skill.name, 'SKILL.md');
+          if (existsSync(skillMdPath)) {
+            const content = readFileSync(skillMdPath, 'utf8');
+            const parsed = parseSkillFrontmatter(content);
+
+            // Get supporting files
+            const skillDir = join(userSkillsDir, skill.name);
+            const supportingFiles = getSupportingFiles(skillDir);
+
+            result.userSkills.push({
+              name: parsed.name || skill.name,
+              description: parsed.description,
+              version: parsed.version,
+              allowedTools: parsed.allowedTools,
+              location: 'user',
+              path: skillDir,
+              supportingFiles
+            });
+          }
+        }
+      }
+    }
+  } catch (error) {
+    console.error('Error reading skills config:', error);
+  }
+
+  return result;
+}
+
+/**
+ * Get single skill detail
+ * @param {string} skillName
+ * @param {string} location - 'project' or 'user'
+ * @param {string} projectPath
+ * @returns {Object}
+ */
+function getSkillDetail(skillName, location, projectPath) {
+  try {
+    const baseDir = location === 'project'
+      ? join(projectPath, '.claude', 'skills')
+      : join(homedir(), '.claude', 'skills');
+
+    const skillDir = join(baseDir, skillName);
+    const skillMdPath = join(skillDir, 'SKILL.md');
+
+    if (!existsSync(skillMdPath)) {
+      return { error: 'Skill not found' };
+    }
+
+    const content = readFileSync(skillMdPath, 'utf8');
+    const parsed = parseSkillFrontmatter(content);
+    const supportingFiles = getSupportingFiles(skillDir);
+
+    return {
+      skill: {
+        name: parsed.name || skillName,
+        description: parsed.description,
+        version: parsed.version,
+        allowedTools: parsed.allowedTools,
+        content: parsed.content,
+        location,
+        path: skillDir,
+        supportingFiles
+      }
+    };
+  } catch (error) {
+    return { error: (error as Error).message };
+  }
+}
+
+/**
+ * Delete a skill
+ * @param {string} skillName
+ * @param {string} location
+ * @param {string} projectPath
+ * @returns {Object}
+ */
+function deleteSkill(skillName, location, projectPath) {
+  try {
+    const baseDir = location === 'project'
+      ? join(projectPath, '.claude', 'skills')
+      : join(homedir(), '.claude', 'skills');
+
+    const skillDir = join(baseDir, skillName);
+
+    if (!existsSync(skillDir)) {
+      return { error: 'Skill not found' };
+    }
+
+    // Recursively delete directory
+    const deleteRecursive = (dirPath) => {
+      if (existsSync(dirPath)) {
+        readdirSync(dirPath).forEach((file) => {
+          const curPath = join(dirPath, file);
+          if (statSync(curPath).isDirectory()) {
+            deleteRecursive(curPath);
+          } else {
+            unlinkSync(curPath);
+          }
+        });
+        fsPromises.rmdir(dirPath);
+      }
+    };
+
+    deleteRecursive(skillDir);
+
+    return { success: true, skillName, location };
+  } catch (error) {
+    return { error: (error as Error).message };
+  }
+}
+
+/**
+ * Validate skill folder structure
+ * @param {string} folderPath - Path to skill folder
+ * @returns {Object} Validation result with skill info
+ */
+function validateSkillFolder(folderPath) {
+  const errors = [];
+
+  // Check if folder exists
+  if (!existsSync(folderPath)) {
+    return { valid: false, errors: ['Folder does not exist'], skillInfo: null };
+  }
+
+  // Check if it's a directory
+  try {
+    const stat = statSync(folderPath);
+    if (!stat.isDirectory()) {
+      return { valid: false, errors: ['Path is not a directory'], skillInfo: null };
+    }
+  } catch (e) {
+    return { valid: false, errors: ['Cannot access folder'], skillInfo: null };
+  }
+
+  // Check SKILL.md exists
+  const skillMdPath = join(folderPath, 'SKILL.md');
+  if (!existsSync(skillMdPath)) {
+    errors.push('SKILL.md file not found');
+    return { valid: false, errors, skillInfo: null };
+  }
+
+  // Parse and validate frontmatter
+  try {
+    const content = readFileSync(skillMdPath, 'utf8');
+    const parsed = parseSkillFrontmatter(content);
+
+    if (!parsed.name) {
+      errors.push('name field is required in frontmatter');
+    }
+    if (!parsed.description) {
+      errors.push('description field is required in frontmatter');
+    }
+
+    // Get supporting files
+    const supportingFiles = getSupportingFiles(folderPath);
+
+    // If validation passed
+    if (errors.length === 0) {
+      return {
+        valid: true,
+        errors: [],
+        skillInfo: {
+          name: parsed.name,
+          description: parsed.description,
+          version: parsed.version,
+          allowedTools: parsed.allowedTools,
+          supportingFiles
+        }
+      };
+    } else {
+      return { valid: false, errors, skillInfo: null };
+    }
+  } catch (error) {
+    return { valid: false, errors: ['Failed to parse SKILL.md: ' + (error as Error).message], skillInfo: null };
+  }
+}
+
+/**
+ * Recursively copy directory
+ * @param {string} source - Source directory path
+ * @param {string} target - Target directory path
+ */
+async function copyDirectoryRecursive(source, target) {
+  await fsPromises.mkdir(target, { recursive: true });
+
+  const entries = await fsPromises.readdir(source, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const sourcePath = join(source, entry.name);
+    const targetPath = join(target, entry.name);
+
+    if (entry.isDirectory()) {
+      await copyDirectoryRecursive(sourcePath, targetPath);
+    } else {
+      await fsPromises.copyFile(sourcePath, targetPath);
+    }
+  }
+}
+
+/**
+ * Import skill from folder
+ * @param {string} sourcePath - Source skill folder path
+ * @param {string} location - 'project' or 'user'
+ * @param {string} projectPath - Project root path
+ * @param {string} customName - Optional custom name for skill
+ * @returns {Object}
+ */
+async function importSkill(sourcePath, location, projectPath, customName) {
+  try {
+    // Validate source folder
+    const validation = validateSkillFolder(sourcePath);
+    if (!validation.valid) {
+      return { error: validation.errors.join(', ') };
+    }
+
+    const baseDir = location === 'project'
+      ? join(projectPath, '.claude', 'skills')
+      : join(homedir(), '.claude', 'skills');
+
+    // Ensure base directory exists
+    if (!existsSync(baseDir)) {
+      await fsPromises.mkdir(baseDir, { recursive: true });
+    }
+
+    // Determine target folder name
+    const skillName = customName || validation.skillInfo.name;
+    const targetPath = join(baseDir, skillName);
+
+    // Check if already exists
+    if (existsSync(targetPath)) {
+      return { error: `Skill '${skillName}' already exists in ${location} location` };
+    }
+
+    // Copy entire folder recursively
+    await copyDirectoryRecursive(sourcePath, targetPath);
+
+    return {
+      success: true,
+      skillName,
+      location,
+      path: targetPath
+    };
+  } catch (error) {
+    return { error: (error as Error).message };
+  }
+}
+
+/**
+ * Generate skill via CLI tool (Gemini)
+ * @param {Object} params - Generation parameters
+ * @param {string} params.generationType - 'description' or 'template'
+ * @param {string} params.description - Skill description from user
+ * @param {string} params.skillName - Name for the skill
+ * @param {string} params.location - 'project' or 'user'
+ * @param {string} params.projectPath - Project root path
+ * @returns {Object}
+ */
+async function generateSkillViaCLI({ generationType, description, skillName, location, projectPath }) {
+  try {
+    // Validate inputs
+    if (!skillName) {
+      return { error: 'Skill name is required' };
+    }
+    if (generationType === 'description' && !description) {
+      return { error: 'Description is required for description-based generation' };
+    }
+
+    // Determine target directory
+    const baseDir = location === 'project'
+      ? join(projectPath, '.claude', 'skills')
+      : join(homedir(), '.claude', 'skills');
+
+    const targetPath = join(baseDir, skillName);
+
+    // Check if already exists
+    if (existsSync(targetPath)) {
+      return { error: `Skill '${skillName}' already exists in ${location} location` };
+    }
+
+    // Ensure base directory exists
+    if (!existsSync(baseDir)) {
+      await fsPromises.mkdir(baseDir, { recursive: true });
+    }
+
+    // Build CLI prompt
+    const targetLocationDisplay = location === 'project'
+      ? '.claude/skills/'
+      : '~/.claude/skills/';
+
+    const prompt = `PURPOSE: Generate a complete Claude Code skill from description
+TASK: • Parse skill requirements • Create SKILL.md with proper frontmatter (name, description, version, allowed-tools) • Generate supporting files if needed in skill folder
+MODE: write
+CONTEXT: @**/*
+EXPECTED: Complete skill folder structure with SKILL.md and all necessary files
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/universal/00-universal-rigorous-style.txt) | Follow Claude Code skill format | Include name, description in frontmatter | write=CREATE
+
+SKILL DESCRIPTION:
+${description || 'Generate a basic skill template'}
+
+SKILL NAME: ${skillName}
+TARGET LOCATION: ${targetLocationDisplay}
+TARGET PATH: ${targetPath}
+
+REQUIREMENTS:
+1. Create SKILL.md with frontmatter containing:
+   - name: "${skillName}"
+   - description: Brief description of the skill
+   - version: "1.0.0"
+   - allowed-tools: List of tools this skill can use (e.g., [Read, Write, Edit, Bash])
+2. Add skill content below frontmatter explaining what the skill does and how to use it
+3. If the skill requires supporting files (e.g., templates, scripts), create them in the skill folder
+4. Ensure all files are properly formatted and follow best practices`;
+
+    // Execute CLI tool (Gemini) with write mode
+    const result = await executeCliTool({
+      tool: 'gemini',
+      prompt,
+      mode: 'write',
+      cd: baseDir,
+      timeout: 600000, // 10 minutes
+      category: 'internal'
+    });
+
+    // Check if execution was successful
+    if (!result.success) {
+      return {
+        error: `CLI generation failed: ${result.stderr || 'Unknown error'}`,
+        stdout: result.stdout,
+        stderr: result.stderr
+      };
+    }
+
+    // Validate the generated skill
+    const validation = validateSkillFolder(targetPath);
+    if (!validation.valid) {
+      return {
+        error: `Generated skill is invalid: ${validation.errors.join(', ')}`,
+        stdout: result.stdout,
+        stderr: result.stderr
+      };
+    }
+
+    return {
+      success: true,
+      skillName: validation.skillInfo.name,
+      location,
+      path: targetPath,
+      stdout: result.stdout,
+      stderr: result.stderr
+    };
+  } catch (error) {
+    return { error: (error as Error).message };
+  }
+}
+
+// ========== Skills API Routes ==========
+
+/**
+ * Handle Skills routes
+ * @returns true if route was handled, false otherwise
+ */
+export async function handleSkillsRoutes(ctx: RouteContext): Promise<boolean> {
+  const { pathname, url, req, res, initialPath, handlePostRequest } = ctx;
+
+  // API: Get all skills (project and user)
+  if (pathname === '/api/skills') {
+    const projectPathParam = url.searchParams.get('path') || initialPath;
+    const skillsData = getSkillsConfig(projectPathParam);
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(skillsData));
+    return true;
+  }
+
+  // API: Get single skill detail
+  if (pathname.startsWith('/api/skills/') && req.method === 'GET' && !pathname.endsWith('/skills/')) {
+    const skillName = decodeURIComponent(pathname.replace('/api/skills/', ''));
+    const location = url.searchParams.get('location') || 'project';
+    const projectPathParam = url.searchParams.get('path') || initialPath;
+    const skillDetail = getSkillDetail(skillName, location, projectPathParam);
+    if (skillDetail.error) {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(skillDetail));
+    } else {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(skillDetail));
+    }
+    return true;
+  }
+
+  // API: Delete skill
+  if (pathname.startsWith('/api/skills/') && req.method === 'DELETE') {
+    const skillName = decodeURIComponent(pathname.replace('/api/skills/', ''));
+    handlePostRequest(req, res, async (body) => {
+      const { location, projectPath: projectPathParam } = body;
+      return deleteSkill(skillName, location, projectPathParam || initialPath);
+    });
+    return true;
+  }
+
+  // API: Validate skill import
+  if (pathname === '/api/skills/validate-import' && req.method === 'POST') {
+    handlePostRequest(req, res, async (body) => {
+      const { sourcePath } = body;
+      if (!sourcePath) {
+        return { valid: false, errors: ['Source path is required'], skillInfo: null };
+      }
+      return validateSkillFolder(sourcePath);
+    });
+    return true;
+  }
+
+  // API: Create/Import skill
+  if (pathname === '/api/skills/create' && req.method === 'POST') {
+    handlePostRequest(req, res, async (body) => {
+      const { mode, location, sourcePath, skillName, description, generationType, projectPath: projectPathParam } = body;
+
+      if (!mode) {
+        return { error: 'Mode is required (import or cli-generate)' };
+      }
+
+      if (!location) {
+        return { error: 'Location is required (project or user)' };
+      }
+
+      const projectPath = projectPathParam || initialPath;
+
+      if (mode === 'import') {
+        // Import mode: copy existing skill folder
+        if (!sourcePath) {
+          return { error: 'Source path is required for import mode' };
+        }
+
+        return await importSkill(sourcePath, location, projectPath, skillName);
+      } else if (mode === 'cli-generate') {
+        // CLI generate mode: use Gemini to generate skill
+        if (!skillName) {
+          return { error: 'Skill name is required for CLI generation mode' };
+        }
+
+        return await generateSkillViaCLI({
+          generationType: generationType || 'description',
+          description,
+          skillName,
+          location,
+          projectPath
+        });
+      } else {
+        return { error: 'Invalid mode. Must be "import" or "cli-generate"' };
+      }
+    });
+    return true;
+  }
+
+  return false;
+}

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

@@ -0,0 +1,57 @@
+// @ts-nocheck
+/**
+ * Status Routes Module
+ * Aggregated status endpoint for faster dashboard loading
+ */
+import type { IncomingMessage, ServerResponse } from 'http';
+import { getCliToolsStatus } from '../../tools/cli-executor.js';
+import { checkVenvStatus, checkSemanticStatus } from '../../tools/codex-lens.js';
+
+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;
+}
+
+/**
+ * Handle status routes
+ * @returns true if route was handled, false otherwise
+ */
+export async function handleStatusRoutes(ctx: RouteContext): Promise<boolean> {
+  const { pathname, res } = ctx;
+
+  // API: Aggregated Status (all statuses in one call)
+  if (pathname === '/api/status/all') {
+    try {
+      // Execute all status checks in parallel
+      const [cliStatus, codexLensStatus, semanticStatus] = await Promise.all([
+        getCliToolsStatus(),
+        checkVenvStatus(),
+        // Always check semantic status (will return available: false if CodexLens not ready)
+        checkSemanticStatus().catch(() => ({ available: false, backend: null }))
+      ]);
+
+      const response = {
+        cli: cliStatus,
+        codexLens: codexLensStatus,
+        semantic: semanticStatus,
+        timestamp: new Date().toISOString()
+      };
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(response));
+      return true;
+    } catch (error) {
+      console.error('[Status Routes] Error fetching aggregated status:', error);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: (error as Error).message }));
+      return true;
+    }
+  }
+
+  return false;
+}