@stackmemoryai/stackmemory 0.5.49 → 0.5.51

package/dist/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/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": "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",
+  "names": []
+}

package/dist/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/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/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

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/features/sweep/status-bar.ts"],
+  "sourcesContent": ["/**\n * Sweep Status Bar\n *\n * Renders a 1-row prediction status bar at the bottom of the terminal\n * using ANSI escape sequences. Preserves cursor position.\n */\n\nimport { basename } from 'path';\n\n// ANSI escape sequences\nconst ESC = '\\x1b';\nconst SAVE_CURSOR = `${ESC}7`;\nconst RESTORE_CURSOR = `${ESC}8`;\nconst CLEAR_LINE = `${ESC}[2K`;\nconst RESET = `${ESC}[0m`;\nconst BG_DARK = `${ESC}[48;5;236m`; // dark gray bg\nconst FG_GRAY = `${ESC}[38;5;244m`; // gray text\nconst FG_CYAN = `${ESC}[38;5;37m`; // cyan for label\nconst FG_DIM = `${ESC}[2m`; // dim\nconst BOLD = `${ESC}[1m`;\n\nfunction moveTo(row: number, col: number): string {\n  return `${ESC}[${row};${col}H`;\n}\n\nexport class StatusBar {\n  private rows: number;\n  private cols: number;\n  private visible = false;\n  private currentPrediction = '';\n  private currentFile = '';\n\n  constructor() {\n    this.rows = process.stdout.rows || 24;\n    this.cols = process.stdout.columns || 80;\n  }\n\n  show(prediction: string, filePath: string, latencyMs: number): void {\n    this.currentPrediction = prediction;\n    this.currentFile = filePath;\n    this.visible = true;\n\n    const file = basename(filePath);\n    const preview = this.truncatePreview(prediction);\n    const latency = `${latencyMs}ms`;\n\n    // Build status bar content\n    const label = `${FG_CYAN}${BOLD}[Sweep]${RESET}${BG_DARK}`;\n    const fileInfo = `${FG_GRAY} ${file}${RESET}${BG_DARK}`;\n    const content = `${FG_GRAY} ${preview}${RESET}${BG_DARK}`;\n    const time = `${FG_DIM}${BG_DARK} ${latency}${RESET}${BG_DARK}`;\n    const keys = `${BOLD}${BG_DARK}  [Tab]${RESET}${BG_DARK}${FG_GRAY} Accept  ${BOLD}${BG_DARK}[Esc]${RESET}${BG_DARK}${FG_GRAY} Dismiss${RESET}`;\n\n    const bar = `${BG_DARK}${label}${fileInfo}${content}${time}${keys}${RESET}`;\n\n    this.render(bar);\n  }\n\n  showLoading(): void {\n    this.visible = true;\n    const bar = `${BG_DARK}${FG_CYAN}${BOLD}[Sweep]${RESET}${BG_DARK}${FG_GRAY} Predicting next edit...${RESET}`;\n    this.render(bar);\n  }\n\n  hide(): void {\n    if (!this.visible) return;\n    this.visible = false;\n    this.currentPrediction = '';\n    this.currentFile = '';\n\n    const output =\n      SAVE_CURSOR + moveTo(this.rows, 1) + CLEAR_LINE + RESTORE_CURSOR;\n\n    process.stdout.write(output);\n  }\n\n  resize(rows: number, cols: number): void {\n    this.rows = rows;\n    this.cols = cols;\n    if (this.visible && this.currentPrediction) {\n      this.show(this.currentPrediction, this.currentFile, 0);\n    }\n  }\n\n  isVisible(): boolean {\n    return this.visible;\n  }\n\n  private render(content: string): void {\n    if (!process.stdout.isTTY) return;\n\n    const output =\n      SAVE_CURSOR +\n      moveTo(this.rows, 1) +\n      CLEAR_LINE +\n      content +\n      RESTORE_CURSOR;\n\n    process.stdout.write(output);\n  }\n\n  private truncatePreview(prediction: string): string {\n    // Take first non-empty line\n    const lines = prediction.trim().split('\\n');\n    let preview = lines[0] || '';\n\n    // Max preview length: cols minus label/keys overhead (~50 chars)\n    const maxLen = Math.max(10, this.cols - 55);\n    if (preview.length > maxLen) {\n      preview = preview.slice(0, maxLen - 3) + '...';\n    }\n\n    // Indicate more lines\n    if (lines.length > 1) {\n      preview += ` (+${lines.length - 1} lines)`;\n    }\n\n    return preview;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/features/sweep/sweep-server-manager.js

@@ -0,0 +1,226 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { spawn, execSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import {
+  DEFAULT_SERVER_CONFIG
+} from "./types.js";
+import { createPredictionClient } from "./prediction-client.js";
+import { logger } from "../../core/monitoring/logger.js";
+const HOME = process.env["HOME"] || "/tmp";
+const PID_FILE = join(HOME, ".stackmemory", "sweep", "server.pid");
+const LOG_FILE = join(HOME, ".stackmemory", "sweep", "server.log");
+class SweepServerManager {
+  config;
+  process = null;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_SERVER_CONFIG, ...config };
+    if (!this.config.modelPath) {
+      this.config.modelPath = join(
+        HOME,
+        ".stackmemory",
+        "models",
+        "sweep",
+        "sweep-next-edit-1.5b.q8_0.v2.gguf"
+      );
+    }
+  }
+  /**
+   * Find llama-server executable
+   */
+  findLlamaServer() {
+    const candidates = [
+      "llama-server",
+      "llama.cpp/llama-server",
+      "/usr/local/bin/llama-server",
+      "/opt/homebrew/bin/llama-server",
+      join(HOME, ".local", "bin", "llama-server")
+    ];
+    for (const cmd of candidates) {
+      try {
+        execSync(`which ${cmd}`, { stdio: "ignore" });
+        return cmd;
+      } catch {
+        if (existsSync(cmd)) {
+          return cmd;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Start the llama-server
+   */
+  async startServer() {
+    const status = await this.getStatus();
+    if (status.running) {
+      return status;
+    }
+    if (!existsSync(this.config.modelPath)) {
+      throw new Error(
+        `Model not found: ${this.config.modelPath}
+Download with: huggingface-cli download sweepai/sweep-next-edit-1.5B sweep-next-edit-1.5b.q8_0.v2.gguf --local-dir ~/.stackmemory/models/sweep`
+      );
+    }
+    const llamaServer = this.findLlamaServer();
+    if (!llamaServer) {
+      throw new Error(
+        "llama-server not found. Install with:\n  brew install llama.cpp\nor build from source: https://github.com/ggerganov/llama.cpp"
+      );
+    }
+    const logDir = dirname(LOG_FILE);
+    if (!existsSync(logDir)) {
+      mkdirSync(logDir, { recursive: true });
+    }
+    const args = [
+      "-m",
+      this.config.modelPath,
+      "--port",
+      String(this.config.port),
+      "--host",
+      this.config.host,
+      "-c",
+      String(this.config.contextSize)
+    ];
+    if (this.config.threads) {
+      args.push("-t", String(this.config.threads));
+    }
+    if (this.config.gpuLayers && this.config.gpuLayers > 0) {
+      args.push("-ngl", String(this.config.gpuLayers));
+    }
+    logger.info("Starting Sweep server", { llamaServer, args });
+    this.process = spawn(llamaServer, args, {
+      detached: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (this.process.pid) {
+      const pidDir = dirname(PID_FILE);
+      if (!existsSync(pidDir)) {
+        mkdirSync(pidDir, { recursive: true });
+      }
+      writeFileSync(
+        PID_FILE,
+        JSON.stringify({
+          pid: this.process.pid,
+          port: this.config.port,
+          host: this.config.host,
+          modelPath: this.config.modelPath,
+          startedAt: Date.now()
+        })
+      );
+    }
+    this.process.unref();
+    const ready = await this.waitForReady(1e4);
+    if (!ready) {
+      await this.stopServer();
+      throw new Error("Server failed to start within timeout");
+    }
+    return this.getStatus();
+  }
+  /**
+   * Wait for server to be ready
+   */
+  async waitForReady(timeoutMs) {
+    const client = createPredictionClient({
+      port: this.config.port,
+      host: this.config.host
+    });
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      if (await client.checkHealth()) {
+        return true;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    return false;
+  }
+  /**
+   * Stop the server
+   */
+  async stopServer() {
+    const status = await this.getStatus();
+    if (!status.running || !status.pid) {
+      return;
+    }
+    try {
+      process.kill(status.pid, "SIGTERM");
+      await new Promise((resolve) => {
+        const checkInterval = setInterval(() => {
+          try {
+            process.kill(status.pid, 0);
+          } catch {
+            clearInterval(checkInterval);
+            resolve();
+          }
+        }, 100);
+        setTimeout(() => {
+          clearInterval(checkInterval);
+          try {
+            process.kill(status.pid, "SIGKILL");
+          } catch {
+          }
+          resolve();
+        }, 5e3);
+      });
+    } catch (error) {
+      logger.warn("Error stopping server", { error });
+    }
+    try {
+      if (existsSync(PID_FILE)) {
+        const { unlinkSync } = await import("fs");
+        unlinkSync(PID_FILE);
+      }
+    } catch {
+    }
+  }
+  /**
+   * Get server status
+   */
+  async getStatus() {
+    if (!existsSync(PID_FILE)) {
+      return { running: false };
+    }
+    try {
+      const data = JSON.parse(readFileSync(PID_FILE, "utf-8"));
+      const { pid, port, host, modelPath, startedAt } = data;
+      try {
+        process.kill(pid, 0);
+      } catch {
+        return { running: false };
+      }
+      const client = createPredictionClient({ port, host });
+      const healthy = await client.checkHealth();
+      return {
+        running: healthy,
+        pid,
+        port,
+        host,
+        modelPath,
+        startedAt
+      };
+    } catch {
+      return { running: false };
+    }
+  }
+  /**
+   * Check server health
+   */
+  async checkHealth() {
+    const client = createPredictionClient({
+      port: this.config.port,
+      host: this.config.host
+    });
+    return client.checkHealth();
+  }
+}
+function createServerManager(config) {
+  return new SweepServerManager(config);
+}
+export {
+  SweepServerManager,
+  createServerManager
+};
+//# sourceMappingURL=sweep-server-manager.js.map

package/dist/features/sweep/sweep-server-manager.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/features/sweep/sweep-server-manager.ts"],
+  "sourcesContent": ["/**\n * Sweep Server Manager\n *\n * Manages the llama-server process for Sweep predictions.\n */\n\nimport { spawn, ChildProcess, execSync } from 'child_process';\nimport { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';\nimport { join, dirname } from 'path';\nimport {\n  SweepServerConfig,\n  SweepServerStatus,\n  DEFAULT_SERVER_CONFIG,\n} from './types.js';\nimport { createPredictionClient } from './prediction-client.js';\nimport { logger } from '../../core/monitoring/logger.js';\n\nconst HOME = process.env['HOME'] || '/tmp';\nconst PID_FILE = join(HOME, '.stackmemory', 'sweep', 'server.pid');\nconst LOG_FILE = join(HOME, '.stackmemory', 'sweep', 'server.log');\n\nexport class SweepServerManager {\n  private config: SweepServerConfig;\n  private process: ChildProcess | null = null;\n\n  constructor(config: Partial<SweepServerConfig> = {}) {\n    this.config = { ...DEFAULT_SERVER_CONFIG, ...config };\n\n    // Set default model path if not provided\n    if (!this.config.modelPath) {\n      this.config.modelPath = join(\n        HOME,\n        '.stackmemory',\n        'models',\n        'sweep',\n        'sweep-next-edit-1.5b.q8_0.v2.gguf'\n      );\n    }\n  }\n\n  /**\n   * Find llama-server executable\n   */\n  private findLlamaServer(): string | null {\n    const candidates = [\n      'llama-server',\n      'llama.cpp/llama-server',\n      '/usr/local/bin/llama-server',\n      '/opt/homebrew/bin/llama-server',\n      join(HOME, '.local', 'bin', 'llama-server'),\n    ];\n\n    for (const cmd of candidates) {\n      try {\n        execSync(`which ${cmd}`, { stdio: 'ignore' });\n        return cmd;\n      } catch {\n        if (existsSync(cmd)) {\n          return cmd;\n        }\n      }\n    }\n\n    return null;\n  }\n\n  /**\n   * Start the llama-server\n   */\n  async startServer(): Promise<SweepServerStatus> {\n    // Check if already running\n    const status = await this.getStatus();\n    if (status.running) {\n      return status;\n    }\n\n    // Check model exists\n    if (!existsSync(this.config.modelPath)) {\n      throw new Error(\n        `Model not found: ${this.config.modelPath}\\n` +\n          'Download with: huggingface-cli download sweepai/sweep-next-edit-1.5B sweep-next-edit-1.5b.q8_0.v2.gguf --local-dir ~/.stackmemory/models/sweep'\n      );\n    }\n\n    // Find llama-server\n    const llamaServer = this.findLlamaServer();\n    if (!llamaServer) {\n      throw new Error(\n        'llama-server not found. Install with:\\n' +\n          '  brew install llama.cpp\\n' +\n          'or build from source: https://github.com/ggerganov/llama.cpp'\n      );\n    }\n\n    // Ensure log directory exists\n    const logDir = dirname(LOG_FILE);\n    if (!existsSync(logDir)) {\n      mkdirSync(logDir, { recursive: true });\n    }\n\n    // Build command args\n    const args = [\n      '-m',\n      this.config.modelPath,\n      '--port',\n      String(this.config.port),\n      '--host',\n      this.config.host,\n      '-c',\n      String(this.config.contextSize),\n    ];\n\n    if (this.config.threads) {\n      args.push('-t', String(this.config.threads));\n    }\n\n    if (this.config.gpuLayers && this.config.gpuLayers > 0) {\n      args.push('-ngl', String(this.config.gpuLayers));\n    }\n\n    logger.info('Starting Sweep server', { llamaServer, args });\n\n    // Start the process\n    this.process = spawn(llamaServer, args, {\n      detached: true,\n      stdio: ['ignore', 'pipe', 'pipe'],\n    });\n\n    // Write PID file\n    if (this.process.pid) {\n      const pidDir = dirname(PID_FILE);\n      if (!existsSync(pidDir)) {\n        mkdirSync(pidDir, { recursive: true });\n      }\n      writeFileSync(\n        PID_FILE,\n        JSON.stringify({\n          pid: this.process.pid,\n          port: this.config.port,\n          host: this.config.host,\n          modelPath: this.config.modelPath,\n          startedAt: Date.now(),\n        })\n      );\n    }\n\n    // Unref to allow parent to exit\n    this.process.unref();\n\n    // Wait for server to be ready\n    const ready = await this.waitForReady(10000);\n    if (!ready) {\n      await this.stopServer();\n      throw new Error('Server failed to start within timeout');\n    }\n\n    return this.getStatus();\n  }\n\n  /**\n   * Wait for server to be ready\n   */\n  private async waitForReady(timeoutMs: number): Promise<boolean> {\n    const client = createPredictionClient({\n      port: this.config.port,\n      host: this.config.host,\n    });\n\n    const startTime = Date.now();\n    while (Date.now() - startTime < timeoutMs) {\n      if (await client.checkHealth()) {\n        return true;\n      }\n      await new Promise((resolve) => setTimeout(resolve, 500));\n    }\n\n    return false;\n  }\n\n  /**\n   * Stop the server\n   */\n  async stopServer(): Promise<void> {\n    const status = await this.getStatus();\n\n    if (!status.running || !status.pid) {\n      return;\n    }\n\n    try {\n      process.kill(status.pid, 'SIGTERM');\n\n      // Wait for process to exit\n      await new Promise<void>((resolve) => {\n        const checkInterval = setInterval(() => {\n          try {\n            process.kill(status.pid!, 0); // Check if still running\n          } catch {\n            clearInterval(checkInterval);\n            resolve();\n          }\n        }, 100);\n\n        // Force kill after 5 seconds\n        setTimeout(() => {\n          clearInterval(checkInterval);\n          try {\n            process.kill(status.pid!, 'SIGKILL');\n          } catch {\n            // Already dead\n          }\n          resolve();\n        }, 5000);\n      });\n    } catch (error) {\n      // Process may already be dead\n      logger.warn('Error stopping server', { error });\n    }\n\n    // Clean up PID file\n    try {\n      if (existsSync(PID_FILE)) {\n        const { unlinkSync } = await import('fs');\n        unlinkSync(PID_FILE);\n      }\n    } catch {\n      // Ignore\n    }\n  }\n\n  /**\n   * Get server status\n   */\n  async getStatus(): Promise<SweepServerStatus> {\n    // Check PID file\n    if (!existsSync(PID_FILE)) {\n      return { running: false };\n    }\n\n    try {\n      const data = JSON.parse(readFileSync(PID_FILE, 'utf-8'));\n      const { pid, port, host, modelPath, startedAt } = data;\n\n      // Check if process is still running\n      try {\n        process.kill(pid, 0);\n      } catch {\n        // Process not running\n        return { running: false };\n      }\n\n      // Verify server is responsive\n      const client = createPredictionClient({ port, host });\n      const healthy = await client.checkHealth();\n\n      return {\n        running: healthy,\n        pid,\n        port,\n        host,\n        modelPath,\n        startedAt,\n      };\n    } catch {\n      return { running: false };\n    }\n  }\n\n  /**\n   * Check server health\n   */\n  async checkHealth(): Promise<boolean> {\n    const client = createPredictionClient({\n      port: this.config.port,\n      host: this.config.host,\n    });\n    return client.checkHealth();\n  }\n}\n\n/**\n * Create a server manager with default config\n */\nexport function createServerManager(\n  config?: Partial<SweepServerConfig>\n): SweepServerManager {\n  return new SweepServerManager(config);\n}\n"],
+  "mappings": "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",
+  "names": []
+}