@freesyntax/notch-cli 0.5.20 → 0.5.21

package/dist/ollama-bench-QQHBIG2D.js

@@ -0,0 +1,190 @@
+import {
+  printNotReachable,
+  renderProgressLine,
+  resolveEndpoint
+} from "./chunk-MMBFNIKE.js";
+import {
+  detectDaemon,
+  listModels,
+  pullModel
+} from "./chunk-GFVLHUSS.js";
+import {
+  resolveByokModel
+} from "./chunk-443G6HCC.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-2ASVER3S.js

@@ -0,0 +1,18 @@
+import {
+  parseFlags,
+  persistOllamaChoice,
+  printNotReachable,
+  renderProgressLine,
+  resolveEndpoint,
+  runOllamaCli
+} from "./chunk-MMBFNIKE.js";
+import "./chunk-GFVLHUSS.js";
+import "./chunk-443G6HCC.js";
+export {
+  parseFlags,
+  persistOllamaChoice,
+  printNotReachable,
+  renderProgressLine,
+  resolveEndpoint,
+  runOllamaCli
+};

package/dist/ollama-usage-2WPCZJJI.js

@@ -0,0 +1,69 @@
+import {
+  isCloudModel
+} from "./chunk-GFVLHUSS.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/{server-W7FRCVRZ.js → server-7UQKCB2Z.js}

@@ -1315,7 +1315,7 @@ function toolsToMcpList(tools) {
   }));
 }
 async function runMcpServer(opts) {
-  const toolsModule = await import("./tools-Q7CDHB4K.js");
+  const toolsModule = await import("./tools-7WAWS6V4.js");
   const { pluginManager } = await import("./plugins-OG2P75K5.js");
   if (opts.includePlugins !== false) {
     try {

package/dist/session-index-SSGOOZXK.js

@@ -0,0 +1,21 @@
+import {
+  deriveEntryFromRollout,
+  forgetSession,
+  getSession,
+  indexFilePath,
+  querySessions,
+  rebuildIndex,
+  tagSession,
+  upsertSessionIndexEntry
+} from "./chunk-OSWUX6TC.js";
+import "./chunk-QKM27RHS.js";
+export {
+  deriveEntryFromRollout,
+  forgetSession,
+  getSession,
+  indexFilePath,
+  querySessions,
+  rebuildIndex,
+  tagSession,
+  upsertSessionIndexEntry
+};

package/dist/{tools-Q7CDHB4K.js → tools-7WAWS6V4.js}

@@ -5,7 +5,8 @@ import {
   initMCPServers,
   listToolNames,
   mcpToolCount
-} from "./chunk-YBYF7L4A.js";
+} from "./chunk-TU465P2P.js";
+import "./chunk-QKM27RHS.js";
 import "./chunk-6CZCFY6H.js";
 import "./chunk-6U3ZAGYA.js";
 import "./chunk-FFB7GK3Y.js";
@@ -14,6 +15,7 @@ import "./chunk-TH6GKC7E.js";
 import "./chunk-KZAS754V.js";
 import "./chunk-UR4XL6OM.js";
 import "./chunk-3QUV4JEX.js";
+import "./chunk-FIFC4V2R.js";
 import "./chunk-CQMAVWLJ.js";
 import "./chunk-O3WZW7GS.js";
 import "./chunk-YAYPQTOU.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freesyntax/notch-cli",
-  "version": "0.5.20",
+  "version": "0.5.21",
   "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/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
-};