@mandipadk7/kavi 0.1.0

package/dist/main.js

@@ -0,0 +1,667 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { createApprovalRequest, describeToolUse, findApprovalRule, listApprovalRequests, resolveApprovalRequest, waitForApprovalDecision } from "./approvals.js";
+import { appendCommand } from "./command-queue.js";
+import { ensureHomeConfig, ensureProjectScaffold, loadConfig } from "./config.js";
+import { KaviDaemon } from "./daemon.js";
+import { runDoctor } from "./doctor.js";
+import { writeJson } from "./fs.js";
+import { createGitignoreEntries, detectRepoRoot, ensureWorktrees, getHeadCommit, landBranches, resolveTargetBranch } from "./git.js";
+import { buildSessionId, resolveAppPaths } from "./paths.js";
+import { isProcessAlive, spawnDetachedNode } from "./process.js";
+import { resolveSessionRuntime } from "./runtime.js";
+import { routePrompt } from "./router.js";
+import { createSessionRecord, loadSessionRecord, readRecentEvents, recordEvent, sessionExists, sessionHeartbeatAgeMs } from "./session.js";
+import { listTaskArtifacts, loadTaskArtifact } from "./task-artifacts.js";
+import { attachTui } from "./tui.js";
+const HEARTBEAT_STALE_MS = 10_000;
+const CLAUDE_AUTO_ALLOW_TOOLS = new Set([
+    "Read",
+    "Glob",
+    "Grep",
+    "LS"
+]);
+function getFlag(args, name) {
+    const index = args.indexOf(name);
+    if (index === -1) {
+        return null;
+    }
+    return args[index + 1] ?? null;
+}
+function getGoal(args) {
+    const explicit = getFlag(args, "--goal");
+    if (explicit) {
+        return explicit;
+    }
+    const filtered = args.filter((arg, index)=>{
+        if (arg === "--goal" || args[index - 1] === "--goal") {
+            return false;
+        }
+        return !arg.startsWith("--");
+    });
+    return filtered.length > 0 ? filtered.join(" ") : null;
+}
+async function readStdinText() {
+    if (process.stdin.isTTY) {
+        return "";
+    }
+    let content = "";
+    process.stdin.setEncoding("utf8");
+    for await (const chunk of process.stdin){
+        content += chunk;
+    }
+    return content;
+}
+function renderUsage() {
+    return [
+        "Usage:",
+        "  kavi init [--home]",
+        "  kavi doctor [--json]",
+        "  kavi start [--goal \"...\"]",
+        "  kavi open [--goal \"...\"]",
+        "  kavi resume",
+        "  kavi status [--json]",
+        "  kavi paths [--json]",
+        "  kavi task [--agent codex|claude|auto] <prompt>",
+        "  kavi tasks [--json]",
+        "  kavi task-output <task-id|latest> [--json]",
+        "  kavi approvals [--json] [--all]",
+        "  kavi approve <request-id|latest> [--remember]",
+        "  kavi deny <request-id|latest> [--remember]",
+        "  kavi events [--limit N]",
+        "  kavi stop",
+        "  kavi land",
+        "  kavi help"
+    ].join("\n");
+}
+function isSessionLive(session) {
+    if (session.status !== "running") {
+        return false;
+    }
+    const heartbeatAgeMs = sessionHeartbeatAgeMs(session);
+    const heartbeatFresh = heartbeatAgeMs !== null && heartbeatAgeMs < HEARTBEAT_STALE_MS;
+    const pidAlive = isProcessAlive(session.daemonPid);
+    if (heartbeatFresh) {
+        return true;
+    }
+    return pidAlive;
+}
+async function waitForSession(paths, expectedState = "running") {
+    const timeoutMs = 10_000;
+    const startedAt = Date.now();
+    while(Date.now() - startedAt < timeoutMs){
+        try {
+            if (await sessionExists(paths)) {
+                const session = await loadSessionRecord(paths);
+                if (expectedState === "running" && isSessionLive(session)) {
+                    return;
+                }
+                if (expectedState === "stopped" && session.status === "stopped") {
+                    return;
+                }
+            }
+        } catch  {}
+        await new Promise((resolve)=>setTimeout(resolve, 200));
+    }
+    throw new Error(`Timed out waiting for session state ${expectedState} in ${paths.stateFile}.`);
+}
+async function commandInit(cwd, args) {
+    const repoRoot = await detectRepoRoot(cwd);
+    const paths = resolveAppPaths(repoRoot);
+    await ensureProjectScaffold(paths);
+    await createGitignoreEntries(repoRoot);
+    if (args.includes("--home")) {
+        await ensureHomeConfig(paths);
+        console.log(`Initialized user-local Kavi config in ${paths.homeConfigFile}`);
+    }
+    console.log(`Initialized Kavi project scaffold in ${paths.kaviDir}`);
+}
+async function commandDoctor(cwd, args) {
+    const repoRoot = await detectRepoRoot(cwd);
+    const paths = resolveAppPaths(repoRoot);
+    await ensureProjectScaffold(paths);
+    const checks = await runDoctor(repoRoot, paths);
+    if (args.includes("--json")) {
+        console.log(JSON.stringify(checks, null, 2));
+        process.exitCode = checks.some((check)=>!check.ok) ? 1 : 0;
+        return;
+    }
+    let failed = false;
+    for (const check of checks){
+        if (!check.ok) {
+            failed = true;
+        }
+        console.log(`${check.ok ? "OK" : "FAIL"} ${check.name}: ${check.detail}`);
+    }
+    process.exitCode = failed ? 1 : 0;
+}
+async function startOrAttachSession(cwd, goal) {
+    const repoRoot = await detectRepoRoot(cwd);
+    const paths = resolveAppPaths(repoRoot);
+    await ensureProjectScaffold(paths);
+    await createGitignoreEntries(repoRoot);
+    await ensureHomeConfig(paths);
+    if (await sessionExists(paths)) {
+        try {
+            const session = await loadSessionRecord(paths);
+            if (isSessionLive(session)) {
+                if (goal) {
+                    await appendCommand(paths, "kickoff", {
+                        prompt: goal
+                    });
+                }
+                return session.socketPath;
+            }
+            await recordEvent(paths, session.id, "daemon.stale_detected", {
+                daemonPid: session.daemonPid,
+                daemonHeartbeatAt: session.daemonHeartbeatAt
+            });
+        } catch  {}
+    }
+    const config = await loadConfig(paths);
+    const runtime = await resolveSessionRuntime(paths);
+    const baseCommit = await getHeadCommit(repoRoot);
+    const sessionId = buildSessionId();
+    const rpcEndpoint = "file://session-state";
+    await fs.writeFile(paths.commandsFile, "", "utf8");
+    const worktrees = await ensureWorktrees(repoRoot, paths, sessionId, config, baseCommit);
+    await createSessionRecord(paths, config, runtime, sessionId, baseCommit, worktrees, goal, rpcEndpoint);
+    const pid = spawnDetachedNode(runtime.nodeExecutable, [
+        fileURLToPath(import.meta.url),
+        "__daemon",
+        "--repo-root",
+        repoRoot
+    ], repoRoot);
+    const session = await loadSessionRecord(paths);
+    session.daemonPid = pid;
+    await writeJson(paths.stateFile, session);
+    await waitForSession(paths);
+    return rpcEndpoint;
+}
+async function requireSession(cwd) {
+    const repoRoot = await detectRepoRoot(cwd);
+    const paths = resolveAppPaths(repoRoot);
+    if (!await sessionExists(paths)) {
+        throw new Error("No Kavi session found for this repository.");
+    }
+    return {
+        repoRoot,
+        paths
+    };
+}
+async function commandOpen(cwd, args) {
+    const goal = getGoal(args);
+    await startOrAttachSession(cwd, goal);
+    const repoRoot = await detectRepoRoot(cwd);
+    const paths = resolveAppPaths(repoRoot);
+    await attachTui(paths);
+}
+async function commandResume(cwd) {
+    const { paths } = await requireSession(cwd);
+    await waitForSession(paths);
+    await attachTui(paths);
+}
+async function commandStart(cwd, args) {
+    const goal = getGoal(args);
+    const repoRoot = await detectRepoRoot(cwd);
+    const socketPath = await startOrAttachSession(cwd, goal);
+    const paths = resolveAppPaths(repoRoot);
+    const session = await loadSessionRecord(paths);
+    console.log(`Started Kavi session ${session.id}`);
+    console.log(`Repo: ${repoRoot}`);
+    console.log(`Control: ${socketPath}`);
+    console.log(`Runtime: node=${session.runtime.nodeExecutable} codex=${session.runtime.codexExecutable} claude=${session.runtime.claudeExecutable}`);
+    for (const worktree of session.worktrees){
+        console.log(`- ${worktree.agent}: ${worktree.path}`);
+    }
+}
+async function commandStatus(cwd, args) {
+    const { paths } = await requireSession(cwd);
+    const session = await loadSessionRecord(paths);
+    const pendingApprovals = await listApprovalRequests(paths);
+    const heartbeatAgeMs = sessionHeartbeatAgeMs(session);
+    const payload = {
+        id: session.id,
+        status: session.status,
+        repoRoot: session.repoRoot,
+        goal: session.goal,
+        daemonPid: session.daemonPid,
+        daemonHeartbeatAt: session.daemonHeartbeatAt,
+        daemonHealthy: isSessionLive(session),
+        heartbeatAgeMs,
+        runtime: session.runtime,
+        taskCounts: {
+            total: session.tasks.length,
+            pending: session.tasks.filter((task)=>task.status === "pending").length,
+            running: session.tasks.filter((task)=>task.status === "running").length,
+            blocked: session.tasks.filter((task)=>task.status === "blocked").length,
+            completed: session.tasks.filter((task)=>task.status === "completed").length,
+            failed: session.tasks.filter((task)=>task.status === "failed").length
+        },
+        approvalCounts: {
+            pending: pendingApprovals.length
+        },
+        worktrees: session.worktrees
+    };
+    if (args.includes("--json")) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    console.log(`Session: ${payload.id}`);
+    console.log(`Status: ${payload.status}${payload.daemonHealthy ? " (healthy)" : " (stale or stopped)"}`);
+    console.log(`Repo: ${payload.repoRoot}`);
+    console.log(`Goal: ${payload.goal ?? "-"}`);
+    console.log(`Daemon PID: ${payload.daemonPid ?? "-"}`);
+    console.log(`Heartbeat: ${payload.daemonHeartbeatAt ?? "-"}${heartbeatAgeMs === null ? "" : ` (${heartbeatAgeMs} ms ago)`}`);
+    console.log(`Runtime: node=${payload.runtime.nodeExecutable} codex=${payload.runtime.codexExecutable} claude=${payload.runtime.claudeExecutable}`);
+    console.log(`Tasks: total=${payload.taskCounts.total} pending=${payload.taskCounts.pending} running=${payload.taskCounts.running} blocked=${payload.taskCounts.blocked} completed=${payload.taskCounts.completed} failed=${payload.taskCounts.failed}`);
+    console.log(`Approvals: pending=${payload.approvalCounts.pending}`);
+    for (const worktree of payload.worktrees){
+        console.log(`- ${worktree.agent}: ${worktree.path}`);
+    }
+}
+async function commandPaths(cwd, args) {
+    const repoRoot = await detectRepoRoot(cwd);
+    const paths = resolveAppPaths(repoRoot);
+    const runtime = await resolveSessionRuntime(paths);
+    const payload = {
+        repoRoot,
+        kaviDir: paths.kaviDir,
+        configFile: paths.configFile,
+        homeConfigFile: paths.homeConfigFile,
+        homeStateDir: paths.homeStateDir,
+        worktreeRoot: paths.worktreeRoot,
+        integrationRoot: paths.integrationRoot,
+        stateFile: paths.stateFile,
+        eventsFile: paths.eventsFile,
+        approvalsFile: paths.approvalsFile,
+        commandsFile: paths.commandsFile,
+        runsDir: paths.runsDir,
+        claudeSettingsFile: paths.claudeSettingsFile,
+        homeApprovalRulesFile: paths.homeApprovalRulesFile,
+        runtime
+    };
+    if (args.includes("--json")) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    console.log(`Repo: ${payload.repoRoot}`);
+    console.log(`Kavi dir: ${payload.kaviDir}`);
+    console.log(`Repo config: ${payload.configFile}`);
+    console.log(`Home config: ${payload.homeConfigFile}`);
+    console.log(`Home state: ${payload.homeStateDir}`);
+    console.log(`Worktrees: ${payload.worktreeRoot}`);
+    console.log(`Integration: ${payload.integrationRoot}`);
+    console.log(`State file: ${payload.stateFile}`);
+    console.log(`Events file: ${payload.eventsFile}`);
+    console.log(`Approvals file: ${payload.approvalsFile}`);
+    console.log(`Command queue: ${payload.commandsFile}`);
+    console.log(`Task artifacts: ${payload.runsDir}`);
+    console.log(`Claude settings: ${payload.claudeSettingsFile}`);
+    console.log(`Approval rules: ${payload.homeApprovalRulesFile}`);
+    console.log(`Runtime: node=${runtime.nodeExecutable} codex=${runtime.codexExecutable} claude=${runtime.claudeExecutable}`);
+}
+async function commandTask(cwd, args) {
+    const { paths } = await requireSession(cwd);
+    const session = await loadSessionRecord(paths);
+    const requestedAgent = getFlag(args, "--agent");
+    const prompt = getGoal(args.filter((arg, index)=>arg !== "--agent" && args[index - 1] !== "--agent"));
+    if (!prompt) {
+        throw new Error("A task prompt is required. Example: kavi task --agent auto \"Build auth route\"");
+    }
+    const owner = requestedAgent === "codex" || requestedAgent === "claude" ? requestedAgent : routePrompt(prompt, session.config);
+    await appendCommand(paths, "enqueue", {
+        owner,
+        prompt
+    });
+    await recordEvent(paths, session.id, "task.cli_enqueued", {
+        owner,
+        prompt
+    });
+    console.log(`Queued task for ${owner}: ${prompt}`);
+}
+async function commandTasks(cwd, args) {
+    const { paths } = await requireSession(cwd);
+    const session = await loadSessionRecord(paths);
+    const artifacts = await listTaskArtifacts(paths);
+    const artifactMap = new Map(artifacts.map((artifact)=>[
+            artifact.taskId,
+            artifact
+        ]));
+    const payload = session.tasks.map((task)=>({
+            id: task.id,
+            title: task.title,
+            owner: task.owner,
+            status: task.status,
+            createdAt: task.createdAt,
+            updatedAt: task.updatedAt,
+            summary: task.summary,
+            hasArtifact: artifactMap.has(task.id)
+        }));
+    if (args.includes("--json")) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    for (const task of payload){
+        console.log(`${task.id} | ${task.owner} | ${task.status} | artifact=${task.hasArtifact ? "yes" : "no"}`);
+        console.log(`  title: ${task.title}`);
+        console.log(`  updated: ${task.updatedAt}`);
+        console.log(`  summary: ${task.summary ?? "-"}`);
+    }
+}
+function resolveRequestedTaskId(args, knownTaskIds) {
+    const positional = args.filter((arg)=>!arg.startsWith("--"));
+    const requested = positional[0] ?? "latest";
+    if (requested !== "latest") {
+        return requested;
+    }
+    const latest = [
+        ...knownTaskIds
+    ].pop();
+    if (!latest) {
+        throw new Error("No tasks found for this session.");
+    }
+    return latest;
+}
+async function commandTaskOutput(cwd, args) {
+    const { paths } = await requireSession(cwd);
+    const session = await loadSessionRecord(paths);
+    const sortedTasks = [
+        ...session.tasks
+    ].sort((left, right)=>left.updatedAt.localeCompare(right.updatedAt));
+    const taskId = resolveRequestedTaskId(args, sortedTasks.map((task)=>task.id));
+    const artifact = await loadTaskArtifact(paths, taskId);
+    if (!artifact) {
+        throw new Error(`No task artifact found for ${taskId}.`);
+    }
+    if (args.includes("--json")) {
+        console.log(JSON.stringify(artifact, null, 2));
+        return;
+    }
+    console.log(`Task: ${artifact.taskId}`);
+    console.log(`Owner: ${artifact.owner}`);
+    console.log(`Status: ${artifact.status}`);
+    console.log(`Started: ${artifact.startedAt}`);
+    console.log(`Finished: ${artifact.finishedAt}`);
+    console.log(`Summary: ${artifact.summary ?? "-"}`);
+    console.log(`Error: ${artifact.error ?? "-"}`);
+    console.log("Envelope:");
+    console.log(JSON.stringify(artifact.envelope, null, 2));
+    console.log("Raw Output:");
+    console.log(artifact.rawOutput ?? "");
+}
+async function commandApprovals(cwd, args) {
+    const { paths } = await requireSession(cwd);
+    const requests = await listApprovalRequests(paths, {
+        includeResolved: args.includes("--all")
+    });
+    if (args.includes("--json")) {
+        console.log(JSON.stringify(requests, null, 2));
+        return;
+    }
+    if (requests.length === 0) {
+        console.log("No approval requests.");
+        return;
+    }
+    for (const request of requests){
+        console.log(`${request.id} | ${request.agent} | ${request.status} | ${request.summary}${request.remember ? " | remembered" : ""}`);
+        console.log(`  created: ${request.createdAt}`);
+        console.log(`  decision: ${request.decision ?? "-"}`);
+    }
+}
+function resolveApprovalRequestId(requests, requested) {
+    if (requested && requested !== "latest") {
+        return requested;
+    }
+    const latest = [
+        ...requests
+    ].filter((request)=>request.status === "pending").sort((left, right)=>left.createdAt.localeCompare(right.createdAt)).pop();
+    if (!latest) {
+        throw new Error("No pending approval requests.");
+    }
+    return latest.id;
+}
+async function commandResolveApproval(cwd, args, decision) {
+    const { paths } = await requireSession(cwd);
+    const requests = await listApprovalRequests(paths, {
+        includeResolved: true
+    });
+    const requestedId = args.find((arg)=>!arg.startsWith("--")) ?? "latest";
+    const requestId = resolveApprovalRequestId(requests, requestedId);
+    const remember = args.includes("--remember");
+    const request = await resolveApprovalRequest(paths, requestId, decision, remember);
+    const session = await loadSessionRecord(paths);
+    await recordEvent(paths, session.id, "approval.resolved", {
+        requestId: request.id,
+        decision,
+        remember,
+        agent: request.agent,
+        toolName: request.toolName
+    });
+    console.log(`${decision === "allow" ? "Approved" : "Denied"} ${request.id}: ${request.summary}${remember ? " (remembered)" : ""}`);
+}
+async function commandEvents(cwd, args) {
+    const { paths } = await requireSession(cwd);
+    const limitArg = getFlag(args, "--limit");
+    const limit = limitArg ? Number(limitArg) : 20;
+    const events = await readRecentEvents(paths, Number.isFinite(limit) ? limit : 20);
+    for (const event of events){
+        console.log(`${event.timestamp} ${event.type} ${JSON.stringify(event.payload)}`);
+    }
+}
+async function commandStop(cwd) {
+    const { paths } = await requireSession(cwd);
+    const session = await loadSessionRecord(paths);
+    if (!isSessionLive(session)) {
+        session.status = "stopped";
+        session.daemonHeartbeatAt = new Date().toISOString();
+        await writeJson(paths.stateFile, session);
+        console.log(`Marked stale Kavi session ${session.id} as stopped`);
+        return;
+    }
+    await appendCommand(paths, "shutdown", {});
+    await recordEvent(paths, session.id, "daemon.stop_requested", {});
+    await waitForSession(paths, "stopped");
+    console.log(`Stopped Kavi session ${session.id}`);
+}
+async function commandLand(cwd) {
+    const repoRoot = await detectRepoRoot(cwd);
+    const paths = resolveAppPaths(repoRoot);
+    const session = await loadSessionRecord(paths);
+    const targetBranch = await resolveTargetBranch(repoRoot, session.config.baseBranch);
+    const result = await landBranches(repoRoot, targetBranch, session.worktrees, session.config.validationCommand, session.id, paths.integrationRoot);
+    await recordEvent(paths, session.id, "land.completed", {
+        targetBranch,
+        integrationBranch: result.integrationBranch,
+        integrationPath: result.integrationPath,
+        snapshotCommits: result.snapshotCommits,
+        commands: result.commandsRun
+    });
+    console.log(`Landed branches into ${targetBranch}`);
+    console.log(`Integration branch: ${result.integrationBranch}`);
+    console.log(`Integration worktree: ${result.integrationPath}`);
+    for (const snapshot of result.snapshotCommits){
+        console.log(`Snapshot ${snapshot.agent}: ${snapshot.commit}${snapshot.createdCommit ? " (created)" : " (unchanged)"}`);
+    }
+    for (const command of result.commandsRun){
+        console.log(`- ${command}`);
+    }
+}
+async function commandDaemon(args) {
+    const repoRoot = getFlag(args, "--repo-root") ?? process.cwd();
+    const paths = resolveAppPaths(repoRoot);
+    const daemon = new KaviDaemon(paths);
+    await daemon.start();
+}
+async function commandHook(args) {
+    const repoRoot = getFlag(args, "--repo-root") ?? process.cwd();
+    const agent = getFlag(args, "--agent") ?? null;
+    const eventName = getFlag(args, "--event") ?? "Unknown";
+    const stdin = await readStdinText();
+    const payload = stdin.trim() ? JSON.parse(stdin) : {};
+    const paths = resolveAppPaths(repoRoot);
+    const session = await sessionExists(paths) ? await loadSessionRecord(paths) : null;
+    const hookPayload = {
+        event: eventName,
+        sessionId: session?.id ?? null,
+        agent,
+        payload
+    };
+    if (session && agent === "claude" && eventName === "PreToolUse") {
+        const descriptor = describeToolUse(payload);
+        if (CLAUDE_AUTO_ALLOW_TOOLS.has(descriptor.toolName)) {
+            await recordEvent(paths, session.id, "approval.auto_allowed", {
+                agent,
+                toolName: descriptor.toolName,
+                summary: descriptor.summary
+            });
+            console.log(JSON.stringify({
+                continue: true,
+                suppressOutput: true,
+                hookSpecificOutput: {
+                    hookEventName: "PreToolUse",
+                    permissionDecision: "allow",
+                    permissionDecisionReason: `Kavi auto-allowed read-only tool: ${descriptor.summary}`
+                }
+            }));
+            return;
+        }
+        const rule = await findApprovalRule(paths, {
+            repoRoot: session.repoRoot,
+            agent,
+            toolName: descriptor.toolName,
+            matchKey: descriptor.matchKey
+        });
+        if (rule) {
+            await recordEvent(paths, session.id, "approval.auto_decided", {
+                agent,
+                toolName: descriptor.toolName,
+                decision: rule.decision,
+                summary: descriptor.summary
+            });
+            console.log(JSON.stringify({
+                continue: true,
+                suppressOutput: true,
+                hookSpecificOutput: {
+                    hookEventName: "PreToolUse",
+                    permissionDecision: rule.decision === "allow" ? "allow" : "deny",
+                    permissionDecisionReason: `Kavi ${rule.decision} rule matched: ${descriptor.summary}`
+                }
+            }));
+            return;
+        }
+        const request = await createApprovalRequest(paths, {
+            sessionId: session.id,
+            repoRoot: session.repoRoot,
+            agent,
+            hookEvent: eventName,
+            payload
+        });
+        await recordEvent(paths, session.id, "approval.requested", {
+            requestId: request.id,
+            agent,
+            toolName: request.toolName,
+            summary: request.summary
+        });
+        const resolved = await waitForApprovalDecision(paths, request.id);
+        const approved = resolved?.status === "approved";
+        const denied = resolved?.status === "denied";
+        const timedOut = resolved?.status === "expired" || !resolved;
+        await recordEvent(paths, session.id, "approval.completed", {
+            requestId: request.id,
+            outcome: approved ? "approved" : denied ? "denied" : "expired"
+        });
+        console.log(JSON.stringify({
+            continue: true,
+            suppressOutput: true,
+            hookSpecificOutput: {
+                hookEventName: "PreToolUse",
+                permissionDecision: approved ? "allow" : "deny",
+                permissionDecisionReason: approved ? `Approved by Kavi: ${request.summary}` : timedOut ? `Kavi approval timed out: ${request.summary}` : `Denied by Kavi: ${request.summary}`
+            }
+        }));
+        return;
+    }
+    if (session) {
+        await recordEvent(paths, session.id, "claude.hook", hookPayload);
+    }
+    console.log(JSON.stringify({
+        continue: true
+    }));
+}
+async function main() {
+    const [command = "open", ...args] = process.argv.slice(2);
+    const cwd = process.cwd();
+    switch(command){
+        case "help":
+        case "--help":
+        case "-h":
+            console.log(renderUsage());
+            break;
+        case "init":
+            await commandInit(cwd, args);
+            break;
+        case "doctor":
+            await commandDoctor(cwd, args);
+            break;
+        case "start":
+            await commandStart(cwd, args);
+            break;
+        case "open":
+            await commandOpen(cwd, args);
+            break;
+        case "resume":
+            await commandResume(cwd);
+            break;
+        case "status":
+            await commandStatus(cwd, args);
+            break;
+        case "paths":
+            await commandPaths(cwd, args);
+            break;
+        case "task":
+            await commandTask(cwd, args);
+            break;
+        case "tasks":
+            await commandTasks(cwd, args);
+            break;
+        case "task-output":
+            await commandTaskOutput(cwd, args);
+            break;
+        case "approvals":
+            await commandApprovals(cwd, args);
+            break;
+        case "approve":
+            await commandResolveApproval(cwd, args, "allow");
+            break;
+        case "deny":
+            await commandResolveApproval(cwd, args, "deny");
+            break;
+        case "events":
+            await commandEvents(cwd, args);
+            break;
+        case "stop":
+            await commandStop(cwd);
+            break;
+        case "land":
+            await commandLand(cwd);
+            break;
+        case "__daemon":
+            await commandDaemon(args);
+            break;
+        case "__hook":
+            await commandHook(args);
+            break;
+        default:
+            throw new Error(`Unknown command: ${command}`);
+    }
+}
+main().catch((error)=>{
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});
+
+
+//# sourceURL=main.ts