@kb-labs/review-core 0.5.0

package/dist/index.js

@@ -0,0 +1,1542 @@
+import { LinterRunner, deduplicateFindings } from '@kb-labs/review-heuristic';
+import { runLLMLiteAnalysis } from '@kb-labs/review-llm';
+import { useConfig, useLogger, useAnalytics, useLLM } from '@kb-labs/sdk';
+import { simpleGit } from 'simple-git';
+import * as path from 'path';
+import { join, dirname } from 'path';
+import { createHash } from 'crypto';
+import { readFile, mkdir, writeFile } from 'fs/promises';
+import { existsSync, readdirSync, statSync, readFileSync } from 'fs';
+
+// src/orchestrator.ts
+
+// src/presets/builtin-presets.ts
+var defaultPreset = {
+  id: "default",
+  name: "Default",
+  description: "Balanced rules for most TypeScript/JavaScript projects",
+  rules: [
+    "eslint:recommended",
+    "@typescript-eslint/recommended"
+  ],
+  excludeRules: [],
+  engines: {
+    eslint: {
+      enabled: true,
+      config: {
+        parser: "@typescript-eslint/parser",
+        parserOptions: {
+          ecmaVersion: 2022,
+          sourceType: "module"
+        },
+        plugins: ["@typescript-eslint"],
+        rules: {
+          // Warnings for common issues
+          "@typescript-eslint/no-explicit-any": "warn",
+          "@typescript-eslint/no-unused-vars": ["warn", {
+            argsIgnorePattern: "^_",
+            varsIgnorePattern: "^_"
+          }],
+          "no-console": "warn",
+          "no-debugger": "error"
+        }
+      }
+    }
+  },
+  include: ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"],
+  exclude: ["**/node_modules/**", "**/dist/**", "**/build/**"]
+};
+var typescriptStrictPreset = {
+  id: "typescript-strict",
+  name: "TypeScript Strict",
+  description: "Strict TypeScript rules with @typescript-eslint/recommended",
+  rules: [
+    "eslint:recommended",
+    "@typescript-eslint/recommended",
+    "@typescript-eslint/recommended-requiring-type-checking"
+  ],
+  excludeRules: [],
+  engines: {
+    eslint: {
+      enabled: true,
+      config: {
+        parser: "@typescript-eslint/parser",
+        parserOptions: {
+          ecmaVersion: "latest",
+          sourceType: "module",
+          project: true
+        },
+        extends: [
+          "eslint:recommended",
+          "plugin:@typescript-eslint/recommended",
+          "plugin:@typescript-eslint/recommended-requiring-type-checking"
+        ],
+        rules: {
+          "@typescript-eslint/no-explicit-any": "error",
+          "@typescript-eslint/explicit-function-return-type": "warn",
+          "@typescript-eslint/no-unused-vars": "error",
+          "@typescript-eslint/strict-boolean-expressions": "warn"
+        }
+      }
+    }
+  },
+  include: ["**/*.ts", "**/*.tsx"],
+  exclude: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/*.test.ts", "**/*.spec.ts"],
+  severity: {
+    failOn: "high"
+  }
+};
+var reactPreset = {
+  id: "react",
+  name: "React",
+  description: "React best practices with hooks rules",
+  rules: [
+    "eslint:recommended",
+    "plugin:react/recommended",
+    "plugin:react-hooks/recommended"
+  ],
+  excludeRules: [],
+  engines: {
+    eslint: {
+      enabled: true,
+      config: {
+        parserOptions: {
+          ecmaVersion: "latest",
+          sourceType: "module",
+          ecmaFeatures: {
+            jsx: true
+          }
+        },
+        extends: [
+          "eslint:recommended",
+          "plugin:react/recommended",
+          "plugin:react-hooks/recommended"
+        ],
+        settings: {
+          react: {
+            version: "detect"
+          }
+        },
+        rules: {
+          "react/react-in-jsx-scope": "off",
+          // Not needed in React 17+
+          "react-hooks/rules-of-hooks": "error",
+          "react-hooks/exhaustive-deps": "warn"
+        }
+      }
+    }
+  },
+  include: ["**/*.tsx", "**/*.jsx"],
+  exclude: ["**/node_modules/**", "**/dist/**", "**/build/**"]
+};
+var securityPreset = {
+  id: "security",
+  name: "Security",
+  description: "Security-focused rules to detect vulnerabilities",
+  rules: [
+    "eslint:recommended",
+    "plugin:security/recommended"
+  ],
+  excludeRules: [],
+  engines: {
+    eslint: {
+      enabled: true,
+      config: {
+        extends: [
+          "eslint:recommended",
+          "plugin:security/recommended"
+        ],
+        rules: {
+          "no-eval": "error",
+          "no-implied-eval": "error",
+          "no-new-func": "error",
+          "security/detect-eval-with-expression": "error",
+          "security/detect-non-literal-regexp": "warn",
+          "security/detect-unsafe-regex": "error"
+        }
+      }
+    }
+  },
+  include: ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"],
+  exclude: ["**/node_modules/**", "**/dist/**", "**/build/**"],
+  severity: {
+    failOn: "medium"
+  }
+};
+var kbLabsPreset = {
+  id: "kb-labs",
+  name: "KB Labs",
+  description: "Comprehensive architectural and security rules for KB Labs platform",
+  rules: [
+    "eslint:recommended",
+    "@typescript-eslint/recommended"
+  ],
+  excludeRules: [],
+  engines: {
+    eslint: {
+      enabled: true,
+      config: {
+        parser: "@typescript-eslint/parser",
+        parserOptions: {
+          ecmaVersion: "latest",
+          sourceType: "module",
+          project: true
+        },
+        plugins: ["@typescript-eslint", "security"],
+        rules: {
+          // Type Safety
+          "@typescript-eslint/no-explicit-any": "error",
+          "@typescript-eslint/no-unsafe-assignment": "warn",
+          "@typescript-eslint/no-unsafe-member-access": "warn",
+          "@typescript-eslint/no-unsafe-call": "warn",
+          "@typescript-eslint/no-unsafe-return": "warn",
+          // Naming Conventions
+          "@typescript-eslint/naming-convention": [
+            "error",
+            {
+              selector: "interface",
+              format: ["PascalCase"],
+              prefix: ["I"]
+            },
+            {
+              selector: "typeAlias",
+              format: ["PascalCase"]
+            },
+            {
+              selector: "class",
+              format: ["PascalCase"]
+            },
+            {
+              selector: "function",
+              format: ["camelCase", "PascalCase"]
+            },
+            {
+              selector: "variable",
+              format: ["camelCase", "UPPER_CASE", "PascalCase"],
+              leadingUnderscore: "allow"
+            }
+          ],
+          // Code Quality
+          "@typescript-eslint/no-unused-vars": ["error", {
+            argsIgnorePattern: "^_",
+            varsIgnorePattern: "^_",
+            caughtErrors: "all"
+          }],
+          "@typescript-eslint/explicit-function-return-type": ["warn", {
+            allowExpressions: true,
+            allowTypedFunctionExpressions: true,
+            allowHigherOrderFunctions: true
+          }],
+          "@typescript-eslint/no-floating-promises": "error",
+          "@typescript-eslint/await-thenable": "error",
+          "@typescript-eslint/no-misused-promises": "error",
+          // Security
+          "no-eval": "error",
+          "no-implied-eval": "error",
+          "no-new-func": "error",
+          "security/detect-eval-with-expression": "error",
+          "security/detect-non-literal-regexp": "warn",
+          "security/detect-unsafe-regex": "error",
+          "security/detect-buffer-noassert": "error",
+          "security/detect-child-process": "warn",
+          "security/detect-disable-mustache-escape": "error",
+          "security/detect-no-csrf-before-method-override": "error",
+          "security/detect-non-literal-fs-filename": "warn",
+          "security/detect-non-literal-require": "warn",
+          "security/detect-object-injection": "warn",
+          "security/detect-possible-timing-attacks": "warn",
+          "security/detect-pseudoRandomBytes": "error",
+          // Best Practices
+          "no-console": ["warn", { allow: ["warn", "error"] }],
+          "no-debugger": "error",
+          "no-alert": "error",
+          "prefer-const": "error",
+          "no-var": "error",
+          "eqeqeq": ["error", "always", { null: "ignore" }]
+        }
+      }
+    }
+  },
+  // LLM Analyzers context
+  context: {
+    projectType: "monorepo",
+    framework: "nodejs",
+    language: "typescript",
+    conventions: {
+      naming: "Interfaces must be prefixed with I (e.g., ILLM, ICache). Classes use PascalCase. Functions and variables use camelCase.",
+      architecture: "Follow V3 plugin system patterns. Use adapter pattern for external services. Implement proper error handling with typed errors.",
+      security: "Never use eval() or Function(). Validate all external inputs. Use parameterized queries. Sanitize file paths."
+    },
+    adrs: [
+      "ADR-0046: LLM Router for tier-based model selection",
+      "ADR-0048: Metadata-based routing with wrapper chain",
+      "ADR-0047: Multi-adapter architecture"
+    ]
+  },
+  include: ["**/packages/*/src/**/*.ts", "**/packages/*/src/**/*.tsx"],
+  exclude: [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/*.test.ts",
+    "**/*.spec.ts",
+    "**/__tests__/**"
+  ],
+  severity: {
+    failOn: "high"
+  }
+};
+var kbLabsStrictPreset = {
+  id: "kb-labs-strict",
+  name: "KB Labs Strict",
+  description: "Maximum strictness for security-critical packages (core, runtime, plugin-runtime)",
+  rules: [
+    "eslint:recommended",
+    "@typescript-eslint/recommended",
+    "@typescript-eslint/recommended-requiring-type-checking"
+  ],
+  excludeRules: [],
+  engines: {
+    eslint: {
+      enabled: true,
+      config: {
+        parser: "@typescript-eslint/parser",
+        parserOptions: {
+          ecmaVersion: "latest",
+          sourceType: "module",
+          project: true
+        },
+        plugins: ["@typescript-eslint", "security"],
+        rules: {
+          // Type Safety - STRICT
+          "@typescript-eslint/no-explicit-any": "error",
+          "@typescript-eslint/no-unsafe-assignment": "error",
+          "@typescript-eslint/no-unsafe-member-access": "error",
+          "@typescript-eslint/no-unsafe-call": "error",
+          "@typescript-eslint/no-unsafe-return": "error",
+          "@typescript-eslint/explicit-function-return-type": "error",
+          "@typescript-eslint/explicit-module-boundary-types": "error",
+          "@typescript-eslint/strict-boolean-expressions": "error",
+          "@typescript-eslint/no-non-null-assertion": "error",
+          // Naming Conventions - STRICT
+          "@typescript-eslint/naming-convention": [
+            "error",
+            {
+              selector: "interface",
+              format: ["PascalCase"],
+              prefix: ["I"]
+            },
+            {
+              selector: "typeAlias",
+              format: ["PascalCase"]
+            },
+            {
+              selector: "class",
+              format: ["PascalCase"]
+            },
+            {
+              selector: "function",
+              format: ["camelCase"]
+            },
+            {
+              selector: "variable",
+              format: ["camelCase", "UPPER_CASE"],
+              leadingUnderscore: "forbid"
+            }
+          ],
+          // Code Quality - STRICT
+          "@typescript-eslint/no-unused-vars": ["error", {
+            argsIgnorePattern: "^_",
+            varsIgnorePattern: "^_",
+            caughtErrors: "all",
+            ignoreRestSiblings: false
+          }],
+          "@typescript-eslint/no-floating-promises": "error",
+          "@typescript-eslint/await-thenable": "error",
+          "@typescript-eslint/no-misused-promises": "error",
+          "@typescript-eslint/require-await": "error",
+          "@typescript-eslint/no-unnecessary-type-assertion": "error",
+          // Security - MAXIMUM
+          "no-eval": "error",
+          "no-implied-eval": "error",
+          "no-new-func": "error",
+          "security/detect-eval-with-expression": "error",
+          "security/detect-non-literal-regexp": "error",
+          "security/detect-unsafe-regex": "error",
+          "security/detect-buffer-noassert": "error",
+          "security/detect-child-process": "error",
+          "security/detect-disable-mustache-escape": "error",
+          "security/detect-no-csrf-before-method-override": "error",
+          "security/detect-non-literal-fs-filename": "error",
+          "security/detect-non-literal-require": "error",
+          "security/detect-object-injection": "error",
+          "security/detect-possible-timing-attacks": "error",
+          "security/detect-pseudoRandomBytes": "error",
+          // Best Practices - STRICT
+          "no-console": "error",
+          "no-debugger": "error",
+          "no-alert": "error",
+          "prefer-const": "error",
+          "no-var": "error",
+          "eqeqeq": ["error", "always"],
+          "no-param-reassign": "error"
+        }
+      }
+    }
+  },
+  // LLM Analyzers context - STRICT
+  context: {
+    projectType: "monorepo",
+    framework: "nodejs",
+    language: "typescript",
+    conventions: {
+      naming: "Strict naming: Interfaces MUST have I prefix. NO leading underscores. Constants MUST be UPPER_CASE.",
+      architecture: "V3 plugin system with strict separation of concerns. ALL functions must have explicit return types. NO any types allowed.",
+      security: "Zero tolerance for security issues. ALL inputs must be validated. ALL promises must be awaited or explicitly handled. NO eval/Function/console allowed."
+    },
+    adrs: [
+      "ADR-0046: LLM Router",
+      "ADR-0048: Metadata-based routing",
+      "ADR-0047: Multi-adapter architecture",
+      "Security: Sandbox isolation with hardcoded deny patterns",
+      "Security: Permission-based file system access"
+    ]
+  },
+  include: [
+    "**/packages/core-*/src/**/*.ts",
+    "**/packages/plugin-runtime/src/**/*.ts",
+    "**/packages/state-*/src/**/*.ts"
+  ],
+  exclude: [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/*.test.ts",
+    "**/*.spec.ts",
+    "**/__tests__/**"
+  ],
+  severity: {
+    failOn: "medium"
+  }
+};
+var builtinPresets = [
+  defaultPreset,
+  typescriptStrictPreset,
+  reactPreset,
+  securityPreset,
+  kbLabsPreset,
+  kbLabsStrictPreset
+];
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key in source) {
+    const sourceValue = source[key];
+    const targetValue = result[key];
+    if (sourceValue === void 0) {
+      continue;
+    }
+    if (typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+      result[key] = deepMerge(targetValue, sourceValue);
+    } else if (Array.isArray(sourceValue) && Array.isArray(targetValue)) {
+      result[key] = [.../* @__PURE__ */ new Set([...targetValue, ...sourceValue])];
+    } else {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+var PresetLoader = class {
+  presets;
+  configLoaded = false;
+  constructor() {
+    this.presets = /* @__PURE__ */ new Map();
+    this.loadBuiltinPresets();
+  }
+  /**
+   * Load builtin presets
+   */
+  loadBuiltinPresets() {
+    for (const preset of builtinPresets) {
+      this.presets.set(preset.id, preset);
+    }
+  }
+  /**
+   * Resolve preset inheritance (extends) with cycle detection
+   */
+  resolveInheritance(preset, visited = /* @__PURE__ */ new Set()) {
+    if (!preset.extends) {
+      return preset;
+    }
+    if (visited.has(preset.id)) {
+      const chain = Array.from(visited).join(" -> ") + " -> " + preset.id;
+      throw new Error(
+        `Circular inheritance detected in presets: ${chain}`
+      );
+    }
+    visited.add(preset.id);
+    const parent = this.presets.get(preset.extends);
+    if (!parent) {
+      throw new Error(
+        `Preset '${preset.id}' extends '${preset.extends}', but parent preset not found`
+      );
+    }
+    const resolvedParent = this.resolveInheritance(parent, visited);
+    const merged = deepMerge(resolvedParent, preset);
+    delete merged.extends;
+    return merged;
+  }
+  /**
+   * Load custom presets from kb.config.json and preset files
+   * Called lazily on first preset access
+   */
+  async loadConfigPresets() {
+    if (this.configLoaded) {
+      return;
+    }
+    try {
+      const config = await useConfig();
+      if (config?.presets) {
+        for (const presetOrPath of config.presets) {
+          if (typeof presetOrPath === "string") {
+            await this.loadPresetFromFile(presetOrPath);
+          } else {
+            this.presets.set(presetOrPath.id, presetOrPath);
+          }
+        }
+      }
+      await this.scanPresetsDirectory();
+      this.configLoaded = true;
+    } catch {
+      this.configLoaded = true;
+    }
+  }
+  /**
+   * Auto-scan .kb/ai-review/presets/ directory for preset files
+   */
+  async scanPresetsDirectory() {
+    try {
+      const fs = await import('fs/promises');
+      const pathModule = await import('path');
+      const presetsDir = pathModule.join(process.cwd(), ".kb", "ai-review", "presets");
+      try {
+        await fs.access(presetsDir);
+      } catch {
+        return;
+      }
+      const entries = await fs.readdir(presetsDir, { withFileTypes: true });
+      const jsonFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".json"));
+      for (const file of jsonFiles) {
+        if (file.name.includes("..") || file.name.includes(pathModule.sep)) {
+          continue;
+        }
+        const filePath = pathModule.join(presetsDir, file.name);
+        try {
+          const content = await fs.readFile(filePath, "utf-8");
+          const preset = JSON.parse(content);
+          if (preset.id) {
+            this.presets.set(preset.id, preset);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Load preset from JSON file
+   */
+  async loadPresetFromFile(relativePath) {
+    try {
+      const fs = await import('fs/promises');
+      const path2 = await import('path');
+      const configDir = path2.join(process.cwd(), ".kb");
+      const presetPath = path2.join(configDir, relativePath);
+      const content = await fs.readFile(presetPath, "utf-8");
+      const preset = JSON.parse(content);
+      this.presets.set(preset.id, preset);
+    } catch (error) {
+      useLogger()?.debug(`[PresetLoader] Failed to load preset from ${relativePath}:`, { error });
+    }
+  }
+  /**
+   * Load atomic rule from .md file
+   */
+  async loadAtomicRule(category, ruleName) {
+    try {
+      const fs = await import('fs/promises');
+      const path2 = await import('path');
+      const configDir = path2.join(process.cwd(), ".kb");
+      const rulePath = path2.join(configDir, "ai-review", "rules", category, `${ruleName}.md`);
+      const content = await fs.readFile(rulePath, "utf-8");
+      return content.trim();
+    } catch (error) {
+      useLogger()?.debug(`[PresetLoader] Failed to load atomic rule ${category}/${ruleName}:`, { error });
+      return void 0;
+    }
+  }
+  /**
+   * Compose atomic rules into convention text
+   */
+  async composeRules(category, include, exclude) {
+    if (!include || include.length === 0) {
+      return "";
+    }
+    const rules = [];
+    for (const ruleName of include) {
+      if (exclude?.includes(ruleName)) {
+        continue;
+      }
+      const ruleContent = await this.loadAtomicRule(category, ruleName);
+      if (ruleContent) {
+        rules.push(ruleContent);
+      }
+    }
+    return rules.join("\n\n");
+  }
+  /**
+   * Apply atomic rules composition to preset
+   * Supports dynamic categories - any category name defined in atomicRules
+   */
+  async applyAtomicRules(preset) {
+    if (!preset.atomicRules) {
+      return preset;
+    }
+    if (!preset.context) {
+      preset.context = {};
+    }
+    if (!preset.context.conventions) {
+      preset.context.conventions = {};
+    }
+    for (const category in preset.atomicRules) {
+      const ruleConfig = preset.atomicRules[category];
+      if (!ruleConfig) {
+        continue;
+      }
+      const composedRules = await this.composeRules(
+        category,
+        ruleConfig.include,
+        ruleConfig.exclude
+      );
+      if (composedRules) {
+        const existingConventions = preset.context.conventions[category] || "";
+        if (existingConventions) {
+          preset.context.conventions[category] = `${composedRules}
+
+${existingConventions}`;
+        } else {
+          preset.context.conventions[category] = composedRules;
+        }
+      }
+    }
+    return preset;
+  }
+  /**
+   * Get preset by ID (with inheritance resolved)
+   */
+  async getPreset(id) {
+    await this.loadConfigPresets();
+    const preset = this.presets.get(id);
+    if (!preset) {
+      return void 0;
+    }
+    const resolved = this.resolveInheritance(preset);
+    return this.applyAtomicRules(resolved);
+  }
+  /**
+   * Get preset by ID or throw error
+   */
+  async getPresetOrThrow(id) {
+    const preset = await this.getPreset(id);
+    if (!preset) {
+      const available = Array.from(this.presets.keys()).join(", ");
+      throw new Error(
+        `Preset not found: "${id}"
+Available presets: ${available}`
+      );
+    }
+    return preset;
+  }
+  /**
+   * List all available presets
+   */
+  async listPresets() {
+    await this.loadConfigPresets();
+    return Array.from(this.presets.values());
+  }
+  /**
+   * Register custom preset
+   */
+  registerPreset(preset) {
+    this.presets.set(preset.id, preset);
+  }
+};
+var globalLoader;
+function getPresetLoader() {
+  if (!globalLoader) {
+    globalLoader = new PresetLoader();
+  }
+  return globalLoader;
+}
+async function loadPreset(id) {
+  return getPresetLoader().getPresetOrThrow(id);
+}
+var DiffProvider = class {
+  git;
+  cwd;
+  constructor(cwd) {
+    if (!cwd || typeof cwd !== "string") {
+      throw new Error("DiffProvider: cwd must be a non-empty string");
+    }
+    const resolvedCwd = path.resolve(cwd);
+    if (cwd.includes("..") && resolvedCwd !== path.resolve(process.cwd(), cwd)) {
+      useLogger()?.debug("[DiffProvider] Potential path traversal detected in cwd:", { cwd, resolvedCwd });
+    }
+    this.cwd = resolvedCwd;
+    this.git = simpleGit(resolvedCwd);
+  }
+  /**
+   * Get diffs for multiple files in one call (batch operation)
+   */
+  async getDiffs(request) {
+    const { files, staged = true, unstaged = true, maxLinesPerFile = 500 } = request;
+    const diffs = [];
+    const errors = [];
+    let totalLines = 0;
+    const BATCH_SIZE = 10;
+    for (let i = 0; i < files.length; i += BATCH_SIZE) {
+      const batch = files.slice(i, i + BATCH_SIZE);
+      const results = await Promise.allSettled(
+        batch.map((file) => this.getFileDiff(file, staged, unstaged, maxLinesPerFile))
+      );
+      for (let j = 0; j < results.length; j++) {
+        const result = results[j];
+        const file = batch[j];
+        if (result.status === "fulfilled" && result.value) {
+          diffs.push(result.value);
+          totalLines += result.value.diff.split("\n").length;
+        } else if (result.status === "rejected") {
+          errors.push({ file, error: result.reason?.message ?? "Unknown error" });
+        }
+      }
+    }
+    return { diffs, errors, totalLines };
+  }
+  /**
+   * Get diff for a single file
+   */
+  async getFileDiff(file, staged = true, unstaged = true, maxLines = 500) {
+    try {
+      let diff = "";
+      if (staged) {
+        const stagedDiff = await this.git.diff(["--cached", "--", file]);
+        if (stagedDiff) {
+          diff = stagedDiff;
+        }
+      }
+      if (unstaged && !diff) {
+        const unstagedDiff = await this.git.diff(["--", file]);
+        if (unstagedDiff) {
+          diff = unstagedDiff;
+        }
+      }
+      if (!diff) {
+        try {
+          const headDiff = await this.git.diff(["HEAD", "--", file]);
+          if (headDiff) {
+            diff = headDiff;
+          }
+        } catch {
+          return null;
+        }
+      }
+      if (!diff) {
+        return null;
+      }
+      const lines = diff.split("\n");
+      if (lines.length > maxLines) {
+        diff = lines.slice(0, maxLines).join("\n") + `
+... (truncated, ${lines.length - maxLines} more lines)`;
+      }
+      return this.parseDiff(file, diff);
+    } catch (error) {
+      useLogger()?.debug(`[DiffProvider] Error getting diff for ${file}:`, { error });
+      return null;
+    }
+  }
+  /**
+   * Parse unified diff into structured format
+   */
+  // eslint-disable-next-line sonarjs/cognitive-complexity -- Diff parsing logic: detects file modes (new/deleted/renamed), parses hunks, tracks line numbers, counts additions/deletions
+  parseDiff(file, diff) {
+    const hunks = [];
+    const changedLines = /* @__PURE__ */ new Set();
+    let additions = 0;
+    let deletions = 0;
+    let isNewFile = false;
+    let isDeleted = false;
+    let isRenamed = false;
+    if (diff.includes("new file mode")) {
+      isNewFile = true;
+    }
+    if (diff.includes("deleted file mode")) {
+      isDeleted = true;
+    }
+    if (diff.includes("rename from") || diff.includes("rename to")) {
+      isRenamed = true;
+    }
+    const lines = diff.split("\n");
+    let currentHunkStart = -1;
+    let currentHunk = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const hunkMatch = line.match(/^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/);
+      if (hunkMatch) {
+        if (currentHunkStart >= 0 && currentHunk.length > 0) {
+          const parsed = this.parseHunkContent(currentHunk, currentHunkStart);
+          hunks.push(parsed);
+          parsed.addedLines.forEach((l) => changedLines.add(l));
+        }
+        currentHunkStart = parseInt(hunkMatch[3], 10);
+        currentHunk = [line];
+      } else if (currentHunkStart >= 0) {
+        currentHunk.push(line);
+      }
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        additions++;
+      } else if (line.startsWith("-") && !line.startsWith("---")) {
+        deletions++;
+      }
+    }
+    if (currentHunkStart >= 0 && currentHunk.length > 0) {
+      const parsed = this.parseHunkContent(currentHunk, currentHunkStart);
+      hunks.push(parsed);
+      parsed.addedLines.forEach((l) => changedLines.add(l));
+    }
+    return {
+      file,
+      diff,
+      additions,
+      deletions,
+      isNewFile,
+      isDeleted,
+      isRenamed,
+      hunks,
+      changedLines
+    };
+  }
+  /**
+   * Parse hunk content to extract line numbers
+   */
+  parseHunkContent(lines, newStart) {
+    const addedLines = [];
+    const deletedLines = [];
+    const header = lines[0];
+    const headerMatch = header.match(/^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/);
+    const oldStart = headerMatch ? parseInt(headerMatch[1], 10) : 0;
+    const oldLines = headerMatch && headerMatch[2] ? parseInt(headerMatch[2], 10) : 1;
+    const newLines = headerMatch && headerMatch[4] ? parseInt(headerMatch[4], 10) : 1;
+    let newLineNum = newStart;
+    let oldLineNum = oldStart;
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        addedLines.push(newLineNum);
+        newLineNum++;
+      } else if (line.startsWith("-") && !line.startsWith("---")) {
+        deletedLines.push(oldLineNum);
+        oldLineNum++;
+      } else if (line.startsWith(" ") || line === "") {
+        newLineNum++;
+        oldLineNum++;
+      }
+    }
+    return {
+      newStart,
+      newLines,
+      oldStart,
+      oldLines,
+      content: lines.join("\n"),
+      addedLines,
+      deletedLines
+    };
+  }
+  /**
+   * Check if a line number is in the diff (was changed)
+   */
+  isLineInDiff(fileDiff, lineNumber) {
+    return fileDiff.changedLines.has(lineNumber);
+  }
+  /**
+   * Get context around a specific line (for verification)
+   */
+  async getLineContext(file, lineNumber, contextLines = 3) {
+    try {
+      const fullPath = path.join(this.cwd, file);
+      const { readFile: readFile3 } = await import('fs/promises');
+      const content = await readFile3(fullPath, "utf-8");
+      const lines = content.split("\n");
+      const start = Math.max(0, lineNumber - contextLines - 1);
+      const end = Math.min(lines.length, lineNumber + contextLines);
+      return {
+        lines: lines.slice(start, end),
+        startLine: start + 1
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+function createDiffProvider(cwd) {
+  return new DiffProvider(cwd);
+}
+var CACHE_VERSION = 1;
+var CACHE_FILENAME = "llm-findings-cache.json";
+function hashFileContent(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function findingSignature(finding) {
+  return `${finding.file}:${finding.line}:${finding.endLine ?? finding.line}:${finding.type}`;
+}
+var FindingsCache = class {
+  cwd;
+  cachePath;
+  data = null;
+  constructor(cwd) {
+    this.cwd = cwd;
+    this.cachePath = join(cwd, ".kb", "ai-review", "cache", CACHE_FILENAME);
+  }
+  /**
+   * Load cache from disk
+   */
+  async load() {
+    try {
+      const content = await readFile(this.cachePath, "utf-8");
+      const parsed = JSON.parse(content);
+      if (parsed.version !== CACHE_VERSION) {
+        this.data = this.createEmptyCache();
+        return;
+      }
+      this.data = parsed;
+    } catch {
+      this.data = this.createEmptyCache();
+    }
+  }
+  /**
+   * Save cache to disk
+   */
+  async save() {
+    if (!this.data) {
+      return;
+    }
+    this.data.metadata.lastUpdatedAt = Date.now();
+    await mkdir(dirname(this.cachePath), { recursive: true });
+    await writeFile(this.cachePath, JSON.stringify(this.data, null, 2));
+  }
+  /**
+   * Look up files in cache
+   * Returns which files can use cached findings vs need fresh analysis
+   */
+  lookup(files) {
+    if (!this.data) {
+      return {
+        cached: [],
+        uncached: files,
+        stats: { cachedFiles: 0, uncachedFiles: files.length, cachedFindings: 0 }
+      };
+    }
+    const cached = [];
+    const uncached = [];
+    let cachedFindings = 0;
+    for (const file of files) {
+      const hash = hashFileContent(file.content);
+      const entry = this.data.entries[file.path];
+      if (entry && entry.contentHash === hash) {
+        cached.push({
+          file,
+          findings: entry.findings.map((f) => this.stripCacheFields(f))
+        });
+        cachedFindings += entry.findings.length;
+        entry.lastAccessedAt = Date.now();
+      } else {
+        uncached.push(file);
+      }
+    }
+    return {
+      cached,
+      uncached,
+      stats: {
+        cachedFiles: cached.length,
+        uncachedFiles: uncached.length,
+        cachedFindings
+      }
+    };
+  }
+  /**
+   * Update cache with new findings
+   */
+  update(files, findings) {
+    if (!this.data) {
+      this.data = this.createEmptyCache();
+    }
+    const findingsByFile = /* @__PURE__ */ new Map();
+    for (const finding of findings) {
+      const existing = findingsByFile.get(finding.file) ?? [];
+      existing.push(finding);
+      findingsByFile.set(finding.file, existing);
+    }
+    for (const file of files) {
+      const hash = hashFileContent(file.content);
+      const fileFindings = findingsByFile.get(file.path) ?? [];
+      const cachedFindings = fileFindings.map((f) => ({
+        ...f,
+        contentHash: hash,
+        cachedAt: Date.now()
+      }));
+      this.data.entries[file.path] = {
+        path: file.path,
+        contentHash: hash,
+        findings: cachedFindings,
+        createdAt: Date.now(),
+        lastAccessedAt: Date.now()
+      };
+    }
+    this.data.metadata.totalFiles = Object.keys(this.data.entries).length;
+    this.data.metadata.totalFindings = Object.values(this.data.entries).reduce((sum, entry) => sum + entry.findings.length, 0);
+  }
+  /**
+   * Compare new findings with cached to find new vs known issues
+   */
+  compareIncremental(newFindings, cachedFindings) {
+    const knownSignatures = /* @__PURE__ */ new Set();
+    if (this.data) {
+      for (const entry of Object.values(this.data.entries)) {
+        for (const finding of entry.findings) {
+          knownSignatures.add(findingSignature(finding));
+        }
+      }
+    }
+    const newIssues = [];
+    const knownIssues = [];
+    for (const finding of newFindings) {
+      const sig = findingSignature(finding);
+      if (knownSignatures.has(sig)) {
+        knownIssues.push(finding);
+      } else {
+        newIssues.push(finding);
+      }
+    }
+    return {
+      newFindings: newIssues,
+      knownFindings: knownIssues,
+      cachedFindings,
+      stats: {
+        new: newIssues.length,
+        known: knownIssues.length,
+        cached: cachedFindings.length,
+        total: newIssues.length + knownIssues.length + cachedFindings.length
+      }
+    };
+  }
+  /**
+   * Clear cache for specific files or all
+   */
+  clear(files) {
+    if (!this.data) {
+      return;
+    }
+    if (files) {
+      for (const file of files) {
+        delete this.data.entries[file];
+      }
+    } else {
+      this.data = this.createEmptyCache();
+    }
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    if (!this.data) {
+      return { totalFiles: 0, totalFindings: 0, cacheAge: 0 };
+    }
+    return {
+      totalFiles: this.data.metadata.totalFiles,
+      totalFindings: this.data.metadata.totalFindings,
+      cacheAge: Date.now() - this.data.metadata.createdAt
+    };
+  }
+  createEmptyCache() {
+    return {
+      version: CACHE_VERSION,
+      entries: {},
+      metadata: {
+        createdAt: Date.now(),
+        lastUpdatedAt: Date.now(),
+        totalFindings: 0,
+        totalFiles: 0
+      }
+    };
+  }
+  stripCacheFields(finding) {
+    const { contentHash: _contentHash, cachedAt: _cachedAt, ...rest } = finding;
+    return rest;
+  }
+};
+function createFindingsCache(cwd) {
+  return new FindingsCache(cwd);
+}
+
+// src/orchestrator.ts
+var ReviewOrchestrator = class {
+  /**
+   * Run code review.
+   *
+   * @param request - Review request
+   * @returns Review result with findings
+   */
+  async review(request) {
+    const startTime = Date.now();
+    const preset = await loadPreset(request.presetId);
+    const analytics = useAnalytics();
+    analytics?.track("review:started", {
+      mode: request.mode,
+      repoScope: request.repoScope,
+      presetId: request.presetId
+    });
+    const runCtx = {};
+    try {
+      const findings = await this.runAnalysis(request, preset, runCtx);
+      const analyzedFiles = await this.countFiles(request, preset);
+      const metadata = {
+        preset: request.presetId,
+        mode: request.mode,
+        filesReviewed: analyzedFiles,
+        analyzedFiles,
+        heuristicFindings: findings.filter((f) => f.source === "heuristic").length,
+        llmFindings: findings.filter((f) => f.source !== "heuristic").length,
+        totalFindings: findings.length,
+        durationMs: Date.now() - startTime,
+        engines: this.getEnginesUsed(findings)
+      };
+      if (runCtx.llmLiteResult) {
+        const llmMeta = runCtx.llmLiteResult.metadata;
+        Object.assign(metadata, {
+          llmLite: {
+            llmCalls: llmMeta.llmCalls,
+            toolCalls: llmMeta.toolCalls,
+            tokens: llmMeta.tokens,
+            estimatedCost: llmMeta.estimatedCost,
+            verification: llmMeta.verification,
+            timing: llmMeta.timing
+          }
+        });
+      }
+      if (runCtx.incrementalResult || runCtx.cacheLookup) {
+        const incr = runCtx.incrementalResult;
+        const cache = runCtx.cacheLookup;
+        const incrementalMeta = {
+          cachedFiles: cache?.stats.cachedFiles ?? 0,
+          analyzedFiles: cache?.stats.uncachedFiles ?? analyzedFiles,
+          newFindings: incr?.stats.new ?? findings.length,
+          knownFindings: incr?.stats.known ?? 0,
+          cachedFindings: incr?.stats.cached ?? 0
+        };
+        Object.assign(metadata, { incremental: incrementalMeta });
+      }
+      const result = {
+        findings,
+        summary: {
+          total: findings.length,
+          bySeverity: {
+            error: findings.filter((f) => f.severity === "blocker" || f.severity === "high").length,
+            warning: findings.filter((f) => f.severity === "medium").length,
+            info: findings.filter((f) => f.severity === "low" || f.severity === "info").length
+          },
+          byType: this.groupByType(findings)
+        },
+        metadata
+      };
+      analytics?.track("review:completed", {
+        mode: request.mode,
+        findingsCount: findings.length,
+        duration: result.metadata.durationMs
+      });
+      return result;
+    } catch (error) {
+      analytics?.track("review:failed", {
+        mode: request.mode,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+   * Run analysis based on review mode.
+   */
+  async runAnalysis(request, preset, runCtx) {
+    const mode = request.mode ?? "heuristic";
+    switch (mode) {
+      case "heuristic":
+        return this.runHeuristicAnalysis(request, preset);
+      case "full":
+        return this.runFullAnalysis(request, preset, runCtx);
+      case "llm":
+        return this.runLLMAnalysis(request, preset, runCtx);
+      default:
+        throw new Error(`Unknown review mode: ${mode}`);
+    }
+  }
+  /**
+   * Run heuristic-only analysis (CI mode).
+   *
+   * Fast, deterministic analysis using linters via CLI.
+   * No LLM calls.
+   */
+  async runHeuristicAnalysis(request, _preset) {
+    const files = request.files?.map((f) => f.path) ?? [];
+    if (files.length === 0) {
+      return [];
+    }
+    const runner = new LinterRunner();
+    const results = await runner.runAll(files);
+    const logger = useLogger();
+    for (const result of results) {
+      if (result.error) {
+        logger?.warn(`[${result.engineId}] ${result.error}`);
+      }
+    }
+    const findings = LinterRunner.collectFindings(results);
+    return deduplicateFindings(findings);
+  }
+  /**
+   * Run full analysis (heuristic + LLM-Lite).
+   *
+   * Runs heuristic analysis (ESLint, etc.) and LLM-Lite in parallel.
+   * Combines deterministic linting with intelligent code review.
+   * Both use caching for incremental analysis.
+   */
+  async runFullAnalysis(request, preset, runCtx) {
+    const llm = useLLM({ tier: "medium" });
+    const [heuristicFindings, llmFindings] = await Promise.all([
+      // Heuristic analysis (ESLint, etc.)
+      this.runHeuristicAnalysis(request, preset),
+      // LLM-Lite analysis with caching (if LLM available and files provided)
+      llm && request.files?.length ? this.runLLMAnalysis(request, preset, runCtx) : Promise.resolve([])
+    ]);
+    return deduplicateFindings([...heuristicFindings, ...llmFindings]);
+  }
+  /**
+   * Run LLM-Lite analysis (v2) with incremental caching.
+   *
+   * Uses batch tools, diff-based context, and anti-hallucination verification.
+   * Caches findings by file content hash to skip unchanged files.
+   */
+  async runLLMAnalysis(request, _preset, runCtx) {
+    if (!request.files || request.files.length === 0) {
+      return [];
+    }
+    const cwd = request.cwd ?? process.cwd();
+    const findingsCache = createFindingsCache(cwd);
+    await findingsCache.load();
+    const cacheLookup = findingsCache.lookup(request.files);
+    runCtx.cacheLookup = cacheLookup;
+    const cachedFindings = [];
+    for (const cached of cacheLookup.cached) {
+      cachedFindings.push(...cached.findings);
+    }
+    if (cacheLookup.uncached.length === 0) {
+      runCtx.incrementalResult = {
+        newFindings: [],
+        knownFindings: [],
+        cachedFindings,
+        stats: {
+          new: 0,
+          known: 0,
+          cached: cachedFindings.length,
+          total: cachedFindings.length
+        }
+      };
+      return cachedFindings;
+    }
+    const diffProvider = createDiffProvider(cwd);
+    const result = await runLLMLiteAnalysis({
+      cwd,
+      files: cacheLookup.uncached,
+      taskContext: request.taskContext,
+      repoScope: request.repoScope,
+      diffProvider
+    });
+    runCtx.llmLiteResult = result;
+    const incrementalResult = findingsCache.compareIncremental(
+      result.findings,
+      cachedFindings
+    );
+    runCtx.incrementalResult = incrementalResult;
+    findingsCache.update(cacheLookup.uncached, result.findings);
+    await findingsCache.save();
+    const allFindings = [
+      ...incrementalResult.newFindings,
+      ...incrementalResult.knownFindings,
+      ...incrementalResult.cachedFindings
+    ];
+    return deduplicateFindings(allFindings);
+  }
+  /**
+   * Resolve file patterns to absolute paths.
+   *
+   * Note: Files must be provided in request.files.
+   * Pattern resolution should happen at CLI layer using ctx.runtime.fs.glob()
+   */
+  async resolvePatterns(request, _preset) {
+    if (!request.files || request.files.length === 0) {
+      throw new Error("No files provided for review. Use ctx.runtime.fs.glob() at CLI layer to resolve patterns.");
+    }
+    return request.files.map((f) => f.path);
+  }
+  /**
+   * Count files to be analyzed.
+   */
+  async countFiles(request, preset) {
+    const files = await this.resolvePatterns(request, preset);
+    return files.length;
+  }
+  /**
+   * Get list of engines that produced findings.
+   */
+  getEnginesUsed(findings) {
+    const engines = new Set(findings.map((f) => f.engine));
+    return [...engines];
+  }
+  /**
+   * Group findings by type.
+   */
+  groupByType(findings) {
+    const groups = {};
+    for (const finding of findings) {
+      const type = finding.type;
+      groups[type] = (groups[type] ?? 0) + 1;
+    }
+    return groups;
+  }
+  /**
+   * Generate cache key for heuristic analysis.
+   */
+  generateCacheKey(engine, request) {
+    const filePaths = request.files ? request.files.map((f) => f.path).sort().join(",") : "default";
+    const repoScopeKey = request.repoScope ? Array.isArray(request.repoScope) ? request.repoScope.join(",") : String(request.repoScope) : "default";
+    const parts = [
+      "review",
+      engine,
+      repoScopeKey,
+      request.presetId ?? "default",
+      filePaths
+    ];
+    return parts.join(":");
+  }
+};
+async function runReview(request) {
+  const orchestrator = new ReviewOrchestrator();
+  return orchestrator.review(request);
+}
+function parseGitmodules(cwd) {
+  const result = /* @__PURE__ */ new Map();
+  const gitmodulesPath = join(cwd, ".gitmodules");
+  if (!existsSync(gitmodulesPath)) {
+    return result;
+  }
+  try {
+    const content = readFileSync(gitmodulesPath, "utf-8");
+    const pathMatches = content.matchAll(/^\s*path\s*=\s*(.+)$/gm);
+    for (const match of pathMatches) {
+      const relPath = (match[1] ?? "").trim();
+      if (!relPath) {
+        continue;
+      }
+      const name = relPath.split("/").pop() ?? relPath;
+      result.set(name, relPath);
+    }
+  } catch {
+  }
+  return result;
+}
+function resolveRepoPath(cwd, repo, submodules) {
+  const direct = join(cwd, repo);
+  if (existsSync(direct)) {
+    return direct;
+  }
+  const relPath = submodules.get(repo);
+  if (relPath) {
+    const full = join(cwd, relPath);
+    if (existsSync(full)) {
+      return full;
+    }
+  }
+  return null;
+}
+function resolveRepoRelative(cwd, repo, submodules) {
+  if (existsSync(join(cwd, repo))) {
+    return repo;
+  }
+  const relPath = submodules.get(repo);
+  if (relPath && existsSync(join(cwd, relPath))) {
+    return relPath;
+  }
+  return null;
+}
+async function resolveGitScope(options) {
+  const {
+    cwd,
+    repos,
+    includeStaged = true,
+    includeUnstaged = true,
+    includeUntracked = false
+  } = options;
+  const allFiles = [];
+  let stagedCount = 0;
+  let unstagedCount = 0;
+  let untrackedCount = 0;
+  const submodules = parseGitmodules(cwd);
+  for (const repo of repos) {
+    const repoPath = resolveRepoPath(cwd, repo, submodules);
+    const repoRelative = resolveRepoRelative(cwd, repo, submodules) ?? repo;
+    if (!repoPath) {
+      useLogger()?.debug(`[git-scope] Repo not found: ${repo}`);
+      continue;
+    }
+    const gitPath = join(repoPath, ".git");
+    const isNestedRepo = existsSync(gitPath);
+    const gitCwd = isNestedRepo ? repoPath : cwd;
+    try {
+      const git = simpleGit(gitCwd);
+      const status = await git.status();
+      const filePaths = [];
+      if (includeStaged) {
+        const stagedNotDeleted = status.staged.filter((f) => !status.deleted.includes(f));
+        stagedCount += stagedNotDeleted.length;
+        filePaths.push(...stagedNotDeleted);
+      }
+      if (includeUnstaged) {
+        const unstaged = status.modified.filter((f) => !status.staged.includes(f));
+        unstagedCount += unstaged.length;
+        filePaths.push(...unstaged);
+      }
+      if (includeUntracked) {
+        untrackedCount += status.not_added.length;
+        filePaths.push(...status.not_added);
+      }
+      const uniquePaths = [...new Set(filePaths)].filter((f) => !shouldIgnoreFile(f)).filter((f) => isReviewableFile(f));
+      for (const filePath of uniquePaths) {
+        try {
+          const absolutePath = join(gitCwd, filePath);
+          const content = await readFile(absolutePath, "utf-8");
+          const relativePath = isNestedRepo ? `${repoRelative}/${filePath}` : filePath;
+          allFiles.push({
+            path: relativePath,
+            content
+          });
+        } catch {
+          useLogger()?.debug(`[git-scope] Could not read file: ${filePath}`);
+        }
+      }
+    } catch (error) {
+      useLogger()?.debug(`[git-scope] Git error in ${repo}:`, { error });
+    }
+  }
+  return {
+    files: allFiles,
+    summary: {
+      repos,
+      staged: stagedCount,
+      unstaged: unstagedCount,
+      untracked: untrackedCount,
+      total: allFiles.length
+    }
+  };
+}
+async function discoverRepos(cwd) {
+  const submodules = parseGitmodules(cwd);
+  if (submodules.size > 0) {
+    return [...submodules.values()].filter(
+      (relPath) => existsSync(join(cwd, relPath, ".git"))
+    );
+  }
+  const repos = [];
+  try {
+    const entries = readdirSync(cwd);
+    for (const entry of entries) {
+      if (entry.startsWith(".") || entry === "node_modules") {
+        continue;
+      }
+      try {
+        const entryPath = join(cwd, entry);
+        if (statSync(entryPath).isDirectory() && existsSync(join(entryPath, ".git"))) {
+          repos.push(entry);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return repos;
+}
+async function getReposWithChanges(cwd) {
+  const allRepos = await discoverRepos(cwd);
+  const reposWithChanges = [];
+  for (const repo of allRepos) {
+    const repoPath = join(cwd, repo);
+    try {
+      const git = simpleGit(repoPath);
+      const status = await git.status();
+      const hasChanges = status.staged.length > 0 || status.modified.length > 0 || status.deleted.length > 0 || status.not_added.length > 0;
+      if (hasChanges) {
+        reposWithChanges.push(repo);
+      }
+    } catch {
+    }
+  }
+  return reposWithChanges;
+}
+function shouldIgnoreFile(file) {
+  const ignoredPaths = [
+    "node_modules/",
+    ".git/",
+    "dist/",
+    "build/",
+    ".next/",
+    ".turbo/",
+    "coverage/",
+    ".cache/",
+    ".temp/",
+    "tmp/",
+    "pnpm-lock.yaml",
+    "package-lock.json",
+    "yarn.lock"
+  ];
+  return ignoredPaths.some((path2) => file.includes(path2));
+}
+function isReviewableFile(file) {
+  const reviewableExtensions = [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".py",
+    ".go",
+    ".rs",
+    ".java",
+    ".kt",
+    ".swift",
+    ".rb",
+    ".php",
+    ".c",
+    ".cpp",
+    ".h",
+    ".hpp",
+    ".cs"
+  ];
+  return reviewableExtensions.some((ext) => file.endsWith(ext));
+}
+
+export { DiffProvider, FindingsCache, PresetLoader, ReviewOrchestrator, builtinPresets, createDiffProvider, createFindingsCache, discoverRepos, findingSignature, getPresetLoader, getReposWithChanges, hashFileContent, loadPreset, resolveGitScope, runReview };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map