@staff0rd/assist 0.454.1 → 0.456.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.454.1",
+  version: "0.456.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -3587,7 +3587,7 @@ function unwrapSchemaNode(node) {
   return { inner: current, defaultValue };
 }
 
-// src/shared/describeConfigLeaves.ts
+// src/shared/scalarUnionMembers.ts
 var LEAF_TYPES = {
   string: "string",
   number: "number",
@@ -3596,9 +3596,39 @@ var LEAF_TYPES = {
   array: "array",
   record: "record"
 };
-function leafType(node) {
+var SCALAR_LEAF_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "enum"
+]);
+function leafTypeOf(node) {
   return LEAF_TYPES[node.def?.type ?? ""] ?? "other";
 }
+function isScalarLeafType(type) {
+  return SCALAR_LEAF_TYPES.has(type);
+}
+function scalarUnionMembers(node) {
+  const options2 = node.def?.options;
+  if (node.def?.type !== "union" || !options2?.length) return void 0;
+  const members = [];
+  for (const option of options2) {
+    const type = leafTypeOf(unwrapSchemaNode(option).inner);
+    if (!isScalarLeafType(type)) return void 0;
+    members.push(type);
+  }
+  return members;
+}
+
+// src/shared/scalarArrayItemType.ts
+function scalarArrayItemType(node) {
+  const element = node.def?.element;
+  if (node.def?.type !== "array" || !element) return void 0;
+  const type = leafTypeOf(unwrapSchemaNode(element).inner);
+  return isScalarLeafType(type) ? type : void 0;
+}
+
+// src/shared/describeConfigLeaves.ts
 function enumValues(node) {
   const entries = node.def?.entries;
   if (!entries) return void 0;
@@ -3607,9 +3637,13 @@ function enumValues(node) {
   );
 }
 function toLeaf(key, node, defaultValue) {
-  const type = leafType(node);
+  const unionTypes = scalarUnionMembers(node);
+  const type = unionTypes ? "union" : leafTypeOf(node);
   const leaf = { key, type };
   if (type === "enum") leaf.enumValues = enumValues(node);
+  if (unionTypes) leaf.unionTypes = unionTypes;
+  const itemType = scalarArrayItemType(node);
+  if (itemType) leaf.itemType = itemType;
   if (defaultValue !== void 0) leaf.defaultValue = defaultValue;
   return leaf;
 }
@@ -10052,21 +10086,10 @@ function applyConfigSet(key, coerced, global, cwd = process.cwd()) {
   return { ok: true, target: "project" };
 }
 
-// src/commands/config/coerceConfigValue.ts
-var EDITABLE_TYPES = /* @__PURE__ */ new Set(["string", "number", "boolean", "enum"]);
-function coerceConfigValue(key, raw) {
-  const leaf = describeConfigLeaves(assistConfigSchema).find(
-    (candidate) => candidate.key === key
-  );
-  if (!leaf) return { ok: false, error: `Unknown config key "${key}"` };
-  if (!EDITABLE_TYPES.has(leaf.type)) {
-    return {
-      ok: false,
-      error: `"${key}" is a ${leaf.type} value and is read-only here`
-    };
-  }
-  if (leaf.type === "boolean") return coerceBoolean(key, raw);
-  if (leaf.type === "number") return coerceNumber(key, raw);
+// src/commands/config/coerceConfigScalar.ts
+function coerceConfigScalar(key, raw, type) {
+  if (type === "boolean") return coerceBoolean(key, raw);
+  if (type === "number") return coerceNumber(key, raw);
   return coerceString(key, raw);
 }
 function coerceBoolean(key, raw) {
@@ -10090,6 +10113,53 @@ function coerceString(key, raw) {
   return { ok: false, error: `${key}: expected a string` };
 }
 
+// src/commands/config/coerceConfigValue.ts
+var EDITABLE_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "enum",
+  "union"
+]);
+function coerceConfigValue(key, raw) {
+  const leaf = describeConfigLeaves(assistConfigSchema).find(
+    (candidate) => candidate.key === key
+  );
+  if (!leaf) return { ok: false, error: `Unknown config key "${key}"` };
+  if (leaf.itemType) return coerceScalarList(key, raw, leaf.itemType);
+  if (!EDITABLE_TYPES.has(leaf.type)) {
+    return {
+      ok: false,
+      error: `"${key}" is a ${leaf.type} value and is read-only here`
+    };
+  }
+  if (leaf.type === "union")
+    return coerceUnion(key, raw, leaf.unionTypes ?? []);
+  return coerceConfigScalar(key, raw, leaf.type);
+}
+function coerceScalarList(key, raw, itemType) {
+  if (!Array.isArray(raw)) {
+    return {
+      ok: false,
+      error: `${key}: expected a list of ${itemType} values`
+    };
+  }
+  const values = [];
+  for (const item of raw) {
+    const result = coerceConfigScalar(key, item, itemType);
+    if (!result.ok) return result;
+    values.push(result.value);
+  }
+  return { ok: true, value: values };
+}
+function coerceUnion(key, raw, types) {
+  for (const type of types) {
+    const result = coerceConfigScalar(key, raw, type);
+    if (result.ok) return result;
+  }
+  return { ok: false, error: `${key}: expected ${types.join(" or ")}` };
+}
+
 // src/commands/sessions/web/readJsonBody.ts
 async function readJsonBody(req) {
   const chunks = [];
@@ -17168,8 +17238,8 @@ function printRepoAuthorBreakdown(repos2) {
 }
 
 // src/commands/github/printCommitsReport.ts
-function printCommitsReport(report) {
-  const { org, since, totalRepos, repos: repos2, committers, repoAuthors } = report;
+function printCommitsReport(report2) {
+  const { org, since, totalRepos, repos: repos2, committers, repoAuthors } = report2;
   const scope = repos2.length < totalRepos ? ` (top ${repos2.length} of ${totalRepos} repos)` : "";
   console.log(`Top repos by commits in ${org} since ${since}${scope}:
 `);
@@ -17198,7 +17268,7 @@ function commits(org, options2) {
     name: repo.name,
     authors: fetchRepoCommitAuthors(org, repo.name, since)
   }));
-  const report = {
+  const report2 = {
     org,
     since: sinceDate,
     totalRepos: allRepos.length,
@@ -17207,11 +17277,11 @@ function commits(org, options2) {
     repoAuthors
   };
   if (options2.json) {
-    console.log(JSON.stringify(report, null, 2));
+    console.log(JSON.stringify(report2, null, 2));
   } else if (repos2.length === 0) {
     console.log(`No commits found in ${org} since ${sinceDate}.`);
   } else {
-    printCommitsReport(report);
+    printCommitsReport(report2);
   }
 }
 
@@ -25482,6 +25552,243 @@ function registerVoice(program2) {
   configHelp(voiceCommand, voiceConfigHelp);
 }
 
+// src/commands/watch/describeOutcome.ts
+var short = (sha) => sha.slice(0, 7);
+function describeOutcome(outcome) {
+  switch (outcome.kind) {
+    case "moved":
+      return {
+        exitCode: 0,
+        message: `remote moved: ${short(outcome.from)}..${short(outcome.to)} (${outcome.count} commit${outcome.count === 1 ? "" : "s"})`
+      };
+    case "timeout":
+      return {
+        exitCode: 2,
+        message: `no movement on ${outcome.upstream} after ${outcome.timeout}`
+      };
+    case "unavailable":
+      return { exitCode: 1, message: `cannot wait: ${outcome.reason}` };
+    case "interrupted":
+      return { exitCode: 130, message: "interrupted" };
+  }
+}
+
+// src/commands/watch/describePull.ts
+function describePull(result) {
+  if (result.kind === "fast-forwarded") {
+    return {
+      exitCode: 0,
+      message: `pulled --ff-only \u2192 ${result.sha.slice(0, 7)}`
+    };
+  }
+  return {
+    exitCode: 3,
+    message: `pull was not a fast-forward:
+${result.reason}`
+  };
+}
+
+// src/commands/watch/parseDuration.ts
+var UNIT_MS = { s: 1e3, m: 6e4, h: 36e5 };
+function parseDuration(value) {
+  const match = /^(\d+)(s|m|h)$/.exec(value.trim());
+  if (!match) {
+    throw new Error(
+      `Invalid duration "${value}". Use a whole number followed by s, m, or h (e.g. 30s, 60m, 2h).`
+    );
+  }
+  const amount = Number(match[1]);
+  if (amount === 0) {
+    throw new Error(`Invalid duration "${value}". Value must be at least 1.`);
+  }
+  return amount * UNIT_MS[match[2]];
+}
+
+// src/commands/watch/gitFailureReason.ts
+function gitFailureReason(error) {
+  const streams = error;
+  for (const stream of [streams?.stderr, streams?.stdout]) {
+    const text17 = stream == null ? "" : String(stream).trim();
+    if (text17) return text17;
+  }
+  const message2 = error instanceof Error ? error.message : String(error);
+  return message2.trim() || "git failed without reporting a reason";
+}
+
+// src/commands/watch/resolveUpstream.ts
+import { execFileSync as execFileSync9 } from "child_process";
+function runGit2(args, cwd) {
+  return execFileSync9("git", args, {
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"],
+    cwd
+  }).trim();
+}
+function resolveUpstream(cwd) {
+  try {
+    runGit2(["rev-parse", "--is-inside-work-tree"], cwd);
+  } catch {
+    throw new Error(
+      "not a git repository \u2014 run assist watch wait from inside a repo"
+    );
+  }
+  let branch2;
+  try {
+    branch2 = runGit2(["symbolic-ref", "--quiet", "--short", "HEAD"], cwd);
+  } catch {
+    throw new Error(
+      "HEAD is detached \u2014 check out a branch before waiting on its upstream"
+    );
+  }
+  try {
+    return {
+      branch: branch2,
+      upstream: runGit2(
+        ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
+        cwd
+      )
+    };
+  } catch {
+    throw new Error(
+      `branch "${branch2}" has no upstream \u2014 set one with: git push -u origin ${branch2}`
+    );
+  }
+}
+
+// src/commands/watch/pullFastForward.ts
+function pullFastForward(cwd) {
+  try {
+    runGit2(["pull", "--ff-only"], cwd);
+    return { kind: "fast-forwarded", sha: runGit2(["rev-parse", "@"], cwd) };
+  } catch (error) {
+    return { kind: "blocked", reason: gitFailureReason(error) };
+  }
+}
+
+// src/commands/watch/fetchQuietly.ts
+import { execFileSync as execFileSync10 } from "child_process";
+function fetchQuietly(cwd, timeoutMs) {
+  try {
+    execFileSync10("git", ["fetch", "--quiet"], {
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd,
+      timeout: timeoutMs
+    });
+  } catch {
+  }
+}
+
+// src/commands/watch/detectMovement.ts
+function detectMovement(from, to, count7) {
+  if (from === to) return void 0;
+  if (!Number.isFinite(count7) || count7 <= 0) return void 0;
+  return { from, to, count: count7 };
+}
+
+// src/commands/watch/readMovement.ts
+function readMovement(cwd) {
+  try {
+    const from = runGit2(["rev-parse", "@"], cwd);
+    const to = runGit2(["rev-parse", "@{u}"], cwd);
+    const count7 = Number(runGit2(["rev-list", "--count", "@..@{u}"], cwd));
+    return detectMovement(from, to, count7);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/commands/watch/waitForUpstream.ts
+var MIN_FETCH_TIMEOUT_MS = 6e4;
+function waitForUpstream(options2) {
+  const { intervalMs, timeoutMs, timeout, cwd, onStart } = options2;
+  let upstream;
+  try {
+    upstream = resolveUpstream(cwd).upstream;
+  } catch (error) {
+    return Promise.resolve({
+      kind: "unavailable",
+      reason: error instanceof Error ? error.message : String(error)
+    });
+  }
+  onStart?.(upstream);
+  const moved = readMovement(cwd);
+  if (moved) {
+    return Promise.resolve({ kind: "moved", upstream, ...moved });
+  }
+  const fetchTimeoutMs = Math.max(intervalMs, MIN_FETCH_TIMEOUT_MS);
+  return new Promise((resolve20) => {
+    let settled = false;
+    const finish = (outcome) => {
+      if (settled) return;
+      settled = true;
+      clearInterval(ticker);
+      clearTimeout(deadline);
+      process.off("SIGINT", onInterrupt);
+      resolve20(outcome);
+    };
+    const onInterrupt = () => finish({ kind: "interrupted" });
+    const ticker = setInterval(() => {
+      fetchQuietly(cwd, fetchTimeoutMs);
+      const found = readMovement(cwd);
+      if (found) finish({ kind: "moved", upstream, ...found });
+    }, intervalMs);
+    const deadline = setTimeout(
+      () => finish({ kind: "timeout", upstream, timeout }),
+      timeoutMs
+    );
+    process.on("SIGINT", onInterrupt);
+  });
+}
+
+// src/commands/watch/watchWait.ts
+function parseOrExit(value) {
+  try {
+    return parseDuration(value);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return process.exit(1);
+  }
+}
+function report({ exitCode, message: message2 }) {
+  if (exitCode === 0) console.log(message2);
+  else console.error(message2);
+}
+async function watchWait(options2) {
+  const intervalMs = parseOrExit(options2.interval);
+  const timeoutMs = parseOrExit(options2.timeout);
+  const outcome = await waitForUpstream({
+    intervalMs,
+    timeoutMs,
+    timeout: options2.timeout,
+    onStart: (upstream) => console.log(`waiting on ${upstream} \u2026`)
+  });
+  const waitReport = describeOutcome(outcome);
+  report(waitReport);
+  if (outcome.kind === "moved" && options2.pull) {
+    const pullReport = describePull(pullFastForward());
+    report(pullReport);
+    process.exit(pullReport.exitCode);
+  }
+  process.exit(waitReport.exitCode);
+}
+
+// src/commands/registerWatch.ts
+function registerWatch(program2) {
+  const watchCommand = program2.command("watch").description("Wait on upstream movement for the current branch");
+  watchCommand.command("wait").description(
+    "Block until the current branch's upstream gains commits, then exit 0 (2 on timeout, 3 when --pull is not a fast-forward, 1 when waiting is impossible, 130 on interrupt)"
+  ).option("--interval <duration>", "How often to fetch (e.g. 30s, 2m)", "30s").option(
+    "--timeout <duration>",
+    "Give up and exit 2 after this long (e.g. 60m, 2h)",
+    "60m"
+  ).option(
+    "--pull",
+    "On movement, fast-forward with git pull --ff-only; exit 3 with git's reason if it is not a clean fast-forward"
+  ).action(
+    (options2) => watchWait(options2)
+  );
+}
+
 // src/commands/roam/auth.ts
 import { randomBytes } from "crypto";
 import chalk204 from "chalk";
@@ -25642,7 +25949,7 @@ async function auth() {
 }
 
 // src/commands/roam/postRoamActivity.ts
-import { execFileSync as execFileSync9 } from "child_process";
+import { execFileSync as execFileSync11 } from "child_process";
 import { readdirSync as readdirSync11, readFileSync as readFileSync47, statSync as statSync9 } from "fs";
 import { join as join66 } from "path";
 function findPortFile(roamDir) {
@@ -25675,7 +25982,7 @@ function postRoamActivity(app, event) {
   }
   const url = `http://127.0.0.1:${port}/api/v1/activity/${app}/${event}?pid=${app === "codex" ? 99998 : 99999}`;
   try {
-    execFileSync9("curl", ["-sf", "--max-time", "0.2", "-X", "POST", url], {
+    execFileSync11("curl", ["-sf", "--max-time", "0.2", "-X", "POST", url], {
       stdio: "ignore"
     });
   } catch {
@@ -25896,13 +26203,13 @@ function runPreCommands(pre, cwd) {
 }
 
 // src/commands/run/spawnRunCommand.ts
-import { execFileSync as execFileSync10, spawn as spawn8 } from "child_process";
+import { execFileSync as execFileSync12, spawn as spawn8 } from "child_process";
 import { existsSync as existsSync58 } from "fs";
 import { dirname as dirname29, join as join67, resolve as resolve15 } from "path";
 function resolveCommand2(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
   try {
-    const gitPath = execFileSync10("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
+    const gitPath = execFileSync12("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
     const gitRoot = resolve15(dirname29(gitPath), "..");
     const gitBash = join67(gitRoot, "bin", "bash.exe");
     if (existsSync58(gitBash)) return gitBash;
@@ -26355,11 +26662,11 @@ function screenshot(processName) {
 }
 
 // src/commands/sessions/daemon/listDaemonPids.ts
-import { execFileSync as execFileSync11 } from "child_process";
+import { execFileSync as execFileSync13 } from "child_process";
 function listDaemonPids() {
   if (process.platform === "win32") return [];
   try {
-    const out = execFileSync11("ps", ["-eo", "pid=,args="], {
+    const out = execFileSync13("ps", ["-eo", "pid=,args="], {
       encoding: "utf8"
     });
     return out.split("\n").filter((line) => line.includes("assist") && / daemon run\b/.test(line)).map((line) => Number.parseInt(line.trim(), 10)).filter((pid) => Number.isInteger(pid));
@@ -30556,7 +30863,7 @@ function summaryPathFor(jsonlPath2) {
 }
 
 // src/commands/sessions/summarise/summariseSession.ts
-import { execFileSync as execFileSync12 } from "child_process";
+import { execFileSync as execFileSync14 } from "child_process";
 
 // src/commands/sessions/summarise/extractFirstUserMessage.ts
 function extractFirstUserMessage(filePath) {
@@ -30580,7 +30887,7 @@ function summariseSession(jsonlPath2) {
   }
   const prompt = buildPrompt3(firstMessage, backlogIds);
   try {
-    const output = execFileSync12("claude", ["-p", "--model", "haiku", prompt], {
+    const output = execFileSync14("claude", ["-p", "--model", "haiku", prompt], {
       encoding: "utf8",
       timeout: 3e4,
       stdio: ["ignore", "pipe", "ignore"]
@@ -31267,6 +31574,7 @@ registerSeq(program);
 registerSql(program);
 registerTranscript(program);
 registerVoice(program);
+registerWatch(program);
 registerSessions(program);
 registerDaemon(program);
 registerPrompts(program);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@staff0rd/assist",
-	"version": "0.454.1",
+	"version": "0.456.0",
 	"type": "module",
 	"main": "dist/index.js",
 	"bin": {