daily-focus 1.2.0-dev.9 → 2.0.0-dev.15

package/dist/{chunk-KL6RU4XT.js → chunk-JTMBBUMD.js}

@@ -1,3 +1,13 @@
+import {
+  canonicalId,
+  foldActionLog
+} from "./chunk-ITUK7XKS.js";
+import {
+  laterISO,
+  localDateKey,
+  parseISO
+} from "./chunk-72NUDSOV.js";
+
 // src/codex.ts
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -99,6 +109,18 @@ async function codexVersionWarning(bin, run = defaultExec) {
   const consequence = olderThan(version, CODEX_CONNECTOR_POLICY) ? `Before ${CODEX_CONNECTOR_POLICY} Codex ignores the dashboard's refusal of connector writes without saying so, so the dashboard won't start the agent or the assistant on it.` : `Before ${CODEX_MINIMUM} Codex can't switch computer use off, so the assistant won't answer while computer use is off in its settings.`;
   return `Codex ${version} is older than ${CODEX_MINIMUM}, the oldest the dashboard's limits on Codex work with. ${consequence} Update Codex.`;
 }
+async function codexLatestModel(bin, run = defaultExec) {
+  try {
+    const catalog = JSON.parse(await run(bin, ["debug", "models"], { timeout: LIST_TIMEOUT_MS }));
+    const listed = (Array.isArray(catalog.models) ? catalog.models : []).filter(
+      (model) => typeof model === "object" && model !== null && typeof model.slug === "string" && typeof model.priority === "number" && model.visibility === "list"
+    );
+    listed.sort((a, b) => a.priority - b.priority);
+    return listed[0]?.slug ?? null;
+  } catch {
+    return null;
+  }
+}
 
 // src/assistant.ts
 import { spawn } from "node:child_process";
@@ -106,6 +128,8 @@ import { randomUUID } from "node:crypto";
 import { appendFile, mkdir, readFile } from "node:fs/promises";
 import { createInterface } from "node:readline";
 var TURN_TIMEOUT_MS = 10 * 6e4;
+var RESTARTED = "the dashboard restarted while this was running";
+var SHUT_DOWN = "the dashboard shut down";
 var TURNS_SHOWN = 20;
 var STEPS_KEPT = 100;
 var DETAIL_LENGTH = 200;
@@ -191,6 +215,7 @@ function foldAssistantLog(text) {
         sessionId: null,
         request: record.request,
         action: typeof record.action === "string" ? record.action : null,
+        auto: typeof record.auto === "string" ? record.auto : null,
         startedAt: record.at,
         endedAt: null,
         status: "running",
@@ -250,7 +275,7 @@ function parseLine(line) {
   }
 }
 var claudeAdapter = {
-  args({ prompt, sessionId, model, effort, tools, denyEdits }) {
+  args({ prompt, sessionId, model, effort, tools, denyEdits, schema }) {
     const args = [
       "-p",
       "--output-format",
@@ -265,6 +290,7 @@ var claudeAdapter = {
     if (tools.length > 0) args.push("--allowedTools", ...tools);
     if (model) args.push("--model", model);
     if (effort) args.push("--effort", effort);
+    if (schema) args.push("--json-schema", schema.json);
     if (sessionId) args.push("--resume", sessionId);
     args.push("--", prompt);
     return args;
@@ -273,6 +299,10 @@ var claudeAdapter = {
     const event = parseLine(line);
     if (!event) return null;
     const type = event.type;
+    if (type === "system" && event.subtype === "task_notification" && typeof event.tool_use_id === "string") {
+      const step = { id: event.tool_use_id, state: event.status === "completed" ? "done" : "failed", final: true };
+      return { steps: [step] };
+    }
     if (type === "system" && typeof event.session_id === "string") {
       return { sessionId: event.session_id };
     }
@@ -284,7 +314,9 @@ var claudeAdapter = {
       if (text) parsed.text = text;
       const steps = content.flatMap((block) => claudeStep(block) ?? []);
       if (steps.length) parsed.steps = steps;
-      return text || steps.length ? parsed : null;
+      if (!text && !steps.length) return null;
+      if (typeof event.parent_tool_use_id === "string") parsed.by = event.parent_tool_use_id;
+      return parsed;
     }
     if (type === "result") {
       const ok = event.is_error !== true && event.subtype === "success";
@@ -297,10 +329,11 @@ var claudeAdapter = {
   }
 };
 var codexAdapter = {
-  args({ prompt, sessionId, model, effort, drafts, codexConfig }) {
+  args({ prompt, sessionId, model, effort, drafts, codexConfig, schema }) {
     const args = ["exec"];
     if (sessionId) args.push("resume");
     args.push("--json", "--skip-git-repo-check");
+    if (schema) args.push("--output-schema", schema.file);
     const config = [
       'sandbox_mode="workspace-write"',
       "sandbox_workspace_write.network_access=true",
@@ -341,7 +374,9 @@ var ADAPTERS = {
   claude: claudeAdapter,
   codex: codexAdapter
 };
-var CLAUDE_QUIET_TOOLS = /* @__PURE__ */ new Set(["ToolSearch", "TodoWrite"]);
+var CLAUDE_QUIET_TOOLS = /* @__PURE__ */ new Set(["ToolSearch", "TodoWrite", "StructuredOutput"]);
+var HANDOFF = "Hand part of it to a subagent";
+var WAIT = "Wait for its subagents";
 function claudeStep(block) {
   if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
     return { id: block.tool_use_id, state: block.is_error === true ? "failed" : "done" };
@@ -366,7 +401,7 @@ function claudeStep(block) {
       return step("List files", said("pattern"));
     case "Task":
     case "Agent":
-      return step("Hand part of it to a subagent", said("description"));
+      return { ...step(HANDOFF, said("description")), handoff: true };
   }
   const mcp = /^mcp__(.+?)__(.+)$/.exec(block.name);
   if (mcp) return step(connectorLabel(mcp[1], mcp[2]), compactArgs(input));
@@ -388,6 +423,7 @@ function codexStep(item, completed) {
   if (item.type === "mcp_tool_call" && typeof item.server === "string" && typeof item.tool === "string") {
     return { id: item.id, text: connectorLabel(item.server, item.tool), detail: compactArgs(item.arguments), state };
   }
+  if (item.type === "collab_tool_call" && item.tool === "wait") return { id: item.id, text: WAIT, detail: null, state };
   if (item.type === "web_search") {
     const action = item.action ?? {};
     if (action.type === "open_page") return { id: item.id, text: "Open a page", detail: shorten(action.url ?? null), state };
@@ -475,7 +511,7 @@ var Assistant = class _Assistant {
     for (const turn of this.turns.values()) {
       if (turn.status !== "running") continue;
       turn.status = "aborted";
-      turn.error = "the dashboard restarted while this was running";
+      turn.error = RESTARTED;
       turn.endedAt = (/* @__PURE__ */ new Date()).toISOString();
       await this.append({
         event: "aborted",
@@ -488,6 +524,15 @@ var Assistant = class _Assistant {
       });
     }
   }
+  /**
+   * Every turn the dashboard started on its own, however old: what has been
+   * asked ahead is never asked again, and the panel's window of recent turns
+   * is no record of that.
+   */
+  autoTurns() {
+    return [...this.turns.values()].filter((turn) => turn.auto !== null);
+  }
+  /** The assistant's half of the state. Asking ahead is `autoask.ts`'s to add, since it needs the board. */
   view() {
     const items = {};
     for (const turn of this.turns.values()) {
@@ -520,9 +565,10 @@ ${typed}` : action.request : typed;
   }
   /**
    * Start a turn. Returns once the process is running, not once it has answered;
-   * the answer arrives through `onChange` and the next state.
+   * the answer arrives through `onChange` and the next state. `auto` marks a
+   * turn the dashboard started on its own, with the key of what it answers.
    */
-  async ask(ask, context) {
+  async ask(ask, context, options = {}) {
     const agent = this.config.assistant.agent;
     if (!agent) throw new Error("the assistant is off; set DAILY_FOCUS_ASSISTANT to claude or codex");
     if (this.running.has(ask.itemId)) throw new Error("the assistant is already working on this item");
@@ -539,6 +585,7 @@ ${typed}` : action.request : typed;
       sessionId: null,
       request: resolved.request,
       action: resolved.action,
+      auto: options.auto ?? null,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       endedAt: null,
       status: "running",
@@ -554,6 +601,7 @@ ${typed}` : action.request : typed;
       agent,
       request: turn.request,
       action: turn.action,
+      ...turn.auto ? { auto: turn.auto } : {},
       at: turn.startedAt
     });
     const prompt = previous ? resolved.request : composePrompt(await this.instructions(), context, resolved.request, this.config.profile);
@@ -653,7 +701,7 @@ ${typed}` : action.request : typed;
   }
   /** Kill everything, for shutdown. The exit handlers write the aborted lines. */
   async close() {
-    for (const itemId of [...this.running.keys()]) await this.stop(itemId, "the dashboard shut down");
+    for (const itemId of [...this.running.keys()]) await this.stop(itemId, SHUT_DOWN);
   }
   async finish(turn, outcome, aborted = false) {
     const at = (/* @__PURE__ */ new Date()).toISOString();
@@ -720,10 +768,268 @@ ${typed}` : action.request : typed;
   }
 };
 
+// src/autoask.ts
+var AUTO_ACTIONS = ["assess-review", "explain-ci"];
+function autoKeys(row) {
+  if (row.court !== "you" || row.status !== "open") return [];
+  const keys = [];
+  const heard = row.reasons.filter((reason) => reason.kind === "changes-requested" || reason.kind === "activity").map((reason) => reason.at ?? "");
+  if (heard.length > 0) keys.push(`assess-review@${heard.sort().at(-1) || row.updatedAt}`);
+  if (row.reasons.some((reason) => reason.kind === "ci-failing")) {
+    const commit = row.headSha ?? row.lastActivityByYou ?? row.updatedAt;
+    keys.push(`explain-ci@${commit}:${[...row.failingChecks].sort().join(",")}`);
+  }
+  return keys;
+}
+function actionOf(key) {
+  const action = key.slice(0, key.indexOf("@"));
+  return AUTO_ACTIONS.includes(action) ? action : null;
+}
+var SETTLE_MS = 1e3;
+var AutoAsk = class {
+  deps;
+  timer = null;
+  /** A look is under way: one at a time, so two can't both start a turn. */
+  looking = false;
+  /** Something changed while a look was under way, so look again after it. */
+  again = false;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  get enabled() {
+    return this.deps.config.assistant.auto && this.deps.assistant.enabled;
+  }
+  /** Something changed — the board, or a turn — so look again shortly. Coalesced. */
+  poke() {
+    if (!this.enabled || this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.consider().catch((err) => {
+        console.error(`[daily-focus] could not ask ahead: ${err.message}`);
+      });
+    }, SETTLE_MS);
+    this.timer.unref();
+  }
+  /**
+   * Start the next question the board calls for, if one may start now. Returns
+   * its key, or null when nothing was started. Each finished turn pokes, which
+   * is what takes the queue on to the next.
+   */
+  async consider() {
+    if (!this.enabled || !this.deps.canStart()) return null;
+    if (this.looking) {
+      this.again = true;
+      return null;
+    }
+    this.looking = true;
+    try {
+      return await this.look();
+    } finally {
+      this.looking = false;
+      if (this.again) {
+        this.again = false;
+        this.poke();
+      }
+    }
+  }
+  async look() {
+    const { assistant } = this.deps;
+    await assistant.start();
+    const asked = assistant.autoTurns();
+    if (asked.some((turn) => turn.status === "running")) return null;
+    if (this.usedToday(asked) >= this.deps.config.assistant.autoLimit) return null;
+    const items = assistant.view().items;
+    const cutShort = (turn) => turn.status === "aborted" && (turn.error === RESTARTED || turn.error === SHUT_DOWN);
+    const done = new Set(asked.filter((turn) => !cutShort(turn)).map((turn) => `${turn.itemId} ${turn.auto}`));
+    for (const row of await this.deps.rows()) {
+      if (items[row.id]?.running) continue;
+      for (const key of autoKeys(row)) {
+        const action = actionOf(key);
+        if (!action || done.has(`${row.id} ${key}`)) continue;
+        try {
+          await assistant.ask({ itemId: row.id, action }, await this.deps.context(row.id), { auto: key });
+          return key;
+        } catch {
+          return null;
+        }
+      }
+    }
+    return null;
+  }
+  /** Asking ahead as the page shows it, for the board's rows as they are now. */
+  view(rows) {
+    const keyed = {};
+    for (const row of rows) {
+      const keys = autoKeys(row);
+      if (keys.length > 0) keyed[row.id] = keys;
+    }
+    return {
+      enabled: this.enabled,
+      limit: this.deps.config.assistant.autoLimit,
+      usedToday: this.usedToday(this.deps.assistant.autoTurns()),
+      rows: keyed
+    };
+  }
+  close() {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+  }
+  /** Turns started on its own today, on the server's calendar, however they went. */
+  usedToday(asked) {
+    const today = localDateKey(this.deps.now?.() ?? /* @__PURE__ */ new Date());
+    return asked.filter((turn) => localDateKey(new Date(turn.startedAt)) === today).length;
+  }
+};
+
+// src/prs.ts
+var NUDGE_AFTER_MS = 24 * 36e5;
+var STALE_DRAFT_AFTER_MS = 14 * 864e5;
+var COURT_ORDER = ["you", "ready", "reviewers", "gate", "blocked", "checks", "draft"];
+function courtOrder(court) {
+  return COURT_ORDER.indexOf(court);
+}
+function ms(iso) {
+  const parsed = parseISO(iso);
+  return parsed ? parsed.getTime() : null;
+}
+function deriveDecision(pr) {
+  if (pr.reviewDecision) return pr.reviewDecision;
+  if (pr.reviews.some((review) => review.state === "CHANGES_REQUESTED")) return "CHANGES_REQUESTED";
+  if (pr.reviews.some((review) => review.state === "APPROVED")) return "APPROVED";
+  return null;
+}
+function matchMergeGates(pr, gates) {
+  if (gates.length === 0) return [];
+  return (pr.pendingChecks ?? []).filter((check) => gates.includes(check.name));
+}
+function newest(pr, state) {
+  return pr.reviews.filter((review) => review.state === state).sort((a, b) => a.at < b.at ? 1 : -1)[0];
+}
+function judge(pr, now, nudgedAt, gates = []) {
+  const decision = deriveDecision(pr);
+  const you = pr.lastActivityByYou ?? null;
+  const others = pr.lastActivityByOthers ?? null;
+  const mergeState = pr.mergeStateStatus ?? null;
+  if (pr.isDraft) {
+    const touched = you ?? pr.createdAt;
+    const idle = now.getTime() - (ms(touched) ?? now.getTime());
+    return { court: "draft", decision, reasons: [], stale: idle >= STALE_DRAFT_AFTER_MS, nudge: false, since: touched };
+  }
+  const reasons = [];
+  if (decision === "CHANGES_REQUESTED") {
+    const request = newest(pr, "CHANGES_REQUESTED");
+    reasons.push({ kind: "changes-requested", login: request?.login, at: request?.at });
+  }
+  if (pr.checks === "failure") reasons.push({ kind: "ci-failing" });
+  if (pr.mergeable === "CONFLICTING" || mergeState === "DIRTY") reasons.push({ kind: "conflicts" });
+  if (mergeState === "BEHIND") reasons.push({ kind: "behind" });
+  const theirMove = others !== null && (you === null || others.at > you);
+  const approval = newest(pr, "APPROVED");
+  const afterApproval = others !== null && approval !== void 0 && others.at > approval.at;
+  const approved = decision === "APPROVED" && !afterApproval;
+  if (theirMove && others && !approved) {
+    reasons.push({ kind: "activity", login: others.login, at: others.at, activity: others.kind });
+  }
+  if (reasons.length > 0) {
+    const since = theirMove && others ? others.at : pr.updatedAt;
+    return { court: "you", decision, reasons, stale: false, nudge: false, since };
+  }
+  const waitingSince = laterISO(pr.readyAt, you) ?? pr.createdAt;
+  const settled = (court, reason) => ({
+    court,
+    decision,
+    reasons: [reason],
+    stale: false,
+    nudge: false,
+    since: waitingSince
+  });
+  if (decision !== "REVIEW_REQUIRED") {
+    const gate = matchMergeGates(pr, gates);
+    if (gate.length > 0) return settled("gate", { kind: "merge-gate", checks: gate });
+    const pending = pr.pendingChecks ?? [];
+    const running = { kind: "checks-pending" };
+    if (pending.length > 0) running.checks = pending;
+    if (mergeState === "BLOCKED" && pending.length === 0) {
+      return settled("blocked", { kind: "merge-blocked" });
+    }
+    if (mergeState === "BLOCKED" || mergeState === "UNSTABLE") return settled("checks", running);
+    if (mergeState === "UNKNOWN") return settled("checks", { kind: "mergeability-unknown" });
+    if (approved) {
+      if (mergeState === "CLEAN" || mergeState === "HAS_HOOKS") {
+        return { court: "ready", decision, reasons: [], stale: false, nudge: false, since: approval?.at ?? pr.updatedAt };
+      }
+      if (mergeState === null) {
+        const unfinished = pr.checks === "pending" || pending.length > 0;
+        if (!unfinished) {
+          return { court: "ready", decision, reasons: [], stale: false, nudge: false, since: approval?.at ?? pr.updatedAt };
+        }
+        return settled("checks", running);
+      }
+    }
+  }
+  const quietSince = laterISO(waitingSince, nudgedAt) ?? waitingSince;
+  const waited = now.getTime() - (ms(quietSince) ?? now.getTime());
+  const verdict = { court: "reviewers", decision, reasons, stale: false, nudge: waited >= NUDGE_AFTER_MS, since: waitingSince };
+  const nudged = ms(nudgedAt);
+  if (nudgedAt && nudged !== null && quietSince === nudgedAt && !verdict.nudge) {
+    verdict.nudgedAt = nudgedAt;
+    verdict.nudgedUntil = new Date(nudged + NUDGE_AFTER_MS).toISOString();
+  }
+  return verdict;
+}
+function resolveBoard(pulls, actions, now, gates = []) {
+  const folded = foldActionLog(actions, now);
+  const rows = pulls.map((pr) => {
+    const log = folded.get(canonicalId(pr.id));
+    const verdict = judge(pr, now, log?.nudgedAt ?? null, gates);
+    const row = { ...pr, ...verdict, status: log?.status === "snoozed" ? "snoozed" : "open", notes: log?.notes ?? [] };
+    if (row.status === "snoozed" && log?.snoozedUntil) row.snoozedUntil = log.snoozedUntil;
+    return row;
+  });
+  return rows.sort((a, b) => {
+    const court = courtOrder(a.court) - courtOrder(b.court);
+    if (court !== 0) return court;
+    if (a.since !== b.since) return a.since < b.since ? -1 : 1;
+    return a.id < b.id ? -1 : 1;
+  });
+}
+function countBoard(rows) {
+  const counts = {
+    you: 0,
+    ready: 0,
+    reviewers: 0,
+    gate: 0,
+    blocked: 0,
+    checks: 0,
+    draft: 0,
+    parked: 0
+  };
+  for (const row of rows) {
+    if (row.status === "snoozed") counts.parked++;
+    else counts[row.court]++;
+  }
+  return counts;
+}
+
 export {
+  computerUseOff,
+  refusalFor,
   CodexGate,
   codexVersionWarning,
+  codexLatestModel,
   QUICK_ACTIONS,
   ADAPTERS,
-  Assistant
+  HANDOFF,
+  WAIT,
+  unwrapShell,
+  connectorLabel,
+  compactArgs,
+  shorten,
+  Assistant,
+  autoKeys,
+  actionOf,
+  AutoAsk,
+  judge,
+  resolveBoard,
+  countBoard
 };

package/dist/chunk-QG4XXKBP.js

@@ -0,0 +1,18 @@
+// src/fs.ts
+import { mkdir, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+async function writeJsonAtomic(path, value) {
+  await mkdir(dirname(path), { recursive: true });
+  const temp = tempPathFor(path);
+  await writeFile(temp, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+  await rename(temp, path);
+}
+function tempPathFor(path) {
+  return `${path}.tmp`;
+}
+
+export {
+  writeJsonAtomic,
+  tempPathFor
+};