@mrclrchtr/supi-code-intelligence 3.2.0 → 4.1.0

package/src/tool/result/inspect.ts

@@ -1,60 +1,202 @@
 import type { ConfidenceMode } from "@mrclrchtr/supi-code-runtime/api";
-import type { EvidenceListMetadata } from "../../analysis/evidence.ts";
-import type { InspectDetails } from "./types.ts";
-
-export interface InspectResultData {
-  relPath: string;
-  line: number;
-  character: number;
-  confidence: ConfidenceMode;
-  node: {
-    type: string;
-    text: string;
-    startLine: number;
-    startCharacter: number;
-    ancestry?: Array<
-      | string
-      | {
-          type: string;
-          startLine: number;
-          startCharacter: number;
-          endLine?: number;
-          endCharacter?: number;
-        }
-    >;
-  } | null;
-  enclosingSymbol: {
-    name: string;
-    kind: string;
-    startLine: number;
-    endLine: number;
-  } | null;
-  hover: string | null;
-  definitions: Array<{ file: string; line: number; character: number }>;
-  diagnostics: Array<{ line: number; severity: number | string; message: string }>;
-  codeActions: Array<{ title: string; kind?: string }>;
-  codeActionEvidence?: EvidenceListMetadata;
-  unavailableSections: string[];
-}
+import {
+  createEvidenceList,
+  createPartialEvidenceList,
+  type EvidenceList,
+} from "../../analysis/evidence.ts";
+import type {
+  InspectDefinition,
+  InspectDiagnostic,
+  InspectObservation,
+  InspectResultData,
+} from "../../session/inspect-types.ts";
+import {
+  assembledNextQueries,
+  assembleToolResult,
+  type ResultProvenance,
+  type ResultSection,
+  type ToolResultAssembly,
+} from "./assembly.ts";
+import type { InspectDetails, InspectSectionDetails } from "./types.ts";
+
+export type { InspectResultData } from "../../session/inspect-types.ts";
 
+/** Assembled inspection evidence consumed by markdown and TUI adapters. */
 export interface InspectResultAssembly {
   data: InspectResultData;
+  displayedDefinitions: readonly InspectDefinition[];
+  displayedDiagnostics: readonly InspectDiagnostic[];
+  definitionEvidence: EvidenceList<InspectDefinition> | null;
+  diagnosticEvidence: EvidenceList<InspectDiagnostic> | null;
+  assembled: ToolResultAssembly<InspectResultData>;
   details: InspectDetails;
 }
 
 /** Assemble code_inspect evidence/details before presentation adapters render it. */
 export function assembleInspectResult(
   data: InspectResultData,
-  nextQueries: string[],
+  nextQueries: readonly string[],
 ): InspectResultAssembly {
+  const definitionEvidence = listEvidence(
+    "inspect.definitions",
+    data.sections.definition,
+    data.maxResults,
+  );
+  const diagnosticEvidence = listEvidence(
+    "inspect.diagnostics",
+    data.sections.diagnostics,
+    data.maxResults,
+  );
+  const sections = inspectResultSections(data);
+  const provenance = overallProvenance(data);
+  const evidenceLists = [definitionEvidence, diagnosticEvidence].flatMap((evidence) =>
+    evidence ? [evidence.metadata] : [],
+  );
+  const assembled = assembleToolResult({
+    data,
+    sections,
+    evidenceLists,
+    nextQueries,
+    candidateCount: sections.reduce((sum, section) => sum + section.items.length, 0),
+    confidence: data.confidence,
+    provenance,
+  });
+
   return {
     data,
+    displayedDefinitions: definitionEvidence?.items ?? [],
+    displayedDiagnostics: diagnosticEvidence?.items ?? [],
+    definitionEvidence,
+    diagnosticEvidence,
+    assembled,
     details: {
       confidence: data.confidence,
       focusTarget: `${data.relPath}:${data.line}:${data.character}`,
-      unavailableSections: data.unavailableSections,
-      evidenceLists: data.codeActionEvidence ? [data.codeActionEvidence] : [],
-      nextQueries,
+      diagnosticWindow: { ...data.diagnosticWindow },
+      sections: inspectSectionDetails(data),
+      evidenceLists: [...assembled.evidenceLists],
+      nextQueries: assembledNextQueries(assembled),
     },
   };
 }
+
+function listEvidence<T>(
+  key: string,
+  observation: InspectObservation<readonly T[]>,
+  maxResults: number,
+): EvidenceList<T> | null {
+  if (observation.kind === "unavailable") return null;
+  const params = { key, items: [...observation.data], maxResults };
+  return observation.kind === "partial"
+    ? createPartialEvidenceList({ ...params, partialReason: "provider-limited" })
+    : createEvidenceList(params);
+}
+
+function inspectResultSections(data: InspectResultData): ResultSection[] {
+  const structural = [{ source: "structural" as const, capability: "tree-sitter" }];
+  const semantic = [{ source: "semantic" as const, capability: "LSP" }];
+  return [
+    resultSection("inspect.node", "Syntax node", data.sections.node, structural),
+    resultSection(
+      "inspect.enclosingSymbol",
+      "Enclosing symbol",
+      data.sections.enclosingSymbol,
+      structural,
+    ),
+    resultSection("inspect.hover", "Hover", data.sections.hover, semantic),
+    resultSection("inspect.definition", "Definition", data.sections.definition, semantic),
+    resultSection("inspect.diagnostics", "Nearby diagnostics", data.sections.diagnostics, semantic),
+  ];
+}
+
+function resultSection<T>(
+  key: string,
+  title: string,
+  observation: InspectObservation<T>,
+  provenance: ResultProvenance[],
+): ResultSection {
+  return {
+    key,
+    title,
+    status: observationStatus(observation),
+    items: observation.kind === "unavailable" ? [] : observationItems(observation.data),
+    confidence: provenance[0]?.source === "semantic" ? "semantic" : "structural",
+    provenance: observation.kind === "unavailable" ? [] : provenance,
+  };
+}
+
+function observationItems(data: unknown): readonly unknown[] {
+  if (data === null) return [];
+  return Array.isArray(data) ? data : [data];
+}
+
+function observationStatus(
+  observation: InspectObservation<unknown>,
+): "complete" | "partial" | "unavailable" {
+  if (observation.kind === "completed") return "complete";
+  return observation.kind;
+}
+
+function inspectSectionDetails(data: InspectResultData): InspectSectionDetails[] {
+  return [
+    sectionDetails("node", "Syntax node", data.sections.node, {
+      confidence: "structural",
+      capability: "tree-sitter",
+    }),
+    sectionDetails("enclosingSymbol", "Enclosing symbol", data.sections.enclosingSymbol, {
+      confidence: "structural",
+      capability: "tree-sitter",
+    }),
+    sectionDetails("hover", "Hover", data.sections.hover, {
+      confidence: "semantic",
+      capability: "LSP",
+    }),
+    sectionDetails("definition", "Definition", data.sections.definition, {
+      confidence: "semantic",
+      capability: "LSP",
+    }),
+    sectionDetails("diagnostics", "Nearby diagnostics", data.sections.diagnostics, {
+      confidence: "semantic",
+      capability: "LSP",
+    }),
+  ];
+}
+
+function sectionDetails<T>(
+  key: InspectSectionDetails["key"],
+  title: string,
+  observation: InspectObservation<T>,
+  source: { confidence: ConfidenceMode; capability: string },
+): InspectSectionDetails {
+  return {
+    key,
+    title,
+    status: observationStatus(observation),
+    reason: observation.kind === "completed" ? null : observation.reason,
+    itemCount: observation.kind === "unavailable" ? 0 : observationItems(observation.data).length,
+    confidence: source.confidence,
+    provenance:
+      observation.kind === "unavailable"
+        ? []
+        : [
+            {
+              source: source.confidence === "semantic" ? "semantic" : "structural",
+              capability: source.capability,
+            },
+          ],
+  };
+}
+
+function overallProvenance(data: InspectResultData): ResultProvenance[] {
+  const structural =
+    data.sections.node.kind !== "unavailable" ||
+    data.sections.enclosingSymbol.kind !== "unavailable";
+  const semantic =
+    data.sections.hover.kind !== "unavailable" ||
+    data.sections.definition.kind !== "unavailable" ||
+    data.sections.diagnostics.kind !== "unavailable";
+  return [
+    ...(semantic ? [{ source: "semantic" as const, capability: "LSP" }] : []),
+    ...(structural ? [{ source: "structural" as const, capability: "tree-sitter" }] : []),
+  ];
+}

package/src/tool/result/orientation.ts

@@ -1,30 +1,132 @@
 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 {
+  OrientationCandidate,
+  OrientationResultData,
+  OrientationSectionData,
+} from "../../session/orientation-types.ts";
 import type { TargetStoreEntry } from "../../session/target-store.ts";
-import type { ContextDetails } from "./types.ts";
+import {
+  assembledNextQueries,
+  assembledReadNext,
+  assembleToolResult,
+  type ResultSection,
+  type ToolResultAssembly,
+} from "./assembly.ts";
+import type { ContextDetails, OrientationSectionDetails } from "./types.ts";
 
 export interface OrientationDetailsInput {
-  confidence: ConfidenceMode;
-  task?: string | null;
-  focusTarget?: string | null;
-  requestedSections?: string[];
-  renderedSections?: string[];
-  omittedCount?: number;
-  nextQueries: string[];
-  target?: TargetStoreEntry;
-  candidates?: ContextDetails["candidates"];
+  readonly confidence: ConfidenceMode;
+  readonly task?: string | null;
+  readonly focusTarget?: string | null;
+  readonly requestedSections?: readonly string[];
+  readonly renderedSections?: readonly string[];
+  readonly omittedCount?: number;
+  readonly evidenceLists?: readonly EvidenceListMetadata[];
+  readonly sections?: readonly OrientationSectionData[];
+  readonly nextQueries: readonly string[];
+  readonly readNext?: readonly ReadNextItem[];
+  readonly target?: Readonly<TargetStoreEntry>;
+  readonly candidates?: readonly OrientationCandidate[];
+  readonly instructions?: OrientationResultData["instructions"];
 }
 
-/** Assemble code_orientation details before presentation adapters render content. */
+export interface OrientationResultAssembly {
+  readonly assembled: ToolResultAssembly<OrientationResultData>;
+  readonly details: ContextDetails;
+}
+
+/** Assemble Orientation facts and shared result policy before rendering. */
+export function assembleOrientationResult(data: OrientationResultData): OrientationResultAssembly {
+  const sections = data.sections.map(toResultSection);
+  const evidenceLists = data.sections.flatMap((section) => section.evidenceLists);
+  const assembled = assembleToolResult({
+    data,
+    sections,
+    evidenceLists,
+    nextQueries: data.nextQueries,
+    readNext: data.readNext,
+    confidence: data.confidence,
+    provenance: uniqueProvenance(data.sections),
+  });
+  return {
+    assembled,
+    details: assembleOrientationDetails({
+      confidence: assembled.confidence,
+      focusTarget: assembled.data.focusTarget,
+      requestedSections: assembled.data.requestedSections,
+      renderedSections: assembled.data.renderedSections,
+      omittedCount: assembled.totals.omittedCount,
+      evidenceLists: assembled.evidenceLists,
+      sections: assembled.data.sections,
+      nextQueries: assembledNextQueries(assembled),
+      readNext: assembledReadNext(assembled),
+      target: assembled.data.target,
+      instructions: assembled.data.instructions,
+    }),
+  };
+}
+
+/** Project canonical Orientation facts into structured Tool details. */
 export function assembleOrientationDetails(input: OrientationDetailsInput): ContextDetails {
   return {
     confidence: input.confidence,
     task: input.task ?? null,
     focusTarget: input.focusTarget ?? null,
-    requestedSections: input.requestedSections ?? [],
-    renderedSections: input.renderedSections ?? [],
+    requestedSections: [...(input.requestedSections ?? [])],
+    renderedSections: [...(input.renderedSections ?? [])],
     omittedCount: input.omittedCount ?? 0,
-    nextQueries: input.nextQueries,
-    target: input.target,
-    candidates: input.candidates,
+    evidenceLists: input.evidenceLists ? [...input.evidenceLists] : undefined,
+    sections: input.sections?.map(toDetailsSection),
+    nextQueries: [...input.nextQueries],
+    readNext: input.readNext ? [...input.readNext] : undefined,
+    target: input.target ? { ...input.target } : undefined,
+    instructions: input.instructions,
+    candidates: input.candidates?.map((candidate) => ({
+      targetId: candidate.targetId,
+      name: candidate.name,
+      kind: candidate.kind,
+      container: candidate.container,
+      file: candidate.file,
+      line: candidate.line,
+      character: candidate.character,
+      rank: candidate.rank,
+    })),
+  };
+}
+
+function toResultSection(section: OrientationSectionData): ResultSection {
+  return {
+    key: section.key,
+    title: section.title,
+    status: section.status,
+    items: [section.key],
+    confidence: section.confidence,
+    provenance: section.provenance,
+  };
+}
+
+function toDetailsSection(section: OrientationSectionData): OrientationSectionDetails {
+  return {
+    key: section.key,
+    title: section.title,
+    status: section.status,
+    reason: section.reason,
+    confidence: section.confidence,
+    provenance: section.provenance.map((provenance) => ({ ...provenance })),
+    evidenceLists: section.evidenceLists.map((evidence) => ({ ...evidence })),
   };
 }
+
+function uniqueProvenance(sections: readonly OrientationSectionData[]) {
+  const seen = new Set<string>();
+  return sections.flatMap((section) =>
+    section.provenance.filter((provenance) => {
+      const key = `${provenance.source}:${provenance.capability ?? ""}:${provenance.detail ?? ""}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    }),
+  );
+}

package/src/tool/result/refactor.ts

@@ -1,35 +1,115 @@
-import type { WorkspaceEdit } from "@mrclrchtr/supi-code-runtime/api";
-import { createEvidenceList } from "../../analysis/evidence.ts";
-import type { ApplyResult } from "../refactor-apply/apply.ts";
+import type { FileEdit } from "@mrclrchtr/supi-code-runtime/api";
+import { createEvidenceList, type EvidenceList } from "../../analysis/evidence.ts";
+import type { ApplyResult } from "../../analysis/refactor/apply.ts";
+import type { RefactorPlan } from "../../session/refactor-plans.ts";
+import { assembledNextQueries, assembleToolResult, type ToolResultAssembly } from "./assembly.ts";
 import type { SearchDetails } from "./types.ts";
 
+export interface RefactorPlanAssemblyData {
+  readonly plan: Readonly<RefactorPlan>;
+  readonly cwd: string;
+  readonly edits: EvidenceList<FileEdit>;
+}
+
+export interface RefactorPlanResultAssembly {
+  readonly assembled: ToolResultAssembly<RefactorPlanAssemblyData>;
+  readonly details: SearchDetails;
+}
+
+export interface RefactorApplyAssemblyData {
+  readonly plan: Readonly<RefactorPlan>;
+  readonly result: Readonly<ApplyResult>;
+}
+
+export interface RefactorApplyResultAssembly {
+  readonly assembled: ToolResultAssembly<RefactorApplyAssemblyData>;
+  readonly details: SearchDetails;
+}
+
+/** Assemble a bounded refactor plan and all facts needed by its renderers. */
 export function assembleRefactorPlanDetails(
-  edits: WorkspaceEdit,
-  planId: string,
+  plan: Readonly<RefactorPlan>,
+  cwd: string,
   maxResults = 5,
-): SearchDetails {
-  const editEvidence = createEvidenceList({
+): RefactorPlanResultAssembly {
+  const edits = createEvidenceList({
     key: "refactor.edits",
-    items: edits.edits,
+    items: [...plan.edits.edits],
     maxResults,
-  }).metadata;
+  });
+  const provenance = [{ source: "semantic" as const, capability: "LSP refactor" }];
+  const assembled = assembleToolResult({
+    data: { plan, cwd, edits },
+    sections: [
+      {
+        key: "refactor.edits",
+        title: "Proposed edits",
+        status: "complete",
+        items: edits.items,
+        confidence: "semantic",
+        provenance,
+      },
+    ],
+    evidenceLists: [edits.metadata],
+    nextQueries: [`Use code_refactor_apply with planId: "${plan.id}" to apply this refactor`],
+    candidateCount: edits.metadata.totalCount ?? edits.metadata.shownCount,
+    confidence: "semantic",
+    provenance,
+  });
 
   return {
-    confidence: "semantic",
-    scope: null,
-    candidateCount: edits.edits.length,
-    omittedCount: editEvidence.omittedCount ?? 0,
-    evidenceLists: [editEvidence],
-    nextQueries: [`Use code_refactor_apply with planId: "${planId}" to apply this refactor`],
+    assembled,
+    details: {
+      confidence: assembled.confidence,
+      scope: null,
+      candidateCount: assembled.totals.candidateCount,
+      omittedCount: assembled.totals.omittedCount,
+      evidenceLists: [...assembled.evidenceLists],
+      nextQueries: assembledNextQueries(assembled),
+    },
   };
 }
 
-export function assembleRefactorApplyDetails(applyResult: ApplyResult): SearchDetails {
+/** Assemble a refactor apply outcome with the originating plan and follow-up action. */
+export function assembleRefactorApplyDetails(
+  applyResult: ApplyResult,
+  plan: Readonly<RefactorPlan>,
+): RefactorApplyResultAssembly {
+  const candidateCount = applyResult.kind === "applied" ? applyResult.totalEdits : 0;
+  const provenance = [{ source: "runtime" as const, capability: "file-mutation-queue" }];
+  const assembled = assembleToolResult({
+    data: { plan, result: applyResult },
+    sections: [
+      {
+        key: "refactor.apply",
+        title: "Applied edits",
+        status: applyResult.kind === "applied" ? "complete" : "unavailable",
+        items: applyResult.kind === "applied" ? [applyResult] : [],
+        confidence: applyResult.kind === "applied" ? "semantic" : "unavailable",
+        provenance,
+      },
+    ],
+    nextQueries:
+      applyResult.kind === "applied"
+        ? ["Use code_health to check for new issues after the refactor"]
+        : [],
+    candidateCount,
+    confidence: applyResult.kind === "applied" ? "semantic" : "unavailable",
+    provenance,
+  });
+
   return {
-    confidence: "semantic",
-    scope: null,
-    candidateCount: applyResult.kind === "applied" ? applyResult.totalEdits : 0,
-    omittedCount: 0,
-    nextQueries: ["`code_health` to check for new issues after the refactor"],
+    assembled,
+    details: {
+      confidence: assembled.confidence,
+      scope: null,
+      candidateCount: assembled.totals.candidateCount,
+      omittedCount: assembled.totals.omittedCount,
+      evidenceLists: [...assembled.evidenceLists],
+      nextQueries: assembledNextQueries(assembled),
+      ...(applyResult.kind === "applied"
+        ? { changedFiles: [...new Set(plan.edits.edits.map((edit) => edit.file))] }
+        : {}),
+    },
   };
 }