@saadnvd1/agent-os 0.3.506 → 0.3.507

package/lib/session-logs/build.ts

@@ -123,11 +123,17 @@ const usd = (x: number, floor: boolean) =>
 const url = (u: string) =>
   /^https?:\/\/[^\s<>()[\]`]+$/.test(u) ? `<${u}>` : codeSpan(u);
 
+// A commit hash is not a secret, so it skips redact(): only a plain hash
+// (or one the log labels as the PR head) is printed, anything else is not.
+const SHA = /^[0-9a-f]{7,40}( \(PR head\))?$/;
+export const commitText = (sha: string | null): string =>
+  sha && SHA.test(sha) ? `\`${sha}\`` : "unknown";
+
 function header(d: LogData): string {
   const start = sqliteMs(d.startedAt);
   const end = sqliteMs(d.mergedAt);
   const duration =
-    start !== null && end !== null ? formatDuration(end - start) : "unknown";
+    start !== null && end !== null ? formatDuration(end - start) : null;
   const rows: [string, string][] = [
     ["Task", `${codeSpan(d.name)} (${codeSpan(d.id)})`],
     ["Workspace", d.workspace ? codeSpan(d.workspace) : "none"],
@@ -139,10 +145,10 @@ function header(d: LogData): string {
         ? `#${d.prNumber}${d.prUrl ? ` ${url(d.prUrl)}` : ""}`
         : "none recorded",
     ],
-    ["Merge commit", d.mergeCommit ? codeSpan(d.mergeCommit) : "not recorded"],
+    ["Merge commit", commitText(d.mergeCommit)],
     ["Started", when(d.startedAt)],
-    ["Merged", when(d.mergedAt)],
-    ["Duration", duration],
+    ["Merged", d.mergedAt ? when(d.mergedAt) : "unknown"],
+    ...(duration ? [["Duration", duration] as [string, string]] : []),
   ];
   return rows.map(([k, v]) => `- **${k}:** ${v}`).join("\n");
 }

package/lib/session-logs/folder.ts

@@ -140,3 +140,8 @@ export function writeLogFileTo(
 
 export const writeLogFile = (t: FileTarget, markdown: string): string =>
   writeLogFileTo(t, markdown).file;
+
+// Rewrites a log's own file in place (never creates one, never moves it).
+export function overwriteLogFile(file: string, markdown: string): void {
+  if (fs.existsSync(file)) fs.writeFileSync(file, markdown, { mode: 0o600 });
+}

package/lib/session-logs/index.ts

@@ -14,10 +14,22 @@ import { db, type Session } from "../db";
 import { getProject } from "../projects";
 import { run } from "../tasks/gh";
 import { buildLogMarkdown, sqliteMs } from "./build";
-import { writeLogFileTo, type Destination } from "./folder";
+import {
+  overwriteLogFile,
+  destination,
+  writeLogFileTo,
+  type Destination,
+} from "./folder";
 import { commitLogs } from "./hq";
 import { gatherLogData, readPlanFile } from "./gather";
-import { hasLog, insertLog, setFilePath } from "./store";
+import {
+  getLog,
+  hasLog,
+  headerOf,
+  insertLog,
+  setFilePath,
+  updateLog,
+} from "./store";
 
 export * from "./store";
 export { buildLogMarkdown } from "./build";
@@ -43,6 +55,10 @@ export interface CaptureOpts {
   // Given, the file is handed over instead of committed: a batch commits
   // once at its end.
   onFile?: (file: string, hq: NonNullable<Destination["hq"]>) => void;
+  // Regenerate a log that exists: update its row and file in place.
+  rewrite?: boolean;
+  // With rewrite: report whether the log would change, write nothing.
+  dryRun?: boolean;
 }
 
 function eligible(s: Session | undefined): s is Session {
@@ -55,31 +71,51 @@ function eligible(s: Session | undefined): s is Session {
   );
 }
 
-async function mergeCommitOf(s: Session): Promise<string | null> {
+// GitHub's ISO time as SQLite's UTC "YYYY-MM-DD HH:MM:SS"; null when absent.
+export function ghTimeToSqlite(iso: unknown): string | null {
+  if (typeof iso !== "string") return null;
+  const ms = Date.parse(iso);
+  return Number.isNaN(ms)
+    ? null
+    : new Date(ms).toISOString().replace("T", " ").slice(0, 19);
+}
+
+async function mergeInfoOf(
+  s: Session
+): Promise<{ commit: string | null; mergedAt: string | null }> {
+  const none = { commit: null, mergedAt: 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;
+    return none;
   try {
     const out = await run(
       "gh",
-      [
-        "pr",
-        "view",
-        String(s.pr_number),
-        "--json",
-        "mergeCommit",
-        "-q",
-        ".mergeCommit.oid",
-      ],
+      ["pr", "view", String(s.pr_number), "--json", "mergeCommit,mergedAt"],
       project.working_directory.replace(/^~/, os.homedir()),
       15_000
     );
-    return out.trim() || null;
+    const j = JSON.parse(out) as {
+      mergeCommit?: { oid?: string } | null;
+      mergedAt?: string | null;
+    };
+    return {
+      commit: j.mergeCommit?.oid?.trim() || null,
+      mergedAt: ghTimeToSqlite(j.mergedAt),
+    };
   } catch {
-    return null;
+    return none;
   }
 }
 
+const planSection = (md: string) =>
+  /^## Plan\n[\s\S]*?(?=\n## Timeline\n)/m.exec(md)?.[0] ?? null;
+
+function keepPlan(fresh: string, old: string): string {
+  const was = planSection(old);
+  const now = planSection(fresh);
+  return was && now ? fresh.replace(now, () => was) : fresh;
+}
+
 export async function writeLog(
   id: string,
   opts: CaptureOpts & { plan?: string | null } = {}
@@ -87,20 +123,77 @@ export async function writeLog(
   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 existing = getLog(id);
+  if (!eligible(row) || (existing && !opts.rewrite)) return false;
+  const info = opts.noGh
+    ? { commit: null, mergedAt: null }
+    : await mergeInfoOf(row);
+  const mergeCommit = info.commit;
+  const s = { ...row, merged_at: row.merged_at ?? info.mergedAt };
+  const kept = existing ? headerOf(existing) : null;
   const data = gatherLogData(s, {
     plan: opts.plan ?? null,
-    planKept: opts.planKept ?? true,
+    planKept: kept ? kept.planKept : (opts.planKept ?? true),
     head: opts.head ?? null,
     mergeCommit: mergeCommit ?? (opts.head ? `${opts.head} (PR head)` : null),
   });
-  const markdown = buildLogMarkdown(data);
+  let markdown = buildLogMarkdown(data);
+  // The plan file went with the worktree: keep the plan the log has.
+  if (existing && kept?.hasPlan)
+    markdown = keepPlan(markdown, existing.markdown);
   const start = sqliteMs(data.startedAt);
   const end = sqliteMs(data.mergedAt);
   const workspaceId =
     s.workspace_id ?? getProject(s.project_id ?? "")?.workspace_id ?? null;
+  if (existing) {
+    const changed = existing.markdown !== markdown;
+    if (opts.dryRun || !changed) return changed;
+    // Only the generated text changes; the row, its id and its file stay.
+    updateLog(id, markdown, {
+      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: kept?.hasPlan ?? data.plan !== null,
+    });
+    if (existing.file_path) {
+      try {
+        overwriteLogFile(existing.file_path, markdown);
+        const { hq } = destination({
+          workspace: data.workspace,
+          workspaceId,
+          project: data.project,
+          projectId: s.project_id,
+          name: data.name,
+          id,
+          day: "",
+        });
+        if (hq && existing.file_path.startsWith(hq.dir)) {
+          if (opts.onFile) opts.onFile(existing.file_path, hq);
+          else
+            await commitLogs(
+              hq.dir,
+              [existing.file_path],
+              `session log rewritten: ${data.name.replace(/\s+/g, " ").trim().slice(0, 100)}`,
+              hq.visibility
+            );
+        }
+      } catch (error) {
+        console.error(`[session-logs] file for ${id}:`, error);
+      }
+    }
+    return true;
+  }
+  if (opts.dryRun) return true;
   const stored = insertLog({
     sessionId: id,
     projectId: s.project_id,

package/lib/session-logs/store.ts

@@ -70,6 +70,17 @@ export function insertLog(row: {
   );
 }
 
+// Replaces the text and header of a log that exists; the row stays.
+export function updateLog(
+  sessionId: string,
+  markdown: string,
+  header: Omit<LogHeader, "createdAt" | "filePath">
+): void {
+  db.prepare(
+    `UPDATE session_logs SET markdown = ?, data = ? WHERE session_id = ?`
+  ).run(markdown, JSON.stringify(header), sessionId);
+}
+
 export function setFilePath(sessionId: string, filePath: string): void {
   db.prepare(`UPDATE session_logs SET file_path = ? WHERE session_id = ?`).run(
     filePath,

package/package.json

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

package/scripts/backfill-session-logs.ts

@@ -1,18 +1,21 @@
 /**
  * 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.
+ * each says "plan not kept". Idempotent: a task with a log is skipped, unless --rewrite.
  *
- *   npx tsx scripts/backfill-session-logs.ts --db <path to agent-os.db> [--no-gh] [--dry] [--reexport]
+ *   npx tsx scripts/backfill-session-logs.ts --db <path to agent-os.db> [--no-gh] [--dry] [--dry-run] [--rewrite] [--reexport]
  *
  * --db is required so a run never lands on a database by accident. Files go
  * where new logs go: a project's folder, else the workspace's HQ repo (one
  * commit per HQ at the end of the run), else ~/.agent-os/session-logs; run
  * with HOME set elsewhere to keep a trial away from the real folder.
- * --no-gh skips asking GitHub for each merge commit.
+ * --no-gh skips asking GitHub for each merge commit and time.
  * --reexport writes the files of logs already in the database to where they
  * go now, from the stored markdown (no rebuild, no model), and writes no new
  * logs. Old files are left in place.
+ * --rewrite regenerates logs that exist (row and file updated in place, a
+ * kept plan stays); no model is called, only the one gh call per PR.
+ * --dry-run prints how many logs would be written or change, and writes none.
  */
 
 const args = process.argv.slice(2);
@@ -21,7 +24,7 @@ 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] [--reexport]"
+    "usage: backfill-session-logs.ts --db <path> [--no-gh] [--dry] [--dry-run] [--rewrite] [--reexport]"
   );
   process.exit(2);
 }
@@ -50,17 +53,15 @@ async function main() {
        ORDER BY COALESCE(merged_at, updated_at)`
     )
     .all() as { id: string; name: string }[];
-  const todo = rows.filter((r) => !hasLog(r.id));
+  const rewrite = flag("--rewrite");
+  const dry = flag("--dry") || flag("--dry-run");
+  const todo = rewrite ? rows : 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)" : ""}`
+    `${rows.length} merged tasks, ${rows.length - rows.filter((r) => !hasLog(r.id)).length} already logged, ${todo.length} to ${rewrite ? "regenerate" : "write"}${dry ? " (dry run)" : ""}`
   );
   let written = 0;
   const byHq = new Map<string, { files: string[]; visibility: Visibility }>();
   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,
@@ -73,10 +74,12 @@ async function main() {
           e.files.push(file);
           byHq.set(hq.dir, e);
         },
+        rewrite,
+        dryRun: dry,
       });
       if (ok) written++;
       console.log(
-        `  ${ok ? "logged" : "skipped"} ${r.name} (${r.id.slice(0, 8)})`
+        `  ${ok ? (dry ? "would change" : rewrite ? "rewrote" : "logged") : "skipped"} ${r.name} (${r.id.slice(0, 8)})`
       );
     } catch (error) {
       console.error(`  FAILED ${r.name} (${r.id.slice(0, 8)}):`, error);
@@ -89,7 +92,9 @@ async function main() {
       `session logs: ${files.length} backfilled`,
       visibility
     );
-  console.log(`wrote ${written} logs`);
+  console.log(
+    `${dry ? `${written} logs would change` : `wrote ${written} logs`}`
+  );
 }
 
 main().then(