open-walnut 0.4.1 → 0.4.2

package/README.md

@@ -44,12 +44,9 @@ local-first, self-hosted, and has no telemetry.
 - Node.js 22 or newer. If you don't have it: `curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash` then `nvm install 22`.
 - git, only for the checkout route below (macOS: `xcode-select --install`, Ubuntu: `sudo apt install git`)
 - Linux: a C library from 2019 or later (glibc 2.29+: Ubuntu 20.04+, Debian 11+, AL2023, Fedora). Older distros compile one native module and need a newer Python and GCC first; `npm start` prints the exact commands, and [Getting Started](GETTING_STARTED.md#older-linux-glibc-before-229) has them too.
-- [Claude Code](https://docs.anthropic.com/en/docs/claude-code) for coding sessions
-- An Anthropic API key, AWS Bedrock credentials, or another supported model provider
-  for Walnut
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code), signed in once (`npm install -g @anthropic-ai/claude-code`, then run `claude`)
 
-Claude Code and Walnut authenticate separately. Coding sessions use your existing
-Claude Code CLI login, while Walnut uses the model provider selected during setup.
+That is the whole AI setup. Walnut runs on your Claude Code: the chat, coding sessions, and background work (summaries, titles, subagents) all use the `claude` you already have, however it signs in (Anthropic account, Bedrock, or Vertex). An Anthropic API key or AWS Bedrock credentials are optional, for people who would rather point Walnut's background work at a provider directly (Settings → AI Provider).
 
 ### Install
 

package/dist/cli-fast.js

@@ -291,9 +291,9 @@ function causeCode(err) {
   }
   return void 0;
 }
-async function rawRequest(base, method, path6, body, timeoutMs, prov) {
+async function rawRequest(base, method, path7, body, timeoutMs, prov) {
   const serverRoot = base.replace(/\/api\/v1$/, "");
-  const url = path6.startsWith("/api/") ? `${serverRoot}${path6}` : `${base}${path6}`;
+  const url = path7.startsWith("/api/") ? `${serverRoot}${path7}` : `${base}${path7}`;
   let res;
   try {
     res = await fetch(url, {
@@ -312,7 +312,7 @@ async function rawRequest(base, method, path6, body, timeoutMs, prov) {
       return { ok: false, message: `Walnut server not running at ${base} \u2014 start with \`open-walnut web\`` };
     }
     if (err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError")) {
-      return { ok: false, message: `Walnut request timed out after ${timeoutMs}ms: ${method} ${path6}` };
+      return { ok: false, message: `Walnut request timed out after ${timeoutMs}ms: ${method} ${path7}` };
     }
     return { ok: false, message: `Walnut request failed: ${err instanceof Error ? err.message : String(err)}` };
   }
@@ -335,7 +335,7 @@ async function rawRequest(base, method, path6, body, timeoutMs, prov) {
 }
 function materializeBinding(bind, args2) {
   const used = /* @__PURE__ */ new Set();
-  const path6 = bind.path.replace(/:([A-Za-z_][A-Za-z0-9_]*)/g, (_, name) => {
+  const path7 = bind.path.replace(/:([A-Za-z_][A-Za-z0-9_]*)/g, (_, name) => {
     used.add(name);
     const v = args2[name];
     if (v === void 0 || v === null || v === "") {
@@ -363,7 +363,7 @@ function materializeBinding(bind, args2) {
   const qs = sp.toString();
   const needsBody = bind.method !== "GET" && bind.method !== "DELETE";
   const body = bodyEntries.length > 0 ? Object.fromEntries(bodyEntries) : needsBody ? {} : void 0;
-  return { path: qs ? `${path6}?${qs}` : path6, body };
+  return { path: qs ? `${path7}?${qs}` : path7, body };
 }
 async function executeOp(name, rawArgs, options = {}) {
   const op = getOp(name);
@@ -384,8 +384,8 @@ async function runOp(op, args2, base, prov) {
   const timeoutMs = op.timeoutMs ?? REQUEST_TIMEOUT_MS;
   if (op.handler) {
     try {
-      const call = async (method, path6, body) => {
-        const r2 = await rawRequest(base, method, path6, body, timeoutMs, prov);
+      const call = async (method, path7, body) => {
+        const r2 = await rawRequest(base, method, path7, body, timeoutMs, prov);
         if (!r2.ok) throw new Error(r2.message);
         return r2.result;
       };
@@ -1104,11 +1104,34 @@ var init_model_catalog = __esm({
   }
 });
 
+// src/core/claude-cli-detect.ts
+import { execFileSync } from "child_process";
+import fs3 from "fs";
+import os2 from "os";
+import path3 from "path";
+var _CLAUDE_CREDENTIALS_HOME;
+var init_claude_cli_detect = __esm({
+  "src/core/claude-cli-detect.ts"() {
+    "use strict";
+    init_constants();
+    _CLAUDE_CREDENTIALS_HOME = os2.homedir();
+  }
+});
+
+// src/agent/providers/default-provider.ts
+var init_default_provider = __esm({
+  "src/agent/providers/default-provider.ts"() {
+    "use strict";
+    init_claude_cli_detect();
+  }
+});
+
 // src/core/cheap-model.ts
 var init_cheap_model = __esm({
   "src/core/cheap-model.ts"() {
     "use strict";
     init_model_catalog();
+    init_default_provider();
   }
 });
 
@@ -1257,8 +1280,8 @@ var init_output_mode = __esm({
 });
 
 // src/core/session-hooks/builtins.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 function caseInsensitiveFragment(pattern) {
   return pattern.replace(/[a-zA-Z]/g, (ch) => `[${ch.toUpperCase()}${ch.toLowerCase()}]`);
 }
@@ -1456,8 +1479,8 @@ var init_tasks = __esm({
         if (effective.limit === void 0 && args2.working_set !== true) {
           effective.limit = DEFAULT_TASK_LIST_LIMIT;
         }
-        const { path: path6 } = materializeBinding(TASK_LIST_BINDING, effective);
-        const body = await call("GET", path6);
+        const { path: path7 } = materializeBinding(TASK_LIST_BINDING, effective);
+        const body = await call("GET", path7);
         const tasks = body?.tasks;
         if (!Array.isArray(tasks)) return body;
         const total = typeof body?.total === "number" ? body.total : tasks.length;
@@ -1687,10 +1710,10 @@ function looksLikeNoteId(value) {
 }
 async function resolveNoteTarget(args2, call) {
   const id = typeof args2.id === "string" ? args2.id.trim() : "";
-  const path6 = typeof args2.path === "string" ? args2.path.trim() : "";
-  if (!id && !path6) throw new Error("pass path (vault-relative note path) or id (from note_search)");
-  const ref = id || path6;
-  if (!id && !looksLikeNoteId(path6)) return path6;
+  const path7 = typeof args2.path === "string" ? args2.path.trim() : "";
+  if (!id && !path7) throw new Error("pass path (vault-relative note path) or id (from note_search)");
+  const ref = id || path7;
+  if (!id && !looksLikeNoteId(path7)) return path7;
   const resolved = await call("GET", `/notes/resolve?ref=${encodeURIComponent(ref)}`);
   const resolvedPath = resolved.path;
   if (typeof resolvedPath !== "string" || !resolvedPath) throw new Error(`cannot resolve note reference: ${ref}`);
@@ -1829,16 +1852,16 @@ var init_core = __esm({
         expectedHash: z4.string().optional().describe("contentHash from note_read (update only)")
       },
       handler: async (args2, call) => {
-        const { path: path6, content, expectedHash } = args2;
-        const encoded = encodeVaultPath(String(path6));
+        const { path: path7, content, expectedHash } = args2;
+        const encoded = encodeVaultPath(String(path7));
         if (expectedHash === void 0) {
           try {
-            return await call("POST", "/notes", { path: path6, content });
+            return await call("POST", "/notes", { path: path7, content });
           } catch (err) {
             const message = err instanceof Error ? err.message : String(err);
             if (/already exists/i.test(message)) {
               throw new Error(
-                `note exists; pass expectedHash from note_read to update ${String(path6)} (note_read \u2192 contentHash \u2192 note_write), or use note_edit for a partial change`
+                `note exists; pass expectedHash from note_read to update ${String(path7)} (note_read \u2192 contentHash \u2192 note_write), or use note_edit for a partial change`
               );
             }
             throw err;
@@ -1926,11 +1949,11 @@ var init_core = __esm({
       },
       handler: async (args2, call) => {
         const method = String(args2.method);
-        const path6 = String(args2.path);
-        if (!path6.startsWith("/api/")) {
+        const path7 = String(args2.path);
+        if (!path7.startsWith("/api/")) {
           throw new Error("api passthrough only accepts paths starting with /api/");
         }
-        return call(method, path6, args2.body);
+        return call(method, path7, args2.body);
       },
       tags: { readonly: false, remote: "allow" }
     });
@@ -2215,9 +2238,9 @@ function classifyArgsSource(raw, stdinIsTty) {
   const value = raw.trim();
   if (value === "-") return { kind: "stdin" };
   if (value.startsWith("@")) {
-    const path6 = value.slice(1);
-    if (!path6) return { kind: "usage-error", message: "@ needs a file path, e.g. @/tmp/letter.json" };
-    return { kind: "file", path: path6 };
+    const path7 = value.slice(1);
+    if (!path7) return { kind: "usage-error", message: "@ needs a file path, e.g. @/tmp/letter.json" };
+    return { kind: "file", path: path7 };
   }
   if (!value) return { kind: "none" };
   return { kind: "inline", json: raw };
@@ -2260,10 +2283,10 @@ __export(wn_cli_exports, {
   resolveWalnutCliEndpoint: () => resolveWalnutCliEndpoint,
   runWalnutCli: () => runWalnutCli
 });
-import fs4 from "fs";
+import fs5 from "fs";
 import net from "net";
-import os2 from "os";
-import path4 from "path";
+import os3 from "os";
+import path5 from "path";
 function parseWalnutCliArgs(argv2) {
   const [head, ...rest2] = argv2;
   if (head === void 0) return { kind: "usage-error", message: "missing command" };
@@ -2399,7 +2422,7 @@ The 0600 socket mode is the gateway credential, so walnut will not talk to it.`
 }
 function probeSocket(socketPath) {
   try {
-    const st = fs4.statSync(socketPath);
+    const st = fs5.statSync(socketPath);
     return { isSocket: st.isSocket(), uid: st.uid, mode: st.mode & 511 };
   } catch {
     return null;
@@ -2505,12 +2528,12 @@ run \`walnut --help\` for usage
     else if (source.kind === "stdin") {
       rawJson = await readStdin();
       if (Buffer.byteLength(rawJson, "utf-8") > GATEWAY_INLINE_ARGS_MAX_BYTES) {
-        spilledArgsFile = path4.join(
-          os2.tmpdir(),
+        spilledArgsFile = path5.join(
+          os3.tmpdir(),
           `walnut-args-${process.pid}-${Date.now().toString(36)}.json`
         );
         try {
-          fs4.writeFileSync(spilledArgsFile, rawJson, { encoding: "utf-8", mode: 384 });
+          fs5.writeFileSync(spilledArgsFile, rawJson, { encoding: "utf-8", mode: 384 });
         } catch (err) {
           process.stderr.write(
             `walnut: cannot stage a large payload at ${spilledArgsFile}: ${err instanceof Error ? err.message : String(err)}
@@ -2521,10 +2544,10 @@ run \`walnut --help\` for usage
         argsFile = spilledArgsFile;
       }
     } else if (source.kind === "file") {
-      const abs = path4.resolve(source.path);
+      const abs = path5.resolve(source.path);
       let size = -1;
       try {
-        size = fs4.statSync(abs).size;
+        size = fs5.statSync(abs).size;
       } catch (err) {
         process.stderr.write(
           `walnut: cannot read arguments from ${source.path}: ${err instanceof Error ? err.message : String(err)}
@@ -2536,7 +2559,7 @@ run \`walnut --help\` for usage
         argsFile = abs;
       } else {
         try {
-          rawJson = fs4.readFileSync(abs, "utf-8");
+          rawJson = fs5.readFileSync(abs, "utf-8");
         } catch (err) {
           process.stderr.write(
             `walnut: cannot read arguments from ${source.path}: ${err instanceof Error ? err.message : String(err)}
@@ -2577,7 +2600,7 @@ run \`walnut --help\` for usage
   } finally {
     if (spilledArgsFile) {
       try {
-        fs4.unlinkSync(spilledArgsFile);
+        fs5.unlinkSync(spilledArgsFile);
       } catch {
       }
     }
@@ -2997,12 +3020,12 @@ function apiBaseUrl() {
   const raw = process.env.OPEN_WALNUT_API_URL?.trim();
   return (raw || DEFAULT_BASE_URL).replace(/\/+$/, "");
 }
-async function request(method, path6, body, opts) {
+async function request(method, path7, body, opts) {
   const base = apiBaseUrl();
   const timeoutMs = opts?.timeoutMs ?? REQUEST_TIMEOUT_MS2;
   let res;
   try {
-    res = await fetch(base + path6, {
+    res = await fetch(base + path7, {
       method,
       ...body !== void 0 ? { headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) } : {},
       signal: AbortSignal.timeout(timeoutMs)
@@ -3036,11 +3059,11 @@ async function request(method, path6, body, opts) {
   }
   return parsed;
 }
-function apiGet(path6, opts) {
-  return request("GET", path6, void 0, opts);
+function apiGet(path7, opts) {
+  return request("GET", path7, void 0, opts);
 }
-function apiPost(path6, body) {
-  return request("POST", path6, body ?? {});
+function apiPost(path7, body) {
+  return request("POST", path7, body ?? {});
 }
 function reportApiError(err, globals2) {
   const message = err instanceof ApiUnreachableError ? `Open Walnut server is not running at ${err.baseUrl} \u2014 start it with: open-walnut web` : err instanceof Error ? err.message : String(err);
@@ -3519,8 +3542,8 @@ var init_start = __esm({
 });
 
 // src/cli-fast.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path6 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var LITE_COMMANDS = /* @__PURE__ */ new Set([
   "tools",
@@ -3537,8 +3560,8 @@ var LITE_COMMANDS = /* @__PURE__ */ new Set([
 var argv = process.argv.slice(2);
 if (argv.includes("--version") || argv.includes("-V")) {
   try {
-    const pkgPath = path5.join(path5.dirname(fileURLToPath2(import.meta.url)), "..", "package.json");
-    console.log(JSON.parse(fs5.readFileSync(pkgPath, "utf-8")).version ?? "0.0.0");
+    const pkgPath = path6.join(path6.dirname(fileURLToPath2(import.meta.url)), "..", "package.json");
+    console.log(JSON.parse(fs6.readFileSync(pkgPath, "utf-8")).version ?? "0.0.0");
   } catch {
     console.log("0.0.0");
   }