@devmarketplacenpm/devmp 0.1.1-beta.5

package/lib/executor.js

@@ -0,0 +1,208 @@
+"use strict";
+
+const {
+  isInteractive,
+  confirmOverwrite,
+  confirmFileChange,
+  confirmDestructive,
+} = require("./prompt");
+const { formatUnifiedDiff } = require("./diff");
+const {
+  listFiles,
+  readFileRaw,
+  writeFileRaw,
+  appendFileRaw,
+  editFileRaw,
+  deleteFileRaw,
+  moveFileRaw,
+  fileExists,
+  searchFiles,
+} = require("./workspace");
+
+const MAX_SAFE_CHANGE_BYTES = 4 * 1024 * 1024;
+
+/** Execute server-requested filesystem operations inside the local workspace.
+ * Interactive M5 sessions opt into diff review + durable pre-image capture;
+ * one-shot M1-M3 clients retain their existing overwrite behavior. */
+function createExecutor({
+  rootDir,
+  yes,
+  reviewChanges = false,
+  checkpoint,
+  onFile = () => undefined,
+  interactive: interactiveOverride,
+  confirmChange = confirmFileChange,
+  confirmDestructiveChange = confirmDestructive,
+}) {
+  const interactive =
+    interactiveOverride === undefined ? isInteractive() : interactiveOverride;
+  let overwriteAll = yes === true;
+  const approved = new Set();
+
+  function assertSafeSize(content, relPath) {
+    if (Buffer.byteLength(String(content), "utf8") > MAX_SAFE_CHANGE_BYTES) {
+      throw new Error(
+        `Refused ${relPath}: proposed content exceeds the checkpoint safety limit.`
+      );
+    }
+  }
+
+  async function approveOrdinary(relPath, before, after) {
+    if (before === after) return "unchanged";
+    assertSafeSize(after, relPath);
+    if (overwriteAll) return "yes";
+
+    if (reviewChanges) {
+      if (!interactive) return "no";
+      const choice = await confirmChange({ path: relPath, before, after });
+      if (choice === "all") overwriteAll = true;
+      return choice;
+    }
+
+    // Legacy behavior: new files and files already approved during this run do
+    // not prompt; existing user files do.
+    if (approved.has(relPath)) return "yes";
+    if (!(await fileExists(rootDir, relPath))) {
+      approved.add(relPath);
+      return "yes";
+    }
+    if (!interactive) return "no";
+    const choice = await confirmOverwrite(relPath);
+    if (choice === "all") overwriteAll = true;
+    if (choice !== "no") approved.add(relPath);
+    return choice;
+  }
+
+  async function capture(paths) {
+    if (checkpoint) await checkpoint.capture(paths);
+  }
+
+  async function handle(op, args = {}) {
+    if (op === "list") return { paths: await listFiles(rootDir) };
+    if (op === "read")
+      return { content: await readFileRaw(rootDir, args.path) };
+    // Read-only: searching never needs approval, and the repo never leaves the
+    // machine — only the matching lines do.
+    if (op === "search") return searchFiles(rootDir, args);
+
+    if (op === "write" || op === "append") {
+      const before = await readFileRaw(rootDir, args.path);
+      const after =
+        op === "write"
+          ? String(args.content)
+          : `${before || ""}${String(args.content)}`;
+      const choice = await approveOrdinary(args.path, before, after);
+      if (choice === "unchanged") return { unchanged: true };
+      if (choice === "no") {
+        onFile(args.path, "skipped");
+        return { skipped: true };
+      }
+      await capture([args.path]);
+      const existed = before !== null;
+      const ok =
+        op === "write"
+          ? await writeFileRaw(rootDir, args.path, args.content)
+          : await appendFileRaw(rootDir, args.path, args.content);
+      if (!ok) throw new Error(`refused ${args.path} (outside workspace)`);
+      const outcome = existed ? "updated" : "created";
+      onFile(args.path, outcome);
+      return { outcome };
+    }
+
+    if (op === "edit") {
+      const before = await readFileRaw(rootDir, args.path);
+      if (before === null || !before.includes(args.oldString)) {
+        return { replaced: false };
+      }
+      const after = before.replace(args.oldString, args.newString);
+      const choice = await approveOrdinary(args.path, before, after);
+      if (choice === "unchanged") return { replaced: true, unchanged: true };
+      if (choice === "no") {
+        onFile(args.path, "skipped");
+        return { replaced: false, skipped: true };
+      }
+      await capture([args.path]);
+      const result = await editFileRaw(
+        rootDir,
+        args.path,
+        args.oldString,
+        args.newString
+      );
+      if (result.refused)
+        throw new Error(`refused ${args.path} (outside workspace)`);
+      if (result.replaced) onFile(args.path, "updated");
+      return {
+        replaced: result.replaced,
+        outcome: result.replaced ? "updated" : undefined,
+      };
+    }
+
+    if (op === "delete") {
+      const before = await readFileRaw(rootDir, args.path);
+      if (before === null) return { deleted: false };
+      if (!interactive) return { deleted: false, skipped: true };
+      const choice = await confirmDestructiveChange({
+        description: `Delete ${args.path}`,
+        diffs: [formatUnifiedDiff({ path: args.path, before, after: null })],
+      });
+      if (choice !== "yes") {
+        onFile(args.path, "skipped");
+        return { deleted: false, skipped: true };
+      }
+      await capture([args.path]);
+      const result = await deleteFileRaw(rootDir, args.path);
+      if (result.refused)
+        throw new Error(`refused ${args.path} (unsafe file target)`);
+      if (result.deleted) onFile(args.path, "deleted");
+      return result;
+    }
+
+    if (op === "move") {
+      const fromPath = args.fromPath;
+      const toPath = args.toPath;
+      const source = await readFileRaw(rootDir, fromPath);
+      if (source === null) return { moved: false };
+      const destination = await readFileRaw(rootDir, toPath);
+      if (!interactive) return { moved: false, skipped: true };
+      const choice = await confirmDestructiveChange({
+        description: `Move ${fromPath} → ${toPath}${
+          destination !== null ? " (replace destination)" : ""
+        }`,
+        diffs: [
+          formatUnifiedDiff({ path: fromPath, before: source, after: null }),
+          formatUnifiedDiff({
+            path: toPath,
+            before: destination,
+            after: source,
+          }),
+        ],
+      });
+      if (choice !== "yes") {
+        onFile(toPath, "skipped", { fromPath });
+        return { moved: false, skipped: true };
+      }
+      await capture([fromPath, toPath]);
+      const result = await moveFileRaw(rootDir, fromPath, toPath);
+      if (result.refused) {
+        throw new Error(
+          `refused move ${fromPath} → ${toPath} (unsafe file target)`
+        );
+      }
+      if (result.moved) {
+        await checkpoint?.recordMove(fromPath, toPath);
+        onFile(toPath, "moved", { fromPath });
+      }
+      return result;
+    }
+
+    throw new Error(`unknown fs op: ${op}`);
+  }
+
+  function setOverwriteAll(value) {
+    overwriteAll = value === true;
+  }
+
+  return { handle, setOverwriteAll };
+}
+
+module.exports = { createExecutor };

package/lib/git.js

@@ -0,0 +1,39 @@
+"use strict";
+
+const { execFile } = require("child_process");
+
+function git(args, cwd) {
+  return new Promise((resolve, reject) => {
+    execFile(
+      "git",
+      args,
+      { cwd, timeout: 3000, maxBuffer: 1024 * 1024, encoding: "utf8" },
+      (error, stdout) => {
+        if (error) reject(error);
+        else resolve(String(stdout).trim());
+      }
+    );
+  });
+}
+
+async function getGitInfo(rootDir) {
+  try {
+    const [topLevel, branch, status] = await Promise.all([
+      git(["rev-parse", "--show-toplevel"], rootDir),
+      git(["rev-parse", "--abbrev-ref", "HEAD"], rootDir),
+      git(["status", "--short", "--untracked-files=normal"], rootDir),
+    ]);
+    const entries = status ? status.split("\n").filter(Boolean) : [];
+    return {
+      isRepo: true,
+      topLevel,
+      branch: branch === "HEAD" ? "detached HEAD" : branch,
+      changed: entries.length,
+      entries,
+    };
+  } catch {
+    return { isRepo: false, changed: 0, entries: [] };
+  }
+}
+
+module.exports = { getGitInfo };

package/lib/instructions.js

@@ -0,0 +1,69 @@
+"use strict";
+
+const path = require("path");
+const fs = require("fs/promises");
+
+// Project instructions: the file a repository keeps to tell a coding agent how
+// this codebase works — its conventions, its build, the things a newcomer gets
+// wrong. Without it every session starts from zero and the agent relearns the
+// project by guessing, which is the difference between a demo and a tool people
+// keep using.
+//
+// `AGENTS.md` is first because it is the name several agents already read, so a
+// repository that has one works here with no extra file. The others are
+// accepted so a team that already standardised on one is not asked to rename it.
+const CANDIDATES = ["AGENTS.md", "DEVMP.md", "CLAUDE.md", ".devmp.md"];
+
+// Instructions ride along with every turn, so their size is a running cost, not
+// a one-off. 8 KB is a generous page of conventions and still small next to a
+// turn's own context.
+const MAX_BYTES = 8 * 1024;
+
+/**
+ * Find and read the workspace's instructions file.
+ *
+ * Returns null when there is none — the common case, and not an error. A file
+ * that exists but cannot be read is also null: instructions are an enhancement,
+ * and failing a run over them would be the wrong trade.
+ */
+async function readProjectInstructions(rootDir) {
+  const root = path.resolve(rootDir);
+  for (const name of CANDIDATES) {
+    let buf;
+    try {
+      buf = await fs.readFile(path.join(root, name));
+    } catch {
+      continue; // absent, unreadable, or a directory — try the next name
+    }
+    const truncated = buf.length > MAX_BYTES;
+    const text = buf.subarray(0, MAX_BYTES).toString("utf8").trim();
+    if (!text) return null; // an empty file is the same as no file
+    return { text, source: name, truncated };
+  }
+  return null;
+}
+
+/**
+ * Which instructions file this workspace already has, if any. Separate from
+ * reading it: `/init` needs to know whether one exists before it offers to
+ * write one, and must never overwrite what is there.
+ */
+async function findProjectInstructionsFile(rootDir) {
+  const root = path.resolve(rootDir);
+  for (const name of CANDIDATES) {
+    try {
+      const stat = await fs.stat(path.join(root, name));
+      if (stat.isFile()) return name;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+module.exports = {
+  readProjectInstructions,
+  findProjectInstructionsFile,
+  CANDIDATES,
+  MAX_BYTES,
+};