codebaseiq 0.1.0

package/dist/queries/system-map.d.ts

@@ -0,0 +1,449 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import { F as FileKind } from '../file-kind-BKCVMNUf.js';
+import { B as BehaviorSignal, a as BoundarySourceScope, S as SystemMapNextAnchorPacket } from '../next-anchor-candidates-BwMczMvX.js';
+export { b as SystemMapNextAnchor, c as SystemMapNextAnchorAlternative } from '../next-anchor-candidates-BwMczMvX.js';
+import { c as SymbolResolutionCandidate } from '../symbol-types-BIQwfoAx.js';
+import { a as CalleeEvidenceSource } from '../call-graph-evidence-gNsxjCW8.js';
+import { E as ExplorationSourceLocation, b as ExplorationTopologyNode, c as ExplorationEvidenceSource, a as ExplorationEvidenceStrength, d as ExplorationTopology } from '../exploration-topology-BG4v30HZ.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+type ConnectedBehaviorStepRole = 'anchor' | 'connector' | 'junction';
+interface ConnectedBehaviorLine {
+    line: number;
+    endLine: number;
+    depth: number;
+    signals: BehaviorSignal[];
+    text: string;
+    copied: boolean;
+}
+interface ConnectedBehaviorSupportingDeclaration {
+    kind: 'compiler-referenced-declaration' | 'focused-causal-target' | 'return-value-transformer';
+    symbol: string;
+    label: string;
+    file: string;
+    line: number;
+    endLine: number;
+    text: string;
+}
+/**
+ * One source-faithful description of a selected construct. An outline accounts
+ * for every source statement; exact source is used when outlining would not
+ * save characters or the installed parser cannot build a faithful outline.
+ */
+interface ConnectedBehaviorRepresentation {
+    kind: 'connector-slice' | 'outline' | 'source';
+    constructKind: string;
+    signature: string;
+    lines: ConnectedBehaviorLine[];
+    coverage: {
+        sourceStatements: number;
+        representedStatements: number;
+        copiedStatements: number;
+        omittedStatements: number;
+    };
+    rawCharacters: number;
+    renderedCharacters: number;
+    supportingDeclarations?: ConnectedBehaviorSupportingDeclaration[];
+    omittedSupportingDeclarations?: Array<Omit<ConnectedBehaviorSupportingDeclaration, 'kind' | 'text'> & {
+        reason: 'source-too-large';
+    }>;
+}
+/** One selected repository construct or non-source junction in connector order. */
+interface ConnectedBehaviorStep {
+    id: string;
+    nodeId: string;
+    order: number;
+    role: ConnectedBehaviorStepRole;
+    kind: string;
+    label: string;
+    location: ExplorationTopologyNode['location'];
+    behavior: ConnectedBehaviorRepresentation | null;
+}
+/** One original directed graph edge connecting two returned behavior steps. */
+interface ConnectedBehaviorTransition {
+    id: string;
+    edgeId: string;
+    order: number;
+    kind: string;
+    fromStepId: string;
+    toStepId: string;
+    directed: true;
+    pathTraversal: 'forward' | 'reverse' | 'adjacent';
+    evidence: ExplorationEvidenceSource[];
+}
+interface ConnectedBehaviorPath {
+    id: string;
+    status: 'connected' | 'partial' | 'candidate';
+    stepIds: string[];
+    transitionIds: string[];
+}
+/**
+ * A connected behavior packet is a graph-ordered source explanation: selected
+ * constructs plus the exact relationships that make them one explored slice.
+ */
+interface ConnectedBehaviorPacket {
+    status: 'connected' | 'partial' | 'ambiguous' | 'unavailable';
+    steps: ConnectedBehaviorStep[];
+    transitions: ConnectedBehaviorTransition[];
+    paths: ConnectedBehaviorPath[];
+    coverage: {
+        candidateNodes: number;
+        returnedNodes: number;
+        omittedNodeIds: string[];
+        returnedTransitions: number;
+        withheldStatements: number;
+        requestedFocusLocations: ExplorationSourceLocation[];
+        matchedFocusLocations: ExplorationSourceLocation[];
+        unmatchedFocusLocations: ExplorationSourceLocation[];
+    };
+    behaviorCommand: string | null;
+    exactSourceCommand: string | null;
+}
+interface ConnectedBehaviorOptions {
+    /** Soft limit: matched anchors and nodes on an anchor-connector path are never omitted. */
+    maxSteps?: number;
+    /** Exact source locations that should focus behavior inside otherwise-large selected constructs. */
+    focusLocations?: readonly ExplorationSourceLocation[];
+}
+
+type SystemMapRelationKind = 'call' | 'contract-symbol' | 'import' | 'reference' | 'runtime-boundary';
+
+type SystemMapAnchorKind = 'literal' | 'symbol';
+type SystemMapAnchorStatus = 'matched' | 'ambiguous' | 'missing';
+
+type SystemMapEvidenceFloor = 'exact' | 'derived';
+type SystemMapSourceScope = BoundarySourceScope;
+type SystemMapReferenceScope = 'none' | 'all' | 'forward-regions' | 'cross-workspace-or-forward';
+type SystemMapRelationEvidence = CalleeEvidenceSource | 'ast-constructed-member-callsite' | 'ast-factory-callback-callsite' | 'ast-service-member-callsite' | 'ast-member-import-candidate' | 'scip-occurrence-callsite' | 'scip-occurrence-reference' | 'compiler-cross-workspace-symbol' | 'indexed-or-source-reference' | 'indexed-or-source-import' | `runtime-boundary:${string}`;
+type SystemMapRelationStrength = ExplorationEvidenceStrength;
+
+interface SystemMapOptions {
+    searches?: readonly string[];
+    symbols?: readonly string[];
+    behaviorFocusLocations?: readonly {
+        file: string;
+        line: number;
+    }[];
+    maxDepth?: number;
+    expand?: readonly string[];
+    relations?: readonly SystemMapRelationKind[];
+    evidenceFloor?: SystemMapEvidenceFloor;
+    sourceScopes?: readonly SystemMapSourceScope[];
+    maxTopologyCharacters?: number;
+    topologyFrontiers?: readonly string[];
+    /** Stable upstream route IDs to materialize together. */
+    routeIds?: readonly string[];
+    fullLiteralTraversal?: boolean;
+    /** @deprecated Accepted as a no-op; query vocabulary no longer affects graph selection. */
+    selectionTerms?: readonly string[];
+}
+interface SystemMapAnchorCandidate extends SymbolResolutionCandidate {
+    endLine: number;
+}
+interface SystemMapAnchor {
+    kind: SystemMapAnchorKind;
+    query: string;
+    status: SystemMapAnchorStatus;
+    matchedRegionIds: string[];
+    matchingLines?: number;
+    /** Matches actually materialized as graph traversal seeds. */
+    seedMatchingLines?: number;
+    /** Embedded-substring and out-of-scope matches that are not traversal eligible. */
+    matchOnlyLines?: number;
+    /** Matches eligible to seed traversal before a broad-selector guard is applied. */
+    eligibleSeedMatchingLines?: number;
+    materializedMatchingLines?: number;
+    withheldMatchingLines?: number;
+    literalTraversal?: 'materialized' | 'withheld-broad';
+    representativeMatches?: SystemMapLiteralHit[];
+    narrowingCommands?: string[];
+    exhaustiveTraversalCommand?: string;
+    seedRegionIds?: string[];
+    matchOnlyRegionIds?: string[];
+    symbolCandidates?: SystemMapAnchorCandidate[];
+    totalSymbolCandidates?: number;
+    omittedSymbolCandidates?: number;
+}
+interface SystemMapLiteralHit {
+    query: string;
+    file: string;
+    line: number;
+    ownerSymbol: string | null;
+    ownerShortName: string | null;
+    ownerStartLine?: number | null;
+    ownerEndLine?: number | null;
+    sourceLine: string;
+    matchKind?: 'exact-value' | 'boundary' | 'embedded';
+    traversalSeed?: boolean;
+}
+interface SystemMapFile {
+    file: string;
+    kind: FileKind;
+    depth: number;
+    origins: string[];
+}
+interface SystemMapSymbol {
+    symbol: string;
+    shortName: string;
+    file: string;
+    startLine: number;
+    endLine: number;
+    depth: number;
+    origins: string[];
+    anchorQueries: string[];
+    referenceExpansion: boolean;
+    referenceScope: SystemMapReferenceScope;
+}
+interface SystemMapRelation {
+    kind: SystemMapRelationKind;
+    evidence: SystemMapRelationEvidence;
+    fromRegionId: string;
+    fromFile: string;
+    fromSymbol: string | null;
+    toRegionId: string;
+    toFile: string;
+    toSymbol: string | null;
+    /** Source-backed runtime participant used when this endpoint has no compiler symbol. */
+    fromBoundaryParticipant?: SystemMapBoundaryParticipant;
+    /** Source-backed runtime participant used when this endpoint has no compiler symbol. */
+    toBoundaryParticipant?: SystemMapBoundaryParticipant;
+    /** Exact source callable used when this endpoint has no compiler symbol. */
+    fromSourceConstruct?: SystemMapSourceConstruct;
+    /** Exact source callable used when this endpoint has no compiler symbol. */
+    toSourceConstruct?: SystemMapSourceConstruct;
+    /** Exact normalized rendezvous key that joined the runtime participants. */
+    runtimeBoundaryKey?: string;
+    line: number | null;
+    /** Present in results produced by schema version 1 topology-aware builds. */
+    strength?: SystemMapRelationStrength;
+}
+/** One parser-delimited callable that is absent from the compiler symbol catalog. */
+interface SystemMapSourceConstruct {
+    file: string;
+    name: string;
+    startLine: number;
+    endLine: number;
+}
+/** One exact producer or consumer observation at a runtime crossing. */
+interface SystemMapBoundaryParticipant {
+    observationId: string;
+    action: string;
+    protocol: string;
+    role: string;
+    /** Stable, source-derived key parts that distinguish operations sharing one owner file. */
+    address?: string;
+    file: string;
+    line: number;
+    endLine: number;
+    ownerName: string | null;
+    ownerSymbol: string | null;
+}
+interface SystemMapRegionRelation {
+    fromRegionId: string;
+    toRegionId: string;
+    kinds: SystemMapRelationKind[];
+    relationCount: number;
+    fromFiles: string[];
+    toFiles: string[];
+    fromSymbols: string[];
+    toSymbols: string[];
+    evidence: SystemMapRelationEvidence[];
+    /** Present in results produced by schema version 1 topology-aware builds. */
+    strengths?: SystemMapRelationStrength[];
+}
+interface SystemMapExternalBoundary {
+    kind: 'external-import';
+    name: string;
+    fromRegionIds: string[];
+    fromFiles: string[];
+}
+interface SystemMapBoundaryFrontier {
+    observationId: string;
+    action: string;
+    strength: 'exact' | 'derived' | 'candidate';
+    file: string;
+    line: number;
+    ownerShortName: string | null;
+    address: string;
+    reason: string;
+    /** Exact observation context retained even when its runtime peer is unresolved. */
+    protocol?: string;
+    role?: string;
+    modality?: 'must' | 'may' | 'unknown';
+    resolution?: 'locally-linked' | 'external' | 'unresolved' | 'ambiguous';
+    sourceScope?: BoundarySourceScope;
+    keyParts?: Array<{
+        name: string;
+        value: string;
+        evidence: string;
+    }>;
+}
+interface SystemMapNotableSymbol {
+    shortName: string;
+    file: string;
+    origins: string[];
+}
+interface SystemMapRegion {
+    id: string;
+    label: string;
+    workspace: string;
+    structuralPath: string;
+    minDepth: number;
+    fileCount: number;
+    sourceFileCount: number;
+    testFileCount: number;
+    symbolCount: number;
+    literalHitCount: number;
+    anchorQueries: string[];
+    relationKinds: SystemMapRelationKind[];
+    incomingRegionIds: string[];
+    outgoingRegionIds: string[];
+    memberCallCandidateRelationCount: number;
+    notableSymbols: SystemMapNotableSymbol[];
+    omittedNotableSymbols: number;
+    expanded: boolean;
+    files: SystemMapFile[];
+    symbols: SystemMapSymbol[];
+    literalHits: SystemMapLiteralHit[];
+    relations: SystemMapRelation[];
+}
+interface SystemMapDrilldownAnchor {
+    kind: 'symbol' | 'literal';
+    regionId: string;
+    file: string;
+    line: number;
+    endLine: number | null;
+    label: string;
+}
+interface SystemMapDrilldown {
+    command: string | null;
+    definitionCommand: string | null;
+    candidateAnchors: number;
+    selectedAnchors: number;
+    omittedAnchors: number;
+    anchors: SystemMapDrilldownAnchor[];
+}
+interface SystemMapExpansion {
+    command: string | null;
+    regionCount: number;
+    regionIds: string[];
+    candidateRegionCount?: number;
+    omittedRegionIds?: string[];
+}
+/** The bounded human topology view; the structured result still retains every region and relation. */
+interface SystemMapPresentation {
+    maxCharacters: number;
+    estimatedCharacters: number;
+    totalEstimatedCharacters: number;
+    regionIds: string[];
+    omittedRegionIds: string[];
+    relationKeys: string[];
+    omittedRelations: number;
+    complete: boolean;
+    expansionCommand: string | null;
+}
+interface SystemMapRelationFamilyCoverage {
+    evidence: 'compiler-graph' | 'exact-source' | 'mixed';
+    scope: string;
+    completeWithinScope: true;
+}
+interface SystemMapCoverage {
+    explicitAnchorCount: number;
+    requestedRelationKinds: SystemMapRelationKind[];
+    evidenceFloor: SystemMapEvidenceFloor;
+    includedSourceScopes: BoundarySourceScope[];
+    matchedAnchorCount: number;
+    literalSearchesComplete: true;
+    broadLiteralAnchors?: number;
+    withheldLiteralMatches?: number;
+    symbolCandidateSetsComplete: boolean;
+    omittedSymbolCandidates: number;
+    maxTraversalDepth: number;
+    frontierSymbols: number;
+    frontierFiles: number;
+    supportFilesNotTraversed: number;
+    filteredUnverifiedCallEdges: number;
+    memberCallCandidateEdges: number;
+    unresolvedMemberCallsites: number;
+    runtimeBoundaryEvidenceAvailable: boolean;
+    runtimeBoundaryObservations: number;
+    runtimeBoundaryExactLinks: number;
+    runtimeBoundaryDerivedLinks: number;
+    runtimeBoundaryCandidateLinks: number;
+    repositoryRuntimeBoundaryExactLinks: number;
+    repositoryRuntimeBoundaryDerivedLinks: number;
+    repositoryRuntimeBoundaryCandidateLinks: number;
+    runtimeBoundaryTraversedLinks: number;
+    runtimeBoundaryFrontiers: number;
+    referenceExpansionEligibleSymbols: number;
+    referenceExpansionSkippedSymbols: number;
+    dynamicDispatchRepresented: boolean;
+    runtimeGeneratedLinksRepresented: boolean;
+    regionBoundariesAreStructural: true;
+    relationFamilies: Record<SystemMapRelationKind | 'literal-anchor', SystemMapRelationFamilyCoverage>;
+    blindSpots: string[];
+}
+/** Accounting for the declared query, not a claim that the English task is globally understood. */
+interface SystemMapQueryClosure {
+    status: 'accounted' | 'incomplete';
+    emitted: {
+        regions: number;
+        relations: number;
+        runtimeLinks: number;
+    };
+    withheld: {
+        symbols: number;
+        files: number;
+        regions: number;
+        drillAnchors: number;
+        literalMatches?: number;
+    };
+    ambiguous: {
+        anchors: number;
+        omittedSymbolCandidates: number;
+    };
+    external: number;
+    unresolved: number;
+    explanation: string;
+}
+interface SystemMapResult {
+    anchors: SystemMapAnchor[];
+    regions: SystemMapRegion[];
+    regionRelations: SystemMapRegionRelation[];
+    externalBoundaries: SystemMapExternalBoundary[];
+    boundaryFrontiers: SystemMapBoundaryFrontier[];
+    unmatchedExpansions: string[];
+    expansion?: SystemMapExpansion;
+    drilldown?: SystemMapDrilldown;
+    presentation: SystemMapPresentation;
+    /** Additive universal graph contract; absent only in results serialized by older builds. */
+    topology?: ExplorationTopology;
+    /** Graph-ordered constructs and the evidence-bearing transitions between them. */
+    behavior?: ConnectedBehaviorPacket;
+    /** Structurally important callable targets not yet materialized in behavior. */
+    nextAnchors?: SystemMapNextAnchorPacket;
+    closure: SystemMapQueryClosure;
+    coverage: SystemMapCoverage;
+}
+/**
+ * Build a layered repository map from explicit literal and symbol anchors.
+ *
+ * The query does not infer a feature or system from English. It preserves all
+ * supplied anchor matches, follows named compiler/source evidence families,
+ * and exposes traversal and runtime blind spots in the result.
+ */
+declare function systemMap(db: ScipDatabase, opts: SystemMapOptions): SystemMapResult;
+/**
+ * Build only the canonical typed topology for an explicit system-map request.
+ *
+ * Unlike {@link systemMap}, this operation does not materialize connected
+ * behavior, causal corridors, adjacent-recovery candidates, legacy
+ * presentation, or expansion commands. Canonical graph projections use this
+ * seam so compatibility-only presentation work cannot leak into their cost or
+ * semantics.
+ */
+declare function systemMapTopology(db: ScipDatabase, opts: SystemMapOptions): ExplorationTopology;
+declare function systemMapRegionRelationKey(relation: Pick<SystemMapRegionRelation, 'fromRegionId' | 'toRegionId'>): string;
+
+export { type ConnectedBehaviorLine, type ConnectedBehaviorOptions, type ConnectedBehaviorPacket, type ConnectedBehaviorPath, type ConnectedBehaviorRepresentation, type ConnectedBehaviorStep, type ConnectedBehaviorStepRole, type ConnectedBehaviorTransition, type SystemMapAnchor, type SystemMapAnchorCandidate, type SystemMapAnchorKind, type SystemMapAnchorStatus, type SystemMapBoundaryFrontier, type SystemMapBoundaryParticipant, type SystemMapCoverage, type SystemMapDrilldown, type SystemMapDrilldownAnchor, type SystemMapEvidenceFloor, type SystemMapExpansion, type SystemMapExternalBoundary, type SystemMapFile, type SystemMapLiteralHit, SystemMapNextAnchorPacket, type SystemMapNotableSymbol, type SystemMapOptions, type SystemMapPresentation, type SystemMapQueryClosure, type SystemMapReferenceScope, type SystemMapRegion, type SystemMapRegionRelation, type SystemMapRelation, type SystemMapRelationEvidence, type SystemMapRelationFamilyCoverage, type SystemMapRelationKind, type SystemMapRelationStrength, type SystemMapResult, type SystemMapSourceConstruct, type SystemMapSourceScope, type SystemMapSymbol, systemMap, systemMapRegionRelationKey, systemMapTopology };

package/dist/queries/system-map.js

@@ -0,0 +1,2 @@
+import{a,b,c}from"../chunk-MOVBWNIP.js";import"../chunk-MVB3DAEY.js";import"../chunk-YSNONTJ2.js";import"../chunk-QHRNXP3C.js";import"../chunk-L57ZKWVG.js";import"../chunk-SMRBZ6EC.js";import"../chunk-JEJLSICM.js";import"../chunk-FQKZWM4L.js";import"../chunk-VE5AVNMP.js";import"../chunk-7FND7D7N.js";import"../chunk-BGBBVSH4.js";import"../chunk-JOIRNPPY.js";import"../chunk-6CS3UQTN.js";import"../chunk-P5XHIJHI.js";import"../chunk-J77SU6VA.js";import"../chunk-UCD3H3UZ.js";import"../chunk-CVYSU6BX.js";import"../chunk-ELNRLMC5.js";import"../chunk-UZGZB3VB.js";import"../chunk-ZKX2FRS6.js";import"../chunk-C7QOQX32.js";import"../chunk-TIIC3ZE7.js";import"../chunk-YUKYB54I.js";import"../chunk-OANDYLJQ.js";import"../chunk-NNOKTMZT.js";import"../chunk-SGX43S2L.js";import"../chunk-FETNQCFO.js";import"../chunk-O6QTXQPJ.js";import"../chunk-ADTBPVUZ.js";import"../chunk-BMYOV5GP.js";import"../chunk-CWONGW6P.js";import"../chunk-3LCDIREB.js";import"../chunk-NNJ2KZZG.js";export{a as systemMap,c as systemMapRegionRelationKey,b as systemMapTopology};
+//# sourceMappingURL=system-map.js.map

package/dist/queries/system.d.ts

@@ -0,0 +1,21 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import { SymbolResult } from './symbols.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface SystemResult {
+    files: string[];
+    symbols: SymbolResult[];
+    dependsOn: string[];
+    dependedOnBy: string[];
+}
+/** Full system map for a module path: files, symbols, deps in/out.
+ *
+ * Exported-symbol ranges come from getDefinitionsForFile so they are
+ * source-corrected and match `scip symbols` output.
+ */
+declare function system(db: ScipDatabase, modulePattern: string): SystemResult;
+/** One-hop module summary; this does not infer a repository subsystem boundary. */
+declare function moduleMap(db: ScipDatabase, modulePattern: string): SystemResult;
+
+export { type SystemResult, moduleMap, system };

package/dist/queries/system.js

@@ -0,0 +1,2 @@
+import{a,b}from"../chunk-GCHRX4YW.js";import"../chunk-GW6Z3WGY.js";import"../chunk-GTXSJDCO.js";import"../chunk-UZGZB3VB.js";import"../chunk-NNOKTMZT.js";import"../chunk-FETNQCFO.js";import"../chunk-O6QTXQPJ.js";import"../chunk-ADTBPVUZ.js";import"../chunk-BMYOV5GP.js";import"../chunk-CWONGW6P.js";import"../chunk-3LCDIREB.js";import"../chunk-NNJ2KZZG.js";export{b as moduleMap,a as system};
+//# sourceMappingURL=system.js.map

package/dist/queries/test-quality.d.ts

@@ -0,0 +1,56 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+/**
+ * test-quality (D3): the biggest uncovered surface — test files are not
+ * SCIP-indexed (house convention), so this detector works entirely from the
+ * source-facts layer (raw source text + `classifyFile`'s test-file
+ * classification), never the graph. Three independently reportable
+ * sub-checks:
+ *  - assertion-free: `it`/`test` bodies with no reachable assertion call.
+ *  - skipped: `it.skip`/`describe.skip`/`xit`/`.todo` inventory with
+ *    git-blame age on the skip line.
+ *  - mock-echo: a test asserting the same literal it stubbed into a mock.
+ */
+type AssertionFreeSeverity = 'high' | 'low';
+type SkippedTestKind = 'skip' | 'todo';
+type SkipRot = 'rot' | 'workflow' | 'unknown';
+interface AssertionFreeFinding {
+    file: string;
+    startLine: number;
+    endLine: number;
+    title: string;
+    severity: AssertionFreeSeverity;
+}
+interface SkippedTestFinding {
+    file: string;
+    startLine: number;
+    title: string;
+    skipKind: SkippedTestKind;
+    blockKind: 'it' | 'test' | 'describe';
+    ageDays: number | null;
+    rot: SkipRot;
+}
+interface MockEchoFinding {
+    file: string;
+    startLine: number;
+    endLine: number;
+    title: string;
+    echoedValue: string;
+}
+interface TestQualityReport {
+    assertionFree: AssertionFreeFinding[];
+    skipped: SkippedTestFinding[];
+    mockEcho: MockEchoFinding[];
+}
+interface TestQualityOptions {
+    scope?: string;
+    limit?: number;
+    scanLimit?: number;
+    /** Skips older than this many days are reported as 'rot' rather than 'workflow'. Default 60. */
+    rotDays?: number;
+}
+declare function testQuality(db: ScipDatabase, opts?: TestQualityOptions): TestQualityReport;
+
+export { type AssertionFreeFinding, type AssertionFreeSeverity, type MockEchoFinding, type SkipRot, type SkippedTestFinding, type SkippedTestKind, type TestQualityOptions, type TestQualityReport, testQuality };

package/dist/queries/test-quality.js

@@ -0,0 +1,2 @@
+import{a}from"../chunk-UNBY47BC.js";import"../chunk-4WKDMDEW.js";import"../chunk-B75HZHUP.js";import"../chunk-BGBBVSH4.js";import"../chunk-P5XHIJHI.js";import"../chunk-C7QOQX32.js";import"../chunk-TIIC3ZE7.js";import"../chunk-YUKYB54I.js";import"../chunk-OANDYLJQ.js";import"../chunk-NNOKTMZT.js";import"../chunk-FETNQCFO.js";import"../chunk-O6QTXQPJ.js";import"../chunk-ADTBPVUZ.js";import"../chunk-BMYOV5GP.js";import"../chunk-CWONGW6P.js";import"../chunk-3LCDIREB.js";import"../chunk-NNJ2KZZG.js";export{a as testQuality};
+//# sourceMappingURL=test-quality.js.map

package/dist/queries/trace.d.ts

@@ -0,0 +1,68 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+interface TraceResult {
+    definitions: Array<{
+        relativePath: string;
+        startLine: number;
+        endLine: number;
+        signature: string | null;
+        source: string | null;
+    }>;
+    referencedBy: Array<{
+        relativePath: string;
+        line: number;
+        enclosingSymbol: string | null;
+        enclosingShort: string;
+    }>;
+}
+interface TraceEvidenceResult {
+    definitions: TraceResult['definitions'];
+    referencedBy: Array<TraceResult['referencedBy'][number] & {
+        sourceStartLine: number | null;
+        sourceEndLine: number | null;
+        source: string | null;
+    }>;
+}
+type TraceReferenceProvenance = 'source-attribution' | 'scip-reference-chunk';
+type TraceReferenceSourceKind = 'complete-call-expression' | 'non-call-reference' | 'bounded-context' | 'unavailable';
+interface TraceReferenceEvidence {
+    relativePath: string;
+    line: number;
+    provenance: TraceReferenceProvenance;
+    sourceKind: TraceReferenceSourceKind;
+}
+interface QualifiedTraceEvidenceResult extends TraceEvidenceResult {
+    referenceEvidence: TraceReferenceEvidence[];
+    claimSupport: TraceClaimSupport | null;
+}
+type TraceClaimEligibility = {
+    status: 'eligible';
+    scope: string;
+    limitations: string[];
+} | {
+    status: 'ineligible';
+    scope: string;
+    reason: string;
+    followup: string | null;
+};
+interface TraceClaimSupport {
+    referenceAbsence: TraceClaimEligibility;
+    callsitePredicates: TraceClaimEligibility;
+}
+declare function trace(db: ScipDatabase, symbolPattern: string, opts?: {
+    semantic?: boolean;
+}): TraceResult;
+/** Trace a symbol and include bounded source around each reference. */
+declare function traceEvidence(db: ScipDatabase, symbolPattern: string, opts?: {
+    semantic?: boolean;
+    referenceContext?: number;
+}): TraceEvidenceResult;
+/** Trace a symbol with explicit metadata governing which claims its source can support. */
+declare function qualifiedTraceEvidence(db: ScipDatabase, symbolPattern: string, opts?: {
+    semantic?: boolean;
+    referenceContext?: number;
+}): QualifiedTraceEvidenceResult;
+
+export { type QualifiedTraceEvidenceResult, type TraceClaimEligibility, type TraceClaimSupport, type TraceEvidenceResult, type TraceReferenceEvidence, type TraceReferenceProvenance, type TraceReferenceSourceKind, type TraceResult, qualifiedTraceEvidence, trace, traceEvidence };

package/dist/queries/trace.js

@@ -0,0 +1,2 @@
+import{a,b,c}from"../chunk-ID63777H.js";import"../chunk-PTAWHLVJ.js";import"../chunk-YSNONTJ2.js";import"../chunk-JEJLSICM.js";import"../chunk-JOIRNPPY.js";import"../chunk-6CS3UQTN.js";import"../chunk-P5XHIJHI.js";import"../chunk-UCD3H3UZ.js";import"../chunk-CVYSU6BX.js";import"../chunk-ELNRLMC5.js";import"../chunk-UZGZB3VB.js";import"../chunk-ZKX2FRS6.js";import"../chunk-TIIC3ZE7.js";import"../chunk-NNOKTMZT.js";import"../chunk-FETNQCFO.js";import"../chunk-O6QTXQPJ.js";import"../chunk-ADTBPVUZ.js";import"../chunk-BMYOV5GP.js";import"../chunk-CWONGW6P.js";import"../chunk-3LCDIREB.js";import"../chunk-NNJ2KZZG.js";export{c as qualifiedTraceEvidence,a as trace,b as traceEvidence};
+//# sourceMappingURL=trace.js.map

package/dist/queries/twin-ab.d.ts

@@ -0,0 +1,66 @@
+import { S as ScipDatabase } from '../db-D7sauVFH.js';
+import 'better-sqlite3';
+import '../config-types-BNoC96J3.js';
+
+/**
+ * twin-ab (Q4): mechanical support for the cleanup integrity scenario
+ * ("cross-examine same-concept twins" — feed both the same input and
+ * require the same answer). v1 is a scaffold generator, not an executor:
+ * generating realistic inputs for arbitrary types is a rabbit hole, so this
+ * resolves both referents, verifies they are callable and importable, and
+ * emits a ready-to-fill vitest file — the agent fills the input table and
+ * runs it.
+ */
+interface TwinAbSymbol {
+    ref: string;
+    symbol: string;
+    shortName: string;
+    file: string;
+    startLine: number;
+    /** Cleaned SCIP signature text (e.g. `(value: string): string`); null when the index has none. */
+    signature: string | null;
+    /** Top-level parameter count parsed from `signature`; null when unparseable. */
+    paramCount: number | null;
+}
+interface TwinAbSuccess {
+    ok: true;
+    a: TwinAbSymbol;
+    b: TwinAbSymbol;
+    /** Null when either side's param count is unknown — compatibility cannot be judged. */
+    signatureCompatible: boolean | null;
+    testSource: string;
+}
+interface TwinAbRefusal {
+    ok: false;
+    reason: string;
+}
+type TwinAbOutcome = TwinAbSuccess | TwinAbRefusal;
+interface TwinAbOptions {
+    refA: string;
+    refB: string;
+    /** Absolute path used to derive import specifiers in the generated test. */
+    outFile: string;
+}
+/**
+ * Project-root-relative default `--out` path when the caller doesn't pass
+ * one — a deterministic, ref-derived path under a dedicated generated-
+ * artifacts directory, mirroring `tla scaffold`'s convention of a fixed
+ * project-relative directory (`specs/<moduleName>`) rather than an OS tmp
+ * dir. Derived from the raw ref strings (not the resolved symbols) so the
+ * caller can compute it before resolution — `twinAb` needs the output path
+ * up front to compute import specifiers.
+ */
+declare function defaultTwinAbOutPath(refA: string, refB: string): string;
+/**
+ * `outFile` is the absolute path the caller intends to write the generated
+ * vitest file to — needed up front so the generated `import` specifiers are
+ * correct relative paths, not just the twin's own file paths.
+ */
+declare function twinAb(db: ScipDatabase, options: TwinAbOptions): TwinAbOutcome;
+/**
+ * @deprecated Use `twinAb(db, { refA, refB, outFile })` so symbol references
+ * cannot be transposed with the output path.
+ */
+declare function twinAb(db: ScipDatabase, refA: string, refB: string, outFile: string): TwinAbOutcome;
+
+export { type TwinAbOptions, type TwinAbOutcome, type TwinAbRefusal, type TwinAbSuccess, type TwinAbSymbol, defaultTwinAbOutPath, twinAb };