@saadnvd1/agent-os 0.3.715 → 0.3.728

package/lib/reports/store.ts

@@ -0,0 +1,180 @@
+import { db } from "../db";
+import type {
+  DraftStatus,
+  HealthReport,
+  ReportSummary,
+  ReportTrigger,
+} from "./types";
+
+interface Row {
+  id: number;
+  session_id: string;
+  workspace_id: string | null;
+  head: string | null;
+  trigger: ReportTrigger;
+  evidence_hash: string;
+  data: string;
+  model: string | null;
+  cost_usd: number | null;
+  draft_text: string | null;
+  draft_status: DraftStatus | null;
+  created_at: string;
+}
+
+// What is stored in `data`: the report without what the row itself holds.
+type Stored = Omit<
+  HealthReport,
+  "id" | "sessionId" | "workspaceId" | "createdAt" | "stale" | "draft"
+> & { draft: HealthReport["draft"] };
+
+export function insertReport(
+  r: Omit<HealthReport, "id" | "createdAt" | "stale">,
+  hash: string
+): number {
+  const { id: _i, sessionId, workspaceId, ...rest } = r as HealthReport;
+  void _i;
+  const draft = r.draft?.source === "report" ? r.draft : null;
+  db.prepare(
+    `UPDATE health_reports SET draft_status = 'superseded'
+      WHERE session_id = ? AND draft_status = 'pending'`
+  ).run(sessionId);
+  const info = db
+    .prepare(
+      `INSERT INTO health_reports (session_id, workspace_id, head, trigger, evidence_hash, data, model, cost_usd, draft_text, draft_status)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    )
+    .run(
+      sessionId,
+      workspaceId,
+      r.head,
+      r.trigger,
+      hash,
+      JSON.stringify({ ...rest, draft: null } satisfies Stored),
+      r.model,
+      r.costUsd,
+      draft?.text ?? null,
+      draft ? "pending" : null
+    );
+  return Number(info.lastInsertRowid);
+}
+
+function toReport(row: Row, head: string | null | undefined): HealthReport {
+  const data = JSON.parse(row.data) as Stored;
+  return {
+    ...data,
+    id: row.id,
+    sessionId: row.session_id,
+    workspaceId: row.workspace_id,
+    createdAt: row.created_at,
+    draft: row.draft_text
+      ? {
+          source: "report",
+          id: String(row.id),
+          text: row.draft_text,
+          status: row.draft_status ?? "pending",
+        }
+      : null,
+    stale: head !== undefined && head !== row.head,
+  };
+}
+
+// `head` is the task's current head, to mark an older report stale.
+export function latestReport(
+  sessionId: string,
+  head?: string | null
+): HealthReport | null {
+  const row = db
+    .prepare(
+      `SELECT * FROM health_reports WHERE session_id = ? ORDER BY id DESC LIMIT 1`
+    )
+    .get(sessionId) as Row | undefined;
+  return row ? toReport(row, head) : null;
+}
+
+export function getReport(id: number): HealthReport | null {
+  const row = db
+    .prepare(`SELECT * FROM health_reports WHERE id = ?`)
+    .get(id) as Row | undefined;
+  return row ? toReport(row, undefined) : null;
+}
+
+export function hashOfLatest(sessionId: string): string | null {
+  const row = db
+    .prepare(
+      `SELECT evidence_hash FROM health_reports WHERE session_id = ? ORDER BY id DESC LIMIT 1`
+    )
+    .get(sessionId) as { evidence_hash: string } | undefined;
+  return row?.evidence_hash ?? null;
+}
+
+// Claimed first, so a double tap sends once.
+export function claimDraft(
+  reportId: number,
+  to: Exclude<DraftStatus, "pending">
+): boolean {
+  return (
+    db
+      .prepare(
+        `UPDATE health_reports SET draft_status = ?, draft_decided_at = datetime('now')
+          WHERE id = ? AND draft_status = 'pending'`
+      )
+      .run(to, reportId).changes === 1
+  );
+}
+
+export function reopenDraft(reportId: number): void {
+  db.prepare(
+    `UPDATE health_reports SET draft_status = 'pending', draft_decided_at = NULL
+      WHERE id = ? AND draft_status = 'sent'`
+  ).run(reportId);
+}
+
+export function setDraftText(
+  reportId: number,
+  text: string,
+  status: DraftStatus
+) {
+  db.prepare(
+    `UPDATE health_reports SET draft_text = ?, draft_status = ? WHERE id = ?`
+  ).run(text, status, reportId);
+}
+
+export function historyOf(sessionId: string, limit = 20): ReportSummary[] {
+  const rows = db
+    .prepare(
+      `SELECT * FROM health_reports WHERE session_id = ? ORDER BY id DESC LIMIT ?`
+    )
+    .all(sessionId, limit) as Row[];
+  return rows.map((r) => summaryOf(toReport(r, undefined), ""));
+}
+
+export function summaryOf(r: HealthReport, name: string): ReportSummary {
+  return {
+    sessionId: r.sessionId,
+    name,
+    headline: r.headline,
+    state: r.state,
+    estimate: {
+      done: r.estimate.done,
+      total: r.estimate.total,
+      basis: r.estimate.basis,
+    },
+    createdAt: r.createdAt,
+  };
+}
+
+// The newest report of each task in a workspace.
+export function latestByTask(
+  workspaceId: string
+): { report: HealthReport; name: string }[] {
+  const rows = db
+    .prepare(
+      `SELECT h.*, s.name AS name FROM health_reports h
+         JOIN session_rows s ON s.id = h.session_id
+        WHERE h.workspace_id = ?
+          AND h.id = (SELECT MAX(id) FROM health_reports WHERE session_id = h.session_id)
+        ORDER BY h.id DESC LIMIT 100`
+    )
+    .all(workspaceId) as (Row & { name: string })[];
+  return rows.map((r) => ({ report: toReport(r, undefined), name: r.name }));
+}

package/lib/reports/template.ts

@@ -0,0 +1,117 @@
+// The report with no model: sentences built from the same evidence. Used when
+// the model fails or every line it wrote was rejected, and for the headline.
+
+import type { TaskState } from "../tasks/state";
+import type { EvidenceRef, ReportLine } from "./types";
+
+const HEADLINES: Record<TaskState, string> = {
+  working: "The agent is working on it",
+  "needs-input": "The agent is waiting for an answer",
+  blocked: "The task is blocked and needs a decision",
+  review: "The pull request is open and waiting on review",
+  "checks-failing": "Checks are failing on the latest push",
+  "plan-ready": "The plan is written and waits for your approval",
+  exited: "The agent stopped before finishing",
+  merged: "The work is merged",
+  dropped: "The task was dropped",
+  done: "The task is finished",
+  moving: "The task is moving to another machine",
+};
+
+export const headlineFor = (state: TaskState) => HEADLINES[state];
+
+const NEXT: Partial<Record<TaskState, string>> = {
+  "checks-failing": "Next: fix the failing checks, then push again.",
+  review: "Next: wait for the review and the checks to settle, then merge.",
+  blocked: "Next: answer what the task is waiting on.",
+  "needs-input": "Next: reply to the agent so it can go on.",
+  "plan-ready": "Next: read the plan and approve it.",
+  exited: "Next: restart the agent or take the work over.",
+  working: "Next: let the agent finish its turn.",
+};
+
+export function templateLines(
+  state: TaskState,
+  evidence: EvidenceRef[]
+): {
+  lines: ReportLine[];
+  recommendation: { text: string; evidence: string[] } | null;
+} {
+  const lines: ReportLine[] = [];
+  const add = (tone: ReportLine["tone"], text: string, ev: EvidenceRef[]) =>
+    lines.push({
+      id: `l${lines.length + 1}`,
+      tone,
+      text,
+      evidence: ev.map((e) => e.id),
+    });
+  const of = (kind: EvidenceRef["kind"]) =>
+    evidence.filter((e) => e.kind === kind);
+
+  const ci = of("ci");
+  const ciPass = ci.filter((e) => e.status === "pass");
+  const ciFail = ci.filter((e) => e.status === "fail");
+  const ciWait = ci.filter((e) => e.status === "pending");
+  if (ciPass.length)
+    add(
+      "done",
+      `${ciPass.length} CI check${ciPass.length === 1 ? "" : "s"} passed.`,
+      ciPass
+    );
+  for (const e of ciFail) add("warn", `${e.label} is failing.`, [e]);
+  if (ciWait.length)
+    add(
+      "warn",
+      `${ciWait.length} CI check${ciWait.length === 1 ? " is" : "s are"} still running.`,
+      ciWait
+    );
+
+  for (const e of of("test"))
+    add(
+      e.status === "pass" ? "done" : e.status === "fail" ? "warn" : "next",
+      e.status === "pass"
+        ? `Tests passed: ${e.label}.`
+        : e.status === "fail"
+          ? `Tests failed: ${e.label}.`
+          : `Tests are running: ${e.label}.`,
+      [e]
+    );
+
+  for (const e of of("review"))
+    add(
+      e.status === "pass" ? "done" : e.status === "fail" ? "warn" : "next",
+      e.status === "pass"
+        ? "The independent review passed."
+        : e.status === "fail"
+          ? "The independent review found problems to fix."
+          : "The independent review has not finished.",
+      [e]
+    );
+
+  for (const e of of("piece"))
+    add(e.status === "pass" ? "done" : "next", `${e.label}.`, [e]);
+  for (const e of of("accept").filter((e) => e.status === "pass"))
+    add("done", `Verified: ${e.label}.`, [e]);
+  for (const e of of("ask")) add("blocked", `${e.label}.`, [e]);
+  for (const e of of("log")) add("done", `${e.label}.`, [e]);
+
+  const hasDiff = of("diff");
+  if (hasDiff.length)
+    add(
+      "done",
+      `${hasDiff.length} file${hasDiff.length === 1 ? "" : "s"} changed.`,
+      hasDiff.slice(0, 12)
+    );
+
+  const stateEv = of("state");
+  if (NEXT[state] && stateEv.length) add("next", NEXT[state]!, stateEv);
+
+  const bad = [...ciFail, ...of("test").filter((e) => e.status === "fail")];
+  const recommendation = bad.length
+    ? {
+        text: `Ask the agent to fix ${bad[0].label} first; everything else waits on it.`,
+        evidence: [bad[0].id],
+      }
+    : null;
+  return { lines, recommendation };
+}

package/lib/reports/types.ts

@@ -0,0 +1,135 @@
+// Plain-English health reports: types shared by the server, the browser and
+// the native app (no Node modules here).
+
+import type { TaskState } from "../tasks/state";
+
+export const OPERATING_MODES = ["manual", "assisted", "autonomous"] as const;
+export type OperatingMode = (typeof OPERATING_MODES)[number];
+export const isMode = (v: unknown): v is OperatingMode =>
+  typeof v === "string" && (OPERATING_MODES as readonly string[]).includes(v);
+
+export const MODE_COPY: Record<
+  OperatingMode,
+  { label: string; blurb: string }
+> = {
+  manual: {
+    label: "Manual",
+    blurb: "The analyst recommends, you decide.",
+  },
+  assisted: {
+    label: "Assisted",
+    blurb: "The analyst drafts the next prompt, you approve it with one click.",
+  },
+  autonomous: {
+    label: "Autonomous",
+    blurb: "Agents iterate on their own, within the loop's safeguards.",
+  },
+};
+
+export type ReportTrigger = "on-demand" | "cycle" | "end";
+export type LineTone = "done" | "warn" | "blocked" | "next";
+export type EvidenceKind =
+  | "ci"
+  | "test"
+  | "review"
+  | "diff"
+  | "piece"
+  | "accept"
+  | "ask"
+  | "state"
+  | "log";
+export type EvidenceStatus = "pass" | "fail" | "pending" | "info";
+
+export interface EvidenceRef {
+  id: string;
+  kind: EvidenceKind;
+  label: string;
+  status: EvidenceStatus;
+  at: string;
+  // The head it belongs to; stale when it differs from the current head.
+  sha?: string;
+  url?: string;
+  href?: string;
+  excerpt?: string;
+}
+
+export interface ReportLine {
+  id: string;
+  tone: LineTone;
+  text: string;
+  evidence: string[];
+}
+
+export interface EstimateItem {
+  label: string;
+  verified: boolean;
+  evidence: string[];
+}
+
+export interface Estimate {
+  done: number;
+  total: number;
+  basis: "acceptance" | "stages";
+  items: EstimateItem[];
+}
+
+export type DraftStatus = "pending" | "sent" | "dismissed" | "superseded";
+
+export interface NextPromptDraft {
+  // The report row that holds it, or the analyst recommendation.
+  source: "report" | "analyst";
+  id: string;
+  text: string;
+  status: DraftStatus;
+  // Analyst drafts send through the analyst link.
+  linkId?: string;
+}
+
+export interface HealthReport {
+  id: number;
+  sessionId: string;
+  workspaceId: string | null;
+  head: string | null;
+  trigger: ReportTrigger;
+  createdAt: string;
+  headline: string;
+  state: TaskState;
+  estimate: Estimate;
+  lines: ReportLine[];
+  recommendation: { text: string; evidence: string[] } | null;
+  draft: NextPromptDraft | null;
+  evidence: EvidenceRef[];
+  // "template": the model failed, or every line it wrote was rejected.
+  source: "model" | "template";
+  // Model lines the validator rejected.
+  dropped: number;
+  model: string | null;
+  costUsd: number | null;
+  // Computed on read: the head moved since.
+  stale: boolean;
+}
+
+export interface ReportSummary {
+  sessionId: string;
+  name: string;
+  headline: string;
+  state: TaskState;
+  estimate: Pick<Estimate, "done" | "total" | "basis">;
+  createdAt: string;
+}
+
+export interface ReportResponse {
+  report: HealthReport | null;
+  generating: boolean;
+  mode: { mode: OperatingMode; source: "task" | "workspace" | "default" };
+}
+
+export const estimateLabel = (e: Pick<Estimate, "done" | "total" | "basis">) =>
+  `Estimate · ${e.done} of ${e.total} ${
+    e.basis === "acceptance"
+      ? "acceptance items verified"
+      : "delivery stages reached"
+  }`;
+
+export const estimatePercent = (e: Pick<Estimate, "done" | "total">) =>
+  e.total ? Math.round((100 * e.done) / e.total) : 0;

package/lib/reports/validate.ts

@@ -0,0 +1,142 @@
+// What a model may say in a report. Every line must cite evidence that
+// exists, say only numbers that evidence contains, never use a percent sign,
+// and take a tone its evidence supports. What fails is dropped and counted.
+
+import type { EvidenceRef, LineTone, ReportLine } from "./types";
+import type { Mapping } from "./estimate";
+
+export interface ModelReport {
+  headline?: unknown;
+  lines?: unknown;
+  recommendation?: unknown;
+  acceptance?: unknown;
+  nextPrompt?: unknown;
+}
+
+export interface Validated {
+  headline: string | null;
+  lines: ReportLine[];
+  recommendation: { text: string; evidence: string[] } | null;
+  mappings: Mapping[];
+  nextPrompt: string | null;
+  dropped: number;
+}
+
+export const MAX_LINE = 280;
+export const MAX_LINES = 10;
+export const MAX_PROMPT = 4000;
+const TONES: LineTone[] = ["done", "warn", "blocked", "next"];
+
+const str = (v: unknown, max: number) =>
+  typeof v === "string" ? v.trim().slice(0, max) : "";
+const ids = (v: unknown): string[] =>
+  Array.isArray(v)
+    ? [...new Set(v.filter((x): x is string => typeof x === "string"))]
+    : [];
+
+// Digits in the text that none of the cited evidence contains.
+function inventedNumber(text: string, cited: EvidenceRef[]): boolean {
+  const nums = text.match(/\d+/g);
+  if (!nums) return false;
+  const haystack = cited
+    .map((e) => `${e.id} ${e.label} ${e.excerpt ?? ""} ${e.sha ?? ""}`)
+    .join("\n");
+  return nums.some((n) => !new RegExp(`(?<!\\d)${n}(?!\\d)`).test(haystack));
+}
+
+export function sayable(text: string, cited: EvidenceRef[]): boolean {
+  return (
+    !!text &&
+    text.length <= MAX_LINE &&
+    !/%/.test(text) &&
+    !inventedNumber(text, cited)
+  );
+}
+
+function toneFits(tone: LineTone, cited: EvidenceRef[]): boolean {
+  if (tone === "done") return cited.some((e) => e.status === "pass");
+  if (tone === "warn" || tone === "blocked")
+    return cited.some(
+      (e) => e.status === "fail" || e.status === "pending" || e.kind === "ask"
+    );
+  return true;
+}
+
+export function validateModelReport(
+  raw: unknown,
+  evidence: EvidenceRef[]
+): Validated {
+  const out: Validated = {
+    headline: null,
+    lines: [],
+    recommendation: null,
+    mappings: [],
+    nextPrompt: null,
+    dropped: 0,
+  };
+  if (!raw || typeof raw !== "object") return out;
+  const m = raw as ModelReport;
+  const byId = new Map(evidence.map((e) => [e.id, e]));
+  const resolve = (cites: string[]) => {
+    const found = cites.map((c) => byId.get(c));
+    return found.some((e) => !e) ? null : (found as EvidenceRef[]);
+  };
+
+  const headline = str(m.headline, MAX_LINE);
+  if (
+    headline &&
+    sayable(
+      headline,
+      evidence.filter((e) => e.kind === "state")
+    )
+  )
+    out.headline = headline;
+  else if (headline) out.dropped++;
+
+  const rawLines = Array.isArray(m.lines) ? m.lines.slice(0, 24) : [];
+  for (const l of rawLines) {
+    const o = (l ?? {}) as Record<string, unknown>;
+    const tone = o.tone as LineTone;
+    const text = str(o.text, MAX_LINE + 1);
+    const cites = ids(o.evidence);
+    const cited = cites.length ? resolve(cites) : null;
+    if (
+      !TONES.includes(tone) ||
+      !cited ||
+      !sayable(text, cited) ||
+      !toneFits(tone, cited) ||
+      out.lines.length >= MAX_LINES
+    ) {
+      out.dropped++;
+      continue;
+    }
+    out.lines.push({
+      id: `l${out.lines.length + 1}`,
+      tone,
+      text,
+      evidence: cites,
+    });
+  }
+
+  if (m.recommendation && typeof m.recommendation === "object") {
+    const r = m.recommendation as Record<string, unknown>;
+    const text = str(r.text, 600);
+    const cites = ids(r.evidence);
+    const cited = cites.length ? resolve(cites) : null;
+    if (text && cited && !/%/.test(text) && !inventedNumber(text, cited))
+      out.recommendation = { text, evidence: cites };
+    else out.dropped++;
+  }
+
+  if (Array.isArray(m.acceptance))
+    for (const a of m.acceptance.slice(0, 24)) {
+      const o = (a ?? {}) as Record<string, unknown>;
+      // The model sees items numbered from 1, as in "accept:1".
+      if (typeof o.item === "number" && Number.isInteger(o.item) && o.item >= 1)
+        out.mappings.push({ item: o.item - 1, evidence: ids(o.evidence) });
+    }
+
+  const prompt = str(m.nextPrompt, MAX_PROMPT);
+  if (prompt) out.nextPrompt = prompt;
+  return out;
+}

package/lib/session-artifacts/agentos-files.ts

@@ -0,0 +1,94 @@
+/**
+ * What a task saves under .agentos/mockups and .agentos/screenshots. Git
+ * ignores that folder (its .gitignore is `*`) and a Bash write isn't a
+ * file-writing tool call, so neither other source lists them.
+ */
+
+import fs from "fs";
+import path from "path";
+import { isSecretPath } from "../secret-paths";
+import { SCREENSHOT_DIR } from "../tasks/ui-brief";
+import { kindForPath, type Candidate } from "./derive";
+
+export const MOCKUP_DIR = ".agentos/mockups";
+export const AGENTOS_DIRS = [MOCKUP_DIR, SCREENSHOT_DIR];
+const MAX_DEPTH = 3;
+const MAX_LISTED = 200;
+
+const isAgentosFile = (rel: string) =>
+  AGENTOS_DIRS.some((d) => rel.startsWith(`${d}/`));
+
+function candidate(
+  worktree: string,
+  rel: string,
+  at: number
+): Candidate | null {
+  const file = path.join(worktree, rel);
+  if (isSecretPath(file)) return null;
+  return {
+    key: `file:${file}`,
+    kind: kindForPath(file),
+    name: path.basename(file),
+    at,
+    by: "shell",
+    source: { type: "file", path: file },
+  };
+}
+
+function walk(root: string, rel: string, depth: number, out: string[]): void {
+  if (out.length >= MAX_LISTED) return;
+  let names: fs.Dirent[];
+  try {
+    names = fs.readdirSync(path.join(root, rel), { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const d of names) {
+    const child = `${rel}/${d.name}`;
+    // Symlinks are skipped: they could point out of the worktree.
+    if (d.isFile()) out.push(child);
+    else if (d.isDirectory() && depth < MAX_DEPTH)
+      walk(root, child, depth + 1, out);
+  }
+}
+
+export function agentosFiles(worktree: string): { rel: string; at: number }[] {
+  const rels: string[] = [];
+  for (const dir of AGENTOS_DIRS) walk(worktree, dir, 1, rels);
+  return rels.slice(0, MAX_LISTED).flatMap((rel) => {
+    try {
+      return [{ rel, at: fs.statSync(path.join(worktree, rel)).mtimeMs }];
+    } catch {
+      return [];
+    }
+  });
+}
+
+export function fromAgentosDirs(
+  worktree: string,
+  known: Set<string>
+): Candidate[] {
+  return agentosFiles(worktree).flatMap(({ rel, at }) => {
+    const c = candidate(worktree, rel, at);
+    return c && !known.has(c.key) ? [c] : [];
+  });
+}
+
+// After the worktree is gone: the copies that were kept.
+export function fromKept(
+  worktree: string,
+  kept: string[],
+  at: number,
+  known: Set<string>
+): Candidate[] {
+  return kept.filter(isAgentosFile).flatMap((rel) => {
+    const c = candidate(worktree, rel, at);
+    return c && !known.has(c.key) ? [c] : [];
+  });
+}
+
+// Changes when a file is added, removed or rewritten there.
+export function agentosSignature(worktree: string): string {
+  const files = agentosFiles(worktree);
+  return `${files.length}:${files.reduce((m, f) => Math.max(m, f.at), 0)}`;
+}