@mrclrchtr/supi-code-intelligence 3.2.0 → 4.1.0

package/src/tool/orientation/precise-target.ts

@@ -1,253 +0,0 @@
-/**
- * Precise-target resolution and execution for code_orientation.
- *
- * Handles targetId expansion, coordinate-based symbol resolution, and
- * running the use-case layer for a resolved symbol target. Shared by
- * the main code_orientation executor.
- *
- * Uses the session target workflow (deep seam) instead of ad-hoc
- * expandTargetId / executeResolveService calls.
- */
-
-import { relative } from "node:path";
-import type { TargetWorkflowOutcome } from "../../session/session.ts";
-import type { TargetStoreEntry } from "../../session/target-store.ts";
-import type { CodeIntelResult, CodeIntelToolExecCtx, ContextDetails } from "../../types/index.ts";
-import { orientationCoordinateRules } from "../infra/cross-field.ts";
-import { unavailableContextDetails } from "../infra/error-results.ts";
-import { assembleOrientationDetails } from "../result/orientation.ts";
-import { prepareOrientationDeps } from "./deps.ts";
-import type { CodeOrientationToolParams } from "./execute.ts";
-import { executeOrientation } from "./orchestrate.ts";
-
-/**
- * A resolved precise target: the store entry (with handles) plus
- * contextual notes (e.g. "targetId took precedence over focus").
- */
-export interface PreciseTarget {
-  entry: TargetStoreEntry;
-  notes: string[];
-}
-
-/**
- * Outcome of precise-target resolution in code_orientation.
- */
-export type PreciseTargetOutcome =
-  | { kind: "resolved"; result: CodeIntelResult }
-  | { kind: "fallthrough" };
-
-/** Orientation target-workflow policy: file-level not for precise, name anchor not required. */
-const ORIENTATION_TARGET_POLICY = {
-  fileLevelAllowed: false,
-  nameAnchorRequired: false,
-  waitForSemantic: true,
-} as const;
-
-/**
- * Resolve a precise target ({@link CodeOrientationToolParams.targetId}
- * wins over focus/coordinates), then run symbol-centered orientation
- * sections. Falls through to orientation-mode when both targetId
- * expansion and coordinate resolution produce no target.
- */
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: layered resolution + disambiguation + section building stays together for clarity
-export async function resolvePreciseTarget(
-  params: CodeOrientationToolParams,
-  ctx: CodeIntelToolExecCtx,
-  hasCoords: boolean,
-): Promise<PreciseTargetOutcome> {
-  // ── Deep seam: resolve through session target workflow ──
-  if (params.targetId !== undefined && params.targetId !== null) {
-    const outcome = await ctx.session.resolveTarget(
-      {
-        targetId: params.targetId,
-        file: hasCoords ? params.focus : undefined,
-        line: hasCoords ? params.line : undefined,
-        character: hasCoords ? params.character : undefined,
-      },
-      ORIENTATION_TARGET_POLICY,
-    );
-    if (outcome.kind === "resolved") {
-      const precise: PreciseTarget = {
-        entry: outcome.entry,
-        notes: outcome.notes,
-      };
-      return wrapOutcome(await runWithOrientationTarget(params, ctx, precise));
-    }
-    if (outcome.kind === "invalid-input" || outcome.kind === "unavailable") {
-      return wrapOutcome({
-        content: `**Error:** ${outcome.kind === "invalid-input" ? outcome.message : outcome.reason}`,
-        details: unavailableContextDetails([
-          "Verify the `targetId` is valid and from this session",
-          "Re-resolve with `code_resolve` to get a fresh targetId",
-        ]),
-      });
-    }
-  }
-
-  if (hasCoords) {
-    const coordOutcome = await resolveCoordinateTarget(params, ctx);
-    if (coordOutcome.kind === "resolved") return coordOutcome;
-  }
-
-  return { kind: "fallthrough" };
-}
-
-/** Resolve a focus+coordinate-supplied precise target, or fallthrough. */
-async function resolveCoordinateTarget(
-  params: CodeOrientationToolParams,
-  ctx: CodeIntelToolExecCtx,
-): Promise<PreciseTargetOutcome> {
-  const coordError = validateCoordinateParams(params, ctx.cwd);
-  if (coordError) {
-    return wrapOutcome({
-      content: coordError,
-      details: unavailableContextDetails([
-        "Provide `focus`, `line`, and `character` together for symbol orientation",
-      ]),
-    });
-  }
-
-  const outcome = await ctx.session.resolveTarget(
-    { file: params.focus, line: params.line, character: params.character },
-    ORIENTATION_TARGET_POLICY,
-  );
-
-  if (outcome.kind === "resolved") {
-    return wrapOutcome(
-      await runWithOrientationTarget(params, ctx, { entry: outcome.entry, notes: outcome.notes }),
-    );
-  }
-
-  if (outcome.kind === "disambiguation") {
-    return wrapOutcome(disambiguationResult(outcome));
-  }
-
-  if (outcome.kind === "invalid-input") {
-    return wrapOutcome({
-      content: outcome.message,
-      details: unavailableContextDetails([
-        "Use `code_inspect` for point-level facts at this coordinate",
-        "Or pass the identifier coordinate of a declaration",
-      ]),
-    });
-  }
-
-  return wrapOutcome({
-    content: "**Error:** Coordinate resolution returned no target.",
-    details: unavailableContextDetails(["Use `code_inspect` for point-level facts"]),
-  });
-}
-
-/** Wrap a CodeIntelResult into a resolved PreciseTargetOutcome. */
-function wrapOutcome(result: CodeIntelResult): PreciseTargetOutcome {
-  return { kind: "resolved", result };
-}
-
-async function runWithOrientationTarget(
-  params: CodeOrientationToolParams,
-  ctx: CodeIntelToolExecCtx,
-  precise: PreciseTarget,
-): Promise<CodeIntelResult> {
-  const entry = precise.entry;
-  params.file = entry.file;
-  params.line = entry.displayLine;
-  params.character = entry.displayCharacter;
-  params.targetName = entry.name;
-  params.targetKind = entry.kind;
-  params.targetAnchorKind = entry.anchorKind;
-
-  const deps = await prepareOrientationDeps(params, ctx);
-  if ("content" in deps) return deps;
-
-  const result = await executeOrientation(
-    {
-      target: buildOrientationTarget(params),
-      maxResults: params.maxResults ?? 10,
-      showGitContext: false,
-    },
-    { ...deps, cwd: ctx.cwd },
-  );
-
-  const content = prependNotes(result.content, precise.notes, entry, ctx.cwd);
-  const details: ContextDetails = { ...result.details, target: entry };
-  return { content, details: { type: "context", data: details } };
-}
-
-// ── Helpers ───────────────────────────────────────────────────────────
-
-/** Cross-field rule for code_orientation coordinate mode. */
-const validateCoordinateParams = orientationCoordinateRules<CodeOrientationToolParams>();
-
-function buildOrientationTarget(params: CodeOrientationToolParams) {
-  if (!params.file || params.line == null || params.character == null) return null;
-  return {
-    file: params.file,
-    line: params.line,
-    character: params.character,
-    name: params.targetName ?? null,
-    kind: params.targetKind ?? null,
-    anchorKind: params.targetAnchorKind ?? "name",
-  };
-}
-
-/** Prepend notes + a resolved-target summary to rendered orientation content. */
-function prependNotes(
-  content: string,
-  notes: string[],
-  entry: TargetStoreEntry,
-  cwd: string,
-): string {
-  const head: string[] = [];
-  if (notes.length > 0) {
-    head.push(notes.join("\n\n"));
-    head.push("");
-  }
-  const namePart = entry.name ? ` **${entry.name}**` : "";
-  const relFile = relative(cwd, entry.file) || entry.file;
-  head.push(
-    `Resolved target${namePart}: \`${relFile}\`:${entry.displayLine}:${entry.displayCharacter} — Target ID: \`${entry.targetId}\``,
-  );
-  head.push("");
-  return `${head.join("\n")}${content}`;
-}
-
-// ── Disambiguation ────────────────────────────────────────────────────
-
-/** Build the ambiguous-coordinate result: candidate targetIds, no sections. */
-function disambiguationResult(
-  outcome: Extract<TargetWorkflowOutcome, { kind: "disambiguation" }>,
-): CodeIntelResult {
-  const lines: string[] = ["# Multiple matches found", ""];
-  lines.push(
-    "Coordinate resolution was ambiguous. Use `focus` + `line` + `character` for one of the candidates (pass the identifier coordinate):",
-  );
-  lines.push("");
-  for (const c of outcome.candidates) {
-    const kind = c.kind ? ` (\`${c.kind}\`)` : "";
-    const container = c.container ? ` in \`${c.container}\`` : "";
-    lines.push(
-      `${c.rank}. **${c.name}**${kind}${container} — \`${c.file}\`:${c.line}:${c.character}`,
-    );
-    lines.push(`   Target ID: \`${c.targetId}\``);
-  }
-
-  const details: ContextDetails = assembleOrientationDetails({
-    confidence: "semantic",
-    omittedCount: outcome.omittedCount,
-    candidates: outcome.candidates.map((c) => ({
-      targetId: c.targetId,
-      name: c.name,
-      kind: c.kind,
-      container: c.container,
-      file: c.file,
-      line: c.line,
-      character: c.character,
-      rank: c.rank,
-    })),
-    nextQueries: [
-      "Use `focus` + `line` + `character` for one of the candidates above (pass the identifier coordinate)",
-    ],
-  });
-
-  return { content: lines.join("\n"), details: { type: "context", data: details } };
-}

package/src/tool/params.ts

@@ -1,15 +0,0 @@
-/** Shared parameter bag for internal code-intelligence actions. */
-export interface CodeQueryParams {
-  path?: string;
-  file?: string;
-  line?: number;
-  character?: number;
-  symbol?: string;
-  pattern?: string;
-  regex?: boolean;
-  kind?: string;
-  exportedOnly?: boolean;
-  maxResults?: number;
-  contextLines?: number;
-  summary?: boolean;
-}

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

@@ -1,118 +0,0 @@
-/**
- * Markdown renderer for refactor results.
- */
-
-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 "./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 {
-  const lines: string[] = [];
-  const changedFiles = collectChangedFiles(plan);
-  const fileCount = changedFiles.length;
-
-  lines.push(`# Refactor Plan: ${plan.operation}`);
-  lines.push("");
-  lines.push(`**Plan ID:** \`${plan.id}\``);
-  lines.push(`**Operation:** \`${plan.operation}\``);
-  lines.push(
-    `**Target:** \`${toDisplayPath(cwd, plan.targetFile)}\`:${plan.targetLine}:${plan.targetCharacter}`,
-  );
-  if (plan.newName) {
-    lines.push(`**New name:** \`${plan.newName}\``);
-  }
-  if (plan.destination) {
-    lines.push(`**Destination:** \`${plan.destination}\``);
-  }
-  lines.push(`**Files to change:** ${fileCount} file${fileCount !== 1 ? "s" : ""}`);
-  lines.push(`**Total edits:** ${plan.edits.edits.length}`);
-  lines.push("");
-
-  lines.push("## Files");
-  for (const [file, count] of changedFiles) {
-    lines.push(`- \`${toDisplayPath(cwd, file)}\` — ${count} edit${count !== 1 ? "s" : ""}`);
-  }
-  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) {
-    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}`,
-    );
-    lines.push("  ```");
-    lines.push(`  ${edit.newText.slice(0, 80).split("\n").join("\n  ")}`);
-    lines.push("  ```");
-  }
-  const disclosure = renderEvidenceListDisclosure(editEvidence);
-  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.`);
-  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}`;
-  }
-  const lines = [
-    `**Refactor applied successfully.** Plan: \`${plan.id}\``,
-    `- Operation: \`${plan.operation}\``,
-    `- Files changed: ${applyResult.filesChanged}`,
-    `- Total edits: ${applyResult.totalEdits}`,
-  ];
-  if (plan.newName) {
-    lines.push(`- New name: \`${plan.newName}\``);
-  }
-  if (plan.destination) {
-    lines.push(`- Destination: \`${plan.destination}\``);
-  }
-  lines.push("", "Verify the changes before continuing with other work.");
-  return lines.join("\n");
-}
-
-function collectChangedFiles(plan: RefactorPlan): 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);
-  }
-  return [...counts.entries()];
-}

package/src/tool/refactor-apply/orchestrate.ts

@@ -1,84 +0,0 @@
-/**
- * Refactor apply orchestration use-case.
- *
- * Handles plan lookup, freshness checking, safety re-validation, and
- * workspace edit application for a previously stored refactor plan.
- * Returns a rendered CodeIntelResult.
- *
- * Extracted from execute-refactor-apply.ts as part of the thin-executor
- * normalization.
- */
-
-import { validateEdit } from "../../analysis/refactor/safety.ts";
-import { isPlanFresh } from "../../session/refactor-plans.ts";
-import type { WorkspaceCodeIntelligenceSession } from "../../session/session.ts";
-import type { CodeIntelResult } from "../../types/index.ts";
-import { unavailableSearchDetails } from "../infra/error-results.ts";
-import { renderRefactorApplyResult } from "../refactor-plan/markdown.ts";
-import { assembleRefactorApplyDetails } from "../result/refactor.ts";
-import { applyWorkspaceEdit } from "./apply.ts";
-
-export interface RefactorApplyInput {
-  planId: string;
-}
-
-export interface RefactorApplyDeps {
-  session: WorkspaceCodeIntelligenceSession;
-}
-
-/**
- * Execute the refactor apply use-case.
- *
- * Validates plan existence, freshness, and safety, then applies the
- * workspace edit. Removes the plan from the session store on success.
- */
-export async function executeRefactorApply(
-  input: RefactorApplyInput,
-  deps: RefactorApplyDeps,
-): Promise<CodeIntelResult> {
-  if (!input.planId) {
-    return {
-      content: "**Error:** `planId` is required.",
-      details: unavailableSearchDetails(null, ["Provide a valid `planId` from code_refactor_plan"]),
-    };
-  }
-
-  const plan = deps.session.getPlan(input.planId);
-  if (!plan) {
-    return {
-      content: `**Error:** Plan "${input.planId}" not found. The plan may have expired or was generated in a different session. Use code_refactor_plan to generate a new plan.`,
-      details: unavailableSearchDetails(null, ["Run code_refactor_plan to generate a new plan"]),
-    };
-  }
-
-  const freshness = isPlanFresh(plan);
-  if (!freshness.fresh) {
-    return {
-      content: `**Stale plan:** ${freshness.reason}`,
-      details: unavailableSearchDetails(null, ["Regenerate the plan with code_refactor_plan"]),
-    };
-  }
-
-  const validation = validateEdit(plan.edits);
-  if (!validation.safe) {
-    return {
-      content: `**Safety check failed:** ${validation.reason}. Regenerate the plan with code_refactor_plan.`,
-      details: unavailableSearchDetails(null, ["Regenerate the plan with code_refactor_plan"]),
-    };
-  }
-
-  const applyResult = await applyWorkspaceEdit(plan.edits);
-  if (applyResult.kind === "applied") {
-    deps.session.removePlan(plan.id);
-  }
-
-  const content = renderRefactorApplyResult(applyResult, plan);
-
-  return {
-    content,
-    details: {
-      type: "search" as const,
-      data: assembleRefactorApplyDetails(applyResult),
-    },
-  };
-}