@shakecodeslikecray/npc-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1055 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+import { basename, dirname, join } from "node:path";
+import * as auth from "./client/auth.js";
+import * as api from "./client/api.js";
+import { CREDENTIALS_PATH, DEFAULT_API_URL } from "./config.js";
+import { getAdapter, listSupportedTools, DEFAULT_TOOL } from "./adapters/index.js";
+function prompt(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => { rl.close(); resolve(answer.trim()); });
+    });
+}
+function promptPassword(question) {
+    return new Promise((resolve) => {
+        process.stdout.write(question);
+        const stdin = process.stdin;
+        stdin.resume();
+        if (stdin.isTTY)
+            stdin.setRawMode(true);
+        stdin.setEncoding("utf8");
+        let pw = "";
+        const onData = (c) => {
+            if (c === "\n" || c === "\r" || c === "\u0004") {
+                if (stdin.isTTY)
+                    stdin.setRawMode(false);
+                stdin.removeListener("data", onData);
+                stdin.pause();
+                process.stdout.write("\n");
+                resolve(pw);
+            }
+            else if (c === "\u007f" || c === "\b") {
+                if (pw.length > 0) {
+                    pw = pw.slice(0, -1);
+                    process.stdout.write("\b \b");
+                }
+            }
+            else if (c === "\u0003") {
+                if (stdin.isTTY)
+                    stdin.setRawMode(false);
+                process.exit(0);
+            }
+            else {
+                pw += c;
+                process.stdout.write("*");
+            }
+        };
+        stdin.on("data", onData);
+    });
+}
+const program = new Command();
+program
+    .name("npc")
+    .description("NPC CLI -- agent-first project orchestration")
+    .version("0.1.0");
+// ---------------------------------------------------------------------------
+// Auth commands
+// ---------------------------------------------------------------------------
+const authCmd = program.command("auth").description("Authentication");
+authCmd
+    .command("login")
+    .description("Login to NPC API")
+    .option("-e, --email <email>", "Email address")
+    .option("-p, --password <password>", "Password (for scripted/non-interactive auth)")
+    .option("-t, --tenant <id>", "Tenant UUID (optional)")
+    .option("-u, --url <url>", "API URL", DEFAULT_API_URL)
+    .action(async (opts) => {
+    try {
+        const email = opts.email || await prompt("Email: ");
+        const password = opts.password || await promptPassword("Password: ");
+        const res = await auth.login(email, password, opts.url, opts.tenant);
+        console.log(`Logged in as ${res.user.email} (${res.user.role})`);
+        console.log(`Tenant: ${res.user.tenant_id}`);
+        if (res.must_reset_password) {
+            console.log("WARNING: You must reset your password.");
+        }
+    }
+    catch (err) {
+        console.error("Login failed:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+authCmd
+    .command("status")
+    .description("Show current auth state")
+    .action(() => {
+    const creds = auth.getCredentials();
+    if (!creds) {
+        console.log("Not authenticated.");
+        return;
+    }
+    console.log(`Email: ${creds.email}`);
+    console.log(`API: ${creds.api_url}`);
+    console.log(`Tenant: ${creds.tenant_id}`);
+    console.log(`Expires: ${creds.expires_at}`);
+    console.log(`Credentials: ${CREDENTIALS_PATH}`);
+});
+authCmd
+    .command("logout")
+    .description("Clear credentials")
+    .action(() => {
+    auth.logout();
+    console.log("Logged out.");
+});
+authCmd
+    .command("agent-key <key>")
+    .description("Store an agent API key for queue operations")
+    .action((key) => {
+    try {
+        auth.setApiKey(key);
+        console.log("Agent API key stored.");
+    }
+    catch (err) {
+        console.error("Failed:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+// ---------------------------------------------------------------------------
+// Project commands (project groups)
+// ---------------------------------------------------------------------------
+const projectCmd = program.command("project").description("Project group operations");
+projectCmd
+    .command("create")
+    .description("Create a new project group")
+    .requiredOption("-n, --name <name>", "Project group name")
+    .requiredOption("-i, --identifier <id>", "Short identifier")
+    .option("-d, --description <desc>", "Description")
+    .action(async (opts) => {
+    try {
+        const project = await api.createProject({
+            name: opts.name,
+            identifier: opts.identifier,
+            description: opts.description,
+        });
+        console.log(`Created project group: ${project.name} (${project.id})`);
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+projectCmd
+    .command("list")
+    .description("List all project groups")
+    .action(async () => {
+    try {
+        const projects = await api.listProjects();
+        if (projects.length === 0) {
+            console.log("No project groups found.");
+            return;
+        }
+        for (const p of projects) {
+            console.log(`  ${p.identifier.padEnd(8)} ${p.name.padEnd(30)} ${p.id}`);
+        }
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+projectCmd
+    .command("get <project-id>")
+    .description("Get details for a specific project group")
+    .action(async (projectId) => {
+    try {
+        const project = await api.getProject(projectId);
+        console.log(`Name: ${project.name}`);
+        console.log(`Identifier: ${project.identifier}`);
+        console.log(`ID: ${project.id}`);
+        console.log(`Tenant: ${project.tenant_id}`);
+        if (project.description)
+            console.log(`Description: ${project.description}`);
+        console.log(`Created: ${project.created_at}`);
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+projectCmd
+    .command("stats")
+    .description("Show stats for all project groups in the tenant")
+    .action(async () => {
+    try {
+        const stats = await api.getProjectStats();
+        for (const [id, s] of Object.entries(stats)) {
+            console.log(`\nProject: ${id}`);
+            console.log(`  Repos: ${s.total_repos} | Items: ${s.total_items} | Done: ${s.done} | In Progress: ${s.in_progress}`);
+            console.log(`  Not Started: ${s.not_started} | Blocked: ${s.blocked}`);
+        }
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+// ---------------------------------------------------------------------------
+// Repo commands (individual codebases)
+// ---------------------------------------------------------------------------
+const repoCmd = program.command("repo").description("Repo operations");
+repoCmd
+    .command("create")
+    .description("Create a new repo")
+    .requiredOption("-n, --name <name>", "Repo name")
+    .requiredOption("-i, --identifier <id>", "Short identifier")
+    .option("-d, --description <desc>", "Description")
+    .option("-p, --project <project-id>", "Parent project group UUID")
+    .action(async (opts) => {
+    try {
+        const repo = await api.createRepo({
+            name: opts.name,
+            identifier: opts.identifier,
+            description: opts.description,
+            project_id: opts.project,
+        });
+        console.log(`Created repo: ${repo.name} (${repo.id})`);
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+repoCmd
+    .command("list")
+    .description("List all repos")
+    .action(async () => {
+    try {
+        const repos = await api.listRepos();
+        if (repos.length === 0) {
+            console.log("No repos found.");
+            return;
+        }
+        for (const r of repos) {
+            console.log(`  ${r.identifier.padEnd(8)} ${r.name.padEnd(30)} ${r.id}`);
+        }
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+repoCmd
+    .command("get <repo-id>")
+    .description("Get details for a specific repo")
+    .action(async (repoId) => {
+    try {
+        const repo = await api.getRepo(repoId);
+        console.log(`Name: ${repo.name}`);
+        console.log(`Identifier: ${repo.identifier}`);
+        console.log(`ID: ${repo.id}`);
+        console.log(`Tenant: ${repo.tenant_id}`);
+        if (repo.project_id)
+            console.log(`Project: ${repo.project_id}`);
+        if (repo.description)
+            console.log(`Description: ${repo.description}`);
+        console.log(`Created: ${repo.created_at}`);
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+repoCmd
+    .command("stats")
+    .description("Show stats for all repos in the tenant")
+    .action(async () => {
+    try {
+        const stats = await api.getRepoStats();
+        for (const [id, s] of Object.entries(stats)) {
+            const pct = s.total > 0 ? Math.round((s.done / s.total) * 100) : 0;
+            console.log(`\nRepo: ${id}`);
+            console.log(`  Total: ${s.total} | Done: ${s.done} (${pct}%) | In Progress: ${s.in_progress}`);
+            console.log(`  Blocked: ${s.blocked} | Not Started: ${s.not_started}`);
+        }
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+// ---------------------------------------------------------------------------
+// Items commands
+// ---------------------------------------------------------------------------
+const itemsCmd = program.command("items").description("Work item operations");
+itemsCmd
+    .command("list <repo-id>")
+    .description("List work items in a repo")
+    .option("-s, --state <state>", "Filter by state")
+    .option("--priority <priority>", "Filter by priority")
+    .option("--parent <id>", "Filter by parent work item UUID")
+    .action(async (repoId, opts) => {
+    try {
+        const params = {};
+        if (opts.state)
+            params.state = opts.state;
+        if (opts.priority)
+            params.priority = opts.priority;
+        if (opts.parent)
+            params.parent_id = opts.parent;
+        const items = await api.getWorkItems(repoId, params);
+        if (items.length === 0) {
+            console.log("No work items found.");
+            return;
+        }
+        for (const wi of items) {
+            console.log(`  [${wi.state.padEnd(12)}] ${wi.title} (${wi.priority}) ${wi.id.slice(0, 8)}`);
+        }
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+itemsCmd
+    .command("get <repo-id> <item-id>")
+    .description("Get a specific work item")
+    .action(async (repoId, itemId) => {
+    try {
+        const wi = await api.getWorkItem(repoId, itemId);
+        console.log(`Title: ${wi.title}`);
+        console.log(`ID: ${wi.id}`);
+        console.log(`State: ${wi.state}`);
+        console.log(`Priority: ${wi.priority}`);
+        if (wi.description)
+            console.log(`Description: ${wi.description}`);
+        if (wi.estimated_hours)
+            console.log(`Estimated: ${wi.estimated_hours}h`);
+        if (wi.actual_hours)
+            console.log(`Actual: ${wi.actual_hours}h`);
+        if (wi.labels?.length)
+            console.log(`Labels: ${wi.labels.join(", ")}`);
+        if (wi.claimed_by)
+            console.log(`Claimed by: ${wi.claimed_by}`);
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+itemsCmd
+    .command("bulk-create <repo-id> <file>")
+    .description("Bulk create work items from a JSON file")
+    .action(async (repoId, file) => {
+    try {
+        const raw = readFileSync(file, "utf-8");
+        const items = JSON.parse(raw);
+        const created = await api.bulkCreateWorkItems(repoId, items);
+        console.log(`Created ${created.length} work items.`);
+        for (const wi of created) {
+            console.log(`  [${wi.id.slice(0, 8)}] ${wi.title}`);
+        }
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+// ---------------------------------------------------------------------------
+// Edge commands
+// ---------------------------------------------------------------------------
+const edgeCmd = program.command("edge").description("DAG edge operations");
+edgeCmd
+    .command("list <repo-id>")
+    .description("List all edges in a repo")
+    .action(async (repoId) => {
+    try {
+        const edges = await api.listEdges(repoId);
+        if (edges.length === 0) {
+            console.log("No edges found.");
+            return;
+        }
+        for (const e of edges) {
+            console.log(`  ${e.from_id.slice(0, 8)} --${e.edge_type}--> ${e.to_id.slice(0, 8)}  (${e.id.slice(0, 8)})`);
+        }
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+edgeCmd
+    .command("create")
+    .description("Create a dependency edge")
+    .requiredOption("--repo <id>", "Repo UUID")
+    .requiredOption("--from <id>", "Source work item UUID")
+    .requiredOption("--to <id>", "Target work item UUID")
+    .option("--type <type>", "Edge type: blocks | relates_to", "blocks")
+    .action(async (opts) => {
+    try {
+        const edge = await api.createEdge(opts.repo, {
+            from_id: opts.from,
+            to_id: opts.to,
+            edge_type: opts.type,
+        });
+        console.log(`Created edge: ${edge.id}`);
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+// ---------------------------------------------------------------------------
+// Task commands
+// ---------------------------------------------------------------------------
+program
+    .command("tasks")
+    .description("List my assigned tasks")
+    .action(async () => {
+    try {
+        const items = await api.getMyTasks();
+        if (items.length === 0) {
+            console.log("No tasks assigned.");
+            return;
+        }
+        // Group by state
+        const grouped = {};
+        for (const item of items) {
+            if (!grouped[item.state])
+                grouped[item.state] = [];
+            grouped[item.state].push(item);
+        }
+        for (const [state, tasks] of Object.entries(grouped)) {
+            console.log(`\n${state} (${tasks.length}):`);
+            for (const t of tasks) {
+                console.log(`  [${t.id.slice(0, 8)}] ${t.title} (${t.priority})`);
+            }
+        }
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+program
+    .command("pull")
+    .description("Get next unblocked task from the queue")
+    .option("-r, --repo <id>", "Filter by repo UUID")
+    .action(async (opts) => {
+    try {
+        const result = await api.queueNext(opts.repo);
+        const wi = result.work_item;
+        console.log(`Task: ${wi.title}`);
+        console.log(`ID: ${wi.id}`);
+        console.log(`State: ${wi.state}`);
+        console.log(`Priority: ${wi.priority}`);
+        if (wi.description)
+            console.log(`Description: ${wi.description}`);
+        if (result.ancestors.length > 0) {
+            console.log(`Context: ${result.ancestors.map((a) => a.title).join(" > ")}`);
+        }
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+program
+    .command("start <task-id>")
+    .description("Start working on a task")
+    .action(async (taskId) => {
+    try {
+        const wi = await api.startWorkItem(taskId);
+        console.log(`Started: ${wi.title} (${wi.state})`);
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+program
+    .command("complete <task-id>")
+    .description("Mark a task as in_review")
+    .option("-s, --summary <text>", "Completion summary", "")
+    .option("-h, --hours <n>", "Actual hours spent")
+    .action(async (taskId, opts) => {
+    try {
+        const wi = await api.completeWorkItem(taskId, {
+            notes: opts.summary,
+            actual_hours: opts.hours ? parseFloat(opts.hours) : undefined,
+        });
+        console.log(`Completed: ${wi.title} (${wi.state})`);
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+program
+    .command("block <task-id>")
+    .description("Block a task")
+    .requiredOption("-r, --reason <text>", "Block reason")
+    .action(async (taskId, opts) => {
+    try {
+        const wi = await api.blockWorkItem(taskId, { reason: opts.reason });
+        console.log(`Blocked: ${wi.title}`);
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+// ---------------------------------------------------------------------------
+// Signal commands
+// ---------------------------------------------------------------------------
+const signalCmd = program.command("signal").description("Signal operations");
+signalCmd
+    .command("create <task-id>")
+    .description("Report a signal for a task")
+    .requiredOption("-c, --category <cat>", "Signal category: process, quality, scope")
+    .requiredOption("-t, --type <type>", "Signal type: tests_passed, lint_clean, build_ok, etc.")
+    .requiredOption("-v, --value <json>", "Signal value as JSON")
+    .action(async (taskId, opts) => {
+    try {
+        const value = JSON.parse(opts.value);
+        const signal = await api.createSignal(taskId, {
+            category: opts.category,
+            signal_type: opts.type,
+            value,
+        });
+        console.log(`Signal created: ${signal.id}`);
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+signalCmd
+    .command("list <task-id>")
+    .description("List all signals for a task")
+    .action(async (taskId) => {
+    try {
+        const signals = await api.listSignals(taskId);
+        if (signals.length === 0) {
+            console.log("No signals found.");
+            return;
+        }
+        for (const s of signals) {
+            console.log(`  [${s.category}] ${s.signal_type}: ${JSON.stringify(s.value)} (${s.created_at})`);
+        }
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+signalCmd
+    .command("health <task-id>")
+    .description("Check signal health for a task")
+    .action(async (taskId) => {
+    try {
+        const health = await api.getSignalHealth(taskId);
+        console.log(`Status: ${health.all_green ? "ALL GREEN" : "MISSING SIGNALS"}`);
+        console.log(`Required: ${health.required_signals.join(", ") || "none"}`);
+        console.log(`Present: ${health.signals.map((s) => s.signal_type).join(", ") || "none"}`);
+        if (health.missing.length > 0) {
+            console.log(`Missing: ${health.missing.join(", ")}`);
+        }
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+program
+    .command("transition <task-id> <state>")
+    .description("Transition a task to a specific state")
+    .action(async (taskId, state) => {
+    try {
+        const wi = await api.transitionWorkItem(taskId, state);
+        console.log(`Transitioned: ${wi.title} -> ${wi.state}`);
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+program
+    .command("context <module-id>")
+    .description("Get full context for a module/work item")
+    .action(async (moduleId) => {
+    try {
+        const ctx = await api.getWorkItemContext(moduleId);
+        const wi = ctx.work_item;
+        console.log(`\nModule: ${wi.title} (${wi.state})`);
+        console.log(`ID: ${wi.id}`);
+        if (wi.description)
+            console.log(`Description: ${wi.description}`);
+        if (ctx.ancestors.length > 0) {
+            console.log(`\nAncestors:`);
+            for (const a of ctx.ancestors) {
+                console.log(`  ${a.title} (${a.state})`);
+            }
+        }
+        if (ctx.children.length > 0) {
+            console.log(`\nChildren (${ctx.children.length}):`);
+            for (const c of ctx.children) {
+                console.log(`  [${c.state.padEnd(12)}] ${c.title} (${c.id.slice(0, 8)})`);
+            }
+        }
+        if (ctx.blockers.length > 0) {
+            console.log(`\nBlockers:`);
+            for (const b of ctx.blockers) {
+                console.log(`  ${b.title} (${b.state})`);
+            }
+        }
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+// ---------------------------------------------------------------------------
+// Models commands
+// ---------------------------------------------------------------------------
+const modelsCmd = program.command("models").description("AI model operations");
+modelsCmd
+    .command("list")
+    .description("List all AI models (global registry)")
+    .action(async () => {
+    try {
+        const models = await api.listAIModels();
+        if (models.length === 0) {
+            console.log("No AI models found.");
+            return;
+        }
+        // Group by provider
+        const grouped = {};
+        for (const m of models) {
+            if (!grouped[m.provider])
+                grouped[m.provider] = [];
+            grouped[m.provider].push(m);
+        }
+        for (const [provider, providerModels] of Object.entries(grouped)) {
+            console.log(`\n${provider}:`);
+            for (const m of providerModels) {
+                const ctx = m.context_window ? `${(m.context_window / 1000).toFixed(0)}k` : "-";
+                console.log(`  ${m.model_name.padEnd(30)} ${m.model_id.padEnd(30)} T${m.capability_tier}  ${ctx.padStart(6)}`);
+            }
+        }
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+modelsCmd
+    .command("available")
+    .description("List org's available models")
+    .action(async () => {
+    try {
+        const models = await api.listAvailableModels();
+        if (models.length === 0) {
+            console.log("No available models found.");
+            return;
+        }
+        console.log("Available models:");
+        for (const m of models) {
+            const ctx = m.context_window ? `${(m.context_window / 1000).toFixed(0)}k` : "-";
+            console.log(`  ${m.model_name.padEnd(30)} ${m.model_id.padEnd(30)} T${m.capability_tier}  ${ctx.padStart(6)}`);
+        }
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+modelsCmd
+    .command("mine")
+    .description("List my models")
+    .action(async () => {
+    try {
+        const models = await api.getMyModels();
+        if (models.length === 0) {
+            console.log("No models set. Use `npc models set` to configure.");
+            return;
+        }
+        console.log("My models:");
+        for (const m of models) {
+            const ctx = m.context_window ? `${(m.context_window / 1000).toFixed(0)}k` : "-";
+            console.log(`  ${m.model_name.padEnd(30)} ${m.model_id.padEnd(30)} T${m.capability_tier}  ${ctx.padStart(6)}`);
+        }
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+modelsCmd
+    .command("set")
+    .description("Set my models")
+    .option("-m, --models <ids>", "Comma-separated model_id strings (e.g. claude-opus-4-6,claude-sonnet-4-6)")
+    .action(async (opts) => {
+    try {
+        const modelIdStrings = opts.models
+            ? opts.models.split(",").map((s) => s.trim())
+            : [];
+        if (modelIdStrings.length === 0) {
+            console.error("Provide model IDs via --models flag.");
+            console.error("Example: npc models set --models claude-opus-4-6,claude-sonnet-4-6");
+            process.exit(1);
+        }
+        // Resolve model_id strings to UUIDs
+        const allModels = await api.listAIModels();
+        const uuids = [];
+        const notFound = [];
+        for (const mid of modelIdStrings) {
+            const found = allModels.find((m) => m.model_id === mid);
+            if (found) {
+                uuids.push(found.id);
+            }
+            else {
+                notFound.push(mid);
+            }
+        }
+        if (notFound.length > 0) {
+            console.error(`Unknown model IDs: ${notFound.join(", ")}`);
+            console.error("Run `npc models list` to see valid model IDs.");
+            process.exit(1);
+        }
+        await api.setMyModels(uuids);
+        console.log("Updated your models. Org pool synced.");
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+// ---------------------------------------------------------------------------
+// Telemetry commands
+// ---------------------------------------------------------------------------
+const telemetryCmd = program.command("telemetry").description("Telemetry reporting");
+telemetryCmd
+    .command("report-session")
+    .description("Parse an agent transcript and report telemetry to NPC")
+    .option("--transcript <path>", "Path to transcript JSONL file")
+    .option("--work-item <id>", "Work item UUID (overrides auto-detection)")
+    .option("--tool <name>", `Agent tool that produced the transcript. Supported parsers: claude_code`, "claude_code")
+    .action(async (opts) => {
+    try {
+        // Only claude_code transcript format is parsed today. Other tools can be
+        // added by implementing a parser in src/adapters/<tool>.ts and wiring it
+        // in below.
+        const supportedParsers = ["claude_code"];
+        if (!supportedParsers.includes(opts.tool)) {
+            console.log(`Transcript parsing not yet supported for ${opts.tool}. Use npc_report_telemetry MCP tool for manual reporting.`);
+            process.exit(0);
+        }
+        // Read hook input from stdin if no --transcript provided
+        let transcriptPath = opts.transcript;
+        if (!transcriptPath) {
+            // Claude Code Stop hook passes JSON on stdin with transcript_path
+            const chunks = [];
+            for await (const chunk of process.stdin) {
+                chunks.push(chunk);
+            }
+            const stdinData = Buffer.concat(chunks).toString("utf-8").trim();
+            if (stdinData) {
+                try {
+                    const hookInput = JSON.parse(stdinData);
+                    transcriptPath = hookInput.transcript_path;
+                }
+                catch {
+                    // Not JSON, maybe it's the path itself
+                    transcriptPath = stdinData;
+                }
+            }
+        }
+        if (!transcriptPath) {
+            console.error("No transcript path provided. Use --transcript or pipe hook input on stdin.");
+            process.exit(1);
+        }
+        const { parseClaudeCodeTranscript } = await import("./adapters/claude-code.js");
+        const parsed = parseClaudeCodeTranscript(transcriptPath);
+        const workItemId = opts.workItem ?? parsed.work_item_id;
+        if (!workItemId) {
+            console.error("No active work item found in transcript. Use --work-item to specify.");
+            process.exit(0); // Exit 0 — not an error, just nothing to report
+        }
+        const ev = await api.createTelemetry(workItemId, {
+            session_id: parsed.session_id,
+            agent_tool: opts.tool,
+            model: parsed.model,
+            tokens_in: parsed.tokens_in,
+            tokens_out: parsed.tokens_out,
+            cache_read_tokens: parsed.cache_read_tokens,
+            cache_creation_tokens: parsed.cache_creation_tokens,
+            cost_usd: parsed.cost_usd,
+            duration_ms: parsed.duration_ms,
+            num_turns: parsed.num_turns,
+            tool_calls: parsed.tool_calls,
+            tool_failures: parsed.tool_failures,
+            metadata: parsed.metadata,
+        });
+        console.log(`Telemetry reported for work item ${workItemId.slice(0, 8)}: $${ev.cost_usd.toFixed(4)}, ${ev.tokens_in + ev.tokens_out} tokens`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Failed to report telemetry: ${msg}`);
+        process.exit(1);
+    }
+});
+// ---------------------------------------------------------------------------
+// Docs commands
+// ---------------------------------------------------------------------------
+const docsCmd = program.command("docs").description("Document storage operations");
+docsCmd
+    .command("list <repo-id>")
+    .description("List all documents stored for a repo")
+    .action(async (repoId) => {
+    try {
+        const docs = await api.listDocuments(repoId);
+        if (docs.length === 0) {
+            console.log("No documents found.");
+            return;
+        }
+        for (const d of docs) {
+            const kb = (d.size_bytes / 1024).toFixed(1);
+            console.log(`  ${d.filename.padEnd(45)} ${kb.padStart(8)}KB  ${d.id}`);
+        }
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+docsCmd
+    .command("upload <repo-id> <file>")
+    .description("Upload a document file to a repo")
+    .option("-n, --name <filename>", "Override filename (default: basename of <file>)")
+    .action(async (repoId, file, opts) => {
+    try {
+        const content = readFileSync(file);
+        const filename = opts.name ?? basename(file);
+        const contentType = filename.endsWith(".md") ? "text/markdown" : "text/plain";
+        const doc = await api.uploadDocument(repoId, filename, content, contentType);
+        const baseUrl = auth.getApiUrl().replace(/\/$/, "");
+        const contentUrl = `${baseUrl}/api/v1/repos/${repoId}/documents/${doc.id}/content`;
+        console.log(`Uploaded: ${doc.filename} (${(doc.size_bytes / 1024).toFixed(1)}KB)`);
+        console.log(`ID:  ${doc.id}`);
+        console.log(`URL: ${contentUrl}`);
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+docsCmd
+    .command("cat <repo-id> <doc-id>")
+    .description("Print document content to stdout")
+    .action(async (repoId, docId) => {
+    try {
+        const content = await api.getDocumentContent(repoId, docId);
+        process.stdout.write(content);
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+docsCmd
+    .command("delete <repo-id> <doc-id>")
+    .description("Delete a document from a repo")
+    .action(async (repoId, docId) => {
+    try {
+        await api.deleteDocument(repoId, docId);
+        console.log("Deleted.");
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+docsCmd
+    .command("upload-and-link <repo-id> <file> <work-item-id>")
+    .description("Upload a document and immediately attach it as a reference to a work item")
+    .option("-n, --name <filename>", "Override filename")
+    .option("-l, --label <label>", "Reference label (default: filename)")
+    .option("-t, --type <ref-type>", "Reference type: prd, design, screenshot, client_doc, external, user_flow", "user_flow")
+    .action(async (repoId, file, workItemId, opts) => {
+    try {
+        const content = readFileSync(file);
+        const filename = opts.name ?? basename(file);
+        const contentType = filename.endsWith(".md") ? "text/markdown" : "text/plain";
+        // 1. Upload
+        const doc = await api.uploadDocument(repoId, filename, content, contentType);
+        const baseUrl = auth.getApiUrl().replace(/\/$/, "");
+        const contentUrl = `${baseUrl}/api/v1/repos/${repoId}/documents/${doc.id}/content`;
+        console.log(`Uploaded: ${doc.filename} (${(doc.size_bytes / 1024).toFixed(1)}KB) → ${doc.id}`);
+        // 2. Attach as reference
+        const label = opts.label ?? filename.replace(/\.[^.]+$/, "").replace(/[-_]/g, " ");
+        const ref = await api.createReference(workItemId, {
+            url: contentUrl,
+            label,
+            ref_type: opts.type,
+        });
+        console.log(`Linked:   [${ref.ref_type}] "${ref.label}" → ${workItemId.slice(0, 8)}`);
+        console.log(`Ref ID:   ${ref.id}`);
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+// ---------------------------------------------------------------------------
+// Refs commands
+// ---------------------------------------------------------------------------
+const refsCmd = program.command("refs").description("Work item reference operations");
+refsCmd
+    .command("list <work-item-id>")
+    .description("List references for a work item")
+    .option("--inherited", "Include references from all ancestor items", false)
+    .action(async (workItemId, opts) => {
+    try {
+        const refs = await api.listReferences(workItemId, opts.inherited);
+        if (refs.length === 0) {
+            console.log("No references found.");
+            return;
+        }
+        for (const r of refs) {
+            const from = r.from_level ? ` (from ${r.from_level})` : "";
+            console.log(`  [${r.ref_type.padEnd(12)}] ${r.label}${from}`);
+            console.log(`              ${r.url}`);
+            console.log(`              id: ${r.id}`);
+        }
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+refsCmd
+    .command("add <work-item-id>")
+    .description("Attach a URL reference to a work item")
+    .requiredOption("-u, --url <url>", "Reference URL")
+    .requiredOption("-l, --label <label>", "Human-readable label")
+    .option("-t, --type <type>", "Reference type: prd, design, screenshot, client_doc, external, user_flow", "external")
+    .action(async (workItemId, opts) => {
+    try {
+        const ref = await api.createReference(workItemId, {
+            url: opts.url,
+            label: opts.label,
+            ref_type: opts.type,
+        });
+        console.log(`Added reference: [${ref.ref_type}] ${ref.label}`);
+        console.log(`ID: ${ref.id}`);
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+refsCmd
+    .command("delete <work-item-id> <ref-id>")
+    .description("Delete a reference from a work item")
+    .action(async (workItemId, refId) => {
+    try {
+        await api.deleteReference(workItemId, refId);
+        console.log("Deleted.");
+    }
+    catch (err) {
+        console.error("Error:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+// ---------------------------------------------------------------------------
+// MCP server commands
+// ---------------------------------------------------------------------------
+const mcpCmd = program.command("mcp").description("MCP server operations");
+mcpCmd
+    .command("start")
+    .description("Start MCP server mode (stdio transport)")
+    .action(async () => {
+    await import("./mcp.js");
+});
+mcpCmd
+    .command("install")
+    .description("Register NPC as an MCP server in a supported agent tool")
+    .option("--tool <name>", `Agent tool to configure. Supported: ${listSupportedTools().join(", ")}`, DEFAULT_TOOL)
+    .action((opts) => {
+    const adapter = getAdapter(opts.tool);
+    if (!adapter) {
+        console.error(`Unknown tool: "${opts.tool}". Supported: ${listSupportedTools().join(", ")}`);
+        process.exit(1);
+    }
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const mcpEntrypoint = join(__dirname, "mcp.js");
+    if (!existsSync(mcpEntrypoint)) {
+        console.error(`MCP entrypoint not found at ${mcpEntrypoint}`);
+        console.error("Run `npm run build` in npc-cli first.");
+        process.exit(1);
+    }
+    // Read existing config or start fresh
+    let config = {};
+    if (existsSync(adapter.configPath)) {
+        try {
+            config = JSON.parse(readFileSync(adapter.configPath, "utf-8"));
+        }
+        catch {
+            // Corrupted file — start fresh
+        }
+    }
+    // Ensure mcpServers key exists
+    const key = adapter.mcpServersKey;
+    if (!config[key] || typeof config[key] !== "object") {
+        config[key] = {};
+    }
+    config[key].npc = {
+        type: "stdio",
+        command: "node",
+        args: [mcpEntrypoint],
+    };
+    // Create parent dirs if needed
+    mkdirSync(dirname(adapter.configPath), { recursive: true });
+    writeFileSync(adapter.configPath, JSON.stringify(config, null, 2) + "\n");
+    console.log(`NPC MCP server registered in ${adapter.displayName}.`);
+    console.log(`  Config: ${adapter.configPath}`);
+    console.log(`  Entry:  node ${mcpEntrypoint}`);
+    console.log(`\n${adapter.restartHint}`);
+});
+mcpCmd
+    .command("uninstall")
+    .description("Remove NPC from an agent tool's MCP config")
+    .option("--tool <name>", `Agent tool to remove from. Supported: ${listSupportedTools().join(", ")}`, DEFAULT_TOOL)
+    .action((opts) => {
+    const adapter = getAdapter(opts.tool);
+    if (!adapter) {
+        console.error(`Unknown tool: "${opts.tool}". Supported: ${listSupportedTools().join(", ")}`);
+        process.exit(1);
+    }
+    if (!existsSync(adapter.configPath)) {
+        console.log(`No ${adapter.displayName} config found. Nothing to remove.`);
+        return;
+    }
+    try {
+        const config = JSON.parse(readFileSync(adapter.configPath, "utf-8"));
+        const servers = config[adapter.mcpServersKey];
+        if (!servers?.npc) {
+            console.log(`NPC not found in ${adapter.displayName} MCP config.`);
+            return;
+        }
+        delete servers.npc;
+        writeFileSync(adapter.configPath, JSON.stringify(config, null, 2) + "\n");
+        console.log(`NPC MCP server removed from ${adapter.displayName}.`);
+        console.log(`${adapter.restartHint}`);
+    }
+    catch {
+        console.error(`Failed to read ${adapter.configPath}`);
+        process.exit(1);
+    }
+});
+program.parse();
+//# sourceMappingURL=index.js.map