iriai-build 0.1.0

package/cli/terminal-input.js

@@ -0,0 +1,666 @@
+// terminal-input.js — Full-screen TUI with alternate screen buffer, scroll regions,
+// and raw stdin input. Output scrolls in the top region. A defined input area
+// with status sits at the bottom, vertically centered for tall terminals.
+
+import readline from "node:readline";
+import { select, input, confirm } from "@inquirer/prompts";
+import * as queries from "../v3/queries.js";
+import { setOutputFn } from "./display.js";
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+const C = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  white: "\x1b[37m",
+  clearLine: "\x1b[2K",
+};
+
+const ROLE_LABELS = {
+  pm: "PM", designer: "Designer", architect: "Architect",
+  "plan-compiler": "Plan Compiler", "feature-lead": "FL",
+};
+
+// Footer height: top-border, status, blank, input, bottom-border, padding
+const FOOTER_LINES = 6;
+
+export class TerminalInput {
+  constructor({ orchestrator }) {
+    this.orchestrator = orchestrator;
+    this._activeFeatureId = null;
+    this._activeChannel = null;
+    this._inputLoopRunning = false;
+    this._statusText = "";
+    this._statusTimer = null;
+    this._spinnerFrame = 0;
+    this._agentState = "idle";
+
+    // TUI state
+    this._inTUI = false;
+    this._rows = 0;
+    this._cols = 0;
+    this._scrollBottom = 0; // last row of scroll region
+    this._footerTop = 0;    // first row of footer area
+    this._inputBuffer = "";
+    this._cursorPos = 0;
+    this._inputResolve = null;
+    this._keypressHandler = null;
+    this._resizeHandler = null;
+  }
+
+  setActiveFeature(featureId, channel) {
+    this._activeFeatureId = featureId;
+    this._activeChannel = channel;
+  }
+
+  // ─── TUI Screen Management ──────────────────────────────────────
+
+  _enterTUI() {
+    if (this._inTUI) return;
+    this._inTUI = true;
+
+    // Use the normal screen buffer (not alternate) so terminal scrollback works.
+    // Push enough newlines to make room for the footer at the bottom.
+    const rows = process.stdout.rows || 24;
+    process.stdout.write("\n".repeat(rows));
+    process.stdout.write(`\x1b[${rows};1H`); // move to bottom
+
+    this._setupLayout();
+
+    // Print welcome header in scroll region
+    const feature = this._activeFeatureId
+      ? queries.getFeatureById(this._activeFeatureId)
+      : null;
+    const slug = feature?.slug || "unknown";
+    const w = Math.min(this._cols, 60);
+    this._printToScrollRegion("");
+    this._printToScrollRegion(
+      `  ${C.bold}${C.cyan}iriai-build${C.reset} ${C.dim}v3${C.reset}`
+    );
+    this._printToScrollRegion(
+      `  ${C.dim}${"─".repeat(w)}${C.reset}`
+    );
+    this._printToScrollRegion(
+      `  ${C.bold}Feature:${C.reset} ${C.cyan}${slug}${C.reset}`
+    );
+    this._printToScrollRegion(
+      `  ${C.dim}Planning pipeline: PM → Designer → Architect → Plan Approval${C.reset}`
+    );
+    this._printToScrollRegion(
+      `  ${C.dim}Type a message to talk to the Operator. Ctrl+C to quit.${C.reset}`
+    );
+    this._printToScrollRegion(
+      `  ${C.dim}${"─".repeat(w)}${C.reset}`
+    );
+    this._printToScrollRegion("");
+
+    // Handle terminal resize
+    this._resizeHandler = () => {
+      this._setupLayout();
+      this._drawFooter();
+      this._drawInputLine();
+    };
+    process.stdout.on("resize", this._resizeHandler);
+
+    // Route display.js output through TUI
+    setOutputFn((text) => this.printAboveLine(text));
+
+    // Set up raw stdin input
+    this._setupRawInput();
+
+    // Show cursor at input line
+    process.stdout.write("\x1b[?25h");
+    this._drawInputLine();
+  }
+
+  _exitTUI() {
+    if (!this._inTUI) return;
+    this._inTUI = false;
+
+    // Tear down raw input
+    this._teardownRawInput();
+
+    // Remove resize handler
+    if (this._resizeHandler) {
+      process.stdout.removeListener("resize", this._resizeHandler);
+      this._resizeHandler = null;
+    }
+
+    // Reset scroll region, move cursor below footer, show cursor
+    process.stdout.write("\x1b[r");
+    const rows = process.stdout.rows || 24;
+    process.stdout.write(`\x1b[${rows};1H\n`);
+    process.stdout.write("\x1b[?25h");
+
+    // Reset display output to console.log
+    setOutputFn(null);
+  }
+
+  /**
+   * Clean up TUI on final shutdown. Resets scroll region and cursor.
+   */
+  exitScreen() {
+    if (this._inTUI) this._exitTUI();
+    process.stdout.write("\x1b[?25h");
+    process.stdout.write("\x1b[r");
+  }
+
+  _setupLayout() {
+    this._rows = process.stdout.rows || 24;
+    this._cols = process.stdout.columns || 80;
+
+    // Output region uses all rows above the footer
+    const outputRows = this._rows - FOOTER_LINES;
+
+    // Footer starts right after output region
+    this._footerTop = outputRows + 1;
+    this._scrollBottom = outputRows;
+
+    // Set scroll region (rows 1 through scrollBottom)
+    process.stdout.write(`\x1b[1;${this._scrollBottom}r`);
+
+    // Draw footer
+    this._drawFooter();
+  }
+
+  // ─── Footer (bordered input area) ─────────────────────────────
+
+  _drawFooter() {
+    if (!this._inTUI) return;
+
+    const w = this._cols;
+    const sepRow    = this._footerTop;     // horizontal rule
+    const statusRow = this._footerTop + 1; // status line
+    const blankRow  = this._footerTop + 2; // spacing
+    const inputRow  = this._footerTop + 3; // input prompt
+    const padRow    = this._footerTop + 4; // bottom padding
+
+    const rule = "─".repeat(w);
+
+    // Save cursor, draw footer, restore
+    process.stdout.write("\x1b7");
+
+    // Separator rule
+    process.stdout.write(`\x1b[${sepRow};1H${C.clearLine}${C.dim}${rule}${C.reset}`);
+
+    // Status line
+    const statusContent = this._buildStatusLine();
+    process.stdout.write(`\x1b[${statusRow};1H${C.clearLine} ${statusContent}`);
+
+    // Blank spacing
+    process.stdout.write(`\x1b[${blankRow};1H${C.clearLine}`);
+
+    // Input line (drawn separately for cursor positioning)
+    process.stdout.write(`\x1b[${inputRow};1H${C.clearLine}`);
+
+    // Bottom padding
+    process.stdout.write(`\x1b[${padRow};1H${C.clearLine}`);
+
+    // Clear any rows below the footer
+    for (let r = padRow + 1; r <= this._rows; r++) {
+      process.stdout.write(`\x1b[${r};1H${C.clearLine}`);
+    }
+
+    process.stdout.write("\x1b8");
+  }
+
+  _drawInputLine() {
+    if (!this._inTUI) return;
+
+    const inputRow = this._footerTop + 3;
+    const prompt = `${C.bold}>${C.reset} `;
+
+    process.stdout.write(`\x1b[${inputRow};1H${C.clearLine} ${prompt}${this._inputBuffer}`);
+
+    // Position cursor: " > " = 3 visible chars before input, 1-indexed
+    const cursorCol = 4 + this._cursorPos;
+    process.stdout.write(`\x1b[${inputRow};${cursorCol}H`);
+  }
+
+  // ─── Status ─────────────────────────────────────────────────────
+
+  _buildStatusLine() {
+    if (this._agentState === "running") {
+      const frame = SPINNER_FRAMES[this._spinnerFrame % SPINNER_FRAMES.length];
+      return `${C.cyan}${frame}${C.reset} ${C.dim}${this._statusText}${C.reset}`;
+    } else if (this._agentState === "decision") {
+      return `${C.yellow}${C.bold}●${C.reset} ${C.yellow}${this._statusText}${C.reset}`;
+    }
+    return `${C.dim}○ ${this._statusText || "Idle"}${C.reset}`;
+  }
+
+  _updateStatus() {
+    if (!this._activeFeatureId) {
+      this._agentState = "idle";
+      this._statusText = "No active feature";
+      return;
+    }
+
+    const feature = queries.getFeatureById(this._activeFeatureId);
+    if (!feature) {
+      this._agentState = "idle";
+      this._statusText = "Feature not found";
+      return;
+    }
+
+    const running = queries.getRunningAgents(this._activeFeatureId);
+    const meta = queries.getFeatureMetadata(this._activeFeatureId);
+
+    // Phase context
+    let phaseInfo = feature.phase;
+    if (feature.phase === "planning" && feature.active_planning_role) {
+      phaseInfo = `${ROLE_LABELS[feature.active_planning_role] || feature.active_planning_role} phase`;
+    } else if (feature.phase === "plan-approval") {
+      phaseInfo = "Plan approval";
+    } else if (feature.phase === "impl") {
+      phaseInfo = `Implementation · gate ${feature.gate_number || 0}`;
+    }
+
+    // Determine state
+    if (meta.awaiting_phase_review) {
+      this._agentState = "decision";
+      const reviewRole = ROLE_LABELS[meta.phase_review_role] || meta.phase_review_role;
+      this._statusText = `Awaiting your decision · ${reviewRole} review`;
+    } else if (feature.phase === "plan-approval") {
+      this._agentState = "decision";
+      this._statusText = "Awaiting your decision · Plan approval";
+    } else if (running.length > 0) {
+      this._agentState = "running";
+      const agentNames = running
+        .filter(a => a.agent_type !== "operator")
+        .map(a => ROLE_LABELS[a.role_name] || a.role_name || a.agent_type);
+      const unique = [...new Set(agentNames)];
+      const agentInfo = unique.length > 0 ? unique.join(", ") : "agents";
+      this._statusText = `${running.length} agent${running.length > 1 ? "s" : ""} working · ${phaseInfo} · ${agentInfo}`;
+    } else {
+      this._agentState = "idle";
+      this._statusText = `Idle · ${phaseInfo}`;
+    }
+  }
+
+  _refreshStatus() {
+    if (!this._inTUI) return;
+    this._spinnerFrame++;
+    this._updateStatus();
+    this._drawFooter();
+    this._drawInputLine();
+  }
+
+  // ─── Output ─────────────────────────────────────────────────────
+
+  /**
+   * Print a line into the scroll region (above the footer).
+   * Works by moving to the bottom of the scroll region, issuing a linefeed
+   * to scroll up, then writing the text. The footer is outside the scroll
+   * region so it stays fixed.
+   */
+  _printToScrollRegion(text) {
+    const lines = text.split("\n");
+    for (const line of lines) {
+      process.stdout.write(
+        `\x1b[${this._scrollBottom};1H` + // move to bottom of scroll region
+        "\n" +                             // scroll region up
+        `\x1b[${this._scrollBottom};1H` + // ensure we're at bottom row
+        `${C.clearLine}${line}`            // clear and write
+      );
+    }
+  }
+
+  /**
+   * Print text above the footer. Safe to call from adapter or display.js.
+   */
+  printAboveLine(text) {
+    if (!this._inTUI) {
+      console.log(text);
+      return;
+    }
+
+    // Save cursor (at input line), print in scroll region, restore cursor
+    process.stdout.write("\x1b7");
+    this._printToScrollRegion(text);
+    process.stdout.write("\x1b8");
+    // Redraw input line to keep cursor position correct
+    this._drawInputLine();
+  }
+
+  // ─── Raw Input ──────────────────────────────────────────────────
+
+  _setupRawInput() {
+    if (!process.stdin.isTTY) return;
+
+    // Set up keypress event parsing (idempotent guard)
+    if (!process.stdin.__keypressEventsEmitted) {
+      readline.emitKeypressEvents(process.stdin);
+      process.stdin.__keypressEventsEmitted = true;
+    }
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+
+    this._keypressHandler = (str, key) => this._handleKeypress(str, key);
+    process.stdin.on("keypress", this._keypressHandler);
+  }
+
+  _teardownRawInput() {
+    if (this._keypressHandler) {
+      process.stdin.removeListener("keypress", this._keypressHandler);
+      this._keypressHandler = null;
+    }
+    if (process.stdin.isTTY && process.stdin.rawMode) {
+      process.stdin.setRawMode(false);
+    }
+    process.stdin.pause();
+  }
+
+  _handleKeypress(str, key) {
+    if (!key && str) {
+      this._insertChar(str);
+      return;
+    }
+    if (!key) return;
+
+    // Ctrl+C → SIGINT
+    if (key.ctrl && key.name === "c") {
+      process.kill(process.pid, "SIGINT");
+      return;
+    }
+
+    // Ctrl+D → close input
+    if (key.ctrl && key.name === "d") {
+      if (this._inputResolve) {
+        const resolve = this._inputResolve;
+        this._inputResolve = null;
+        resolve(null);
+      }
+      return;
+    }
+
+    // Enter → submit line
+    if (key.name === "return") {
+      const text = this._inputBuffer;
+      this._inputBuffer = "";
+      this._cursorPos = 0;
+      this._drawInputLine();
+      if (this._inputResolve) {
+        const resolve = this._inputResolve;
+        this._inputResolve = null;
+        resolve(text);
+      }
+      return;
+    }
+
+    // Backspace
+    if (key.name === "backspace") {
+      if (this._cursorPos > 0) {
+        this._inputBuffer =
+          this._inputBuffer.slice(0, this._cursorPos - 1) +
+          this._inputBuffer.slice(this._cursorPos);
+        this._cursorPos--;
+        this._drawInputLine();
+      }
+      return;
+    }
+
+    // Delete
+    if (key.name === "delete") {
+      if (this._cursorPos < this._inputBuffer.length) {
+        this._inputBuffer =
+          this._inputBuffer.slice(0, this._cursorPos) +
+          this._inputBuffer.slice(this._cursorPos + 1);
+        this._drawInputLine();
+      }
+      return;
+    }
+
+    // Arrow keys
+    if (key.name === "left" && this._cursorPos > 0) {
+      this._cursorPos--;
+      this._drawInputLine();
+      return;
+    }
+    if (key.name === "right" && this._cursorPos < this._inputBuffer.length) {
+      this._cursorPos++;
+      this._drawInputLine();
+      return;
+    }
+
+    // Home / Ctrl+A
+    if (key.name === "home" || (key.ctrl && key.name === "a")) {
+      this._cursorPos = 0;
+      this._drawInputLine();
+      return;
+    }
+
+    // End / Ctrl+E
+    if (key.name === "end" || (key.ctrl && key.name === "e")) {
+      this._cursorPos = this._inputBuffer.length;
+      this._drawInputLine();
+      return;
+    }
+
+    // Ctrl+U → clear line
+    if (key.ctrl && key.name === "u") {
+      this._inputBuffer = "";
+      this._cursorPos = 0;
+      this._drawInputLine();
+      return;
+    }
+
+    // Ctrl+K → kill to end of line
+    if (key.ctrl && key.name === "k") {
+      this._inputBuffer = this._inputBuffer.slice(0, this._cursorPos);
+      this._drawInputLine();
+      return;
+    }
+
+    // Ctrl+W → delete word backward
+    if (key.ctrl && key.name === "w") {
+      const before = this._inputBuffer.slice(0, this._cursorPos);
+      const after = this._inputBuffer.slice(this._cursorPos);
+      const trimmed = before.replace(/\S+\s*$/, "");
+      this._cursorPos = trimmed.length;
+      this._inputBuffer = trimmed + after;
+      this._drawInputLine();
+      return;
+    }
+
+    // Regular printable character
+    if (str && !key.ctrl && !key.meta) {
+      this._insertChar(str);
+    }
+  }
+
+  _insertChar(ch) {
+    this._inputBuffer =
+      this._inputBuffer.slice(0, this._cursorPos) +
+      ch +
+      this._inputBuffer.slice(this._cursorPos);
+    this._cursorPos += ch.length;
+    this._drawInputLine();
+  }
+
+  // ─── Wait for input ─────────────────────────────────────────────
+
+  _waitForLine() {
+    return new Promise((resolve) => {
+      this._inputResolve = resolve;
+    });
+  }
+
+  // ─── Pre-loop prompts (before TUI is active) ───────────────────
+
+  async promptFeatureDescription() {
+    const desc = await input({ message: "Describe the feature:" });
+    return desc.trim();
+  }
+
+  async promptConfirm(message) {
+    return confirm({ message });
+  }
+
+  async promptContinueToImpl() {
+    this.stopInputLoop();
+    const choices = [
+      { name: "Continue to implementation", value: "continue" },
+      { name: "Exit (resume later with `iriai-build implementation`)", value: "exit" },
+    ];
+    const selected = await select({
+      message: "Plan approved! What would you like to do?",
+      choices,
+    });
+    return selected === "continue";
+  }
+
+  // ─── Input loop ─────────────────────────────────────────────────
+
+  startInputLoop() {
+    if (this._inputLoopRunning) return;
+    this._inputLoopRunning = true;
+
+    // Enter TUI mode
+    this._enterTUI();
+
+    // Poll agent status every 250ms
+    this._statusTimer = setInterval(() => this._refreshStatus(), 250);
+
+    this._runInputLoop().catch((err) => {
+      if (err?.name === "ExitPromptError") return;
+      console.error("[terminal-input] Input loop crashed:", err);
+    });
+  }
+
+  stopInputLoop() {
+    this._inputLoopRunning = false;
+    if (this._statusTimer) {
+      clearInterval(this._statusTimer);
+      this._statusTimer = null;
+    }
+    // Resolve any pending input
+    if (this._inputResolve) {
+      const resolve = this._inputResolve;
+      this._inputResolve = null;
+      resolve(null);
+    }
+    // Exit TUI mode (but stay on alternate screen)
+    this._exitTUI();
+  }
+
+  async _handleTransferToSlack() {
+    try {
+      const { getSlackConfig, isSlackConfigured } = await import("./config.js");
+      if (!isSlackConfigured()) {
+        this.printAboveLine(`${C.yellow}${C.bold}[system]${C.reset} Slack not configured. Run \`iriai-build setup\` first.`);
+        return;
+      }
+
+      const slack = getSlackConfig();
+      const { SlackAdapter } = await import("../v3/adapters/slack-adapter.js");
+      const { Recovery } = await import("../v3/recovery.js");
+
+      this.printAboveLine(`${C.dim}[system]${C.reset} Connecting to Slack...`);
+      const slackAdapter = new SlackAdapter({
+        appToken: slack.appToken,
+        botToken: slack.botToken,
+        planningChannel: slack.channelId,
+      });
+      await slackAdapter.connect();
+      this.printAboveLine(`${C.green}${C.bold}[system]${C.reset} Slack connected (${slackAdapter.botUserId})`);
+
+      // Exit TUI — switch to plain console output for Slack bridge mode
+      this.stopInputLoop();
+      this.exitScreen();
+
+      // Swap adapter on the orchestrator
+      this.orchestrator.adapter = slackAdapter;
+      slackAdapter.setOrchestrator(this.orchestrator);
+
+      // Prevent macOS from sleeping while the bridge is running
+      const { spawn: cpSpawn } = await import("node:child_process");
+      const caffeinate = cpSpawn("caffeinate", ["-dims"], { stdio: "ignore", detached: true });
+      caffeinate.unref();
+
+      console.log("\n\x1b[1m\x1b[36miriai-build\x1b[0m — Transferred to Slack bridge mode\n");
+
+      // Sync all CLI features to Slack
+      const activeFeatures = queries.getActiveFeatures();
+      for (const feature of activeFeatures) {
+        const ch = feature.feature_channel;
+        if (ch && !/^[CGD][A-Z0-9]+$/.test(ch)) {
+          try {
+            const channelId = await slackAdapter.createFeatureChannel(feature.id, feature.slug);
+            if (channelId) {
+              queries.updateFeatureChannel(feature.id, channelId);
+              await slackAdapter.web.chat.postMessage({
+                channel: slack.channelId,
+                text: `[FEATURE][CLI SYNC] ${feature.slug} → <#${channelId}>`,
+              });
+              const phase = feature.phase || "planning";
+              const meta = queries.getFeatureMetadata(feature.id);
+              const lines = [`*Feature:* \`${feature.slug}\``, `*Phase:* ${phase}`];
+              if (meta.awaiting_phase_review) lines.push(`*Status:* Awaiting ${meta.phase_review_role} phase review`);
+              lines.push("_Transferred from CLI._");
+              await slackAdapter.postMessage(feature.id, lines.join("\n"));
+              console.log(`  Synced: ${feature.slug} → #impl-${feature.slug}`);
+            }
+          } catch (err) {
+            console.error(`  Failed to sync ${feature.slug}: ${err.message}`);
+          }
+        }
+      }
+
+      // Run recovery to re-post pending decisions via Slack
+      console.log("Running recovery...");
+      const recovery = new Recovery({ orchestrator: this.orchestrator, adapter: slackAdapter });
+      await recovery.run();
+
+      console.log("\n\x1b[32m\x1b[1mSlack bridge running.\x1b[0m Press Ctrl+C to stop.\n");
+
+      // Keep process alive — Slack socket handles events, Ctrl+C exits
+      const shutdown = async (signal) => {
+        console.log(`\n[bridge] ${signal} — shutting down...`);
+        caffeinate.kill();
+        if (this.orchestrator.reviewSessions) await this.orchestrator.reviewSessions.stopAll();
+        await this.orchestrator.shutdown();
+        process.exit(0);
+      };
+      process.on("SIGINT", () => shutdown("SIGINT"));
+      process.on("SIGTERM", () => shutdown("SIGTERM"));
+
+    } catch (err) {
+      this.printAboveLine(`${C.yellow}${C.bold}[system]${C.reset} Transfer failed: ${err.message}`);
+    }
+  }
+
+  async _runInputLoop() {
+    while (this._inputLoopRunning) {
+      if (!this._activeFeatureId) {
+        await new Promise((r) => setTimeout(r, 300));
+        continue;
+      }
+
+      const text = await this._waitForLine();
+      if (text === null) break; // Ctrl+D
+
+      if (text.trim()) {
+        const trimmed = text.trim();
+
+        // Inline commands
+        if (trimmed === "/transfer-to-slack") {
+          this.printAboveLine(`${C.cyan}${C.bold}[system]${C.reset} Transferring to Slack...`);
+          await this._handleTransferToSlack();
+          continue;
+        }
+
+        // Echo user input in the display area
+        this.printAboveLine(
+          `${C.green}${C.bold}[you]${C.reset} ${trimmed}`
+        );
+        this.orchestrator.routeUserMessage(this._activeFeatureId, trimmed);
+      }
+    }
+  }
+}