dsh-hashline-edit 0.2.0 → 0.2.2

package/src/edit-render.ts

@@ -0,0 +1,161 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { getPreviewInput as contractPreviewInput, type EditItem } from "./payload-contract.js";
+import type { EditDetails } from "./edit-response.js";
+
+export type FgT = Pick<Theme, "fg">;
+export type CallT = Pick<Theme, "fg" | "bold">;
+export type MdTheme = Pick<Theme, "fg" | "bold" | "italic" | "underline" | "strikethrough">;
+
+export type RPreview = { diff: string } | { error: string };
+
+export type RRState = {
+  argsKey?: string;
+  preview?: RPreview;
+  previewGeneration?: number;
+  previewTimer?: ReturnType<typeof setTimeout>;
+};
+
+export function getPreviewInput(args: unknown): { file: string; edits: EditItem[] } | null {
+  return contractPreviewInput(args);
+}
+
+export function colorLines(lines: string[], theme: FgT): string[] {
+  return lines.map((line) => {
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      return theme.fg("success", line);
+    }
+    if (line.startsWith("-") && !line.startsWith("---")) {
+      return theme.fg("error", line);
+    }
+    return theme.fg("dim", line);
+  });
+}
+
+export function fmtPreview(diff: string, expanded: boolean, theme: FgT): string {
+  const lines = diff.split("\n");
+  const maxLines = expanded ? 40 : 16;
+  const shown = colorLines(lines.slice(0, maxLines), theme);
+
+  if (lines.length > maxLines) {
+    shown.push(theme.fg("muted", `... ${lines.length - maxLines} more diff lines`));
+  }
+  return shown.join("\n");
+}
+
+export function fmtResult(diff: string, theme: FgT): string {
+  return colorLines(diff.split("\n"), theme).join("\n");
+}
+
+export function fmtCall(
+  args: { file: string; edits: EditItem[] } | null,
+  state: RRState,
+  expanded: boolean,
+  theme: CallT,
+): string {
+  const path = args?.file;
+  const pathDisplay =
+    typeof path === "string" && path.length > 0
+      ? theme.fg("accent", path)
+      : theme.fg("toolOutput", "...");
+  const arity = args && args.edits.length > 1 ? ` (${args.edits.length} edits)` : "";
+  let text = `${theme.fg("toolTitle", theme.bold("edit"))} ${pathDisplay}${arity}`;
+
+  if (!state.preview) {
+    return text;
+  }
+
+  if ("error" in state.preview) {
+    text += `\n\n${theme.fg("error", state.preview.error)}`;
+    return text;
+  }
+
+  if (state.preview.diff) {
+    text += `\n\n${fmtPreview(state.preview.diff, expanded, theme)}`;
+  }
+  return text;
+}
+
+export function getResultText(result: {
+  content?: Array<{ type: string; text?: string }>;
+}): string | undefined {
+  const textContent = result.content?.find(
+    (entry): entry is { type: "text"; text: string } =>
+      entry.type === "text" && typeof entry.text === "string",
+  );
+  return textContent?.text;
+}
+
+export function isApplied(details: EditDetails | undefined): boolean {
+  const metrics = details?.metrics;
+  return (
+    metrics?.classification === "applied" &&
+    metrics.added_lines !== undefined &&
+    metrics.removed_lines !== undefined
+  );
+}
+
+export function buildAppliedText(details: EditDetails | undefined, theme: FgT): string | undefined {
+  const sections: string[] = [];
+  if (details?.diff) {
+    sections.push(fmtResult(details.diff, theme));
+  }
+  const warnings = details?.warnings;
+  if (warnings?.length) {
+    sections.push(theme.fg("dim", warnings.join("\n")));
+  }
+  const driftNotice = details?.driftNotice;
+  if (driftNotice) {
+    sections.push(theme.fg("dim", driftNotice));
+  }
+  return sections.length > 0 ? sections.join("\n\n") : undefined;
+}
+function trimEmpty(lines: string[]): string[] {
+  let start = 0;
+  let end = lines.length;
+
+  while (start < end && lines[start] === "") {
+    start++;
+  }
+  while (end > start && lines[end - 1] === "") {
+    end--;
+  }
+
+  return lines.slice(start, end);
+}
+
+export function fmtResultMd(text: string): string {
+  return trimEmpty(text.split("\n")).join("\n");
+}
+
+export function mkMdTheme(theme: MdTheme) {
+  return {
+    heading: (text: string) => theme.fg("mdHeading", text),
+    link: (text: string) => theme.fg("mdLink", text),
+    linkUrl: (text: string) => theme.fg("mdLinkUrl", text),
+    code: (text: string) => theme.fg("mdCode", text),
+    codeBlock: (text: string) => theme.fg("mdCodeBlock", text),
+    codeBlockBorder: (text: string) => theme.fg("mdCodeBlockBorder", text),
+    quote: (text: string) => theme.fg("mdQuote", text),
+    quoteBorder: (text: string) => theme.fg("mdQuoteBorder", text),
+    hr: (text: string) => theme.fg("mdHr", text),
+    listBullet: (text: string) => theme.fg("mdListBullet", text),
+    bold: (text: string) => theme.bold(text),
+    italic: (text: string) => (theme.italic ? theme.italic(text) : text),
+    underline: (text: string) => (theme.underline ? theme.underline(text) : text),
+    strikethrough: (text: string) => (theme.strikethrough ? theme.strikethrough(text) : text),
+    highlightCode: (code: string, lang?: string) =>
+      code.split("\n").map((line) => {
+        if (lang === "diff") {
+          if (line.startsWith("+") && !line.startsWith("+++")) {
+            return theme.fg("toolDiffAdded", line);
+          }
+          if (line.startsWith("-") && !line.startsWith("---")) {
+            return theme.fg("toolDiffRemoved", line);
+          }
+          return theme.fg("toolDiffContext", line);
+        }
+
+        return theme.fg("mdCodeBlock", line);
+      }),
+  };
+}

package/src/edit-tool.ts

@@ -0,0 +1,118 @@
+/** SAFETY: EditTool — deep module owning the edit Use Case seam.
+ *
+ * Graded surface: one narrow interface `EditTool { execute, preview }`
+ * hides pipeline delegation, warnings/drift stitching.
+ * Frameworks (pi TUI) never cross this seam — that lives in TuiPresenter.
+ * Clean Architecture: Use Cases depend inward only (mutation-engine),
+ * never outward to Frameworks.
+ *
+ * Typed boundaries: validate once at admission (payload-contract via normReq/assertReq),
+ * trust inside. Immutable state: never mutates caller-owned request.
+ */
+
+import { constants } from "node:fs";
+import { sessionKeyFor } from "./served-session/session.js";
+import { normReq, assertReq, type NormalizedEditRequest } from "./payload-contract.js";
+import { execute as engineExecute, preview as enginePreview } from "./mutation-engine/engine.js";
+import { isMutationSuccess } from "./mutation-engine/types.js";
+import { attachEnvelope } from "./error-envelope.js";
+
+type EditToolContext = {
+  cwd: string;
+  sessionManager?: { getSessionId(): string };
+};
+
+export type PreviewContext = {
+  sessionManager?: { getSessionId(): string };
+};
+
+type PreviewResult = { diff: string } | { error: string };
+
+export interface EditTool {
+  /** SAFETY: Execute a validated edit; returns pi tool_result or throws on failure. Admission: params validated by normReq/assertReq. */
+  execute(
+    params: unknown,
+    signal: AbortSignal | undefined,
+    ctx: EditToolContext,
+  ): Promise<{
+    content: Array<{ type: "text"; text: string }>;
+    details: unknown;
+  }>;
+  /** SAFETY: Preview without persisting — mirrors pi's compPreview(request, cwd, ctx). The ctx must carry the session whose serves the anchors came from (#165). */
+  preview(request: unknown, cwd: string, ctx: PreviewContext): Promise<PreviewResult>;
+}
+
+export function createEditTool(): EditTool {
+  return {
+    async execute(params, signal, ctx) {
+      const canonical = normReq(params);
+      assertReq(canonical);
+      // SAFETY: ctx is untyped at pi boundary — cast validated by pi's runtime context shape (cwd + sessionManager)
+      const sessionKey = sessionKeyFor(
+        ctx as unknown as { sessionManager?: { getSessionId(): string } },
+      );
+      // SAFETY: canonical is validated NormalizedEditRequest after assertReq — trusted inside boundary
+      const result = await engineExecute(canonical as NormalizedEditRequest, ctx.cwd, {
+        accessMode: constants.R_OK | constants.W_OK,
+        // SAFETY: signal is AbortSignal | undefined at pi boundary — runtime check via engine's abortIf
+        ...(signal !== undefined ? { signal } : {}),
+        sessionKey,
+      });
+      if (isMutationSuccess(result)) {
+        // SAFETY: toolResult is validated by isMutationSuccess discriminated union guard
+        return result.toolResult as {
+          content: Array<{ type: "text"; text: string }>;
+          details: unknown;
+        };
+      }
+      // WHY: every range-family producer emits `details.cause` (user-facing diagnosis) —
+      // WHY: carry it on the thrown error so callers catching the message still see the cause.
+      // WHY: the whole failure envelope (code, diagnosis, rows, block) is stamped through the
+      // WHY: envelope assembler (src/error-envelope.ts) — this seam never hand-copies fields.
+      const failure = new Error(result.message);
+      attachEnvelope(failure, {
+        code: result.code,
+        ...(result.cause !== undefined ? { cause: result.cause } : {}),
+        // WHY: the raw payload message rides the envelope so the adapter can name the tool.
+        // WHY: The rendered message alone cannot say which call raised the refusal.
+        ...(result.payloadMessage !== undefined ? { payloadMessage: result.payloadMessage } : {}),
+        servedRows: result.servedRows ?? [],
+        servedBlock: result.servedBlock ?? "",
+      });
+      throw failure;
+    },
+    async preview(request, cwd, ctx) {
+      try {
+        const normalized = normReq(request);
+        assertReq(normalized);
+        // SAFETY: normalized is validated NormalizedEditRequest after assertReq
+        // WHY: (#165) preview verifies against the SAME session the anchors were served to —
+        // WHY: without a session, sessionKeyFor fails loud here instead of minting a key whose
+        // WHY: lease lookups all miss as a misleading E_UNKNOWN_ANCHOR.
+        const result = await enginePreview(normalized as NormalizedEditRequest, cwd, {
+          accessMode: constants.R_OK,
+          sessionKey: sessionKeyFor(ctx),
+        });
+        if (!isMutationSuccess(result)) {
+          return { error: result.message };
+        }
+        const file = result.raw;
+        // WHY: the call's own classification, not the primary file's bytes: a multi-file edit may
+        // WHY: change another file while the primary stands still, and that IS a change to preview.
+        if (result.metrics.classification === "noop") {
+          return {
+            error: `No changes made to ${file.path}. The edit produced identical content.`,
+          };
+        }
+        return {
+          // WHY: #174 single projection — the engine's `preview` seam already produced the
+          // WHY: `genDiff` text with the pane's context; this display path renders it and
+          // WHY: never re-projects.
+          diff: result.diff,
+        };
+      } catch (error: unknown) {
+        return { error: error instanceof Error ? error.message : String(error) };
+      }
+    },
+  };
+}