@ninjaxtools/slopdex 0.19.0 → 0.20.0

package/dist/cli.js

@@ -1,1130 +0,0 @@
-#!/usr/bin/env node
-import {
-  TerminalProgress,
-  clearProgress
-} from "./chunk-S225GYCL.js";
-import {
-  DEFAULT_PARALLELISM,
-  compileNameRegex
-} from "./chunk-VH5VGRCI.js";
-import {
-  CodeIndexError,
-  GitUnavailableError,
-  IncompatibleIndexError
-} from "./chunk-DKRB2XT5.js";
-
-// src/cli.ts
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { DatabaseSync } from "node:sqlite";
-import { parseArgs } from "node:util";
-
-// src/format.ts
-function functionName(value) {
-  return `${value.path} :: ${value.qualifiedName}`;
-}
-function formatSimilaritySummary(matches, source) {
-  const lines = matches.map((match) => `${source ? "  " : ""}${rankDetails(match)}  ${functionName(match.function)}${distanceDetails(match)}${scoreDetails(match)}`);
-  if (!source) return lines.length > 0 ? lines.join("\n") : "No matches.";
-  return [functionName(source), ...lines.length > 0 ? lines : ["  No matches."]].join("\n");
-}
-function rankDetails(match) {
-  return match.rerankScore === void 0 ? match.similarity.toFixed(4) : `${match.rerankScore.toFixed(4)} rerank (${match.similarity.toFixed(4)} similarity)`;
-}
-function distanceDetails(match) {
-  return "physicalDistance" in match && match.physicalDistance !== void 0 ? `  [distance ${match.physicalDistance}]` : "";
-}
-function formatSimilarityClusters(results, sameIndex, limit) {
-  const combined = results.some((result) => result.matches.some((match) => match.descriptionSimilarity !== void 0));
-  const nodes = /* @__PURE__ */ new Map();
-  const neighbors = /* @__PURE__ */ new Map();
-  const edges = [];
-  const connect = (left, right) => {
-    const leftNeighbors = neighbors.get(left) ?? /* @__PURE__ */ new Set();
-    const rightNeighbors = neighbors.get(right) ?? /* @__PURE__ */ new Set();
-    leftNeighbors.add(right);
-    rightNeighbors.add(left);
-    neighbors.set(left, leftNeighbors);
-    neighbors.set(right, rightNeighbors);
-  };
-  for (const result of results) {
-    const sourceKey = `${sameIndex ? "index" : "source"}:${result.source.id}`;
-    nodes.set(sourceKey, { function: result.source, role: "source" });
-    for (const match of result.matches) {
-      const matchKey = `${sameIndex ? "index" : "target"}:${match.function.id}`;
-      nodes.set(matchKey, { function: match.function, role: sameIndex ? "source" : "target" });
-      connect(sourceKey, matchKey);
-      edges.push({ left: sourceKey, right: matchKey, similarity: match.similarity });
-    }
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const clusters = [];
-  for (const start of neighbors.keys()) {
-    if (seen.has(start)) continue;
-    const pending = [start];
-    const keys = /* @__PURE__ */ new Set();
-    while (pending.length > 0) {
-      const key = pending.pop();
-      if (seen.has(key)) continue;
-      seen.add(key);
-      keys.add(key);
-      for (const neighbor of neighbors.get(key) ?? []) pending.push(neighbor);
-    }
-    const similarities = edges.filter((edge) => keys.has(edge.left) && keys.has(edge.right)).map((edge) => edge.similarity);
-    clusters.push({
-      members: [...keys].map((key) => nodes.get(key)).sort((left, right) => clusterFunctionName(left, sameIndex).localeCompare(clusterFunctionName(right, sameIndex))),
-      min: Math.min(...similarities),
-      max: Math.max(...similarities)
-    });
-  }
-  clusters.sort((left, right) => right.members.length - left.members.length || clusterFunctionName(left.members[0], sameIndex).localeCompare(clusterFunctionName(right.members[0], sameIndex)));
-  const limited = limit !== void 0 ? clusters.slice(0, limit) : clusters;
-  if (limited.length === 0) return "No clusters.";
-  return limited.map((cluster, index) => {
-    const similarity = cluster.min === cluster.max ? cluster.min.toFixed(4) : `${cluster.min.toFixed(4)}-${cluster.max.toFixed(4)}`;
-    return [
-      `Cluster ${index + 1} (${cluster.members.length} functions, similarity ${similarity}${combined ? ", combined code + callable description + file description" : ""})`,
-      ...cluster.members.map((member) => `  ${clusterFunctionName(member, sameIndex)}`)
-    ].join("\n");
-  }).join("\n\n");
-}
-function scoreDetails(scores) {
-  if (scores.descriptionSimilarity === void 0 || scores.fileDescriptionSimilarity === void 0) return "";
-  if (scores.codeSimilarity === void 0) {
-    return `  [combined 50/50; description ${scores.descriptionSimilarity.toFixed(4)}, file ${scores.fileDescriptionSimilarity.toFixed(4)}]`;
-  }
-  return `  [combined thirds; code ${scores.codeSimilarity.toFixed(4)}, description ${scores.descriptionSimilarity.toFixed(4)}, file ${scores.fileDescriptionSimilarity.toFixed(4)}]`;
-}
-function clusterFunctionName(member, sameIndex) {
-  const role = sameIndex ? "" : `[${member.role}] `;
-  return `${role}${member.function.path}:${member.function.startLine}:${member.function.startColumn} :: ${member.function.qualifiedName}`;
-}
-
-// src/cli.ts
-var DESCRIPTION_PROVIDER_NAMES = ["openai", "opencode", "opencode-go"];
-function isDescriptionProviderName(value) {
-  return DESCRIPTION_PROVIDER_NAMES.includes(value);
-}
-var parsed = (() => {
-  try {
-    return parseArgs({
-      args: process.argv.slice(2),
-      allowPositionals: true,
-      strict: true,
-      options: {
-        root: { type: "string", default: process.cwd() },
-        config: { type: "string" },
-        index: { type: "string" },
-        provider: { type: "string" },
-        model: { type: "string" },
-        "description-provider": { type: "string" },
-        "description-model": { type: "string" },
-        "reranker-candidates": { type: "string" },
-        dimensions: { type: "string" },
-        target: { type: "string" },
-        "target-root": { type: "string" },
-        "target-index": { type: "string" },
-        "target-config": { type: "string" },
-        "changed-since": { type: "string" },
-        uncommitted: { type: "boolean", default: false },
-        "source-path": { type: "string" },
-        "min-lines": { type: "string" },
-        regex: { type: "string" },
-        regexp: { type: "string", short: "e" },
-        limit: { type: "string" },
-        matches: { type: "string" },
-        threshold: { type: "string" },
-        format: { type: "string" },
-        cohesion: { type: "boolean", default: false },
-        "include-symmetric-duplicates": { type: "boolean", default: false },
-        "cross-file-only": { type: "boolean", default: false },
-        "rebuild-on-divergence": { type: "boolean", default: false },
-        "force-reindex": { type: "boolean", default: false },
-        "no-reindex": { type: "boolean", default: false },
-        callables: { type: "boolean", default: false },
-        "ignore-errors": { type: "boolean", default: false },
-        verbose: { type: "boolean", default: false },
-        version: { type: "boolean", default: false },
-        help: { type: "boolean", short: "h", default: false }
-      }
-    });
-  } catch (error) {
-    process.stderr.write(`slopdex: ${error instanceof Error ? error.message : String(error)}
-`);
-    process.exit(2);
-  }
-})();
-var [command, ...positionals] = parsed.positionals;
-var descriptionsAction = command === "descriptions" ? positionals[0] : void 0;
-if (parsed.values.version) {
-  const version = true ? "0.19.0" : JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
-  process.stdout.write(`${version}
-`);
-  process.exit(0);
-}
-if (parsed.values.help || !command) {
-  printHelp();
-  process.exit(parsed.values.help ? 0 : 1);
-}
-var diagnosticIndexes = /* @__PURE__ */ new Set();
-function readErrorCountsLight(indexPath) {
-  const database = new DatabaseSync(indexPath, { readOnly: true });
-  try {
-    if (!database.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'indexing_errors'").get()) {
-      return { errors: 0, files: 0 };
-    }
-    const counts = database.prepare("SELECT COUNT(*) AS errors, COUNT(DISTINCT path) AS files FROM indexing_errors").get();
-    return { errors: Number(counts.errors), files: Number(counts.files) };
-  } finally {
-    database.close();
-  }
-}
-process.on("exit", () => {
-  if (parsed.values["ignore-errors"]) return;
-  try {
-    const rootDir = path.resolve(parsed.values.root);
-    const config = loadConfig(rootDir, parsed.values.config);
-    diagnosticIndexes.add(path.resolve(parsed.values.index ?? config.indexPath ?? path.join(rootDir, ".slopdex/index.sqlite")));
-    if (parsed.values["target-index"]) diagnosticIndexes.add(path.resolve(parsed.values["target-index"]));
-  } catch {
-  }
-  for (const indexPath of diagnosticIndexes) {
-    try {
-      if (!existsSync(indexPath)) continue;
-      const { errors, files } = readErrorCountsLight(indexPath);
-      if (errors === 0) continue;
-      process.stderr.write(`slopdex: warning: ${errors} unresolved indexing error(s) in ${files} file(s); run slopdex index-errors --index ${JSON.stringify(indexPath)} to inspect, or use --ignore-errors to silence this warning.
-`);
-    } catch {
-    }
-  }
-});
-void main().catch((error) => {
-  clearProgress();
-  const message = error instanceof Error ? error.message : String(error);
-  process.stderr.write(`slopdex: ${message}
-`);
-  process.exitCode = error instanceof CodeIndexError ? 2 : 1;
-});
-async function main() {
-  validateInvocation();
-  const rootDir = path.resolve(parsed.values.root);
-  if (command === "models") {
-    await runModels();
-    return;
-  }
-  if (command === "config") {
-    await runConfig(rootDir);
-    return;
-  }
-  const config = loadConfig(rootDir, parsed.values.config);
-  if (command === "index-errors") {
-    const indexPath = path.resolve(parsed.values.index ?? config.indexPath ?? path.join(rootDir, ".slopdex/index.sqlite"));
-    const { readIndexErrors } = await import("./database-P5XWJWQL.js");
-    const errors = existsSync(indexPath) ? readIndexErrors(indexPath) : [];
-    if (outputFormat("summary") === "summary") {
-      process.stdout.write(errors.length === 0 ? "No indexing errors.\n" : `${errors.map(
-        (error) => `${error.path}${error.startLine === null ? "" : `:${error.startLine}:${error.startColumn}`} ${error.qualifiedName ? `:: ${error.qualifiedName} ` : ""}[${error.code}]
-  ${error.message}`
-      ).join("\n")}
-`);
-    } else printJson(errors);
-    return;
-  }
-  const provider = await createProvider(config);
-  const reranker = command === "search" || command === "search-description" ? await createReranker(config) : void 0;
-  const descriptionProvider = await createDescriptionProvider(config);
-  const progress = new TerminalProgress();
-  const indexOptions = {
-    rootDir,
-    provider,
-    parallelism: config.parallelism ?? DEFAULT_PARALLELISM,
-    onProgress: (value) => progress.update(value),
-    ...reranker ? { reranker } : {},
-    ...descriptionProvider ? { descriptionProvider } : {},
-    onWarning: () => {
-    },
-    // Persisted diagnostics are reported once per index at exit.
-    ...parsed.values.index || config.indexPath ? { indexPath: parsed.values.index ?? config.indexPath } : {},
-    ...config.include ? { include: config.include } : {},
-    ...config.exclude ? { exclude: config.exclude } : {},
-    ...config.maxFileSize ? { maxFileSize: config.maxFileSize } : {},
-    ...config.embeddingBatchSize ? { embeddingBatchSize: config.embeddingBatchSize } : {},
-    ...config.verbose ? { verbose: true } : {}
-  };
-  const updateTarget = command === "update-git" ? parsed.values.target ?? "HEAD" : "HEAD";
-  const updateStats = await ensureIndexUpdated(
-    indexOptions,
-    "index",
-    updateTarget,
-    parsed.values["rebuild-on-divergence"],
-    parsed.values["force-reindex"],
-    parsed.values["no-reindex"],
-    descriptionRefresh(config)
-  );
-  const { CodeIndex } = await import("./code-index-MWSJKV3G.js");
-  const index = new CodeIndex(indexOptions);
-  try {
-    switch (command) {
-      case "status":
-        printJson(index.status());
-        break;
-      case "update-files":
-        if (positionals.length === 0) throw new CodeIndexError("update-files requires at least one path.");
-        printJson(await index.updateFiles({ upsert: positionals }));
-        break;
-      case "delete-files":
-        if (positionals.length === 0) throw new CodeIndexError("delete-files requires at least one path.");
-        printJson(await index.updateFiles({ delete: positionals }));
-        break;
-      case "update-git": {
-        printJson(updateStats);
-        break;
-      }
-      case "reindex-files":
-        printJson(await index.reindexFiles({ includeCallables: parsed.values.callables }));
-        break;
-      case "descriptions":
-        printJson(descriptionsAction === "enable" ? await index.useDescriptions() : index.disableDescriptions());
-        break;
-      case "search":
-      case "search-description": {
-        const query = positionals.join(" ").trim();
-        if (!query) throw new CodeIndexError(`${command} requires a query.`);
-        const threshold = similarityThreshold();
-        const nameRegex = qualifiedNameRegex();
-        const results = await (command === "search-description" ? index.searchDescription.bind(index) : index.similaritySearch.bind(index))({
-          query,
-          ...nameRegex !== void 0 ? { nameRegex } : {},
-          ...parsed.values.limit === void 0 ? {} : { limit: positiveIntegerOption(parsed.values.limit, 1, "limit") },
-          minSimilarity: threshold.min,
-          ...threshold.max !== void 0 ? { maxSimilarity: threshold.max } : {}
-        });
-        const format = outputFormat("summary");
-        if (format === "clusters") throw new CodeIndexError("clusters format is only available for cross-search.");
-        if (format === "summary") {
-          process.stdout.write(`${command === "search-description" ? results.map((match) => `${formatSimilaritySummary([match])}
-  ${match.function.description}`).join("\n") : formatSimilaritySummary(results)}
-`);
-        } else printJson(results.map(presentMatch));
-        break;
-      }
-      case "cross-search":
-        await runCrossSearch(index, indexOptions, provider);
-        break;
-      default:
-        throw new CodeIndexError(`Unknown command: ${command}`);
-    }
-  } finally {
-    index.close();
-  }
-}
-async function runCrossSearch(source, sourceOptions, provider) {
-  const targetRoot = parsed.values["target-root"];
-  const targetPath = parsed.values["target-index"];
-  if (targetRoot && !targetPath || !targetRoot && targetPath) {
-    throw new CodeIndexError("Cross-index search requires both --target-root and --target-index.");
-  }
-  const targetRootDir = targetRoot ? path.resolve(targetRoot) : void 0;
-  const resolvedTargetPath = targetPath ? path.resolve(targetPath) : void 0;
-  const usesSourceAsTarget = targetRootDir === source.rootDir && resolvedTargetPath === source.indexPath;
-  const targetConfig = targetRootDir && !usesSourceAsTarget ? loadConfig(targetRootDir, parsed.values["target-config"]) : void 0;
-  const targetDescriptionProvider = targetConfig ? await createDescriptionProvider(targetConfig) : void 0;
-  const targetOptions = targetRootDir && resolvedTargetPath && !usesSourceAsTarget ? {
-    rootDir: targetRootDir,
-    indexPath: resolvedTargetPath,
-    provider,
-    ...sourceOptions.parallelism !== void 0 ? { parallelism: sourceOptions.parallelism } : {},
-    ...sourceOptions.onProgress ? { onProgress: sourceOptions.onProgress } : {},
-    ...sourceOptions.onWarning ? { onWarning: sourceOptions.onWarning } : {},
-    ...targetConfig?.include ? { include: targetConfig.include } : {},
-    ...targetConfig?.exclude ? { exclude: targetConfig.exclude } : {},
-    ...targetConfig?.maxFileSize ? { maxFileSize: targetConfig.maxFileSize } : {},
-    ...targetConfig?.embeddingBatchSize ? { embeddingBatchSize: targetConfig.embeddingBatchSize } : {},
-    ...targetConfig?.verbose ? { verbose: true } : {},
-    ...targetDescriptionProvider ? { descriptionProvider: targetDescriptionProvider } : {}
-  } : void 0;
-  if (targetOptions) {
-    await ensureIndexUpdated(
-      targetOptions,
-      "target index",
-      "HEAD",
-      parsed.values["rebuild-on-divergence"],
-      parsed.values["force-reindex"],
-      parsed.values["no-reindex"],
-      descriptionRefresh(targetConfig)
-    );
-  }
-  const { CodeIndex: CodeIndexClass } = await import("./code-index-MWSJKV3G.js");
-  const { crossSearch } = await import("./cross-search-ERBFC25T.js");
-  const target = targetOptions ? new CodeIndexClass({ ...targetOptions, readOnly: true }) : void 0;
-  const format = outputFormat(parsed.values.cohesion ? "summary" : "clusters");
-  const threshold = similarityThreshold();
-  const indexProgress = sourceOptions.onProgress;
-  const outputLimit = parsed.values.limit === void 0 ? void 0 : positiveIntegerOption(parsed.values.limit, 1, "limit");
-  const searchOptions = {
-    source,
-    ...target ? { target } : {},
-    sourceFilter: crossSearchSourceFilter(),
-    limitPerFunction: positiveIntegerOption(parsed.values.matches, 5, "matches"),
-    minSimilarity: threshold.min,
-    ...threshold.max !== void 0 ? { maxSimilarity: threshold.max } : {},
-    includeSymmetricDuplicates: parsed.values["include-symmetric-duplicates"],
-    crossFileOnly: parsed.values["cross-file-only"],
-    cohesion: parsed.values.cohesion,
-    minLines: minimumLines(),
-    // Per-source read progress (including read-repair scans) on the terminal bar.
-    ...indexProgress ? {
-      onProgress: (value) => indexProgress({ phase: "cross-search", ...value })
-    } : {}
-  };
-  try {
-    if (format === "clusters") {
-      const results = [];
-      for await (const result of crossSearch(searchOptions)) results.push(result);
-      process.stdout.write(`${formatSimilarityClusters(results, !target, outputLimit)}
-`);
-      return;
-    }
-    let emitted = 0;
-    for await (const result of crossSearch(searchOptions)) {
-      if (outputLimit !== void 0 && emitted >= outputLimit) break;
-      if (format === "summary") {
-        process.stdout.write(`${formatSimilaritySummary(result.matches, result.source)}
-`);
-      } else {
-        process.stdout.write(`${JSON.stringify({
-          source: presentFunction(result.source),
-          matches: result.matches.map(presentMatch),
-          scoring: result.scoring
-        })}
-`);
-      }
-      emitted += 1;
-    }
-  } finally {
-    target?.close();
-  }
-}
-async function ensureIndexUpdated(options, label, target, rebuildOnDivergence, forceRebuild, noReindex, hooks) {
-  diagnosticIndexes.add(resolveIndexPath(options));
-  const initialized = await initializeMissingIndex(options, label, target, noReindex, hooks);
-  if (initialized) return initialized;
-  const { CodeIndex } = await import("./code-index-MWSJKV3G.js");
-  try {
-    const index = new CodeIndex(options);
-    try {
-      await hooks?.beforeRefresh?.(index);
-      const stats = await refreshIndex(index, label, target, rebuildOnDivergence, noReindex);
-      await hooks?.afterRefresh?.(index);
-      return stats;
-    } finally {
-      index.close();
-    }
-  } catch (error) {
-    if (!forceRebuild || !(error instanceof IncompatibleIndexError)) throw error;
-    process.stderr.write(
-      `slopdex: warning: ${label} is incompatible (${error.message}); rebuilding automatically because --force-reindex was specified.
-`
-    );
-    const indexPath = resolveIndexPath(options);
-    const descriptionProfile = descriptionProfileForRebuild(indexPath, options.rootDir);
-    try {
-      const { resetIndexState } = await import("./database-P5XWJWQL.js");
-      resetIndexState(indexPath, options.rootDir, options.provider.profile);
-    } catch (resetError) {
-      if (!(resetError instanceof IncompatibleIndexError)) throw resetError;
-      removeIndexArtifacts(indexPath);
-    }
-    return initializeIndex(options, indexPath, label, target, noReindex, descriptionProfile, hooks);
-  }
-}
-async function initializeMissingIndex(options, label, target, noReindex, hooks) {
-  const indexPath = resolveIndexPath(options);
-  if (existsSync(indexPath)) return null;
-  process.stderr.write(
-    `slopdex: ${label} not found at ${indexPath}; initializing automatically from ${target}${noReindex ? "" : " and the working tree"}.
-`
-  );
-  return initializeIndex(options, indexPath, label, target, noReindex, null, hooks);
-}
-async function initializeIndex(options, indexPath, label, target, noReindex, descriptionProfile = null, hooks) {
-  const { CodeIndex } = await import("./code-index-MWSJKV3G.js");
-  const rebuiltDescriptionProvider = descriptionProfile && !options.descriptionProvider ? await createDescriptionProvider({
-    descriptionProvider: descriptionProfile.provider,
-    descriptionModel: descriptionProfile.model,
-    parallelism: options.parallelism ?? DEFAULT_PARALLELISM,
-    ...options.verbose ? { verbose: true } : {}
-  }) : void 0;
-  const index = new CodeIndex({
-    ...options,
-    indexPath,
-    ...rebuiltDescriptionProvider ? { descriptionProvider: rebuiltDescriptionProvider } : {}
-  });
-  try {
-    if (descriptionProfile) await index.useDescriptions();
-    await hooks?.beforeRefresh?.(index);
-    const stats = await refreshIndex(index, label, target, false, noReindex);
-    await hooks?.afterRefresh?.(index);
-    return stats;
-  } finally {
-    index.close();
-  }
-}
-function descriptionProfileForRebuild(indexPath, rootDir) {
-  const db = new DatabaseSync(indexPath, { readOnly: true });
-  try {
-    const metadata = new Map(db.prepare("SELECT key, value FROM metadata").all().map((row) => [row.key, row.value]));
-    if (metadata.get("root_dir") !== path.resolve(rootDir) || metadata.get("descriptions_enabled") !== "true") return null;
-    const profile = JSON.parse(metadata.get("description_profile"));
-    if (!isDescriptionProviderName(profile.provider)) {
-      throw new CodeIndexError("Rebuilding this description index requires its custom description provider through the library API.");
-    }
-    return profile;
-  } finally {
-    db.close();
-  }
-}
-async function refreshIndex(index, label, target, rebuildOnDivergence, noReindex) {
-  try {
-    return await index.updateFromGit({ target, rebuildOnDivergence, includeWorkingTree: !noReindex });
-  } catch (error) {
-    if (!(error instanceof GitUnavailableError)) throw error;
-    const status = index.status();
-    if (noReindex && status.fileCount > 0) {
-      process.stderr.write(
-        `slopdex: warning: no Git repository is available for ${label}; full working-tree re-index skipped because --no-reindex was specified.
-`
-      );
-      return {
-        filesUpdated: 0,
-        filesDeleted: 0,
-        functionsAdded: 0,
-        functionsUpdated: 0,
-        functionsDeleted: 0,
-        embeddingsCreated: 0,
-        checkpoint: status.gitCheckpoint
-      };
-    }
-    process.stderr.write(
-      `slopdex: warning: no Git repository is available for ${label}; re-indexing all source files from the working tree.
-`
-    );
-    return await index.updateFromWorkingTree();
-  }
-}
-function resolveIndexPath(options) {
-  return path.resolve(options.indexPath ?? path.join(path.resolve(options.rootDir), ".slopdex", "index.sqlite"));
-}
-function removeIndexArtifacts(indexPath) {
-  for (const suffix of ["", "-shm", "-wal", "-journal"]) rmSync(`${indexPath}${suffix}`, { force: true });
-}
-function loadConfig(rootDir, configuredPath) {
-  const configPath = path.resolve(configuredPath ?? path.join(rootDir, ".slopdex", "config.json"));
-  if (!existsSync(configPath)) return commandLineConfig({});
-  const value = JSON.parse(readFileSync(configPath, "utf8"));
-  return commandLineConfig(value);
-}
-function commandLineConfig(config) {
-  const dimensions = parsed.values.dimensions ? numberOption(parsed.values.dimensions, 0, "dimensions") : config.dimensions;
-  const providerValue = parsed.values.provider ?? config.provider;
-  if (providerValue !== void 0 && providerValue !== "openai" && providerValue !== "jina") {
-    throw new CodeIndexError(`Unsupported provider: ${providerValue}`);
-  }
-  const provider = providerValue === "openai" || providerValue === "jina" ? providerValue : void 0;
-  const descriptionProviderValue = parsed.values["description-provider"] ?? config.descriptionProvider;
-  if (descriptionProviderValue !== void 0 && !isDescriptionProviderName(descriptionProviderValue)) {
-    throw new CodeIndexError(`Unsupported description provider: ${descriptionProviderValue}`);
-  }
-  if (config.rerankingEnabled !== void 0 && typeof config.rerankingEnabled !== "boolean") {
-    throw new CodeIndexError("rerankingEnabled must be a boolean.");
-  }
-  if (config.parallelism !== void 0 && (!Number.isInteger(config.parallelism) || config.parallelism < 1)) {
-    throw new CodeIndexError("parallelism must be a positive integer.");
-  }
-  if (config.verbose !== void 0 && typeof config.verbose !== "boolean") {
-    throw new CodeIndexError("verbose must be a boolean.");
-  }
-  if (config.rerankingEnabled === true) {
-    if (config.rerankerProvider !== "cohere" && config.rerankerProvider !== "jina" && config.rerankerProvider !== "openai") {
-      throw new CodeIndexError(`Unsupported reranker provider: ${String(config.rerankerProvider)}`);
-    }
-    if (config.rerankerModel !== void 0 && (typeof config.rerankerModel !== "string" || !config.rerankerModel.trim())) {
-      throw new CodeIndexError("rerankerModel must be a non-empty string.");
-    }
-    if (config.rerankerProvider === "openai" && config.rerankerCandidates !== void 0 && (typeof config.rerankerCandidates !== "number" || !Number.isInteger(config.rerankerCandidates) || config.rerankerCandidates < 1)) {
-      throw new CodeIndexError("rerankerCandidates must be a positive integer.");
-    }
-    if (config.rerankerProvider === "openai" && typeof config.rerankerCandidates === "number" && config.rerankerCandidates > 100) {
-      throw new CodeIndexError("rerankerCandidates must not exceed 100.");
-    }
-  }
-  return {
-    ...config,
-    ...provider ? { provider } : {},
-    ...parsed.values.model ? { model: parsed.values.model } : {},
-    ...descriptionProviderValue ? { descriptionProvider: descriptionProviderValue } : {},
-    ...parsed.values["description-model"] ? { descriptionModel: parsed.values["description-model"] } : {},
-    ...dimensions ? { dimensions } : {},
-    ...parsed.values.verbose ? { verbose: true } : {}
-  };
-}
-async function createDescriptionProvider(config) {
-  if (!config.descriptionProvider && !config.descriptionModel) return void 0;
-  const { OpenAIDescriptionProvider } = await import("./openai-EC6THXKV.js");
-  return new OpenAIDescriptionProvider({
-    ...config.descriptionProvider ? { provider: config.descriptionProvider } : {},
-    ...config.descriptionModel ? { model: config.descriptionModel } : {},
-    parallelism: config.parallelism ?? DEFAULT_PARALLELISM,
-    ...config.verbose ? { verbose: true } : {}
-  });
-}
-function descriptionRefresh(config) {
-  if (command === "descriptions") {
-    return descriptionsAction === "disable" ? { beforeRefresh: (index) => {
-      index.disableDescriptions();
-    } } : enableDescriptionRefresh(false);
-  }
-  if (config.descriptionsEnabled === true) return enableDescriptionRefresh();
-  if (config.descriptionsEnabled === false) return { beforeRefresh: (index) => {
-    index.disableDescriptions();
-  } };
-  return void 0;
-}
-function enableDescriptionRefresh(afterRefresh = true) {
-  return {
-    ...afterRefresh ? { afterRefresh: async (index) => {
-      await index.useDescriptions();
-    } } : {}
-  };
-}
-async function runModels() {
-  const positionalProvider = positionals[0];
-  const optionProvider = parsed.values["description-provider"];
-  if (positionalProvider && optionProvider && positionalProvider !== optionProvider) {
-    throw new CodeIndexError("models provider and --description-provider must match when both are supplied.");
-  }
-  const requested = positionalProvider ?? optionProvider;
-  if (requested !== void 0 && !isOpenCodeDescriptionProvider(requested)) {
-    throw new CodeIndexError("models provider must be opencode or opencode-go.");
-  }
-  const providers = requested ? [requested] : ["opencode", "opencode-go"];
-  const models = (await Promise.all(providers.map(fetchPublishedModels))).flat();
-  const format = outputFormat("summary");
-  if (format === "clusters") throw new CodeIndexError("clusters format is only available for cross-search.");
-  if (format === "json") printJson(models);
-  else process.stdout.write(`${models.map(({ provider, model }) => `${provider}/${model}`).join("\n")}
-`);
-}
-async function runConfig(rootDir) {
-  const configPath = path.resolve(parsed.values.config ?? path.join(rootDir, ".slopdex", "config.json"));
-  const config = readConfigFile(configPath);
-  const action = positionals[0];
-  let result;
-  if (action === "descriptions") {
-    config.descriptionsEnabled = positionals[1] === "enable";
-    result = { descriptionsEnabled: config.descriptionsEnabled };
-  } else if (action === "model") {
-    const selected = await resolveConfiguredModel(positionals[1]);
-    config.descriptionProvider = selected.provider;
-    config.descriptionModel = selected.model;
-    result = { descriptionProvider: selected.provider, descriptionModel: selected.model };
-  } else if (action === "parallelism") {
-    const parallelism = Number(positionals[1]);
-    config.parallelism = parallelism;
-    result = { parallelism };
-  } else {
-    const provider = positionals[1];
-    if (provider === "disable") {
-      config.rerankingEnabled = false;
-      result = { rerankingEnabled: false };
-    } else {
-      const sameProvider = config.rerankerProvider === provider;
-      const defaultModel = provider === "cohere" ? "rerank-v4.0-pro" : provider === "jina" ? "jina-reranker-v3.5" : "gpt-5.6-luna";
-      const model = positionals[2] ?? (sameProvider && typeof config.rerankerModel === "string" && config.rerankerModel.trim() ? config.rerankerModel : defaultModel);
-      config.rerankerProvider = provider;
-      config.rerankerModel = model;
-      if (provider === "openai") {
-        const savedCandidates = sameProvider && typeof config.rerankerCandidates === "number" && Number.isInteger(config.rerankerCandidates) && config.rerankerCandidates > 0 ? config.rerankerCandidates : 10;
-        config.rerankerCandidates = openAIRerankerCandidateCount(
-          parsed.values["reranker-candidates"],
-          savedCandidates,
-          "reranker candidate count"
-        );
-      } else {
-        delete config.rerankerCandidates;
-      }
-      config.rerankingEnabled = true;
-      result = {
-        rerankingEnabled: true,
-        rerankerProvider: provider,
-        rerankerModel: model,
-        ...provider === "openai" ? { rerankerCandidates: config.rerankerCandidates } : {}
-      };
-    }
-  }
-  writeConfigFile(configPath, config);
-  const format = outputFormat("summary");
-  if (format === "clusters") throw new CodeIndexError("clusters format is only available for cross-search.");
-  if (format === "json") printJson({ configPath, ...result });
-  else process.stdout.write(`Updated ${configPath}: ${Object.entries(result).map(([key, value]) => `${key}=${value}`).join(" ")}
-`);
-}
-async function resolveConfiguredModel(positionalModel) {
-  const optionModel = parsed.values["description-model"];
-  if (positionalModel && optionModel && positionalModel !== optionModel) {
-    throw new CodeIndexError("config model argument and --description-model must match when both are supplied.");
-  }
-  let reference = positionalModel ?? optionModel;
-  if (!reference) throw new CodeIndexError("config model requires a model ID or provider/model reference.");
-  let provider = parsed.values["description-provider"];
-  const separator = reference.indexOf("/");
-  if (separator !== -1) {
-    const qualifiedProvider = reference.slice(0, separator);
-    reference = reference.slice(separator + 1);
-    if (provider && provider !== qualifiedProvider) {
-      throw new CodeIndexError("Model reference and --description-provider must select the same provider.");
-    }
-    provider = qualifiedProvider;
-  }
-  if (!reference) throw new CodeIndexError("config model requires a non-empty model ID.");
-  if (provider !== void 0) {
-    if (!isOpenCodeDescriptionProvider(provider)) {
-      throw new CodeIndexError("config model provider must be opencode or opencode-go.");
-    }
-    const models = await fetchPublishedModels(provider);
-    if (!models.some(({ model }) => model === reference)) {
-      throw new CodeIndexError(`Unknown ${provider} model: ${reference}`);
-    }
-    return { provider, model: reference };
-  }
-  const matches = (await Promise.all([
-    fetchPublishedModels("opencode"),
-    fetchPublishedModels("opencode-go")
-  ])).flat().filter(({ model }) => model === reference);
-  if (matches.length === 0) throw new CodeIndexError(`Unknown OpenCode model: ${reference}`);
-  if (matches.length > 1) {
-    throw new CodeIndexError(`Model ${reference} is available from multiple providers; use provider/model.`);
-  }
-  return matches[0];
-}
-async function fetchPublishedModels(provider) {
-  const { descriptionProviderBaseUrl } = await import("./openai-EC6THXKV.js");
-  const url = `${descriptionProviderBaseUrl(provider)}/models`;
-  let response;
-  try {
-    response = await fetch(url);
-  } catch (error) {
-    throw new CodeIndexError(`Could not fetch ${provider} models: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-  }
-  if (!response.ok) {
-    throw new CodeIndexError(`Could not fetch ${provider} models (${response.status}): ${(await response.text()).slice(0, 500)}`);
-  }
-  let body;
-  try {
-    body = await response.json();
-  } catch (error) {
-    throw new CodeIndexError(`${provider} returned a malformed model list.`, { cause: error });
-  }
-  if (!Array.isArray(body.data) || body.data.some((item) => typeof item.id !== "string" || item.id.length === 0)) {
-    throw new CodeIndexError(`${provider} returned a malformed model list.`);
-  }
-  return [...new Set(body.data.map((item) => item.id))].map((model) => ({ provider, model }));
-}
-function isOpenCodeDescriptionProvider(value) {
-  return value === "opencode" || value === "opencode-go";
-}
-function readConfigFile(configPath) {
-  if (!existsSync(configPath)) return {};
-  const value = JSON.parse(readFileSync(configPath, "utf8"));
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new CodeIndexError(`Config must contain a JSON object: ${configPath}`);
-  }
-  return value;
-}
-function writeConfigFile(configPath, config) {
-  mkdirSync(path.dirname(configPath), { recursive: true });
-  const temporaryPath = `${configPath}.tmp-${process.pid}`;
-  writeFileSync(temporaryPath, `${JSON.stringify(config, null, 2)}
-`);
-  renameSync(temporaryPath, configPath);
-}
-async function createProvider(config) {
-  if ((config.provider ?? "openai") === "jina") {
-    const { JinaEmbeddingProvider } = await import("./jina-43RL7C6M.js");
-    return new JinaEmbeddingProvider({
-      ...config.model ? { model: config.model } : {},
-      ...config.dimensions ? { dimensions: config.dimensions } : {},
-      parallelism: config.parallelism ?? DEFAULT_PARALLELISM,
-      ...config.verbose ? { verbose: true } : {}
-    });
-  }
-  const { OpenAIEmbeddingProvider } = await import("./openai-CYUPNBGB.js");
-  return new OpenAIEmbeddingProvider({
-    ...config.model ? { model: config.model } : {},
-    ...config.dimensions ? { dimensions: config.dimensions } : {},
-    parallelism: config.parallelism ?? DEFAULT_PARALLELISM,
-    ...config.verbose ? { verbose: true } : {}
-  });
-}
-async function createReranker(config) {
-  if (config.rerankingEnabled !== true) return void 0;
-  if (config.rerankerProvider === "cohere" || config.rerankerProvider === "jina") {
-    const { CohereReranker, JinaReranker } = await import("./hosted-GHIUHKOU.js");
-    if (config.rerankerProvider === "cohere") {
-      return new CohereReranker({
-        ...config.rerankerModel ? { model: config.rerankerModel } : {},
-        ...config.verbose ? { verbose: true } : {}
-      });
-    }
-    return new JinaReranker({
-      ...config.rerankerModel ? { model: config.rerankerModel } : {},
-      ...config.verbose ? { verbose: true } : {}
-    });
-  }
-  if (config.rerankerProvider === "openai") {
-    const { OpenAILLMReranker } = await import("./openai-TCRXM66O.js");
-    return new OpenAILLMReranker({
-      ...config.rerankerModel ? { model: config.rerankerModel } : {},
-      ...config.rerankerCandidates ? { candidateCount: config.rerankerCandidates } : {},
-      ...config.verbose ? { verbose: true } : {}
-    });
-  }
-  throw new CodeIndexError("rerankerProvider is required when rerankingEnabled is true.");
-}
-function numberOption(value, defaultValue, name) {
-  if (value === void 0) return defaultValue;
-  const parsedValue = Number(value);
-  if (!Number.isFinite(parsedValue)) throw new CodeIndexError(`${name} must be a number.`);
-  return parsedValue;
-}
-function validateInvocation() {
-  if (parsed.values["reranker-candidates"] !== void 0 && (command !== "config" || positionals[0] !== "reranker" || positionals[1] !== "openai")) {
-    throw new CodeIndexError("--reranker-candidates is only available with config reranker openai.");
-  }
-  if (parsed.values.cohesion && command !== "cross-search") {
-    throw new CodeIndexError("--cohesion is only available for cross-search.");
-  }
-  if (parsed.values.matches !== void 0 && command !== "cross-search") {
-    throw new CodeIndexError("--matches is only available for cross-search.");
-  }
-  const nameRegex = qualifiedNameRegex();
-  if (nameRegex !== void 0) {
-    if (!["search", "search-description", "cross-search"].includes(command)) {
-      throw new CodeIndexError("-e/--regexp/--regex is only available for search, search-description, and cross-search.");
-    }
-    compileNameRegex(nameRegex, parsed.values.regex !== void 0 ? "--regex value" : "-e/--regexp value");
-  }
-  switch (command) {
-    case "models":
-      if (positionals.length > 1) throw new CodeIndexError("models accepts at most one provider.");
-      if (outputFormat("summary") === "clusters") throw new CodeIndexError("clusters format is only available for cross-search.");
-      return;
-    case "config":
-      if (outputFormat("summary") === "clusters") throw new CodeIndexError("clusters format is only available for cross-search.");
-      if (positionals[0] === "descriptions") {
-        if (positionals.length !== 2 || positionals[1] !== "enable" && positionals[1] !== "disable") {
-          throw new CodeIndexError("config descriptions requires enable or disable.");
-        }
-        return;
-      }
-      if (positionals[0] === "model") {
-        if (positionals.length > 2 || !positionals[1] && !parsed.values["description-model"]) {
-          throw new CodeIndexError("config model requires a model ID or provider/model reference.");
-        }
-        return;
-      }
-      if (positionals[0] === "parallelism") {
-        const value = Number(positionals[1]);
-        if (positionals.length !== 2 || !Number.isInteger(value) || value < 1) {
-          throw new CodeIndexError("config parallelism requires a positive integer.");
-        }
-        return;
-      }
-      if (positionals[0] === "reranker") {
-        const provider = positionals[1];
-        if (provider !== "cohere" && provider !== "jina" && provider !== "openai" && provider !== "disable" || positionals.length > (provider === "disable" ? 2 : 3) || positionals[2] !== void 0 && !positionals[2].trim()) {
-          throw new CodeIndexError("config reranker requires cohere, jina, openai, or disable, optionally followed by a model ID.");
-        }
-        if (provider === "openai") openAIRerankerCandidateCount(parsed.values["reranker-candidates"], 10, "reranker candidate count");
-        return;
-      }
-      throw new CodeIndexError("config requires descriptions, model, parallelism, or reranker.");
-    case "index-errors":
-      if (outputFormat("summary") === "clusters") throw new CodeIndexError("clusters format is only available for cross-search.");
-      return;
-    case "status":
-    case "update-git":
-      return;
-    case "reindex-files":
-      if (positionals.length > 0) throw new CodeIndexError("reindex-files does not accept positional arguments.");
-      return;
-    case "descriptions":
-      if (positionals.length !== 1 || descriptionsAction !== "enable" && descriptionsAction !== "disable") {
-        throw new CodeIndexError("descriptions requires enable or disable.");
-      }
-      return;
-    case "update-files":
-      if (positionals.length === 0) throw new CodeIndexError("update-files requires at least one path.");
-      return;
-    case "delete-files":
-      if (positionals.length === 0) throw new CodeIndexError("delete-files requires at least one path.");
-      return;
-    case "search":
-    case "search-description": {
-      if (!positionals.join(" ").trim()) throw new CodeIndexError(`${command} requires a query.`);
-      validateOutputLimit();
-      similarityThreshold();
-      if (outputFormat("summary") === "clusters") throw new CodeIndexError("clusters format is only available for cross-search.");
-      return;
-    }
-    case "cross-search":
-      if (Boolean(parsed.values["target-root"]) !== Boolean(parsed.values["target-index"])) {
-        throw new CodeIndexError("Cross-index search requires both --target-root and --target-index.");
-      }
-      if (parsed.values["target-config"] && !parsed.values["target-root"]) {
-        throw new CodeIndexError("--target-config requires --target-root and --target-index.");
-      }
-      validateMatches(5);
-      validateOutputLimit();
-      similarityThreshold();
-      if (parsed.values.cohesion && outputFormat("summary") === "clusters") {
-        throw new CodeIndexError("clusters format does not preserve cohesion match order; use summary or json.");
-      }
-      outputFormat(parsed.values.cohesion ? "summary" : "clusters");
-      minimumLines();
-      crossSearchSourceFilter();
-      return;
-    default:
-      throw new CodeIndexError(`Unknown command: ${command}`);
-  }
-}
-function validateMatches(defaultValue) {
-  positiveIntegerOption(parsed.values.matches, defaultValue, "matches");
-}
-function validateOutputLimit() {
-  if (parsed.values.limit !== void 0) positiveIntegerOption(parsed.values.limit, 1, "limit");
-}
-function positiveIntegerOption(value, defaultValue, name) {
-  const parsedValue = numberOption(value, defaultValue, name);
-  if (!Number.isInteger(parsedValue) || parsedValue < 1) throw new CodeIndexError(`${name} must be a positive integer.`);
-  return parsedValue;
-}
-function openAIRerankerCandidateCount(value, defaultValue, name) {
-  const count = positiveIntegerOption(value, defaultValue, name);
-  if (count > 100) throw new CodeIndexError(`${name} must not exceed 100.`);
-  return count;
-}
-function similarityThreshold(defaultMin = 0.3) {
-  const threshold = parsed.values.threshold;
-  if (threshold === void 0) return { min: defaultMin };
-  const number = "[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?";
-  const range = new RegExp(`^\\s*(${number})\\s*-\\s*(${number})\\s*$`, "i").exec(threshold);
-  if (!range) return { min: numberOption(threshold, defaultMin, "threshold") };
-  const min = Number(range[1]);
-  const max = Number(range[2]);
-  if (!Number.isFinite(min) || !Number.isFinite(max)) throw new CodeIndexError("threshold range bounds must be numbers.");
-  if (min >= max) throw new CodeIndexError("threshold range minimum must be less than its maximum.");
-  return { min, max };
-}
-function outputFormat(defaultValue) {
-  const value = parsed.values.format ?? defaultValue;
-  if (value !== "json" && value !== "summary" && value !== "clusters") {
-    throw new CodeIndexError("format must be json, summary, or clusters.");
-  }
-  return value;
-}
-function minimumLines() {
-  const value = numberOption(parsed.values["min-lines"], 2, "min-lines");
-  if (!Number.isInteger(value) || value < 1) throw new CodeIndexError("min-lines must be a positive integer.");
-  return value;
-}
-function qualifiedNameRegex() {
-  if (parsed.values.regexp !== void 0 && parsed.values.regex !== void 0 && parsed.values.regexp !== parsed.values.regex) {
-    throw new CodeIndexError("-e/--regexp and --regex are aliases and cannot use different values.");
-  }
-  return parsed.values.regexp ?? parsed.values.regex;
-}
-function crossSearchSourceFilter() {
-  const changedSince = parsed.values["changed-since"];
-  const uncommitted = parsed.values.uncommitted;
-  const nameRegex = qualifiedNameRegex();
-  const restrictions = {
-    ...parsed.values["source-path"] ? { path: parsed.values["source-path"] } : {},
-    ...nameRegex !== void 0 ? { nameRegex } : {}
-  };
-  if (changedSince) return { type: "changed-since", commit: changedSince, ...uncommitted ? { uncommitted: true } : {}, ...restrictions };
-  if (uncommitted) return { type: "uncommitted", ...restrictions };
-  return { type: "all", ...restrictions };
-}
-function presentFunction(value) {
-  const { embeddingInput: _embeddingInput, embeddingId: _embeddingId, descriptionEmbeddingId: _descriptionEmbeddingId, ...result } = value;
-  return result;
-}
-function presentMatch(value) {
-  const { function: callable, ...scores } = value;
-  return { ...scores, function: presentFunction(callable) };
-}
-function printJson(value) {
-  process.stdout.write(`${JSON.stringify(value, null, 2)}
-`);
-}
-function printHelp() {
-  process.stdout.write(`Usage: slopdex <command> [arguments] [options]
-
-Commands:
-  models [opencode|opencode-go]        List current published OpenCode models
-  config model <model|provider/model>  Validate and save an OpenCode description model
-  config descriptions <enable|disable> Save description state without opening an index
-  config parallelism <count>           Save the concurrent provider request limit (default: 10)
-  config reranker <provider|disable>    Save Cohere, Jina, or OpenAI reranking settings
-  status                              Show index metadata
-  index-errors                        List persisted file and function indexing failures
-  update-files <path...>              Index specific working-tree files
-  reindex-files                       Regenerate stale file descriptions
-  delete-files <path...>              Remove specific files from the index
-  update-git                          Index a Git snapshot plus working-tree changes
-  search <query>                      Search functions by semantic similarity
-  descriptions <enable|disable>       Enable or disable automatic purpose descriptions
-  search-description <query>          Search functions using description embeddings
-  cross-search                        Find nearest functions for each source function
-
-Examples:
-  Search code:
-    slopdex search "validate an authenticated session"
-
-    slopdex search "keep the repository index synchronized"
-    0.4284  tests/languages.test.ts :: refresh
-    0.4200  src/cli.ts :: refreshIndex
-    0.4113  src/code-index.ts :: CodeIndex.updateFromGit
-    ...
-
-  Enable descriptions, then search by their meaning:
-    slopdex descriptions enable
-    slopdex search-description "keep the repository index synchronized"
-
-    slopdex models opencode-go
-    slopdex config model opencode-go/gpt-5.6-luna
-
-  Find duplicate code:
-    Compare functions across files, exclude short wrappers, and group matches into clusters:
-      slopdex cross-search --cross-file-only --min-lines 4 --threshold 0.9
-
-      Cluster 1 (3 functions, similarity 0.9124-0.9568)
-        src/auth/session.ts:18:1 :: validateSession
-        src/http/middleware.ts:42:1 :: authenticate
-        src/users/user-service.ts:27:3 :: UserService.authenticate
-
-      This found three substantial authentication functions in separate files with very
-      high similarity. Review them for repeated validation or session logic that could be shared.
-      Middleware and service locations may be intentional architectural layers, so this is
-      evidence to inspect rather than proof they should merge. Connected components may use
-      transitive links, so every function need not directly match every other function.
-
-    Using --cross-file-only is useful to exclude similar code in the same file.
-
-    Review adjacent bands with threshold ranges:
-      slopdex cross-search --cross-file-only --min-lines 4 --threshold 0.9
-      slopdex cross-search --cross-file-only --min-lines 4 --threshold 0.85-0.9
-
-  Restrict functions used in cross-search:
-    Only use uncommitted working-tree functions as sources:
-      slopdex cross-search --uncommitted --cross-file-only --min-lines 4 --threshold 0.9
-
-    Only use functions changed since origin/main as sources:
-      slopdex cross-search --changed-since origin/main --threshold 0.9
-
-    Only use matching symbols under src/services as sources:
-      slopdex cross-search --source-path src/services -e '^UserService\\.' --threshold 0.9
-
-  Find related code stored far apart:
-    --cohesion orders matches from farthest to nearest, which can highlight similar code
-    that could be made more cohesive through an abstraction:
-      slopdex cross-search --cross-file-only --cohesion --threshold 0.8
-
-      src/auth/session.ts :: validateSession
-        0.9400  packages/http/middleware.ts :: authenticate  [distance 4]
-        0.9300  src/auth/token.ts :: validateToken  [distance 1]
-
-      --cohesion keeps cross-search's semantic matches but orders each source's matches
-      from greatest to least path distance. Similarity breaks distance ties. This highlights
-      related functions stored far apart without introducing a separate analysis command.
-
-  Use with agents:
-    slopdex search "..." --threshold 0.5
-    slopdex cross-search --uncommitted --threshold 0.8
-
-  Reranking (second-stage reranker for search and search-description):
-    slopdex config reranker cohere
-    slopdex config reranker jina
-    slopdex config reranker openai
-
-  Compare repositories:
-    slopdex cross-search --target-root /path/to/other/repo --target-index /path/to/other/repo/.slopdex/index.sqlite --threshold 0.9
-
-  Inspect index health:
-    slopdex status
-    slopdex index-errors --format summary
-    slopdex --version
-
-Options:
-  --version                           Show the package version
-  --root <path>                       Repository root (default: current directory)
-  --config <path>                     Config file (default: .slopdex/config.json)
-  --index <path>                      SQLite index path
-  --provider <openai|jina>            Embedding provider
-  --model <name>                      Embedding model
-  --description-provider <name>       Description provider: openai, opencode, or opencode-go
-  --description-model <name>          Description model (provider default: gpt-5.6-luna or muse-spark-1.3-contributor)
-  --reranker-candidates <number>       Candidates sent to the OpenAI LLM reranker (default: 10)
-  --dimensions <number>               Embedding dimensions
-  --target <ref>                      Target ref for update-git (default: HEAD)
-  --rebuild-on-divergence             Rebuild after a rebase or branch change
-  --force-reindex                     Rebuild an incompatible existing index
-  --no-reindex                        Skip worktree overlays or reuse a non-Git index
-  --callables                         With reindex-files, also regenerate callable descriptions
-  --ignore-errors                     Silence warnings about persisted indexing errors
-  --verbose                           Log every external model call instead of one per kind/model
-  --limit <number>                    Output limit (default: unlimited; threshold filters results)
-  --matches <number>                  Cross-search matches per source function (default: 5)
-  --threshold <number|range>          Show similarities at/above a value or within a range (default: 0.3)
-  --format <json|summary|clusters>    Output format (default: summary; cross-search: clusters)
-  --cohesion                          Re-rank cross-search matches by physical distance
-  --include-symmetric-duplicates      Show both directions of same-index matches
-  --cross-file-only                   Exclude matches from the source file
-  --min-lines <number>               Minimum callable length for cross-search (default: 2)
-  -e, --regexp <regex>               Filter qualified symbols (analysis: sources only)
-  --regex <regex>                    Alias for -e/--regexp
-  --changed-since <commit>            Search added, modified, or moved functions
-  --uncommitted                       Search functions from uncommitted files
-  --source-path <path>                Restrict cross-search sources to a file or directory
-  --target-root <path>                Root of a second indexed codebase
-  --target-index <path>               SQLite path of a second index
-  --target-config <path>              Config file for a second indexed codebase
-
-Other Examples:
-  Save description state and parallelism without opening an index:
-    slopdex config descriptions enable
-    slopdex config parallelism 10
-
-  Index specific working-tree files:
-    slopdex update-files src/service.ts src/model.ts
-
-  Regenerate stale file descriptions, optionally continuing through callable descriptions:
-    slopdex reindex-files
-    slopdex reindex-files --callables
-
-  Remove deleted files from the index:
-    slopdex delete-files src/removed.ts
-
-  Index HEAD and overlay uncommitted working-tree changes:
-    slopdex update-git --target HEAD
-
-  Combine source restrictions (all must match):
-    slopdex cross-search -e 'validate' --source-path src --changed-since origin/main --uncommitted
-
-  Filter semantic search results by qualified symbol before applying the limit:
-    slopdex search "validate session" -e '^Session\\.' --limit 10
-`);
-}
-//# sourceMappingURL=cli.js.map