icopilot 2.3.4 → 2.3.5

package/CHANGELOG.md

@@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [2.3.5] — 2026-06-30
+
+### Fixed
+- **Release workflow** — bumped `package.json` version to `2.3.5` to match the `v2.3.5` git tag; the previous publish attempt was rejected by npm because version `2.3.4` was already published
+
 ## [2.3.4] — 2026-06-29
 
 ### Fixed

package/dist/modes/tui.js

@@ -1,10 +1,13 @@
 import readline from 'node:readline';
 import { Writable } from 'node:stream';
+import simpleGit from 'simple-git';
 import { loadAliases, resolveAlias } from '../commands/alias-cmd.js';
 import { MetricsCollector } from '../commands/metrics-cmd.js';
 import { handleSlash } from '../commands/slash.js';
 import { Session } from '../session/session.js';
 import { altScreenEnter, altScreenExit, clear, hideCursor, showCursor, size, } from '../ui/screen.js';
+import { WORKSPACE_TABS, renderTabBar, renderHero, renderStatusDock, magentaSeparator, renderFooter, } from '../ui/tui-layout.js';
+import { safeUnicode } from '../ui/theme.js';
 import { handlePostTurnContextBudget } from './auto-compact.js';
 import { backgroundTaskManager } from './background.js';
 import { runAutopilot } from './autopilot.js';
@@ -12,6 +15,7 @@ import { runTurn } from './turn.js';
 import { hookManager } from '../hooks/lifecycle.js';
 const VERSION = '1.3.0';
 const FRAME_MS = 33;
+const CREDIT_BUDGET = 1000;
 export async function runTui(initialMode = 'ask', opts = {}) {
     const session = new Session({ mode: initialMode });
     await session.initializeGitContext();
@@ -39,7 +43,33 @@ export async function runTui(initialMode = 'ask', opts = {}) {
     let cleaned = false;
     let frame;
     let currentAbort = null;
+    let activeTab = 0;
+    let gitBranch = '';
+    let branchInFlight = false;
+    let lastCwd = session.state.cwd;
     const pendingInputs = [];
+    // Resolve the current git branch once (and on cwd change) for the status dock.
+    // A simple in-flight guard avoids overlapping lookups racing to set gitBranch.
+    const refreshBranch = () => {
+        if (branchInFlight)
+            return;
+        branchInFlight = true;
+        void (async () => {
+            try {
+                const git = simpleGit(session.state.cwd);
+                if (await git.checkIsRepo()) {
+                    gitBranch = (await git.revparse(['--abbrev-ref', 'HEAD'])).trim();
+                    markDirty();
+                }
+            }
+            catch {
+                /* not a git repo — leave the branch blank */
+            }
+            finally {
+                branchInFlight = false;
+            }
+        })();
+    };
     const rl = readline.createInterface({
         input: process.stdin,
         output: silentOutput,
@@ -58,7 +88,7 @@ export async function runTui(initialMode = 'ask', opts = {}) {
         process.stdout.write = originalWrite;
         process.stdout.off('resize', onResize);
         process.off('SIGINT', onSigint);
-        process.stdin.off('keypress', markDirty);
+        process.stdin.off('keypress', onKeypress);
         if (frame)
             clearInterval(frame);
         rl.close();
@@ -81,38 +111,69 @@ export async function runTui(initialMode = 'ask', opts = {}) {
             return;
         dirty = false;
         const { rows, cols } = size();
+        // Refresh branch if cwd changed since the last render.
+        if (session.state.cwd !== lastCwd) {
+            lastCwd = session.state.cwd;
+            refreshBranch();
+        }
+        // Absolute row anchors (1-indexed for ANSI cursor positioning):
+        //   row 1            → tabbed navigation header
+        //   rows 2..dockRow-1 → hero canvas + conversation timeline
+        //   dockRow           → status dock (locked 3 rows above the bottom)
+        //   dockRow + 1       → magenta boundary line
+        //   dockRow + 2       → input dock
+        //   rows (bottom)     → persistent footer
+        const tabRow = 1;
         const chatTop = 2;
-        const chatBottom = Math.max(chatTop, rows - 3);
+        // The status dock is locked exactly 3 rows above the absolute bottom, so the
+        // four bottom rows are: dock, magenta separator, input dock, footer.
+        const dockRow = Math.max(chatTop, rows - 3);
+        const separatorRow = Math.min(dockRow + 1, rows);
+        const inputRow = Math.min(dockRow + 2, rows);
+        const footerRow = Math.min(dockRow + 3, rows);
+        const chatBottom = dockRow - 1;
         const chatHeight = Math.max(1, chatBottom - chatTop + 1);
         writeRaw('\x1b[2J\x1b[H');
-        writeRaw(statusLine(session, cols, busy));
-        const lines = wrapLines(chat.trimEnd(), Math.max(1, cols));
+        // Row 0 — tabbed navigation header.
+        writeRaw(`\x1b[${tabRow};1H`);
+        writeRaw(renderTabBar(activeTab, cols));
+        // Conversation timeline (hero canvas shown only while it is empty).
+        const showHero = !chat.trim();
+        const heroLines = showHero ? heroCanvas(session, cols) : [];
+        const lines = showHero ? heroLines : wrapLines(chat.trimEnd(), Math.max(1, cols));
         const visible = lines.slice(-chatHeight);
         for (let i = 0; i < chatHeight; i++) {
             writeRaw(`\x1b[${chatTop + i};1H`);
-            writeRaw(pad(visible[i] || '', cols));
+            // Hero lines are already padded to the full width (and carry ANSI), so
+            // they are written verbatim; plain chat lines are padded here.
+            writeRaw(showHero ? visible[i] || '' : padToCols(visible[i] || '', cols));
         }
-        // separator with thinking indicator
-        writeRaw(`\x1b[${Math.max(1, rows - 2)};1H`);
+        // Status dock — left: cwd + branch, right: live consumption metrics.
+        writeRaw(`\x1b[${dockRow};1H`);
+        writeRaw(statusDock(session, gitBranch, cols, busy));
+        // Magenta boundary line.
+        writeRaw(`\x1b[${separatorRow};1H`);
         if (busy) {
             const thinkLabel = ' ◆ Copilot is thinking… ';
             const sideLen = Math.max(0, Math.floor((cols - thinkLabel.length) / 2));
-            writeRaw('─'.repeat(sideLen) +
+            writeRaw('\x1b[35m' +
+                '─'.repeat(sideLen) +
                 thinkLabel +
-                '─'.repeat(Math.max(0, cols - sideLen - thinkLabel.length)));
+                '─'.repeat(Math.max(0, cols - sideLen - thinkLabel.length)) +
+                '\x1b[0m');
         }
         else {
-            writeRaw('─'.repeat(cols));
+            writeRaw(magentaSeparator(cols));
         }
-        writeRaw(`\x1b[${Math.max(1, rows - 1)};1H`);
+        // Input dock — a single dedicated line bracket below the separator.
+        writeRaw(`\x1b[${inputRow};1H`);
         const promptIcon = busy ? '\x1b[33m◆\x1b[0m' : '\x1b[32m❯\x1b[0m';
-        const prompt = `${promptIcon} ${rl.line || ''}`;
-        writeRaw(pad(prompt, cols));
-        writeRaw(`\x1b[${rows};1H`);
-        const hint = busy
-            ? '\x1b[2m Ctrl+C to cancel  \x1b[0m'
-            : '\x1b[2m Enter to send  •  /help for commands  •  /suggest for shell commands \x1b[0m';
-        writeRaw(pad(hint, cols));
+        const buffer = (rl.line || '').replace(/\t/g, '');
+        writeRaw('\x1b[2K');
+        writeRaw(padToCols(`${promptIcon} ${buffer}`, cols));
+        // Absolute bottom row — persistent footer legend.
+        writeRaw(`\x1b[${footerRow};1H`);
+        writeRaw(renderFooter(cols));
     };
     const appendCaptured = (chunk) => {
         const text = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk);
@@ -227,11 +288,22 @@ export async function runTui(initialMode = 'ask', opts = {}) {
         if (running)
             cleanup();
     });
-    process.stdin.on('keypress', markDirty);
+    const onKeypress = (_ch, key) => {
+        // Tab / Shift+Tab cycles the workspace navigation tabs.
+        if (key?.name === 'tab') {
+            const delta = key.shift ? -1 : 1;
+            activeTab = (activeTab + delta + WORKSPACE_TABS.length) % WORKSPACE_TABS.length;
+        }
+        markDirty();
+    };
+    process.stdin.on('keypress', onKeypress);
     altScreenEnter();
     hideCursor();
     clear();
-    chat = 'Welcome to iCopilot TUI prototype. Type /help for commands.\n';
+    // An empty timeline makes the renderer show the hero/branding canvas (with its
+    // tip bulletins) until the first turn produces conversation output.
+    chat = '';
+    refreshBranch();
     frame = setInterval(render, FRAME_MS);
     try {
         await new Promise((resolve) => {
@@ -254,12 +326,29 @@ export async function runTui(initialMode = 'ask', opts = {}) {
         });
     }
 }
-function statusLine(session, cols, busy) {
-    const mode = session.state.mode.toUpperCase();
+function heroCanvas(session, cols) {
+    const modelShort = session.state.model.replace('openai/', '').replace('github/', '');
+    return renderHero({
+        version: VERSION,
+        provider: 'GitHub Models',
+        experimental: '/experimental [Active]',
+        tips: [
+            'Tip: Run /doctor to diagnose your environment configuration and tool availability.',
+            'Tool access is determined by your configured role and policy settings.',
+            `Active model: ${modelShort}. Type /help for commands or @ to target files.`,
+        ],
+    }, cols);
+}
+function statusDock(session, branch, cols, busy) {
     const modelShort = session.state.model.replace('openai/', '').replace('github/', '');
-    const busyBadge = busy ? ' \x1b[33m◆ WORKING\x1b[0;7m' : '';
-    const text = ` \x1b[1miCopilot\x1b[0;7m v${VERSION}${busyBadge}  │  model: ${modelShort}  │  mode: ${mode}  │  Ctrl+C to exit `;
-    return `\x1b[7m${pad(text, cols)}\x1b[0m`;
+    // Nerd-font git branch glyph (U+F02A2) when supported, plain label otherwise.
+    const branchIcon = safeUnicode ? '\u{F02A2} ' : 'git:';
+    const branchLabel = branch ? ` [${branchIcon}${branch}]` : '';
+    const left = `${session.state.cwd}${branchLabel}`;
+    const used = Math.min(CREDIT_BUDGET, Math.ceil(session.tokenUsage() / 1000));
+    const working = busy ? ' \x1b[33m◆ WORKING\x1b[0m  │ ' : '';
+    const right = `${working}Usage: ${used}/${CREDIT_BUDGET} credits  │  ${modelShort}`;
+    return renderStatusDock(left, right, cols);
 }
 function wrapLines(text, width) {
     const out = [];
@@ -271,7 +360,7 @@ function wrapLines(text, width) {
     }
     return out.length ? out : [''];
 }
-function pad(text, cols) {
+function padToCols(text, cols) {
     const clipped = text.length > cols ? text.slice(0, cols) : text;
     return clipped + ' '.repeat(Math.max(0, cols - clipped.length));
 }

package/dist/ui/tui-layout.js

@@ -0,0 +1,121 @@
+/**
+ * Pure, side-effect-free rendering helpers for the full-screen TUI.
+ *
+ * Every function returns a string (or array of strings) that is painted at an
+ * absolute coordinate by the renderer in `modes/tui.ts`. Keeping these helpers
+ * pure makes the visual geometry unit-testable without spawning a PTY.
+ *
+ * The colour language follows the modern engineering-agent CLIs:
+ *   - deep blue (`\x1b[44m`) track for the tabbed navigation header
+ *   - magenta (`\x1b[35m`) single line as the conversation/input boundary
+ */
+/** Workspace navigation contexts shown in the Row-0 tab bar. */
+export const WORKSPACE_TABS = ['Session', 'Issues', 'Pull requests', 'Gists', 'Settings'];
+const RESET = '\x1b[0m';
+const BLUE_BG = '\x1b[44m';
+const MAGENTA = '\x1b[35m';
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+/** Remove ANSI escape sequences from a string. */
+export function stripAnsi(text) {
+    return text.replace(ANSI_RE, '');
+}
+/** Visible (printable) width of a string, ignoring ANSI escape sequences. */
+export function visibleWidth(text) {
+    return stripAnsi(text).length;
+}
+/**
+ * Pad (or clip) a string to an exact visible width. Clipping is performed on
+ * the plain text so we never emit a half-written escape sequence.
+ */
+export function padVisible(text, cols) {
+    const width = visibleWidth(text);
+    if (width === cols)
+        return text;
+    if (width < cols)
+        return text + ' '.repeat(cols - width);
+    // Too long: fall back to the plain text and hard-clip it.
+    return stripAnsi(text).slice(0, cols);
+}
+/**
+ * Row 0 — the persistent tabbed navigation header.
+ *
+ *   [Session]   Issues   Pull requests   Gists   Settings
+ *
+ * The active tab is wrapped in brackets and brightened; the whole row sits on a
+ * deep-blue background track that spans the full terminal width.
+ */
+export function renderTabBar(activeIndex, cols) {
+    const active = ((activeIndex % WORKSPACE_TABS.length) + WORKSPACE_TABS.length) % WORKSPACE_TABS.length;
+    const gap = '   ';
+    const plainParts = WORKSPACE_TABS.map((tab, i) => (i === active ? `[${tab}]` : ` ${tab} `));
+    const plain = plainParts.join(gap);
+    if (plain.length > cols) {
+        // Degrade gracefully on narrow terminals: blue track + clipped plain text.
+        return `${BLUE_BG}${plain.slice(0, cols)}${RESET}`;
+    }
+    const coloredParts = WORKSPACE_TABS.map((tab, i) => i === active ? `\x1b[1;97m[${tab}]\x1b[22;39m` : `\x1b[2;37m ${tab} \x1b[22;39m`);
+    const colored = coloredParts.join(gap);
+    const fill = ' '.repeat(Math.max(0, cols - plain.length));
+    return `${BLUE_BG}${colored}${fill}${RESET}`;
+}
+/**
+ * Section B — the left-aligned hero/branding canvas. Returns one string per
+ * row so the renderer can place it line-by-line from the top of the timeline.
+ */
+export function renderHero(info, cols) {
+    const bullet = '\x1b[35m●\x1b[0m';
+    const lines = [];
+    lines.push(padVisible(`\x1b[1miCopilot CLI Agent v${info.version}\x1b[0m  │  Provider: ${info.provider}`, cols));
+    if (info.experimental) {
+        lines.push(padVisible(`Experimental Capabilities: ${info.experimental}`, cols));
+    }
+    lines.push(padVisible('', cols));
+    for (const tip of info.tips ?? []) {
+        lines.push(padVisible(`${bullet} ${tip}`, cols));
+    }
+    return lines;
+}
+/**
+ * Section C — the horizontal status dock. The left context (cwd + git branch)
+ * is left-aligned; the right context (usage metrics + model) is right-aligned.
+ * When the two would overlap, the left side is clipped to preserve the metrics.
+ */
+export function renderStatusDock(left, right, cols) {
+    const leftWidth = visibleWidth(left);
+    const rightWidth = visibleWidth(right);
+    // Right side alone fills or overflows the terminal — show only right side.
+    if (rightWidth >= cols) {
+        return stripAnsi(right).slice(0, cols);
+    }
+    if (leftWidth + 1 + rightWidth > cols) {
+        const room = Math.max(0, cols - rightWidth - 1);
+        const clippedLeft = stripAnsi(left).slice(0, room);
+        const gap = ' '.repeat(Math.max(0, cols - clippedLeft.length - rightWidth));
+        return `${clippedLeft}${gap}${right}`;
+    }
+    const gap = ' '.repeat(cols - leftWidth - rightWidth);
+    return `${left}${gap}${right}`;
+}
+/** The full-width magenta boundary line that separates timeline from input. */
+export function magentaSeparator(cols) {
+    return `${MAGENTA}${'─'.repeat(Math.max(0, cols))}${RESET}`;
+}
+/** Absolute bottom-row footer with the persistent keybinding legend. */
+export function renderFooter(cols) {
+    const legend = '[Ctrl+C] Quit  │  [PageUp/Down] Scroll Output  │  [/] System Commands  │  [@] Target Context';
+    return `\x1b[2m${padVisible(legend, cols)}\x1b[0m`;
+}
+/**
+ * Tokenise a slash command by splitting on whitespace thresholds rather than
+ * fixed slices: `/model gpt-4o` → { command: 'model', args: ['gpt-4o'] }.
+ */
+export function parseSlashCommand(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith('/'))
+        return null;
+    const [command, ...args] = trimmed.slice(1).split(/\s+/);
+    if (!command)
+        return null;
+    return { command, args };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "icopilot",
-  "version": "2.3.4",
+  "version": "2.3.5",
   "description": "iCopilot — terminal-native agentic CLI powered by GitHub Models",
   "type": "module",
   "bin": {