codebaseiq 0.1.0

package/dist/command-panels-SZONPMLJ.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import{a,b,c}from"./chunk-B3UYV66Z.js";import"./chunk-362QOSFD.js";import"./chunk-B2OB55RR.js";export{a as commandPanelId,b as commandPanels,c as renderRootCommandHelp};
+//# sourceMappingURL=command-panels-SZONPMLJ.js.map

package/dist/config-types-BNoC96J3.d.ts

@@ -0,0 +1,560 @@
+declare const LEGACY_OBSERVATION_RECEIPT_SCHEMA_VERSION: 1;
+declare const OBSERVATION_RECEIPT_SCHEMA_VERSION: 2;
+declare const OBSERVATION_IDENTITY_SCHEMA_VERSION: 1;
+declare const OBSERVATION_IDENTITY_CANONICALIZATION_VERSION: 1;
+declare const OBSERVATION_IDENTITY_HASH_ALGORITHM: "sha256";
+declare const OBSERVATION_STATE_AUTHORITY_POLICY_VERSION: 1;
+type ObservationAuthorityKind = 'index-worktree' | 'index-only' | 'worktree-only' | 'process-local';
+/**
+ * A version-1 receipt identifies the local index/worktree evidence emitted by
+ * codebaseiq before state identity was split into independent facts. Its
+ * project and worktree values are retained as historical facts, but their
+ * combined path/state meanings cannot prove v2 collaboration, workspace, or
+ * content relationships.
+ */
+interface ObservationReceiptV1 {
+    schemaVersion: typeof LEGACY_OBSERVATION_RECEIPT_SCHEMA_VERSION;
+    authorityKind: ObservationAuthorityKind;
+    observedAt: string;
+    projectIdentity: string;
+    index?: {
+        generationIdentity: string;
+        source: 'immutable' | 'legacy';
+        alignment: 'not-certified' | 'leased';
+    };
+    worktree?: {
+        identity: string;
+        clean: boolean;
+        headCommit?: string;
+        treeOid?: string;
+    };
+}
+/**
+ * An observation identity is a content-derived identifier whose projection
+ * says which real inputs were selected and whose digest says what values that
+ * projection observed. Including every version in the hash preimage prevents
+ * equal-looking digests from silently crossing incompatible identity rules.
+ */
+interface ObservationIdentity {
+    schemaVersion: typeof OBSERVATION_IDENTITY_SCHEMA_VERSION;
+    canonicalizationVersion: typeof OBSERVATION_IDENTITY_CANONICALIZATION_VERSION;
+    hashAlgorithm: typeof OBSERVATION_IDENTITY_HASH_ALGORITHM;
+    projection: {
+        name: string;
+        version: number;
+    };
+    digest: string;
+}
+interface RelevantInputIdentity {
+    /** The result or claim family whose answer can be changed by this projection. */
+    subject: string;
+    identity: ObservationIdentity;
+}
+type ObservationSourceKind = 'index-generation' | 'repository-snapshot' | 'live-workspace' | 'process';
+/**
+ * An observed source is one state-bearing input an operation actually read.
+ * It names the referent only; whether that referent stayed fixed is a separate
+ * stability fact.
+ */
+interface ObservationSourceFact {
+    kind: ObservationSourceKind;
+    identity?: ObservationIdentity;
+}
+type ObservationStabilityProofKind = 'immutable' | 'fixed-snapshot' | 'bracketed' | 'not-established' | 'invalidated';
+/**
+ * A stability proof records how one observed source was prevented from
+ * changing during the observation interval. Immutable and fixed-snapshot
+ * proofs establish fixed input; bracketed equality is weaker because an
+ * intermediate change can return to the same endpoint.
+ */
+interface ObservationStabilityProof {
+    source: ObservationSourceKind;
+    kind: ObservationStabilityProofKind;
+}
+interface ObservationReceiptV2 {
+    schemaVersion: typeof OBSERVATION_RECEIPT_SCHEMA_VERSION;
+    observedAt: string;
+    facts: {
+        collaborationDomain?: ObservationIdentity;
+        repositoryLineage?: ObservationIdentity;
+        workspaceInstance?: ObservationIdentity;
+        wholeContent?: ObservationIdentity;
+        relevantInputs?: readonly RelevantInputIdentity[];
+        index?: {
+            generation: ObservationIdentity;
+            /** Inputs persisted with the immutable generation when known. */
+            inputs?: ObservationIdentity;
+            source: 'immutable' | 'legacy';
+        };
+    };
+    observedSources: readonly ObservationSourceFact[];
+    stabilityProofs: readonly ObservationStabilityProof[];
+    /** Human-useful state facts that are not compatibility identities. */
+    diagnostics?: {
+        clean?: boolean;
+        headCommit?: string;
+        treeOid?: string;
+    };
+}
+type ObservationReceipt = ObservationReceiptV1 | ObservationReceiptV2;
+type DecodedObservationReceipt = {
+    kind: 'legacy';
+    schemaVersion: 1;
+    receipt: ObservationReceiptV1;
+} | {
+    kind: 'supported';
+    schemaVersion: 2;
+    receipt: ObservationReceiptV2;
+} | {
+    kind: 'unsupported';
+    schemaVersion: number;
+    direction: 'older' | 'future';
+} | {
+    kind: 'malformed';
+    reason: string;
+};
+type ObservationRelationshipState = 'established' | 'disproven' | 'unknown';
+type ObservationComparisonReason = 'identities-equal' | 'identities-different' | 'left-fact-missing' | 'right-fact-missing' | 'both-facts-missing' | 'identity-projections-not-comparable' | 'legacy-fact-not-comparable' | 'all-observed-sources-fixed' | 'left-observation-has-no-repository-source' | 'right-observation-has-no-repository-source' | 'left-observation-not-fixed' | 'right-observation-not-fixed' | 'left-observation-invalidated' | 'right-observation-invalidated';
+type ObservationComparedFact = {
+    kind: 'identity';
+    identity: ObservationIdentity;
+} | {
+    kind: 'legacy-index-generation';
+    value: string;
+} | {
+    kind: 'stability';
+    proof: ObservationStabilityProof;
+};
+interface ObservationRelationshipJudgment {
+    state: ObservationRelationshipState;
+    reasons: readonly ObservationComparisonReason[];
+    facts: {
+        left: readonly ObservationComparedFact[];
+        right: readonly ObservationComparedFact[];
+    };
+}
+interface RelevantInputRelationshipJudgment {
+    subject: string;
+    projection: string;
+    judgment: ObservationRelationshipJudgment;
+}
+/**
+ * A receipt comparison is a set of independent relationship judgments. Each
+ * field answers one real question; no field is a total "strength" score and
+ * no established relationship silently upgrades another.
+ */
+interface ObservationReceiptComparison {
+    collaborationDomain: ObservationRelationshipJudgment;
+    repositoryLineage: ObservationRelationshipJudgment;
+    workspaceInstance: ObservationRelationshipJudgment;
+    wholeContent: ObservationRelationshipJudgment;
+    relevantInputs: readonly RelevantInputRelationshipJudgment[];
+    indexInput: ObservationRelationshipJudgment;
+    indexGeneration: ObservationRelationshipJudgment;
+    observationStability: ObservationRelationshipJudgment;
+}
+type ObservationStateAuthority = 'completion' | 'advisory' | 'none';
+/**
+ * A derived state-authority judgment is product policy applied to receipt
+ * facts at use time. It is not serialized into the producer's receipt, so a
+ * producer cannot grant itself completion authority by asserting a label.
+ */
+interface DerivedObservationStateAuthority {
+    policyVersion: typeof OBSERVATION_STATE_AUTHORITY_POLICY_VERSION;
+    authority: ObservationStateAuthority;
+    requiredRelationships: readonly ['collaborationDomain', 'wholeContent', 'observationStability'];
+    reasons: readonly string[];
+}
+declare function createObservationIdentity(projectionName: string, projectionVersion: number, canonicalValue: string): ObservationIdentity;
+declare function decodeObservationReceipt(value: unknown): DecodedObservationReceipt;
+declare function isObservationReceipt(value: unknown): value is ObservationReceipt;
+declare function compareObservationReceipts(left: ObservationReceipt, right: ObservationReceipt): ObservationReceiptComparison;
+declare function deriveObservationStateAuthority(left: ObservationReceipt, right: ObservationReceipt, comparison?: ObservationReceiptComparison): DerivedObservationStateAuthority;
+declare function observationReceiptGenerationIdentity(receipt: ObservationReceipt): string | undefined;
+declare function observationReceiptWorkspaceIdentity(receipt: ObservationReceipt): string | undefined;
+declare function observationReceiptStabilityLabel(receipt: ObservationReceipt): string;
+
+interface InstallMethod {
+    /** Human-readable label (e.g., "npm", "pip", "go install") */
+    label: string;
+    /** Immutable package/module identity requested from the installer. */
+    identity?: string;
+    /** Host location class that the installer will mutate. */
+    destination?: string;
+    /** Binary that must exist for this install method to work (e.g., "npm", "pip3", "go") */
+    prerequisite: string;
+    /** Command to execute */
+    binary: string;
+    /** Arguments for the command */
+    args: string[];
+}
+type SupportedLanguage = 'typescript' | 'javascript' | 'java' | 'scala' | 'kotlin' | 'rust' | 'python' | 'ruby' | 'go' | 'cpp' | 'c' | 'csharp' | 'vb' | 'dart' | 'php' | 'clojure';
+type TypeScriptProjectMode = 'single' | 'workspace';
+interface IndexerConfig {
+    language: SupportedLanguage;
+    /** Preferred executable name for the indexer */
+    indexerBinary: string;
+    /** Additional executable names accepted on PATH for the same indexer */
+    binaryAliases?: string[];
+    /** Project-local executable paths to prefer when they exist */
+    projectLocalBinaries?: string[];
+    /** Command to check if the indexer is installed */
+    checkCommand: string;
+    /** Returns the binary + args array for execFileSync (no shell injection) */
+    indexArgs: (opts: {
+        projectRoot: string;
+        outputPath: string;
+        pnpmWorkspaces?: boolean;
+        indexerBinary: string;
+        projectPath?: string;
+        configPath?: string;
+    }) => {
+        binary: string;
+        args: string[];
+    };
+    /** Relative output path written by the indexer when it ignores outputPath */
+    defaultOutputPath?: string;
+    /** Marker files that indicate this language is present */
+    markerFiles: string[];
+    /** Installation methods to try in order of preference */
+    installMethods?: InstallMethod[];
+    /** URL for manual installation if auto-install fails */
+    installUrl?: string;
+    /**
+     * npm package bundled with codebaseiq as an optionalDependency. When this
+     * package resolves locally (i.e. it installed successfully), the indexer is
+     * considered available even if its binary isn't on PATH — `npx <binary>`
+     * will pick up the local install.
+     */
+    bundledNpmPackage?: string;
+}
+interface CodeBaseIQConfig {
+    /** Path to the SQLite database (index.db) */
+    dbPath: string;
+    /** Path to the SCIP protobuf index (index.scip) */
+    indexPath: string;
+    /** Project root directory */
+    projectRoot: string;
+    /** Committed identity shared by branches, clones, and forks intended to merge into one project history. */
+    collaborationDomainId?: string;
+    /** Internal repository-level read-through cache for proven content-addressed evidence products. */
+    sharedEvidenceDbPath?: string;
+    /** Project-specific externally-live roots for dead-code filtering */
+    entryRoots?: EntryRootsConfig;
+    /** Paths to .gitignore files to load for filtering */
+    gitignorePaths?: string[];
+    /** Optional semantic-provider configuration */
+    semantic?: SemanticConfig;
+    /** Machine-readable accepted findings. */
+    suppressions?: FindingSuppression[];
+    /** Project-declared file groups that intentionally change together. */
+    declaredCouplings?: DeclaredCouplingConfig[];
+    /** Optional analyzer configuration. */
+    locality?: LocalityConfig;
+    /** Project-owned architectural boundaries and dependency rules. */
+    architecture?: ArchitectureConfig;
+    /** Enumeration-rot contracts: a declared key set that must track a ground-truth source. */
+    coverageContracts?: CoverageContractConfig[];
+    /** Documentation policy (snapshot-doc exemptions, ...). */
+    docs?: DocsConfig;
+}
+interface ProjectConfig {
+    /** JSON Schema hint for editors. Persisted writers add the packaged project-config schema. */
+    $schema?: string;
+    /** Persisted project-config format. Omitted only by readable legacy v1 records and in-memory callers. */
+    schemaVersion?: 2;
+    /**
+     * Opaque committed identity shared by branches, clones, linked worktrees,
+     * and contributor forks whose durable decisions are intended to merge.
+     * Independent derivatives deliberately replace it.
+     */
+    collaborationDomainId?: string;
+    /** Override which languages to index (default: auto-detect) */
+    languages?: SupportedLanguage[];
+    /** Number of indexer workers to run at once (default: adaptive, max 8) */
+    indexerConcurrency?: number;
+    /** Watch mode settings */
+    watch?: WatchConfig;
+    /** Per-language indexer overrides */
+    indexer?: Partial<Record<SupportedLanguage, IndexerOverrides>>;
+    /** Override the database storage path (default: ~/.cache/codebaseiq/<hash>/) */
+    dbPath?: string;
+    /** Project-specific externally-live roots for dead-code filtering */
+    entryRoots?: EntryRootsConfig;
+    /** Optional semantic-provider configuration */
+    semantic?: SemanticConfig;
+    /** Machine-readable accepted findings. */
+    suppressions?: FindingSuppression[];
+    /** Project-declared file groups that intentionally change together. */
+    declaredCouplings?: DeclaredCouplingConfig[];
+    /** Optional locality analyzer configuration. */
+    locality?: LocalityConfig;
+    /** Project-owned architectural boundaries and dependency rules. */
+    architecture?: ArchitectureConfig;
+    /** Enumeration-rot contracts: a declared key set that must track a ground-truth source. */
+    coverageContracts?: CoverageContractConfig[];
+    /** Documentation policy (snapshot-doc exemptions, ...). */
+    docs?: DocsConfig;
+    /** Resident query execution settings. */
+    daemon?: DaemonConfig;
+}
+interface DaemonConfig {
+    /** Serve eligible evidence commands from the resident watch service (default: false). */
+    enabled?: boolean;
+}
+type CoverageContractKeySpec = {
+    type: 'object-literal-keys';
+    identifier: string;
+} | {
+    type: 'string-array';
+    identifier: string;
+} | {
+    type: 'markdown-list';
+    marker: string;
+};
+type CoverageContractSourceSpec = {
+    type: 'top-level-dirs';
+    path: string;
+} | {
+    type: 'file-glob';
+    pattern: string;
+} | {
+    type: 'registered-commands';
+} | {
+    type: 'builtin-skills';
+};
+interface CoverageContractConfig {
+    /** Human-readable name for the contract, used in finding messages. */
+    name: string;
+    /** File the declared key set is extracted from. */
+    file: string;
+    /** How to extract the declared key set from `file`. */
+    keys: CoverageContractKeySpec;
+    /** The ground-truth source the declared key set must track. */
+    mustEqual: CoverageContractSourceSpec;
+    /** When false (the default), declared keys with no ground-truth match are also flagged. */
+    allowExtra?: boolean;
+}
+interface LocalityConfig {
+    /** Folder names that should be treated as architectural ownership boundaries. */
+    architecturalBoundarySegments?: string[];
+}
+interface ArchitectureBoundaryConfig {
+    /** Stable name used by dependency rules and reports. */
+    name: string;
+    /** Project-relative exact paths or trailing /* and /** patterns owned by this boundary. */
+    paths: string[];
+    /** File ceiling for this boundary, overriding `architecture.maxBoundaryFiles`. */
+    maxFiles?: number;
+    /**
+     * Granularity used when checking this boundary's internal structure under
+     * `requireResolvedBoundaries`.
+     *
+     * `directory` (the default) groups members by their containing directory, so
+     * a boundary that *is* one directory has a single sub-unit and no internal
+     * structure to check. `file` treats every member as its own sub-unit, which
+     * makes a cycle between files in the same directory visible. Use `file` for
+     * a large single-directory boundary whose members form layers.
+     */
+    subUnits?: 'directory' | 'file';
+}
+interface ArchitectureConfig {
+    /** Named code groups whose files serve one stable responsibility. */
+    boundaries: ArchitectureBoundaryConfig[];
+    /**
+     * Closed outgoing dependency rows. When a boundary has a row, cross-boundary
+     * targets omitted from that row are forbidden. A missing row remains
+     * descriptive and makes no allow/deny claim.
+     */
+    allowedDependencies?: Record<string, string[]>;
+    /**
+     * Require every configured boundary to have a closed outgoing dependency
+     * row. This prevents an omitted row from silently weakening enforcement.
+     */
+    requireCompletePolicy?: boolean;
+    /**
+     * Require every indexed, non-ignored file to belong to exactly one declared
+     * boundary. Unmapped and ambiguously mapped files otherwise remain visible
+     * coverage facts without being policy violations.
+     */
+    requireCompleteCoverage?: boolean;
+    /** Treat every multi-boundary dependency cycle as a declared violation. */
+    requireAcyclic?: boolean;
+    /**
+     * Treat a boundary that hides an internal dependency cycle as a declared
+     * violation.
+     *
+     * `requireAcyclic` only sees the graph *between* boundaries: every edge whose
+     * endpoints share a boundary is discarded before the check runs. A boundary
+     * coarse enough to contain both sides of a cycle therefore passes while
+     * saying nothing about the code inside it. This rule closes that gap by
+     * quotienting each boundary by its sub-directories and requiring that
+     * quotient to be acyclic too.
+     *
+     * Defaults to false so upgrading does not tighten an existing project's gate.
+     */
+    requireResolvedBoundaries?: boolean;
+    /**
+     * Treat a declared dependency allowance that no real edge uses as a
+     * violation.
+     *
+     * `requireCompletePolicy` checks that a row *exists*, not that it is
+     * *minimal*. An allowance therefore outlives the edge that justified it: the
+     * import is deleted, the row stays, and the policy silently widens until it
+     * permits something nobody reviewed. This rule keeps the declared matrix and
+     * the observed graph converged in both directions.
+     *
+     * Defaults to false so upgrading does not tighten an existing project's gate.
+     */
+    requireMinimalPolicy?: boolean;
+    /**
+     * Maximum number of distinct boundaries one boundary may depend on.
+     *
+     * Guards the failure mode that coarse boundaries otherwise hide: a boundary
+     * that keeps accumulating dependencies until it is coupled to most of the
+     * system. Unset means no limit.
+     */
+    maxBoundaryFanOut?: number;
+    /**
+     * Maximum number of files one boundary may own. Unset means no limit.
+     *
+     * A boundary large enough to hold unrelated responsibilities stops being a
+     * useful policy unit even when it is internally acyclic.
+     */
+    maxBoundaryFiles?: number;
+    /**
+     * Globs for test roots, e.g. `["tests/**"]`.
+     *
+     * Test files are usually excluded from the compiler project and therefore
+     * from the index, which puts them outside every boundary rule. Declaring the
+     * roots turns that back on: each test is judged against the boundary of the
+     * code it covers (found by path mirroring) and may not import beyond what
+     * that boundary is allowed to reach.
+     *
+     * Unset means tests stay unchecked, which is the historical behavior.
+     */
+    testPaths?: string[];
+}
+interface DocsConfig {
+    /**
+     * Glob patterns (see src/analysis/glob-match.ts for supported syntax) for
+     * dated snapshot docs that intentionally cite code "as of" a moment in
+     * time — excluded from doc-drift's
+     * default findings. A `<!-- codebaseiq: snapshot -->` marker inside a doc
+     * has the same effect regardless of its path.
+     */
+    snapshotPaths?: string[];
+}
+interface DeclaredCouplingConfig {
+    /** Human-readable name for the maintenance unit. */
+    name: string;
+    /** Exact relative file paths that form one intentional co-change group. */
+    files: string[];
+    /** Human reason for why these files should move together. */
+    reason?: string;
+}
+declare const SUPPRESSION_REASON_CODES: readonly ["entry-surface", "generated-code", "compatibility-shim", "reflection-or-registration", "test-fixture", "intentional-twin", "historical-coupling-ended", "detector-counterexample"];
+type SuppressionReasonCode = (typeof SUPPRESSION_REASON_CODES)[number];
+type SuppressionEvidenceKind = 'source' | 'config' | 'test' | 'graph';
+interface SuppressionCounterevidence {
+    /** What kind of independently inspectable referent supports the exception. */
+    kind: SuppressionEvidenceKind;
+    /** Project-relative path for source/config/test, or exact codebaseiq command for graph evidence. */
+    referent: string;
+    /** The concrete claim this referent establishes. */
+    claim: string;
+    /** SHA-256 of source/config/test bytes when target-content invalidation is enabled. */
+    contentHash?: string;
+    /** Index generation that produced graph evidence, when available. */
+    generation?: string;
+}
+interface SuppressionDecision {
+    kind: 'automated-adjudication';
+    reasonCode: SuppressionReasonCode;
+    decidedBy: 'agent' | 'human';
+    policyVersion: 1;
+    /** Repository/index state observed when this adjudication record was created. */
+    observation?: ObservationReceipt;
+    evidence: SuppressionCounterevidence[];
+    invalidateOn: {
+        targetContentChange: boolean;
+        detectorMajorChange: boolean;
+    };
+}
+interface FindingSuppression {
+    /** Stable finding id, for example SQABC123DEF456. */
+    id?: string;
+    /** Detector name, for example "twin-drift". */
+    check?: string;
+    /** Optional file path to narrow check-level suppressions. */
+    file?: string;
+    /** Human reason for accepting the finding. Required by config validation. */
+    reason: string;
+    /** ISO date after which the suppression no longer applies. */
+    expiresAt?: string;
+    /** ISO timestamp stamped when the suppression file was written. */
+    createdAt?: string;
+    /** Structured, mechanically adjudicated exception evidence. Omission is readable legacy policy, not automatic authority. */
+    decision?: SuppressionDecision;
+}
+interface SemanticConfig {
+    typescript?: TypeScriptSemanticConfig;
+    rust?: {
+        /** Optional rust-analyzer executable path/name for future semantic backend use. */
+        rustAnalyzerPath?: string;
+    };
+}
+interface TypeScriptSemanticConfig {
+    /** Explicit tsconfig paths, relative to project root unless absolute */
+    tsconfigs?: string[];
+}
+interface EntryRootsConfig {
+    /** Any symbol defined in these path prefixes is externally live */
+    pathPrefixes?: string[];
+    /** Any symbol defined in these exact files is externally live */
+    files?: string[];
+    /** Symbols matching these regular expressions are externally live */
+    symbolPatterns?: string[];
+    /** Qualified var names like my.ns/my-fn that are externally live */
+    qualifiedVars?: string[];
+}
+interface WatchConfig {
+    /** Enable file watching (default: false, must opt in) */
+    enabled?: boolean;
+    /** Ms to wait after the last file change before triggering reindex (default: 2000) */
+    debounceMs?: number;
+    /** Requested ms between reindex completions; values below 5000 use the 5000ms safety floor. */
+    cooldownMs?: number;
+    /** Ms between Git HEAD/index state checks (default: 2000) */
+    gitPollMs?: number;
+    /** Ms of clean inactivity before the background watcher exits; 0 keeps it running (default: 180000) */
+    idleTimeoutMs?: number;
+    /** Let project agent hooks refresh stale indexes without a live watch process (default: true) */
+    autoRefresh?: boolean;
+    /** Extra glob patterns to ignore beyond .gitignore */
+    ignore?: string[];
+    /** Rolling admission guard for automatic watcher rebuilds. */
+    resourceBudget?: WatchResourceBudgetConfig;
+}
+interface WatchResourceBudgetConfig {
+    /** Enable automatic rebuild admission limits (default: true). */
+    enabled?: boolean;
+    /** Rolling observation window in milliseconds (default: 900000 / 15 minutes). */
+    windowMs?: number;
+    /** Completed rebuilds allowed inside the window before automatic work pauses (default: 2). */
+    maxRebuilds?: number;
+    /** Estimated bytes written inside the window before automatic work pauses (default: 1 GiB). */
+    maxEstimatedWriteBytes?: number;
+}
+interface IndexerOverrides {
+    /** Enable pnpm workspace support (TypeScript) */
+    pnpmWorkspaces?: boolean;
+    /** TypeScript indexing strategy: one inferred project, or parallel workspace project roots */
+    projectMode?: TypeScriptProjectMode;
+    /** Explicit TypeScript project roots or tsconfig paths, relative to project root unless absolute */
+    projects?: string[];
+    /** Indexer-specific config file path, relative to project root */
+    configPath?: string;
+}
+
+export { isObservationReceipt as A, observationReceiptGenerationIdentity as B, type CodeBaseIQConfig as C, type DerivedObservationStateAuthority as D, observationReceiptStabilityLabel as E, observationReceiptWorkspaceIdentity as F, type ArchitectureConfig as G, type IndexerConfig as I, LEGACY_OBSERVATION_RECEIPT_SCHEMA_VERSION as L, type ObservationSourceKind as O, type ProjectConfig as P, type RelevantInputIdentity as R, type SupportedLanguage as S, type TypeScriptProjectMode as T, type WatchConfig as W, type WatchResourceBudgetConfig as a, type ObservationReceipt as b, type DecodedObservationReceipt as c, OBSERVATION_IDENTITY_CANONICALIZATION_VERSION as d, OBSERVATION_IDENTITY_HASH_ALGORITHM as e, OBSERVATION_IDENTITY_SCHEMA_VERSION as f, OBSERVATION_RECEIPT_SCHEMA_VERSION as g, OBSERVATION_STATE_AUTHORITY_POLICY_VERSION as h, type ObservationAuthorityKind as i, type ObservationComparedFact as j, type ObservationComparisonReason as k, type ObservationIdentity as l, type ObservationReceiptComparison as m, type ObservationReceiptV1 as n, type ObservationReceiptV2 as o, type ObservationRelationshipJudgment as p, type ObservationRelationshipState as q, type ObservationSourceFact as r, type ObservationStabilityProof as s, type ObservationStabilityProofKind as t, type ObservationStateAuthority as u, type RelevantInputRelationshipJudgment as v, compareObservationReceipts as w, createObservationIdentity as x, decodeObservationReceipt as y, deriveObservationStateAuthority as z };

package/dist/db-D7sauVFH.d.ts

@@ -0,0 +1,95 @@
+import Database from 'better-sqlite3';
+import { C as CodeBaseIQConfig } from './config-types-BNoC96J3.js';
+
+/**
+ * One retained publication of the compiler index. Its immutable paths and
+ * metadata bytes are the only companion evidence that may be combined with
+ * the open SQLite connection carrying this handle.
+ */
+interface SqliteGenerationHandle {
+    identity: string;
+    databasePath: string;
+    indexPath?: string;
+    metadataPath?: string;
+    metadataRaw?: string;
+    source: 'immutable' | 'legacy';
+    /** Internal race token for opening a legacy replaceable database path. */
+    databaseFileIdentity?: string;
+}
+
+/** The path-exclusion capability storage consumes from project source policy. */
+interface PathExclusionPolicy {
+    isIgnored(relativePath: string): boolean;
+}
+/** Read operations exposed by a prepared SQLite statement. */
+interface ScipPreparedReadStatement<BindParameters extends unknown[] = unknown[], Result = unknown> {
+    get(...params: BindParameters): Result | undefined;
+    all(...params: BindParameters): Result[];
+    iterate(...params: BindParameters): IterableIterator<Result>;
+    pluck(toggleState?: boolean): this;
+    expand(toggleState?: boolean): this;
+    raw(toggleState?: boolean): this;
+    bind(...params: BindParameters): this;
+    columns(): Database.ColumnDefinition[];
+    safeIntegers(toggleState?: boolean): this;
+}
+/** Query-only facade that cannot close or reconfigure the owned connection. */
+interface ScipDatabaseQueryPort {
+    prepare<BindParameters extends unknown[] = unknown[], Result = unknown>(source: string): ScipPreparedReadStatement<BindParameters, Result>;
+}
+/**
+ * Thin wrapper around better-sqlite3 with a pre-configured connection
+ * and helper methods for the SCIP SQLite schema.
+ *
+ * The schema is produced by `scip expt-convert` and is identical
+ * regardless of source language (TypeScript, Rust, Python, etc.).
+ *
+ * Tables:
+ *   documents             — indexed files (id, language, relative_path)
+ *   global_symbols        — all symbols (id, symbol, display_name, kind, documentation)
+ *   defn_enclosing_ranges — definition locations (document_id, symbol_id, start/end line/char)
+ *   mentions              — references & definitions (chunk_id, symbol_id, role)
+ *   chunks                — code segments (document_id, chunk_index, start/end line, occurrences)
+ */
+declare class ScipDatabase {
+    readonly db: ScipDatabaseQueryPort;
+    readonly config: CodeBaseIQConfig;
+    readonly generation: SqliteGenerationHandle;
+    private pathFilter;
+    private readonly connection;
+    private readonly connectionOwnership;
+    private statementCache;
+    private closed;
+    constructor(config: CodeBaseIQConfig, pathFilter?: PathExclusionPolicy);
+    /** Check if a path should be excluded based on .gitignore rules */
+    isIgnored(relativePath: string): boolean;
+    /**
+     * The local-symbol predicate: only match symbols that are defined
+     * in files NOT excluded by gitignore. This replaces the old hardcoded
+     * `NOT LIKE 'node_modules/%'` check.
+     *
+     * Since SQLite can't evaluate JS gitignore rules inline, we use a
+     * simpler approach: query broadly, then filter in JS. For queries
+     * that need SQL-level filtering, use excludedPathPatterns().
+     */
+    get localSymbolPredicate(): string;
+    /**
+     * SQL WHERE clause fragments to exclude common build/dependency paths.
+     * Complements the JS-level gitignore filtering for performance.
+     */
+    get pathExclusions(): string;
+    /** Reusable SQL fragment: filter out synthetic/internal symbol noise */
+    get symbolNoise(): string;
+    /** Build SQL path exclusions for one or more document table aliases */
+    pathExclusionsFor(...aliases: string[]): string;
+    /** Build SQL symbol exclusions for the given global_symbols alias */
+    symbolNoiseFor(alias: string): string;
+    /** Run a raw SQL query and return all rows */
+    all<T = Record<string, unknown>>(sql: string, ...params: unknown[]): T[];
+    /** Run a raw SQL query and return the first row */
+    get<T = Record<string, unknown>>(sql: string, ...params: unknown[]): T | undefined;
+    close(): void;
+    private statement;
+}
+
+export { ScipDatabase as S };

package/dist/direct-navigation-DP4LVMRX.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import{z as a}from"./chunk-KWVHSKHK.js";import"./chunk-UXM43C7T.js";import"./chunk-ECQBG7PW.js";import"./chunk-XZEE23VG.js";import"./chunk-G6XFR4ZL.js";import"./chunk-3JSXXYTZ.js";import"./chunk-DO6WQD2T.js";import"./chunk-2X7V4HS4.js";import"./chunk-SNNWPCN7.js";import"./chunk-B2OB55RR.js";export{a as directNavigationQueryCommandDescriptors};
+//# sourceMappingURL=direct-navigation-DP4LVMRX.js.map

package/dist/direct-navigation-FLUS3BT6.js

@@ -0,0 +1,2 @@
+import{z as a}from"./chunk-4FC325IF.js";import"./chunk-LTA3BRZX.js";import"./chunk-GTIYTDRE.js";import"./chunk-ZZ3MWF33.js";import"./chunk-NCZUNH3E.js";import"./chunk-YUKYB54I.js";import"./chunk-NNO6A2PO.js";import"./chunk-P5XHIJHI.js";import"./chunk-KUW32IRO.js";import"./chunk-5VKBFZZU.js";import"./chunk-7MGU3HPH.js";import"./chunk-FAJQ7LWY.js";import"./chunk-Z54RD7VL.js";import"./chunk-RU65DDUP.js";import"./chunk-QW7EP6WI.js";import"./chunk-3IER7Q6H.js";import"./chunk-FM5BPL4V.js";import"./chunk-DRENNWRG.js";import"./chunk-RDBI2RXU.js";import"./chunk-R2NOK63J.js";import"./chunk-EF2R3WNQ.js";import"./chunk-WE5RZHZ7.js";import"./chunk-2Q2LW5JW.js";export{a as directNavigationQueryCommandDescriptors};
+//# sourceMappingURL=direct-navigation-FLUS3BT6.js.map