ai-control-center 1.15.2

package/lib/utils/codebase-indexer.js

@@ -0,0 +1,381 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync } from 'fs';
+import { join, extname, relative } from 'path';
+import { execSync } from 'child_process';
+
+const WORKFLOW_DIR = '.ai-workflow';
+const INDEX_FILE = join(WORKFLOW_DIR, 'codebase-index.json');
+const MAX_DEPTH = 4;
+const MAX_FILE_SIZE = 50000; // 50KB max per file for indexing
+
+// File extensions to analyze
+const CODE_EXTENSIONS = new Set([
+  '.js', '.ts', '.jsx', '.tsx', '.py', '.rb', '.go', '.rs', '.java',
+  '.c', '.cpp', '.h', '.hpp', '.cs', '.php', '.swift', '.kt',
+  '.vue', '.svelte', '.html', '.css', '.scss', '.less',
+  '.json', '.yaml', '.yml', '.toml', '.xml',
+  '.md', '.mdx', '.txt',
+  '.sql', '.graphql', '.proto',
+  '.sh', '.bash', '.zsh', '.fish',
+  '.dockerfile', '.env',
+]);
+
+const IGNORE_DIRS = new Set([
+  'node_modules', '.git', 'dist', 'build', 'out', '.next', '.nuxt',
+  'coverage', '.nyc_output', '__pycache__', '.pytest_cache',
+  '.ai-workflow', '.vscode', '.idea', 'vendor', 'target',
+]);
+
+export function getFileTree(dir, depth = 0, maxDepth = MAX_DEPTH) {
+  if (depth > maxDepth) return [];
+  const entries = [];
+  try {
+    const items = readdirSync(dir);
+    for (const item of items) {
+      if (item.startsWith('.') && depth === 0 && item !== '.env.example') continue;
+      if (IGNORE_DIRS.has(item)) continue;
+
+      const fullPath = join(dir, item);
+      try {
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+          const children = getFileTree(fullPath, depth + 1, maxDepth);
+          entries.push({ name: item, type: 'dir', children, path: relative(process.cwd(), fullPath) });
+        } else if (stat.isFile()) {
+          const ext = extname(item).toLowerCase();
+          entries.push({
+            name: item,
+            type: 'file',
+            size: stat.size,
+            ext,
+            path: relative(process.cwd(), fullPath),
+          });
+        }
+      } catch { /* permission error, skip */ }
+    }
+  } catch { /* directory read error */ }
+  return entries;
+}
+
+export function readPackageJson(dir) {
+  const pkgPath = join(dir, 'package.json');
+  if (!existsSync(pkgPath)) return null;
+  try {
+    return JSON.parse(readFileSync(pkgPath, 'utf8'));
+  } catch { return null; }
+}
+
+export function getRecentCommits(count = 20) {
+  try {
+    const log = execSync(`git log --oneline -${count} --no-color 2>/dev/null`, {
+      encoding: 'utf8', timeout: 5000,
+    });
+    return log.trim().split('\n').filter(Boolean);
+  } catch { return []; }
+}
+
+export function detectEntryPoints(tree) {
+  const entryNames = ['index.js', 'index.ts', 'main.js', 'main.ts', 'app.js', 'app.ts',
+    'server.js', 'server.ts', 'cli.js', 'cli.ts'];
+  const entries = [];
+
+  function walk(items, prefix = '') {
+    for (const item of items) {
+      if (item.type === 'file' && entryNames.includes(item.name)) {
+        entries.push(item.path);
+      }
+      if (item.children) walk(item.children, join(prefix, item.name));
+    }
+  }
+  walk(tree);
+  return entries;
+}
+
+export function extractDependencies(packageJson) {
+  if (!packageJson) return { production: [], dev: [] };
+  return {
+    production: Object.keys(packageJson.dependencies || {}),
+    dev: Object.keys(packageJson.devDependencies || {}),
+  };
+}
+
+export function detectModules(tree) {
+  const modules = [];
+  function walk(items) {
+    for (const item of items) {
+      if (item.type === 'dir' && item.children && item.children.length > 0) {
+        const files = item.children.filter(c => c.type === 'file');
+        const hasIndex = files.some(f => f.name.startsWith('index.'));
+        if (hasIndex || files.length >= 2) {
+          modules.push({
+            name: item.name,
+            path: item.path,
+            files: files.map(f => f.name),
+            fileCount: files.length,
+          });
+        }
+        walk(item.children);
+      }
+    }
+  }
+  walk(tree);
+  return modules;
+}
+
+export function detectAPIEndpoints(tree) {
+  const apiFiles = [];
+  function walk(items) {
+    for (const item of items) {
+      if (item.type === 'file' && (
+        item.name.includes('route') || item.name.includes('api') ||
+        item.name.includes('controller') || item.name.includes('endpoint')
+      )) {
+        apiFiles.push(item.path);
+      }
+      if (item.children) walk(item.children);
+    }
+  }
+  walk(tree);
+
+  const endpoints = [];
+  for (const filePath of apiFiles.slice(0, 10)) {
+    try {
+      const content = readFileSync(filePath, 'utf8');
+      const routePatterns = [
+        /\.(get|post|put|delete|patch)\s*\(\s*['"`]([^'"`]+)['"`]/gi,
+        /router\.(get|post|put|delete|patch)\s*\(\s*['"`]([^'"`]+)['"`]/gi,
+        /@(Get|Post|Put|Delete|Patch)\s*\(\s*['"`]([^'"`]*)['"`]\s*\)/gi,
+      ];
+      for (const pattern of routePatterns) {
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+          endpoints.push({ method: match[1].toUpperCase(), path: match[2], file: filePath });
+        }
+      }
+    } catch { /* skip unreadable */ }
+  }
+  return endpoints;
+}
+
+export function extractFileExports(filePath) {
+  try {
+    const content = readFileSync(filePath, 'utf8');
+    if (content.length > MAX_FILE_SIZE) return [];
+    const exports = [];
+    const exportPatterns = [
+      /export\s+(async\s+)?function\s+(\w+)/g,
+      /export\s+(const|let|var)\s+(\w+)/g,
+      /export\s+class\s+(\w+)/g,
+      /export\s+default\s+(class|function)\s*(\w*)/g,
+    ];
+    for (const pattern of exportPatterns) {
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const name = match[2] || match[1];
+        if (name && name !== 'async') exports.push(name);
+      }
+    }
+    return exports;
+  } catch { return []; }
+}
+
+export function generateSummary(tree, packageJson) {
+  const flatFiles = [];
+  function walk(items) {
+    for (const item of items) {
+      if (item.type === 'file') flatFiles.push(item);
+      if (item.children) walk(item.children);
+    }
+  }
+  walk(tree);
+
+  const byExt = {};
+  for (const f of flatFiles) {
+    const ext = f.ext || 'other';
+    byExt[ext] = (byExt[ext] || 0) + 1;
+  }
+
+  return {
+    totalFiles: flatFiles.length,
+    totalSize: flatFiles.reduce((s, f) => s + (f.size || 0), 0),
+    byExtension: byExt,
+    languages: detectLanguages(byExt),
+    framework: detectFramework(packageJson),
+  };
+}
+
+function detectLanguages(byExt) {
+  const langs = [];
+  if (byExt['.js'] || byExt['.jsx']) langs.push('JavaScript');
+  if (byExt['.ts'] || byExt['.tsx']) langs.push('TypeScript');
+  if (byExt['.py']) langs.push('Python');
+  if (byExt['.go']) langs.push('Go');
+  if (byExt['.rs']) langs.push('Rust');
+  if (byExt['.java'] || byExt['.kt']) langs.push('Java/Kotlin');
+  if (byExt['.rb']) langs.push('Ruby');
+  if (byExt['.php']) langs.push('PHP');
+  return langs;
+}
+
+function detectFramework(pkg) {
+  if (!pkg) return 'unknown';
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  if (deps['next']) return 'Next.js';
+  if (deps['nuxt']) return 'Nuxt';
+  if (deps['@angular/core']) return 'Angular';
+  if (deps['react']) return 'React';
+  if (deps['vue']) return 'Vue';
+  if (deps['svelte']) return 'Svelte';
+  if (deps['express']) return 'Express';
+  if (deps['fastify']) return 'Fastify';
+  if (deps['django']) return 'Django';
+  if (deps['flask']) return 'Flask';
+  return 'Node.js';
+}
+
+export async function indexCodebase(projectDir = process.cwd()) {
+  const tree = getFileTree(projectDir);
+  const packageJson = readPackageJson(projectDir);
+  const gitLog = getRecentCommits(20);
+  const entryPoints = detectEntryPoints(tree);
+  const dependencies = extractDependencies(packageJson);
+  const modules = detectModules(tree);
+  const apis = detectAPIEndpoints(tree);
+  const summary = generateSummary(tree, packageJson);
+
+  const index = {
+    generatedAt: new Date().toISOString(),
+    projectDir: relative(process.cwd(), projectDir) || '.',
+    summary,
+    tree,
+    packageJson: packageJson ? {
+      name: packageJson.name,
+      version: packageJson.version,
+      description: packageJson.description,
+      scripts: Object.keys(packageJson.scripts || {}),
+    } : null,
+    gitLog,
+    entryPoints,
+    dependencies,
+    modules,
+    apis,
+  };
+
+  if (!existsSync(WORKFLOW_DIR)) mkdirSync(WORKFLOW_DIR, { recursive: true });
+  writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2));
+  return index;
+}
+
+export function loadIndex() {
+  if (!existsSync(INDEX_FILE)) return null;
+  try {
+    return JSON.parse(readFileSync(INDEX_FILE, 'utf8'));
+  } catch { return null; }
+}
+
+export function isIndexStale(maxAgeMs = 3600000) {
+  if (!existsSync(INDEX_FILE)) return true;
+  try {
+    const index = JSON.parse(readFileSync(INDEX_FILE, 'utf8'));
+    const age = Date.now() - new Date(index.generatedAt).getTime();
+    return age > maxAgeMs;
+  } catch { return true; }
+}
+
+export function searchIndex(query, index = null) {
+  if (!index) index = loadIndex();
+  if (!index) return { results: [], message: 'No index found. Run: aicc index' };
+
+  const q = query.toLowerCase();
+  const results = [];
+
+  function walkTree(items) {
+    for (const item of items) {
+      if (item.name && item.name.toLowerCase().includes(q)) {
+        results.push({ type: 'file', name: item.name, path: item.path });
+      }
+      if (item.children) walkTree(item.children);
+    }
+  }
+  walkTree(index.tree || []);
+
+  for (const mod of (index.modules || [])) {
+    if (mod.name.toLowerCase().includes(q)) {
+      results.push({ type: 'module', name: mod.name, path: mod.path, files: mod.files });
+    }
+  }
+
+  for (const api of (index.apis || [])) {
+    if (api.path.toLowerCase().includes(q)) {
+      results.push({ type: 'api', method: api.method, path: api.path, file: api.file });
+    }
+  }
+
+  const allDeps = [...(index.dependencies?.production || []), ...(index.dependencies?.dev || [])];
+  for (const dep of allDeps) {
+    if (dep.toLowerCase().includes(q)) {
+      results.push({ type: 'dependency', name: dep });
+    }
+  }
+
+  return { results, total: results.length };
+}
+
+export function formatIndexSummary(index) {
+  if (!index) return 'No codebase index found. Run: aicc index';
+  const s = index.summary || {};
+  const lines = [
+    `📊 Codebase Index (${index.generatedAt})`,
+    `   Project: ${index.packageJson?.name || 'unknown'} v${index.packageJson?.version || '?'}`,
+    `   Framework: ${s.framework || 'unknown'}`,
+    `   Languages: ${(s.languages || []).join(', ') || 'unknown'}`,
+    `   Files: ${s.totalFiles || 0} (${((s.totalSize || 0) / 1024).toFixed(0)} KB)`,
+    `   Entry points: ${(index.entryPoints || []).join(', ') || 'none'}`,
+    `   Modules: ${(index.modules || []).length}`,
+    `   API endpoints: ${(index.apis || []).length}`,
+    `   Dependencies: ${(index.dependencies?.production || []).length} prod, ${(index.dependencies?.dev || []).length} dev`,
+    `   Recent commits: ${(index.gitLog || []).length}`,
+  ];
+  return lines.join('\n');
+}
+
+export function getCompactContext(index = null) {
+  if (!index) index = loadIndex();
+  if (!index) return '';
+
+  const sections = [];
+
+  if (index.packageJson) {
+    sections.push(`Project: ${index.packageJson.name} v${index.packageJson.version}`);
+    if (index.packageJson.description) sections.push(`Description: ${index.packageJson.description}`);
+    sections.push(`Scripts: ${(index.packageJson.scripts || []).join(', ')}`);
+  }
+
+  function treeToString(items, indent = '') {
+    return items.map(item => {
+      if (item.type === 'dir') {
+        const children = item.children ? treeToString(item.children, indent + '  ') : '';
+        return `${indent}${item.name}/\n${children}`;
+      }
+      return `${indent}${item.name}`;
+    }).join('\n');
+  }
+  sections.push('File Structure:\n' + treeToString(index.tree));
+
+  if (index.modules?.length > 0) {
+    sections.push('Modules: ' + index.modules.map(m => `${m.name} (${m.fileCount} files)`).join(', '));
+  }
+
+  if (index.apis?.length > 0) {
+    sections.push('API Endpoints:\n' + index.apis.map(a => `  ${a.method} ${a.path} → ${a.file}`).join('\n'));
+  }
+
+  if (index.dependencies?.production?.length > 0) {
+    sections.push('Dependencies: ' + index.dependencies.production.slice(0, 20).join(', '));
+  }
+
+  if (index.gitLog?.length > 0) {
+    sections.push('Recent commits:\n' + index.gitLog.slice(0, 10).map(c => `  ${c}`).join('\n'));
+  }
+
+  return sections.join('\n\n');
+}

package/lib/utils/config-schema.js

@@ -0,0 +1,230 @@
+/**
+ * JSON Schema validation for aicc.config.js
+ */
+
+export const CONFIG_SCHEMA = {
+  name: { type: 'string', description: 'Project name' },
+  sourceDir: { type: 'string', description: 'Source directory' },
+  framework: { type: 'string', description: 'Project framework' },
+  deployCommand: { type: 'string', description: 'Deploy shell command' },
+  testCommand: { type: 'string', description: 'Test shell command' },
+  models: {
+    type: 'object',
+    description: 'AI model configuration',
+    properties: {
+      gemini: { type: 'string', description: 'Gemini model identifier' },
+      claude: { type: 'string', description: 'Claude model identifier' },
+      copilot: { type: 'string', description: 'Copilot model identifier' },
+      ollama: { type: 'string', description: 'Ollama model identifier' },
+      tokenLimits: {
+        type: 'object',
+        description: 'Token limits per persona',
+        properties: {
+          pm: { type: 'number', description: 'Token limit for PM persona' },
+          explore: { type: 'number', description: 'Token limit for explore persona' },
+          arch: { type: 'number', description: 'Token limit for architect persona' },
+          impl: { type: 'number', description: 'Token limit for implementation persona' },
+          review: { type: 'number', description: 'Token limit for review persona' },
+          chat: { type: 'number', description: 'Token limit for chat persona' },
+        },
+      },
+    },
+  },
+  pipeline: {
+    type: 'object',
+    description: 'Pipeline configuration',
+    properties: {
+      stages: { type: 'array', items: 'string', description: 'Pipeline stage names' },
+      autoReview: { type: 'boolean', description: 'Enable automatic code review' },
+      maxReviewCycles: { type: 'number', description: 'Maximum review iterations' },
+    },
+  },
+  hub: {
+    type: 'object',
+    description: 'Hub configuration for multi-project management',
+    properties: {
+      enabled: { type: 'boolean', description: 'Enable hub mode' },
+      port: { type: 'number', description: 'Hub server port' },
+      pollInterval: { type: 'number', description: 'Polling interval in milliseconds' },
+      projects: {
+        type: 'array',
+        description: 'Hub project entries',
+        items: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Project name' },
+            url: { type: 'string', description: 'Project URL' },
+            color: { type: 'string', description: 'Display color' },
+            icon: { type: 'string', description: 'Display icon' },
+          },
+        },
+      },
+    },
+  },
+  rbac: {
+    type: 'object',
+    description: 'Role-based access control',
+    properties: {
+      users: { type: 'object', description: 'Map of userId to role' },
+      apiKeys: { type: 'object', description: 'Map of API key to role' },
+      defaultRole: { type: 'string', description: 'Default role for unauthenticated users' },
+    },
+  },
+  webhooks: {
+    type: 'array',
+    description: 'Webhook configurations',
+    items: {
+      type: 'object',
+      properties: {
+        url: { type: 'string', description: 'Webhook endpoint URL' },
+        events: { type: 'array', items: 'string', description: 'Events to trigger on' },
+        secret: { type: 'string', description: 'Webhook signing secret' },
+      },
+    },
+  },
+  mcp: {
+    type: 'object',
+    description: 'MCP server configuration',
+    properties: {
+      servers: {
+        type: 'array',
+        description: 'MCP server entries',
+        items: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Server name' },
+            command: { type: 'string', description: 'Server command' },
+            args: { type: 'array', items: 'string', description: 'Command arguments' },
+          },
+        },
+      },
+    },
+  },
+  customQueries: {
+    type: 'object',
+    description: 'Custom query definitions',
+    properties: {},
+    additionalProperties: {
+      type: 'object',
+      properties: {
+        label: { type: 'string', description: 'Display label' },
+        command: { type: 'string', description: 'Shell command to execute' },
+      },
+    },
+  },
+};
+
+function validateValue(value, schema, path) {
+  const errors = [];
+
+  if (schema.type === 'string') {
+    if (typeof value !== 'string') {
+      errors.push(`Invalid config at '${path}': expected string, got ${typeof value}`);
+    }
+  } else if (schema.type === 'number') {
+    if (typeof value !== 'number') {
+      errors.push(`Invalid config at '${path}': expected number, got ${typeof value}`);
+    }
+  } else if (schema.type === 'boolean') {
+    if (typeof value !== 'boolean') {
+      errors.push(`Invalid config at '${path}': expected boolean, got ${typeof value}`);
+    }
+  } else if (schema.type === 'array') {
+    if (!Array.isArray(value)) {
+      errors.push(`Invalid config at '${path}': expected array, got ${typeof value}`);
+    } else if (schema.items) {
+      for (let i = 0; i < value.length; i++) {
+        if (typeof schema.items === 'string') {
+          if (typeof value[i] !== schema.items) {
+            errors.push(`Invalid config at '${path}[${i}]': expected ${schema.items}, got ${typeof value[i]}`);
+          }
+        } else {
+          errors.push(...validateValue(value[i], schema.items, `${path}[${i}]`));
+        }
+      }
+    }
+  } else if (schema.type === 'object') {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+      errors.push(`Invalid config at '${path}': expected object, got ${Array.isArray(value) ? 'array' : typeof value}`);
+    } else if (schema.properties) {
+      for (const [key, val] of Object.entries(value)) {
+        if (schema.properties[key]) {
+          errors.push(...validateValue(val, schema.properties[key], `${path}.${key}`));
+        } else if (schema.additionalProperties) {
+          errors.push(...validateValue(val, schema.additionalProperties, `${path}.${key}`));
+        }
+      }
+    }
+  }
+
+  return errors;
+}
+
+export function validateConfig(config) {
+  if (typeof config !== 'object' || config === null || Array.isArray(config)) {
+    return { valid: false, errors: ['Config must be a plain object'] };
+  }
+
+  const errors = [];
+
+  for (const [key, value] of Object.entries(config)) {
+    const fieldSchema = CONFIG_SCHEMA[key];
+    if (!fieldSchema) {
+      continue; // allow unknown top-level fields
+    }
+
+    if (fieldSchema.type) {
+      errors.push(...validateValue(value, fieldSchema, key));
+    } else {
+      // top-level simple field
+      if (typeof value !== fieldSchema.type) {
+        errors.push(`Invalid config at '${key}': expected ${fieldSchema.type}, got ${typeof value}`);
+      }
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+export function getDefaultConfig() {
+  return {
+    name: 'my-project',
+    sourceDir: 'src',
+    framework: 'node',
+    testCommand: 'npm test',
+    deployCommand: 'npm run build',
+    models: {
+      gemini: 'gemini-2.5-pro',
+      claude: 'claude-sonnet-4-6',
+    },
+    pipeline: {
+      stages: ['inbox', 'spec', 'architecture', 'implementation', 'review', 'approved', 'deployed'],
+      autoReview: true,
+      maxReviewCycles: 3,
+    },
+  };
+}
+
+export function describeField(path) {
+  const parts = path.split('.');
+  let current = CONFIG_SCHEMA;
+
+  for (const part of parts) {
+    if (!current) return null;
+
+    if (current.properties && current.properties[part]) {
+      current = current.properties[part];
+    } else if (current[part]) {
+      current = current[part];
+    } else {
+      return null;
+    }
+  }
+
+  if (!current) return null;
+
+  return {
+    type: current.type || 'unknown',
+    description: current.description || '',
+  };
+}