hilos-agent 0.1.0 → 0.1.3

package/README.md

@@ -22,14 +22,16 @@ hilos channel  ──MCP/HTTPS──▶  hilos-agent (your laptop)
 ## Quick start
 
 In hilos: open your agent's profile → **Connect** → copy the
-`hilos-agent --join …` command. Then on your machine:
+`hilos-agent --join …` command. Then on your machine, **run it from inside your
+repo's folder** — the daemon matches the repo by its git remote, so no config is
+needed:
 
 ```sh
-npx hilos-agent --join <blob>        # connect (token + endpoint come from the link)
-hilos-agent init                     # or: write a starter config to edit
+cd ~/code/your-repo
+npx hilos-agent --join <blob>        # token + endpoint from the link; repo auto-detected from cwd
 ```
 
-Map each repo the agent may touch to a local checkout, then run it:
+Running from elsewhere, or want to map several repos explicitly? Use a config:
 
 ```jsonc
 // ~/.hilos/agent.json  (or ./hilos-agent.json)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hilos-agent",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Run your own coding agent (Claude Code / Codex / Cursor) as an autonomous teammate in a hilos channel. Picks up @mentions, proposes a diff, and pushes only after a human approves — your code and credentials never leave your machine.",
   "type": "module",
   "bin": {
@@ -14,6 +14,15 @@
   "engines": {
     "node": ">=18"
   },
+  "homepage": "https://hilos.sh",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pablostanley/hilos.git",
+    "directory": "packages/hilos-agent"
+  },
+  "bugs": {
+    "url": "https://github.com/pablostanley/hilos/issues"
+  },
   "keywords": [
     "hilos",
     "mcp",

package/src/handler.mjs

@@ -3,6 +3,7 @@
 // hilos. Nothing is pushed until approved. Your code + credentials stay local.
 
 import { spawnSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
 import {
   branchSlug,
   truncateDiff,
@@ -55,7 +56,22 @@ async function awaitDecision({ tool, channelId, reportMessageId, cfg, deps }) {
 
 async function applyDecision({ decision, repoPath, branch, task, cfg, tool, channelId, deps }) {
   if (decision.kind === "approved") {
-    deps.git(repoPath, ["commit", "-m", commitMessage(task)]);
+    // Guard: nothing staged → don't push an empty branch and falsely report "shipped".
+    if (deps.git(repoPath, ["diff", "--cached", "--quiet"]).status === 0) {
+      await tool("post_message", {
+        channelId,
+        body: `Approved, but there are no staged changes to commit on \`${branch}\`.`,
+      });
+      return { status: "nothing-staged", branch };
+    }
+    const commit = deps.git(repoPath, ["commit", "-m", commitMessage(task)]);
+    if (commit.status !== 0) {
+      await tool("post_message", {
+        channelId,
+        body: `Approved, but the commit failed: ${(commit.stderr || "").trim().slice(0, 300)}`,
+      });
+      return { status: "commit-failed", branch };
+    }
     const push = deps.git(repoPath, ["push", "-u", "origin", branch]);
     if (push.status !== 0) {
       await tool("post_message", {
@@ -103,27 +119,100 @@ async function applyDecision({ decision, repoPath, branch, task, cfg, tool, chan
   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)\b/;
+  return verb.test(t);
+}
+
+/** owner/name from a GitHub remote URL (https or ssh), or null. */
+export function normalizeRemote(url) {
+  const m = String(url || "")
+    .trim()
+    .match(/github\.com[:/]+([^/\s]+\/[^/\s]+?)(?:\.git)?$/i);
+  return m ? m[1] : null;
+}
+
+/** Run the configured CLI to produce a chat reply, using recent channel context. */
+async function respondConversationally({ message, channelId, tool, me, cfg }) {
+  void message;
+  const { messages = [] } = await tool("read_channel", { channelId, limit: 20 }).catch(() => ({
+    messages: [],
+  }));
+  const transcript = messages
+    .map((m) => `${m.author}: ${m.body}`)
+    .join("\n")
+    .slice(-6000);
+  const name = me?.agentName || "an assistant";
+  const prompt =
+    `You are ${name}, a teammate in a team chat (hilos). Reply to the latest message ` +
+    `concisely and directly as a single chat message — no preamble, no headings. ` +
+    `If asked to change code, note that a repo isn't linked to this channel yet.\n\n` +
+    `Conversation so far:\n${transcript}`;
+
+  const parts = cfg.codingCmd.split(" ").filter(Boolean);
+  const run = spawnSync(parts[0], [...parts.slice(1), prompt], {
+    encoding: "utf8",
+    timeout: cfg.runTimeoutMs,
+    maxBuffer: 50 * 1024 * 1024,
+  });
+  const reply = (run.stdout || "").trim();
+  await tool("post_message", {
+    channelId,
+    body: reply || `(my CLI returned nothing — is \`${cfg.codingCmd}\` installed and on PATH?)`,
+  });
+}
+
 /** Handle one task. cfg/deps injectable for tests. */
-export async function handleTask({ message, channelId, tool }, cfg, depsOverride) {
+export async function handleTask({ message, channelId, tool, me }, cfg, depsOverride) {
   const deps = depsOverride || defaultDeps();
   const git = deps.git;
 
   const { links = [] } = await tool("get_links", { channelId }).catch(() => ({ links: [] }));
   const repoLink = links.find((l) => l.repo_full_name);
-  if (!repoLink) {
-    await tool("post_message", {
-      channelId,
-      body: "No repo is linked to this channel — link one so I can work on it.",
-    });
-    return { status: "no-repo" };
+  // Chat (no repo linked, OR a greeting/question even in a repo channel) →
+  // reply via the CLI. Only an actual code request runs the branch/diff/PR flow.
+  if (!repoLink || !looksLikeCodeTask(message.body)) {
+    await respondConversationally({ message, channelId, tool, me, cfg });
+    return { status: "chat" };
   }
   const repoFullName = repoLink.repo_full_name;
 
-  const repoPath = resolveRepoPath(cfg, repoFullName);
+  let repoPath = resolveRepoPath(cfg, repoFullName);
+  if (!repoPath) {
+    // Zero-config path: if the daemon is running INSIDE a checkout of this repo
+    // (its origin matches), just use the current directory — no repos map needed.
+    const cwd = process.cwd();
+    const origin = git(cwd, ["remote", "get-url", "origin"]);
+    if (origin.status === 0 && normalizeRemote(origin.stdout) === repoFullName) {
+      repoPath = cwd;
+    }
+  }
   if (!repoPath) {
     await tool("post_message", {
       channelId,
-      body: `No local path is configured for ${repoFullName}. Add it to your hilos-agent.json under "repos".`,
+      body:
+        `I don't have a local checkout of ${repoFullName}. Either run me from inside that ` +
+        `repo, or add it to your hilos-agent.json: "repos": { "${repoFullName}": "/abs/path" }.`,
     });
     return { status: "no-path" };
   }
@@ -141,7 +230,7 @@ export async function handleTask({ message, channelId, tool }, cfg, depsOverride
     return { status: "dirty" };
   }
 
-  const branch = branchSlug(message.body, String(deps.now()).slice(-6));
+  const branch = branchSlug(message.body, randomBytes(3).toString("hex"));
   git(repoPath, ["fetch", "origin", cfg.defaultBranch]);
   const co = git(repoPath, ["switch", "-c", branch]);
   if (co.status !== 0) {

package/src/mcp.mjs

@@ -10,6 +10,13 @@ export function makeClient({ url, token }) {
       headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
       body: JSON.stringify({ jsonrpc: "2.0", id: ++id, method, params }),
     });
+    if (!res.ok) {
+      const hint =
+        res.status === 401 || res.status === 403
+          ? "token rejected — generate a fresh one in hilos (Connect)"
+          : await res.text().catch(() => "");
+      throw new Error(`hilos ${res.status}: ${hint.slice(0, 200)}`);
+    }
     const json = await res.json();
     if (json.error) throw new Error(json.error.message || "rpc error");
     return json.result;

package/src/run.mjs

@@ -16,6 +16,10 @@ export async function run(cfg, { handler = handleTask, log = console } = {}) {
 
   const who = await tool("whoami");
   const me = { ...who, handle: mentionHandle(who.agentName) };
+  if (!me.handle) {
+    log.error("This agent has no display name / handle — set one in hilos, then reconnect.");
+    process.exit(1);
+  }
   log.log(`hilos-agent: ${me.agentName} (@${me.handle}) — ${cfg.url}`);
   if (cfg.channelId) log.log(`scope: channel ${cfg.channelId}`);
   log.log(`repos: ${Object.keys(cfg.repos).join(", ") || "(none configured)"}`);
@@ -41,7 +45,11 @@ export async function run(cfg, { handler = handleTask, log = console } = {}) {
       if (seen.has(m.id)) continue;
       seen.add(m.id);
       await safeHandle(m, m.channelId);
-      if (!cursor.value || m.created_at > cursor.value) cursor.value = m.created_at;
+      // Compare numerically — created_at formats differ (Z vs +00:00 offset),
+      // so a lexicographic string compare can fail to advance the cursor.
+      if (!cursor.value || new Date(m.created_at).getTime() > new Date(cursor.value).getTime()) {
+        cursor.value = m.created_at;
+      }
     }
   }
 
@@ -61,7 +69,7 @@ export async function run(cfg, { handler = handleTask, log = console } = {}) {
   async function safeHandle(message, channelId) {
     try {
       log.log(`→ task in ${channelId}: "${(message.body || "").slice(0, 80)}"`);
-      await handler({ message, channelId, tool }, cfg);
+      await handler({ message, channelId, tool, me }, cfg);
     } catch (e) {
       log.error(`handler error: ${e.message}`);
       await tool("post_message", {