propr-cli 0.8.3

package/dist/commands/checkCommands.js

@@ -0,0 +1,384 @@
+/**
+ * Environment Check (doctor)
+ *
+ * `propr check` verifies the host is ready to run a local ProPR stack: Docker is
+ * installed and running, the stack images are available, and agent credentials
+ * are present. It is also what bare `propr` runs.
+ */
+import { Command } from "commander";
+import { spawnSync } from "node:child_process";
+import { existsSync, accessSync, readFileSync, constants as fsConstants } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { resolveGithubAuthMode, validateRelayUrl } from "../vendor/shared/index.js";
+import { createConfigManager } from "../config/index.js";
+import { getHostConfig } from "../orchestrator/index.js";
+import { printOutput } from "../utils/index.js";
+function agentDescriptors() {
+    const home = homedir();
+    return [
+        { type: "claude", hostDirKey: "hostClaudeDir", envKey: "HOST_CLAUDE_DIR", defaultDir: join(home, ".claude"), imageKey: "agent-claude", bin: "claude" },
+        { type: "codex", hostDirKey: "hostCodexDir", envKey: "HOST_CODEX_DIR", defaultDir: join(home, ".codex"), imageKey: "agent-codex", bin: "codex" },
+        { type: "antigravity", hostDirKey: "hostAntigravityDir", envKey: "HOST_ANTIGRAVITY_DIR", defaultDir: join(home, ".gemini"), imageKey: "agent-antigravity", bin: "gemini" },
+        { type: "opencode", hostDirKey: "hostOpencodeXdgDir", envKey: "HOST_OPENCODE_XDG_DIR", defaultDir: join(home, ".config", "opencode"), imageKey: "agent-opencode", bin: "opencode" },
+        { type: "opencode-legacy", hostDirKey: "hostOpencodeLegacyDir", envKey: "HOST_OPENCODE_LEGACY_DIR", defaultDir: join(home, ".opencode"), imageKey: "agent-opencode", bin: "opencode" },
+        { type: "opencode-data", hostDirKey: "hostOpencodeDataDir", envKey: "HOST_OPENCODE_DATA_DIR", defaultDir: join(home, ".local", "share", "opencode"), imageKey: "agent-opencode", bin: "opencode" },
+        { type: "vibe", hostDirKey: "hostVibeDir", envKey: "HOST_VIBE_DIR", defaultDir: join(home, ".vibe"), imageKey: "agent-vibe", bin: "vibe" },
+    ];
+}
+export const STACK_CONFIG_CHECK_NAME = "Stack config (.env)";
+const STATUS_GLYPH = { ok: "✓", warn: "!", fail: "✗" };
+/** Run all checks and return the structured outcome (no printing). */
+export async function runChecks(options = {}) {
+    const results = [];
+    const configManager = await createConfigManager();
+    // 1. Docker installed
+    const dockerVersion = spawnSync("docker", ["--version"], { encoding: "utf-8" });
+    if (dockerVersion.status === 0) {
+        results.push({ name: "Docker installed", status: "ok", detail: dockerVersion.stdout.trim() });
+    }
+    else {
+        results.push({
+            name: "Docker installed",
+            status: "fail",
+            detail: "`docker` command not found",
+            fix: "Install Docker: https://docs.docker.com/get-docker/",
+        });
+    }
+    const { orch, cfg, rootDir } = await getHostConfig({ configManager, root: options.root });
+    // 2. Docker daemon running
+    const daemonUp = orch.dockerAvailable();
+    results.push(daemonUp
+        ? { name: "Docker daemon", status: "ok", detail: "daemon is reachable" }
+        : {
+            name: "Docker daemon",
+            status: "fail",
+            detail: "cannot reach the Docker daemon (`docker info` failed)",
+            fix: "Start Docker (e.g. `sudo systemctl start docker`) and ensure your user can access it.",
+        });
+    // 3. Docker socket (informational — only relevant for the default socket setup)
+    const socketPath = "/var/run/docker.sock";
+    if (existsSync(socketPath)) {
+        let accessible = true;
+        try {
+            accessSync(socketPath, fsConstants.R_OK | fsConstants.W_OK);
+        }
+        catch {
+            accessible = false;
+        }
+        results.push(accessible
+            ? { name: "Docker socket", status: "ok", detail: socketPath }
+            : {
+                name: "Docker socket",
+                status: "warn",
+                detail: `${socketPath} is not read/write for the current user`,
+                fix: "Add your user to the `docker` group, or run with sufficient privileges.",
+            });
+    }
+    // 4. Stack root + .env
+    const envPath = join(rootDir, ".env");
+    if (existsSync(envPath)) {
+        results.push({ name: STACK_CONFIG_CHECK_NAME, status: "ok", detail: envPath });
+    }
+    else {
+        results.push({
+            name: STACK_CONFIG_CHECK_NAME,
+            status: "warn",
+            detail: `no .env found at ${rootDir}`,
+            fix: "Run `propr init stack` to scaffold .env, data/, logs/ and repos/.",
+        });
+    }
+    // 5. Stack images present locally
+    if (daemonUp) {
+        for (const [key, tag] of Object.entries(cfg.images)) {
+            if (key === "docs" && !cfg.docsEnabled)
+                continue;
+            const present = imagePresent(orch, tag);
+            if (present) {
+                results.push({ name: `Image ${key}`, status: "ok", detail: tag });
+            }
+            else {
+                const isAgent = key.startsWith("agent-");
+                results.push({
+                    name: `Image ${key}`,
+                    status: "warn",
+                    detail: `${tag} not present locally`,
+                    fix: isAgent
+                        ? "Jobs using this agent fail until the image is pulled. `propr start` pulls it, or build with scripts/build-images.sh."
+                        : "Will be pulled automatically on `propr start`.",
+                });
+            }
+        }
+    }
+    // 6. Agent credential dirs
+    for (const agent of agentDescriptors()) {
+        const configured = cfg[agent.hostDirKey];
+        const dir = configured || agent.defaultDir;
+        if (existsSync(dir)) {
+            results.push({ name: `Agent creds: ${agent.type}`, status: "ok", detail: dir });
+        }
+        else {
+            results.push({
+                name: `Agent creds: ${agent.type}`,
+                status: "warn",
+                detail: `${dir} not found — ${agent.type} will not authenticate`,
+                fix: `Log in with the ${agent.type} CLI on this host, or set ${agent.envKey} in .env.`,
+            });
+        }
+    }
+    // 7. GitHub credentials (the backend hard-exits without a valid auth mode)
+    const fileEnv = existsSync(envPath) ? orch.readEnvFile(envPath) : {};
+    for (const r of checkGithubAuth(fileEnv, cfg))
+        results.push(r);
+    // 8. User whitelist — warn when no whitelist is configured for non-demo stacks
+    const whitelistRaw = process.env.GITHUB_USER_WHITELIST ?? fileEnv.GITHUB_USER_WHITELIST;
+    const whitelistEntries = (whitelistRaw ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+    const authMode = (process.env.GH_AUTH_MODE ?? fileEnv.GH_AUTH_MODE ?? "").trim().toLowerCase();
+    const isDemo = isTruthy(process.env.PROPR_DEMO_MODE ?? fileEnv.PROPR_DEMO_MODE) || authMode === "demo";
+    if (whitelistEntries.length === 0 && !isDemo) {
+        results.push({
+            name: "User whitelist",
+            status: "warn",
+            detail: "GITHUB_USER_WHITELIST is not set — any GitHub user who can authenticate to this instance may trigger processing and use the API (within the App's repository access)",
+            fix: "Set GITHUB_USER_WHITELIST to a comma-separated list of allowed GitHub usernames in .env.",
+        });
+    }
+    else if (whitelistEntries.length > 0) {
+        results.push({ name: "User whitelist", status: "ok", detail: `${whitelistEntries.length} user(s) allowed` });
+    }
+    // 9. Config validation from the orchestrator (bind paths, vibe dirs, etc.)
+    const validation = orch.validateEnv(cfg);
+    for (const warn of validation.warnings) {
+        results.push({ name: "Config warning", status: "warn", detail: warn });
+    }
+    for (const err of validation.errors) {
+        // env file / data dir absence is already surfaced by steps 4–6 above; skip duplicates.
+        if (/env file path is not set/i.test(err))
+            continue;
+        if (/data directory.*is not set/i.test(err))
+            continue;
+        results.push({ name: "Config error", status: "fail", detail: err });
+    }
+    // 10. Deep verify (opt-in): image/CLI smoke test per selected agent
+    if (options.verify && daemonUp) {
+        const selected = options.agents && options.agents.length
+            ? agentDescriptors().filter((a) => options.agents.includes(a.type))
+            : agentDescriptors();
+        for (const agent of selected) {
+            const tag = cfg.images[agent.imageKey];
+            if (!tag || !imagePresent(orch, tag)) {
+                results.push({
+                    name: `Verify: ${agent.type}`,
+                    status: "warn",
+                    detail: `image ${tag ?? agent.imageKey} not present — skipped`,
+                });
+                continue;
+            }
+            const run = spawnSync("docker", ["run", "--rm", "--network=none", "--memory=512m", tag, agent.bin, "--version"], { encoding: "utf-8", timeout: 60000 });
+            if (run.status === 0) {
+                results.push({ name: `Verify: ${agent.type}`, status: "ok", detail: `image runs (${(run.stdout || "").trim().split("\n")[0]})` });
+            }
+            else {
+                results.push({
+                    name: `Verify: ${agent.type}`,
+                    status: "warn",
+                    detail: `image/CLI smoke test failed: ${(run.stderr || run.stdout || "").trim().split("\n")[0]}`,
+                });
+            }
+        }
+    }
+    const anyFail = results.some((r) => r.status === "fail");
+    return { results, cfg, rootDir, anyFail };
+}
+function imagePresent(orch, tag) {
+    const res = orch.docker(["images", "-q", tag], { capture: true });
+    return res.stdout.trim().length > 0;
+}
+const TRUTHY = new Set(["1", "true", "yes", "on"]);
+function isTruthy(value) {
+    return value !== undefined && TRUTHY.has(value.trim().toLowerCase());
+}
+// Matches the unedited .env.example placeholders (your_app_id, path/to/..., etc.).
+// Every alternative is anchored so a real value that merely contains a
+// placeholder-looking substring is not misflagged.
+function isPlaceholder(value) {
+    if (!value || value.trim() === "")
+        return true;
+    return /^your_|^\.?\/path\/to|^changeme$|^x{4,}$|^example\.com$/i.test(value.trim());
+}
+// Forward-compatible relay env names (see the token-relay plan). Presence of the
+// relay URL selects relay mode.
+const RELAY_URL_KEY = "PROPR_GH_RELAY_URL";
+const RELAY_TOKEN_KEY = "PROPR_GH_RELAY_TOKEN";
+/**
+ * Verify the GitHub credentials the backend needs to boot. The daemon/worker/api
+ * import @propr/core's githubAuth, which hard-exits unless one of these is true:
+ * demo mode, a token relay, or a configured GitHub App + readable key.
+ *
+ * The mode itself comes from @propr/shared's resolveGithubAuthMode — the same
+ * function the backend uses — so this check cannot drift from boot behavior.
+ */
+function checkGithubAuth(env, cfg) {
+    const val = (k) => process.env[k] ?? env[k];
+    const out = [];
+    const relayUrl = val(RELAY_URL_KEY);
+    const relayToken = val(RELAY_TOKEN_KEY);
+    const { mode, warnings } = resolveGithubAuthMode({
+        demoMode: isTruthy(val("PROPR_DEMO_MODE")),
+        ghAuthMode: val("GH_AUTH_MODE"),
+        relayUrl,
+        relayToken,
+        appId: val("GH_APP_ID"),
+        privateKeyPath: val("GH_PRIVATE_KEY_PATH"),
+        installationId: val("GH_INSTALLATION_ID"),
+    });
+    for (const warning of warnings) {
+        out.push({ name: "GitHub auth", status: "warn", detail: warning });
+    }
+    if (mode === "demo") {
+        out.push({ name: "GitHub auth", status: "ok", detail: "demo mode — GitHub access disabled" });
+        return out;
+    }
+    if (mode === "none") {
+        out.push({
+            name: "GitHub auth mode",
+            status: "fail",
+            detail: "no GitHub auth configured — the backend will exit at startup",
+            fix: "Set GH_APP_ID + GH_INSTALLATION_ID + a private key (own App), or PROPR_GH_RELAY_URL + PROPR_GH_RELAY_TOKEN (token relay), or PROPR_DEMO_MODE=true.",
+        });
+        return out;
+    }
+    if (mode === "relay") {
+        const urlError = relayUrl ? validateRelayUrl(relayUrl) : `${RELAY_URL_KEY} must be set for relay mode`;
+        out.push(urlError
+            ? { name: "GitHub auth mode", status: "fail", detail: urlError, fix: "Use an https:// relay URL (http only for localhost)." }
+            : { name: "GitHub auth mode", status: "ok", detail: `token relay (${relayUrl})` });
+        if (!relayToken) {
+            out.push({
+                name: "Relay credential",
+                status: "fail",
+                detail: `${RELAY_TOKEN_KEY} is not set`,
+                fix: `Set ${RELAY_TOKEN_KEY} to the relay credential issued for your installation.`,
+            });
+        }
+        else {
+            out.push({ name: "Relay credential", status: "ok", detail: `${RELAY_TOKEN_KEY} is set` });
+        }
+        return out;
+    }
+    // App mode (default).
+    out.push({ name: "GitHub auth mode", status: "ok", detail: "GitHub App (own/shared app)" });
+    const appId = val("GH_APP_ID");
+    const installationId = val("GH_INSTALLATION_ID");
+    out.push(isPlaceholder(appId)
+        ? { name: "GH_APP_ID", status: "fail", detail: "missing or placeholder", fix: "Set GH_APP_ID from your GitHub App settings." }
+        : { name: "GH_APP_ID", status: "ok", detail: appId });
+    out.push(isPlaceholder(installationId)
+        ? { name: "GH_INSTALLATION_ID", status: "fail", detail: "missing or placeholder", fix: "Set GH_INSTALLATION_ID for the App's installation on your account/org." }
+        : { name: "GH_INSTALLATION_ID", status: "ok", detail: installationId });
+    // Private key reachability. Prefer the explicit host mount (HOST_GH_PRIVATE_KEY).
+    const hostKey = cfg.hostGhPrivateKey;
+    const keyPath = val("GH_PRIVATE_KEY_PATH");
+    if (hostKey) {
+        if (!existsSync(hostKey)) {
+            out.push({ name: "GitHub App key", status: "fail", detail: `HOST_GH_PRIVATE_KEY (${hostKey}) does not exist` });
+        }
+        else {
+            let readable = true;
+            try {
+                accessSync(hostKey, fsConstants.R_OK);
+            }
+            catch {
+                readable = false;
+            }
+            const looksLikePem = readable && /-----BEGIN [A-Z ]*PRIVATE KEY-----/.test(safeRead(hostKey));
+            out.push(readable && looksLikePem
+                ? { name: "GitHub App key", status: "ok", detail: `${hostKey} (mounted read-only)` }
+                : {
+                    name: "GitHub App key",
+                    status: "fail",
+                    detail: readable ? `${hostKey} does not look like a PEM private key` : `${hostKey} is not readable`,
+                });
+        }
+    }
+    else if (isPlaceholder(keyPath)) {
+        out.push({
+            name: "GitHub App key",
+            status: "fail",
+            detail: "no private key configured",
+            fix: "Set HOST_GH_PRIVATE_KEY to your .pem host path (recommended), or stage the key under data/ and set GH_PRIVATE_KEY_PATH.",
+        });
+    }
+    else {
+        out.push({
+            name: "GitHub App key",
+            status: "warn",
+            detail: `GH_PRIVATE_KEY_PATH=${keyPath} — reachability inside the container not verified`,
+            fix: "Prefer HOST_GH_PRIVATE_KEY (bind-mounts the key), or ensure this path resolves inside the container (e.g. under data/).",
+        });
+    }
+    return out;
+}
+function safeRead(path) {
+    try {
+        return readFileSync(path, "utf-8").slice(0, 200);
+    }
+    catch {
+        return "";
+    }
+}
+/** Print a human-readable check table. */
+export function printChecks(outcome) {
+    console.log("");
+    console.log(`ProPR environment check  (stack root: ${outcome.rootDir})`);
+    console.log("─".repeat(60));
+    for (const r of outcome.results) {
+        const glyph = STATUS_GLYPH[r.status];
+        console.log(`${glyph}  ${r.name.padEnd(24)} ${r.detail}`);
+        if (r.fix && r.status !== "ok") {
+            console.log(`   ↳ ${r.fix}`);
+        }
+    }
+    console.log("─".repeat(60));
+    const counts = { ok: 0, warn: 0, fail: 0 };
+    for (const r of outcome.results)
+        counts[r.status]++;
+    console.log(`${counts.ok} ok, ${counts.warn} warning(s), ${counts.fail} failure(s)`);
+}
+/** Creates the `check` command. */
+export function createCheckCommand() {
+    return new Command("check")
+        .description("Verify the host is ready to run a local ProPR stack (Docker, images, agents)")
+        .option("--root <dir>", "Stack root directory (where .env/data/logs/repos live)")
+        .option("--verify", "Also run an image/CLI smoke test for each agent (slower)")
+        .option("--agents <list>", "Comma-separated agent types to --verify (default: all)")
+        .option("--json", "Output raw JSON")
+        .addHelpText("after", `
+Examples:
+  $ propr check
+  $ propr check --verify
+  $ propr check --verify --agents claude,codex
+  $ propr check --json
+`)
+        .action(async (options) => {
+        try {
+            const outcome = await runChecks({
+                root: options.root,
+                verify: options.verify,
+                agents: options.agents ? options.agents.split(",").map((s) => s.trim()).filter(Boolean) : undefined,
+            });
+            if (options.json) {
+                printOutput({ rootDir: outcome.rootDir, results: outcome.results }, true);
+            }
+            else {
+                printChecks(outcome);
+            }
+            if (outcome.anyFail)
+                process.exit(1);
+        }
+        catch (error) {
+            console.error(`Error running checks: ${error.message}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/implementCommands.js

@@ -0,0 +1,178 @@
+/**
+ * Implementation Commands
+ *
+ * CLI commands for implementing issues using the ProPR backend.
+ * Provides the `issue` command group with the `implement` subcommand.
+ */
+import { Command } from "commander";
+import { ProjectResolutionError } from "../utils/index.js";
+import { implementIssue, getTaskStatus, } from "../api/index.js";
+/**
+ * Terminal states that indicate a task has finished processing.
+ */
+const TERMINAL_STATES = ["completed", "failed", "cancelled"];
+/**
+ * Poll interval in milliseconds.
+ */
+const POLL_INTERVAL_MS = 3000;
+/**
+ * Maximum wait time in milliseconds (10 minutes).
+ */
+const MAX_WAIT_MS = 600000;
+/**
+ * Parses an issue identifier in the format "draft-id/issue-number" or "draft-id:issue-number".
+ */
+function parseIssueId(issueId) {
+    const separatorMatch = issueId.match(/^(.+)[\/:](\d+)$/);
+    if (separatorMatch) {
+        const draftId = separatorMatch[1];
+        const issueNumber = parseInt(separatorMatch[2], 10);
+        if (!isNaN(issueNumber) && issueNumber > 0) {
+            return { draftId, issueNumber };
+        }
+    }
+    return null;
+}
+/**
+ * Formats the current task state for display.
+ */
+function formatState(state) {
+    const stateMap = {
+        pending: "Pending",
+        queued: "Queued",
+        processing: "Processing",
+        claude_execution: "Executing",
+        post_processing: "Post-processing",
+        completed: "Completed",
+        failed: "Failed",
+        cancelled: "Cancelled",
+    };
+    return stateMap[state] || state;
+}
+/**
+ * Polls the task status until it reaches a terminal state.
+ */
+async function pollTaskStatus(taskId) {
+    const startTime = Date.now();
+    let lastState = "";
+    while (Date.now() - startTime < MAX_WAIT_MS) {
+        const status = await getTaskStatus(taskId);
+        if (status.currentState !== lastState) {
+            console.log(`Status: ${formatState(status.currentState)}`);
+            lastState = status.currentState;
+        }
+        if (TERMINAL_STATES.includes(status.currentState)) {
+            return status;
+        }
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    }
+    const finalStatus = await getTaskStatus(taskId);
+    return finalStatus;
+}
+/**
+ * Creates the `issue` command group.
+ */
+export function createIssueCommand() {
+    const issue = new Command("issue")
+        .description("Manage GitHub issue implementation")
+        .addHelpText("after", `
+Examples:
+  $ propr issue implement abc123/1
+  $ propr issue implement abc123:42 --wait
+  $ propr issue implement abc123/1 -a claude --wait --auto-merge
+`);
+    issue
+        .command("implement <issue-id>")
+        .description("Implement a GitHub issue from a plan using AI agents")
+        .option("-p, --project <project>", "Target project (owner/repo)")
+        .option("-w, --wait", "Wait for the implementation to complete")
+        .option("-a, --agent <agent>", "Agent alias to use for implementation")
+        .option("-m, --model <model>", "Model name to use for implementation")
+        .option("--epic", "Create an Epic PR to collect all related PRs")
+        .option("--auto-merge", "Enable auto-merge for the created PR")
+        .addHelpText("after", `
+Argument:
+  issue-id    Format: <draft-id>/<issue-number> or <draft-id>:<issue-number>
+
+Examples:
+  $ propr issue implement abc123/1
+  $ propr issue implement abc123:42 --wait
+  $ propr issue implement abc123/1 -a claude -m claude-sonnet-4-20250514 --wait
+  $ propr issue implement abc123/1 --epic --auto-merge
+`)
+        .action(async (issueId, options) => {
+        try {
+            const parsed = parseIssueId(issueId);
+            if (!parsed) {
+                console.error("Error: Invalid issue ID format. Expected: <draft-id>/<issue-number> or <draft-id>:<issue-number>");
+                console.error("");
+                console.error("Examples:");
+                console.error("  propr issue implement abc123/1");
+                console.error("  propr issue implement draft-uuid-here:42");
+                process.exit(1);
+            }
+            const { draftId, issueNumber } = parsed;
+            console.log(`Implementing issue #${issueNumber} from draft ${draftId}...`);
+            const result = await implementIssue(draftId, issueNumber, {
+                agent_alias: options.agent,
+                model_name: options.model,
+                useEpic: options.epic,
+                autoMerge: options.autoMerge,
+            });
+            if (!result.success) {
+                console.error(`Error: ${result.message}`);
+                process.exit(1);
+            }
+            console.log(result.message);
+            if (result.taskId) {
+                console.log(`Task ID: ${result.taskId}`);
+            }
+            if (!options.wait) {
+                if (result.taskId) {
+                    console.log("");
+                    console.log("Use 'propr issue implement <issue-id> --wait' to wait for completion.");
+                }
+                return;
+            }
+            if (!result.taskId) {
+                console.log("");
+                console.log("Note: No task ID returned. The implementation may be triggered asynchronously.");
+                return;
+            }
+            console.log("");
+            console.log("Waiting for implementation to complete...");
+            const finalStatus = await pollTaskStatus(result.taskId);
+            console.log("");
+            if (finalStatus.isCompleted) {
+                console.log("Implementation completed successfully!");
+                if (finalStatus.prNumber) {
+                    console.log(`Pull Request: #${finalStatus.prNumber}`);
+                }
+                if (finalStatus.prUrl) {
+                    console.log(`PR URL: ${finalStatus.prUrl}`);
+                }
+            }
+            else if (finalStatus.isFailed) {
+                console.error("Implementation failed.");
+                if (finalStatus.failureReason) {
+                    console.error(`Reason: ${finalStatus.failureReason}`);
+                }
+                process.exit(1);
+            }
+            else {
+                console.log(`Implementation is still ${formatState(finalStatus.currentState)}.`);
+                console.log(`Task ID: ${result.taskId}`);
+                console.log("You can check the status later using the ProPR dashboard.");
+            }
+        }
+        catch (error) {
+            if (error instanceof ProjectResolutionError) {
+                console.error(`Error: ${error.message}`);
+                process.exit(1);
+            }
+            console.error(`Error implementing issue: ${error.message}`);
+            process.exit(1);
+        }
+    });
+    return issue;
+}

package/dist/commands/index.js

@@ -0,0 +1,22 @@
+/**
+ * CLI Commands Module
+ *
+ * Exports command creation functions for the ProPR CLI.
+ */
+export { createIssueCommand } from "./implementCommands.js";
+export { createPlanCommand } from "./planCommands.js";
+export { createTaskCommand } from "./taskCommands.js";
+export { createRepoCommand } from "./repoCommands.js";
+export { createAgentCommand } from "./agentCommands.js";
+export { createSettingCommand } from "./settingCommands.js";
+export { createLogCommand } from "./logCommands.js";
+export { createTodoCommand } from "./todoCommands.js";
+export { createRemoteStatusCommand, createQueueCommand } from "./systemCommands.js";
+export { createInitCommand } from "./initCommands.js";
+// Control-plane commands (local Docker stack)
+export { createCheckCommand, runChecks, printChecks, STACK_CONFIG_CHECK_NAME } from "./checkCommands.js";
+export { createStartCommand } from "./startCommand.js";
+export { createStackStatusCommand, createStopCommand } from "./stackCommands.js";
+export { createUiCommand, createDocsCommand } from "./uiDocsCommands.js";
+export { createTankCommand } from "./tankCommands.js";
+export { createRelayCommand } from "./relayCommands.js";