nlm-memory 0.4.2 → 0.5.1

package/src/install/ollama.ts

@@ -1,211 +0,0 @@
-/**
- * Ollama preflight helpers for `nlm setup`.
- *
- * Three cases handled:
- *   1. Ollama not installed     → install it
- *   2. Ollama installed, server not responding → start the server
- *   3. Embedding model missing  → pull it
- *
- * Platform support:
- *   macOS  — brew install / Ollama.app / brew services / open -a
- *   Linux  — official install.sh / systemctl / detached spawn
- *   Windows — winget install / detached spawn
- */
-
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir, platform } from "node:os";
-import { join } from "node:path";
-import { spawnSync, spawn } from "node:child_process";
-
-export const EMBEDDING_MODEL = "nomic-embed-text";
-const OS = platform();
-
-export interface OllamaResult {
-  readonly ok: boolean;
-  readonly output: string;
-}
-
-// ── Detection ─────────────────────────────────────────────────────────────
-
-export function ollamaBinaryAvailable(): boolean {
-  const r = spawnSync("ollama", ["--version"], { encoding: "utf8" });
-  return r.status === 0;
-}
-
-/** Returns true if the Ollama server is accepting API requests. */
-export function ollamaServerRunning(): boolean {
-  const r = spawnSync("ollama", ["list"], { encoding: "utf8" });
-  return r.status === 0;
-}
-
-/** Returns true if nomic-embed-text is present in `ollama list`. */
-export function embeddingModelPresent(): boolean {
-  const r = spawnSync("ollama", ["list"], { encoding: "utf8" });
-  if (r.status !== 0) return false;
-  return r.stdout.includes(EMBEDDING_MODEL);
-}
-
-function brewAvailable(): boolean {
-  return spawnSync("brew", ["--version"], { encoding: "utf8" }).status === 0;
-}
-
-function ollamaAppInstalled(): boolean {
-  return existsSync("/Applications/Ollama.app");
-}
-
-function wingetAvailable(): boolean {
-  return spawnSync("winget", ["--version"], { encoding: "utf8", shell: true }).status === 0;
-}
-
-function systemctlAvailable(): boolean {
-  return spawnSync("systemctl", ["--version"], { encoding: "utf8" }).status === 0;
-}
-
-// ── Install ───────────────────────────────────────────────────────────────
-
-/**
- * Install Ollama using the best available method for the current platform.
- * Returns { ok: false } if no automated path exists — caller shows manual instructions.
- */
-export function installOllama(): OllamaResult {
-  if (OS === "darwin") {
-    if (brewAvailable()) {
-      const r = spawnSync("brew", ["install", "ollama"], { encoding: "utf8" });
-      return { ok: r.status === 0, output: (r.stdout + r.stderr).trim() };
-    }
-    return {
-      ok: false,
-      output: "Homebrew not found. Download Ollama from https://ollama.com/download and re-run setup.",
-    };
-  }
-
-  if (OS === "linux") {
-    // Runs: curl -fsSL https://ollama.com/install.sh | sh
-    // The official Ollama installer — sets up the binary and a systemd service.
-    // Requires sudo internally and may modify /etc/systemd/. The caller is
-    // responsible for confirming this with the user before calling.
-    const r = spawnSync("sh", ["-c", "curl -fsSL --proto '=https' https://ollama.com/install.sh | sh"], {
-      encoding: "utf8",
-      timeout: 120_000,
-    });
-    return { ok: r.status === 0, output: (r.stdout + r.stderr).trim() };
-  }
-
-  if (OS === "win32") {
-    if (wingetAvailable()) {
-      const r = spawnSync("winget", ["install", "Ollama.Ollama"], { encoding: "utf8", shell: true });
-      return { ok: r.status === 0, output: (r.stdout + r.stderr).trim() };
-    }
-    return {
-      ok: false,
-      output: "Download Ollama from https://ollama.com/download and re-run setup.",
-    };
-  }
-
-  return { ok: false, output: `Unsupported platform: ${OS}. Install from https://ollama.com/download.` };
-}
-
-// ── Server start ──────────────────────────────────────────────────────────
-
-/**
- * Start the Ollama server in the background.
- *
- * Platform preference:
- *   macOS + brew    → brew services start ollama
- *   macOS + app     → open -a Ollama
- *   Linux + systemd → systemctl start ollama (needs sudo; falls back to spawn)
- *   All others      → detached spawn of `ollama serve`
- */
-export function startOllamaServer(): OllamaResult {
-  if (OS === "darwin") {
-    if (brewAvailable()) {
-      const r = spawnSync("brew", ["services", "start", "ollama"], { encoding: "utf8" });
-      if (r.status === 0) return { ok: true, output: "Started via brew services" };
-    }
-    if (ollamaAppInstalled()) {
-      const r = spawnSync("open", ["-a", "Ollama"], { encoding: "utf8" });
-      if (r.status === 0) return { ok: true, output: "Started via Ollama.app" };
-    }
-  }
-
-  if (OS === "linux" && systemctlAvailable()) {
-    // systemctl requires root — try without sudo first (works in user sessions
-    // where the service is installed under the current user), fall through on failure.
-    const r = spawnSync("systemctl", ["start", "ollama"], { encoding: "utf8" });
-    if (r.status === 0) return { ok: true, output: "Started via systemctl" };
-  }
-
-  // Universal fallback: detach `ollama serve`.
-  try {
-    mkdirSync(join(homedir(), ".nlm", "logs"), { recursive: true });
-    const child = spawn("ollama", ["serve"], {
-      detached: true,
-      stdio: "ignore",
-    });
-    child.unref();
-    return { ok: true, output: `ollama serve started (pid ${child.pid})` };
-  } catch (e) {
-    return { ok: false, output: e instanceof Error ? e.message : String(e) };
-  }
-}
-
-/**
- * Poll until the Ollama server is accepting requests or maxAttempts is reached.
- * Returns true if the server came up, false on timeout.
- */
-export async function waitForOllamaServer(
-  maxAttempts = 15,
-  intervalMs = 1000,
-): Promise<boolean> {
-  for (let i = 0; i < maxAttempts; i++) {
-    if (ollamaServerRunning()) return true;
-    await new Promise((res) => setTimeout(res, intervalMs));
-  }
-  return false;
-}
-
-// ── Model pull ────────────────────────────────────────────────────────────
-
-/**
- * Pull the embedding model. Blocks until complete (~1–3 min on first run, a
- * few seconds on subsequent runs). The caller shows a spinner during this call.
- */
-export function pullEmbeddingModel(): OllamaResult {
-  // Give the server a moment to accept connections if it was just started.
-  const r = spawnSync("ollama", ["pull", EMBEDDING_MODEL], { encoding: "utf8" });
-  return { ok: r.status === 0, output: (r.stdout + r.stderr).trim() };
-}
-
-// ── API key / classifier config ───────────────────────────────────────────
-
-export type ClassifierChoice = "deepseek" | "ollama-offline";
-
-/**
- * Write classifier config to ~/.nlm/.env. Merges into the existing file —
- * only the lines we manage are updated; anything the user added by hand stays.
- */
-export function writeClassifierConfig(choice: ClassifierChoice, apiKey?: string): void {
-  const envPath = join(homedir(), ".nlm", ".env");
-  const nlmDir = join(homedir(), ".nlm");
-  mkdirSync(nlmDir, { recursive: true, mode: 0o700 });
-  chmodSync(nlmDir, 0o700);
-
-  const existing = existsSync(envPath) ? readFileSync(envPath, "utf8") : "";
-  const kept = existing
-    .split("\n")
-    .filter((l) => !l.startsWith("DEEPSEEK_API_KEY=") && !l.startsWith("NLM_CLASSIFIER="))
-    .join("\n")
-    .replace(/\n{3,}/g, "\n\n")
-    .trim();
-
-  const additions: string[] = [];
-  if (choice === "deepseek" && apiKey) {
-    // Strip newlines that clipboard paste can introduce.
-    const sanitized = apiKey.replace(/[\r\n]/g, "").trim();
-    additions.push(`DEEPSEEK_API_KEY=${sanitized}`);
-  }
-  if (choice === "ollama-offline") additions.push("NLM_CLASSIFIER=ollama");
-
-  writeFileSync(envPath, [kept, ...additions].filter(Boolean).join("\n") + "\n", { mode: 0o600 });
-  chmodSync(envPath, 0o600);
-}

package/src/install/setup.ts

@@ -1,368 +0,0 @@
-/**
- * `nlm setup` — interactive first-run wizard.
- *
- * Step order:
- *   1. Select runtimes
- *   2. Ollama preflight (install → start server → pull embedding model)
- *   3. Classifier API key
- *   4. DB migrations
- *   5. Daemon (LaunchAgent on macOS / systemd hint on Linux / Task Scheduler hint on Windows)
- *   6. Per-runtime MCP + hook wiring
- */
-
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { execFileSync } from "node:child_process";
-import { homedir, platform } from "node:os";
-import { join } from "node:path";
-import {
-  cancel, confirm, intro, isCancel, log, multiselect, outro, password, select, spinner,
-} from "@clack/prompts";
-import { connectClaudeCode } from "./claude-code.js";
-import { connectHermes } from "./hermes.js";
-import { codexBinaryAvailable, connectCodex, pluginScriptsDir } from "./codex.js";
-import { defaultDbPath as openCodeDefaultDbPath } from "../core/adapters/opencode.js";
-import type { ClaudeHookEvent } from "../core/hook/claude-settings.js";
-import {
-  type ClassifierChoice,
-  EMBEDDING_MODEL,
-  embeddingModelPresent,
-  installOllama,
-  ollamaBinaryAvailable,
-  ollamaServerRunning,
-  pullEmbeddingModel,
-  startOllamaServer,
-  waitForOllamaServer,
-  writeClassifierConfig,
-} from "./ollama.js";
-import { installClaudeCodeHooks } from "./claude-code.js";
-
-const OS = platform();
-
-export interface SetupOptions {
-  readonly nlmBinPath: string;
-  readonly nodeExecPath: string;
-  readonly migrationsDir: string;
-  readonly repoRoot: string;
-  readonly dbPath: string;
-  readonly launchAgentLabel: string;
-  readonly launchAgentPlist: string;
-  readonly buildPlist: (nodeExec: string, binPath: string) => string;
-  readonly claudeSettingsPath: string;
-  readonly allHooks: ReadonlyArray<{
-    event: ClaudeHookEvent;
-    script: string;
-    label: string;
-  }>;
-  readonly addHook: (path: string, command: string, event?: ClaudeHookEvent) => void;
-  readonly removeHook: (path: string, event?: ClaudeHookEvent | "*") => void;
-  readonly buildHookCommand: (nodeExec: string, script: string, mode: "shadow" | "live") => string;
-  readonly smokeTestHookCommand: (command: string, logPath: string) => { ok: boolean; reason?: string; stderr?: string };
-}
-
-type RuntimeId = "claude-code" | "codex" | "opencode" | "hermes" | "pi";
-
-interface RuntimeOption {
-  readonly id: RuntimeId;
-  readonly label: string;
-  readonly hint: string;
-  readonly detected: boolean;
-}
-
-function detectRuntimes(): RuntimeOption[] {
-  const claudeProjectsPath = process.env["NLM_CLAUDE_PROJECTS_PATH"]
-    ?? join(homedir(), ".claude", "projects");
-  const hermesPath = process.env["NLM_HERMES_SESSIONS_PATH"]
-    ?? join(homedir(), ".hermes", "sessions");
-  const piPath = process.env["PI_SESSIONS_PATH"]
-    ?? join(homedir(), ".pi", "agent", "sessions");
-  const openCodeDb = openCodeDefaultDbPath();
-
-  return [
-    {
-      id: "claude-code",
-      label: "Claude Code",
-      hint: existsSync(claudeProjectsPath) ? "detected" : "not found",
-      detected: existsSync(claudeProjectsPath),
-    },
-    {
-      id: "codex",
-      label: "Codex (OpenAI)",
-      hint: codexBinaryAvailable() ? "detected" : "not found — install: npm i -g @openai/codex",
-      detected: codexBinaryAvailable(),
-    },
-    {
-      id: "opencode",
-      label: "OpenCode (sst)",
-      hint: existsSync(openCodeDb) ? "detected" : "not found",
-      detected: existsSync(openCodeDb),
-    },
-    {
-      id: "hermes",
-      label: "Hermes",
-      hint: existsSync(hermesPath) ? "detected" : "not found",
-      detected: existsSync(hermesPath),
-    },
-    {
-      id: "pi",
-      label: "pi.dev",
-      hint: existsSync(piPath) ? "detected" : "not found",
-      detected: existsSync(piPath),
-    },
-  ];
-}
-
-export async function runSetup(opts: SetupOptions): Promise<void> {
-  intro("NLM Memory — first-run setup");
-
-  // ── Step 1: runtime selection ─────────────────────────────────────────
-  const runtimes = detectRuntimes();
-  const detectedIds = runtimes.filter((r) => r.detected).map((r) => r.id);
-
-  const selected = await multiselect<RuntimeId>({
-    message: "Which AI coding runtimes do you use?",
-    options: runtimes.map((r) => ({ value: r.id, label: r.label, hint: r.hint })),
-    initialValues: detectedIds,
-    required: false,
-  });
-  if (isCancel(selected)) { cancel("Setup cancelled."); process.exit(0); }
-  const chosen = selected as RuntimeId[];
-
-  // ── Step 2: Ollama preflight ──────────────────────────────────────────
-  if (!ollamaBinaryAvailable()) {
-    const installMsg = OS === "linux"
-      ? "Ollama not found. Install now? (runs the official install.sh as current user — see https://ollama.com/install.sh)"
-      : "Ollama not found. Install it now? (required for memory indexing)";
-    const doInstall = await confirm({ message: installMsg });
-    if (isCancel(doInstall)) { cancel("Setup cancelled."); process.exit(0); }
-
-    if (doInstall) {
-      const is = spinner();
-      is.start("Installing Ollama");
-      const result = installOllama();
-      if (result.ok) {
-        is.stop("Ollama installed");
-      } else {
-        is.stop("Ollama install failed");
-        log.warn(result.output);
-        log.warn("Install Ollama manually from https://ollama.com/download, then re-run `nlm setup`.");
-      }
-    } else {
-      log.warn("Skipping Ollama install — memory indexing won't work until Ollama is running with nomic-embed-text.");
-    }
-  }
-
-  // Ensure server is running before attempting pull.
-  if (ollamaBinaryAvailable() && !ollamaServerRunning()) {
-    const ss = spinner();
-    ss.start("Starting Ollama server");
-    const result = startOllamaServer();
-    if (result.ok) {
-      ss.start("Waiting for Ollama server to accept connections");
-      const ready = await waitForOllamaServer(15, 1000);
-      if (ready) {
-        ss.stop("Ollama server ready");
-      } else {
-        ss.stop("Ollama server started but not responding yet");
-        log.warn("If the model pull fails, wait a moment and run `ollama pull nomic-embed-text` manually.");
-      }
-    } else {
-      ss.stop("Could not start Ollama server automatically");
-      log.warn(`Start it manually with \`ollama serve\`, then re-run \`nlm setup\`. (${result.output})`);
-    }
-  }
-
-  if (ollamaBinaryAvailable() && !embeddingModelPresent()) {
-    const doPull = await confirm({ message: `Pull the ${EMBEDDING_MODEL} embedding model now? (~274 MB, required for semantic recall)` });
-    if (isCancel(doPull)) { cancel("Setup cancelled."); process.exit(0); }
-
-    if (doPull) {
-      const ps = spinner();
-      ps.start(`Pulling ${EMBEDDING_MODEL} (this may take a few minutes)`);
-      const result = pullEmbeddingModel();
-      if (result.ok) {
-        ps.stop(`${EMBEDDING_MODEL} ready`);
-      } else {
-        ps.stop("Model pull failed");
-        log.warn(`Run \`ollama pull ${EMBEDDING_MODEL}\` manually to retry.`);
-      }
-    } else {
-      log.warn(`Skipping model pull — run \`ollama pull ${EMBEDDING_MODEL}\` before using memory recall.`);
-    }
-  }
-
-  if (ollamaBinaryAvailable() && embeddingModelPresent()) {
-    log.success(`Ollama ready — ${EMBEDDING_MODEL} present`);
-  }
-
-  // ── Step 3: classifier API key ────────────────────────────────────────
-  const wantKey = await confirm({ message: "Add a classifier API key? (enables accurate session tagging; DeepSeek is ~$0.002/session)" });
-  if (isCancel(wantKey)) { cancel("Setup cancelled."); process.exit(0); }
-
-  if (wantKey) {
-    const classifierChoice = await select<ClassifierChoice>({
-      message: "Which classifier?",
-      options: [
-        { value: "deepseek", label: "DeepSeek", hint: "recommended — fast, cheap, needs DEEPSEEK_API_KEY" },
-        { value: "ollama-offline", label: "Ollama (offline)", hint: "free, no API key, slower and less accurate" },
-      ],
-    });
-    if (isCancel(classifierChoice)) { cancel("Setup cancelled."); process.exit(0); }
-
-    if (classifierChoice === "deepseek") {
-      const key = await password({ message: "DeepSeek API key (get one at platform.deepseek.com):" });
-      if (isCancel(key)) { cancel("Setup cancelled."); process.exit(0); }
-      if (key && (key as string).trim()) {
-        writeClassifierConfig("deepseek", (key as string).trim());
-        log.success("DeepSeek API key saved to ~/.nlm/.env");
-      } else {
-        log.warn("No key entered — set DEEPSEEK_API_KEY in ~/.nlm/.env later.");
-      }
-    } else {
-      writeClassifierConfig("ollama-offline");
-      log.success("Classifier set to Ollama offline (saved to ~/.nlm/.env)");
-    }
-  }
-
-  // ── Step 4: migrations ────────────────────────────────────────────────
-  const ms = spinner();
-  ms.start("Running database migrations");
-  try {
-    const { SqliteSessionStore } = await import("../core/storage/sqlite-session-store.js");
-    const store = new SqliteSessionStore({ dbPath: opts.dbPath, migrationsDir: opts.migrationsDir });
-    store.close();
-    ms.stop("Database ready");
-  } catch (e) {
-    ms.stop("Migration failed");
-    log.error(`${e instanceof Error ? e.message : String(e)}`);
-    process.exit(1);
-  }
-
-  // ── Step 5: daemon ────────────────────────────────────────────────────
-  if (OS === "darwin") {
-    const installDaemon = await confirm({ message: "Install macOS LaunchAgent (auto-start on login)?" });
-    if (isCancel(installDaemon)) { cancel("Setup cancelled."); process.exit(0); }
-
-    if (installDaemon) {
-      const ds = spinner();
-      ds.start("Installing LaunchAgent");
-      try {
-        const uid = process.getuid?.();
-        if (uid === undefined) throw new Error("Could not determine UID");
-        mkdirSync(join(homedir(), ".nlm", "logs"), { recursive: true });
-        writeFileSync(opts.launchAgentPlist, opts.buildPlist(opts.nodeExecPath, opts.nlmBinPath), "utf8");
-        try {
-          execFileSync("launchctl", ["bootout", `gui/${uid}`, opts.launchAgentLabel], { stdio: "ignore" });
-        } catch { /* not loaded yet — expected */ }
-        execFileSync("launchctl", ["bootstrap", `gui/${uid}`, opts.launchAgentPlist]);
-        ds.stop("LaunchAgent installed — daemon running");
-      } catch (e) {
-        ds.stop("LaunchAgent install failed");
-        log.error(`${e instanceof Error ? e.message : String(e)}`);
-        log.warn("Run `nlm install` manually later.");
-      }
-    }
-  } else if (OS === "linux") {
-    log.info("Linux daemon: add `nlm start` to your init system to auto-start on boot.");
-    log.info("  systemd example:  sudo systemctl enable --now nlm  (after creating a unit file)");
-    log.info("  Quick start now:  nlm start &");
-  } else if (OS === "win32") {
-    log.info("Windows daemon: run `nlm start` at login via Task Scheduler.");
-    log.info("  Or start manually: nlm start");
-  }
-
-  // ── Step 6: per-runtime configuration ────────────────────────────────
-  for (const id of chosen) {
-    switch (id) {
-      case "claude-code": {
-        // MCP config
-        const cs = spinner();
-        cs.start("Configuring Claude Code — MCP server");
-        try {
-          const report = connectClaudeCode({ nlmBinPath: opts.nlmBinPath, nodeExecPath: opts.nodeExecPath });
-          cs.stop(`MCP server ${report.alreadyPresent ? "updated" : "written"} → ${report.mcpConfigPath}`);
-        } catch (e) {
-          cs.stop("MCP config write failed");
-          log.error(`${e instanceof Error ? e.message : String(e)}`);
-        }
-
-        // Hooks — Claude Code hooks are process hooks (settings.json), not
-        // OS-level scripts, so they work on all platforms where Claude Code runs.
-        const hs = spinner();
-        hs.start("Configuring Claude Code — session hooks");
-        const hookLogPath = process.env["NLM_HOOK_LOG"] ?? join(homedir(), ".nlm", "hook-log.jsonl");
-        const hookResult = installClaudeCodeHooks({
-          nodeExecPath: opts.nodeExecPath,
-          hooks: opts.allHooks,
-          settingsPath: opts.claudeSettingsPath,
-          hookLogPath,
-          addHook: opts.addHook,
-          removeHook: opts.removeHook,
-          buildHookCommand: opts.buildHookCommand,
-          smokeTestHookCommand: opts.smokeTestHookCommand,
-        });
-        if (hookResult.ok) {
-          hs.stop(`${hookResult.count} hooks installed → ${opts.claudeSettingsPath}`);
-        } else {
-          hs.stop(`Hook install failed (${hookResult.failedLabel ?? "unknown"})`);
-          if (hookResult.errorMessage) log.error(hookResult.errorMessage);
-          log.warn("Run `nlm hook install` manually after checking your Node path.");
-        }
-        break;
-      }
-
-      case "codex": {
-        if (!codexBinaryAvailable()) {
-          log.warn("Codex binary not found — install with `npm i -g @openai/codex`, then run `nlm connect codex`.");
-          break;
-        }
-        const cs = spinner();
-        cs.start("Connecting Codex");
-        try {
-          const report = connectCodex({ source: "pbmagnet4/nlm-memory-ts" }, pluginScriptsDir(opts.repoRoot));
-          if (report.marketplaceAdd?.status !== 0 || report.pluginAdd?.status !== 0) {
-            cs.stop("Codex connect had errors — run `nlm connect codex` manually to retry");
-          } else {
-            cs.stop("Codex marketplace + plugin registered");
-          }
-        } catch (e) {
-          cs.stop("Codex connect failed");
-          log.error(`${e instanceof Error ? e.message : String(e)}`);
-        }
-        break;
-      }
-
-      case "opencode":
-        log.success("OpenCode: session scanning enabled (passive — no extra config needed)");
-        break;
-
-      case "hermes": {
-        const hs = spinner();
-        hs.start("Configuring Hermes");
-        try {
-          const report = connectHermes({ nlmBinPath: opts.nlmBinPath, nodeExecPath: opts.nodeExecPath });
-          hs.stop(`MCP server ${report.alreadyPresent ? "updated" : "written"} → ${report.configPath}`);
-        } catch (e) {
-          hs.stop("Hermes config write failed");
-          log.error(`${e instanceof Error ? e.message : String(e)}`);
-          log.warn("Run `nlm connect hermes` manually after checking ~/.hermes/config.yaml.");
-        }
-        break;
-      }
-
-      case "pi":
-        log.success("pi.dev: session scanning enabled (passive — no extra config needed)");
-        break;
-    }
-  }
-
-  // ── Summary ───────────────────────────────────────────────────────────
-  const needsRestart: string[] = [];
-  if (chosen.includes("claude-code")) needsRestart.push("Claude Code");
-  if (chosen.includes("hermes")) needsRestart.push("Hermes");
-
-  outro(
-    needsRestart.length > 0
-      ? `Done! Restart ${needsRestart.join(" and ")} for the MCP server to activate, then start a session — memory will follow.`
-      : "Done! Start a session in any configured runtime and NLM will begin indexing automatically.",
-  );
-}

package/src/llm/classifier-box.ts

@@ -1,64 +0,0 @@
-/**
- * ClassifierBox — a mutable LLMClient wrapper holding the active classifier
- * client. The scheduler reads `inner` on each tick, so a runtime swap takes
- * effect on the next session ingest without restarting the daemon.
- *
- * Only `classify()` is delegated. `embed()` throws — embeddings are wired
- * separately through the dedicated Ollama embedder; the classifier slot is
- * for transcript classification only.
- */
-
-import type {
-  ClassifyResult,
-  EmbedResult,
-  EmbeddingKind,
-  LLMClient,
-} from "@ports/llm-client.js";
-import { DeepSeekClient } from "./deepseek-client.js";
-import { OllamaClient } from "./ollama-client.js";
-
-export type ClassifierProvider = "deepseek" | "ollama";
-
-export interface ClassifierBoxOptions {
-  readonly provider: ClassifierProvider;
-  readonly model: string;
-  readonly ollamaUrl?: string;
-}
-
-export class ClassifierBox implements LLMClient {
-  private inner: LLMClient;
-  private providerName: ClassifierProvider;
-  private modelName: string;
-  private readonly ollamaUrl: string;
-
-  constructor(opts: ClassifierBoxOptions) {
-    this.providerName = opts.provider;
-    this.modelName = opts.model;
-    this.ollamaUrl = opts.ollamaUrl ?? "http://localhost:11434";
-    this.inner = this.construct(opts.provider, opts.model);
-  }
-
-  get provider(): ClassifierProvider { return this.providerName; }
-  get model(): string { return this.modelName; }
-
-  swap(provider: ClassifierProvider, model: string): void {
-    this.inner = this.construct(provider, model);
-    this.providerName = provider;
-    this.modelName = model;
-  }
-
-  embed(_text: string, _kind: EmbeddingKind): Promise<EmbedResult> {
-    throw new Error("ClassifierBox.embed is not supported — wire OllamaClient as the embedder.");
-  }
-
-  classify(transcript: string): Promise<ClassifyResult> {
-    return this.inner.classify(transcript);
-  }
-
-  private construct(provider: ClassifierProvider, model: string): LLMClient {
-    if (provider === "ollama") {
-      return new OllamaClient({ baseUrl: this.ollamaUrl, classifyModel: model });
-    }
-    return new DeepSeekClient({ classifyModel: model });
-  }
-}