@saadnvd1/agent-os 0.3.503 → 0.3.505

package/lib/session-logs/store.ts

@@ -0,0 +1,105 @@
+import { db } from "../db";
+
+// What the list and the orchestrator's tool show of a log without its text.
+export interface LogHeader {
+  id: string;
+  name: string;
+  workspace: string | null;
+  project: string | null;
+  branch: string | null;
+  prNumber: number | null;
+  prUrl: string | null;
+  mergeCommit: string | null;
+  startedAt: string | null;
+  mergedAt: string | null;
+  durationMs: number | null;
+  costUsd: number;
+  planKept: boolean;
+  hasPlan: boolean;
+  createdAt: string;
+  filePath: string | null;
+}
+
+export interface LogRow {
+  session_id: string;
+  project_id: string | null;
+  workspace_id: string | null;
+  created_at: string;
+  markdown: string;
+  data: string;
+  file_path: string | null;
+}
+
+export const hasLog = (sessionId: string): boolean =>
+  !!db
+    .prepare(`SELECT 1 FROM session_logs WHERE session_id = ?`)
+    .get(sessionId);
+
+export function getLog(sessionId: string): LogRow | null {
+  return (
+    (db
+      .prepare(`SELECT * FROM session_logs WHERE session_id = ?`)
+      .get(sessionId) as LogRow | undefined) ?? null
+  );
+}
+
+// True when this call stored it: a log already there is never replaced.
+export function insertLog(row: {
+  sessionId: string;
+  projectId: string | null;
+  workspaceId: string | null;
+  markdown: string;
+  header: Omit<LogHeader, "createdAt" | "filePath">;
+  filePath: string | null;
+}): boolean {
+  return (
+    db
+      .prepare(
+        `INSERT OR IGNORE INTO session_logs
+           (session_id, project_id, workspace_id, markdown, data, file_path)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        row.sessionId,
+        row.projectId,
+        row.workspaceId,
+        row.markdown,
+        JSON.stringify(row.header),
+        row.filePath
+      ).changes > 0
+  );
+}
+
+export function setFilePath(sessionId: string, filePath: string): void {
+  db.prepare(`UPDATE session_logs SET file_path = ? WHERE session_id = ?`).run(
+    filePath,
+    sessionId
+  );
+}
+
+const toHeader = (r: LogRow): LogHeader => ({
+  ...(JSON.parse(r.data) as LogHeader),
+  createdAt: r.created_at,
+  filePath: r.file_path,
+});
+
+export const headerOf = (r: LogRow): LogHeader => toHeader(r);
+
+// Newest merge first.
+export function listLogs(
+  where: { projectId?: string; workspaceId?: string },
+  limit = 50
+): LogHeader[] {
+  const rows = db
+    .prepare(
+      `SELECT * FROM session_logs
+       WHERE (@p IS NULL OR project_id = @p) AND (@w IS NULL OR workspace_id = @w)
+       ORDER BY json_extract(data, '$.mergedAt') DESC, created_at DESC LIMIT @n`
+    )
+    .all({
+      p: where.projectId ?? null,
+      w: where.workspaceId ?? null,
+      n: Math.max(1, Math.min(limit, 500)),
+    }) as LogRow[];
+  return rows.map(toHeader);
+}

package/lib/sidebar/live-status.ts

@@ -0,0 +1,52 @@
+import {
+  PR_STAGE_BUSY,
+  PR_STAGE_SHORT,
+  type PrStage,
+  type PrStageName,
+} from "../tasks/pr-stage";
+
+export type LiveTone = "blue" | "amber" | "red" | "green" | "purple" | "muted";
+
+export interface LivePart {
+  text: string;
+  tone: LiveTone;
+  // Still moving on its own: the UI shows a spinner.
+  busy?: boolean;
+}
+
+export const PR_STAGE_TONE: Record<PrStageName, LiveTone> = {
+  merged: "purple",
+  conflicts: "amber",
+  "ci-failed": "red",
+  "ci-running": "blue",
+  "ci-settling": "blue",
+  "review-running": "blue",
+  "review-blocked": "red",
+  waiting: "amber",
+  armed: "green",
+  open: "muted",
+};
+
+// What the row's second line says about the session right now, in order:
+// "Compacting", then "PR CI". Empty when there is nothing to say.
+export function liveParts(input: {
+  compacting?: boolean;
+  prStage?: PrStage;
+}): LivePart[] {
+  const parts: LivePart[] = [];
+  if (input.compacting)
+    parts.push({ text: "Compacting", tone: "blue", busy: true });
+  const s = input.prStage;
+  if (s) {
+    const word = PR_STAGE_SHORT[s.stage];
+    parts.push({
+      text: s.stage === "open" ? "PR" : `PR ${word}`,
+      tone: PR_STAGE_TONE[s.stage],
+      busy: PR_STAGE_BUSY.has(s.stage),
+    });
+  }
+  return parts;
+}
+
+export const liveText = (parts: LivePart[]) =>
+  parts.map((p) => p.text).join(" · ");

package/lib/tasks/finish.ts

@@ -23,6 +23,7 @@ import { getProject } from "../projects";
 import { canSignOff } from "./state";
 import { forgetPR, getTaskSession, prFor, projectPathFor } from "./session";
 import { dropSessionDatabase } from "../project-config/database";
+import { captureMergedTask } from "../session-logs";
 
 // Never deleted, whatever a setting says.
 export const PROTECTED_BRANCHES = new Set(["main", "master", "HEAD"]);
@@ -154,6 +155,8 @@ export async function signOffTask(
     signingOff.delete(id);
   }
   syncTaskCardInBackground(session, "merged", pr);
+  // Reads the plan file now: cleanup below removes the worktree.
+  void captureMergedTask(id, { head: opts.head ?? pr!.head ?? null });
   const head = opts.head ?? pr!.head;
   resolveMergedTaskAsks(
     id,

package/lib/tasks/pr-stage.ts

@@ -90,3 +90,17 @@ export const PR_STAGE_LABEL: Record<PrStageName, string> = {
 
 export const prStageText = (s: Pick<PrStage, "stage" | "number">) =>
   `PR #${s.number} · ${PR_STAGE_LABEL[s.stage]}`;
+
+// The short wording for the badge itself; the full wording is the tooltip.
+export const PR_STAGE_SHORT: Record<PrStageName, string> = {
+  merged: "Merged",
+  conflicts: "Conflicts",
+  "ci-failed": "CI failed",
+  "ci-running": "CI",
+  "ci-settling": "CI",
+  "review-running": "Review",
+  "review-blocked": "Blocked",
+  waiting: "Waiting on you",
+  armed: "Armed",
+  open: "PR",
+};

package/lib/tasks/session.ts

@@ -9,6 +9,7 @@ import { getProject } from "../projects";
 import { findPRStrict } from "./gh";
 import { currentBranch, git } from "../git-exec";
 import { lookupPR } from "./pr-poll";
+import { captureMergedTask } from "../session-logs";
 import { notifyStatusChanged } from "../status/hub";
 import type { TaskPR } from "./state";
 
@@ -185,6 +186,9 @@ export async function prFor(
     db.prepare(
       `UPDATE sessions SET pr_url = ?, pr_number = ?, pr_status = ? WHERE id = ?`
     ).run(pr.url, pr.number, pr.state.toLowerCase(), session.id);
+    // Merged on GitHub rather than through AgentOS: its log is due too.
+    if (pr.state === "MERGED")
+      void captureMergedTask(session.id, { head: pr.head });
   }
   // Only an answer just read from GitHub: a cached one may predate a
   // retarget AgentOS made itself (a restack).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.503",
+  "version": "0.3.505",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/scripts/backfill-session-logs.ts

@@ -0,0 +1,70 @@
+/**
+ * Writes session logs for tasks that merged before logs existed, from what
+ * the database still holds. Their plan files went with their worktrees, so
+ * each says "plan not kept". Idempotent: a task with a log is skipped.
+ *
+ *   npx tsx scripts/backfill-session-logs.ts --db <path to agent-os.db> [--no-gh] [--dry]
+ *
+ * --db is required so a run never lands on a database by accident. Files go
+ * where new logs go (~/.agent-os/session-logs, or a project's folder); run
+ * with HOME set elsewhere to keep a trial away from the real folder.
+ * --no-gh skips asking GitHub for each merge commit.
+ */
+
+const args = process.argv.slice(2);
+const flag = (name: string) => args.includes(name);
+const dbPath = args[args.indexOf("--db") + 1];
+
+if (!flag("--db") || !dbPath || dbPath.startsWith("--")) {
+  console.error(
+    "usage: backfill-session-logs.ts --db <path> [--no-gh] [--dry]"
+  );
+  process.exit(2);
+}
+process.env.DB_PATH = dbPath;
+
+async function main() {
+  const { db } = await import("../lib/db");
+  const { writeLog } = await import("../lib/session-logs");
+  const { hasLog } = await import("../lib/session-logs/store");
+  const rows = db
+    .prepare(
+      `SELECT id, name FROM sessions
+       WHERE task_prompt IS NOT NULL AND peer_mirror = 0
+         AND (task_status = 'merged' OR (pr_status = 'merged' AND task_status != 'dropped'))
+       ORDER BY COALESCE(merged_at, updated_at)`
+    )
+    .all() as { id: string; name: string }[];
+  const todo = rows.filter((r) => !hasLog(r.id));
+  console.log(
+    `${rows.length} merged tasks, ${rows.length - todo.length} already logged, ${todo.length} to write${flag("--dry") ? " (dry run)" : ""}`
+  );
+  let written = 0;
+  for (const r of todo) {
+    if (flag("--dry")) {
+      console.log(`  would log ${r.name} (${r.id.slice(0, 8)})`);
+      continue;
+    }
+    try {
+      const ok = await writeLog(r.id, {
+        planKept: false,
+        noGh: flag("--no-gh"),
+      });
+      if (ok) written++;
+      console.log(
+        `  ${ok ? "logged" : "skipped"} ${r.name} (${r.id.slice(0, 8)})`
+      );
+    } catch (error) {
+      console.error(`  FAILED ${r.name} (${r.id.slice(0, 8)}):`, error);
+    }
+  }
+  console.log(`wrote ${written} logs`);
+}
+
+main().then(
+  () => process.exit(0),
+  (error) => {
+    console.error(error);
+    process.exit(1);
+  }
+);