@hicaru/pi-rlm 0.1.7 → 0.1.8

package/src/text/edits.ts

@@ -1,3 +1,9 @@
+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;
@@ -14,3 +20,145 @@ export function countOccurrences(haystack: string, needle: string): number {
     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,10 +1,10 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
 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 { countOccurrences } from "../text/edits.ts";
+import { planEdit } from "../text/edits.ts";
 import { errorMessage, formatError } from "../util/errors.ts";
 
 export const ApplyEditsToolParams = Object.freeze(Type.Object({
@@ -205,8 +205,10 @@ export function createApplyEditsTool(editRegistry: EditRegistry): ToolDefinition
       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);
@@ -217,41 +219,46 @@ export function createApplyEditsTool(editRegistry: EditRegistry): ToolDefinition
           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 {
-          const fullPath = resolve(ctx.cwd, edit.path);
-          if (edit.oldText.length === 0) {
-            await mkdir(dirname(fullPath), { recursive: true });
-            await writeFile(fullPath, edit.newText, "utf8");
-            mergeFileStat(fileStatsByPath, edit.path, "applied", diffStats("", edit.newText), { oldText: edit.oldText, newText: edit.newText });
+          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;
           }
-
-          const content = await readFile(fullPath, "utf8");
-          const occurrences = countOccurrences(content, edit.oldText);
-          if (occurrences !== 1) {
-            errors[failedCount] = { id, path: edit.path, error: formatError(`anchor occurs ${occurrences} times in ${edit.path}`) };
-            mergeFileStat(fileStatsByPath, edit.path, "failed", { added: 0, removed: 0 }, { oldText: edit.oldText, newText: edit.newText });
-            failedCount++;
-            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,
+            );
           }
-
-          const after = content.replace(edit.oldText, edit.newText);
-          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 },
           );
-          mergeFileStat(fileStatsByPath, edit.path, "applied", diffStats(content, after), { oldText: edit.oldText, newText: edit.newText });
           editRegistry.delete(id);
           appliedCount++;
         } catch (error: unknown) {
-          const path = edit.path;
-          errors[failedCount] = { id, path, error: formatError(errorMessage(error)) };
-          mergeFileStat(fileStatsByPath, path, "failed", { added: 0, removed: 0 }, { oldText: edit.oldText, newText: edit.newText });
+          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++;
         }
       }

package/src/tool/repl-tool.ts

@@ -18,6 +18,7 @@ import type { Model, Usage, Api } from "@earendil-works/pi-ai";
 import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
 import { modelRef, resolveModelId } from "../config/settings.ts";
 import { buildInteractiveHandlers } from "../bridge/interactive.ts";
+import { buildLibraryHandler } from "../bridge/library.ts";
 import { createPiInteractiveDeps } from "../bridge/pi-interactive.ts";
 import { type ChatMsg, modelComplete } from "../bridge/model.ts";
 import { previewText } from "../text/preview.ts";
@@ -341,13 +342,19 @@ export interface ReplToolDeps {
   readonly signal?: AbortSignal;
   readonly onUsage?: (usage: Usage, role: "sub") => void;
   readonly ensureContext?: () => Promise<void>;
+  /** Register a reset hook for sandbox death/dispose (e.g. load_library slot counter). */
+  readonly registerDiscardHook?: (reset: () => void) => void;
 }
 
 export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplToolParams, ReplDetails> {
   const { sandboxManager, workerModel, registry, editRegistry, config, signal, onUsage } = deps;
   const bridgeState = new NativeBridgeState();
 
-  // Build handlers once — llm/rlm use mutable refs, interactive is session-stable
+  // Late-bound cwd — getOrCreate installs handlers only at spawn; never rebuild the closure.
+  let sessionCwd = process.cwd();
+
+  // Build handlers once — llm/rlm/library use late-bound deps so the same closures stay correct
+  // across repl() calls; counter resets when the sandbox is discarded and re-spawned.
   const llmHandlers = bridgeState.buildLlmHandlers({
     workerModel,
     getWorkerModel: deps.getWorkerModel,
@@ -373,6 +380,17 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
     llmHandlers,
   });
 
+  const libraryBundle = config.libraryLoader
+    ? buildLibraryHandler({
+        getCwd: () => sessionCwd,
+        getEmitter: () => bridgeState.currentEmitter,
+        parentId: undefined,
+        signal,
+        startIndex: 1,
+      })
+    : undefined;
+  if (libraryBundle) deps.registerDiscardHook?.(libraryBundle.reset);
+
   return {
     name: "repl",
     label: "REPL",
@@ -382,7 +400,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
       "chunk `context` and delegate semantic work to llm_query / llm_query_batched / " +
       "llm_query_chunked / rlm_query — stdout returned to you is hard-capped at 4K chars, so " +
       "printing file bodies is useless. Variables, imports, and state persist across calls. " +
-      "Also supports todo and ask_user_question inside the sandbox.",
+      "Also supports todo, ask_user_question, and load_library inside the sandbox.",
     parameters: ReplToolParams,
 
     async execute(_toolCallId, rawParams, _execSignal, onUpdate, ctx) {
@@ -448,12 +466,15 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
           parentId: undefined,
         });
 
+        sessionCwd = ctx.cwd ?? process.cwd();
+
         await deps.ensureContext?.();
         await sandboxManager.getOrCreate({
           ...llmHandlers,
           ...rlmHandlers,
           askUserQuestion: interactiveHandlers.askUserQuestion,
           todo: interactiveHandlers.todo,
+          ...(libraryBundle?.handlers ?? {}),
         });
 
         // Detect queue contention AFTER sandbox init (initPromise settled, isExecuting now accurate)

package/src/tool/rlm-tool.ts

@@ -1,7 +1,6 @@
 /**
  * RLM tool — registers the RLM engine as a Pi tool with inline rendering.
  *
- * Modeled after rpiv-mono's subagent tool.
  * The tool's execute() wraps createEngine() with an RlmEmitter + RlmEventAggregator that feeds
  * onUpdate(partialResult) for progressive TUI re-rendering.
  */

package/src/ui/config-panel.ts

@@ -16,11 +16,13 @@ const CHOICES = Object.freeze({
   maxErrors: Object.freeze(["3", "5", "10", "none"]),
   orchestrator: Object.freeze(["on", "off"]),
   pipeline: Object.freeze(["on", "off"]),
+  maxBackwardJumps: Object.freeze(["0", "1", "2", "3"]),
   compaction: Object.freeze(["on", "off"]),
   rootSamplingMaxTokens: Object.freeze(["4096", "8192", "16384", "32768"]),
   sandboxInitTimeoutMs: Object.freeze(["10000", "30000", "60000", "120000"]),
   askUserQuestion: Object.freeze(["on", "off"]),
   todo: Object.freeze(["on", "off"]),
+  libraryLoader: Object.freeze(["on", "off"]),
 });
 
 function item(id: string, label: string, currentValue: string, values: readonly string[], description: string): SettingItem {
@@ -39,12 +41,15 @@ export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig):
     item("maxTokens", "Token ceiling", config.maxTokens != null ? String(config.maxTokens) : "none", CHOICES.maxTokens, "Total input+output token cap for the whole recursive tree."),
     item("maxErrors", "Max consecutive errors", config.maxErrors != null ? String(config.maxErrors) : "none", CHOICES.maxErrors, "Stop after this many consecutive failing turns; none disables the guard."),
     item("orchestrator", "Orchestrator addendum", config.orchestrator ? "on" : "off", CHOICES.orchestrator, "Append extra divide-and-conquer guidance to the root model system prompt."),
-    item("pipeline", "Phase pipeline", config.pipeline ? "on" : "off", CHOICES.pipeline, "Enable advance_phase plus phase-stall reminders at root depth."),
+    item("pipeline", "Phase pipeline", config.pipeline ? "on" : "off", CHOICES.pipeline, "Enable artifact-gated phases: clarify→research→blueprint→implement fanout→validate (clarify needs Ask user on)."),
+    item("maxBackwardJumps", "Max validate→blueprint loops", String(config.maxBackwardJumps), CHOICES.maxBackwardJumps, "Bounded corrective re-entries when validation reports blockers_count > 0."),
     item("compaction", "Trajectory compaction", config.compaction ? "on" : "off", CHOICES.compaction, "Summarize old turns when history approaches the model context window."),
     item("rootSamplingMaxTokens", "Root model output cap (tok)", String(config.rootSampling?.maxTokens ?? 16384), CHOICES.rootSamplingMaxTokens, "Max output tokens per root-model turn. Lower values keep each turn lean."),
     item("sandboxInitTimeoutMs", "Sandbox init timeout", String(config.sandboxInitTimeoutMs), CHOICES.sandboxInitTimeoutMs, "How long to wait for the Python worker to start."),
     item("askUserQuestion", "[Interactive] Ask user", config.askUserQuestion ? "on" : "off", CHOICES.askUserQuestion, "Allow root REPL code to present structured ask_user_question dialogs."),
     item("todo", "[Interactive] Todo", config.todo ? "on" : "off", CHOICES.todo, "Allow REPL code to manage a visible todo task list."),
+    item("libraryLoader", "Library loader", config.libraryLoader ? "on" : "off", CHOICES.libraryLoader,
+      "Allow load_library() to pull an external dir, file, or git repo into a new context_N slot."),
     item("__save__", "Save & close", "↵", ["↵"], "Save these settings and close (Esc also saves)."),
   ];
 
@@ -86,10 +91,12 @@ function applySetting(config: RlmConfig, id: string, value: string): void {
     case "maxErrors": config.maxErrors = value === "none" ? undefined : Number(value); break;
     case "orchestrator": config.orchestrator = value === "on"; break;
     case "pipeline": config.pipeline = value === "on"; break;
+    case "maxBackwardJumps": config.maxBackwardJumps = Number(value); break;
     case "compaction": config.compaction = value === "on"; break;
     case "rootSamplingMaxTokens": config.rootSampling = Object.freeze({ ...config.rootSampling, maxTokens: Number(value) }); break;
     case "sandboxInitTimeoutMs": config.sandboxInitTimeoutMs = Number(value); break;
     case "askUserQuestion": config.askUserQuestion = value === "on"; break;
     case "todo": config.todo = value === "on"; break;
+    case "libraryLoader": config.libraryLoader = value === "on"; break;
   }
 }