@stackmemoryai/stackmemory 0.5.57 → 0.5.59

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

@@ -0,0 +1,155 @@
+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/src/features/sweep/prediction-client.js.map

@@ -0,0 +1,7 @@
+{
+  "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/src/features/sweep/prompt-builder.js

@@ -0,0 +1,85 @@
+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/src/features/sweep/prompt-builder.js.map

@@ -0,0 +1,7 @@
+{
+  "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/src/features/sweep/pty-wrapper.js

@@ -0,0 +1,171 @@
+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/src/features/sweep/pty-wrapper.js.map

@@ -0,0 +1,7 @@
+{
+  "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": ";;;;AASA,SAAS,YAAY;AACrB,SAAS,eAAe,YAAY,iBAAiB;AACrD,SAAS,gBAAgB;AACzB,SAAS,yBAA+C;AACxD,SAAS,iBAAiB;AAC1B,SAAS,sBAAsB;AAE/B,MAAM,OAAO,QAAQ,IAAI,MAAM,KAAK;AACpC,MAAM,eAAe,KAAK,MAAM,gBAAgB,oBAAoB;AAGpE,MAAM,mBAAmB;AACzB,MAAM,kBAAkB;AAiBjB,MAAM,WAAW;AAAA,EACd;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,oBAA4C;AAAA,EAC5C,cAAc;AAAA,EACd,aAAgC;AAAA,EAExC,YAAY,SAA2B,CAAC,GAAG;AACzC,SAAK,SAAS;AAAA,MACZ,WAAW,OAAO,aAAa,KAAK,WAAW;AAAA,MAC/C,YAAY,OAAO,cAAc,CAAC;AAAA,MAClC,WACE,OAAO,aAAa,KAAK,MAAM,gBAAgB,kBAAkB;AAAA,IACrE;AAEA,SAAK,eAAe,IAAI,kBAAkB,KAAK,OAAO,SAAS;AAC/D,SAAK,YAAY,IAAI,UAAU;AAC/B,SAAK,iBAAiB,IAAI,eAAe;AAAA,MACvC,UAAU,MAAM,KAAK,iBAAiB;AAAA,MACtC,WAAW,MAAM,KAAK,kBAAkB;AAAA,MACxC,eAAe,CAAC,SAAS,KAAK,YAAY,MAAM,KAAK,SAAS,OAAO,CAAC;AAAA,IACxE,CAAC;AAAA,EACH;AAAA,EAEA,MAAM,QAAuB;AAE3B,QAAI;AACJ,QAAI;AACF,YAAM,MAAM,OAAO,UAAU;AAAA,IAC/B,QAAQ;AACN,YAAM,IAAI;AAAA,QACR;AAAA,MAEF;AAAA,IACF;AAEA,UAAM,OAAO,QAAQ,OAAO,WAAW;AACvC,UAAM,OAAO,QAAQ,OAAO,QAAQ;AAGpC,UAAM,MAA8B,CAAC;AACrC,eAAW,CAAC,GAAG,CAAC,KAAK,OAAO,QAAQ,QAAQ,GAAG,GAAG;AAChD,UAAI,MAAM,OAAW,KAAI,CAAC,IAAI;AAAA,IAChC;AAGA,SAAK,aAAa,IAAI,MAAM,KAAK,OAAO,WAAW,KAAK,OAAO,YAAY;AAAA,MACzE,MAAM,QAAQ,IAAI,MAAM,KAAK;AAAA,MAC7B;AAAA,MACA,MAAM,OAAO;AAAA,MACb,KAAK,QAAQ,IAAI;AAAA,MACjB;AAAA,IACF,CAAC;AAGD,QAAI,QAAQ,MAAM,OAAO;AACvB,cAAQ,MAAM,WAAW,IAAI;AAAA,IAC/B;AACA,YAAQ,MAAM,OAAO;AAGrB,SAAK,WAAW,OAAO,CAAC,SAAiB;AAEvC,UAAI,KAAK,SAAS,gBAAgB,GAAG;AACnC,aAAK,cAAc;AACnB,aAAK,UAAU,KAAK;AAAA,MACtB;AACA,UAAI,KAAK,SAAS,eAAe,GAAG;AAClC,aAAK,cAAc;AAAA,MACrB;AAEA,cAAQ,OAAO,MAAM,IAAI;AAAA,IAC3B,CAAC;AAGD,YAAQ,MAAM,GAAG,QAAQ,CAAC,SAAiB;AACzC,WAAK,eAAe,QAAQ,IAAI;AAAA,IAClC,CAAC;AAGD,SAAK,aAAa,GAAG,WAAW,MAAM;AACpC,UAAI,CAAC,KAAK,aAAa;AACrB,aAAK,UAAU,YAAY;AAAA,MAC7B;AAAA,IACF,CAAC;AAED,SAAK,aAAa,GAAG,cAAc,CAAC,UAA2B;AAC7D,WAAK,oBAAoB;AACzB,WAAK,eAAe,oBAAoB,IAAI;AAC5C,UAAI,CAAC,KAAK,aAAa;AACrB,aAAK,UAAU;AAAA,UACb,MAAM;AAAA,UACN,MAAM;AAAA,UACN,MAAM;AAAA,QACR;AAAA,MACF;AAAA,IACF,CAAC;AAED,SAAK,aAAa,MAAM;AAGxB,YAAQ,OAAO,GAAG,UAAU,MAAM;AAChC,YAAM,UAAU,QAAQ,OAAO,WAAW;AAC1C,YAAM,UAAU,QAAQ,OAAO,QAAQ;AACvC,WAAK,YAAY,OAAO,SAAS,UAAU,CAAC;AAC5C,WAAK,UAAU,OAAO,SAAS,OAAO;AAAA,IACxC,CAAC;AAGD,SAAK,WAAW,OAAO,CAAC,EAAE,SAAS,MAAM;AACvC,WAAK,QAAQ;AACb,cAAQ,KAAK,QAAQ;AAAA,IACvB,CAAC;AAGD,UAAM,WAAW,MAAM;AACrB,WAAK,QAAQ;AACb,cAAQ,KAAK,CAAC;AAAA,IAChB;AACA,YAAQ,GAAG,UAAU,QAAQ;AAC7B,YAAQ,GAAG,WAAW,QAAQ;AAAA,EAChC;AAAA,EAEQ,mBAAyB;AAC/B,QAAI,CAAC,KAAK,qBAAqB,CAAC,KAAK,WAAY;AAGjD,UAAM,MAAM,KAAK,MAAM,cAAc;AACrC,QAAI,CAAC,WAAW,GAAG,GAAG;AACpB,gBAAU,KAAK,EAAE,WAAW,KAAK,CAAC;AAAA,IACpC;AACA;AAAA,MACE;AAAA,MACA,KAAK;AAAA,QACH;AAAA,UACE,WAAW,KAAK,kBAAkB;AAAA,UAClC,mBAAmB,KAAK,kBAAkB;AAAA,UAC1C,WAAW,KAAK,IAAI;AAAA,QACtB;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAMA,UAAM,SAAS,mCAAmC,YAAY;AAAA;AAC9D,SAAK,WAAW,MAAM,MAAM;AAE5B,SAAK,kBAAkB;AAAA,EACzB;AAAA,EAEQ,oBAA0B;AAChC,SAAK,oBAAoB;AACzB,SAAK,eAAe,oBAAoB,KAAK;AAC7C,SAAK,UAAU,KAAK;AAAA,EACtB;AAAA,EAEQ,UAAgB;AACtB,SAAK,aAAa,KAAK;AACvB,SAAK,UAAU,KAAK;AAEpB,QAAI,QAAQ,MAAM,OAAO;AACvB,cAAQ,MAAM,WAAW,KAAK;AAAA,IAChC;AACA,YAAQ,MAAM,MAAM;AAAA,EACtB;AAAA,EAEQ,aAAqB;AAE3B,QAAI;AACF,YAAM,WAAW,SAAS,gBAAgB,EAAE,UAAU,QAAQ,CAAC,EAAE,KAAK;AACtE,UAAI,SAAU,QAAO;AAAA,IACvB,QAAQ;AAAA,IAER;AAGA,UAAM,aAAa;AAAA,MACjB,KAAK,MAAM,QAAQ,OAAO,QAAQ;AAAA,MAClC;AAAA,MACA;AAAA,IACF;AAEA,eAAW,KAAK,YAAY;AAC1B,UAAI,WAAW,CAAC,EAAG,QAAO;AAAA,IAC5B;AAEA,WAAO;AAAA,EACT;AACF;AAKA,eAAsB,cAAc,QAA0C;AAC5E,QAAM,UAAU,IAAI,WAAW,MAAM;AACrC,QAAM,QAAQ,MAAM;AACtB;",
+  "names": []
+}

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

@@ -0,0 +1,87 @@
+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/src/features/sweep/state-watcher.js.map

@@ -0,0 +1,7 @@
+{
+  "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/src/features/sweep/status-bar.js

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