hilos-agent 0.1.15 → 0.4.0

package/src/daemon.mjs

@@ -31,6 +31,55 @@ export function resolveRepoPath(config, repoFullName) {
   return (config && config.repos && config.repos[repoFullName]) || null;
 }
 
+/** Local folder path for a channel from config (folder mode, 0322), or null.
+ *  Mirrors resolveRepoPath — a channel with no linked repo can still map to a
+ *  plain folder on this machine where the agent works directly. */
+export function resolveFolderPath(config, channelId) {
+  return (config && config.folders && config.folders[channelId]) || null;
+}
+
+/** Parse `git status --porcelain` (v1) into a Map(path → "XY" status code).
+ *  Handles renames ("old -> new" → keeps the new name) and quoted paths. */
+function parsePorcelain(text) {
+  const map = new Map();
+  for (const raw of String(text || "").split("\n")) {
+    if (!raw.trim()) continue;
+    const code = raw.slice(0, 2); // two status columns
+    let path = raw.slice(3); // skip the single separating space
+    const arrow = path.indexOf(" -> ");
+    if (arrow >= 0) path = path.slice(arrow + 4); // a rename reports old -> new
+    path = path.replace(/^"(.*)"$/, "$1"); // unquote paths with special chars
+    if (path) map.set(path, code);
+  }
+  return map;
+}
+
+/**
+ * What changed between two `git status --porcelain` snapshots taken before and
+ * after a run: files the run created (new/untracked/added), modified, or deleted.
+ * Pure + unit-testable. A path whose status is identical in both snapshots is a
+ * PRE-EXISTING local change (dirty before the run) and is excluded. Returns
+ * `{ modified, created, deleted }`, each a sorted string[].
+ */
+export function diffStatusSets(before, after) {
+  const b = parsePorcelain(before);
+  const a = parsePorcelain(after);
+  const created = [];
+  const modified = [];
+  const deleted = [];
+  for (const [path, code] of a) {
+    if (b.get(path) === code) continue; // unchanged since before the run
+    const c = code.trim();
+    if (code.includes("?") || c === "A" || c === "AM") created.push(path);
+    else if (c.startsWith("D")) deleted.push(path);
+    else modified.push(path);
+  }
+  created.sort();
+  modified.sort();
+  deleted.sort();
+  return { modified, created, deleted };
+}
+
 /** Parse `git diff --shortstat` output into counts. */
 export function parseShortstat(s) {
   const files = /(\d+) files? changed/.exec(s || "");
@@ -89,3 +138,21 @@ export function mentionHandle(name) {
     .replace(/[^a-z0-9]+/g, "-")
     .replace(/^-+|-+$/g, "");
 }
+
+/**
+ * A GitHub PR reference embedded in `text` for `repoFullName`, or null. The
+ * server tags a "request changes" rework ping with the existing PR's URL
+ * ("…update the PR <url>…"), so the daemon can update THAT PR's branch
+ * (same-branch iteration) instead of opening a brand-new one.
+ *
+ * Anchored on a "PR <url>" lead-in (and scoped to the channel's repo) so only an
+ * explicit "update the PR <url>" — the server ping, or a person naming a PR —
+ * triggers continuation. A stray reference link to some other PR (same or other
+ * repo, quoted for context) must NOT hijack the branch.
+ */
+export function detectPrContinuation(text, repoFullName) {
+  const m = /\bPR\s+(https?:\/\/github\.com\/([^/\s]+\/[^/\s]+)\/pull\/(\d+))/i.exec(String(text || ""));
+  if (!m) return null;
+  if (repoFullName && m[2].toLowerCase() !== String(repoFullName).toLowerCase()) return null;
+  return { url: m[1], repoFullName: m[2], number: Number(m[3]) };
+}

package/src/followup.mjs

@@ -0,0 +1,161 @@
+// Same-PR follow-up resolver (0281) — the decision core for "a human replied in a
+// thread asking for a change; do we continue the PR this thread already owns, or
+// fork a new one?" Pure + dependency-free (it needs no imports at all) so it
+// unit-tests without any I/O and is shared by the daemon (handler.mjs) and the
+// hosted path (lib/, via TS import).
+//
+// The PRIMARY classifier is the LLM (the daemon's routeIntent reads intent in any
+// language, in context); the cue lists below are ONLY a hint for that prompt and a
+// deterministic FALLBACK when the model is unavailable. Never let the cue lists be
+// the main brain — they're the safety net.
+
+/**
+ * The three reads of a follow-up message, relative to the run its thread owns:
+ *   'change'    — continue/adjust that work ("also make it blue", "actually revert")
+ *   'new-scope' — explicitly wants a SEPARATE PR ("do that in a new PR")
+ *   'ambiguous' — unclear; a plain follow-up with no explicit fresh-PR cue
+ * @typedef {'change' | 'new-scope' | 'ambiguous'} FollowupSignal
+ */
+
+/**
+ * The routing decision:
+ *   'iterate'  — continue the SAME branch/PR the thread already owns
+ *   'redirect' — supersede the old run and start a fresh, separate PR
+ *   'new'      — today's default: a brand-new branch + run (no run to continue)
+ * @typedef {'iterate' | 'new' | 'redirect'} FollowupMode
+ */
+
+/**
+ * Illustrative "continue this work" cues, multi-language friendly. NOT exhaustive
+ * and NOT the primary classifier — a hint for the LLM prompt and the deterministic
+ * fallback. Matched as substrings against a normalized (lowercased,
+ * punctuation-collapsed) message.
+ */
+export const CHANGE_CUES = [
+  // English
+  "also",
+  "actually",
+  "instead",
+  "revert",
+  "undo",
+  "roll back",
+  "change it",
+  "make it",
+  "tweak",
+  "adjust",
+  "one more",
+  "on second thought",
+  "same pr",
+  "keep going",
+  // Spanish
+  "también",
+  "en vez",
+  "revierte",
+  "deshaz",
+  "cámbialo",
+  "ajusta",
+  // Portuguese / French / German (small illustrative set)
+  "ao invés",
+  "au lieu",
+  "annule",
+  "stattdessen",
+];
+
+/**
+ * Illustrative "make it a SEPARATE PR" cues — an explicit request to fork rather
+ * than continue. Same role: LLM hint + deterministic fallback.
+ */
+export const NEW_SCOPE_CUES = [
+  // English
+  "separate pr",
+  "separate branch",
+  "new pr",
+  "another pr",
+  "different pr",
+  "fresh pr",
+  "its own pr",
+  "own pr",
+  "new branch",
+  "as a new",
+  "in a new",
+  // Spanish
+  "pr aparte",
+  "pr separado",
+  "otro pr",
+  "nuevo pr",
+  "rama aparte",
+  // Portuguese / French
+  "nova pr",
+  "pr séparée",
+];
+
+/** Lowercase + collapse any run of non-alphanumeric (unicode letters kept) to a
+ *  single space, so matching is case- AND punctuation-insensitive. */
+function normalize(text) {
+  return String(text || "")
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}]+/gu, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+/** True when the normalized haystack contains the normalized cue, so "new  PR!"
+ *  matches "new pr". */
+function hasCue(normalizedHaystack, cue) {
+  const c = normalize(cue);
+  if (!c) return false;
+  return normalizedHaystack === c || normalizedHaystack.includes(c);
+}
+
+/**
+ * Deterministic cue-based classifier — the FALLBACK when the LLM produced no
+ * signal. Explicit new-scope cues win over change cues (an explicit "in a new PR"
+ * is a stronger intent than a stray "also"); nothing matched → 'ambiguous'.
+ * @param {string} text
+ * @returns {FollowupSignal}
+ */
+export function classifyFollowupCue(text) {
+  const h = normalize(text);
+  if (!h) return "ambiguous";
+  if (NEW_SCOPE_CUES.some((c) => hasCue(h, c))) return "new-scope";
+  if (CHANGE_CUES.some((c) => hasCue(h, c))) return "change";
+  return "ambiguous";
+}
+
+/** Coerce an arbitrary model/string signal into the enum; unknown → 'ambiguous'. */
+export function normalizeSignal(raw) {
+  const s = normalize(raw);
+  if (s === "new scope" || s === "newscope" || s === "new" || s === "separate") return "new-scope";
+  if (s === "change" || s === "iterate" || s === "continue") return "change";
+  if (s === "ambiguous" || s === "unsure" || s === "unknown") return "ambiguous";
+  return "ambiguous";
+}
+
+/**
+ * The truth table. Deliberately small + exhaustive over
+ * (hasActiveRun × prOpen × signal):
+ *
+ *   hasActiveRun | prOpen | signal      -> mode
+ *   -------------|--------|-------------|----------
+ *   false        |   *    |    *        -> 'new'       (today's behavior — nothing to continue)
+ *   true         | true   | 'change'    -> 'iterate'   (continue the same PR)
+ *   true         | true   | 'ambiguous' -> 'iterate'   (default a plain reply to the open PR it belongs to)
+ *   true         | true   | 'new-scope' -> 'redirect'  (explicit "separate PR" — supersede + fork)
+ *   true         | false  |    *        -> 'new'        (PR merged/closed — NEVER iterate onto it)
+ *
+ * Safety: iterate REQUIRES an open PR, so a false 'iterate' can't push a genuinely
+ * new task onto a merged/closed PR; an explicit new-scope always forks even when a
+ * PR is open.
+ *
+ * @param {{ hasActiveRun: boolean, prOpen: boolean, signal: FollowupSignal }} o
+ * @returns {FollowupMode}
+ */
+export function resolveFollowupMode({ hasActiveRun, prOpen, signal } = {}) {
+  if (!hasActiveRun) return "new";
+  // Recency guard: only ever continue an OPEN PR. A run whose PR is merged/closed
+  // (or that never opened one) starts fresh — a follow-up there is new work.
+  if (!prOpen) return "new";
+  if (signal === "new-scope") return "redirect";
+  // 'change' or 'ambiguous' on an open PR → continue it.
+  return "iterate";
+}