@golba98/codexa 1.0.1

package/src/ui/runActivityView.ts

@@ -0,0 +1,37 @@
+import type { RunEvent } from "../session/types.js";
+
+const MAX_VISIBLE_ACTIVE_ACTIVITY = 6;
+const MAX_VISIBLE_SUMMARY_ACTIVITY = 4;
+export function selectVisibleRunActivity(event: RunEvent) {
+  const source = event.status === "running"
+    ? event.activity
+    : event.activitySummary?.recent ?? event.activity;
+  const limit = event.status === "running" ? MAX_VISIBLE_ACTIVE_ACTIVITY : MAX_VISIBLE_SUMMARY_ACTIVITY;
+  const visible = source.slice(-limit);
+  return {
+    visible,
+    hiddenCount: Math.max(0, source.length - visible.length),
+  };
+}
+
+export function shouldShowRawOutputFallback(event: RunEvent): boolean {
+  void event;
+  return false;
+}
+
+export function getVisibleRawOutputLines(event: RunEvent): string[] {
+  void event;
+  return [];
+}
+
+export function formatRunActivityStats(event: RunEvent): string | null {
+  const summary = event.activitySummary;
+  if (!summary || event.touchedFileCount === 0) return null;
+
+  return [
+    `${event.touchedFileCount} file${event.touchedFileCount === 1 ? "" : "s"} touched`,
+    `+${summary.created}`,
+    `~${summary.modified}`,
+    `-${summary.deleted}`,
+  ].join("  ");
+}

package/src/ui/runLifecycleView.test.tsx

@@ -0,0 +1,237 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import React from "react";
+import { PassThrough } from "node:stream";
+import { Box, render } from "ink";
+import type { UIState } from "../session/types.js";
+import { isBusy } from "../session/types.js";
+import { BottomComposer } from "./BottomComposer.js";
+import { createLayoutSnapshot } from "./layout.js";
+import { getRunFooterStatus, RunFooter } from "./RunFooter.js";
+import { ThemeProvider } from "./theme.js";
+
+class TestInput extends PassThrough {
+  readonly isTTY = true;
+
+  setRawMode(): this {
+    return this;
+  }
+
+  override resume(): this {
+    return this;
+  }
+
+  override pause(): this {
+    return this;
+  }
+
+  ref(): this {
+    return this;
+  }
+
+  unref(): this {
+    return this;
+  }
+}
+
+class TestOutput extends PassThrough {
+  readonly isTTY = true;
+  columns = 120;
+  rows = 40;
+}
+
+function stripAnsi(value: string): string {
+  return value.replace(/\u001B\[[0-?]*[ -/]*[@-~]/g, "");
+}
+
+function sleep(ms = 50): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+const TEST_LAYOUT = createLayoutSnapshot(120, 40);
+
+test("idle footer status is empty by contract", () => {
+  assert.equal(getRunFooterStatus({ kind: "IDLE" }), "");
+});
+
+function LifecycleHarness({ uiState, value, showBusyLoader = true }: { uiState: UIState; value: string; showBusyLoader?: boolean }) {
+  const showComposer = !isBusy(uiState);
+
+  return (
+    <ThemeProvider theme="purple">
+      <Box flexDirection="column" width="100%">
+        {showComposer ? (
+          <BottomComposer
+            layout={TEST_LAYOUT}
+            uiState={uiState}
+            mode="suggest"
+            model="gpt-5.4"
+            reasoningLevel="balanced"
+            tokensUsed={100}
+            value={value}
+            cursor={value.length}
+            onChangeInput={() => {}}
+            onSubmit={() => {}}
+            onCancel={() => {}}
+            onChangeValue={() => {}}
+            onChangeCursor={() => {}}
+            onHistoryUp={() => {}}
+            onHistoryDown={() => {}}
+            onOpenBackendPicker={() => {}}
+            onOpenModelPicker={() => {}}
+            onOpenModePicker={() => {}}
+            onOpenThemePicker={() => {}}
+            onOpenAuthPanel={() => {}}
+            onTogglePlanMode={() => {}}
+            onClear={() => {}}
+            onCycleMode={() => {}}
+            onQuit={() => {}}
+          />
+        ) : (
+          <RunFooter uiState={uiState} showBusyLoader={showBusyLoader} onCancel={() => {}} onQuit={() => {}} />
+        )}
+      </Box>
+    </ThemeProvider>
+  );
+}
+
+test("collapses composer during thinking so input buffer artifacts are removed", async () => {
+  const stdin = new TestInput();
+  const stdout = new TestOutput();
+  let output = "";
+  stdout.on("data", (chunk) => {
+    output += chunk.toString();
+  });
+
+  const instance = render(
+    <LifecycleHarness uiState={{ kind: "IDLE" }} value="draft prompt" />,
+    {
+      stdin: stdin as unknown as NodeJS.ReadStream,
+      stdout: stdout as unknown as NodeJS.WriteStream,
+      stderr: stdout as unknown as NodeJS.WriteStream,
+      debug: true,
+      exitOnCtrlC: false,
+    },
+  );
+
+  await sleep();
+  let frame = stripAnsi(output);
+  assert.match(frame, /draft prompt/i);
+
+  output = "";
+  instance.rerender(<LifecycleHarness uiState={{ kind: "THINKING", turnId: 1 }} value="draft prompt" />);
+  await sleep();
+  frame = stripAnsi(output);
+  assert.doesNotMatch(frame, /draft prompt/i);
+  assert.match(frame, /Codexa is thinking/i);
+
+  instance.unmount();
+});
+
+test("busy footer advances from local status state without a parent rerender", async () => {
+  const stdin = new TestInput();
+  const stdout = new TestOutput();
+  let output = "";
+
+  stdout.on("data", (chunk) => {
+    output += chunk.toString();
+  });
+
+  const instance = render(
+    <LifecycleHarness uiState={{ kind: "THINKING", turnId: 1 }} value="" />,
+    {
+      stdin: stdin as unknown as NodeJS.ReadStream,
+      stdout: stdout as unknown as NodeJS.WriteStream,
+      stderr: stdout as unknown as NodeJS.WriteStream,
+      debug: true,
+      exitOnCtrlC: false,
+    },
+  );
+
+  await sleep();
+  let frame = stripAnsi(output);
+  assert.match(frame, /Codexa is thinking \./);
+
+  output = "";
+  await sleep(950);
+  frame = stripAnsi(output);
+  assert.match(frame, /Codexa is thinking \.\./);
+
+  instance.unmount();
+});
+
+test("busy footer omits loader frames when disabled", async () => {
+  const stdin = new TestInput();
+  const stdout = new TestOutput();
+  let output = "";
+
+  stdout.on("data", (chunk) => {
+    output += chunk.toString();
+  });
+
+  const instance = render(
+    <LifecycleHarness uiState={{ kind: "THINKING", turnId: 1 }} value="" showBusyLoader={false} />,
+    {
+      stdin: stdin as unknown as NodeJS.ReadStream,
+      stdout: stdout as unknown as NodeJS.WriteStream,
+      stderr: stdout as unknown as NodeJS.WriteStream,
+      debug: true,
+      exitOnCtrlC: false,
+    },
+  );
+
+  try {
+    await sleep();
+    let frame = stripAnsi(output);
+    assert.match(frame, /Codexa is thinking/);
+    assert.doesNotMatch(frame, /Codexa is thinking \./);
+
+    output = "";
+    await sleep(950);
+    frame = stripAnsi(output);
+    assert.equal(frame, "");
+  } finally {
+    instance.unmount();
+  }
+});
+
+test("static status debug flag reserves status text without dot ticks", async () => {
+  const previous = process.env.CODEXA_DEBUG_STATIC_STATUS;
+  process.env.CODEXA_DEBUG_STATIC_STATUS = "1";
+  const stdin = new TestInput();
+  const stdout = new TestOutput();
+  let output = "";
+
+  stdout.on("data", (chunk) => {
+    output += chunk.toString();
+  });
+
+  const instance = render(
+    <LifecycleHarness uiState={{ kind: "THINKING", turnId: 1 }} value="" />,
+    {
+      stdin: stdin as unknown as NodeJS.ReadStream,
+      stdout: stdout as unknown as NodeJS.WriteStream,
+      stderr: stdout as unknown as NodeJS.WriteStream,
+      debug: true,
+      exitOnCtrlC: false,
+    },
+  );
+
+  try {
+    await sleep();
+    let frame = stripAnsi(output);
+    assert.match(frame, /Codexa is thinking \.\.\./);
+
+    output = "";
+    await sleep(950);
+    frame = stripAnsi(output);
+    assert.equal(frame, "");
+  } finally {
+    instance.unmount();
+    if (previous === undefined) {
+      delete process.env.CODEXA_DEBUG_STATIC_STATUS;
+    } else {
+      process.env.CODEXA_DEBUG_STATIC_STATUS = previous;
+    }
+  }
+});

package/src/ui/slashCommands.ts

@@ -0,0 +1,41 @@
+export interface SlashCommandSuggestion {
+  cmd: string;
+  desc: string;
+  aliases?: readonly string[];
+}
+
+export const SLASH_COMMANDS = [
+  { cmd: "/help", desc: "Show available commands" },
+  { cmd: "/clear", desc: "Clear chat and cancel active run" },
+  { cmd: "/providers", desc: "Open AI provider picker", aliases: ["/provider"] },
+  { cmd: "/model", desc: "Change active model" },
+  { cmd: "/models", desc: "Open model picker" },
+  { cmd: "/mode", desc: "Change execution mode" },
+  { cmd: "/route", desc: "Show active chat route" },
+  { cmd: "/backend", desc: "Change active backend" },
+  { cmd: "/reasoning", desc: "Change reasoning level" },
+  { cmd: "/plan", desc: "Show or toggle session plan mode" },
+  { cmd: "/settings", desc: "Open the settings picker", aliases: ["/setting"] },
+  { cmd: "/status", desc: "Show effective runtime configuration" },
+  { cmd: "/permissions", desc: "Inspect or update permissions and sandbox controls" },
+  { cmd: "/runtime", desc: "Compatibility runtime policy controls" },
+  { cmd: "/themes", desc: "Open visual theme picker" },
+  { cmd: "/verbose", desc: "Toggle verbose mode (detailed processing info)" },
+  { cmd: "/auth", desc: "Manage authentication" },
+  { cmd: "/workspace", desc: "Show the locked workspace" },
+  { cmd: "/copy", desc: "Copy the full conversation transcript to clipboard" },
+  { cmd: "/mouse", desc: "Toggle mouse capture for wheel scrolling (off by default)" },
+  { cmd: "/exit", desc: "Quit the application" },
+] as const satisfies readonly SlashCommandSuggestion[];
+
+export type CommandSuggestion = (typeof SLASH_COMMANDS)[number];
+
+function matchesPrefix(suggestion: SlashCommandSuggestion, prefix: string): boolean {
+  if (suggestion.cmd.startsWith(prefix)) return true;
+  return suggestion.aliases?.some((alias) => alias.startsWith(prefix)) ?? false;
+}
+
+export function getSlashCommandSuggestions(prefix: string): readonly CommandSuggestion[] {
+  const normalized = prefix.toLowerCase();
+  return SLASH_COMMANDS.filter((command) => matchesPrefix(command, normalized)).slice(0, 5);
+}