@ouro.bot/cli 0.1.0-alpha.315 → 0.1.0-alpha.316

package/changelog.json

@@ -1,6 +1,12 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.316",
+      "changes": [
+        "feat(daemon): unified progress TUI for ouro up lifecycle. New UpProgress accumulated-checklist renderer replaces disconnected writeStdout calls with a cohesive progress display showing completed phases with checkmarks and active phase with spinner. In-place ANSI overwrite in TTY mode, static lines in non-TTY (CI/pipes). Wired into daemon.up handler for all phases: update check, system setup, agent updates, bundle pruning, daemon start. Emits nerves events for each phase completion."
+      ]
+    },
     {
       "version": "0.1.0-alpha.315",
       "changes": [

package/dist/heart/daemon/cli-exec.js

@@ -75,6 +75,7 @@ const interactive_repair_1 = require("./interactive-repair");
 const agentic_repair_1 = require("./agentic-repair");
 const startup_tui_1 = require("./startup-tui");
 const stale_bundle_prune_1 = require("./stale-bundle-prune");
+const up_progress_1 = require("./up-progress");
 // ── ensureDaemonRunning ──
 async function ensureDaemonRunning(deps) {
     const alive = await deps.checkSocketAlive(deps.socketPath);
@@ -814,19 +815,19 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             }
         }
         const linkedVersionBeforeUp = deps.getCurrentCliVersion?.() ?? null;
+        const progress = new up_progress_1.UpProgress({ write: deps.writeStdout, isTTY: false });
         // ── versioned CLI update check ──
         if (deps.checkForCliUpdate) {
-            deps.writeStdout("checking for updates...");
+            progress.startPhase("update check");
             let pendingReExec = false;
             try {
                 const updateResult = await deps.checkForCliUpdate();
                 if (updateResult.available && updateResult.latestVersion) {
-                    deps.writeStdout(`installing ${updateResult.latestVersion}...`);
                     /* v8 ignore next -- fallback: getCurrentCliVersion always injected in tests @preserve */
                     const currentVersion = linkedVersionBeforeUp ?? "unknown";
                     await deps.installCliVersion(updateResult.latestVersion);
                     deps.activateCliVersion(updateResult.latestVersion);
-                    deps.writeStdout(`ouro updated to ${updateResult.latestVersion} (was ${currentVersion})`);
+                    progress.completePhase("update check", `installed ${updateResult.latestVersion}`);
                     const changelogCommand = (0, ouro_version_manager_1.buildChangelogCommand)(currentVersion, updateResult.latestVersion);
                     /* v8 ignore next -- buildChangelogCommand is non-null when an actual newer version is installed @preserve */
                     if (changelogCommand) {
@@ -847,13 +848,16 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             }
             /* v8 ignore stop */
             if (pendingReExec) {
+                progress.end();
                 deps.reExecFromNewVersion(args);
             }
             else {
-                deps.writeStdout("up to date.");
+                progress.completePhase("update check", "up to date");
             }
         }
+        progress.startPhase("system setup");
         await performSystemSetup(deps);
+        progress.completePhase("system setup");
         // Track whether we've already printed the "ouro updated to" message
         // this turn so the bundle-meta-fallback path below doesn't double-print.
         // There are three independent paths that can detect "the binary just
@@ -919,15 +923,18 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             const to = updateSummary.updated[0].to;
             const fromStr = from ? ` (was ${from})` : "";
             const count = agents.length;
-            deps.writeStdout(`updated ${count} agent${count === 1 ? "" : "s"} to runtime ${to}${fromStr}`);
+            progress.startPhase("agent updates");
+            progress.completePhase("agent updates", `${count} agent${count === 1 ? "" : "s"} to runtime ${to}${fromStr}`);
         }
         // ── stale bundle pruning ──
         const prunedBundles = (0, stale_bundle_prune_1.pruneStaleEphemeralBundles)({ bundlesRoot: deps.bundlesRoot });
-        for (const name of prunedBundles) {
-            deps.writeStdout(`pruned stale bundle: ${name}`);
+        if (prunedBundles.length > 0) {
+            progress.startPhase("bundle cleanup");
+            progress.completePhase("bundle cleanup", `pruned ${prunedBundles.length} stale bundle${prunedBundles.length === 1 ? "" : "s"}`);
         }
-        deps.writeStdout("starting daemon...");
+        progress.startPhase("starting daemon");
         const daemonResult = await ensureDaemonRunning(deps);
+        progress.end();
         deps.writeStdout(daemonResult.message);
         // Interactive repair for degraded agents (Unit 5) — skipped by --no-repair (Unit 6)
         if (daemonResult.stability?.degraded && daemonResult.stability.degraded.length > 0) {

package/dist/heart/daemon/up-progress.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * UpProgress — accumulated-checklist progress renderer for `ouro up`.
+ *
+ * Displays completed phases with checkmarks, the current phase with a
+ * spinner and elapsed time, and pending phases as plain text. Uses ANSI
+ * cursor control for in-place overwriting in TTY mode, and falls back to
+ * static line-per-phase output in non-TTY mode.
+ *
+ * The caller drives animation by calling `render(now)` on a setInterval.
+ * This module owns no timers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpProgress = void 0;
+const runtime_1 = require("../../nerves/runtime");
+// ── ANSI constants (shared with startup-tui.ts pattern) ──
+const SPINNER_FRAMES = "\u280B\u2819\u2839\u2838\u283C\u2834\u2826\u2827\u2807\u280F";
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[38;2;46;204;64m";
+// ── UpProgress class ──
+class UpProgress {
+    write;
+    isTTY;
+    completed = [];
+    currentPhase = null;
+    prevLineCount = 0;
+    ended = false;
+    constructor(options) {
+        /* v8 ignore next -- thin wrapper: raw process.stdout.write for ANSI cursor control @preserve */
+        this.write = options?.write ?? ((text) => process.stdout.write(text));
+        /* v8 ignore next -- thin wrapper: real isTTY check injected for testability @preserve */
+        this.isTTY = options?.isTTY ?? (process.stdout.isTTY === true);
+    }
+    /**
+     * Begin a new phase with spinner. If a phase is already active, it is
+     * auto-completed (no detail text).
+     */
+    startPhase(label) {
+        if (this.currentPhase) {
+            this.completePhase(this.currentPhase.label);
+        }
+        this.currentPhase = { label, startedAt: Date.now() };
+    }
+    /**
+     * Mark the current phase as done. In non-TTY mode, immediately writes
+     * a static line. Emits a nerves event for observability.
+     */
+    completePhase(label, detail) {
+        if (!this.currentPhase) {
+            return;
+        }
+        const elapsedMs = Date.now() - this.currentPhase.startedAt;
+        this.completed.push({ label, detail });
+        this.currentPhase = null;
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.up_phase_complete",
+            message: `phase complete: ${label}`,
+            meta: { phase: label, detail: detail ?? null, elapsedMs },
+        });
+        if (!this.isTTY) {
+            const detailStr = detail ? ` \u2014 ${detail}` : "";
+            this.write(`  \u2713 ${label}${detailStr}\n`);
+        }
+    }
+    /**
+     * Build an ANSI string for in-place terminal display. Returns empty
+     * string in non-TTY mode (output is written eagerly in completePhase).
+     */
+    render(now) {
+        if (!this.isTTY) {
+            return "";
+        }
+        const lines = [];
+        // Completed phases
+        for (const phase of this.completed) {
+            const detailStr = phase.detail ? ` ${DIM}\u2014 ${phase.detail}${RESET}` : "";
+            lines.push(`  ${GREEN}\u2713${RESET} ${phase.label}${detailStr}`);
+        }
+        // Current phase with spinner
+        if (this.currentPhase) {
+            const elapsed = now - this.currentPhase.startedAt;
+            const elapsedSec = (elapsed / 1000).toFixed(1);
+            const frameIndex = Math.floor(elapsed / 80) % SPINNER_FRAMES.length;
+            const spinner = SPINNER_FRAMES[frameIndex];
+            lines.push(`  ${BOLD}${spinner}${RESET} ${this.currentPhase.label} ${DIM}(${elapsedSec}s)${RESET}`);
+        }
+        let output = "";
+        if (this.prevLineCount > 0) {
+            output += `\x1b[${this.prevLineCount}A`;
+        }
+        for (const line of lines) {
+            output += `\x1b[2K${line}\n`;
+        }
+        // Clear any leftover lines from previous render that are no longer needed
+        if (lines.length < this.prevLineCount) {
+            for (let i = 0; i < this.prevLineCount - lines.length; i++) {
+                output += `\x1b[2K\n`;
+            }
+        }
+        this.prevLineCount = lines.length;
+        return output;
+    }
+    /**
+     * Finalize the progress display. Clears the current phase (if any) and
+     * writes the final checklist state. Idempotent.
+     */
+    end() {
+        if (this.ended) {
+            return;
+        }
+        this.ended = true;
+        if (this.currentPhase) {
+            this.currentPhase = null;
+        }
+        if (this.isTTY) {
+            const output = this.render(Date.now());
+            if (output) {
+                this.write(output);
+            }
+        }
+    }
+}
+exports.UpProgress = UpProgress;

package/dist/senses/cli/ouro-tui.js

@@ -253,6 +253,16 @@ function InputArea({ onSubmit, onCtrlC, history, queuedInputs, onPopQueue, agent
         // PageUp/PageDown: suppress (no text insertion, no action)
         if (key.pageUp || key.pageDown)
             return;
+        // Alt+Enter (single data event): Ink checks `return: input === '\r'` before
+        // stripping the \x1b prefix, so key.return is false when the terminal sends
+        // \x1b\r as one chunk.  Detect via the stripped inputChar instead.
+        if (inputChar === "\r" && key.meta) {
+            lastEscTime.current = 0;
+            const before = inputRef.current.slice(0, cursorRef.current);
+            const after = inputRef.current.slice(cursorRef.current);
+            updateInput(before + "\n" + after, cursorRef.current + 1);
+            return;
+        }
         if (key.return) {
             // Alt+Enter: detect via key.meta OR recent ESC (within 50ms — Ink splits \x1b\r)
             const recentEsc = (Date.now() - lastEscTime.current) < 50;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.315",
+  "version": "0.1.0-alpha.316",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",
@@ -26,6 +26,7 @@
     "teams": "tsc && node dist/senses/teams-entry.js --agent ouroboros",
     "bluebubbles": "tsc && node dist/senses/bluebubbles/entry.js --agent ouroboros",
     "test": "vitest run",
+    "test:outlook-ui": "npm test --prefix packages/outlook-ui",
     "test:coverage:vitest": "vitest run --coverage",
     "test:coverage": "node scripts/run-coverage-gate.cjs",
     "build": "tsc && (cd packages/outlook-ui && npm install --ignore-scripts 2>/dev/null && npm run build && cp -r dist ../../dist/outlook-ui) || echo 'outlook-ui build skipped'",
@@ -50,11 +51,19 @@
     "url": "https://github.com/ouroborosbot/ouroboros"
   },
   "devDependencies": {
+    "@testing-library/react": "^16.3.2",
     "@types/semver": "^7.7.1",
     "@vitest/coverage-v8": "^4.0.18",
     "eslint": "^10.0.2",
+    "jsdom": "^29.0.2",
     "typescript": "^5.7.0",
     "typescript-eslint": "^8.56.1",
     "vitest": "^4.0.18"
+  },
+  "overrides": {
+    "@testing-library/react": {
+      "react": "$react",
+      "@types/react": "$@types/react"
+    }
   }
 }