@agilsee/mcp-orchestrator 0.5.0

package/templates/shared/record-mistake.ts

@@ -0,0 +1,40 @@
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join, dirname } from "path";
+
+interface RecordMistakeArgs {
+  title: string;
+  found_during: string;
+  file: string;
+  root_cause: string;
+  fix: string;
+  impact: "low" | "medium" | "high";
+  related?: string;
+}
+
+export async function recordMistake(docsPath: string, args: RecordMistakeArgs) {
+  const path = join(docsPath, "MISTAKES.md");
+  await mkdir(dirname(path), { recursive: true });
+
+  let content: string;
+  try {
+    content = await readFile(path, "utf-8");
+  } catch {
+    content = "# Known Mistakes & Gotchas\n\n> Auto-updated oleh agent saat menemukan bug/gotcha.\n\n";
+  }
+
+  const today = new Date().toISOString().slice(0, 10);
+  const entry = [
+    `## [${today}] — ${args.title}`,
+    `- **Ditemukan saat**: ${args.found_during}`,
+    `- **File**: ${args.file}`,
+    `- **Root cause**: ${args.root_cause}`,
+    `- **Fix**: ${args.fix}`,
+    `- **Impact**: ${args.impact}`,
+    args.related ? `- **Related**: ${args.related}` : null,
+    "",
+  ].filter(Boolean).join("\n");
+
+  content = content.trimEnd() + "\n\n" + entry + "\n";
+  await writeFile(path, content, "utf-8");
+  return { file: path, title: args.title, message: `Recorded mistake: ${args.title}` };
+}

package/templates/shared/update-state.ts

@@ -0,0 +1,83 @@
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join, dirname } from "path";
+
+interface UpdateStateArgs {
+  action: "add_task" | "complete_task" | "update_task";
+  task_id: string;
+  title?: string;
+  status?: string;
+  scope?: string;
+  files_changed?: string[];
+  notes?: string;
+}
+
+export async function updateState(docsPath: string, args: UpdateStateArgs) {
+  const path = join(docsPath, "CURRENT_STATE.md");
+  await mkdir(dirname(path), { recursive: true });
+
+  let content: string;
+  try {
+    content = await readFile(path, "utf-8");
+  } catch {
+    content = `# Current State\nLast Updated: ${new Date().toISOString().slice(0, 10)}\n\n## Task Aktif\n\n(tidak ada)\n\n## Terakhir Selesai\n\n(belum ada)\n\n## Blockers\n\n(tidak ada)\n`;
+  }
+
+  const today = new Date().toISOString().slice(0, 10);
+  content = content.replace(/Last Updated:.*/, `Last Updated: ${today}`);
+
+  switch (args.action) {
+    case "add_task": {
+      const taskBlock = buildTaskBlock(args);
+      const activeHeader = "## Task Aktif";
+      const activeIdx = content.indexOf(activeHeader);
+      if (activeIdx !== -1) {
+        const afterHeader = activeIdx + activeHeader.length;
+        const nextSection = content.indexOf("\n## ", afterHeader + 1);
+        const sectionContent = nextSection !== -1 ? content.slice(afterHeader, nextSection) : content.slice(afterHeader);
+        const cleaned = sectionContent.replace(/\n\(tidak ada\)\n?/, "\n");
+        const replacement = cleaned.trimEnd() + "\n\n" + taskBlock + "\n";
+        content = nextSection !== -1 ? content.slice(0, afterHeader) + replacement + "\n" + content.slice(nextSection) : content.slice(0, afterHeader) + replacement;
+      }
+      break;
+    }
+    case "complete_task": {
+      const taskPattern = new RegExp(`### ${esc(args.task_id)}[^]*?(?=\\n### |\\n## |$)`, "m");
+      const match = content.match(taskPattern);
+      const completedEntry = [`### ${args.task_id}${args.title ? " " + args.title : ""}`, `- **Status**: done`, `- **Selesai**: ${today}`, args.notes ? `- **Notes**: ${args.notes}` : null].filter(Boolean).join("\n");
+      if (match) {
+        content = content.replace(match[0], "").replace(/\n{3,}/g, "\n\n");
+      }
+      const compIdx = content.indexOf("## Terakhir Selesai");
+      if (compIdx !== -1) {
+        const afterComp = compIdx + "## Terakhir Selesai".length;
+        const cleaned = content.slice(afterComp).replace(/^\n\(belum ada\)\n?/, "\n");
+        content = content.slice(0, afterComp) + "\n\n" + completedEntry + cleaned;
+      }
+      break;
+    }
+    case "update_task": {
+      const taskPattern = new RegExp(`(### ${esc(args.task_id)}[^\n]*)(\n[^]*?)(?=\n### |\n## |$)`, "m");
+      const match = content.match(taskPattern);
+      if (match) {
+        let taskBody = match[2];
+        if (args.status) taskBody = taskBody.replace(/- \*\*Status\*\*:.*/, `- **Status**: ${args.status}`);
+        if (args.notes) taskBody = taskBody.trimEnd() + `\n- **Update ${today}**: ${args.notes}\n`;
+        content = content.replace(match[0], match[1] + taskBody);
+      }
+      break;
+    }
+  }
+
+  await writeFile(path, content, "utf-8");
+  return { file: path, action: args.action, task_id: args.task_id, message: `State updated: ${args.action} ${args.task_id}` };
+}
+
+function buildTaskBlock(args: UpdateStateArgs): string {
+  const lines = [`### ${args.task_id}${args.title ? " " + args.title : ""}`, `- **Status**: ${args.status ?? "in progress"}`];
+  if (args.scope) lines.push(`- **Scope**: ${args.scope}`);
+  if (args.files_changed?.length) lines.push(`- **Files**: ${args.files_changed.join(", ")}`);
+  if (args.notes) lines.push(`- **Notes**: ${args.notes}`);
+  return lines.join("\n");
+}
+
+function esc(s: string): string { return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); }

package/templates/stacks/express/config.json

@@ -0,0 +1,9 @@
+{
+  "stack": "express",
+  "label": "Express.js (Node)",
+  "detect_package_deps": ["express"],
+  "scan_roots": ["src", "routes", "controllers", "middleware", "models", "services", "utils", "lib"],
+  "file_extensions": [".ts", ".js"],
+  "symbol_index": true,
+  "tools": ["find_symbol", "get_symbol_body", "list_routes", "predict_impact"]
+}

package/templates/stacks/express/list-routes.ts

@@ -0,0 +1,56 @@
+import { readdir, readFile, stat } from "fs/promises";
+import { join, relative } from "path";
+
+interface RouteEntry { method: string; path: string; handler: string; file: string; line: number; }
+
+const IGNORED = new Set(["node_modules", ".git", "dist", "build"]);
+const ROUTE_DIRS = ["routes", "src/routes", "src/api", "api"];
+const EXTS = [".ts", ".js"];
+
+export async function listRoutes(projectPath: string) {
+  const routes: RouteEntry[] = [];
+
+  for (const dir of ROUTE_DIRS) {
+    const full = join(projectPath, dir);
+    try { await stat(full); await scanRouteDir(full, projectPath, routes); } catch {}
+  }
+
+  // Also scan entry files
+  for (const entry of ["app.ts", "app.js", "server.ts", "server.js", "index.ts", "index.js", "src/app.ts", "src/app.js", "src/index.ts", "src/index.js"]) {
+    const full = join(projectPath, entry);
+    try { await stat(full); await scanRouteFile(full, projectPath, routes); } catch {}
+  }
+
+  return { count: routes.length, routes };
+}
+
+async function scanRouteDir(dir: string, root: string, out: RouteEntry[]) {
+  let entries;
+  try { entries = await readdir(dir, { withFileTypes: true }); } catch { return; }
+  for (const e of entries) {
+    if (e.name.startsWith(".") || IGNORED.has(e.name)) continue;
+    const full = join(dir, e.name);
+    if (e.isDirectory()) await scanRouteDir(full, root, out);
+    else if (e.isFile() && EXTS.some((ext) => e.name.endsWith(ext))) await scanRouteFile(full, root, out);
+  }
+}
+
+async function scanRouteFile(file: string, root: string, out: RouteEntry[]) {
+  let content: string;
+  try { content = await readFile(file, "utf-8"); } catch { return; }
+  const lines = content.split("\n");
+  // Match: router.get('/path', handler) / app.post('/path', middleware, handler)
+  const routeRe = /(?:router|app|route)\.(get|post|put|patch|delete|all|use)\s*\(\s*['"`]([^'"`]+)['"`]/i;
+
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(routeRe);
+    if (!m) continue;
+    out.push({
+      method: m[1].toUpperCase(),
+      path: m[2],
+      handler: lines[i].trim().slice(0, 150),
+      file: relative(root, file).replace(/\\/g, "/"),
+      line: i + 1,
+    });
+  }
+}

package/templates/stacks/express/symbol-index.ts

@@ -0,0 +1,70 @@
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+
+export interface SymbolEntry { name: string; kind: "function" | "class" | "middleware" | "type"; file: string; line: number; }
+
+const IGNORED = new Set(["node_modules", ".git", "dist", "build", "coverage", "__tests__", "test"]);
+const ROOTS = ["src", "routes", "controllers", "middleware", "models", "services", "utils", "lib", "helpers"];
+const EXTS = [".ts", ".js"];
+
+export class SymbolIndex {
+  private symbols: SymbolEntry[] = [];
+  private built = false;
+  private buildPromise: Promise<void> | null = null;
+  constructor(private projectPath: string) {}
+  get size() { return this.symbols.length; }
+
+  async ensureBuilt() {
+    if (this.built) return;
+    if (this.buildPromise) return this.buildPromise;
+    this.buildPromise = this.build();
+    await this.buildPromise;
+  }
+
+  private async build() {
+    for (const root of ROOTS) {
+      try { await this.scanDir(join(this.projectPath, root)); } catch {}
+    }
+    this.built = true;
+  }
+
+  private async scanDir(dir: string): Promise<void> {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+      if (e.name.startsWith(".") || IGNORED.has(e.name)) continue;
+      const full = join(dir, e.name);
+      if (e.isDirectory()) await this.scanDir(full);
+      else if (e.isFile() && EXTS.some((ext) => e.name.endsWith(ext))) await this.indexFile(full);
+    }
+  }
+
+  private async indexFile(file: string) {
+    let content: string;
+    try { content = await readFile(file, "utf-8"); } catch { return; }
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const fn = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
+      if (fn) { this.symbols.push({ name: fn[1], kind: "function", file, line: i + 1 }); continue; }
+      const cls = line.match(/(?:export\s+)?class\s+(\w+)/);
+      if (cls) { this.symbols.push({ name: cls[1], kind: "class", file, line: i + 1 }); continue; }
+      // Arrow function exports: export const xxx = (req, res) / export const xxx = async (
+      const arrow = line.match(/(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\(/);
+      if (arrow) { this.symbols.push({ name: arrow[1], kind: "function", file, line: i + 1 }); continue; }
+      const type = line.match(/export\s+(?:type|interface)\s+(\w+)/);
+      if (type) { this.symbols.push({ name: type[1], kind: "type", file, line: i + 1 }); }
+    }
+  }
+
+  async rebuild() {
+    this.symbols = []; this.built = false; this.buildPromise = null;
+    const start = Date.now();
+    await this.ensureBuilt();
+    return { count: this.symbols.length, ms: Date.now() - start };
+  }
+
+  find(name: string, kind?: string): SymbolEntry[] {
+    const k = kind && kind !== "any" ? kind : null;
+    return this.symbols.filter((s) => s.name === name && (!k || s.kind === k));
+  }
+}

package/templates/stacks/laravel/config.json

@@ -0,0 +1,9 @@
+{
+  "stack": "laravel",
+  "label": "Laravel (PHP)",
+  "detect": ["composer.json", "artisan"],
+  "scan_roots": ["app", "routes", "resources", "config"],
+  "file_extensions": [".php", ".blade.php", ".js"],
+  "symbol_index": true,
+  "tools": ["find_symbol", "get_symbol_body", "list_routes", "predict_impact", "generate_system_map"]
+}

package/templates/stacks/laravel/list-routes.ts

@@ -0,0 +1,19 @@
+import { readFile } from "fs/promises";
+import { join } from "path";
+
+export async function listRoutes(projectPath: string) {
+  const path = join(projectPath, "routes", "web.php");
+  const content = await readFile(path, "utf-8");
+  const lines = content.split("\n");
+  const routes: Array<{ method: string; uri: string; handler: string; name: string | null; line: number }> = [];
+  const routeRe = /Route::(get|post|put|patch|delete|any|match)\s*\(\s*['"]([^'"]+)['"]\s*,\s*(?:\[([^\]]+)\]|['"]([^'"]+)['"])/;
+  const nameRe = /->name\(\s*['"]([^'"]+)['"]\s*\)/;
+
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(routeRe);
+    if (!m) continue;
+    const nm = lines[i].match(nameRe);
+    routes.push({ method: m[1].toUpperCase(), uri: m[2], handler: (m[3] || m[4] || "").trim(), name: nm ? nm[1] : null, line: i + 1 });
+  }
+  return { file: path, count: routes.length, routes };
+}

package/templates/stacks/laravel/symbol-index.ts

@@ -0,0 +1,64 @@
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+
+export interface SymbolEntry { name: string; kind: "function" | "method" | "class"; file: string; line: number; }
+
+const IGNORED = new Set(["vendor", "node_modules", ".git", "storage", "bootstrap", "public", "database", "tests"]);
+const ROOTS = ["app", "routes"];
+
+export class SymbolIndex {
+  private symbols: SymbolEntry[] = [];
+  private built = false;
+  private buildPromise: Promise<void> | null = null;
+  constructor(private projectPath: string) {}
+  get size() { return this.symbols.length; }
+
+  async ensureBuilt() {
+    if (this.built) return;
+    if (this.buildPromise) return this.buildPromise;
+    this.buildPromise = this.build();
+    await this.buildPromise;
+  }
+
+  private async build() {
+    for (const root of ROOTS) {
+      try { await this.scanDir(join(this.projectPath, root)); } catch {}
+    }
+    this.built = true;
+  }
+
+  private async scanDir(dir: string): Promise<void> {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+      if (e.name.startsWith(".") || IGNORED.has(e.name)) continue;
+      const full = join(dir, e.name);
+      if (e.isDirectory()) await this.scanDir(full);
+      else if (e.isFile() && e.name.endsWith(".php")) await this.indexFile(full);
+    }
+  }
+
+  private async indexFile(file: string) {
+    let content: string;
+    try { content = await readFile(file, "utf-8"); } catch { return; }
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const cls = line.match(/^\s*(?:abstract\s+|final\s+)?class\s+(\w+)/);
+      if (cls) { this.symbols.push({ name: cls[1], kind: "class", file, line: i + 1 }); continue; }
+      const fn = line.match(/^\s*(?:(?:public|protected|private|static|abstract|final)\s+)*function\s+(\w+)\s*\(/);
+      if (fn) { this.symbols.push({ name: fn[1], kind: /^\s*(public|protected|private|static|abstract|final)/.test(line) ? "method" : "function", file, line: i + 1 }); }
+    }
+  }
+
+  async rebuild() {
+    this.symbols = []; this.built = false; this.buildPromise = null;
+    const start = Date.now();
+    await this.ensureBuilt();
+    return { count: this.symbols.length, ms: Date.now() - start };
+  }
+
+  find(name: string, kind?: string): SymbolEntry[] {
+    const k = kind && kind !== "any" ? kind : null;
+    return this.symbols.filter((s) => s.name === name && (!k || s.kind === k));
+  }
+}

package/templates/stacks/nextjs/config.json

@@ -0,0 +1,9 @@
+{
+  "stack": "nextjs",
+  "label": "Next.js (React)",
+  "detect": ["next.config.js", "next.config.mjs", "next.config.ts"],
+  "scan_roots": ["src", "app", "pages", "components", "lib", "hooks", "utils"],
+  "file_extensions": [".ts", ".tsx", ".js", ".jsx"],
+  "symbol_index": true,
+  "tools": ["find_symbol", "get_symbol_body", "list_routes", "predict_impact"]
+}

package/templates/stacks/nextjs/list-routes.ts

@@ -0,0 +1,67 @@
+import { readdir, stat } from "fs/promises";
+import { join, relative } from "path";
+
+interface PageRoute { path: string; file: string; type: "page" | "api" | "layout" | "loading" | "error"; }
+
+const IGNORED = new Set(["node_modules", ".git", ".next", "dist"]);
+
+export async function listRoutes(projectPath: string) {
+  const routes: PageRoute[] = [];
+
+  // App Router (app/)
+  const appDir = join(projectPath, "app");
+  try { await stat(appDir); await scanAppDir(appDir, projectPath, "", routes); } catch {}
+
+  // Pages Router (pages/)
+  const pagesDir = join(projectPath, "pages");
+  try { await stat(pagesDir); await scanPagesDir(pagesDir, projectPath, "", routes); } catch {}
+
+  // src/app/ and src/pages/
+  const srcAppDir = join(projectPath, "src", "app");
+  try { await stat(srcAppDir); await scanAppDir(srcAppDir, projectPath, "", routes); } catch {}
+  const srcPagesDir = join(projectPath, "src", "pages");
+  try { await stat(srcPagesDir); await scanPagesDir(srcPagesDir, projectPath, "", routes); } catch {}
+
+  return { count: routes.length, routes };
+}
+
+async function scanAppDir(dir: string, root: string, prefix: string, out: PageRoute[]) {
+  let entries;
+  try { entries = await readdir(dir, { withFileTypes: true }); } catch { return; }
+  for (const e of entries) {
+    if (e.name.startsWith(".") || IGNORED.has(e.name)) continue;
+    const full = join(dir, e.name);
+    if (e.isDirectory()) {
+      const segment = e.name.startsWith("(") ? "" : "/" + e.name.replace(/^\[\.\.\./, ":").replace(/^\[/, ":").replace(/\]$/, "");
+      await scanAppDir(full, root, prefix + segment, out);
+    } else if (e.isFile()) {
+      const name = e.name.replace(/\.(tsx?|jsx?|mdx?)$/, "");
+      let type: PageRoute["type"] = "page";
+      if (name === "page") type = "page";
+      else if (name === "layout") type = "layout";
+      else if (name === "loading") type = "loading";
+      else if (name === "error") type = "error";
+      else if (name === "route") type = "api";
+      else continue;
+      out.push({ path: prefix || "/", file: relative(root, full).replace(/\\/g, "/"), type });
+    }
+  }
+}
+
+async function scanPagesDir(dir: string, root: string, prefix: string, out: PageRoute[]) {
+  let entries;
+  try { entries = await readdir(dir, { withFileTypes: true }); } catch { return; }
+  for (const e of entries) {
+    if (e.name.startsWith(".") || e.name.startsWith("_") || IGNORED.has(e.name)) continue;
+    const full = join(dir, e.name);
+    if (e.isDirectory()) {
+      const segment = "/" + e.name.replace(/^\[\.\.\./, ":").replace(/^\[/, ":").replace(/\]$/, "");
+      await scanPagesDir(full, root, prefix + segment, out);
+    } else if (e.isFile()) {
+      const name = e.name.replace(/\.(tsx?|jsx?|mdx?)$/, "");
+      const isApi = full.includes(join("pages", "api"));
+      const route = name === "index" ? (prefix || "/") : prefix + "/" + name.replace(/^\[\.\.\./, ":").replace(/^\[/, ":").replace(/\]$/, "");
+      out.push({ path: route, file: relative(root, full).replace(/\\/g, "/"), type: isApi ? "api" : "page" });
+    }
+  }
+}

package/templates/stacks/nextjs/symbol-index.ts

@@ -0,0 +1,78 @@
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+
+export interface SymbolEntry { name: string; kind: "function" | "component" | "class" | "hook" | "type"; file: string; line: number; }
+
+const IGNORED = new Set(["node_modules", ".git", ".next", "dist", "build", "public", "coverage", "__tests__"]);
+const ROOTS = ["src", "app", "pages", "components", "lib", "hooks", "utils"];
+const EXTS = [".ts", ".tsx", ".js", ".jsx"];
+
+export class SymbolIndex {
+  private symbols: SymbolEntry[] = [];
+  private built = false;
+  private buildPromise: Promise<void> | null = null;
+  constructor(private projectPath: string) {}
+  get size() { return this.symbols.length; }
+
+  async ensureBuilt() {
+    if (this.built) return;
+    if (this.buildPromise) return this.buildPromise;
+    this.buildPromise = this.build();
+    await this.buildPromise;
+  }
+
+  private async build() {
+    for (const root of ROOTS) {
+      try { await this.scanDir(join(this.projectPath, root)); } catch {}
+    }
+    this.built = true;
+  }
+
+  private async scanDir(dir: string): Promise<void> {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+      if (e.name.startsWith(".") || IGNORED.has(e.name)) continue;
+      const full = join(dir, e.name);
+      if (e.isDirectory()) await this.scanDir(full);
+      else if (e.isFile() && EXTS.some((ext) => e.name.endsWith(ext))) await this.indexFile(full);
+    }
+  }
+
+  private async indexFile(file: string) {
+    let content: string;
+    try { content = await readFile(file, "utf-8"); } catch { return; }
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      // React component: export default function ComponentName / export function ComponentName / const ComponentName =
+      const compExport = line.match(/export\s+(?:default\s+)?function\s+([A-Z]\w+)/);
+      if (compExport) { this.symbols.push({ name: compExport[1], kind: "component", file, line: i + 1 }); continue; }
+      const compConst = line.match(/export\s+(?:const|let)\s+([A-Z]\w+)\s*[=:]/);
+      if (compConst) { this.symbols.push({ name: compConst[1], kind: "component", file, line: i + 1 }); continue; }
+      // Hook: export function useXxx
+      const hook = line.match(/export\s+(?:default\s+)?function\s+(use[A-Z]\w+)/);
+      if (hook) { this.symbols.push({ name: hook[1], kind: "hook", file, line: i + 1 }); continue; }
+      // Regular function: export function xxx / function xxx
+      const fn = line.match(/(?:export\s+)?(?:async\s+)?function\s+([a-z]\w+)/);
+      if (fn) { this.symbols.push({ name: fn[1], kind: "function", file, line: i + 1 }); continue; }
+      // Class
+      const cls = line.match(/(?:export\s+)?class\s+(\w+)/);
+      if (cls) { this.symbols.push({ name: cls[1], kind: "class", file, line: i + 1 }); continue; }
+      // Type/Interface
+      const type = line.match(/export\s+(?:type|interface)\s+(\w+)/);
+      if (type) { this.symbols.push({ name: type[1], kind: "type", file, line: i + 1 }); }
+    }
+  }
+
+  async rebuild() {
+    this.symbols = []; this.built = false; this.buildPromise = null;
+    const start = Date.now();
+    await this.ensureBuilt();
+    return { count: this.symbols.length, ms: Date.now() - start };
+  }
+
+  find(name: string, kind?: string): SymbolEntry[] {
+    const k = kind && kind !== "any" ? kind : null;
+    return this.symbols.filter((s) => s.name === name && (!k || s.kind === k));
+  }
+}

package/templates/stacks/react/config.json

@@ -0,0 +1,10 @@
+{
+  "stack": "react",
+  "label": "React (Vite/CRA)",
+  "detect_package_deps": ["react"],
+  "detect_not": ["next"],
+  "scan_roots": ["src", "components", "hooks", "utils", "lib", "contexts", "pages", "features", "store"],
+  "file_extensions": [".ts", ".tsx", ".js", ".jsx"],
+  "symbol_index": true,
+  "tools": ["find_symbol", "get_symbol_body", "list_routes", "predict_impact"]
+}

package/templates/stacks/react/list-routes.ts

@@ -0,0 +1,44 @@
+import { readFile, stat } from "fs/promises";
+import { join } from "path";
+
+interface RouteEntry { path: string; component: string; file: string; line: number; }
+
+export async function listRoutes(projectPath: string) {
+  const routes: RouteEntry[] = [];
+
+  // Try common router config locations
+  const candidates = [
+    "src/App.tsx", "src/App.jsx", "src/App.ts", "src/App.js",
+    "src/routes.tsx", "src/routes.ts", "src/routes.jsx", "src/routes.js",
+    "src/router.tsx", "src/router.ts", "src/router.jsx", "src/router.js",
+    "src/routes/index.tsx", "src/routes/index.ts",
+  ];
+
+  for (const candidate of candidates) {
+    const full = join(projectPath, candidate);
+    try {
+      await stat(full);
+      const content = await readFile(full, "utf-8");
+      const lines = content.split("\n");
+
+      // Match: <Route path="/xxx" / path: "/xxx" / { path: "/xxx"
+      const routeRe = /(?:path\s*[=:]\s*['"`]([^'"`]+)['"`]|<Route\s[^>]*path\s*=\s*['"`]([^'"`]+)['"`])/;
+      const compRe = /(?:element\s*[=:]\s*[{<]?\s*(\w+)|component\s*[=:]\s*[{]?\s*(\w+))/;
+
+      for (let i = 0; i < lines.length; i++) {
+        const rm = lines[i].match(routeRe);
+        if (!rm) continue;
+        const path = rm[1] || rm[2];
+        const cm = lines[i].match(compRe);
+        routes.push({
+          path,
+          component: cm ? (cm[1] || cm[2] || "unknown") : "unknown",
+          file: candidate,
+          line: i + 1,
+        });
+      }
+    } catch { continue; }
+  }
+
+  return { count: routes.length, routes };
+}

package/templates/stacks/react/symbol-index.ts

@@ -0,0 +1,81 @@
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+
+export interface SymbolEntry { name: string; kind: "component" | "hook" | "function" | "class" | "type" | "context"; file: string; line: number; }
+
+const IGNORED = new Set(["node_modules", ".git", "dist", "build", "public", "coverage", "__tests__", "test"]);
+const ROOTS = ["src", "components", "hooks", "utils", "lib", "contexts", "pages", "features", "store"];
+const EXTS = [".ts", ".tsx", ".js", ".jsx"];
+
+export class SymbolIndex {
+  private symbols: SymbolEntry[] = [];
+  private built = false;
+  private buildPromise: Promise<void> | null = null;
+  constructor(private projectPath: string) {}
+  get size() { return this.symbols.length; }
+
+  async ensureBuilt() {
+    if (this.built) return;
+    if (this.buildPromise) return this.buildPromise;
+    this.buildPromise = this.build();
+    await this.buildPromise;
+  }
+
+  private async build() {
+    for (const root of ROOTS) {
+      try { await this.scanDir(join(this.projectPath, root)); } catch {}
+    }
+    this.built = true;
+  }
+
+  private async scanDir(dir: string): Promise<void> {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+      if (e.name.startsWith(".") || IGNORED.has(e.name)) continue;
+      const full = join(dir, e.name);
+      if (e.isDirectory()) await this.scanDir(full);
+      else if (e.isFile() && EXTS.some((ext) => e.name.endsWith(ext))) await this.indexFile(full);
+    }
+  }
+
+  private async indexFile(file: string) {
+    let content: string;
+    try { content = await readFile(file, "utf-8"); } catch { return; }
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      // Context: export const XxxContext = createContext
+      const ctx = line.match(/export\s+const\s+(\w+Context)\s*=\s*(?:React\.)?createContext/);
+      if (ctx) { this.symbols.push({ name: ctx[1], kind: "context", file, line: i + 1 }); continue; }
+      // Hook: export function useXxx
+      const hook = line.match(/(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+(use[A-Z]\w+)/);
+      if (hook) { this.symbols.push({ name: hook[1], kind: "hook", file, line: i + 1 }); continue; }
+      // Component: export function/const ComponentName (PascalCase)
+      const compFn = line.match(/export\s+(?:default\s+)?function\s+([A-Z]\w+)/);
+      if (compFn) { this.symbols.push({ name: compFn[1], kind: "component", file, line: i + 1 }); continue; }
+      const compConst = line.match(/export\s+(?:const|let)\s+([A-Z]\w+)\s*[=:]/);
+      if (compConst && !line.includes("createContext")) { this.symbols.push({ name: compConst[1], kind: "component", file, line: i + 1 }); continue; }
+      // Regular function
+      const fn = line.match(/(?:export\s+)?(?:async\s+)?function\s+([a-z]\w+)/);
+      if (fn) { this.symbols.push({ name: fn[1], kind: "function", file, line: i + 1 }); continue; }
+      // Class
+      const cls = line.match(/(?:export\s+)?class\s+(\w+)/);
+      if (cls) { this.symbols.push({ name: cls[1], kind: "class", file, line: i + 1 }); continue; }
+      // Type/Interface
+      const type = line.match(/export\s+(?:type|interface)\s+(\w+)/);
+      if (type) { this.symbols.push({ name: type[1], kind: "type", file, line: i + 1 }); }
+    }
+  }
+
+  async rebuild() {
+    this.symbols = []; this.built = false; this.buildPromise = null;
+    const start = Date.now();
+    await this.ensureBuilt();
+    return { count: this.symbols.length, ms: Date.now() - start };
+  }
+
+  find(name: string, kind?: string): SymbolEntry[] {
+    const k = kind && kind !== "any" ? kind : null;
+    return this.symbols.filter((s) => s.name === name && (!k || s.kind === k));
+  }
+}