kelocan 0.1.0

package/README.md

@@ -0,0 +1,121 @@
+# kelocan
+
+CLI for the [Kelocan](https://kanban.sakze.com) kanban board — a thin client over the
+REST API, designed for humans **and** AI agents (low-token output via `--json` /
+`--fields`).
+
+## Install
+
+```bash
+npm install -g kelocan        # or: npx kelocan <command>
+```
+
+Requires Node.js ≥ 20.
+
+## Onboarding — install the MCP server & skills into your agent
+
+```bash
+npx kelocan init
+```
+
+One command: logs you in (browser), detects installed agents, lets you pick
+which to configure, writes the `kelocan` MCP entry **and** the agent skills,
+then verifies the connection — in ≤ 3 prompts.
+
+Supported agents:
+
+| Agent | Config file | Entry | Auth | Skills dir |
+| --- | --- | --- | --- | --- |
+| Devin CLI | `~/.config/devin/mcp_config.json` | `mcpServers.kelocan.url` | OAuth | `~/.agents/skills` |
+| Claude Code | `claude mcp add` (fallback `~/.claude.json`) | `mcpServers.kelocan` (http) | OAuth | `~/.claude/skills` |
+| Cursor | `~/.cursor/mcp.json` | `mcpServers.kelocan.url` | OAuth | `~/.agents/skills` |
+| Codex | `~/.codex/config.toml` | `[mcp_servers.kelocan]` + `bearer_token_env_var` | API key env | `~/.agents/skills` |
+| Opencode | `~/.config/opencode/opencode.json` | `mcp.kelocan` (remote) | OAuth | `~/.agents/skills` |
+| Antigravity | `~/.gemini/antigravity/mcp_config.json` or `~/.gemini/config/mcp_config.json` (whichever exists) | `mcpServers.kelocan.serverUrl` + headers | API key header | `skills/` next to the config |
+| Hermes | `~/.hermes/config.yaml` | `mcp_servers.kelocan` + `auth: oauth` | OAuth | `~/.hermes/skills` |
+
+Safety: only the `kelocan` entry is ever merged — other MCP entries are left
+untouched, the original file is backed up to `<config>.bak`, and re-running is
+idempotent. Secrets are never written literally; API-key installs reference
+`$KELOCAN_API_KEY` from the environment.
+
+Non-interactive:
+
+```bash
+kelocan init --agent devin,cursor        # specific agents
+kelocan mcp install --agent all          # only MCP entries
+kelocan skills install --agent claude    # only skill files
+kelocan uninstall --agent codex          # remove kelocan entry + skills only
+kelocan doctor                           # verify everything (read-only)
+```
+
+The skills can also be installed by any agent that supports the Agent Skills
+convention: `npx skills add IFLyer/kelocan-cli`.
+
+## Auth
+
+```bash
+kelocan login                          # browser flow: opens the /cli/authorize page
+kelocan login --api-key klc_...        # headless: store an existing API key
+kelocan login --url http://localhost:8001 --web-url http://localhost:5173
+kelocan whoami
+kelocan logout
+```
+
+Config is stored in `~/.config/kelocan/config.json` (mode `600`;
+`%APPDATA%/kelocan` on Windows). Environment overrides:
+`KELOCAN_URL`, `KELOCAN_API_KEY`, `KELOCAN_WEB_URL`.
+
+## Commands
+
+| Command | Description |
+| --- | --- |
+| `board show <board>` | Board columns & task counts |
+| `task list <board> [--column X] [--label Y] [--sprint Z]` | List tasks |
+| `task show <id>` | Task detail |
+| `task prompt <id>` | Rendered agent prompt |
+| `task create <board> --title "..." [--column X] [--kind task\|idea\|feedback] [--priority low\|medium\|high\|urgent] [--label a,b] [--sprint active\|backlog\|uuid]` | Create task |
+| `task move <id> --to <column\|role> [--position N]` | Move task |
+| `task comment <id> -m "..."` / `--file path` | Add comment / attachment |
+| `run start <task> --agent "Devin"` | Open agent run (prints `run_id`) |
+| `run finish <run_id> --outcome succeeded\|failed\|cancelled -m "..."` | Close run |
+| `subtask list <task>` / `subtask toggle <id>` | Sub-task checklist |
+
+Boards, columns, and labels can be referenced by **name, workflow role**
+(`backlog|active|review|done`) **or UUID**. Ambiguous names produce an error
+listing the candidates.
+
+## Output & exit codes
+
+Default output is concise text. `--json` prints the raw API payload;
+`--fields a,b,c` selects fields (JSON objects, or tab-separated text).
+
+Exit codes: `0` success · `1` validation/usage (message lists valid values) ·
+`2` auth · `3` network/server.
+
+Every command supports `--help` with examples:
+`kelocan task create --help`.
+
+## Agent workflow example
+
+```bash
+kelocan task prompt 8c8fb91c-... > prompt.md          # fetch instructions
+kelocan run start 8c8fb91c-... --agent "Devin"        # -> run_id: ...
+kelocan task comment 8c8fb91c-... -m "Progress: ..."  # report progress
+kelocan task move 8c8fb91c-... --to review            # move card
+kelocan run finish <run_id> --outcome succeeded -m "PR opened"
+```
+
+## Development
+
+```bash
+npm install
+npm run build          # tsc -> dist/
+npm test               # unit tests (node:test via tsx)
+npm run test:e2e       # e2e vs live backend (needs KELOCAN_E2E=1, KELOCAN_URL, KELOCAN_API_KEY)
+```
+
+## Publishing
+
+GitHub Actions publishes to npm when a `v*` tag is pushed
+(`.github/workflows/publish.yml`). Requires an `NPM_TOKEN` secret.

package/dist/agents.js

@@ -0,0 +1,326 @@
+import { existsSync } from "node:fs";
+import { delimiter, dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { CliError } from "./errors.js";
+function skillDirNextTo(configPath) {
+    // ~/.gemini/antigravity/mcp_config.json -> ~/.gemini/antigravity/skills
+    return join(dirname(configPath), "skills");
+}
+export const AGENTS = [
+    {
+        id: "devin",
+        name: "Devin CLI",
+        bins: ["devin"],
+        configCandidates: ["~/.config/devin/mcp_config.json"],
+        containerKey: "mcpServers",
+        format: "json",
+        defaultAuth: "oauth",
+        skillDirs: (home) => [join(home, ".agents", "skills")],
+    },
+    {
+        id: "claude",
+        name: "Claude Code",
+        bins: ["claude"],
+        configCandidates: ["~/.claude.json"],
+        containerKey: "mcpServers",
+        format: "json",
+        defaultAuth: "oauth",
+        cli: {
+            bin: "claude",
+            args: (url) => ["mcp", "add", "--transport", "http", "--scope", "user", "kelocan", url],
+        },
+        skillDirs: (home) => [join(home, ".claude", "skills")],
+    },
+    {
+        id: "cursor",
+        name: "Cursor",
+        bins: ["cursor"],
+        configCandidates: ["~/.cursor/mcp.json"],
+        containerKey: "mcpServers",
+        format: "json",
+        defaultAuth: "oauth",
+        skillDirs: (home) => [join(home, ".agents", "skills")],
+    },
+    {
+        id: "codex",
+        name: "Codex",
+        bins: ["codex"],
+        configCandidates: ["~/.codex/config.toml"],
+        format: "toml",
+        defaultAuth: "api-key",
+        skillDirs: (home) => [join(home, ".agents", "skills")],
+    },
+    {
+        id: "opencode",
+        name: "Opencode",
+        bins: ["opencode"],
+        configCandidates: [
+            "~/.config/opencode/opencode.json",
+            "~/.config/opencode/opencode.jsonc",
+        ],
+        containerKey: "mcp",
+        format: "json",
+        defaultAuth: "oauth",
+        skillDirs: (home) => [join(home, ".agents", "skills")],
+    },
+    {
+        id: "antigravity",
+        name: "Antigravity",
+        bins: ["antigravity", "gemini"],
+        configCandidates: [
+            "~/.gemini/antigravity/mcp_config.json",
+            "~/.gemini/config/mcp_config.json",
+        ],
+        containerKey: "mcpServers",
+        format: "json",
+        defaultAuth: "api-key",
+        skillDirs: (_home, configPath) => [skillDirNextTo(configPath)],
+    },
+    {
+        id: "hermes",
+        name: "Hermes Agent",
+        bins: ["hermes"],
+        configCandidates: ["~/.hermes/config.yaml", "~/.hermes/config.yml"],
+        format: "yaml",
+        defaultAuth: "oauth",
+        skillDirs: (home) => [join(home, ".hermes", "skills")],
+    },
+];
+export function agentById(id) {
+    const def = AGENTS.find((a) => a.id === id || a.name.toLowerCase() === id.toLowerCase());
+    if (!def) {
+        throw new CliError(`Unknown agent "${id}". Valid agents: ${AGENTS.map((a) => a.id).join(", ")}`);
+    }
+    return def;
+}
+export function expandHome(p, home) {
+    return p.startsWith("~/") || p === "~" ? join(home, p.slice(2)) : p;
+}
+/** True when a binary is found on PATH (checks common Windows extensions too). */
+export function binOnPath(bin) {
+    const pathEnv = process.env.PATH ?? "";
+    const exts = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+    for (const dir of pathEnv.split(delimiter)) {
+        if (!dir)
+            continue;
+        for (const ext of exts) {
+            if (existsSync(join(dir, bin + ext)))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Pick the active config path for an agent:
+ * an existing file wins; otherwise a candidate whose parent dir already exists;
+ * otherwise the first candidate (file will be created there).
+ */
+export function resolveConfigPath(def, home = homedir()) {
+    const cands = def.configCandidates.map((p) => expandHome(p, home));
+    for (const c of cands)
+        if (existsSync(c))
+            return c;
+    for (const c of cands)
+        if (existsSync(dirname(c)))
+            return c;
+    return cands[0];
+}
+export function detectAgent(def, home = homedir()) {
+    const via = [];
+    for (const bin of def.bins) {
+        if (binOnPath(bin))
+            via.push(`binary ${bin}`);
+    }
+    const configPath = resolveConfigPath(def, home);
+    const configExists = def.configCandidates
+        .map((p) => expandHome(p, home))
+        .some((p) => existsSync(p));
+    if (configExists)
+        via.push(configPath);
+    const skillDirs = def.skillDirs(home, configPath);
+    for (const d of skillDirs)
+        if (existsSync(d))
+            via.push(d);
+    return {
+        def,
+        detected: via.length > 0,
+        via,
+        configPath,
+        configExists,
+        skillDirs,
+    };
+}
+export function detectAll(home = homedir()) {
+    return AGENTS.map((a) => detectAgent(a, home));
+}
+// ---------- MCP entry builders ----------
+const KEY_REF = "${KELOCAN_API_KEY}";
+function apiKeyHeaders() {
+    return { Authorization: `Bearer ${KEY_REF}` };
+}
+/** JSON-format MCP server entry for an agent, honoring the auth mode. */
+export function jsonEntry(def, url, auth) {
+    const base = {};
+    switch (def.id) {
+        case "claude":
+            Object.assign(base, { type: "http", url });
+            break;
+        case "opencode":
+            Object.assign(base, { type: "remote", url, enabled: true });
+            break;
+        case "antigravity":
+            Object.assign(base, { serverUrl: url });
+            break;
+        default:
+            base.url = url;
+    }
+    if (auth === "api-key" || def.defaultAuth === "api-key") {
+        if (def.id === "antigravity")
+            base.headers = apiKeyHeaders();
+        else if (auth === "api-key")
+            base.headers = apiKeyHeaders();
+    }
+    return base;
+}
+/** TOML section text for Codex (trailing newline included). */
+export function tomlEntry(url) {
+    return (`[mcp_servers.kelocan]\n` +
+        `url = "${url}"\n` +
+        `bearer_token_env_var = "KELOCAN_API_KEY"\n`);
+}
+/** YAML block for Hermes (2-space child of `mcp_servers:`, trailing newline). */
+export function yamlEntry(url, auth) {
+    const authLine = auth === "api-key" ? `    auth: api_key\n` : `    auth: oauth\n`;
+    const headers = auth === "api-key"
+        ? `    headers:\n      Authorization: "Bearer ${KEY_REF}"\n`
+        : "";
+    return `  kelocan:\n    url: "${url}"\n` + authLine + headers;
+}
+// ---------- TOML / YAML upsert & removal ----------
+const TOML_HEADER = "[mcp_servers.kelocan]";
+export function upsertTomlEntry(text, block) {
+    const lines = (text ?? "").split("\n");
+    const headerIdx = lines.findIndex((l) => l.trim() === TOML_HEADER);
+    if (headerIdx === -1) {
+        const prefix = text && !text.endsWith("\n") ? "\n" : "";
+        const sep = text && !text.endsWith("\n\n") ? "\n" : "";
+        return { text: (text ?? "") + prefix + sep + block, changed: true };
+    }
+    let end = headerIdx + 1;
+    while (end < lines.length && !/^\s*\[/.test(lines[end]))
+        end++;
+    const existing = lines.slice(headerIdx, end).join("\n").trimEnd() + "\n";
+    if (existing.trim() === block.trim())
+        return { text: text ?? "", changed: false };
+    const out = [...lines.slice(0, headerIdx), ...block.trimEnd().split("\n"), ...lines.slice(end)];
+    return { text: out.join("\n"), changed: true };
+}
+export function removeTomlEntry(text) {
+    const lines = text.split("\n");
+    const headerIdx = lines.findIndex((l) => l.trim() === TOML_HEADER);
+    if (headerIdx === -1)
+        return { text, changed: false };
+    let end = headerIdx + 1;
+    while (end < lines.length && !/^\s*\[/.test(lines[end]))
+        end++;
+    // drop a preceding blank separator line if present
+    const start = headerIdx > 0 && lines[headerIdx - 1].trim() === "" ? headerIdx - 1 : headerIdx;
+    const out = [...lines.slice(0, start), ...lines.slice(end)];
+    return { text: out.join("\n"), changed: true };
+}
+const YAML_CONTAINER = "mcp_servers";
+const YAML_ENTRY_KEY = "kelocan";
+function isTopLevelKey(line) {
+    return /^\S[^:]*:/.test(line);
+}
+/**
+ * Merge a `kelocan:` child mapping under top-level `mcp_servers:`.
+ * `entry` is the pre-rendered 2-space-indented block (yamlEntry()).
+ */
+export function upsertYamlEntry(text, entry) {
+    const lines = (text ?? "").split("\n");
+    const containerIdx = lines.findIndex((l) => new RegExp(`^${YAML_CONTAINER}\\s*:`).test(l));
+    if (containerIdx === -1) {
+        const block = `${YAML_CONTAINER}:\n${entry}`;
+        const sep = text && !text.endsWith("\n") ? "\n" : "";
+        return { text: (text ?? "") + sep + (text ? "\n" : "") + block, changed: true };
+    }
+    // container block: until next top-level key
+    let blockEnd = lines.length;
+    for (let i = containerIdx + 1; i < lines.length; i++) {
+        if (isTopLevelKey(lines[i])) {
+            blockEnd = i;
+            break;
+        }
+    }
+    const entryIdx = lines
+        .slice(containerIdx + 1, blockEnd)
+        .findIndex((l) => /^\s+kelocan\s*:/.test(l));
+    if (entryIdx === -1) {
+        const out = [
+            ...lines.slice(0, blockEnd),
+            ...entry.trimEnd().split("\n"),
+            ...lines.slice(blockEnd),
+        ];
+        return { text: out.join("\n"), changed: true };
+    }
+    const absIdx = containerIdx + 1 + entryIdx;
+    const indent = /^\s*/.exec(lines[absIdx])[0];
+    let entryEnd = absIdx + 1;
+    while (entryEnd < blockEnd) {
+        if (lines[entryEnd].trim() === "") {
+            entryEnd++;
+            continue;
+        }
+        if ((/^\s*/.exec(lines[entryEnd])[0]).length <= indent.length)
+            break;
+        entryEnd++;
+    }
+    const existing = lines.slice(absIdx, entryEnd).join("\n").trimEnd() + "\n";
+    if (existing.trim() === entry.trim()) {
+        return { text: text ?? "", changed: false };
+    }
+    const out = [
+        ...lines.slice(0, absIdx),
+        ...entry.trimEnd().split("\n"),
+        ...lines.slice(entryEnd),
+    ];
+    return { text: out.join("\n"), changed: true };
+}
+export function removeYamlEntry(text) {
+    const lines = text.split("\n");
+    const containerIdx = lines.findIndex((l) => new RegExp(`^${YAML_CONTAINER}\\s*:`).test(l));
+    if (containerIdx === -1)
+        return { text, changed: false };
+    let blockEnd = lines.length;
+    for (let i = containerIdx + 1; i < lines.length; i++) {
+        if (isTopLevelKey(lines[i])) {
+            blockEnd = i;
+            break;
+        }
+    }
+    const relIdx = lines.slice(containerIdx + 1, blockEnd).findIndex((l) => /^\s+kelocan\s*:/.test(l));
+    if (relIdx === -1)
+        return { text, changed: false };
+    const absIdx = containerIdx + 1 + relIdx;
+    const indent = /^\s*/.exec(lines[absIdx])[0];
+    let entryEnd = absIdx + 1;
+    while (entryEnd < blockEnd) {
+        if (lines[entryEnd].trim() === "") {
+            entryEnd++;
+            continue;
+        }
+        const ind = /^\s*/.exec(lines[entryEnd])[0];
+        if (ind.length <= indent.length)
+            break;
+        entryEnd++;
+    }
+    // if kelocan was the only child, drop the now-empty `mcp_servers:` header too
+    const siblings = lines
+        .slice(containerIdx + 1, absIdx)
+        .concat(lines.slice(entryEnd, blockEnd))
+        .filter((l) => l.trim() !== "");
+    const cutStart = siblings.length === 0 ? containerIdx : absIdx;
+    const out = [...lines.slice(0, cutStart), ...lines.slice(entryEnd)];
+    return { text: out.join("\n"), changed: true };
+}

package/dist/api.js

@@ -0,0 +1,86 @@
+import { apiBase, apiKey, readConfig } from "./config.js";
+import { CliError, authError } from "./errors.js";
+function exitCodeFor(status, code) {
+    if (status === 401 || status === 403)
+        return 2;
+    if (code === "UNAUTHORIZED" || code === "INVALID_TOKEN" || code === "FORBIDDEN")
+        return 2;
+    if (status >= 500)
+        return 3;
+    return 1;
+}
+function formatDetails(details) {
+    if (!details)
+        return "";
+    if (Array.isArray(details)) {
+        const parts = details.map((d) => {
+            if (d && typeof d === "object") {
+                const rec = d;
+                const loc = Array.isArray(rec.loc) ? rec.loc.join(".") : "";
+                const msg = typeof rec.msg === "string" ? rec.msg : JSON.stringify(rec);
+                const input = rec.input !== undefined ? ` (got: ${JSON.stringify(rec.input)})` : "";
+                return `${loc ? loc + ": " : ""}${msg}${input}`;
+            }
+            return String(d);
+        });
+        return ` — ${parts.join("; ")}`;
+    }
+    try {
+        return ` — ${JSON.stringify(details)}`;
+    }
+    catch {
+        return "";
+    }
+}
+export async function request(path, opts = {}) {
+    const config = readConfig();
+    const base = apiBase(config);
+    const key = apiKey(config);
+    if (!key && !opts.anonymous) {
+        throw authError("Not authenticated. Run `kelocan login` or set KELOCAN_API_KEY / api_key in " +
+            "~/.config/kelocan/config.json");
+    }
+    const headers = {};
+    if (key)
+        headers.Authorization = `Bearer ${key}`;
+    let body;
+    if (opts.form) {
+        body = opts.form;
+    }
+    else if (opts.body !== undefined) {
+        headers["Content-Type"] = "application/json";
+        body = JSON.stringify(opts.body);
+    }
+    let res;
+    try {
+        res = await fetch(`${base}${path}`, {
+            method: opts.method ?? (body ? "POST" : "GET"),
+            headers,
+            body,
+            redirect: "follow",
+        });
+    }
+    catch (e) {
+        throw new CliError(`Cannot reach Kelocan server at ${base}: ${e instanceof Error ? e.message : e}`, 3);
+    }
+    let payload;
+    const text = await res.text();
+    if (text) {
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            payload = undefined;
+        }
+    }
+    if (!res.ok || payload?.success === false) {
+        const err = payload?.error;
+        const code = err?.code;
+        const detail = formatDetails(err?.details ?? (res.status === 422 ? payload : undefined));
+        const msg = err?.message ?? payload?.message ?? res.statusText;
+        const exit = exitCodeFor(res.status, code);
+        const hint = exit === 2 ? " (check your API key: kelocan login / KELOCAN_API_KEY)" : "";
+        throw new CliError(`${msg}${detail}${hint}`, exit);
+    }
+    return (payload?.data ?? payload);
+}

package/dist/args.js

@@ -0,0 +1,60 @@
+import { usageError } from "./errors.js";
+/** Short flag aliases shared by all commands. */
+const SHORT = { m: "message" };
+export function parseArgs(argv) {
+    const _ = [];
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--") {
+            _.push(...argv.slice(i + 1));
+            break;
+        }
+        if (a.startsWith("--")) {
+            const eq = a.indexOf("=");
+            if (eq !== -1) {
+                flags[a.slice(2, eq)] = a.slice(eq + 1);
+            }
+            else {
+                const name = a.slice(2);
+                const next = argv[i + 1];
+                if (next !== undefined && !next.startsWith("-")) {
+                    flags[name] = next;
+                    i++;
+                }
+                else {
+                    flags[name] = true;
+                }
+            }
+        }
+        else if (a.startsWith("-") && a.length > 1) {
+            const name = SHORT[a.slice(1)] ?? a.slice(1);
+            const next = argv[i + 1];
+            if (next !== undefined && !next.startsWith("-")) {
+                flags[name] = next;
+                i++;
+            }
+            else {
+                flags[name] = true;
+            }
+        }
+        else {
+            _.push(a);
+        }
+    }
+    return { _, flags };
+}
+export function need(flags, name, hint) {
+    const v = flags[name];
+    if (typeof v !== "string" || v.length === 0) {
+        throw usageError(`Missing required option --${name}. ${hint}`);
+    }
+    return v;
+}
+export function flagStr(flags, name) {
+    const v = flags[name];
+    return typeof v === "string" && v.length > 0 ? v : undefined;
+}
+export function flagBool(flags, name) {
+    return flags[name] === true || flags[name] === "true";
+}

package/dist/cli.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { parseArgs } from "./args.js";
+import { cmdBoardShow, cmdLogin, cmdLogout, cmdRunFinish, cmdRunStart, cmdSubtaskList, cmdSubtaskToggle, cmdTaskComment, cmdTaskCreate, cmdTaskList, cmdTaskMove, cmdTaskPrompt, cmdTaskShow, cmdWhoami, } from "./commands.js";
+import { CliError, usageError } from "./errors.js";
+import { HELP, ROOT_HELP } from "./help.js";
+import { errLine, line } from "./output.js";
+import { cmdDoctor, cmdInit, cmdMcpInstall, cmdSkillsInstall, cmdUninstall, } from "./setup.js";
+const ROUTES = {
+    init: cmdInit,
+    doctor: cmdDoctor,
+    "mcp install": cmdMcpInstall,
+    "skills install": cmdSkillsInstall,
+    uninstall: cmdUninstall,
+    login: cmdLogin,
+    logout: cmdLogout,
+    whoami: cmdWhoami,
+    "board show": cmdBoardShow,
+    "task list": cmdTaskList,
+    "task show": cmdTaskShow,
+    "task prompt": cmdTaskPrompt,
+    "task create": cmdTaskCreate,
+    "task move": cmdTaskMove,
+    "task comment": cmdTaskComment,
+    "run start": cmdRunStart,
+    "run finish": cmdRunFinish,
+    "subtask list": cmdSubtaskList,
+    "subtask toggle": cmdSubtaskToggle,
+};
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h" || argv[0] === "help") {
+        line(ROOT_HELP);
+        return;
+    }
+    const [group, sub, ...rest] = argv;
+    const key = sub && !sub.startsWith("-") ? `${group} ${sub}` : group;
+    const handler = ROUTES[key];
+    if (!handler) {
+        if (group === "--version" || group === "-v" || group === "version") {
+            line("kelocan 0.1.0");
+            return;
+        }
+        throw usageError(`Unknown command "${argv.join(" ")}". Run 'kelocan --help'.`);
+    }
+    const args = parseArgs(key === group ? [sub, ...rest].filter(Boolean) : rest);
+    if (args.flags.help || args.flags.h) {
+        line(HELP[key] ?? ROOT_HELP);
+        return;
+    }
+    await handler(args);
+}
+main().catch((e) => {
+    if (e instanceof CliError) {
+        errLine(`error: ${e.message}`);
+        process.exitCode = e.exitCode;
+    }
+    else {
+        errLine(`error: ${e instanceof Error ? e.message : e}`);
+        process.exitCode = 1;
+    }
+});