claude-code-workflow 6.1.4 → 6.2.1

package/src/core/routes/rules-routes.ts

@@ -0,0 +1,526 @@
+// @ts-nocheck
+/**
+ * Rules Routes Module
+ * Handles all Rules-related API endpoints
+ */
+import type { IncomingMessage, ServerResponse } from 'http';
+import { readFileSync, existsSync, readdirSync, 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;
+}
+
+/**
+ * Parse rule frontmatter
+ * @param {string} content
+ * @returns {Object}
+ */
+function parseRuleFrontmatter(content) {
+  const result = {
+    paths: [],
+    content: 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 === 'paths') {
+            // Parse as comma-separated or YAML array
+            result.paths = value.replace(/^\[|\]$/g, '').split(',').map(t => t.trim()).filter(Boolean);
+          }
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Recursively scan rules directory for .md files
+ * @param {string} dirPath
+ * @param {string} location
+ * @param {string} subdirectory
+ * @returns {Object[]}
+ */
+function scanRulesDirectory(dirPath, location, subdirectory) {
+  const rules = [];
+
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dirPath, entry.name);
+
+      if (entry.isFile() && entry.name.endsWith('.md')) {
+        const content = readFileSync(fullPath, 'utf8');
+        const parsed = parseRuleFrontmatter(content);
+
+        rules.push({
+          name: entry.name,
+          paths: parsed.paths,
+          content: parsed.content,
+          location,
+          path: fullPath,
+          subdirectory: subdirectory || null
+        });
+      } else if (entry.isDirectory()) {
+        // Recursively scan subdirectories
+        const subRules = scanRulesDirectory(fullPath, location, subdirectory ? `${subdirectory}/${entry.name}` : entry.name);
+        rules.push(...subRules);
+      }
+    }
+  } catch (e) {
+    // Ignore errors
+  }
+
+  return rules;
+}
+
+/**
+ * Get rules configuration from project and user directories
+ * @param {string} projectPath
+ * @returns {Object}
+ */
+function getRulesConfig(projectPath) {
+  const result = {
+    projectRules: [],
+    userRules: []
+  };
+
+  try {
+    // Project rules: .claude/rules/
+    const projectRulesDir = join(projectPath, '.claude', 'rules');
+    if (existsSync(projectRulesDir)) {
+      const rules = scanRulesDirectory(projectRulesDir, 'project', '');
+      result.projectRules = rules;
+    }
+
+    // User rules: ~/.claude/rules/
+    const userRulesDir = join(homedir(), '.claude', 'rules');
+    if (existsSync(userRulesDir)) {
+      const rules = scanRulesDirectory(userRulesDir, 'user', '');
+      result.userRules = rules;
+    }
+  } catch (error) {
+    console.error('Error reading rules config:', error);
+  }
+
+  return result;
+}
+
+/**
+ * Find rule file in directory (including subdirectories)
+ * @param {string} baseDir
+ * @param {string} ruleName
+ * @returns {string|null}
+ */
+function findRuleFile(baseDir, ruleName) {
+  try {
+    // Direct path
+    const directPath = join(baseDir, ruleName);
+    if (existsSync(directPath)) {
+      return directPath;
+    }
+
+    // Search in subdirectories
+    const entries = readdirSync(baseDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const subPath = findRuleFile(join(baseDir, entry.name), ruleName);
+        if (subPath) return subPath;
+      }
+    }
+  } catch (e) {
+    // Ignore errors
+  }
+  return null;
+}
+
+/**
+ * Get single rule detail
+ * @param {string} ruleName
+ * @param {string} location - 'project' or 'user'
+ * @param {string} projectPath
+ * @returns {Object}
+ */
+function getRuleDetail(ruleName, location, projectPath) {
+  try {
+    const baseDir = location === 'project'
+      ? join(projectPath, '.claude', 'rules')
+      : join(homedir(), '.claude', 'rules');
+
+    // Find the rule file (could be in subdirectory)
+    const rulePath = findRuleFile(baseDir, ruleName);
+
+    if (!rulePath) {
+      return { error: 'Rule not found' };
+    }
+
+    const content = readFileSync(rulePath, 'utf8');
+    const parsed = parseRuleFrontmatter(content);
+
+    return {
+      rule: {
+        name: ruleName,
+        paths: parsed.paths,
+        content: parsed.content,
+        location,
+        path: rulePath
+      }
+    };
+  } catch (error) {
+    return { error: (error as Error).message };
+  }
+}
+
+/**
+ * Delete a rule
+ * @param {string} ruleName
+ * @param {string} location
+ * @param {string} projectPath
+ * @returns {Object}
+ */
+function deleteRule(ruleName, location, projectPath) {
+  try {
+    const baseDir = location === 'project'
+      ? join(projectPath, '.claude', 'rules')
+      : join(homedir(), '.claude', 'rules');
+
+    const rulePath = findRuleFile(baseDir, ruleName);
+
+    if (!rulePath) {
+      return { error: 'Rule not found' };
+    }
+
+    unlinkSync(rulePath);
+
+    return { success: true, ruleName, location };
+  } catch (error) {
+    return { error: (error as Error).message };
+  }
+}
+
+/**
+ * Generate rule content via CLI tool
+ * @param {Object} params
+ * @param {string} params.generationType - 'description' | 'template' | 'extract'
+ * @param {string} params.description - Rule description (for 'description' mode)
+ * @param {string} params.templateType - Template type (for 'template' mode)
+ * @param {string} params.extractScope - Scope pattern (for 'extract' mode)
+ * @param {string} params.extractFocus - Focus areas (for 'extract' mode)
+ * @param {string} params.fileName - Target file name
+ * @param {string} params.location - 'project' or 'user'
+ * @param {string} params.subdirectory - Optional subdirectory
+ * @param {string} params.projectPath - Project root path
+ * @returns {Object}
+ */
+async function generateRuleViaCLI(params) {
+  try {
+    const {
+      generationType,
+      description,
+      templateType,
+      extractScope,
+      extractFocus,
+      fileName,
+      location,
+      subdirectory,
+      projectPath
+    } = params;
+
+    let prompt = '';
+    let mode = 'analysis';
+    let workingDir = projectPath;
+
+    // Build prompt based on generation type
+    if (generationType === 'description') {
+      mode = 'write';
+      prompt = `PURPOSE: Generate Claude Code memory rule from description to guide Claude's behavior
+TASK: • Analyze rule requirements • Generate markdown content with clear instructions
+MODE: write
+EXPECTED: Complete rule content in markdown format
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/universal/00-universal-rigorous-style.txt) | Follow Claude Code rule format | Use frontmatter for conditional rules if paths specified | write=CREATE
+
+RULE DESCRIPTION:
+${description}
+
+FILE NAME: ${fileName}`;
+    } else if (generationType === 'template') {
+      mode = 'write';
+      prompt = `PURPOSE: Generate Claude Code rule from template type
+TASK: • Create rule based on ${templateType} template • Generate structured markdown content
+MODE: write
+EXPECTED: Complete rule content in markdown format following template structure
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/universal/00-universal-rigorous-style.txt) | Follow Claude Code rule format | Use ${templateType} template patterns | write=CREATE
+
+TEMPLATE TYPE: ${templateType}
+FILE NAME: ${fileName}`;
+    } else if (generationType === 'extract') {
+      mode = 'analysis';
+      prompt = `PURPOSE: Extract coding rules from existing codebase to document patterns and conventions
+TASK: • Analyze code patterns in specified scope • Extract common conventions • Identify best practices
+MODE: analysis
+CONTEXT: @${extractScope || '**/*'}
+EXPECTED: Rule content based on codebase analysis with examples
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/02-analyze-code-patterns.txt) | Focus on actual patterns found | Include code examples | analysis=READ-ONLY
+
+ANALYSIS SCOPE: ${extractScope || '**/*'}
+FOCUS AREAS: ${extractFocus || 'naming conventions, error handling, code structure'}`;
+    } else {
+      return { error: `Unknown generation type: ${generationType}` };
+    }
+
+    // Execute CLI tool (Gemini) with at least 10 minutes timeout
+    const result = await executeCliTool({
+      tool: 'gemini',
+      prompt,
+      mode,
+      cd: workingDir,
+      timeout: 600000 // 10 minutes
+    });
+
+    if (!result.success) {
+      return {
+        error: `CLI execution failed: ${result.stderr || 'Unknown error'}`,
+        stderr: result.stderr
+      };
+    }
+
+    // Extract generated content from stdout
+    const generatedContent = result.stdout.trim();
+
+    if (!generatedContent) {
+      return {
+        error: 'CLI execution returned empty content',
+        stdout: result.stdout,
+        stderr: result.stderr
+      };
+    }
+
+    // Create the rule using the generated content
+    const createResult = await createRule({
+      fileName,
+      content: generatedContent,
+      paths: [],
+      location,
+      subdirectory,
+      projectPath
+    });
+
+    return {
+      success: createResult.success || false,
+      ...createResult,
+      generatedContent,
+      executionId: result.conversation?.id
+    };
+  } catch (error) {
+    return { error: (error as Error).message };
+  }
+}
+
+/**
+ * Create a new rule
+ * @param {Object} params
+ * @param {string} params.fileName - Rule file name (must end with .md)
+ * @param {string} params.content - Rule content (markdown)
+ * @param {string[]} params.paths - Optional paths for conditional rule
+ * @param {string} params.location - 'project' or 'user'
+ * @param {string} params.subdirectory - Optional subdirectory path
+ * @param {string} params.projectPath - Project root path
+ * @returns {Object}
+ */
+async function createRule(params) {
+  try {
+    const { fileName, content, paths, location, subdirectory, projectPath } = params;
+
+    // Validate file name
+    if (!fileName || !fileName.endsWith('.md')) {
+      return { error: 'File name must end with .md' };
+    }
+
+    // Build base directory
+    const baseDir = location === 'project'
+      ? join(projectPath, '.claude', 'rules')
+      : join(homedir(), '.claude', 'rules');
+
+    // Build target directory (with optional subdirectory)
+    const targetDir = subdirectory
+      ? join(baseDir, subdirectory)
+      : baseDir;
+
+    // Ensure target directory exists
+    await fsPromises.mkdir(targetDir, { recursive: true });
+
+    // Build complete file path
+    const filePath = join(targetDir, fileName);
+
+    // Check if file already exists
+    if (existsSync(filePath)) {
+      return { error: `Rule '${fileName}' already exists in ${location} location` };
+    }
+
+    // Build complete content with frontmatter if paths provided
+    let completeContent = content;
+    if (paths && paths.length > 0) {
+      const frontmatter = `---
+paths: [${paths.join(', ')}]
+---
+
+`;
+      completeContent = frontmatter + content;
+    }
+
+    // Write rule file
+    await fsPromises.writeFile(filePath, completeContent, 'utf8');
+
+    return {
+      success: true,
+      fileName,
+      location,
+      path: filePath,
+      subdirectory: subdirectory || null
+    };
+  } catch (error) {
+    return { error: (error as Error).message };
+  }
+}
+
+/**
+ * Handle Rules routes
+ * @returns true if route was handled, false otherwise
+ */
+export async function handleRulesRoutes(ctx: RouteContext): Promise<boolean> {
+  const { pathname, url, req, res, initialPath, handlePostRequest } = ctx;
+
+  // API: Get all rules
+  if (pathname === '/api/rules') {
+    const projectPathParam = url.searchParams.get('path') || initialPath;
+    const rulesData = getRulesConfig(projectPathParam);
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(rulesData));
+    return true;
+  }
+
+  // API: Get single rule detail
+  if (pathname.startsWith('/api/rules/') && req.method === 'GET' && !pathname.endsWith('/rules/')) {
+    const ruleName = decodeURIComponent(pathname.replace('/api/rules/', ''));
+    const location = url.searchParams.get('location') || 'project';
+    const projectPathParam = url.searchParams.get('path') || initialPath;
+    const ruleDetail = getRuleDetail(ruleName, location, projectPathParam);
+    if (ruleDetail.error) {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(ruleDetail));
+    } else {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(ruleDetail));
+    }
+    return true;
+  }
+
+  // API: Delete rule
+  if (pathname.startsWith('/api/rules/') && req.method === 'DELETE') {
+    const ruleName = decodeURIComponent(pathname.replace('/api/rules/', ''));
+    handlePostRequest(req, res, async (body) => {
+      const { location, projectPath: projectPathParam } = body;
+      return deleteRule(ruleName, location, projectPathParam || initialPath);
+    });
+    return true;
+  }
+
+  // API: Create rule
+  if (pathname === '/api/rules/create' && req.method === 'POST') {
+    handlePostRequest(req, res, async (body) => {
+      const {
+        mode,
+        fileName,
+        content,
+        paths,
+        location,
+        subdirectory,
+        projectPath: projectPathParam,
+        // CLI generation parameters
+        generationType,
+        description,
+        templateType,
+        extractScope,
+        extractFocus
+      } = body;
+
+      if (!fileName) {
+        return { error: 'File name is required' };
+      }
+
+      if (!location) {
+        return { error: 'Location is required (project or user)' };
+      }
+
+      const projectPath = projectPathParam || initialPath;
+
+      // CLI generation mode
+      if (mode === 'cli-generate') {
+        if (!generationType) {
+          return { error: 'generationType is required for CLI generation mode' };
+        }
+
+        // Validate based on generation type
+        if (generationType === 'description' && !description) {
+          return { error: 'description is required for description-based generation' };
+        }
+
+        if (generationType === 'template' && !templateType) {
+          return { error: 'templateType is required for template-based generation' };
+        }
+
+        return await generateRuleViaCLI({
+          generationType,
+          description,
+          templateType,
+          extractScope,
+          extractFocus,
+          fileName,
+          location,
+          subdirectory: subdirectory || '',
+          projectPath
+        });
+      }
+
+      // Manual creation mode
+      if (!content) {
+        return { error: 'Content is required for manual creation' };
+      }
+
+      return await createRule({
+        fileName,
+        content,
+        paths: paths || [],
+        location,
+        subdirectory: subdirectory || '',
+        projectPath
+      });
+    });
+    return true;
+  }
+
+  return false;
+}