dsh-code-index 0.8.0 → 0.9.0

package/dist/index.d.ts

@@ -0,0 +1,634 @@
+import * as _deepseek_ai_dsh_tools from '@deepseek-ai/dsh-tools';
+import Schema from '@deepseek-ai/schemastery';
+
+/** Shared data model for dsh-code-index. */
+/** On-disk cache layout version. Bump when persisted graph/symbol shapes change. */
+declare const REPO_INDEX_SCHEMA_VERSION: 2;
+type SymbolKind = 'function' | 'method' | 'class' | 'interface' | 'type' | 'enum' | 'variable' | 'field' | 'import' | 'module';
+/** Stable, file-qualified symbol identity: `sym:v1:<file>#<scope>/<segment>`. */
+type SymbolId = string;
+/** Vocabulary for one scope segment in a qualified symbol id. */
+type ScopeKind = 'module' | 'namespace' | 'class' | 'interface' | 'trait' | 'impl' | 'function' | 'method' | 'owner';
+interface SymbolScopePart {
+    kind: ScopeKind;
+    name: string;
+    /** 1-based among sibling scope owners with the same kind and name. */
+    ordinal: number;
+}
+interface SymbolInfo {
+    /** Stable qualified id; unique within a RepoIndex. */
+    id: SymbolId;
+    /** Symbol name (identifier / type id / member name). */
+    name: string;
+    kind: SymbolKind;
+    /** Repo-relative path of the containing file, always forward-slash. */
+    file: string;
+    /** 1-based start line. */
+    line: number;
+    /** 1-based end line (inclusive). */
+    endLine: number;
+    /** True when the symbol is exported at module level (export .. / export default). */
+    exported: boolean;
+    /** Short human-readable signature, e.g. `greet(name: string)` — empty when n/a. */
+    signature: string;
+    /** Owners only; excludes the symbol itself. Empty at module level. */
+    scope: SymbolScopePart[];
+    /** 1-based among symbols with the same scope, kind, and name. */
+    ordinal: number;
+}
+/** One name bound by an import statement, with its local alias. */
+interface ImportBinding {
+    /** Imported name: "foo" | "default" | "*" | null (namespace/package). */
+    imported: string | null;
+    /** Name visible in this file (alias when renamed). */
+    local: string;
+    kind: 'named' | 'default' | 'namespace' | 'package' | 'static' | 'glob';
+}
+/** Structured form of one import/include/use site. */
+interface ImportInfo {
+    specifier: string;
+    line: number;
+    kind: 'import' | 'reexport' | 'include' | 'use';
+    bindings: ImportBinding[];
+}
+/** One call site: callee name, line, and enclosing function ('' = module level). */
+interface CallInfo {
+    /** Callee name as written (identifier, member/property, or qualified tail). */
+    name: string;
+    /** 1-based line of the call expression. */
+    line: number;
+    /** Enclosing function/method name, or '' for a module-level call. */
+    from: string;
+    /** Structural owner from AST containment; null at module level. */
+    fromId: SymbolId | null;
+    /** Receiver/namespace text when available: `ns.foo()` -> "ns"; bare -> null. */
+    qualifier: string | null;
+}
+interface IndexedFile {
+    /** Repo-relative path (forward-slash). */
+    path: string;
+    lang: string;
+    /** fs mtime of the source file at index time (milliseconds). */
+    mtimeMs: number;
+    symbols: SymbolInfo[];
+    /** Derived compatibility view of {@link importDetails} specifiers. */
+    imports?: string[];
+    /** Structured import/include/use sites with their name bindings. */
+    importDetails?: ImportInfo[];
+    /** Call sites found in this file (callee + line + enclosing function).
+     *  Optional because caches written before call-graph support lack it. */
+    calls?: CallInfo[];
+}
+interface RepoIndex {
+    /** Persisted layout version; see {@link REPO_INDEX_SCHEMA_VERSION}. */
+    schemaVersion: typeof REPO_INDEX_SCHEMA_VERSION;
+    /** Absolute source root this index describes. */
+    root: string;
+    /** Unix ms when the index was generated. */
+    generatedAt: number;
+    files: IndexedFile[];
+    excludedDirs: string[];
+}
+declare function symbolCount(index: RepoIndex): number;
+/** Optional config consumed by the index build pipeline. */
+interface IndexOptions {
+    /** Extra directories to exclude, appended to the defaults. */
+    excludeDirs?: string[];
+    /** Minimum mtime delta (ms) that forces a re-extract in refresh mode. */
+    staleToleranceMs?: number;
+}
+
+/** Build a RepoIndex for a workspace: scan -> extract -> persist. */
+
+/**
+ * Full build: scan + extract every supported file. Existing per-file
+ * extraction is reused when `previous` holds an identical mtime for the
+ * same rel path (incremental refresh), so touched files alone re-parse.
+ */
+declare function buildIndex(root: string, options?: IndexOptions, previous?: RepoIndex | null, forcePaths?: ReadonlySet<string>): Promise<RepoIndex>;
+/** Convenience wrapper: evolve an on-disk cache if `root` exists. */
+declare function buildIndexWithCache(root: string, options?: IndexOptions, cacheDir?: string, forcePaths?: ReadonlySet<string>): Promise<RepoIndex>;
+/**
+ * Locate the git repo root for a path by walking up to the nearest `.git`
+ * directory. Bounded walk (max `maxLevels` levels); returns `null` when no
+ * repo marker is found — callers must NOT index an untagged directory
+ * (the fs root is the classic footgun: indexing `C:\` by accident).
+ */
+declare function findRepoRoot(startDir: string, maxLevels?: number): Promise<string | null>;
+
+/**
+ * tree-sitter symbol extraction.
+ *
+ * Parses a source text with a per-language grammar (web-tree-sitter WASM,
+ * static grammars from tree-sitter-wasms) and returns flat SymbolInfo rows.
+ *
+ * NOTE on the dependency pin: web-tree-sitter must stay at ^0.20.x — newer
+ * releases expect dylinked grammar wasm, while tree-sitter-wasms ships
+ * static builds. Verified working pair: web-tree-sitter@0.20.8 + tree-sitter-wasms@0.1.13.
+ */
+
+type LanguageId = 'typescript' | 'javascript' | 'python' | 'go' | 'rust' | 'java' | 'cpp' | 'c';
+declare function languageForFile(filePath: string): LanguageId | null;
+interface ExtractedFile {
+    symbols: SymbolInfo[];
+    /** Derived compatibility view of {@link importDetails} specifiers. */
+    imports: string[];
+    /** Structured import/include/use sites with name bindings. */
+    importDetails: ImportInfo[];
+    /** Call sites, ordered by line: callee name + enclosing function. */
+    calls: CallInfo[];
+}
+declare function extractAll(code: string, id: LanguageId, file?: string): Promise<ExtractedFile>;
+/** Symbols only — see extractAll for the combined parse. */
+declare function extractSymbols(code: string, id: LanguageId): Promise<SymbolInfo[]>;
+/** Compile a symbol query for a code sample (used by tests). */
+declare function parseFileToSymbols(filePath: string, repoRoot: string, code?: string): Promise<SymbolInfo[]>;
+
+/** Workspace file discovery with dir exclusions and mtime tracking. */
+
+declare const DEFAULT_EXCLUDED_DIRS: string[];
+/** Language-agnostic source extensions we index. */
+declare const SUPPORTED_EXTS: Set<string>;
+interface ScannedFile {
+    /** Absolute path on disk. */
+    abs: string;
+    /** Repo-relative path (forward-slash). */
+    rel: string;
+    mtimeMs: number;
+}
+/**
+ * Recursively walk `root` and return indexed files, skipping excluded dir
+ * components at any depth. Uses readdir with `withFileTypes` so we never
+ * stat every entry; mtime comes from a targeted stat per candidate file.
+ */
+declare function scanRepo(root: string, options?: IndexOptions): Promise<ScannedFile[]>;
+
+/** On-disk JSON cache for RepoIndex, keyed by repo root. */
+
+declare const CACHE_DIR_NAME = ".dsh-code-index";
+/** Default cache location: `<repoRoot>/.dsh-code-index/index.json`. */
+declare function defaultCachePath(root: string, cacheDir?: string): string;
+declare function loadIndex(cachePath: string): Promise<RepoIndex | null>;
+declare function saveIndex(cachePath: string, index: RepoIndex): Promise<void>;
+
+/** Pure search / filter logic over a RepoIndex — unit-testable, no IO. */
+
+interface SymbolFilter {
+    query?: string;
+    file?: string;
+    kind?: SymbolKind;
+    exportedOnly?: boolean;
+}
+interface RankedHit extends SymbolInfo {
+    /** 0..1 relevance. 1 = exact name match; lower = fuzzier. */
+    score: number;
+}
+/** Filter symbols by file/kind/export, then score by name against query (if any). */
+declare function searchSymbols(index: RepoIndex, filter: SymbolFilter, limit?: number, refs?: Map<string, number>): RankedHit[];
+/** Neat one-line rendering of a hit for terminal/chat output. */
+declare function renderHit(hit: RankedHit): string;
+
+/**
+ * Bounded, ranked repo map generation — the "aider-style" overview the model
+ * can turn to before browsing files. Pure logic, no IO.
+ */
+
+interface RepoMapOptions {
+    /** Max files to include (default 24). */
+    topFiles?: number;
+    /** Max symbols per file (default 18). */
+    symbolsPerFile?: number;
+    /** Hard cap on rendered characters (default 3200). */
+    maxChars?: number;
+}
+interface RepoMapEntry {
+    path: string;
+    score: number;
+    symbols: Array<{
+        name: string;
+        kind: SymbolKind;
+        line: number;
+        signature: string;
+    }>;
+}
+/** Density-aware file score: weighted symbols minus bloat; test paths damped. */
+declare function scoreFile(file: IndexedFile): number;
+/** Rank files, take the top slice, cap per-file symbols. */
+declare function rankRepoMap(index: RepoIndex, options?: RepoMapOptions): RepoMapEntry[];
+/** Render the ranked map as markdown, hard-truncated to maxChars. */
+declare function renderRepoMap(entries: RepoMapEntry[], options?: RepoMapOptions): string;
+
+/** Function-level call graph built from the cached index — pure, no IO. */
+
+/** name -> definitions; several when same-named symbols live in different files. */
+declare function buildSymbolTable(index: RepoIndex): Map<string, SymbolInfo[]>;
+/** One call site that invokes the queried symbol. */
+interface CallerHit {
+    file: string;
+    line: number;
+    from: string;
+}
+/** One distinct symbol the queried function calls, with its first call line. */
+interface CalleeHit {
+    name: string;
+    line: number;
+    /** In-repo definitions matched by the callee name. */
+    targets: SymbolInfo[];
+}
+interface SymbolRefs {
+    /** Definitions of the queried symbol (empty when only call sites exist). */
+    defs: SymbolInfo[];
+    callers: CallerHit[];
+    callees: CalleeHit[];
+}
+/** How many call sites reference each name — used to rank search hits. */
+declare function callerCounts(index: RepoIndex): Map<string, number>;
+/**
+ * Resolve one symbol to its callers (call sites invoking it anywhere) and its
+ * callees (calls made inside the definition, attributed by the extracted
+ * enclosing-function name). Name-based, so it is a best-effort view: like-named
+ * symbols are reported as candidates rather than guessed apart.
+ */
+declare function symbolRefs(index: RepoIndex, symbol: string, limit?: number): SymbolRefs;
+/**
+ * How sure the graph is about one resolved edge. Deliberately coarse: the
+ * index has no type checker, so `exact` only ever means "one structurally
+ * unambiguous target under this index's model".
+ */
+type ResolutionLabel = 'exact' | 'import-scoped' | 'name-only';
+/** Which resolution tier produced an edge — the *why* behind its label. */
+type ResolutionProvenance = 'structural-owner' | 'local-unique' | 'explicit-import-binding' | 'namespace-import' | 'resolved-import-module' | 'global-name';
+
+/** Import-graph health checks: circular dependencies and orphan modules. */
+
+interface ModuleGraph {
+    nodes: string[];
+    edges: Map<string, Set<string>>;
+}
+/** Nodes are indexed files; an edge A -> B means A imports B (self-edges dropped). */
+declare function buildModuleGraph(index: RepoIndex): ModuleGraph;
+/** Tarjan strongly-connected components of size > 1 — i.e. import cycles. */
+declare function findCycles(index: RepoIndex): string[][];
+/**
+ * Symbol-bearing files that neither import nor are imported by any other file,
+ * excluding conventional entry points and tests (which are legitimately
+ * unreferenced). A cheap, low-false-positive stand-in for dead-code detection.
+ */
+declare function findOrphanModules(index: RepoIndex): string[];
+
+/**
+ * Unified-diff parsing and a thin `git` adapter.
+ *
+ * `parseUnifiedDiff` is pure (no IO) so it is unit-testable in isolation; the
+ * two readers shell out to `git` exclusively through `execFile` with an argv
+ * array — a ref or path is never interpolated into a shell string.
+ */
+/** One `@@` hunk header; a missing count means 1 (git omits `,1`). */
+interface DiffHunk {
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+}
+/** One file's entry in a unified diff. */
+interface FileChange {
+    /** Repo-relative path on the base side, or null for an added file. */
+    oldPath: string | null;
+    /** Repo-relative path on the current side, or null for a deleted file. */
+    newPath: string | null;
+    status: 'added' | 'modified' | 'deleted' | 'renamed';
+    hunks: DiffHunk[];
+}
+/**
+ * Parse `git diff` / `diff -u` output into per-file changes. Handles
+ * `diff --git`, `new file mode`, `deleted file mode`, `rename from/to`,
+ * `---`/`+++` (including `/dev/null`), and `@@` headers with omitted counts.
+ */
+declare function parseUnifiedDiff(text: string): FileChange[];
+/**
+ * Working-tree diff against `baseRef`, rename-aware and hunk-minimal.
+ * Includes non-ignored untracked files and reliable exact-content renames.
+ */
+declare function readWorkingTreeDiff(root: string, baseRef: string): Promise<string>;
+/** Read one repo-relative file at a ref; null when the path/ref is absent. */
+declare function readGitFileAtRef(root: string, ref: string, repoRelativePath: string): Promise<string | null>;
+
+/**
+ * Change-aware context (design §3): map a git/working-tree diff (or an explicit
+ * file/symbol selection) onto indexed symbols, then walk the provenance-labeled
+ * reference graph to surface callers, import dependents, transitive impact,
+ * entry-point paths, and likely affected tests.
+ *
+ * Every relation keeps the reference graph's honest label (`exact` /
+ * `import-scoped` / `name-only`); a diff hunk intersecting a symbol's declared
+ * line range is the only thing treated as `exact`.
+ */
+
+type ChangeKind = 'added' | 'modified' | 'deleted' | 'renamed' | 'unclassified';
+interface ChangedSymbol {
+    symbol: SymbolInfo;
+    change: ChangeKind;
+    side: 'current' | 'base';
+    /** A hunk range intersecting the declaration is structural, not inferred. */
+    resolution: 'exact';
+    /** First intersecting changed line, used for large-declaration windows. */
+    focusLine?: number;
+}
+interface UnmappedChange {
+    file: string;
+    side: 'current' | 'base';
+    ranges: Array<{
+        startLine: number;
+        endLine: number;
+    }>;
+    reason: 'outside-symbol' | 'base-content-unavailable';
+}
+interface ImpactHop {
+    fromId: SymbolId | null;
+    toId: SymbolId;
+    callSite: {
+        file: string;
+        line: number;
+    };
+    resolution: ResolutionLabel;
+    reason: ResolutionProvenance;
+}
+interface ImpactRow {
+    symbol: SymbolInfo;
+    depth: number;
+    via: ImpactHop;
+    resolution: ResolutionLabel;
+}
+interface SymbolPath {
+    entry: SymbolInfo;
+    changed: SymbolInfo;
+    hops: ImpactHop[];
+    resolution: ResolutionLabel;
+}
+interface ImportDependent {
+    file: string;
+    changedFile: string;
+    specifier: string;
+    resolution: 'import-scoped';
+}
+interface AffectedTest {
+    file: string;
+    resolution: ResolutionLabel;
+    reason: 'changed-test' | 'imports-changed-file' | 'imports-impact-file' | 'references-symbol-name' | 'path-convention';
+    distance?: number;
+}
+interface ChangeContextResult {
+    root: string;
+    source: 'git' | 'diff' | 'files' | 'symbols';
+    baseRef?: string;
+    changed: ChangedSymbol[];
+    unmapped: UnmappedChange[];
+    directCallers: ImpactRow[];
+    importDependents: ImportDependent[];
+    paths: SymbolPath[];
+    impact: ImpactRow[];
+    tests: AffectedTest[];
+    warnings: string[];
+    truncated: {
+        callers: boolean;
+        dependents: boolean;
+        paths: boolean;
+        impact: boolean;
+        tests: boolean;
+    };
+}
+interface CodeChangeContextArgs {
+    repoRoot?: string;
+    diff?: string;
+    baseRef?: string;
+    files?: string[];
+    symbols?: SymbolId[];
+    maxDepth?: number;
+    maxImpact?: number;
+    maxPaths?: number;
+    maxTests?: number;
+}
+interface ChangeContextOptions {
+    maxDepth?: number;
+    maxImpact?: number;
+    maxPaths?: number;
+    maxTests?: number;
+}
+/** Normalized input: exactly one selection mode. */
+type ChangeContextInput = {
+    kind: 'git';
+    root: string;
+    baseRef: string;
+} | {
+    kind: 'diff';
+    root: string;
+    text: string;
+    baseRef?: string;
+} | {
+    kind: 'files';
+    files: string[];
+} | {
+    kind: 'symbols';
+    symbolIds: SymbolId[];
+};
+/** Validate flat tool args and normalize them into one input mode. */
+declare function changeContextInputFromArgs(args: Pick<CodeChangeContextArgs, 'diff' | 'baseRef' | 'files' | 'symbols'>, root: string): ChangeContextInput;
+declare function buildChangeContext(index: RepoIndex, input: ChangeContextInput, options?: ChangeContextOptions): Promise<ChangeContextResult>;
+/**
+ * Render the result as fixed skeleton sections. Section headers and warnings
+ * are always kept; rows are trimmed to the final character cap, which then
+ * appends an explicit truncation line.
+ */
+declare function renderChangeContext(result: ChangeContextResult, maxChars?: number): string;
+
+interface SourceExcerpt {
+    file: string;
+    startLine: number;
+    endLine: number;
+    side: 'current' | 'base';
+    ref?: string;
+    mode: 'complete' | 'window' | 'signature';
+    code?: string;
+    signature?: string;
+}
+
+interface ContextPackItem extends Partial<SourceExcerpt> {
+    kind: 'primary' | 'caller' | 'callee' | 'import' | 'test' | 'change' | 'file' | 'relationship';
+    name?: string;
+    reason: string;
+    resolution?: ResolutionLabel;
+    provenance?: string;
+    change?: string;
+    text?: string;
+}
+/** The only final presentation DTO. Items here have already passed selection. */
+interface ContextPack {
+    version: 1;
+    root: string;
+    task: string;
+    route: TaskContextResult['route']['kind'];
+    items: ContextPackItem[];
+    gaps: string[];
+    budget: {
+        budgetChars: number;
+        usedChars: number;
+        packChars: number;
+        truncated: boolean;
+    };
+}
+declare function renderContextPack(pack: ContextPack): string;
+
+/**
+ * Task-aware structural context orchestration.
+ *
+ * This module deliberately contains no parser, search index, graph, or git
+ * implementation of its own. It ranks the existing primitives into a compact
+ * package that answers the question: which code matters for this task?
+ */
+
+type ContextTaskKind = 'change' | 'symbol' | 'architecture' | 'test' | 'exploration' | 'ambiguous';
+interface ContextRoute {
+    kind: ContextTaskKind;
+    queries: string[];
+    mentionedFiles: string[];
+    exactSymbolNames: string[];
+    sources: string[];
+    includeChangeContext: boolean;
+    includeRelationships: boolean;
+}
+interface ContextOptions {
+    budgetChars?: number;
+    maxFiles?: number;
+    maxSymbols?: number;
+}
+interface ContextSymbol {
+    symbol: SymbolInfo;
+    score: number;
+    provenance: 'exact' | 'lexical';
+    reason: string;
+}
+interface ContextFile {
+    path: string;
+    score: number;
+    reason: string;
+}
+interface ContextRelationship {
+    text: string;
+    resolution: ResolutionLabel;
+    priority: number;
+    key: string;
+    provenance: string;
+}
+interface ContextConfidence {
+    exact: number;
+    'import-scoped': number;
+    'name-only': number;
+}
+interface TaskContextResult {
+    pack: ContextPack;
+    root: string;
+    task: string;
+    route: ContextRoute;
+    primarySymbols: ContextSymbol[];
+    relevantFiles: ContextFile[];
+    relationships: ContextRelationship[];
+    changeContext: ChangeContextResult | null;
+    tests: string[];
+    testEvidence: AffectedTest[];
+    confidence: ContextConfidence;
+    warnings: string[];
+    budget: {
+        usedChars: number;
+        budgetChars: number;
+        truncated: boolean;
+    };
+}
+/** Classify a task and decide which existing primitives should be composed. */
+declare function routeTask(task: string, index?: RepoIndex): ContextRoute;
+/** Build a deterministic, bounded context package from the current task. */
+declare function buildTaskContext(index: RepoIndex, task: string, options?: ContextOptions): Promise<TaskContextResult>;
+/** Text always renders the final selected pack. */
+declare function renderTaskContext(result: TaskContextResult): string;
+
+declare const tools: _deepseek_ai_dsh_tools.ToolDefinition[];
+
+/** Plugin configuration: merged once at apply time, read wherever needed. */
+
+/** DSH 0.1.7+ renders fields marked volatile in its per-plugin config forms. */
+declare const Config: Schema<Schemastery.ObjectS<NoInfer<{
+    excludeDirs: Schema<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+    mapTopFiles: Schema<number, number, "volatile-defined">;
+    mapMaxChars: Schema<number, number, "volatile-defined">;
+    mapTtlMs: Schema<number, number, "volatile-defined">;
+    autoInject: Schema<boolean, boolean, "volatile-defined">;
+    codeHealth: Schema<boolean, boolean, "volatile-defined">;
+    toolSurface: Schema<string, string, "volatile-defined">;
+    externalWatch: Schema<boolean, boolean, "volatile-defined">;
+    watchDebounceMs: Schema<number, number, "volatile-defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    excludeDirs: Schema<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+    mapTopFiles: Schema<number, number, "volatile-defined">;
+    mapMaxChars: Schema<number, number, "volatile-defined">;
+    mapTtlMs: Schema<number, number, "volatile-defined">;
+    autoInject: Schema<boolean, boolean, "volatile-defined">;
+    codeHealth: Schema<boolean, boolean, "volatile-defined">;
+    toolSurface: Schema<string, string, "volatile-defined">;
+    externalWatch: Schema<boolean, boolean, "volatile-defined">;
+    watchDebounceMs: Schema<number, number, "volatile-defined">;
+}>>, "plain">;
+interface PluginConfig {
+    /** Extra directories to exclude from indexing (appended to defaults). */
+    excludeDirs?: string[];
+    /** Max files in the ranked repo map (code_map / auto section). */
+    mapTopFiles?: number;
+    /** Hard char cap for rendered maps. */
+    mapMaxChars?: number;
+    /** Refresh interval for the auto-injected map (ms, min 1000). */
+    mapTtlMs?: number;
+    /** Set false to disable the auto-injected system section. */
+    autoInject?: boolean;
+    /** Register the code_health tool (circles / orphans). Off by default. */
+    codeHealth?: boolean;
+    /** Experimental tool surface; full preserves the complete v0.6 API. */
+    toolSurface?: 'full' | 'compact';
+    /** Observe source changes made by editors and external tools. */
+    externalWatch?: boolean;
+    /** Coalesce filesystem events before refreshing affected files. */
+    watchDebounceMs?: number;
+}
+
+/**
+ * dsh-code-index — DeepSeek Harness bundle entry.
+ *
+ * Registers model-visible tools (code_index / code_symbols / code_search /
+ * code_map / code_refs / code_change_context / code_context) plus an opt-in code_health
+ * (config.codeHealth) backed by a tree-sitter symbol + call-graph index,
+ * and injects a bounded auto-updating repo map for the default workspace
+ * into the system prompt.
+ */
+type Disposer = void | (() => void);
+/** Minimal structural Context; the real @deepseek-ai/cordis type is a
+ *  runtime dependency we intentionally do not import in the bundle entry. */
+interface MinimalContext {
+    effect(fn: () => Disposer): void;
+    tools: {
+        register(t: unknown): () => void;
+    };
+    get?(name: string): unknown;
+    inject?(deps: string[], run: (ctx: MinimalContext) => void): unknown;
+    on?(event: string, listener: () => void): () => void;
+    fiber?: unknown;
+    systemPrompt: {
+        section(section: {
+            name: string;
+            order: number;
+            text: string | ((context: unknown) => string);
+        }): () => void;
+    };
+}
+declare const name = "dsh-code-index";
+
+declare const inject: readonly ["tools", "systemPrompt"];
+declare function apply(ctx: MinimalContext, pluginConfig?: PluginConfig): void;
+
+export { type AffectedTest, CACHE_DIR_NAME, type ChangeContextInput, type ChangeContextOptions, type ChangeContextResult, type ChangeKind, type ChangedSymbol, type CodeChangeContextArgs, Config, type ContextFile, type ContextOptions, type ContextPack, type ContextPackItem, type ContextRelationship, type ContextRoute, type ContextSymbol, type ContextTaskKind, DEFAULT_EXCLUDED_DIRS, type DiffHunk, type FileChange, type ImpactHop, type ImpactRow, type ImportDependent, type IndexOptions, type IndexedFile, type RepoIndex, SUPPORTED_EXTS, type SymbolInfo, type SymbolKind, type SymbolPath, type TaskContextResult, type UnmappedChange, apply, buildChangeContext, buildIndex, buildIndexWithCache, buildModuleGraph, buildSymbolTable, buildTaskContext, callerCounts, changeContextInputFromArgs, defaultCachePath, extractAll, extractSymbols, findCycles, findOrphanModules, findRepoRoot, inject, languageForFile, loadIndex, name, parseFileToSymbols, parseUnifiedDiff, rankRepoMap, readGitFileAtRef, readWorkingTreeDiff, renderChangeContext, renderContextPack, renderHit, renderRepoMap, renderTaskContext, routeTask, saveIndex, scanRepo, scoreFile, searchSymbols, symbolCount, symbolRefs, tools };