@klaudworks/rmr 1.0.1 → 1.1.2

package/README.md

@@ -8,6 +8,14 @@
 
 Inspired by [snarktank/antfarm](https://github.com/snarktank/antfarm).
 
+## Why rmr?
+
+Coding agents produce slop. Not because they're bad, but because "go make it work" is a bad prompt, the same way it's a bad brief for a human developer. You wouldn't hand someone a one-liner and expect clean, well-structured code back. Yet that's how most people use coding agents today.
+
+The fix is simple: break the work into steps. Plan first, then implement, then review. Loop back if the review finds problems. This is how good teams already work. rmr just lets you encode that process in a YAML file and run it automatically.
+
+It doesn't care how you plan (markdown files, Beads, Linear, whatever) or which agent you use (Claude Code, Codex, OpenCode). You can mix and match harnesses within a single workflow too, like using Claude for planning and Codex for implementation. It just makes sure each step gets the right context, the output flows to the next step, and you can pause and pick up where you left off.
+
 ## Quick Start
 
 **Instructions for humans**

package/dist/index.js

@@ -1114,17 +1114,17 @@ var require_visit = __commonJS((exports) => {
   visit.BREAK = BREAK;
   visit.SKIP = SKIP;
   visit.REMOVE = REMOVE;
-  function visit_(key, node, visitor, path) {
-    const ctrl = callVisitor(key, node, visitor, path);
+  function visit_(key, node, visitor, path2) {
+    const ctrl = callVisitor(key, node, visitor, path2);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path, ctrl);
-      return visit_(key, ctrl, visitor, path);
+      replaceNode(key, path2, ctrl);
+      return visit_(key, ctrl, visitor, path2);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node)) {
-        path = Object.freeze(path.concat(node));
+        path2 = Object.freeze(path2.concat(node));
         for (let i = 0;i < node.items.length; ++i) {
-          const ci = visit_(i, node.items[i], visitor, path);
+          const ci = visit_(i, node.items[i], visitor, path2);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -1135,13 +1135,13 @@ var require_visit = __commonJS((exports) => {
           }
         }
       } else if (identity.isPair(node)) {
-        path = Object.freeze(path.concat(node));
-        const ck = visit_("key", node.key, visitor, path);
+        path2 = Object.freeze(path2.concat(node));
+        const ck = visit_("key", node.key, visitor, path2);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = visit_("value", node.value, visitor, path);
+        const cv = visit_("value", node.value, visitor, path2);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -1162,17 +1162,17 @@ var require_visit = __commonJS((exports) => {
   visitAsync.BREAK = BREAK;
   visitAsync.SKIP = SKIP;
   visitAsync.REMOVE = REMOVE;
-  async function visitAsync_(key, node, visitor, path) {
-    const ctrl = await callVisitor(key, node, visitor, path);
+  async function visitAsync_(key, node, visitor, path2) {
+    const ctrl = await callVisitor(key, node, visitor, path2);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path, ctrl);
-      return visitAsync_(key, ctrl, visitor, path);
+      replaceNode(key, path2, ctrl);
+      return visitAsync_(key, ctrl, visitor, path2);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node)) {
-        path = Object.freeze(path.concat(node));
+        path2 = Object.freeze(path2.concat(node));
         for (let i = 0;i < node.items.length; ++i) {
-          const ci = await visitAsync_(i, node.items[i], visitor, path);
+          const ci = await visitAsync_(i, node.items[i], visitor, path2);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -1183,13 +1183,13 @@ var require_visit = __commonJS((exports) => {
           }
         }
       } else if (identity.isPair(node)) {
-        path = Object.freeze(path.concat(node));
-        const ck = await visitAsync_("key", node.key, visitor, path);
+        path2 = Object.freeze(path2.concat(node));
+        const ck = await visitAsync_("key", node.key, visitor, path2);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node.key = null;
-        const cv = await visitAsync_("value", node.value, visitor, path);
+        const cv = await visitAsync_("value", node.value, visitor, path2);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -1216,23 +1216,23 @@ var require_visit = __commonJS((exports) => {
     }
     return visitor;
   }
-  function callVisitor(key, node, visitor, path) {
+  function callVisitor(key, node, visitor, path2) {
     if (typeof visitor === "function")
-      return visitor(key, node, path);
+      return visitor(key, node, path2);
     if (identity.isMap(node))
-      return visitor.Map?.(key, node, path);
+      return visitor.Map?.(key, node, path2);
     if (identity.isSeq(node))
-      return visitor.Seq?.(key, node, path);
+      return visitor.Seq?.(key, node, path2);
     if (identity.isPair(node))
-      return visitor.Pair?.(key, node, path);
+      return visitor.Pair?.(key, node, path2);
     if (identity.isScalar(node))
-      return visitor.Scalar?.(key, node, path);
+      return visitor.Scalar?.(key, node, path2);
     if (identity.isAlias(node))
-      return visitor.Alias?.(key, node, path);
+      return visitor.Alias?.(key, node, path2);
     return;
   }
-  function replaceNode(key, path, node) {
-    const parent = path[path.length - 1];
+  function replaceNode(key, path2, node) {
+    const parent = path2[path2.length - 1];
     if (identity.isCollection(parent)) {
       parent.items[key] = node;
     } else if (identity.isPair(parent)) {
@@ -1789,10 +1789,10 @@ var require_Collection = __commonJS((exports) => {
   var createNode = require_createNode();
   var identity = require_identity();
   var Node = require_Node();
-  function collectionFromPath(schema, path, value) {
+  function collectionFromPath(schema, path2, value) {
     let v = value;
-    for (let i = path.length - 1;i >= 0; --i) {
-      const k = path[i];
+    for (let i = path2.length - 1;i >= 0; --i) {
+      const k = path2[i];
       if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
         const a = [];
         a[k] = v;
@@ -1811,7 +1811,7 @@ var require_Collection = __commonJS((exports) => {
       sourceObjects: new Map
     });
   }
-  var isEmptyPath = (path) => path == null || typeof path === "object" && !!path[Symbol.iterator]().next().done;
+  var isEmptyPath = (path2) => path2 == null || typeof path2 === "object" && !!path2[Symbol.iterator]().next().done;
 
   class Collection extends Node.NodeBase {
     constructor(type, schema) {
@@ -1832,11 +1832,11 @@ var require_Collection = __commonJS((exports) => {
         copy.range = this.range.slice();
       return copy;
     }
-    addIn(path, value) {
-      if (isEmptyPath(path))
+    addIn(path2, value) {
+      if (isEmptyPath(path2))
         this.add(value);
       else {
-        const [key, ...rest] = path;
+        const [key, ...rest] = path2;
         const node = this.get(key, true);
         if (identity.isCollection(node))
           node.addIn(rest, value);
@@ -1846,8 +1846,8 @@ var require_Collection = __commonJS((exports) => {
           throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
       }
     }
-    deleteIn(path) {
-      const [key, ...rest] = path;
+    deleteIn(path2) {
+      const [key, ...rest] = path2;
       if (rest.length === 0)
         return this.delete(key);
       const node = this.get(key, true);
@@ -1856,8 +1856,8 @@ var require_Collection = __commonJS((exports) => {
       else
         throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
     }
-    getIn(path, keepScalar) {
-      const [key, ...rest] = path;
+    getIn(path2, keepScalar) {
+      const [key, ...rest] = path2;
       const node = this.get(key, true);
       if (rest.length === 0)
         return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -1872,15 +1872,15 @@ var require_Collection = __commonJS((exports) => {
         return n == null || allowScalar && identity.isScalar(n) && n.value == null && !n.commentBefore && !n.comment && !n.tag;
       });
     }
-    hasIn(path) {
-      const [key, ...rest] = path;
+    hasIn(path2) {
+      const [key, ...rest] = path2;
       if (rest.length === 0)
         return this.has(key);
       const node = this.get(key, true);
       return identity.isCollection(node) ? node.hasIn(rest) : false;
     }
-    setIn(path, value) {
-      const [key, ...rest] = path;
+    setIn(path2, value) {
+      const [key, ...rest] = path2;
       if (rest.length === 0) {
         this.set(key, value);
       } else {
@@ -4262,9 +4262,9 @@ var require_Document = __commonJS((exports) => {
       if (assertCollection(this.contents))
         this.contents.add(value);
     }
-    addIn(path, value) {
+    addIn(path2, value) {
       if (assertCollection(this.contents))
-        this.contents.addIn(path, value);
+        this.contents.addIn(path2, value);
     }
     createAlias(node, name) {
       if (!node.anchor) {
@@ -4313,30 +4313,30 @@ var require_Document = __commonJS((exports) => {
     delete(key) {
       return assertCollection(this.contents) ? this.contents.delete(key) : false;
     }
-    deleteIn(path) {
-      if (Collection.isEmptyPath(path)) {
+    deleteIn(path2) {
+      if (Collection.isEmptyPath(path2)) {
         if (this.contents == null)
           return false;
         this.contents = null;
         return true;
       }
-      return assertCollection(this.contents) ? this.contents.deleteIn(path) : false;
+      return assertCollection(this.contents) ? this.contents.deleteIn(path2) : false;
     }
     get(key, keepScalar) {
       return identity.isCollection(this.contents) ? this.contents.get(key, keepScalar) : undefined;
     }
-    getIn(path, keepScalar) {
-      if (Collection.isEmptyPath(path))
+    getIn(path2, keepScalar) {
+      if (Collection.isEmptyPath(path2))
         return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-      return identity.isCollection(this.contents) ? this.contents.getIn(path, keepScalar) : undefined;
+      return identity.isCollection(this.contents) ? this.contents.getIn(path2, keepScalar) : undefined;
     }
     has(key) {
       return identity.isCollection(this.contents) ? this.contents.has(key) : false;
     }
-    hasIn(path) {
-      if (Collection.isEmptyPath(path))
+    hasIn(path2) {
+      if (Collection.isEmptyPath(path2))
         return this.contents !== undefined;
-      return identity.isCollection(this.contents) ? this.contents.hasIn(path) : false;
+      return identity.isCollection(this.contents) ? this.contents.hasIn(path2) : false;
     }
     set(key, value) {
       if (this.contents == null) {
@@ -4345,13 +4345,13 @@ var require_Document = __commonJS((exports) => {
         this.contents.set(key, value);
       }
     }
-    setIn(path, value) {
-      if (Collection.isEmptyPath(path)) {
+    setIn(path2, value) {
+      if (Collection.isEmptyPath(path2)) {
         this.contents = value;
       } else if (this.contents == null) {
-        this.contents = Collection.collectionFromPath(this.schema, Array.from(path), value);
+        this.contents = Collection.collectionFromPath(this.schema, Array.from(path2), value);
       } else if (assertCollection(this.contents)) {
-        this.contents.setIn(path, value);
+        this.contents.setIn(path2, value);
       }
     }
     setSchema(version, options = {}) {
@@ -6240,9 +6240,9 @@ var require_cst_visit = __commonJS((exports) => {
   visit.BREAK = BREAK;
   visit.SKIP = SKIP;
   visit.REMOVE = REMOVE;
-  visit.itemAtPath = (cst, path) => {
+  visit.itemAtPath = (cst, path2) => {
     let item = cst;
-    for (const [field, index] of path) {
+    for (const [field, index] of path2) {
       const tok = item?.[field];
       if (tok && "items" in tok) {
         item = tok.items[index];
@@ -6251,23 +6251,23 @@ var require_cst_visit = __commonJS((exports) => {
     }
     return item;
   };
-  visit.parentCollection = (cst, path) => {
-    const parent = visit.itemAtPath(cst, path.slice(0, -1));
-    const field = path[path.length - 1][0];
+  visit.parentCollection = (cst, path2) => {
+    const parent = visit.itemAtPath(cst, path2.slice(0, -1));
+    const field = path2[path2.length - 1][0];
     const coll = parent?.[field];
     if (coll && "items" in coll)
       return coll;
     throw new Error("Parent collection not found");
   };
-  function _visit(path, item, visitor) {
-    let ctrl = visitor(item, path);
+  function _visit(path2, item, visitor) {
+    let ctrl = visitor(item, path2);
     if (typeof ctrl === "symbol")
       return ctrl;
     for (const field of ["key", "value"]) {
       const token = item[field];
       if (token && "items" in token) {
         for (let i = 0;i < token.items.length; ++i) {
-          const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);
+          const ci = _visit(Object.freeze(path2.concat([[field, i]])), token.items[i], visitor);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -6278,10 +6278,10 @@ var require_cst_visit = __commonJS((exports) => {
           }
         }
         if (typeof ctrl === "function" && field === "key")
-          ctrl = ctrl(item, path);
+          ctrl = ctrl(item, path2);
       }
     }
-    return typeof ctrl === "function" ? ctrl(item, path) : ctrl;
+    return typeof ctrl === "function" ? ctrl(item, path2) : ctrl;
   }
   exports.visit = visit;
 });
@@ -11255,7 +11255,8 @@ var adapters = {
       return { binary: "copilot", args: withModelArgs(options.model, args) };
     },
     buildResumeCommand(_sessionId, prompt, options) {
-      const args = ["-p", prompt];
+      const auto = options.allowAll ? ["--allow-all", "--no-ask-user"] : [];
+      const args = [...auto, "-p", prompt];
       return { binary: "copilot", args: withModelArgs(options.model, args) };
     },
     createStreamParser: createPassthroughParser,
@@ -11274,6 +11275,41 @@ function getHarnessAdapter(name) {
 
 // src/lib/process-runner.ts
 import { spawn } from "node:child_process";
+import path from "node:path";
+var PATH_PARAMETER_KEYS = new Set(["file_path", "filepath", "path", "notebook_path"]);
+var PARAMETER_MAX_LENGTH = 60;
+var RAW_INPUT_MAX_LENGTH = 100;
+function truncateFromEnd(value, maxLength) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return value.slice(0, maxLength - 3) + "...";
+}
+function truncateFromBeginning(value, maxLength) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return "..." + value.slice(-(maxLength - 3));
+}
+function isPathParameterKey(key) {
+  return PATH_PARAMETER_KEYS.has(key.toLowerCase());
+}
+function looksLikeFilePath(value) {
+  return path.isAbsolute(value) || value.includes("/") || value.includes("\\") || value.startsWith("./") || value.startsWith("../") || value.startsWith("~/");
+}
+function stripWorkspacePrefix(filePath, workspaceRoot) {
+  if (!path.isAbsolute(filePath)) {
+    return filePath;
+  }
+  const relativePath = path.relative(workspaceRoot, filePath);
+  if (relativePath && !relativePath.startsWith("..") && !path.isAbsolute(relativePath)) {
+    return relativePath;
+  }
+  if (relativePath === "") {
+    return ".";
+  }
+  return filePath;
+}
 function formatToolInput(toolInput) {
   try {
     const parsed = JSON.parse(toolInput);
@@ -11281,14 +11317,17 @@ function formatToolInput(toolInput) {
     if (entries.length === 0) {
       return "";
     }
+    const workspaceRoot = process.cwd();
     const parts = entries.map(([key, value]) => {
       const strValue = typeof value === "string" ? value : JSON.stringify(value);
-      const truncated = strValue.length > 60 ? strValue.slice(0, 57) + "..." : strValue;
+      const isPathLike = typeof value === "string" && isPathParameterKey(key) && looksLikeFilePath(value);
+      const formatted = isPathLike ? stripWorkspacePrefix(strValue, workspaceRoot) : strValue;
+      const truncated = isPathLike ? truncateFromBeginning(formatted, PARAMETER_MAX_LENGTH) : truncateFromEnd(formatted, PARAMETER_MAX_LENGTH);
       return `${key}=${truncated}`;
     });
     return parts.join(" ");
   } catch {
-    return toolInput.length > 100 ? toolInput.slice(0, 97) + "..." : toolInput;
+    return truncateFromEnd(toolInput, RAW_INPUT_MAX_LENGTH);
   }
 }
 async function runHarnessCommand(command, parseStreamLine) {
@@ -12218,41 +12257,6 @@ class RootCommand extends BaseCommand {
   }
 }
 
-// src/lib/logger.ts
-var colors = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  red: "\x1B[31m",
-  yellow: "\x1B[33m",
-  cyan: "\x1B[36m",
-  green: "\x1B[32m"
-};
-function wrap(color, text) {
-  return `${color}${text}${colors.reset}`;
-}
-var logger = {
-  header(text) {
-    process.stdout.write(`${wrap(colors.bold + colors.cyan, text)}
-`);
-  },
-  info(text) {
-    process.stdout.write(`${text}
-`);
-  },
-  success(text) {
-    process.stdout.write(`${wrap(colors.green, text)}
-`);
-  },
-  warn(text) {
-    process.stderr.write(`${wrap(colors.yellow, text)}
-`);
-  },
-  error(text) {
-    process.stderr.write(`${wrap(colors.red, text)}
-`);
-  }
-};
-
 // src/commands/run.ts
 import { readFile as readFile4, stat } from "node:fs/promises";
 import { resolve as resolve9 } from "node:path";
@@ -12315,6 +12319,9 @@ async function resolveWorkflowPath(inputPath) {
     throw new UserInputError(`Failed to access workflow path "${absolutePath}": ${getErrorMessage(error)}`);
   }
 }
+function workflowRequiresTask(workflow) {
+  return workflow.steps.some((step) => step.requires.inputs.includes("task"));
+}
 
 class RunCommand extends BaseCommand {
   static paths = [["run"]];
@@ -12402,7 +12409,7 @@ class RunCommand extends BaseCommand {
       }
       throw new UserInputError(`Failed to load workflow "${workflowPath}": ${getErrorMessage(error)}`);
     }
-    const { task, displayTask } = await this.resolveTask();
+    const { task, displayTask } = workflowRequiresTask(workflow) ? await this.resolveTask() : { task: "", displayTask: "(none)" };
     const runId = generateRunId();
     const runState = createInitialRunState({
       runId,
@@ -12451,13 +12458,13 @@ try {
   process.exitCode = Math.max(process.exitCode ?? 0, exitCode);
 } catch (error) {
   if (error instanceof RmrError) {
-    logger.error(`${error.code}: ${error.message}`);
+    ui.error(`${error.code}: ${error.message}`);
     process.exitCode = 1;
   } else if (error instanceof Error) {
-    logger.error(error.message);
+    ui.error(error.message);
     process.exitCode = 1;
   } else {
-    logger.error("Unknown error");
+    ui.error("Unknown error");
     process.exitCode = 1;
   }
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@klaudworks/rex",
-  "version": "1.0.1",
+  "version": "1.1.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@klaudworks/rex",
-      "version": "1.0.1",
+      "version": "1.1.2",
       "dependencies": {
         "clipanion": "^4.0.0-rc.4",
         "yaml": "^2.8.2"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@klaudworks/rmr",
-  "version": "1.0.1",
+  "version": "1.1.2",
   "description": "Define multi-step coding workflows for AI agents",
   "license": "MIT",
   "repository": {