daily-focus 1.1.1-dev.2 → 1.2.0-dev.10

package/dist/chunk-GFCWPYEI.js

@@ -1,456 +0,0 @@
-// src/assistant.ts
-import { spawn } from "node:child_process";
-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 TURNS_SHOWN = 20;
-var QUICK_ACTIONS = [
-  {
-    id: "assess-review",
-    label: "Assess the review",
-    sources: ["github"],
-    request: "Read every review comment and requested change on this pull request against the diff. For each one say whether it is right, partly right or mistaken, with the evidence, and what I should do about it."
-  },
-  {
-    id: "explain-ci",
-    label: "Explain the CI failure",
-    sources: ["github"],
-    request: "Find the failing checks on this pull request and read their logs. Explain what is failing, why, and the smallest change that would fix it. Do not attempt the fix."
-  },
-  {
-    id: "summarise-pr",
-    label: "Summarise the change",
-    sources: ["github"],
-    request: "Summarise what this pull request changes and why, in a form I could paste as its description, and flag anything a reviewer is likely to push back on."
-  },
-  {
-    id: "reply-reviewer",
-    label: "Draft replies to reviewers",
-    sources: ["github"],
-    request: "Draft a reply to each open review comment on this pull request, in my voice, agreeing where the reviewer is right and explaining where they are not. Give me the text to post. Do not post it."
-  },
-  {
-    id: "draft-reply",
-    label: "Draft a reply",
-    sources: ["email"],
-    request: "Read the whole thread and draft a reply from me, in my voice, that answers what was asked. Create it as a Gmail draft on this thread so I can open it there. Never send it. If you cannot create drafts, give me the text instead and say so."
-  },
-  {
-    id: "summarise-thread",
-    label: "Summarise the thread",
-    sources: ["email"],
-    request: "Read the whole thread and summarise it: who wants what, what has been decided, and what is still open."
-  },
-  {
-    id: "what-they-need",
-    label: "What do they need from me?",
-    sources: ["email", "slack", "messages"],
-    request: "Read this and tell me exactly what is being asked of me, by whom, by when, and what the smallest adequate response would be."
-  },
-  {
-    id: "summarise-ticket",
-    label: "Summarise the ticket",
-    sources: ["jira"],
-    request: "Read this ticket, its comments and anything it links to, and summarise where it stands: what is done, what is left, and what is blocking it."
-  },
-  {
-    id: "status-comment",
-    label: "Draft a status comment",
-    sources: ["jira"],
-    request: "Read this ticket and its linked pull requests, and draft a short status comment from me for the ticket. Give me the text to post. Do not post it."
-  },
-  {
-    id: "next-steps",
-    label: "Break it into next steps",
-    sources: null,
-    request: "Read whatever this item points at and turn it into three to five concrete next steps I could start on today, smallest first."
-  }
-];
-function foldAssistantLog(text) {
-  const turns = /* @__PURE__ */ new Map();
-  for (const line of text.split("\n")) {
-    if (line.trim() === "") continue;
-    let record;
-    try {
-      record = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (typeof record !== "object" || record === null || typeof record.turn !== "string") continue;
-    if (record.event === "started") {
-      if (typeof record.item !== "string" || typeof record.request !== "string") continue;
-      turns.set(record.turn, {
-        id: record.turn,
-        itemId: record.item,
-        agent: record.agent,
-        sessionId: null,
-        request: record.request,
-        action: typeof record.action === "string" ? record.action : null,
-        startedAt: record.at,
-        endedAt: null,
-        status: "running",
-        reply: "",
-        error: null
-      });
-      continue;
-    }
-    const turn = turns.get(record.turn);
-    if (!turn) continue;
-    turn.sessionId = typeof record.sessionId === "string" ? record.sessionId : turn.sessionId;
-    turn.reply = typeof record.reply === "string" ? record.reply : turn.reply;
-    turn.endedAt = record.at;
-    if (record.event === "finished") {
-      turn.status = "done";
-    } else if (record.event === "failed") {
-      turn.status = "failed";
-      turn.error = record.error;
-    } else if (record.event === "aborted") {
-      turn.status = "aborted";
-      turn.error = record.reason;
-    }
-  }
-  return turns;
-}
-function parseLine(line) {
-  const trimmed = line.trim();
-  if (!trimmed.startsWith("{")) return null;
-  try {
-    const parsed = JSON.parse(trimmed);
-    return typeof parsed === "object" && parsed !== null ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-var claudeAdapter = {
-  args({ prompt, sessionId, model, effort, tools, denyEdits }) {
-    const args = [
-      "-p",
-      "--output-format",
-      "stream-json",
-      "--verbose",
-      "--permission-mode",
-      "dontAsk",
-      "--permission-prompts",
-      "none"
-    ];
-    if (denyEdits) args.push("--disallowedTools", "Edit", "Write", "NotebookEdit");
-    if (tools.length > 0) args.push("--allowedTools", ...tools);
-    if (model) args.push("--model", model);
-    if (effort) args.push("--effort", effort);
-    if (sessionId) args.push("--resume", sessionId);
-    args.push("--", prompt);
-    return args;
-  },
-  parse(line) {
-    const event = parseLine(line);
-    if (!event) return null;
-    const type = event.type;
-    if (type === "system" && typeof event.session_id === "string") {
-      return { sessionId: event.session_id };
-    }
-    if (type === "assistant") {
-      const message = event.message;
-      const content = Array.isArray(message?.content) ? message.content : [];
-      const text = content.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n\n");
-      return text ? { text } : null;
-    }
-    if (type === "result") {
-      const ok = event.is_error !== true && event.subtype === "success";
-      const reply = typeof event.result === "string" ? event.result : void 0;
-      const parsed = { done: ok ? { ok, reply } : { ok, error: reply ?? String(event.subtype ?? "failed") } };
-      if (typeof event.session_id === "string") parsed.sessionId = event.session_id;
-      return parsed;
-    }
-    return null;
-  }
-};
-var codexAdapter = {
-  args({ prompt, sessionId, model, effort }) {
-    const args = ["exec"];
-    if (sessionId) args.push("resume");
-    args.push("--json", "--skip-git-repo-check");
-    args.push("-c", 'sandbox_mode="workspace-write"', "-c", "sandbox_workspace_write.network_access=true");
-    if (model) args.push("-c", `model=${JSON.stringify(model)}`);
-    if (effort) args.push("-c", `model_reasoning_effort=${JSON.stringify(effort)}`);
-    if (sessionId) args.push(sessionId);
-    args.push(prompt);
-    return args;
-  },
-  parse(line) {
-    const event = parseLine(line);
-    if (!event) return null;
-    const type = event.type;
-    if (type === "thread.started" && typeof event.thread_id === "string") {
-      return { sessionId: event.thread_id };
-    }
-    if (type === "item.completed") {
-      const item = event.item;
-      if (item?.type === "agent_message" && typeof item.text === "string") return { text: item.text };
-      return null;
-    }
-    if (type === "turn.completed") return { done: { ok: true } };
-    if (type === "turn.failed" || type === "error") {
-      const error = event.error;
-      const message = typeof event.message === "string" ? event.message : error?.message;
-      return { done: { ok: false, error: message ?? String(type) } };
-    }
-    return null;
-  }
-};
-var ADAPTERS = {
-  claude: claudeAdapter,
-  codex: codexAdapter
-};
-function composePrompt(instructions, context, request, profile) {
-  const now = /* @__PURE__ */ new Date();
-  const facts = [`- Profile: ${profile}`, `- Today: ${now.toISOString().slice(0, 10)}`];
-  const parts = [instructions.trim(), "", "## Context", "", ...facts, ""];
-  if (context.item) parts.push("### The item", "", "```json", JSON.stringify(context.item, null, 2), "```", "");
-  if (context.pull) parts.push("### The pull request, as the board last saw it", "", "```json", JSON.stringify(context.pull, null, 2), "```", "");
-  if (context.ticket) parts.push("### The ticket, as the board last saw it", "", "```json", JSON.stringify(context.ticket, null, 2), "```", "");
-  parts.push("## Request", "", request.trim());
-  return parts.join("\n");
-}
-var Assistant = class _Assistant {
-  turns = /* @__PURE__ */ new Map();
-  running = /* @__PURE__ */ new Map();
-  loaded = false;
-  config;
-  hooks;
-  spawnFn;
-  constructor(config, hooks, spawnFn = spawn) {
-    this.config = config;
-    this.hooks = hooks;
-    this.spawnFn = spawnFn;
-  }
-  get enabled() {
-    return this.config.assistant.agent !== null;
-  }
-  /** Whether any turn has a process going right now. */
-  get busy() {
-    return this.running.size > 0;
-  }
-  /**
-   * Read the log, and close whatever was left running when the last process
-   * died. Cheap when the assistant is off: the log is read only if it exists.
-   */
-  async start() {
-    if (this.loaded) return;
-    this.loaded = true;
-    let text = "";
-    try {
-      text = await readFile(this.config.assistantLogFile, "utf8");
-    } catch {
-      return;
-    }
-    for (const [id, turn] of foldAssistantLog(text)) this.turns.set(id, turn);
-    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.endedAt = (/* @__PURE__ */ new Date()).toISOString();
-      await this.append({
-        event: "aborted",
-        turn: turn.id,
-        sessionId: turn.sessionId,
-        reason: turn.error,
-        reply: turn.reply,
-        at: turn.endedAt
-      });
-    }
-  }
-  view() {
-    const items = {};
-    for (const turn of this.turns.values()) {
-      const entry = items[turn.itemId] ??= { running: false, sessionId: null, turns: [] };
-      entry.turns.push(turn);
-      if (turn.status === "running") entry.running = true;
-      if (turn.sessionId && turn.agent === this.config.assistant.agent) entry.sessionId = turn.sessionId;
-    }
-    for (const entry of Object.values(items)) {
-      entry.turns.sort((a, b) => a.startedAt.localeCompare(b.startedAt));
-      entry.turns = entry.turns.slice(-TURNS_SHOWN);
-    }
-    return {
-      enabled: this.enabled,
-      agent: this.config.assistant.agent,
-      quickActions: [...QUICK_ACTIONS],
-      items
-    };
-  }
-  /** The request text an ask resolves to, or null when there is nothing to send. */
-  static requestFor(ask) {
-    const action = ask.action ? QUICK_ACTIONS.find((candidate) => candidate.id === ask.action) : void 0;
-    if (ask.action && !action) return null;
-    const typed = (ask.text ?? "").trim();
-    if (!action && typed === "") return null;
-    const request = action ? typed ? `${action.request}
-
-${typed}` : action.request : typed;
-    return { request, action: action?.id ?? null };
-  }
-  /**
-   * Start a turn. Returns once the process is running, not once it has answered;
-   * the answer arrives through `onChange` and the next state.
-   */
-  async ask(ask, context) {
-    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");
-    const resolved = _Assistant.requestFor(ask);
-    if (!resolved) throw new Error("nothing to ask: give a quick action or some text");
-    await this.start();
-    const previous = this.view().items[ask.itemId]?.sessionId ?? null;
-    const turn = {
-      id: randomUUID(),
-      itemId: ask.itemId,
-      agent,
-      // Null until the CLI says: a resumed session that fails must not be
-      // recorded as if this CLI had owned it.
-      sessionId: null,
-      request: resolved.request,
-      action: resolved.action,
-      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      endedAt: null,
-      status: "running",
-      reply: "",
-      error: null
-    };
-    this.turns.set(turn.id, turn);
-    await this.append({
-      event: "started",
-      turn: turn.id,
-      item: turn.itemId,
-      agent,
-      request: turn.request,
-      action: turn.action,
-      at: turn.startedAt
-    });
-    const prompt = previous ? resolved.request : composePrompt(await this.instructions(), context, resolved.request, this.config.profile);
-    await mkdir(this.config.assistantDir, { recursive: true });
-    const adapter = ADAPTERS[agent];
-    const args = adapter.args({
-      prompt,
-      sessionId: previous,
-      model: this.config.assistant.model,
-      effort: this.config.assistant.effort,
-      tools: this.config.assistant.tools,
-      denyEdits: true
-    });
-    let child;
-    try {
-      child = this.spawnFn(this.config.assistant.binPath, args, {
-        cwd: this.config.assistantDir,
-        // Stdin closed: both CLIs wait on it otherwise, one of them for three seconds.
-        stdio: ["ignore", "pipe", "pipe"],
-        env: process.env
-      });
-    } catch (err) {
-      await this.finish(turn, { ok: false, error: this.spawnError(err) });
-      return turn;
-    }
-    const timer = setTimeout(() => this.stop(turn.itemId, "gave up after ten minutes"), TURN_TIMEOUT_MS);
-    timer.unref();
-    const run = { turn, child, timer, abortReason: null };
-    this.running.set(turn.itemId, run);
-    this.hooks.onChange();
-    let done;
-    const stderr = [];
-    child.stderr?.on("data", (chunk) => {
-      stderr.push(chunk.toString("utf8"));
-      if (stderr.length > 50) stderr.shift();
-    });
-    if (child.stdout) {
-      const lines = createInterface({ input: child.stdout });
-      lines.on("line", (line) => {
-        const event = adapter.parse(line);
-        if (!event) return;
-        if (event.sessionId) turn.sessionId = event.sessionId;
-        if (event.text) {
-          turn.reply = turn.reply ? `${turn.reply}
-
-${event.text}` : event.text;
-          this.hooks.onChange();
-        }
-        if (event.done) done = event.done;
-      });
-    }
-    child.on("error", (err) => {
-      done = { ok: false, error: this.spawnError(err) };
-    });
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      this.running.delete(turn.itemId);
-      const outcome = run.abortReason ? { ok: false, error: run.abortReason } : done ?? {
-        ok: false,
-        error: `${agent} exited with code ${code}${stderr.length ? `: ${stderr.join("").trim().split("\n").slice(-3).join(" ")}` : ""}`
-      };
-      void this.finish(turn, outcome, run.abortReason !== null);
-    });
-    return turn;
-  }
-  /** Kill the turn running on an item, if any. */
-  async stop(itemId, reason = "stopped") {
-    const run = this.running.get(itemId);
-    if (!run) return false;
-    run.abortReason = reason;
-    run.child.kill("SIGTERM");
-    return true;
-  }
-  /** 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");
-  }
-  async finish(turn, outcome, aborted = false) {
-    const at = (/* @__PURE__ */ new Date()).toISOString();
-    const reply = outcome.reply ?? turn.reply;
-    turn.reply = reply;
-    turn.endedAt = at;
-    if (outcome.ok) {
-      turn.status = "done";
-      await this.append({ event: "finished", turn: turn.id, sessionId: turn.sessionId, reply, at });
-    } else if (aborted) {
-      turn.status = "aborted";
-      turn.error = outcome.error ?? "stopped";
-      await this.append({ event: "aborted", turn: turn.id, sessionId: turn.sessionId, reason: turn.error, reply, at });
-    } else {
-      turn.status = "failed";
-      turn.error = outcome.error ?? "failed";
-      await this.append({ event: "failed", turn: turn.id, sessionId: turn.sessionId, error: turn.error, reply, at });
-    }
-    this.hooks.onChange();
-  }
-  spawnError(err) {
-    const code = err.code;
-    const bin = this.config.assistant.binPath;
-    if (code === "ENOENT") return `could not find ${bin}; install it or set DAILY_FOCUS_ASSISTANT_BIN to its path`;
-    return `could not run ${bin}: ${err instanceof Error ? err.message : String(err)}`;
-  }
-  /** The store's copy, or the repo's before `npm run init` has linked it. */
-  async instructions() {
-    for (const path of [this.config.assistantPromptFile, this.config.assistantPromptSource]) {
-      try {
-        return await readFile(path, "utf8");
-      } catch {
-      }
-    }
-    return "You are helping with one item from a personal dashboard. Read only; never send, post or edit anything.";
-  }
-  /**
-   * The log records what happened; the turn in memory is updated by the caller
-   * first. Only this process writes the file, so the memory never has to be
-   * re-read from it.
-   */
-  async append(record) {
-    await mkdir(this.config.dataDir, { recursive: true });
-    await appendFile(this.config.assistantLogFile, `${JSON.stringify(record)}
-`, "utf8");
-  }
-};
-
-export {
-  QUICK_ACTIONS,
-  ADAPTERS,
-  Assistant
-};