@saadnvd1/agent-os 0.3.503 → 0.3.505

package/lib/session-logs/folder.ts

@@ -0,0 +1,145 @@
+/**
+ * Where a log's markdown file goes. By default
+ * ~/.agent-os/session-logs/<workspace>/<project>/YYYY-MM-DD-<task>.md; a
+ * project can name its own folder. Never inside the project's repository:
+ * repositories can be public, and a log holds briefs and reviews.
+ */
+
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { db } from "../db";
+import { slugify } from "../git";
+import { getProject, getProjectRepositories } from "../projects";
+
+// AGENTOS_SESSION_LOGS_DIR moves the default (tests keep it off the real one).
+export const DEFAULT_ROOT = () =>
+  process.env.AGENTOS_SESSION_LOGS_DIR ||
+  path.join(os.homedir(), ".agent-os", "session-logs");
+
+const key = (projectId: string) => `session-logs.folder.${projectId}`;
+
+const expand = (p: string) =>
+  p === "~" ? os.homedir() : p.replace(/^~(?=\/)/, os.homedir());
+
+// The path with symlinks resolved as far as it exists, so a link into a
+// repository is seen for what it is.
+function resolved(p: string): string {
+  let cur = path.resolve(p);
+  const rest: string[] = [];
+  while (!fs.existsSync(cur)) {
+    const up = path.dirname(cur);
+    if (up === cur) break;
+    rest.unshift(path.basename(cur));
+    cur = up;
+  }
+  return path.join(fs.realpathSync(cur), ...rest);
+}
+
+const within = (child: string, parent: string) => {
+  const rel = path.relative(parent, child);
+  return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+};
+
+function repoPaths(projectId: string): string[] {
+  const project = getProject(projectId);
+  if (!project) return [];
+  return [
+    project.working_directory,
+    ...getProjectRepositories(projectId).map((r) => r.path),
+  ]
+    .filter(Boolean)
+    .map((p) => resolved(expand(p)));
+}
+
+// Throws a plain message when `dir` is inside one of the project's repos.
+export function assertOutsideRepos(projectId: string, dir: string): void {
+  const target = resolved(dir);
+  const repo = repoPaths(projectId).find((r) => within(target, r));
+  if (repo)
+    throw new Error(
+      `${dir} is inside the project's repository (${repo}). Repositories can be public, so logs are never written into one: choose a folder outside it.`
+    );
+}
+
+export function logFolder(projectId: string): string | null {
+  const row = db
+    .prepare(`SELECT value FROM settings WHERE key = ?`)
+    .get(key(projectId)) as { value: string } | undefined;
+  return row?.value || null;
+}
+
+// Throws on a value that isn't an absolute or ~ path, or that points into
+// the project's repository. An empty value goes back to the default.
+export function setLogFolder(projectId: string, value: string | null): void {
+  const folder = value?.trim() ?? "";
+  if (!folder) {
+    db.prepare(`DELETE FROM settings WHERE key = ?`).run(key(projectId));
+    return;
+  }
+  if (!getProject(projectId)) throw new Error("Project not found");
+  if (!(folder === "~" || folder.startsWith("~/") || path.isAbsolute(folder)))
+    throw new Error(
+      `"${folder}" isn't an absolute path. Use a full path or one starting with ~/.`
+    );
+  assertOutsideRepos(projectId, expand(folder));
+  db.prepare(
+    `INSERT INTO settings (key, value) VALUES (?, ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+  ).run(key(projectId), folder);
+}
+
+export interface FileTarget {
+  workspace: string | null;
+  project: string | null;
+  projectId: string | null;
+  name: string;
+  id: string;
+  // YYYY-MM-DD
+  day: string;
+}
+
+// The folder this task's log goes into: the project's override when it
+// still passes the repository check, else the default.
+export function targetDir(t: FileTarget): string {
+  const custom = t.projectId ? logFolder(t.projectId) : null;
+  if (custom && t.projectId) {
+    try {
+      const dir = expand(custom);
+      assertOutsideRepos(t.projectId, dir);
+      return dir;
+    } catch (error) {
+      console.error(
+        `[session-logs] ignoring the project's log folder: ${error instanceof Error ? error.message : error}`
+      );
+    }
+  }
+  return path.join(
+    DEFAULT_ROOT(),
+    slugify(t.workspace ?? "") || "no-workspace",
+    slugify(t.project ?? "") || "no-project"
+  );
+}
+
+// Writes the log once and returns its path. A file that's already there
+// (another task, same name, same day) is never overwritten.
+export function writeLogFile(t: FileTarget, markdown: string): string {
+  const dir = targetDir(t);
+  if (t.projectId && !logFolder(t.projectId))
+    assertOutsideRepos(t.projectId, dir);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const slug = slugify(t.name) || t.id.slice(0, 8);
+  for (const file of [
+    `${t.day}-${slug}.md`,
+    `${t.day}-${slug}-${t.id.slice(0, 8)}.md`,
+  ]) {
+    const full = path.join(dir, file);
+    try {
+      fs.writeFileSync(full, markdown, { flag: "wx", mode: 0o600 });
+      return full;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+    }
+  }
+  throw new Error(`a log file for ${t.name} already exists in ${dir}`);
+}

package/lib/session-logs/gather.ts

@@ -0,0 +1,301 @@
+/**
+ * Everything a merged task's log says, read from what AgentOS already
+ * stores: the session row, the brief and its amendments, the independent
+ * review and CI records, the asks raised about it, the usage ledger and the
+ * task agent's last message. Nothing here is computed again or sent to a
+ * model.
+ */
+
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { db, type Session } from "../db";
+import { itemsOfKind } from "../chat/store";
+import { effectiveModels } from "../models/config";
+import { ANTHROPIC } from "../models/roles";
+import { getProject } from "../projects";
+import { getWorkspace } from "../workspaces";
+import { amendmentsOf } from "../orchestrator/amendments";
+import { PLAN_FILE } from "../models/plan-step";
+import { estimateCost, rowModel } from "../usage/cost";
+import { sessionLink } from "../session-url";
+import type { LogData, LogEvent, LogUsageRow } from "./build";
+
+const expandHome = (p: string) => p.replace(/^~/, os.homedir());
+
+// The task's plan file, read while its worktree still exists. null: none.
+const MAX_PLAN_BYTES = 256 * 1024;
+export function readPlanFile(worktreePath: string | null): string | null {
+  if (!worktreePath) return null;
+  try {
+    const file = path.join(expandHome(worktreePath), PLAN_FILE);
+    const stat = fs.statSync(file);
+    if (!stat.isFile() || stat.size > MAX_PLAN_BYTES) return null;
+    const text = fs.readFileSync(file, "utf8");
+    return text.trim() ? text : null;
+  } catch {
+    return null;
+  }
+}
+
+interface CheckRow {
+  sha: string;
+  kind: string;
+  status: string;
+  detail: string | null;
+  created_at: string;
+}
+
+const REVIEW_WORD: Record<string, string> = {
+  pass: "Review passed",
+  block: "Review blocked the merge",
+  error: "Review could not run",
+  running: "Review started",
+};
+const SCOPE_WORD: Record<string, string> = {
+  pass: "Scope check passed",
+  block: "Scope check blocked the merge",
+  error: "Scope check could not run",
+  running: "Scope check started",
+};
+
+function checkEvents(id: string, merged: string | null): LogEvent[] {
+  const rows = db
+    .prepare(
+      `SELECT sha, kind, status, detail, created_at FROM orchestrator_checks
+       WHERE session_id = ? ORDER BY created_at, id`
+    )
+    .all(id) as CheckRow[];
+  return rows.flatMap((c): LogEvent[] => {
+    if (c.kind === "ci")
+      // The settle record exists for every head that had checks; only the
+      // head that merged is known to have been green.
+      return c.sha === merged
+        ? [{ at: c.created_at, text: "CI green", sha: c.sha }]
+        : [];
+    const word = (c.kind === "review" ? REVIEW_WORD : SCOPE_WORD)[c.status];
+    if (!word) return [];
+    return [
+      {
+        at: c.created_at,
+        text: word,
+        sha: c.sha,
+        detail: c.status === "running" ? null : c.detail,
+      },
+    ];
+  });
+}
+
+const GATE_WORD: Record<string, string> = {
+  ci: "CI failed",
+  review: "Review gate failed",
+  "code-review": "Code-review gate failed",
+  scope: "Scope gate failed",
+  blocked: "Blocked gate failed",
+  stack: "Stack gate failed",
+};
+
+// The failure text names its failing check inside an untrusted fence;
+// the fence tags carry no information here.
+const unfence = (s: string) => s.replace(/<\/?untrusted[^>]*>/g, "");
+
+function failureEvents(id: string): LogEvent[] {
+  const rows = db
+    .prepare(
+      `SELECT gate, sha, reason, created_at FROM orchestrator_gate_failure_commits
+       WHERE session_id = ? ORDER BY created_at`
+    )
+    .all(id) as {
+    gate: string;
+    sha: string;
+    reason: string | null;
+    created_at: string;
+  }[];
+  return rows.map((r) => {
+    const conflict = /conflict/i.test(r.reason ?? "");
+    const failing =
+      r.gate === "ci" ? /\(([^)]+)\)\s*$/.exec(unfence(r.reason ?? "")) : null;
+    return {
+      at: r.created_at,
+      text: conflict
+        ? "Merge conflict held the gates"
+        : (GATE_WORD[r.gate] ?? `Gate ${r.gate} failed`),
+      sha: r.sha,
+      quote: failing ? `failing check: ${failing[1]}` : null,
+      detail: failing || !r.reason ? null : unfence(r.reason),
+    };
+  });
+}
+
+function askEvents(id: string): LogEvent[] {
+  const rows = db
+    .prepare(
+      `SELECT kind, title, detail, status, answer, created_at, resolved_at, sha
+       FROM orchestrator_asks WHERE subject = ? ORDER BY id`
+    )
+    .all(`task:${id}`) as {
+    kind: string;
+    title: string;
+    detail: string;
+    status: string;
+    answer: string | null;
+    created_at: string;
+    resolved_at: string | null;
+    sha: string | null;
+  }[];
+  return rows.flatMap((a): LogEvent[] => {
+    const raised: LogEvent = {
+      at: a.created_at,
+      text: `Escalated to Saad (${a.kind})`,
+      sha: a.sha,
+      quote: a.title,
+      detail: a.detail || null,
+    };
+    if (!a.resolved_at) return [raised];
+    return [
+      raised,
+      {
+        at: a.resolved_at,
+        text: `Saad ${a.status === "approved" ? "approved" : a.status === "declined" ? "declined" : "answered"}`,
+        sha: a.sha,
+        quote: a.title,
+        detail: a.answer,
+      },
+    ];
+  });
+}
+
+function rebaseEvents(s: Session): LogEvent[] {
+  if (!s.rebased_from || !s.rebased_to) return [];
+  return [
+    {
+      at: null,
+      text: `Last automatic rebase moved the branch from ${s.rebased_from.slice(0, 7)} to ${s.rebased_to.slice(0, 7)}`,
+    },
+  ];
+}
+
+export function usageRows(id: string): LogUsageRow[] {
+  const calls = db
+    .prepare(
+      `SELECT role, model, provider, COUNT(*) AS turns,
+         SUM(input_tokens) AS input_tokens,
+         SUM(output_tokens) AS output_tokens,
+         SUM(cache_read_tokens) AS cache_read_tokens,
+         SUM(cache_write_5m_tokens + cache_write_1h_tokens) AS cache_write_tokens
+       FROM usage_calls WHERE task_id = ? GROUP BY role, model, provider`
+    )
+    .all(id) as {
+    role: string | null;
+    model: string | null;
+    provider: string | null;
+    turns: number;
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_tokens: number;
+    cache_write_tokens: number;
+  }[];
+  const { prices } = effectiveModels();
+  const label = (role: string | null) =>
+    role?.startsWith("gate-") ? role.slice(5) : (role ?? "unrecorded");
+  const rows = calls.map((c): LogUsageRow => {
+    const priced = {
+      provider: c.provider ?? ANTHROPIC,
+      model: c.model,
+      cost_usd: 0,
+      input_tokens: c.input_tokens,
+      output_tokens: c.output_tokens,
+      cache_read_tokens: c.cache_read_tokens,
+      cache_write_tokens: c.cache_write_tokens,
+    };
+    const cost = estimateCost(priced, prices);
+    const m = rowModel(priced);
+    return {
+      role: label(c.role),
+      model: `${m.provider}/${m.model}`,
+      turns: c.turns,
+      inputTokens: c.input_tokens,
+      outputTokens: c.output_tokens,
+      cacheReadTokens: c.cache_read_tokens,
+      cacheWriteTokens: c.cache_write_tokens,
+      costUsd: cost.usd,
+      unpriced: !cost.priced,
+    };
+  });
+  const order = ["plan", "implement", "review", "scope"];
+  const rank = (r: string) =>
+    order.indexOf(r) === -1 ? order.length : order.indexOf(r);
+  return rows.sort(
+    (a, b) => rank(a.role) - rank(b.role) || b.costUsd - a.costUsd
+  );
+}
+
+// The last thing the task's agent said, verbatim. A terminal task keeps no
+// conversation, so it has none.
+export function finalMessage(id: string): string | null {
+  const said = itemsOfKind(id, "assistant").filter((i) => i.text.trim());
+  return said.at(-1)?.text ?? null;
+}
+
+export interface GatherOpts {
+  // The plan file's text when it was read before the worktree went; undefined
+  // when nobody could (the backfill), which a log says.
+  plan?: string | null;
+  planKept?: boolean;
+  // The PR's head when it merged, and the commit the merge made.
+  head?: string | null;
+  mergeCommit?: string | null;
+}
+
+export function gatherLogData(s: Session, opts: GatherOpts = {}): LogData {
+  const project = s.project_id ? getProject(s.project_id) : undefined;
+  const workspaceId = s.workspace_id ?? project?.workspace_id ?? null;
+  const workspace = workspaceId ? getWorkspace(workspaceId) : null;
+  const amendments = amendmentsOf(s.id);
+  const mergedAt = s.merged_at ?? null;
+  const head = opts.head ?? null;
+  const events: LogEvent[] = [
+    ...(s.pr_number
+      ? [{ at: null, text: `PR #${s.pr_number} opened` } as LogEvent]
+      : []),
+    ...failureEvents(s.id),
+    ...checkEvents(s.id, head),
+    ...askEvents(s.id),
+  ];
+  // Dated events in time order (a stable sort keeps same-second ones as
+  // recorded); the undated ones bracket them: the PR opening first, the
+  // rebase before the merge.
+  const dated = events
+    .filter((e) => e.at)
+    .sort((a, b) => (a.at as string).localeCompare(b.at as string));
+  const opened = events.filter((e) => !e.at);
+  const timeline = [
+    ...opened,
+    ...dated,
+    ...rebaseEvents(s),
+    {
+      at: mergedAt,
+      text: `PR${s.pr_number ? ` #${s.pr_number}` : ""} merged`,
+    },
+  ];
+  return {
+    id: s.id,
+    name: s.name,
+    workspace: workspace?.name ?? null,
+    project: project?.name ?? null,
+    branch: s.branch_name,
+    prNumber: s.pr_number,
+    prUrl: s.pr_url,
+    mergeCommit: opts.mergeCommit ?? null,
+    startedAt: s.created_at,
+    mergedAt,
+    prompt: s.task_prompt ?? "",
+    scopeChanges: amendments.map((a) => ({ at: a.created_at, text: a.text })),
+    plan: opts.plan ?? null,
+    planKept: opts.planKept ?? true,
+    timeline,
+    usage: usageRows(s.id),
+    outcome: finalMessage(s.id),
+    sessionPath: sessionLink("", s.id),
+  };
+}

package/lib/session-logs/index.ts

@@ -0,0 +1,178 @@
+/**
+ * Session logs: when a task merges, AgentOS writes a log of it from data it
+ * already holds. It costs no model tokens, on purpose: nothing in this
+ * folder may call a model (a test holds it to that).
+ *
+ * captureMergedTask is called from every place a task becomes merged
+ * (sign-off, done, a merge seen on GitHub). It reads the plan file at once,
+ * because cleanup removes the worktree, then does the rest in the
+ * background. It runs once per task and never throws into the merge.
+ */
+
+import os from "os";
+import { db, type Session } from "../db";
+import { getProject } from "../projects";
+import { run } from "../tasks/gh";
+import { buildLogMarkdown, sqliteMs } from "./build";
+import { writeLogFile } from "./folder";
+import { gatherLogData, readPlanFile } from "./gather";
+import { hasLog, insertLog, setFilePath } from "./store";
+
+export * from "./store";
+export { buildLogMarkdown } from "./build";
+export { logFolder, setLogFolder } from "./folder";
+
+const inFlight = new Map<string, Promise<void>>();
+// Tasks known to have a log, so a poll that sees a merged PR again asks
+// nothing of the database.
+const done = new Set<string>();
+
+const sqliteNow = () => new Date().toISOString().replace("T", " ").slice(0, 19);
+
+export interface CaptureOpts {
+  // The PR's head at the merge, when the caller knows it.
+  head?: string | null;
+  // The plan, when it was read already; else the worktree is read now.
+  plan?: string | null;
+  // A log written after the worktree went (the backfill).
+  planKept?: boolean;
+  // Skip asking GitHub for the merge commit (a batch of old tasks).
+  noGh?: boolean;
+}
+
+function eligible(s: Session | undefined): s is Session {
+  return (
+    !!s &&
+    !!s.task_prompt &&
+    !s.peer_mirror &&
+    s.task_status !== "dropped" &&
+    (s.task_status === "merged" || s.pr_status === "merged")
+  );
+}
+
+async function mergeCommitOf(s: Session): Promise<string | null> {
+  const project = s.project_id ? getProject(s.project_id) : undefined;
+  if (!project || !s.pr_number || process.env.AGENTOS_SESSION_LOGS_NO_GH)
+    return null;
+  try {
+    const out = await run(
+      "gh",
+      [
+        "pr",
+        "view",
+        String(s.pr_number),
+        "--json",
+        "mergeCommit",
+        "-q",
+        ".mergeCommit.oid",
+      ],
+      project.working_directory.replace(/^~/, os.homedir()),
+      15_000
+    );
+    return out.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+export async function writeLog(
+  id: string,
+  opts: CaptureOpts & { plan?: string | null } = {}
+): Promise<boolean> {
+  const row = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+    | Session
+    | undefined;
+  if (!eligible(row) || hasLog(id)) return false;
+  const s = { ...row, merged_at: row.merged_at ?? sqliteNow() };
+  const mergeCommit = opts.noGh ? null : await mergeCommitOf(s);
+  const data = gatherLogData(s, {
+    plan: opts.plan ?? null,
+    planKept: opts.planKept ?? true,
+    head: opts.head ?? null,
+    mergeCommit: mergeCommit ?? (opts.head ? `${opts.head} (PR head)` : null),
+  });
+  const markdown = buildLogMarkdown(data);
+  const start = sqliteMs(data.startedAt);
+  const end = sqliteMs(data.mergedAt);
+  const stored = insertLog({
+    sessionId: id,
+    projectId: s.project_id,
+    workspaceId:
+      s.workspace_id ?? getProject(s.project_id ?? "")?.workspace_id ?? null,
+    markdown,
+    header: {
+      id,
+      name: data.name,
+      workspace: data.workspace,
+      project: data.project,
+      branch: data.branch,
+      prNumber: data.prNumber,
+      prUrl: data.prUrl,
+      mergeCommit: data.mergeCommit,
+      startedAt: data.startedAt,
+      mergedAt: data.mergedAt,
+      durationMs: start !== null && end !== null ? end - start : null,
+      costUsd: data.usage.reduce((t, u) => t + u.costUsd, 0),
+      planKept: data.planKept,
+      hasPlan: data.plan !== null,
+    },
+    filePath: null,
+  });
+  if (!stored) return false;
+  try {
+    const file = writeLogFile(
+      {
+        workspace: data.workspace,
+        project: data.project,
+        projectId: s.project_id,
+        name: data.name,
+        id,
+        day: (data.mergedAt ?? sqliteNow()).slice(0, 10),
+      },
+      markdown
+    );
+    setFilePath(id, file);
+  } catch (error) {
+    // The database holds the log; the file is a copy.
+    console.error(`[session-logs] file for ${id}:`, error);
+  }
+  return true;
+}
+
+export function captureMergedTask(
+  id: string,
+  opts: CaptureOpts = {}
+): Promise<void> {
+  if (done.has(id)) return Promise.resolve();
+  const running = inFlight.get(id);
+  if (running) return running;
+  let plan: string | null | undefined = opts.plan;
+  try {
+    if (plan === undefined) {
+      const row = db
+        .prepare(`SELECT worktree_path FROM sessions WHERE id = ?`)
+        .get(id) as { worktree_path: string | null } | undefined;
+      plan = readPlanFile(row?.worktree_path ?? null);
+    }
+  } catch (error) {
+    console.error(`[session-logs] plan for ${id}:`, error);
+  }
+  const job = (async () => {
+    // After the caller's own work: the merge never waits on this.
+    await new Promise<void>((r) => setImmediate(r));
+    try {
+      await writeLog(id, { ...opts, plan });
+      if (hasLog(id)) done.add(id);
+    } catch (error) {
+      console.error(`[session-logs] ${id}:`, error);
+    }
+  })().finally(() => inFlight.delete(id));
+  inFlight.set(id, job);
+  return job;
+}
+
+// Tests start from nothing.
+export function resetSessionLogState(): void {
+  done.clear();
+  inFlight.clear();
+}