@armstrongnate/april 0.1.3 → 0.2.0

package/dist/commands/investigate.js

@@ -0,0 +1,93 @@
+import { loadConfig } from "../config.js";
+import { getAgent } from "../agents.js";
+import { getSessionBackend } from "../session/index.js";
+import { slugify } from "../slug.js";
+import { resolveRepo, INVESTIGATE_PREFIX } from "../work.js";
+import { INVESTIGATE_SKILL } from "../skill.js";
+const USAGE = `april investigate "<problem>" [--repo OWNER/NAME] [--auto]
+
+  Dispatch a research agent in the CURRENT directory to investigate a problem
+  and file a GitHub issue. The session may span repos; it is not tied to a
+  worktree.
+
+  "<problem>"  free-text description of what to investigate
+  --repo       suggest the owning repo (the agent still decides where it belongs)
+  --auto       create the issue already labeled so april picks it up immediately
+  --review     explicit deferred mode (the default): file for human review, no label
+  --dry-run    print the session name and the prompt that would be dispatched, then exit`;
+export async function run(args) {
+    let repoFlag;
+    let auto = false;
+    let dryRun = false;
+    const words = [];
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--repo") {
+            repoFlag = args[++i];
+            if (!repoFlag)
+                throw new Error("--repo requires a value");
+        }
+        else if (a === "--auto") {
+            auto = true;
+        }
+        else if (a === "--review") {
+            auto = false;
+        }
+        else if (a === "--dry-run") {
+            dryRun = true;
+        }
+        else if (a.startsWith("--")) {
+            console.error(`Unknown option: ${a}\n\n${USAGE}`);
+            return 2;
+        }
+        else {
+            words.push(a);
+        }
+    }
+    const problem = words.join(" ").trim();
+    if (!problem) {
+        console.error(`Missing problem description.\n\n${USAGE}`);
+        return 2;
+    }
+    const config = loadConfig();
+    // Validate the hint early so a typo'd --repo fails before spawning a session.
+    const suggested = repoFlag ? resolveRepo(config, repoFlag) : undefined;
+    const mode = auto ? "auto" : "deferred";
+    const cwd = process.cwd();
+    const shortId = Date.now().toString(36).slice(-4);
+    const slug = `${INVESTIGATE_PREFIX}${shortId}-${slugify(problem, 30, "investigation")}`;
+    const repoList = config.repos
+        .map((r) => `  - ${r.owner}/${r.name} — ${r.path}`)
+        .join("\n");
+    const modeLine = mode === "auto"
+        ? `create the issue assigned to ${config.assignee} AND apply the "${config.label}" label so april picks it up immediately.`
+        : `create the issue assigned to ${config.assignee} WITHOUT the "${config.label}" label, then print the URL for review.`;
+    const body = [
+        problem,
+        "",
+        "Context for filing the issue:",
+        `- Assignee: ${config.assignee}`,
+        `- Trigger label: ${config.label}`,
+        `- Mode: ${mode}`,
+        ...(suggested ? [`- Suggested owning repo: ${suggested.owner}/${suggested.name}`] : []),
+        "- Candidate repos:",
+        repoList,
+        "",
+        `Investigate the problem above, then ${modeLine}`,
+    ].join("\n");
+    const agent = getAgent(config.llm);
+    const prompt = agent.buildPrompt(INVESTIGATE_SKILL, body);
+    const command = agent.buildCommand(config);
+    if (dryRun) {
+        console.log(`session: ${slug}`);
+        console.log(`cwd:     ${cwd}`);
+        console.log(`mode:    ${mode}`);
+        console.log(`command: ${command}`);
+        console.log(`\nprompt:\n${prompt}`);
+        return 0;
+    }
+    console.log(`Starting investigation "${slug}" in ${cwd} (${mode} mode)…`);
+    await getSessionBackend(config).spawn({ name: slug, cwd, command, prompt });
+    console.log(`Done. Track it with \`april ps\`; attach to the session "${slug}".`);
+    return 0;
+}

package/dist/commands/kill.js

@@ -0,0 +1,91 @@
+import { execFileSync } from "node:child_process";
+import { findConfigPath, parseConfigFile } from "../config.js";
+import { getSessionBackend } from "../session/index.js";
+import { listActiveWork } from "../work.js";
+const USAGE = `april kill <slug|issue> [--repo OWNER/NAME] [--worktree]
+
+  Kill a single session by slug or issue number. Works for investigations
+  (inv-…) too. With --worktree, also remove the backing worktree.
+
+  <slug|issue>  a session slug (gh-123-…, inv-…) or an issue number (123)
+  --repo        disambiguate when an issue number matches more than one repo
+  --worktree    also remove the worktree (only applies to issue work)`;
+export async function run(args) {
+    let target;
+    let repoFlag;
+    let withWorktree = false;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--repo") {
+            repoFlag = args[++i];
+            if (!repoFlag)
+                throw new Error("--repo requires a value");
+        }
+        else if (a === "--worktree") {
+            withWorktree = true;
+        }
+        else if (a.startsWith("--")) {
+            console.error(`Unknown option: ${a}\n\n${USAGE}`);
+            return 2;
+        }
+        else if (!target) {
+            target = a;
+        }
+        else {
+            console.error(`Unexpected argument: ${a}\n\n${USAGE}`);
+            return 2;
+        }
+    }
+    if (!target) {
+        console.error(`Missing slug or issue number.\n\n${USAGE}`);
+        return 2;
+    }
+    const config = parseConfigFile(findConfigPath());
+    const items = await listActiveWork(config);
+    let slug;
+    let item;
+    if (/^#?\d+$/.test(target)) {
+        const n = parseInt(target.replace(/^#/, ""), 10);
+        let matches = items.filter((it) => it.issueNumber === n);
+        if (repoFlag)
+            matches = matches.filter((it) => it.repo === repoFlag || it.repo?.endsWith(`/${repoFlag}`));
+        if (matches.length === 0) {
+            console.log(`No active session or worktree for issue #${n}.`);
+            return 0;
+        }
+        if (matches.length > 1) {
+            console.error(`#${n} matches multiple repos — pass --repo OWNER/NAME:`);
+            for (const m of matches)
+                console.error(`  ${m.repo} (${m.slug})`);
+            return 2;
+        }
+        item = matches[0];
+        slug = item.slug;
+    }
+    else {
+        slug = target;
+        item = items.find((it) => it.slug === target);
+    }
+    console.log(`Killing session "${slug}"…`);
+    await getSessionBackend(config).kill(slug);
+    if (withWorktree) {
+        if (item?.repoPath && item.worktreePath) {
+            try {
+                execFileSync("wt", ["remove", slug, "-f", "-D"], {
+                    cwd: item.repoPath,
+                    timeout: 60_000,
+                    stdio: "pipe",
+                });
+                console.log(`Removed worktree ${item.worktreePath}`);
+            }
+            catch (err) {
+                console.warn(`wt remove ${slug} failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        else {
+            console.log("No worktree associated with this session — nothing to remove.");
+        }
+    }
+    console.log("Done.");
+    return 0;
+}

package/dist/commands/ps.js

@@ -0,0 +1,70 @@
+import { findConfigPath, parseConfigFile } from "../config.js";
+import { listActiveWork } from "../work.js";
+import { daemonStatus } from "../daemon.js";
+const USAGE = `april ps [--json]
+
+  List active work — issues in flight and investigations — derived from
+  worktrees and live sessions. Works whether or not the daemon is running.`;
+function fmtUptime(seconds) {
+    const s = Math.floor(seconds);
+    const h = Math.floor(s / 3600);
+    const m = Math.floor((s % 3600) / 60);
+    if (h > 0)
+        return `${h}h${m}m`;
+    if (m > 0)
+        return `${m}m${s % 60}s`;
+    return `${s}s`;
+}
+function renderTable(items) {
+    const header = ["KIND", "ISSUE", "SESSION", "REPO", "SLUG"];
+    const rows = items.map((it) => [
+        it.kind === "investigation" ? "investigate" : "issue",
+        it.issueNumber ? `#${it.issueNumber}` : "-",
+        it.sessionAlive ? "live" : "stale",
+        it.repo ?? "-",
+        it.slug,
+    ]);
+    const widths = header.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
+    const fmt = (cols) => cols.map((c, i) => c.padEnd(widths[i])).join("  ").trimEnd();
+    console.log(fmt(header));
+    for (const r of rows)
+        console.log(fmt(r));
+}
+export async function run(args) {
+    const wantJson = args.includes("--json");
+    for (const a of args) {
+        if (a !== "--json") {
+            console.error(`Unknown option: ${a}\n\n${USAGE}`);
+            return 2;
+        }
+    }
+    let config;
+    try {
+        config = parseConfigFile(findConfigPath());
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return 1;
+    }
+    const items = await listActiveWork(config);
+    const status = await daemonStatus(config.port);
+    if (wantJson) {
+        console.log(JSON.stringify({ daemon: status, work: items }, null, 2));
+        return 0;
+    }
+    if (status) {
+        const fw = status.forwarders;
+        const liveFw = fw.filter((f) => f.alive).length;
+        console.log(`daemon: up (${fmtUptime(status.uptime)}), ${liveFw}/${fw.length} forwarder${fw.length === 1 ? "" : "s"} live`);
+    }
+    else {
+        console.log(`daemon: not reachable on :${config.port}`);
+    }
+    console.log("");
+    if (items.length === 0) {
+        console.log("No active work.");
+        return 0;
+    }
+    renderTable(items);
+    return 0;
+}

package/dist/commands/run-issue.js

@@ -0,0 +1,46 @@
+import { loadConfig } from "../config.js";
+import { handleNewIssue } from "../spawner.js";
+import { parseIssueRef, resolveRepo, fetchIssue } from "../work.js";
+const USAGE = `april run <issue> [--repo OWNER/NAME]
+
+  Manually start work on an issue — the same path the daemon takes on a
+  labeled+assigned webhook, minus the label requirement. Creates the worktree,
+  spawns the agent session, and flips labels to agent:wip.
+
+  <issue>   123, #123, or owner/name#123
+  --repo    Repo to act on when <issue> is a bare number and multiple are configured.`;
+export async function run(args) {
+    let ref;
+    let repoFlag;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--repo") {
+            repoFlag = args[++i];
+            if (!repoFlag)
+                throw new Error("--repo requires a value");
+        }
+        else if (a.startsWith("--")) {
+            console.error(`Unknown option: ${a}\n\n${USAGE}`);
+            return 2;
+        }
+        else if (!ref) {
+            ref = a;
+        }
+        else {
+            console.error(`Unexpected argument: ${a}\n\n${USAGE}`);
+            return 2;
+        }
+    }
+    if (!ref) {
+        console.error(`Missing issue reference.\n\n${USAGE}`);
+        return 2;
+    }
+    const config = loadConfig();
+    const { repoRef, number } = parseIssueRef(ref);
+    const repo = resolveRepo(config, repoFlag ?? repoRef);
+    const issue = fetchIssue(repo, number);
+    console.log(`Starting work on ${repo.owner}/${repo.name}#${issue.number} — "${issue.title}"`);
+    await handleNewIssue(repo, issue, config);
+    console.log(`Done. Track it with \`april ps\`.`);
+    return 0;
+}

package/dist/config.js

@@ -7,7 +7,7 @@ import { createLogger } from "./logger.js";
 import { isGhWebhookExtensionInstalled, GH_EXTENSION_INSTALL_CMD } from "./precheck.js";
 import { AGENT_KINDS, getAgent } from "./agents.js";
 const log = createLogger("config");
-function findConfigPath() {
+export function findConfigPath() {
     const envPath = process.env.APRIL_CONFIG;
     if (envPath) {
         if (!existsSync(envPath)) {
@@ -29,13 +29,23 @@ function findConfigPath() {
         `  - ${localPath}\n` +
         "Create a config.yaml (see config.example.yaml).");
 }
+/** Whether a binary is resolvable on PATH. Non-throwing; used by `doctor`. */
+export function checkTool(tool) {
+    try {
+        execSync(`which ${tool}`, { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** The external binaries april needs for this agent + session backend. */
+export function requiredTools(agentCli, sessionManager) {
+    return ["gh", "git", agentCli, sessionManager === "herdr" ? "herdr" : "tmux"];
+}
 function validateTools(agentCli, sessionManager) {
-    const tools = ["gh", "git", agentCli, sessionManager === "herdr" ? "herdr" : "tmux"];
-    for (const tool of tools) {
-        try {
-            execSync(`which ${tool}`, { stdio: "pipe" });
-        }
-        catch {
+    for (const tool of requiredTools(agentCli, sessionManager)) {
+        if (!checkTool(tool)) {
             throw new Error(`Required tool "${tool}" not found on PATH. Install it before running april.`);
         }
     }

package/dist/daemon.js

@@ -0,0 +1,27 @@
+/**
+ * Tiny client for the running daemon's HTTP endpoints. Used by `ps`/`doctor`
+ * to enrich their output when the daemon is up; every caller treats `null`
+ * (daemon down/unreachable) as a normal, non-error condition.
+ */
+async function getJson(url, timeoutMs = 1500) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, { signal: controller.signal });
+        if (!res.ok)
+            return null;
+        return (await res.json());
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function daemonStatus(port) {
+    return getJson(`http://127.0.0.1:${port}/status`);
+}
+export async function daemonReachable(port) {
+    return (await getJson(`http://127.0.0.1:${port}/health`)) !== null;
+}

package/dist/index.js

@@ -1,5 +1,6 @@
 import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { join, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
 import { createLogger } from "./logger.js";
 import { loadConfig } from "./config.js";
@@ -8,6 +9,16 @@ import { startServer } from "./server.js";
 import { startWebhookForwarders, shutdownForwarders } from "./processes.js";
 const log = createLogger("main");
 const PID_PATH = join(homedir(), ".config", "april", "april.pid");
+function readVersion() {
+    try {
+        // dist/index.js -> package root
+        const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+        return JSON.parse(readFileSync(join(root, "package.json"), "utf-8")).version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
 function checkPidFile() {
     if (!existsSync(PID_PATH))
         return;
@@ -42,7 +53,7 @@ function removePidFile() {
 }
 async function main() {
     console.log("");
-    console.log("  april v0.0.1");
+    console.log(`  april v${readVersion()}`);
     console.log("");
     // 1. Load config
     const config = loadConfig();

package/dist/processes.js

@@ -95,6 +95,14 @@ function spawnForwarder(config, repoKey, url) {
     start();
     return state;
 }
+/** Snapshot of the webhook forwarders, for the daemon's /status endpoint. */
+export function getForwarderStatus() {
+    return forwarders.map((f) => ({
+        repoKey: f.repoKey,
+        alive: !!f.child && !f.child.killed && f.child.exitCode === null && !f.stopped,
+        consecutiveFailures: f.consecutiveFailures,
+    }));
+}
 export function startWebhookForwarders(config) {
     const url = `http://localhost:${config.port}/webhook/github`;
     for (const repo of config.repos) {

package/dist/server.js

@@ -1,7 +1,8 @@
 import Fastify from "fastify";
 import { createLogger } from "./logger.js";
 import { parseWebhookEvent } from "./webhook.js";
-import { isIssueActive, handlePrClosed } from "./spawner.js";
+import { isIssueActive, handlePrClosed, getActiveCounts } from "./spawner.js";
+import { getForwarderStatus } from "./processes.js";
 const log = createLogger("server");
 export async function startServer(config, onNewIssue) {
     const app = Fastify({ logger: false });
@@ -68,6 +69,17 @@ export async function startServer(config, onNewIssue) {
         return reply.code(200).send({ ok: true });
     });
     app.get("/health", async () => ({ status: "ok" }));
+    // Live daemon state for `april ps` / `april doctor`. Everything here is also
+    // derivable from disk, so the CLI degrades gracefully when the daemon is down.
+    app.get("/status", async () => ({
+        uptime: process.uptime(),
+        assignee: config.assignee,
+        label: config.label,
+        sessionManager: config.sessionManager ?? "tmux",
+        repos: config.repos.map((r) => `${r.owner}/${r.name}`),
+        active: await getActiveCounts(config),
+        forwarders: getForwarderStatus(),
+    }));
     await app.listen({ port: config.port, host: "127.0.0.1" });
     log.info(`Server listening on http://127.0.0.1:${config.port}`);
     return app;

package/dist/service/systemd.js

@@ -50,7 +50,7 @@ function ensureSystemctlPresent() {
         throw new Error("systemctl not found on PATH. april service install requires systemd.");
     }
 }
-function lingerEnabled() {
+export function lingerEnabled() {
     try {
         const out = execFileSync("loginctl", ["show-user", process.env.USER ?? ""], {
             encoding: "utf-8",

package/dist/session/herdr.js

@@ -35,11 +35,45 @@ async function waitForAgentReady(paneId, attempts = 10, intervalMs = 1000) {
     log.warn(`Agent in pane ${paneId} never reported a known status; proceeding anyway`);
 }
 const SUBMIT_SETTLE_MS = 1000;
+const INJECT_ATTEMPTS = 4;
 /** Read a pane's current agent status (undefined if unavailable). */
 async function paneStatus(paneId) {
     const res = await herdrRequest("pane.get", { pane_id: paneId });
     return res.pane?.agent_status;
 }
+/** A status that means the agent left the input box and picked up the prompt. */
+function isAccepted(status) {
+    return status !== undefined && status !== "idle" && status !== "unknown";
+}
+const normalizeWhitespace = (text) => text.replace(/\s+/g, " ");
+/**
+ * A short, wrap-safe slice of the prompt to look for in the pane's input box.
+ * Kept brief (and whitespace-normalized) so terminal wrapping or the `❯ `
+ * prefix don't break the substring match against what pane.read returns.
+ */
+function promptSignature(prompt) {
+    return normalizeWhitespace(prompt).trim().slice(0, 24);
+}
+/** Visible (on-screen) text of a pane; "" if it can't be read. */
+async function readVisible(paneId) {
+    try {
+        const res = await herdrRequest("pane.read", {
+            pane_id: paneId,
+            source: "visible",
+        });
+        return res.read?.text ?? "";
+    }
+    catch {
+        // transient; treat as "can't confirm"
+        return "";
+    }
+}
+/** Whether our prompt text currently appears in the pane (i.e. the input box). */
+async function promptIsVisible(paneId, signature) {
+    if (!signature)
+        return true;
+    return normalizeWhitespace(await readVisible(paneId)).includes(signature);
+}
 /**
  * Wait for the agent to leave `idle` — confirmation that the Enter submitted
  * and the agent picked up the prompt. `working`/`blocked`/`done` all mean the
@@ -48,8 +82,7 @@ async function paneStatus(paneId) {
 async function confirmSubmitted(paneId, attempts = 6, intervalMs = 500) {
     for (let i = 0; i < attempts; i++) {
         try {
-            const status = await paneStatus(paneId);
-            if (status && status !== "idle" && status !== "unknown")
+            if (isAccepted(await paneStatus(paneId)))
                 return true;
         }
         catch {
@@ -59,21 +92,53 @@ async function confirmSubmitted(paneId, attempts = 6, intervalMs = 500) {
     }
     return false;
 }
-async function submit(paneId, text) {
-    // send_text writes the raw text; send_keys ["Enter"] submits it as a real
-    // key event. The settle delay between them is load-bearing — see the header
-    // note: without it the Enter is swallowed by Claude's paste burst and the
-    // prompt just sits in the input box (mirrors april's tmux text-then-C-m wait).
-    await herdrRequest("pane.send_text", { pane_id: paneId, text });
-    await delay(SUBMIT_SETTLE_MS);
-    await herdrRequest("pane.send_keys", { pane_id: paneId, keys: ["Enter"] });
-    // Confirm via herdr's own agent_status that the prompt was accepted. If the
-    // agent is still idle, the Enter didn't take — resend it once. Resending
-    // Enter on an already-submitted (empty) input box is a harmless no-op.
-    if (await confirmSubmitted(paneId))
-        return;
-    log.warn(`Agent in pane ${paneId} still idle after submit; resending Enter`);
-    await herdrRequest("pane.send_keys", { pane_id: paneId, keys: ["Enter"] });
+/**
+ * Inject the prompt and verify the agent actually picked it up, retrying around
+ * the two misfires documented in the header. Returns the agent status when we
+ * stop so the caller can log the outcome.
+ *
+ * The loop is self-correcting: each pass first checks whether the agent is
+ * already working (a prior Enter landed even if its confirm timed out — never
+ * retype into a running agent), then ensures the text is in the box (typing it
+ * only if absent, so retries can't duplicate it), then submits and confirms.
+ */
+async function injectPrompt(paneId, prompt) {
+    const signature = promptSignature(prompt);
+    for (let attempt = 1; attempt <= INJECT_ATTEMPTS; attempt++) {
+        const status = await paneStatus(paneId).catch(() => undefined);
+        if (isAccepted(status)) {
+            if (attempt > 1)
+                log.info(`Agent in pane ${paneId} accepted the prompt (status: ${status})`);
+            return status;
+        }
+        // 1. Ensure our text is in the input box — type it only if it isn't there,
+        //    so a retry after a failed submit doesn't append a second copy.
+        if (!(await promptIsVisible(paneId, signature))) {
+            await herdrRequest("pane.send_text", { pane_id: paneId, text: prompt });
+            await delay(SUBMIT_SETTLE_MS);
+        }
+        // 2. Still not there → a Claude startup screen ate the burst. Dismiss it
+        //    with Enter and loop to retype. (That Enter may instead have submitted
+        //    real text on a flaky read, so re-check status before retrying.)
+        if (!(await promptIsVisible(paneId, signature))) {
+            log.warn(`Prompt text not visible in pane ${paneId} input (attempt ${attempt}/${INJECT_ATTEMPTS}); dismissing startup screen and retrying`);
+            await herdrRequest("pane.send_keys", { pane_id: paneId, keys: ["Enter"] });
+            await delay(SUBMIT_SETTLE_MS);
+            const dismissed = await paneStatus(paneId).catch(() => undefined);
+            if (isAccepted(dismissed))
+                return dismissed;
+            continue;
+        }
+        // 3. Text is in the box — submit it and confirm via agent_status.
+        await herdrRequest("pane.send_keys", { pane_id: paneId, keys: ["Enter"] });
+        if (await confirmSubmitted(paneId)) {
+            const accepted = await paneStatus(paneId).catch(() => undefined);
+            log.info(`Prompt submitted to pane ${paneId} on attempt ${attempt} (status: ${accepted ?? "unknown"})`);
+            return accepted;
+        }
+        log.warn(`Agent in pane ${paneId} still idle after Enter (attempt ${attempt}/${INJECT_ATTEMPTS}); will retry`);
+    }
+    return paneStatus(paneId).catch(() => undefined);
 }
 export const herdrBackend = {
     async listSessions() {
@@ -128,10 +193,15 @@ export const herdrBackend = {
             }
         }
         log.info(`Started agent in herdr workspace "${name}" (pane ${paneId})`);
-        // Wait until the agent is up, then inject the prompt.
+        // Wait until the agent is up, then inject the prompt and verify it landed.
         await waitForAgentReady(paneId);
-        await submit(paneId, prompt);
-        log.info(`Prompt sent to herdr workspace "${name}"`);
+        const status = await injectPrompt(paneId, prompt);
+        if (isAccepted(status)) {
+            log.info(`Prompt delivered to herdr workspace "${name}" — agent is ${status} (pane ${paneId})`);
+        }
+        else {
+            log.error(`Prompt may NOT have been accepted in herdr workspace "${name}" — agent status "${status ?? "unavailable"}" after ${INJECT_ATTEMPTS} attempts (pane ${paneId}). The session likely needs manual attention.`);
+        }
     },
     async kill(name) {
         const ws = await findByLabel(name);

package/dist/skill.js

@@ -3,20 +3,25 @@ import { dirname, resolve } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { configuredLlmKind } from "./config.js";
 import { getAgent } from "./agents.js";
-const SKILL_NAME = "issue-worker";
-export function bundledSkillPath() {
-    // dist/skill.js -> dist/.. -> package root, then skills/issue-worker/SKILL.md
+/** Skill that works a labeled issue end-to-end (the daemon's worker). */
+export const ISSUE_WORKER_SKILL = "issue-worker";
+/** Skill that researches a free-text problem and files a GitHub issue. */
+export const INVESTIGATE_SKILL = "issue-investigator";
+/** Every skill april bundles and keeps installed for the configured agent. */
+export const ALL_BUNDLED_SKILLS = [ISSUE_WORKER_SKILL, INVESTIGATE_SKILL];
+export function bundledSkillPath(skill) {
+    // dist/skill.js -> dist/.. -> package root, then skills/<skill>/SKILL.md
     const here = fileURLToPath(import.meta.url);
-    return resolve(dirname(here), "..", "skills", SKILL_NAME, "SKILL.md");
+    return resolve(dirname(here), "..", "skills", skill, "SKILL.md");
 }
-export function skillDestPath(kind = configuredLlmKind()) {
-    return getAgent(kind).skillFile(SKILL_NAME);
+export function skillDestPath(skill, kind = configuredLlmKind()) {
+    return getAgent(kind).skillFile(skill);
 }
-export function compareSkill(kind = configuredLlmKind()) {
-    const dst = skillDestPath(kind);
+export function compareSkill(skill, kind = configuredLlmKind()) {
+    const dst = skillDestPath(skill, kind);
     if (!existsSync(dst))
         return "missing";
-    const src = bundledSkillPath();
+    const src = bundledSkillPath(skill);
     if (!existsSync(src))
         return "matches-bundled"; // can't compare; don't alarm
     return readFileSync(dst).equals(readFileSync(src))