@saadnvd1/agent-os 0.3.509 → 0.3.512

package/lib/tasks/loop-types.ts

@@ -0,0 +1,202 @@
+/**
+ * The shapes the building-loop endpoints answer with (start options, a
+ * task's diff, its checks and review verdict, its plan), plus their caps.
+ * Pure data, no imports, so the native app can sync this file on its own.
+ * Every string that came from a log, a review or a plan is untrusted text
+ * to display, never to run.
+ */
+
+export const DIFF_MAX_FILES = 300;
+export const DIFF_PATCH_MAX_BYTES = 200_000;
+export const CHECK_LOG_MAX_BYTES = 8_000;
+export const CHECK_LOGS_MAX = 3;
+export const REVIEW_DETAIL_MAX = 20_000;
+export const REVIEW_FINDINGS_MAX = 50;
+export const PLAN_TEXT_MAX = 4_000;
+
+// -- Start options ---------------------------------------------------------
+
+export interface StartAgent {
+  value: string;
+  label: string;
+  // On this machine; null when the project runs on another machine.
+  installed: boolean | null;
+  auth: string | null;
+  hint: string | null;
+  models: { value: string; label: string }[];
+  defaultModel: string;
+}
+
+export interface StartHost {
+  id: string;
+  name: string;
+  linked: boolean;
+  // Why a project here can't go to this machine, when it can't.
+  unavailable: string | null;
+}
+
+export interface TaskModelChoice {
+  ref: string;
+  label: string;
+  provider: string;
+}
+
+export interface StartOptions {
+  project: {
+    id: string;
+    name: string;
+    agentType: string;
+    defaultModel: string;
+    hostId: string;
+  } | null;
+  agents: StartAgent[];
+  // "provider/model" refs a task can run on, and the role defaults.
+  taskModels: TaskModelChoice[];
+  roles: { plan: string; implement: string };
+  planDefault: boolean;
+  planError: string | null;
+  hosts: StartHost[];
+  git: {
+    isGitRepo: boolean;
+    defaultBranch: string | null;
+    currentBranch: string | null;
+    branches: string[];
+  } | null;
+}
+
+// -- A task's whole change -------------------------------------------------
+
+export interface TaskDiffFile {
+  path: string;
+  // git's letters: A added, M modified, D deleted, R renamed, C copied,
+  // T type changed.
+  status: string;
+  // null for a binary file.
+  additions: number | null;
+  deletions: number | null;
+  binary: boolean;
+}
+
+export interface TaskDiffList {
+  source: "worktree" | "pr";
+  base: string;
+  head: string;
+  files: TaskDiffFile[];
+  totalFiles: number;
+  additions: number;
+  deletions: number;
+  truncated: boolean;
+}
+
+export interface TaskDiffPatch {
+  source: "worktree" | "pr";
+  path: string;
+  patch: string | null;
+  truncated: boolean;
+  // No patch to show: binary, or too big for git or GitHub to give.
+  tooLarge: boolean;
+}
+
+// -- Checks and the review verdict ----------------------------------------
+
+export type CheckState =
+  | "pass"
+  | "fail"
+  | "pending"
+  | "skipped"
+  | "cancelled"
+  | "neutral";
+
+export interface TaskCheck {
+  name: string;
+  workflow: string | null;
+  state: CheckState;
+  conclusion: string | null;
+  url: string | null;
+  startedAt: string | null;
+  completedAt: string | null;
+  durationSec: number | null;
+  // The failed step's log around its error, for a failing Actions job.
+  log?: { step: string | null; tail: string; truncated: boolean };
+}
+
+export interface ReviewFinding {
+  severity: string;
+  file: string | null;
+  line: number | null;
+  summary: string;
+}
+
+export interface TaskReviewVerdict {
+  sha: string;
+  status: "running" | "pass" | "block" | "error";
+  summary: string;
+  findings: ReviewFinding[];
+  at: string;
+  truncated: boolean;
+}
+
+export interface TaskChecks {
+  pr: {
+    number: number;
+    url: string;
+    state: string;
+    head: string | null;
+  } | null;
+  checks: TaskCheck[];
+  review: TaskReviewVerdict | null;
+}
+
+// -- A task's plan ---------------------------------------------------------
+
+export interface TaskPlan {
+  // As the starter decided (null reason when unstated).
+  planned: boolean;
+  reason: string | null;
+  // null: no plan document yet.
+  status: "writing" | "ready" | "approved" | null;
+  source: "step" | "chat" | null;
+  title: string | null;
+  // Relative to the task's worktree.
+  path: string | null;
+  text: string | null;
+  truncated: boolean;
+}
+
+// Splits a stored review detail (lib/orchestrator/review-prompt.ts writes
+// "summary" then "- [severity] file:line: text" lines) back into a summary and
+// findings. A line that isn't a finding stays in the summary.
+const FINDING = /^- \[([^\]\n]{1,40})\](?: ([^\s:]+)(?::(\d+))?)?: (.*)$/;
+
+export function parseReviewDetail(detail: string | null | undefined): {
+  summary: string;
+  findings: ReviewFinding[];
+  truncated: boolean;
+} {
+  let truncated = false;
+  let text = detail ?? "";
+  if (text.length > REVIEW_DETAIL_MAX) {
+    text = text.slice(0, REVIEW_DETAIL_MAX);
+    truncated = true;
+  }
+  const summary: string[] = [];
+  const findings: ReviewFinding[] = [];
+  for (const line of text.split("\n")) {
+    const m = FINDING.exec(line);
+    if (!m) {
+      summary.push(line);
+      continue;
+    }
+    if (findings.length >= REVIEW_FINDINGS_MAX) {
+      truncated = true;
+      continue;
+    }
+    findings.push({
+      severity: m[1],
+      file: m[2] ?? null,
+      line: m[3] ? Number(m[3]) : null,
+      summary: m[4],
+    });
+  }
+  return { summary: summary.join("\n").trim(), findings, truncated };
+}

package/lib/tasks/plan-view.ts

@@ -0,0 +1,127 @@
+/**
+ * A task's plan as the list shows it: whether one is being written, waits for
+ * a decision, or was approved, with its title and a capped piece of text.
+ * Two sources: a chat in plan mode proposes one (a "plan" item, carried out
+ * when approved), and the plan step writes one to a file in the worktree.
+ */
+
+import fs from "fs";
+import path from "path";
+import { db, type Session } from "../db";
+import { PLAN_FILE, planSummary } from "../models/plan-step";
+import { PLAN_TEXT_MAX, type TaskPlan } from "./loop-types";
+import { expandHome } from "./session";
+
+const TITLE_MAX = 120;
+
+export function planTitle(text: string): string | null {
+  const heading = /^#{1,6}\s+(.+)$/m.exec(text)?.[1]?.trim();
+  const title = heading ?? planSummary(text, 1)[0] ?? null;
+  if (!title) return null;
+  return title.length > TITLE_MAX ? `${title.slice(0, TITLE_MAX - 1)}…` : title;
+}
+
+function chatPlan(
+  sessionId: string
+): { text: string; carried: boolean } | null {
+  const row = db
+    .prepare(
+      `SELECT data FROM chat_items WHERE session_id = ?
+         AND json_extract(data, '$.kind') = 'plan' ORDER BY seq DESC LIMIT 1`
+    )
+    .get(sessionId) as { data: string } | undefined;
+  if (!row) return null;
+  try {
+    const item = JSON.parse(row.data) as { plan?: unknown; carried?: boolean };
+    return typeof item.plan === "string"
+      ? { text: item.plan, carried: !!item.carried }
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+// Only the first `max` bytes, not the whole file.
+function readHead(file: string, max: number): string | null {
+  let fd: number | undefined;
+  try {
+    fd = fs.openSync(file, "r");
+    const buf = Buffer.alloc(max + 1);
+    const n = fs.readSync(fd, buf, 0, max + 1, 0);
+    return buf.subarray(0, n).toString("utf8");
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) fs.closeSync(fd);
+  }
+}
+
+function capped(text: string) {
+  const over = text.length > PLAN_TEXT_MAX;
+  return { text: over ? text.slice(0, PLAN_TEXT_MAX) : text, truncated: over };
+}
+
+export function taskPlan(session: Session): TaskPlan | null {
+  const decided = session.plan_decided ?? null;
+  const phase = session.plan_phase ?? null;
+  // Only a chat in plan mode is asked: listing tasks must stay cheap.
+  const maybeChat = !!session.chat_plan;
+  if (decided === null && !phase && !maybeChat) return null;
+
+  const base = {
+    planned: decided === null ? false : !!decided,
+    reason: session.plan_reason ?? null,
+  };
+  const none = {
+    ...base,
+    status: null,
+    source: null,
+    title: null,
+    path: null,
+    text: null,
+    truncated: false,
+  } satisfies TaskPlan;
+
+  const chat = maybeChat ? chatPlan(session.id) : null;
+  if (chat && !chat.carried)
+    return {
+      ...base,
+      planned: true,
+      status: "ready",
+      source: "chat",
+      title: planTitle(chat.text),
+      path: null,
+      ...capped(chat.text),
+    };
+
+  if (phase && session.worktree_path) {
+    const file = path.join(expandHome(session.worktree_path), PLAN_FILE);
+    const text = readHead(file, PLAN_TEXT_MAX);
+    if (text !== null || phase === "planning") {
+      const body = text ?? "";
+      return {
+        ...base,
+        planned: true,
+        status: phase === "planning" ? "writing" : "approved",
+        source: "step",
+        title: planTitle(body),
+        path: text !== null ? PLAN_FILE : null,
+        ...capped(body),
+      };
+    }
+  }
+
+  if (chat)
+    return {
+      ...base,
+      planned: true,
+      status: "approved",
+      source: "chat",
+      title: planTitle(chat.text),
+      path: null,
+      ...capped(chat.text),
+    };
+
+  if (decided === null) return null;
+  return none;
+}

package/lib/tasks/session.ts

@@ -1,6 +1,12 @@
 import fs from "fs";
 import os from "os";
-import { db, queries, stackQueries, type Session } from "../db";
+import {
+  db,
+  queries,
+  sessionListColumns,
+  stackQueries,
+  type Session,
+} from "../db";
 import { getDefaultBranch, isBranchName } from "../git";
 import { parentBranchOf } from "../stacks/guard";
 import { voidApprovalsOn } from "../orchestrator/ask-approvals";
@@ -15,10 +21,14 @@ import type { TaskPR } from "./state";
 
 export const expandHome = (p: string) => p.replace(/^~/, os.homedir());
 
-export function taskSessions(): Session[] {
+// Without the brief and system prompt: a list doesn't need them.
+export function taskSessions(includeArchived = true): Session[] {
   return db
     .prepare(
-      `SELECT * FROM sessions WHERE task_status IS NOT NULL AND task_status != 'moved' ORDER BY created_at DESC`
+      `SELECT ${sessionListColumns(db)} FROM sessions
+         WHERE task_status IS NOT NULL AND task_status != 'moved'
+           ${includeArchived ? "" : "AND archived_at IS NULL"}
+         ORDER BY created_at DESC`
     )
     .all() as Session[];
 }
@@ -37,7 +47,7 @@ export function projectPathFor(session: Session): string | null {
 
 // The task's worktree, when it's here to look at: null when it's gone or on
 // another host.
-function localWorktree(session: Session): string | null {
+export function localWorktree(session: Session): string | null {
   if (!session.worktree_path) return null;
   if (session.host_id && session.host_id !== "local") return null;
   const dir = expandHome(session.worktree_path);

package/package.json

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