runcastle 1.2.0 → 1.2.2

package/bin/runcastle.js

@@ -246,7 +246,7 @@ var init_ids = () => {};
 
 // ../core/src/schemas.ts
 import * as z2 from "zod";
-var Phase, TicketStatus, SessionKind, RunStatus, FeatureStatus, SessionStatus, TicketInput, Ticket, WaypointType, WaypointStatus, WaypointDisposition, WaypointInput, Waypoint, PREPARED_KEYS, PreparedKey, DRIVE_LOOP_KEYS, FindingSource, PROJECT_NAME_MAX = 80, ProjectName, Project, ProjectFinding, Feature, SessionRow, Run, SettingSource, SettingScope, SettingField, SettingsView, SettingsUpdateInput, EventRow;
+var Phase, TicketStatus, SessionKind, RunStatus, FeatureStatus, SessionStatus, TicketInput, Ticket, WaypointType, WaypointStatus, WaypointDisposition, WaypointInput, Waypoint, TestNoteStatus, TestNote, PREPARED_KEYS, PreparedKey, DRIVE_LOOP_KEYS, FindingSource, PROJECT_NAME_MAX = 80, ProjectName, Project, ProjectFinding, Feature, SessionRow, Run, SettingSource, SettingScope, SettingField, SettingsView, SettingsUpdateInput, EventRow;
 var init_schemas = __esm(() => {
   Phase = z2.enum([
     "ideation",
@@ -308,6 +308,17 @@ var init_schemas = __esm(() => {
     lastSessionId: z2.string().optional(),
     summary: z2.string().optional()
   });
+  TestNoteStatus = z2.enum(["open", "done", "promoted"]);
+  TestNote = z2.object({
+    id: z2.string(),
+    featureId: z2.string(),
+    lap: z2.number(),
+    text: z2.string(),
+    status: TestNoteStatus,
+    ticketId: z2.string().optional(),
+    createdAt: z2.number(),
+    updatedAt: z2.number()
+  });
   PREPARED_KEYS = [
     "setupCommand",
     "verifyCommands",
@@ -560,7 +571,7 @@ var init_pipeline = __esm(() => {
 
 // ../core/src/db-schema.ts
 import { integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
-var projects, projectFindings, features, sessions, tickets, waypoints, runs, events, gateOverrides;
+var projects, projectFindings, features, sessions, tickets, testNotes, waypoints, runs, events, gateOverrides;
 var init_db_schema = __esm(() => {
   projects = sqliteTable("projects", {
     id: text("id").primaryKey(),
@@ -632,6 +643,16 @@ var init_db_schema = __esm(() => {
     attemptBranch: text("attempt_branch"),
     conflictFiles: text("conflict_files", { mode: "json" }).$type()
   });
+  testNotes = sqliteTable("test_notes", {
+    id: text("id").primaryKey(),
+    featureId: text("feature_id").notNull(),
+    lap: integer("lap").notNull(),
+    text: text("text").notNull(),
+    status: text("status").notNull().$type(),
+    ticketId: text("ticket_id"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull()
+  });
   waypoints = sqliteTable("waypoints", {
     id: text("id").primaryKey(),
     featureId: text("feature_id").notNull(),
@@ -694,6 +715,7 @@ var init_schema = __esm(() => {
     features,
     sessions,
     tickets,
+    testNotes,
     waypoints,
     runs,
     events,
@@ -1774,6 +1796,7 @@ var init_waypoints = __esm(() => {
 });
 
 // src/pty/dev-pane.ts
+import { execFileSync } from "child_process";
 function drivePaneId(ownerId) {
   return `${DRIVE_PREFIX}${ownerId}`;
 }
@@ -1833,14 +1856,20 @@ function devPaneLive(paneId) {
   const entry = ptyRegistry().get(paneId);
   return !!entry && !entry.exited;
 }
+function killProcessTree(pid) {
+  try {
+    if (process.platform === "win32") {
+      execFileSync("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore" });
+    } else {
+      process.kill(-pid, "SIGTERM");
+    }
+  } catch {}
+}
 function stopDevPane(paneId) {
   const reg = ptyRegistry();
   const entry = reg.get(paneId);
-  if (entry && !entry.exited && process.platform !== "win32") {
-    try {
-      process.kill(-entry.pty.pid, "SIGTERM");
-    } catch {}
-  }
+  if (entry && !entry.exited)
+    killProcessTree(entry.pty.pid);
   reg.kill(paneId);
   reg.remove(paneId);
 }
@@ -9346,8 +9375,188 @@ var init_system = __esm(() => {
   });
 });
 
-// src/trpc/routers/ticket.ts
+// src/services/test-notes.ts
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname10 } from "path";
+import { asc as asc4, eq as eq14 } from "drizzle-orm";
+function rowToNote(row) {
+  return {
+    id: row.id,
+    featureId: row.featureId,
+    lap: row.lap,
+    text: row.text,
+    status: row.status,
+    ticketId: row.ticketId ?? undefined,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function getNote(ctx, id) {
+  const row = ctx.db.select().from(testNotes).where(eq14(testNotes.id, id)).get();
+  if (!row)
+    throw new NotFoundError(`test note ${id} not found`);
+  return rowToNote(row);
+}
+function cleanText(text2) {
+  const trimmed = text2.trim();
+  if (!trimmed)
+    throw new InvalidInputError("note text cannot be empty");
+  return trimmed;
+}
+function assertOpen(note, action) {
+  if (note.status !== "open") {
+    throw new InvalidInputError(`cannot ${action} note ${note.id} \u2014 it is ${note.status}; only open notes can be changed`);
+  }
+}
+function listByFeature3(ctx, featureId) {
+  return ctx.db.select().from(testNotes).where(eq14(testNotes.featureId, featureId)).orderBy(asc4(testNotes.createdAt), asc4(testNotes.id)).all().map(rowToNote);
+}
+function addNote(ctx, featureId, text2) {
+  const body = cleanText(text2);
+  const feature = getFeatureRow(ctx, featureId);
+  const now = Date.now();
+  const row = ctx.db.insert(testNotes).values({
+    id: newId("note"),
+    featureId,
+    lap: feature.lap,
+    text: body,
+    status: "open",
+    ticketId: null,
+    createdAt: now,
+    updatedAt: now
+  }).returning().get();
+  const note = rowToNote(row);
+  emit(ctx, featureId, {
+    type: "note.added",
+    message: `note captured on lap ${note.lap}`,
+    data: { noteId: note.id, lap: note.lap }
+  });
+  renderTestNotes(ctx, feature);
+  return note;
+}
+function editNote(ctx, noteId, text2) {
+  const current2 = getNote(ctx, noteId);
+  assertOpen(current2, "edit");
+  const body = cleanText(text2);
+  ctx.db.update(testNotes).set({ text: body, updatedAt: Date.now() }).where(eq14(testNotes.id, noteId)).run();
+  emit(ctx, current2.featureId, {
+    type: "note.edited",
+    message: "note edited",
+    data: { noteId }
+  });
+  renderTestNotes(ctx, getFeatureRow(ctx, current2.featureId));
+  return getNote(ctx, noteId);
+}
+function deleteNote(ctx, noteId) {
+  const current2 = getNote(ctx, noteId);
+  assertOpen(current2, "delete");
+  ctx.db.delete(testNotes).where(eq14(testNotes.id, noteId)).run();
+  emit(ctx, current2.featureId, {
+    type: "note.deleted",
+    message: "note deleted",
+    data: { noteId }
+  });
+  renderTestNotes(ctx, getFeatureRow(ctx, current2.featureId));
+}
+function toggleNote(ctx, noteId) {
+  const current2 = getNote(ctx, noteId);
+  if (current2.status === "promoted") {
+    throw new InvalidInputError(`cannot toggle note ${noteId} \u2014 it is promoted, and promoted notes are frozen`);
+  }
+  const status = current2.status === "open" ? "done" : "open";
+  ctx.db.update(testNotes).set({ status, updatedAt: Date.now() }).where(eq14(testNotes.id, noteId)).run();
+  emit(ctx, current2.featureId, {
+    type: "note.toggled",
+    message: `note ${current2.status} \u2192 ${status}`,
+    data: { noteId, from: current2.status, to: status }
+  });
+  renderTestNotes(ctx, getFeatureRow(ctx, current2.featureId));
+  return getNote(ctx, noteId);
+}
+function promotionTicket(feature, note) {
+  const firstLine = note.text.split(`
+`)[0].trim();
+  const docs = featureDocsRel(feature.slug);
+  return {
+    title: firstLine.length <= TITLE_MAX ? firstLine : `${firstLine.slice(0, TITLE_MAX - 1).trimEnd()}\u2026`,
+    goal: note.text,
+    context: [
+      `Found during lap ${note.lap} test drive of ${feature.slug}.`,
+      `Read ${docs}/spec.md and ${docs}/decisions.md for what this feature is meant to do.`
+    ].join(`
+
+`),
+    acceptanceCriteria: [`The noted behavior no longer reproduces: ${note.text}`],
+    seams: [],
+    blockedBy: []
+  };
+}
+function promoteNote(ctx, noteId) {
+  const current2 = getNote(ctx, noteId);
+  assertOpen(current2, "promote");
+  const feature = getFeatureRow(ctx, current2.featureId);
+  const [ticket] = storeTickets(ctx, current2.featureId, [promotionTicket(feature, current2)]);
+  ctx.db.update(testNotes).set({ status: "promoted", ticketId: ticket.id, updatedAt: Date.now() }).where(eq14(testNotes.id, noteId)).run();
+  emit(ctx, current2.featureId, {
+    type: "note.promoted",
+    message: `note promoted to ticket ${ticket.seq}`,
+    ticketId: ticket.id,
+    data: { noteId, seq: ticket.seq }
+  });
+  renderTestNotes(ctx, feature);
+  return { note: getNote(ctx, noteId), ticket };
+}
+function noteLine(ctx, note) {
+  if (note.status === "open")
+    return `- [ ] ${note.text}`;
+  const ticket = note.ticketId ? ` (\u2192 ticket ${getTicket(ctx, note.ticketId).seq})` : "";
+  return `- [x] ${note.text}${ticket}`;
+}
+function renderTestNotes(ctx, feature) {
+  const notes = listByFeature3(ctx, feature.id);
+  const laps = [...new Set(notes.map((n) => n.lap))].sort((a, b) => a - b);
+  const lines = ["# Test notes"];
+  for (const lap of laps) {
+    lines.push("", `## Lap ${lap}`, "");
+    for (const note of notes.filter((n) => n.lap === lap))
+      lines.push(noteLine(ctx, note));
+  }
+  const path = featureDocPath(projectForFeature(ctx, feature), feature, "test-notes.md");
+  mkdirSync9(dirname10(path), { recursive: true });
+  writeFileSync5(path, `${lines.join(`
+`)}
+`, "utf8");
+}
+var TITLE_MAX = 60;
+var init_test_notes = __esm(() => {
+  init_src();
+  init_paths();
+  init_schema();
+  init_errors();
+  init_events();
+  init_feature_docs();
+  init_repo();
+  init_tickets();
+});
+
+// src/trpc/routers/test-notes.ts
 import * as z12 from "zod";
+var testNotesRouter;
+var init_test_notes2 = __esm(() => {
+  init_test_notes();
+  init_context();
+  testNotesRouter = router({
+    list: publicProcedure.input(z12.object({ featureId: z12.string() })).query(({ ctx, input }) => listByFeature3(ctx, input.featureId)),
+    add: publicProcedure.input(z12.object({ featureId: z12.string(), text: z12.string().min(1) })).mutation(({ ctx, input }) => addNote(ctx, input.featureId, input.text)),
+    edit: publicProcedure.input(z12.object({ noteId: z12.string(), text: z12.string().min(1) })).mutation(({ ctx, input }) => editNote(ctx, input.noteId, input.text)),
+    remove: publicProcedure.input(z12.object({ noteId: z12.string() })).mutation(({ ctx, input }) => deleteNote(ctx, input.noteId)),
+    toggle: publicProcedure.input(z12.object({ noteId: z12.string() })).mutation(({ ctx, input }) => toggleNote(ctx, input.noteId)),
+    promote: publicProcedure.input(z12.object({ noteId: z12.string() })).mutation(({ ctx, input }) => promoteNote(ctx, input.noteId))
+  });
+});
+
+// src/trpc/routers/ticket.ts
+import * as z13 from "zod";
 var ticketRouter;
 var init_ticket = __esm(() => {
   init_features();
@@ -9356,8 +9565,8 @@ var init_ticket = __esm(() => {
   init_ticket_burner();
   init_context();
   ticketRouter = router({
-    retry: publicProcedure.input(z12.object({ ticketId: z12.string(), fresh: z12.boolean().optional() })).mutation(({ ctx, input }) => retryTicket(ctx, input.ticketId, { fresh: input.fresh })),
-    stop: publicProcedure.input(z12.object({ ticketId: z12.string() })).mutation(({ ctx, input }) => {
+    retry: publicProcedure.input(z13.object({ ticketId: z13.string(), fresh: z13.boolean().optional() })).mutation(({ ctx, input }) => retryTicket(ctx, input.ticketId, { fresh: input.fresh })),
+    stop: publicProcedure.input(z13.object({ ticketId: z13.string() })).mutation(({ ctx, input }) => {
       if (stopTicketRun(input.ticketId))
         return { stopped: true, swept: false };
       const ticket = getTicket(ctx, input.ticketId);
@@ -9367,13 +9576,13 @@ var init_ticket = __esm(() => {
       }
       return { stopped: false, swept: false };
     }),
-    cancel: publicProcedure.input(z12.object({ ticketId: z12.string(), reason: z12.string().optional() })).mutation(({ ctx, input }) => cancelTicket(ctx, input.ticketId, input.reason)),
-    edit: publicProcedure.input(z12.object({
-      ticketId: z12.string(),
-      title: z12.string().min(1).optional(),
-      goal: z12.string().min(1).optional(),
-      context: z12.string().optional(),
-      acceptanceCriteria: z12.array(z12.string().min(1)).optional()
+    cancel: publicProcedure.input(z13.object({ ticketId: z13.string(), reason: z13.string().optional() })).mutation(({ ctx, input }) => cancelTicket(ctx, input.ticketId, input.reason)),
+    edit: publicProcedure.input(z13.object({
+      ticketId: z13.string(),
+      title: z13.string().min(1).optional(),
+      goal: z13.string().min(1).optional(),
+      context: z13.string().optional(),
+      acceptanceCriteria: z13.array(z13.string().min(1)).optional()
     })).mutation(({ ctx, input }) => {
       const { ticketId, ...patch } = input;
       return editTicket(ctx, ticketId, patch);
@@ -9393,12 +9602,14 @@ var init_router = __esm(() => {
   init_settings2();
   init_setup2();
   init_system();
+  init_test_notes2();
   init_ticket();
   appRouter = router({
     project: projectRouter,
     feature: featureRouter,
     run: runRouter,
     ticket: ticketRouter,
+    notes: testNotesRouter,
     events: eventsRouter,
     docs: docsRouter,
     settings: settingsRouter,
@@ -9408,14 +9619,14 @@ var init_router = __esm(() => {
 });
 
 // src/workflows/reconcile-runs.ts
-import { eq as eq14 } from "drizzle-orm";
+import { eq as eq15 } from "drizzle-orm";
 async function reconcileStaleRuns(ctx) {
-  const stale = ctx.db.select().from(runs).where(eq14(runs.status, "running")).all().map(rowToRun);
+  const stale = ctx.db.select().from(runs).where(eq15(runs.status, "running")).all().map(rowToRun);
   const reconciled = [];
   for (const run3 of stale) {
     if (isRunActive(run3.id))
       continue;
-    ctx.db.update(runs).set({ status: "failed", endedAt: Date.now(), summary: "orphaned by server restart" }).where(eq14(runs.id, run3.id)).run();
+    ctx.db.update(runs).set({ status: "failed", endedAt: Date.now(), summary: "orphaned by server restart" }).where(eq15(runs.id, run3.id)).run();
     const released = releaseForSession(ctx, run3.id);
     const swept = workflowClaimsFeatureBranch(run3.workflow) ? sweepOrphanedBurning(ctx, run3.featureId, "orphaned by server restart \u2014 retry to resume its commits") : [];
     if (workflowClaimsFeatureBranch(run3.workflow)) {
@@ -9645,7 +9856,7 @@ var init_cli = __esm(() => {
 // src/bin/runcastle.ts
 init_asset_paths();
 init_version();
-import { dirname as dirname10, resolve as resolve11 } from "path";
+import { dirname as dirname11, resolve as resolve11 } from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 function parseCommand(argv) {
   const [first, ...rest] = argv;
@@ -9670,7 +9881,7 @@ Usage:
   runcastle --help     Show this help
 `;
 async function main(argv) {
-  applyInstalledAssetEnv(resolve11(dirname10(fileURLToPath8(import.meta.url)), ".."));
+  applyInstalledAssetEnv(resolve11(dirname11(fileURLToPath8(import.meta.url)), ".."));
   const { command, args } = parseCommand(argv);
   switch (command) {
     case "version":

package/drizzle/0018_nice_lorna_dane.sql

@@ -0,0 +1,10 @@
+CREATE TABLE `test_notes` (
+	`id` text PRIMARY KEY NOT NULL,
+	`feature_id` text NOT NULL,
+	`lap` integer NOT NULL,
+	`text` text NOT NULL,
+	`status` text NOT NULL,
+	`ticket_id` text,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL
+);