@saadnvd1/agent-os 0.3.700 → 0.3.723

package/lib/claims/collectLocal.ts

@@ -0,0 +1,123 @@
+// Turns this machine's live sessions into claims: the repo, branch and the
+// paths their diff touches so far. Only paths leave git, never content.
+
+import { getDb } from "../db";
+import { getCurrentBranch, getDefaultBranch } from "../git";
+import { git } from "../git-exec";
+import { repoKey } from "../git-remote";
+import { IN_FLIGHT } from "../tasks/queue-rows";
+import { expandHome } from "../tasks/session";
+import { MAX_FILES } from "./types";
+import {
+  localLiveSessionIds,
+  release,
+  upsertLocal,
+  type LocalClaim,
+} from "./store";
+
+interface SessionRow {
+  id: string;
+  name: string;
+  working_directory: string;
+  worktree_path: string | null;
+  branch_name: string | null;
+  base_branch: string | null;
+  pr_url: string | null;
+  pr_status: string | null;
+  task_status: string | null;
+}
+
+const OPTS = { timeout: 5000 };
+
+const paths = (out: string) => out.split("\0").filter(Boolean);
+
+export async function changedFiles(
+  dir: string,
+  base: string
+): Promise<string[]> {
+  const mergeBase = (
+    await git(dir, ["merge-base", "HEAD", `origin/${base}`], OPTS).catch(() =>
+      git(dir, ["merge-base", "HEAD", base], OPTS).catch(() => "")
+    )
+  ).trim();
+  const [committed, untracked] = await Promise.all([
+    mergeBase
+      ? git(dir, ["diff", "--name-only", "-z", mergeBase], OPTS)
+      : git(dir, ["diff", "--name-only", "-z", "HEAD"], OPTS).catch(() => ""),
+    git(dir, ["ls-files", "--others", "--exclude-standard", "-z"], OPTS),
+  ]);
+  return [...new Set([...paths(committed), ...paths(untracked)])].filter(
+    (p) => !p.split("/").some((seg) => seg.endsWith(".aos-partial"))
+  );
+}
+
+// Sessions that can hold a claim: local, not a mirror of another machine's.
+function candidates(): SessionRow[] {
+  return getDb()
+    .prepare(
+      `SELECT id, name, working_directory, worktree_path, branch_name, base_branch,
+              pr_url, pr_status, task_status
+         FROM session_rows
+        WHERE archived_at IS NULL AND COALESCE(peer_mirror, 0) = 0
+          AND (host_id IS NULL OR host_id = 'local')`
+    )
+    .all() as SessionRow[];
+}
+
+const last = new Map<string, LocalClaim>();
+
+// Writes this machine's claims and releases the ones whose session is gone,
+// finished, or whose PR closed. A git failure keeps the last good paths.
+export async function collectLocal(origin: {
+  id: string;
+  name: string;
+}): Promise<void> {
+  const alive = new Set<string>();
+  for (const s of candidates()) {
+    try {
+      const done = s.pr_status === "merged" || s.pr_status === "closed";
+      const idleTask =
+        s.task_status &&
+        !IN_FLIGHT.includes(s.task_status) &&
+        s.pr_status !== "open";
+      if (done || idleTask) {
+        if (done) release(s.id, s.pr_status === "merged" ? "merged" : "done");
+        continue;
+      }
+      const dir = expandHome(s.worktree_path || s.working_directory);
+      const repo = await repoKey(dir);
+      if (!repo) continue;
+      const branch = s.branch_name || (await getCurrentBranch(dir));
+      const base = s.base_branch || (await getDefaultBranch(dir));
+      let files: string[];
+      try {
+        files = await changedFiles(dir, base);
+      } catch {
+        files = last.get(s.id)?.files ?? [];
+      }
+      // A shell sitting on the default branch with no changes claims nothing.
+      if ((branch === base || branch === "HEAD") && !files.length) continue;
+      const claim: LocalClaim = {
+        sessionId: s.id,
+        sessionName: s.name,
+        repo,
+        branch,
+        base,
+        goal: s.name,
+        files: files.slice(0, MAX_FILES),
+        filesMore: Math.max(0, files.length - MAX_FILES),
+        prUrl: s.pr_url,
+      };
+      last.set(s.id, claim);
+      upsertLocal(origin, claim);
+      alive.add(s.id);
+    } catch {
+      // This session claims nothing this round.
+    }
+  }
+  for (const id of localLiveSessionIds())
+    if (!alive.has(id)) {
+      release(id, "abandoned");
+      last.delete(id);
+    }
+}

package/lib/claims/describe.ts

@@ -0,0 +1,41 @@
+// The claims as text for the orchestrator and `aos claims`. A goal and a
+// session name are another machine's words: fenced as data.
+
+import { untrusted } from "../orchestrator/untrusted";
+import { machineId } from "./machine";
+import { findOverlaps } from "./overlap";
+import type { Claim } from "./types";
+
+const ago = (ms: number) => {
+  const m = Math.max(0, Math.round(ms / 60_000));
+  return m < 1 ? "just now" : m < 60 ? `${m}m` : `${Math.round(m / 60)}h`;
+};
+
+export function describeClaims(
+  claims: Claim[],
+  opts: { onlyOthers?: boolean; now?: number } = {}
+): string {
+  const now = opts.now ?? Date.now();
+  const self = machineId();
+  const shown = opts.onlyOthers
+    ? claims.filter((c) => c.origin !== self)
+    : claims;
+  if (!shown.length) return "";
+  const lines = shown.map((c) => {
+    const where = c.origin === self ? "here" : `on ${c.originName}`;
+    const files = c.files.length + c.filesMore;
+    return `- ${untrusted("claim", c.goal)} ${where}, ${c.branch ?? "no branch"}, ${files} file${files === 1 ? "" : "s"}, started ${ago(now - c.startedAt)} ago${c.prUrl ? `, ${c.prUrl}` : ""}`;
+  });
+  const overlaps = findOverlaps(claims).filter(
+    (o) => !opts.onlyOthers || o.a.origin !== self || o.b.origin !== self
+  );
+  const tail = overlaps.map(
+    (o) =>
+      `! ${o.strength} overlap (${o.kinds.join("+")}): ${untrusted("claim", o.a.goal)} (${o.a.originName}) and ${untrusted("claim", o.b.goal)} (${o.b.originName})${o.shared.length ? `, shared ${o.shared.slice(0, 5).join(", ")}` : ""}`
+  );
+  return [
+    "Claimed work (live sessions on linked machines):",
+    ...lines,
+    ...tail,
+  ].join("\n");
+}

package/lib/claims/exchange.ts

@@ -0,0 +1,91 @@
+// The claims exchange between linked machines: one request carries our claims
+// and brings back theirs. The side that holds the link does the calling, so
+// it works when only one machine can reach the other.
+
+import { hostApi, HostApiError, type HostLink } from "../hosts/remote-api";
+import { claimsShared, machineId, machineName } from "./machine";
+import { exchangeTargets, peerMachineOf, rememberPeer } from "./peers";
+import { upsertRemote, wireFor } from "./store";
+import { exchangeBody, type ExchangeBody } from "./types";
+
+const OLD_PEER_MS = 60 * 60_000;
+const skipUntil = new Map<string, number>();
+const failing = new Set<string>();
+
+export const selfMachine = () => ({ id: machineId(), name: machineName() });
+
+// Takes what a peer sent; returns how many claims were new or newer.
+// viaHost is the link it arrived through, when we know it.
+export function acceptExchange(
+  body: ExchangeBody,
+  viaHost: string | null = null,
+  now = Date.now()
+): number {
+  if (!claimsShared()) return 0;
+  const self = machineId();
+  if (body.machine.id === self) return 0;
+  let n = 0;
+  for (const c of body.claims)
+    if (upsertRemote(self, body.machine.id, c, now, viaHost)) n++;
+  return n;
+}
+
+// What we answer a peer that called: our claims, not echoed back to it.
+export function answerExchange(body: ExchangeBody): ExchangeBody {
+  const self = selfMachine();
+  return {
+    machine: self,
+    claims: claimsShared()
+      ? wireFor(self.id, { machineId: body.machine.id })
+      : [],
+  };
+}
+
+async function exchangeOver(
+  link: HostLink,
+  self: { id: string; name: string },
+  log: (line: string) => void
+): Promise<boolean> {
+  const hostId = link.hostId;
+  if ((skipUntil.get(hostId) ?? 0) > Date.now()) return false;
+  try {
+    const raw = await hostApi<unknown>(link, "/api/claims/exchange", {
+      body: {
+        machine: self,
+        claims: wireFor(self.id, { machineId: peerMachineOf(hostId) }),
+      },
+      timeout: 8000,
+    });
+    const parsed = exchangeBody.safeParse(raw);
+    if (!parsed.success) throw new Error("its answer wasn't claims");
+    rememberPeer(hostId, parsed.data.machine.id);
+    acceptExchange(parsed.data, hostId);
+    failing.delete(hostId);
+    return true;
+  } catch (err) {
+    if (err instanceof HostApiError && err.status === 404) {
+      skipUntil.set(hostId, Date.now() + OLD_PEER_MS);
+      return false;
+    }
+    if (!failing.has(hostId)) {
+      failing.add(hostId);
+      log(
+        `claims: ${link.hostName} didn't answer: ${(err as Error)?.message ?? err}`
+      );
+    }
+    return false;
+  }
+}
+
+// Each machine once per tick, over its best working link.
+export async function syncPeers(
+  log: (line: string) => void = () => {}
+): Promise<void> {
+  if (!claimsShared()) return;
+  const self = selfMachine();
+  await Promise.all(
+    exchangeTargets().map(async (links) => {
+      for (const link of links) if (await exchangeOver(link, self, log)) return;
+    })
+  );
+}

package/lib/claims/goal.ts

@@ -0,0 +1,45 @@
+// How alike two one-line goals read: the share of content words they have
+// in common. Words every task title has (add, fix, update) carry nothing.
+
+const STOP = new Set(
+  "a an and the to of for in on at with from by or as is are be it its this that into via add adds added fix fixes fixed update updates make makes use using new support improve implement allow when not no all use".split(
+    " "
+  )
+);
+
+const stem = (w: string) =>
+  w.length > 5 && w.endsWith("ing")
+    ? w.slice(0, -3)
+    : w.length > 3 && w.endsWith("s") && !w.endsWith("ss")
+      ? w.slice(0, -1)
+      : w;
+
+export function goalWords(goal: string): Set<string> {
+  return new Set(
+    goal
+      .toLowerCase()
+      .split(/[^a-z0-9]+/)
+      .filter((w) => w.length > 1 && !STOP.has(w))
+      .map(stem)
+  );
+}
+
+export function goalSimilarity(
+  a: string,
+  b: string
+): {
+  score: number;
+  shared: number;
+} {
+  const x = goalWords(a);
+  const y = goalWords(b);
+  let shared = 0;
+  for (const w of x) if (y.has(w)) shared++;
+  const union = x.size + y.size - shared;
+  return { score: union ? shared / union : 0, shared };
+}
+
+export const goalsAlike = (a: string, b: string) => {
+  const { score, shared } = goalSimilarity(a, b);
+  return score >= 0.5 && shared >= 2;
+};

package/lib/claims/index.ts

@@ -0,0 +1,10 @@
+export { startClaimsLoop, claimsTick } from "./loop";
+export { acceptExchange, answerExchange, selfMachine } from "./exchange";
+export { liveClaim, liveClaims } from "./store";
+export { findOverlaps, overlapBetween } from "./overlap";
+export { describeClaims } from "./describe";
+export { claimsShared, machineId, machineName } from "./machine";
+export type { Claim, Overlap, ClaimWire } from "./types";
+export { endOutside, registerOutside } from "./outside";
+export { claimsSnapshot, refreshOverlapCache } from "./overlapCache";
+export { claimsView } from "./view";

package/lib/claims/loop.ts

@@ -0,0 +1,51 @@
+import { collectLocal } from "./collectLocal";
+import { selfMachine, syncPeers } from "./exchange";
+import { claimsShared } from "./machine";
+import { dropViaInactive } from "./peers";
+import { notifyOverlaps } from "./notifyOverlaps";
+import { handleMerged } from "./onMerged";
+import { refreshOverlapCache } from "./overlapCache";
+import { purgeExpired } from "./store";
+import { CLAIMS_SYNC_MS } from "./types";
+
+export async function claimsTick(
+  log: (line: string) => void = () => {}
+): Promise<void> {
+  if (!claimsShared()) return;
+  try {
+    await collectLocal(selfMachine());
+    await syncPeers(log);
+    await notifyOverlaps();
+    await handleMerged();
+    dropViaInactive();
+    purgeExpired();
+    refreshOverlapCache();
+  } catch (err) {
+    log(`claims: ${(err as Error)?.message ?? err}`);
+  }
+}
+
+// One tick a minute. Nothing here may throw into the server.
+export function startClaimsLoop(
+  log: (line: string) => void = (l) => console.log(l)
+): { stop: () => void } {
+  let stopped = false;
+  let timer: NodeJS.Timeout | null = null;
+  const next = () => {
+    if (stopped) return;
+    timer = setTimeout(run, CLAIMS_SYNC_MS);
+    timer.unref?.();
+  };
+  const run = async () => {
+    await claimsTick(log);
+    next();
+  };
+  timer = setTimeout(run, 5000);
+  timer.unref?.();
+  return {
+    stop: () => {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+    },
+  };
+}

package/lib/claims/machine.ts

@@ -0,0 +1,21 @@
+import { randomUUID } from "crypto";
+import os from "os";
+import { getSetting, putSetting } from "../settings-store";
+
+const ID_KEY = "claims.machine_id";
+
+export function machineId(): string {
+  const have = getSetting(ID_KEY);
+  if (have) return have;
+  const id = randomUUID();
+  putSetting(ID_KEY, id);
+  return id;
+}
+
+export function machineName(): string {
+  const set = getSetting("claims.machine_name")?.trim();
+  return (set || os.hostname().split(".")[0] || "machine").slice(0, 60);
+}
+
+// Off: this machine neither sends nor takes claims.
+export const claimsShared = () => getSetting("claims.share") !== "off";

package/lib/claims/mine.ts

@@ -0,0 +1,43 @@
+// The strong overlaps that touch a session on this machine, each seen from
+// that session's side. Pure over the claims it is given.
+
+import { findOverlaps } from "./overlap";
+import { pairKey, whoYields } from "./yield";
+import type { Claim } from "./types";
+
+export interface SessionOverlap {
+  sessionId: string;
+  pairKey: string;
+  mine: Claim;
+  other: Claim;
+  shared: string[];
+  kinds: ("branch" | "files" | "goal")[];
+  // This session is the one asked to give way.
+  yields: boolean;
+}
+
+export function sessionOverlaps(
+  self: string,
+  claims: Claim[]
+): SessionOverlap[] {
+  const out: SessionOverlap[] = [];
+  for (const o of findOverlaps(claims)) {
+    if (o.strength !== "strong") continue;
+    const yielder = whoYields(o.a, o.b);
+    for (const [mine, other] of [
+      [o.a, o.b],
+      [o.b, o.a],
+    ] as const)
+      if (mine.origin === self && mine.sessionId)
+        out.push({
+          sessionId: mine.sessionId,
+          pairKey: pairKey(o.a, o.b),
+          mine,
+          other,
+          shared: o.shared,
+          kinds: o.kinds,
+          yields: yielder === mine,
+        });
+  }
+  return out;
+}

package/lib/claims/notifyOverlaps.ts

@@ -0,0 +1,101 @@
+// Each sync: tells a local session about a strong overlap it is in. An
+// overlap must hold on two syncs in a row, and is told again only when the
+// shared set grows. Both machines run this for their own sessions, so
+// nothing is sent across machines. Never pauses or stops anything.
+
+import { getDb } from "../db";
+import { sendMessage } from "../bus";
+import { machineId } from "./machine";
+import { sessionOverlaps, type SessionOverlap } from "./mine";
+import { sessionMessage } from "./overlapText";
+import { liveClaims } from "./store";
+
+export const HOLD_SYNCS = 2;
+// A told pair that has not overlapped for this long is forgotten.
+const FORGET_MS = 60 * 60_000;
+
+export type Tell = (sessionId: string, body: string) => Promise<void>;
+
+export const tellSession: Tell = async (sessionId, body) => {
+  await sendMessage({
+    fromId: null,
+    to: sessionId,
+    body,
+    fromLabel: "AgentOS",
+    origin: { kind: "system", label: "Overlap", body },
+  });
+};
+
+interface Notice {
+  pair_key: string;
+  hits: number;
+  shared: string;
+  told_at: number | null;
+  seen_at: number;
+}
+
+const parse = (raw: string): string[] => {
+  try {
+    const v = JSON.parse(raw);
+    return Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+  } catch {
+    return [];
+  }
+};
+
+export async function notifyOverlaps(
+  tell: Tell = tellSession,
+  now = Date.now()
+): Promise<number> {
+  const db = getDb();
+  const byPair = new Map<string, SessionOverlap[]>();
+  for (const o of sessionOverlaps(machineId(), liveClaims({ now })))
+    byPair.set(o.pairKey, [...(byPair.get(o.pairKey) ?? []), o]);
+  const get = db.prepare(`SELECT * FROM claim_notices WHERE pair_key = ?`);
+  const save = db.prepare(
+    `INSERT INTO claim_notices (pair_key, hits, shared, told_at, seen_at)
+     VALUES (@key, @hits, @shared, @told, @now)
+     ON CONFLICT(pair_key) DO UPDATE SET hits = @hits, shared = @shared,
+       told_at = @told, seen_at = @now`
+  );
+  let told = 0;
+  for (const [key, sides] of byPair) {
+    const row = get.get(key) as Notice | undefined;
+    const hits = (row?.hits ?? 0) + 1;
+    const shared = sides[0].shared;
+    const known = new Set(parse(row?.shared ?? "[]"));
+    const grew = !!row?.told_at && shared.some((f) => !known.has(f));
+    const due = hits >= HOLD_SYNCS && (!row?.told_at || grew);
+    let delivered = false;
+    if (due)
+      for (const side of sides)
+        try {
+          await tell(side.sessionId, sessionMessage(side));
+          delivered = true;
+        } catch {
+          // Left untold when nobody got it: the next sync tries again.
+        }
+    if (delivered) told++;
+    save.run({
+      key,
+      hits,
+      shared: delivered ? JSON.stringify(shared) : (row?.shared ?? "[]"),
+      told: delivered ? now : (row?.told_at ?? null),
+      now,
+    });
+  }
+  // Consecutive means consecutive: a pair that dropped out starts again.
+  const rows = db.prepare(`SELECT * FROM claim_notices`).all() as Notice[];
+  for (const r of rows) {
+    if (byPair.has(r.pair_key)) continue;
+    if (!r.told_at || now - r.seen_at > FORGET_MS)
+      db.prepare(`DELETE FROM claim_notices WHERE pair_key = ?`).run(
+        r.pair_key
+      );
+    else if (r.hits)
+      db.prepare(`UPDATE claim_notices SET hits = 0 WHERE pair_key = ?`).run(
+        r.pair_key
+      );
+  }
+  return told;
+}

package/lib/claims/onMerged.ts

@@ -0,0 +1,85 @@
+// A winner of an overlap merged: the base moved under the session that gave
+// way. One with a PR is left to rebaseConflicting once GitHub flags a
+// conflict. One without gets a single message, and a refreshBase when it is
+// idle with nothing uncommitted (refreshBase never loses work). Nothing here
+// pauses or stops a session.
+
+import { getDb } from "../db";
+import { git } from "../git-exec";
+import { statusOf } from "../orchestrator/facts";
+import { getSessionRow } from "../schedules/store";
+import { refreshBase, type RefreshTarget } from "../tasks/refresh-base";
+import { expandHome } from "../tasks/session";
+import { machineId } from "./machine";
+import { mergedMessage } from "./overlapText";
+import { claimById } from "./store";
+import { tellSession, type Tell } from "./notifyOverlaps";
+import { winner } from "./yield";
+
+export interface MergedDeps {
+  tell: Tell;
+  idle: (sessionId: string) => Promise<boolean>;
+  clean: (dir: string) => Promise<boolean>;
+  refresh: (t: RefreshTarget) => Promise<unknown>;
+}
+
+export const realMerged: MergedDeps = {
+  tell: tellSession,
+  idle: async (id) => {
+    const s = getSessionRow(id);
+    return !!s && (await statusOf(s)).status === "idle";
+  },
+  clean: async (dir) =>
+    !(await git(dir, ["status", "--porcelain"], { timeout: 5000 })).trim(),
+  refresh: refreshBase,
+};
+
+interface Row {
+  pair_key: string;
+}
+
+export async function handleMerged(
+  deps: MergedDeps = realMerged,
+  now = Date.now()
+): Promise<number> {
+  const db = getDb();
+  const self = machineId();
+  const rows = db
+    .prepare(
+      `SELECT pair_key FROM claim_notices WHERE told_at IS NOT NULL AND merged_at IS NULL`
+    )
+    .all() as Row[];
+  const done = db.prepare(
+    `UPDATE claim_notices SET merged_at = ? WHERE pair_key = ?`
+  );
+  let handled = 0;
+  for (const { pair_key } of rows) {
+    const [a, b] = pair_key.split("|").map((id) => claimById(id));
+    if (!a || !b) continue;
+    const gone = [a, b].find((c) => c.released === "merged");
+    const mine = [a, b].find(
+      (c) => !c.released && c.origin === self && c.sessionId
+    );
+    if (!gone || !mine || winner(gone, mine) !== gone) continue;
+    try {
+      const s = getSessionRow(mine.sessionId!);
+      // A session with a PR is the rebase pipeline's.
+      if (s && !s.pr_url && s.pr_status !== "open") {
+        await deps.tell(s.id, mergedMessage(gone, s.base_branch ?? mine.base));
+        const dir = s.worktree_path ? expandHome(s.worktree_path) : null;
+        if (dir && (await deps.idle(s.id)) && (await deps.clean(dir)))
+          await deps.refresh({
+            name: s.name,
+            worktree: dir,
+            branch: s.branch_name,
+            base: s.base_branch,
+          });
+        handled++;
+      }
+      done.run(now, pair_key);
+    } catch {
+      // Tried again next sync.
+    }
+  }
+  return handled;
+}

package/lib/claims/outside.ts

@@ -0,0 +1,36 @@
+// Sessions AgentOS didn't start register a claim themselves, through
+// `aos claim` or the hook. The CLI sends what git said in its own folder.
+
+import { repoKeyOfRemote } from "../git-remote";
+import { machineId, machineName } from "./machine";
+import {
+  liveClaim,
+  newOutsideId,
+  releaseOutside,
+  upsertOutside,
+} from "./store";
+import type { Claim, OutsideBody } from "./types";
+
+const self = () => ({ id: machineId(), name: machineName() });
+
+// Null when the remote isn't one a claim can be keyed by, or the id is not
+// this machine's outside claim.
+export function registerOutside(b: OutsideBody): { claim: Claim } | null {
+  const repo = repoKeyOfRemote(b.remote);
+  if (!repo) return null;
+  const id = b.id ?? newOutsideId();
+  const prior = liveClaim(id);
+  const ok = upsertOutside(self(), {
+    id,
+    sessionName: b.name ?? null,
+    repo,
+    branch: b.branch ?? null,
+    base: b.base ?? null,
+    goal: b.goal || prior?.goal || "outside session",
+    files: b.files,
+  });
+  const claim = ok ? liveClaim(id) : null;
+  return claim ? { claim } : null;
+}
+
+export const endOutside = (id: string) => releaseOutside(machineId(), id);