@selesai/code 0.9.15 → 0.10.0

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

@@ -1,204 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { getAgentPath, getHomeDir } from "../paths.ts";
-
-interface PersistedHistoryEntry {
-  command: string;
-  cwd: string;
-  timestamp: number;
-}
-
-// mode and ctimeMs are part of the fingerprint so permission/ACL transitions
-// (e.g. chmod 000) invalidate the cache even when content is unchanged.
-interface FileFingerprint {
-  ctimeMs: number;
-  mtimeMs: number;
-  mode: number;
-  size: number;
-}
-
-interface CachedHistory<T> extends FileFingerprint {
-  entries: T;
-}
-
-function matchesFingerprint(cached: FileFingerprint, stat: FileFingerprint): boolean {
-  return cached.ctimeMs === stat.ctimeMs
-    && cached.mtimeMs === stat.mtimeMs
-    && cached.mode === stat.mode
-    && cached.size === stat.size;
-}
-
-const projectHistoryCache = new Map<string, CachedHistory<PersistedHistoryEntry[]>>();
-const globalHistoryCache = new Map<string, CachedHistory<string[]>>();
-
-function getHistoryDir(): string {
-  return getAgentPath("powerline-footer", "bash-history");
-}
-
-function projectKey(cwd: string): string {
-  return cwd.replace(/^[/\\]+|[/\\]+$/g, "").replace(/[\\/]+/g, "-") || "root";
-}
-
-function projectHistoryPath(cwd: string): string {
-  return join(getHistoryDir(), `${projectKey(cwd)}.json`);
-}
-
-function normalizePersistedEntries(value: unknown): PersistedHistoryEntry[] {
-  if (!Array.isArray(value)) return [];
-
-  const entries: PersistedHistoryEntry[] = [];
-  for (const entry of value) {
-    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) continue;
-    const command = typeof entry.command === "string" ? entry.command.trim() : "";
-    const cwd = typeof entry.cwd === "string" ? entry.cwd.trim() : "";
-    const timestamp = typeof entry.timestamp === "number" && Number.isFinite(entry.timestamp)
-      ? entry.timestamp
-      : 0;
-    if (!command || !cwd || !timestamp) continue;
-    entries.push({ command, cwd, timestamp });
-  }
-  return entries;
-}
-
-export function readProjectHistory(cwd: string): PersistedHistoryEntry[] {
-  const filePath = projectHistoryPath(cwd);
-  if (!existsSync(filePath)) {
-    projectHistoryCache.delete(filePath);
-    return [];
-  }
-
-  try {
-    const stat = statSync(filePath);
-    const cached = projectHistoryCache.get(filePath);
-    if (cached && matchesFingerprint(cached, stat)) {
-      return cached.entries;
-    }
-
-    const parsed = JSON.parse(readFileSync(filePath, "utf8"));
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return [];
-    const entries = normalizePersistedEntries((parsed as { entries?: unknown }).entries)
-      .sort((a, b) => b.timestamp - a.timestamp);
-    projectHistoryCache.set(filePath, {
-      ctimeMs: stat.ctimeMs,
-      mtimeMs: stat.mtimeMs,
-      mode: stat.mode,
-      size: stat.size,
-      entries,
-    });
-    return entries;
-  } catch (error) {
-    // Project history is a best-effort cache. If it is unreadable or malformed,
-    // bash mode should keep working instead of failing command entry entirely.
-    console.debug(`[powerline-footer] Failed to read bash project history from ${filePath}:`, error);
-    return [];
-  }
-}
-
-export function appendProjectHistory(cwd: string, command: string, entryCwd: string): void {
-  const normalizedCommand = command.trim();
-  if (!normalizedCommand) return;
-
-  const existing = readProjectHistory(cwd);
-  const next: PersistedHistoryEntry[] = [
-    { command: normalizedCommand, cwd: entryCwd, timestamp: Date.now() },
-    ...existing.filter((entry) => entry.command !== normalizedCommand),
-  ]
-    .slice(0, 500)
-    .sort((a, b) => b.timestamp - a.timestamp);
-
-  const filePath = projectHistoryPath(cwd);
-  projectHistoryCache.delete(filePath);
-  try {
-    mkdirSync(dirname(filePath), { recursive: true });
-    writeFileSync(filePath, JSON.stringify({ version: 1, entries: next }, null, 2) + "\n");
-    const stat = statSync(filePath);
-    projectHistoryCache.set(filePath, {
-      ctimeMs: stat.ctimeMs,
-      mtimeMs: stat.mtimeMs,
-      mode: stat.mode,
-      size: stat.size,
-      entries: next,
-    });
-  } catch (error) {
-    // History persistence should never block a successful shell command from completing.
-    console.debug(`[powerline-footer] Failed to persist bash project history to ${filePath}:`, error);
-  }
-}
-
-function parseZshHistoryLine(line: string): string | null {
-  const trimmed = line.trim();
-  if (!trimmed) return null;
-  if (!trimmed.startsWith(":")) return trimmed;
-  const parts = trimmed.split(";");
-  if (parts.length < 2) return null;
-  return parts.slice(1).join(";").trim() || null;
-}
-
-function parseBashHistory(lines: string[]): string[] {
-  return lines.map((line) => line.trim()).filter(Boolean);
-}
-
-function parseFishHistory(raw: string): string[] {
-  const matches = raw.matchAll(/^\s*-\s*cmd:\s*(.+)$/gm);
-  const commands: string[] = [];
-  for (const match of matches) {
-    const command = match[1]?.trim();
-    if (command) commands.push(command);
-  }
-  return commands;
-}
-
-export function readGlobalShellHistory(shellPath: string): string[] {
-  const shellName = shellPath.split("/").pop()?.toLowerCase() ?? "";
-  const home = getHomeDir();
-  const filePath = shellName.includes("fish")
-    ? join(home, ".local", "share", "fish", "fish_history")
-    : process.env.HISTFILE || join(home, shellName.includes("zsh") ? ".zsh_history" : ".bash_history");
-  const cacheKey = `${shellName}\0${filePath}`;
-
-  if (!existsSync(filePath)) {
-    globalHistoryCache.delete(cacheKey);
-    return [];
-  }
-
-  let stat: FileFingerprint | undefined;
-  try {
-    stat = statSync(filePath);
-    const cached = globalHistoryCache.get(cacheKey);
-    if (cached && matchesFingerprint(cached, stat)) {
-      return cached.entries;
-    }
-
-    const raw = readFileSync(filePath, "utf8");
-    const entries = shellName.includes("zsh")
-      ? raw.split("\n").map(parseZshHistoryLine).filter((entry): entry is string => Boolean(entry)).reverse()
-      : shellName.includes("fish")
-        ? parseFishHistory(raw).reverse()
-        : parseBashHistory(raw.split("\n")).reverse();
-    globalHistoryCache.set(cacheKey, { ...stat, entries });
-    return entries;
-  } catch (error) {
-    if (stat) {
-      globalHistoryCache.set(cacheKey, { ...stat, entries: [] });
-      console.debug(`[powerline-footer] Failed to read global shell history for ${shellName}:`, error);
-    }
-    return [];
-  }
-}
-
-export function matchHistoryEntries(entries: string[], prefix: string, limit: number): string[] {
-  const trimmedPrefix = prefix.trim();
-  const seen = new Set<string>();
-  const matches: string[] = [];
-
-  for (const rawEntry of entries) {
-    const entry = rawEntry?.trim();
-    if (!entry || seen.has(entry)) continue;
-    if (trimmedPrefix && !entry.startsWith(trimmedPrefix)) continue;
-    seen.add(entry);
-    matches.push(entry);
-    if (matches.length >= limit) break;
-  }
-
-  return matches;
-}

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

@@ -1,286 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

@@ -1,60 +0,0 @@
-export interface BashModeSettings {
-  toggleShortcut: string | null;
-  completions: boolean;
-  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;
-}