@hicaru/pi-rlm 0.1.8 → 0.2.0

package/src/mode/input-router.ts

@@ -1,23 +0,0 @@
-import type { InputSource } from "@earendil-works/pi-coding-agent";
-
-export interface InputRouteState {
-  readonly enabled: boolean;
-  readonly busy: boolean;
-}
-
-export interface InputRouteEvent {
-  readonly source: InputSource;
-  readonly text: string;
-}
-
-export type InputRouteDecision = "continue" | "route" | "busy";
-
-export function decideRlmInputRoute(event: InputRouteEvent, state: InputRouteState): InputRouteDecision {
-  const eligible = state.enabled && event.source === "interactive" && !event.text.trimStart().startsWith("/");
-  if (!eligible) return "continue";
-  return state.busy ? "busy" : "route";
-}
-
-export function shouldRouteRlmInput(event: InputRouteEvent, state: InputRouteState): boolean {
-  return decideRlmInputRoute(event, state) === "route";
-}

package/src/registry/edit-registry.ts

@@ -1,22 +0,0 @@
-import type { ProposedEdit } from "../sandbox/protocol.ts";
-
-export class EditRegistry {
-  private readonly edits = new Map<string, ProposedEdit>();
-
-  registerAll(edits: readonly ProposedEdit[] | undefined): void {
-    if (edits === undefined) return;
-    for (const edit of edits) this.edits.set(edit.id, edit);
-  }
-
-  get(id: string): ProposedEdit | undefined {
-    return this.edits.get(id);
-  }
-
-  delete(id: string): boolean {
-    return this.edits.delete(id);
-  }
-
-  clear(): void {
-    this.edits.clear();
-  }
-}

package/src/text/edits.ts

@@ -1,164 +0,0 @@
-import { access, mkdir, readFile, writeFile } from "node:fs/promises";
-import { constants } from "node:fs";
-import { dirname, resolve } from "node:path";
-import type { ProposedEdit } from "../sandbox/protocol.ts";
-import { errorMessage, formatError } from "../util/errors.ts";
-
-export interface AnchorEdit {
-  readonly oldText: string;
-  readonly newText: string;
-}
-
-export function countOccurrences(haystack: string, needle: string): number {
-  if (needle.length === 0) return 0;
-  let count = 0;
-  let offset = 0;
-  for (;;) {
-    const match = haystack.indexOf(needle, offset);
-    if (match < 0) return count;
-    count++;
-    offset = match + needle.length;
-  }
-}
-
-/**
- * Literal string replace of the first occurrence of `oldText` with `newText`.
- * Splice-based so `$&` / `$$` / `$'` in newText are NOT treated as
- * special replacement patterns (String.prototype.replace string-form hazard).
- */
-export function replaceOnceLiteral(content: string, oldText: string, newText: string): string {
-  const idx = content.indexOf(oldText);
-  if (idx < 0) return content;
-  return content.slice(0, idx) + newText + content.slice(idx + oldText.length);
-}
-
-export type PlanEditResult =
-  | {
-      readonly ok: true;
-      /** create = new file; replace = one-shot anchor swap; already-applied = idempotent skip */
-      readonly kind: "create" | "replace" | "already-applied";
-      readonly before: string;
-      readonly after: string;
-    }
-  | { readonly ok: false; readonly error: string };
-
-async function pathExists(abs: string): Promise<boolean> {
-  try {
-    await access(abs, constants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Validate and compute an edit without writing.
- * Shared by headless apply and the native apply_edits tool (DRY).
- *
- * Idempotent retry: if a prior unit already landed the change
- * (oldText absent + newText already present for replace; create with identical content),
- * returns kind "already-applied" so a failed fanout can be retried without wedging.
- *
- * Create-file: refuses to clobber when the target exists with different content.
- */
-export async function planEdit(
-  cwd: string,
-  path: string,
-  oldText: string,
-  newText: string,
-): Promise<PlanEditResult> {
-  try {
-    const fullPath = resolve(cwd, path);
-    if (oldText.length === 0) {
-      if (await pathExists(fullPath)) {
-        const existing = await readFile(fullPath, "utf8");
-        if (existing === newText) {
-          return { ok: true, kind: "already-applied", before: existing, after: existing };
-        }
-        return {
-          ok: false,
-          error: formatError(
-            `${path}: file already exists with different content — refuse to clobber (create requires empty target or identical content)`,
-          ),
-        };
-      }
-      return { ok: true, kind: "create", before: "", after: newText };
-    }
-
-    const content = await readFile(fullPath, "utf8");
-    const occurrences = countOccurrences(content, oldText);
-    if (occurrences === 0) {
-      // Idempotent skip: prior apply already removed the anchor and left newText.
-      // Deletions (newText === "") always "include" empty string — treat them as
-      // retry-unsafe so a typo'd anchor fails instead of silently skipping.
-      if (newText.length > 0 && content.includes(newText)) {
-        return { ok: true, kind: "already-applied", before: content, after: content };
-      }
-      return { ok: false, error: formatError(`anchor occurs 0 times in ${path}`) };
-    }
-    if (occurrences !== 1) {
-      return { ok: false, error: formatError(`anchor occurs ${occurrences} times in ${path}`) };
-    }
-    const after = replaceOnceLiteral(content, oldText, newText);
-    return { ok: true, kind: "replace", before: content, after };
-  } catch (err: unknown) {
-    return { ok: false, error: formatError(`${path}: ${errorMessage(err)}`) };
-  }
-}
-
-export type ApplyOneEditResult =
-  | { readonly ok: true; readonly before: string; readonly after: string; readonly kind: "create" | "replace" | "already-applied" }
-  | { readonly ok: false; readonly error: string };
-
-/**
- * Apply a single anchor edit to the working tree (direct disk write).
- * Used by the implement fanout and any headless apply path.
- */
-export async function applyOneEdit(
-  cwd: string,
-  path: string,
-  oldText: string,
-  newText: string,
-): Promise<ApplyOneEditResult> {
-  const planned = await planEdit(cwd, path, oldText, newText);
-  if (!planned.ok) return planned;
-  if (planned.kind === "already-applied") {
-    return { ok: true, before: planned.before, after: planned.after, kind: "already-applied" };
-  }
-  try {
-    const fullPath = resolve(cwd, path);
-    if (planned.kind === "create") {
-      await mkdir(dirname(fullPath), { recursive: true });
-    }
-    await writeFile(fullPath, planned.after, "utf8");
-    return { ok: true, before: planned.before, after: planned.after, kind: planned.kind };
-  } catch (err: unknown) {
-    return { ok: false, error: formatError(`${path}: ${errorMessage(err)}`) };
-  }
-}
-
-export type ApplyProposedEditsResult =
-  | { readonly ok: true; readonly applied: number }
-  | { readonly ok: false; readonly error: string; readonly applied: number };
-
-/**
- * Apply a series of proposed edits to the working tree (patch series, not a race).
- * Shared by the implement fanout and any headless apply path.
- * Safe to re-run: already-applied units succeed without re-writing.
- */
-export async function applyProposedEdits(
-  edits: readonly ProposedEdit[],
-  cwd: string,
-): Promise<ApplyProposedEditsResult> {
-  let applied = 0;
-  for (let i = 0; i < edits.length; i++) {
-    const edit = edits[i];
-    if (edit === undefined) continue;
-    const one = await applyOneEdit(cwd, edit.path, edit.oldText, edit.newText);
-    if (!one.ok) {
-      return { ok: false, error: one.error, applied };
-    }
-    applied++;
-  }
-  return { ok: true, applied };
-}

package/src/tool/apply-edits-tool.ts

@@ -1,295 +0,0 @@
-import { createEditToolDefinition, type AgentToolResult, type Theme, type ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { Container, Text, type Component } from "@earendil-works/pi-tui";
-import { Type } from "typebox";
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-import type { EditRegistry } from "../registry/edit-registry.ts";
-import { planEdit } from "../text/edits.ts";
-import { errorMessage, formatError } from "../util/errors.ts";
-
-export const ApplyEditsToolParams = Object.freeze(Type.Object({
-  ids: Type.Array(Type.String({ description: "A staged edit ID returned by stage_edit()." }), {
-    description: "Staged edit IDs to apply.",
-  }),
-}));
-
-export interface ApplyEditsFailure {
-  readonly id: string;
-  readonly path: string;
-  readonly error: string;
-}
-
-export interface ApplyEditsPatch {
-  readonly oldText: string;
-  readonly newText: string;
-}
-
-export interface ApplyEditsFileStat {
-  readonly path: string;
-  readonly status: "applied" | "failed";
-  readonly added: number;
-  readonly removed: number;
-  readonly edits: readonly ApplyEditsPatch[];
-}
-
-export interface ApplyEditsDetails {
-  readonly status: "done" | "partial" | "error";
-  readonly appliedCount: number;
-  readonly failedCount: number;
-  readonly errors: readonly ApplyEditsFailure[];
-  readonly fileStats: readonly ApplyEditsFileStat[];
-}
-
-export interface LineStats {
-  readonly added: number;
-  readonly removed: number;
-}
-
-export function countLines(text: string): number {
-  return text.length === 0 ? 0 : text.split("\n").length;
-}
-
-export function diffStats(before: string, after: string): LineStats {
-  const beforeLineCount = countLines(before);
-  const afterLineCount = countLines(after);
-  return Object.freeze({
-    added: Math.max(0, afterLineCount - beforeLineCount),
-    removed: Math.max(0, beforeLineCount - afterLineCount),
-  });
-}
-
-function statusFor(appliedCount: number, failedCount: number): ApplyEditsDetails["status"] {
-  if (failedCount === 0 && appliedCount > 0) return "done";
-  return appliedCount > 0 ? "partial" : "error";
-}
-
-function aggregateLineStats(fileStats: readonly ApplyEditsFileStat[]): LineStats {
-  let added = 0;
-  let removed = 0;
-  for (let i = 0; i < fileStats.length; i++) {
-    const stat = fileStats[i];
-    added += stat.added;
-    removed += stat.removed;
-  }
-  return Object.freeze({ added, removed });
-}
-
-function appendPatch(existing: readonly ApplyEditsPatch[], patch: ApplyEditsPatch | undefined): readonly ApplyEditsPatch[] {
-  if (patch === undefined) return existing;
-  const patches = new Array<ApplyEditsPatch>(existing.length + 1);
-  for (let i = 0; i < existing.length; i++) {
-    patches[i] = existing[i];
-  }
-  patches[existing.length] = patch;
-  return Object.freeze(patches);
-}
-
-function mergeFileStat(
-  fileStatsByPath: Map<string, ApplyEditsFileStat>,
-  path: string,
-  status: ApplyEditsFileStat["status"],
-  stats: LineStats,
-  patch?: ApplyEditsPatch,
-): void {
-  const existing = fileStatsByPath.get(path);
-  const nextStatus: ApplyEditsFileStat["status"] = existing?.status === "failed" || status === "failed" ? "failed" : "applied";
-  fileStatsByPath.set(path, {
-    path,
-    status: nextStatus,
-    added: (existing?.added ?? 0) + stats.added,
-    removed: (existing?.removed ?? 0) + stats.removed,
-    edits: appendPatch(existing?.edits ?? Object.freeze([]), patch),
-  });
-}
-
-function renderLineStats(stats: LineStats, theme: Theme): string {
-  return `${theme.fg("success", `+${stats.added}`)} ${theme.fg("error", `-${stats.removed}`)} lines`;
-}
-
-function formatEditCounts(details: ApplyEditsDetails): string {
-  return details.failedCount > 0
-    ? `${details.appliedCount} applied, ${details.failedCount} failed`
-    : `${details.appliedCount} applied`;
-}
-
-function formatFileCount(fileCount: number): string {
-  return `${fileCount} file${fileCount === 1 ? "" : "s"}`;
-}
-
-function summarizeFiles(details: ApplyEditsDetails): string {
-  return `apply_edits: ${formatFileCount(details.fileStats.length)}, ${formatEditCounts(details)}`;
-}
-
-function summarize(details: ApplyEditsDetails): string {
-  const stats = aggregateLineStats(details.fileStats);
-  const head = `${summarizeFiles(details)} (+${stats.added} -${stats.removed} lines)`;
-  if (details.errors.length === 0) return `${head}.`;
-  const rows = new Array<string>(details.errors.length);
-  for (let i = 0; i < details.errors.length; i++) {
-    const error = details.errors[i];
-    rows[i] = `${error.id}: ${error.error}`;
-  }
-  return `${head}.\n${rows.join("\n")}`;
-}
-
-function renderCollapsed(details: ApplyEditsDetails, theme: Theme): Text {
-  const stats = aggregateLineStats(details.fileStats);
-  const statusColor = details.status === "error" ? "error" : "success";
-  return new Text(`${theme.fg(statusColor, summarizeFiles(details))} ${renderLineStats(stats, theme)}`, 0, 0);
-}
-
-function renderFileLine(fileStat: ApplyEditsFileStat, theme: Theme): Text {
-  const glyph = fileStat.status === "applied" ? theme.fg("success", "✓") : theme.fg("error", "✗");
-  const stats = renderLineStats(fileStat, theme);
-  return new Text(`${glyph} ${theme.fg("dim", fileStat.path)} ${stats}`, 0, 0);
-}
-
-function limitPatchText(text: string): string {
-  const maxChars = 2_000;
-  return text.length > maxChars ? `${text.slice(0, maxChars)}…` : text;
-}
-
-function renderPatchLines(text: string, prefix: string, color: "error" | "success", theme: Theme): string {
-  const limitedText = limitPatchText(text);
-  const lines = limitedText.split("\n");
-  const rendered = new Array<string>(lines.length);
-  for (let i = 0; i < lines.length; i++) {
-    rendered[i] = theme.fg(color, `${prefix}${lines[i]}`);
-  }
-  return rendered.join("\n");
-}
-
-function renderPatch(patch: ApplyEditsPatch, theme: Theme): Text {
-  const oldText = patch.oldText.length === 0 ? "(new file)" : patch.oldText;
-  const text = [
-    theme.fg("error", "--- old"),
-    renderPatchLines(oldText, "- ", "error", theme),
-    theme.fg("success", "+++ new"),
-    renderPatchLines(patch.newText, "+ ", "success", theme),
-  ].join("\n");
-  return new Text(text, 2, 0);
-}
-
-function renderExpanded(details: ApplyEditsDetails, theme: Theme): Container {
-  const container = new Container();
-  const header = summarizeFiles(details);
-  const headerColor = details.status === "error" ? "error" : "success";
-  container.addChild(new Text(theme.fg(headerColor, header), 0, 0));
-  for (let i = 0; i < details.fileStats.length; i++) {
-    const fileStat = details.fileStats[i];
-    container.addChild(renderFileLine(fileStat, theme));
-    for (let editIndex = 0; editIndex < fileStat.edits.length; editIndex++) {
-      container.addChild(renderPatch(fileStat.edits[editIndex], theme));
-    }
-  }
-  if (details.errors.length > 0) {
-    const rows = new Array<string>(details.errors.length);
-    for (let i = 0; i < details.errors.length; i++) {
-      const error = details.errors[i];
-      rows[i] = `${error.id}: ${error.error}`;
-    }
-    container.addChild(new Text(theme.fg("error", rows.join("\n")), 0, 0));
-  }
-  return container;
-}
-
-export function createApplyEditsTool(editRegistry: EditRegistry): ToolDefinition<typeof ApplyEditsToolParams, ApplyEditsDetails> {
-  return {
-    name: "apply_edits",
-    label: "Apply Edits",
-    description: "Apply staged REPL edits by ID without re-typing file paths or edit bodies.",
-    parameters: ApplyEditsToolParams,
-
-    async execute(toolCallId, params, signal, _onUpdate, ctx): Promise<AgentToolResult<ApplyEditsDetails>> {
-      const errors = new Array<ApplyEditsFailure>(params.ids.length);
-      const fileStatsByPath = new Map<string, ApplyEditsFileStat>();
-      let appliedCount = 0;
-      let failedCount = 0;
-      // Native mode: plan/validate with shared planEdit, then write through the host
-      // edit tool so file-watcher / undo hooks still fire (direct write for create only).
-      const editTool = createEditToolDefinition(ctx.cwd);
-
-      for (let i = 0; i < params.ids.length; i++) {
-        const id = params.ids[i];
-        const edit = editRegistry.get(id);
-        if (edit === undefined) {
-          errors[failedCount] = { id, path: id, error: formatError("unknown edit id") };
-          mergeFileStat(fileStatsByPath, id, "failed", { added: 0, removed: 0 });
-          failedCount++;
-          continue;
-        }
-
-        const planned = await planEdit(ctx.cwd, edit.path, edit.oldText, edit.newText);
-        if (!planned.ok) {
-          errors[failedCount] = { id, path: edit.path, error: planned.error };
-          mergeFileStat(fileStatsByPath, edit.path, "failed", { added: 0, removed: 0 }, { oldText: edit.oldText, newText: edit.newText });
-          failedCount++;
-          continue;
-        }
-
-        try {
-          if (planned.kind === "already-applied") {
-            mergeFileStat(fileStatsByPath, edit.path, "applied", { added: 0, removed: 0 }, { oldText: edit.oldText, newText: edit.newText });
-            editRegistry.delete(id);
-            appliedCount++;
-            continue;
-          }
-          if (planned.kind === "create") {
-            const fullPath = resolve(ctx.cwd, edit.path);
-            await mkdir(dirname(fullPath), { recursive: true });
-            await writeFile(fullPath, planned.after, "utf8");
-          } else {
-            await editTool.execute(
-              toolCallId,
-              { path: edit.path, edits: [{ oldText: edit.oldText, newText: edit.newText }] },
-              signal,
-              undefined,
-              ctx,
-            );
-          }
-          mergeFileStat(
-            fileStatsByPath,
-            edit.path,
-            "applied",
-            diffStats(planned.before, planned.after),
-            { oldText: edit.oldText, newText: edit.newText },
-          );
-          editRegistry.delete(id);
-          appliedCount++;
-        } catch (error: unknown) {
-          errors[failedCount] = { id, path: edit.path, error: formatError(errorMessage(error)) };
-          mergeFileStat(fileStatsByPath, edit.path, "failed", { added: 0, removed: 0 }, { oldText: edit.oldText, newText: edit.newText });
-          failedCount++;
-        }
-      }
-
-      const fileStats = new Array<ApplyEditsFileStat>(fileStatsByPath.size);
-      let fileStatIndex = 0;
-      for (const stat of fileStatsByPath.values()) {
-        fileStats[fileStatIndex] = stat;
-        fileStatIndex++;
-      }
-
-      const details = Object.freeze({
-        status: statusFor(appliedCount, failedCount),
-        appliedCount,
-        failedCount,
-        errors: Object.freeze(errors.slice(0, failedCount)),
-        fileStats: Object.freeze(fileStats),
-      });
-      return { content: [{ type: "text", text: summarize(details) }], details };
-    },
-
-    renderCall(args, theme) {
-      const editCount = args.ids.length;
-      const summary = `apply_edits: ${editCount} edit${editCount === 1 ? "" : "s"}`;
-      return new Text(theme.fg("toolTitle", theme.bold(summary)), 0, 0);
-    },
-
-    renderResult(result, options, theme): Component {
-      const details = result.details;
-      if (details === undefined) return new Text("(no apply_edits details)", 0, 0);
-      return options.expanded ? renderExpanded(details, theme) : renderCollapsed(details, theme);
-    },
-  };
-}