codebaseiq 0.1.0

package/dist/reindex.d.ts

@@ -0,0 +1,254 @@
+import { S as SupportedLanguage, I as IndexerConfig, T as TypeScriptProjectMode } from './config-types-BNoC96J3.js';
+import { R as RefreshTrigger, L as LastRefreshMetadata } from './scip-cli-B7N3haxa.js';
+export { t as tryInstallScipCli } from './scip-cli-B7N3haxa.js';
+import { Index } from '@c4312/scip';
+
+interface ReindexWriteTelemetry {
+    reflinkedBytes: number;
+    fallbackCopiedBytes: number;
+}
+
+/**
+ * Detect which languages are present in a project directory by checking for
+ * marker files, root-level project files, and source-file extensions.
+ */
+declare function detectLanguages(projectRoot: string): SupportedLanguage[];
+
+type PostIndexAugmentationFact = 'auxiliary-document' | 'synthetic-symbol' | 'source-mapped-occurrence' | 'definition-mention' | 'replacement-chunk' | 'fingerprint-cache' | 'runtime-boundary-observation' | 'runtime-boundary-link';
+interface PostIndexAugmentationContext {
+    projectRoot: string;
+    dbPath: string;
+    onStatus?: (message: string) => void;
+}
+interface PostIndexAugmentationStage<Result> {
+    id: string;
+    facts: readonly PostIndexAugmentationFact[];
+    run(context: PostIndexAugmentationContext): Result;
+}
+declare function runPostIndexAugmentation<Result>(stage: PostIndexAugmentationStage<Result>, context: PostIndexAugmentationContext): {
+    stageId: string;
+    facts: readonly PostIndexAugmentationFact[];
+    durationMs: number;
+    result: Result;
+};
+
+interface AugmentAuxiliaryDocumentsOptions {
+    projectRoot: string;
+    dbPath: string;
+    extensions?: readonly string[];
+    onStatus?: (message: string) => void;
+}
+interface AugmentAuxiliaryDocumentsResult {
+    scanned: number;
+    inserted: number;
+    existing: number;
+}
+declare function auxiliaryDocumentsAugmentationStage(opts?: {
+    extensions?: readonly string[];
+}): PostIndexAugmentationStage<AugmentAuxiliaryDocumentsResult>;
+/**
+ * Add source files that upstream SCIP indexers skipped to the SQLite
+ * documents table. Vue SFCs are the motivating case: scip-typescript can
+ * resolve imports to generated TS, but it does not emit `.vue` documents.
+ */
+declare function augmentAuxiliaryDocuments(opts: AugmentAuxiliaryDocumentsOptions): AugmentAuxiliaryDocumentsResult;
+
+interface AugmentVueResolvedResult {
+    vueFiles: number;
+    resolvedReferences: number;
+    resolvedReferenceSamples: VueResolvedReferenceSample[];
+    insertedMentions: number;
+    /** Backwards-compatible count of unresolved source identifier tokens. */
+    skippedReferences: number;
+    skippedReferenceReasons: VueSkippedReferenceCounts;
+    skippedReferenceSamples: VueSkippedReferenceSample[];
+    syntheticSymbols: number;
+}
+type VueSkippedReferenceReason = 'missing-source-file' | 'missing-service-script' | 'no-definition' | 'same-file-definition' | 'unindexed-definition';
+type VueSkippedReferenceCounts = Record<VueSkippedReferenceReason, number>;
+interface VueSkippedReferenceSample {
+    sourceFile: string;
+    sourceLine: number;
+    sourceStartChar: number;
+    sourceEndChar: number;
+    token: string;
+    reason: VueSkippedReferenceReason;
+}
+interface ResolvedOccurrence {
+    sourceFile: string;
+    sourceLine: number;
+    sourceStartChar: number;
+    sourceEndChar: number;
+    sourceToken: string;
+    definitionFile: string;
+    symbolId: number;
+}
+interface VueResolvedReferenceSample extends Omit<ResolvedOccurrence, 'symbolId'> {
+    definitionSymbol: string;
+}
+
+interface AugmentVueResolvedOptions {
+    projectRoot: string;
+    dbPath: string;
+    tsconfig: string;
+    onStatus?: (message: string) => void;
+}
+declare function vueResolvedReferencesAugmentationStage(opts: {
+    tsconfig: string;
+}): PostIndexAugmentationStage<AugmentVueResolvedResult>;
+declare function augmentVueResolvedReferences(opts: AugmentVueResolvedOptions): AugmentVueResolvedResult;
+/**
+ * Async Vue augmentation enables the opt-in worker policy while preserving the
+ * synchronous public entry point's existing return type and reliable
+ * single-context execution.
+ */
+declare function augmentVueResolvedReferencesAsync(opts: AugmentVueResolvedOptions): Promise<AugmentVueResolvedResult>;
+
+/**
+ * Indexer configurations for each supported language.
+ * Each entry describes how to produce a SCIP index for that language.
+ *
+ * The `scip` CLI binary is required for all languages (to convert protobuf -> SQLite).
+ * Each language also needs its own SCIP indexer installed.
+ */
+declare const INDEXER_CONFIGS: Record<SupportedLanguage, IndexerConfig>;
+/** Get the indexer config for a language */
+declare function getIndexerConfig(language: SupportedLanguage): IndexerConfig;
+
+interface MergeScipResult {
+    documentCount: number;
+    externalSymbolCount: number;
+    inputCount: number;
+}
+/**
+ * Merge multiple SCIP indices into a single index message.
+ *
+ * A SCIP index is a code graph snapshot: metadata about one indexed project plus
+ * the documents and external symbols discovered by one or more indexers. Merging
+ * means producing one unified snapshot so later conversion to SQLite sees the
+ * whole repo instead of whichever language indexed last.
+ */
+declare function mergeScipIndexes(indexes: readonly Index[]): Index;
+declare function mergeScipFiles(inputPaths: readonly string[], outputPath: string): MergeScipResult;
+
+type IndexerToolchain = Pick<IndexerConfig, 'language' | 'indexerBinary' | 'binaryAliases' | 'projectLocalBinaries' | 'bundledNpmPackage' | 'installUrl'>;
+/**
+ * Describe the accepted executable names for an indexer.
+ */
+declare function describeIndexerBinary(toolchain: IndexerToolchain): string;
+/**
+ * Resolve the first available executable name for an indexer.
+ *
+ * Falls back to the indexer's bundled npm package bin when it is installed
+ * alongside codebaseiq. Returning the concrete bin path keeps indexing stable
+ * even when the target project is not itself an npm project.
+ */
+declare function resolveIndexerBinary(toolchain: IndexerToolchain): string | null;
+/**
+ * Check if an indexer's binary is available on PATH.
+ */
+declare function isIndexerInstalled(toolchain: IndexerToolchain): boolean;
+/**
+ * Resolve a project-local indexer binary when the project vendors its own executable.
+ */
+declare function resolveProjectLocalIndexerBinary(toolchain: IndexerToolchain, projectRoot: string): string | null;
+/**
+ * Build the environment needed to execute a language indexer.
+ * Currently only .NET indexers need special handling because `scip-dotnet`
+ * still targets the .NET 9 runtime.
+ */
+declare function getIndexerExecutionEnv(toolchain: IndexerToolchain, baseEnv?: NodeJS.ProcessEnv, binary?: string): NodeJS.ProcessEnv;
+
+declare function isBinaryAvailable(name: string): boolean;
+
+/**
+ * Attempt to auto-install an indexer using its configured install methods.
+ * Tries each method in order, checking prerequisites first.
+ * Returns true if installation succeeded.
+ */
+declare function tryInstallIndexer(config: IndexerConfig, onStatus: (msg: string) => void): boolean;
+
+interface ReindexOptions {
+    projectRoot: string;
+    /** Override language detection — index only these languages */
+    languages?: SupportedLanguage[];
+    /** Path for the SCIP protobuf output (default: <projectRoot>/index.scip) */
+    outputScip?: string;
+    /** Path for the SQLite output (default: <projectRoot>/index.db) */
+    outputDb?: string;
+    /** Max Node.js heap size in MB (default: 8192) */
+    maxHeapMb?: number;
+    /** Callback for status updates */
+    onStatus?: (message: string) => void;
+    /** Extra flags for pnpm-workspace-aware TS indexing */
+    pnpmWorkspaces?: boolean;
+    /** TypeScript indexing strategy (default: single inferred project). */
+    typescriptProjectMode?: TypeScriptProjectMode;
+    /** Explicit TypeScript project roots or tsconfig paths for workspace mode. */
+    typescriptProjects?: string[];
+    /** Optional scip-clojure config path, relative to project root unless absolute. */
+    clojureConfigPath?: string;
+    /** Skip auto-install prompts */
+    skipAutoInstall?: boolean;
+    /** Explicitly permit installing missing global tools for this operation. */
+    installMissing?: boolean;
+    /** Permit repository-local indexers after an explicit trust decision. */
+    trustProjectTools?: boolean;
+    /** Reuse an existing index when tracked source inputs are unchanged (default true). */
+    skipIfUnchanged?: boolean;
+    /** Permit a partial index when some detected/requested languages fail (default false). */
+    allowPartial?: boolean;
+    /** Number of language indexers to run at once (default: conservative auto). */
+    indexerConcurrency?: number;
+    /** Source that requested this refresh, persisted for status and setup diagnostics. */
+    trigger?: RefreshTrigger;
+    /** Cancel this reindex and every bounded child process. */
+    signal?: AbortSignal;
+}
+interface ReindexShardDiagnostic {
+    /** Unique id for this shard: the language, or `<language>:<projectPath>` for a TS workspace sub-project. */
+    id: string;
+    language: SupportedLanguage;
+    /** True when the cached shard was reused without rerunning its indexer. */
+    reused: boolean;
+    /** Present only when `reused` is false: why the cached shard could not be used. */
+    missReason?: string;
+    /** Short hash of this shard's fingerprint inputs (source content + indexer options). */
+    fingerprint: string;
+    /** Size in bytes of the shard's cached SCIP output, or null when unavailable. */
+    outputBytes: number | null;
+    /** Wall time spent producing this shard; 0 when reused. */
+    durationMs: number;
+    /** Indexer command invoked to produce this shard; absent when reused. */
+    command?: string;
+}
+interface ReindexResult {
+    /** Languages that were successfully indexed. */
+    languages: SupportedLanguage[];
+    indexPath: string;
+    dbPath: string;
+    durationMs: number;
+    /** True when existing SCIP/SQLite outputs were reused because inputs were unchanged. */
+    reused: boolean;
+    /**
+     * Languages detected in the project but skipped because their indexer
+     * could not be located, installed, or run. Each entry includes the reason.
+     */
+    skipped: {
+        language: SupportedLanguage;
+        reason: string;
+    }[];
+    /** Persisted description of this refresh attempt. */
+    lastRefresh?: LastRefreshMetadata;
+    /** Per-shard reuse diagnostics (plan6 6.5.2); one entry per language/workspace shard. */
+    shards?: ReindexShardDiagnostic[];
+    /** Staging-copy cost split by copy-on-write clones and real byte-copy fallbacks. */
+    writeTelemetry?: ReindexWriteTelemetry;
+}
+/**
+ * Reindex a project: detect languages, run the appropriate SCIP indexer(s),
+ * and convert the output to SQLite.
+ */
+declare function reindex(opts: ReindexOptions): Promise<ReindexResult>;
+
+export { INDEXER_CONFIGS, type ReindexOptions, type ReindexResult, type ReindexShardDiagnostic, augmentAuxiliaryDocuments, augmentVueResolvedReferences, augmentVueResolvedReferencesAsync, auxiliaryDocumentsAugmentationStage, describeIndexerBinary, detectLanguages, getIndexerConfig, getIndexerExecutionEnv, isBinaryAvailable, isIndexerInstalled, mergeScipFiles, mergeScipIndexes, reindex, resolveIndexerBinary, resolveProjectLocalIndexerBinary, runPostIndexAugmentation, tryInstallIndexer, vueResolvedReferencesAugmentationStage };