killeros 1.4.8 → 1.5.0

package/killeros/shell-ui.ts

@@ -0,0 +1,270 @@
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import {
+  CustomEditor,
+  DynamicBorder,
+  VERSION,
+  type ExtensionAPI,
+  type ExtensionContext,
+  type KeybindingsManager,
+  type Theme,
+} from "@earendil-works/pi-coding-agent";
+import {
+  Container,
+  Text,
+  truncateToWidth,
+  visibleWidth,
+  wrapTextWithAnsi,
+  type EditorTheme,
+  type TUI,
+} from "@earendil-works/pi-tui";
+import { formatCwd, padRight } from "./display.ts";
+import { reportError } from "./errors.ts";
+import { formatModel } from "./footer.ts";
+import { LEVEL_COLORS, type ThinkingLevel } from "./variants.ts";
+
+const COMMAND_BLUE_RGB = "120;169;255";
+const COMPACT_HEADER_MAX_WIDTH = 52;
+
+const commandBlue = (text: string): string => `\x1B[38;2;${COMMAND_BLUE_RGB}m${text}\x1B[39m`;
+
+function readPackageVersion(path: string | URL): string | undefined {
+  try {
+    const value = JSON.parse(readFileSync(path, "utf8")) as { version?: unknown };
+    return typeof value.version === "string" ? value.version : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+const KILLEROS_VERSION = readPackageVersion(new URL("../package.json", import.meta.url));
+
+const STARTUP_TIPS = [
+  "Press Shift+Enter to insert a line break without sending.",
+  "Run /variants to tune the model's reasoning depth.",
+  "Type / to browse every command available in this session.",
+] as const;
+
+function resolveGitBranch(cwd: string): string | undefined {
+  try {
+    const branch = execFileSync("git", ["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"], {
+      encoding: "utf8",
+      maxBuffer: 64 * 1024,
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 500,
+      windowsHide: true,
+    }).trim();
+    if (!branch) return undefined;
+    return branch === "HEAD" ? "detached" : branch;
+  } catch {
+    return undefined;
+  }
+}
+
+function shuffledTips(): string[] {
+  const tips = [...STARTUP_TIPS];
+  for (let index = tips.length - 1; index > 0; index -= 1) {
+    const swapIndex = Math.floor(Math.random() * (index + 1));
+    [tips[index], tips[swapIndex]] = [tips[swapIndex]!, tips[index]!];
+  }
+  return tips;
+}
+
+function compactBoxLine(content: string, width: number, theme: Theme): string {
+  if (width < 4) return truncateToWidth(content, width, "");
+  return `${theme.fg("dim", "│")} ${padRight(content, width - 4)} ${theme.fg("dim", "│")}`;
+}
+
+class PiStartupHeader {
+  private readonly pi: ExtensionAPI;
+  private readonly ctx: ExtensionContext;
+  private readonly branch: string | undefined;
+  private readonly tip: string;
+
+  constructor(pi: ExtensionAPI, ctx: ExtensionContext, tip: string) {
+    this.pi = pi;
+    this.ctx = ctx;
+    this.branch = resolveGitBranch(ctx.cwd);
+    this.tip = tip;
+  }
+
+  private tipLines(width: number, theme: Theme): string[] {
+    const indent = "  ";
+    const text = `${theme.fg("text", theme.bold("Tip:"))}${theme.fg("dim", ` ${this.tip}`)}`;
+    return wrapTextWithAnsi(text, width - indent.length)
+      .map((line) => padRight(`${indent}${line}`, width));
+  }
+
+  render(width: number): string[] {
+    if (width <= 0) return [];
+    const theme = this.ctx.ui.theme;
+    if (width < 28) return [truncateToWidth(theme.fg("text", theme.bold("KillerOS")), width, "")];
+
+    const panelWidth = Math.min(width, COMPACT_HEADER_MAX_WIDTH);
+    const innerWidth = panelWidth - 4;
+    const version = KILLEROS_VERSION ? theme.fg("dim", ` (v${KILLEROS_VERSION})`) : "";
+    const identity = `${theme.fg("dim", "›")} ${theme.fg("text", theme.bold("KillerOS"))}${version}`;
+    const thinkingLevel = this.pi.getThinkingLevel() as ThinkingLevel;
+    const reasoning = this.ctx.model?.reasoning === false
+      ? theme.fg("thinkingOff", "no reasoning")
+      : theme.fg(LEVEL_COLORS[thinkingLevel], thinkingLevel);
+    const agent = `${formatModel(this.ctx.model, theme)}${theme.fg("dim", " · ")}${reasoning}`;
+    const directory = formatCwd(this.ctx.cwd);
+    const repository = this.branch
+      ? `${directory} ${theme.fg("dim", `· ${this.branch}`)}`
+      : directory;
+    const modelCommand = commandBlue("/model");
+    const agentWidth = Math.max(0, innerWidth - visibleWidth(modelCommand) - 1);
+    const agentCommand = `${truncateToWidth(agent, agentWidth, "…")} ${modelCommand}`;
+    const border = (left: string, right: string): string => theme.fg("dim", `${left}${"─".repeat(panelWidth - 2)}${right}`);
+    const lines = [
+      border("╭", "╮"),
+      compactBoxLine(identity, panelWidth, theme),
+      compactBoxLine("", panelWidth, theme),
+      compactBoxLine(agentCommand, panelWidth, theme),
+      compactBoxLine(repository, panelWidth, theme),
+      border("╰", "╯"),
+      " ".repeat(panelWidth),
+      ...this.tipLines(panelWidth, theme),
+    ];
+    return lines;
+  }
+
+  invalidate(): void {}
+  dispose(): void {}
+}
+
+const ANSI_REGEX = /\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+
+function stripAnsi(text: string): string {
+  return text.replace(ANSI_REGEX, "").trim();
+}
+
+function isBorderLine(line: string): boolean {
+  const unstyled = stripAnsi(line);
+  return /^[─━═]+$/.test(unstyled) || /^───\s*[↓↑]/.test(unstyled) || /^─{3,}/.test(unstyled);
+}
+
+class PiCodeEditor extends CustomEditor {
+  private readonly appKeybindings: KeybindingsManager;
+
+  constructor(tui: TUI, theme: EditorTheme, appKeybindings: KeybindingsManager) {
+    super(tui, theme, appKeybindings);
+    this.appKeybindings = appKeybindings;
+  }
+
+  override handleInput(data: string): void {
+    const isShiftEnter = data === "\x1B[13;2u"
+      || data === "\x1B[13;2~"
+      || data === "\x1B[27;2;13~"
+      || data === "\x1B\r"
+      || data === "\x1B\n"
+      || this.appKeybindings.matches(data, "tui.input.newLine");
+    if (isShiftEnter) {
+      this.insertTextAtCursor("\n");
+      return;
+    }
+    super.handleInput(data);
+  }
+
+  override render(width: number): string[] {
+    if (width < 4) return super.render(width);
+    const innerWidth = width - 2;
+    const lines = super.render(innerWidth);
+    if (lines.length < 2) return lines.map((line) => truncateToWidth(line, width, ""));
+
+    const gray = (text: string): string => `\x1B[90m${text}\x1B[39m`;
+    let bottomBorderIndex = -1;
+    for (let index = lines.length - 1; index >= 1; index -= 1) {
+      if (isBorderLine(lines[index] ?? "")) {
+        bottomBorderIndex = index;
+        break;
+      }
+    }
+    if (bottomBorderIndex < 0) bottomBorderIndex = lines.length - 1;
+
+    const framed: string[] = [];
+    const top = stripAnsi(lines[0] ?? "");
+    const isScrolledHeader = top.includes("↑");
+    if (isScrolledHeader) {
+      const count = top.match(/↑\s*(\d+)/)?.[1] ?? "";
+      const indicator = `${gray("─── ↑ ")}${count}${gray(" more ")}${gray("─".repeat(Math.max(0, width - 12 - count.length)))}`;
+      framed.push(truncateToWidth(indicator, width, ""));
+    } else {
+      framed.push(gray("─".repeat(width)));
+    }
+
+    for (let index = 1; index < bottomBorderIndex; index += 1) {
+      const prefix = index === 1 && !isScrolledHeader ? gray("❯ ") : "  ";
+      framed.push(`${prefix}${padRight(lines[index] ?? "", innerWidth)}`);
+    }
+
+    const bottom = stripAnsi(lines[bottomBorderIndex] ?? "");
+    if (bottom.includes("↓")) {
+      const count = bottom.match(/↓\s*(\d+)/)?.[1] ?? "";
+      const indicator = `${gray("─── ↓ ")}${count}${gray(" more ")}${gray("─".repeat(Math.max(0, width - 12 - count.length)))}`;
+      framed.push(truncateToWidth(indicator, width, ""));
+    } else {
+      framed.push(gray("─".repeat(width)));
+    }
+
+    for (let index = bottomBorderIndex + 1; index < lines.length; index += 1) {
+      framed.push(`  ${padRight(lines[index] ?? "", innerWidth)}`);
+    }
+    return framed.map((line) => truncateToWidth(line, width, ""));
+  }
+}
+
+const ACTIVITY_WORDS = ["Brewing", "Pondering", "Tinkering", "Wrangling", "Noodling", "Cooking"] as const;
+
+export function registerShellUi(pi: ExtensionAPI): void {
+  let activeHeader: PiStartupHeader | undefined;
+  let activityWordIndex = 0;
+  let tipDeck: string[] = [];
+  const nextStartupTip = (): string => {
+    if (tipDeck.length === 0) tipDeck = shuffledTips();
+    return tipDeck.pop() ?? STARTUP_TIPS[0];
+  };
+
+  pi.on("session_start", (_event, ctx) => {
+    if (ctx.mode !== "tui") return;
+    try {
+      ctx.ui.setTheme("killeros");
+      const startupTip = nextStartupTip();
+      ctx.ui.setHeader(() => {
+        activeHeader?.dispose();
+        activeHeader = new PiStartupHeader(pi, ctx, startupTip);
+        return activeHeader;
+      });
+      ctx.ui.setWorkingIndicator({
+        frames: [
+          ctx.ui.theme.fg("dim", "✻"),
+          ctx.ui.theme.fg("muted", "✻"),
+          ctx.ui.theme.fg("accent", "✻"),
+          ctx.ui.theme.fg("muted", "✻"),
+        ],
+        intervalMs: 180,
+      });
+      ctx.ui.setHiddenThinkingLabel("└ Thinking…");
+      ctx.ui.setEditorComponent((tui, theme, keybindings) => new PiCodeEditor(tui, theme, keybindings));
+    } catch (error) {
+      reportError(ctx, "Killeros UI failed to initialize", error);
+    }
+  });
+
+  pi.on("agent_start", (_event, ctx) => {
+    if (ctx.mode !== "tui") return;
+    ctx.ui.setWorkingMessage(`${ACTIVITY_WORDS[activityWordIndex]}…`);
+    activityWordIndex = (activityWordIndex + 1) % ACTIVITY_WORDS.length;
+  });
+
+  pi.on("agent_end", (_event, ctx) => {
+    if (ctx.mode === "tui") ctx.ui.setWorkingMessage();
+  });
+
+  pi.on("session_shutdown", () => {
+    activeHeader?.dispose();
+    activeHeader = undefined;
+    activityWordIndex = 0;
+  });
+}