tryharness 0.7.22 → 0.7.25

package/lib/folders.mjs

@@ -2,31 +2,40 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
-import { mainCheckout } from "./worktrees.mjs";
 import { nameOf } from "./members.mjs";
 import { paths } from "./paths.mjs";
 import { t3Projects } from "./places.mjs";
 
 // Where the person's threads work. The folder is the person's to choose, any folder on the computer: the composer offers
-// the folders they work in (T3 Code's projects, the folders their agents' sessions and threads ran in) and browses from
-// their home folder. With none chosen, Harness picks one from the message among those folders (src/server/swarm/folder.ts),
-// else the folder the agent last worked in. The home folder itself and hidden folders are never offered or picked, nor
-// Harness's and T3's own copies (their repository's checkout stands for them): work there is never what was meant (the
-// owner's October 13 thread ran Codex over their whole home folder).
+// the folders they work in (T3 Code's projects, the folders their agents' sessions and threads ran in, each as its
+// repository) and browses from their home folder. With none chosen, Harness picks one from the message among those folders
+// (src/server/swarm/folder.ts), else the folder the agent last worked in. The home folder itself and hidden folders are never
+// offered or picked, nor Harness's and T3's own copies or a repository's subfolders (the repository stands for them): work
+// there is never what was meant (the owner's October 13 thread ran Codex over their whole home folder; on October 14 a
+// buddy message was picked into ~/harness/src).
 
 const CODING = new Set(["claude-code", "codex", "pi", "opencode"]);
 // Folders offered and sent to Jev: the most recently worked in. Browsing reaches any other.
 const OFFERED = 60;
 const LISTED = 200;
-const README_MAX = 100_000;
-const TOP_LEVEL_MAX = 2_000;
 const PICK_TTL_MS = 10 * 60_000;
-const README = /^readme(\.(md|markdown|txt|rst))?$/i;
 
-const realDir = (dir) => { try { return fs.realpathSync(dir); } catch { return null; } };
-export const isDir = (dir) => typeof dir === "string" && path.isAbsolute(dir) && fs.statSync(dir, { throwIfNoEntry: false })?.isDirectory() === true;
+const realDir = (dir) => {
+  try {
+    return fs.realpathSync(dir);
+  } catch {
+    return null;
+  }
+};
+export const isDir = (dir) =>
+  typeof dir === "string" &&
+  path.isAbsolute(dir) &&
+  fs.statSync(dir, { throwIfNoEntry: false })?.isDirectory() === true;
 
-const within = (dir, root) => { const rel = root ? path.relative(root, dir) : ".."; return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel)); };
+const within = (dir, root) => {
+  const rel = root ? path.relative(root, dir) : "..";
+  return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+};
 
 /** A folder Harness may offer or pick by itself: not the home folder or above it, not hidden, not Harness's own, not gone. */
 function offerable(dir) {
@@ -35,47 +44,113 @@ function offerable(dir) {
   const home = realDir(os.homedir()) ?? os.homedir();
   const rel = path.relative(home, real);
   if (rel === "" || path.parse(real).root === real) return false;
-  if (!rel.startsWith("..") && !path.isAbsolute(rel)) return !rel.split(path.sep).some((part) => part.startsWith("."));
+  if (!rel.startsWith("..") && !path.isAbsolute(rel))
+    return !rel.split(path.sep).some((part) => part.startsWith("."));
   return !real.split(path.sep).some((part) => part.startsWith("."));
 }
 
-const git = (cwd, args) => { const found = spawnSync("git", args, { cwd, encoding: "utf8", timeout: 2_000 }); return found.status === 0 ? (found.stdout || "").trim() : ""; };
+const git = (cwd, args) => {
+  const found = spawnSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    timeout: 2_000,
+  });
+  return found.status === 0 ? (found.stdout || "").trim() : "";
+};
 
-/** What Jev reads of a folder: its name, repository, top level and README, whole. */
+// The repository a folder is in, as its main checkout (for a worktree's or a subfolder's sessions), else the folder itself.
+const ROOT_TTL_MS = 10 * 60_000;
+const roots = new Map();
+function repositoryOf(dir) {
+  const cached = roots.get(dir);
+  if (cached && cached.at > Date.now() - ROOT_TTL_MS) return cached.root;
+  const [top, common] = git(dir, [
+    "rev-parse",
+    "--path-format=absolute",
+    "--show-toplevel",
+    "--git-common-dir",
+  ]).split("\n");
+  const root =
+    (top && common
+      ? realDir(path.basename(common) === ".git" ? path.dirname(common) : top)
+      : null) ?? dir;
+  roots.set(dir, { root, at: Date.now() });
+  return root;
+}
+
+/**
+ * What Jev reads of a folder: its name, its repository, who worked there and when, and the titles of the sessions there
+ * (each the start of its first message), newest first. What was worked on in a folder says where new work goes; READMEs
+ * mostly say how to install a project, and together they passed Jev's limit (October 14).
+ */
 function facts(place) {
-  let entries = [];
-  try { entries = fs.readdirSync(place.path, { withFileTypes: true }).filter((entry) => ![".git", ".DS_Store"].includes(entry.name)); } catch {}
-  const readme = entries.find((entry) => entry.isFile() && README.test(entry.name));
-  let text = null;
-  try { text = readme ? fs.readFileSync(path.join(place.path, readme.name), "utf8") : null; } catch {}
   // A remote's address without any credentials in it.
-  const remote = git(place.path, ["remote", "get-url", "origin"]).replace(/\/\/[^@/]+@/, "//");
+  const remote = git(place.path, ["remote", "get-url", "origin"]).replace(
+    /\/\/[^@/]+@/,
+    "//"
+  );
   return {
-    path: place.path, name: place.name, repository: remote || null,
-    topLevel: entries.map((entry) => `${entry.name}${entry.isDirectory() ? "/" : ""}`).sort().slice(0, TOP_LEVEL_MAX),
-    readme: text && text.length <= README_MAX ? text : null,
-    agents: place.agents.map(nameOf), lastWorked: place.lastWorked,
+    path: place.path,
+    name: place.name,
+    repository: remote || null,
+    agents: place.agents.map(nameOf),
+    lastWorked: place.lastWorked,
+    titles: place.titles,
   };
 }
 
-export function createFolders({ store, askHarness, canAsk, privacy, log = () => {} }) {
-  /** The folders the person works in, most recently worked in first: { path, name, t3, agents, lastWorked }. */
+export function createFolders({
+  store,
+  askHarness,
+  canAsk,
+  privacy,
+  log = () => {},
+  lastChanged = () => null,
+  rank = async (_message, places) => places,
+}) {
+  /** The folders the person works in, most recently worked in first: { path, name, t3, agents, lastWorked, titles }. */
   const known = () => {
     const byPath = new Map();
-    const add = (dir, agent, at) => {
-      const where = realDir(dir) && realDir(mainCheckout(realDir(dir)));
+    const add = (dir, agent, at, title) => {
+      const real = realDir(dir);
+      const where = real && repositoryOf(real);
       if (!where || !offerable(where)) return;
-      const place = byPath.get(where) ?? { path: where, name: path.basename(where), t3: false, agents: [], lastWorked: null };
-      if (agent && CODING.has(agent) && !place.agents.includes(agent)) place.agents.push(agent);
-      if (at && (!place.lastWorked || at > place.lastWorked)) place.lastWorked = at;
+      const place = byPath.get(where) ?? {
+        path: where,
+        name: path.basename(where),
+        t3: false,
+        agents: [],
+        lastWorked: null,
+        titles: [],
+      };
+      if (agent && CODING.has(agent) && !place.agents.includes(agent))
+        place.agents.push(agent);
+      if (at && (!place.lastWorked || at > place.lastWorked))
+        place.lastWorked = at;
+      if (title && !place.titles.includes(title)) place.titles.push(title);
       byPath.set(where, place);
     };
-    for (const row of store.sessionFolders(300)) add(row.cwd, row.agent, row.at);
-    for (const thread of store.goals({ all: true })) if (thread.goal?.workspace) for (const agent of thread.goal.team) add(thread.goal.workspace, agent, thread.updated_at || thread.created_at);
+    for (const row of store.sessionPlaces())
+      add(row.cwd, row.agent, row.at, row.title);
+    for (const thread of store.goals({ all: true }))
+      if (thread.goal?.workspace)
+        for (const agent of thread.goal.team)
+          add(
+            thread.goal.workspace,
+            agent,
+            thread.updated_at || thread.created_at
+          );
     const projects = t3Projects();
     for (const dir of projects) add(dir, null, null);
-    for (const place of byPath.values()) place.t3 = projects.includes(place.path);
-    return [...byPath.values()].sort((a, b) => (b.lastWorked ?? "").localeCompare(a.lastWorked ?? "") || a.name.localeCompare(b.name)).slice(0, OFFERED);
+    for (const place of byPath.values())
+      place.t3 = projects.includes(place.path);
+    return [...byPath.values()]
+      .sort(
+        (a, b) =>
+          (b.lastWorked ?? "").localeCompare(a.lastWorked ?? "") ||
+          a.name.localeCompare(b.name)
+      )
+      .slice(0, OFFERED);
   };
 
   /**
@@ -84,20 +159,48 @@ export function createFolders({ store, askHarness, canAsk, privacy, log = () =>
    */
   const browse = (typed) => {
     const raw = String(typed ?? "").trim() || "~";
-    const expanded = raw === "~" ? os.homedir() : raw.startsWith("~/") ? path.join(os.homedir(), raw.slice(2)) : raw;
-    if (!path.isAbsolute(expanded)) return { ok: false, error: "type a full path, or start with ~" };
+    const expanded =
+      raw === "~"
+        ? os.homedir()
+        : raw.startsWith("~/")
+          ? path.join(os.homedir(), raw.slice(2))
+          : raw;
+    if (!path.isAbsolute(expanded))
+      return { ok: false, error: "type a full path, or start with ~" };
     // "~" or a path ending in "/" lists that folder; anything else lists the folders beside it that start with its name.
     const inside = raw === "~" || raw.endsWith("/");
     const dir = path.resolve(inside ? expanded : path.dirname(expanded));
     const start = inside ? "" : path.basename(expanded).toLowerCase();
-    if (!isDir(dir)) return { ok: false, error: `${dir} is not a folder on this computer` };
+    if (!isDir(dir))
+      return { ok: false, error: `${dir} is not a folder on this computer` };
     let entries = [];
-    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch (error) { return { ok: false, error: `${dir} can't be read: ${error.code || error.message}` }; }
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch (error) {
+      return {
+        ok: false,
+        error: `${dir} can't be read: ${error.code || error.message}`,
+      };
+    }
     const folders = entries
-      .filter((entry) => (entry.isDirectory() || (entry.isSymbolicLink() && isDir(path.join(dir, entry.name)))) && entry.name.toLowerCase().startsWith(start) && (start.startsWith(".") || !entry.name.startsWith(".")))
+      .filter(
+        (entry) =>
+          (entry.isDirectory() ||
+            (entry.isSymbolicLink() && isDir(path.join(dir, entry.name)))) &&
+          entry.name.toLowerCase().startsWith(start) &&
+          (start.startsWith(".") || !entry.name.startsWith("."))
+      )
       .map((entry) => ({ path: path.join(dir, entry.name), name: entry.name }))
-      .sort((a, b) => a.name.localeCompare(b.name, undefined, { sensitivity: "base" })).slice(0, LISTED);
-    return { ok: true, dir, parent: path.dirname(dir) === dir ? null : path.dirname(dir), folders };
+      .sort((a, b) =>
+        a.name.localeCompare(b.name, undefined, { sensitivity: "base" })
+      )
+      .slice(0, LISTED);
+    return {
+      ok: true,
+      dir,
+      parent: path.dirname(dir) === dir ? null : path.dirname(dir),
+      folders,
+    };
   };
 
   // A pick is asked once per message: the composer shows it, and the thread it starts uses it.
@@ -106,33 +209,96 @@ export function createFolders({ store, askHarness, canAsk, privacy, log = () =>
     const key = JSON.stringify([message, places.map((place) => place.path)]);
     const cached = picks.get(key);
     if (cached && cached.at > Date.now() - PICK_TTL_MS) return cached.pending;
-    const pending = askHarness("pick_folder", { message, folders: places.map(facts) }, null).then((reply) => {
-      if (!reply?.ok) throw new Error(reply?.error || "Harness did not pick a folder");
-      return places.some((place) => place.path === reply.folder) ? reply.folder : null;
-    });
+    // How recently each folder's files changed, where Harness takes it (a daemon newer than the server would be refused).
+    const changed = lastChanged();
+    const ask = (offered) =>
+      askHarness(
+        "pick_folder",
+        {
+          message,
+          folders: offered.map((place) =>
+            changed
+              ? { ...facts(place), lastChanged: changed(place.path) }
+              : facts(place)
+          ),
+        },
+        null
+      );
+    const pending = (async () => {
+      let reply = await ask(places);
+      // Over Jev's limit: asked again about the most recently worked in half, halving until it fits. On the owner's
+      // sessions that half held the folder 99.5% of the time; the search model's closest half, 95.6% (eval folder-shortlist).
+      if (reply?.ok && reply.tooLarge) {
+        const ranked = await rank(message, places);
+        for (
+          let n = Math.ceil(places.length / 2);
+          reply?.ok && reply.tooLarge && n >= 2;
+          n = Math.floor(n / 2)
+        ) {
+          log(
+            `folder pick: ${places.length} folders are over Jev's limit; asking about the closest ${n}`
+          );
+          reply = await ask(ranked.slice(0, n));
+        }
+      }
+      if (!reply?.ok)
+        throw new Error(reply?.error || "Harness did not pick a folder");
+      const folder = places.some((place) => place.path === reply.folder)
+        ? reply.folder
+        : null;
+      // Jev's answers, so a wrong pick can be explained (not the message).
+      log(
+        `folder pick: ${folder ?? "none"}${reply.tooLarge ? " (over Jev's limit)" : ""} ${JSON.stringify(reply.judgments ?? null)}`
+      );
+      return folder;
+    })();
     picks.set(key, { at: Date.now(), pending });
-    for (const [old, entry] of picks) if (entry.at <= Date.now() - PICK_TTL_MS || picks.size > 50) picks.delete(old);
+    for (const [old, entry] of picks)
+      if (entry.at <= Date.now() - PICK_TTL_MS || picks.size > 50)
+        picks.delete(old);
     pending.catch(() => picks.delete(key));
     return pending;
   };
 
   /**
-   * The folder for a thread the person starts without choosing one: { folder, by }, by "message" (Jev's pick from what
-   * they wrote), "last" (where one of its agents last worked) or null when there is none to suggest.
+   * The folder for a thread the person starts without choosing one: { folder, by, lastWorked }, by "message" (Jev's pick
+   * from what they wrote), "last" (where one of its agents last worked) or null when there is none to suggest; lastWorked
+   * is that last folder when Jev picked another, for the person to take instead.
    */
   const suggest = async (text, agents) => {
     const places = known();
-    const message = String(text).replace(/@([a-z][a-z0-9-]*)(:\S+)?\s*/g, "").trim();
+    const coding = agents.filter((agent) => CODING.has(agent));
+    const last =
+      places
+        .filter((place) => place.lastWorked)
+        .find(
+          (place) =>
+            !coding.length ||
+            place.agents.some((agent) => coding.includes(agent))
+        )?.path ?? null;
+    const message = String(text)
+      .replace(/@([a-z][a-z0-9-]*)(:\S+)?\s*/g, "")
+      .trim();
     if (message && places.length && canAsk() && !privacy()) {
       try {
         const folder = await pickFromMessage(message, places);
-        if (folder) return { folder, by: "message" };
-      } catch (error) { log(`folder pick: ${error.message}`); }
+        if (folder)
+          return {
+            folder,
+            by: "message",
+            lastWorked: folder === last ? null : last,
+          };
+      } catch (error) {
+        log(`folder pick: ${error.message}`);
+      }
     }
-    const coding = agents.filter((agent) => CODING.has(agent));
-    const last = places.filter((place) => place.lastWorked).find((place) => !coding.length || place.agents.some((agent) => coding.includes(agent)));
-    return last ? { folder: last.path, by: "last" } : { folder: null, by: null };
+    return { folder: last, by: last ? "last" : null, lastWorked: null };
   };
 
-  return { known, browse, suggest };
+  // Offered to the composer without the session titles, which only Jev reads.
+  return {
+    known: () => known().map(({ titles, ...place }) => place),
+    browse,
+    suggest,
+  };
 }