scip-query 0.1.0

package/dist/index.js

@@ -0,0 +1,1271 @@
+import "./chunk-JJP7KQND.js";
+import {
+  surface
+} from "./chunk-FFSWWE5O.js";
+import {
+  symbols
+} from "./chunk-KCBMVQL5.js";
+import {
+  system
+} from "./chunk-DCKMSTJ4.js";
+import {
+  trace
+} from "./chunk-TBP6BICL.js";
+import {
+  redundantReexports
+} from "./chunk-3E2X7RIE.js";
+import {
+  refs
+} from "./chunk-6NBLIDF4.js";
+import {
+  similarChains
+} from "./chunk-JKP5GH6T.js";
+import {
+  similarFiles
+} from "./chunk-Z73NYSBZ.js";
+import {
+  similarSignatures
+} from "./chunk-SEFSL2GF.js";
+import {
+  slice
+} from "./chunk-ZJRYBOEE.js";
+import {
+  hierarchy
+} from "./chunk-DEZKCZXD.js";
+import {
+  hotspots
+} from "./chunk-BFSCMC22.js";
+import {
+  importedBy,
+  imports,
+  unusedImports
+} from "./chunk-BEPIEVLR.js";
+import {
+  members
+} from "./chunk-3UOUTZQT.js";
+import {
+  methods
+} from "./chunk-NUZ4OMU3.js";
+import {
+  outline
+} from "./chunk-6SXADWLW.js";
+import {
+  deps,
+  rdeps
+} from "./chunk-N5KEREIA.js";
+import {
+  diffImpact
+} from "./chunk-YZAA4LYG.js";
+import {
+  docCoverage
+} from "./chunk-FGXRVW7G.js";
+import {
+  fanIn,
+  fanOut,
+  topFanIn,
+  topFanOut
+} from "./chunk-GTILYBH6.js";
+import {
+  files
+} from "./chunk-MGNMHKX3.js";
+import {
+  health
+} from "./chunk-7OZPA5OO.js";
+import {
+  staleAbstractions
+} from "./chunk-GJFURBEW.js";
+import {
+  stats
+} from "./chunk-XFXDXEUN.js";
+import {
+  testCoverage,
+  testCoverageSummary
+} from "./chunk-3ZZJVBIO.js";
+import {
+  wrapperCandidates
+} from "./chunk-TDNNOR6D.js";
+import {
+  passthroughCandidates
+} from "./chunk-NDSQYIWT.js";
+import {
+  similar,
+  similarAll
+} from "./chunk-TSPZOMHC.js";
+import {
+  isolated
+} from "./chunk-LUSIFBXO.js";
+import {
+  drift
+} from "./chunk-36OMT7ZJ.js";
+import {
+  extractCandidates
+} from "./chunk-CM454WL3.js";
+import {
+  complexityHotspots
+} from "./chunk-EMDQWNYR.js";
+import {
+  complexity
+} from "./chunk-BP2ATLK2.js";
+import {
+  convergence
+} from "./chunk-LB7OS35Q.js";
+import {
+  coupling,
+  topCoupling
+} from "./chunk-KVSW5KYP.js";
+import {
+  cycles
+} from "./chunk-5WTJAXY2.js";
+import {
+  dataflow
+} from "./chunk-T6ARFSBZ.js";
+import {
+  dead
+} from "./chunk-5FGUEU7N.js";
+import {
+  deepChains
+} from "./chunk-MBVNHJVN.js";
+import {
+  affected
+} from "./chunk-6VJ6Q7IE.js";
+import {
+  bottlenecks
+} from "./chunk-2QZ23IBN.js";
+import {
+  byKind,
+  kindCounts
+} from "./chunk-LAWMH22O.js";
+import {
+  callGraph
+} from "./chunk-UNTPVD36.js";
+import {
+  changeSurface
+} from "./chunk-VRUJH4BO.js";
+import "./chunk-4TYLS5XX.js";
+import {
+  code
+} from "./chunk-VZ7AMAFL.js";
+import "./chunk-FUHJCHS4.js";
+import {
+  leafName,
+  parseSymbol,
+  shortenSymbol
+} from "./chunk-QOV2R2WT.js";
+
+// src/db.ts
+import Database from "better-sqlite3";
+import { statSync } from "fs";
+var ScipDatabase = class {
+  db;
+  config;
+  pathFilter;
+  constructor(config, pathFilter) {
+    this.config = config;
+    this.pathFilter = pathFilter ?? null;
+    this.db = new Database(config.dbPath, { readonly: true });
+    this.db.pragma("busy_timeout = 5000");
+  }
+  /** Attach a gitignore-based path filter for query results */
+  setPathFilter(filter) {
+    this.pathFilter = filter;
+  }
+  /** Check if a path should be excluded based on .gitignore rules */
+  isIgnored(relativePath) {
+    return this.pathFilter?.isIgnored(relativePath) ?? false;
+  }
+  /** Filter an array of paths using the gitignore filter */
+  filterPaths(paths) {
+    return this.pathFilter?.filter(paths) ?? paths;
+  }
+  /**
+   * The local-symbol predicate: only match symbols that are defined
+   * in files NOT excluded by gitignore. This replaces the old hardcoded
+   * `NOT LIKE 'node_modules/%'` check.
+   *
+   * Since SQLite can't evaluate JS gitignore rules inline, we use a
+   * simpler approach: query broadly, then filter in JS. For queries
+   * that need SQL-level filtering, use excludedPathPatterns().
+   */
+  get localSymbolPredicate() {
+    return `EXISTS (
+      SELECT 1
+      FROM defn_enclosing_ranges local_der
+      JOIN documents local_d ON local_der.document_id = local_d.id
+      WHERE local_der.symbol_id = gs.id
+        ${this.pathExclusionsFor("local_d").trimStart()}
+    )`;
+  }
+  /**
+   * SQL WHERE clause fragments to exclude common build/dependency paths.
+   * Complements the JS-level gitignore filtering for performance.
+   */
+  get pathExclusions() {
+    return this.pathExclusionsFor("d");
+  }
+  /** Reusable SQL fragment: filter out synthetic/internal symbol noise */
+  get symbolNoise() {
+    return this.symbolNoiseFor("gs");
+  }
+  /** Build SQL path exclusions for one or more document table aliases */
+  pathExclusionsFor(...aliases) {
+    return aliases.flatMap((alias) => [
+      `AND ${alias}.relative_path NOT LIKE 'node_modules/%'`,
+      `AND ${alias}.relative_path NOT LIKE '.git/%'`
+    ]).join("\n      ");
+  }
+  /** Build SQL symbol exclusions for the given global_symbols alias */
+  symbolNoiseFor(alias) {
+    return `AND ${alias}.symbol NOT LIKE '%().(%' AND ${alias}.symbol NOT LIKE '%typeLiteral%'`;
+  }
+  /** Run a raw SQL query and return all rows */
+  all(sql, ...params) {
+    return this.db.prepare(sql).all(...params);
+  }
+  /** Run a raw SQL query and return the first row */
+  get(sql, ...params) {
+    return this.db.prepare(sql).get(...params);
+  }
+  /** Get the database file size in bytes */
+  sizeBytes() {
+    try {
+      return statSync(this.config.dbPath).size;
+    } catch {
+      return 0;
+    }
+  }
+  /** Get the last modification time of the database file */
+  lastModified() {
+    try {
+      return statSync(this.config.dbPath).mtime;
+    } catch {
+      return null;
+    }
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/gitignore-filter.ts
+import ignore from "ignore";
+import { readFileSync, existsSync } from "fs";
+import { join, dirname } from "path";
+function createGitignoreFilter(projectRoot) {
+  const ig = ignore();
+  let loaded = false;
+  const gitignorePaths = findGitignoreFiles(projectRoot);
+  for (const gitignorePath of gitignorePaths) {
+    try {
+      const content = readFileSync(gitignorePath, "utf-8");
+      ig.add(content);
+      loaded = true;
+    } catch {
+    }
+  }
+  if (!loaded) {
+    ig.add(DEFAULT_IGNORES);
+  }
+  return {
+    isIgnored: (relativePath) => ig.ignores(relativePath),
+    filter: (paths) => paths.filter((p) => !ig.ignores(p))
+  };
+}
+function findGitignoreFiles(projectRoot) {
+  const files2 = [];
+  const rootGitignore = join(projectRoot, ".gitignore");
+  if (existsSync(rootGitignore)) {
+    files2.push(rootGitignore);
+  }
+  let dir = dirname(projectRoot);
+  let depth = 0;
+  while (dir !== dirname(dir) && depth < 5) {
+    const parentGitignore = join(dir, ".gitignore");
+    if (existsSync(parentGitignore)) {
+      files2.push(parentGitignore);
+    }
+    if (existsSync(join(dir, ".git"))) break;
+    dir = dirname(dir);
+    depth++;
+  }
+  return files2;
+}
+var DEFAULT_IGNORES = `
+# Dependencies
+node_modules/
+vendor/
+.bundle/
+
+# Build output
+dist/
+build/
+out/
+target/
+bin/
+obj/
+
+# Python
+__pycache__/
+*.pyc
+*.pyo
+.venv/
+venv/
+.env/
+env/
+*.egg-info/
+
+# Rust
+target/
+
+# Java / Kotlin / Scala
+*.class
+.gradle/
+.mvn/
+
+# C# / .NET
+bin/
+obj/
+packages/
+
+# Go
+vendor/
+
+# Dart
+.dart_tool/
+build/
+
+# PHP
+vendor/
+
+# IDE / OS
+.idea/
+.vscode/
+*.swp
+*.swo
+.DS_Store
+Thumbs.db
+
+# Type definitions (often noise in queries)
+*.d.ts
+`;
+
+// src/reindex/index.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+
+// src/reindex/detect.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var LANGUAGE_MARKERS = [
+  { language: "typescript", files: ["tsconfig.json", "tsconfig.base.json"] },
+  { language: "rust", files: ["Cargo.toml"] },
+  { language: "go", files: ["go.mod"] },
+  { language: "java", files: ["pom.xml", "build.gradle", "build.gradle.kts"] },
+  { language: "kotlin", files: ["build.gradle.kts"] },
+  { language: "scala", files: ["build.sbt"] },
+  { language: "python", files: ["pyproject.toml", "setup.py", "setup.cfg", "Pipfile"] },
+  { language: "ruby", files: ["Gemfile"] },
+  { language: "csharp", files: ["*.csproj", "*.sln"] },
+  { language: "dart", files: ["pubspec.yaml"] },
+  { language: "php", files: ["composer.json"] },
+  { language: "javascript", files: ["package.json"] }
+  // Last — very common, low specificity
+];
+function detectLanguages(projectRoot) {
+  const detected = [];
+  for (const marker of LANGUAGE_MARKERS) {
+    for (const file of marker.files) {
+      if (file.includes("*")) {
+        continue;
+      }
+      if (existsSync2(join2(projectRoot, file))) {
+        if (!detected.includes(marker.language)) {
+          detected.push(marker.language);
+        }
+        break;
+      }
+    }
+  }
+  if (detected.includes("typescript")) {
+    const jsIdx = detected.indexOf("javascript");
+    if (jsIdx !== -1) detected.splice(jsIdx, 1);
+  }
+  return detected;
+}
+
+// src/reindex/indexers.ts
+var INDEXER_CONFIGS = {
+  typescript: {
+    language: "typescript",
+    indexerBinary: "scip-typescript",
+    checkCommand: "npx scip-typescript --version",
+    indexArgs: ({ outputPath, pnpmWorkspaces }) => {
+      const args = ["scip-typescript", "index", "--infer-tsconfig", "--output", outputPath, "--no-progress-bar"];
+      if (pnpmWorkspaces) args.splice(2, 0, "--pnpm-workspaces");
+      return { binary: "npx", args };
+    },
+    markerFiles: ["tsconfig.json"],
+    installMethods: [
+      { label: "npm", prerequisite: "npm", binary: "npm", args: ["install", "-g", "@sourcegraph/scip-typescript"] }
+    ],
+    installUrl: "https://github.com/sourcegraph/scip-typescript"
+  },
+  javascript: {
+    language: "javascript",
+    indexerBinary: "scip-typescript",
+    checkCommand: "npx scip-typescript --version",
+    indexArgs: ({ outputPath }) => ({
+      binary: "npx",
+      args: ["scip-typescript", "index", "--infer-tsconfig", "--output", outputPath, "--no-progress-bar"]
+    }),
+    markerFiles: ["package.json"],
+    installMethods: [
+      { label: "npm", prerequisite: "npm", binary: "npm", args: ["install", "-g", "@sourcegraph/scip-typescript"] }
+    ],
+    installUrl: "https://github.com/sourcegraph/scip-typescript"
+  },
+  java: {
+    language: "java",
+    indexerBinary: "scip-java",
+    checkCommand: "scip-java --version",
+    indexArgs: ({ outputPath }) => ({
+      binary: "scip-java",
+      args: ["index", "--output", outputPath]
+    }),
+    markerFiles: ["pom.xml", "build.gradle"],
+    installMethods: [
+      { label: "coursier", prerequisite: "cs", binary: "cs", args: ["install", "scip-java"] }
+    ],
+    installUrl: "https://github.com/sourcegraph/scip-java/releases"
+  },
+  scala: {
+    language: "scala",
+    indexerBinary: "scip-java",
+    checkCommand: "scip-java --version",
+    indexArgs: ({ outputPath }) => ({
+      binary: "scip-java",
+      args: ["index", "--output", outputPath]
+    }),
+    markerFiles: ["build.sbt"],
+    installMethods: [
+      { label: "coursier", prerequisite: "cs", binary: "cs", args: ["install", "scip-java"] }
+    ],
+    installUrl: "https://github.com/sourcegraph/scip-java/releases"
+  },
+  kotlin: {
+    language: "kotlin",
+    indexerBinary: "scip-java",
+    checkCommand: "scip-java --version",
+    indexArgs: ({ outputPath }) => ({
+      binary: "scip-java",
+      args: ["index", "--output", outputPath]
+    }),
+    markerFiles: ["build.gradle.kts"],
+    installMethods: [
+      { label: "coursier", prerequisite: "cs", binary: "cs", args: ["install", "scip-java"] }
+    ],
+    installUrl: "https://github.com/sourcegraph/scip-java/releases"
+  },
+  rust: {
+    language: "rust",
+    indexerBinary: "rust-analyzer",
+    checkCommand: "rust-analyzer --version",
+    indexArgs: ({ outputPath }) => ({
+      binary: "rust-analyzer",
+      args: ["scip", ".", "--output", outputPath]
+    }),
+    markerFiles: ["Cargo.toml"],
+    installMethods: [
+      { label: "rustup", prerequisite: "rustup", binary: "rustup", args: ["component", "add", "rust-analyzer"] }
+    ],
+    installUrl: "https://github.com/rust-lang/rust-analyzer"
+  },
+  python: {
+    language: "python",
+    indexerBinary: "scip-python",
+    checkCommand: "scip-python --version",
+    indexArgs: ({ outputPath }) => ({
+      binary: "scip-python",
+      args: ["index", "--output", outputPath, "--project-name", "project"]
+    }),
+    markerFiles: ["pyproject.toml", "setup.py"],
+    installMethods: [
+      { label: "npm", prerequisite: "npm", binary: "npm", args: ["install", "-g", "scip-python-plus"] }
+    ],
+    installUrl: "https://github.com/PlunderStruck/scip-python"
+  },
+  ruby: {
+    language: "ruby",
+    indexerBinary: "scip-ruby",
+    checkCommand: "scip-ruby --version",
+    indexArgs: ({ outputPath }) => ({
+      binary: "scip-ruby",
+      args: ["--output", outputPath]
+    }),
+    markerFiles: ["Gemfile"],
+    installMethods: [],
+    installUrl: "https://github.com/sourcegraph/scip-ruby/releases"
+  },
+  go: {
+    language: "go",
+    indexerBinary: "scip-go",
+    checkCommand: "scip-go --version",
+    indexArgs: ({ outputPath }) => ({
+      binary: "scip-go",
+      args: ["--output", outputPath]
+    }),
+    markerFiles: ["go.mod"],
+    installMethods: [
+      { label: "go install", prerequisite: "go", binary: "go", args: ["install", "github.com/sourcegraph/scip-go@latest"] }
+    ],
+    installUrl: "https://github.com/sourcegraph/scip-go"
+  },
+  cpp: {
+    language: "cpp",
+    indexerBinary: "scip-clang",
+    checkCommand: "scip-clang --version",
+    indexArgs: ({ outputPath }) => ({
+      binary: "scip-clang",
+      args: ["--output", outputPath]
+    }),
+    markerFiles: ["CMakeLists.txt", "Makefile"],
+    installMethods: [],
+    installUrl: "https://github.com/sourcegraph/scip-clang/releases"
+  },
+  c: {
+    language: "c",
+    indexerBinary: "scip-clang",
+    checkCommand: "scip-clang --version",
+    indexArgs: ({ outputPath }) => ({
+      binary: "scip-clang",
+      args: ["--output", outputPath]
+    }),
+    markerFiles: ["CMakeLists.txt", "Makefile"],
+    installMethods: [],
+    installUrl: "https://github.com/sourcegraph/scip-clang/releases"
+  },
+  csharp: {
+    language: "csharp",
+    indexerBinary: "scip-dotnet",
+    checkCommand: "scip-dotnet --version",
+    indexArgs: ({ outputPath }) => ({
+      binary: "scip-dotnet",
+      args: ["index", "--output", outputPath]
+    }),
+    markerFiles: [],
+    installMethods: [
+      { label: "dotnet", prerequisite: "dotnet", binary: "dotnet", args: ["tool", "install", "--global", "scip-dotnet"] }
+    ],
+    installUrl: "https://github.com/sourcegraph/scip-dotnet/releases"
+  },
+  dart: {
+    language: "dart",
+    indexerBinary: "scip-dart",
+    checkCommand: "scip-dart --version",
+    indexArgs: ({ outputPath }) => ({
+      binary: "scip-dart",
+      args: ["index", "--output", outputPath]
+    }),
+    markerFiles: ["pubspec.yaml"],
+    installMethods: [
+      { label: "dart pub", prerequisite: "dart", binary: "dart", args: ["pub", "global", "activate", "scip_dart"] }
+    ],
+    installUrl: "https://github.com/Workiva/scip-dart/releases"
+  },
+  php: {
+    language: "php",
+    indexerBinary: "scip-php",
+    checkCommand: "scip-php --version",
+    indexArgs: ({ outputPath }) => ({
+      binary: "scip-php",
+      args: ["index", "--output", outputPath]
+    }),
+    markerFiles: ["composer.json"],
+    installMethods: [
+      { label: "composer", prerequisite: "composer", binary: "composer", args: ["global", "require", "davidrjenni/scip-php"] }
+    ],
+    installUrl: "https://github.com/davidrjenni/scip-php/releases"
+  }
+};
+function getIndexerConfig(language) {
+  return INDEXER_CONFIGS[language];
+}
+
+// src/reindex/install.ts
+import { execFileSync } from "child_process";
+import { platform } from "os";
+var IS_WINDOWS = platform() === "win32";
+function isBinaryAvailable(name) {
+  const cmd = IS_WINDOWS ? "where" : "which";
+  try {
+    execFileSync(cmd, [name], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isIndexerInstalled(config) {
+  return isBinaryAvailable(config.indexerBinary);
+}
+function tryInstallIndexer(config, onStatus) {
+  const methods2 = config.installMethods;
+  if (!methods2?.length) {
+    onStatus(`No auto-install method available for ${config.indexerBinary}.`);
+    if (config.installUrl) {
+      onStatus(`Install manually from: ${config.installUrl}`);
+    }
+    return false;
+  }
+  for (const method of methods2) {
+    if (!isBinaryAvailable(method.prerequisite)) {
+      continue;
+    }
+    onStatus(`Installing ${config.indexerBinary} via ${method.label}...`);
+    try {
+      execFileSync(method.binary, method.args, {
+        stdio: "inherit",
+        timeout: 3e5,
+        env: process.env
+      });
+      if (isIndexerInstalled(config)) {
+        onStatus(`Successfully installed ${config.indexerBinary} via ${method.label}`);
+        return true;
+      }
+      onStatus(`${method.label} command completed but ${config.indexerBinary} not found on PATH`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      onStatus(`${method.label} install failed: ${msg}`);
+    }
+  }
+  onStatus(`Could not auto-install ${config.indexerBinary}.`);
+  if (config.installUrl) {
+    onStatus(`Install manually from: ${config.installUrl}`);
+  }
+  return false;
+}
+function tryInstallScipCli(onStatus) {
+  if (platform() === "darwin" && isBinaryAvailable("brew")) {
+    onStatus("Installing scip CLI via Homebrew...");
+    try {
+      execFileSync("brew", ["install", "sourcegraph/scip/scip"], {
+        stdio: "inherit",
+        timeout: 3e5,
+        env: process.env
+      });
+      if (isBinaryAvailable("scip")) {
+        onStatus("Successfully installed scip CLI via Homebrew");
+        return true;
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      onStatus(`Homebrew install failed: ${msg}`);
+    }
+  }
+  if (isBinaryAvailable("go")) {
+    onStatus("Installing scip CLI via go install...");
+    try {
+      execFileSync("go", ["install", "github.com/sourcegraph/scip/cmd/scip@latest"], {
+        stdio: "inherit",
+        timeout: 3e5,
+        env: process.env
+      });
+      if (isBinaryAvailable("scip")) {
+        onStatus("Successfully installed scip CLI via go install");
+        return true;
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      onStatus(`go install failed: ${msg}`);
+    }
+  }
+  onStatus("Could not auto-install scip CLI.");
+  onStatus("Install manually from: https://github.com/sourcegraph/scip/releases");
+  return false;
+}
+
+// src/reindex/index.ts
+async function reindex(opts) {
+  const {
+    projectRoot,
+    maxHeapMb = 8192,
+    onStatus = console.log,
+    skipAutoInstall = false
+  } = opts;
+  const outputScip = opts.outputScip ?? join3(projectRoot, "index.scip");
+  const outputDb = opts.outputDb ?? join3(projectRoot, "index.db");
+  const start = Date.now();
+  const languages = opts.languages ?? detectLanguages(projectRoot);
+  if (languages.length === 0) {
+    throw new Error(
+      "No supported languages detected in this project. Looked for: tsconfig.json, Cargo.toml, go.mod, pyproject.toml, etc."
+    );
+  }
+  onStatus(`Detected languages: ${languages.join(", ")}`);
+  if (!isBinaryAvailable("scip")) {
+    if (skipAutoInstall) {
+      throw new Error(
+        "The scip CLI is required but not found on PATH.\nInstall from: https://github.com/sourcegraph/scip/releases"
+      );
+    }
+    onStatus("scip CLI not found on PATH. Attempting auto-install...");
+    if (!tryInstallScipCli(onStatus)) {
+      throw new Error(
+        "The scip CLI is required but could not be installed.\nInstall manually from: https://github.com/sourcegraph/scip/releases"
+      );
+    }
+  }
+  const env = {
+    ...process.env,
+    NODE_OPTIONS: `--max-old-space-size=${maxHeapMb}`
+  };
+  for (const lang of languages) {
+    const config = getIndexerConfig(lang);
+    if (!isIndexerInstalled(config)) {
+      if (skipAutoInstall) {
+        throw new Error(
+          `${config.indexerBinary} is required to index ${lang} but not found on PATH.
+` + (config.installUrl ? `Install from: ${config.installUrl}` : `Make sure ${config.indexerBinary} is installed and available on PATH.`)
+        );
+      }
+      onStatus(`${config.indexerBinary} not found. Attempting auto-install...`);
+      if (!tryInstallIndexer(config, onStatus)) {
+        throw new Error(
+          `${config.indexerBinary} is required to index ${lang} but could not be installed.
+` + (config.installUrl ? `Install manually from: ${config.installUrl}` : `Make sure ${config.indexerBinary} is installed and available on PATH.`)
+        );
+      }
+    }
+    onStatus(`Indexing ${lang} with ${config.indexerBinary}...`);
+    const { binary, args } = config.indexArgs({
+      projectRoot,
+      outputPath: outputScip,
+      pnpmWorkspaces: opts.pnpmWorkspaces
+    });
+    try {
+      execFileSync2(binary, args, {
+        cwd: projectRoot,
+        env,
+        stdio: "pipe",
+        maxBuffer: 50 * 1024 * 1024
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(
+        `Failed to index ${lang} with ${config.indexerBinary}: ${msg}
+Make sure ${config.indexerBinary} is installed and available on PATH.`
+      );
+    }
+  }
+  onStatus("Converting to SQLite...");
+  if (!existsSync3(outputScip)) {
+    throw new Error(`SCIP index not found at ${outputScip} after indexing`);
+  }
+  try {
+    execFileSync2("scip", ["expt-convert", "--output", outputDb, outputScip], {
+      env,
+      stdio: "pipe",
+      maxBuffer: 50 * 1024 * 1024
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to convert SCIP index to SQLite: ${msg}`);
+  }
+  const durationMs = Date.now() - start;
+  onStatus(`Done in ${(durationMs / 1e3).toFixed(1)}s`);
+  return { languages, indexPath: outputScip, dbPath: outputDb, durationMs };
+}
+
+// src/config.ts
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync4, mkdirSync } from "fs";
+import { join as join4, resolve } from "path";
+import { createHash } from "crypto";
+import { homedir } from "os";
+var CONFIG_FILENAME = ".scipquery.json";
+var DEFAULT_WATCH = {
+  enabled: false,
+  debounceMs: 3e4,
+  cooldownMs: 6e4,
+  ignore: []
+};
+function loadProjectConfig(projectRoot) {
+  const configPath = join4(projectRoot, CONFIG_FILENAME);
+  if (!existsSync4(configPath)) {
+    return {};
+  }
+  try {
+    const raw = readFileSync2(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function resolveWatchConfig(config) {
+  return {
+    ...DEFAULT_WATCH,
+    ...config.watch
+  };
+}
+function resolveCacheDir(projectRoot, config) {
+  const envOverride = process.env["SCIP_QUERY_CACHE_DIR"];
+  if (envOverride) return ensureDir(envOverride);
+  if (config?.dbPath) return ensureDir(resolve(projectRoot, config.dbPath));
+  const xdgCache = process.env["XDG_CACHE_HOME"];
+  const cacheBase = xdgCache || join4(homedir(), ".cache");
+  const projectHash = createHash("sha256").update(resolve(projectRoot)).digest("hex").slice(0, 12);
+  const dir = join4(cacheBase, "scip-query", "projects", projectHash);
+  return ensureDir(dir);
+}
+function resolveIndexPaths(projectRoot, config) {
+  const cacheDir = resolveCacheDir(projectRoot, config);
+  return {
+    cacheDir,
+    dbPath: join4(cacheDir, "index.db"),
+    indexPath: join4(cacheDir, "index.scip"),
+    metaPath: join4(cacheDir, "meta.json")
+  };
+}
+function initProjectConfig(projectRoot, languages) {
+  const configPath = join4(projectRoot, CONFIG_FILENAME);
+  if (existsSync4(configPath)) {
+    return configPath;
+  }
+  const config = {
+    languages,
+    watch: {
+      enabled: false,
+      debounceMs: 3e4,
+      cooldownMs: 6e4
+    }
+  };
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  return configPath;
+}
+function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// src/watch.ts
+import { watch } from "fs";
+import { existsSync as existsSync5, renameSync } from "fs";
+import { join as join5, relative } from "path";
+import { fork } from "child_process";
+import ignore2 from "ignore";
+var Watcher = class {
+  projectRoot;
+  watchConfig;
+  indexPaths;
+  languages;
+  pnpmWorkspaces;
+  onStatus;
+  onReindexComplete;
+  onError;
+  // State machine
+  status = { state: "idle" };
+  debounceTimer = null;
+  cooldownTimer = null;
+  dirty = false;
+  changedFiles = 0;
+  reindexInFlight = false;
+  lastReindexEnd = 0;
+  // fs.watch watchers (one per watched directory)
+  fsWatchers = [];
+  gitignoreFilter;
+  extraIgnore;
+  stopped = false;
+  constructor(opts) {
+    this.projectRoot = opts.projectRoot;
+    this.watchConfig = resolveWatchConfig(opts.config);
+    this.indexPaths = resolveIndexPaths(opts.projectRoot, opts.config);
+    this.languages = opts.languages;
+    this.pnpmWorkspaces = opts.config.indexer?.typescript?.pnpmWorkspaces ?? false;
+    this.onStatus = opts.onStatus ?? (() => {
+    });
+    this.onReindexComplete = opts.onReindexComplete ?? (() => {
+    });
+    this.onError = opts.onError ?? ((e) => console.error(e.message));
+    this.gitignoreFilter = createGitignoreFilter(opts.projectRoot);
+    this.extraIgnore = ignore2();
+    if (this.watchConfig.ignore.length > 0) {
+      this.extraIgnore.add(this.watchConfig.ignore);
+    }
+  }
+  /** Start watching for file changes */
+  start() {
+    this.stopped = false;
+    this.setStatus({ state: "idle" });
+    try {
+      const watcher = watch(
+        this.projectRoot,
+        { recursive: true },
+        (_event, filename) => {
+          if (filename && !this.stopped) {
+            this.handleFileChange(filename);
+          }
+        }
+      );
+      this.fsWatchers.push(watcher);
+    } catch {
+      this.onError(new Error(
+        "Failed to start file watcher. On Linux, you may need to increase inotify limits: sysctl -w fs.inotify.max_user_watches=524288"
+      ));
+    }
+  }
+  /** Stop watching and clean up */
+  stop() {
+    this.stopped = true;
+    for (const w of this.fsWatchers) w.close();
+    this.fsWatchers = [];
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    if (this.cooldownTimer) clearTimeout(this.cooldownTimer);
+    this.setStatus({ state: "idle" });
+  }
+  /** Get current watcher status */
+  getStatus() {
+    return this.status;
+  }
+  // ── Internal ─────────────────────────────────────────────
+  handleFileChange(filename) {
+    const rel = relative(this.projectRoot, join5(this.projectRoot, filename));
+    if (this.gitignoreFilter.isIgnored(rel)) return;
+    if (this.extraIgnore.ignores(rel)) return;
+    if (filename.endsWith("index.db") || filename.endsWith("index.scip") || filename.endsWith("index.db.tmp") || filename.endsWith(".scipquery.json")) {
+      return;
+    }
+    this.changedFiles++;
+    if (this.reindexInFlight) {
+      this.dirty = true;
+      this.setStatus({
+        state: "indexing",
+        startedAt: this.status.startedAt
+      });
+      return;
+    }
+    if (this.status.state === "cooldown") {
+      this.dirty = true;
+      this.setStatus({ state: "cooldown", until: this.status.until, dirty: true });
+      return;
+    }
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    const reindexAt = Date.now() + this.watchConfig.debounceMs;
+    this.setStatus({ state: "waiting", changedFiles: this.changedFiles, reindexAt });
+    this.debounceTimer = setTimeout(() => {
+      this.debounceTimer = null;
+      this.triggerReindex();
+    }, this.watchConfig.debounceMs);
+  }
+  triggerReindex() {
+    if (this.reindexInFlight || this.stopped) return;
+    const timeSinceLastReindex = Date.now() - this.lastReindexEnd;
+    if (this.lastReindexEnd > 0 && timeSinceLastReindex < this.watchConfig.cooldownMs) {
+      const remaining = this.watchConfig.cooldownMs - timeSinceLastReindex;
+      this.dirty = true;
+      const until = Date.now() + remaining;
+      this.setStatus({ state: "cooldown", until, dirty: true });
+      this.cooldownTimer = setTimeout(() => {
+        this.cooldownTimer = null;
+        if (this.dirty && !this.stopped) {
+          this.dirty = false;
+          this.triggerReindex();
+        }
+      }, remaining);
+      return;
+    }
+    this.reindexInFlight = true;
+    this.dirty = false;
+    this.changedFiles = 0;
+    const startedAt = Date.now();
+    this.setStatus({ state: "indexing", startedAt });
+    this.runReindex().then((durationMs) => {
+      this.reindexInFlight = false;
+      this.lastReindexEnd = Date.now();
+      this.onReindexComplete(durationMs);
+      if (this.dirty && !this.stopped) {
+        const until = Date.now() + this.watchConfig.cooldownMs;
+        this.setStatus({ state: "cooldown", until, dirty: true });
+        this.cooldownTimer = setTimeout(() => {
+          this.cooldownTimer = null;
+          if (this.dirty && !this.stopped) {
+            this.dirty = false;
+            this.triggerReindex();
+          } else {
+            this.setStatus({ state: "idle" });
+          }
+        }, this.watchConfig.cooldownMs);
+      } else {
+        this.setStatus({ state: "idle" });
+      }
+    }).catch((err) => {
+      this.reindexInFlight = false;
+      this.lastReindexEnd = Date.now();
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+      this.setStatus({ state: "idle" });
+    });
+  }
+  /**
+   * Run the reindex in a forked child process.
+   * Writes to index.db.tmp, then atomically renames to index.db.
+   */
+  runReindex() {
+    return new Promise((resolve3, reject) => {
+      const start = Date.now();
+      const tmpDb = this.indexPaths.dbPath + ".tmp";
+      const tmpScip = this.indexPaths.indexPath + ".tmp";
+      const child = fork(
+        new URL("./reindex-worker.js", import.meta.url).pathname,
+        [],
+        {
+          env: {
+            ...process.env,
+            SCIP_REINDEX_PROJECT_ROOT: this.projectRoot,
+            SCIP_REINDEX_OUTPUT_SCIP: tmpScip,
+            SCIP_REINDEX_OUTPUT_DB: tmpDb,
+            SCIP_REINDEX_LANGUAGES: this.languages?.join(",") ?? "",
+            SCIP_REINDEX_PNPM_WORKSPACES: this.pnpmWorkspaces ? "1" : ""
+          },
+          stdio: "pipe"
+        }
+      );
+      child.on("exit", (code2) => {
+        if (code2 === 0) {
+          try {
+            if (existsSync5(tmpDb)) {
+              renameSync(tmpDb, this.indexPaths.dbPath);
+            }
+            if (existsSync5(tmpScip)) {
+              renameSync(tmpScip, this.indexPaths.indexPath);
+            }
+            resolve3(Date.now() - start);
+          } catch (err) {
+            reject(new Error(`Atomic swap failed: ${err}`));
+          }
+        } else {
+          reject(new Error(`Reindex worker exited with code ${code2}`));
+        }
+      });
+      child.on("error", reject);
+    });
+  }
+  setStatus(status) {
+    this.status = status;
+    this.onStatus(status);
+  }
+};
+
+// src/setup.ts
+import {
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync2,
+  symlinkSync,
+  readlinkSync,
+  unlinkSync
+} from "fs";
+import { join as join6, dirname as dirname2, resolve as resolve2 } from "path";
+import { homedir as homedir2, platform as platform2, arch } from "os";
+import { execFileSync as execFileSync3 } from "child_process";
+import { fileURLToPath } from "url";
+var IS_WINDOWS2 = platform2() === "win32";
+var SKILLS = ["concrete-plan", "scip-explore", "scip-debloat", "scip-verify"];
+var SCIP_VERSION = "v0.7.0";
+function installSkills(opts = {}) {
+  const log = opts.quiet ? () => {
+  } : console.log;
+  const thisFile = fileURLToPath(import.meta.url);
+  const skillsSource = resolve2(dirname2(thisFile), "..", "skills");
+  const targets = [
+    join6(homedir2(), ".claude", "skills"),
+    join6(homedir2(), ".codex", "skills")
+  ];
+  const result = {
+    installed: [],
+    skipped: [],
+    alreadyLinked: []
+  };
+  for (const targetDir of targets) {
+    const parentDir = dirname2(targetDir);
+    if (!existsSync6(parentDir)) {
+      continue;
+    }
+    mkdirSync2(targetDir, { recursive: true });
+    const toolName = targetDir.includes(".codex") ? "Codex" : "Claude";
+    for (const skill of SKILLS) {
+      const source = join6(skillsSource, skill);
+      const target = join6(targetDir, skill);
+      if (!existsSync6(source)) {
+        result.skipped.push(`${toolName}/${skill}`);
+        continue;
+      }
+      if (existsSync6(target)) {
+        try {
+          const existing = readlinkSync(target);
+          if (resolve2(existing) === resolve2(source)) {
+            result.alreadyLinked.push(`${toolName}/${skill}`);
+            log(`  ok:   ${skill} \u2192 ${toolName} (already linked)`);
+            continue;
+          }
+        } catch {
+          result.skipped.push(`${toolName}/${skill}`);
+          log(`  skip: ${skill} \u2192 ${toolName} (exists, not a symlink)`);
+          continue;
+        }
+        unlinkSync(target);
+      }
+      symlinkSync(source, target, IS_WINDOWS2 ? "junction" : "dir");
+      result.installed.push(`${toolName}/${skill}`);
+      log(`  done: ${skill} \u2192 ${toolName}`);
+    }
+  }
+  return result;
+}
+function isScipInstalled() {
+  try {
+    const cmd = IS_WINDOWS2 ? "where" : "which";
+    execFileSync3(cmd, ["scip"], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getScipVersion() {
+  try {
+    const output = execFileSync3("scip", ["--version"], { stdio: "pipe" }).toString().trim();
+    return output;
+  } catch {
+    return null;
+  }
+}
+function getScipDownloadUrl() {
+  const os = platform2();
+  const cpu = arch();
+  let osName;
+  let archName;
+  let ext;
+  switch (os) {
+    case "darwin":
+      osName = "darwin";
+      ext = "tar.gz";
+      break;
+    case "linux":
+      osName = "linux";
+      ext = "tar.gz";
+      break;
+    case "win32":
+      osName = "windows";
+      ext = "zip";
+      break;
+    default:
+      return null;
+  }
+  switch (cpu) {
+    case "arm64":
+      archName = "arm64";
+      break;
+    case "x64":
+      archName = "amd64";
+      break;
+    default:
+      return null;
+  }
+  const filename = `scip-${osName}-${archName}.${ext}`;
+  const url = `https://github.com/sourcegraph/scip/releases/download/${SCIP_VERSION}/${filename}`;
+  return { url, filename };
+}
+function printScipInstallInstructions() {
+  const download = getScipDownloadUrl();
+  console.log("\nThe `scip` CLI is required but not found on PATH.\n");
+  if (platform2() === "darwin") {
+    console.log("Install via Homebrew:");
+    console.log("  brew install sourcegraph/scip/scip\n");
+    console.log("Or download manually:");
+  } else {
+    console.log("Download from:");
+  }
+  if (download) {
+    console.log(`  ${download.url}
+`);
+  } else {
+    console.log(`  https://github.com/sourcegraph/scip/releases/tag/${SCIP_VERSION}
+`);
+  }
+  console.log("After installing, ensure `scip` is on your PATH and run `scip-query reindex`.");
+}
+export {
+  INDEXER_CONFIGS,
+  ScipDatabase,
+  Watcher,
+  affected,
+  bottlenecks,
+  byKind,
+  callGraph,
+  changeSurface,
+  code,
+  complexity,
+  complexityHotspots,
+  convergence,
+  coupling,
+  createGitignoreFilter,
+  cycles,
+  dataflow,
+  dead,
+  deepChains,
+  deps,
+  detectLanguages,
+  diffImpact,
+  docCoverage,
+  drift,
+  extractCandidates,
+  fanIn,
+  fanOut,
+  files,
+  getIndexerConfig,
+  getScipVersion,
+  health,
+  hierarchy,
+  hotspots,
+  importedBy,
+  imports,
+  initProjectConfig,
+  installSkills,
+  isBinaryAvailable,
+  isIndexerInstalled,
+  isScipInstalled,
+  isolated,
+  kindCounts,
+  leafName,
+  loadProjectConfig,
+  members,
+  methods,
+  outline,
+  parseSymbol,
+  passthroughCandidates,
+  printScipInstallInstructions,
+  rdeps,
+  redundantReexports,
+  refs,
+  reindex,
+  resolveCacheDir,
+  resolveIndexPaths,
+  shortenSymbol,
+  similar,
+  similarAll,
+  similarChains,
+  similarFiles,
+  similarSignatures,
+  slice,
+  staleAbstractions,
+  stats,
+  surface,
+  symbols,
+  system,
+  testCoverage,
+  testCoverageSummary,
+  topCoupling,
+  topFanIn,
+  topFanOut,
+  trace,
+  tryInstallIndexer,
+  tryInstallScipCli,
+  unusedImports,
+  wrapperCandidates
+};
+//# sourceMappingURL=index.js.map