@freesyntax/notch-cli 0.5.20 → 0.5.22

package/dist/{lsp-UPY6I3L7.js → lsp-JXQVU7NP.js}

@@ -1,6 +1,7 @@
 import {
   lspTool
 } from "./chunk-TH6GKC7E.js";
+import "./chunk-KFQGP6VL.js";
 export {
   lspTool
 };

package/dist/model-download-3NDKS3VM.js

@@ -0,0 +1,176 @@
+import {
+  MODEL_CATALOG
+} from "./chunk-JXQ4HZ47.js";
+import "./chunk-PPEBWOMJ.js";
+import "./chunk-KFQGP6VL.js";
+
+// src/commands/model-download.ts
+import { spawn } from "child_process";
+import { statfs, promises as fsp } from "fs";
+import os from "os";
+import path from "path";
+import chalk from "chalk";
+async function probeSystemCapabilities(cacheDir = os.homedir()) {
+  const totalRamBytes = os.totalmem();
+  const totalRamGb = Number((totalRamBytes / 1024 / 1024 / 1024).toFixed(1));
+  const freeDiskGb = await new Promise((resolve) => {
+    try {
+      statfs(cacheDir, (err, stats) => {
+        if (err) return resolve(null);
+        const freeBytes = Number(stats.bsize) * Number(stats.bavail);
+        resolve(Math.round(freeBytes / 1024 / 1024 / 1024));
+      });
+    } catch {
+      resolve(null);
+    }
+  });
+  const gpu = await probeNvidiaSmi();
+  return {
+    platform: process.platform,
+    totalRamGb,
+    freeDiskGb,
+    gpuVramGb: gpu?.vramGb ?? null,
+    gpuName: gpu?.name ?? null
+  };
+}
+function probeNvidiaSmi() {
+  return new Promise((resolve) => {
+    try {
+      const proc = spawn("nvidia-smi", [
+        "--query-gpu=name,memory.total",
+        "--format=csv,noheader,nounits"
+      ], { stdio: ["ignore", "pipe", "ignore"] });
+      let buf = "";
+      proc.stdout.on("data", (c) => {
+        buf += c.toString();
+      });
+      proc.on("error", () => resolve(null));
+      proc.on("close", (code) => {
+        if (code !== 0 || !buf.trim()) return resolve(null);
+        const first = buf.split("\n")[0]?.trim();
+        if (!first) return resolve(null);
+        const [name, memStr] = first.split(",").map((s) => s.trim());
+        const memMb = Number(memStr);
+        if (!name || !Number.isFinite(memMb) || memMb <= 0) return resolve(null);
+        resolve({ vramGb: Number((memMb / 1024).toFixed(1)), name });
+      });
+    } catch {
+      resolve(null);
+    }
+  });
+}
+function evaluateHardware(info, caps) {
+  const hw = info.hardware;
+  const checks = [];
+  checks.push({
+    label: "RAM",
+    required: `${hw.ramGb} GB`,
+    detected: `${caps.totalRamGb} GB`,
+    status: caps.totalRamGb >= hw.ramGb ? "pass" : caps.totalRamGb >= hw.ramGb * 0.75 ? "warn" : "fail"
+  });
+  checks.push({
+    label: "Disk",
+    required: `${hw.diskGb} GB`,
+    detected: caps.freeDiskGb == null ? "unknown" : `${caps.freeDiskGb} GB free`,
+    status: caps.freeDiskGb == null ? "unknown" : caps.freeDiskGb >= hw.diskGb ? "pass" : "fail"
+  });
+  if (caps.gpuVramGb == null) {
+    checks.push({
+      label: "GPU",
+      required: `${hw.vramGb} GB VRAM (${hw.recommendedGpu})`,
+      detected: "no CUDA GPU detected",
+      // Apple silicon users run well on unified memory with Ollama even
+      // without a discrete GPU — don't fail, just warn so the CLI stays
+      // usable on Macs.
+      status: caps.platform === "darwin" ? "warn" : "warn"
+    });
+  } else {
+    checks.push({
+      label: "GPU",
+      required: `${hw.vramGb} GB VRAM (${hw.recommendedGpu})`,
+      detected: `${caps.gpuVramGb} GB \xB7 ${caps.gpuName ?? "unknown"}`,
+      status: caps.gpuVramGb >= hw.vramGb ? "pass" : caps.gpuVramGb >= hw.vramGb * 0.75 ? "warn" : "fail"
+    });
+  }
+  const ok = checks.every((c) => c.status === "pass" || c.status === "warn");
+  const failures = checks.filter((c) => c.status === "fail").map((c) => c.label);
+  const summary = ok ? `Your system meets the ${hw.tier} tier requirements for ${info.label}.` : `Your system is under-resourced for ${info.label} \u2014 ${failures.join(", ")} below minimum.`;
+  return { ok, checks, summary };
+}
+function renderVerdict(info, verdict) {
+  const lines = [];
+  lines.push(chalk.gray(`  \u2500\u2500\u2500 ${info.label} (${info.size}) \xB7 ${info.hardware.tier} tier \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`));
+  for (const c of verdict.checks) {
+    const icon = c.status === "pass" ? chalk.green("\u2713") : c.status === "warn" ? chalk.yellow("!") : c.status === "fail" ? chalk.red("\u2717") : chalk.gray("?");
+    lines.push(`  ${icon} ${c.label.padEnd(5)} required: ${chalk.white(c.required.padEnd(34))} detected: ${chalk.gray(c.detected)}`);
+  }
+  lines.push("");
+  lines.push(verdict.ok ? chalk.green(`  ${verdict.summary}`) : chalk.yellow(`  ${verdict.summary}`));
+  return lines.join("\n");
+}
+var activeDownloads = /* @__PURE__ */ new Map();
+function getDownloadStatus(id) {
+  return activeDownloads.get(id) ?? null;
+}
+function listDownloads() {
+  return [...activeDownloads.values()];
+}
+function getHuggingFaceCacheDir() {
+  const hfHome = process.env.HF_HOME ?? process.env.HUGGINGFACE_HUB_CACHE;
+  if (hfHome) return hfHome;
+  return path.join(os.homedir(), ".cache", "huggingface", "hub");
+}
+async function startModelDownload(id) {
+  const info = MODEL_CATALOG[id];
+  if (!info) throw new Error(`Unknown Notch model: ${id}`);
+  if (!info.hfRepo) {
+    throw new Error(
+      `${info.label} is not yet available for local download. Use the hosted Notch API in the meantime \u2014 run \`notch login\` to get a key.`
+    );
+  }
+  const existing = activeDownloads.get(id);
+  if (existing && existing.result == null) return existing;
+  const cacheDir = getHuggingFaceCacheDir();
+  await fsp.mkdir(cacheDir, { recursive: true });
+  const handle = {
+    modelId: id,
+    startedAt: /* @__PURE__ */ new Date(),
+    cacheDir,
+    pid: 0,
+    lastLine: "queued",
+    result: null
+  };
+  const args = ["download", info.hfRepo, "--local-dir-use-symlinks", "False"];
+  const proc = spawn("huggingface-cli", args, {
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: false,
+    env: { ...process.env, HF_HUB_ENABLE_HF_TRANSFER: "1" }
+  });
+  handle.pid = proc.pid ?? 0;
+  activeDownloads.set(id, handle);
+  const absorb = (buf) => {
+    const text = buf.toString();
+    const line = text.split(/\r?\n/).filter((l) => l.trim().length > 0).pop();
+    if (line) handle.lastLine = line.slice(0, 200);
+  };
+  proc.stdout?.on("data", absorb);
+  proc.stderr?.on("data", absorb);
+  proc.on("error", (err) => {
+    handle.result = { code: null, error: err.message };
+    handle.lastLine = `error: ${err.message}`;
+  });
+  proc.on("close", (code) => {
+    handle.result = { code, error: code === 0 ? null : `exited with code ${code ?? "null"}` };
+    if (code === 0) handle.lastLine = "complete";
+  });
+  return handle;
+}
+export {
+  evaluateHardware,
+  getDownloadStatus,
+  getHuggingFaceCacheDir,
+  listDownloads,
+  probeSystemCapabilities,
+  renderVerdict,
+  startModelDownload
+};

package/dist/{notebook-FXJBTSPA.js → notebook-MFODW345.js}

@@ -1,6 +1,7 @@
 import {
   notebookTool
 } from "./chunk-KZAS754V.js";
+import "./chunk-KFQGP6VL.js";
 export {
   notebookTool
 };

package/dist/ollama-bench-5V5CCOCQ.js

@@ -0,0 +1,194 @@
+import {
+  printNotReachable,
+  renderProgressLine,
+  resolveEndpoint
+} from "./chunk-FZVPGJJW.js";
+import {
+  detectDaemon,
+  listModels,
+  pullModel
+} from "./chunk-GFVLHUSS.js";
+import "./chunk-O6AKZ4OH.js";
+import "./chunk-KCAR5DOB.js";
+import {
+  resolveByokModel
+} from "./chunk-JXQ4HZ47.js";
+import "./chunk-PPEBWOMJ.js";
+import "./chunk-KFQGP6VL.js";
+
+// src/commands/ollama-bench.ts
+import fs from "fs/promises";
+import path from "path";
+import chalk from "chalk";
+import { streamText } from "ai";
+var DEFAULT_PROMPT = "Write a 5-line Python function that returns the n-th Fibonacci number.";
+var DEFAULT_BENCH_MODELS = [
+  "qwen3-coder:30b",
+  "llama3.2:latest",
+  "gpt-oss:20b"
+];
+function approximateTokens(text) {
+  if (!text) return 0;
+  return Math.round(text.split(/\s+/).filter(Boolean).length / 0.75);
+}
+async function ensureModelPresent(modelName, baseUrl, apiKey, allowPull) {
+  try {
+    const installed = await listModels(baseUrl, { apiKey });
+    if (installed.some((m) => m.name === modelName)) return true;
+  } catch {
+    return false;
+  }
+  if (!allowPull) return false;
+  console.log(chalk.gray(`
+  Pulling ${modelName} (not installed)...
+`));
+  const lastStatus = { label: "" };
+  try {
+    for await (const ev of pullModel(modelName, baseUrl, { apiKey })) {
+      renderProgressLine(ev, lastStatus);
+    }
+  } catch (err) {
+    process.stdout.write("\n");
+    console.error(chalk.red(`  Pull failed: ${err.message}`));
+    return false;
+  }
+  return true;
+}
+async function runOne(model, prompt, baseUrl, apiKey, isCloud) {
+  const providerId = isCloud ? "ollama-cloud" : "ollama";
+  const { model: languageModel } = resolveByokModel({
+    provider: providerId,
+    model,
+    apiKey,
+    baseUrl
+  });
+  const messages = [{ role: "user", content: prompt }];
+  const started = Date.now();
+  let firstTokenAt = 0;
+  let output = "";
+  try {
+    const stream = streamText({ model: languageModel, messages });
+    for await (const chunk of stream.textStream) {
+      if (!firstTokenAt) firstTokenAt = Date.now();
+      output += chunk;
+    }
+    const finished = Date.now();
+    const usage = await stream.usage;
+    const promptTokens = usage?.promptTokens ?? approximateTokens(prompt);
+    const completionTokens = usage?.completionTokens ?? approximateTokens(output);
+    const totalMs = finished - started;
+    const firstTokenMs = firstTokenAt ? firstTokenAt - started : totalMs;
+    const seconds = Math.max(1e-3, totalMs / 1e3);
+    return {
+      model,
+      firstTokenMs,
+      totalMs,
+      tokensPerSec: completionTokens / seconds,
+      promptTokens,
+      completionTokens,
+      output
+    };
+  } catch (err) {
+    return {
+      model,
+      firstTokenMs: 0,
+      totalMs: Date.now() - started,
+      tokensPerSec: 0,
+      promptTokens: 0,
+      completionTokens: 0,
+      output: "",
+      error: err.message
+    };
+  }
+}
+function formatRow(r) {
+  const name = r.model.padEnd(28);
+  const ttft = `${r.firstTokenMs.toString().padStart(5)} ms`;
+  const total = `${r.totalMs.toString().padStart(6)} ms`;
+  const tps = `${r.tokensPerSec.toFixed(1).padStart(6)} tok/s`;
+  const toks = `${r.promptTokens}\u2192${r.completionTokens}`;
+  if (r.error) {
+    return `  ${chalk.red("\u2717")} ${chalk.white(name)} ${chalk.red(r.error.slice(0, 70))}`;
+  }
+  return `  ${chalk.green("\u2713")} ${chalk.white(name)} ${chalk.gray(ttft)}  ${chalk.gray(total)}  ${chalk.cyan(tps)}  ${chalk.gray(toks.padEnd(12))}`;
+}
+async function persistBench(projectRoot, results, prompt) {
+  const outDir = path.join(projectRoot, ".notch");
+  await fs.mkdir(outDir, { recursive: true });
+  const file = path.join(outDir, "ollama-bench.json");
+  const payload = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    prompt,
+    results: results.map((r) => ({
+      model: r.model,
+      firstTokenMs: r.firstTokenMs,
+      totalMs: r.totalMs,
+      tokensPerSec: Number(r.tokensPerSec.toFixed(2)),
+      promptTokens: r.promptTokens,
+      completionTokens: r.completionTokens,
+      error: r.error
+    }))
+  };
+  await fs.writeFile(file, JSON.stringify(payload, null, 2) + "\n", "utf-8");
+  return file;
+}
+async function runOllamaBench(flags, opts) {
+  const { baseUrl, apiKey, mode } = await resolveEndpoint(flags);
+  if (!await detectDaemon(baseUrl, { apiKey })) {
+    printNotReachable(baseUrl, mode);
+    return 1;
+  }
+  const modelsArg = flags.model ?? "";
+  const fromFlag = modelsArg.split(",").map((s) => s.trim()).filter(Boolean);
+  const models = fromFlag.length > 0 ? fromFlag : DEFAULT_BENCH_MODELS;
+  const prompt = flags.positional.join(" ").trim() || DEFAULT_PROMPT;
+  console.log("");
+  console.log(chalk.cyan(`  Ollama bench \u2014 ${models.length} model(s) @ ${baseUrl}`));
+  console.log(chalk.gray(`  Prompt: ${prompt}`));
+  console.log("");
+  const results = [];
+  for (const model of models) {
+    if (mode === "local") {
+      const present = await ensureModelPresent(model, baseUrl, apiKey, flags.yes);
+      if (!present) {
+        results.push({
+          model,
+          firstTokenMs: 0,
+          totalMs: 0,
+          tokensPerSec: 0,
+          promptTokens: 0,
+          completionTokens: 0,
+          output: "",
+          error: "not installed (pass -y to auto-pull)"
+        });
+        continue;
+      }
+    }
+    process.stdout.write(chalk.gray(`  running ${model}... `));
+    const result = await runOne(model, prompt, baseUrl, apiKey, mode === "cloud");
+    results.push(result);
+    process.stdout.write("\r\x1B[K");
+  }
+  const ranked = [...results].sort((a, b) => {
+    if (a.error && !b.error) return 1;
+    if (!a.error && b.error) return -1;
+    return b.tokensPerSec - a.tokensPerSec;
+  });
+  const header = `  ${"  "}${"model".padEnd(28)} ${"ttft".padStart(8)}  ${"total".padStart(9)}  ${"throughput".padStart(12)}  ${"tokens (p\u2192c)"}`;
+  console.log(chalk.gray(header));
+  console.log(chalk.gray(`  ${"-".repeat(header.length - 2)}`));
+  for (const r of ranked) console.log(formatRow(r));
+  try {
+    const saved = await persistBench(opts.projectRoot, ranked, prompt);
+    console.log("");
+    console.log(chalk.gray(`  Saved: ${saved}`));
+    console.log("");
+  } catch (err) {
+    console.warn(chalk.yellow(`  ! Could not persist bench: ${err.message}`));
+  }
+  const anyFailed = ranked.some((r) => r.error);
+  return anyFailed ? 1 : 0;
+}
+export {
+  runOllamaBench
+};

package/dist/ollama-launch-P5KBK7AJ.js

@@ -0,0 +1,22 @@
+import {
+  parseFlags,
+  persistOllamaChoice,
+  printNotReachable,
+  renderProgressLine,
+  resolveEndpoint,
+  runOllamaCli
+} from "./chunk-FZVPGJJW.js";
+import "./chunk-GFVLHUSS.js";
+import "./chunk-O6AKZ4OH.js";
+import "./chunk-KCAR5DOB.js";
+import "./chunk-JXQ4HZ47.js";
+import "./chunk-PPEBWOMJ.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  parseFlags,
+  persistOllamaChoice,
+  printNotReachable,
+  renderProgressLine,
+  resolveEndpoint,
+  runOllamaCli
+};

package/dist/ollama-usage-3PROM2WC.js

@@ -0,0 +1,70 @@
+import {
+  isCloudModel
+} from "./chunk-GFVLHUSS.js";
+import "./chunk-KFQGP6VL.js";
+
+// src/ui/ollama-usage.ts
+import chalk from "chalk";
+var OllamaCloudUsageTracker = class {
+  turns = [];
+  /**
+   * Record a turn. The tracker auto-filters: only entries whose modelId
+   * looks like an Ollama Cloud model are kept. Non-cloud turns are
+   * silently ignored so callers can fire this once per turn without
+   * conditionals.
+   */
+  record(turn) {
+    if (!this.isCloudTurn(turn.modelId)) return;
+    this.turns.push(turn);
+  }
+  isCloudTurn(modelId) {
+    if (!modelId) return false;
+    if (modelId.startsWith("ollama-cloud:")) return true;
+    return isCloudModel(modelId);
+  }
+  get turnCount() {
+    return this.turns.length;
+  }
+  get sessionTotals() {
+    return this.turns.reduce(
+      (acc, t) => ({
+        promptTokens: acc.promptTokens + t.promptTokens,
+        completionTokens: acc.completionTokens + t.completionTokens,
+        totalTokens: acc.totalTokens + t.totalTokens,
+        toolCalls: acc.toolCalls + t.toolCalls,
+        iterations: acc.iterations + t.iterations
+      }),
+      { promptTokens: 0, completionTokens: 0, totalTokens: 0, toolCalls: 0, iterations: 0 }
+    );
+  }
+  /**
+   * One-line footer rendered after every turn when the active model is
+   * an Ollama Cloud alias. Kept intentionally short — it sits beside
+   * the existing UsageTracker.formatLast() output.
+   */
+  formatFooter(activeModelId) {
+    if (!this.isCloudTurn(activeModelId) || this.turnCount === 0) return "";
+    const total = this.sessionTotals;
+    const totalK = (total.totalTokens / 1e3).toFixed(1);
+    return chalk.gray(`  [cloud: ${this.turnCount} turns, ${totalK}K tokens]`);
+  }
+  /**
+   * Multi-line breakdown for `/usage cloud` / `/status` style surfaces.
+   */
+  formatDetail() {
+    if (this.turnCount === 0) {
+      return chalk.gray("  No Ollama Cloud traffic this session.");
+    }
+    const total = this.sessionTotals;
+    return [
+      chalk.gray("  Ollama Cloud"),
+      chalk.gray(`    turns      ${this.turnCount}`),
+      chalk.gray(`    prompt     ${total.promptTokens.toLocaleString()} tokens`),
+      chalk.gray(`    completion ${total.completionTokens.toLocaleString()} tokens`),
+      chalk.gray(`    total      ${total.totalTokens.toLocaleString()} tokens`)
+    ].join("\n");
+  }
+};
+export {
+  OllamaCloudUsageTracker
+};

package/dist/{plugins-OG2P75K5.js → plugins-PNGRZLFW.js}

@@ -1,6 +1,7 @@
 import {
   pluginManager
 } from "./chunk-3QUV4JEX.js";
+import "./chunk-KFQGP6VL.js";
 export {
   pluginManager
 };

package/dist/{read-OVJG2XKW.js → read-B64XE7N3.js}

@@ -1,6 +1,7 @@
 import {
   readTool
 } from "./chunk-CQMAVWLJ.js";
+import "./chunk-KFQGP6VL.js";
 export {
   readTool
 };

package/dist/{server-W7FRCVRZ.js → server-IGOZHW52.js}

@@ -1,3 +1,5 @@
+import "./chunk-KFQGP6VL.js";
+
 // src/mcp/server.ts
 import readline from "readline";
 
@@ -1315,8 +1317,8 @@ function toolsToMcpList(tools) {
   }));
 }
 async function runMcpServer(opts) {
-  const toolsModule = await import("./tools-Q7CDHB4K.js");
-  const { pluginManager } = await import("./plugins-OG2P75K5.js");
+  const toolsModule = await import("./tools-XWKCW4RN.js");
+  const { pluginManager } = await import("./plugins-PNGRZLFW.js");
   if (opts.includePlugins !== false) {
     try {
       await pluginManager.init(opts.cwd, (m) => logStderr(m));
@@ -1325,19 +1327,19 @@ async function runMcpServer(opts) {
     }
   }
   const getTools = () => toolsModule.listToolNames().map((name) => ({ name, desc: toolsModule.describeTools() })).filter(() => true);
-  const { readTool } = await import("./read-OVJG2XKW.js");
-  const { writeTool } = await import("./write-NNHLOTYK.js");
-  const { editTool } = await import("./edit-JEFEK43H.js");
-  const { applyPatchTool } = await import("./apply-patch-D5PDUXUC.js");
-  const { shellTool } = await import("./shell-4X545EVN.js");
-  const { gitTool } = await import("./git-5T5TSQTX.js");
-  const { githubTool } = await import("./github-DWRGWX6U.js");
-  const { grepTool } = await import("./grep-VZ3I5GNW.js");
-  const { globTool } = await import("./glob-BI3P4C7Q.js");
-  const { webFetchTool } = await import("./web-fetch-KNIV3Z3W.js");
-  const { lspTool } = await import("./lsp-UPY6I3L7.js");
-  const { notebookTool } = await import("./notebook-FXJBTSPA.js");
-  const { taskTool } = await import("./task-OS3E5F3X.js");
+  const { readTool } = await import("./read-B64XE7N3.js");
+  const { writeTool } = await import("./write-ZOSB7I4J.js");
+  const { editTool } = await import("./edit-6QYAXVNU.js");
+  const { applyPatchTool } = await import("./apply-patch-U6K67CMT.js");
+  const { shellTool } = await import("./shell-BOZTHQUT.js");
+  const { gitTool } = await import("./git-DNQ5EELH.js");
+  const { githubTool } = await import("./github-34T4QQIH.js");
+  const { grepTool } = await import("./grep-T2CXYNRI.js");
+  const { globTool } = await import("./glob-XT43LEJ4.js");
+  const { webFetchTool } = await import("./web-fetch-OTNDICGJ.js");
+  const { lspTool } = await import("./lsp-JXQVU7NP.js");
+  const { notebookTool } = await import("./notebook-MFODW345.js");
+  const { taskTool } = await import("./task-67G4KLYC.js");
   const exposed = [
     readTool,
     writeTool,

package/dist/session-index-7FWEVP6E.js

@@ -0,0 +1,22 @@
+import {
+  deriveEntryFromRollout,
+  forgetSession,
+  getSession,
+  indexFilePath,
+  querySessions,
+  rebuildIndex,
+  tagSession,
+  upsertSessionIndexEntry
+} from "./chunk-4HPRBCSY.js";
+import "./chunk-6NKRMZTX.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  deriveEntryFromRollout,
+  forgetSession,
+  getSession,
+  indexFilePath,
+  querySessions,
+  rebuildIndex,
+  tagSession,
+  upsertSessionIndexEntry
+};

package/dist/{shell-4X545EVN.js → shell-BOZTHQUT.js}

@@ -1,6 +1,7 @@
 import {
   shellTool
 } from "./chunk-W4FAGQFL.js";
+import "./chunk-KFQGP6VL.js";
 export {
   shellTool
 };

package/dist/{task-OS3E5F3X.js → task-67G4KLYC.js}

@@ -3,6 +3,7 @@ import {
   getAllTasks,
   taskTool
 } from "./chunk-UR4XL6OM.js";
+import "./chunk-KFQGP6VL.js";
 export {
   formatTasksDisplay,
   getAllTasks,

package/dist/{tools-Q7CDHB4K.js → tools-XWKCW4RN.js}

@@ -5,7 +5,8 @@ import {
   initMCPServers,
   listToolNames,
   mcpToolCount
-} from "./chunk-YBYF7L4A.js";
+} from "./chunk-EPSOOCNB.js";
+import "./chunk-6NKRMZTX.js";
 import "./chunk-6CZCFY6H.js";
 import "./chunk-6U3ZAGYA.js";
 import "./chunk-FFB7GK3Y.js";
@@ -14,12 +15,14 @@ import "./chunk-TH6GKC7E.js";
 import "./chunk-KZAS754V.js";
 import "./chunk-UR4XL6OM.js";
 import "./chunk-3QUV4JEX.js";
+import "./chunk-PPEBWOMJ.js";
 import "./chunk-CQMAVWLJ.js";
 import "./chunk-O3WZW7GS.js";
 import "./chunk-YAYPQTOU.js";
 import "./chunk-C4CPDDMN.js";
 import "./chunk-W4FAGQFL.js";
 import "./chunk-FAULT7VE.js";
+import "./chunk-KFQGP6VL.js";
 export {
   buildToolMap,
   describeTools,

package/dist/{web-fetch-KNIV3Z3W.js → web-fetch-OTNDICGJ.js}

@@ -1,6 +1,7 @@
 import {
   webFetchTool
 } from "./chunk-FFB7GK3Y.js";
+import "./chunk-KFQGP6VL.js";
 export {
   webFetchTool
 };

package/dist/{write-NNHLOTYK.js → write-ZOSB7I4J.js}

@@ -1,6 +1,7 @@
 import {
   writeTool
 } from "./chunk-O3WZW7GS.js";
+import "./chunk-KFQGP6VL.js";
 export {
   writeTool
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freesyntax/notch-cli",
-  "version": "0.5.20",
+  "version": "0.5.22",
   "description": "Notch CLI — AI-powered coding assistant by Driftrail",
   "type": "module",
   "bin": {
@@ -20,6 +20,7 @@
     "prepublishOnly": "npm run build:publish"
   },
   "dependencies": {
+    "@ai-sdk/anthropic": "^1.2.12",
     "@ai-sdk/openai": "^1.2.0",
     "ai": "^4.3.2",
     "chalk": "^5.3.0",

package/dist/auth-JQX6MHJG.js

@@ -1,16 +0,0 @@
-import {
-  clearCredentials,
-  getConfigDir,
-  getCredentialsPath,
-  loadCredentials,
-  login,
-  saveCredentials
-} from "./chunk-FIFC4V2R.js";
-export {
-  clearCredentials,
-  getConfigDir,
-  getCredentialsPath,
-  loadCredentials,
-  login,
-  saveCredentials
-};

package/dist/compression-UTB2Y4BB.js

@@ -1,16 +0,0 @@
-import {
-  autoCompactSummarize,
-  autoCompress,
-  compressHistory,
-  estimateTokens,
-  fullCompact,
-  microCompact
-} from "./chunk-6M6CXXWR.js";
-export {
-  autoCompactSummarize,
-  autoCompress,
-  compressHistory,
-  estimateTokens,
-  fullCompact,
-  microCompact
-};