@kynver-app/runtime 0.1.9 → 0.1.11

package/dist/cli.js

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { mkdirSync as mkdirSync5 } from "node:fs";
-import path14 from "node:path";
+import { mkdirSync as mkdirSync5, realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 
 // src/config.ts
@@ -381,12 +380,12 @@ var DEFAULT_CRITICAL_FREE_BYTES = 15 * 1024 * 1024 * 1024;
 var DEFAULT_MAX_USED_PERCENT = 80;
 var DEFAULT_HARD_MAX_USED_PERCENT = 90;
 function observeRunnerDiskGate(input = {}) {
-  const path15 = input.diskPath?.trim() || "/";
+  const path14 = input.diskPath?.trim() || "/";
   const warnBelowBytes = input.diskFreeWarnBytes ?? DEFAULT_WARN_FREE_BYTES;
   const criticalBelowBytes = input.diskFreeCriticalBytes ?? DEFAULT_CRITICAL_FREE_BYTES;
   const maxUsedPercent = input.diskMaxUsedPercent ?? DEFAULT_MAX_USED_PERCENT;
   const hardMaxUsedPercent = input.diskHardMaxUsedPercent ?? DEFAULT_HARD_MAX_USED_PERCENT;
-  const stats = statfsSync(path15);
+  const stats = statfsSync(path14);
   const freeBytes = Number(stats.bavail) * Number(stats.bsize);
   const totalBytes = Number(stats.blocks) * Number(stats.bsize);
   const usedPercent = totalBytes > 0 ? (totalBytes - freeBytes) / totalBytes * 100 : 100;
@@ -406,7 +405,7 @@ function observeRunnerDiskGate(input = {}) {
   }
   return {
     ok,
-    path: path15,
+    path: path14,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -594,6 +593,92 @@ function ensureGitRepo(repo) {
 function gitStatusShort(worktreePath) {
   return git(worktreePath, ["status", "--short"], { allowFailure: true }).split("\n").map((line) => line.trim()).filter(Boolean);
 }
+function gitCapture(cwd, args) {
+  try {
+    const res = spawnSync("git", args, { cwd, encoding: "utf8" });
+    return {
+      status: res.status,
+      stdout: res.stdout || "",
+      stderr: res.stderr || "",
+      error: res.error ? res.error.message : null
+    };
+  } catch (error) {
+    return {
+      status: null,
+      stdout: "",
+      stderr: "",
+      error: error.message
+    };
+  }
+}
+function gitIsAncestor(cwd, ancestor, descendant) {
+  const res = gitCapture(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]);
+  if (res.status === 0) return { isAncestor: true, error: null };
+  if (res.status === 1) return { isAncestor: false, error: null };
+  return { isAncestor: null, error: res.error || res.stderr || res.stdout || `git exited ${res.status}` };
+}
+function computeGitAncestry(worktreePath, base = "origin/main") {
+  if (!worktreePath) {
+    return unknownAncestry(base, "missing worktree path");
+  }
+  const head = gitCapture(worktreePath, ["rev-parse", "HEAD"]);
+  if (head.status !== 0) return unknownAncestry(base, head.error || head.stderr || head.stdout || "failed to resolve HEAD");
+  const baseHead = gitCapture(worktreePath, ["rev-parse", base]);
+  if (baseHead.status !== 0) {
+    return unknownAncestry(base, baseHead.error || baseHead.stderr || baseHead.stdout || `failed to resolve ${base}`, head.stdout.trim());
+  }
+  const headSha = head.stdout.trim();
+  const baseSha = baseHead.stdout.trim();
+  if (headSha === baseSha) {
+    return {
+      checked: true,
+      base,
+      head: headSha,
+      baseHead: baseSha,
+      baseIsAncestorOfHead: true,
+      headIsAncestorOfBase: true,
+      relation: "synced"
+    };
+  }
+  const baseIsAncestorOfHead = gitIsAncestor(worktreePath, baseSha, headSha);
+  const headIsAncestorOfBase = gitIsAncestor(worktreePath, headSha, baseSha);
+  const error = baseIsAncestorOfHead.error || headIsAncestorOfBase.error || void 0;
+  if (baseIsAncestorOfHead.isAncestor == null || headIsAncestorOfBase.isAncestor == null) {
+    return {
+      checked: false,
+      base,
+      head: headSha,
+      baseHead: baseSha,
+      baseIsAncestorOfHead: baseIsAncestorOfHead.isAncestor,
+      headIsAncestorOfBase: headIsAncestorOfBase.isAncestor,
+      relation: "unknown",
+      ...error ? { error } : {}
+    };
+  }
+  const relation = baseIsAncestorOfHead.isAncestor ? "ahead" : headIsAncestorOfBase.isAncestor ? "merged" : "diverged";
+  return {
+    checked: true,
+    base,
+    head: headSha,
+    baseHead: baseSha,
+    baseIsAncestorOfHead: baseIsAncestorOfHead.isAncestor,
+    headIsAncestorOfBase: headIsAncestorOfBase.isAncestor,
+    relation,
+    ...error ? { error } : {}
+  };
+}
+function unknownAncestry(base, error, head = null) {
+  return {
+    checked: false,
+    base,
+    head,
+    baseHead: null,
+    baseIsAncestorOfHead: null,
+    headIsAncestorOfBase: null,
+    relation: "unknown",
+    error
+  };
+}
 function scrubClaudeEnv(env) {
   const next = { ...env };
   delete next.ANTHROPIC_API_KEY;
@@ -620,7 +705,7 @@ function computeAttention(input) {
   }
   return { state: "ok", reason: "recent activity" };
 }
-function computeWorkerStatus(worker) {
+function computeWorkerStatus(worker, options = {}) {
   const parsed = parseClaudeStream(worker.stdoutPath);
   const heartbeat = parseHeartbeat(worker.heartbeatPath);
   const alive = isPidAlive(worker.pid);
@@ -628,6 +713,7 @@ function computeWorkerStatus(worker) {
   const stderrBytes = fileSize(worker.stderrPath);
   const heartbeatBytes = fileSize(worker.heartbeatPath);
   const changedFiles = gitStatusShort(worker.worktreePath);
+  const gitAncestry = computeGitAncestry(worker.worktreePath, options.base);
   const lastActivityAt = latestIso([
     parsed.lastEventAt,
     heartbeat.lastHeartbeatAt,
@@ -669,7 +755,8 @@ function computeWorkerStatus(worker) {
     heartbeatBlocker: heartbeat.heartbeatBlocker,
     finalResult: parsed.finalResult,
     error: parsed.error || (!alive && !parsed.finalResult ? tailFile(worker.stderrPath, 10).trim() || void 0 : void 0),
-    changedFiles
+    changedFiles,
+    gitAncestry
   };
 }
 function isFinishedWorkerStatus(status) {
@@ -1431,7 +1518,7 @@ function runStatus(args) {
     if (!worker) {
       return { worker: name, status: "missing", attention: "needs_attention", attentionReason: "worker.json not found" };
     }
-    const status = computeWorkerStatus(worker);
+    const status = computeWorkerStatus(worker, { base: run.base });
     return {
       worker: status.worker,
       status: status.status,
@@ -1445,7 +1532,9 @@ function runStatus(args) {
       lastHeartbeatSummary: status.lastHeartbeatSummary,
       heartbeatBlocker: status.heartbeatBlocker,
       changedFileCount: status.changedFiles.length,
-      branch: status.branch
+      branch: status.branch,
+      ancestry: status.gitAncestry.relation,
+      ancestryChecked: status.gitAncestry.checked
     };
   });
   const board = {
@@ -1829,6 +1918,7 @@ async function main(argv = process.argv.slice(2)) {
   } else {
     rest = argv;
   }
+  if (action && isHelpFlag(action) || rest.some(isHelpFlag)) return usage(0);
   const args = parseArgs(rest);
   const { runsDir, worktreesDir } = getPaths();
   mkdirSync5(runsDir, { recursive: true });
@@ -1851,7 +1941,7 @@ async function main(argv = process.argv.slice(2)) {
   if (scope === "worker" && action === "complete") return void await completeWorker(args);
   unknownCommand(scope, action);
 }
-var isCliEntry = process.argv[1] && path14.resolve(process.argv[1]) === path14.resolve(fileURLToPath(import.meta.url));
+var isCliEntry = process.argv[1] && realpathSync.native(process.argv[1]) === realpathSync.native(fileURLToPath(import.meta.url));
 if (isCliEntry) {
   void main().catch((error) => {
     console.error(error);