propr-cli 0.8.3

package/dist/commands/settingCommands.js

@@ -0,0 +1,237 @@
+/**
+ * System Settings Commands
+ *
+ * CLI commands for managing system settings using the ProPR backend.
+ * Provides the `setting` command group with `get` and `update` subcommands.
+ */
+import { Command } from "commander";
+import { getSettings, updateSetting, isValidSettingKey, parseSettingValue, VALID_SETTING_KEYS, } from "../api/index.js";
+import { printOutput, } from "../utils/index.js";
+/**
+ * Formats a setting value for display.
+ */
+function formatValue(value) {
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return "(empty)";
+        }
+        return value.join(", ");
+    }
+    if (value === null || value === undefined || value === "") {
+        return "(not set)";
+    }
+    return String(value);
+}
+/**
+ * Gets a human-readable description for a setting key.
+ */
+function getSettingDescription(key) {
+    const descriptions = {
+        default_agent_alias: "Alias of the default implementation agent",
+        worker_concurrency: "Number of concurrent workers for processing tasks",
+        github_user_whitelist: "GitHub usernames allowed to use the system",
+        analysis_model_fast: "Model for fast analysis operations",
+        planner_context_model: "Model for planner context generation",
+        planner_generation_model: "Model for planner generation",
+        auto_followup_score_threshold: "Score threshold (0-9) for auto-followup",
+        auto_resolve_merge_conflicts: "Automatically resolve merge conflicts",
+        pr_review_model: "Model for full PR reviews",
+        pr_review_prompt: "Override for the PR review prompt guidance (empty = built-in default)",
+        ultrafix_rating_goal: "Target quality rating for ultrafix cycles",
+        ultrafix_max_cycles: "Maximum number of ultrafix cycles",
+        ultrafix_pause_seconds: "Pause duration between ultrafix cycles",
+    };
+    return descriptions[key];
+}
+function formatSettingKeysHelp() {
+    return VALID_SETTING_KEYS
+        .map((key) => `  ${key.padEnd(32)} ${getSettingDescription(key)}`)
+        .join("\n");
+}
+function printValidSettingKeys(includeDescriptions = false) {
+    console.log("Valid setting keys:");
+    for (const validKey of VALID_SETTING_KEYS) {
+        const description = includeDescriptions ? `: ${getSettingDescription(validKey)}` : "";
+        console.log(`  - ${validKey}${description}`);
+    }
+}
+/**
+ * Displays all settings in a formatted table.
+ */
+function displaySettingsTable(settings) {
+    const keys = Object.keys(settings);
+    const keyWidth = Math.max("Setting".length, ...keys.map((k) => k.length));
+    const valueWidth = Math.max("Value".length, ...keys.map((k) => formatValue(settings[k]).length));
+    const header = [
+        "Setting".padEnd(keyWidth),
+        "Value".padEnd(valueWidth),
+    ].join("  ");
+    console.log(header);
+    console.log("-".repeat(header.length));
+    for (const key of keys) {
+        const value = settings[key];
+        const row = [
+            key.padEnd(keyWidth),
+            formatValue(value).padEnd(valueWidth),
+        ].join("  ");
+        console.log(row);
+    }
+}
+/**
+ * Displays detailed information about a single setting.
+ */
+function displaySettingDetail(key, value) {
+    console.log("");
+    console.log("=".repeat(50));
+    console.log(`Setting: ${key}`);
+    console.log("=".repeat(50));
+    console.log("");
+    console.log(`Description: ${getSettingDescription(key)}`);
+    console.log(`Value:       ${formatValue(value)}`);
+    console.log("");
+}
+/**
+ * Creates the `setting` command group.
+ */
+export function createSettingCommand() {
+    const setting = new Command("setting")
+        .description("Manage system settings")
+        .addHelpText("after", `
+Examples:
+  $ propr setting get                                    # Show all settings
+  $ propr setting get -k worker_concurrency              # Show specific setting
+  $ propr setting update worker_concurrency 10           # Update a setting
+`);
+    // setting get
+    setting
+        .command("get")
+        .description("View current system settings for ProPR backend")
+        .option("-k, --key <key>", "Show only a specific setting key")
+        .option("-j, --json", "Output settings as JSON")
+        .addHelpText("after", `
+Valid Setting Keys:
+${formatSettingKeysHelp()}
+
+Examples:
+  $ propr setting get                                 # Show all settings
+  $ propr setting get -k worker_concurrency           # Show specific setting
+  $ propr setting get --json                          # Output as JSON
+`)
+        .action(async (options) => {
+        try {
+            const settings = await getSettings();
+            if (options.json) {
+                if (options.key) {
+                    if (!isValidSettingKey(options.key)) {
+                        console.error(`Error: Invalid setting key: ${options.key}`);
+                        console.log("");
+                        printValidSettingKeys();
+                        process.exit(1);
+                    }
+                    printOutput({ [options.key]: settings[options.key] }, true);
+                }
+                else {
+                    printOutput(settings, true);
+                }
+                return;
+            }
+            if (options.key) {
+                if (!isValidSettingKey(options.key)) {
+                    console.error(`Error: Invalid setting key: ${options.key}`);
+                    console.log("");
+                    printValidSettingKeys();
+                    process.exit(1);
+                }
+                displaySettingDetail(options.key, settings[options.key]);
+                return;
+            }
+            console.log("Fetching system settings...");
+            console.log("");
+            displaySettingsTable(settings);
+            console.log("");
+            console.log(`Total: ${Object.keys(settings).length} setting(s)`);
+        }
+        catch (error) {
+            const errorMessage = error.message;
+            if (errorMessage.includes("401") ||
+                errorMessage.includes("unauthorized")) {
+                console.error("Error: Unauthorized. Please run 'propr login' first.");
+            }
+            else if (errorMessage.includes("403") ||
+                errorMessage.includes("forbidden")) {
+                console.error("Error: Access denied. You do not have permission to view settings.");
+            }
+            else {
+                console.error(`Error fetching settings: ${errorMessage}`);
+            }
+            process.exit(1);
+        }
+    });
+    // setting update
+    setting
+        .command("update <key> <value>")
+        .description("Update a system setting")
+        .addHelpText("after", `
+Valid setting keys:
+${formatSettingKeysHelp()}
+
+Examples:
+  $ propr setting update worker_concurrency 10
+  $ propr setting update auto_followup_score_threshold 7
+  $ propr setting update github_user_whitelist "user1,user2,user3"
+  $ propr setting update analysis_model_fast claude-3-5-sonnet-20241022
+`)
+        .action(async (key, value) => {
+        try {
+            if (!isValidSettingKey(key)) {
+                console.error(`Error: Invalid setting key: ${key}`);
+                console.log("");
+                printValidSettingKeys(true);
+                process.exit(1);
+            }
+            let parsedValue;
+            try {
+                parsedValue = parseSettingValue(key, value);
+            }
+            catch (parseError) {
+                console.error(`Error: ${parseError.message}`);
+                process.exit(1);
+            }
+            console.log(`Updating setting: ${key}...`);
+            const result = await updateSetting(key, parsedValue);
+            if (result.success) {
+                console.log("");
+                console.log(`Successfully updated setting: ${key}`);
+                console.log(`  New value: ${formatValue(parsedValue)}`);
+            }
+            else {
+                console.error("Failed to update setting.");
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            const errorMessage = error.message;
+            if (errorMessage.includes("400")) {
+                console.error(`Error: Invalid value for setting "${key}".`);
+                console.log("");
+                console.log(`Description: ${getSettingDescription(key)}`);
+            }
+            else if (errorMessage.includes("401") ||
+                errorMessage.includes("unauthorized")) {
+                console.error("Error: Unauthorized. Please run 'propr login' first.");
+            }
+            else if (errorMessage.includes("403") ||
+                errorMessage.includes("forbidden")) {
+                console.error("Error: Access denied. You do not have permission to update settings.");
+            }
+            else if (errorMessage.includes("409")) {
+                console.error("Error: Configuration is being updated. Please try again.");
+            }
+            else {
+                console.error(`Error updating setting: ${errorMessage}`);
+            }
+            process.exit(1);
+        }
+    });
+    return setting;
+}

package/dist/commands/stackCommands.js

@@ -0,0 +1,86 @@
+/**
+ * Control-plane stack commands: `propr status` and `propr stop`.
+ *
+ * (`propr start` lives in ../tui because it renders a live dashboard.)
+ */
+import { Command } from "commander";
+import { createConfigManager } from "../config/index.js";
+import { getHostConfig } from "../orchestrator/index.js";
+import { renderStatusTable } from "../orchestrator/format.js";
+import { printOutput } from "../utils/index.js";
+/** Creates the `status` command — local stack status. */
+export function createStackStatusCommand() {
+    return new Command("status")
+        .description("Show the status of the local ProPR stack")
+        .option("--root <dir>", "Stack root directory")
+        .option("--json", "Output raw JSON")
+        .addHelpText("after", `
+Examples:
+  $ propr status
+  $ propr status --json
+
+(For backend job/queue status of a remote ProPR server, use 'propr remote-status'.)
+`)
+        .action(async (options) => {
+        try {
+            const configManager = await createConfigManager();
+            const { orch, cfg } = await getHostConfig({ configManager, root: options.root });
+            if (!orch.dockerAvailable()) {
+                console.error("Error: cannot reach the Docker daemon. Run 'propr check'.");
+                process.exit(1);
+            }
+            const status = orch.getStackStatus(cfg);
+            if (printOutput(status, options.json ?? false))
+                return;
+            console.log("");
+            console.log(renderStatusTable(status));
+            console.log("");
+            if (!status.running) {
+                console.log("Stack is not running. Start it with: propr start");
+            }
+        }
+        catch (error) {
+            console.error(`Error reading stack status: ${error.message}`);
+            process.exit(1);
+        }
+    });
+}
+/** Creates the `stop` command — stop (and remove) the local stack. */
+export function createStopCommand() {
+    return new Command("stop")
+        .description("Stop the local ProPR stack")
+        .option("--root <dir>", "Stack root directory")
+        .option("--keep", "Stop containers without removing them")
+        .addHelpText("after", `
+Examples:
+  $ propr stop
+  $ propr stop --keep
+`)
+        .action(async (options) => {
+        try {
+            const configManager = await createConfigManager();
+            const { orch, cfg } = await getHostConfig({ configManager, root: options.root });
+            if (!orch.dockerAvailable()) {
+                console.error("Error: cannot reach the Docker daemon. Run 'propr check'.");
+                process.exit(1);
+            }
+            const before = orch.getStackStatus(cfg);
+            if (!before.services.some((s) => s.exists)) {
+                console.log("No ProPR stack containers found — nothing to stop.");
+                return;
+            }
+            console.log("Stopping ProPR stack…");
+            const { failed } = orch.stopStack(cfg, { remove: !options.keep, removeNetwork: !options.keep, onLog: (l) => console.log(l) });
+            if (failed.length > 0) {
+                console.error(`\nError: ${failed.length} container(s) could not be stopped: ${failed.join(", ")}`);
+                console.error("Inspect them with `docker ps` / `docker logs` and retry `propr stop`.");
+                process.exit(1);
+            }
+            console.log(options.keep ? "Stack stopped (containers kept)." : "Stack stopped and removed.");
+        }
+        catch (error) {
+            console.error(`Error stopping stack: ${error.message}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/startCommand.js

@@ -0,0 +1,36 @@
+/**
+ * `propr start` — launch the local ProPR stack with a live dashboard.
+ */
+import { Command } from "commander";
+import { createConfigManager } from "../config/index.js";
+import { runStart } from "../tui/render.js";
+export function createStartCommand() {
+    return new Command("start")
+        .description("Start the local ProPR stack and show a live status dashboard")
+        .option("--root <dir>", "Stack root directory (where .env/data/logs/repos live)")
+        .option("--no-tui", "Skip the live dashboard; start and print a status snapshot")
+        .option("--no-pull", "Skip pulling images before starting")
+        .option("--restart", "Recreate services if the stack is already running")
+        .addHelpText("after", `
+Keys (live dashboard):
+  b  background (keep the stack running)    q  stop the stack
+  l  follow logs for the selected service   ↑/↓  select a service
+  u  toggle the UI service                  r  refresh    ?  help
+
+Examples:
+  $ propr start
+  $ propr start --restart
+  $ propr start --no-tui
+  $ propr start --root ~/propr
+`)
+        .action(async (options) => {
+        try {
+            const configManager = await createConfigManager();
+            await runStart(configManager, options);
+        }
+        catch (error) {
+            console.error(`Error starting stack: ${error.message}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/systemCommands.js

@@ -0,0 +1,221 @@
+/**
+ * System Status Commands
+ *
+ * CLI commands for checking system health and queue statistics.
+ * Provides `status` and `queue` as top-level commands.
+ */
+import { Command } from "commander";
+import { getSystemStatus, getQueueStats, } from "../api/index.js";
+import { printOutput } from "../utils/index.js";
+/**
+ * Formats a status value with color-like indicators for terminal display.
+ */
+function formatStatusIndicator(status) {
+    const normalizedStatus = status.toLowerCase();
+    if (normalizedStatus === "healthy" ||
+        normalizedStatus === "connected" ||
+        normalizedStatus === "running") {
+        return `[OK] ${status}`;
+    }
+    if (normalizedStatus === "disconnected" ||
+        normalizedStatus === "stopped" ||
+        normalizedStatus === "unknown") {
+        return `[!!] ${status}`;
+    }
+    return `[--] ${status}`;
+}
+/**
+ * Displays the system status in a formatted table.
+ */
+function displaySystemStatus(status) {
+    console.log("");
+    console.log("=".repeat(50));
+    console.log("System Status");
+    console.log("=".repeat(50));
+    console.log("");
+    const labels = [
+        "API",
+        "Redis",
+        "Daemon",
+        "Worker",
+        "Workers Active",
+        "GitHub Auth",
+        "Claude Auth",
+        "Timestamp",
+    ];
+    const maxLabelWidth = Math.max(...labels.map((l) => l.length));
+    console.log(`${"API".padEnd(maxLabelWidth)}  ${formatStatusIndicator(status.api)}`);
+    console.log(`${"Redis".padEnd(maxLabelWidth)}  ${formatStatusIndicator(status.redis)}`);
+    console.log(`${"Daemon".padEnd(maxLabelWidth)}  ${formatStatusIndicator(status.daemon)}`);
+    console.log(`${"Worker".padEnd(maxLabelWidth)}  ${formatStatusIndicator(status.worker)}`);
+    if (status.workerCount !== undefined) {
+        console.log(`${"Workers Active".padEnd(maxLabelWidth)}  ${status.workerCount}`);
+    }
+    console.log(`${"GitHub Auth".padEnd(maxLabelWidth)}  ${formatStatusIndicator(status.githubAuth)}`);
+    console.log(`${"Claude Auth".padEnd(maxLabelWidth)}  ${formatStatusIndicator(status.claudeAuth)}`);
+    console.log("");
+    console.log(`${"Timestamp".padEnd(maxLabelWidth)}  ${new Date(status.timestamp).toLocaleString()}`);
+    console.log("");
+    console.log("=".repeat(50));
+    const allHealthy = status.api === "healthy" &&
+        status.redis === "connected" &&
+        status.daemon === "running" &&
+        status.worker === "running" &&
+        status.githubAuth === "connected";
+    console.log("");
+    if (allHealthy) {
+        console.log("All systems operational.");
+    }
+    else {
+        console.log("Some components require attention.");
+        if (status.redis !== "connected") {
+            console.log("  - Redis is not connected. Check Redis server.");
+        }
+        if (status.daemon !== "running") {
+            console.log("  - Daemon is not running. Start the daemon service.");
+        }
+        if (status.worker !== "running") {
+            console.log("  - No workers active. Check worker processes.");
+        }
+        if (status.githubAuth !== "connected") {
+            console.log("  - GitHub auth not configured. Check GH_APP_ID, GH_PRIVATE_KEY_PATH, and GH_INSTALLATION_ID.");
+        }
+        if (status.claudeAuth !== "connected") {
+            console.log("  - Claude auth status unknown or no recent activity.");
+        }
+    }
+}
+/**
+ * Displays the queue statistics in a formatted table.
+ */
+function displayQueueStats(stats) {
+    console.log("");
+    console.log("=".repeat(50));
+    console.log("Queue Statistics");
+    console.log("=".repeat(50));
+    console.log("");
+    const labels = ["Waiting", "Active", "Completed", "Failed", "Delayed", "Total"];
+    const maxLabelWidth = Math.max(...labels.map((l) => l.length));
+    const formatNumber = (n) => n.toLocaleString();
+    console.log(`${"Waiting".padEnd(maxLabelWidth)}  ${formatNumber(stats.waiting)}`);
+    console.log(`${"Active".padEnd(maxLabelWidth)}  ${formatNumber(stats.active)}`);
+    console.log(`${"Completed".padEnd(maxLabelWidth)}  ${formatNumber(stats.completed)}`);
+    console.log(`${"Failed".padEnd(maxLabelWidth)}  ${formatNumber(stats.failed)}`);
+    console.log(`${"Delayed".padEnd(maxLabelWidth)}  ${formatNumber(stats.delayed)}`);
+    console.log("-".repeat(30));
+    console.log(`${"Total".padEnd(maxLabelWidth)}  ${formatNumber(stats.total)}`);
+    console.log("");
+    console.log("=".repeat(50));
+    console.log("");
+    if (stats.active > 0) {
+        console.log(`Currently processing ${stats.active} job(s).`);
+    }
+    if (stats.waiting > 0) {
+        console.log(`${stats.waiting} job(s) waiting in queue.`);
+    }
+    if (stats.failed > 0) {
+        const failRate = stats.total > 0
+            ? ((stats.failed / stats.total) * 100).toFixed(1)
+            : "0.0";
+        console.log(`${stats.failed} job(s) failed (${failRate}% failure rate).`);
+    }
+    if (stats.total === 0) {
+        console.log("Queue is empty.");
+    }
+}
+/**
+ * Creates the `remote-status` command.
+ *
+ * Reports the health of a remote ProPR backend (API/Redis/daemon/worker) over
+ * HTTP. The top-level `propr status` now reports the local Docker stack, so this
+ * backend health view is exposed as `remote-status`.
+ */
+export function createRemoteStatusCommand() {
+    return new Command("remote-status")
+        .description("Display the health status of a remote ProPR backend (API, Redis, daemon, worker)")
+        .option("--json", "Output raw JSON response")
+        .addHelpText("after", `
+Components Checked:
+  - API health
+  - Redis connection
+  - Daemon status
+  - Worker status
+  - GitHub authentication
+  - Claude authentication
+
+Examples:
+  $ propr remote-status           # Human-readable output
+  $ propr remote-status --json    # JSON output for scripting
+`)
+        .action(async (options) => {
+        try {
+            const status = await getSystemStatus();
+            if (printOutput(status, options.json ?? false)) {
+                return;
+            }
+            console.log("Checking system status...");
+            displaySystemStatus(status);
+        }
+        catch (error) {
+            const errorMessage = error.message;
+            if (errorMessage.includes("401") ||
+                errorMessage.includes("unauthorized")) {
+                console.error("Error: Unauthorized. Please run 'propr login' first.");
+            }
+            else if (errorMessage.includes("ECONNREFUSED") ||
+                errorMessage.includes("network")) {
+                console.error("Error: Cannot connect to ProPR backend. Is the server running?");
+            }
+            else {
+                console.error(`Error checking system status: ${errorMessage}`);
+            }
+            process.exit(1);
+        }
+    });
+}
+/**
+ * Creates the `queue` command.
+ */
+export function createQueueCommand() {
+    return new Command("queue")
+        .description("Display job queue statistics and counts")
+        .option("--json", "Output raw JSON response")
+        .addHelpText("after", `
+Statistics Shown:
+  - Waiting jobs
+  - Active jobs
+  - Completed jobs
+  - Failed jobs
+  - Delayed jobs
+  - Failure rate
+
+Examples:
+  $ propr queue           # Human-readable output
+  $ propr queue --json    # JSON output for scripting
+`)
+        .action(async (options) => {
+        try {
+            const stats = await getQueueStats();
+            if (printOutput(stats, options.json ?? false)) {
+                return;
+            }
+            console.log("Fetching queue statistics...");
+            displayQueueStats(stats);
+        }
+        catch (error) {
+            const errorMessage = error.message;
+            if (errorMessage.includes("401") ||
+                errorMessage.includes("unauthorized")) {
+                console.error("Error: Unauthorized. Please run 'propr login' first.");
+            }
+            else if (errorMessage.includes("ECONNREFUSED") ||
+                errorMessage.includes("network")) {
+                console.error("Error: Cannot connect to ProPR backend. Is the server running?");
+            }
+            else {
+                console.error(`Error fetching queue statistics: ${errorMessage}`);
+            }
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/tankCommands.js

@@ -0,0 +1,55 @@
+/**
+ * `propr tank on|off` — toggle Agent Tank LLM usage tracking.
+ *
+ * Agent Tank is an external service, not a stack container, so this is a backend
+ * setting flip routed through the running ProPR API.
+ */
+import { Command } from "commander";
+import { getAgentTank, setAgentTank } from "../api/agentTank.js";
+import { NetworkError, UnauthorizedError } from "../api/errors.js";
+import { parseOnOffState, ParseStateError } from "../utils/index.js";
+function handleApiError(error) {
+    if (error instanceof NetworkError) {
+        console.error("Error: cannot reach the ProPR backend. Start the stack first: propr start");
+    }
+    else if (error instanceof UnauthorizedError) {
+        console.error("Error: Unauthorized. Please run 'propr login' first.");
+    }
+    else {
+        console.error(`Error updating Agent Tank: ${error.message}`);
+    }
+    process.exit(1);
+}
+export function createTankCommand() {
+    const tank = new Command("tank")
+        .description("Toggle Agent Tank LLM usage tracking (requires the stack running)")
+        .argument("[state]", "on or off (omit to show current setting)")
+        .option("--url <url>", "Agent Tank service URL")
+        .addHelpText("after", `
+Examples:
+  $ propr tank              # show current setting
+  $ propr tank on
+  $ propr tank off
+  $ propr tank on --url http://127.0.0.1:3456
+`)
+        .action(async (state, options) => {
+        try {
+            if (!state) {
+                const current = await getAgentTank();
+                console.log(`Agent Tank: ${current.enabled ? "on" : "off"}${current.url ? `  (${current.url})` : ""}`);
+                return;
+            }
+            const enable = parseOnOffState(state);
+            const result = await setAgentTank(enable, options.url);
+            console.log(`Agent Tank ${result.enabled ? "enabled" : "disabled"}${result.url ? `  (${result.url})` : ""}.`);
+        }
+        catch (error) {
+            if (error instanceof ParseStateError) {
+                console.error(`Error: ${error.message}`);
+                process.exit(1);
+            }
+            handleApiError(error);
+        }
+    });
+    return tank;
+}