@thoughtflow/codebase 0.2.0

package/src/tools/neural/neural-debug.tool.ts

@@ -0,0 +1,199 @@
+import { z } from "zod";
+import { ToolBase, ToolContext, ToolExecutionResult } from "@thoughtflow/core";
+import { DependencyExtractor } from "../../libs/codebase/graph/dependency-extractor";
+import { CodebaseExplorer } from "../../libs/codebase/indexer/explorer";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const DebugResultSchema = z.object({
+  errorType: z.string(),
+  rootCause: z.string(),
+  suggestedFix: z.string(),
+  codeFixExample: z.string().optional(),
+  affectedFiles: z.array(z.string()),
+  confidence: z.enum(["high", "medium", "low"]),
+});
+
+type DebugResult = z.infer<typeof DebugResultSchema>;
+
+export class NeuralDebugTool extends ToolBase {
+  readonly name = "neuralDebug";
+  readonly description = "Analyze a stack trace or error against the codebase to suggest a fix. Parses stack frames, finds relevant source files, extracts context, and uses LLM to propose solutions.";
+  override readonly readonly = true;
+
+  constructor() {
+    super(z.object({
+      error: z.string().describe("Stack trace or error message"),
+      projectPath: z.string().optional(),
+      maxFrames: z.number().optional().describe("Max stack frames to analyze"),
+    }));
+  }
+
+  async run(input: Record<string, unknown>, ctx: ToolContext): Promise<ToolExecutionResult> {
+    const { error, maxFrames } = input as { error: string; projectPath?: string; maxFrames?: number };
+    const rootPath = (input.projectPath as string) ?? process.cwd();
+    const max = maxFrames ?? 5;
+
+    const frames = this.parseStackTrace(error, rootPath);
+    const relevantFrames = frames.slice(0, max);
+
+    const analysis: Array<{ file: string; line: number; column?: number; context: string; suggestions: string[] }> = [];
+
+    for (const frame of relevantFrames) {
+      const absolutePath = path.join(rootPath, frame.file);
+      if (!fs.existsSync(absolutePath)) continue;
+
+      const content = fs.readFileSync(absolutePath, "utf8");
+      const lines = content.split("\n");
+      const start = Math.max(0, frame.line - 10);
+      const end = Math.min(lines.length, frame.line + 10);
+      const context = lines.slice(start, end)
+        .map((l, i) => `${start + i + 1}: ${l}`)
+        .join("\n");
+
+      const suggestions = this.staticAnalyzeContext(lines, frame.line, frame.message);
+
+      analysis.push({ file: frame.file, line: frame.line, column: frame.column, context, suggestions });
+    }
+
+    const explorer = new CodebaseExplorer();
+    const files = explorer.explore({ rootPath });
+    const codeFiles = files.filter((f) => f.classification === "source-code")
+      .map((f) => ({ relativePath: f.relativePath, absolutePath: f.absolutePath }));
+
+    const depExtractor = new DependencyExtractor();
+    const graph = await depExtractor.buildGraph(codeFiles, rootPath);
+
+    const affectedFiles = new Set<string>();
+    for (const frame of relevantFrames) {
+      affectedFiles.add(frame.file);
+      const dependents = graph.edges.filter((e) => e.to === frame.file);
+      for (const dep of dependents.slice(0, 5)) {
+        affectedFiles.add(dep.from);
+      }
+    }
+
+    const callStructured = ctx.conversation?.callStructured;
+    if (!callStructured) {
+      return {
+        success: true,
+        output: JSON.stringify({
+          error: error.split("\n")[0],
+          framesAnalyzed: analysis.length,
+          totalFrames: frames.length,
+          affectedFiles: Array.from(affectedFiles).slice(0, 15),
+          analysis,
+          llmUsed: false,
+        }),
+      };
+    }
+
+    const codeContext = analysis
+      .map((a) => `=== ${a.file}:${a.line} ===\n${a.context}`)
+      .join("\n\n")
+      .slice(0, 8000);
+
+    const prompt = `You are an expert software debugger. Analyze the stack trace and source code context, then provide a structured root cause analysis, a concrete suggested fix with code example, and list of affected files.
+
+ERROR:
+${error}
+
+RELEVANT SOURCE CODE:
+${codeContext}
+
+STATIC ANALYSIS HINTS:
+${analysis.map((a) => `- ${a.file}:${a.line}: ${a.suggestions.join("; ")}`).join("\n")}`;
+
+    try {
+      const result = await callStructured(prompt, DebugResultSchema);
+
+      return {
+        success: true,
+        output: JSON.stringify({
+          ...result,
+          stackFrames: frames.length,
+          relevantFiles: relevantFrames.map((f) => f.file),
+          affectedFiles: Array.from(affectedFiles).slice(0, 15),
+          filesAnalyzed: analysis.length,
+          llmUsed: true,
+        }),
+      };
+    } catch {
+      return {
+        success: true,
+        output: JSON.stringify({
+          error: error.split("\n")[0],
+          stackFrames: frames.length,
+          relevantFiles: relevantFrames.map((f) => f.file),
+          affectedFiles: Array.from(affectedFiles).slice(0, 15),
+          analysis,
+          llmUsed: false,
+        }),
+      };
+    }
+  }
+
+  private parseStackTrace(error: string, rootPath: string): Array<{ file: string; line: number; column?: number; message: string }> {
+    const frames: Array<{ file: string; line: number; column?: number; message: string }> = [];
+    const lines = error.split("\n");
+    const message = lines[0];
+
+    const patterns = [
+      /at\s+(?:async\s+)?(?:\S+\s+)?\(?(.+?):(\d+):(\d+)\)?/g,
+      /at\s+(.+?):(\d+):(\d+)/g,
+    ];
+
+    for (const line of lines) {
+      for (const pattern of patterns) {
+        pattern.lastIndex = 0;
+        let match;
+        while ((match = pattern.exec(line)) !== null) {
+          const file = match[1].replace(/^file:\/\//, "");
+          const lineNum = parseInt(match[2], 10);
+          const col = match[3] ? parseInt(match[3], 10) : undefined;
+
+          if (file.includes("node_modules") || file.includes("node:")) continue;
+
+          const relative = file.startsWith(rootPath)
+            ? path.relative(rootPath, file)
+            : file;
+
+          frames.push({ file: relative, line: lineNum, column: col, message });
+        }
+      }
+    }
+
+    return frames;
+  }
+
+  private staticAnalyzeContext(lines: string[], lineNum: number, errorMsg: string): string[] {
+    const suggestions: string[] = [];
+    const targetLine = lines[lineNum - 1] ?? "";
+
+    if (targetLine.trim().startsWith("//") || targetLine.trim().startsWith("/*")) {
+      suggestions.push("Error on a comment line — check preceding/succeeding code");
+    }
+
+    if (targetLine.includes("undefined") || targetLine.includes("null")) {
+      suggestions.push("Possible null/undefined access — add null check or optional chaining");
+    }
+
+    if (targetLine.includes(".map(") || targetLine.includes(".filter(") || targetLine.includes(".find(")) {
+      suggestions.push("Array method may be called on undefined — ensure array is initialized");
+    }
+
+    if (targetLine.includes("await")) {
+      suggestions.push("Async operation — verify error handling with try/catch or .catch()");
+    }
+
+    if (targetLine.includes("import")) {
+      suggestions.push("Import resolution error — check file path, extension, and module existence");
+    }
+
+    if (suggestions.length === 0) {
+      suggestions.push("Review the surrounding context for variable initialization and error handling");
+    }
+
+    return suggestions;
+  }
+}

package/src/tools/neural/neural-explain.tool.ts

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { ToolBase, ToolContext, ToolExecutionResult } from "@thoughtflow/core";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export class NeuralExplainTool extends ToolBase {
+  readonly name = "neuralExplain";
+  readonly description = "Explain any code snippet, function, or file in natural language. Uses LLM to provide clear, educational explanations of what the code does, its purpose, and how it works.";
+  override readonly readonly = true;
+
+  constructor() {
+    super(z.object({
+      target: z.string().describe("File path, function name, or code snippet to explain"),
+      detail: z.enum(["brief", "detailed", "tutorial"]).optional().describe("Level of detail (default: detailed)"),
+      projectPath: z.string().optional(),
+    }));
+  }
+
+  async run(input: Record<string, unknown>, ctx: ToolContext): Promise<ToolExecutionResult> {
+    const { target, detail } = input as { target: string; detail?: string };
+    const rootPath = (input.projectPath as string) ?? process.cwd();
+    const level = detail ?? "detailed";
+
+    let codeToExplain = target;
+    const fullPath = path.join(rootPath, target);
+    try {
+      if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+        codeToExplain = fs.readFileSync(fullPath, "utf8").slice(0, 8000);
+      }
+    } catch {
+      /* use target as-is */
+    }
+
+    const callStructured = ctx.conversation?.callStructured;
+    if (!callStructured) {
+      return {
+        success: true,
+        output: JSON.stringify({
+          explanation: "LLM not available — raw code provided for manual review",
+          code: codeToExplain.slice(0, 500),
+          level,
+        }),
+      };
+    }
+
+    const prompt = level === "brief"
+      ? `Explain this code in 1-2 sentences:\n\n\`\`\`\n${codeToExplain}\n\`\`\``
+      : level === "tutorial"
+      ? `Explain this code as a step-by-step tutorial for beginners. Cover what it does, why each part exists, and how each piece works together:\n\n\`\`\`\n${codeToExplain}\n\`\`\``
+      : `Explain this code in detail — what it does, its purpose, key design decisions, and how it fits into the larger system. Cover the logic flow, data transformations, and any notable patterns:\n\n\`\`\`\n${codeToExplain}\n\`\`\``;
+
+    try {
+      const result = await callStructured(prompt, z.object({ explanation: z.string() }));
+      const data = result as { explanation?: string };
+      return { success: true, output: data.explanation ?? "No explanation generated" };
+    } catch (err) {
+      return {
+        success: true,
+        output: JSON.stringify({
+          explanation: `Failed to generate explanation: ${err instanceof Error ? err.message : "Unknown error"}`,
+          code: codeToExplain.slice(0, 500),
+          level,
+        }),
+      };
+    }
+  }
+}

package/src/tools/neural/neural-optimize.tool.ts

@@ -0,0 +1,93 @@
+import { z } from "zod";
+import { ToolBase, ToolContext, ToolExecutionResult } from "@thoughtflow/core";
+import { CodebaseExplorer } from "../../libs/codebase/indexer/explorer";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const OptimizeSuggestionSchema = z.object({
+  category: z.string(),
+  severity: z.enum(["high", "medium", "low"]),
+  message: z.string(),
+  fix: z.string(),
+  estimatedImpact: z.string(),
+});
+
+export class NeuralOptimizeTool extends ToolBase {
+  readonly name = "neuralOptimize";
+  readonly description = "AI-powered performance optimization. Combines static pattern detection (N+1 queries, sync-in-async, missing memoization) with LLM semantic analysis of hot-path inefficiencies. Provides concrete fix suggestions with estimated impact.";
+  override readonly readonly = true;
+
+  constructor() {
+    super(z.object({
+      target: z.string().optional().describe("File path or leave empty for worst offenders"),
+      projectPath: z.string().optional(),
+    }));
+  }
+
+  async run(input: Record<string, unknown>, ctx: ToolContext): Promise<ToolExecutionResult> {
+    const rootPath = (input.projectPath as string) ?? process.cwd();
+    const target = (input.target as string) || undefined;
+
+    const explorer = new CodebaseExplorer();
+    const files = explorer.explore({ rootPath });
+    const scanFiles = target
+      ? files.filter((f) => f.relativePath.includes(target)).slice(0, 5)
+      : files.filter((f) => f.classification === "source-code").slice(0, 20);
+
+    const staticIssues: Array<{ category: string; severity: string; file: string; line?: number; message: string; fix: string; estimatedImpact: string }> = [];
+
+    for (const file of scanFiles) {
+      const content = fs.readFileSync(file.absolutePath, "utf8");
+      const lines = content.split("\n");
+
+      for (let i = 0; i < lines.length; i++) {
+        const surrounding = lines.slice(Math.max(0, i - 3), i + 3).join("\n");
+        if (lines[i].match(/\.findMany|\.findFirst|\.findUnique|\.query|\.execute/) && surrounding.match(/for\s*\(|forEach|\.map\s*\(/)) {
+          staticIssues.push({ category: "n+1", severity: "high", file: file.relativePath, line: i + 1, message: "Database query inside loop — potential N+1 problem", fix: "Use batch query, eager loading (include), or DataLoader", estimatedImpact: "Can reduce DB calls from N to 1" });
+        }
+        if (lines[i].includes("await") && surrounding.match(/for\s*\(.*of/) && lines[i].match(/await\s+\w+/)) {
+          staticIssues.push({ category: "sequential-async", severity: "medium", file: file.relativePath, line: i + 1, message: "Sequential awaits in loop — can parallelize", fix: "Use Promise.all() for independent async operations", estimatedImpact: "Can reduce total time by factor of N" });
+        }
+      }
+
+      if (content.match(/\.filter|\.sort|\.reduce/) && !content.includes("useMemo") && !content.includes("useCallback") && (file.relativePath.endsWith(".tsx") || file.relativePath.endsWith(".jsx"))) {
+        staticIssues.push({ category: "missing-memo", severity: "medium", file: file.relativePath, message: "Expensive computation in render without memoization", fix: "Wrap in useMemo/useCallback", estimatedImpact: "Can prevent unnecessary re-renders" });
+      }
+    }
+
+    const cs = ctx.conversation?.callStructured;
+    if (!cs) {
+      return { success: true, output: JSON.stringify({ filesScanned: scanFiles.length, issuesFound: staticIssues.length, issues: staticIssues }) };
+    }
+
+    const codeSnippets = scanFiles.filter((f) => {
+      const c = fs.readFileSync(f.absolutePath, "utf8");
+      return c.includes("await") || c.includes(".find") || c.includes(".map") || c.includes("for");
+    }).slice(0, 3).map((f) => {
+      const c = fs.readFileSync(f.absolutePath, "utf8").slice(0, 3000);
+      return `--- ${f.relativePath} ---\n${c}`;
+    }).join("\n\n");
+
+    if (!codeSnippets) {
+      return { success: true, output: JSON.stringify({ filesScanned: scanFiles.length, issuesFound: staticIssues.length, issues: staticIssues }) };
+    }
+
+    const prompt = `Analyze this code for performance optimization opportunities: N+1 queries, missing caching/memoization, unnecessary re-renders, expensive operations in hot paths, sync operations in async contexts, large dependency imports, unnecessary closures, unbatched state updates, premature materialization of large collections, missing lazy evaluation.\n\n${codeSnippets}\n\nReturn structured suggestions with severity and estimated impact.`;
+
+    try {
+      const result = await cs(prompt, z.object({ suggestions: z.array(OptimizeSuggestionSchema) }));
+      const llmIssues = (result.suggestions ?? []).map((s) => ({
+        category: s.category,
+        severity: s.severity,
+        file: target ?? "",
+        message: s.message,
+        fix: s.fix,
+        estimatedImpact: s.estimatedImpact,
+      }));
+      const allIssues = [...staticIssues, ...llmIssues];
+      return { success: true, output: JSON.stringify({ filesScanned: scanFiles.length, issuesFound: allIssues.length, issues: allIssues.slice(0, 20) }) };
+    } catch {
+      return { success: true, output: JSON.stringify({ filesScanned: scanFiles.length, issuesFound: staticIssues.length, issues: staticIssues }) };
+    }
+  }
+}

package/src/tools/neural/neural-pattern.tool.ts

@@ -0,0 +1,141 @@
+import { z } from "zod";
+import { ToolBase, ToolContext, ToolExecutionResult } from "@thoughtflow/core";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export class NeuralPatternTool extends ToolBase {
+  readonly name = "neuralPattern";
+  readonly description = "Recognize design patterns used in the codebase using static analysis and LLM verification. Detects Singleton, Factory, Observer, Strategy, Decorator, Repository, Adapter, Builder, Command, Mediator, Chain of Responsibility, and more.";
+  override readonly readonly = true;
+
+  constructor() {
+    super(z.object({
+      target: z.string().optional().describe("File or directory to scan"),
+      projectPath: z.string().optional(),
+      verifyWithLLM: z.boolean().optional().describe("Use LLM to verify ambiguous pattern detections"),
+    }));
+  }
+
+  async run(input: Record<string, unknown>, ctx: ToolContext): Promise<ToolExecutionResult> {
+    const rootPath = (input.projectPath as string) ?? process.cwd();
+    const target = (input.target as string) || "src";
+    const verify = (input.verifyWithLLM as boolean) ?? false;
+    const targetPath = path.join(rootPath, target);
+
+    let files: string[] = [];
+    if (fs.statSync(targetPath).isDirectory()) {
+      const walk = (dir: string) => {
+        for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+          if (e.name.startsWith(".") || e.name === "node_modules") continue;
+          const fp = path.join(dir, e.name);
+          if (e.isDirectory()) walk(fp);
+          else if (e.name.endsWith(".ts")) files.push(fp);
+        }
+      };
+      walk(targetPath);
+    } else {
+      files = [targetPath];
+    }
+
+    const patterns: Array<{ pattern: string; confidence: string; file: string; evidence: string; llmVerified?: boolean }> = [];
+
+    for (const file of files) {
+      const content = fs.readFileSync(file, "utf8");
+      const rel = path.relative(rootPath, file);
+
+      const detections = this.detectPatterns(rel, content);
+      for (const d of detections) {
+        patterns.push({ ...d, file: rel });
+      }
+    }
+
+    let llmResult: { verified?: boolean; corrections?: string[] } | null = null;
+    const callStructured = ctx.conversation?.callStructured;
+    if (verify && callStructured && patterns.length > 0) {
+      const ambiguous = patterns.filter((p) => p.confidence === "medium");
+      const toVerify = ambiguous.length > 0 ? ambiguous : patterns.slice(0, 10);
+      const patternList = toVerify.map((p) => `- ${p.file}: ${p.pattern} (${p.confidence})`).join("\n");
+      const prompt = `Verify these design pattern detections in a codebase:\n${patternList}\n\nAre these correct? Flag any false positives. Return: { verified: boolean, corrections: string[] }`;
+      try {
+        llmResult = await callStructured(prompt, z.object({ verified: z.boolean(), corrections: z.array(z.string()) }));
+      } catch {
+        /* skip LLM verification */
+      }
+    }
+
+    if (llmResult?.verified && patterns.length > 0) {
+      for (const p of patterns) {
+        if (p.confidence === "medium") {
+          p.llmVerified = true;
+        }
+      }
+    }
+
+    const patternCounts: Record<string, number> = {};
+    for (const p of patterns) {
+      patternCounts[p.pattern] = (patternCounts[p.pattern] ?? 0) + 1;
+    }
+
+    return {
+      success: true,
+      output: JSON.stringify({
+        filesScanned: files.length,
+        patternsFound: patterns.length,
+        byType: patternCounts,
+        llmVerified: llmResult?.verified ?? false,
+        llmCorrections: llmResult?.corrections,
+        patterns: patterns.slice(0, 30),
+      }),
+    };
+  }
+
+  private detectPatterns(rel: string, content: string): Array<{ pattern: string; confidence: string; evidence: string }> {
+    const results: Array<{ pattern: string; confidence: string; evidence: string }> = [];
+
+    if (rel.toLowerCase().includes("factory")) {
+      results.push({ pattern: "Factory", confidence: "high", evidence: "File name indicates Factory pattern" });
+    }
+    if (rel.toLowerCase().includes("singleton")) {
+      results.push({ pattern: "Singleton", confidence: "high", evidence: "File name indicates Singleton" });
+    }
+    if (rel.toLowerCase().includes("observer") || rel.toLowerCase().includes("listener") || rel.toLowerCase().includes("subscriber")) {
+      results.push({ pattern: "Observer", confidence: "high", evidence: "File name indicates Observer pattern" });
+    }
+    if (rel.toLowerCase().includes("strategy")) {
+      results.push({ pattern: "Strategy", confidence: "high", evidence: "File name indicates Strategy pattern" });
+    }
+    if (rel.toLowerCase().includes("decorator")) {
+      results.push({ pattern: "Decorator", confidence: "high", evidence: "File name indicates Decorator" });
+    }
+    if (rel.toLowerCase().includes("adapter") || rel.toLowerCase().includes("wrapper")) {
+      results.push({ pattern: "Adapter", confidence: "high", evidence: "File name indicates Adapter" });
+    }
+    if (rel.toLowerCase().includes("repository") || rel.toLowerCase().includes("repo")) {
+      results.push({ pattern: "Repository", confidence: "high", evidence: "File name indicates Repository" });
+    }
+    if (rel.toLowerCase().includes("builder")) {
+      results.push({ pattern: "Builder", confidence: "high", evidence: "File name indicates Builder" });
+    }
+    if (rel.toLowerCase().includes("command") || rel.toLowerCase().includes("handler")) {
+      results.push({ pattern: "Command", confidence: "medium", evidence: "File name suggests Command pattern" });
+    }
+    if (rel.toLowerCase().includes("mediator") || rel.toLowerCase().includes("coordinator") || rel.toLowerCase().includes("orchestrator")) {
+      results.push({ pattern: "Mediator", confidence: "medium", evidence: "File name suggests Mediator/Coordinator" });
+    }
+    if (rel.toLowerCase().includes("middleware")) {
+      results.push({ pattern: "Chain of Responsibility", confidence: "medium", evidence: "Middleware suggests Chain of Responsibility" });
+    }
+
+    if (content.includes("class ") && content.includes("private static") && content.includes("instance")) {
+      results.push({ pattern: "Singleton", confidence: "medium", evidence: "private static instance field detected" });
+    }
+    if (content.match(/abstract\s+class\s+\w+\s*\{/)) {
+      results.push({ pattern: "Template Method", confidence: "medium", evidence: "Abstract class found" });
+    }
+    if (content.match(/interface\s+\w+/)) {
+      results.push({ pattern: "Strategy", confidence: "low", evidence: "Interface suggests potential Strategy pattern" });
+    }
+
+    return results;
+  }
+}

package/src/tools/neural/neural-review.tool.ts

@@ -0,0 +1,145 @@
+import { z } from "zod";
+import { ToolBase, ToolContext, ToolExecutionResult } from "@thoughtflow/core";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const ReviewIssueSchema = z.object({
+  severity: z.enum(["critical", "high", "medium", "low", "info"]),
+  category: z.enum(["bug", "security", "performance", "style", "types", "architecture", "naming", "maintainability"]),
+  line: z.number().optional(),
+  message: z.string(),
+  suggestion: z.string(),
+});
+
+const ReviewResultSchema = z.object({
+  summary: z.string(),
+  issues: z.array(ReviewIssueSchema),
+  overallScore: z.number().min(0).max(100),
+});
+
+type ReviewIssue = z.infer<typeof ReviewIssueSchema>;
+
+export class NeuralReviewTool extends ToolBase {
+  readonly name = "neuralReview";
+  readonly description = "AI-powered code review. Analyzes code for bugs, anti-patterns, style issues, type safety, and correctness. Returns issues with severity levels and fix suggestions.";
+  override readonly readonly = true;
+
+  constructor() {
+    super(z.object({
+      target: z.string().describe("File path or code to review"),
+      focus: z.enum(["all", "bugs", "security", "performance", "style", "types"]).optional(),
+      projectPath: z.string().optional(),
+    }));
+  }
+
+  async run(input: Record<string, unknown>, ctx: ToolContext): Promise<ToolExecutionResult> {
+    const { target, focus } = input as { target: string; focus?: string };
+    const rootPath = (input.projectPath as string) ?? process.cwd();
+    const reviewFocus = focus ?? "all";
+
+    let code = target;
+    let filePath = "(inline)";
+    const fullPath = path.join(rootPath, target);
+    try {
+      if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+        code = fs.readFileSync(fullPath, "utf8").slice(0, 12000);
+        filePath = target;
+      }
+    } catch {
+      /* use target as-is */
+    }
+
+    const staticIssues = this.runStaticChecks(code);
+
+    const callStructured = ctx.conversation?.callStructured;
+    if (!callStructured) {
+      return this.buildResult(filePath, staticIssues, "Static analysis only — no LLM available", 50);
+    }
+
+    const focusInstruction = reviewFocus !== "all"
+      ? `Focus exclusively on ${reviewFocus} issues. Ignore other categories.`
+      : "Comprehensively review all aspects.";
+
+    const prompt = `You are a senior code reviewer. ${focusInstruction}
+
+File: ${filePath}
+
+\`\`\`
+${code.slice(0, 8000)}
+\`\`\`
+
+Provide a structured review with issues ordered by severity. Consider: bugs, security vulnerabilities, performance problems, type safety gaps, code style violations, architectural issues, poor naming, and maintainability concerns. Be specific — cite exact line numbers where possible. For each issue provide a concrete, actionable fix suggestion.`;
+
+    try {
+      const result = await callStructured(prompt, ReviewResultSchema);
+      const data = result as { summary?: string; issues?: ReviewIssue[]; overallScore?: number };
+      const allIssues = [...staticIssues, ...(data.issues ?? [])];
+      return this.buildResult(
+        filePath,
+        allIssues.slice(0, 30),
+        data.summary ?? "Review complete",
+        data.overallScore ?? 50,
+      );
+    } catch {
+      return this.buildResult(filePath, staticIssues.slice(0, 20), "LLM review failed — static analysis only", 40);
+    }
+  }
+
+  private runStaticChecks(code: string): ReviewIssue[] {
+    const issues: ReviewIssue[] = [];
+    const lines = code.split("\n");
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      if (line.includes("console.log") || line.includes("console.warn") || line.includes("console.error") || line.includes("console.debug")) {
+        issues.push({ severity: "low", category: "style", line: i + 1, message: "Console statement in code", suggestion: "Replace with proper logger" });
+      }
+
+      if (line.match(/eval\s*\(/)) {
+        issues.push({ severity: "critical", category: "security", line: i + 1, message: "eval() usage — code injection risk", suggestion: "Avoid eval(); use safer alternatives" });
+      }
+
+      if (line.match(/password|secret|api[_-]?key/i) && line.includes("=") && !line.includes("process.env") && !line.trim().startsWith("//")) {
+        issues.push({ severity: "critical", category: "security", line: i + 1, message: "Potential hardcoded secret", suggestion: "Move to environment variable" });
+      }
+
+      if (line.match(/==\s*(true|false|null|undefined)/) && !line.includes("===")) {
+        issues.push({ severity: "medium", category: "bug", line: i + 1, message: "Loose equality with boolean/null/undefined", suggestion: "Use === instead of ==" });
+      }
+
+      if (line.length > 150) {
+        issues.push({ severity: "low", category: "style", line: i + 1, message: `Line too long (${line.length} chars)`, suggestion: "Split into multiple lines" });
+      }
+    }
+
+    return issues;
+  }
+
+  private buildResult(
+    filePath: string,
+    issues: ReviewIssue[],
+    summary: string,
+    overallScore: number,
+  ): ToolExecutionResult {
+    const severityCounts = {
+      critical: issues.filter((i) => i.severity === "critical").length,
+      high: issues.filter((i) => i.severity === "high").length,
+      medium: issues.filter((i) => i.severity === "medium").length,
+      low: issues.filter((i) => i.severity === "low").length,
+      info: issues.filter((i) => i.severity === "info").length,
+    };
+
+    return {
+      success: true,
+      output: JSON.stringify({
+        file: filePath,
+        summary,
+        overallScore,
+        issueCount: issues.length,
+        bySeverity: severityCounts,
+        issues,
+      }),
+    };
+  }
+}