@saadnvd1/agent-os 0.3.715 → 0.3.723

package/lib/analyst/pushDigest.ts

@@ -0,0 +1,143 @@
+import type { ChatItem } from "../chat/events";
+import { hasItem, itemsAfter, lastItems } from "../chat/store";
+import { listQueue } from "../chat/queued";
+import { sendChat } from "../chat/runner";
+import { db } from "../db";
+import { buildDigest } from "./buildDigest";
+import { dropPendingDigest, getLink, markDigestPending } from "./store";
+import type { AnalystLink } from "./types";
+
+// How far back a first review, or a review of the same turn again, reads.
+const LAST_TURN_ITEMS = 400;
+
+export const digestPrefix = (linkId: string) => `user-analyst-${linkId}-`;
+
+const sessionName = (id: string) =>
+  (
+    db.prepare(`SELECT name FROM sessions WHERE id = ?`).get(id) as
+      { name: string } | undefined
+  )?.name ?? "coding agent";
+
+const lastTurnEnd = (items: ChatItem[]) =>
+  items.findLastIndex((i) => i.kind === "turn_end");
+
+// The latest finished turn: from after the turn_end before it.
+function lastTurn(sessionId: string): ChatItem[] {
+  const items = lastItems(sessionId, LAST_TURN_ITEMS);
+  const end = lastTurnEnd(items);
+  if (end < 0) return [];
+  const before = items
+    .slice(0, end)
+    .findLastIndex((i) => i.kind === "turn_end");
+  return items.slice(before + 1, end + 1);
+}
+
+// The coding agent's finished turns the analyst hasn't reviewed.
+export function unreviewedTurns(link: AnalystLink): ChatItem[] {
+  if (!link.reviewedThrough) return lastTurn(link.coderSessionId);
+  const items = itemsAfter(link.coderSessionId, link.reviewedThrough);
+  return items.slice(0, lastTurnEnd(items) + 1);
+}
+
+// The turns a pending digest covers: after the cursor, up to its end.
+function pendingTurns(link: AnalystLink): ChatItem[] {
+  const items = link.reviewedThrough
+    ? itemsAfter(link.coderSessionId, link.reviewedThrough)
+    : lastItems(link.coderSessionId, LAST_TURN_ITEMS);
+  const end = items.findIndex((i) => i.id === link.pendingThrough);
+  if (end < 0) return [];
+  if (link.reviewedThrough) return items.slice(0, end + 1);
+  const before = items
+    .slice(0, end)
+    .findLastIndex((i) => i.kind === "turn_end");
+  return items.slice(before + 1, end + 1);
+}
+
+const taken = (sessionId: string, id: string) =>
+  hasItem(sessionId, id) || listQueue(sessionId).some((q) => q.id === id);
+
+// A pending digest the analyst will never answer: lost before it arrived,
+// or answered by a turn whose end this server didn't see (a crash).
+export function pendingIsStale(link: AnalystLink): boolean {
+  const id = link.pendingDigestId;
+  if (!id) return false;
+  if (!taken(link.analystSessionId, id)) return true;
+  // Still queued: it waits its turn.
+  if (!hasItem(link.analystSessionId, id)) return false;
+  return itemsAfter(link.analystSessionId, id, 200).some(
+    (i) => i.kind === "turn_end"
+  );
+}
+
+async function send(link: AnalystLink, id: string, items: ChatItem[]) {
+  const through = items[items.length - 1].id;
+  const digest = buildDigest(items, {
+    coderName: sessionName(link.coderSessionId),
+    through,
+  });
+  markDigestPending(link.id, id, through, digest.signals);
+  await sendChat(link.analystSessionId, {
+    text: digest.text,
+    id,
+    queue: true,
+    origin: {
+      kind: "event",
+      label: "Coding agent",
+      sessionId: link.coderSessionId,
+      body: digest.label,
+    },
+  });
+}
+
+export type PushResult =
+  "sent" | "nothing" | "paused" | "busy" | "ended" | "interrupted";
+
+/**
+ * Sends the analyst the coding agent's turns since it last reviewed, once:
+ * turns that end while it is still on a digest wait for the next one, and
+ * a turn the user stopped rides along with the turn after it. `force`
+ * (Review now) sends even when paused, busy or stopped, and with nothing
+ * new reviews the last turn again.
+ */
+export async function pushDigest(
+  linkId: string,
+  opts: { force?: boolean } = {}
+): Promise<PushResult> {
+  let link = getLink(linkId);
+  if (!link || link.endedAt) return "ended";
+  if (link.pendingDigestId && (opts.force || pendingIsStale(link))) {
+    dropPendingDigest(link.id);
+    link = getLink(linkId)!;
+  }
+  if (!opts.force) {
+    if (link.paused) return "paused";
+    if (link.pendingDigestId) return "busy";
+  }
+  const items = unreviewedTurns(link);
+  const end = items[items.length - 1];
+  if (end?.kind === "turn_end") {
+    if (end.interrupted && !opts.force) return "interrupted";
+    await send(link, `${digestPrefix(link.id)}${end.id}`, items);
+    return "sent";
+  }
+  if (!opts.force) return "nothing";
+  const again = lastTurn(link.coderSessionId);
+  if (!again.length) return "nothing";
+  await send(link, `${digestPrefix(link.id)}again-${Date.now()}`, again);
+  return "sent";
+}
+
+// After a restart: a digest marked pending is sent again under its id (a
+// no-op when it landed).
+export async function resendPending(linkId: string): Promise<boolean> {
+  const link = getLink(linkId);
+  if (!link?.pendingDigestId || link.endedAt) return false;
+  if (taken(link.analystSessionId, link.pendingDigestId)) return false;
+  const items = pendingTurns(link);
+  if (!items.length) {
+    dropPendingDigest(link.id);
+    return false;
+  }
+  await send(link, link.pendingDigestId, items);
+  return true;
+}

package/lib/analyst/resume.ts

@@ -0,0 +1,35 @@
+import { onTurnEnd } from "./onTurnEnd";
+import { pushDigest, resendPending } from "./pushDigest";
+import { liveLinks } from "./store";
+import type { ChatItem } from "../chat/events";
+import { FLUSH_MS } from "../chat/store";
+
+// The worker writes a turn's items a moment after reporting its end.
+export const SETTLE_MS = 4 * FLUSH_MS;
+
+// The chat registry's hook for every finished turn: read once the items
+// have landed. Never throws into the chat path.
+export function analystTurnEndHook(
+  sessionId: string,
+  item: Extract<ChatItem, { kind: "turn_end" }>
+): void {
+  setTimeout(() => {
+    onTurnEnd(sessionId, item).catch((error) =>
+      console.error("[analyst] turn end:", error)
+    );
+  }, SETTLE_MS);
+}
+
+// After a restart: digests marked pending go again under their ids (a
+// no-op where they landed), and turns that ended while the server was down
+// are sent.
+export async function resumeAnalystLinks(): Promise<void> {
+  for (const link of liveLinks()) {
+    try {
+      if (link.pendingDigestId) await resendPending(link.id);
+      else await pushDigest(link.id);
+    } catch (error) {
+      console.error(`[analyst] resuming ${link.id}:`, error);
+    }
+  }
+}

package/lib/analyst/route.ts

@@ -0,0 +1,50 @@
+import { NextResponse } from "next/server";
+import type { z } from "zod";
+import { ModelUnavailableError } from "../models/agent-binding";
+import { AnalystError } from "./types";
+
+// An analyst action for a route: a body that fails its schema is a 400, an
+// AnalystError its status, a role model that's down a 409 with its fallback.
+export async function analystRoute<S extends z.ZodType>(
+  request: Request,
+  schema: S,
+  act: (body: z.infer<S>) => unknown
+): Promise<NextResponse> {
+  const raw = await request.text().catch(() => "");
+  let json: unknown = {};
+  try {
+    json = raw.trim() ? JSON.parse(raw) : {};
+  } catch {
+    return NextResponse.json({ error: "Bad JSON" }, { status: 400 });
+  }
+  const parsed = schema.safeParse(json);
+  if (!parsed.success)
+    return NextResponse.json(
+      { error: parsed.error.issues[0]?.message ?? "Bad request" },
+      { status: 400 }
+    );
+  return run(() => act(parsed.data));
+}
+
+export async function run(act: () => unknown): Promise<NextResponse> {
+  try {
+    return NextResponse.json(await act());
+  } catch (err) {
+    if (err instanceof AnalystError)
+      return NextResponse.json({ error: err.message }, { status: err.status });
+    if (err instanceof ModelUnavailableError)
+      return NextResponse.json(
+        {
+          code: err.code,
+          role: err.role,
+          ref: err.ref,
+          fallback: err.fallback ?? null,
+          error: err.message,
+        },
+        { status: 409 }
+      );
+    const message = err instanceof Error ? err.message : String(err);
+    console.error("[analyst]", message);
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}

package/lib/analyst/signals.ts

@@ -0,0 +1,121 @@
+import type { ChatItem } from "../chat/events";
+import type { DigestSignals } from "./types";
+
+type Tool = Extract<ChatItem, { kind: "tool" }>;
+
+// A command that checks the work: tests, a build, a typecheck, a lint.
+const CHECK =
+  /\b(?:vitest|jest|pytest|mocha|playwright|rspec|phpunit|tsc|eslint|ruff|mypy|clippy|go\s+(?:test|vet|build)|cargo\s+(?:test|build|check)|swift\s+(?:test|build)|xcodebuild|gradle\w*\s+(?:test|build)|mvn\s+(?:test|verify)|(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:test|build|typecheck|lint|check)|make\s+(?:test|check|build)|scripts\/check|rails\s+test|rake\s+test)\b/;
+
+const WEB_TOOLS = new Set(["WebFetch", "WebSearch"]);
+const EDIT_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+// A curl or wget to anything but this machine.
+const REMOTE_FETCH =
+  /\b(?:curl|wget)\b[^|;&]*\bhttps?:\/\/(?!localhost\b|127\.0\.0\.1\b|\[::1\])/;
+
+const input = (t: Tool) =>
+  (t.input && typeof t.input === "object" ? t.input : {}) as Record<
+    string,
+    unknown
+  >;
+
+export const commandOf = (t: Tool): string | null =>
+  t.name === "Bash" && typeof input(t).command === "string"
+    ? (input(t).command as string)
+    : null;
+
+export const isCheckCommand = (command: string) => CHECK.test(command);
+
+function pathOf(t: Tool): string | null {
+  if (t.diff?.path) return t.diff.path;
+  if (!EDIT_TOOLS.has(t.name)) return null;
+  const i = input(t);
+  const p = i.file_path ?? i.notebook_path;
+  return typeof p === "string" ? p : null;
+}
+
+// What the turns did, counted from their items: the same answer whatever
+// the analyst writes about them.
+export function turnSignals(items: ChatItem[]): DigestSignals {
+  const s: DigestSignals = {
+    turns: 0,
+    toolCalls: 0,
+    failedTools: 0,
+    checks: [],
+    filesChanged: [],
+    durationMs: 0,
+    costUsd: 0,
+    interrupted: false,
+    errors: 0,
+    noToolTurns: 0,
+    readWeb: false,
+  };
+  const files = new Set<string>();
+  let toolsThisTurn = 0;
+  for (const item of items) {
+    if (item.kind === "tool") {
+      s.toolCalls++;
+      toolsThisTurn++;
+      if (item.status === "error") s.failedTools++;
+      const command = commandOf(item);
+      if (command && isCheckCommand(command) && item.status !== "running")
+        s.checks.push({
+          command: command.trim().split("\n")[0].slice(0, 200),
+          passed: item.status === "done",
+        });
+      if (
+        WEB_TOOLS.has(item.name) ||
+        item.name.startsWith("mcp__") ||
+        (command && REMOTE_FETCH.test(command))
+      )
+        s.readWeb = true;
+      const path = item.status !== "error" ? pathOf(item) : null;
+      if (path) files.add(path);
+    } else if (item.kind === "error") s.errors++;
+    else if (item.kind === "turn_end") {
+      s.turns++;
+      s.durationMs += item.durationMs ?? 0;
+      s.costUsd += item.costUsd ?? 0;
+      if (item.interrupted) s.interrupted = true;
+      if (!toolsThisTurn && !item.interrupted) s.noToolTurns++;
+      toolsThisTurn = 0;
+    }
+  }
+  s.filesChanged = [...files];
+  return s;
+}
+
+// The last check of each command decides it: a test that failed and then
+// passed counts as passing.
+export function latestChecks(s: DigestSignals) {
+  const by = new Map<string, boolean>();
+  for (const c of s.checks) by.set(c.command, c.passed);
+  return [...by].map(([command, passed]) => ({ command, passed }));
+}
+
+const plural = (n: number, word: string) => `${n} ${word}${n === 1 ? "" : "s"}`;
+
+// One line heading the digest, and the chips the card shows.
+export function signalLine(s: DigestSignals): string {
+  const checks = latestChecks(s);
+  const failed = checks.filter((c) => !c.passed);
+  const parts = [
+    plural(s.toolCalls, "tool call"),
+    s.failedTools ? `${s.failedTools} failed` : "",
+    checks.length
+      ? failed.length
+        ? `checks FAILED (${failed.map((c) => c.command).join("; ")})`
+        : `checks passed (${checks.length})`
+      : "no checks run",
+    s.filesChanged.length
+      ? plural(s.filesChanged.length, "file") + " changed"
+      : "",
+    s.noToolTurns ? `${plural(s.noToolTurns, "turn")} with no tool calls` : "",
+    s.interrupted ? "stopped by the user" : "",
+    s.errors ? plural(s.errors, "error") : "",
+    s.readWeb ? "read web content" : "",
+    s.durationMs ? `${Math.round(s.durationMs / 1000)}s` : "",
+    s.costUsd ? `$${s.costUsd.toFixed(2)}` : "",
+  ];
+  return parts.filter(Boolean).join(" · ");
+}

package/lib/analyst/store.ts

@@ -0,0 +1,303 @@
+import { randomUUID } from "crypto";
+import { db } from "../db";
+import {
+  AnalystError,
+  type AnalystLink,
+  type DigestSignals,
+  type Issue,
+  type Recommendation,
+  type RecommendationState,
+  type Verdict,
+} from "./types";
+
+interface LinkRow {
+  id: string;
+  coder_session_id: string;
+  analyst_session_id: string;
+  paused: number;
+  reviewed_through: string | null;
+  pending_digest_id: string | null;
+  pending_through: string | null;
+  digest_signals: string | null;
+  created_at: number;
+  ended_at: number | null;
+}
+
+interface RecRow {
+  id: string;
+  link_id: string;
+  analyst_item_id: string;
+  coder_through: string | null;
+  verdict: string | null;
+  summary: string;
+  issues: string;
+  signals: string | null;
+  prompt: string | null;
+  state: string;
+  error: string | null;
+  sent_text: string | null;
+  sent_item_id: string | null;
+  edited: number;
+  created_at: number;
+  decided_at: number | null;
+}
+
+const parse = <T>(s: string | null, fallback: T): T => {
+  if (!s) return fallback;
+  try {
+    return JSON.parse(s) as T;
+  } catch {
+    return fallback;
+  }
+};
+
+const toLink = (r: LinkRow): AnalystLink => ({
+  id: r.id,
+  coderSessionId: r.coder_session_id,
+  analystSessionId: r.analyst_session_id,
+  paused: !!r.paused,
+  reviewedThrough: r.reviewed_through,
+  pendingDigestId: r.pending_digest_id,
+  pendingThrough: r.pending_through,
+  digestSignals: parse<DigestSignals | null>(r.digest_signals, null),
+  createdAt: r.created_at,
+  endedAt: r.ended_at,
+});
+
+const toRec = (r: RecRow): Recommendation => ({
+  id: r.id,
+  linkId: r.link_id,
+  analystItemId: r.analyst_item_id,
+  coderThrough: r.coder_through,
+  verdict: r.verdict as Verdict | null,
+  summary: r.summary,
+  issues: parse<Issue[]>(r.issues, []),
+  signals: parse<DigestSignals | null>(r.signals, null),
+  prompt: r.prompt,
+  state: r.state as RecommendationState,
+  error: r.error,
+  sentText: r.sent_text,
+  sentItemId: r.sent_item_id,
+  edited: !!r.edited,
+  createdAt: r.created_at,
+  decidedAt: r.decided_at,
+});
+
+export function getLink(id: string): AnalystLink | null {
+  const r = db.prepare(`SELECT * FROM analyst_links WHERE id = ?`).get(id) as
+    LinkRow | undefined;
+  return r ? toLink(r) : null;
+}
+
+export function getLinkOrThrow(id: string): AnalystLink {
+  const link = getLink(id);
+  if (!link) throw new AnalystError("Pairing not found", 404);
+  return link;
+}
+
+// The live link a session is in, on either side.
+export function liveLinkFor(sessionId: string): AnalystLink | null {
+  const r = db
+    .prepare(
+      `SELECT * FROM analyst_links WHERE ended_at IS NULL
+         AND (coder_session_id = ? OR analyst_session_id = ?)`
+    )
+    .get(sessionId, sessionId) as LinkRow | undefined;
+  return r ? toLink(r) : null;
+}
+
+// Any link, live or ended, the session was the analyst of.
+export function linkOfAnalyst(sessionId: string): AnalystLink | null {
+  const r = db
+    .prepare(`SELECT * FROM analyst_links WHERE analyst_session_id = ?`)
+    .get(sessionId) as LinkRow | undefined;
+  return r ? toLink(r) : null;
+}
+
+export function liveLinks(): AnalystLink[] {
+  return (
+    db
+      .prepare(`SELECT * FROM analyst_links WHERE ended_at IS NULL`)
+      .all() as LinkRow[]
+  ).map(toLink);
+}
+
+export function insertLink(
+  coderSessionId: string,
+  analystSessionId: string,
+  reviewedThrough: string | null
+): AnalystLink {
+  const id = randomUUID();
+  db.prepare(
+    `INSERT INTO analyst_links (id, coder_session_id, analyst_session_id,
+       reviewed_through, created_at) VALUES (?, ?, ?, ?, ?)`
+  ).run(id, coderSessionId, analystSessionId, reviewedThrough, Date.now());
+  return getLink(id)!;
+}
+
+export function setPausedRow(id: string, paused: boolean): void {
+  db.prepare(`UPDATE analyst_links SET paused = ? WHERE id = ?`).run(
+    paused ? 1 : 0,
+    id
+  );
+}
+
+export function endLinkRow(id: string): boolean {
+  return (
+    db
+      .prepare(
+        `UPDATE analyst_links SET ended_at = ? WHERE id = ? AND ended_at IS NULL`
+      )
+      .run(Date.now(), id).changes > 0
+  );
+}
+
+// Recorded before the digest is sent, so a restart can send it again.
+export function markDigestPending(
+  id: string,
+  digestId: string,
+  through: string,
+  signals: DigestSignals
+): void {
+  db.prepare(
+    `UPDATE analyst_links SET pending_digest_id = ?, pending_through = ?,
+       digest_signals = ? WHERE id = ?`
+  ).run(digestId, through, JSON.stringify(signals), id);
+}
+
+// The analyst answered the digest: its turns count as reviewed.
+export function settleDigest(id: string, digestId: string): boolean {
+  return (
+    db
+      .prepare(
+        `UPDATE analyst_links SET reviewed_through = pending_through,
+           pending_digest_id = NULL, pending_through = NULL
+         WHERE id = ? AND pending_digest_id = ?`
+      )
+      .run(id, digestId).changes > 0
+  );
+}
+
+// A digest that never arrived: dropped, so the next one covers its turns.
+export function dropPendingDigest(id: string): void {
+  db.prepare(
+    `UPDATE analyst_links SET pending_digest_id = NULL, pending_through = NULL
+      WHERE id = ?`
+  ).run(id);
+}
+
+export function listRecommendations(
+  linkId: string,
+  limit = 20
+): Recommendation[] {
+  return (
+    db
+      .prepare(
+        `SELECT * FROM analyst_recommendations WHERE link_id = ?
+          ORDER BY created_at DESC, rowid DESC LIMIT ?`
+      )
+      .all(linkId, limit) as RecRow[]
+  ).map(toRec);
+}
+
+export function getRecommendation(id: string): Recommendation | null {
+  const r = db
+    .prepare(`SELECT * FROM analyst_recommendations WHERE id = ?`)
+    .get(id) as RecRow | undefined;
+  return r ? toRec(r) : null;
+}
+
+export function recommendationFor(
+  linkId: string,
+  analystItemId: string
+): Recommendation | null {
+  const r = db
+    .prepare(
+      `SELECT * FROM analyst_recommendations WHERE link_id = ? AND analyst_item_id = ?`
+    )
+    .get(linkId, analystItemId) as RecRow | undefined;
+  return r ? toRec(r) : null;
+}
+
+export interface NewRecommendation {
+  linkId: string;
+  analystItemId: string;
+  coderThrough: string | null;
+  verdict: Verdict | null;
+  summary: string;
+  issues: Issue[];
+  signals: DigestSignals | null;
+  prompt: string | null;
+  state: "open" | "invalid";
+  error?: string | null;
+}
+
+// Once per analyst reply: a repeat is a no-op. A new one retires the
+// cards still open, so only one is ever actionable.
+export function insertRecommendation(
+  r: NewRecommendation
+): Recommendation | null {
+  const id = randomUUID();
+  const inserted = db.transaction(() => {
+    const changes = db
+      .prepare(
+        `INSERT OR IGNORE INTO analyst_recommendations (id, link_id,
+           analyst_item_id, coder_through, verdict, summary, issues, signals,
+           prompt, state, error, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        id,
+        r.linkId,
+        r.analystItemId,
+        r.coderThrough,
+        r.verdict,
+        r.summary,
+        JSON.stringify(r.issues),
+        r.signals ? JSON.stringify(r.signals) : null,
+        r.prompt,
+        r.state,
+        r.error ?? null,
+        Date.now()
+      ).changes;
+    if (!changes) return false;
+    db.prepare(
+      `UPDATE analyst_recommendations SET state = 'superseded', decided_at = ?
+        WHERE link_id = ? AND id != ? AND state IN ('open', 'invalid')`
+    ).run(Date.now(), r.linkId, id);
+    return true;
+  })();
+  return inserted ? getRecommendation(id) : null;
+}
+
+// Moves an open card to its decision, once: false when it was decided.
+export function decideRecommendation(
+  id: string,
+  state: "sent" | "dismissed",
+  sent?: { text: string; itemId: string; edited: boolean }
+): boolean {
+  return (
+    db
+      .prepare(
+        `UPDATE analyst_recommendations SET state = ?, decided_at = ?,
+           sent_text = ?, sent_item_id = ?, edited = ?
+         WHERE id = ? AND state IN ('open', 'invalid')`
+      )
+      .run(
+        state,
+        Date.now(),
+        sent?.text ?? null,
+        sent?.itemId ?? null,
+        sent?.edited ? 1 : 0,
+        id
+      ).changes > 0
+  );
+}
+
+// Back to open: a send that failed after the card was claimed.
+export function reopenRecommendation(id: string): void {
+  db.prepare(
+    `UPDATE analyst_recommendations SET state = 'open', decided_at = NULL,
+       sent_text = NULL, sent_item_id = NULL, edited = 0 WHERE id = ?`
+  ).run(id);
+}