@mrclrchtr/supi-code-intelligence 3.2.0 → 4.1.0

package/src/tool/result/graph.ts

@@ -1,93 +1,192 @@
 import type { ConfidenceMode } from "@mrclrchtr/supi-code-runtime/api";
-import type { EvidenceListMetadata } from "../../analysis/evidence.ts";
-import type { ReadNextItem } from "../../analysis/read-next.ts";
-import type { TestSurfaceDetails } from "../../analysis/tests/test-discovery.ts";
+import { createEvidenceList, type EvidenceList } from "../../analysis/evidence.ts";
+import type { RelationLocationPartialReason } from "../../analysis/relations/provider-locations.ts";
+import type {
+  CallEntry,
+  ImplementationEntry,
+  ReferenceEntry,
+} from "../../analysis/relations/types.ts";
+import type { GraphSection } from "../../session/graph-types.ts";
+import {
+  assembledNextQueries,
+  assembleToolResult,
+  type ResultProvenance,
+  type ToolResultAssembly,
+} from "./assembly.ts";
 import type { SearchDetails } from "./types.ts";
 
-/** Relation families accepted by code_graph. */
-export type GraphRelationKind =
-  | "all"
-  | "references"
-  | "callees"
-  | "imports"
-  | "exports"
-  | "implements"
-  | "tests";
+export type { GraphRelationKind, GraphSection } from "../../session/graph-types.ts";
 
-/** A relation section in an assembled code_graph result. */
-export type GraphSection =
-  | {
-      kind: "ok";
-      rel: GraphRelationKind;
-      count: number;
-      /** Relation body prepared for markdown/TUI presentation adapters. */
-      content: string;
-      evidenceLists?: EvidenceListMetadata[];
-      tests?: TestSurfaceDetails;
-      readNext?: ReadNextItem[];
-    }
-  | { kind: "unavailable"; rel: GraphRelationKind; message: string; tests?: TestSurfaceDetails }
-  | {
-      kind: "not-implemented";
-      rel: GraphRelationKind;
-      message: string;
-      tests?: TestSurfaceDetails;
-    };
+type UnavailableGraphSection = Extract<GraphSection, { kind: "unavailable" }>;
+type ReferenceGraphSection = Extract<GraphSection, { kind: "ok"; rel: "references" }>;
+type CalleeGraphSection = Extract<GraphSection, { kind: "ok"; rel: "callees" }>;
+type ImplementationGraphSection = Extract<GraphSection, { kind: "ok"; rel: "implements" }>;
 
+/** A relation section after canonical evidence bounding. */
+export type AssembledGraphSection =
+  | UnavailableGraphSection
+  | (ReferenceGraphSection & { readonly evidence: EvidenceList<ReferenceEntry> })
+  | (CalleeGraphSection & { readonly evidence: EvidenceList<CallEntry> })
+  | (ImplementationGraphSection & {
+      readonly evidence: EvidenceList<ImplementationEntry>;
+    });
+
+/** Presentation-neutral assembled graph result. */
 export interface GraphResultAssembly {
   displayName: string;
-  sections: GraphSection[];
+  sections: readonly AssembledGraphSection[];
   resolvedDisplayFile: string;
-  scope: string | undefined;
+  cwd: string;
+  assembled: ToolResultAssembly<{ readonly sections: readonly AssembledGraphSection[] }>;
   details: SearchDetails;
 }
 
-/** Assemble code_graph evidence/details before markdown and TUI adapters render it. */
+/** Assemble graph evidence once before either presentation adapter consumes it. */
 export function assembleGraphResult(input: {
   displayName: string;
-  sections: GraphSection[];
+  sections: readonly GraphSection[];
   resolvedDisplayFile: string;
-  scope: string | undefined;
+  maxResults: number;
+  cwd: string;
 }): GraphResultAssembly {
-  const evidenceLists = input.sections.flatMap((section) =>
-    section.kind === "ok" ? (section.evidenceLists ?? []) : [],
+  const sections = input.sections.map((section) => assembleGraphSection(section, input.maxResults));
+  const evidenceLists = sections.flatMap((section) =>
+    section.kind === "ok" ? [section.evidence.metadata] : [],
   );
-  const omittedCount = evidenceLists.reduce(
-    (sum, evidenceList) => sum + (evidenceList.omittedCount ?? 0),
+  const candidateCount = sections.reduce(
+    (sum, section) => sum + (section.kind === "ok" ? evidenceTotal(section.evidence) : 0),
     0,
   );
+  const confidence = graphConfidence(sections);
+  const provenance = graphProvenance(sections);
+  const assembled = assembleToolResult({
+    data: { sections },
+    sections: sections.map((section) => ({
+      key: section.rel,
+      title: section.rel,
+      status: section.kind === "ok" ? evidenceStatus(section.evidence) : "unavailable",
+      items: section.kind === "ok" ? section.evidence.items : [],
+      confidence: sectionConfidence(section),
+      provenance: section.kind === "ok" ? graphProvenance([section]) : [],
+    })),
+    evidenceLists,
+    nextQueries: ["Use code_orientation on an exact result before editing"],
+    readNext: sections.flatMap((section) => (section.kind === "ok" ? section.readNext : [])),
+    candidateCount,
+    confidence,
+    provenance,
+  });
 
   return {
-    ...input,
+    displayName: input.displayName,
+    sections,
+    resolvedDisplayFile: input.resolvedDisplayFile,
+    cwd: input.cwd,
+    assembled,
     details: {
-      confidence: graphConfidence(input.sections),
-      scope: input.scope ?? null,
-      candidateCount: input.sections.reduce(
-        (sum, section) => sum + (section.kind === "ok" ? section.count : 0),
-        0,
-      ),
-      omittedCount,
-      evidenceLists,
-      nextQueries: [
-        "`code_orientation` on individual results for deeper orientation",
-        "`code_impact` for impact analysis",
-      ],
-      tests: input.sections.find((section) => section.rel === "tests")?.tests,
+      confidence,
+      scope: null,
+      candidateCount,
+      omittedCount: assembled.totals.omittedCount,
+      evidenceLists: [...assembled.evidenceLists],
+      nextQueries: assembledNextQueries(assembled),
     },
   };
 }
 
-function graphConfidence(sections: GraphSection[]): ConfidenceMode {
-  const hasStructural = sections.some(
-    (s) =>
-      s.kind === "ok" &&
-      (s.rel === "callees" ||
-        s.rel === "imports" ||
-        s.rel === "exports" ||
-        (s.rel === "tests" && s.count > 0)),
-  );
+function assembleGraphSection(section: GraphSection, maxResults: number): AssembledGraphSection {
+  if (section.kind === "unavailable") return section;
+  switch (section.rel) {
+    case "references":
+      return {
+        ...section,
+        evidence: createRelationEvidenceList({
+          key: "references.locations",
+          items: [...section.data.references],
+          maxResults,
+          invalidLocationCount: section.data.invalidLocationCount,
+          partialReason: section.data.partialReason,
+        }),
+      };
+    case "callees":
+      return {
+        ...section,
+        evidence: createEvidenceList({
+          key: "callees.calls",
+          items: [...section.data.calls],
+          maxResults,
+        }),
+      };
+    case "implements":
+      return {
+        ...section,
+        evidence: createRelationEvidenceList({
+          key: "implements.locations",
+          items: [...section.data.implementations],
+          maxResults,
+          invalidLocationCount: section.data.invalidLocationCount,
+          partialReason: section.data.partialReason,
+        }),
+      };
+  }
+}
+
+function createRelationEvidenceList<T>(params: {
+  key: string;
+  items: T[];
+  maxResults: number;
+  invalidLocationCount: number;
+  partialReason: RelationLocationPartialReason | null;
+}): EvidenceList<T> {
+  const evidence = createEvidenceList({
+    key: params.key,
+    items: params.items,
+    maxResults: params.maxResults,
+  });
+  if (params.partialReason === null) return evidence;
+  return {
+    ...evidence,
+    metadata: {
+      ...evidence.metadata,
+      partialReason: params.partialReason,
+      invalidLocationCount: params.invalidLocationCount,
+    },
+  };
+}
+
+function evidenceTotal(evidence: EvidenceList<unknown>): number {
+  return evidence.metadata.totalCount ?? evidence.metadata.shownCount;
+}
+
+function evidenceStatus(evidence: EvidenceList<unknown>): "complete" | "partial" {
+  return evidence.metadata.partialReason !== null || (evidence.metadata.omittedCount ?? 0) > 0
+    ? "partial"
+    : "complete";
+}
+
+function sectionConfidence(section: AssembledGraphSection): ConfidenceMode {
+  if (section.kind !== "ok") return "unavailable";
+  return section.rel === "callees" ? "structural" : "semantic";
+}
+
+function graphProvenance(sections: readonly AssembledGraphSection[]): ResultProvenance[] {
+  const result: ResultProvenance[] = [];
+  if (sections.some((section) => section.kind === "ok" && section.rel !== "callees")) {
+    result.push({ source: "semantic", capability: "LSP" });
+  }
+  if (sections.some((section) => section.kind === "ok" && section.rel === "callees")) {
+    result.push({ source: "structural", capability: "tree-sitter" });
+  }
+  return result;
+}
+
+function graphConfidence(sections: readonly AssembledGraphSection[]): ConfidenceMode {
   const hasSemantic = sections.some(
-    (s) => s.kind === "ok" && (s.rel === "references" || s.rel === "implements"),
+    (section) =>
+      section.kind === "ok" && (section.rel === "references" || section.rel === "implements"),
+  );
+  const hasStructural = sections.some(
+    (section) => section.kind === "ok" && section.rel === "callees",
   );
   return hasSemantic ? "semantic" : hasStructural ? "structural" : "unavailable";
 }

package/src/tool/result/health.ts

@@ -1,94 +1,191 @@
-import type { CoverageWarningReport } from "../../analysis/coverage/coverage-warnings.ts";
-import type { EvidenceListMetadata } from "../../analysis/evidence.ts";
-import type { GitContext } from "../../analysis/signals/git.ts";
-import type { HealthDetails } from "./types.ts";
+import type { ConfidenceMode } from "@mrclrchtr/supi-code-runtime/api";
+import type { HealthData, HealthSection } from "../../session/health-types.ts";
+import {
+  assembleToolResult,
+  type ResultProvenance,
+  type ResultSection,
+  type ToolResultAssembly,
+} from "./assembly.ts";
+import type { HealthDetails, HealthSectionDetails } from "./types.ts";
 
-export type HealthSection = "diagnostics" | "servers" | "dirty" | "coverage" | "unused";
+export type {
+  HealthData,
+  HealthDiagnosticEntry,
+  HealthDiagnosticObservation,
+  HealthDiagnosticScope,
+  HealthRefreshAttempt,
+  HealthRefreshState,
+  HealthSection,
+  HealthServerInfo,
+  HealthStaleAssessment,
+  SemanticHealthState,
+} from "../../session/health-types.ts";
+export type { HealthSectionDetails } from "./types.ts";
 
-export interface HealthServerInfo {
-  name: string;
-  root: string;
-  fileTypes: string[];
-  status: string;
+export interface HealthResultAssembly {
+  data: HealthData;
+  assembled: ToolResultAssembly<HealthData>;
+  details: HealthDetails;
 }
 
-export interface HealthDiagnosticEntry {
-  file: string;
-  errors: number;
-  warnings: number;
-}
+const SECTION_TITLES: Record<HealthSection, string> = {
+  diagnostics: "Diagnostics",
+  servers: "Servers",
+};
+
+/** Assemble public code_health evidence and details before presentation adapters render it. */
+export function assembleHealthResult(data: HealthData): HealthResultAssembly {
+  const projections = data.includedSections.map((section) => projectSection(section, data));
+  const sections = projections.map((projection) => projection.section);
+  const sectionDetails = projections.map((projection) => projection.details);
+  const evidenceLists: never[] = [];
+  const provenance = uniqueProvenance([
+    ...sections.flatMap((section) => section.provenance),
+    { source: "runtime", capability: "workspace-health" },
+  ]);
+  const confidence = healthConfidence(sectionDetails);
+  const assembled = assembleToolResult({
+    data,
+    sections,
+    evidenceLists,
+    candidateCount: sections.reduce((sum, section) => sum + section.items.length, 0),
+    confidence,
+    provenance,
+  });
 
-export interface HealthCoverageEntry {
-  file: string;
-  pct: number;
+  return {
+    data,
+    assembled,
+    details: {
+      includedSections: [...data.includedSections],
+      sections: sectionDetails,
+      confidence,
+      provenance: [...assembled.provenance],
+      candidateCount: assembled.totals.candidateCount,
+      omittedCount: assembled.totals.omittedCount,
+      semanticState: data.semanticState,
+      serverInventoryAvailable: data.serverInventoryAvailable,
+      serverInventoryScope: "workspace",
+      diagnosticObservation: data.diagnostics,
+      refresh: data.refresh,
+      structuralAvailable: structuralCapabilityReady(data),
+      structuralStatus: data.structuralStatus,
+      capabilityWarnings: data.capabilityWarnings ?? null,
+      diagnosticFileCount: data.diagnostics.entries.length,
+      serverCount: data.servers.length,
+      evidenceLists: [...assembled.evidenceLists],
+    },
+  };
 }
 
-export interface HealthCoverageData {
+interface HealthSectionFacts {
+  status: "complete" | "partial" | "unavailable";
   available: boolean;
-  entries: HealthCoverageEntry[];
+  items: readonly unknown[];
+  confidence: ConfidenceMode;
+  provenance: ResultProvenance[];
+}
+
+function projectSection(
+  key: HealthSection,
+  data: HealthData,
+): { section: ResultSection; details: HealthSectionDetails } {
+  const facts = collectSectionFacts(key, data);
+  const confidence = facts.status === "unavailable" ? "unavailable" : facts.confidence;
+  return {
+    section: {
+      key: `health.${key}`,
+      title: SECTION_TITLES[key],
+      status: facts.status,
+      items: facts.items,
+      confidence,
+      provenance: facts.provenance,
+    },
+    details: {
+      key,
+      title: SECTION_TITLES[key],
+      status: facts.status,
+      confidence,
+      provenance: [...facts.provenance],
+      itemCount: facts.items.length,
+      available: facts.available,
+    },
+  };
 }
 
-export interface HealthUnusedExportEntry {
-  file: string;
-  name: string;
+function collectSectionFacts(key: HealthSection, data: HealthData): HealthSectionFacts {
+  if (key === "servers") return serverFacts(data);
+
+  switch (data.diagnostics.kind) {
+    case "completed":
+      return semanticDiagnosticFacts("complete", data.diagnostics.entries);
+    case "partial":
+      return semanticDiagnosticFacts("partial", data.diagnostics.entries);
+    case "unavailable":
+    case "not-requested":
+      return {
+        status: "unavailable",
+        available: false,
+        items: [],
+        confidence: "unavailable",
+        provenance: [],
+      };
+  }
 }
 
-export interface HealthUnusedData {
-  available: boolean;
-  files: string[];
-  exports: HealthUnusedExportEntry[];
+function semanticDiagnosticFacts(
+  status: "complete" | "partial",
+  entries: HealthData["diagnostics"]["entries"],
+): HealthSectionFacts {
+  return {
+    status,
+    available: true,
+    items: entries,
+    confidence: "semantic",
+    provenance: [{ source: "semantic", capability: "LSP" }],
+  };
 }
 
-/** A suggested code action at a specific diagnostic location. */
-export interface CodeActionSuggestion {
-  file: string;
-  line: number;
-  title: string;
-  kind?: string;
+function serverFacts(data: HealthData): HealthSectionFacts {
+  const available = data.serverInventoryAvailable;
+  return {
+    status: available ? "complete" : "unavailable",
+    available,
+    items: data.servers,
+    confidence: "heuristic",
+    provenance: available ? [{ source: "runtime", capability: "language-server-status" }] : [],
+  };
 }
 
-export interface HealthData {
-  includedSections: HealthSection[];
-  lspAvailable: boolean;
-  lspStatus: string;
-  recovered: boolean;
-  /** Structural (tree-sitter) substrate readiness. Undefined when not evaluated. */
-  structuralStatus?: string;
-  diagnostics: HealthDiagnosticEntry[];
-  servers: HealthServerInfo[];
-  gitContext: GitContext | null;
-  scopeFilter: string | null;
-  level: "summary" | "detailed";
-  /** Code action suggestions collected from LSP (only populated in detailed mode). */
-  codeActions: CodeActionSuggestion[] | null;
-  coverage: HealthCoverageData | null;
-  unused: HealthUnusedData | null;
-  /** Coverage warnings for degraded semantic/structural substrate. Undefined when fully healthy. */
-  degradedCoverage?: CoverageWarningReport;
-  /** Seconds since diagnostics were last refreshed, or undefined if never refreshed. */
-  diagnosticAgeSeconds?: number;
+/** Accept only the explicit ready state; arbitrary status text is not provenance. */
+function structuralCapabilityReady(data: HealthData): boolean {
+  return data.structuralAvailable === true;
 }
 
-export interface HealthResultAssembly {
-  data: HealthData;
-  details: HealthDetails;
+function healthConfidence(sections: readonly HealthSectionDetails[]): ConfidenceMode {
+  if (
+    sections.some(
+      (section) => section.status !== "unavailable" && section.confidence === "semantic",
+    )
+  ) {
+    return "semantic";
+  }
+  if (
+    sections.some(
+      (section) => section.status !== "unavailable" && section.confidence === "heuristic",
+    )
+  ) {
+    return "heuristic";
+  }
+  return "unavailable";
 }
 
-/** Assemble public code_health evidence and details before presentation adapters render it. */
-export function assembleHealthResult(
-  data: HealthData,
-  evidenceLists: EvidenceListMetadata[],
-): HealthResultAssembly {
-  return {
-    data,
-    details: {
-      lspAvailable: data.lspAvailable,
-      lspStatus: data.lspStatus,
-      recovered: data.recovered,
-      structuralStatus: data.structuralStatus,
-      diagnosticFileCount: data.diagnostics.length,
-      serverCount: data.servers.length,
-      evidenceLists,
-    },
-  };
+function uniqueProvenance(provenance: readonly ResultProvenance[]): ResultProvenance[] {
+  const seen = new Set<string>();
+  return provenance.filter((entry) => {
+    const key = `${entry.source}|${entry.capability ?? ""}|${entry.detail ?? ""}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
 }