runcastle 1.0.1 → 1.0.5

package/bin/runcastle.js

@@ -1,13 +1,17 @@
 #!/usr/bin/env bun
 // @bun
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -226,6 +230,7 @@ var init_schemas = __esm(() => {
     mapped: z2.boolean(),
     phase: Phase,
     branch: z2.string(),
+    baseBranch: z2.string().optional(),
     status: FeatureStatus,
     createdAt: z2.number()
   });
@@ -439,6 +444,7 @@ var init_db_schema = __esm(() => {
     mapped: integer("mapped", { mode: "boolean" }).notNull().default(false),
     phase: text("phase").notNull().$type(),
     branch: text("branch").notNull(),
+    baseBranch: text("base_branch"),
     status: text("status").notNull().$type(),
     createdAt: integer("created_at").notNull()
   });
@@ -1165,6 +1171,7 @@ function rowToFeature(row) {
     mapped: row.mapped,
     phase: row.phase,
     branch: row.branch,
+    baseBranch: row.baseBranch ?? undefined,
     status: row.status,
     createdAt: row.createdAt
   };
@@ -1901,20 +1908,59 @@ async function detectMainBranch(repoPath) {
   } catch {}
   return "main";
 }
-async function createFeatureBranch(project, slug) {
+async function createFeatureBranch(project, slug, base) {
   const branch = featureBranch(slug);
+  const from = base?.trim() || project.mainBranch;
   const g = git(project.repoPath);
   const branches = await g.branchLocal();
   if (branches.all.includes(branch))
     return branch;
-  await g.raw(["branch", branch, project.mainBranch]);
+  if (!branches.all.includes(from)) {
+    throw new Error(`base branch "${from}" does not exist in ${project.repoPath}`);
+  }
+  await g.raw(["branch", branch, from]);
   return branch;
 }
+async function listBranches(project) {
+  const g = git(project.repoPath);
+  const local = await g.branchLocal();
+  const branches = local.all.filter((name) => !name.startsWith("feature/"));
+  const localSet = new Set(local.all);
+  let remoteBranches = [];
+  try {
+    const remote = await g.branch(["-r"]);
+    remoteBranches = remote.all.filter((r) => !r.includes(" -> ") && !r.endsWith("/HEAD")).filter((r) => {
+      const short = r.replace(/^[^/]+\//, "");
+      return !short.startsWith("feature/") && !localSet.has(short);
+    });
+  } catch {}
+  return { current: local.current, mainBranch: project.mainBranch, branches, remoteBranches };
+}
+async function resolveBaseBranch(project, base) {
+  const g = git(project.repoPath);
+  const local = await g.branchLocal();
+  if (local.all.includes(base))
+    return base;
+  const remotes = (await g.getRemotes()).map((r) => r.name);
+  for (const rem of remotes) {
+    const prefix = `${rem}/`;
+    if (!base.startsWith(prefix))
+      continue;
+    const name = base.slice(prefix.length);
+    if (!name || name.endsWith("/HEAD"))
+      break;
+    if (local.all.includes(name))
+      return name;
+    await g.raw(["branch", "--track", name, base]);
+    return name;
+  }
+  throw new Error(`base branch "${base}" does not exist in ${project.repoPath}`);
+}
 async function ensureTalkWorktree(project, feature) {
   const worktreePath = worktreeDir(project.id, feature.slug);
   const branch = featureBranch(feature.slug);
   const g = git(project.repoPath);
-  await ensureBranchExists(g, branch, project.mainBranch);
+  await ensureBranchExists(g, branch, feature.baseBranch ?? project.mainBranch);
   if (await worktreeIsValid(g, worktreePath, branch))
     return worktreePath;
   mkdirSync2(dirname(worktreePath), { recursive: true });
@@ -2185,6 +2231,7 @@ async function testDrive(ctx, project, feature, action) {
   return { ok: true, branch };
 }
 async function mergeFeature(project, feature) {
+  const target = feature.baseBranch ?? project.mainBranch;
   if (testDriveState) {
     throw new GateError("Cannot merge while a test drive is active \u2014 stop it first");
   }
@@ -2193,19 +2240,33 @@ async function mergeFeature(project, feature) {
   if (porcelain !== "") {
     throw new GateError("Cannot merge \u2014 working tree has uncommitted changes");
   }
+  const branches = await g.branchLocal();
+  if (!branches.all.includes(target)) {
+    throw new GateError(`Cannot merge \u2014 base branch "${target}" no longer exists`);
+  }
+  const previous = (await g.revparse(["--abbrev-ref", "HEAD"])).trim();
   const branch = featureBranch(feature.slug);
-  await g.checkout(project.mainBranch);
+  await g.checkout(target);
   try {
     await g.merge(["--no-ff", branch]);
-    return { ok: true };
+    await restoreBranch(g, previous, target);
+    return { ok: true, target };
   } catch (e) {
     if (await mergeInProgress(g)) {
       await g.raw(["merge", "--abort"]);
-      return { ok: false, conflict: true };
+      await restoreBranch(g, previous, target);
+      return { ok: false, conflict: true, target };
     }
     throw e instanceof Error ? e : new Error(errMsg(e));
   }
 }
+async function restoreBranch(g, previous, target) {
+  if (previous === target || previous === "HEAD" || !previous)
+    return;
+  try {
+    await g.checkout(previous);
+  } catch {}
+}
 async function mergeInProgress(g) {
   try {
     await g.raw(["rev-parse", "--verify", "--quiet", "MERGE_HEAD"]);
@@ -3119,7 +3180,8 @@ async function createFeature(ctx, input) {
   const project = requireProjectById(ctx, input.projectId);
   const slug = uniqueSlug(ctx, project.id, input.title);
   const branch = `feature/${slug}`;
-  const { branchReady } = await ensureFeatureBranch(project, slug);
+  const requestedBase = input.baseBranch?.trim() || project.mainBranch;
+  const { branchReady, baseBranch } = await ensureFeatureBranch(project, slug, requestedBase);
   const row = {
     id: newId("feat"),
     projectId: project.id,
@@ -3130,6 +3192,7 @@ async function createFeature(ctx, input) {
     mapped: input.mapped ?? false,
     phase: "ideation",
     branch,
+    baseBranch,
     status: "active",
     createdAt: Date.now()
   };
@@ -3137,8 +3200,8 @@ async function createFeature(ctx, input) {
   const feature = rowToFeature(inserted);
   emit(ctx, feature.id, {
     type: "feature.created",
-    message: branchReady ? `feature.created (${branch})` : "feature.created (branch pending)",
-    data: { slug, branch, branchReady }
+    message: branchReady ? `feature.created (${branch} \u2190 ${baseBranch})` : "feature.created (branch pending)",
+    data: { slug, branch, baseBranch, branchReady }
   });
   scaffoldDocs(ctx, feature);
   if (branchReady) {
@@ -3148,13 +3211,14 @@ async function createFeature(ctx, input) {
   }
   return feature;
 }
-async function ensureFeatureBranch(project, slug) {
+async function ensureFeatureBranch(project, slug, requestedBase) {
   try {
-    await createFeatureBranch(project, slug);
-    return { branchReady: true };
+    const baseBranch = await resolveBaseBranch(project, requestedBase);
+    await createFeatureBranch(project, slug, baseBranch);
+    return { branchReady: true, baseBranch };
   } catch (e) {
     if (isNotImplemented(e))
-      return { branchReady: false };
+      return { branchReady: false, baseBranch: requestedBase };
     throw e;
   }
 }
@@ -4383,7 +4447,8 @@ var init_feature = __esm(() => {
       title: z6.string().min(1),
       oneLiner: z6.string(),
       size: FeatureSize,
-      mapped: z6.boolean().optional()
+      mapped: z6.boolean().optional(),
+      baseBranch: z6.string().optional()
     })).mutation(({ ctx, input }) => createFeature(ctx, input)),
     list: publicProcedure.input(z6.object({ projectId: z6.string() })).query(({ ctx, input }) => list(ctx, input.projectId)),
     get: publicProcedure.input(z6.object({ id: z6.string() })).query(({ ctx, input }) => getFeatureFull(ctx, input.id)),
@@ -4408,7 +4473,7 @@ var init_feature = __esm(() => {
       }
       const res = await mergeFeature(project, feature);
       if (res.ok) {
-        setPhase(ctx, input.featureId, "shipped", "feature.shipped", `merged to ${project.mainBranch}`);
+        setPhase(ctx, input.featureId, "shipped", "feature.shipped", `merged to ${res.target}`);
         setFeatureStatus(ctx, input.featureId, "shipped");
       } else {
         emit(ctx, input.featureId, {
@@ -4514,10 +4579,13 @@ var init_projects = __esm(() => {
 import * as z7 from "zod";
 var projectRouter;
 var init_project = __esm(() => {
+  init_git();
   init_projects();
+  init_repo();
   init_context();
   projectRouter = router({
     list: publicProcedure.query(({ ctx }) => listProjects(ctx)),
+    branches: publicProcedure.input(z7.object({ projectId: z7.string() })).query(({ ctx, input }) => listBranches(requireProjectById(ctx, input.projectId))),
     open: publicProcedure.input(z7.object({ repoPath: z7.string().min(1) })).mutation(({ ctx, input }) => openProject(ctx, input.repoPath)),
     close: publicProcedure.input(z7.object({ projectId: z7.string() })).mutation(({ ctx, input }) => closeProject(ctx, input.projectId)),
     rename: publicProcedure.input(z7.object({ projectId: z7.string(), name: z7.string().min(1) })).mutation(({ ctx, input }) => renameProject(ctx, input.projectId, input.name))
@@ -5442,9 +5510,6 @@ var init_src2 = __esm(() => {
   init_web();
   init_router();
   init_reconcile_runs();
-  if (import.meta.main) {
-    startServer();
-  }
 });
 
 // src/doctor/report.ts

package/drizzle/0006_living_typhoid_mary.sql

@@ -0,0 +1 @@
+ALTER TABLE `features` ADD `base_branch` text;