@groeponline/pi-wishcraft 0.17.3

package/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/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/bash-mode/types.ts

@@ -0,0 +1,80 @@
+import type { KeybindingsManager } from "@earendil-works/pi-coding-agent";
+
+import type { EditorBoundaryShortcuts } from "./editor-input.ts";
+
+export interface BashModeSettings {
+  toggleShortcut: string | null;
+  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;
+}
+
+export interface BashModeEditorOptions {
+  keybindings: KeybindingsManager;
+  isBashModeActive: () => boolean;
+  isShellRunning: () => boolean;
+  onExitBashMode: () => void;
+  onSubmitCommand: (command: string) => void;
+  onEditorSubmit?: () => void;
+  editorBoundaryShortcuts?: EditorBoundaryShortcuts;
+  onInterrupt: () => void;
+  onNotify: (message: string, level?: "info" | "warning" | "error") => void;
+  getHistoryEntries: (prefix: string) => string[];
+  resolveGhostSuggestion: (
+    text: string,
+    signal: AbortSignal,
+  ) => Promise<GhostSuggestion | null>;
+}

package/index.ts

@@ -0,0 +1,6 @@
+export { default } from "./src/extension/activate.ts";
+export {
+  parseBashModeSettings,
+  resolveShortcutConfig,
+} from "./src/extension/shortcuts-config.ts";
+export type { PowerlineShortcuts } from "./src/extension/types.ts";

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@groeponline/pi-wishcraft",
+  "version": "0.17.3",
+  "description": "Wishcraft status bar & interaction layer for the pi coding agent — powerline segments, vibes, queue, bash mode, and full customization.",
+  "type": "module",
+  "files": [
+    "*.ts",
+    "*.md",
+    "*.json",
+    "src/**/*.ts",
+    "src/**/*.md",
+    "src/**/*.txt",
+    "bash-mode/**/*.ts",
+    "queue/**/*.ts"
+  ],
+  "keywords": [
+    "pi-package",
+    "pi",
+    "coding-agent",
+    "powerline",
+    "status-bar",
+    "extension"
+  ],
+  "author": "Nico Bailon",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GroepOnline/pi-wishcraft.git"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "node --experimental-strip-types --test tests/**/*.test.ts",
+    "release": "node scripts/release.mjs",
+    "prepublishOnly": "tsc --noEmit",
+    "circular": "madge --circular src index.ts bash-mode queue"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": ">=0.81.0 <0.85.0",
+    "@earendil-works/pi-coding-agent": ">=0.81.0 <0.85.0",
+    "@earendil-works/pi-tui": ">=0.81.0 <0.85.0"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-ai": "^0.84.0",
+    "@earendil-works/pi-coding-agent": "^0.84.0",
+    "@earendil-works/pi-tui": "^0.84.0",
+    "@types/node": "24.13.3",
+    "madge": "^8.0.0",
+    "typescript": "5.9.3"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}