@stackmemoryai/stackmemory 0.5.59 → 0.5.61

package/dist/features/sweep/prediction-client.js

@@ -1,155 +0,0 @@
-import { fileURLToPath as __fileURLToPath } from 'url';
-import { dirname as __pathDirname } from 'path';
-const __filename = __fileURLToPath(import.meta.url);
-const __dirname = __pathDirname(__filename);
-import {
-  SWEEP_STOP_TOKENS,
-  DEFAULT_SERVER_CONFIG
-} from "./types.js";
-import { buildSweepPrompt } from "./prompt-builder.js";
-class SweepPredictionClient {
-  config;
-  baseUrl;
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_SERVER_CONFIG, ...config };
-    this.baseUrl = `http://${this.config.host}:${this.config.port}`;
-  }
-  /**
-   * Check if the server is healthy
-   */
-  async checkHealth() {
-    try {
-      const response = await fetch(`${this.baseUrl}/health`, {
-        method: "GET",
-        signal: AbortSignal.timeout(2e3)
-      });
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Run a prediction using the Sweep model
-   */
-  async predict(input) {
-    const startTime = Date.now();
-    try {
-      const prompt = buildSweepPrompt({
-        filePath: input.file_path,
-        originalContent: input.original_content || input.current_content,
-        currentContent: input.current_content,
-        recentDiffs: input.recent_diffs || [],
-        contextFiles: input.context_files
-      });
-      const request = {
-        model: "sweep",
-        prompt,
-        max_tokens: input.max_tokens || 2048,
-        temperature: input.temperature || 0.1,
-        top_k: input.top_k || 40,
-        stop: SWEEP_STOP_TOKENS,
-        stream: false
-      };
-      const response = await fetch(`${this.baseUrl}/v1/completions`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(request),
-        signal: AbortSignal.timeout(3e4)
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        return {
-          success: false,
-          error: "server_error",
-          message: `Server returned ${response.status}: ${errorText}`
-        };
-      }
-      const data = await response.json();
-      const latencyMs = Date.now() - startTime;
-      if (!data.choices || data.choices.length === 0) {
-        return {
-          success: false,
-          error: "no_choices",
-          message: "Server returned no completion choices"
-        };
-      }
-      const completionText = data.choices[0].text;
-      if (!completionText || completionText.trim().length === 0) {
-        return {
-          success: true,
-          predicted_content: "",
-          file_path: input.file_path,
-          latency_ms: latencyMs,
-          tokens_generated: 0,
-          message: "No changes predicted"
-        };
-      }
-      return {
-        success: true,
-        predicted_content: completionText,
-        file_path: input.file_path,
-        latency_ms: latencyMs,
-        tokens_generated: data.usage?.completion_tokens || 0
-      };
-    } catch (error) {
-      const latencyMs = Date.now() - startTime;
-      if (error instanceof Error) {
-        if (error.name === "AbortError" || error.name === "TimeoutError") {
-          return {
-            success: false,
-            error: "timeout",
-            message: "Request timed out",
-            latency_ms: latencyMs
-          };
-        }
-        if (error.message.includes("ECONNREFUSED")) {
-          return {
-            success: false,
-            error: "connection_refused",
-            message: "Server not running. Start with: stackmemory sweep start",
-            latency_ms: latencyMs
-          };
-        }
-        return {
-          success: false,
-          error: "request_error",
-          message: error.message,
-          latency_ms: latencyMs
-        };
-      }
-      return {
-        success: false,
-        error: "unknown_error",
-        message: String(error),
-        latency_ms: latencyMs
-      };
-    }
-  }
-  /**
-   * Get server info
-   */
-  async getServerInfo() {
-    try {
-      const response = await fetch(`${this.baseUrl}/v1/models`, {
-        method: "GET",
-        signal: AbortSignal.timeout(2e3)
-      });
-      if (response.ok) {
-        return await response.json();
-      }
-      return null;
-    } catch {
-      return null;
-    }
-  }
-}
-function createPredictionClient(config) {
-  return new SweepPredictionClient(config);
-}
-export {
-  SweepPredictionClient,
-  createPredictionClient
-};
-//# sourceMappingURL=prediction-client.js.map

package/dist/features/sweep/prediction-client.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/features/sweep/prediction-client.ts"],
-  "sourcesContent": ["/**\n * Sweep Prediction Client\n *\n * HTTP client for llama-server's OpenAI-compatible completions API.\n */\n\nimport {\n  SweepServerConfig,\n  SweepPredictInput,\n  SweepPredictResult,\n  CompletionRequest,\n  CompletionResponse,\n  SWEEP_STOP_TOKENS,\n  DEFAULT_SERVER_CONFIG,\n} from './types.js';\nimport { buildSweepPrompt } from './prompt-builder.js';\n\nexport class SweepPredictionClient {\n  private config: SweepServerConfig;\n  private baseUrl: string;\n\n  constructor(config: Partial<SweepServerConfig> = {}) {\n    this.config = { ...DEFAULT_SERVER_CONFIG, ...config };\n    this.baseUrl = `http://${this.config.host}:${this.config.port}`;\n  }\n\n  /**\n   * Check if the server is healthy\n   */\n  async checkHealth(): Promise<boolean> {\n    try {\n      const response = await fetch(`${this.baseUrl}/health`, {\n        method: 'GET',\n        signal: AbortSignal.timeout(2000),\n      });\n      return response.ok;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Run a prediction using the Sweep model\n   */\n  async predict(input: SweepPredictInput): Promise<SweepPredictResult> {\n    const startTime = Date.now();\n\n    try {\n      // Build the prompt\n      const prompt = buildSweepPrompt({\n        filePath: input.file_path,\n        originalContent: input.original_content || input.current_content,\n        currentContent: input.current_content,\n        recentDiffs: input.recent_diffs || [],\n        contextFiles: input.context_files,\n      });\n\n      // Create completion request\n      const request: CompletionRequest = {\n        model: 'sweep',\n        prompt,\n        max_tokens: input.max_tokens || 2048,\n        temperature: input.temperature || 0.1,\n        top_k: input.top_k || 40,\n        stop: SWEEP_STOP_TOKENS,\n        stream: false,\n      };\n\n      // Call the server\n      const response = await fetch(`${this.baseUrl}/v1/completions`, {\n        method: 'POST',\n        headers: {\n          'Content-Type': 'application/json',\n        },\n        body: JSON.stringify(request),\n        signal: AbortSignal.timeout(30000),\n      });\n\n      if (!response.ok) {\n        const errorText = await response.text();\n        return {\n          success: false,\n          error: 'server_error',\n          message: `Server returned ${response.status}: ${errorText}`,\n        };\n      }\n\n      const data = (await response.json()) as CompletionResponse;\n      const latencyMs = Date.now() - startTime;\n\n      if (!data.choices || data.choices.length === 0) {\n        return {\n          success: false,\n          error: 'no_choices',\n          message: 'Server returned no completion choices',\n        };\n      }\n\n      const completionText = data.choices[0].text;\n\n      // Check for empty or whitespace-only completion\n      if (!completionText || completionText.trim().length === 0) {\n        return {\n          success: true,\n          predicted_content: '',\n          file_path: input.file_path,\n          latency_ms: latencyMs,\n          tokens_generated: 0,\n          message: 'No changes predicted',\n        };\n      }\n\n      return {\n        success: true,\n        predicted_content: completionText,\n        file_path: input.file_path,\n        latency_ms: latencyMs,\n        tokens_generated: data.usage?.completion_tokens || 0,\n      };\n    } catch (error) {\n      const latencyMs = Date.now() - startTime;\n\n      if (error instanceof Error) {\n        if (error.name === 'AbortError' || error.name === 'TimeoutError') {\n          return {\n            success: false,\n            error: 'timeout',\n            message: 'Request timed out',\n            latency_ms: latencyMs,\n          };\n        }\n\n        if (error.message.includes('ECONNREFUSED')) {\n          return {\n            success: false,\n            error: 'connection_refused',\n            message: 'Server not running. Start with: stackmemory sweep start',\n            latency_ms: latencyMs,\n          };\n        }\n\n        return {\n          success: false,\n          error: 'request_error',\n          message: error.message,\n          latency_ms: latencyMs,\n        };\n      }\n\n      return {\n        success: false,\n        error: 'unknown_error',\n        message: String(error),\n        latency_ms: latencyMs,\n      };\n    }\n  }\n\n  /**\n   * Get server info\n   */\n  async getServerInfo(): Promise<Record<string, unknown> | null> {\n    try {\n      const response = await fetch(`${this.baseUrl}/v1/models`, {\n        method: 'GET',\n        signal: AbortSignal.timeout(2000),\n      });\n\n      if (response.ok) {\n        return (await response.json()) as Record<string, unknown>;\n      }\n      return null;\n    } catch {\n      return null;\n    }\n  }\n}\n\n/**\n * Create a prediction client with default config\n */\nexport function createPredictionClient(\n  config?: Partial<SweepServerConfig>\n): SweepPredictionClient {\n  return new SweepPredictionClient(config);\n}\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/features/sweep/prompt-builder.js

@@ -1,85 +0,0 @@
-import { fileURLToPath as __fileURLToPath } from 'url';
-import { dirname as __pathDirname } from 'path';
-const __filename = __fileURLToPath(import.meta.url);
-const __dirname = __pathDirname(__filename);
-function buildSweepPrompt(input) {
-  const parts = [];
-  if (input.contextFiles) {
-    for (const [path, content] of Object.entries(input.contextFiles)) {
-      parts.push(`<|file_sep|>${path}`);
-      parts.push(content);
-    }
-  }
-  const diffSection = buildDiffSection(input.recentDiffs);
-  if (diffSection) {
-    parts.push(diffSection);
-  }
-  parts.push(`<|file_sep|>original/${input.filePath}`);
-  parts.push(input.originalContent || input.currentContent);
-  parts.push(`<|file_sep|>current/${input.filePath}`);
-  parts.push(input.currentContent);
-  parts.push(`<|file_sep|>updated/${input.filePath}`);
-  return parts.join("\n");
-}
-function buildDiffSection(diffs) {
-  if (!diffs || diffs.length === 0) {
-    return "";
-  }
-  const parts = [];
-  for (const diff of diffs) {
-    if (!diff.original && !diff.updated) {
-      continue;
-    }
-    parts.push(`<|file_sep|>${diff.file_path}.diff`);
-    parts.push("original:");
-    parts.push(diff.original || "");
-    parts.push("updated:");
-    parts.push(diff.updated || "");
-  }
-  return parts.join("\n");
-}
-function trimContentAroundCursor(lines, cursorLine, cursorCol, maxTokens) {
-  const totalChars = lines.join("\n").length;
-  const estimatedTokens = Math.ceil(totalChars / 4);
-  if (estimatedTokens <= maxTokens) {
-    return { lines, offset: 0, didTrim: false };
-  }
-  const targetChars = maxTokens * 4;
-  const avgLineLength = totalChars / lines.length;
-  const windowSize = Math.floor(targetChars / avgLineLength);
-  const halfWindow = Math.floor(windowSize / 2);
-  let start = Math.max(0, cursorLine - halfWindow);
-  let end = Math.min(lines.length, start + windowSize);
-  if (end === lines.length) {
-    start = Math.max(0, end - windowSize);
-  }
-  return {
-    lines: lines.slice(start, end),
-    offset: start,
-    didTrim: true
-  };
-}
-function parseCompletion(completionText, originalLines, windowStart, windowEnd) {
-  let text = completionText.replace(/<\|file_sep\|>$/, "").replace(/<\/s>$/, "").trimEnd();
-  if (!text || text.trim().length === 0) {
-    return null;
-  }
-  const newLines = text.split("\n");
-  const oldLines = originalLines.slice(windowStart, windowEnd);
-  const oldText = oldLines.join("\n").trimEnd();
-  if (text === oldText) {
-    return null;
-  }
-  return {
-    lines: newLines,
-    startLine: windowStart + 1,
-    // Convert to 1-indexed
-    endLine: windowEnd
-  };
-}
-export {
-  buildSweepPrompt,
-  parseCompletion,
-  trimContentAroundCursor
-};
-//# sourceMappingURL=prompt-builder.js.map

package/dist/features/sweep/prompt-builder.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/features/sweep/prompt-builder.ts"],
-  "sourcesContent": ["/**\n * Sweep Prompt Builder\n *\n * Builds prompts in the Sweep Next-Edit format with <|file_sep|> tokens.\n * Format based on Qwen2.5-Coder pretrained model structure.\n */\n\nimport { SweepPromptInput, DiffEntry } from './types.js';\n\n/**\n * Build a Sweep-format prompt for next-edit prediction\n *\n * Format:\n *   <|file_sep|>{file}.diff\n *   original:\n *   {before}\n *   updated:\n *   {after}\n *   <|file_sep|>original/{file_path}\n *   {original_content}\n *   <|file_sep|>current/{file_path}\n *   {current_content}\n *   <|file_sep|>updated/{file_path}\n */\nexport function buildSweepPrompt(input: SweepPromptInput): string {\n  const parts: string[] = [];\n\n  // Add context files if provided\n  if (input.contextFiles) {\n    for (const [path, content] of Object.entries(input.contextFiles)) {\n      parts.push(`<|file_sep|>${path}`);\n      parts.push(content);\n    }\n  }\n\n  // Add recent diffs section\n  const diffSection = buildDiffSection(input.recentDiffs);\n  if (diffSection) {\n    parts.push(diffSection);\n  }\n\n  // Add original file state\n  parts.push(`<|file_sep|>original/${input.filePath}`);\n  parts.push(input.originalContent || input.currentContent);\n\n  // Add current file state\n  parts.push(`<|file_sep|>current/${input.filePath}`);\n  parts.push(input.currentContent);\n\n  // Add updated marker - model generates from here\n  parts.push(`<|file_sep|>updated/${input.filePath}`);\n\n  return parts.join('\\n');\n}\n\n/**\n * Build the diff history section\n */\nfunction buildDiffSection(diffs: DiffEntry[]): string {\n  if (!diffs || diffs.length === 0) {\n    return '';\n  }\n\n  const parts: string[] = [];\n\n  for (const diff of diffs) {\n    if (!diff.original && !diff.updated) {\n      continue;\n    }\n\n    parts.push(`<|file_sep|>${diff.file_path}.diff`);\n    parts.push('original:');\n    parts.push(diff.original || '');\n    parts.push('updated:');\n    parts.push(diff.updated || '');\n  }\n\n  return parts.join('\\n');\n}\n\n/**\n * Trim content around cursor position to fit token budget\n */\nexport function trimContentAroundCursor(\n  lines: string[],\n  cursorLine: number,\n  cursorCol: number,\n  maxTokens: number\n): { lines: string[]; offset: number; didTrim: boolean } {\n  // Estimate tokens: ~4 chars per token\n  const totalChars = lines.join('\\n').length;\n  const estimatedTokens = Math.ceil(totalChars / 4);\n\n  if (estimatedTokens <= maxTokens) {\n    return { lines, offset: 0, didTrim: false };\n  }\n\n  // Calculate window size based on token budget\n  const targetChars = maxTokens * 4;\n  const avgLineLength = totalChars / lines.length;\n  const windowSize = Math.floor(targetChars / avgLineLength);\n\n  // Center window around cursor\n  const halfWindow = Math.floor(windowSize / 2);\n  let start = Math.max(0, cursorLine - halfWindow);\n  let end = Math.min(lines.length, start + windowSize);\n\n  // Adjust if we hit the end\n  if (end === lines.length) {\n    start = Math.max(0, end - windowSize);\n  }\n\n  return {\n    lines: lines.slice(start, end),\n    offset: start,\n    didTrim: true,\n  };\n}\n\n/**\n * Parse completion text from model output\n */\nexport function parseCompletion(\n  completionText: string,\n  originalLines: string[],\n  windowStart: number,\n  windowEnd: number\n): { lines: string[]; startLine: number; endLine: number } | null {\n  // Strip trailing stop tokens\n  let text = completionText\n    .replace(/<\\|file_sep\\|>$/, '')\n    .replace(/<\\/s>$/, '')\n    .trimEnd();\n\n  if (!text || text.trim().length === 0) {\n    return null;\n  }\n\n  const newLines = text.split('\\n');\n  const oldLines = originalLines.slice(windowStart, windowEnd);\n  const oldText = oldLines.join('\\n').trimEnd();\n\n  // No change if identical\n  if (text === oldText) {\n    return null;\n  }\n\n  return {\n    lines: newLines,\n    startLine: windowStart + 1, // Convert to 1-indexed\n    endLine: windowEnd,\n  };\n}\n"],
-  "mappings": ";;;;AAwBO,SAAS,iBAAiB,OAAiC;AAChE,QAAM,QAAkB,CAAC;AAGzB,MAAI,MAAM,cAAc;AACtB,eAAW,CAAC,MAAM,OAAO,KAAK,OAAO,QAAQ,MAAM,YAAY,GAAG;AAChE,YAAM,KAAK,eAAe,IAAI,EAAE;AAChC,YAAM,KAAK,OAAO;AAAA,IACpB;AAAA,EACF;AAGA,QAAM,cAAc,iBAAiB,MAAM,WAAW;AACtD,MAAI,aAAa;AACf,UAAM,KAAK,WAAW;AAAA,EACxB;AAGA,QAAM,KAAK,wBAAwB,MAAM,QAAQ,EAAE;AACnD,QAAM,KAAK,MAAM,mBAAmB,MAAM,cAAc;AAGxD,QAAM,KAAK,uBAAuB,MAAM,QAAQ,EAAE;AAClD,QAAM,KAAK,MAAM,cAAc;AAG/B,QAAM,KAAK,uBAAuB,MAAM,QAAQ,EAAE;AAElD,SAAO,MAAM,KAAK,IAAI;AACxB;AAKA,SAAS,iBAAiB,OAA4B;AACpD,MAAI,CAAC,SAAS,MAAM,WAAW,GAAG;AAChC,WAAO;AAAA,EACT;AAEA,QAAM,QAAkB,CAAC;AAEzB,aAAW,QAAQ,OAAO;AACxB,QAAI,CAAC,KAAK,YAAY,CAAC,KAAK,SAAS;AACnC;AAAA,IACF;AAEA,UAAM,KAAK,eAAe,KAAK,SAAS,OAAO;AAC/C,UAAM,KAAK,WAAW;AACtB,UAAM,KAAK,KAAK,YAAY,EAAE;AAC9B,UAAM,KAAK,UAAU;AACrB,UAAM,KAAK,KAAK,WAAW,EAAE;AAAA,EAC/B;AAEA,SAAO,MAAM,KAAK,IAAI;AACxB;AAKO,SAAS,wBACd,OACA,YACA,WACA,WACuD;AAEvD,QAAM,aAAa,MAAM,KAAK,IAAI,EAAE;AACpC,QAAM,kBAAkB,KAAK,KAAK,aAAa,CAAC;AAEhD,MAAI,mBAAmB,WAAW;AAChC,WAAO,EAAE,OAAO,QAAQ,GAAG,SAAS,MAAM;AAAA,EAC5C;AAGA,QAAM,cAAc,YAAY;AAChC,QAAM,gBAAgB,aAAa,MAAM;AACzC,QAAM,aAAa,KAAK,MAAM,cAAc,aAAa;AAGzD,QAAM,aAAa,KAAK,MAAM,aAAa,CAAC;AAC5C,MAAI,QAAQ,KAAK,IAAI,GAAG,aAAa,UAAU;AAC/C,MAAI,MAAM,KAAK,IAAI,MAAM,QAAQ,QAAQ,UAAU;AAGnD,MAAI,QAAQ,MAAM,QAAQ;AACxB,YAAQ,KAAK,IAAI,GAAG,MAAM,UAAU;AAAA,EACtC;AAEA,SAAO;AAAA,IACL,OAAO,MAAM,MAAM,OAAO,GAAG;AAAA,IAC7B,QAAQ;AAAA,IACR,SAAS;AAAA,EACX;AACF;AAKO,SAAS,gBACd,gBACA,eACA,aACA,WACgE;AAEhE,MAAI,OAAO,eACR,QAAQ,mBAAmB,EAAE,EAC7B,QAAQ,UAAU,EAAE,EACpB,QAAQ;AAEX,MAAI,CAAC,QAAQ,KAAK,KAAK,EAAE,WAAW,GAAG;AACrC,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,KAAK,MAAM,IAAI;AAChC,QAAM,WAAW,cAAc,MAAM,aAAa,SAAS;AAC3D,QAAM,UAAU,SAAS,KAAK,IAAI,EAAE,QAAQ;AAG5C,MAAI,SAAS,SAAS;AACpB,WAAO;AAAA,EACT;AAEA,SAAO;AAAA,IACL,OAAO;AAAA,IACP,WAAW,cAAc;AAAA;AAAA,IACzB,SAAS;AAAA,EACX;AACF;",
-  "names": []
-}

package/dist/features/sweep/pty-wrapper.js

@@ -1,171 +0,0 @@
-import { fileURLToPath as __fileURLToPath } from 'url';
-import { dirname as __pathDirname } from 'path';
-const __filename = __fileURLToPath(import.meta.url);
-const __dirname = __pathDirname(__filename);
-import { join } from "path";
-import { writeFileSync, existsSync, mkdirSync } from "fs";
-import { execSync } from "child_process";
-import { SweepStateWatcher } from "./state-watcher.js";
-import { StatusBar } from "./status-bar.js";
-import { TabInterceptor } from "./tab-interceptor.js";
-const HOME = process.env["HOME"] || "/tmp";
-const PENDING_FILE = join(HOME, ".stackmemory", "sweep-pending.json");
-const ALT_SCREEN_ENTER = "\x1B[?1049h";
-const ALT_SCREEN_EXIT = "\x1B[?1049l";
-class PtyWrapper {
-  config;
-  stateWatcher;
-  statusBar;
-  tabInterceptor;
-  currentPrediction = null;
-  inAltScreen = false;
-  ptyProcess = null;
-  constructor(config = {}) {
-    this.config = {
-      claudeBin: config.claudeBin || this.findClaude(),
-      claudeArgs: config.claudeArgs || [],
-      stateFile: config.stateFile || join(HOME, ".stackmemory", "sweep-state.json")
-    };
-    this.stateWatcher = new SweepStateWatcher(this.config.stateFile);
-    this.statusBar = new StatusBar();
-    this.tabInterceptor = new TabInterceptor({
-      onAccept: () => this.acceptPrediction(),
-      onDismiss: () => this.dismissPrediction(),
-      onPassthrough: (data) => this.ptyProcess?.write(data.toString("utf-8"))
-    });
-  }
-  async start() {
-    let pty;
-    try {
-      pty = await import("node-pty");
-    } catch {
-      throw new Error(
-        "node-pty is required for the PTY wrapper.\nInstall with: npm install node-pty"
-      );
-    }
-    const cols = process.stdout.columns || 80;
-    const rows = process.stdout.rows || 24;
-    const env = {};
-    for (const [k, v] of Object.entries(process.env)) {
-      if (v !== void 0) env[k] = v;
-    }
-    this.ptyProcess = pty.spawn(this.config.claudeBin, this.config.claudeArgs, {
-      name: process.env["TERM"] || "xterm-256color",
-      cols,
-      rows: rows - 1,
-      cwd: process.cwd(),
-      env
-    });
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(true);
-    }
-    process.stdin.resume();
-    this.ptyProcess.onData((data) => {
-      if (data.includes(ALT_SCREEN_ENTER)) {
-        this.inAltScreen = true;
-        this.statusBar.hide();
-      }
-      if (data.includes(ALT_SCREEN_EXIT)) {
-        this.inAltScreen = false;
-      }
-      process.stdout.write(data);
-    });
-    process.stdin.on("data", (data) => {
-      this.tabInterceptor.process(data);
-    });
-    this.stateWatcher.on("loading", () => {
-      if (!this.inAltScreen) {
-        this.statusBar.showLoading();
-      }
-    });
-    this.stateWatcher.on("prediction", (event) => {
-      this.currentPrediction = event;
-      this.tabInterceptor.setPredictionActive(true);
-      if (!this.inAltScreen) {
-        this.statusBar.show(
-          event.prediction,
-          event.file_path,
-          event.latency_ms
-        );
-      }
-    });
-    this.stateWatcher.start();
-    process.stdout.on("resize", () => {
-      const newCols = process.stdout.columns || 80;
-      const newRows = process.stdout.rows || 24;
-      this.ptyProcess?.resize(newCols, newRows - 1);
-      this.statusBar.resize(newRows, newCols);
-    });
-    this.ptyProcess.onExit(({ exitCode }) => {
-      this.cleanup();
-      process.exit(exitCode);
-    });
-    const onSignal = () => {
-      this.cleanup();
-      process.exit(0);
-    };
-    process.on("SIGINT", onSignal);
-    process.on("SIGTERM", onSignal);
-  }
-  acceptPrediction() {
-    if (!this.currentPrediction || !this.ptyProcess) return;
-    const dir = join(HOME, ".stackmemory");
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-    writeFileSync(
-      PENDING_FILE,
-      JSON.stringify(
-        {
-          file_path: this.currentPrediction.file_path,
-          predicted_content: this.currentPrediction.prediction,
-          timestamp: Date.now()
-        },
-        null,
-        2
-      )
-    );
-    const prompt = `Apply the Sweep prediction from ${PENDING_FILE}
-`;
-    this.ptyProcess.write(prompt);
-    this.dismissPrediction();
-  }
-  dismissPrediction() {
-    this.currentPrediction = null;
-    this.tabInterceptor.setPredictionActive(false);
-    this.statusBar.hide();
-  }
-  cleanup() {
-    this.stateWatcher.stop();
-    this.statusBar.hide();
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(false);
-    }
-    process.stdin.pause();
-  }
-  findClaude() {
-    try {
-      const resolved = execSync("which claude", { encoding: "utf-8" }).trim();
-      if (resolved) return resolved;
-    } catch {
-    }
-    const candidates = [
-      join(HOME, ".bun", "bin", "claude"),
-      "/usr/local/bin/claude",
-      "/opt/homebrew/bin/claude"
-    ];
-    for (const c of candidates) {
-      if (existsSync(c)) return c;
-    }
-    return "claude";
-  }
-}
-async function launchWrapper(config) {
-  const wrapper = new PtyWrapper(config);
-  await wrapper.start();
-}
-export {
-  PtyWrapper,
-  launchWrapper
-};
-//# sourceMappingURL=pty-wrapper.js.map

package/dist/features/sweep/pty-wrapper.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/features/sweep/pty-wrapper.ts"],
-  "sourcesContent": ["/**\n * Sweep PTY Wrapper\n *\n * Wraps Claude Code in a pseudo-terminal to add a Sweep prediction\n * status bar at the bottom of the terminal. Predictions from the\n * PostToolUse hook are displayed via the status bar. Tab to accept,\n * Esc to dismiss.\n */\n\nimport { join } from 'path';\nimport { writeFileSync, existsSync, mkdirSync } from 'fs';\nimport { execSync } from 'child_process';\nimport { SweepStateWatcher, type PredictionEvent } from './state-watcher.js';\nimport { StatusBar } from './status-bar.js';\nimport { TabInterceptor } from './tab-interceptor.js';\n\nconst HOME = process.env['HOME'] || '/tmp';\nconst PENDING_FILE = join(HOME, '.stackmemory', 'sweep-pending.json');\n\n// Alt screen buffer detection\nconst ALT_SCREEN_ENTER = '\\x1b[?1049h';\nconst ALT_SCREEN_EXIT = '\\x1b[?1049l';\n\nexport interface PtyWrapperConfig {\n  claudeBin?: string;\n  claudeArgs?: string[];\n  stateFile?: string;\n}\n\n// Minimal interface for node-pty process to avoid compile-time dep\ninterface PtyProcess {\n  write(data: string): void;\n  resize(cols: number, rows: number): void;\n  onData(cb: (data: string) => void): void;\n  onExit(cb: (e: { exitCode: number }) => void): void;\n  kill(): void;\n}\n\nexport class PtyWrapper {\n  private config: Required<PtyWrapperConfig>;\n  private stateWatcher: SweepStateWatcher;\n  private statusBar: StatusBar;\n  private tabInterceptor: TabInterceptor;\n  private currentPrediction: PredictionEvent | null = null;\n  private inAltScreen = false;\n  private ptyProcess: PtyProcess | null = null;\n\n  constructor(config: PtyWrapperConfig = {}) {\n    this.config = {\n      claudeBin: config.claudeBin || this.findClaude(),\n      claudeArgs: config.claudeArgs || [],\n      stateFile:\n        config.stateFile || join(HOME, '.stackmemory', 'sweep-state.json'),\n    };\n\n    this.stateWatcher = new SweepStateWatcher(this.config.stateFile);\n    this.statusBar = new StatusBar();\n    this.tabInterceptor = new TabInterceptor({\n      onAccept: () => this.acceptPrediction(),\n      onDismiss: () => this.dismissPrediction(),\n      onPassthrough: (data) => this.ptyProcess?.write(data.toString('utf-8')),\n    });\n  }\n\n  async start(): Promise<void> {\n    // Dynamic import for optional dependency\n    let pty: typeof import('node-pty');\n    try {\n      pty = await import('node-pty');\n    } catch {\n      throw new Error(\n        'node-pty is required for the PTY wrapper.\\n' +\n          'Install with: npm install node-pty'\n      );\n    }\n\n    const cols = process.stdout.columns || 80;\n    const rows = process.stdout.rows || 24;\n\n    // Filter undefined values from env\n    const env: Record<string, string> = {};\n    for (const [k, v] of Object.entries(process.env)) {\n      if (v !== undefined) env[k] = v;\n    }\n\n    // Spawn Claude Code in a PTY with 1 row reserved for status bar\n    this.ptyProcess = pty.spawn(this.config.claudeBin, this.config.claudeArgs, {\n      name: process.env['TERM'] || 'xterm-256color',\n      cols,\n      rows: rows - 1,\n      cwd: process.cwd(),\n      env,\n    }) as PtyProcess;\n\n    // Set raw mode on stdin\n    if (process.stdin.isTTY) {\n      process.stdin.setRawMode(true);\n    }\n    process.stdin.resume();\n\n    // PTY stdout -> parent stdout (transparent passthrough)\n    this.ptyProcess.onData((data: string) => {\n      // Detect alt screen buffer transitions\n      if (data.includes(ALT_SCREEN_ENTER)) {\n        this.inAltScreen = true;\n        this.statusBar.hide();\n      }\n      if (data.includes(ALT_SCREEN_EXIT)) {\n        this.inAltScreen = false;\n      }\n\n      process.stdout.write(data);\n    });\n\n    // Parent stdin -> tab interceptor -> PTY\n    process.stdin.on('data', (data: Buffer) => {\n      this.tabInterceptor.process(data);\n    });\n\n    // State watcher -> status bar\n    this.stateWatcher.on('loading', () => {\n      if (!this.inAltScreen) {\n        this.statusBar.showLoading();\n      }\n    });\n\n    this.stateWatcher.on('prediction', (event: PredictionEvent) => {\n      this.currentPrediction = event;\n      this.tabInterceptor.setPredictionActive(true);\n      if (!this.inAltScreen) {\n        this.statusBar.show(\n          event.prediction,\n          event.file_path,\n          event.latency_ms\n        );\n      }\n    });\n\n    this.stateWatcher.start();\n\n    // Handle terminal resize\n    process.stdout.on('resize', () => {\n      const newCols = process.stdout.columns || 80;\n      const newRows = process.stdout.rows || 24;\n      this.ptyProcess?.resize(newCols, newRows - 1);\n      this.statusBar.resize(newRows, newCols);\n    });\n\n    // Handle PTY exit\n    this.ptyProcess.onExit(({ exitCode }) => {\n      this.cleanup();\n      process.exit(exitCode);\n    });\n\n    // Handle signals\n    const onSignal = () => {\n      this.cleanup();\n      process.exit(0);\n    };\n    process.on('SIGINT', onSignal);\n    process.on('SIGTERM', onSignal);\n  }\n\n  private acceptPrediction(): void {\n    if (!this.currentPrediction || !this.ptyProcess) return;\n\n    // Write prediction to pending file for Claude to read\n    const dir = join(HOME, '.stackmemory');\n    if (!existsSync(dir)) {\n      mkdirSync(dir, { recursive: true });\n    }\n    writeFileSync(\n      PENDING_FILE,\n      JSON.stringify(\n        {\n          file_path: this.currentPrediction.file_path,\n          predicted_content: this.currentPrediction.prediction,\n          timestamp: Date.now(),\n        },\n        null,\n        2\n      )\n    );\n\n    // Inject acceptance prompt into PTY stdin.\n    // SAFETY: PENDING_FILE is a constant path, not user-controlled.\n    // The prompt is written to Claude Code's input, which interprets\n    // it as a user message, not as a shell command.\n    const prompt = `Apply the Sweep prediction from ${PENDING_FILE}\\n`;\n    this.ptyProcess.write(prompt);\n\n    this.dismissPrediction();\n  }\n\n  private dismissPrediction(): void {\n    this.currentPrediction = null;\n    this.tabInterceptor.setPredictionActive(false);\n    this.statusBar.hide();\n  }\n\n  private cleanup(): void {\n    this.stateWatcher.stop();\n    this.statusBar.hide();\n\n    if (process.stdin.isTTY) {\n      process.stdin.setRawMode(false);\n    }\n    process.stdin.pause();\n  }\n\n  private findClaude(): string {\n    // Check PATH first via which\n    try {\n      const resolved = execSync('which claude', { encoding: 'utf-8' }).trim();\n      if (resolved) return resolved;\n    } catch {\n      // Not on PATH\n    }\n\n    // Check known locations\n    const candidates = [\n      join(HOME, '.bun', 'bin', 'claude'),\n      '/usr/local/bin/claude',\n      '/opt/homebrew/bin/claude',\n    ];\n\n    for (const c of candidates) {\n      if (existsSync(c)) return c;\n    }\n\n    return 'claude';\n  }\n}\n\n/**\n * Launch the PTY wrapper\n */\nexport async function launchWrapper(config?: PtyWrapperConfig): Promise<void> {\n  const wrapper = new PtyWrapper(config);\n  await wrapper.start();\n}\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/features/sweep/state-watcher.js

@@ -1,87 +0,0 @@
-import { fileURLToPath as __fileURLToPath } from 'url';
-import { dirname as __pathDirname } from 'path';
-const __filename = __fileURLToPath(import.meta.url);
-const __dirname = __pathDirname(__filename);
-import { EventEmitter } from "events";
-import { watch, readFileSync, existsSync } from "fs";
-import { join } from "path";
-const HOME = process.env["HOME"] || "/tmp";
-const DEFAULT_STATE_FILE = join(HOME, ".stackmemory", "sweep-state.json");
-class SweepStateWatcher extends EventEmitter {
-  stateFile;
-  lastPredictionTs = 0;
-  lastPendingTs = 0;
-  watcher = null;
-  debounceTimer = null;
-  pollTimer = null;
-  constructor(stateFile) {
-    super();
-    this.stateFile = stateFile || DEFAULT_STATE_FILE;
-  }
-  start() {
-    if (this.watcher) return;
-    if (!existsSync(this.stateFile)) {
-      this.pollTimer = setInterval(() => {
-        if (existsSync(this.stateFile)) {
-          clearInterval(this.pollTimer);
-          this.pollTimer = null;
-          this.startWatching();
-        }
-      }, 1e3);
-      return;
-    }
-    this.startWatching();
-  }
-  startWatching() {
-    this.readState();
-    this.watcher = watch(this.stateFile, () => {
-      if (this.debounceTimer) clearTimeout(this.debounceTimer);
-      this.debounceTimer = setTimeout(() => this.readState(), 100);
-    });
-    this.watcher.on("error", () => {
-      this.watcher?.close();
-      this.watcher = null;
-      setTimeout(() => this.start(), 1e3);
-    });
-  }
-  readState() {
-    try {
-      if (!existsSync(this.stateFile)) return;
-      const raw = readFileSync(this.stateFile, "utf-8");
-      const state = JSON.parse(raw);
-      if (state.pendingPrediction && state.pendingPrediction !== this.lastPendingTs) {
-        this.lastPendingTs = state.pendingPrediction;
-        this.emit("loading");
-      }
-      if (state.lastPrediction && state.lastPrediction.timestamp > this.lastPredictionTs) {
-        this.lastPredictionTs = state.lastPrediction.timestamp;
-        const event = {
-          file_path: state.lastPrediction.file_path,
-          prediction: state.lastPrediction.prediction,
-          latency_ms: state.lastPrediction.latency_ms,
-          timestamp: state.lastPrediction.timestamp
-        };
-        this.emit("prediction", event);
-      }
-    } catch {
-    }
-  }
-  stop() {
-    if (this.pollTimer) {
-      clearInterval(this.pollTimer);
-      this.pollTimer = null;
-    }
-    if (this.debounceTimer) {
-      clearTimeout(this.debounceTimer);
-      this.debounceTimer = null;
-    }
-    if (this.watcher) {
-      this.watcher.close();
-      this.watcher = null;
-    }
-  }
-}
-export {
-  SweepStateWatcher
-};
-//# sourceMappingURL=state-watcher.js.map

package/dist/features/sweep/state-watcher.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/features/sweep/state-watcher.ts"],
-  "sourcesContent": ["/**\n * Sweep State Watcher\n *\n * Watches sweep-state.json for new predictions via fs.watch.\n * Emits events when predictions arrive or loading begins.\n */\n\nimport { EventEmitter } from 'events';\nimport { watch, readFileSync, existsSync, type FSWatcher } from 'fs';\nimport { join } from 'path';\n\nconst HOME = process.env['HOME'] || '/tmp';\nconst DEFAULT_STATE_FILE = join(HOME, '.stackmemory', 'sweep-state.json');\n\nexport interface PredictionEvent {\n  file_path: string;\n  prediction: string;\n  latency_ms: number;\n  timestamp: number;\n}\n\ninterface SweepState {\n  recentDiffs: Array<{\n    file_path: string;\n    original: string;\n    updated: string;\n    timestamp: number;\n  }>;\n  lastPrediction: {\n    file_path: string;\n    prediction: string;\n    latency_ms: number;\n    timestamp: number;\n  } | null;\n  pendingPrediction: number | null;\n  fileContents: Record<string, unknown>;\n}\n\nexport class SweepStateWatcher extends EventEmitter {\n  private stateFile: string;\n  private lastPredictionTs = 0;\n  private lastPendingTs = 0;\n  private watcher: FSWatcher | null = null;\n  private debounceTimer: ReturnType<typeof setTimeout> | null = null;\n  private pollTimer: ReturnType<typeof setInterval> | null = null;\n\n  constructor(stateFile?: string) {\n    super();\n    this.stateFile = stateFile || DEFAULT_STATE_FILE;\n  }\n\n  start(): void {\n    if (this.watcher) return;\n\n    if (!existsSync(this.stateFile)) {\n      // Poll until file appears\n      this.pollTimer = setInterval(() => {\n        if (existsSync(this.stateFile)) {\n          clearInterval(this.pollTimer!);\n          this.pollTimer = null;\n          this.startWatching();\n        }\n      }, 1000);\n      return;\n    }\n\n    this.startWatching();\n  }\n\n  private startWatching(): void {\n    // Read initial state\n    this.readState();\n\n    this.watcher = watch(this.stateFile, () => {\n      // Debounce rapid writes\n      if (this.debounceTimer) clearTimeout(this.debounceTimer);\n      this.debounceTimer = setTimeout(() => this.readState(), 100);\n    });\n\n    this.watcher.on('error', () => {\n      // File may have been deleted, try to re-watch\n      this.watcher?.close();\n      this.watcher = null;\n      setTimeout(() => this.start(), 1000);\n    });\n  }\n\n  private readState(): void {\n    try {\n      if (!existsSync(this.stateFile)) return;\n\n      const raw = readFileSync(this.stateFile, 'utf-8');\n      const state: SweepState = JSON.parse(raw);\n\n      // Check for new pending prediction (loading state)\n      if (\n        state.pendingPrediction &&\n        state.pendingPrediction !== this.lastPendingTs\n      ) {\n        this.lastPendingTs = state.pendingPrediction;\n        this.emit('loading');\n      }\n\n      // Check for new completed prediction\n      if (\n        state.lastPrediction &&\n        state.lastPrediction.timestamp > this.lastPredictionTs\n      ) {\n        this.lastPredictionTs = state.lastPrediction.timestamp;\n        const event: PredictionEvent = {\n          file_path: state.lastPrediction.file_path,\n          prediction: state.lastPrediction.prediction,\n          latency_ms: state.lastPrediction.latency_ms,\n          timestamp: state.lastPrediction.timestamp,\n        };\n        this.emit('prediction', event);\n      }\n    } catch {\n      // Ignore parse errors from partial writes\n    }\n  }\n\n  stop(): void {\n    if (this.pollTimer) {\n      clearInterval(this.pollTimer);\n      this.pollTimer = null;\n    }\n    if (this.debounceTimer) {\n      clearTimeout(this.debounceTimer);\n      this.debounceTimer = null;\n    }\n    if (this.watcher) {\n      this.watcher.close();\n      this.watcher = null;\n    }\n  }\n}\n"],
-  "mappings": ";;;;AAOA,SAAS,oBAAoB;AAC7B,SAAS,OAAO,cAAc,kBAAkC;AAChE,SAAS,YAAY;AAErB,MAAM,OAAO,QAAQ,IAAI,MAAM,KAAK;AACpC,MAAM,qBAAqB,KAAK,MAAM,gBAAgB,kBAAkB;AA0BjE,MAAM,0BAA0B,aAAa;AAAA,EAC1C;AAAA,EACA,mBAAmB;AAAA,EACnB,gBAAgB;AAAA,EAChB,UAA4B;AAAA,EAC5B,gBAAsD;AAAA,EACtD,YAAmD;AAAA,EAE3D,YAAY,WAAoB;AAC9B,UAAM;AACN,SAAK,YAAY,aAAa;AAAA,EAChC;AAAA,EAEA,QAAc;AACZ,QAAI,KAAK,QAAS;AAElB,QAAI,CAAC,WAAW,KAAK,SAAS,GAAG;AAE/B,WAAK,YAAY,YAAY,MAAM;AACjC,YAAI,WAAW,KAAK,SAAS,GAAG;AAC9B,wBAAc,KAAK,SAAU;AAC7B,eAAK,YAAY;AACjB,eAAK,cAAc;AAAA,QACrB;AAAA,MACF,GAAG,GAAI;AACP;AAAA,IACF;AAEA,SAAK,cAAc;AAAA,EACrB;AAAA,EAEQ,gBAAsB;AAE5B,SAAK,UAAU;AAEf,SAAK,UAAU,MAAM,KAAK,WAAW,MAAM;AAEzC,UAAI,KAAK,cAAe,cAAa,KAAK,aAAa;AACvD,WAAK,gBAAgB,WAAW,MAAM,KAAK,UAAU,GAAG,GAAG;AAAA,IAC7D,CAAC;AAED,SAAK,QAAQ,GAAG,SAAS,MAAM;AAE7B,WAAK,SAAS,MAAM;AACpB,WAAK,UAAU;AACf,iBAAW,MAAM,KAAK,MAAM,GAAG,GAAI;AAAA,IACrC,CAAC;AAAA,EACH;AAAA,EAEQ,YAAkB;AACxB,QAAI;AACF,UAAI,CAAC,WAAW,KAAK,SAAS,EAAG;AAEjC,YAAM,MAAM,aAAa,KAAK,WAAW,OAAO;AAChD,YAAM,QAAoB,KAAK,MAAM,GAAG;AAGxC,UACE,MAAM,qBACN,MAAM,sBAAsB,KAAK,eACjC;AACA,aAAK,gBAAgB,MAAM;AAC3B,aAAK,KAAK,SAAS;AAAA,MACrB;AAGA,UACE,MAAM,kBACN,MAAM,eAAe,YAAY,KAAK,kBACtC;AACA,aAAK,mBAAmB,MAAM,eAAe;AAC7C,cAAM,QAAyB;AAAA,UAC7B,WAAW,MAAM,eAAe;AAAA,UAChC,YAAY,MAAM,eAAe;AAAA,UACjC,YAAY,MAAM,eAAe;AAAA,UACjC,WAAW,MAAM,eAAe;AAAA,QAClC;AACA,aAAK,KAAK,cAAc,KAAK;AAAA,MAC/B;AAAA,IACF,QAAQ;AAAA,IAER;AAAA,EACF;AAAA,EAEA,OAAa;AACX,QAAI,KAAK,WAAW;AAClB,oBAAc,KAAK,SAAS;AAC5B,WAAK,YAAY;AAAA,IACnB;AACA,QAAI,KAAK,eAAe;AACtB,mBAAa,KAAK,aAAa;AAC/B,WAAK,gBAAgB;AAAA,IACvB;AACA,QAAI,KAAK,SAAS;AAChB,WAAK,QAAQ,MAAM;AACnB,WAAK,UAAU;AAAA,IACjB;AAAA,EACF;AACF;",
-  "names": []
-}

package/dist/features/sweep/status-bar.js

@@ -1,88 +0,0 @@
-import { fileURLToPath as __fileURLToPath } from 'url';
-import { dirname as __pathDirname } from 'path';
-const __filename = __fileURLToPath(import.meta.url);
-const __dirname = __pathDirname(__filename);
-import { basename } from "path";
-const ESC = "\x1B";
-const SAVE_CURSOR = `${ESC}7`;
-const RESTORE_CURSOR = `${ESC}8`;
-const CLEAR_LINE = `${ESC}[2K`;
-const RESET = `${ESC}[0m`;
-const BG_DARK = `${ESC}[48;5;236m`;
-const FG_GRAY = `${ESC}[38;5;244m`;
-const FG_CYAN = `${ESC}[38;5;37m`;
-const FG_DIM = `${ESC}[2m`;
-const BOLD = `${ESC}[1m`;
-function moveTo(row, col) {
-  return `${ESC}[${row};${col}H`;
-}
-class StatusBar {
-  rows;
-  cols;
-  visible = false;
-  currentPrediction = "";
-  currentFile = "";
-  constructor() {
-    this.rows = process.stdout.rows || 24;
-    this.cols = process.stdout.columns || 80;
-  }
-  show(prediction, filePath, latencyMs) {
-    this.currentPrediction = prediction;
-    this.currentFile = filePath;
-    this.visible = true;
-    const file = basename(filePath);
-    const preview = this.truncatePreview(prediction);
-    const latency = `${latencyMs}ms`;
-    const label = `${FG_CYAN}${BOLD}[Sweep]${RESET}${BG_DARK}`;
-    const fileInfo = `${FG_GRAY} ${file}${RESET}${BG_DARK}`;
-    const content = `${FG_GRAY} ${preview}${RESET}${BG_DARK}`;
-    const time = `${FG_DIM}${BG_DARK} ${latency}${RESET}${BG_DARK}`;
-    const keys = `${BOLD}${BG_DARK}  [Tab]${RESET}${BG_DARK}${FG_GRAY} Accept  ${BOLD}${BG_DARK}[Esc]${RESET}${BG_DARK}${FG_GRAY} Dismiss${RESET}`;
-    const bar = `${BG_DARK}${label}${fileInfo}${content}${time}${keys}${RESET}`;
-    this.render(bar);
-  }
-  showLoading() {
-    this.visible = true;
-    const bar = `${BG_DARK}${FG_CYAN}${BOLD}[Sweep]${RESET}${BG_DARK}${FG_GRAY} Predicting next edit...${RESET}`;
-    this.render(bar);
-  }
-  hide() {
-    if (!this.visible) return;
-    this.visible = false;
-    this.currentPrediction = "";
-    this.currentFile = "";
-    const output = SAVE_CURSOR + moveTo(this.rows, 1) + CLEAR_LINE + RESTORE_CURSOR;
-    process.stdout.write(output);
-  }
-  resize(rows, cols) {
-    this.rows = rows;
-    this.cols = cols;
-    if (this.visible && this.currentPrediction) {
-      this.show(this.currentPrediction, this.currentFile, 0);
-    }
-  }
-  isVisible() {
-    return this.visible;
-  }
-  render(content) {
-    if (!process.stdout.isTTY) return;
-    const output = SAVE_CURSOR + moveTo(this.rows, 1) + CLEAR_LINE + content + RESTORE_CURSOR;
-    process.stdout.write(output);
-  }
-  truncatePreview(prediction) {
-    const lines = prediction.trim().split("\n");
-    let preview = lines[0] || "";
-    const maxLen = Math.max(10, this.cols - 55);
-    if (preview.length > maxLen) {
-      preview = preview.slice(0, maxLen - 3) + "...";
-    }
-    if (lines.length > 1) {
-      preview += ` (+${lines.length - 1} lines)`;
-    }
-    return preview;
-  }
-}
-export {
-  StatusBar
-};
-//# sourceMappingURL=status-bar.js.map