dsh-hashline-edit 0.1.0 → 0.2.0

package/src/lifecycle-hooks/types.ts

@@ -1,64 +0,0 @@
-import type { ServedRow } from "../served-session/serve-render.js";
-import type { EditDetails } from "../edit-response.js";
-import type { NormFile, ReadNormOptions } from "../file-reader.js";
-import type { LFile, LoadFileOptions } from "../file-kind.js";
-import type { Hasher } from "../hashline/hasher.js";
-import type { TruncationResult } from "@earendil-works/pi-coding-agent";
-
-import type { DisplayTransform } from "../bash-classifier.js";
-
-export type ToolResultEvent = {
-  toolName: string;
-  isError: boolean;
-  input?: Record<string, unknown>;
-  content?: Array<{ type: string; text: string }>;
-  details?: EditDetails;
-};
-
-export type ToolContext = {
-  cwd: string;
-  sessionManager?: { getSessionId(): string };
-  ui: { notify: (msg: string, level: string) => void };
-};
-
-export type LifecycleDeps = {
-  initHasher: () => Promise<Hasher>;
-  pruneMissingAll: () => Promise<void>;
-  clearUndo: (path: string) => Promise<void>;
-  resolveTarget: (path: string) => Promise<string>;
-  toCwd: (path: string, cwd: string) => string;
-  valAccess: (resolved: string, display: string) => Promise<void>;
-  loadFileKindAndText: (path: string, opts?: LoadFileOptions) => Promise<LFile>;
-  readNormFile: (displayPath: string, cwd: string, opts?: ReadNormOptions) => Promise<NormFile>;
-  fmtReadPreview: (
-    normalized: string,
-    opts: {
-      offset?: number;
-      limit?: number;
-      sectionHeader?: (startLine: number, endLine: number, totalLines: number) => string;
-      windows?: Array<{ offset: number; limit: number }>;
-    },
-    fileHashes: string[],
-    absolutePath: string,
-    maxBytes: number,
-    maxLines: number,
-  ) => Promise<{ text: string; truncation?: TruncationResult; served: ServedRow[] }>;
-  recordDiffServes: (input: {
-    sessionKey: string;
-    path: string;
-    servedRows: ServedRow[];
-    /** Committed `file_snapshots.snapshot_hash` of the content served; binds the leases granted. */
-    contentHash: string;
-    resultLineCount?: number;
-    firstChangedLine?: number;
-    lastChangedLine?: number;
-  }) => Promise<void>;
-  sessionKeyFor: (ctx?: { sessionManager?: { getSessionId(): string } }) => string;
-  finalizeToolResult: (details: EditDetails) => {
-    content: Array<{ type: string; text: string }>;
-    servedRows?: ServedRow[];
-  };
-  visLines: (s: string) => string[];
-  /** (ADR-0048 D2) re-run the terminal display transform on the exact raw head bytes. */
-  runDisplayTransform: (transform: DisplayTransform, input: string) => Promise<string | undefined>;
-};

package/src/mutated-files.ts

@@ -1,75 +0,0 @@
-/**
- * Mutated-file observer seam — the domain-neutral notification of which file this tool just
- * changed, and which of its lines moved. Producers (edit, undo-last-edit, write) hand over the
- * 1-indexed changed ranges; this module fans them out to registered observers.
- *
- * WHY a seam: the mutated set is known deep in the mutation paths, while the consumer is an
- * optional outer integration that may be absent entirely (the mutation bridge). Inverting
- * the dependency here keeps every producer free of integration imports, and with no observer
- * registered the behavior of the tool is unchanged.
- *
- * Invariant: an empty `ranges` list means the WHOLE file changed (whole-file authorship, an undo
- * that re-serves the file, a producer that knows no line detail) — it is never "nothing happened",
- * so every notification is delivered. `src/served-spans.ts` makes the opposite choice for the same
- * word: an empty `spans` list there means nothing was served and is dropped. The two payloads read
- * alike but mean opposites, which is why the two seams stay separate modules.
- *
- * Invariant: no path handling lives here — `filePath` is the absolute normalized path the caller
- * already holds. Ranges are 1-indexed and expected ascending, non-overlapping, non-adjacent.
- */
-import type { ServedSpan } from "./served-spans.js";
-
-/** One file this tool changed, and the lines it changed. */
-export interface MutatedFileNotification {
-  /** Absolute normalized path supplied by the caller; never resolved or rewritten here. */
-  filePath: string;
-  /** `edit` is a partial change carrying `ranges`; `write` is whole-file authorship. */
-  kind: "edit" | "write";
-  /** 1-indexed changed ranges; EMPTY means the whole file changed. */
-  ranges: ServedSpan[];
-  /** Which tool produced the mutation, for consumers that attribute the write. */
-  sourceTool: "edit" | "undo_last_edit" | "write";
-}
-
-export type MutatedFileObserver = (notification: MutatedFileNotification) => void;
-
-let observers: MutatedFileObserver[] = [];
-
-/**
- * Register an observer. The returned unsubscribe is idempotent and removes exactly this
- * registration, so registering the same function twice yields two independent subscriptions.
- */
-export function addMutatedFileObserver(observer: MutatedFileObserver): () => void {
-  observers.push(observer);
-  return () => {
-    const index = observers.indexOf(observer);
-    if (index >= 0) observers.splice(index, 1);
-  };
-}
-
-/**
- * Fan out to a snapshot of the observers, in registration order.
- *
- * WHY the two deliberate choices: every notification is delivered — including one whose `ranges`
- * are empty, because empty means whole-file rather than nothing — and one throwing observer must
- * not starve the others. That failure belongs to the observer, never to the tool call whose write
- * already landed.
- */
-export function notifyMutatedFile(notification: MutatedFileNotification): void {
-  // WHY: a snapshot keeps this pass stable — an observer that subscribes or unsubscribes during
-  // WHY: fan-out must not change the recipient set mid-iteration.
-  const snapshot = observers.slice();
-  for (const observer of snapshot) {
-    try {
-      observer(notification);
-    } catch {
-      // SAFETY: observer isolation — a broken integration sink must never fail the edit or write
-      // SAFETY: that already landed, nor silence the remaining observers.
-    }
-  }
-}
-
-/** Test helper: drop every registration so observer state cannot leak between tests. */
-export function clearMutatedFileObserversForTests(): void {
-  observers = [];
-}

package/src/mutation-engine/engine.ts

@@ -1,173 +0,0 @@
-/**
- * SAFETY: MutationEngine — deep module behind the mutation seam.
- *
- * Small interface: `execute` + `preview`. Deep implementation: load → parse
- * → mutate → finalize → drift → persist → serve hidden inside the pipeline.
- * Internal seams (validate, verify, mutate, guard, persist, record) stay
- * private — not exported. The interface is the test surface.
- *
- * Typed boundaries: validate once at admission (edit.ts via payload-contract),
- * trust inside. Errors fail loud with typed `MutationFailure`.
- */
-
-import { apply as pipelineApply, previewEdits as pipelinePreview } from "./pipeline.js";
-import { genDiff } from "../edit-diff.js";
-import { DIFF_PREVIEW_CONTEXT } from "../constants.js";
-import type { PipelineOptions } from "./types.js";
-import type { MutationResult } from "./types.js";
-import type { NormalizedEditRequest } from "../payload-contract.js";
-import { DomainError, badPayloadMessageOf, type DomainErrorCode } from "../domain-errors.js";
-import { readEnvelope, type ErrorEnvelope } from "../error-envelope.js";
-
-function failureFromEnvelope(args: {
-  code: DomainErrorCode;
-  message: string;
-  env: ErrorEnvelope;
-  payloadMessage?: string;
-}): MutationResult {
-  const { code, message, env, payloadMessage } = args;
-  return {
-    ok: false,
-    code,
-    message,
-    ...(payloadMessage !== undefined ? { payloadMessage } : {}),
-    ...(env.servedRows !== undefined && env.servedRows.length > 0
-      ? { servedRows: env.servedRows }
-      : {}),
-    ...(env.servedBlock !== undefined ? { servedBlock: env.servedBlock } : {}),
-    ...(env.cause !== undefined ? { cause: env.cause, details: { code, cause: env.cause } } : {}),
-  };
-}
-
-function toFailure(error: unknown): MutationResult {
-  // WHY: registry errors carry their code, rows, block, and diagnosis as typed
-  // WHY: fields — the code is read, never scraped from the message, so a
-  // WHY: `[MODEL]`-only message can never surface as `code: "MODEL"`.
-  if (error instanceof DomainError) {
-    // WHY: a rendered refusal cannot be re-attributed at the tool seam.
-    // WHY: The RAW payload message travels beside it, undefined for every other code.
-    const payloadMessage = badPayloadMessageOf(error);
-    return failureFromEnvelope({
-      code: error.code,
-      message: error.message,
-      env: readEnvelope(error) ?? {},
-      ...(payloadMessage !== undefined ? { payloadMessage } : {}),
-    });
-  }
-  const message = error instanceof Error ? error.message : String(error);
-  // WHY: the batch-abort wrapper preserves the failing item's own code as a
-  // WHY: plain field — a registry member routes the typed path, while
-  // WHY: errno-style codes (ENOENT) and unexpected throws fall through to
-  // WHY: `E_UNKNOWN` instead of leaking a scraped token as the code. The
-  // WHY: envelope reader owns that validation: a non-registry code reads back
-  // WHY: as no code at all, which is exactly the fall-through condition.
-  const env = readEnvelope(error);
-  if (env !== undefined && env.code !== undefined) {
-    return failureFromEnvelope({ code: env.code, message, env });
-  }
-  // WHY: unexpected errors emit `E_UNKNOWN` through the registry: the first
-  // WHY: message line only, never the verbatim `String(error)` dump.
-  const unknown = new DomainError("E_UNKNOWN", {
-    errorName: error instanceof Error ? error.name : typeof error,
-    message,
-  });
-  return failureFromEnvelope({
-    code: unknown.code,
-    message: unknown.message,
-    env: readEnvelope(unknown) ?? {},
-  });
-}
-
-/**
- * SAFETY: Execute a mutation against the file system (persist + undo + serve).
- * Returns discriminated `MutationResult` — callers must switch on `ok`.
- *
- * No `any` threading: input is `NormalizedEditRequest` (validated at
- * admission), output is typed. Failures are `ok:false` with `code`, not
- * loose `isError` flags.
- */
-export async function execute(
-  request: NormalizedEditRequest,
-  cwd: string,
-  options?: PipelineOptions,
-): Promise<MutationResult> {
-  try {
-    const { result, diff, drift, metrics, raw, toolResult } = await pipelineApply(
-      request,
-      cwd,
-      options,
-    );
-    if (!metrics) throw new Error("missing metrics from pipeline — invariant violation");
-    return {
-      ok: true,
-      result,
-      diff,
-      drift,
-      metrics,
-      raw,
-      toolResult,
-    };
-  } catch (error) {
-    return toFailure(error);
-  }
-}
-
-/**
- * SAFETY: Preview a mutation without persisting (noPersist). Same seam as `execute`,
- * same `MutationResult` — one interface, N call sites (preview + apply share
- * the internal path via `runMutations` with `noPersist:true`).
- */
-export async function preview(
-  request: NormalizedEditRequest,
-  cwd: string,
-  options?: Omit<PipelineOptions, "noPersist">,
-): Promise<MutationResult> {
-  try {
-    // WHY: pipelinePreview does not persist and does not write undo — but still
-    // WHY: runs the full mutate→finalize→drift path.
-    const file = await pipelinePreview(request, cwd, options);
-    // WHY: #174 single-projection contract — the preview diff IS the `genDiff` projection,
-    // WHY: produced here at the same seam that returns execute's projected `diff`, with the
-    // WHY: preview pane's context (`DIFF_PREVIEW_CONTEXT`). The display path (`edit-tool
-    // WHY: preview` → preview-controller → edit-render) consumes this text and never
-    // WHY: re-projects; `file` already carries everything `genDiff` needs, so no side
-    // WHY: decision of an empty diff is synthesized here.
-    const diff = genDiff(
-      file.originalNormalized,
-      file.result,
-      DIFF_PREVIEW_CONTEXT,
-      file.resultHashes,
-      file.originalHashes,
-    ).diff;
-    const metrics: import("../edit-response.js").RMetrics = {
-      classification: (file.appliedCount > 0 ? "applied" : "noop") as "applied" | "noop",
-      edits_attempted: file.appliedCount + file.noopCount,
-      edits_noop: file.noopCount,
-      warnings: file.warnings.length,
-      added_lines: file.totalAddedLines,
-      removed_lines: file.totalRemovedLines,
-      ...(file.literalDeclarations > 0 ? { literalDeclarations: file.literalDeclarations } : {}),
-    };
-    const details: import("../edit-response.js").EditDetails = {
-      diff,
-      ...(file.warnings.length > 0 ? { warnings: file.warnings } : {}),
-      ...(file.driftNotice !== undefined ? { driftNotice: file.driftNotice } : {}),
-      metrics,
-      servedRows: [],
-    };
-    return {
-      ok: true,
-      result: file.result,
-      diff,
-      drift: file.driftNotice,
-      metrics,
-      raw: file,
-      toolResult: { content: [{ type: "text", text: diff }], details },
-    };
-  } catch (error) {
-    return toFailure(error);
-  }
-}
-
-// WHY: Re-export for callers that need the throw-based legacy path.
-export { toFailure };

package/src/mutation-engine/index.ts

@@ -1,17 +0,0 @@
-/**
- * SAFETY: MutationEngine — public interface for the deep mutation seam.
- *
- * One seam, small interface, deep implementation. Internal pipeline phases
- * (load, parse, mutate, finalize, drift, persist, serve) stay private.
- * Two adapters justify the seam: SQLiteSnapshotStore (prod) vs
- * MemorySnapshotStore (tests) — local-substitutable.
- *
- * Callers cross this seam via `execute` / `preview` and switch on the
- * discriminated `MutationResult` (`ok:true` vs `ok:false`). No `any`,
- * no `isError` flag checks, no threading of `sessionKey`/`store` details.
- */
-
-export { isMutationSuccess, isMutationFailure } from "./types.js";
-
-// WHY: Deep seam — small interface.
-export { execute, preview } from "./engine.js";