codebaseiq 0.1.0

package/dist/exploration-topology-BG4v30HZ.d.ts

@@ -0,0 +1,256 @@
+/**
+ * A repository location is a source-backed place that another query can
+ * retrieve exactly. A null location means the evidence identifies a
+ * repository relationship but the installed index does not retain one
+ * authoritative source line for that relationship.
+ */
+interface ExplorationSourceLocation {
+    file: string;
+    line: number;
+    endLine?: number;
+}
+type ExplorationEvidenceStrength = 'exact' | 'derived' | 'candidate' | 'mixed' | 'unknown';
+type ExplorationDisposition = 'emitted' | 'folded' | 'excluded' | 'unsupported';
+type ExplorationAnchorStatus = 'matched' | 'ambiguous' | 'missing';
+/**
+ * The closed semantic families used to explain program relationships without
+ * baking language or framework vocabulary into the universal graph contract.
+ */
+declare const PROGRAM_EDGE_FAMILIES: readonly ["identity", "contract", "control", "data", "state", "temporal"];
+type ProgramEdgeFamily = (typeof PROGRAM_EDGE_FAMILIES)[number];
+/** Context that qualifies a semantic relationship without changing its family. */
+interface ProgramEdgeSemanticContext {
+    crossesRuntimeBoundary?: true;
+    protocol?: string;
+    runtimeKey?: string;
+    process?: string;
+    transaction?: string;
+    synchronizationScope?: string;
+}
+type ProgramEdgeSemanticAttribute = string | number | boolean | null;
+/** One primitive interpretation of an existing evidenced topology edge. */
+interface ProgramEdgeSemantic {
+    family: ProgramEdgeFamily;
+    subtype: string;
+    context?: ProgramEdgeSemanticContext;
+    /** Evidence-specific values that qualify this primitive relationship. */
+    attributes?: Record<string, ProgramEdgeSemanticAttribute>;
+}
+interface ProgramEdgeFamilyInventory {
+    sourceEdges: number;
+    projectedEdges: number;
+    subtypes: string[];
+}
+/** Diagnostic accounting for semantic coverage of one topology packet. */
+interface ProgramEdgeInventory {
+    sourceEdges: number;
+    mappedSourceEdges: number;
+    projectedEdges: number;
+    unmappedSourceEdges: number;
+    unsupportedSourceEdges: number;
+    unmappedKinds: string[];
+    families: Record<ProgramEdgeFamily, ProgramEdgeFamilyInventory>;
+}
+/**
+ * A completion status names what one repository query established, never
+ * whether the agent has finished the user's task. Selection completion covers
+ * requested units, connector completion covers proved paths between anchors,
+ * frontier accounting covers reversible withheld directions, and incomplete
+ * coverage means at least one required identity or direction remains unknown.
+ */
+type ExplorationCompletionStatus = 'selection-complete' | 'connector-complete' | 'frontier-accounted' | 'coverage-incomplete';
+interface ExplorationCompletion {
+    status: ExplorationCompletionStatus;
+    scope: string;
+    explanation: string;
+}
+/** One independently inspectable basis for a graph relationship. */
+interface ExplorationEvidenceSource {
+    method: string;
+    strength: ExplorationEvidenceStrength;
+    identity: string | null;
+    location: ExplorationSourceLocation | null;
+}
+/**
+ * An anchor records how an explicit query term was tied to repository units.
+ * Candidate identities remain separate from matched identities so ambiguity
+ * is never silently converted into a graph fact.
+ */
+interface ExplorationTopologyAnchor {
+    id: string;
+    kind: string;
+    query: string;
+    status: ExplorationAnchorStatus;
+    nodeIds: string[];
+    candidateNodeIds: string[];
+    omittedCandidates: number;
+}
+/** A node is one repository unit at the resolution chosen by the producer. */
+interface ExplorationTopologyNode {
+    id: string;
+    kind: string;
+    label: string;
+    disposition: ExplorationDisposition;
+    location: ExplorationSourceLocation | null;
+    anchorIds: string[];
+    attributes: Record<string, string | number | boolean | null>;
+}
+/** An edge is one directed, evidenced relationship between two nodes. */
+interface ExplorationTopologyEdge {
+    id: string;
+    kind: string;
+    fromNodeId: string;
+    toNodeId: string;
+    directed: true;
+    disposition: ExplorationDisposition;
+    evidence: ExplorationEvidenceSource[];
+    /** Additive semantic projection; absent means this producer has not mapped the edge yet. */
+    semantics?: ProgramEdgeSemantic[];
+}
+/** A path records a proved or still-partial connection between explicit anchors. */
+interface ExplorationTopologyPath {
+    id: string;
+    fromAnchorId: string;
+    toAnchorId: string;
+    status: 'connected' | 'partial' | 'candidate';
+    nodeIds: string[];
+    edgeIds: string[];
+}
+/**
+ * A frontier group is an accounted direction that the current packet did not
+ * materialize. Its exact members make folding reversible without pretending
+ * that those members were inspected.
+ */
+interface ExplorationFrontierGroup {
+    id: string;
+    kind: string;
+    direction: 'incoming' | 'outgoing' | 'undirected' | 'unresolved';
+    fromNodeIds: string[];
+    edgeIds: string[];
+    memberNodeIds: string[];
+    memberCount: number;
+    disposition: 'folded' | 'excluded' | 'unsupported';
+    reason: string;
+    expansion: string | null;
+}
+interface ExplorationDispositionCounts {
+    total: number;
+    emitted: number;
+    folded: number;
+    excluded: number;
+    unsupported: number;
+}
+/**
+ * Coverage accounts for the declared query scope. It does not claim that the
+ * producer understood the user's English goal or represented dynamic runtime
+ * behavior that its installed analyzers cannot observe.
+ */
+interface ExplorationTopologyCoverage {
+    status: 'accounted' | 'incomplete';
+    scope: string;
+    nodes: ExplorationDispositionCounts;
+    edges: ExplorationDispositionCounts;
+    matchedAnchors: number;
+    ambiguousAnchors: number;
+    missingAnchors: number;
+    omittedCandidates: number;
+    frontierGroups: number;
+    /** Additive semantic inventory; absent on topology values produced before semantic projection. */
+    programEdges?: ProgramEdgeInventory;
+    blindSpots: string[];
+    explanation: string;
+}
+interface ExplorationTopology {
+    schemaVersion: 1;
+    anchors: ExplorationTopologyAnchor[];
+    nodes: ExplorationTopologyNode[];
+    edges: ExplorationTopologyEdge[];
+    paths: ExplorationTopologyPath[];
+    frontiers: ExplorationFrontierGroup[];
+    coverage: ExplorationTopologyCoverage;
+    completion?: ExplorationCompletion;
+    /** Optional proved anchor-to-outcome closure used by system-map rendering. */
+    corridor?: ExplorationCausalCorridor;
+    /** Additive catalogue of proved upstream routes available for explicit selection. */
+    routeCatalog?: ExplorationRouteCatalog;
+}
+interface ExplorationTopologyInput {
+    anchors: readonly ExplorationTopologyAnchor[];
+    nodes: readonly ExplorationTopologyNode[];
+    edges: readonly ExplorationTopologyEdge[];
+    paths?: readonly ExplorationTopologyPath[];
+    frontiers?: readonly ExplorationFrontierGroup[];
+    scope: string;
+    blindSpots?: readonly string[];
+    incompleteReasons?: readonly string[];
+    routeCatalog?: ExplorationRouteCatalog;
+}
+type CausalCorridorStatus = 'complete' | 'incomplete';
+interface CausalCorridorCoverage {
+    protectedNodes: number;
+    protectedEdges: number;
+    baseNodes: number;
+    baseEdges: number;
+    accountedFrontiers: number;
+    unresolvedFrontiers: number;
+    unresolvedEdges: number;
+}
+/**
+ * A causal corridor is the proved subgraph from explicit anchors to mechanical
+ * outcomes, closed over the facts required to interpret that path without
+ * guessing from names or repository vocabulary.
+ */
+interface ExplorationCausalCorridor {
+    schemaVersion: 1;
+    status: CausalCorridorStatus;
+    startNodeIds: string[];
+    outcomeNodeIds: string[];
+    baseNodeIds: string[];
+    baseEdgeIds: string[];
+    nodeIds: string[];
+    edgeIds: string[];
+    accountedFrontierIds: string[];
+    unresolvedFrontierIds: string[];
+    unresolvedEdgeIds: string[];
+    coverage: CausalCorridorCoverage;
+    explanation: string;
+}
+type ExplorationUpstreamEndpointKind = 'public-entry' | 'runtime-boundary' | 'traversal-root';
+interface ExplorationRoute {
+    id: string;
+    status: 'proved';
+    anchorNodeId: string;
+    anchorLabel: string;
+    endpointNodeId: string;
+    endpointLabel: string;
+    endpointLocation: ExplorationSourceLocation;
+    endpointKind: Exclude<ExplorationUpstreamEndpointKind, 'traversal-root'>;
+    /** Ordered in runtime direction, from the upstream endpoint to the anchor. */
+    nodeIds: string[];
+    /** Ordered in runtime direction, from the upstream endpoint to the anchor. */
+    edgeIds: string[];
+    evidenceStrengths: ExplorationEvidenceStrength[];
+    spineEdgeFamilies: ProgramEdgeFamily[];
+    relatedEdgeFamilies: ProgramEdgeFamily[];
+    crossesRuntimeBoundary: boolean;
+}
+interface ExplorationRouteCatalogCoverage {
+    status: 'accounted' | 'incomplete';
+    scope: string;
+    enumeration: 'one-shortest-proved-path-per-endpoint';
+    maximumDepth: number;
+    anchorNodeIds: string[];
+    anchorsWithRoutes: string[];
+    anchorsWithoutRoutes: string[];
+    depthLimitedAnchorNodeIds: string[];
+    routeCount: number;
+    explanation: string;
+}
+interface ExplorationRouteCatalog {
+    schemaVersion: 1;
+    routes: ExplorationRoute[];
+    selectedRouteIds: string[];
+    coverage: ExplorationRouteCatalogCoverage;
+}
+
+export type { ExplorationSourceLocation as E, ProgramEdgeSemantic as P, ExplorationEvidenceStrength as a, ExplorationTopologyNode as b, ExplorationEvidenceSource as c, ExplorationTopology as d, ExplorationAnchorStatus as e, ExplorationCompletion as f, ExplorationCompletionStatus as g, ExplorationDisposition as h, ExplorationDispositionCounts as i, ExplorationFrontierGroup as j, ExplorationTopologyAnchor as k, ExplorationTopologyCoverage as l, ExplorationTopologyEdge as m, ExplorationTopologyInput as n, ExplorationTopologyPath as o };

package/dist/file-dep-graph-Bqg3t3Px.d.ts

@@ -0,0 +1,4 @@
+/** The public relation selected by file dependency analyses. */
+type FileDependencyEdgeBasis = 'symbol-references' | 'imports';
+
+export type { FileDependencyEdgeBasis as F };

package/dist/file-kind-BKCVMNUf.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A file kind is a source-path role distinguished by the convention that
+ * makes a file an executable boundary, re-export surface, worker, test, or
+ * ordinary implementation. It is intentionally derived from paths alone.
+ */
+type FileKind = 'entry' | 'barrel' | 'worker' | 'test' | 'source';
+/** Classify a source path by its structural role without consulting project state. */
+declare function classifyFile(file: string): FileKind;
+
+export { type FileKind as F, classifyFile as c };

package/dist/frontend-behavior-evidence-EfM4_9bc.d.ts

@@ -0,0 +1,4 @@
+type FrontendBehaviorEvidenceClass = 'domain-behavior' | 'generic-workflow-scaffolding' | 'mixed' | 'shared-abstraction';
+type FrontendBehaviorActionTier = 'signal' | 'support';
+
+export type { FrontendBehaviorEvidenceClass as F, FrontendBehaviorActionTier as a };

package/dist/git-history-ChNHbfZQ.d.ts

@@ -0,0 +1,13 @@
+type CoChangeCommitScope = 'focused' | 'mixed' | 'broad-sweep';
+type CoChangeRecency = 'recent' | 'stale';
+type CoChangeExternalIssueLabelStatus = 'unavailable';
+type GitHistoryMode = 'bounded' | 'full';
+interface CoChangeSubjectContext {
+    /** Locally inferred from commit subjects, not issue tracker metadata. */
+    subjectLabels: string[];
+    issueRefs: string[];
+    sampleSubjects: string[];
+    externalIssueLabelStatus: CoChangeExternalIssueLabelStatus;
+}
+
+export type { CoChangeCommitScope as C, GitHistoryMode as G, CoChangeRecency as a, CoChangeSubjectContext as b };

package/dist/graph-evidence-BIFqyisO.d.ts

@@ -0,0 +1,131 @@
+import { S as ScipDatabase } from './db-D7sauVFH.js';
+import { P as ProgramEdgeSemantic, E as ExplorationSourceLocation, a as ExplorationEvidenceStrength } from './exploration-topology-BG4v30HZ.js';
+
+/** Agent-facing graph families. Provider-specific detail belongs in edge subtypes. */
+declare const GRAPH_EVIDENCE_FAMILIES: readonly ["execution", "runtime", "dataflow", "state", "temporal", "contract", "identity", "ownership", "dependencies"];
+type GraphEvidenceFamily = (typeof GRAPH_EVIDENCE_FAMILIES)[number];
+declare const GRAPH_PROJECTION_DIRECTIONS: readonly ["incoming", "outgoing", "both"];
+type GraphProjectionDirection = (typeof GRAPH_PROJECTION_DIRECTIONS)[number];
+
+declare const GRAPH_EVIDENCE_VIEWS: readonly ["causal", "structure", "complete"];
+type GraphEvidenceView = (typeof GRAPH_EVIDENCE_VIEWS)[number];
+interface GraphEvidenceSelectors {
+    symbols?: readonly string[];
+    locations?: readonly string[];
+    searches?: readonly string[];
+}
+interface GraphEvidenceOptions {
+    view?: GraphEvidenceView;
+    families?: readonly GraphEvidenceFamily[];
+    direction?: GraphProjectionDirection;
+    subtypes?: readonly string[];
+    connecting?: boolean;
+    inventoryOnly?: boolean;
+    /** Materialize the exact membership of recoverable folds from the same projection. */
+    foldIds?: readonly string[];
+    maxDepth?: number;
+    maxEdges?: number;
+}
+interface GraphEvidenceSelection {
+    direction: GraphProjectionDirection;
+    subtypes: string[];
+    connecting: boolean;
+    inventoryOnly: boolean;
+    foldIds: string[];
+}
+interface GraphEvidenceInventoryRow {
+    family: GraphEvidenceFamily;
+    subtype: string;
+    incoming: number;
+    outgoing: number;
+    both: number;
+}
+interface GraphEvidenceFold {
+    id: string;
+    mode: 'linear' | 'scc' | 'topology';
+    family: GraphEvidenceFamily;
+    /** One subtype name, or `mixed` when this structural fold contains several. */
+    subtype: string;
+    /** Complete subtype inventory for the folded relationships. */
+    subtypes?: string[];
+    /** Query-neutral structural region shared by the folded relationships. */
+    region?: string;
+    edgeCount: number;
+    edgeIds: string[];
+    nodeIds: string[];
+    minimumMaxEdges: number;
+}
+interface GraphEvidenceTarget {
+    kind: string;
+    query: string;
+    status: 'matched' | 'ambiguous' | 'missing';
+    nodeIds: string[];
+    omittedCandidates: number;
+}
+interface GraphEvidenceNode {
+    id: string;
+    kind: string;
+    label: string;
+    symbol: string | null;
+    location: ExplorationSourceLocation | null;
+}
+interface GraphEvidenceEdge {
+    id: string;
+    family: GraphEvidenceFamily;
+    /** Original typed-program semantic family before presentation grouping. */
+    semanticFamily: ProgramEdgeSemantic['family'];
+    subtype: string;
+    from: GraphEvidenceNode;
+    to: GraphEvidenceNode;
+    sourceKind: string;
+    providerId: string;
+    supportCeiling: 'exact' | 'partial' | 'candidate';
+    establishes: string;
+    nonClaims: readonly string[];
+    recoverWith: readonly string[];
+    evidenceStrength: ExplorationEvidenceStrength;
+    evidenceMethods: string[];
+    evidenceConstituents?: Array<{
+        method: string;
+        strength: ExplorationEvidenceStrength;
+    }>;
+    context: ProgramEdgeSemantic['context'] | null;
+    attributes: ProgramEdgeSemantic['attributes'] | null;
+}
+interface GraphEvidenceCoverage {
+    status: 'accounted' | 'bounded' | 'incomplete';
+    topologyStatus: 'accounted' | 'incomplete';
+    scope: string;
+    maxDepth: number;
+    maxEdges: number;
+    /** Present for projection-aware callers; omitted by results produced before projection metadata existed. */
+    matchedEdges?: number;
+    eligibleEdges: number;
+    returnedEdges: number;
+    omittedEdges: number;
+    frontierGroups: number;
+    unsupportedFrontiers: number;
+    blindSpots: string[];
+    explanation: string;
+}
+interface GraphEvidenceResult {
+    kind: 'graph';
+    view: GraphEvidenceView | 'custom';
+    families: GraphEvidenceFamily[];
+    /** Explicit projection applied by the current implementation. */
+    selection?: GraphEvidenceSelection;
+    targets: GraphEvidenceTarget[];
+    /** Complete relationship counts before materialization budgeting. */
+    inventory?: GraphEvidenceInventoryRow[];
+    edges: GraphEvidenceEdge[];
+    /** Recoverable membership for relationships withheld by the materialization budget. */
+    folds?: GraphEvidenceFold[];
+    coverage: GraphEvidenceCoverage;
+}
+/**
+ * Compose the existing system-map topology into one small, agent-selected
+ * relationship packet. This function performs no task-relevance inference.
+ */
+declare function graphEvidence(db: ScipDatabase, selectors: GraphEvidenceSelectors, options?: GraphEvidenceOptions): GraphEvidenceResult;
+
+export { type GraphEvidenceCoverage as G, type GraphEvidenceEdge as a, type GraphEvidenceTarget as b, GRAPH_EVIDENCE_FAMILIES as c, GRAPH_EVIDENCE_VIEWS as d, type GraphEvidenceFamily as e, type GraphEvidenceFold as f, type GraphEvidenceInventoryRow as g, type GraphEvidenceNode as h, type GraphEvidenceOptions as i, type GraphEvidenceResult as j, type GraphEvidenceSelection as k, type GraphEvidenceSelectors as l, type GraphEvidenceView as m, type GraphProjectionDirection as n, graphEvidence as o };