@mrclrchtr/supi-code-intelligence 3.2.0 → 4.1.0

package/src/tool/refactor-plan/execute.ts

@@ -1,73 +1,56 @@
-/**
- * Tool executor for the preview-only refactor planning path.
- *
- * Thin executor: validates semantic readiness via pipeline, then delegates
- * to the refactor plan use-case for operation normalization, target resolution,
- * provider interaction, and plan storage. Returns a planId for code_refactor_apply.
- */
+/** Thin Pi adapter for session-owned refactor planning. */
 
+import type {
+  RefactorOperationInput,
+  RefactorPlanWorkflowInput,
+} from "../../session/refactor-types.ts";
+import type { RefactorTargetInput } from "../../session/target-input.ts";
 import type { CodeIntelResult, CodeIntelToolExecCtx } from "../../types/index.ts";
-import { gateSemanticReadiness, runPipe } from "../infra/pipeline.ts";
-import { renderSemanticReadinessTimeout } from "../infra/readiness-message.ts";
-import { executeRefactorPlan } from "./orchestrate.ts";
+import { unavailableSearchDetails } from "../infra/error-results.ts";
+import { toWorkflowControl } from "../infra/workflow-control.ts";
+import { assembleRefactorPlanDetails } from "../result/refactor.ts";
+import { renderRefactorPlanResult } from "./markdown.ts";
 
 export interface CodeRefactorPlanToolParams {
-  targetId?: string;
-  operation: string;
-  file?: string;
-  line?: number;
-  character?: number;
-  range?: {
-    start: { line: number; character: number };
-    end: { line: number; character: number };
-  };
-  newName?: string;
+  target: RefactorTargetInput;
+  operation: RefactorOperationInput;
 }
 
 export async function executeRefactorPlanTool(
   params: CodeRefactorPlanToolParams,
   ctx: CodeIntelToolExecCtx,
-  invokedAs: "code_refactor_plan" = "code_refactor_plan",
+  _invokedAs: "code_refactor_plan" = "code_refactor_plan",
 ): Promise<CodeIntelResult> {
-  return runPipe(
-    params,
-    ctx,
-    [
-      gateSemanticReadiness("code_refactor_plan", {
-        fileParam: "file",
-        onTimeout: () => ({
-          content: renderSemanticReadinessTimeout(invokedAs, 15_000),
-          details: {
-            type: "search" as const,
-            data: {
-              confidence: "unavailable" as const,
-              scope: null,
-              candidateCount: 0,
-              omittedCount: 0,
-              nextQueries: ["Retry shortly or check `code_health`"],
-            },
-          },
-        }),
-        throwOnUnavailable: true,
-      }),
-    ],
-    async (_p, c) => {
-      return executeRefactorPlan(
-        {
-          targetId: params.targetId,
-          operation: params.operation,
-          file: params.file,
-          line: params.line,
-          character: params.character,
-          range: params.range,
-          newName: params.newName,
-        },
-        {
-          cwd: c.cwd,
-          session: c.session,
-          provider: c.session.getSemanticProvider(),
-        },
-      );
-    },
+  const outcome = await ctx.session.planRefactor(
+    params as RefactorPlanWorkflowInput,
+    toWorkflowControl(ctx),
   );
+  if (outcome.kind === "unavailable") throw new Error(outcome.reason);
+  if (outcome.kind === "invalid-input") {
+    return {
+      content: `**Error:** ${outcome.message}`,
+      details: unavailableSearchDetails(null, ["Fix the target or operation and retry"]),
+    };
+  }
+  if (outcome.kind === "ambiguous") {
+    const candidates = outcome.candidates
+      .map(
+        (candidate, index) =>
+          `${index + 1}. ${candidate.description} (${candidate.file}:${candidate.line})`,
+      )
+      .join("\n");
+    return {
+      content: `**Refactor ambiguous:**\n${candidates}`,
+      details: unavailableSearchDetails(null, ["Use a precise target handle or anchor"]),
+    };
+  }
+
+  const assembly = assembleRefactorPlanDetails(outcome.plan, ctx.cwd);
+  return {
+    content: renderRefactorPlanResult(assembly),
+    details: {
+      type: "search",
+      data: assembly.details,
+    },
+  };
 }

package/src/tool/refactor-plan/markdown.ts

@@ -1,39 +1,14 @@
-/**
- * Markdown renderer for refactor results.
- */
+import { renderEvidenceListDisclosure } from "../../analysis/evidence.ts";
+import { toDisplayPath } from "../../analysis/search/paths.ts";
+import { assembledNextQueries } from "../result/assembly.ts";
+import type {
+  RefactorApplyResultAssembly,
+  RefactorPlanResultAssembly,
+} from "../result/refactor.ts";
 
-import { createEvidenceList, renderEvidenceListDisclosure } from "../../analysis/evidence.ts";
-import { toDisplayPath } from "../../analysis/search/ripgrep.ts";
-import type { RefactorPlan } from "../../session/refactor-plans.ts";
-import type { ApplyResult } from "../refactor-apply/apply.ts";
-
-export interface RefactorRenderInput {
-  result: ApplyResult;
-  operation: string;
-  targetDescription: string;
-}
-
-/**
- * Render a refactor result as human-readable markdown.
- */
-export function renderRefactorResult(input: RefactorRenderInput): string {
-  const { result, operation, targetDescription } = input;
-
-  if (result.kind === "error") {
-    return `**Refactor failed:** ${result.reason}`;
-  }
-
-  return [
-    `**Refactor applied:** ${operation} on ${targetDescription}`,
-    `- Files changed: ${result.filesChanged}`,
-    `- Total edits: ${result.totalEdits}`,
-  ].join("\n");
-}
-
-/**
- * Render a refactor plan preview.
- */
-export function renderRefactorPlanResult(plan: RefactorPlan, cwd: string): string {
+/** Render a refactor plan from its canonical assembled evidence. */
+export function renderRefactorPlanResult(assembly: RefactorPlanResultAssembly): string {
+  const { plan, cwd, edits } = assembly.assembled.data;
   const lines: string[] = [];
   const changedFiles = collectChangedFiles(plan);
   const fileCount = changedFiles.length;
@@ -51,8 +26,11 @@ export function renderRefactorPlanResult(plan: RefactorPlan, cwd: string): strin
   if (plan.destination) {
     lines.push(`**Destination:** \`${plan.destination}\``);
   }
+  lines.push(`**Confidence:** \`${assembly.assembled.confidence}\``);
   lines.push(`**Files to change:** ${fileCount} file${fileCount !== 1 ? "s" : ""}`);
-  lines.push(`**Total edits:** ${plan.edits.edits.length}`);
+  lines.push(`**Total edits:** ${assembly.assembled.totals.candidateCount}`);
+  lines.push(`**Shown edits:** ${edits.metadata.shownCount}`);
+  lines.push(`**Omitted edits:** ${assembly.assembled.totals.omittedCount}`);
   lines.push("");
 
   lines.push("## Files");
@@ -62,42 +40,38 @@ export function renderRefactorPlanResult(plan: RefactorPlan, cwd: string): strin
   lines.push("");
   lines.push("## Preview");
   lines.push("");
-  const editEvidence = createEvidenceList({
-    key: "refactor.edits",
-    items: plan.edits.edits,
-    maxResults: 5,
-  });
-  for (const edit of editEvidence.items) {
+  for (const edit of edits.items) {
     const range = edit.range;
     lines.push(
-      `- \`${toDisplayPath(cwd, edit.file)}\` L${range.start.line + 1}:${range.start.character} → L${range.end.line + 1}:${range.end.character}`,
+      `- \`${toDisplayPath(cwd, edit.file)}\` L${range.start.line + 1}:${range.start.character + 1} → L${range.end.line + 1}:${range.end.character + 1}`,
     );
     lines.push("  ```");
-    lines.push(`  ${edit.newText.slice(0, 80).split("\n").join("\n  ")}`);
+    lines.push(`  ${edit.newText.split("\n").join("\n  ")}`);
     lines.push("  ```");
   }
-  const disclosure = renderEvidenceListDisclosure(editEvidence);
+  const disclosure = renderEvidenceListDisclosure(edits);
   if (disclosure) {
     lines.push(disclosure);
   }
   lines.push("");
   lines.push("**This is a preview. No files were changed.**");
-  lines.push(`Use code_refactor_apply with planId: "${plan.id}" to apply this refactor.`);
+  lines.push(...assembledNextQueries(assembly.assembled));
   return lines.join("\n");
 }
 
-/**
- * Render a refactor apply result.
- */
-export function renderRefactorApplyResult(applyResult: ApplyResult, plan: RefactorPlan): string {
-  if (applyResult.kind === "error") {
-    return `**Refactor apply failed:** ${applyResult.reason}`;
+/** Render a refactor apply outcome from its canonical assembled facts. */
+export function renderRefactorApplyResult(assembly: RefactorApplyResultAssembly): string {
+  const { plan, result } = assembly.assembled.data;
+  if (result.kind === "error") {
+    return `**Refactor apply failed:** ${result.reason}`;
   }
+
   const lines = [
     `**Refactor applied successfully.** Plan: \`${plan.id}\``,
     `- Operation: \`${plan.operation}\``,
-    `- Files changed: ${applyResult.filesChanged}`,
-    `- Total edits: ${applyResult.totalEdits}`,
+    `- Confidence: \`${assembly.assembled.confidence}\``,
+    `- Files changed: ${result.filesChanged}`,
+    `- Total edits: ${result.totalEdits}`,
   ];
   if (plan.newName) {
     lines.push(`- New name: \`${plan.newName}\``);
@@ -105,11 +79,14 @@ export function renderRefactorApplyResult(applyResult: ApplyResult, plan: Refact
   if (plan.destination) {
     lines.push(`- Destination: \`${plan.destination}\``);
   }
-  lines.push("", "Verify the changes before continuing with other work.");
+  const followUps = assembledNextQueries(assembly.assembled);
+  if (followUps.length > 0) lines.push("", ...followUps);
   return lines.join("\n");
 }
 
-function collectChangedFiles(plan: RefactorPlan): Array<[file: string, count: number]> {
+function collectChangedFiles(
+  plan: RefactorPlanResultAssembly["assembled"]["data"]["plan"],
+): Array<[file: string, count: number]> {
   const counts = new Map<string, number>();
   for (const edit of plan.edits.edits) {
     counts.set(edit.file, (counts.get(edit.file) ?? 0) + 1);

package/src/tool/refactor-plan/tui.ts

@@ -9,22 +9,21 @@ import { type ResultOptios, renderSimpleResult, type ToolResult } from "../../ui
 
 export function renderRefactorPlanCall(args: unknown, theme: Theme, _context: unknown): Text {
   const params = (args ?? {}) as {
-    operation?: string;
-    newName?: string;
-    file?: string;
+    operation?: Record<string, { newName?: string }>;
+    target?: { anchor?: { file: string }; handle?: string };
   };
 
   let content = theme.fg("toolTitle", "code_refactor_plan");
-
-  if (params.operation) {
-    content += ` ${theme.fg("accent", params.operation)}`;
+  const operation = params.operation ? Object.entries(params.operation)[0] : undefined;
+  if (operation) {
+    content += ` ${theme.fg("accent", operation[0])}`;
+    if (operation[1].newName) content += ` ${theme.fg("muted", operation[1].newName)}`;
   }
-
-  if (params.newName) {
-    content += ` ${theme.fg("muted", params.newName)}`;
-  } else if (params.file) {
-    const file = params.file.split("/").pop() ?? params.file;
+  if (params.target?.anchor) {
+    const file = params.target.anchor.file.split("/").pop() ?? params.target.anchor.file;
     content += ` ${theme.fg("muted", file)}`;
+  } else if (params.target?.handle) {
+    content += ` ${theme.fg("muted", params.target.handle)}`;
   }
 
   return new Text(content, 0, 0);

package/src/tool/register.ts

@@ -11,7 +11,6 @@ import {
   type CodeIntelligenceToolPromptSurfaceMap,
 } from "./guidance.ts";
 import { renderHealthCall, renderHealthResult } from "./health/tui.ts";
-import { renderImpactCall, renderImpactResult } from "./impact/tui.ts";
 import { truncateToolContent } from "./infra/truncate.ts";
 import { renderInspectCall, renderInspectResult } from "./inspect/tui.ts";
 import { renderOrientationCall, renderOrientationResult } from "./orientation/tui.ts";
@@ -20,6 +19,9 @@ import { renderRefactorPlanCall, renderRefactorPlanResult } from "./refactor-pla
 import { renderResolveCall, renderResolveResult } from "./resolve/tui.ts";
 import { CODE_INTELLIGENCE_TOOL_SPECS, type CodeIntelligenceToolDefinitionSpec } from "./specs.ts";
 
+const TOOL_OUTPUT_CONTRACT =
+  " Output over 2000 lines or 50KB is truncated, with full Markdown saved to a temporary file.";
+
 interface ToolRenderer {
   // biome-ignore lint/suspicious/noExplicitAny: pi render call/result signatures vary per tool; spread into pi.registerTool where concrete typing handles variance
   renderCall?: (...args: any[]) => Component;
@@ -51,8 +53,6 @@ function getToolRenderer(name: string): ToolRenderer {
       return { renderCall: renderInspectCall, renderResult: renderInspectResult };
     case "code_find":
       return { renderCall: renderFindCall, renderResult: renderFindResult };
-    case "code_impact":
-      return { renderCall: renderImpactCall, renderResult: renderImpactResult };
     case "code_refactor_plan":
       return {
         renderCall: renderRefactorPlanCall,
@@ -85,13 +85,14 @@ export function registerCodeIntelligenceTools(
     pi.registerTool({
       name: spec.name,
       label: spec.label,
-      description: surface.description,
+      description: surface.description + TOOL_OUTPUT_CONTRACT,
       promptSnippet: surface.promptSnippet,
       promptGuidelines: surface.promptGuidelines,
       parameters: spec.parameters,
       // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
       execute: async (_toolCallId, params, signal, onUpdate, ctx: ExtensionContext) => {
         const session = getOrCreateSession(ctx.cwd);
+        session.setProjectTrusted(ctx.isProjectTrusted());
         const { content, details } = await spec.run(params, {
           cwd: ctx.cwd,
           signal,
@@ -102,7 +103,7 @@ export function registerCodeIntelligenceTools(
           maxLines: spec.maxLines,
           maxBytes: spec.maxBytes,
         });
-        if (truncated && spec.spillToTempFile && content.length > 0) {
+        if (truncated && content.length > 0) {
           const dir = mkdtempSync(join(tmpdir(), "supi-ci-"));
           const spillPath = join(dir, `${spec.name}-output.md`);
           writeFileSync(spillPath, content, "utf-8");

package/src/tool/resolve/execute.ts

@@ -1,82 +1,36 @@
-/**
- * Tool executor for code_resolve.
- *
- * Thin adapter: validates params, gates readiness, delegates to orchestrate.
- */
+/** Thin Pi adapter for code_resolve. */
 
+import type { ResolveTargetInput } from "../../session/target-input.ts";
 import type { CodeIntelResult, CodeIntelToolExecCtx } from "../../types/index.ts";
-import { resolveCrossFieldRules } from "../infra/cross-field.ts";
-import { unavailableResolveDetails } from "../infra/error-results.ts";
-import {
-  expandTargetId,
-  gateSemanticReadiness,
-  resolveScopeParam,
-  runPipe,
-  validateParams,
-} from "../infra/pipeline.ts";
-import { renderSemanticReadinessTimeout } from "../infra/readiness-message.ts";
-import { orchestrateResolve } from "./orchestrate.ts";
+import { toWorkflowControl } from "../infra/workflow-control.ts";
+import { assembleResolveResult, suggestedResolveRelations } from "../result/resolve.ts";
+import { renderResolveResult } from "./markdown.ts";
 
 export interface CodeResolveToolParams {
-  query?: string;
-  scope?: string;
-  kind?: string;
-  file?: string;
-  line?: number;
-  character?: number;
+  target: ResolveTargetInput;
   maxResults?: number;
-  targetId?: string;
 }
 
 export async function executeResolveTool(
   params: CodeResolveToolParams,
   ctx: CodeIntelToolExecCtx,
 ): Promise<CodeIntelResult> {
-  const needsSemantic = Boolean(params.query) && params.kind !== "file" && params.kind !== "File";
+  const outcome = await ctx.session.resolve(params, toWorkflowControl(ctx));
+  if (outcome.kind === "unavailable") {
+    throw new Error(outcome.reason);
+  }
 
-  return runPipe(
-    params,
-    ctx,
-    [
-      expandTargetId((msg) => ({
-        content: msg,
-        details: unavailableResolveDetails([
-          "Fix the input parameters and retry",
-          "Use anchored `file` + `line` + `character` or a `query` for resolution",
-        ]),
-      })),
-      resolveScopeParam((reason) => ({
-        content: `**Error:** ${reason}`,
-        details: unavailableResolveDetails([
-          "Verify the `scope` path exists and is within the workspace",
-          "Use an existing workspace-relative file or directory path",
-        ]),
-      })),
-      validateParams(resolveCrossFieldRules, (msg) => ({
-        content: msg,
-        details: unavailableResolveDetails([
-          "Fix the input parameters and retry",
-          "Use anchored `file` + `line` + `character` or a `query` for resolution",
-        ]),
-      })),
-      ...(needsSemantic
-        ? [
-            gateSemanticReadiness("code_resolve", {
-              onTimeout: () => ({
-                content: renderSemanticReadinessTimeout("code_resolve", 15_000),
-                details: unavailableResolveDetails(["Retry shortly or check `code_health`"]),
-              }),
-              throwOnUnavailable: true,
-            }),
-          ]
-        : []),
-    ],
-    async (p, c) => {
-      return orchestrateResolve({
-        params: { ...p, scope: p.scope },
-        session: c.session,
-        cwd: c.cwd,
-      });
-    },
-  );
+  const assembly = assembleResolveResult(outcome, ctx.cwd);
+  let content = renderResolveResult(assembly);
+  if (outcome.kind === "resolved") {
+    const relations = suggestedResolveRelations(outcome.entry.kind);
+    content +=
+      `\n\nChain next: \`code_graph({ target: { handle: "${outcome.entry.targetId}" }, ` +
+      `relations: ${JSON.stringify(relations)} })\``;
+  }
+
+  return {
+    content,
+    details: { type: "resolve", data: assembly.details },
+  };
 }