cto-ai-cli 4.0.0 → 5.0.0

package/dist/cli/score.js

@@ -1344,10 +1344,7 @@ var init_secrets = __esm({
 });
 
 // src/engine/pruner.ts
-import { Project as Project2, SyntaxKind as SyntaxKind2 } from "ts-morph";
 import { readFile as readFile4 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-import { join as join4 } from "path";
 async function pruneFile(file, level) {
   if (level === "excluded") {
     return emptyResult(file, "excluded");
@@ -1369,23 +1366,7 @@ async function pruneTypeScript(file, level) {
   } catch {
     return emptyResult(file, level);
   }
-  let project;
-  try {
-    const tsConfigPath = findTsConfig(file.path);
-    project = new Project2({
-      tsConfigFilePath: tsConfigPath,
-      skipAddingFilesFromTsConfig: true,
-      compilerOptions: tsConfigPath ? void 0 : { allowJs: true, esModuleInterop: true }
-    });
-    project.createSourceFile(file.path, content, { overwrite: true });
-  } catch {
-    return pruneGenericFromContent(file, content, level);
-  }
-  const sourceFile = project.getSourceFiles()[0];
-  if (!sourceFile) {
-    return pruneGenericFromContent(file, content, level);
-  }
-  const prunedContent = level === "signatures" ? extractSignaturesAST(sourceFile) : extractSkeletonAST(sourceFile);
+  const prunedContent = level === "signatures" ? extractSignaturesRegex(content) : extractSkeletonRegex(content);
   const prunedTokens = countTokensChars4(Buffer.byteLength(prunedContent, "utf-8"));
   const savingsPercent = file.tokens > 0 ? (file.tokens - prunedTokens) / file.tokens * 100 : 0;
   return {
@@ -1397,131 +1378,281 @@ async function pruneTypeScript(file, level) {
     savingsPercent: Math.max(0, savingsPercent)
   };
 }
-function extractSignaturesAST(sf) {
+function extractSignaturesRegex(content) {
+  const lines = content.split("\n");
   const parts = [];
-  for (const imp of sf.getImportDeclarations()) {
-    parts.push(imp.getText());
-  }
-  if (parts.length > 0) parts.push("");
-  for (const ta of sf.getTypeAliases()) {
-    addJSDoc(ta, parts);
-    parts.push(ta.getText());
-  }
-  for (const iface of sf.getInterfaces()) {
-    addJSDoc(iface, parts);
-    parts.push(iface.getText());
-  }
-  for (const en of sf.getEnums()) {
-    addJSDoc(en, parts);
-    parts.push(en.getText());
-  }
-  for (const fn of sf.getFunctions()) {
-    addJSDoc(fn, parts);
-    const isExported = fn.isExported();
-    const isAsync = fn.isAsync();
-    const name = fn.getName() ?? "<anonymous>";
-    const params = fn.getParameters().map((p) => p.getText()).join(", ");
-    const returnType = fn.getReturnTypeNode()?.getText();
-    const returnStr = returnType ? `: ${returnType}` : "";
-    const prefix = isExported ? "export " : "";
-    const asyncStr = isAsync ? "async " : "";
-    parts.push(`${prefix}${asyncStr}function ${name}(${params})${returnStr} { /* ... */ }`);
-  }
-  for (const stmt of sf.getVariableStatements()) {
-    for (const decl of stmt.getDeclarations()) {
-      const init = decl.getInitializer();
-      if (init && (init.getKind() === SyntaxKind2.ArrowFunction || init.getKind() === SyntaxKind2.FunctionExpression)) {
-        addJSDoc(stmt, parts);
-        const isExported = stmt.isExported();
-        const prefix = isExported ? "export " : "";
-        const kind = stmt.getDeclarationKind();
-        const name = decl.getName();
-        const typeNode = decl.getTypeNode()?.getText();
-        const typeStr = typeNode ? `: ${typeNode}` : "";
-        parts.push(`${prefix}${kind} ${name}${typeStr} = /* ... */;`);
-      } else {
-        addJSDoc(stmt, parts);
-        parts.push(stmt.getText());
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      i++;
+      continue;
+    }
+    if (trimmed.startsWith("/**")) {
+      const docLines = [];
+      while (i < lines.length) {
+        docLines.push(lines[i]);
+        if (lines[i].includes("*/")) {
+          i++;
+          break;
+        }
+        i++;
       }
+      parts.push(docLines.join("\n"));
+      continue;
     }
-  }
-  for (const cls of sf.getClasses()) {
-    addJSDoc(cls, parts);
-    const isExported = cls.isExported();
-    const prefix = isExported ? "export " : "";
-    const name = cls.getName() ?? "<anonymous>";
-    const ext = cls.getExtends()?.getText();
-    const impl = cls.getImplements().map((i) => i.getText()).join(", ");
-    let header = `${prefix}class ${name}`;
-    if (ext) header += ` extends ${ext}`;
-    if (impl) header += ` implements ${impl}`;
-    header += " {";
-    parts.push(header);
-    for (const prop of cls.getProperties()) {
-      parts.push(`  ${prop.getText()}`);
-    }
-    const ctor = cls.getConstructors()[0];
-    if (ctor) {
-      const ctorParams = ctor.getParameters().map((p) => p.getText()).join(", ");
-      parts.push(`  constructor(${ctorParams}) { /* ... */ }`);
-    }
-    for (const method of cls.getMethods()) {
-      const isStatic = method.isStatic();
-      const isAsync = method.isAsync();
-      const methodName = method.getName();
-      const methodParams = method.getParameters().map((p) => p.getText()).join(", ");
-      const returnType = method.getReturnTypeNode()?.getText();
-      const returnStr = returnType ? `: ${returnType}` : "";
-      const staticStr = isStatic ? "static " : "";
-      const asyncStr = isAsync ? "async " : "";
-      parts.push(`  ${staticStr}${asyncStr}${methodName}(${methodParams})${returnStr} { /* ... */ }`);
-    }
-    parts.push("}");
-  }
-  for (const exp of sf.getExportDeclarations()) {
-    parts.push(exp.getText());
-  }
-  for (const exp of sf.getExportAssignments()) {
-    parts.push(exp.getText());
+    if (trimmed.startsWith("//")) {
+      parts.push(line);
+      i++;
+      continue;
+    }
+    if (/^\s*(import|export)\s/.test(line) && (trimmed.includes(" from ") || trimmed.startsWith("import "))) {
+      const block = collectBracedLine(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    if (/^\s*export\s*(\{|\*)/.test(trimmed)) {
+      const block = collectBracedLine(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    if (/^\s*(export\s+)?type\s+\w/.test(trimmed) && !trimmed.startsWith("typeof")) {
+      const block = collectBalanced(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    if (/^\s*(export\s+)?interface\s+\w/.test(trimmed)) {
+      const block = collectBalanced(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    if (/^\s*(export\s+)?(const\s+)?enum\s+\w/.test(trimmed)) {
+      const block = collectBalanced(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    const fnMatch = trimmed.match(/^(export\s+)?(async\s+)?function\s+(\w+)/);
+    if (fnMatch) {
+      const sig = extractFnSignature(lines, i);
+      parts.push(`${sig} { /* ... */ }`);
+      i = skipBlock(lines, i);
+      continue;
+    }
+    const arrowMatch = trimmed.match(/^(export\s+)?(const|let|var)\s+(\w+)/);
+    if (arrowMatch && looksLikeFunctionDecl(lines, i)) {
+      const prefix = trimmed.match(/^((?:export\s+)?(?:const|let|var)\s+\w+[^=]*=)/)?.[1];
+      if (prefix) {
+        parts.push(`${prefix} /* ... */;`);
+      }
+      i = skipBlock(lines, i);
+      continue;
+    }
+    if (arrowMatch) {
+      const block = collectStatement(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    if (/^\s*(export\s+)?(abstract\s+)?class\s+\w/.test(trimmed)) {
+      const classOutline = extractClassOutline(lines, i);
+      parts.push(classOutline.text);
+      i = classOutline.nextIndex;
+      continue;
+    }
+    i++;
   }
   return parts.join("\n");
 }
-function extractSkeletonAST(sf) {
+function extractSkeletonRegex(content) {
+  const lines = content.split("\n");
   const parts = [];
-  for (const imp of sf.getImportDeclarations()) {
-    parts.push(imp.getText());
-  }
-  if (parts.length > 0) parts.push("");
-  for (const ta of sf.getTypeAliases()) {
-    if (ta.isExported()) parts.push(ta.getText());
-  }
-  for (const iface of sf.getInterfaces()) {
-    if (!iface.isExported()) continue;
-    const ext = iface.getExtends().map((e) => e.getText());
-    const extStr = ext.length > 0 ? ` extends ${ext.join(", ")}` : "";
-    parts.push(`export interface ${iface.getName()}${extStr} { /* ${iface.getProperties().length} props */ }`);
-  }
-  for (const en of sf.getEnums()) {
-    if (!en.isExported()) continue;
-    const members = en.getMembers().map((m) => m.getName());
-    parts.push(`export enum ${en.getName()} { ${members.join(", ")} }`);
-  }
-  for (const fn of sf.getFunctions()) {
-    if (!fn.isExported()) continue;
-    const name = fn.getName() ?? "<anonymous>";
-    const params = fn.getParameters().map((p) => p.getText()).join(", ");
-    parts.push(`export function ${name}(${params});`);
-  }
-  for (const cls of sf.getClasses()) {
-    if (!cls.isExported()) continue;
-    const methods = cls.getMethods().map((m) => m.getName());
-    parts.push(`export class ${cls.getName()} { /* methods: ${methods.join(", ")} */ }`);
-  }
-  for (const exp of sf.getExportDeclarations()) {
-    parts.push(exp.getText());
+  let i = 0;
+  while (i < lines.length) {
+    const trimmed = lines[i].trim();
+    if (/^import\s/.test(trimmed)) {
+      const block = collectBracedLine(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    if (/^export\s+(type|interface)\s+\w/.test(trimmed)) {
+      const block = collectBalanced(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    if (/^export\s+(const\s+)?enum\s+\w/.test(trimmed)) {
+      const block = collectBalanced(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    if (/^export\s+(async\s+)?function\s+\w/.test(trimmed)) {
+      const sig = extractFnSignature(lines, i);
+      parts.push(`${sig};`);
+      i = skipBlock(lines, i);
+      continue;
+    }
+    if (/^export\s+(abstract\s+)?class\s+/.test(trimmed)) {
+      const nameMatch = trimmed.match(/class\s+(\w+)/);
+      const name = nameMatch?.[1] ?? "Unknown";
+      const end = skipBlock(lines, i);
+      const methods = [];
+      for (let j = i + 1; j < end; j++) {
+        const mt = lines[j].trim();
+        const mm = mt.match(/^(?:static\s+)?(?:async\s+)?(\w+)\s*\(/);
+        if (mm && mm[1] !== "constructor") methods.push(mm[1]);
+      }
+      parts.push(`export class ${name} { /* methods: ${methods.join(", ")} */ }`);
+      i = end;
+      continue;
+    }
+    if (/^export\s*(\{|\*)/.test(trimmed)) {
+      const block = collectBracedLine(lines, i);
+      parts.push(block.text);
+      i = block.nextIndex;
+      continue;
+    }
+    i++;
   }
   return parts.join("\n");
 }
+function collectBracedLine(lines, start) {
+  let text = lines[start];
+  let i = start + 1;
+  while (i < lines.length && !text.includes(";") && !text.trimEnd().endsWith("'") && !text.trimEnd().endsWith('"')) {
+    text += "\n" + lines[i];
+    i++;
+  }
+  return { text, nextIndex: i };
+}
+function collectBalanced(lines, start) {
+  let depth = 0;
+  let text = "";
+  let i = start;
+  let started = false;
+  while (i < lines.length) {
+    const line = lines[i];
+    text += (text ? "\n" : "") + line;
+    for (const ch of line) {
+      if (ch === "{" || ch === "(") {
+        depth++;
+        started = true;
+      }
+      if (ch === "}" || ch === ")") depth--;
+    }
+    i++;
+    if (started && depth <= 0) break;
+    if (!started && line.includes(";")) break;
+  }
+  return { text, nextIndex: i };
+}
+function collectStatement(lines, start) {
+  let text = lines[start];
+  let i = start + 1;
+  if (text.includes(";")) return { text, nextIndex: i };
+  let depth = 0;
+  for (const ch of text) {
+    if (ch === "{" || ch === "(" || ch === "[") depth++;
+    if (ch === "}" || ch === ")" || ch === "]") depth--;
+  }
+  while (i < lines.length && depth > 0) {
+    text += "\n" + lines[i];
+    for (const ch of lines[i]) {
+      if (ch === "{" || ch === "(" || ch === "[") depth++;
+      if (ch === "}" || ch === ")" || ch === "]") depth--;
+    }
+    i++;
+  }
+  return { text, nextIndex: i };
+}
+function extractFnSignature(lines, start) {
+  let sig = "";
+  let i = start;
+  while (i < lines.length) {
+    const line = lines[i].trim();
+    sig += (sig ? " " : "") + line;
+    if (line.includes("{")) {
+      sig = sig.replace(/\s*\{[^]*$/, "").trim();
+      break;
+    }
+    i++;
+  }
+  return sig;
+}
+function skipBlock(lines, start) {
+  let depth = 0;
+  let i = start;
+  let foundBrace = false;
+  while (i < lines.length) {
+    for (const ch of lines[i]) {
+      if (ch === "{") {
+        depth++;
+        foundBrace = true;
+      }
+      if (ch === "}") depth--;
+    }
+    i++;
+    if (foundBrace && depth <= 0) break;
+    if (!foundBrace && lines[i - 1].includes(";")) break;
+  }
+  return i;
+}
+function looksLikeFunctionDecl(lines, start) {
+  const chunk = lines.slice(start, Math.min(start + 5, lines.length)).join(" ");
+  return /=>/.test(chunk) || /=\s*function/.test(chunk);
+}
+function extractClassOutline(lines, start) {
+  const header = lines[start].trim();
+  let headerText = header;
+  let i = start + 1;
+  if (!header.includes("{")) {
+    while (i < lines.length) {
+      headerText += " " + lines[i].trim();
+      if (lines[i].includes("{")) {
+        i++;
+        break;
+      }
+      i++;
+    }
+  } else {
+    i = start + 1;
+  }
+  const bodyParts = [headerText.replace(/\{[^]*$/, "{").trim()];
+  let depth = 1;
+  while (i < lines.length && depth > 0) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    for (const ch of line) {
+      if (ch === "{") depth++;
+      if (ch === "}") depth--;
+    }
+    if (depth <= 0) {
+      i++;
+      break;
+    }
+    if (depth === 1) {
+      if (/^(private|protected|public|readonly|static|#)/.test(trimmed) && !trimmed.includes("(")) {
+        bodyParts.push(`  ${trimmed}`);
+      } else if (/^constructor\s*\(/.test(trimmed)) {
+        const sig = extractFnSignature(lines, i);
+        bodyParts.push(`  ${sig} { /* ... */ }`);
+      } else if (/^(?:static\s+)?(?:async\s+)?(?:get\s+|set\s+)?\w+\s*[(<]/.test(trimmed) && !trimmed.startsWith("//")) {
+        const sig = extractFnSignature(lines, i);
+        bodyParts.push(`  ${sig} { /* ... */ }`);
+      }
+    }
+    i++;
+  }
+  bodyParts.push("}");
+  return { text: bodyParts.join("\n"), nextIndex: i };
+}
 async function pruneGeneric(file, level) {
   let content;
   try {
@@ -1582,22 +1713,6 @@ function emptyResult(file, level) {
     savingsPercent: 100
   };
 }
-function addJSDoc(node, parts) {
-  if (!node.getJsDocs) return;
-  const docs = node.getJsDocs();
-  if (docs.length > 0) {
-    parts.push(docs[0].getText());
-  }
-}
-function findTsConfig(filePath) {
-  let dir = filePath;
-  for (let i = 0; i < 10; i++) {
-    dir = join4(dir, "..");
-    const candidate = join4(dir, "tsconfig.json");
-    if (existsSync3(candidate)) return candidate;
-  }
-  return void 0;
-}
 var TS_EXTENSIONS2;
 var init_pruner = __esm({
   "src/engine/pruner.ts"() {
@@ -2241,7 +2356,7 @@ var init_providers = __esm({
 
 // src/gateway/interceptor.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve6 } from "path";
+import { resolve as resolve10 } from "path";
 function estimateTokensFromString(s) {
   return Math.ceil(Buffer.byteLength(s, "utf-8") / 4);
 }
@@ -2355,7 +2470,7 @@ async function optimizeContext(messages, analysis, config) {
         continue;
       }
       try {
-        const fullPath = resolve6(config.projectPath, f.relativePath);
+        const fullPath = resolve10(config.projectPath, f.relativePath);
         const content = readFileSync2(fullPath, "utf-8");
         const fileTokens = estimateTokensFromString(content);
         const remainingBudget = contentBudget - usedTokens;
@@ -2438,8 +2553,8 @@ var init_interceptor = __esm({
 });
 
 // src/gateway/tracker.ts
-import { mkdirSync as mkdirSync2, appendFileSync, readFileSync as readFileSync3, readdirSync, existsSync as existsSync6 } from "fs";
-import { join as join7 } from "path";
+import { mkdirSync as mkdirSync2, appendFileSync, readFileSync as readFileSync3, readdirSync, existsSync as existsSync5 } from "fs";
+import { join as join9 } from "path";
 import { randomUUID } from "crypto";
 var UsageTracker;
 var init_tracker = __esm({
@@ -2455,7 +2570,7 @@ var init_tracker = __esm({
       memRecords = [];
       constructor(config) {
         this.config = config;
-        this.logDir = join7(config.logDir, "usage");
+        this.logDir = join9(config.logDir, "usage");
         mkdirSync2(this.logDir, { recursive: true });
       }
       // ===== EVENT SYSTEM =====
@@ -2478,7 +2593,7 @@ var init_tracker = __esm({
           ...params
         };
         const monthKey = this.getMonthKey(record.timestamp);
-        const logFile = join7(this.logDir, `${monthKey}.jsonl`);
+        const logFile = join9(this.logDir, `${monthKey}.jsonl`);
         const line = JSON.stringify({
           ...record,
           timestamp: record.timestamp.toISOString()
@@ -2612,8 +2727,8 @@ var init_tracker = __esm({
         return date.toISOString().slice(0, 7);
       }
       getMonthRecordsByKey(monthKey) {
-        const filePath = join7(this.logDir, `${monthKey}.jsonl`);
-        if (!existsSync6(filePath)) return [];
+        const filePath = join9(this.logDir, `${monthKey}.jsonl`);
+        if (!existsSync5(filePath)) return [];
         return readFileSync3(filePath, "utf-8").split("\n").filter((line) => line.trim()).map((line) => {
           try {
             const parsed = JSON.parse(line);
@@ -2627,8 +2742,8 @@ var init_tracker = __esm({
       getMonthRecords(date) {
         const monthKey = this.getMonthKey(date);
         if (this.cache && this.cacheMonth === monthKey) return this.cache;
-        const filePath = join7(this.logDir, `${monthKey}.jsonl`);
-        if (!existsSync6(filePath)) return [];
+        const filePath = join9(this.logDir, `${monthKey}.jsonl`);
+        if (!existsSync5(filePath)) return [];
         const records = readFileSync3(filePath, "utf-8").split("\n").filter((line) => line.trim()).map((line) => {
           try {
             const parsed = JSON.parse(line);
@@ -2643,11 +2758,11 @@ var init_tracker = __esm({
         return records;
       }
       getAllRecords() {
-        if (!existsSync6(this.logDir)) return [];
+        if (!existsSync5(this.logDir)) return [];
         const files = readdirSync(this.logDir).filter((f) => f.endsWith(".jsonl")).sort();
         const allRecords = [];
         for (const file of files) {
-          const content = readFileSync3(join7(this.logDir, file), "utf-8");
+          const content = readFileSync3(join9(this.logDir, file), "utf-8");
           const records = content.split("\n").filter((line) => line.trim()).map((line) => {
             try {
               const parsed = JSON.parse(line);
@@ -2676,7 +2791,7 @@ import { request as httpRequest } from "http";
 import { URL } from "url";
 import { lookup } from "dns/promises";
 function readBody(req, maxBytes = 0) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve12, reject) => {
     const chunks = [];
     let totalBytes = 0;
     req.on("data", (chunk) => {
@@ -2688,7 +2803,7 @@ function readBody(req, maxBytes = 0) {
       }
       chunks.push(chunk);
     });
-    req.on("end", () => resolve8(Buffer.concat(chunks).toString()));
+    req.on("end", () => resolve12(Buffer.concat(chunks).toString()));
     req.on("error", reject);
   });
 }
@@ -2904,18 +3019,18 @@ var init_server = __esm({
           this.analysisPromise = this.refreshAnalysis();
         }
         this.server = createServer((req, res) => this.handleRequest(req, res));
-        return new Promise((resolve8) => {
+        return new Promise((resolve12) => {
           this.server.listen(this.config.port, this.config.host, () => {
-            resolve8();
+            resolve12();
           });
         });
       }
       async stop() {
-        return new Promise((resolve8) => {
+        return new Promise((resolve12) => {
           if (this.server) {
-            this.server.close(() => resolve8());
+            this.server.close(() => resolve12());
           } else {
-            resolve8();
+            resolve12();
           }
         });
       }
@@ -3097,7 +3212,7 @@ var init_server = __esm({
           if (value) forwardHeaders[key] = Array.isArray(value) ? value[0] : value;
         }
         forwardHeaders["content-length"] = Buffer.byteLength(body).toString();
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve12, reject) => {
           const proxyReq = requester(
             {
               hostname: url.hostname,
@@ -3118,7 +3233,7 @@ var init_server = __esm({
                   parsed,
                   interceptResult,
                   startTime
-                ).then(resolve8).catch(reject);
+                ).then(resolve12).catch(reject);
               } else {
                 this.handleBufferedResponse(
                   proxyRes,
@@ -3127,7 +3242,7 @@ var init_server = __esm({
                   parsed,
                   interceptResult,
                   startTime
-                ).then(resolve8).catch(reject);
+                ).then(resolve12).catch(reject);
               }
             }
           );
@@ -3147,7 +3262,7 @@ var init_server = __esm({
         let inputTokens = 0;
         let outputTokens = 0;
         let sseBuffer = "";
-        return new Promise((resolve8) => {
+        return new Promise((resolve12) => {
           proxyRes.on("data", (chunk) => {
             clientRes.write(chunk);
             sseBuffer += chunk.toString();
@@ -3208,17 +3323,17 @@ var init_server = __esm({
               latencyMs: Date.now() - startTime,
               stream: true
             });
-            resolve8();
+            resolve12();
           });
           proxyRes.on("error", () => {
             clientRes.end();
-            resolve8();
+            resolve12();
           });
         });
       }
       // ===== BUFFERED HANDLER =====
       async handleBufferedResponse(proxyRes, clientRes, provider, parsed, interceptResult, startTime) {
-        return new Promise((resolve8) => {
+        return new Promise((resolve12) => {
           const chunks = [];
           proxyRes.on("data", (chunk) => chunks.push(chunk));
           proxyRes.on("end", () => {
@@ -3275,11 +3390,11 @@ var init_server = __esm({
                 error: "response-parse-failed"
               });
             }
-            resolve8();
+            resolve12();
           });
           proxyRes.on("error", () => {
             clientRes.end();
-            resolve8();
+            resolve12();
           });
         });
       }
@@ -3297,7 +3412,7 @@ var init_server = __esm({
 
 // src/cli/score.ts
 init_analyzer();
-import { resolve as resolve7, join as join8 } from "path";
+import { resolve as resolve11, join as join10 } from "path";
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2, readFileSync as readFileSync4, appendFileSync as appendFileSync2 } from "fs";
 
 // src/engine/score.ts
@@ -3605,9 +3720,9 @@ function renderBar(pct, width) {
   return "\u2588".repeat(filled) + "\u2591".repeat(empty);
 }
 function padCenter(str, width) {
-  const pad2 = Math.max(0, width - str.length);
-  const left = Math.floor(pad2 / 2);
-  return " ".repeat(left) + str + " ".repeat(pad2 - left);
+  const pad3 = Math.max(0, width - str.length);
+  const left = Math.floor(pad3 / 2);
+  return " ".repeat(left) + str + " ".repeat(pad3 - left);
 }
 function formatNumber(n) {
   if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
@@ -3775,8 +3890,8 @@ init_secrets();
 
 // src/engine/monorepo.ts
 import { readFile as readFile5, readdir as readdir2 } from "fs/promises";
-import { join as join5, relative as relative4, basename as basename3 } from "path";
-import { existsSync as existsSync4 } from "fs";
+import { join as join4, relative as relative4, basename as basename3 } from "path";
+import { existsSync as existsSync3 } from "fs";
 async function detectMonorepoTool(rootPath) {
   const checks = [
     { file: "nx.json", tool: "nx" },
@@ -3797,14 +3912,14 @@ async function detectMonorepoTool(rootPath) {
     }
   ];
   for (const check of checks) {
-    const filePath = join5(rootPath, check.file);
-    if (existsSync4(filePath)) {
+    const filePath = join4(rootPath, check.file);
+    if (existsSync3(filePath)) {
       if (!check.validate) return check.tool;
       try {
         const content = await readFile5(filePath, "utf-8");
         if (check.validate(content)) {
           if (check.tool === "npm-workspaces") {
-            if (existsSync4(join5(rootPath, "yarn.lock"))) return "yarn-workspaces";
+            if (existsSync3(join4(rootPath, "yarn.lock"))) return "yarn-workspaces";
             return "npm-workspaces";
           }
           return check.tool;
@@ -3819,15 +3934,15 @@ async function resolveWorkspaceGlobs(rootPath, globs) {
   const packagePaths = [];
   for (const glob of globs) {
     const cleanGlob = glob.replace(/\/?\*\*?$/, "");
-    const searchDir = join5(rootPath, cleanGlob);
-    if (!existsSync4(searchDir)) continue;
+    const searchDir = join4(rootPath, cleanGlob);
+    if (!existsSync3(searchDir)) continue;
     try {
       const entries = await readdir2(searchDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const pkgJsonPath = join5(searchDir, entry.name, "package.json");
-        if (existsSync4(pkgJsonPath)) {
-          packagePaths.push(join5(searchDir, entry.name));
+        const pkgJsonPath = join4(searchDir, entry.name, "package.json");
+        if (existsSync3(pkgJsonPath)) {
+          packagePaths.push(join4(searchDir, entry.name));
         }
       }
     } catch {
@@ -3839,12 +3954,12 @@ async function discoverPackages(rootPath, tool) {
   switch (tool) {
     case "npm-workspaces":
     case "yarn-workspaces": {
-      const pkgJson = JSON.parse(await readFile5(join5(rootPath, "package.json"), "utf-8"));
+      const pkgJson = JSON.parse(await readFile5(join4(rootPath, "package.json"), "utf-8"));
       const workspaces = Array.isArray(pkgJson.workspaces) ? pkgJson.workspaces : pkgJson.workspaces?.packages || [];
       return resolveWorkspaceGlobs(rootPath, workspaces);
     }
     case "pnpm-workspaces": {
-      const content = await readFile5(join5(rootPath, "pnpm-workspace.yaml"), "utf-8");
+      const content = await readFile5(join4(rootPath, "pnpm-workspace.yaml"), "utf-8");
       const packages = [];
       let inPackages = false;
       for (const line of content.split("\n")) {
@@ -3862,20 +3977,20 @@ async function discoverPackages(rootPath, tool) {
       return resolveWorkspaceGlobs(rootPath, packages);
     }
     case "turborepo": {
-      const pkgJson = JSON.parse(await readFile5(join5(rootPath, "package.json"), "utf-8"));
+      const pkgJson = JSON.parse(await readFile5(join4(rootPath, "package.json"), "utf-8"));
       const workspaces = Array.isArray(pkgJson.workspaces) ? pkgJson.workspaces : pkgJson.workspaces?.packages || [];
       if (workspaces.length > 0) return resolveWorkspaceGlobs(rootPath, workspaces);
-      if (existsSync4(join5(rootPath, "pnpm-workspace.yaml"))) {
+      if (existsSync3(join4(rootPath, "pnpm-workspace.yaml"))) {
         return discoverPackages(rootPath, "pnpm-workspaces");
       }
       return [];
     }
     case "nx": {
       const standardDirs = ["packages", "apps", "libs"];
-      const globs = standardDirs.filter((d) => existsSync4(join5(rootPath, d)));
+      const globs = standardDirs.filter((d) => existsSync3(join4(rootPath, d)));
       if (globs.length > 0) return resolveWorkspaceGlobs(rootPath, globs);
       try {
-        const pkgJson = JSON.parse(await readFile5(join5(rootPath, "package.json"), "utf-8"));
+        const pkgJson = JSON.parse(await readFile5(join4(rootPath, "package.json"), "utf-8"));
         const workspaces = Array.isArray(pkgJson.workspaces) ? pkgJson.workspaces : [];
         if (workspaces.length > 0) return resolveWorkspaceGlobs(rootPath, workspaces);
       } catch {
@@ -3883,7 +3998,7 @@ async function discoverPackages(rootPath, tool) {
       return [];
     }
     case "lerna": {
-      const lernaJson = JSON.parse(await readFile5(join5(rootPath, "lerna.json"), "utf-8"));
+      const lernaJson = JSON.parse(await readFile5(join4(rootPath, "lerna.json"), "utf-8"));
       const packages = lernaJson.packages || ["packages/*"];
       return resolveWorkspaceGlobs(rootPath, packages);
     }
@@ -3937,7 +4052,7 @@ async function analyzeMonorepo(rootPath, analysis) {
   const packages = [];
   const packageTokenMap = {};
   for (const pkgPath of packagePaths) {
-    const pkgJsonPath = join5(pkgPath, "package.json");
+    const pkgJsonPath = join4(pkgPath, "package.json");
     let name = basename3(pkgPath);
     let pkgDeps = [];
     try {
@@ -3980,7 +4095,7 @@ async function analyzeMonorepo(rootPath, analysis) {
   }
   const pkgNames = new Set(packages.map((p) => p.name));
   for (const pkg of packages) {
-    const pkgJsonPath = join5(pkg.path, "package.json");
+    const pkgJsonPath = join4(pkg.path, "package.json");
     try {
       const pkgJson = JSON.parse(await readFile5(pkgJsonPath, "utf-8"));
       const allDeps = {
@@ -4134,7 +4249,7 @@ function renderPackageContext(result) {
 // src/engine/quality-gate.ts
 import { readFile as readFile6, writeFile as writeFile2, mkdir } from "fs/promises";
 import { resolve as resolve5 } from "path";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 var DEFAULT_GATE_CONFIG = {
   threshold: 70,
   failOnSecrets: true,
@@ -4145,7 +4260,7 @@ var DEFAULT_GATE_CONFIG = {
 };
 async function loadBaseline(projectPath, baselinePath) {
   const filePath = resolve5(projectPath, baselinePath || ".cto/baseline.json");
-  if (!existsSync5(filePath)) return null;
+  if (!existsSync4(filePath)) return null;
   try {
     const content = await readFile6(filePath, "utf-8");
     return JSON.parse(content);
@@ -4155,7 +4270,7 @@ async function loadBaseline(projectPath, baselinePath) {
 }
 async function saveBaseline(projectPath, score, commit, branch, baselinePath) {
   const dir = resolve5(projectPath, ".cto");
-  if (!existsSync5(dir)) await mkdir(dir, { recursive: true });
+  if (!existsSync4(dir)) await mkdir(dir, { recursive: true });
   const baseline = {
     score: score.overall,
     grade: score.grade,
@@ -4303,6 +4418,914 @@ Warnings: ${warnings.map((c) => c.name).join(", ")}`;
   return summary;
 }
 
+// src/engine/feedback.ts
+import { resolve as resolve6, join as join6 } from "path";
+import { readFile as readFile7, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
+
+// src/interact/router.ts
+var TASK_KEYWORDS = {
+  debug: ["debug", "fix", "bug", "error", "issue", "broken", "crash", "failing", "wrong"],
+  review: ["review", "check", "assess", "evaluate", "audit", "inspect", "critique"],
+  refactor: ["refactor", "restructure", "reorganize", "clean up", "simplify", "extract", "move"],
+  test: ["test", "spec", "coverage", "unit test", "integration test", "e2e"],
+  docs: ["document", "docs", "readme", "jsdoc", "comment", "explain"],
+  feature: ["add", "implement", "create", "build", "new", "feature", "endpoint"],
+  architecture: ["architecture", "design", "system", "structure", "migrate", "pattern"],
+  "simple-edit": ["rename", "typo", "update", "change", "modify", "tweak", "adjust"]
+};
+function classifyTask(taskDescription) {
+  const lower = taskDescription.toLowerCase();
+  let bestType = "simple-edit";
+  let bestScore = 0;
+  for (const [type, keywords] of Object.entries(TASK_KEYWORDS)) {
+    let score = 0;
+    for (const kw of keywords) {
+      if (lower.includes(kw)) score++;
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      bestType = type;
+    }
+  }
+  return bestType;
+}
+
+// src/engine/feedback.ts
+async function getFeedbackPath(projectPath) {
+  const ctoDir = join6(resolve6(projectPath), ".cto");
+  await mkdir2(ctoDir, { recursive: true });
+  return join6(ctoDir, "feedback.json");
+}
+async function getModelPath(projectPath) {
+  const ctoDir = join6(resolve6(projectPath), ".cto");
+  await mkdir2(ctoDir, { recursive: true });
+  return join6(ctoDir, "feedback-model.json");
+}
+async function loadFeedback(projectPath) {
+  try {
+    const raw = await readFile7(await getFeedbackPath(projectPath), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+async function loadFeedbackModel(projectPath) {
+  try {
+    const raw = await readFile7(await getModelPath(projectPath), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return createEmptyModel();
+  }
+}
+function createEmptyModel() {
+  return {
+    version: 2,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalFeedback: 0,
+    acceptRate: 0,
+    fileAcceptance: {},
+    taskTypeAcceptance: {},
+    pairAcceptance: {},
+    sessions: {},
+    strategyComparison: {},
+    insights: []
+  };
+}
+async function exportFeedbackForTeam(projectPath, projectName) {
+  const model = await loadFeedbackModel(projectPath);
+  const entries = await loadFeedback(projectPath);
+  return {
+    version: 2,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    projectName,
+    model,
+    entrySummary: {
+      total: entries.length,
+      accepted: entries.filter((e) => e.outcome.accepted).length,
+      sessions: new Set(entries.map((e) => e.sessionId).filter(Boolean)).size
+    }
+  };
+}
+function renderFeedbackReport(model) {
+  const lines = [];
+  lines.push("");
+  lines.push(`  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557`);
+  lines.push(`  \u2551        \u{1F4CA} Feedback Loop Report                   \u2551`);
+  lines.push(`  \u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563`);
+  lines.push(`  \u2551                                                  \u2551`);
+  lines.push(`  \u2551  Total feedback:  ${pad2(model.totalFeedback.toString(), 8)}                   \u2551`);
+  lines.push(`  \u2551  Accept rate:     ${pad2(Math.round(model.acceptRate * 100) + "%", 8)}                   \u2551`);
+  lines.push(`  \u2551  Tracked files:   ${pad2(Object.keys(model.fileAcceptance).length.toString(), 8)}                   \u2551`);
+  lines.push(`  \u2551  Task types:      ${pad2(Object.keys(model.taskTypeAcceptance).length.toString(), 8)}                   \u2551`);
+  lines.push(`  \u2551                                                  \u2551`);
+  if (model.insights.length > 0) {
+    lines.push(`  \u2551  Insights:                                       \u2551`);
+    for (const insight of model.insights.slice(0, 5)) {
+      const icon = insight.type === "positive" ? "\u2705" : insight.type === "negative" ? "\u26A0\uFE0F" : "\u{1F4A1}";
+      lines.push(`  \u2551  ${icon} ${pad2(insight.title, 43)}  \u2551`);
+    }
+  }
+  lines.push(`  \u2551                                                  \u2551`);
+  lines.push(`  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D`);
+  return lines.join("\n");
+}
+function pad2(s, w) {
+  return s.padEnd(w).substring(0, w);
+}
+function renderCrossRepoReport(stats) {
+  const lines = [];
+  lines.push("");
+  lines.push("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+  lines.push("  \u2551        \u{1F310} Cross-Repo Intelligence                \u2551");
+  lines.push("  \u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563");
+  lines.push("  \u2551                                                  \u2551");
+  lines.push(`  \u2551  Projects learned:    ${pad2(stats.totalProjects.toString(), 8)}                   \u2551`);
+  lines.push(`  \u2551  Total observations:  ${pad2(stats.totalObservations.toString(), 8)}                   \u2551`);
+  lines.push(`  \u2551  Archetypes:          ${pad2(stats.archetypes.length.toString(), 8)}                   \u2551`);
+  lines.push(`  \u2551  Universal patterns:  ${pad2(stats.universalPatterns.toString(), 8)}                   \u2551`);
+  lines.push("  \u2551                                                  \u2551");
+  if (stats.archetypes.length > 0) {
+    lines.push("  \u2551  Archetypes:                                     \u2551");
+    for (const a of stats.archetypes.slice(0, 5)) {
+      lines.push(`  \u2551    ${pad2(a.name, 24)} ${pad2(a.observations + " obs", 12)}     \u2551`);
+    }
+  }
+  lines.push("  \u2551                                                  \u2551");
+  lines.push("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+  return lines.join("\n");
+}
+
+// src/engine/predictor.ts
+import { resolve as resolve7, join as join7 } from "path";
+import { readFile as readFile8, writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
+init_graph_utils();
+var DEFAULT_PREDICTOR_CONFIG = {
+  maxCoSelectionPairs: 500,
+  decayFactor: 0.95,
+  // slight decay to favor recent patterns
+  minObservations: 2
+  // need at least 2 observations before predicting
+};
+async function getModelPath2(projectPath) {
+  const ctoDir = join7(resolve7(projectPath), ".cto");
+  await mkdir3(ctoDir, { recursive: true });
+  return join7(ctoDir, "predictor.json");
+}
+async function loadModel(projectPath) {
+  try {
+    const path = await getModelPath2(projectPath);
+    const raw = await readFile8(path, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return createEmptyModel2();
+  }
+}
+function createEmptyModel2() {
+  return {
+    version: 1,
+    trainedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalObservations: 0,
+    taskTypeFrequency: {},
+    keywordFrequency: {},
+    fileStats: {},
+    coSelection: {}
+  };
+}
+async function predictRelevantFiles(projectPath, task, analysis, config = {}) {
+  const cfg = { ...DEFAULT_PREDICTOR_CONFIG, ...config };
+  const model = await loadModel(projectPath);
+  if (model.totalObservations < cfg.minObservations) {
+    return [];
+  }
+  const taskType = classifyTask(task);
+  const keywords = extractKeywords(task);
+  const scores = /* @__PURE__ */ new Map();
+  const boost = (path, amount, reason) => {
+    const existing = scores.get(path) ?? { score: 0, reasons: [] };
+    existing.score += amount;
+    existing.reasons.push(reason);
+    scores.set(path, existing);
+  };
+  const taskFreqs = model.taskTypeFrequency[taskType];
+  if (taskFreqs) {
+    const maxFreq = Math.max(...Object.values(taskFreqs));
+    for (const [path, freq] of Object.entries(taskFreqs)) {
+      const normalized = maxFreq > 0 ? freq / maxFreq : 0;
+      boost(path, normalized * 30, `${taskType} task history (${freq}\xD7 selected)`);
+    }
+  }
+  for (const kw of keywords) {
+    const kwFreqs = model.keywordFrequency[kw];
+    if (kwFreqs) {
+      const maxFreq = Math.max(...Object.values(kwFreqs));
+      for (const [path, freq] of Object.entries(kwFreqs)) {
+        const normalized = maxFreq > 0 ? freq / maxFreq : 0;
+        boost(path, normalized * 20, `keyword "${kw}" (${freq}\xD7 selected)`);
+      }
+    }
+  }
+  for (const [path, stats] of Object.entries(model.fileStats)) {
+    const freqRatio = model.totalObservations > 0 ? stats.totalSelections / model.totalObservations : 0;
+    if (freqRatio > 0.3) {
+      boost(path, freqRatio * 10, `frequently selected (${stats.totalSelections}/${model.totalObservations})`);
+    }
+  }
+  const topPredicted = [...scores.entries()].sort((a, b) => b[1].score - a[1].score).slice(0, 10).map(([path]) => path);
+  for (const topPath of topPredicted) {
+    const coFiles = model.coSelection[topPath];
+    if (coFiles) {
+      for (const [coPath, count] of Object.entries(coFiles)) {
+        if (count >= 2) {
+          boost(coPath, count * 2, `co-selected with ${topPath} (${count}\xD7)`);
+        }
+      }
+    }
+  }
+  const existingPaths = new Set(analysis.files.map((f) => f.relativePath));
+  const results = [];
+  for (const [path, data] of scores) {
+    if (existingPaths.has(path)) {
+      results.push({
+        filePath: path,
+        predictedScore: Math.round(data.score * 10) / 10,
+        reasons: data.reasons.slice(0, 5)
+      });
+    }
+  }
+  return results.sort((a, b) => b.predictedScore - a.predictedScore).slice(0, 50);
+}
+function getModelStats(model) {
+  const coSelectionPairs = Object.values(model.coSelection).reduce((s, pairs) => s + Object.keys(pairs).length, 0) / 2;
+  return {
+    observations: model.totalObservations,
+    taskTypes: Object.keys(model.taskTypeFrequency).length,
+    keywords: Object.keys(model.keywordFrequency).length,
+    trackedFiles: Object.keys(model.fileStats).length,
+    coSelectionPairs: Math.round(coSelectionPairs),
+    trainedAt: model.trainedAt
+  };
+}
+function extractKeywords(task) {
+  const stopWords = /* @__PURE__ */ new Set([
+    "the",
+    "a",
+    "an",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "can",
+    "shall",
+    "to",
+    "of",
+    "in",
+    "for",
+    "on",
+    "with",
+    "at",
+    "by",
+    "from",
+    "as",
+    "into",
+    "through",
+    "and",
+    "but",
+    "or",
+    "not",
+    "this",
+    "that",
+    "it",
+    "its",
+    "fix",
+    "add",
+    "remove",
+    "update",
+    "change",
+    "refactor",
+    "implement",
+    "create",
+    "build",
+    "make",
+    "code",
+    "file",
+    "module",
+    "function"
+  ]);
+  return task.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 2 && !stopWords.has(w));
+}
+
+// src/engine/cross-repo.ts
+import { join as join8, basename as basename4 } from "path";
+import { readFile as readFile9, writeFile as writeFile5, mkdir as mkdir4 } from "fs/promises";
+function getGlobalModelPath() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "/tmp";
+  return join8(home, ".cto", "global-intelligence.json");
+}
+async function loadGlobalModel() {
+  try {
+    const raw = await readFile9(getGlobalModelPath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return createEmptyModel3();
+  }
+}
+function createEmptyModel3() {
+  return {
+    version: 1,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalProjects: 0,
+    totalObservations: 0,
+    archetypes: {},
+    universalPatterns: []
+  };
+}
+function getCrossRepoStats(model) {
+  return {
+    totalProjects: model.totalProjects,
+    totalObservations: model.totalObservations,
+    archetypes: Object.values(model.archetypes).map((a) => ({
+      name: a.name,
+      projects: a.projectCount,
+      observations: a.observationCount
+    })),
+    universalPatterns: model.universalPatterns.length
+  };
+}
+
+// src/engine/code-review.ts
+init_graph_utils();
+import { resolve as resolve9, basename as basename5, dirname as dirname4 } from "path";
+import { readFile as readFile10 } from "fs/promises";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var exec = promisify(execFile);
+async function git(args, cwd) {
+  try {
+    const { stdout } = await exec("git", args, { cwd, maxBuffer: 10 * 1024 * 1024 });
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+}
+async function analyzeForReview(analysis, options = {}) {
+  const projectPath = resolve9(analysis.projectPath);
+  const baseBranch = options.baseBranch ?? "main";
+  const depth = options.depth ?? 2;
+  const maxPromptFiles = options.maxPromptFiles ?? 20;
+  const isRepo = await git(["rev-parse", "--is-inside-work-tree"], projectPath) === "true";
+  if (!isRepo) {
+    return emptyResult2(baseBranch);
+  }
+  const branch = await git(["rev-parse", "--abbrev-ref", "HEAD"], projectPath);
+  const changedFiles = await getChangedFilesWithHunks(projectPath, baseBranch, analysis);
+  if (changedFiles.length === 0) {
+    return {
+      ...emptyResult2(baseBranch),
+      branch,
+      isGitRepo: true,
+      renderedSummary: "# Code Review\n\nNo changed files detected."
+    };
+  }
+  const totalLinesChanged = changedFiles.reduce((s, f) => s + f.linesAdded + f.linesRemoved, 0);
+  const breakingChanges = detectBreakingChanges(changedFiles, analysis);
+  const missingFiles = findMissingFiles(changedFiles, analysis, depth);
+  const impactRadius = computeImpactRadius(changedFiles, analysis, depth);
+  const reviewQuality = calculateReviewQuality(changedFiles, breakingChanges, missingFiles, impactRadius, totalLinesChanged);
+  const reviewPrompt = await generateReviewPrompt(changedFiles, breakingChanges, missingFiles, analysis, projectPath, maxPromptFiles);
+  const renderedSummary = renderReviewSummary(branch, baseBranch, changedFiles, breakingChanges, missingFiles, impactRadius, reviewQuality);
+  return {
+    branch,
+    baseBranch,
+    isGitRepo: true,
+    changedFiles,
+    totalLinesChanged,
+    breakingChanges,
+    missingFiles,
+    impactRadius,
+    reviewQuality,
+    reviewPrompt,
+    renderedSummary
+  };
+}
+async function getChangedFilesWithHunks(projectPath, baseBranch, analysis) {
+  const files = [];
+  const fileMap = new Map(analysis.files.map((f) => [f.relativePath, f]));
+  const numstat = await git(["diff", "--numstat", "HEAD"], projectPath);
+  const branchNumstat = await git(["diff", "--numstat", `${baseBranch}...HEAD`], projectPath);
+  const nameStatus = await git(["diff", "--name-status", `${baseBranch}...HEAD`], projectPath);
+  const changeTypes = /* @__PURE__ */ new Map();
+  for (const line of nameStatus.split("\n")) {
+    const parts = line.trim().split("	");
+    if (parts.length < 2) continue;
+    const status = parts[0];
+    const filePath = parts[parts.length - 1];
+    if (status === "A") changeTypes.set(filePath, "added");
+    else if (status === "D") changeTypes.set(filePath, "deleted");
+    else if (status.startsWith("R")) changeTypes.set(filePath, "renamed");
+    else changeTypes.set(filePath, "modified");
+  }
+  const allNumstat = (numstat + "\n" + branchNumstat).split("\n");
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of allNumstat) {
+    const parts = line.trim().split("	");
+    if (parts.length < 3) continue;
+    const added = parts[0] === "-" ? 0 : parseInt(parts[0], 10) || 0;
+    const removed = parts[1] === "-" ? 0 : parseInt(parts[1], 10) || 0;
+    const filePath = parts[2];
+    if (!filePath || seen.has(filePath)) continue;
+    seen.add(filePath);
+    const af = fileMap.get(filePath);
+    const changeType = changeTypes.get(filePath) ?? "modified";
+    const hunks = await parseDiffHunks(projectPath, baseBranch, filePath);
+    const hasExportChanges = hunks.some(
+      (h) => h.additions.some((l) => /^\s*export\s/.test(l)) || h.deletions.some((l) => /^\s*export\s/.test(l))
+    );
+    const hasTypeChanges = hunks.some(
+      (h) => h.additions.some((l) => /^\s*(interface|type|enum)\s/.test(l)) || h.deletions.some((l) => /^\s*(interface|type|enum)\s/.test(l))
+    );
+    files.push({
+      relativePath: filePath,
+      changeType,
+      linesAdded: added,
+      linesRemoved: removed,
+      riskScore: af?.riskScore ?? 0,
+      kind: af?.kind ?? "unknown",
+      hunks,
+      hasExportChanges,
+      hasTypeChanges
+    });
+  }
+  const workingNumstat = await git(["diff", "--numstat"], projectPath);
+  for (const line of workingNumstat.split("\n")) {
+    const parts = line.trim().split("	");
+    if (parts.length < 3) continue;
+    const filePath = parts[2];
+    if (!filePath || seen.has(filePath)) continue;
+    seen.add(filePath);
+    const af = fileMap.get(filePath);
+    const added = parts[0] === "-" ? 0 : parseInt(parts[0], 10) || 0;
+    const removed = parts[1] === "-" ? 0 : parseInt(parts[1], 10) || 0;
+    files.push({
+      relativePath: filePath,
+      changeType: "modified",
+      linesAdded: added,
+      linesRemoved: removed,
+      riskScore: af?.riskScore ?? 0,
+      kind: af?.kind ?? "unknown",
+      hunks: [],
+      hasExportChanges: false,
+      hasTypeChanges: false
+    });
+  }
+  return files.sort((a, b) => b.riskScore - a.riskScore);
+}
+async function parseDiffHunks(projectPath, baseBranch, filePath) {
+  const diff = await git(["diff", "-U3", `${baseBranch}...HEAD`, "--", filePath], projectPath);
+  if (!diff) return [];
+  const hunks = [];
+  const lines = diff.split("\n");
+  let currentHunk = null;
+  for (const line of lines) {
+    const hunkMatch = line.match(/^@@\s+-(\d+)(?:,\d+)?\s+\+(\d+)(?:,\d+)?\s+@@\s*(.*)/);
+    if (hunkMatch) {
+      if (currentHunk) hunks.push(currentHunk);
+      currentHunk = {
+        startLine: parseInt(hunkMatch[2], 10),
+        endLine: parseInt(hunkMatch[2], 10),
+        header: hunkMatch[3] || "",
+        additions: [],
+        deletions: []
+      };
+      continue;
+    }
+    if (!currentHunk) continue;
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      currentHunk.additions.push(line.substring(1));
+      currentHunk.endLine++;
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      currentHunk.deletions.push(line.substring(1));
+    } else if (!line.startsWith("\\")) {
+      if (currentHunk) currentHunk.endLine++;
+    }
+  }
+  if (currentHunk) hunks.push(currentHunk);
+  return hunks;
+}
+function detectBreakingChanges(changedFiles, analysis) {
+  const breaks = [];
+  const adj = buildAdjacencyList(analysis.graph.edges);
+  for (const file of changedFiles) {
+    if (file.changeType === "deleted") {
+      const dependents = findDependents(file.relativePath, analysis);
+      if (dependents.length > 0) {
+        breaks.push({
+          file: file.relativePath,
+          type: "export-removed",
+          severity: "critical",
+          description: `File deleted but ${dependents.length} files depend on it`,
+          affectedFiles: dependents
+        });
+      }
+      continue;
+    }
+    for (const hunk of file.hunks) {
+      for (const del of hunk.deletions) {
+        const exportMatch = del.match(/^\s*export\s+(function|const|class|type|interface|enum)\s+(\w+)/);
+        if (exportMatch) {
+          const [, kind, name] = exportMatch;
+          const wasReAdded = hunk.additions.some(
+            (a) => new RegExp(`export\\s+${kind}\\s+${name}\\b`).test(a)
+          );
+          if (!wasReAdded) {
+            const dependents = findDependents(file.relativePath, analysis);
+            breaks.push({
+              file: file.relativePath,
+              type: kind === "type" || kind === "interface" ? "type-changed" : "export-removed",
+              severity: dependents.length > 3 ? "critical" : dependents.length > 0 ? "high" : "medium",
+              description: `Removed export ${kind} ${name}`,
+              affectedFiles: dependents
+            });
+          }
+        }
+        const propMatch = del.match(/^\s+(\w+)\s*[?:].*[;,]?\s*$/);
+        if (propMatch && file.hasTypeChanges) {
+          const propName = propMatch[1];
+          const wasReAdded = hunk.additions.some(
+            (a) => new RegExp(`\\b${propName}\\s*[?:]`).test(a)
+          );
+          if (!wasReAdded) {
+            breaks.push({
+              file: file.relativePath,
+              type: "interface-changed",
+              severity: "high",
+              description: `Removed property "${propName}" from type/interface`,
+              affectedFiles: findDependents(file.relativePath, analysis)
+            });
+          }
+        }
+      }
+      for (const add of hunk.additions) {
+        const fnMatch = add.match(/^\s*export\s+(async\s+)?function\s+(\w+)\s*\(([^)]*)\)/);
+        if (fnMatch) {
+          const [, , fnName, newParams] = fnMatch;
+          for (const del of hunk.deletions) {
+            const origMatch = del.match(new RegExp(`export\\s+(async\\s+)?function\\s+${fnName}\\s*\\(([^)]*)\\)`));
+            if (origMatch) {
+              const oldParams = origMatch[2];
+              if (oldParams !== newParams) {
+                const oldCount = oldParams.split(",").filter((p) => p.trim()).length;
+                const newCount = newParams.split(",").filter((p) => p.trim()).length;
+                if (oldCount !== newCount || !paramsCompatible(oldParams, newParams)) {
+                  breaks.push({
+                    file: file.relativePath,
+                    type: "function-signature",
+                    severity: "high",
+                    description: `Function "${fnName}" signature changed: (${oldParams.trim()}) \u2192 (${newParams.trim()})`,
+                    affectedFiles: findDependents(file.relativePath, analysis)
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return breaks.sort((a, b) => {
+    const sev = { critical: 0, high: 1, medium: 2 };
+    return sev[a.severity] - sev[b.severity];
+  });
+}
+function paramsCompatible(oldParams, newParams) {
+  const oldParts = oldParams.split(",").map((p) => p.trim().split(":")[0].trim().replace("?", ""));
+  const newParts = newParams.split(",").map((p) => p.trim().split(":")[0].trim().replace("?", ""));
+  let j = 0;
+  for (let i = 0; i < oldParts.length && j < newParts.length; i++) {
+    if (oldParts[i] === newParts[j]) j++;
+  }
+  return j >= oldParts.length;
+}
+function findDependents(filePath, analysis) {
+  return analysis.files.filter((f) => f.imports.includes(filePath) || f.imports.some((imp) => imp.endsWith(filePath))).map((f) => f.relativePath);
+}
+function findMissingFiles(changedFiles, analysis, depth) {
+  const missing = [];
+  const changedPaths = new Set(changedFiles.map((f) => f.relativePath));
+  const fileMap = new Map(analysis.files.map((f) => [f.relativePath, f]));
+  for (const changed of changedFiles) {
+    if (changed.changeType === "deleted") continue;
+    const af = fileMap.get(changed.relativePath);
+    if (!af) continue;
+    if (changed.hasTypeChanges || changed.hasExportChanges) {
+      const dir2 = dirname4(changed.relativePath);
+      const base = basename5(changed.relativePath).replace(/\.[^.]+$/, "");
+      const typeVariants = [
+        `${dir2}/${base}.types.ts`,
+        `${dir2}/${base}.types.tsx`,
+        `${dir2}/types.ts`,
+        `${dir2}/types/${base}.ts`,
+        `${dir2}/index.d.ts`
+      ];
+      for (const variant of typeVariants) {
+        if (fileMap.has(variant) && !changedPaths.has(variant)) {
+          missing.push({
+            file: variant,
+            reason: `Type file for ${changed.relativePath} \u2014 may need updates`,
+            severity: changed.hasExportChanges ? "high" : "medium",
+            relatedChangedFile: changed.relativePath,
+            relationship: "sibling-type"
+          });
+        }
+      }
+    }
+    const testVariants = [
+      changed.relativePath.replace(/\.([^.]+)$/, ".test.$1"),
+      changed.relativePath.replace(/\.([^.]+)$/, ".spec.$1"),
+      changed.relativePath.replace(/^src\//, "tests/").replace(/\.([^.]+)$/, ".test.$1"),
+      changed.relativePath.replace(/^src\//, "__tests__/").replace(/\.([^.]+)$/, ".test.$1")
+    ];
+    for (const testPath of testVariants) {
+      if (fileMap.has(testPath) && !changedPaths.has(testPath)) {
+        missing.push({
+          file: testPath,
+          reason: `Test file for ${changed.relativePath} \u2014 should be updated`,
+          severity: "medium",
+          relatedChangedFile: changed.relativePath,
+          relationship: "test"
+        });
+        break;
+      }
+    }
+    if (changed.hasExportChanges) {
+      const importers = analysis.files.filter(
+        (f) => f.imports.includes(af.relativePath) && !changedPaths.has(f.relativePath)
+      );
+      for (const importer of importers.slice(0, 5)) {
+        missing.push({
+          file: importer.relativePath,
+          reason: `Imports ${changed.relativePath} which has export changes`,
+          severity: "high",
+          relatedChangedFile: changed.relativePath,
+          relationship: "imported-by"
+        });
+      }
+    }
+    const dir = dirname4(changed.relativePath);
+    const indexFile = `${dir}/index.ts`;
+    if (fileMap.has(indexFile) && !changedPaths.has(indexFile) && changed.hasExportChanges) {
+      missing.push({
+        file: indexFile,
+        reason: `Barrel export may need updating after changes to ${changed.relativePath}`,
+        severity: "medium",
+        relatedChangedFile: changed.relativePath,
+        relationship: "co-located"
+      });
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return missing.filter((m) => {
+    if (seen.has(m.file)) return false;
+    seen.add(m.file);
+    return true;
+  }).sort((a, b) => {
+    const sev = { high: 0, medium: 1, low: 2 };
+    return sev[a.severity] - sev[b.severity];
+  });
+}
+function computeImpactRadius(changedFiles, analysis, depth) {
+  const changedPaths = changedFiles.map((f) => f.relativePath);
+  const adj = buildAdjacencyList(analysis.graph.edges);
+  const direct = /* @__PURE__ */ new Set();
+  for (const path of changedPaths) {
+    const importers = adj.reverse.get(path) ?? [];
+    const imports = adj.forward.get(path) ?? [];
+    for (const n of [...importers, ...imports]) {
+      if (!changedPaths.includes(n)) direct.add(n);
+    }
+  }
+  const allAffected = bfsBidirectional(changedPaths, adj, depth);
+  const transitive = /* @__PURE__ */ new Set();
+  for (const path of allAffected) {
+    if (!changedPaths.includes(path) && !direct.has(path)) {
+      transitive.add(path);
+    }
+  }
+  const affectedTests = [...allAffected].filter((p) => {
+    const f = analysis.files.find((af) => af.relativePath === p);
+    return f?.kind === "test";
+  }).length;
+  const hotspots = changedFiles.map((f) => ({
+    file: f.relativePath,
+    dependents: adj.reverse.get(f.relativePath)?.length ?? 0,
+    riskScore: f.riskScore
+  })).sort((a, b) => b.dependents * b.riskScore - a.dependents * a.riskScore).slice(0, 5);
+  const totalAffected = direct.size + transitive.size;
+  const maxRisk = Math.max(...changedFiles.map((f) => f.riskScore), 0);
+  const avgRisk = changedFiles.length > 0 ? changedFiles.reduce((s, f) => s + f.riskScore, 0) / changedFiles.length : 0;
+  const riskScore = Math.min(100, Math.round(
+    avgRisk * 0.3 + maxRisk * 0.2 + Math.min(100, totalAffected * 3) * 0.3 + Math.min(100, changedFiles.length * 5) * 0.2
+  ));
+  return {
+    directlyAffected: direct.size,
+    transitivelyAffected: transitive.size,
+    totalAffected,
+    affectedTests,
+    riskScore,
+    hotspots
+  };
+}
+function calculateReviewQuality(changedFiles, breakingChanges, missingFiles, impactRadius, totalLinesChanged) {
+  const factors = [];
+  const sizeScore = totalLinesChanged <= 50 ? 100 : totalLinesChanged <= 200 ? 85 : totalLinesChanged <= 500 ? 65 : totalLinesChanged <= 1e3 ? 40 : 20;
+  factors.push({
+    name: "PR Size",
+    score: sizeScore,
+    weight: 0.25,
+    detail: `${totalLinesChanged} lines changed \u2014 ${sizeScore >= 80 ? "easy" : sizeScore >= 50 ? "manageable" : "too large"} to review`
+  });
+  const focusScore = changedFiles.length <= 3 ? 100 : changedFiles.length <= 8 ? 80 : changedFiles.length <= 15 ? 55 : 25;
+  factors.push({
+    name: "Focus",
+    score: focusScore,
+    weight: 0.2,
+    detail: `${changedFiles.length} files \u2014 ${focusScore >= 80 ? "focused" : focusScore >= 50 ? "moderate scope" : "unfocused"}`
+  });
+  const criticalBreaks = breakingChanges.filter((b) => b.severity === "critical").length;
+  const highBreaks = breakingChanges.filter((b) => b.severity === "high").length;
+  const breakScore = criticalBreaks > 0 ? 10 : highBreaks > 2 ? 30 : highBreaks > 0 ? 60 : breakingChanges.length > 0 ? 80 : 100;
+  factors.push({
+    name: "Breaking Changes",
+    score: breakScore,
+    weight: 0.25,
+    detail: `${breakingChanges.length} breaking changes (${criticalBreaks} critical, ${highBreaks} high)`
+  });
+  const highMissing = missingFiles.filter((m) => m.severity === "high").length;
+  const completenessScore = highMissing > 3 ? 20 : highMissing > 0 ? 50 : missingFiles.length > 3 ? 65 : missingFiles.length > 0 ? 80 : 100;
+  factors.push({
+    name: "Completeness",
+    score: completenessScore,
+    weight: 0.15,
+    detail: `${missingFiles.length} potentially missing files (${highMissing} high priority)`
+  });
+  const radiusScore = impactRadius.totalAffected <= 5 ? 100 : impactRadius.totalAffected <= 15 ? 75 : impactRadius.totalAffected <= 30 ? 50 : 25;
+  factors.push({
+    name: "Blast Radius",
+    score: radiusScore,
+    weight: 0.15,
+    detail: `${impactRadius.totalAffected} files affected (${impactRadius.directlyAffected} direct, ${impactRadius.transitivelyAffected} transitive)`
+  });
+  const overall = Math.round(factors.reduce((s, f) => s + f.score * f.weight, 0));
+  const grade = overall >= 95 ? "A+" : overall >= 90 ? "A" : overall >= 85 ? "A-" : overall >= 80 ? "B+" : overall >= 75 ? "B" : overall >= 70 ? "B-" : overall >= 65 ? "C+" : overall >= 60 ? "C" : overall >= 55 ? "C-" : overall >= 50 ? "D+" : overall >= 45 ? "D" : overall >= 40 ? "D-" : "F";
+  return { score: overall, grade, factors };
+}
+async function generateReviewPrompt(changedFiles, breakingChanges, missingFiles, analysis, projectPath, maxFiles) {
+  const lines = [];
+  lines.push("# Code Review Context");
+  lines.push("");
+  lines.push("## Project: " + analysis.projectName);
+  lines.push("## Stack: " + analysis.stack.join(", "));
+  lines.push("");
+  if (breakingChanges.length > 0) {
+    lines.push("## \u26A0\uFE0F BREAKING CHANGES DETECTED");
+    lines.push("");
+    for (const bc of breakingChanges) {
+      lines.push("- **" + bc.severity.toUpperCase() + "** " + bc.file + ": " + bc.description);
+      if (bc.affectedFiles.length > 0) {
+        lines.push("  Affected: " + bc.affectedFiles.slice(0, 5).join(", "));
+      }
+    }
+    lines.push("");
+  }
+  if (missingFiles.length > 0) {
+    lines.push("## \u{1F4CB} Potentially Missing Files");
+    lines.push("");
+    for (const mf of missingFiles.slice(0, 10)) {
+      lines.push("- " + mf.file + " \u2014 " + mf.reason);
+    }
+    lines.push("");
+  }
+  lines.push("## Changed Files");
+  lines.push("");
+  const topFiles = changedFiles.slice(0, maxFiles);
+  for (const file of topFiles) {
+    const icon = file.changeType === "added" ? "\u{1F195}" : file.changeType === "deleted" ? "\u{1F5D1}\uFE0F" : "\u{1F4DD}";
+    lines.push("### " + icon + " " + file.relativePath + " (risk: " + file.riskScore + ", " + file.kind + ")");
+    lines.push("+" + file.linesAdded + "/-" + file.linesRemoved + " lines");
+    lines.push("");
+    if (file.riskScore >= 40 && file.changeType !== "deleted") {
+      try {
+        const content = await readFile10(resolve9(projectPath, file.relativePath), "utf-8");
+        const ext = file.relativePath.split(".").pop() ?? "";
+        const maxChars = 4e3;
+        const truncated = content.length > maxChars;
+        lines.push("```" + ext);
+        lines.push(content.slice(0, maxChars));
+        if (truncated) lines.push("// ... [truncated]");
+        lines.push("```");
+        lines.push("");
+      } catch {
+      }
+    }
+  }
+  lines.push("## Review Instructions");
+  lines.push("");
+  lines.push("1. Check breaking changes above for correctness");
+  lines.push("2. Verify all affected files have been updated");
+  lines.push("3. Review changed files for bugs, security issues, and code quality");
+  lines.push("4. Ensure tests cover the changes");
+  if (missingFiles.length > 0) {
+    lines.push('5. Consider whether the "potentially missing files" need updates');
+  }
+  return lines.join("\n");
+}
+function renderReviewSummary(branch, baseBranch, changedFiles, breakingChanges, missingFiles, impactRadius, reviewQuality) {
+  const lines = [];
+  const qIcon = reviewQuality.score >= 80 ? "\u{1F7E2}" : reviewQuality.score >= 60 ? "\u{1F7E1}" : "\u{1F534}";
+  lines.push("");
+  lines.push("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  lines.push("  " + qIcon + " Code Review: " + reviewQuality.score + "/100 (" + reviewQuality.grade + ")");
+  lines.push("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  lines.push("");
+  lines.push("  Branch: " + branch + " \u2190 " + baseBranch);
+  lines.push("  Files: " + changedFiles.length + " changed");
+  lines.push("  Lines: +" + changedFiles.reduce((s, f) => s + f.linesAdded, 0) + "/-" + changedFiles.reduce((s, f) => s + f.linesRemoved, 0));
+  lines.push("");
+  for (const f of reviewQuality.factors) {
+    const icon = f.score >= 80 ? "\u2705" : f.score >= 50 ? "\u26A0\uFE0F" : "\u274C";
+    lines.push("  " + icon + " " + f.name + ": " + f.score + "/100 \u2014 " + f.detail);
+  }
+  if (breakingChanges.length > 0) {
+    lines.push("");
+    lines.push("  \u26A0\uFE0F  BREAKING CHANGES (" + breakingChanges.length + "):");
+    for (const bc of breakingChanges.slice(0, 5)) {
+      const icon = bc.severity === "critical" ? "\u{1F534}" : bc.severity === "high" ? "\u{1F7E0}" : "\u{1F7E1}";
+      lines.push("    " + icon + " " + bc.file + ": " + bc.description);
+    }
+  }
+  if (missingFiles.length > 0) {
+    lines.push("");
+    lines.push("  \u{1F4CB} Potentially missing (" + missingFiles.length + "):");
+    for (const mf of missingFiles.slice(0, 5)) {
+      lines.push("    \u2192 " + mf.file + " (" + mf.reason + ")");
+    }
+  }
+  lines.push("");
+  lines.push("  \u{1F4A5} Impact: " + impactRadius.totalAffected + " files affected (" + impactRadius.directlyAffected + " direct, " + impactRadius.transitivelyAffected + " transitive)");
+  if (impactRadius.affectedTests > 0) {
+    lines.push("  \u{1F9EA} Tests: " + impactRadius.affectedTests + " test files in blast radius");
+  }
+  if (impactRadius.hotspots.length > 0) {
+    lines.push("");
+    lines.push("  \u{1F525} Hotspots:");
+    for (const h of impactRadius.hotspots.slice(0, 3)) {
+      lines.push("    " + h.file + " (risk: " + h.riskScore + ", " + h.dependents + " dependents)");
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function emptyResult2(baseBranch) {
+  return {
+    branch: "",
+    baseBranch,
+    isGitRepo: false,
+    changedFiles: [],
+    totalLinesChanged: 0,
+    breakingChanges: [],
+    missingFiles: [],
+    impactRadius: {
+      directlyAffected: 0,
+      transitivelyAffected: 0,
+      totalAffected: 0,
+      affectedTests: 0,
+      riskScore: 0,
+      hotspots: []
+    },
+    reviewQuality: {
+      score: 0,
+      grade: "F",
+      factors: []
+    },
+    reviewPrompt: "",
+    renderedSummary: "# Code Review\n\nNot a git repository."
+  };
+}
+
 // src/cli/score.ts
 async function main() {
   const args = process.argv.slice(2);
@@ -4318,6 +5341,9 @@ async function main() {
   const monorepoMode = args.includes("--monorepo");
   const gatewayMode = args.includes("--gateway");
   const ciMode = args.includes("--ci");
+  const learnMode = args.includes("--learn") || args.includes("--feedback");
+  const predictMode = args.includes("--predict");
+  const reviewMode = args.includes("--review");
   const helpMode = args.includes("--help") || args.includes("-h");
   const pkgIdx = args.indexOf("--package");
   const targetPackage = pkgIdx !== -1 && args[pkgIdx + 1] ? args[pkgIdx + 1] : null;
@@ -4326,7 +5352,7 @@ async function main() {
   const contextIdx = args.indexOf("--context");
   const contextTask = contextIdx !== -1 && args[contextIdx + 1] ? args[contextIdx + 1] : null;
   const pathArg = args.find((a) => !a.startsWith("--") && !a.startsWith("-") && a !== contextTask && a !== targetPackage);
-  const projectPath = resolve7(pathArg ?? ".");
+  const projectPath = resolve11(pathArg ?? ".");
   if (helpMode) {
     console.log(`
   \u26A1 cto-score \u2014 How AI-ready is your codebase?
@@ -4363,6 +5389,15 @@ async function main() {
     npx cto-ai-cli --ci --threshold 80           Set minimum score (default: 70)
     npx cto-ai-cli --ci --json                   JSON output for CI pipelines
 
+  Phase 7 \u2014 Learning Mode:
+    npx cto-ai-cli --learn                       Show feedback model & cross-repo intelligence
+    npx cto-ai-cli --predict                     Predict relevant files for a task
+    npx cto-ai-cli --learn --json                Export learning data as JSON
+
+  Phase 8 \u2014 Code Review:
+    npx cto-ai-cli --review                      Smart PR review analysis
+    npx cto-ai-cli --review --json               JSON output for CI
+
   Options:
     npx cto-ai-cli --json                        Output as JSON (for CI/scripts)
 
@@ -4444,29 +5479,35 @@ async function main() {
     const score = await computeContextScore(analysis);
     const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
     if (jsonMode) {
-      console.log(JSON.stringify({
-        project: analysis.projectName,
-        files: analysis.totalFiles,
-        tokens: analysis.totalTokens,
-        score: score.overall,
-        grade: score.grade,
-        dimensions: {
-          efficiency: score.dimensions.efficiency.score,
-          coverage: score.dimensions.coverage.score,
-          riskControl: score.dimensions.riskControl.score,
-          structure: score.dimensions.structure.score,
-          governance: score.dimensions.governance.score
-        },
-        savings: {
-          percent: score.comparison.savedPercent,
-          monthlyUSD: score.comparison.monthlySavingsUSD,
-          tokensOptimized: score.comparison.optimizedTokens,
-          tokensNaive: score.comparison.naiveTokens
-        }
-      }, null, 2));
-      process.exit(0);
+      const hasModeFlag2 = learnMode || predictMode || reviewMode || ciMode;
+      if (!hasModeFlag2) {
+        console.log(JSON.stringify({
+          project: analysis.projectName,
+          files: analysis.totalFiles,
+          tokens: analysis.totalTokens,
+          score: score.overall,
+          grade: score.grade,
+          dimensions: {
+            efficiency: score.dimensions.efficiency.score,
+            coverage: score.dimensions.coverage.score,
+            riskControl: score.dimensions.riskControl.score,
+            structure: score.dimensions.structure.score,
+            governance: score.dimensions.governance.score
+          },
+          savings: {
+            percent: score.comparison.savedPercent,
+            monthlyUSD: score.comparison.monthlySavingsUSD,
+            tokensOptimized: score.comparison.optimizedTokens,
+            tokensNaive: score.comparison.naiveTokens
+          }
+        }, null, 2));
+        process.exit(0);
+      }
+    }
+    const hasModeFlag = learnMode || predictMode || reviewMode || ciMode;
+    if (!(jsonMode && hasModeFlag)) {
+      console.log(renderContextScore(score));
     }
-    console.log(renderContextScore(score));
     if (benchmarkMode) {
       const benchmark = await runBenchmark(analysis);
       console.log(renderBenchmark(benchmark));
@@ -4492,6 +5533,18 @@ async function main() {
     if (ciMode) {
       await runCIGate(projectPath, analysis, score, thresholdArg, jsonMode);
     }
+    if (learnMode) {
+      await runLearn(projectPath, analysis, jsonMode);
+    }
+    if (predictMode) {
+      await runPredict(projectPath, analysis, contextTask ?? "general code review", jsonMode);
+    }
+    if (reviewMode) {
+      await runReview(projectPath, analysis, jsonMode);
+    }
+    if (jsonMode && hasModeFlag) {
+      process.exit(0);
+    }
     console.log("");
     console.log(`  Scanned in ${elapsed}s \xB7 ${analysis.totalFiles} files \xB7 ${Math.round(analysis.totalTokens / 1e3)}K tokens`);
     console.log("");
@@ -4521,7 +5574,7 @@ async function main() {
   }
 }
 async function runFix(projectPath, analysis, score) {
-  const ctoDir = join8(projectPath, ".cto");
+  const ctoDir = join10(projectPath, ".cto");
   mkdirSync3(ctoDir, { recursive: true });
   const selection = await selectContext({
     task: "general code review and refactoring",
@@ -4580,7 +5633,7 @@ async function runFix(projectPath, analysis, score) {
 `;
   contextMd += `## Savings: ${score.comparison.savedPercent}% (${formatTokens(score.comparison.savedTokens)})
 `;
-  writeFileSync2(join8(ctoDir, "context.md"), contextMd);
+  writeFileSync2(join10(ctoDir, "context.md"), contextMd);
   const config = {
     version: "3.0",
     project: analysis.projectName,
@@ -4608,7 +5661,7 @@ async function runFix(projectPath, analysis, score) {
       impact: i.impact
     }))
   };
-  writeFileSync2(join8(ctoDir, "config.json"), JSON.stringify(config, null, 2));
+  writeFileSync2(join10(ctoDir, "config.json"), JSON.stringify(config, null, 2));
   const ignoreContent = [
     "# CTO AI-ignore \u2014 files that add noise to AI context",
     "# Generated by cto-ai-cli",
@@ -4634,7 +5687,7 @@ async function runFix(projectPath, analysis, score) {
     }).slice(0, 20).map((o) => `${o}  # orphan, low-risk`),
     ""
   ].join("\n");
-  writeFileSync2(join8(ctoDir, ".cteignore"), ignoreContent);
+  writeFileSync2(join10(ctoDir, ".cteignore"), ignoreContent);
   console.log("");
   console.log("  \u2705 Auto-fix complete! Generated:");
   console.log("");
@@ -4647,7 +5700,7 @@ async function runFix(projectPath, analysis, score) {
   console.log("");
 }
 async function runContext(projectPath, analysis, task) {
-  const ctoDir = join8(projectPath, ".cto");
+  const ctoDir = join10(projectPath, ".cto");
   mkdirSync3(ctoDir, { recursive: true });
   const selection = await selectContext({
     task,
@@ -4744,7 +5797,7 @@ ${content.slice(0, maxChars)}${truncated ? "\n// ... [truncated \u2014 " + (cont
   }
   const safeName = task.replace(/[^a-zA-Z0-9]/g, "-").toLowerCase().slice(0, 40);
   const filename = `context-${safeName}.md`;
-  writeFileSync2(join8(ctoDir, filename), contextMd);
+  writeFileSync2(join10(ctoDir, filename), contextMd);
   console.log("");
   console.log(`  \u2705 Task context generated!`);
   console.log("");
@@ -4837,9 +5890,9 @@ async function runReport(projectPath, analysis, score) {
 `;
   report += `*Run \`npx cto-ai-cli\` to generate your own report. [Learn more](https://npmjs.com/package/cto-ai-cli)*
 `;
-  const ctoDir = join8(projectPath, ".cto");
+  const ctoDir = join10(projectPath, ".cto");
   mkdirSync3(ctoDir, { recursive: true });
-  writeFileSync2(join8(ctoDir, "report.md"), report);
+  writeFileSync2(join10(ctoDir, "report.md"), report);
   console.log("");
   console.log("  \u2705 Report generated!");
   console.log("");
@@ -4982,12 +6035,12 @@ async function runAudit(projectPath, analysis, flags = {}) {
       console.log(`  ${icon} ${rec}`);
     }
   }
-  const ctoDir = join8(projectPath, ".cto");
-  const auditDir = join8(ctoDir, "audit");
+  const ctoDir = join10(projectPath, ".cto");
+  const auditDir = join10(ctoDir, "audit");
   mkdirSync3(auditDir, { recursive: true });
   const now = /* @__PURE__ */ new Date();
   const dateStr = now.toISOString().split("T")[0];
-  const logFile = join8(auditDir, `${dateStr}.jsonl`);
+  const logFile = join10(auditDir, `${dateStr}.jsonl`);
   const logEntry = {
     timestamp: now.toISOString(),
     version: "3.2.0",
@@ -5056,7 +6109,7 @@ async function runAudit(projectPath, analysis, flags = {}) {
 `;
     }
   }
-  writeFileSync2(join8(auditDir, "report.md"), report);
+  writeFileSync2(join10(auditDir, "report.md"), report);
   const envSecrets = findings.filter(
     (f) => f.type === "env-variable" || f.type === "password" || f.type === "api-key" || f.type === "aws-key" || f.type === "connection-string"
   );
@@ -5078,7 +6131,7 @@ async function runAudit(projectPath, analysis, flags = {}) {
         envExample += `${name}=your_${name.toLowerCase()}_here
 `;
       }
-      writeFileSync2(join8(ctoDir, ".env.example"), envExample);
+      writeFileSync2(join10(ctoDir, ".env.example"), envExample);
     }
   }
   console.log("");
@@ -5148,4 +6201,106 @@ async function runCIGate(projectPath, analysis, score, threshold, jsonMode) {
     process.exit(1);
   }
 }
+async function runLearn(projectPath, analysis, jsonMode) {
+  const feedbackModel = await loadFeedbackModel(projectPath);
+  const predictorModel = await loadModel(projectPath);
+  const predictorStats = getModelStats(predictorModel);
+  const globalModel = await loadGlobalModel();
+  const crossRepoStats = getCrossRepoStats(globalModel);
+  if (jsonMode) {
+    const exported = await exportFeedbackForTeam(projectPath, analysis.projectName);
+    console.log(JSON.stringify({
+      feedback: feedbackModel,
+      predictor: predictorStats,
+      crossRepo: crossRepoStats,
+      teamExport: exported
+    }, null, 2));
+    return;
+  }
+  console.log(renderFeedbackReport(feedbackModel));
+  console.log("");
+  console.log("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  console.log("  \u{1F9E0} Predictor Model");
+  console.log("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  console.log("");
+  console.log(`  Observations:     ${predictorStats.observations}`);
+  console.log(`  Task types:       ${predictorStats.taskTypes}`);
+  console.log(`  Keywords:         ${predictorStats.keywords}`);
+  console.log(`  Tracked files:    ${predictorStats.trackedFiles}`);
+  console.log(`  Co-selection:     ${predictorStats.coSelectionPairs} pairs`);
+  console.log(`  Last trained:     ${predictorStats.trainedAt || "never"}`);
+  console.log("");
+  console.log(renderCrossRepoReport(crossRepoStats));
+  if (feedbackModel.insights.length > 0) {
+    console.log("");
+    console.log("  \u{1F4A1} Top Insights:");
+    console.log("");
+    for (const insight of feedbackModel.insights.slice(0, 8)) {
+      const icon = insight.type === "positive" ? "\u2705" : insight.type === "negative" ? "\u26A0\uFE0F" : "\u{1F4A1}";
+      console.log(`  ${icon} ${insight.title}`);
+      console.log(`     ${insight.detail}`);
+    }
+    console.log("");
+  }
+  const strategies = Object.entries(feedbackModel.strategyComparison);
+  if (strategies.length > 1) {
+    console.log("");
+    console.log("  \u{1F52C} A/B Strategy Comparison:");
+    console.log("");
+    for (const [name, sc] of strategies) {
+      console.log(`  ${name}: ${Math.round(sc.acceptRate * 100)}% accept (n=${sc.totalCount}), avg ${Math.round(sc.avgTimeToAccept / 1e3)}s`);
+    }
+    console.log("");
+  }
+}
+async function runPredict(projectPath, analysis, task, jsonMode) {
+  const predictions = await predictRelevantFiles(projectPath, task, analysis);
+  if (jsonMode) {
+    console.log(JSON.stringify({ task, predictions }, null, 2));
+    return;
+  }
+  console.log("");
+  console.log("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  console.log(`  \u{1F52E} Predictions for: "${task}"`);
+  console.log("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  console.log("");
+  if (predictions.length === 0) {
+    console.log("  Not enough learning data yet. Use the tool more and run --learn to see insights.");
+    console.log("");
+    return;
+  }
+  for (const p of predictions.slice(0, 15)) {
+    const bar = "\u2588".repeat(Math.round(p.predictedScore / 5)) + "\u2591".repeat(Math.max(0, 20 - Math.round(p.predictedScore / 5)));
+    console.log(`  ${bar} ${p.predictedScore.toFixed(1).padStart(5)}  ${p.filePath}`);
+    if (p.reasons.length > 0) {
+      console.log(`                           ${p.reasons[0]}`);
+    }
+  }
+  console.log("");
+  console.log(`  ${predictions.length} files predicted as relevant.`);
+  console.log("");
+}
+async function runReview(projectPath, analysis, jsonMode) {
+  const result = await analyzeForReview(analysis);
+  if (jsonMode) {
+    console.log(JSON.stringify({
+      branch: result.branch,
+      baseBranch: result.baseBranch,
+      changedFiles: result.changedFiles.length,
+      totalLinesChanged: result.totalLinesChanged,
+      breakingChanges: result.breakingChanges,
+      missingFiles: result.missingFiles,
+      impactRadius: result.impactRadius,
+      reviewQuality: result.reviewQuality
+    }, null, 2));
+    return;
+  }
+  console.log(result.renderedSummary);
+  const ctoDir = join10(projectPath, ".cto");
+  mkdirSync3(ctoDir, { recursive: true });
+  writeFileSync2(join10(ctoDir, "review-prompt.md"), result.reviewPrompt);
+  console.log("  \u{1F4CB} Review prompt saved: .cto/review-prompt.md");
+  console.log("     Paste it into Claude/Cursor for an AI-powered code review.");
+  console.log("");
+}
 main();