hilos-agent 0.1.9 → 0.1.10

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.10",
   "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,65 +165,51 @@ 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 (for chat) produce that reply 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.
+ *
+ * Returns one of:
+ *   { aborted: true }
+ *   { code: true }                 → run the coding flow
+ *   { 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;
-  }
-  // 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 || ""),
-  );
+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 ` +
+    `EXACTLY this and nothing else:\n${CODE_SIGNAL}\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)) return { code: true };
+  return { code: false, reply: out };
 }
 
 /**
@@ -415,27 +401,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