@saadnvd1/agent-os 0.3.533 → 0.3.535

package/lib/plans/features.ts

@@ -0,0 +1,200 @@
+// A plan that split into pieces: the feature, its pieces, and the one-time
+// checks that turn a plan file into rows. A one-piece plan makes none.
+
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { randomUUID } from "crypto";
+import { db, type Session } from "../db";
+import { loadProjectConfig } from "../project-config";
+import {
+  applyEdits,
+  checkPieces,
+  parseEdits,
+  type CheckContext,
+  type PiecesResult,
+  type Piece,
+  type ProjectRef,
+} from "./pieces";
+
+export type PieceStatus =
+  | "waiting"
+  | "building"
+  | "merged"
+  | "blocked"
+  | "dropped";
+
+export interface Feature {
+  id: string;
+  workspace_id: string;
+  name: string;
+  plan_session_id: string;
+  plan_text: string;
+  status: "building" | "done" | "dropped";
+  done_at: string | null;
+  cost_usd: number | null;
+  duration_ms: number | null;
+  created_at: string;
+}
+
+export interface FeaturePiece {
+  id: number;
+  feature_id: string;
+  position: number;
+  name: string;
+  slice: string;
+  project_id: string;
+  after_position: number | null;
+  after_kind: "merged" | "deployed" | null;
+  reasons: string | null;
+  owns: string | null;
+  status: PieceStatus;
+  session_id: string | null;
+  note: string | null;
+}
+
+const expandHome = (p: string) => p.replace(/^~/, os.homedir());
+
+export const plansDir = () =>
+  process.env.AGENTOS_PLANS_DIR ||
+  path.join(os.homedir(), ".agent-os", "plans");
+export const planPathOf = (featureId: string) =>
+  path.join(plansDir(), `${featureId}.md`);
+
+function ref(id: string): ProjectRef | null {
+  const p = db
+    .prepare(`SELECT id, name, working_directory FROM projects WHERE id = ?`)
+    .get(id) as
+    | { id: string; name: string; working_directory: string }
+    | undefined;
+  if (!p) return null;
+  const deploy = loadProjectConfig(expandHome(p.working_directory)).config
+    .deploy;
+  return { id: p.id, name: p.name, deploys: !!deploy?.deployed };
+}
+
+export function checkContext(
+  s: Pick<Session, "project_id">
+): CheckContext | null {
+  const own = s.project_id ? ref(s.project_id) : null;
+  if (!own) return null;
+  const rows = db
+    .prepare(
+      `SELECT id, name FROM projects
+       WHERE workspace_id = (SELECT workspace_id FROM projects WHERE id = ?)`
+    )
+    .all(own.id) as { id: string; name: string }[];
+  return {
+    own,
+    find: (name) => {
+      const hit = rows.find(
+        (r) => r.name.toLowerCase() === name.trim().toLowerCase()
+      );
+      return hit ? ref(hit.id) : null;
+    },
+  };
+}
+
+// The plan's pieces after the checker, with Saad's edits applied. Null when
+// there's no plan file or no project: one piece, as always.
+export function planFor(s: Session, text: string): PiecesResult | null {
+  const ctx = checkContext(s);
+  return ctx ? checkPieces(text, ctx) : null;
+}
+
+export function getFeature(id: string): Feature | undefined {
+  return db.prepare(`SELECT * FROM features WHERE id = ?`).get(id) as
+    | Feature
+    | undefined;
+}
+
+export function piecesOf(featureId: string): FeaturePiece[] {
+  return db
+    .prepare(
+      `SELECT * FROM feature_pieces WHERE feature_id = ? ORDER BY position`
+    )
+    .all(featureId) as FeaturePiece[];
+}
+
+export function pieceOfSession(sessionId: string): FeaturePiece | undefined {
+  return db
+    .prepare(`SELECT * FROM feature_pieces WHERE session_id = ?`)
+    .get(sessionId) as FeaturePiece | undefined;
+}
+
+export function featureOfPlan(sessionId: string): Feature | undefined {
+  return db
+    .prepare(`SELECT * FROM features WHERE plan_session_id = ?`)
+    .get(sessionId) as Feature | undefined;
+}
+
+export interface Split {
+  pieces: Piece[];
+  notBuilding: string[];
+}
+
+// The pieces to build for a plan (one, when it isn't split). Edits Saad
+// made on the plan view apply only here, at approval.
+export function splitOf(s: Session, text: string): Split | null {
+  const result = planFor(s, text);
+  if (!result || result.pieces.length < 2) return null;
+  const { pieces, notBuilding } = applyEdits(result, parseEdits(s.plan_edits));
+  return { pieces, notBuilding };
+}
+
+// One transaction: the feature, its pieces, and the plan kept past the
+// worktree. Piece 1 is the planning task's own.
+export function createFeature(
+  s: Session,
+  text: string,
+  pieces: Piece[],
+  workspaceId: string
+): Feature {
+  const id = randomUUID();
+  fs.mkdirSync(plansDir(), { recursive: true });
+  fs.writeFileSync(planPathOf(id), text);
+  db.transaction(() => {
+    db.prepare(
+      `INSERT INTO features (id, workspace_id, name, plan_session_id, plan_text, status)
+       VALUES (?, ?, ?, ?, ?, 'building')`
+    ).run(id, workspaceId, s.name, s.id, text);
+    const insert = db.prepare(
+      `INSERT INTO feature_pieces
+         (feature_id, position, name, slice, project_id, after_position, after_kind,
+          reasons, owns, status, session_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    for (const p of pieces)
+      insert.run(
+        id,
+        p.position,
+        p.name,
+        p.slice,
+        p.project.id,
+        p.afterPosition,
+        p.afterKind,
+        p.reasons.join("+") || null,
+        p.owns.join(", ") || null,
+        p.position === 1 ? "building" : "waiting",
+        p.position === 1 ? s.id : null
+      );
+  })();
+  return getFeature(id)!;
+}
+
+const PLAN_IN_REVIEW = 20_000;
+
+// What a piece's review judges the diff against: its slice, not the whole
+// task. The last piece standing is also asked whether the plan is done.
+export function reviewGoal(sessionId: string): string | null {
+  const piece = pieceOfSession(sessionId);
+  const feature = piece ? getFeature(piece.feature_id) : undefined;
+  if (!piece || !feature) return null;
+  const all = piecesOf(feature.id);
+  const live = all.filter((p) => p.status !== "dropped");
+  const owns = piece.owns ? `\nThis piece owns: ${piece.owns}.` : "";
+  const head = `Piece ${piece.position} of ${live.length}, "${piece.name}": ${piece.slice}${owns}`;
+  const last = live.every((p) => p.id === piece.id || p.status === "merged");
+  if (!last || live.length < 2) return head;
+  return `${head}\n\nThis is the last piece. Also check that the plan as a whole is now done, and list anything in it that no piece built. The plan:\n${feature.plan_text.slice(0, PLAN_IN_REVIEW)}`;
+}

package/lib/plans/pieces.ts

@@ -0,0 +1,366 @@
+/**
+ * The `## Pieces` block a plan ends with, and the deterministic check that
+ * decides how many pieces it really is. A plan is one piece unless it names
+ * one of four reasons for splitting, and these rules (not a model) enforce
+ * that: a piece without a standing reason is folded into the one before it.
+ */
+
+export const MAX_PIECES = 6;
+
+export type PieceReason = "a" | "b" | "c" | "d";
+
+export interface ProjectRef {
+  id: string;
+  name: string;
+  // Whether the project's agentos.json names a `deploy.deployed` file.
+  deploys: boolean;
+}
+
+export interface Piece {
+  position: number;
+  name: string;
+  slice: string;
+  project: ProjectRef;
+  afterPosition: number | null;
+  afterKind: "merged" | "deployed" | null;
+  reasons: PieceReason[];
+  owns: string[];
+}
+
+export interface Folded {
+  name: string;
+  into: number;
+  why: string;
+}
+
+export interface PiecesResult {
+  pieces: Piece[];
+  folded: Folded[];
+  warnings: string[];
+}
+
+interface Raw {
+  position: number;
+  name: string;
+  slice: string;
+  repo: string | null;
+  after: { position: number; kind: "merged" | "deployed" } | null;
+  reasons: PieceReason[];
+  owns: string[];
+}
+
+const HEADING = /^##\s+pieces\s*$/i;
+const ITEM = /^\s{0,3}(\d+)[.)]\s+(.*\S)\s*$/;
+const AFTER = /^\s*after:\s*(\d+)\s+is\s+(merged|deployed)\s*$/i;
+const WHY = /^\s*why split:\s*(.+?)\s*$/i;
+const OWNS = /^\s*owns:\s*(.+?)\s*$/i;
+
+function block(text: string): string[] | null {
+  const lines = text.split("\n");
+  let start = -1;
+  lines.forEach((l, i) => {
+    if (HEADING.test(l.trim())) start = i;
+  });
+  if (start < 0) return null;
+  const out: string[] = [];
+  for (const l of lines.slice(start + 1)) {
+    if (/^#{1,2}\s/.test(l)) break;
+    out.push(l);
+  }
+  return out;
+}
+
+function parseItem(position: number, rest: string): Raw {
+  let repo: string | null = null;
+  const withRepo = rest.match(/^(.*?)\s*\(repo:\s*([^)]+)\)\s*$/i);
+  if (withRepo) {
+    rest = withRepo[1];
+    repo = withRepo[2].trim();
+  }
+  const split = rest.indexOf(":");
+  const name = (split > 0 ? rest.slice(0, split) : rest).trim();
+  const slice = (split > 0 ? rest.slice(split + 1) : rest).trim();
+  return {
+    position,
+    name: name.slice(0, 80) || `Piece ${position}`,
+    slice: slice || name,
+    repo,
+    after: null,
+    reasons: [],
+    owns: [],
+  };
+}
+
+function parseBlock(lines: string[]): Raw[] | null {
+  const items: Raw[] = [];
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const item = line.match(ITEM);
+    if (item) {
+      items.push(parseItem(Number(item[1]), item[2]));
+      continue;
+    }
+    const current = items[items.length - 1];
+    if (!current) return null;
+    const after = line.match(AFTER);
+    const why = line.match(WHY);
+    const owns = line.match(OWNS);
+    if (after)
+      current.after = {
+        position: Number(after[1]),
+        kind: after[2].toLowerCase() as "merged" | "deployed",
+      };
+    else if (why)
+      current.reasons = [
+        ...new Set(
+          (why[1].toLowerCase().match(/\(([abcd])\)/g) ?? []).map(
+            (m) => m[1] as PieceReason
+          )
+        ),
+      ];
+    else if (owns)
+      current.owns = owns[1]
+        .split(/[,;]/)
+        .map((o) => o.trim().toLowerCase())
+        .filter(Boolean);
+    else return null;
+  }
+  if (!items.length || items.some((it, i) => it.position !== i + 1))
+    return null;
+  return items;
+}
+
+export interface CheckContext {
+  // The project the plan's task works in: a piece naming none gets this.
+  own: ProjectRef;
+  find: (name: string) => ProjectRef | null;
+}
+
+function one(text: string, ctx: CheckContext, warnings: string[]) {
+  return {
+    pieces: [
+      {
+        position: 1,
+        name: "Plan",
+        slice: text.trim().slice(0, 500),
+        project: ctx.own,
+        afterPosition: null,
+        afterKind: null,
+        reasons: [],
+        owns: [],
+      } satisfies Piece,
+    ],
+    folded: [] as Folded[],
+    warnings,
+  };
+}
+
+export function checkPieces(text: string, ctx: CheckContext): PiecesResult {
+  const lines = block(text);
+  if (!lines) return one("", ctx, []);
+  const raw = parseBlock(lines);
+  if (!raw)
+    return one("", ctx, [
+      "The Pieces block couldn't be read, so this is one piece.",
+    ]);
+  if (raw.length > MAX_PIECES)
+    return one("", ctx, [
+      `${raw.length} pieces is past the limit of ${MAX_PIECES}; built as one piece.`,
+    ]);
+
+  const warnings: string[] = [];
+  const projects = raw.map((r) => {
+    if (!r.repo) return ctx.own;
+    const found = ctx.find(r.repo);
+    if (!found)
+      warnings.push(`"${r.name}": no project named ${r.repo}; using this one.`);
+    return found ?? ctx.own;
+  });
+
+  // Where each original piece ended up, for `after:` lines that pointed at a
+  // piece that was folded.
+  const landed = new Map<number, number>();
+  const pieces: Piece[] = [];
+  const folded: Folded[] = [];
+
+  raw.forEach((r, i) => {
+    const project = projects[i];
+    const fold = (why: string) => {
+      const into = pieces[pieces.length - 1];
+      into.slice = `${into.slice}\n${r.name}: ${r.slice}`;
+      into.owns = [...new Set([...into.owns, ...r.owns])];
+      landed.set(r.position, into.position);
+      folded.push({ name: r.name, into: into.position, why });
+    };
+    const keep = (p: Omit<Piece, "position">) => {
+      const position = pieces.length + 1;
+      pieces.push({ ...p, position });
+      landed.set(r.position, position);
+    };
+
+    if (i === 0) {
+      keep({
+        name: r.name,
+        slice: r.slice,
+        project,
+        afterPosition: null,
+        afterKind: null,
+        reasons: [],
+        owns: r.owns,
+      });
+      return;
+    }
+
+    let reasons = r.reasons;
+    if (!reasons.length) return fold("no reason for a separate piece");
+
+    if (reasons.includes("a")) {
+      const others = projects.filter((_, j) => j !== i);
+      if (others.some((p) => p.id === project.id)) {
+        reasons = reasons.filter((x) => x !== "a");
+        warnings.push(
+          `"${r.name}" claimed (a) but shares a repo with another piece.`
+        );
+      }
+    }
+
+    let afterPosition: number | null = null;
+    let afterKind = r.after?.kind ?? null;
+    if (r.after) {
+      const target = landed.get(r.after.position);
+      if (target === undefined || r.after.position >= r.position) {
+        warnings.push(`"${r.name}": after: ${r.after.position} isn't earlier.`);
+        afterKind = null;
+      } else {
+        afterPosition = target;
+      }
+    }
+
+    if (reasons.includes("b")) {
+      const dep = afterPosition ? pieces[afterPosition - 1] : null;
+      if (afterKind !== "deployed" || !dep) {
+        reasons = reasons.filter((x) => x !== "b");
+      } else if (!dep.project.deploys) {
+        reasons = reasons.filter((x) => x !== "b");
+        afterKind = "merged";
+        warnings.push(
+          `"${r.name}" waits on a deploy that ${dep.project.name} can't check; it waits for the merge instead.`
+        );
+      }
+    } else if (afterKind === "deployed") {
+      const dep = afterPosition ? pieces[afterPosition - 1] : null;
+      if (!dep?.project.deploys) afterKind = "merged";
+    }
+
+    if (!reasons.length) return fold("its reason didn't hold");
+
+    keep({
+      name: r.name,
+      slice: r.slice,
+      project,
+      afterPosition,
+      afterKind: afterPosition ? (afterKind ?? "merged") : null,
+      reasons,
+      owns: r.owns,
+    });
+  });
+
+  const seen = new Map<string, number>();
+  for (const p of pieces)
+    for (const o of p.owns) {
+      const first = seen.get(o);
+      if (first !== undefined && first !== p.position)
+        warnings.push(`"${o}" is owned by pieces ${first} and ${p.position}.`);
+      else seen.set(o, p.position);
+    }
+
+  return { pieces, folded, warnings };
+}
+
+export const PIECES_PROMPT = `At the end of the plan, add a \`## Pieces\` block. The default is exactly one piece, which is what almost every task is, and one piece needs no more than:
+
+## Pieces
+1. <name>: <one-line slice>  (repo: <project>)
+
+Add another piece only when one of these holds, and say which on a \`why split:\` line:
+(a) it spans repositories (a task works in one repo);
+(b) one part must be live (merged and deployed) before the other can merge;
+(c) one part needs the user mid-way (signing, a credential, a product call) and the rest doesn't;
+(d) one part must be revertible on its own: a migration that rewrites or deletes existing rows, or an auth or security change bundled with unrelated work. An additive migration doesn't count.
+Diff size is never a reason. A later piece looks like:
+2. <name>: <one-line slice>  (repo: <project>)
+   after: 1 is merged   (or: 1 is deployed)
+   why split: (a) + (b)
+   owns: migration 81
+A shared resource (a migration id, a new table, a config key) goes on exactly one piece's \`owns:\` line. A piece with no valid reason is folded into the one before it.`;
+
+// Shown to a piece's agent in place of the whole plan.
+export function pieceBrief(
+  total: number,
+  piece: Pick<Piece, "position" | "name" | "slice" | "owns">,
+  planPath: string,
+  before: string[] = []
+): string {
+  const owns = piece.owns.length
+    ? `\nThis piece owns: ${piece.owns.join(", ")}. No other piece touches it.`
+    : "";
+  const earlier = before.length
+    ? `\nPieces before you: ${before.join("; ")}.`
+    : "";
+  return `Build piece ${piece.position} of ${total} only, "${piece.name}": ${piece.slice}${owns}${earlier}\nThe rest of the plan is other pieces' work; don't start it. Full plan: ${planPath}`;
+}
+
+export interface PlanEdits {
+  // Positions to fold into the piece before them, and to leave out.
+  merge?: number[];
+  drop?: number[];
+}
+
+export function parseEdits(raw: string | null | undefined): PlanEdits {
+  try {
+    const o = JSON.parse(raw ?? "{}") as PlanEdits;
+    const ints = (v: unknown) =>
+      Array.isArray(v) ? v.filter((n) => Number.isInteger(n)) : [];
+    return { merge: ints(o.merge), drop: ints(o.drop) };
+  } catch {
+    return {};
+  }
+}
+
+// Saad's edits to the pieces before approving: a merged piece joins the one
+// before it, a dropped one is left out (and listed, so nothing vanishes).
+// Piece 1 can't be dropped or merged.
+export function applyEdits(
+  result: PiecesResult,
+  edits: PlanEdits
+): { pieces: Piece[]; notBuilding: string[] } {
+  const drop = new Set(edits.drop ?? []);
+  const merge = new Set(edits.merge ?? []);
+  const notBuilding: string[] = [];
+  const kept: Piece[] = [];
+  const landed = new Map<number, number>();
+  for (const p of result.pieces) {
+    const before = kept[kept.length - 1];
+    if (p.position > 1 && drop.has(p.position)) {
+      notBuilding.push(`${p.name}: ${p.slice}`);
+      continue;
+    }
+    if (p.position > 1 && merge.has(p.position) && before) {
+      before.slice = `${before.slice}\n${p.name}: ${p.slice}`;
+      before.owns = [...new Set([...before.owns, ...p.owns])];
+      landed.set(p.position, before.position);
+      continue;
+    }
+    const position = kept.length + 1;
+    landed.set(p.position, position);
+    const after =
+      p.afterPosition === null ? undefined : landed.get(p.afterPosition);
+    kept.push({
+      ...p,
+      position,
+      afterPosition: after && after < position ? after : null,
+      afterKind: after && after < position ? p.afterKind : null,
+    });
+  }
+  return { pieces: kept, notBuilding };
+}