scip-query 0.3.5 → 0.4.0

package/dist/index.js

@@ -1,55 +1,55 @@
 import "./chunk-FVH3Y44U.js";
 import {
   surface
-} from "./chunk-EOROMIFO.js";
+} from "./chunk-MA3B3IUT.js";
 import {
   symbols
-} from "./chunk-CPVAQJEC.js";
+} from "./chunk-D4I3ZMN5.js";
 import {
   system
-} from "./chunk-O7Q7FDUJ.js";
+} from "./chunk-A4GWYETB.js";
 import {
   trace
-} from "./chunk-GEXE2T6I.js";
+} from "./chunk-EOHPASDV.js";
 import {
   redundantReexports
-} from "./chunk-P3E6L7KW.js";
+} from "./chunk-P42KQKJZ.js";
 import {
   refs
-} from "./chunk-MPGIHELS.js";
+} from "./chunk-7YBLWIXY.js";
 import {
   similarChains
-} from "./chunk-WGAD3GNR.js";
+} from "./chunk-WNPF2I25.js";
 import {
   similarFiles
-} from "./chunk-HLUS2HEB.js";
+} from "./chunk-VUBLUTMU.js";
 import {
   similarSignatures
-} from "./chunk-TOIEB3LG.js";
+} from "./chunk-NWCJWA36.js";
 import {
   slice
-} from "./chunk-CHDJXYBG.js";
+} from "./chunk-A5BGEBM7.js";
 import {
   hotspots
-} from "./chunk-KBOQX573.js";
+} from "./chunk-RIEA5DOB.js";
 import {
   importedBy,
   imports,
   unusedImports
-} from "./chunk-26DOJ63W.js";
+} from "./chunk-N2LH3M2P.js";
 import {
   members
-} from "./chunk-NFS5W3PP.js";
+} from "./chunk-CQUNEJYM.js";
 import {
   methods
-} from "./chunk-GU2H5QRN.js";
+} from "./chunk-GIBETK3W.js";
 import {
   outline
-} from "./chunk-5OMVSV6E.js";
+} from "./chunk-LOVDB4C6.js";
 import {
   deps,
   rdeps
-} from "./chunk-VT4JBH6L.js";
+} from "./chunk-KDCQJTYW.js";
 import {
   diffImpact
 } from "./chunk-7HK5ZLOE.js";
@@ -58,88 +58,88 @@ import {
   fanOut,
   topFanIn,
   topFanOut
-} from "./chunk-VMM4SYV4.js";
+} from "./chunk-HNURMDF4.js";
 import {
   files
 } from "./chunk-MGNMHKX3.js";
 import {
   health
-} from "./chunk-6FKIA6EI.js";
+} from "./chunk-2F2WH5WQ.js";
 import {
   stats
 } from "./chunk-74RFWB5T.js";
 import {
   wrapperCandidates
-} from "./chunk-4JCSOF2O.js";
+} from "./chunk-AS7N27JK.js";
 import {
   similar,
   similarAll
-} from "./chunk-OIDHN6GD.js";
+} from "./chunk-I2JM34UV.js";
 import {
   staleAbstractions
-} from "./chunk-YGGFLMTM.js";
+} from "./chunk-5RKYZSQ6.js";
 import {
   isolated
-} from "./chunk-UQEQ6AHX.js";
+} from "./chunk-VISMEWYP.js";
 import {
   passthroughCandidates
-} from "./chunk-ZEUCXQBN.js";
+} from "./chunk-5AJJGPZE.js";
 import {
   drift
-} from "./chunk-7KIMF5PV.js";
+} from "./chunk-HRDPUTIQ.js";
 import {
   extractCandidates
-} from "./chunk-EPWLXXBL.js";
+} from "./chunk-IV6NZ426.js";
 import {
   hierarchy
-} from "./chunk-YDBXNPYU.js";
+} from "./chunk-PGHN5UTM.js";
 import {
   complexityHotspots
-} from "./chunk-VIYSWZCO.js";
+} from "./chunk-SL674KAW.js";
 import {
   complexity
-} from "./chunk-UGQKAVCD.js";
+} from "./chunk-QCYR4S6T.js";
 import {
   convergence
-} from "./chunk-TRESG7OB.js";
+} from "./chunk-VCOJRQPP.js";
 import {
   coupling,
   topCoupling
-} from "./chunk-KKCHYLVI.js";
+} from "./chunk-A7YY7IDA.js";
 import {
   cycles
-} from "./chunk-LFJQVJYJ.js";
+} from "./chunk-VU7FDTWV.js";
 import {
   dataflow
-} from "./chunk-GSH2FPKV.js";
+} from "./chunk-XH56HXLC.js";
 import {
   dead
-} from "./chunk-LQJUPXQY.js";
-import "./chunk-YY4QGUQ5.js";
+} from "./chunk-SRELHCMG.js";
+import "./chunk-X3J4VPWM.js";
 import {
   deepChains
-} from "./chunk-DH7G3DDV.js";
+} from "./chunk-ZU2AQQB5.js";
 import {
   affected
-} from "./chunk-VJJKSGIX.js";
+} from "./chunk-UTRKBUCB.js";
 import {
   bottlenecks
-} from "./chunk-F7XU27LU.js";
+} from "./chunk-CQRYLK33.js";
 import {
   byKind,
   kindCounts
-} from "./chunk-EN2Z2CLO.js";
+} from "./chunk-4ZT7UGWW.js";
 import {
   callGraph
-} from "./chunk-C7H5WBTJ.js";
+} from "./chunk-2UISVZGQ.js";
 import {
   changeSurface
-} from "./chunk-SMDCNPMK.js";
+} from "./chunk-H3FPW5YN.js";
 import "./chunk-4TYLS5XX.js";
 import {
   code
-} from "./chunk-J3JSOSUO.js";
-import "./chunk-AXQKUYKF.js";
+} from "./chunk-E7J7Q7UW.js";
+import "./chunk-QGCEAVJD.js";
 import {
   leafName,
   parseSymbol,
@@ -181,12 +181,23 @@ var ScipDatabase = class {
    * 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()}
+    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()}
+      )
+      OR EXISTS (
+        SELECT 1
+        FROM mentions local_m
+        JOIN chunks local_c ON local_m.chunk_id = local_c.id
+        JOIN documents local_d ON local_c.document_id = local_d.id
+        WHERE local_m.symbol_id = gs.id
+          AND local_m.role = 1
+          ${this.pathExclusionsFor("local_d").trimStart()}
+      )
     )`;
   }
   /**
@@ -344,8 +355,8 @@ Thumbs.db
 
 // src/reindex/index.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync5, renameSync } from "fs";
+import { join as join5 } from "path";
 
 // src/scip-cli.ts
 import { execFileSync as execFileSync2 } from "child_process";
@@ -353,7 +364,9 @@ import { platform as platform2, arch } from "os";
 
 // src/reindex/install.ts
 import { execFileSync } from "child_process";
+import { existsSync as existsSync2 } from "fs";
 import { platform } from "os";
+import { join as join2 } from "path";
 var IS_WINDOWS = platform() === "win32";
 function isBinaryAvailable(name) {
   const cmd = IS_WINDOWS ? "where" : "which";
@@ -382,6 +395,31 @@ function resolveIndexerBinary(config) {
 function isIndexerInstalled(config) {
   return resolveIndexerBinary(config) !== null;
 }
+function resolveProjectLocalIndexerBinary(config, projectRoot) {
+  for (const relativePath of config.projectLocalBinaries ?? []) {
+    const candidate = join2(projectRoot, relativePath);
+    if (existsSync2(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function getIndexerExecutionEnv(config, baseEnv = process.env, binary = config.indexerBinary) {
+  if (config.indexerBinary !== "scip-dotnet") {
+    return baseEnv;
+  }
+  if (canRunDotnetIndexer(binary, baseEnv)) {
+    return baseEnv;
+  }
+  const dotnetRoot = resolveWorkingDotnetRoot(binary, baseEnv);
+  if (!dotnetRoot) {
+    return baseEnv;
+  }
+  return {
+    ...baseEnv,
+    DOTNET_ROOT: dotnetRoot
+  };
+}
 function tryInstallIndexer(config, onStatus) {
   const methods2 = config.installMethods;
   const binaryLabel = describeIndexerBinary(config);
@@ -421,6 +459,46 @@ function tryInstallIndexer(config, onStatus) {
   }
   return false;
 }
+function resolveWorkingDotnetRoot(binary, env) {
+  for (const dotnetRoot of getDotnetRootCandidates(env)) {
+    if (canRunDotnetIndexer(binary, { ...env, DOTNET_ROOT: dotnetRoot })) {
+      return dotnetRoot;
+    }
+  }
+  return null;
+}
+function getDotnetRootCandidates(env) {
+  const candidates = [];
+  const configured = env["DOTNET_ROOT"];
+  if (configured && existsSync2(configured)) {
+    candidates.push(configured);
+  }
+  if (platform() === "darwin" && isBinaryAvailable("brew")) {
+    try {
+      const prefix = execFileSync("brew", ["--prefix", "dotnet@9"], {
+        stdio: "pipe",
+        env
+      }).toString().trim();
+      const candidate = join2(prefix, "libexec");
+      if (existsSync2(candidate) && !candidates.includes(candidate)) {
+        candidates.push(candidate);
+      }
+    } catch {
+    }
+  }
+  return candidates;
+}
+function canRunDotnetIndexer(binary, env) {
+  try {
+    execFileSync(binary, ["--version"], {
+      stdio: "pipe",
+      env
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 // src/scip-cli.ts
 var IS_WINDOWS2 = platform2() === "win32";
@@ -538,46 +616,151 @@ function tryInstallScipCli(onStatus) {
 }
 
 // src/reindex/detect.ts
-import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync3, readdirSync } from "fs";
+import { extname, join as join3 } from "path";
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  ".idea",
+  ".vscode",
+  "node_modules",
+  "vendor",
+  "dist",
+  "build",
+  "target",
+  "bin",
+  "obj",
+  ".dart_tool",
+  ".gradle",
+  ".next",
+  ".venv",
+  "venv",
+  "__pycache__"
+]);
 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
+  { language: "typescript", files: ["tsconfig.json", "tsconfig.base.json"], extensions: [".ts", ".tsx", ".mts", ".cts"] },
+  { language: "rust", files: ["Cargo.toml"], extensions: [".rs"] },
+  { language: "go", files: ["go.mod"], extensions: [".go"] },
+  { language: "java", files: ["pom.xml", "build.gradle", "build.gradle.kts"], extensions: [".java"] },
+  { language: "kotlin", files: ["build.gradle.kts"], extensions: [".kt", ".kts"] },
+  { language: "scala", files: ["build.sbt"], extensions: [".scala"] },
+  { language: "python", files: ["pyproject.toml", "setup.py", "setup.cfg", "Pipfile"], extensions: [".py", ".pyi"] },
+  { language: "ruby", files: ["Gemfile"], extensions: [".rb"] },
+  { language: "cpp", files: ["compile_commands.json", "CMakeLists.txt", "Makefile"], extensions: [".cc", ".cpp", ".cxx", ".hpp", ".hh", ".hxx"] },
+  { language: "c", files: ["compile_commands.json", "CMakeLists.txt", "Makefile"], extensions: [".c", ".h"] },
+  { language: "csharp", globs: ["*.csproj", "*.sln"], extensions: [".cs"] },
+  { language: "vb", globs: ["*.vbproj"], extensions: [".vb"] },
+  { language: "dart", files: ["pubspec.yaml"], extensions: [".dart"] },
+  { language: "php", files: ["composer.json"], extensions: [".php"] },
+  { language: "javascript", files: ["package.json"], extensions: [".js", ".jsx", ".mjs", ".cjs"] }
+  // Last — very common
 ];
 function detectLanguages(projectRoot) {
   const detected = [];
+  const rootEntries = safeReadDir(projectRoot);
+  const extensionSet = collectExtensions(projectRoot);
   for (const marker of LANGUAGE_MARKERS) {
-    for (const file of marker.files) {
-      if (file.includes("*")) {
-        continue;
+    if (hasMarkerFile(projectRoot, marker.files)) {
+      detected.push(marker.language);
+      continue;
+    }
+    if (matchesRootGlob(rootEntries, marker.globs)) {
+      detected.push(marker.language);
+      continue;
+    }
+    if (hasExtension(extensionSet, marker.extensions)) {
+      detected.push(marker.language);
+    }
+  }
+  if (detected.includes("typescript")) {
+    removeLanguage(detected, "javascript");
+  }
+  if (detected.includes("cpp") && !extensionSet.has(".c")) {
+    removeLanguage(detected, "c");
+  }
+  return detected;
+}
+function safeReadDir(projectRoot) {
+  try {
+    return readdirSync(projectRoot);
+  } catch {
+    return [];
+  }
+}
+function hasMarkerFile(projectRoot, files2) {
+  if (!files2?.length) {
+    return false;
+  }
+  return files2.some((file) => existsSync3(join3(projectRoot, file)));
+}
+function matchesRootGlob(entries, globs) {
+  if (!globs?.length) {
+    return false;
+  }
+  return entries.some((entry) => globs.some((glob) => matchesSimpleGlob(entry, glob)));
+}
+function matchesSimpleGlob(entry, pattern) {
+  if (pattern === "*") {
+    return true;
+  }
+  if (!pattern.includes("*")) {
+    return entry === pattern;
+  }
+  const [prefix, suffix] = pattern.split("*");
+  return entry.startsWith(prefix ?? "") && entry.endsWith(suffix ?? "");
+}
+function collectExtensions(projectRoot) {
+  const found = /* @__PURE__ */ new Set();
+  const stack = [projectRoot];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) {
+      continue;
+    }
+    let entries;
+    try {
+      entries = readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && !entry.name.endsWith("proj") && !entry.name.endsWith("sln")) {
+        if (entry.isDirectory()) {
+          continue;
+        }
       }
-      if (existsSync2(join2(projectRoot, file))) {
-        if (!detected.includes(marker.language)) {
-          detected.push(marker.language);
+      const fullPath = join3(current, entry.name);
+      if (entry.isDirectory()) {
+        if (!IGNORED_DIRS.has(entry.name)) {
+          stack.push(fullPath);
         }
-        break;
+        continue;
+      }
+      const extension = extname(entry.name).toLowerCase();
+      if (extension) {
+        found.add(extension);
       }
     }
   }
-  if (detected.includes("typescript")) {
-    const jsIdx = detected.indexOf("javascript");
-    if (jsIdx !== -1) detected.splice(jsIdx, 1);
+  return found;
+}
+function hasExtension(extensionSet, extensions) {
+  if (!extensions?.length) {
+    return false;
+  }
+  return extensions.some((extension) => extensionSet.has(extension));
+}
+function removeLanguage(detected, language) {
+  const index = detected.indexOf(language);
+  if (index !== -1) {
+    detected.splice(index, 1);
   }
-  return detected;
 }
 
 // src/reindex/indexers.ts
+import { existsSync as existsSync4, readdirSync as readdirSync2 } from "fs";
+import { join as join4 } from "path";
 var INDEXER_CONFIGS = {
   typescript: {
     language: "typescript",
@@ -617,9 +800,7 @@ var INDEXER_CONFIGS = {
       args: ["index", "--output", outputPath]
     }),
     markerFiles: ["pom.xml", "build.gradle"],
-    installMethods: [
-      { label: "coursier", prerequisite: "cs", binary: "cs", args: ["install", "scip-java"] }
-    ],
+    installMethods: [],
     installUrl: "https://github.com/sourcegraph/scip-java/releases"
   },
   scala: {
@@ -631,9 +812,7 @@ var INDEXER_CONFIGS = {
       args: ["index", "--output", outputPath]
     }),
     markerFiles: ["build.sbt"],
-    installMethods: [
-      { label: "coursier", prerequisite: "cs", binary: "cs", args: ["install", "scip-java"] }
-    ],
+    installMethods: [],
     installUrl: "https://github.com/sourcegraph/scip-java/releases"
   },
   kotlin: {
@@ -645,9 +824,7 @@ var INDEXER_CONFIGS = {
       args: ["index", "--output", outputPath]
     }),
     markerFiles: ["build.gradle.kts"],
-    installMethods: [
-      { label: "coursier", prerequisite: "cs", binary: "cs", args: ["install", "scip-java"] }
-    ],
+    installMethods: [],
     installUrl: "https://github.com/sourcegraph/scip-java/releases"
   },
   rust: {
@@ -683,10 +860,11 @@ var INDEXER_CONFIGS = {
     language: "ruby",
     indexerBinary: "scip-ruby",
     checkCommand: "scip-ruby --version",
-    indexArgs: ({ outputPath }) => ({
-      binary: "scip-ruby",
-      args: ["--output", outputPath]
+    indexArgs: ({ indexerBinary }) => ({
+      binary: indexerBinary,
+      args: ["--dir", "."]
     }),
+    defaultOutputPath: "index.scip",
     markerFiles: ["Gemfile"],
     installMethods: [],
     installUrl: "https://github.com/sourcegraph/scip-ruby/releases"
@@ -711,7 +889,7 @@ var INDEXER_CONFIGS = {
     checkCommand: "scip-clang --version",
     indexArgs: ({ outputPath }) => ({
       binary: "scip-clang",
-      args: ["--output", outputPath]
+      args: ["--compdb-path", "compile_commands.json", "--index-output-path", outputPath]
     }),
     markerFiles: ["CMakeLists.txt", "Makefile"],
     installMethods: [],
@@ -723,7 +901,7 @@ var INDEXER_CONFIGS = {
     checkCommand: "scip-clang --version",
     indexArgs: ({ outputPath }) => ({
       binary: "scip-clang",
-      args: ["--output", outputPath]
+      args: ["--compdb-path", "compile_commands.json", "--index-output-path", outputPath]
     }),
     markerFiles: ["CMakeLists.txt", "Makefile"],
     installMethods: [],
@@ -733,11 +911,25 @@ var INDEXER_CONFIGS = {
     language: "csharp",
     indexerBinary: "scip-dotnet",
     checkCommand: "scip-dotnet --version",
-    indexArgs: ({ outputPath }) => ({
+    indexArgs: ({ projectRoot, outputPath }) => ({
       binary: "scip-dotnet",
-      args: ["index", "--output", outputPath]
+      args: ["index", resolveDotnetProject(projectRoot, [".sln", ".csproj"]) ?? projectRoot, "--output", outputPath, "--working-directory", projectRoot]
     }),
-    markerFiles: [],
+    markerFiles: ["*.csproj", "*.sln"],
+    installMethods: [
+      { label: "dotnet", prerequisite: "dotnet", binary: "dotnet", args: ["tool", "install", "--global", "scip-dotnet"] }
+    ],
+    installUrl: "https://github.com/sourcegraph/scip-dotnet/releases"
+  },
+  vb: {
+    language: "vb",
+    indexerBinary: "scip-dotnet",
+    checkCommand: "scip-dotnet --version",
+    indexArgs: ({ projectRoot, outputPath }) => ({
+      binary: "scip-dotnet",
+      args: ["index", resolveDotnetProject(projectRoot, [".sln", ".vbproj"]) ?? projectRoot, "--output", outputPath, "--working-directory", projectRoot]
+    }),
+    markerFiles: ["*.vbproj", "*.sln"],
     installMethods: [
       { label: "dotnet", prerequisite: "dotnet", binary: "dotnet", args: ["tool", "install", "--global", "scip-dotnet"] }
     ],
@@ -747,9 +939,9 @@ var INDEXER_CONFIGS = {
     language: "dart",
     indexerBinary: "scip-dart",
     checkCommand: "scip-dart --version",
-    indexArgs: ({ outputPath }) => ({
-      binary: "scip-dart",
-      args: ["index", "--output", outputPath]
+    indexArgs: ({ indexerBinary, outputPath }) => ({
+      binary: indexerBinary,
+      args: ["--output", outputPath]
     }),
     markerFiles: ["pubspec.yaml"],
     installMethods: [
@@ -760,21 +952,44 @@ var INDEXER_CONFIGS = {
   php: {
     language: "php",
     indexerBinary: "scip-php",
+    projectLocalBinaries: ["vendor/davidrjenni/scip-php/bin/scip-php", "vendor/bin/scip-php"],
     checkCommand: "scip-php --version",
-    indexArgs: ({ outputPath }) => ({
-      binary: "scip-php",
-      args: ["index", "--output", outputPath]
-    }),
+    indexArgs: ({ projectRoot, indexerBinary }) => {
+      const localBinary = join4(projectRoot, "vendor", "bin", "scip-php");
+      const nestedLocalBinary = join4(projectRoot, "vendor", "davidrjenni", "scip-php", "bin", "scip-php");
+      const targetBinary = existsSync4(nestedLocalBinary) ? nestedLocalBinary : existsSync4(localBinary) ? localBinary : indexerBinary;
+      return {
+        binary: "php",
+        args: [
+          "-d",
+          "error_reporting=E_ALL & ~E_DEPRECATED & ~E_USER_DEPRECATED",
+          targetBinary
+        ]
+      };
+    },
+    defaultOutputPath: "index.scip",
     markerFiles: ["composer.json"],
-    installMethods: [
-      { label: "composer", prerequisite: "composer", binary: "composer", args: ["global", "require", "davidrjenni/scip-php"] }
-    ],
+    installMethods: [],
     installUrl: "https://github.com/davidrjenni/scip-php/releases"
   }
 };
 function getIndexerConfig(language) {
   return INDEXER_CONFIGS[language];
 }
+function resolveDotnetProject(projectRoot, suffixes) {
+  let entries;
+  try {
+    entries = readdirSync2(projectRoot);
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    if (suffixes.some((suffix) => entry.endsWith(suffix))) {
+      return join4(projectRoot, entry);
+    }
+  }
+  return null;
+}
 
 // src/reindex/index.ts
 async function reindex(opts) {
@@ -784,8 +999,8 @@ async function reindex(opts) {
     onStatus = console.log,
     skipAutoInstall = false
   } = opts;
-  const outputScip = opts.outputScip ?? join3(projectRoot, "index.scip");
-  const outputDb = opts.outputDb ?? join3(projectRoot, "index.db");
+  const outputScip = opts.outputScip ?? join5(projectRoot, "index.scip");
+  const outputDb = opts.outputDb ?? join5(projectRoot, "index.db");
   const start = Date.now();
   const languages = opts.languages ?? detectLanguages(projectRoot);
   if (languages.length === 0) {
@@ -814,7 +1029,8 @@ async function reindex(opts) {
   for (const lang of languages) {
     const config = getIndexerConfig(lang);
     const binaryLabel = describeIndexerBinary(config);
-    if (!isIndexerInstalled(config)) {
+    const projectLocalBinary = resolveProjectLocalIndexerBinary(config, projectRoot);
+    if (!projectLocalBinary && !isIndexerInstalled(config)) {
       if (skipAutoInstall) {
         throw new Error(
           `${binaryLabel} is required to index ${lang} but not found on PATH.
@@ -829,7 +1045,7 @@ async function reindex(opts) {
         );
       }
     }
-    const resolvedBinary = resolveIndexerBinary(config);
+    const resolvedBinary = projectLocalBinary ?? resolveIndexerBinary(config);
     if (!resolvedBinary) {
       throw new Error(
         `${binaryLabel} is required to index ${lang} but was not found on PATH after installation checks.
@@ -837,6 +1053,7 @@ async function reindex(opts) {
       );
     }
     onStatus(`Indexing ${lang} with ${resolvedBinary}...`);
+    const indexerEnv = getIndexerExecutionEnv(config, env, resolvedBinary);
     const { binary, args } = config.indexArgs({
       projectRoot,
       outputPath: outputScip,
@@ -846,7 +1063,7 @@ async function reindex(opts) {
     try {
       execFileSync3(binary, args, {
         cwd: projectRoot,
-        env,
+        env: indexerEnv,
         stdio: "pipe",
         maxBuffer: 50 * 1024 * 1024
       });
@@ -857,9 +1074,10 @@ async function reindex(opts) {
 Make sure ${binaryLabel} is installed and available on PATH.`
       );
     }
+    moveDefaultOutputIfNeeded(config, projectRoot, outputScip);
   }
   onStatus("Converting to SQLite...");
-  if (!existsSync3(outputScip)) {
+  if (!existsSync5(outputScip)) {
     throw new Error(`SCIP index not found at ${outputScip} after indexing`);
   }
   try {
@@ -876,10 +1094,19 @@ Make sure ${binaryLabel} is installed and available on PATH.`
   onStatus(`Done in ${(durationMs / 1e3).toFixed(1)}s`);
   return { languages, indexPath: outputScip, dbPath: outputDb, durationMs };
 }
+function moveDefaultOutputIfNeeded(config, projectRoot, outputScip) {
+  if (!config.defaultOutputPath) {
+    return;
+  }
+  const defaultOutputPath = join5(projectRoot, config.defaultOutputPath);
+  if (outputScip !== defaultOutputPath && existsSync5(defaultOutputPath)) {
+    renameSync(defaultOutputPath, outputScip);
+  }
+}
 
 // src/config.ts
-import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync4, mkdirSync } from "fs";
-import { join as join4, resolve } from "path";
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync6, mkdirSync } from "fs";
+import { join as join6, resolve } from "path";
 import { createHash } from "crypto";
 import { homedir } from "os";
 var CONFIG_FILENAME = ".scipquery.json";
@@ -890,8 +1117,8 @@ var DEFAULT_WATCH = {
   ignore: []
 };
 function loadProjectConfig(projectRoot) {
-  const configPath = join4(projectRoot, CONFIG_FILENAME);
-  if (!existsSync4(configPath)) {
+  const configPath = join6(projectRoot, CONFIG_FILENAME);
+  if (!existsSync6(configPath)) {
     return {};
   }
   try {
@@ -912,23 +1139,23 @@ function resolveCacheDir(projectRoot, config) {
   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 cacheBase = xdgCache || join6(homedir(), ".cache");
   const projectHash = createHash("sha256").update(resolve(projectRoot)).digest("hex").slice(0, 12);
-  const dir = join4(cacheBase, "scip-query", "projects", projectHash);
+  const dir = join6(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")
+    dbPath: join6(cacheDir, "index.db"),
+    indexPath: join6(cacheDir, "index.scip"),
+    metaPath: join6(cacheDir, "meta.json")
   };
 }
 function initProjectConfig(projectRoot, languages) {
-  const configPath = join4(projectRoot, CONFIG_FILENAME);
-  if (existsSync4(configPath)) {
+  const configPath = join6(projectRoot, CONFIG_FILENAME);
+  if (existsSync6(configPath)) {
     return configPath;
   }
   const config = {
@@ -949,8 +1176,8 @@ function ensureDir(dir) {
 
 // src/watch.ts
 import { watch } from "fs";
-import { existsSync as existsSync5, renameSync } from "fs";
-import { join as join5, relative } from "path";
+import { existsSync as existsSync7, renameSync as renameSync2 } from "fs";
+import { join as join7, relative } from "path";
 import { fork } from "child_process";
 import ignore2 from "ignore";
 var Watcher = class {
@@ -1028,7 +1255,7 @@ var Watcher = class {
   }
   // ── Internal ─────────────────────────────────────────────
   handleFileChange(filename) {
-    const rel = relative(this.projectRoot, join5(this.projectRoot, filename));
+    const rel = relative(this.projectRoot, join7(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")) {
@@ -1131,11 +1358,11 @@ var Watcher = class {
       child.on("exit", (code2) => {
         if (code2 === 0) {
           try {
-            if (existsSync5(tmpDb)) {
-              renameSync(tmpDb, this.indexPaths.dbPath);
+            if (existsSync7(tmpDb)) {
+              renameSync2(tmpDb, this.indexPaths.dbPath);
             }
-            if (existsSync5(tmpScip)) {
-              renameSync(tmpScip, this.indexPaths.indexPath);
+            if (existsSync7(tmpScip)) {
+              renameSync2(tmpScip, this.indexPaths.indexPath);
             }
             resolve3(Date.now() - start);
           } catch (err) {
@@ -1159,25 +1386,31 @@ function tempScipPath(indexPath) {
 
 // src/setup.ts
 import {
-  existsSync as existsSync6,
+  existsSync as existsSync8,
   mkdirSync as mkdirSync2,
   symlinkSync,
   readlinkSync,
   unlinkSync
 } from "fs";
-import { join as join6, dirname as dirname2, resolve as resolve2 } from "path";
+import { join as join8, dirname as dirname2, resolve as resolve2 } from "path";
 import { homedir as homedir2, platform as platform3 } from "os";
 import { fileURLToPath } from "url";
 var IS_WINDOWS3 = platform3() === "win32";
-var SKILLS = ["concrete-plan", "scip-explore", "scip-debloat", "scip-verify"];
+var BUILTIN_SKILLS = [
+  "concrete-plan",
+  "scip-explore",
+  "scip-debloat",
+  "scip-verify",
+  "scip-language-playbook"
+];
 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")
+    join8(homedir2(), ".claude", "skills"),
+    join8(homedir2(), ".codex", "skills")
   ];
   const result = {
     installed: [],
@@ -1186,19 +1419,19 @@ function installSkills(opts = {}) {
   };
   for (const targetDir of targets) {
     const parentDir = dirname2(targetDir);
-    if (!existsSync6(parentDir)) {
+    if (!existsSync8(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)) {
+    for (const skill of BUILTIN_SKILLS) {
+      const source = join8(skillsSource, skill);
+      const target = join8(targetDir, skill);
+      if (!existsSync8(source)) {
         result.skipped.push(`${toolName}/${skill}`);
         continue;
       }
-      if (existsSync6(target)) {
+      if (existsSync8(target)) {
         try {
           const existing = readlinkSync(target);
           if (resolve2(existing) === resolve2(source)) {