@mu-crew/mu 3.2.1 → 3.3.0

package/dist/extension/mu-pi.js

@@ -1,26 +1,30 @@
 // extension/mu-pi.ts
 import {
   chmodSync,
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   linkSync,
   mkdirSync,
-  readFileSync,
+  readdirSync,
+  readFileSync as readFileSync2,
   realpathSync,
   rmSync,
   statSync as statSync2
 } from "fs";
 import { connect, createServer } from "net";
-import { dirname, join as join2 } from "path";
+import { dirname, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/ctl/protocol.ts
 var CTL_PROTOCOL_VERSION = 1;
+var CTL_COMMANDS = ["new", "reload", "compact"];
 var CTL_OPS = [
   "hello",
   "status",
   "send",
   "wait",
   "abort",
-  "fresh"
+  "fresh",
+  "command"
 ];
 var UNKNOWN_OP_PREFIX = "unknown op: ";
 function encode(msg) {
@@ -427,10 +431,143 @@ ${task}` : task, "-w", W]);
   });
 }
 
+// extension/nudge.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { join as join2 } from "path";
+var NUDGE_MESSAGE_TYPE = "mu-keep-driving";
+var NUDGE_LOG_KIND = "nudge";
+var MARK_START = "<!-- mu:keep-driving -->";
+var MARK_END = "<!-- /mu:keep-driving -->";
+var WAIT_HINT_MAX = 8;
+function nudgeEnabled(env = process.env) {
+  return env.MU_NUDGE !== "0";
+}
+function keepDrivingRule(skillMd) {
+  const i = skillMd.indexOf(MARK_START);
+  const j = skillMd.indexOf(MARK_END);
+  if (i < 0 || j < i) return void 0;
+  const text = skillMd.slice(i + MARK_START.length, j).trim();
+  return text === "" ? void 0 : text;
+}
+function readSkill() {
+  for (const up of ["..", "../.."]) {
+    const p = join2(import.meta.dirname ?? "", up, "skills", "mu", "SKILL.md");
+    if (existsSync2(p)) return readFileSync(p, "utf8");
+  }
+  return void 0;
+}
+function dispatchedWorkstreams(command) {
+  const found = /* @__PURE__ */ new Set();
+  for (const seg of command.split(/&&|\|\||;|\n|\|/)) {
+    const words = seg.trim().split(/\s+/);
+    const at = words.findIndex((w) => w === "mu" || w.endsWith("/mu"));
+    if (at < 0) continue;
+    const [noun, verb] = [words[at + 1], words[at + 2]];
+    const isSendSpawn = noun === "agent" && (verb === "send" || verb === "spawn");
+    const isClaimFor = noun === "task" && verb === "claim" && words.includes("--for");
+    if (!isSendSpawn && !isClaimFor) continue;
+    let ws = "";
+    for (let k = at + 3; k < words.length; k++) {
+      const w = words[k] ?? "";
+      if (w === "-w" || w === "--workstream") ws = unquote(words[k + 1] ?? "");
+      else if (w.startsWith("--workstream=")) ws = unquote(w.slice("--workstream=".length));
+    }
+    if (ws === "" && isClaimFor) {
+      const ref = words[at + 3] ?? "";
+      if (ref.includes("/")) ws = unquote(ref.split("/")[0] ?? "");
+    }
+    if (ws !== "scratch") found.add(ws);
+  }
+  return found.size > 0 ? [...found] : void 0;
+}
+function unquote(s) {
+  return s.replace(/^['"]|['"]$/g, "");
+}
+async function inProgress(run, workstreams) {
+  const named = workstreams.filter((w) => w !== "");
+  const args = ["state", "--json", "--events", "0"];
+  for (const w of named) args.push("-w", w);
+  const r = await run(args);
+  if (r.code !== 0) return void 0;
+  let json;
+  try {
+    json = JSON.parse(r.stdout);
+  } catch {
+    return void 0;
+  }
+  const cards = json.workstreams ?? [json];
+  const refs = [];
+  for (const ws of cards) {
+    for (const t of ws.inProgress ?? []) {
+      if (t.name) refs.push(`${ws.workstreamName ?? ""}/${t.name}`);
+    }
+  }
+  return refs;
+}
+function nudgeText(rule, refs) {
+  const shown = refs.slice(0, WAIT_HINT_MAX).join(" ");
+  const more = refs.length > WAIT_HINT_MAX ? ` (+${refs.length - WAIT_HINT_MAX} more)` : "";
+  return [
+    `[mu] ${rule}`,
+    "",
+    `${refs.length} task(s) IN_PROGRESS. Next: mu task wait ${shown} --first --on-stall exit --json${more}`
+  ].join("\n");
+}
+function outcomeOf(event) {
+  return typeof event === "object" && event !== null ? event.outcome : void 0;
+}
+function bashCommand(event) {
+  if (typeof event !== "object" || event === null) return void 0;
+  const e = event;
+  return e.toolName === "bash" && typeof e.input?.command === "string" ? e.input.command : void 0;
+}
+function registerNudge(pi, run = defaultRunner(), skillMd = readSkill()) {
+  if (!nudgeEnabled()) return;
+  const rule = skillMd === void 0 ? void 0 : keepDrivingRule(skillMd);
+  if (rule === void 0) return;
+  const armed = /* @__PURE__ */ new Set();
+  let fired = false;
+  pi.on("input", () => {
+    armed.clear();
+    fired = false;
+  });
+  pi.on("tool_call", (event) => {
+    const cmd = bashCommand(event);
+    if (cmd === void 0) return;
+    for (const ws of dispatchedWorkstreams(cmd) ?? []) armed.add(ws);
+  });
+  pi.on("agent_before_settle", async (event) => {
+    if (fired || armed.size === 0) return;
+    if (outcomeOf(event) !== "completed") return;
+    fired = true;
+    const refs = await inProgress(run, [...armed]);
+    if (refs === void 0 || refs.length === 0) return;
+    const text = nudgeText(rule, refs);
+    const logWs = [...armed].find((w) => w !== "");
+    await run([
+      "log",
+      ...logWs ? ["-w", logWs] : [],
+      "--kind",
+      NUDGE_LOG_KIND,
+      `keep-driving: ${refs.length} in progress`
+    ]);
+    return {
+      entries: [
+        { type: "custom_message", customType: NUDGE_MESSAGE_TYPE, content: text, display: true }
+      ],
+      continue: true
+    };
+  });
+}
+
 // extension/mu-pi.ts
-var EXT_VERSION = true ? "3.2.1" : void 0;
+var EXT_VERSION = true ? "3.3.0" : void 0;
 var FRESH_COMMAND = "mu-fresh";
 var FRESH_TIMEOUT_MS = 3e4;
+function commandName(name) {
+  return `mu-${name}`;
+}
+var COMMAND_TIMEOUT_MS = 3e4;
 var LAST_TEXT_MAX_BYTES = 64 * 1024;
 var LAST_TEXT_TRUNCATED = "[truncated, see pane]";
 var LIVE_PROBE_MS = 500;
@@ -444,9 +581,9 @@ function detectPiVersion() {
     if (!entry) return void 0;
     let dir = dirname(realpathSync(entry));
     for (let i = 0; i < 6; i++) {
-      const pkgPath = join2(dir, "package.json");
-      if (existsSync2(pkgPath)) {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+      const pkgPath = join3(dir, "package.json");
+      if (existsSync3(pkgPath)) {
+        const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
         if (typeof pkg === "object" && pkg !== null) {
           const { name, version } = pkg;
           if (typeof name === "string" && /pi/.test(name) && typeof version === "string") {
@@ -529,8 +666,31 @@ function reasonOf(event) {
   const r = typeof event === "object" && event !== null ? event.reason : void 0;
   return typeof r === "string" ? r : void 0;
 }
+function promptsDir(from = import.meta.url) {
+  let here;
+  try {
+    here = dirname(fileURLToPath2(from));
+  } catch {
+    return void 0;
+  }
+  for (const up of ["..", "../.."]) {
+    const d = join3(here, up, "prompts");
+    if (existsSync3(join3(d, "ultrathink.md"))) return d;
+  }
+  return void 0;
+}
+function registerPrompts(pi) {
+  pi.on("resources_discover", () => {
+    const d = promptsDir();
+    if (!d) return {};
+    const paths = readdirSync(d).filter((f) => f.endsWith(".md")).sort().map((f) => join3(d, f));
+    return { promptPaths: paths };
+  });
+}
 function muPi(pi) {
   registerDelegate(pi);
+  registerPrompts(pi);
+  registerNudge(pi);
   serveCtl(pi);
 }
 function serveCtl(pi) {
@@ -565,6 +725,12 @@ function serveCtl(pi) {
     g.fresh = void 0;
     f.settle(r);
   };
+  const settleCommand = (r) => {
+    const c = g.command;
+    if (!c) return;
+    g.command = void 0;
+    c.settle(r);
+  };
   pi.on("agent_start", (_e, c) => {
     g.ctx = c;
     g.state = "busy";
@@ -603,10 +769,69 @@ function serveCtl(pi) {
       settleFresh({ v: V, ok: true, ...status() });
     }
   });
+  pi.on("session_before_compact", () => {
+    if (g.command?.name === "compact") settleCommand({ v: V, ok: true, ...status() });
+  });
+  async function runCommand(name, ctx) {
+    const c = g.command;
+    if (c?.name !== name) return;
+    const ok = () => settleCommand({ v: V, ok: true, ...status() });
+    const failWith = (e) => settleCommand(fail(e instanceof Error ? e.message : String(e)));
+    try {
+      if (name === "new") {
+        const r = await ctx.newSession();
+        if (r.cancelled) settleCommand(fail("new session was cancelled"));
+        else ok();
+      } else if (name === "reload") {
+        await ctx.reload();
+        if (c.reloaded) ok();
+        else settleCommand(fail("pi did not reload (busy or compacting)"));
+      } else {
+        ctx.compact({
+          ...c.instructions !== void 0 ? { customInstructions: c.instructions } : {},
+          onComplete: ok,
+          onError: failWith
+        });
+      }
+    } catch (e) {
+      failWith(e);
+    }
+  }
+  for (const name of CTL_COMMANDS) {
+    pi.registerCommand(commandName(name), {
+      description: `mu internal: /${name} requested over the control socket (mu agent send '/${name}')`,
+      handler: (_args, ctx) => runCommand(name, ctx)
+    });
+  }
+  function command(req) {
+    const name = CTL_COMMANDS.find((n) => n === req.name);
+    if (name === void 0) {
+      return fail(`command must be one of ${CTL_COMMANDS.join(", ")}`);
+    }
+    if (g.fresh || g.command) return fail("a fresh send or command is already in progress");
+    const busy = !(g.ctx?.isIdle() ?? g.state === "idle");
+    if (busy && req.force !== true) return fail("busy");
+    const instructions = str(req, "instructions");
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => settleCommand(fail(`/${name} timed out`)), COMMAND_TIMEOUT_MS);
+      g.command = {
+        name,
+        ...instructions !== void 0 ? { instructions } : {},
+        reloaded: false,
+        settle: (r) => {
+          clearTimeout(timer);
+          resolve(r);
+        }
+      };
+      Promise.resolve(
+        g.pi.sendUserMessage(`/${commandName(name)}`, { expandPromptTemplates: true })
+      ).catch((e) => settleCommand(fail(e instanceof Error ? e.message : String(e))));
+    });
+  }
   function fresh(req) {
     const text = str(req, "text");
     if (text === void 0) return fail("fresh needs a string text");
-    if (g.fresh) return fail("a fresh send is already in progress");
+    if (g.fresh || g.command) return fail("a fresh send or command is already in progress");
     const busy = !(g.ctx?.isIdle() ?? g.state === "idle");
     if (busy && req.force !== true) return fail("busy");
     return new Promise((resolve) => {
@@ -648,6 +873,8 @@ function serveCtl(pi) {
       }
       case "fresh":
         return fresh(req);
+      case "command":
+        return command(req);
       case "wait":
         return wait(num(req, "afterRuns"), num(req, "timeoutMs"), conn);
       case "abort":
@@ -720,7 +947,7 @@ function serveCtl(pi) {
       return;
     }
     rmSync(sockPath, { force: true });
-    const tmp = join2(dirname(sockPath), `.${process.pid.toString(36)}${(++bindSeq).toString(36)}`);
+    const tmp = join3(dirname(sockPath), `.${process.pid.toString(36)}${(++bindSeq).toString(36)}`);
     rmSync(tmp, { force: true });
     const s = createServer(onConnection);
     await new Promise((resolve, reject) => {
@@ -745,8 +972,9 @@ function serveCtl(pi) {
     g.server = s;
     g.ino = inodeOf(sockPath);
   }
-  pi.on("session_start", async (_e, c) => {
+  pi.on("session_start", async (e, c) => {
     g.ctx = c;
+    if (reasonOf(e) === "reload" && g.command?.name === "reload") g.command.reloaded = true;
     const s = g.server;
     if (s) {
       if (g.ino !== void 0 && inodeOf(sockPath) === g.ino) return;
@@ -769,18 +997,22 @@ function serveCtl(pi) {
     if (!s) return;
     g.waiters.clear();
     settleFresh(fail("pi is shutting down"));
+    settleCommand(fail("pi is shutting down"));
     for (const c of g.conns) c.destroy();
     await new Promise((resolve) => s.close(() => resolve()));
     if (ino !== void 0 && inodeOf(sockPath) === ino) rmSync(sockPath, { force: true });
   });
 }
 export {
+  COMMAND_TIMEOUT_MS,
   FRESH_COMMAND,
   FRESH_TIMEOUT_MS,
   LAST_TEXT_MAX_BYTES,
   LAST_TEXT_TRUNCATED,
   LIVE_PROBE_MS,
+  commandName,
   muPi as default,
-  lastAssistantText
+  lastAssistantText,
+  promptsDir
 };
 //# sourceMappingURL=mu-pi.js.map