hilos-agent 0.1.9 → 0.1.11

package/README.md

@@ -72,6 +72,10 @@ hilos-agent --channel <id>   # scope to one channel
 ## How it works
 
 - **Trigger** — an `@mention` of your agent in a channel that's linked to a repo.
+- **Chat or code?** — the agent reads the conversation and decides with the model
+  (via `chatCmd`), not a keyword list: a question/greeting/"let's just discuss" →
+  a chat reply; anything asking for a change — including "just code it", "finish
+  it", "approved", or "go for it" after a request, in any language → a code run.
 - **Repo resolution** — the channel's linked repo is mapped to a local path via
   `repos`. No mapping → the agent says so and stops.
 - **Run** — it branches off `defaultBranch` (refuses a dirty tree), runs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hilos-agent",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "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

@@ -165,87 +165,86 @@ async function applyDecision({ decision, repoPath, branch, task, requester, cfg,
   return { status: "timeout", branch };
 }
 
-/**
- * Does this mention ask for a code change (→ branch/diff/PR flow), or is it
- * chat (→ a conversational reply)? Greetings and questions are chat even when
- * they mention code; an action verb means work. Keeps casual talk in a
- * repo-linked channel from spawning empty branches.
- */
-export function looksLikeCodeTask(text) {
-  const t = String(text || "")
-    .toLowerCase()
-    .replace(/@[a-z0-9-]+/g, " ")
-    .trim();
-  if (!t) return false;
-  // Greetings / questions → chat (even if they name code things).
-  if (
-    /^(hi|hey|hello|yo|sup|gm|thanks|thank you|nice|cool|ok|okay|how|what|why|when|who|where|which|is\b|are\b|do you|does|did|could you (tell|explain|show|describe)|can you (tell|explain|show|describe))/.test(
-      t,
-    )
-  ) {
-    return false;
-  }
-  const verb =
-    /\b(fix|add|implement|refactor|change|update|create|remove|delete|rename|write|build|bump|migrate|wire|patch|optimi[sz]e|debug|revert|rebase|configure|improve|replace|extract|split|move|generate|scaffold|make|set up|hook up|adjust|tweak|ship|commit|push|merge)\b/;
-  return verb.test(t);
-}
+// 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__";
 
 /**
- * A short go-ahead that approves whatever was just discussed — "go", "ship it",
- * "do it", "lfg", "send a PR". On its own this isn't a code task (no verb), but
- * after the agent has proposed a plan it MEANS "execute it". handleTask treats
- * an affirmation as code only when a repo is linked AND the agent's last message
- * looked like a plan — so casual "yes"/"cool" in a repo channel stays chat.
+ * Decide — with the LLM, not a word list — whether the latest message wants a
+ * code change or a conversational reply, and produce the payload in the SAME
+ * call. The model reads the whole conversation, so it judges by intent and
+ * context, in any language: "just code it", "dale, hazlo", "yeah go for it" after
+ * a request → code; "how does this work?", "thoughts?", "thanks" → chat.
+ *
+ * For a code request it ALSO distills an imperative task brief — resolving
+ * references like "this" / "keep working on it" against the conversation — so the
+ * coding agent gets a clean spec instead of a noisy transcript (which, with the
+ * agent's own past "no changes" messages in it, made it reply instead of edit).
+ *
+ * Returns one of:
+ *   { aborted: true }
+ *   { code: true, task }           → run the coding flow with `task` as the spec
+ *   { code: false, reply, error }  → post `reply` as a chat message
+ *
+ * `error` is set when the model produced nothing (so the caller can be honest
+ * about a timeout vs a missing binary instead of inventing a reply).
  */
-export function isAffirmation(text) {
-  const t = String(text || "")
-    .toLowerCase()
-    .replace(/@[a-z0-9-]+/g, " ")
-    .replace(/[^a-z0-9'\s]/g, " ")
-    .replace(/\s+/g, " ")
-    .trim();
-  if (!t) return false;
-  // A strong go-ahead phrase ANYWHERE means "execute it" even inside a longer,
-  // excited message ("…so it's safe to start. go for it, babyyyy"). Safe because
-  // handleTask only treats it as code when the agent had just proposed a plan.
-  if (/\b(go for it|go ahead|ship it|send it|send a pr|open a pr|make it so|lfg|let'?s go|fire away)\b/.test(t)) {
-    return true;
+async function routeIntent({ name, repoFullName, transcript, workspaceMemory, cfg, signal }) {
+  const cmd = cfg.chatCmd || cfg.codingCmd;
+  const parts = cmd.split(" ").filter(Boolean);
+  const prompt =
+    `You are ${name}, a teammate in a team chat (hilos) connected to the git repository ` +
+    `${repoFullName}. Read the conversation and judge what the LATEST message wants from you.\n\n` +
+    `If it is asking you to make a code or repository change — implement/fix/refactor/adjust ` +
+    `something, continue or finish work discussed above, or give a go-ahead to act ("yeah, do ` +
+    `it", "go for it", "just code it", "approved", "dale", in ANY language) — respond with the ` +
+    `token ${CODE_SIGNAL} on the FIRST line, then on the next lines a short, imperative spec of ` +
+    `exactly what to build or change, resolving any references ("this", "keep working on it") ` +
+    `using the conversation. Example:\n${CODE_SIGNAL}\nAdd a hover popover to message reactions ` +
+    `that lists who reacted with each emoji.\n\n` +
+    `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` +
+    `${memoryPreamble(workspaceMemory)}Conversation so far:\n${transcript}`;
+  const run = await runCli({
+    cmd: parts[0],
+    args: [...parts.slice(1), prompt],
+    timeoutMs: cfg.chatTimeoutMs || cfg.runTimeoutMs,
+    label: "thinking",
+    signal,
+  });
+  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() : "" };
   }
-  // Otherwise only a SHORT message counts — a long one carries its own intent.
-  if (t.length > 40) return false;
-  return /^(go|do it|do that|yes|yep|yeah|yup|sure|ship|proceed|sounds good|sgtm|please do|please)\b/.test(t);
-}
-
-/** Does the agent's most recent message read like a plan/proposal it offered? */
-export function agentProposedWork(rows, agentName) {
-  const mine = (rows || []).filter((m) => m && m.author === agentName);
-  const last = mine[mine.length - 1];
-  if (!last) return false;
-  return /\b(i'?ll|i will|plan|propose|pr\b|pull request|branch|here'?s|let me|on it|i'?d|i can)\b/i.test(
-    String(last.body || ""),
-  );
+  return { code: false, reply: out };
 }
 
 /**
- * The task text handed to the coding CLI. The mention is always the instruction,
- * but it's almost never self-contained: a reply like "yeah, do it" only means
- * something against what was just said, and even a direct request is clearer with
- * the surrounding discussion. So we ALWAYS prepend the recent conversation when we
- * have it — the same context the chat path already gets. Falls back to the bare
- * mention only when there's no transcript at all.
+ * The prompt handed to the CODING CLI. Framed as an engineering directive, NOT a
+ * chat: the old "you're in a team chat, do what the latest message asks" wording
+ * made the agent reply conversationally to stdout (e.g. to "how u doing? keep
+ * working on this") and edit nothing. So this is imperative — "you are a coding
+ * agent, edit files now" — led by the router's distilled `brief` (what to build),
+ * with the conversation included only as background. Falls back to the raw
+ * mention when there's no brief.
+ * @param {{ message?: { body?: string } | null, context?: { transcript?: string } | null, brief?: string, repoFullName?: string }} [o]
  */
-export function codeTaskPrompt({ message, context }) {
-  const body = String(message?.body || "").trim();
+export function codeTaskPrompt(o) {
+  const { message, context, brief, repoFullName } = o || {};
+  const task = (brief && brief.trim()) || String(message?.body || "").trim();
   const transcript = context?.transcript?.trim();
-  if (!transcript) return body;
-  return (
-    `You're acting on a request in a team chat. Recent conversation (oldest first):\n` +
-    `${transcript}\n\n` +
-    `The latest message is your instruction: "${body}". Do what it asks, using the ` +
-    `conversation above for context — it often carries the actual spec (e.g. a reply ` +
-    `like "go for it" refers to what was just discussed). Make the change directly; ` +
-    `it will be opened as a PR for review.`
-  );
+  const where = repoFullName ? ` in the git repository ${repoFullName}` : "";
+  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}`;
+  if (transcript) {
+    p += `\n\nBackground from the team's discussion (context only — the task above is what to do):\n${transcript}`;
+  }
+  return p;
 }
 
 /** owner/name from a GitHub remote URL (https or ssh), or null. */
@@ -415,27 +414,48 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
   const { memory: workspaceMemory = null } = await tool("get_workspace_memory", {}).catch(() => ({
     memory: null,
   }));
-  // The conversation the agent is replying within — fetched ONCE and handed to
-  // BOTH the chat reply and the coding prompt. Context is always crucial: a reply
-  // like "yeah, do it" only means something against what was just said, and even
-  // a direct request is clearer with the surrounding discussion. The chat path
-  // always had this; the code path used to run on the bare mention alone (so
-  // "go for it" reached the agent with no spec → nothing built). Now both share it.
+  // The conversation the agent is replying within — fetched ONCE and used to
+  // route AND (for a code run) handed to the coding prompt. Context is always
+  // crucial: a reply like "yeah, do it" only means something against what was
+  // just said.
   const context = await fetchContext({ channelId, tool, parentId });
-  // Chat vs code. A clear action verb → code. With a repo linked, a bare
-  // affirmation ("go", "ship it") that follows a plan the agent just proposed
-  // ALSO means "execute it" → code path. Otherwise (greeting/question/no repo) →
-  // a conversational reply.
-  let isCode = looksLikeCodeTask(message.body);
-  if (!isCode && repoLink && isAffirmation(message.body) && agentProposedWork(context.rows, me?.agentName)) {
-    isCode = true;
-  }
-  if (!repoLink || !isCode) {
+
+  // No repo linked → nothing to build; just reply.
+  if (!repoLink) {
     await respondConversationally({ message, channelId, tool, me, cfg, repoLink, parentId, workspaceMemory, signal, context, caps });
     return { status: "chat" };
   }
   const repoFullName = repoLink.repo_full_name;
 
+  // Chat vs code is the LLM's call, not a word list: it reads the whole
+  // conversation and either returns a chat reply or signals a code run. Handles
+  // any phrasing, any language, and "go for it" obviously means "do the thing we
+  // just discussed". When it replies (chat), post that and we're done.
+  const routed = await routeIntent({
+    name: me?.agentName || "an assistant",
+    repoFullName,
+    transcript: context.transcript,
+    workspaceMemory,
+    cfg,
+    signal,
+  });
+  if (routed.aborted || signal?.aborted) {
+    await tool("post_message", { channelId, parentId, body: "Stopped." });
+    return { status: "chat" };
+  }
+  if (!routed.code) {
+    let body = routed.reply;
+    if (!body) {
+      body =
+        routed.error?.code === "ENOENT"
+          ? `(my chat command \`${cfg.chatCmd || cfg.codingCmd}\` isn't installed or on PATH.)`
+          : `Still thinking on this — it's taking longer than usual. I'll follow up shortly.`;
+    }
+    await tool("post_message", { channelId, parentId, body });
+    return { status: "chat" };
+  }
+  // routed.code → fall through to the coding flow below.
+
   let repoPath = resolveRepoPath(cfg, repoFullName);
   if (!repoPath) {
     // Zero-config path: if the daemon is running INSIDE a checkout of this repo
@@ -656,7 +676,7 @@ export async function handleTask({ message, channelId, tool, me, caps = {} }, cf
     return { status: "cancelled", branch };
   };
 
-  const staged = await runAndStage(codeTaskPrompt({ message, context }));
+  const staged = await runAndStage(codeTaskPrompt({ message, context, brief: routed.task, repoFullName }));
   if (staged.aborted) return await postStopped();
   if (staged.empty) {
     let body;