cto-ai-cli 4.0.0 → 5.1.0

package/dist/cli/gateway.js

@@ -97,7 +97,8 @@ var GOOGLE_MODELS = [
   { id: "gemini-1.5-pro", contextWindow: 2e6, costPerMInput: 1.25, costPerMOutput: 5, maxOutput: 8192 }
 ];
 function parseOpenAIRequest(body) {
-  const messages = (body.messages || []).map((m) => ({
+  const rawMessages = Array.isArray(body.messages) ? body.messages : [];
+  const messages = rawMessages.map((m) => ({
     role: m.role || "user",
     content: typeof m.content === "string" ? m.content : JSON.stringify(m.content)
   }));
@@ -109,34 +110,29 @@ function parseOpenAIRequest(body) {
     temperature: body.temperature
   };
 }
-function parseOpenAIResponse(body, streaming) {
-  if (streaming) {
-    return {
-      model: body.model || "unknown",
-      inputTokens: body.usage?.prompt_tokens || 0,
-      outputTokens: body.usage?.completion_tokens || 0,
-      content: body.choices?.[0]?.message?.content || "",
-      finishReason: body.choices?.[0]?.finish_reason || "stop"
-    };
-  }
+function parseOpenAIResponse(body, _streaming) {
+  const usage = body.usage;
+  const choices = Array.isArray(body.choices) ? body.choices : [];
+  const first = choices[0];
+  const msg = first?.message;
   return {
     model: body.model || "unknown",
-    inputTokens: body.usage?.prompt_tokens || 0,
-    outputTokens: body.usage?.completion_tokens || 0,
-    content: body.choices?.[0]?.message?.content || "",
-    finishReason: body.choices?.[0]?.finish_reason || "stop"
+    inputTokens: usage?.prompt_tokens || 0,
+    outputTokens: usage?.completion_tokens || 0,
+    content: msg?.content || "",
+    finishReason: first?.finish_reason || "stop"
   };
 }
 function parseAnthropicRequest(body) {
   const messages = [];
   if (body.system) {
-    messages.push({ role: "system", content: body.system });
+    messages.push({ role: "system", content: String(body.system) });
   }
-  for (const m of body.messages || []) {
-    messages.push({
-      role: m.role || "user",
-      content: typeof m.content === "string" ? m.content : m.content?.map((b) => b.text || "").join("\n") || ""
-    });
+  const rawMessages = Array.isArray(body.messages) ? body.messages : [];
+  for (const m of rawMessages) {
+    const content = typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.map((b) => String(b.text ?? "")).join("\n") : "";
+    const role = m.role || "user";
+    messages.push({ role, content });
   }
   return {
     model: body.model || "unknown",
@@ -147,43 +143,53 @@ function parseAnthropicRequest(body) {
   };
 }
 function parseAnthropicResponse(body, _streaming) {
+  const usage = body.usage;
+  const contentBlocks = Array.isArray(body.content) ? body.content : [];
   return {
     model: body.model || "unknown",
-    inputTokens: body.usage?.input_tokens || 0,
-    outputTokens: body.usage?.output_tokens || 0,
-    content: body.content?.map((b) => b.text || "").join("\n") || "",
+    inputTokens: usage?.input_tokens || 0,
+    outputTokens: usage?.output_tokens || 0,
+    content: contentBlocks.map((b) => String(b.text ?? "")).join("\n"),
     finishReason: body.stop_reason || "end_turn"
   };
 }
 function parseGoogleRequest(body) {
   const messages = [];
-  if (body.systemInstruction?.parts) {
+  const sysInst = body.systemInstruction;
+  if (sysInst && Array.isArray(sysInst.parts)) {
     messages.push({
       role: "system",
-      content: body.systemInstruction.parts.map((p) => p.text || "").join("\n")
+      content: sysInst.parts.map((p) => String(p.text ?? "")).join("\n")
     });
   }
-  for (const item of body.contents || []) {
+  const contents = Array.isArray(body.contents) ? body.contents : [];
+  for (const item of contents) {
     const role = item.role === "model" ? "assistant" : "user";
-    const content = item.parts?.map((p) => p.text || "").join("\n") || "";
+    const parts = Array.isArray(item.parts) ? item.parts : [];
+    const content = parts.map((p) => String(p.text ?? "")).join("\n");
     messages.push({ role, content });
   }
   const model = body.model || body.modelId || "gemini-2.0-flash";
+  const genConfig = body.generationConfig;
   return {
     model,
     messages,
     stream: body.stream === true,
-    maxTokens: body.generationConfig?.maxOutputTokens,
-    temperature: body.generationConfig?.temperature
+    maxTokens: genConfig?.maxOutputTokens,
+    temperature: genConfig?.temperature
   };
 }
 function parseGoogleResponse(body, _streaming) {
-  const candidate = body.candidates?.[0];
+  const candidates = Array.isArray(body.candidates) ? body.candidates : [];
+  const candidate = candidates[0];
+  const usage = body.usageMetadata;
+  const candidateContent = candidate?.content;
+  const parts = Array.isArray(candidateContent?.parts) ? candidateContent.parts : [];
   return {
     model: body.modelVersion || body.model || "gemini-2.0-flash",
-    inputTokens: body.usageMetadata?.promptTokenCount || 0,
-    outputTokens: body.usageMetadata?.candidatesTokenCount || 0,
-    content: candidate?.content?.parts?.map((p) => p.text || "").join("\n") || "",
+    inputTokens: usage?.promptTokenCount || 0,
+    outputTokens: usage?.candidatesTokenCount || 0,
+    content: parts.map((p) => String(p.text ?? "")).join("\n"),
     finishReason: candidate?.finishReason || "STOP"
   };
 }
@@ -483,10 +489,7 @@ function deduplicateFindings(findings) {
 import { createHash as createHash2 } from "crypto";
 
 // src/engine/pruner.ts
-import { Project, SyntaxKind } from "ts-morph";
 import { readFile as readFile3 } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
 
 // src/engine/tokenizer.ts
 import { encodingForModel } from "js-tiktoken";
@@ -541,23 +544,7 @@ async function pruneTypeScript(file, level) {
   } catch {
     return emptyResult(file, level);
   }
-  let project;
-  try {
-    const tsConfigPath = findTsConfig(file.path);
-    project = new Project({
-      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 {
@@ -569,131 +556,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() === SyntaxKind.ArrowFunction || init.getKind() === SyntaxKind.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;
+    }
+    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;
     }
-  }
-  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 (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 {
@@ -754,22 +891,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 = join2(dir, "..");
-    const candidate = join2(dir, "tsconfig.json");
-    if (existsSync2(candidate)) return candidate;
-  }
-  return void 0;
-}
 
 // src/engine/graph-utils.ts
 function buildAdjacencyList(edges) {
@@ -1286,14 +1407,15 @@ async function optimizeContext(messages, analysis, config) {
     );
     return { messages: optimizedMessages, injected: true, optimizeDecisions };
   } catch (err) {
-    optimizeDecisions.push(`Context optimization failed: ${err.message}`);
+    const errMsg = err instanceof Error ? err.message : String(err);
+    optimizeDecisions.push(`Context optimization failed: ${errMsg}`);
     return { messages, injected: false, optimizeDecisions };
   }
 }
 
 // src/gateway/tracker.ts
-import { mkdirSync as mkdirSync2, appendFileSync, readFileSync as readFileSync3, readdirSync, existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
+import { mkdirSync as mkdirSync2, appendFileSync, readFileSync as readFileSync3, readdirSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
 import { randomUUID } from "crypto";
 var UsageTracker = class {
   logDir;
@@ -1305,7 +1427,7 @@ var UsageTracker = class {
   memRecords = [];
   constructor(config) {
     this.config = config;
-    this.logDir = join3(config.logDir, "usage");
+    this.logDir = join2(config.logDir, "usage");
     mkdirSync2(this.logDir, { recursive: true });
   }
   // ===== EVENT SYSTEM =====
@@ -1328,7 +1450,7 @@ var UsageTracker = class {
       ...params
     };
     const monthKey = this.getMonthKey(record.timestamp);
-    const logFile = join3(this.logDir, `${monthKey}.jsonl`);
+    const logFile = join2(this.logDir, `${monthKey}.jsonl`);
     const line = JSON.stringify({
       ...record,
       timestamp: record.timestamp.toISOString()
@@ -1462,8 +1584,8 @@ var UsageTracker = class {
     return date.toISOString().slice(0, 7);
   }
   getMonthRecordsByKey(monthKey) {
-    const filePath = join3(this.logDir, `${monthKey}.jsonl`);
-    if (!existsSync3(filePath)) return [];
+    const filePath = join2(this.logDir, `${monthKey}.jsonl`);
+    if (!existsSync2(filePath)) return [];
     return readFileSync3(filePath, "utf-8").split("\n").filter((line) => line.trim()).map((line) => {
       try {
         const parsed = JSON.parse(line);
@@ -1477,8 +1599,8 @@ var UsageTracker = class {
   getMonthRecords(date) {
     const monthKey = this.getMonthKey(date);
     if (this.cache && this.cacheMonth === monthKey) return this.cache;
-    const filePath = join3(this.logDir, `${monthKey}.jsonl`);
-    if (!existsSync3(filePath)) return [];
+    const filePath = join2(this.logDir, `${monthKey}.jsonl`);
+    if (!existsSync2(filePath)) return [];
     const records = readFileSync3(filePath, "utf-8").split("\n").filter((line) => line.trim()).map((line) => {
       try {
         const parsed = JSON.parse(line);
@@ -1493,11 +1615,11 @@ var UsageTracker = class {
     return records;
   }
   getAllRecords() {
-    if (!existsSync3(this.logDir)) return [];
+    if (!existsSync2(this.logDir)) return [];
     const files = readdirSync(this.logDir).filter((f) => f.endsWith(".jsonl")).sort();
     const allRecords = [];
     for (const file of files) {
-      const content = readFileSync3(join3(this.logDir, file), "utf-8");
+      const content = readFileSync3(join2(this.logDir, file), "utf-8");
       const records = content.split("\n").filter((line) => line.trim()).map((line) => {
         try {
           const parsed = JSON.parse(line);
@@ -1515,7 +1637,7 @@ var UsageTracker = class {
 
 // src/engine/analyzer.ts
 import { readFile as readFile4, readdir, stat as stat2 } from "fs/promises";
-import { join as join5, extname, relative as relative3, resolve as resolve4, basename as basename2 } from "path";
+import { join as join4, extname, relative as relative3, resolve as resolve4, basename as basename2 } from "path";
 import { createHash as createHash3 } from "crypto";
 
 // src/types/engine.ts
@@ -1568,14 +1690,14 @@ var DEFAULT_CONFIG = {
 };
 
 // src/engine/graph.ts
-import { Project as Project2, SyntaxKind as SyntaxKind2 } from "ts-morph";
-import { resolve as resolve3, relative as relative2, dirname as dirname2, join as join4 } from "path";
-import { existsSync as existsSync4 } from "fs";
+import { Project, SyntaxKind } from "ts-morph";
+import { resolve as resolve3, relative as relative2, dirname as dirname2, join as join3 } from "path";
+import { existsSync as existsSync3 } from "fs";
 var TS_EXTENSIONS2 = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "mts", "mjs", "cts", "cjs"]);
 function createProject(projectPath, filePaths) {
-  const tsConfigPath = join4(projectPath, "tsconfig.json");
-  const hasTsConfig = existsSync4(tsConfigPath);
-  const project = new Project2({
+  const tsConfigPath = join3(projectPath, "tsconfig.json");
+  const hasTsConfig = existsSync3(tsConfigPath);
+  const project = new Project({
     tsConfigFilePath: hasTsConfig ? tsConfigPath : void 0,
     skipAddingFilesFromTsConfig: true,
     compilerOptions: hasTsConfig ? void 0 : {
@@ -1775,7 +1897,7 @@ function enrichComplexity(project, absPath, files) {
     }
     for (const varDecl of sourceFile.getVariableDeclarations()) {
       const init = varDecl.getInitializer();
-      if (init && (init.getKind() === SyntaxKind2.ArrowFunction || init.getKind() === SyntaxKind2.FunctionExpression)) {
+      if (init && (init.getKind() === SyntaxKind.ArrowFunction || init.getKind() === SyntaxKind.FunctionExpression)) {
         totalComplexity += calculateCyclomaticComplexity(init);
       }
     }
@@ -1786,22 +1908,22 @@ function calculateCyclomaticComplexity(node) {
   let complexity = 1;
   node.forEachDescendant((descendant) => {
     switch (descendant.getKind()) {
-      case SyntaxKind2.IfStatement:
-      case SyntaxKind2.ConditionalExpression:
-      case SyntaxKind2.ForStatement:
-      case SyntaxKind2.ForInStatement:
-      case SyntaxKind2.ForOfStatement:
-      case SyntaxKind2.WhileStatement:
-      case SyntaxKind2.DoStatement:
-      case SyntaxKind2.CaseClause:
-      case SyntaxKind2.CatchClause:
+      case SyntaxKind.IfStatement:
+      case SyntaxKind.ConditionalExpression:
+      case SyntaxKind.ForStatement:
+      case SyntaxKind.ForInStatement:
+      case SyntaxKind.ForOfStatement:
+      case SyntaxKind.WhileStatement:
+      case SyntaxKind.DoStatement:
+      case SyntaxKind.CaseClause:
+      case SyntaxKind.CatchClause:
         complexity++;
         break;
-      case SyntaxKind2.BinaryExpression: {
+      case SyntaxKind.BinaryExpression: {
         const opToken = descendant.getOperatorToken?.();
         if (opToken) {
           const kind = opToken.getKind();
-          if (kind === SyntaxKind2.AmpersandAmpersandToken || kind === SyntaxKind2.BarBarToken || kind === SyntaxKind2.QuestionQuestionToken) {
+          if (kind === SyntaxKind.AmpersandAmpersandToken || kind === SyntaxKind.BarBarToken || kind === SyntaxKind.QuestionQuestionToken) {
             complexity++;
           }
         }
@@ -1818,14 +1940,14 @@ function resolveImport(sourceFile, moduleSpecifier, projectRoot) {
   const extensions = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
   for (const ext of extensions) {
     const candidate = basePath.endsWith(ext) ? basePath : basePath + ext;
-    if (existsSync4(candidate)) {
+    if (existsSync3(candidate)) {
       const rel = relative2(projectRoot, candidate);
       if (!rel.startsWith("..")) return rel;
     }
   }
   if (moduleSpecifier.endsWith(".js")) {
     const tsPath = basePath.replace(/\.js$/, ".ts");
-    if (existsSync4(tsPath)) {
+    if (existsSync3(tsPath)) {
       const rel = relative2(projectRoot, tsPath);
       if (!rel.startsWith("..")) return rel;
     }
@@ -1986,7 +2108,7 @@ async function walkProject(rootPath, options) {
     }
     const promises = [];
     for (const entry of entries) {
-      const fullPath = join5(dir, entry.name);
+      const fullPath = join4(dir, entry.name);
       if (entry.isDirectory()) {
         if (!ignoreDirSet.has(entry.name) && !entry.name.startsWith(".")) {
           promises.push(walk(fullPath, depth + 1));
@@ -2071,8 +2193,8 @@ async function analyzeProject(projectPath, config) {
     maxDepth: mergedConfig.analysis.maxDepth
   });
   const tokenMethod = mergedConfig.tokens.method;
-  const files = [];
-  for (const entry of walkEntries) {
+  const BATCH_SIZE = 50;
+  async function estimateFileTokens(entry) {
     let tokens;
     if (tokenMethod === "tiktoken") {
       try {
@@ -2084,7 +2206,7 @@ async function analyzeProject(projectPath, config) {
     } else {
       tokens = countTokensChars4(entry.size);
     }
-    files.push({
+    return {
       path: entry.path,
       relativePath: entry.relativePath,
       extension: entry.extension,
@@ -2093,16 +2215,20 @@ async function analyzeProject(projectPath, config) {
       lines: entry.lines,
       lastModified: entry.lastModified,
       kind: classifyFileKind(entry.relativePath),
-      // Graph data — populated by graph analysis
       imports: [],
       importedBy: [],
       isHub: false,
       complexity: 0,
-      // Risk data — populated by risk analysis
       riskScore: 0,
       riskFactors: [],
       exclusionImpact: "none"
-    });
+    };
+  }
+  const files = [];
+  for (let i = 0; i < walkEntries.length; i += BATCH_SIZE) {
+    const batch = walkEntries.slice(i, i + BATCH_SIZE);
+    const results = await Promise.all(batch.map(estimateFileTokens));
+    files.push(...results);
   }
   const graph = buildProjectGraph(absPath, files);
   for (const file of files) {
@@ -2248,7 +2374,8 @@ var ContextGateway = class {
       this.analysis = analysis;
       return analysis;
     } catch (err) {
-      this.emit({ type: "error", message: `Analysis failed: ${err.message}`, error: err });
+      const message = err instanceof Error ? err.message : String(err);
+      this.emit({ type: "error", message: `Analysis failed: ${message}`, error: err instanceof Error ? err : void 0 });
       throw err;
     }
   }
@@ -2285,7 +2412,8 @@ var ContextGateway = class {
     try {
       body = await readBody(req, this.config.maxBodyBytes);
     } catch (err) {
-      const status = err.message === "body-too-large" ? 413 : 400;
+      const errMsg = err instanceof Error ? err.message : String(err);
+      const status = errMsg === "body-too-large" ? 413 : 400;
       res.writeHead(status, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ error: status === 413 ? `Request body too large. Max: ${Math.round(this.config.maxBodyBytes / 1024 / 1024)}MB` : "Failed to read request body" }));
       return;
@@ -2396,12 +2524,13 @@ var ContextGateway = class {
     try {
       await this.proxyRequest(targetUrl, req, res, modifiedBody, provider, parsed, interceptResult, startTime);
     } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
       if (!res.headersSent) {
-        const status = err.message === "upstream-timeout" ? 504 : 502;
+        const status = errMsg === "upstream-timeout" ? 504 : 502;
         res.writeHead(status, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: status === 504 ? "Upstream provider timeout" : `Proxy error: ${err.message}` }));
+        res.end(JSON.stringify({ error: status === 504 ? "Upstream provider timeout" : `Proxy error: ${errMsg}` }));
       }
-      this.emit({ type: "error", message: `Proxy error: ${err.message}`, error: err });
+      this.emit({ type: "error", message: `Proxy error: ${errMsg}`, error: err instanceof Error ? err : void 0 });
     }
   }
   // ===== PROXY =====