@selesai/code 0.1.0

package/dist/extensions/pi-powerline-footer/bash-mode/shell-session.ts

@@ -0,0 +1,286 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import type { BashTranscriptStore } from "./transcript.ts";
+import type { ShellSessionState } from "./types.ts";
+
+const READY_SENTINEL = "__PI_READY__";
+const COMMAND_START_SENTINEL = "__PI_CMD_START__";
+const COMMAND_DONE_SENTINEL = "__PI_CMD_DONE__";
+
+function stripAnsi(value: string): string {
+  return value
+    .replace(/\x1B\[[0-9;?]*[ -/]*[@-~]/g, "")
+    .replace(/\x1B\][^\u0007]*(?:\u0007|\x1b\\)/g, "")
+    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "");
+}
+
+function quoteShellArg(value: string): string {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+
+function getCloseExitCode(code: number | null, signal: NodeJS.Signals | null): number {
+  if (typeof code === "number") {
+    return code;
+  }
+
+  if (signal === "SIGINT") {
+    return 130;
+  }
+
+  if (signal === "SIGTERM") {
+    return 143;
+  }
+
+  if (signal === "SIGKILL") {
+    return 137;
+  }
+
+  return 1;
+}
+
+function getShellInitScript(shellName: string): string {
+  if (shellName.includes("fish")) {
+    return `
+function __pi_eval
+  set -l __pi_id $argv[1]
+  set -l __pi_file $argv[2]
+  echo "${COMMAND_START_SENTINEL}:$__pi_id:$PWD"
+  source $__pi_file
+  set -l __pi_status $status
+  rm -f $__pi_file
+  echo "${COMMAND_DONE_SENTINEL}:$__pi_id:$__pi_status:$PWD"
+end
+echo "${READY_SENTINEL}:$PWD"
+`;
+  }
+
+  if (shellName.includes("bash")) {
+    return `
+__pi_eval() {
+  local __pi_id="$1"
+  local __pi_file="$2"
+  printf '%s:%s:%s\n' '${COMMAND_START_SENTINEL}' "$__pi_id" "$PWD"
+  source "$__pi_file"
+  local __pi_status=$?
+  rm -f "$__pi_file"
+  printf '%s:%s:%s:%s\n' '${COMMAND_DONE_SENTINEL}' "$__pi_id" "$__pi_status" "$PWD"
+}
+printf '%s:%s\n' '${READY_SENTINEL}' "$PWD"
+`;
+  }
+
+  return `
+function __pi_eval() {
+  local __pi_id="$1"
+  local __pi_file="$2"
+  print -r -- "${COMMAND_START_SENTINEL}:$__pi_id:$PWD"
+  builtin source "$__pi_file"
+  local __pi_status=$?
+  rm -f "$__pi_file"
+  print -r -- "${COMMAND_DONE_SENTINEL}:$__pi_id:$__pi_status:$PWD"
+}
+print -r -- "${READY_SENTINEL}:$PWD"
+`;
+}
+
+export class ManagedShellSession {
+  private readonly shellPath: string;
+  private readonly transcript: BashTranscriptStore;
+  private readonly onStateChange: () => void;
+  private readonly onCommandSuccess: (command: string, cwd: string) => void;
+  private process: ChildProcessWithoutNullStreams | null = null;
+  private readonly tempDir = mkdtempSync(join(tmpdir(), "powerline-bash-mode-"));
+  private buffer = "";
+  private commandCounter = 0;
+  private currentCommandId: string | null = null;
+  private readyPromise: Promise<void> | null = null;
+  private readyResolve: (() => void) | null = null;
+  private readyReject: ((error: Error) => void) | null = null;
+  private disposed = false;
+  readonly state: ShellSessionState;
+
+  constructor(
+    shellPath: string,
+    cwd: string,
+    transcript: BashTranscriptStore,
+    onStateChange: () => void,
+    onCommandSuccess: (command: string, cwd: string) => void,
+  ) {
+    this.shellPath = shellPath;
+    this.transcript = transcript;
+    this.onStateChange = onStateChange;
+    this.onCommandSuccess = onCommandSuccess;
+    const shellName = basename(shellPath).toLowerCase();
+    this.state = {
+      ready: false,
+      running: false,
+      shellPath,
+      shellName,
+      cwd,
+      lastExitCode: null,
+    };
+  }
+
+  async ensureReady(): Promise<void> {
+    if (this.state.ready) return;
+    if (this.readyPromise) return this.readyPromise;
+
+    this.readyPromise = new Promise<void>((resolve, reject) => {
+      this.readyResolve = resolve;
+      this.readyReject = reject;
+    });
+
+    this.process = spawn(this.shellPath, [], {
+      cwd: this.state.cwd,
+      env: {
+        ...process.env,
+        DISABLE_AUTO_UPDATE: "true",
+        DISABLE_UPDATE_PROMPT: "true",
+      },
+      stdio: ["pipe", "pipe", "pipe"],
+      detached: true,
+    });
+
+    this.process.stdout.setEncoding("utf8");
+    this.process.stderr.setEncoding("utf8");
+    this.process.stdout.on("data", (chunk) => this.handleChunk(String(chunk)));
+    this.process.stderr.on("data", (chunk) => this.handleChunk(String(chunk)));
+    this.process.on("error", (error) => {
+      if (!this.state.ready) {
+        this.readyReject?.(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+    this.process.on("close", (code, signal) => {
+      const exitCode = getCloseExitCode(code, signal);
+      if (!this.disposed && !this.state.ready) {
+        this.readyReject?.(new Error(`Shell failed to start (exit ${exitCode})`));
+      }
+
+      if (this.currentCommandId) {
+        this.transcript.finishCommand(this.currentCommandId, exitCode);
+        this.state.lastExitCode = exitCode;
+        this.currentCommandId = null;
+      }
+
+      this.process = null;
+      this.buffer = "";
+      this.readyPromise = null;
+      this.readyResolve = null;
+      this.readyReject = null;
+      this.state.ready = false;
+      this.state.running = false;
+      this.onStateChange();
+    });
+
+    this.sendRaw(getShellInitScript(this.state.shellName) + "\n");
+    return this.readyPromise;
+  }
+
+  async runCommand(command: string): Promise<void> {
+    await this.ensureReady();
+    if (!this.process) {
+      throw new Error("Shell process not available");
+    }
+    if (this.state.running) {
+      throw new Error("Shell command already running");
+    }
+
+    const id = `cmd-${++this.commandCounter}`;
+    const extension = this.state.shellName.includes("fish") ? "fish" : "sh";
+    const filePath = join(this.tempDir, `${id}.${extension}`);
+    writeFileSync(filePath, command.endsWith("\n") ? command : `${command}\n`, "utf8");
+
+    this.currentCommandId = id;
+    this.state.running = true;
+    this.transcript.startCommand(id, command, this.state.cwd);
+    this.onStateChange();
+    this.sendRaw(`__pi_eval ${quoteShellArg(id)} ${quoteShellArg(filePath)}\n`);
+  }
+
+  interrupt(): void {
+    if (!this.process || !this.state.running) return;
+    try {
+      process.kill(-this.process.pid!, "SIGINT");
+    } catch {
+      // The shell may not own a process group anymore.
+      this.process.kill("SIGINT");
+    }
+  }
+
+  dispose(): void {
+    this.disposed = true;
+    this.readyPromise = null;
+    this.readyResolve = null;
+    this.readyReject = null;
+    if (!this.process) return;
+    try {
+      process.kill(-this.process.pid!, "SIGKILL");
+    } catch {
+      // The shell may not own a process group anymore.
+      this.process.kill("SIGKILL");
+    }
+    this.process = null;
+  }
+
+  private sendRaw(text: string): void {
+    if (!this.process) return;
+    this.process.stdin.write(text);
+  }
+
+  private handleChunk(chunk: string): void {
+    const sanitized = stripAnsi(chunk).replace(/\r/g, "");
+    if (!sanitized) return;
+
+    this.buffer += sanitized;
+    const parts = this.buffer.split("\n");
+    this.buffer = parts.pop() ?? "";
+
+    for (const rawLine of parts) {
+      const line = rawLine.trimEnd();
+      if (!this.state.ready) {
+        if (line.startsWith(`${READY_SENTINEL}:`)) {
+          this.state.ready = true;
+          this.state.cwd = line.slice(READY_SENTINEL.length + 1) || this.state.cwd;
+          this.readyResolve?.();
+          this.readyResolve = null;
+          this.readyReject = null;
+          this.onStateChange();
+        }
+        continue;
+      }
+
+      if (line.startsWith(`${COMMAND_START_SENTINEL}:`)) {
+        const [, id, cwd] = line.split(":");
+        if (cwd) this.state.cwd = cwd;
+        this.currentCommandId = id ?? this.currentCommandId;
+        this.onStateChange();
+        continue;
+      }
+
+      if (line.startsWith(`${COMMAND_DONE_SENTINEL}:`)) {
+        const [, id, exitCodeText, cwd] = line.split(":");
+        const exitCode = Number.parseInt(exitCodeText ?? "1", 10);
+        this.state.running = false;
+        this.state.lastExitCode = Number.isFinite(exitCode) ? exitCode : 1;
+        if (cwd) this.state.cwd = cwd;
+        if (id) {
+          this.transcript.finishCommand(id, this.state.lastExitCode);
+          const snapshot = this.transcript.getSnapshot();
+          const command = snapshot.commands.find((entry) => entry.id === id);
+          if (command && this.state.lastExitCode === 0) {
+            this.onCommandSuccess(command.command, this.state.cwd);
+          }
+        }
+        this.currentCommandId = null;
+        this.onStateChange();
+        continue;
+      }
+
+      if (!this.currentCommandId) continue;
+      this.transcript.appendOutput(this.currentCommandId, line);
+      this.onStateChange();
+    }
+  }
+}

package/dist/extensions/pi-powerline-footer/bash-mode/transcript.ts

@@ -0,0 +1,108 @@
+import type { BashCommandRecord, BashModeSettings, BashTranscriptSnapshot } from "./types.ts";
+
+function byteLength(value: string): number {
+  return Buffer.byteLength(value, "utf8");
+}
+
+function compactLines(lines: string[]): string[] {
+  const normalized: string[] = [];
+  for (const line of lines) {
+    const sanitized = line.replace(/\r/g, "");
+    if (sanitized.length === 0) {
+      normalized.push("");
+      continue;
+    }
+    normalized.push(...sanitized.split("\n"));
+  }
+  return normalized;
+}
+
+export class BashTranscriptStore {
+  private readonly settings: Pick<BashModeSettings, "transcriptMaxLines" | "transcriptMaxBytes">;
+  private commands: BashCommandRecord[] = [];
+  private commandIndex = new Map<string, BashCommandRecord>();
+  private totalLines = 0;
+  private totalBytes = 0;
+  private truncatedCommands = 0;
+
+  constructor(settings: Pick<BashModeSettings, "transcriptMaxLines" | "transcriptMaxBytes">) {
+    this.settings = settings;
+  }
+
+  startCommand(id: string, command: string, cwdAtStart: string): BashCommandRecord {
+    const entry: BashCommandRecord = {
+      id,
+      command,
+      cwdAtStart,
+      startedAt: Date.now(),
+      output: [],
+      outputBytes: 0,
+      exitCode: null,
+      finishedAt: null,
+      truncated: false,
+    };
+
+    this.commands.push(entry);
+    this.commandIndex.set(id, entry);
+    this.enforceLimits();
+    return entry;
+  }
+
+  appendOutput(id: string, chunk: string): void {
+    const entry = this.commandIndex.get(id);
+    if (!entry || !chunk) return;
+
+    const lines = compactLines([chunk]);
+    if (lines.length === 0) return;
+
+    entry.output.push(...lines);
+    const addedBytes = lines.reduce((sum, line) => sum + byteLength(line) + 1, 0);
+    entry.outputBytes += addedBytes;
+    this.totalLines += lines.length;
+    this.totalBytes += addedBytes;
+    this.enforceLimits();
+  }
+
+  finishCommand(id: string, exitCode: number): void {
+    const entry = this.commandIndex.get(id);
+    if (!entry) return;
+
+    entry.exitCode = exitCode;
+    entry.finishedAt = Date.now();
+  }
+
+  clear(): void {
+    this.commands = [];
+    this.commandIndex.clear();
+    this.totalLines = 0;
+    this.totalBytes = 0;
+    this.truncatedCommands = 0;
+  }
+
+  getSnapshot(): BashTranscriptSnapshot {
+    return {
+      commands: this.commands.map((command) => ({
+        ...command,
+        output: [...command.output],
+      })),
+      totalLines: this.totalLines,
+      totalBytes: this.totalBytes,
+      truncatedCommands: this.truncatedCommands,
+    };
+  }
+
+  private enforceLimits(): void {
+    while (
+      this.commands.length > 1
+      && (this.totalLines > this.settings.transcriptMaxLines || this.totalBytes > this.settings.transcriptMaxBytes)
+    ) {
+      const removed = this.commands.shift();
+      if (!removed) break;
+      this.commandIndex.delete(removed.id);
+      this.totalLines = Math.max(0, this.totalLines - removed.output.length);
+      this.totalBytes = Math.max(0, this.totalBytes - removed.outputBytes);
+      this.truncatedCommands += 1;
+      removed.truncated = true;
+    }
+  }
+}

package/dist/extensions/pi-powerline-footer/bash-mode/types.ts

@@ -0,0 +1,59 @@
+export interface BashModeSettings {
+  toggleShortcut: string;
+  transcriptMaxLines: number;
+  transcriptMaxBytes: number;
+}
+
+export interface BashCommandRecord {
+  id: string;
+  command: string;
+  startedAt: number;
+  cwdAtStart: string;
+  output: string[];
+  outputBytes: number;
+  exitCode: number | null;
+  finishedAt: number | null;
+  truncated: boolean;
+}
+
+export interface BashTranscriptSnapshot {
+  commands: BashCommandRecord[];
+  totalLines: number;
+  totalBytes: number;
+  truncatedCommands: number;
+}
+
+export interface GhostSuggestion {
+  value: string;
+  source:
+    | "project-history"
+    | "global-history"
+    | "git"
+    | "path"
+    | "executable";
+}
+
+export interface ExtendedCompletionItem {
+  value: string;
+  label: string;
+  description?: string;
+  replacement: string;
+  startCol: number;
+  endCol: number;
+  source:
+    | "project-history"
+    | "global-history"
+    | "git"
+    | "path"
+    | "executable";
+  score: number;
+}
+
+export interface ShellSessionState {
+  ready: boolean;
+  running: boolean;
+  shellPath: string;
+  shellName: string;
+  cwd: string;
+  lastExitCode: number | null;
+}

package/dist/extensions/pi-powerline-footer/colors.ts

@@ -0,0 +1,69 @@
+// ANSI escape codes for colors
+// Matching oh-my-pi dark theme colors exactly
+
+export interface AnsiColors {
+  getBgAnsi(r: number, g: number, b: number): string;
+  getFgAnsi(r: number, g: number, b: number): string;
+  getFgAnsi256(code: number): string;
+  reset: string;
+}
+
+export const ansi: AnsiColors = {
+  getBgAnsi: (r, g, b) => `\x1b[48;2;${r};${g};${b}m`,
+  getFgAnsi: (r, g, b) => `\x1b[38;2;${r};${g};${b}m`,
+  getFgAnsi256: (code) => `\x1b[38;5;${code}m`,
+  reset: "\x1b[0m",
+};
+
+// Convert hex to RGB tuple
+function hexToRgb(hex: string): [number, number, number] {
+  const h = hex.replace("#", "");
+  return [
+    parseInt(h.slice(0, 2), 16),
+    parseInt(h.slice(2, 4), 16),
+    parseInt(h.slice(4, 6), 16),
+  ];
+}
+
+// Colors used by welcome/editor chrome rendering
+const THEME = {
+  sep: 244,               // ANSI 256 gray
+  model: "#d787af",       // Pink/mauve
+  path: "#00afaf",        // Teal/cyan
+  gitClean: "#5faf5f",    // Green
+  accent: "#febc38",      // Orange
+};
+
+// Color name to ANSI code mapping
+type ColorName = "sep" | "model" | "path" | "gitClean" | "accent";
+
+function getAnsiCode(color: ColorName): string {
+  const value = THEME[color as keyof typeof THEME];
+  
+  if (value === undefined || value === "") {
+    return ""; // No color, use terminal default
+  }
+  
+  if (typeof value === "number") {
+    return ansi.getFgAnsi256(value);
+  }
+  
+  if (typeof value === "string" && value.startsWith("#")) {
+    const [r, g, b] = hexToRgb(value);
+    return ansi.getFgAnsi(r, g, b);
+  }
+  
+  return "";
+}
+
+// Helper to apply foreground color only (no reset - caller manages reset)
+export function fgOnly(color: ColorName, text: string): string {
+  const code = getAnsiCode(color);
+  return code ? `${code}${text}` : text;
+}
+
+// Get raw ANSI code for a color
+export function getFgAnsiCode(color: ColorName): string {
+  return getAnsiCode(color);
+}
+

package/dist/extensions/pi-powerline-footer/context-usage.ts

@@ -0,0 +1,41 @@
+interface CoreContextUsage {
+  contextTokens: number;
+  contextWindow: number;
+  contextPercent: number;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+export function readCoreContextUsage(ctx: unknown): CoreContextUsage | null {
+  if (!isRecord(ctx) || typeof ctx.getContextUsage !== "function") {
+    return null;
+  }
+
+  const usage = ctx.getContextUsage();
+  if (!isRecord(usage)) {
+    return null;
+  }
+
+  const tokens = usage.tokens;
+  const contextWindow = usage.contextWindow;
+  if (
+    typeof tokens !== "number"
+    || !Number.isFinite(tokens)
+    || typeof contextWindow !== "number"
+    || !Number.isFinite(contextWindow)
+    || contextWindow <= 0
+  ) {
+    return null;
+  }
+
+  const percent = usage.percent;
+  return {
+    contextTokens: tokens,
+    contextWindow,
+    contextPercent: typeof percent === "number" && Number.isFinite(percent)
+      ? percent
+      : (tokens / contextWindow) * 100,
+  };
+}

package/dist/extensions/pi-powerline-footer/fixed-editor/cluster.ts

@@ -0,0 +1,113 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+export const CURSOR_MARKER = "\x1b_pi:c\x07";
+
+export interface FixedEditorClusterInput {
+  width: number;
+  terminalRows: number;
+  statusLines?: string[];
+  topLines?: string[];
+  editorLines: string[];
+  secondaryLines?: string[];
+  transcriptLines?: string[];
+  lastPromptLines?: string[];
+}
+
+export interface FixedEditorCursor {
+  row: number;
+  col: number;
+}
+
+export interface FixedEditorClusterRender {
+  lines: string[];
+  cursor: FixedEditorCursor | null;
+}
+
+function normalizeLines(lines: string[] | undefined, width: number): string[] {
+  if (!lines || width <= 0) return [];
+
+  return lines
+    .filter((line) => line !== undefined && line !== null)
+    .map((line) => visibleWidth(line) > width ? truncateToWidth(line, width, "", true) : line);
+}
+
+function takeTail(lines: string[], count: number): string[] {
+  if (count <= 0) return [];
+  return lines.length <= count ? lines : lines.slice(lines.length - count);
+}
+
+function capEditorLines(lines: string[], count: number): string[] {
+  if (count <= 0) return [];
+  if (lines.length <= count) return lines;
+
+  const cursorRow = lines.findIndex((line) => line.includes(CURSOR_MARKER));
+  if (cursorRow !== -1) {
+    const start = Math.max(0, Math.min(cursorRow - count + 1, lines.length - count));
+    return lines.slice(start, start + count);
+  }
+
+  const selectedRow = lines.findIndex((line) => line.replace(/\x1b\[[0-9;]*m/g, "").trimStart().startsWith("→ "));
+  if (selectedRow === -1) {
+    return lines.slice(0, count);
+  }
+
+  const start = Math.max(0, Math.min(selectedRow - Math.floor(count / 2), lines.length - count));
+  return lines.slice(start, start + count);
+}
+
+function extractCursor(lines: string[]): FixedEditorClusterRender {
+  let cursor: FixedEditorCursor | null = null;
+  const cleaned = lines.map((line, row) => {
+    const markerIndex = line.indexOf(CURSOR_MARKER);
+    if (markerIndex === -1) return line;
+
+    if (!cursor) {
+      cursor = {
+        row,
+        col: visibleWidth(line.slice(0, markerIndex)),
+      };
+    }
+
+    return line.slice(0, markerIndex) + line.slice(markerIndex + CURSOR_MARKER.length);
+  });
+
+  return { lines: cleaned, cursor };
+}
+
+export function renderFixedEditorCluster(input: FixedEditorClusterInput): FixedEditorClusterRender {
+  const width = Math.max(1, input.width);
+  const maxRows = Math.max(1, input.terminalRows - 1);
+
+  const statusLines = normalizeLines(input.statusLines, width);
+  const topLines = normalizeLines(input.topLines, width);
+  const editorSource = normalizeLines(input.editorLines, width);
+  const secondaryLines = normalizeLines(input.secondaryLines, width);
+  const transcriptLines = normalizeLines(input.transcriptLines, width);
+  const lastPromptLines = normalizeLines(input.lastPromptLines, width);
+
+  const editorLines = capEditorLines(editorSource, maxRows);
+  let remaining = maxRows - editorLines.length;
+
+  const top = takeTail(topLines, remaining);
+  remaining -= top.length;
+
+  const secondary = takeTail(secondaryLines, remaining);
+  remaining -= secondary.length;
+
+  const lastPrompt = takeTail(lastPromptLines, remaining);
+  remaining -= lastPrompt.length;
+
+  const status = takeTail(statusLines, remaining);
+  remaining -= status.length;
+
+  const transcript = takeTail(transcriptLines, remaining);
+
+  return extractCursor([
+    ...status,
+    ...top,
+    ...editorLines,
+    ...secondary,
+    ...transcript,
+    ...lastPrompt,
+  ]);
+}