scribeclock 0.0.0-stage → 0.1.0

package/dist/commands/automation.js

@@ -0,0 +1,420 @@
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { createInterface } from "node:readline";
+import { CliError, usageError } from "../cli/errors.js";
+import { confirm } from "../cli/confirm.js";
+import { McpClient, PROTOCOL_VERSION } from "../mcp/client.js";
+import { sensitivity } from "../cli/policy.js";
+import { kebab, requireArgs } from "../mcp/schema.js";
+import { renderResult } from "../render.js";
+import { EXIT } from "../types.js";
+import { fmtDate, parseWhen, startOfDay, startOfWeek, startOfMonth } from "../util/format.js";
+import { PROJECT_FLAG, cmd, num, personName, projectIdArg, renderTaskTable, str } from "./_shared.js";
+import { executeGuarded } from "./tools.js";
+// ---------------------------------------------------------------------------
+// watch tasks
+// ---------------------------------------------------------------------------
+export const watchTasks = cmd({
+    path: "watch tasks",
+    group: "Automation & agents",
+    summary: "Stream task changes to the terminal (or NDJSON with --json); --on-change runs a command per change.",
+    description: "Polls list_tasks(updated_since) every --interval seconds and prints each changed task. With --json each change is one NDJSON line (pipe into jq). --on-change <cmd> runs a shell command per change with SCRIBECLOCK_EVENT (the task as JSON), SCRIBECLOCK_TASK_KEY, SCRIBECLOCK_TASK_STATUS and SCRIBECLOCK_TASK_TITLE in its environment.",
+    tool: "list_tasks",
+    flags: [
+        { name: "interval", alias: "i", type: "number", description: "Seconds between polls (default 30, min 5).", default: 30 },
+        { name: "on-change", type: "string", placeholder: "<cmd>", description: "Shell command to run for each changed task." },
+        { name: "assignee", alias: "a", type: "string", description: "Only this person's tasks (me, unassigned, name…)." },
+        PROJECT_FLAG,
+        { name: "status", alias: "s", type: "string", choices: ["open", "all", "pending", "in-progress", "completed", "cancelled"], description: "Status filter (default all)." },
+        { name: "since", type: "string", placeholder: "<when>", description: "Start from this time instead of now." },
+        { name: "once", type: "boolean", description: "Poll once and exit (for cron / tests)." },
+    ],
+    examples: ["scribeclock watch tasks --assignee me", "scribeclock watch tasks --json | jq -r '.key + \" \" + .status'", "scribeclock watch tasks --on-change 'osascript -e \"display notification \\\"$SCRIBECLOCK_TASK_TITLE\\\" with title \\\"$SCRIBECLOCK_TASK_KEY\\\"\"'"],
+    async run(ctx, inv) {
+        const interval = Math.max(5, Number(inv.flags.interval ?? 30)) * 1000;
+        let since = str(inv.flags.since) ? parseWhen(String(inv.flags.since), ctx.now()) ?? ctx.now() : ctx.now();
+        const seen = new Map();
+        let stop = false;
+        const onSignal = () => {
+            stop = true;
+        };
+        process.once("SIGINT", onSignal);
+        process.once("SIGTERM", onSignal);
+        if (!ctx.flags.json)
+            ctx.out.info(ctx.out.dim(`Watching tasks every ${interval / 1000}s from ${fmtDate(since.toISOString(), { time: true })} (Ctrl-C to stop)…`));
+        try {
+            do {
+                const pollStart = ctx.now();
+                const data = await ctx.call("list_tasks", { updated_since: since.toISOString(), status: str(inv.flags.status) ?? "all", assignee: str(inv.flags.assignee), project_id: await projectIdArg(ctx, inv), order_by: "updated", limit: 200 });
+                const tasks = (data.tasks ?? []).filter((t) => seen.get(String(t.id)) !== String(t.updated_at));
+                for (const t of tasks.reverse()) {
+                    seen.set(String(t.id), String(t.updated_at));
+                    if (ctx.flags.json)
+                        ctx.out.ndjson({ event: "task_updated", at: t.updated_at, ...t });
+                    else
+                        ctx.out.log(`${ctx.out.dim(fmtDate(String(t.updated_at), { time: true }))} ${ctx.out.bold(String(t.key))} ${String(t.title)} · ${String(t.status)}${t.assignee ? ` · ${personName(t.assignee)}` : ""}`);
+                    if (inv.flags["on-change"])
+                        await runHook(ctx, String(inv.flags["on-change"]), t);
+                }
+                since = new Date(pollStart.getTime() - 1000);
+                if (inv.flags.once || stop)
+                    break;
+                await new Promise((r) => setTimeout(r, interval));
+            } while (!stop);
+        }
+        finally {
+            process.off("SIGINT", onSignal);
+            process.off("SIGTERM", onSignal);
+        }
+        return EXIT.OK;
+    },
+});
+function runHook(ctx, command, task) {
+    return new Promise((resolve) => {
+        const child = spawn(command, { shell: true, cwd: ctx.cwd, stdio: ["ignore", "inherit", "inherit"], env: { ...ctx.env, SCRIBECLOCK_EVENT: JSON.stringify(task), SCRIBECLOCK_TASK_KEY: String(task.key ?? ""), SCRIBECLOCK_TASK_STATUS: String(task.status ?? ""), SCRIBECLOCK_TASK_TITLE: String(task.title ?? "") } });
+        child.on("exit", (code) => {
+            if (code)
+                ctx.out.warn(`--on-change exited ${code}`);
+            resolve();
+        });
+        child.on("error", (err) => {
+            ctx.out.warn(`--on-change failed: ${err.message}`);
+            resolve();
+        });
+    });
+}
+export const serveCommand = cmd({
+    path: "serve",
+    group: "Automation & agents",
+    summary: "Run as a local MCP server over stdio (for clients that prefer local servers); proxies every tool to ScribeClock with your login.",
+    description: "Speaks MCP over stdin/stdout (newline-delimited JSON-RPC) and forwards initialize / tools/list / tools/call to the remote server using the CLI's stored login or SCRIBECLOCK_TOKEN. `scribeclock mcp-config <client> --local` prints the matching client configuration.",
+    tool: ["get_viewer"],
+    flags: [{ name: "stdio", type: "boolean", description: "Use stdio (the only transport; present for symmetry with other servers).", default: true }],
+    examples: ["scribeclock serve --stdio", "scribeclock mcp-config claude-code --local"],
+    async run(ctx) {
+        const client = ctx.client();
+        const rpc = client instanceof McpClient ? client : null;
+        const log = (line) => ctx.out.stderr.write(`[scribeclock serve] ${line}\n`);
+        const write = (msg) => ctx.out.stdout.write(JSON.stringify(msg) + "\n");
+        const handle = async (msg) => {
+            const id = msg.id ?? null;
+            const method = msg.method ?? "";
+            if (!method)
+                return;
+            if (msg.id === undefined || method.startsWith("notifications/"))
+                return; // notifications get no reply
+            try {
+                switch (method) {
+                    case "initialize": {
+                        const remote = rpc ? await rpc.initialize() : { instructions: "" };
+                        const requested = String(msg.params?.protocolVersion ?? PROTOCOL_VERSION);
+                        write({ jsonrpc: "2.0", id, result: { protocolVersion: ["2025-11-25", "2025-06-18", "2025-03-26", "2024-11-05"].includes(requested) ? requested : PROTOCOL_VERSION, capabilities: { tools: { listChanged: false } }, serverInfo: { name: "scribeclock-cli", title: "ScribeClock (via CLI)", version: ctx.version }, instructions: typeof remote.instructions === "string" ? remote.instructions : undefined } });
+                        return;
+                    }
+                    case "ping":
+                        write({ jsonrpc: "2.0", id, result: {} });
+                        return;
+                    case "tools/list": {
+                        const result = rpc ? await rpc.rpc("tools/list") : { tools: await client.listTools() };
+                        write({ jsonrpc: "2.0", id, result });
+                        return;
+                    }
+                    case "tools/call": {
+                        if (rpc)
+                            write({ jsonrpc: "2.0", id, result: await rpc.rpc("tools/call", msg.params ?? {}) });
+                        else {
+                            const outcome = await client.callTool(String(msg.params?.name ?? ""), msg.params?.arguments ?? {});
+                            write({ jsonrpc: "2.0", id, result: { content: outcome.content, structuredContent: outcome.data, isError: !outcome.ok } });
+                        }
+                        return;
+                    }
+                    case "resources/list":
+                        write({ jsonrpc: "2.0", id, result: { resources: [] } });
+                        return;
+                    case "prompts/list":
+                        write({ jsonrpc: "2.0", id, result: { prompts: [] } });
+                        return;
+                    default:
+                        write({ jsonrpc: "2.0", id, error: { code: -32601, message: `Method not found: ${method}` } });
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                const code = err instanceof CliError && err.code === EXIT.AUTH ? -32001 : -32603;
+                log(message);
+                write({ jsonrpc: "2.0", id, error: { code, message } });
+            }
+        };
+        log(`proxying ${ctx.endpoint} (Ctrl-C to stop)`);
+        const rl = createInterface({ input: ctx.stdin.stream, crlfDelay: Infinity });
+        for await (const line of rl) {
+            const text = line.trim();
+            if (!text)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+                write({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+                continue;
+            }
+            for (const msg of Array.isArray(parsed) ? parsed : [parsed])
+                await handle(msg);
+        }
+        return EXIT.OK;
+    },
+});
+// ---------------------------------------------------------------------------
+// mcp-config
+// ---------------------------------------------------------------------------
+const CLIENTS = ["claude-code", "claude-ai", "chatgpt", "cursor", "vscode", "windsurf", "codex", "gemini", "generic"];
+export function mcpConfigFor(client, endpoint, local, bin = "scribeclock") {
+    const name = "scribeclock";
+    const remote = { url: endpoint };
+    const stdio = { command: bin, args: ["serve", "--stdio"] };
+    switch (client) {
+        case "claude-code":
+            return { text: local ? `claude mcp add ${name} -- ${bin} serve --stdio` : `claude mcp add --transport http ${name} ${endpoint}`, file: ".mcp.json", merge: { path: ["mcpServers", name], value: local ? { type: "stdio", ...stdio } : { type: "http", url: endpoint }, format: "json" } };
+        case "cursor":
+            return { text: JSON.stringify({ mcpServers: { [name]: local ? stdio : remote } }, null, 2), file: ".cursor/mcp.json", merge: { path: ["mcpServers", name], value: local ? stdio : remote, format: "json" } };
+        case "vscode":
+            return { text: JSON.stringify({ servers: { [name]: local ? { type: "stdio", ...stdio } : { type: "http", url: endpoint } } }, null, 2), file: ".vscode/mcp.json", merge: { path: ["servers", name], value: local ? { type: "stdio", ...stdio } : { type: "http", url: endpoint }, format: "json" } };
+        case "windsurf":
+            return { text: JSON.stringify({ mcpServers: { [name]: local ? stdio : { serverUrl: endpoint } } }, null, 2), file: join(homedir(), ".codeium", "windsurf", "mcp_config.json"), merge: { path: ["mcpServers", name], value: local ? stdio : { serverUrl: endpoint }, format: "json" } };
+        case "codex":
+            return { text: local ? `[mcp_servers.${name}]\ncommand = "${bin}"\nargs = ["serve", "--stdio"]` : `[mcp_servers.${name}]\nurl = "${endpoint}"`, file: join(homedir(), ".codex", "config.toml"), merge: { path: ["mcp_servers", name], value: local ? stdio : remote, format: "toml" } };
+        case "gemini":
+            return { text: JSON.stringify({ mcpServers: { [name]: local ? stdio : { httpUrl: endpoint } } }, null, 2), file: ".gemini/settings.json", merge: { path: ["mcpServers", name], value: local ? stdio : { httpUrl: endpoint }, format: "json" } };
+        case "claude-ai":
+            return { text: local ? "claude.ai only supports remote connectors: Settings → Connectors → Add custom connector → " + endpoint : `Settings → Connectors → Add custom connector → ${endpoint}` };
+        case "chatgpt":
+            return { text: `Settings → Connectors → Create (developer mode) → ${endpoint}` };
+        default:
+            return { text: JSON.stringify(local ? stdio : { type: "http", url: endpoint }, null, 2) };
+    }
+}
+export const mcpConfigCommand = cmd({
+    path: "mcp-config",
+    group: "Automation & agents",
+    summary: `Print (or --install) the MCP client config for ${CLIENTS.filter((c) => c !== "generic").join(", ")}.`,
+    tool: [],
+    positionals: [{ name: "client", required: true, description: CLIENTS.join(" | ") }],
+    flags: [
+        { name: "local", type: "boolean", description: "Configure the local stdio server (scribeclock serve --stdio) instead of the remote URL." },
+        { name: "install", type: "boolean", description: "Write/merge the config into the client's file (asks first)." },
+        { name: "global", type: "boolean", description: "With --install for cursor/vscode/gemini: write the user-level file instead of the project one." },
+    ],
+    examples: ["scribeclock mcp-config claude-code", "scribeclock mcp-config cursor --install", "scribeclock mcp-config codex --local"],
+    async run(ctx, inv) {
+        const client = inv.positionals[0];
+        if (!CLIENTS.includes(client))
+            throw usageError(`Unknown client "${String(client)}".`, `One of: ${CLIENTS.join(", ")}`);
+        const cfg = mcpConfigFor(client, ctx.endpoint, Boolean(inv.flags.local), "scribeclock");
+        if (!inv.flags.install) {
+            if (ctx.flags.json)
+                ctx.out.jsonOut({ ok: true, client, local: Boolean(inv.flags.local), config: cfg.text, file: cfg.file ?? null });
+            else {
+                ctx.out.log(cfg.text);
+                if (cfg.file)
+                    ctx.out.info(ctx.out.dim(`\nFile: ${cfg.file} (add --install to write it)`));
+            }
+            return EXIT.OK;
+        }
+        if (!cfg.merge || !cfg.file)
+            throw usageError(`${client} has no config file to install into; follow the printed steps instead.`);
+        let target = cfg.file;
+        if (inv.flags.global) {
+            if (client === "cursor")
+                target = join(homedir(), ".cursor", "mcp.json");
+            else if (client === "vscode")
+                throw usageError("VS Code's user-level MCP config lives in its settings UI; use the project file (omit --global).");
+            else if (client === "gemini")
+                target = join(homedir(), ".gemini", "settings.json");
+        }
+        const path = target.startsWith("/") || /^[A-Za-z]:\\/.test(target) ? target : join(ctx.cwd, target);
+        const ok = await confirm(ctx, `Add the "scribeclock" MCP server to ${path}?`);
+        if (!ok)
+            return EXIT.ERROR;
+        if (cfg.merge.format === "json") {
+            let json = {};
+            if (existsSync(path)) {
+                try {
+                    json = JSON.parse(readFileSync(path, "utf8"));
+                }
+                catch {
+                    throw new CliError(`${path} is not valid JSON; edit it by hand.`, { id: "invalid_config" });
+                }
+            }
+            let node = json;
+            for (const key of cfg.merge.path.slice(0, -1)) {
+                if (!node[key] || typeof node[key] !== "object")
+                    node[key] = {};
+                node = node[key];
+            }
+            node[cfg.merge.path[cfg.merge.path.length - 1]] = cfg.merge.value;
+            mkdirSync(dirname(path), { recursive: true });
+            writeFileSync(path, JSON.stringify(json, null, 2) + "\n");
+        }
+        else {
+            const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
+            if (/\[mcp_servers\.scribeclock\]/.test(existing))
+                throw new CliError(`${path} already has an [mcp_servers.scribeclock] section.`, { id: "exists", hint: "Edit it by hand to change the URL or command." });
+            mkdirSync(dirname(path), { recursive: true });
+            writeFileSync(path, `${existing.trimEnd()}${existing ? "\n\n" : ""}${cfg.text}\n`);
+        }
+        if (ctx.flags.json)
+            ctx.out.jsonOut({ ok: true, client, file: path, local: Boolean(inv.flags.local) });
+        else
+            ctx.out.log(`${ctx.out.green("✓")} Wrote ${path}. ${client === "claude-code" ? "Restart Claude Code and run /mcp to authenticate." : "Restart the client; it will discover OAuth (or use your CLI login with --local)."}`);
+        return EXIT.OK;
+    },
+});
+const TASK_REF = String.raw `(?:#|task\s*)?(\d{1,6})(?!\d)`;
+const INTENTS = [
+    { match: /^(who am i|whoami|my (account|identity)|which org)/i, tool: "get_viewer", args: () => ({}), why: "identity question" },
+    { match: /\b(am i|is .* )?clocked? ?(in|out)\b.*\?|^clock status|^(am i|are we) (clocked|working)|\bhow long have i been (clocked in|working)/i, tool: "clock_status", args: () => ({}), why: "asks about the clock" },
+    { match: /\bclock\s*(me\s*)?in\b|\bstart (my )?(shift|day|timer)\b/i, tool: "clock_in", args: (_m, q) => ({ project: /(?:on|under|for) (?:project )?["“']?([^"”']+?)["”']?$/i.exec(q)?.[1]?.trim() }), why: "clock in" },
+    { match: /\bclock\s*(me\s*)?out\b|\bend (my )?(shift|day|timer)\b|\bstop (the )?(timer|clock)\b/i, tool: "clock_out", args: (_m, q, c) => ({ summary: /(?:summary|note|saying|with)[:\s]+["“']?(.+?)["”']?$/i.exec(q)?.[1], at: /\bat (\d{1,2}:\d{2})/i.exec(q) ? parseWhen(/\bat (\d{1,2}:\d{2})/i.exec(q)[1], c.now)?.toISOString() : undefined }), why: "clock out" },
+    { match: new RegExp(String.raw `\b(complete|finish|close|mark .*done|done with)\b.*?${TASK_REF}`, "i"), tool: "complete_task", args: (m, q) => ({ task_id: `#${m[m.length - 1]}`, comment: /(?:saying|comment|with|:)\s*["“']?(.+?)["”']?$/i.exec(q)?.[1] }), why: "complete a task" },
+    { match: new RegExp(String.raw `\b(claim|take|grab|start|pick up|work on)\b.*?${TASK_REF}`, "i"), tool: "claim_task", args: (m) => ({ task_id: `#${m[m.length - 1]}` }), why: "claim a task" },
+    { match: new RegExp(String.raw `\b(release|give back|unassign me from|drop)\b.*?${TASK_REF}`, "i"), tool: "release_task", args: (m) => ({ task_id: `#${m[m.length - 1]}` }), why: "release a task" },
+    { match: new RegExp(String.raw `\b(delete|trash|remove)\b.*?${TASK_REF}`, "i"), tool: "delete_task", args: (m) => ({ task_id: `#${m[m.length - 1]}` }), why: "delete a task" },
+    { match: new RegExp(String.raw `\b(restore|undelete)\b.*?${TASK_REF}`, "i"), tool: "restore_task", args: (m) => ({ task_id: `#${m[m.length - 1]}` }), why: "restore a task" },
+    { match: new RegExp(String.raw `\b(comment|note|reply|say)\b.*?${TASK_REF}[:\s]+(.+)$`, "i"), tool: "add_task_comment", args: (m) => ({ task_id: `#${m[m.length - 2]}`, body: m[m.length - 1].replace(/^["“'\s]+|["”'\s]+$/g, "") }), why: "comment on a task" },
+    { match: new RegExp(String.raw `\bassign\b.*?${TASK_REF}\s+to\s+(.+)$`, "i"), tool: "assign_task", args: (m) => ({ task_id: `#${m[m.length - 2]}`, assignee: m[m.length - 1].trim() }), why: "assign a task" },
+    { match: new RegExp(String.raw `\b(comments|thread|discussion)\b.*?${TASK_REF}`, "i"), tool: "list_task_comments", args: (m) => ({ task_id: `#${m[m.length - 1]}` }), why: "read a task's comments" },
+    { match: new RegExp(String.raw `\b(create|add|new|make|file)\b.*\btask\b[:\s]+["“']?(.+?)["”']?$`, "i"), tool: "create_task", args: (m, q) => ({ title: m[m.length - 1].replace(/\s+(high|low|medium) priority.*$/i, "").trim(), priority: /\b(high|low|medium) priority\b/i.exec(q)?.[1]?.toLowerCase(), assignee: /\b(?:for|assign(?:ed)? to) me\b/i.test(q) ? "me" : undefined }), why: "create a task" },
+    { match: new RegExp(String.raw `(?:^|\b(show|open|read|what(?:'s| is)|details? (?:of|for)|tell me about)\b.*?)${TASK_REF}\b`, "i"), tool: "get_task", args: (m) => ({ task_id: `#${m[m.length - 1]}` }), why: "read one task" },
+    { match: /\b(overdue|late|past due)\b.*\btasks?\b|\btasks?\b.*\b(overdue|late|past due)\b/i, tool: "list_tasks", args: (_m, q, c) => ({ assignee: /\bmy\b|\bmine\b/i.test(q) ? "me" : undefined, due_before: c.now.toISOString(), status: "open" }), why: "overdue tasks" },
+    { match: /\b(unassigned|free|unowned|nobody'?s)\b.*\b(tasks?|work)\b/i, tool: "list_tasks", args: () => ({ assignee: "unassigned", status: "open" }), why: "unassigned tasks" },
+    { match: /\b(my|mine)\b.*\b(tasks?|queue|work|todo)\b|\bwhat (am i|should i) (work(ing)? on|do)\b|\btasks? (for|assigned to) me\b/i, tool: "list_tasks", args: () => ({ assignee: "me", status: "open" }), why: "my tasks" },
+    { match: /\b(in[- ]progress|being worked on)\b/i, tool: "list_tasks", args: () => ({ status: "in-progress" }), why: "in-progress tasks" },
+    { match: /\b(who(?:'s| is) (on|in|working in|working on) (this|the) (repo|codebase|repository))|\bteam\b.*\brepo\b/i, tool: "get_repo_team", args: (_m, _q, c) => ({ repo: c.repo }), why: "repo team" },
+    { match: /\b(who(?:'s| is) (working|busy|doing what)|workload|team load|capacity)\b/i, tool: "get_workload", args: () => ({}), why: "team workload" },
+    { match: /\b(search|find|look for|grep)\b.*\btasks?\b.*["“']?([^"”']+)["”']?$|\btasks?\b (about|mentioning|containing) (.+)$/i, tool: "list_tasks", args: (m) => ({ query: (m[2] ?? m[4] ?? "").trim(), status: "all" }), why: "task search" },
+    { match: /\b(list|show|all)\b.*\btasks\b|^tasks$/i, tool: "list_tasks", args: () => ({ status: "open" }), why: "list tasks" },
+    { match: /\b(members|teammates|people|who is in (the|my) (org|team|organization))\b/i, tool: "list_members", args: () => ({}), why: "members" },
+    { match: /\b(hours|timesheet|time (logged|tracked|entries)|how (long|much) (did i|have i) work)/i, tool: "list_time_entries", args: (_m, q, c) => ({ since: /\bthis month\b/i.test(q) ? startOfMonth(c.now).toISOString() : /\btoday\b/i.test(q) ? startOfDay(c.now).toISOString() : /\bthis week\b/i.test(q) ? startOfWeek(c.now).toISOString() : undefined, person: /\b(team|everyone|all)\b/i.test(q) ? "all" : undefined }), why: "time entries" },
+    { match: /\b(prd|requirements?( doc(ument)?)?)\b.*\b(for|of)\b\s+["“']?(.+?)["”']?$/i, tool: "get_prd_version", args: (m) => ({ project_id: m[m.length - 1].trim() }), why: "read a PRD" },
+    { match: /\bproject\b.*\b(status|details?|show|open)\b.*["“']?(.+?)["”']?$|^(show|open) project (.+)$/i, tool: "get_project", args: (m) => ({ project_id: (m[2] ?? m[4] ?? "").trim() }), why: "one project" },
+    { match: /\bprojects?\b/i, tool: "list_projects", args: (_m, q) => ({ status: /\bactive\b/i.test(q) ? "active" : undefined }), why: "projects" },
+    { match: /\btranscript\b.*([0-9a-f]{8}-[0-9a-f-]{27})/i, tool: "get_meeting_transcript", args: (m) => ({ meeting_id: m[1] }), why: "meeting transcript" },
+    { match: /\bmeeting\b.*([0-9a-f]{8}-[0-9a-f-]{27})/i, tool: "get_meeting", args: (m) => ({ meeting_id: m[1] }), why: "one meeting" },
+    { match: /\bmeetings?\b/i, tool: "list_meetings", args: (_m, q, c) => ({ since: /\b(today)\b/i.test(q) ? startOfDay(c.now).toISOString() : /\b(this week)\b/i.test(q) ? startOfWeek(c.now).toISOString() : /\byesterday\b/i.test(q) ? new Date(startOfDay(c.now).getTime() - 86400000).toISOString() : undefined, query: /\babout (.+)$/i.exec(q)?.[1] }), why: "meetings" },
+    { match: /\b(secrets?|env(ironment)? var(iable)?s?|vault)\b.*\b(for|of|in)\b\s+["“']?(.+?)["”']?$/i, tool: "vault_list_secrets", args: (m) => ({ project_id: m[m.length - 1].trim() }), why: "vault listing (names only)" },
+    { match: /\b(dns|records?)\b.*\b(for|of)\b\s+([a-z0-9.-]+\.[a-z]{2,})/i, tool: "cloudflare_dns_records", args: (m) => ({ zone: m[m.length - 1] }), why: "DNS records" },
+    { match: /\b(purge|clear|flush)\b.*\bcache\b.*\b([a-z0-9.-]+\.[a-z]{2,})/i, tool: "cloudflare_purge_cache", args: (m) => ({ zone: m[m.length - 1], purge_everything: true }), why: "purge cache" },
+    { match: /\b(zones|domains)\b/i, tool: "cloudflare_zones", args: () => ({}), why: "zones" },
+    { match: /\b(deploy(ment)?s?|pages)\b.*\b(for|of)\b\s+([a-z0-9-]+)/i, tool: "cloudflare_pages_deployments", args: (m) => ({ project: m[m.length - 1] }), why: "deployments" },
+    { match: /\bhandoff\b|\bwhere did .* leave off\b|\bpick up where\b/i, tool: "get_handoff", args: (_m, _q, c) => ({ repo: c.repo }), why: "handoff" },
+    { match: /\b(files?|documents?)\b.*\b(in|for|of)\b\s+(?:project\s+)?["“']?(.+?)["”']?$/i, tool: "list_project_files", args: (m) => ({ project_id: m[m.length - 1].trim() }), why: "project files" },
+    { match: /\b(files?|documents?|drive)\b/i, tool: "list_organization_files", args: (_m, q) => ({ query: /\b(named|called|about) (.+)$/i.exec(q)?.[2] }), why: "files tab" },
+];
+/** Keyword fallback: score tools by overlap between the question and name/title/description. */
+function keywordPlan(question, tools) {
+    const words = question.toLowerCase().split(/[^a-z0-9#]+/).filter((w) => w.length > 2 && !["the", "and", "for", "with", "show", "please", "can", "you", "what", "all", "list"].includes(w));
+    let best = null;
+    for (const t of tools) {
+        const hay = `${t.name.replace(/_/g, " ")} ${t.title ?? ""} ${t.description.slice(0, 300)}`.toLowerCase();
+        let score = 0;
+        for (const w of words) {
+            if (t.name.includes(w))
+                score += 3;
+            else if (hay.includes(w))
+                score += 1;
+        }
+        if (t.annotations?.readOnlyHint)
+            score += 0.5;
+        if (!best || score > best.score)
+            best = { tool: t, score };
+    }
+    if (!best || best.score < 2)
+        return null;
+    const required = best.tool.inputSchema.required ?? [];
+    const args = {};
+    const taskRef = /#(\d{1,6})/.exec(question);
+    if (required.includes("task_id") && taskRef)
+        args.task_id = `#${taskRef[1]}`;
+    return { tool: best.tool.name, args, confidence: Math.min(0.6, best.score / 10), why: `keywords matched ${best.tool.name}`, alternatives: [] };
+}
+export function planAsk(question, tools, ctx) {
+    const available = new Set(tools.map((t) => t.name));
+    const q = question.trim();
+    for (const intent of INTENTS) {
+        const m = q.match(intent.match);
+        if (!m || !available.has(intent.tool))
+            continue;
+        const args = intent.args(m, q, ctx);
+        for (const k of Object.keys(args))
+            if (args[k] === undefined || args[k] === "")
+                delete args[k];
+        const alternatives = INTENTS.filter((i) => i !== intent && i.tool !== intent.tool && q.match(i.match) && available.has(i.tool)).map((i) => i.tool).slice(0, 3);
+        return { tool: intent.tool, args, confidence: alternatives.length ? 0.7 : 0.9, why: intent.why, alternatives };
+    }
+    return keywordPlan(q, tools);
+}
+export const askCommand = cmd({
+    path: "ask",
+    group: "Automation & agents",
+    summary: 'Plain-language request → one tool call, shown before it runs: ask "what\'s overdue for me?".',
+    description: "Maps a request to a server tool with built-in rules (no AI call, nothing leaves your machine except the tool call itself). Read-only tools run right away; anything that writes or deletes shows the exact call and asks for confirmation (--yes to skip, --dry-run to only show it). Use --plan to print the mapping without running anything.",
+    tool: [],
+    positionals: [{ name: "question", required: true, variadic: true }],
+    flags: [{ name: "plan", type: "boolean", description: "Only print the tool call the request maps to." }],
+    examples: ['scribeclock ask "what are my overdue tasks"', 'scribeclock ask "clock me in on Kisa Print"', 'scribeclock ask "comment on #731: domain purchased" --yes', 'scribeclock ask "how many hours this week" --json'],
+    async run(ctx, inv) {
+        const question = inv.positionals.join(" ").trim();
+        if (!question)
+            throw usageError("Ask something.", 'Example: scribeclock ask "what should I work on next?"');
+        const tools = await ctx.tools();
+        const { repoRef } = await import("../git.js");
+        const plan = planAsk(question, tools, { now: ctx.now(), repo: repoRef(ctx.cwd) ?? undefined });
+        if (!plan)
+            throw new CliError(`I could not map "${question}" to a tool.`, { id: "no_match", hint: "Try naming the thing: tasks, projects, meetings, clock, timesheet, vault, dns… or run `scribeclock tools` and call one directly." });
+        const def = tools.find((t) => t.name === plan.tool);
+        const readOnly = def?.annotations?.readOnlyHint === true;
+        const policy = sensitivity(plan.tool, def, plan.args);
+        const call = `${plan.tool} ${JSON.stringify(plan.args)}`;
+        if (inv.flags.plan || ctx.flags.dryRun) {
+            if (ctx.flags.json)
+                ctx.out.jsonOut({ ok: true, plan, read_only: readOnly });
+            else {
+                ctx.out.log(`${ctx.out.dim("→")} ${call}  ${ctx.out.dim(`(${plan.why}, confidence ${Math.round(plan.confidence * 100)}%${plan.alternatives.length ? `; also possible: ${plan.alternatives.join(", ")}` : ""})`)}`);
+                ctx.out.log(ctx.out.dim(readOnly ? "read-only: would run immediately" : "writes: would ask for confirmation"));
+            }
+            return EXIT.OK;
+        }
+        if (!ctx.flags.json)
+            ctx.out.info(`${ctx.out.dim("→")} ${call}  ${ctx.out.dim(`(${plan.why})`)}`);
+        if (def) {
+            try {
+                requireArgs(plan.args, def.inputSchema, plan.tool);
+            }
+            catch (err) {
+                if (err instanceof CliError)
+                    throw new CliError(`${err.message}`, { code: EXIT.USAGE, hint: `Run it directly: scribeclock ${plan.tool} ${(def.inputSchema.required ?? []).map((r) => `--${kebab(r)} <value>`).join(" ")}` });
+                throw err;
+            }
+        }
+        if (!readOnly && !policy.confirm && !ctx.flags.yes) {
+            const ok = await confirm(ctx, `Run ${call}?`);
+            if (!ok)
+                return EXIT.ERROR;
+        }
+        const result = await executeGuarded(ctx, plan.tool, plan.args, def);
+        if (result.status !== "done")
+            return result.status === "cancelled" ? EXIT.ERROR : EXIT.OK;
+        if (ctx.flags.json)
+            ctx.out.jsonOut({ ...result.data, _plan: plan });
+        else if (plan.tool === "list_tasks" && Array.isArray(result.data.tasks))
+            renderTaskTable(ctx, result.data.tasks);
+        else
+            renderResult(ctx.out, result.data);
+        return EXIT.OK;
+    },
+});
+export const AUTOMATION_COMMANDS = [watchTasks, serveCommand, mcpConfigCommand, askCommand];
+void num;