@golba98/codexa 1.0.1

package/src/ui/commandNormalize.test.ts

@@ -0,0 +1,142 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { normalizeCommand, getFriendlyActionLabel } from "./commandNormalize.js";
+
+// ─── normalizeCommand ─────────────────────────────────────────────────────────
+
+test("normalizeCommand: strips full PowerShell path with single-quoted command", () => {
+  const raw = `"C:\\Program Files\\PowerShell\\7\\pwsh.exe" -Command 'Get-ChildItem -Force | Select-Object Name,Mode,Length'`;
+  assert.equal(normalizeCommand(raw), "Get-ChildItem -Force | Select-Object Name,Mode,Length");
+});
+
+test("normalizeCommand: strips full PowerShell path with double-quoted command", () => {
+  const raw = `"C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe" -Command "Get-Content package.json"`;
+  assert.equal(normalizeCommand(raw), "Get-Content package.json");
+});
+
+test("normalizeCommand: strips bare pwsh.exe -Command", () => {
+  assert.equal(normalizeCommand(`pwsh.exe -Command 'git status'`), "git status");
+  assert.equal(normalizeCommand(`pwsh -Command "npm install"`), "npm install");
+});
+
+test("normalizeCommand: strips bare powershell.exe -Command", () => {
+  assert.equal(normalizeCommand(`powershell.exe -Command 'dir'`), "dir");
+  assert.equal(normalizeCommand(`powershell -Command "Get-Content readme.md"`), "Get-Content readme.md");
+});
+
+test("normalizeCommand: strips cmd.exe /c wrapper", () => {
+  assert.equal(normalizeCommand(`cmd.exe /c "dir /b"`), "dir /b");
+  assert.equal(normalizeCommand(`cmd /C "npm test"`), "npm test");
+});
+
+test("normalizeCommand: strips bash -lc wrapper", () => {
+  assert.equal(normalizeCommand(`bash -lc 'bun install'`), "bun install");
+  assert.equal(normalizeCommand(`bash -lc "git diff"`), "git diff");
+});
+
+test("normalizeCommand: returns command unchanged when no wrapper is detected", () => {
+  assert.equal(normalizeCommand("git status"), "git status");
+  assert.equal(normalizeCommand("bun test"), "bun test");
+  assert.equal(normalizeCommand("python -m pytest"), "python -m pytest");
+  assert.equal(normalizeCommand("tsc --noEmit"), "tsc --noEmit");
+});
+
+test("normalizeCommand: collapses local file paths inside commands", () => {
+  assert.equal(
+    normalizeCommand(`pwsh.exe -Command 'Get-Content C:\\Users\\Example\\Project\\README.md'`),
+    "Get-Content README.md",
+  );
+  assert.equal(
+    normalizeCommand(`Get-Content C:/Users/Example/Project/src/App.tsx`),
+    "Get-Content src/App.tsx",
+  );
+});
+
+test("normalizeCommand: is case-insensitive for -Command flag", () => {
+  assert.equal(normalizeCommand(`pwsh.exe -command 'ls'`), "ls");
+  assert.equal(normalizeCommand(`pwsh.exe -COMMAND 'ls'`), "ls");
+});
+
+// ─── getFriendlyActionLabel ───────────────────────────────────────────────────
+
+test("getFriendlyActionLabel: Get-ChildItem → List files", () => {
+  assert.equal(getFriendlyActionLabel("Get-ChildItem -Force | Select-Object Name,Mode,Length"), "List files");
+  assert.equal(getFriendlyActionLabel("Get-ChildItem"), "List files");
+  assert.equal(getFriendlyActionLabel("dir /b"), "List files");
+  assert.equal(getFriendlyActionLabel("ls -la"), "List files");
+  assert.equal(getFriendlyActionLabel("rg --files"), "List files");
+});
+
+test("getFriendlyActionLabel: Get-Content / cat → Read file", () => {
+  assert.equal(getFriendlyActionLabel("Get-Content package.json"), "Read file");
+  assert.equal(getFriendlyActionLabel("cat src/index.ts"), "Read file");
+});
+
+test("getFriendlyActionLabel: git status → Check git status", () => {
+  assert.equal(getFriendlyActionLabel("git status"), "Check git status");
+  assert.equal(getFriendlyActionLabel("git status --short"), "Check git status");
+});
+
+test("getFriendlyActionLabel: git diff → Inspect changes", () => {
+  assert.equal(getFriendlyActionLabel("git diff"), "Inspect changes");
+  assert.equal(getFriendlyActionLabel("git diff HEAD~1"), "Inspect changes");
+});
+
+test("getFriendlyActionLabel: install commands → Install dependencies", () => {
+  assert.equal(getFriendlyActionLabel("bun install"), "Install dependencies");
+  assert.equal(getFriendlyActionLabel("npm install"), "Install dependencies");
+  assert.equal(getFriendlyActionLabel("npm install --save-dev"), "Install dependencies");
+});
+
+test("getFriendlyActionLabel: test commands → Run tests", () => {
+  assert.equal(getFriendlyActionLabel("bun test"), "Run tests");
+  assert.equal(getFriendlyActionLabel("npm test"), "Run tests");
+});
+
+test("getFriendlyActionLabel: typecheck commands → Run typecheck", () => {
+  assert.equal(getFriendlyActionLabel("tsc --noEmit"), "Run typecheck");
+  assert.equal(getFriendlyActionLabel("bun run typecheck"), "Run typecheck");
+});
+
+test("getFriendlyActionLabel: returns null for unrecognized commands", () => {
+  assert.equal(getFriendlyActionLabel("python -m pytest"), null);
+  assert.equal(getFriendlyActionLabel("echo hello"), null);
+  assert.equal(getFriendlyActionLabel("node scripts/build.js"), null);
+});
+
+test("normalizeCommand: decodes JSON-escaped quotes in PowerShell commands", () => {
+  const raw = `pwsh.exe -Command 'Get-ChildItem | Where-Object { $_.Name -match \\"requirements\\" }'`;
+  assert.equal(
+    normalizeCommand(raw),
+    'Get-ChildItem | Where-Object { $_.Name -match "requirements" }',
+  );
+});
+
+test("normalizeCommand: decodes escaped quotes in bare commands", () => {
+  assert.equal(normalizeCommand(`grep -r \\"TODO\\" ./src`), 'grep -r "TODO" ./src');
+});
+
+test("normalizeCommand: decodes escaped quotes in cmd.exe wrapper", () => {
+  assert.equal(normalizeCommand(`cmd.exe /c "grep \\"error\\" log.txt"`), 'grep "error" log.txt');
+});
+
+test("normalizeCommand: passes through MCP tool call format unchanged", () => {
+  assert.equal(normalizeCommand("filesystem:read_file"), "filesystem:read_file");
+  assert.equal(normalizeCommand("github:create_issue"), "github:create_issue");
+});
+
+test("normalizeCommand: passes through web search format unchanged", () => {
+  assert.equal(
+    normalizeCommand("web search: TypeScript union types"),
+    "web search: TypeScript union types",
+  );
+});
+
+test("getFriendlyActionLabel: returns null for MCP tool call format", () => {
+  assert.equal(getFriendlyActionLabel("filesystem:read_file"), null);
+  assert.equal(getFriendlyActionLabel("github:list_issues"), null);
+});
+
+test("getFriendlyActionLabel: returns null for web search commands", () => {
+  assert.equal(getFriendlyActionLabel("web search: TypeScript generics tutorial"), null);
+});

package/src/ui/commandNormalize.ts

@@ -0,0 +1,66 @@
+import { formatTerminalAnswerInline } from "./terminalAnswerFormat.js";
+
+function stripOuterQuotes(s: string): string {
+  if ((s.startsWith("'") && s.endsWith("'")) || (s.startsWith('"') && s.endsWith('"'))) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+
+function decodeEscapedQuotes(s: string): string {
+  return s.replace(/\\"/g, '"');
+}
+
+function cleanCommand(command: string): string {
+  return formatTerminalAnswerInline(decodeEscapedQuotes(command.trim()));
+}
+
+/**
+ * Strips shell-wrapper invocations from a command string and returns the inner
+ * command that is actually being executed.
+ *
+ * Handles:
+ *   "C:\Program Files\PowerShell\7\pwsh.exe" -Command '...'
+ *   pwsh.exe -Command "..."
+ *   powershell.exe -Command '...'
+ *   cmd.exe /c "..."
+ *   bash -lc '...'
+ */
+export function normalizeCommand(command: string): string {
+  // Full quoted path ending with pwsh.exe / powershell.exe
+  let match = command.match(/^"[^"]*(?:pwsh|powershell)(?:\.exe)?"\s+-Command\s+(.+)$/si);
+  if (match) return cleanCommand(stripOuterQuotes(match[1].trim()));
+
+  // Bare pwsh.exe / powershell.exe on PATH
+  match = command.match(/^(?:pwsh|powershell)(?:\.exe)?\s+-Command\s+(.+)$/si);
+  if (match) return cleanCommand(stripOuterQuotes(match[1].trim()));
+
+  // cmd.exe /c "..."
+  match = command.match(/^cmd(?:\.exe)?\s+\/[cC]\s+(.+)$/s);
+  if (match) return cleanCommand(stripOuterQuotes(match[1].trim()));
+
+  // bash -lc "..." or bash -lc '...'
+  match = command.match(/^bash\s+-lc\s+(.+)$/s);
+  if (match) return cleanCommand(stripOuterQuotes(match[1].trim()));
+
+  return cleanCommand(command);
+}
+
+/**
+ * Maps a normalized command to a short human-readable label.
+ * Returns null when no label applies and the command itself should be shown.
+ */
+export function getFriendlyActionLabel(normalizedCommand: string): string | null {
+  const cmd = normalizedCommand.trim();
+
+  if (/^(?:Get-ChildItem|dir|ls)\b/i.test(cmd)) return "List files";
+  if (/^rg\s+--files\b/i.test(cmd)) return "List files";
+  if (/^(?:Get-Content|cat)\b/i.test(cmd)) return "Read file";
+  if (/^git\s+status\b/.test(cmd)) return "Check git status";
+  if (/^git\s+diff\b/.test(cmd)) return "Inspect changes";
+  if (/^(?:bun|npm)\s+install\b/.test(cmd)) return "Install dependencies";
+  if (/^(?:bun|npm)\s+test\b/.test(cmd)) return "Run tests";
+  if (/^(?:tsc\b|bun\s+run\s+typecheck\b)/.test(cmd)) return "Run typecheck";
+
+  return null;
+}

package/src/ui/diffRenderer.test.ts

@@ -0,0 +1,102 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { isUnifiedDiff, maybeRenderDiff, renderUnifiedDiff } from "./diffRenderer.js";
+
+const GIT_DIFF = [
+  "diff --git a/src/example.ts b/src/example.ts",
+  "index 1111111..2222222 100644",
+  "--- a/src/example.ts",
+  "+++ b/src/example.ts",
+  "@@ -1,3 +1,4 @@",
+  " const name = \"Codexa\";",
+  "-console.log(\"old\");",
+  "+console.log(\"new\");",
+  "+console.log(\"added\");",
+  " export default name;",
+].join("\n");
+
+test("detects a git unified diff", () => {
+  assert.equal(isUnifiedDiff(GIT_DIFF), true);
+});
+
+test("detects a simple file-header and hunk diff", () => {
+  const diff = [
+    "--- old.txt",
+    "+++ new.txt",
+    "@@ -1 +1 @@",
+    "-old",
+    "+new",
+  ].join("\n");
+
+  assert.equal(isUnifiedDiff(diff), true);
+});
+
+test("classifies file, hunk, added, removed, context, and meta lines", () => {
+  const rendered = renderUnifiedDiff(GIT_DIFF);
+  assert.deepEqual(rendered.map((line) => line.type), [
+    "file",
+    "meta",
+    "file",
+    "file",
+    "hunk",
+    "context",
+    "remove",
+    "add",
+    "add",
+    "context",
+  ]);
+});
+
+test("handles malformed diff-like text without throwing", () => {
+  assert.doesNotThrow(() => renderUnifiedDiff("diff --git a/a b/a\nnot enough here"));
+  assert.equal(maybeRenderDiff("diff --git a/a b/a\nnot enough here"), null);
+});
+
+test("does not classify normal text as a diff", () => {
+  const text = [
+    "Here are options:",
+    "- use --help",
+    "+ consider reading docs",
+  ].join("\n");
+
+  assert.equal(isUnifiedDiff(text), false);
+  assert.equal(maybeRenderDiff(text), null);
+});
+
+test("keeps Windows paths readable in file headers", () => {
+  const diff = [
+    "--- a\\src\\example.ts",
+    "+++ b\\src\\example.ts",
+    "@@ -1 +1 @@",
+    "-old",
+    "+new",
+  ].join("\n");
+
+  const rendered = renderUnifiedDiff(diff);
+  assert.equal(rendered[0]?.text, "--- a\\src\\example.ts");
+  assert.equal(rendered[1]?.text, "+++ b\\src\\example.ts");
+});
+
+test("strips ANSI and unsafe controls before classification", () => {
+  const diff = [
+    "\u001b[31m--- a/file.ts\u001b[0m",
+    "\u001b[32m+++ b/file.ts\u001b[0m",
+    "@@ -1 +1 @@",
+    "\u001b[31m-old\u001b[0m",
+    "\u001b[32m+new\u001b[0m\u0007",
+  ].join("\n");
+
+  const rendered = renderUnifiedDiff(diff);
+  assert.deepEqual(rendered.map((line) => line.text), [
+    "--- a/file.ts",
+    "+++ b/file.ts",
+    "@@ -1 +1 @@",
+    "-old",
+    "+new",
+  ]);
+});
+
+test("forced rendering accepts explicit diff fences with change lines", () => {
+  assert.equal(isUnifiedDiff("-old\n+new", { force: true }), true);
+  assert.equal(isUnifiedDiff("-old\n+new"), false);
+});

package/src/ui/diffRenderer.ts

@@ -0,0 +1,116 @@
+import { sanitizeTerminalOutput } from "../core/terminal/terminalSanitize.js";
+
+export type DiffRenderLineType = "file" | "hunk" | "add" | "remove" | "context" | "meta";
+
+export interface DiffRenderLine {
+  type: DiffRenderLineType;
+  text: string;
+}
+
+export interface DiffRenderOptions {
+  force?: boolean;
+}
+
+const DIFF_GIT_HEADER_PATTERN = /^diff --git\s+/;
+const HUNK_HEADER_PATTERN = /^@@\s+-\d+(?:,\d+)?\s+\+\d+(?:,\d+)?\s*@@/;
+const INDEX_HEADER_PATTERN = /^index\s+\S+\.\.\S+/;
+const OLD_FILE_HEADER_PATTERN = /^---\s+\S+/;
+const NEW_FILE_HEADER_PATTERN = /^\+\+\+\s+\S+/;
+const ADD_LINE_PATTERN = /^\+(?!\+\+)/;
+const REMOVE_LINE_PATTERN = /^-(?!--)/;
+
+function normalizeDiffText(text: string): string {
+  return sanitizeTerminalOutput(text, { preserveTabs: false, tabSize: 2 })
+    .replace(/\r\n/g, "\n")
+    .replace(/\r/g, "\n");
+}
+
+function getDiffLines(text: string): string[] {
+  return normalizeDiffText(text)
+    .split("\n")
+    .map((line) => line.trimEnd());
+}
+
+function trimBlankEdges(lines: string[]): string[] {
+  let start = 0;
+  let end = lines.length;
+
+  while (start < end && lines[start]?.trim() === "") start += 1;
+  while (end > start && lines[end - 1]?.trim() === "") end -= 1;
+
+  return lines.slice(start, end);
+}
+
+function hasPairedFileHeaders(lines: readonly string[]): boolean {
+  return lines.some((line) => OLD_FILE_HEADER_PATTERN.test(line))
+    && lines.some((line) => NEW_FILE_HEADER_PATTERN.test(line));
+}
+
+function hasStrongDiffSignal(lines: readonly string[]): boolean {
+  return lines.some((line) =>
+    DIFF_GIT_HEADER_PATTERN.test(line)
+    || HUNK_HEADER_PATTERN.test(line)
+    || INDEX_HEADER_PATTERN.test(line)
+  ) || hasPairedFileHeaders(lines);
+}
+
+function hasRealChangeLine(lines: readonly string[]): boolean {
+  return lines.some((line) => ADD_LINE_PATTERN.test(line) || REMOVE_LINE_PATTERN.test(line));
+}
+
+function shouldRenderUnifiedDiff(lines: readonly string[], options: DiffRenderOptions = {}): boolean {
+  if (lines.length < 2) return false;
+  if (options.force) {
+    return hasStrongDiffSignal(lines) || hasRealChangeLine(lines);
+  }
+  return hasStrongDiffSignal(lines) && hasRealChangeLine(lines);
+}
+
+export function classifyDiffLine(line: string): DiffRenderLineType {
+  if (DIFF_GIT_HEADER_PATTERN.test(line) || OLD_FILE_HEADER_PATTERN.test(line) || NEW_FILE_HEADER_PATTERN.test(line)) {
+    return "file";
+  }
+
+  if (HUNK_HEADER_PATTERN.test(line) || line.startsWith("@@")) {
+    return "hunk";
+  }
+
+  if (ADD_LINE_PATTERN.test(line)) {
+    return "add";
+  }
+
+  if (REMOVE_LINE_PATTERN.test(line)) {
+    return "remove";
+  }
+
+  if (INDEX_HEADER_PATTERN.test(line) || line.startsWith("\\ No newline")) {
+    return "meta";
+  }
+
+  return "context";
+}
+
+export function isUnifiedDiff(text: string, options: DiffRenderOptions = {}): boolean {
+  return shouldRenderUnifiedDiff(trimBlankEdges(getDiffLines(text)), options);
+}
+
+export function renderUnifiedDiff(text: string, options: DiffRenderOptions = {}): DiffRenderLine[] {
+  const lines = trimBlankEdges(getDiffLines(text));
+  if (lines.length === 0) {
+    return [];
+  }
+
+  if (!shouldRenderUnifiedDiff(lines, options)) {
+    return [];
+  }
+
+  return lines.map((line) => ({
+    type: classifyDiffLine(line),
+    text: line,
+  }));
+}
+
+export function maybeRenderDiff(text: string, options: DiffRenderOptions = {}): DiffRenderLine[] | null {
+  const rendered = renderUnifiedDiff(text, options);
+  return rendered.length > 0 ? rendered : null;
+}

package/src/ui/focus.ts

@@ -0,0 +1,61 @@
+import type { Screen } from "../session/types.js";
+
+export const FOCUS_IDS = {
+  composer: "composer",
+  planReviewPanel: "plan-review-panel",
+  backendPicker: "backend-picker",
+  providerPicker: "provider-picker",
+  modelPicker: "model-picker",
+  modePicker: "mode-picker",
+  reasoningPicker: "reasoning-picker",
+  themePicker: "theme-picker",
+  settingsPanel: "settings-panel",
+  authPanel: "auth-panel",
+  permissionsPanel: "permissions-panel",
+  permissionsApprovalPicker: "permissions-approval-picker",
+  permissionsSandboxPicker: "permissions-sandbox-picker",
+  permissionsNetworkPicker: "permissions-network-picker",
+  permissionsAddWritableRoot: "permissions-add-writable-root",
+  permissionsRemoveWritableRoot: "permissions-remove-writable-root",
+  importConfirmationPanel: "import-confirmation",
+} as const;
+
+export type FocusTargetId = (typeof FOCUS_IDS)[keyof typeof FOCUS_IDS];
+
+export function getFocusTargetForScreen(screen: Screen): FocusTargetId {
+  switch (screen) {
+    case "backend-picker":
+      return FOCUS_IDS.backendPicker;
+    case "provider-picker":
+      return FOCUS_IDS.providerPicker;
+    case "model-picker":
+      return FOCUS_IDS.modelPicker;
+    case "mode-picker":
+      return FOCUS_IDS.modePicker;
+    case "reasoning-picker":
+      return FOCUS_IDS.reasoningPicker;
+    case "theme-picker":
+      return FOCUS_IDS.themePicker;
+    case "settings-panel":
+      return FOCUS_IDS.settingsPanel;
+    case "auth-panel":
+      return FOCUS_IDS.authPanel;
+    case "permissions-panel":
+      return FOCUS_IDS.permissionsPanel;
+    case "permissions-approval-picker":
+      return FOCUS_IDS.permissionsApprovalPicker;
+    case "permissions-sandbox-picker":
+      return FOCUS_IDS.permissionsSandboxPicker;
+    case "permissions-network-picker":
+      return FOCUS_IDS.permissionsNetworkPicker;
+    case "permissions-add-writable-root":
+      return FOCUS_IDS.permissionsAddWritableRoot;
+    case "permissions-remove-writable-root":
+      return FOCUS_IDS.permissionsRemoveWritableRoot;
+    case "import-confirmation":
+      return FOCUS_IDS.importConfirmationPanel;
+    case "main":
+    default:
+      return FOCUS_IDS.composer;
+  }
+}