@freesyntax/notch-cli 0.5.20 → 0.5.22

package/dist/chunk-KCAR5DOB.js

@@ -0,0 +1,52 @@
+// src/providers/ollama-credentials.ts
+import fs from "fs/promises";
+import path from "path";
+function notchConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg) return path.join(xdg, "notch");
+  const appdata = process.env.APPDATA;
+  if (appdata && process.platform === "win32") return path.join(appdata, "notch");
+  const home = process.env.HOME ?? process.env.USERPROFILE;
+  if (!home) {
+    throw new Error("Cannot determine home directory for credential storage.");
+  }
+  return path.join(home, ".config", "notch");
+}
+function ollamaCredsPath() {
+  return path.join(notchConfigDir(), "ollama.json");
+}
+async function readOllamaCreds() {
+  try {
+    const raw = await fs.readFile(ollamaCredsPath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.apiKey !== "string" || typeof parsed.endpoint !== "string") return null;
+    return {
+      apiKey: parsed.apiKey,
+      endpoint: parsed.endpoint,
+      createdAt: typeof parsed.createdAt === "number" ? parsed.createdAt : Date.now()
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeOllamaCreds(creds) {
+  const dir = notchConfigDir();
+  await fs.mkdir(dir, { recursive: true, mode: 448 });
+  const file = ollamaCredsPath();
+  await fs.writeFile(file, JSON.stringify(creds, null, 2) + "\n", { mode: 384 });
+}
+async function clearOllamaCreds() {
+  try {
+    await fs.unlink(ollamaCredsPath());
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") throw err;
+  }
+}
+
+export {
+  ollamaCredsPath,
+  readOllamaCreds,
+  writeOllamaCreds,
+  clearOllamaCreds
+};

package/dist/chunk-KFQGP6VL.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __require,
+  __esm,
+  __export,
+  __toCommonJS
+};

package/dist/{chunk-6M6CXXWR.js → chunk-PKZKVOAN.js}

@@ -1,5 +1,6 @@
 // src/agent/compression.ts
 import { generateText } from "ai";
+import { createHash } from "crypto";
 function estimateTokens(messages) {
   let chars = 0;
   for (const msg of messages) {
@@ -15,6 +16,112 @@ function estimateTokens(messages) {
   }
   return Math.ceil(chars / 4);
 }
+var InMemoryArtifactStore = class {
+  map = /* @__PURE__ */ new Map();
+  put(key, value) {
+    this.map.set(key, value);
+  }
+  get(key) {
+    return this.map.get(key);
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+};
+var globalArtifactStore = new InMemoryArtifactStore();
+function setArtifactStore(store) {
+  const prev = globalArtifactStore;
+  globalArtifactStore = store;
+  return () => {
+    globalArtifactStore = prev;
+  };
+}
+function getArtifactStore() {
+  return globalArtifactStore;
+}
+var ARTIFACT_URI_PREFIX = "notch-artifact://";
+function artifactKey(content) {
+  return createHash("sha1").update(content).digest("hex").slice(0, 16);
+}
+function makeArtifactUri(key) {
+  return `${ARTIFACT_URI_PREFIX}${key}`;
+}
+function parseArtifactUri(text) {
+  const match = text.match(/notch-artifact:\/\/([a-f0-9]{8,64})/);
+  return match ? match[1] : null;
+}
+var BUDGET_TOOL_RESULT_MAX = 3e3;
+var BUDGET_PREVIEW_CHARS = 400;
+function budgetReduce(messages, opts = {}) {
+  const maxChars = opts.maxToolResultChars ?? BUDGET_TOOL_RESULT_MAX;
+  const previewChars = opts.previewChars ?? BUDGET_PREVIEW_CHARS;
+  const keepLastN = opts.keepLastN ?? 4;
+  const store = opts.store ?? globalArtifactStore;
+  const toolIdx = [];
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i].role === "tool") toolIdx.push(i);
+  }
+  const eligibleUpTo = toolIdx.length - keepLastN;
+  if (eligibleUpTo <= 0) return { messages, stashed: 0, savedChars: 0 };
+  const eligible = new Set(toolIdx.slice(0, eligibleUpTo));
+  let stashed = 0;
+  let savedChars = 0;
+  const out = messages.map((msg, idx) => {
+    if (msg.role !== "tool" || !eligible.has(idx)) return msg;
+    if (!Array.isArray(msg.content)) return msg;
+    let touched = false;
+    const newContent = msg.content.map((block) => {
+      const b = block;
+      if (b.type !== "tool-result") return block;
+      const resultStr = typeof b.result === "string" ? b.result : JSON.stringify(b.result ?? "");
+      if (resultStr.length <= maxChars) return block;
+      const key = artifactKey(resultStr);
+      try {
+        void store.put(key, resultStr);
+      } catch {
+        return block;
+      }
+      const preview = resultStr.slice(0, previewChars);
+      const replacement = `${preview}
+... [+${resultStr.length - previewChars} chars stashed at ${makeArtifactUri(key)}]`;
+      savedChars += resultStr.length - replacement.length;
+      stashed++;
+      touched = true;
+      return {
+        ...b,
+        result: replacement
+      };
+    });
+    if (!touched) return msg;
+    return { ...msg, content: newContent };
+  });
+  return { messages: out, stashed, savedChars };
+}
+function snip(messages, opts = {}) {
+  const keepStart = opts.keepStart ?? 1;
+  const keepRecent = opts.keepRecent ?? 6;
+  const trigger = opts.triggerMiddleCount ?? 40;
+  const snipCount = opts.snipCount ?? 10;
+  if (messages.length < keepStart + keepRecent + trigger) {
+    return { messages, snipped: 0 };
+  }
+  const head = messages.slice(0, keepStart);
+  const tail = messages.slice(-keepRecent);
+  const middle = messages.slice(keepStart, messages.length - keepRecent);
+  let cut = Math.min(snipCount, middle.length);
+  while (cut < middle.length && middle[cut].role === "tool") cut++;
+  const dropped = middle.slice(0, cut);
+  const kept = middle.slice(cut);
+  if (dropped.length === 0) return { messages, snipped: 0 };
+  const marker = {
+    role: "user",
+    content: `[snip: ${dropped.length} older messages removed by age]`
+  };
+  return {
+    messages: [...head, marker, ...kept, ...tail],
+    snipped: dropped.length
+  };
+}
 var TEXT_BLOCK_MAX = 8e3;
 function microCompact(messages) {
   const result = [];
@@ -35,6 +142,48 @@ function microCompact(messages) {
   }
   return result;
 }
+function contextCollapse(messages, opts = {}) {
+  const keepStart = opts.keepStart ?? 1;
+  const keepRecent = opts.keepRecent ?? 4;
+  const trigger = opts.triggerMiddleCount ?? 12;
+  const store = opts.store ?? globalArtifactStore;
+  if (messages.length < keepStart + keepRecent + trigger) {
+    return { messages, collapsed: false };
+  }
+  const head = messages.slice(0, keepStart);
+  const middle = messages.slice(keepStart, messages.length - keepRecent);
+  const tail = messages.slice(-keepRecent);
+  if (middle.length === 0) return { messages, collapsed: false };
+  let key;
+  try {
+    const serialized = JSON.stringify(middle);
+    key = artifactKey(serialized);
+    void store.put(key, serialized);
+  } catch {
+  }
+  const summaryText = buildDeterministicSummary(middle);
+  const ref = key ? ` (originals at ${makeArtifactUri(key)})` : "";
+  const summaryMarker = {
+    role: "user",
+    content: `[Context collapsed \u2014 ${middle.length} messages summarized${ref}]
+${summaryText}`
+  };
+  return {
+    messages: [...head, summaryMarker, ...tail],
+    collapsed: true,
+    artifactKey: key
+  };
+}
+async function restoreCollapsedSpan(artifactKeyOrUri, store = globalArtifactStore) {
+  const key = artifactKeyOrUri.startsWith(ARTIFACT_URI_PREFIX) ? artifactKeyOrUri.slice(ARTIFACT_URI_PREFIX.length) : artifactKeyOrUri;
+  const raw = await store.get(key);
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
 var RESERVE_BUFFER_TOKENS = 13e3;
 var MAX_SUMMARY_TOKENS = 2e4;
 var MAX_COMPRESSION_FAILURES = 3;
@@ -180,10 +329,19 @@ ${firstContent}`
   return { messages: compressed, compressed: true };
 }
 async function autoCompress(messages, model, contextWindow, onCompress) {
-  let result = microCompact(messages);
   const threshold = (contextWindow - RESERVE_BUFFER_TOKENS) * 0.75;
+  let result = budgetReduce(messages).messages;
+  result = snip(result).messages;
+  result = microCompact(result);
   let tokens = estimateTokens(result);
   if (tokens < threshold) return result;
+  const collapsed = contextCollapse(result);
+  if (collapsed.collapsed) {
+    onCompress?.();
+    result = collapsed.messages;
+    tokens = estimateTokens(result);
+  }
+  if (tokens < threshold) return result;
   const auto = await autoCompactSummarize(result, { model, contextWindow });
   if (auto.compressed) {
     onCompress?.();
@@ -198,6 +356,48 @@ async function autoCompress(messages, model, contextWindow, onCompress) {
   }
   return result;
 }
+async function autoCompressWithStats(messages, model, contextWindow) {
+  const stats = {
+    budgetStashed: 0,
+    snipped: 0,
+    collapsed: false,
+    autoCompacted: false,
+    fullCompacted: false
+  };
+  const threshold = (contextWindow - RESERVE_BUFFER_TOKENS) * 0.75;
+  const br = budgetReduce(messages);
+  let result = br.messages;
+  stats.budgetStashed = br.stashed;
+  const sn = snip(result);
+  result = sn.messages;
+  stats.snipped = sn.snipped;
+  result = microCompact(result);
+  let tokens = estimateTokens(result);
+  if (tokens >= threshold) {
+    const collapsed = contextCollapse(result);
+    if (collapsed.collapsed) {
+      result = collapsed.messages;
+      stats.collapsed = true;
+      tokens = estimateTokens(result);
+    }
+  }
+  if (tokens >= threshold) {
+    const auto = await autoCompactSummarize(result, { model, contextWindow });
+    if (auto.compressed) {
+      result = auto.messages;
+      stats.autoCompacted = true;
+      tokens = estimateTokens(result);
+    }
+  }
+  if (tokens >= threshold) {
+    const full = await fullCompact(result, model);
+    if (full.compressed) {
+      result = full.messages;
+      stats.fullCompacted = true;
+    }
+  }
+  return { messages: result, stats };
+}
 async function compressHistory(messages, opts) {
   const result = await autoCompactSummarize(messages, opts);
   return result;
@@ -205,9 +405,17 @@ async function compressHistory(messages, opts) {
 
 export {
   estimateTokens,
+  setArtifactStore,
+  getArtifactStore,
+  parseArtifactUri,
+  budgetReduce,
+  snip,
   microCompact,
+  contextCollapse,
+  restoreCollapsedSpan,
   autoCompactSummarize,
   fullCompact,
   autoCompress,
+  autoCompressWithStats,
   compressHistory
 };

package/dist/{chunk-FIFC4V2R.js → chunk-PPEBWOMJ.js}

@@ -1,12 +1,29 @@
+import {
+  __esm,
+  __export,
+  __require
+} from "./chunk-KFQGP6VL.js";
+
 // src/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  clearCredentials: () => clearCredentials,
+  getByokSyncPath: () => getByokSyncPath,
+  getConfigDir: () => getConfigDir,
+  getCredentialsPath: () => getCredentialsPath,
+  invalidateSyncedKeysCache: () => invalidateSyncedKeysCache,
+  loadCredentials: () => loadCredentials,
+  loadSyncedByokKeys: () => loadSyncedByokKeys,
+  loadSyncedByokKeysSync: () => loadSyncedByokKeysSync,
+  login: () => login,
+  saveCredentials: () => saveCredentials,
+  syncByokKeys: () => syncByokKeys
+});
 import http from "http";
 import { exec } from "child_process";
 import os from "os";
 import path from "path";
 import fs from "fs/promises";
-var FREESYNTAX_URL = "https://freesyntax.dev";
-var PREFERRED_PORT = 9721;
-var AUTH_TIMEOUT_MS = 5 * 60 * 1e3;
 function getConfigDir() {
   if (process.platform === "win32") {
     return path.join(process.env["APPDATA"] ?? os.homedir(), "notch");
@@ -45,6 +62,58 @@ async function clearCredentials() {
   } catch {
   }
 }
+function getByokSyncPath() {
+  return path.join(getConfigDir(), "byok-sync.json");
+}
+async function syncByokKeys(token, baseUrl = FREESYNTAX_URL) {
+  const url = `${baseUrl.replace(/\/$/, "")}/api/cli/keys`;
+  const res = await fetch(url, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Key sync failed (${res.status}): ${body.slice(0, 200) || res.statusText}`);
+  }
+  const data = await res.json();
+  const dir = getConfigDir();
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(
+    getByokSyncPath(),
+    JSON.stringify({ ...data, syncedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
+    { encoding: "utf-8", mode: 384 }
+  );
+  return data;
+}
+async function loadSyncedByokKeys() {
+  try {
+    const raw = await fs.readFile(getByokSyncPath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && parsed.keys) return parsed;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function loadSyncedByokKeysSync() {
+  if (syncedKeysCache !== void 0) return syncedKeysCache;
+  try {
+    const fsSync = __require("fs");
+    const raw = fsSync.readFileSync(getByokSyncPath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && parsed.keys) {
+      syncedKeysCache = parsed;
+    } else {
+      syncedKeysCache = null;
+    }
+  } catch {
+    syncedKeysCache = null;
+  }
+  return syncedKeysCache;
+}
+function invalidateSyncedKeysCache() {
+  syncedKeysCache = void 0;
+}
 function openBrowser(url) {
   let cmd;
   if (process.platform === "win32") {
@@ -130,7 +199,13 @@ async function login() {
     }, AUTH_TIMEOUT_MS);
   });
 }
-var HTML_BASE = (body) => `<!DOCTYPE html>
+var FREESYNTAX_URL, PREFERRED_PORT, AUTH_TIMEOUT_MS, syncedKeysCache, HTML_BASE, HTML_SUCCESS, HTML_ERROR;
+var init_auth = __esm({
+  "src/auth.ts"() {
+    FREESYNTAX_URL = "https://freesyntax.dev";
+    PREFERRED_PORT = 9721;
+    AUTH_TIMEOUT_MS = 5 * 60 * 1e3;
+    HTML_BASE = (body) => `<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
@@ -157,16 +232,18 @@ var HTML_BASE = (body) => `<!DOCTYPE html>
 </head>
 <body><div class="card">${body}</div></body>
 </html>`;
-var HTML_SUCCESS = HTML_BASE(`
+    HTML_SUCCESS = HTML_BASE(`
   <div class="brand">notch_</div>
   <h1>CLI authorized</h1>
   <p>You can close this tab and return to your terminal.</p>
 `);
-var HTML_ERROR = HTML_BASE(`
+    HTML_ERROR = HTML_BASE(`
   <div class="brand">notch_</div>
   <h1>Authorization failed</h1>
   <p style="color:#CE2127">Run <code>notch login</code> again to retry.</p>
 `);
+  }
+});
 
 export {
   getConfigDir,
@@ -174,5 +251,12 @@ export {
   loadCredentials,
   saveCredentials,
   clearCredentials,
-  login
+  getByokSyncPath,
+  syncByokKeys,
+  loadSyncedByokKeys,
+  loadSyncedByokKeysSync,
+  invalidateSyncedKeysCache,
+  login,
+  auth_exports,
+  init_auth
 };

package/dist/compression-YJLWEHCC.js

@@ -0,0 +1,33 @@
+import {
+  autoCompactSummarize,
+  autoCompress,
+  autoCompressWithStats,
+  budgetReduce,
+  compressHistory,
+  contextCollapse,
+  estimateTokens,
+  fullCompact,
+  getArtifactStore,
+  microCompact,
+  parseArtifactUri,
+  restoreCollapsedSpan,
+  setArtifactStore,
+  snip
+} from "./chunk-PKZKVOAN.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  autoCompactSummarize,
+  autoCompress,
+  autoCompressWithStats,
+  budgetReduce,
+  compressHistory,
+  contextCollapse,
+  estimateTokens,
+  fullCompact,
+  getArtifactStore,
+  microCompact,
+  parseArtifactUri,
+  restoreCollapsedSpan,
+  setArtifactStore,
+  snip
+};

package/dist/config-set-3IWEVZQ4.js

@@ -0,0 +1,110 @@
+import {
+  persistConfigPatch
+} from "./chunk-J66N6AFH.js";
+import "./chunk-KCAR5DOB.js";
+import "./chunk-JXQ4HZ47.js";
+import "./chunk-PPEBWOMJ.js";
+import "./chunk-KFQGP6VL.js";
+
+// src/commands/config-set.ts
+import fs from "fs/promises";
+import path from "path";
+var HELP = `notch config \u2014 manage .notch.json settings
+
+Usage:
+  notch config get [key]
+  notch config set <key> <value>
+  notch config unset <key>
+  notch config yolo [on|off]        # auto-allow every tool call (sticks)
+
+Examples:
+  notch config set permissionMode trust
+  notch config set autoConfirm true
+  notch config set model pyre
+  notch config yolo on
+  notch config yolo off
+`;
+function parseValue(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+async function readCurrent(projectRoot) {
+  const p = path.resolve(projectRoot, ".notch.json");
+  try {
+    const raw = await fs.readFile(p, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return {};
+}
+async function runConfigCli(argv, projectRoot) {
+  const sub = argv[0];
+  if (!sub || sub === "-h" || sub === "--help" || sub === "help") {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  if (sub === "get") {
+    const key = argv[1];
+    const cur = await readCurrent(projectRoot);
+    if (!key) {
+      process.stdout.write(JSON.stringify(cur, null, 2) + "\n");
+      return 0;
+    }
+    if (key in cur) {
+      process.stdout.write(JSON.stringify(cur[key]) + "\n");
+      return 0;
+    }
+    process.stderr.write(`notch: no such key: ${key}
+`);
+    return 1;
+  }
+  if (sub === "set") {
+    const key = argv[1];
+    const value = argv.slice(2).join(" ");
+    if (!key || value.length === 0) {
+      process.stderr.write("usage: notch config set <key> <value>\n");
+      return 2;
+    }
+    const parsed = parseValue(value);
+    const merged = await persistConfigPatch(projectRoot, { [key]: parsed });
+    process.stdout.write(`${key} = ${JSON.stringify(merged[key])}
+`);
+    return 0;
+  }
+  if (sub === "unset") {
+    const key = argv[1];
+    if (!key) {
+      process.stderr.write("usage: notch config unset <key>\n");
+      return 2;
+    }
+    await persistConfigPatch(projectRoot, { [key]: void 0 });
+    process.stdout.write(`removed ${key}
+`);
+    return 0;
+  }
+  if (sub === "yolo") {
+    const arg = (argv[1] ?? "").toLowerCase();
+    const cur = await readCurrent(projectRoot);
+    const currentlyOn = cur.permissionMode === "trust";
+    const turnOn = arg === "" ? !currentlyOn : arg === "on" || arg === "true" || arg === "1" || arg === "yes";
+    await persistConfigPatch(projectRoot, {
+      permissionMode: turnOn ? "trust" : "auto",
+      autoConfirm: turnOn ? true : void 0
+    });
+    process.stdout.write(turnOn ? "YOLO mode ON \u2014 every tool call auto-allowed. Saved to .notch.json.\n" : "YOLO mode OFF \u2014 prompts restored. Saved to .notch.json.\n");
+    return 0;
+  }
+  process.stderr.write(`notch: unknown config subcommand: ${sub}
+`);
+  process.stderr.write(HELP);
+  return 2;
+}
+export {
+  runConfigCli
+};

package/dist/{edit-JEFEK43H.js → edit-6QYAXVNU.js}

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

package/dist/{git-5T5TSQTX.js → git-DNQ5EELH.js}

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

package/dist/{github-DWRGWX6U.js → github-34T4QQIH.js}

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

package/dist/{glob-BI3P4C7Q.js → glob-XT43LEJ4.js}

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

package/dist/{grep-VZ3I5GNW.js → grep-T2CXYNRI.js}

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