hilos-agent 0.1.11 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hilos-agent",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "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__";
@@ -241,6 +290,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}`;
   }
@@ -280,20 +339,38 @@ async function fetchContext({ channelId, tool, parentId }) {
   return { rows, transcript: rows.map((m) => `${m.author}: ${m.body}`).join("\n").slice(-6000) };
 }
 
+/**
+ * Prompt for the fast "here's my plan" ack. Carries the distilled task AND the
+ * conversation as background, so the ack is specific ("On it — I'll add X…")
+ * instead of asking for context it was already handed. (The old bug: fed only the
+ * bare mention, it replied "can't see the channel message yet.")
+ * @param {{ task?: string, transcript?: string, repoFullName?: string }} [o]
+ */
+export function planAckPrompt(o) {
+  const { task, transcript, repoFullName } = o || {};
+  const where = repoFullName ? ` in the repo ${repoFullName}` : "";
+  let p =
+    `A teammate asked you to do this${where}:\n"${(task || "").trim()}"\n\n` +
+    `Reply with ONE or TWO short sentences, first person: acknowledge, state your ` +
+    `plan, and say you'll open a PR and report back. No preamble, no lists, no code. ` +
+    `Tone: "On it — I'll add X by doing Y. I'll open a PR and report back."`;
+  const t = (transcript || "").trim();
+  if (t) {
+    p += `\n\nConversation so far (background — resolve references like "this" against it):\n${t}`;
+  }
+  return p;
+}
+
 /**
  * A 1–2 sentence "here's my plan" line for the instant ack, via the FAST chat
  * CLI. Bounded (≤45s) + best-effort: returns trimmed text, or null on
  * empty/timeout/error so the run keeps the instant template and never stalls.
  */
-async function proposePlanAck({ task, repoFullName, cfg, signal }) {
+async function proposePlanAck({ task, transcript, repoFullName, cfg, signal }) {
   const cmd = cfg.chatCmd;
   if (!cmd) return null;
   const parts = cmd.split(" ").filter(Boolean);
-  const prompt =
-    `A teammate asked you to do this in the repo ${repoFullName}:\n"${task}"\n\n` +
-    `Reply with ONE or TWO short sentences, first person: acknowledge, state your ` +
-    `plan, and say you'll open a PR and report back. No preamble, no lists, no code. ` +
-    `Tone: "On it — I'll add X by doing Y. I'll open a PR and report back."`;
+  const prompt = planAckPrompt({ task, transcript, repoFullName });
   const run = await runCli({
     cmd: parts[0],
     args: [...parts.slice(1), prompt],
@@ -518,7 +595,15 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
   const ack = await tool("post_message", { channelId, parentId, body: ackText(repoFullName) });
   const ackId = ack?.messageId ?? null;
   if (ackId && caps.editMessage && cfg.chatCmd) {
-    const plan = await proposePlanAck({ task: message.body, repoFullName, cfg, signal }).catch(() => null);
+    // Feed the ack the router's distilled brief AND the conversation — not the raw
+    // mention — so it states a real plan instead of "what's the task?".
+    const plan = await proposePlanAck({
+      task: routed.task || message.body,
+      transcript: context.transcript,
+      repoFullName,
+      cfg,
+      signal,
+    }).catch(() => null);
     if (plan && !signal?.aborted) await tool("edit_message", { messageId: ackId, body: plan }).catch(() => {});
   }
 
@@ -615,8 +700,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);
@@ -678,6 +774,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") {