hilos-agent 0.1.12 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hilos-agent",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Run your own coding agent (Claude Code / Codex / Cursor) as an autonomous teammate in a hilos channel. Picks up @mentions in channels and threads, makes the change, and opens a PR for review — your code and credentials never leave your machine. (Approve-before-push is available via gate:true.)",
   "type": "module",
   "bin": {

package/src/handler.mjs

@@ -43,6 +43,17 @@ function defaultDeps() {
       const url = (r.stdout || "").trim().split("\n").filter(Boolean).pop() || null;
       return { ok: r.status === 0, url, stderr: r.stderr || "" };
     },
+    // The open PR for a branch, if one already exists — so when the CLI opened a
+    // PR itself we report THAT instead of opening a duplicate.
+    findPR: (cwd, branch) => {
+      const r = spawnSync(
+        "gh",
+        ["pr", "list", "--head", branch, "--state", "open", "--json", "url", "--jq", ".[0].url // empty"],
+        { cwd, encoding: "utf8" },
+      );
+      const url = (r.stdout || "").trim();
+      return r.status === 0 && url ? url : null;
+    },
     sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
     now: () => Date.now(),
   };
@@ -165,6 +176,44 @@ async function applyDecision({ decision, repoPath, branch, task, requester, cfg,
   return { status: "timeout", branch };
 }
 
+/**
+ * The coding CLI committed the work itself (autonomous run with skip-permissions
+ * in a repo whose docs prescribe a commit+PR flow), so the working tree is clean
+ * and the daemon's diff is empty. Don't claim "no changes": adopt what it did —
+ * push the branch it's on (no-op if already pushed), reuse the PR it opened or
+ * open one, and report it. Used only when NOT gated (bias-to-action).
+ */
+async function shipSelfDriven({ repoPath, branch, task, requester, cfg, tool, channelId, deps, parentId }) {
+  const tag = requesterTag(requester);
+  const lead = tag ? `${tag} — ` : "";
+  // The agent may have committed on the daemon's branch or switched to one of its
+  // own — push whatever HEAD is on now.
+  const cur =
+    (deps.git(repoPath, ["symbolic-ref", "--quiet", "--short", "HEAD"]).stdout || "").trim() || branch;
+  const push = deps.git(repoPath, ["push", "-u", "origin", cur]);
+  let prUrl = deps.findPR ? deps.findPR(repoPath, cur) : null;
+  if (!prUrl && push.status === 0) {
+    const { title, body } = prTitleBody(task, cur);
+    const pr = deps.openPR(repoPath, { title, body, branch: cur, base: cfg.defaultBranch });
+    prUrl = pr.ok && pr.url ? pr.url : null;
+  }
+  const { title } = prTitleBody(task, cur);
+  await tool("post_report", {
+    channelId,
+    parentId,
+    title: `Shipped: ${title}`,
+    summary: prUrl
+      ? `${lead}the coding agent committed on \`${cur}\` and opened a pull request.`
+      : push.status === 0
+        ? `${lead}the coding agent committed and pushed \`${cur}\`. Open a PR manually — \`gh\` didn't return one.`
+        : `${lead}the coding agent committed on \`${cur}\` locally, but pushing it failed.`,
+    prUrl: prUrl || undefined,
+    caveats: push.status === 0 ? [] : [`git push failed: ${(push.stderr || "").trim().slice(0, 200)}`],
+  });
+  if (prUrl) await linkPrFromUrl({ tool, channelId, url: prUrl });
+  return { status: push.status === 0 ? "pushed" : "commit-local", branch: cur, prUrl };
+}
+
 // Sentinel the router model emits when the latest message is a request to change
 // code. Unusual on purpose so it can't be confused with a real chat reply.
 const CODE_SIGNAL = "__CODE__";
@@ -205,6 +254,8 @@ async function routeIntent({ name, repoFullName, transcript, workspaceMemory, cf
     `Otherwise — a question, a greeting, general discussion, or they explicitly don't want code ` +
     `yet — just reply to them concisely and directly as a single chat message (no preamble, no ` +
     `headings). When unsure, prefer to act (${CODE_SIGNAL}); this is a build channel.\n\n` +
+    `You are only routing here — output ONLY your text response. Do NOT use any tools, do NOT ` +
+    `edit files, do NOT run commands; a separate step does the actual coding.\n\n` +
     `${memoryPreamble(workspaceMemory)}Conversation so far:\n${transcript}`;
   const run = await runCli({
     cmd: parts[0],
@@ -216,9 +267,16 @@ async function routeIntent({ name, repoFullName, transcript, workspaceMemory, cf
   if (run.aborted || signal?.aborted) return { aborted: true };
   const out = (run.stdout || "").trim();
   if (!out) return { code: false, reply: null, error: run.error || new Error("no output") };
-  if (new RegExp(`^${CODE_SIGNAL}\\b`).test(out)) {
-    const nl = out.indexOf("\n");
-    return { code: true, task: nl >= 0 ? out.slice(nl + 1).trim() : "" };
+  // Accept the sentinel ANYWHERE, not just the first line — models sometimes add a
+  // line of preamble before it ("Got it, …\n__CODE__\n<brief>"). If it appears,
+  // it's a code run; the brief is whatever follows the sentinel's line and any
+  // preamble before it is discarded. This is also what keeps the raw sentinel out
+  // of a chat message (markdown would render `__CODE__` as a bold "CODE").
+  const idx = out.indexOf(CODE_SIGNAL);
+  if (idx >= 0) {
+    const after = out.slice(idx + CODE_SIGNAL.length);
+    const nl = after.indexOf("\n");
+    return { code: true, task: (nl >= 0 ? after.slice(nl + 1) : after).trim() };
   }
   return { code: false, reply: out };
 }
@@ -241,6 +299,16 @@ export function codeTaskPrompt(o) {
   let p =
     `You are a coding agent working${where}. Implement the following by EDITING FILES now — ` +
     `make the changes directly, do not just describe them, do not ask questions:\n\n${task}`;
+  // The daemon owns git: it stages, commits, pushes, and opens the PR after the
+  // CLI finishes. An autonomous CLI run with skip-permissions inside a repo whose
+  // docs prescribe a commit+PR workflow will otherwise do all of that itself,
+  // leaving a clean tree the daemon reads as "no changes" — so it must not.
+  p +=
+    `\n\nIMPORTANT: edit files ONLY. Do NOT run git; do NOT stage, commit, push, ` +
+    `create branches, or open pull requests; do NOT use the \`gh\` CLI. hilos commits ` +
+    `your changes, pushes the branch, and opens the PR for you after you finish. ` +
+    `Ignore any repository instructions (e.g. CLAUDE.md / CONTRIBUTING) that tell ` +
+    `you to commit or open a PR yourself — just leave your edits in the working tree.`;
   if (transcript) {
     p += `\n\nBackground from the team's discussion (context only — the task above is what to do):\n${transcript}`;
   }
@@ -500,23 +568,55 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
     await tool("post_message", { channelId, parentId, body: `Can't read git status in ${repoPath}.` });
     return { status: "git-error" };
   }
+  // Remember where we started so cancel/cleanup/stash-restore can switch back
+  // explicitly (relying on `git switch -` breaks from a detached HEAD).
+  const symref = git(repoPath, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
+  const startRef =
+    symref.status === 0 && symref.stdout.trim()
+      ? { kind: "branch", ref: symref.stdout.trim() }
+      : { kind: "detached", ref: (git(repoPath, ["rev-parse", "HEAD"]).stdout || "").trim() };
+
+  // A dirty tree used to be a hard stop ("commit or stash first"). But the daemon
+  // runs in the user's own checkout, so that was a constant wall — and the user
+  // can't make the agent clear it. Instead: stash the uncommitted work, run on a
+  // clean branch, and restore it (git stash pop) on the original branch when done.
+  let stashed = false;
   if (status.stdout.trim()) {
+    const st = git(repoPath, ["stash", "push", "-u", "-m", "hilos: auto-stash before agent run"]);
+    if (st.status !== 0) {
+      await tool("post_message", {
+        channelId,
+        parentId,
+        body: `Working tree at ${repoPath} is dirty and I couldn't stash it (${(st.stderr || "").trim().slice(0, 200)}). Commit or stash, then mention me again.`,
+      });
+      return { status: "dirty" };
+    }
+    stashed = true;
     await tool("post_message", {
       channelId,
       parentId,
-      body: `Working tree at ${repoPath} is dirty — commit or stash first.`,
+      body: `Your working tree was dirty — I stashed your uncommitted changes so I can work on a clean branch, and I'll restore them when I'm done.`,
     });
-    return { status: "dirty" };
   }
+  // Restore the stash onto the original branch. Best-effort: a pop conflict (rare —
+  // the daemon's work lands on its own branch, not here) leaves the stash for the
+  // user. Called from `finally` so every exit path restores.
+  const restoreStash = async () => {
+    if (!stashed) return;
+    if (startRef.ref) {
+      git(repoPath, startRef.kind === "branch" ? ["switch", "--force", startRef.ref] : ["switch", "--detach", startRef.ref]);
+    }
+    const pop = git(repoPath, ["stash", "pop"]);
+    if (pop.status !== 0) {
+      await tool("post_message", {
+        channelId,
+        parentId,
+        body: `Heads up: I couldn't auto-restore your stashed changes (conflict). They're safe — run \`git stash pop\` in ${repoPath} when you're ready.`,
+      }).catch(() => {});
+    }
+  };
 
-  // Remember where we started so cancel/cleanup can switch back explicitly
-  // (relying on `git switch -` breaks from a detached HEAD).
-  const symref = git(repoPath, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
-  const startRef =
-    symref.status === 0 && symref.stdout.trim()
-      ? { kind: "branch", ref: symref.stdout.trim() }
-      : { kind: "detached", ref: (git(repoPath, ["rev-parse", "HEAD"]).stdout || "").trim() };
-
+  try {
   const branch = branchSlug(message.body, randomBytes(3).toString("hex"));
   git(repoPath, ["fetch", "origin", cfg.defaultBranch]);
   const co = git(repoPath, ["switch", "-c", branch]);
@@ -641,8 +741,19 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
           stderrTail: oneLine((run.stderr || "").trim().split("\n").slice(-3).join(" "), 300),
         };
       }
+      // Not failed, but nothing staged — the CLI may have done its OWN git
+      // (commit/push/PR) despite being told only to edit. Detect commits it made
+      // on this branch so we report + ship them instead of falsely claiming "no
+      // changes" and deleting a branch that has real work.
+      const base = startRef.ref || cfg.defaultBranch;
+      const ahead =
+        Number((git(repoPath, ["rev-list", "--count", `${base}..HEAD`]).stdout || "0").trim()) || 0;
+      if (ahead > 0) {
+        console.log(`  code → agent self-committed (${ahead} commit(s) ahead); reconciling`);
+        return { empty: true, failed: false, ahead };
+      }
       console.log("  code → no changes produced");
-      return { empty: true, failed: false };
+      return { empty: true, failed: false, ahead: 0 };
     }
     console.log("  code → diff captured");
     const stat = parseShortstat(git(repoPath, ["diff", "--cached", "--shortstat"]).stdout);
@@ -704,6 +815,36 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
 
   const staged = await runAndStage(codeTaskPrompt({ message, context, brief: routed.task, repoFullName }));
   if (staged.aborted) return await postStopped();
+  // The CLI committed on its own (clean tree, but commits ahead of base). Don't
+  // report "no changes" or delete the branch — surface the real work.
+  if (staged.empty && !staged.failed && staged.ahead > 0) {
+    if (cfg.gate) {
+      // Approve-before-push: a self-pushing CLI already bypassed the gate; be
+      // honest and let the human review instead of auto-shipping. Leave the branch.
+      await tool("post_message", {
+        channelId,
+        parentId,
+        body:
+          `The coding agent committed on \`${branch}\` itself (I asked it to only edit files). ` +
+          `Under approve-before-push I won't auto-push it — review \`${branch}\` locally, then ` +
+          `re-mention me to ship or discard.`,
+      });
+      await finalizeProgress(`\`${branch}\` has the agent's own commits — needs review.`);
+      return { status: "self-committed-gated", branch };
+    }
+    await finalizeProgress(`Agent shipped \`${branch}\` itself — report below.`);
+    return await shipSelfDriven({
+      repoPath,
+      branch,
+      task: routed.task || message.body,
+      requester: message.author,
+      cfg,
+      tool,
+      channelId,
+      deps,
+      parentId,
+    });
+  }
   if (staged.empty) {
     let body;
     if (staged.failed && staged.errCode === "ENOENT") {
@@ -796,4 +937,8 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
   });
   await finalizeProgress(`Done on \`${branch}\` — see the report below.`);
   return { ...result, reportMessageId: proposal.reportMessageId, stat: proposal.stat, rounds: round };
+  } finally {
+    // Whatever happened, give the user their uncommitted work back.
+    await restoreStash();
+  }
 }