contextforge-cli-ai-prompt-pirates 0.4.0

package/src/analyzers/ast-parser.js

@@ -0,0 +1,139 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+
+let parseFn = null;
+
+async function getParser() {
+  if (parseFn) return parseFn;
+  try {
+    const babel = await import('@babel/parser');
+    parseFn = babel.parse;
+    return parseFn;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * AST-based route and export extraction (accurate vs regex).
+ * @param {string} projectRoot
+ * @param {string[]} relativePaths
+ */
+export async function parseSourceFilesAst(projectRoot, relativePaths) {
+  const parse = await getParser();
+  if (!parse) {
+    return { available: false, routes: [], exports: [], parseErrors: [] };
+  }
+
+  const routes = [];
+  const exports = [];
+  const parseErrors = [];
+
+  const files = relativePaths
+    .filter((p) => /\.(js|jsx|ts|tsx|mjs|cjs)$/.test(p))
+    .filter((p) => !p.includes('node_modules') && !p.includes('.test.'))
+    .slice(0, 100);
+
+  for (const rel of files) {
+    const full = path.join(projectRoot, rel);
+    let content;
+    try {
+      content = await fs.readFile(full, 'utf8');
+    } catch {
+      continue;
+    }
+
+    const plugins = ['typescript', 'jsx'];
+    if (rel.endsWith('.js') || rel.endsWith('.mjs') || rel.endsWith('.cjs')) {
+      plugins.length = 0;
+      plugins.push('jsx');
+    }
+
+    let ast;
+    try {
+      ast = parse(content, {
+        sourceType: 'module',
+        plugins,
+        errorRecovery: true,
+      });
+    } catch (e) {
+      parseErrors.push({ file: rel, message: e.message?.slice(0, 80) });
+      continue;
+    }
+
+    walkAst(ast, rel, routes, exports);
+  }
+
+  return {
+    available: true,
+    routes: dedupeRoutes(routes),
+    exports: exports.slice(0, 50),
+    parseErrors: parseErrors.slice(0, 10),
+    filesParsed: files.length,
+  };
+}
+
+function walkAst(node, file, routes, exports, parent = null) {
+  if (!node || typeof node !== 'object') return;
+
+  if (node.type === 'CallExpression' && node.callee) {
+    const method = getCalleeMethod(node.callee);
+    if (method && node.arguments?.[0]) {
+      const routePath = getStringArg(node.arguments[0]);
+      if (routePath) {
+        routes.push({ method: method.toUpperCase(), path: routePath, file, source: 'ast' });
+      }
+    }
+  }
+
+  if (
+    node.type === 'ExportNamedDeclaration' &&
+    node.declaration?.type === 'FunctionDeclaration' &&
+    node.declaration.id?.name
+  ) {
+    exports.push({ name: node.declaration.id.name, file, type: 'function' });
+  }
+
+  if (node.type === 'ExportNamedDeclaration' && node.specifiers) {
+    for (const spec of node.specifiers) {
+      if (spec.exported?.name) {
+        exports.push({ name: spec.exported.name, file, type: 'export' });
+      }
+    }
+  }
+
+  for (const key of Object.keys(node)) {
+    const child = node[key];
+    if (Array.isArray(child)) {
+      child.forEach((c) => walkAst(c, file, routes, exports, node));
+    } else if (child && typeof child === 'object' && child.type) {
+      walkAst(child, file, routes, exports, node);
+    }
+  }
+}
+
+function getCalleeMethod(callee) {
+  if (callee.type === 'MemberExpression' && callee.property?.name) {
+    const m = callee.property.name.toLowerCase();
+    if (['get', 'post', 'put', 'patch', 'delete', 'all', 'use'].includes(m)) return m;
+  }
+  return null;
+}
+
+function getStringArg(arg) {
+  if (arg.type === 'StringLiteral') return arg.value;
+  if (arg.type === 'TemplateLiteral' && arg.quasis?.[0]) {
+    return arg.quasis[0].value.cooked || arg.quasis[0].value.raw;
+  }
+  return null;
+}
+
+function dedupeRoutes(routes) {
+  const seen = new Set();
+  return routes.filter((r) => {
+    const k = `${r.method}:${r.path}:${r.file}`;
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+}

package/src/analyzers/bugs-lite.js

@@ -0,0 +1,118 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+
+const ASYNC_NO_CATCH = /async\s+function|\basync\s*\(/;
+const TRY_CATCH = /\btry\s*\{/;
+
+/**
+ * @param {string} projectRoot
+ * @param {{ relativePaths: string[] }} scanResult
+ */
+export async function runBugsLite(projectRoot, scanResult, _config) {
+  const issues = [];
+
+  const sourceFiles = scanResult.relativePaths.filter(
+    (p) => /\.(js|jsx|ts|tsx)$/.test(p) && !p.includes('node_modules') && !p.includes('.test.')
+  );
+
+  const contentCache = new Map();
+
+  for (const rel of sourceFiles.slice(0, 80)) {
+    const full = path.join(projectRoot, rel);
+    try {
+      const content = await fs.readFile(full, 'utf8');
+      contentCache.set(rel, content);
+
+      if (ASYNC_NO_CATCH.test(content) && !TRY_CATCH.test(content) && content.length > 200) {
+        if (rel.includes('service') || rel.includes('controller') || rel.includes('api')) {
+          issues.push({
+            severity: 'medium',
+            type: 'missing-error-handling',
+            file: rel,
+            message: 'Async code without try/catch in service/controller layer',
+          });
+        }
+      }
+
+      if (/\beval\s*\(/.test(content) && !/\/\\beval|RegExp|\.test\(content\)/.test(content)) {
+        const lines = content.split('\n').filter((line) => /\beval\s*\(/.test(line) && !/^\s*\/\//.test(line));
+        if (lines.some((line) => !line.includes('RegExp') && !line.includes('/.test'))) {
+          issues.push({
+            severity: 'high',
+            type: 'security',
+            file: rel,
+            message: 'Use of eval() detected',
+          });
+        }
+      }
+
+      if (/console\.log\(/.test(content) && !rel.includes('test')) {
+        const count = (content.match(/console\.log\(/g) || []).length;
+        if (count > 5) {
+          issues.push({
+            severity: 'low',
+            type: 'cleanup',
+            file: rel,
+            message: `Many console.log statements (${count}) — consider removing for production`,
+          });
+        }
+      }
+    } catch {
+      /* skip */
+    }
+  }
+
+  const validationSnippets = [];
+  for (const [rel, content] of contentCache) {
+    if (/\.validate\(|Joi\.|zod\.|yup\./i.test(content)) {
+      const snippet = content.match(/\.validate\([^)]+\)|Joi\.\w+|z\.object/g);
+      if (snippet) validationSnippets.push({ file: rel, patterns: snippet.slice(0, 3) });
+    }
+  }
+
+  if (validationSnippets.length >= 3) {
+    const files = validationSnippets.map((v) => v.file);
+    const unique = new Set(files);
+    if (unique.size >= 2) {
+      issues.push({
+        severity: 'low',
+        type: 'duplicate-logic',
+        file: files.join(', '),
+        message: 'Duplicate validation patterns may exist across multiple controllers',
+      });
+    }
+  }
+
+  const eslintConfig = scanResult.relativePaths.find(
+    (p) => /^\.eslintrc/i.test(path.basename(p)) || p.endsWith('eslint.config.js')
+  );
+
+  if (eslintConfig) {
+    issues.push({
+      severity: 'info',
+      type: 'tooling',
+      file: eslintConfig,
+      message: 'ESLint config present — run eslint for deeper analysis',
+    });
+  }
+
+  const unusedCandidates = scanResult.relativePaths.filter(
+    (p) => p.includes('/old/') || p.includes('.backup') || p.includes('.bak')
+  );
+  for (const rel of unusedCandidates) {
+    issues.push({
+      severity: 'low',
+      type: 'dead-code',
+      file: rel,
+      message: 'Possibly unused or legacy file path',
+    });
+  }
+
+  return {
+    issues: issues.slice(0, 25),
+    summary:
+      issues.length === 0
+        ? 'No significant issues detected by heuristic scan.'
+        : `Found ${issues.length} potential issue(s) via static heuristics.`,
+  };
+}

package/src/analyzers/changelog.js

@@ -0,0 +1,190 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import { getOutputPath, OUTPUT_FILES, getCacheDir } from '../core/paths.js';
+
+function getChangesHistoryPath(projectRoot) {
+  return path.join(getCacheDir(projectRoot), 'changes-history.json');
+}
+
+/**
+ * Compare file hashes between previous index and current scan.
+ */
+export function computeFileDiff(previousIndex, scannedFiles) {
+  const prevFiles = previousIndex?.files || {};
+  const currentMap = Object.fromEntries(
+    scannedFiles.map((f) => [f.relativePath, f])
+  );
+
+  const added = [];
+  const removed = [];
+  const modified = [];
+
+  for (const f of scannedFiles) {
+    const prev = prevFiles[f.relativePath];
+    if (!prev) added.push(f.relativePath);
+    else if (prev.hash !== f.hash) modified.push(f.relativePath);
+  }
+
+  for (const rel of Object.keys(prevFiles)) {
+    if (!currentMap[rel]) removed.push(rel);
+  }
+
+  return {
+    added: added.sort(),
+    removed: removed.sort(),
+    modified: modified.sort(),
+    hasFileChanges: added.length + removed.length + modified.length > 0,
+  };
+}
+
+/**
+ * Compare current snapshot with previous context.json + file diff.
+ */
+export async function computeChangelog(projectRoot, currentSnapshot, fileDiff = null) {
+  const jsonPath = getOutputPath(projectRoot, OUTPUT_FILES.contextJson);
+  const now = new Date().toISOString();
+
+  const changes = {
+    runAt: now,
+    hasPrevious: false,
+    hasChanges: false,
+    techStackChanged: [],
+    architectureChanged: null,
+    filesScannedDelta: 0,
+    newBugs: 0,
+    bugsResolved: 0,
+    addedFiles: fileDiff?.added || [],
+    removedFiles: fileDiff?.removed || [],
+    modifiedFiles: fileDiff?.modified || [],
+    summary: 'First generation — no previous snapshot to compare.',
+    details: [],
+  };
+
+  if (fileDiff?.hasFileChanges) {
+    changes.hasChanges = true;
+    if (fileDiff.added.length) {
+      changes.details.push(`${fileDiff.added.length} new file(s)`);
+    }
+    if (fileDiff.modified.length) {
+      changes.details.push(`${fileDiff.modified.length} modified file(s)`);
+      const codeFiles = fileDiff.modified.filter((p) =>
+        /\.(js|jsx|ts|tsx|mjs|cjs|vue|svelte|py|go|rs|java|php)$/.test(p)
+      );
+      if (codeFiles.length) {
+        changes.details.push(`${codeFiles.length} code file(s) edited`);
+      }
+    }
+    if (fileDiff.removed.length) {
+      changes.details.push(`${fileDiff.removed.length} removed file(s)`);
+    }
+  }
+
+  if (!(await fs.pathExists(jsonPath))) {
+    await appendChangesHistory(projectRoot, changes);
+    return changes;
+  }
+
+  let previous;
+  try {
+    previous = await fs.readJson(jsonPath);
+  } catch {
+    await appendChangesHistory(projectRoot, changes);
+    return changes;
+  }
+
+  changes.hasPrevious = true;
+  changes.previousRunAt = previous.generatedAt;
+
+  const prevTs = previous.techStack || {};
+  const curTs = currentSnapshot.techStack || {};
+  const categories = ['frontend', 'backend', 'database', 'orm', 'auth', 'state'];
+
+  for (const cat of categories) {
+    const prev = new Set(prevTs[cat] || []);
+    const cur = curTs[cat] || [];
+    for (const item of cur) {
+      if (!prev.has(item)) {
+        changes.techStackChanged.push(`+${cat}: ${item}`);
+        changes.hasChanges = true;
+      }
+    }
+    for (const item of prev) {
+      if (!cur.includes(item)) {
+        changes.techStackChanged.push(`-${cat}: ${item}`);
+        changes.hasChanges = true;
+      }
+    }
+  }
+
+  const prevArch = previous.architecture?.primary?.label;
+  const curArch = currentSnapshot.architecture?.primary?.label;
+  if (prevArch !== curArch) {
+    changes.architectureChanged = `${prevArch || 'unknown'} → ${curArch || 'unknown'}`;
+    changes.hasChanges = true;
+  }
+
+  changes.filesScannedDelta =
+    (currentSnapshot.filesScanned || 0) - (previous.filesScanned || 0);
+  if (changes.filesScannedDelta !== 0) changes.hasChanges = true;
+
+  const prevBugCount = previous.bugs?.issues?.length || 0;
+  const curBugCount = currentSnapshot.bugs?.issues?.length || 0;
+  changes.newBugs = Math.max(0, curBugCount - prevBugCount);
+  changes.bugsResolved = Math.max(0, prevBugCount - curBugCount);
+  if (changes.newBugs > 0) changes.hasChanges = true;
+
+  const parts = [];
+  if (changes.hasChanges) {
+    if (changes.details.length) parts.push(changes.details.join(', '));
+    if (changes.techStackChanged.length) {
+      parts.push(`Tech: ${changes.techStackChanged.join('; ')}`);
+    }
+    if (changes.architectureChanged) {
+      parts.push(`Architecture: ${changes.architectureChanged}`);
+    }
+    if (changes.filesScannedDelta !== 0) {
+      parts.push(`Files scanned: ${changes.filesScannedDelta > 0 ? '+' : ''}${changes.filesScannedDelta}`);
+    }
+    if (changes.newBugs > 0) parts.push(`New issues: +${changes.newBugs}`);
+    changes.summary = parts.join('. ');
+  } else {
+    changes.summary = 'No changes detected since last run.';
+  }
+
+  await appendChangesHistory(projectRoot, changes);
+  return changes;
+}
+
+async function appendChangesHistory(projectRoot, entry) {
+  const historyPath = getChangesHistoryPath(projectRoot);
+  let history = { runs: [] };
+  if (await fs.pathExists(historyPath)) {
+    try {
+      history = await fs.readJson(historyPath);
+    } catch {
+      history = { runs: [] };
+    }
+  }
+
+  history.runs.unshift({
+    runAt: entry.runAt,
+    hasChanges: entry.hasChanges,
+    summary: entry.summary,
+    added: entry.addedFiles?.length || 0,
+    modified: entry.modifiedFiles?.length || 0,
+    removed: entry.removedFiles?.length || 0,
+    techStackChanged: entry.techStackChanged?.length || 0,
+  });
+
+  history.runs = history.runs.slice(0, 50);
+  await fs.writeJson(historyPath, history, { spaces: 2 });
+}
+
+export async function loadChangesHistory(projectRoot, limit = 10) {
+  const historyPath = getChangesHistoryPath(projectRoot);
+  if (!(await fs.pathExists(historyPath))) {
+    return { runs: [] };
+  }
+  const data = await fs.readJson(historyPath);
+  return { runs: (data.runs || []).slice(0, limit) };
+}

package/src/analyzers/code-insights.js

@@ -0,0 +1,225 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+
+const EXPORT_FN = /export\s+(?:async\s+)?(?:function|const)\s+(\w+)/g;
+const ROUTE_PATTERNS = [
+  /router\.(get|post|put|patch|delete)\s*\(\s*['"`]([^'"`]+)['"`]/gi,
+  /app\.(get|post|put|patch|delete)\s*\(\s*['"`]([^'"`]+)['"`]/gi,
+  /\.route\s*\(\s*['"`]([^'"`]+)['"`]/gi,
+];
+const COMPONENT_RE = /export\s+(?:default\s+)?function\s+(\w+)|export\s+const\s+(\w+)\s*=/g;
+
+/**
+ * Deep code structure analysis for business logic & API context (§7.5).
+ * @param {string} projectRoot
+ * @param {{ relativePaths: string[] }} scanResult
+ * @param {object} configFiles
+ */
+export async function analyzeCodeInsights(projectRoot, scanResult, configFiles, astResult = null) {
+  const normalized = scanResult.relativePaths.map((p) => p.replace(/\\/g, '/'));
+
+  const structure = detectProjectStructure(normalized);
+  const modules = {
+    routes: [],
+    controllers: [],
+    services: [],
+    middleware: [],
+    models: [],
+    components: [],
+    hooks: [],
+    utils: [],
+    apiHandlers: [],
+  };
+
+  const businessLogic = [];
+  const apiEndpoints = [];
+  const patterns = [];
+  const importantRules = [];
+
+  const sourceFiles = normalized.filter(
+    (p) => /\.(js|jsx|ts|tsx|mjs|cjs)$/.test(p) && !p.includes('node_modules') && !p.includes('.test.')
+  );
+
+  for (const rel of sourceFiles.slice(0, 120)) {
+    const full = path.join(projectRoot, rel);
+    let content;
+    try {
+      content = await fs.readFile(full, 'utf8');
+    } catch {
+      continue;
+    }
+
+    categorizeFile(rel, content, modules);
+
+    for (const re of ROUTE_PATTERNS) {
+      re.lastIndex = 0;
+      let m;
+      while ((m = re.exec(content)) !== null) {
+        const method = (m[1] || 'route').toUpperCase();
+        const routePath = m[2] || m[1];
+        apiEndpoints.push({ method, path: routePath, file: rel });
+      }
+    }
+
+    if (/\/api\/|pages\/api\//i.test(rel)) {
+      apiEndpoints.push({ method: 'API', path: rel, file: rel });
+    }
+
+    let exp;
+    EXPORT_FN.lastIndex = 0;
+    while ((exp = EXPORT_FN.exec(content)) !== null) {
+      if (rel.includes('services/') || rel.includes('service.')) {
+        businessLogic.push({ type: 'service', name: exp[1], file: rel });
+      }
+    }
+
+    if (content.includes('useEffect') || content.includes('useState')) {
+      patterns.push('React hooks usage');
+    }
+    if (/\btry\s*\{/.test(content) && /catch\s*\(/.test(content)) {
+      if (rel.includes('service') || rel.includes('controller')) {
+        patterns.push(`Error handling in ${path.basename(rel)}`);
+      }
+    }
+    if (/\.interceptors\.(request|response)/.test(content)) {
+      importantRules.push('Use Axios interceptors for HTTP layer');
+    }
+    if (/z\.object|zod\.|Joi\.|yup\./.test(content)) {
+      patterns.push('Schema validation (Zod/Joi/Yup)');
+    }
+  }
+
+  const pkg = configFiles.packageJson;
+  if (pkg?.scripts) {
+    if (pkg.scripts.test) importantRules.push(`Run tests: \`npm test\` (${pkg.scripts.test})`);
+    if (pkg.scripts.lint) importantRules.push(`Lint: \`npm run lint\``);
+    if (pkg.scripts.build) importantRules.push(`Build: \`npm run build\``);
+  }
+
+  if (modules.controllers.length && modules.services.length) {
+    importantRules.push('Keep controllers thin — delegate business logic to services');
+  }
+  if (modules.middleware.length) {
+    importantRules.push('Middleware layer detected — apply cross-cutting concerns there');
+  }
+
+  if (astResult?.available && astResult.routes?.length) {
+    for (const r of astResult.routes) {
+      apiEndpoints.push({ method: r.method, path: r.path, file: r.file, source: 'ast' });
+    }
+  }
+
+  let summary = buildBusinessSummary(modules, businessLogic, apiEndpoints, structure, normalized);
+  if (astResult?.available) {
+    summary += ` AST parsed ${astResult.filesParsed} files for accurate route detection.`;
+  }
+
+  const pipelineFlow = inferPipelineFlow(normalized);
+
+  return {
+    pipelineFlow,
+    projectStructure: structure,
+    modules,
+    businessLogic: businessLogic.slice(0, 30),
+    apiEndpoints: dedupeEndpoints(apiEndpoints).slice(0, 40),
+    patterns: [...new Set(patterns)].slice(0, 15),
+    importantRules: [...new Set(importantRules)].slice(0, 12),
+    summary,
+    fileStats: {
+      totalSource: sourceFiles.length,
+      routes: modules.routes.length,
+      services: modules.services.length,
+      components: modules.components.length,
+    },
+  };
+}
+
+function detectProjectStructure(paths) {
+  const STANDARD_DIRS = [
+    'src', 'app', 'pages', 'components', 'controllers', 'routes',
+    'services', 'models', 'middleware', 'hooks', 'utils', 'config', 'api',
+  ];
+  const found = [];
+  for (const dir of STANDARD_DIRS) {
+    if (paths.some((p) => p === dir || p.startsWith(`${dir}/`))) {
+      found.push(dir);
+    }
+  }
+  return found;
+}
+
+function categorizeFile(rel, content, modules) {
+  const base = path.basename(rel);
+  const entry = { file: rel, name: base };
+
+  if (/routes?\//i.test(rel) || rel.includes('/routes/')) modules.routes.push(entry);
+  if (/controllers?\//i.test(rel)) modules.controllers.push(entry);
+  if (/services?\//i.test(rel)) modules.services.push(entry);
+  if (/middleware/i.test(rel)) modules.middleware.push(entry);
+  if (/models?\//i.test(rel)) modules.models.push(entry);
+  if (/components?\//i.test(rel) || /\.(tsx|jsx)$/.test(rel)) {
+    let m;
+    COMPONENT_RE.lastIndex = 0;
+    const names = [];
+    while ((m = COMPONENT_RE.exec(content)) !== null) {
+      names.push(m[1] || m[2]);
+    }
+    modules.components.push({ ...entry, components: names.slice(0, 5) });
+  }
+  if (/hooks?\//i.test(rel) || /^use[A-Z]/.test(base)) modules.hooks.push(entry);
+  if (/utils?\//i.test(rel)) modules.utils.push(entry);
+}
+
+function dedupeEndpoints(endpoints) {
+  const seen = new Set();
+  return endpoints.filter((e) => {
+    const key = `${e.method}:${e.path}:${e.file}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function inferPipelineFlow(paths) {
+  if (paths.some((p) => p.includes('src/core/pipeline.js'))) {
+    return 'Repository → Scanner → Detectors → Analyzers → Context Generator → context.md';
+  }
+  if (paths.some((p) => p.includes('watcher'))) {
+    return 'File change → Watcher (chokidar) → Pipeline → .contextforge/context.md';
+  }
+  return null;
+}
+
+function buildBusinessSummary(modules, businessLogic, apiEndpoints, structure, paths) {
+  const parts = [];
+
+  if (structure.length) {
+    parts.push(`Project uses directories: ${structure.join(', ')}.`);
+  }
+  if (modules.services.length) {
+    parts.push(`${modules.services.length} service module(s) contain core business logic.`);
+  }
+  if (modules.controllers.length) {
+    parts.push(`${modules.controllers.length} controller file(s) handle HTTP/request orchestration.`);
+  }
+  if (apiEndpoints.length) {
+    parts.push(`${apiEndpoints.length} API route(s) or handlers detected.`);
+  }
+  if (businessLogic.length) {
+    const names = businessLogic.slice(0, 8).map((b) => b.name).join(', ');
+    parts.push(`Exported service functions include: ${names}.`);
+  }
+  if (modules.components.length) {
+    parts.push(`${modules.components.length} UI component file(s) in the tree.`);
+  }
+  if (paths.some((p) => p.includes('src/cli'))) {
+    parts.push('CLI entry via commander; commands delegate to core pipeline.');
+  }
+  if (paths.some((p) => p.includes('src/generators'))) {
+    parts.push('Context output produced by generators/context-markdown.js.');
+  }
+
+  return parts.length
+    ? parts.join(' ')
+    : 'Business logic distributed across scanned source files; no dedicated services/ folder detected.';
+}