@hicaru/pi-rlm 0.1.7 → 0.1.9

package/src/context/repomix-context.ts

@@ -5,8 +5,7 @@
  *
  * Uses repomix internally (worker-thread pool, built-in gitignore support)
  * and caches results in a module-level Map with TTL to avoid re-packing on
- * every run within the same process. `patchContextAfterEdits` updates the
- * cached bundle in-memory after file edits are applied to disk — no re-packing.
+ * every run within the same process.
  */
 
 import { pack } from "repomix";
@@ -172,42 +171,6 @@ export async function packRepository(
   }
 }
 
-export function patchContextAfterEdits(
-  cached: ContextBundle,
-  edits: readonly { readonly path: string; readonly newContent: string }[],
-): ContextBundle {
-  const editMap = new Map<string, string>();
-  for (const edit of edits) {
-    editMap.set(edit.path, edit.newContent);
-  }
-
-  const files = new Array<ContextFile>(cached.files.length);
-  let totalTokens = 0;
-  let totalChars = 0;
-
-  for (let i = 0; i < cached.files.length; i++) {
-    const file = cached.files[i];
-    const newContent = editMap.get(file.path);
-    if (newContent !== undefined) {
-      const tokens = Math.ceil(newContent.length / ESTIMATED_CHARS_PER_TOKEN);
-      files[i] = { path: file.path, content: newContent, tokens };
-      totalTokens += tokens;
-      totalChars += newContent.length;
-    } else {
-      files[i] = file;
-      totalTokens += file.tokens;
-      totalChars += file.content.length;
-    }
-  }
-
-  return {
-    files,
-    totalFiles: files.length,
-    totalTokens,
-    totalChars,
-  };
-}
-
 export function serializeForSandbox(
   bundle: ContextBundle,
 ): readonly ContextFile[] {
@@ -243,13 +206,4 @@ export function formatForLLM(bundle: ContextBundle): string {
   ].join("\n");
 }
 
-export function patchCachedContext(
-  cwd: string,
-  edits: readonly { readonly path: string; readonly newContent: string }[],
-): void {
-  const key = cacheKey(cwd);
-  const entry = cache.get(key);
-  if (!entry) return;
-  const patched = patchContextAfterEdits(entry.bundle, edits);
-  cache.set(key, { bundle: patched, ts: entry.ts });
-}
+

package/src/core/answer.ts

@@ -1,6 +1,6 @@
 /** Helpers for detecting and formatting the RLM final answer from a turn's REPL results. */
 
-import type { ProposedEdit, ReplResult } from "../sandbox/protocol.ts";
+import type { ReplResult } from "../sandbox/protocol.ts";
 import { truncateOutput } from "../text/parsing.ts";
 
 /** First non-null final answer across a turn's executed blocks, or null. */
@@ -18,15 +18,6 @@ export function latestAnswerContentOf(results: readonly ReplResult[]): string |
   return null;
 }
 
-/** Last cumulative legacy anchor proposed-edit set reported by a turn. */
-export function collectEdits(results: readonly ReplResult[]): ProposedEdit[] {
-  for (let i = results.length - 1; i >= 0; i--) {
-    const edits = results[i]?.edits;
-    if (edits && edits.length > 0) return [...edits];
-  }
-  return [];
-}
-
 /** True if any block in the turn raised an exception. Plain stderr does not count. */
 export function turnHadError(results: readonly ReplResult[]): boolean {
   return results.some((r) => r.raised);

package/src/core/artifacts.ts

@@ -0,0 +1,88 @@
+/**
+ * Artifact plumbing for the gated RLM pipeline: goal capture, baseline dirty-tree
+ * snapshot, and timestamped stage artifact writes under `.rlm/artifacts/`.
+ */
+import { execFileSync } from "node:child_process";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { Result } from "../util/errors.ts";
+
+export const ARTIFACTS_DIR = ".rlm/artifacts";
+
+const stamp = (): string => new Date().toISOString().replace(/[:.]/g, "-");
+
+export interface GoalCapture {
+  readonly goalPath: string;      // repo-relative
+  readonly baselinePath: string;  // repo-relative
+}
+
+export type SaveOutcome =
+  | { readonly ok: true; readonly path: string }
+  | { readonly ok: false; readonly error: string };
+
+export type GoalCaptureResult =
+  | { readonly ok: true; readonly value: GoalCapture }
+  | { readonly ok: false; readonly error: string };
+
+/**
+ * Capture the user's brief VERBATIM: no frontmatter, no headers — the raw file
+ * is the only artifact that preserves explicit user constraints unrefracted. The
+ * baseline snapshot records paths ALREADY dirty before the run, so validate
+ * judges only the run's own delta. Best-effort: git failure ⇒ empty baseline.
+ * Failures never throw (unwritable cwd etc.) — returns error for the engine to surface.
+ */
+export function captureGoal(cwd: string, brief: string): GoalCaptureResult {
+  try {
+    const ts = stamp();
+    const dir = join(ARTIFACTS_DIR, "goal");
+    mkdirSync(join(cwd, dir), { recursive: true });
+    const goalPath = join(dir, `goal-${ts}.md`);
+    writeFileSync(join(cwd, goalPath), brief, "utf-8");
+    let paths: readonly string[] = [];
+    try {
+      paths = execFileSync("git", ["status", "--short"], {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"],
+      })
+        .split("\n")
+        .filter((l) => l.trim() !== "")
+        .map((l) => {
+          const rest = l.slice(3).trim();
+          const arrow = rest.indexOf(" -> ");
+          return arrow >= 0 ? rest.slice(arrow + 4).trim() : rest;
+        });
+    } catch {
+      paths = [];
+    }
+    const baselinePath = join(dir, `baseline-${ts}.json`);
+    writeFileSync(join(cwd, baselinePath), JSON.stringify({ paths }, null, 2), "utf-8");
+    return { ok: true, value: { goalPath, baselinePath } };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: message };
+  }
+}
+
+/** Write a stage artifact under its dir; timestamped so runs never collide. */
+export function saveArtifact(cwd: string, dir: string, slug: string, content: string): SaveOutcome {
+  try {
+    const rel = join(ARTIFACTS_DIR, dir, `${stamp()}_${slug}.md`);
+    mkdirSync(join(cwd, ARTIFACTS_DIR, dir), { recursive: true });
+    writeFileSync(join(cwd, rel), content, "utf-8");
+    return { ok: true, path: rel };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: message };
+  }
+}
+
+/** Read a previously saved artifact (repo-relative path). Failures never throw. */
+export function readArtifact(cwd: string, relPath: string): Result<string, string> {
+  try {
+    return { ok: true, value: readFileSync(join(cwd, relPath), "utf-8") };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: `could not read artifact ${relPath}: ${message}` };
+  }
+}

package/src/core/critique.ts

@@ -0,0 +1,92 @@
+/**
+ * Preflight critique for stage artifacts — port of codex-bais `model_critique`.
+ *
+ * Blocking truth comes from `stage.gate` (the same function `advance_phase` runs), so the
+ * two can never drift. `warnings` are advisory model-risk diagnostics that never block.
+ */
+import {
+  countBulletsUnderHeading,
+  phasesMissingSuccessCriteria,
+  sectionHasNonEmptyBody,
+} from "./gates.ts";
+import type { StageDef, StageGateData } from "./pipeline.ts";
+
+export interface Critique {
+  /** Blocking — `advance_phase` will reject while non-empty. */
+  readonly issues: readonly string[];
+  /** Advisory — surfaced to the model, never blocking. */
+  readonly warnings: readonly string[];
+  /**
+   * Convenience alias for `issues.length === 0` — do not set independently;
+   * always derive from `issues`.
+   */
+  readonly canAdvance: boolean;
+  /** Gate payload when `canAdvance` — reused by advance_phase (no second gate run). */
+  readonly gateData?: StageGateData;
+}
+
+const NO_STRINGS: readonly string[] = Object.freeze([]);
+
+/** Advisory checks per artifact kind. Pure; returns a frozen array. */
+function advisoriesFor(stage: StageDef, content: string): readonly string[] {
+  switch (stage.artifactKind) {
+    case "plan": {
+      const missing = phasesMissingSuccessCriteria(content);
+      if (missing.length > 0) {
+        return Object.freeze([
+          `${missing.join(", ")} ${missing.length === 1 ? "has" : "have"} no `
+          + "'### Success Criteria' — validate cannot check them",
+        ]);
+      }
+      return NO_STRINGS;
+    }
+    case "clarification": {
+      const open = countBulletsUnderHeading(content, "Open Questions");
+      if (open > 0) {
+        return Object.freeze([
+          `${open} Open Question(s) carried into blueprint — re-ask any that block the design`,
+        ]);
+      }
+      return NO_STRINGS;
+    }
+    case "research": {
+      if (!sectionHasNonEmptyBody(content, "Findings")) {
+        return Object.freeze(["research artifact has no '## Findings' section"]);
+      }
+      return NO_STRINGS;
+    }
+    default:
+      return NO_STRINGS;
+  }
+}
+
+export function critiqueArtifact(
+  stage: StageDef,
+  content: string,
+  path: string,
+  cwd: string,
+): Critique {
+  const gate = stage.gate(content, path, cwd);
+  const issues = gate.ok ? NO_STRINGS : Object.freeze([gate.error]);
+  return Object.freeze({
+    issues,
+    warnings: advisoriesFor(stage, content),
+    canAdvance: issues.length === 0,
+    gateData: gate.ok ? gate.value : undefined,
+  });
+}
+
+/** Human-readable renderer for the `save_artifact` return value. */
+export function formatCritique(critique: Critique): string {
+  if (critique.issues.length === 0 && critique.warnings.length === 0) {
+    return "gate: clean — call advance_phase when ready.";
+  }
+  const lines = new Array<string>(critique.issues.length + critique.warnings.length);
+  let n = 0;
+  for (let i = 0; i < critique.issues.length; i++) lines[n++] = `  BLOCKER: ${critique.issues[i]}`;
+  for (let i = 0; i < critique.warnings.length; i++) lines[n++] = `  warning: ${critique.warnings[i]}`;
+  const head = critique.canAdvance
+    ? "gate: passes, with advisories —"
+    : "gate: WOULD REJECT — fix before advance_phase:";
+  return `${head}\n${lines.join("\n")}`;
+}