snow-ai 0.7.15 → 0.7.16

package/bundle/cli.mjs

@@ -53450,7 +53450,24 @@ Notebook is your persistent memory for the codebase. Use it aggressively to reco
 - If you notice an existing note is outdated or incorrect, fix it immediately \u2014 do NOT leave stale notes
 - After refactoring removes the fragile code a note warned about, delete that note
 
-**Key actions:** \`action:"add"\` to record, \`action:"query"\` to recall before starting a task, \`action:"update"\` / \`action:"delete"\` to keep notes accurate
+**PARALLEL CALLS RULE:**
+ALWAYS pair notebook-manage with action tools in same call:
+- CORRECT: notebook-manage({action:"query"}) + filesystem-read | notebook-manage({action:"add",...}) + filesystem-edit
+- WRONG: Call notebook-manage alone, wait for result, then act
+
+**Single tool \u2014 \`notebook-manage\` (required \`action\`):**
+- **query**: Search by fuzzy file path pattern; optional \`filePathPattern\`, \`topN\`
+- **list**: All entries for one exact file; required \`filePath\`
+- **add**: \`filePath\` + \`note\` (string or string[] for batch); records note(s) for a file
+- **update**: \`notebookId\` + \`note\` (string); updates one entry's content
+- **delete**: \`notebookId\` (string or string[]); removes entry(s)
+
+**Examples:**
+\`\`\`
+notebook-manage({action:"query", filePathPattern:"auth"}) + filesystem-read("src/auth.ts")
+notebook-manage({action:"add", filePath:"src/auth.ts", note:["validateInput() MUST be called first","Session token is nullable"]}) + filesystem-edit(...)
+notebook-manage({action:"delete", notebookId:["id1","id2"]}) + filesystem-edit(...)
+\`\`\`
 
 **Golden rule:** If you had to think hard to understand something, write it down so the next session doesn't have to.
 
@@ -363045,6 +363062,56 @@ function deleteNotebook(notebookId) {
   }
   return found;
 }
+function addNotebooks(filePath, notes) {
+  const normalizedPath = normalizePath2(filePath);
+  const data = readNotebookData();
+  if (!data[normalizedPath]) {
+    data[normalizedPath] = [];
+  }
+  const entries = [];
+  for (const note of notes) {
+    const now = /* @__PURE__ */ new Date();
+    const localTimeStr = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}T${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}.${String(now.getMilliseconds()).padStart(3, "0")}`;
+    const entry = {
+      id: `notebook-${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      filePath: normalizedPath,
+      note,
+      createdAt: localTimeStr,
+      updatedAt: localTimeStr
+    };
+    data[normalizedPath].unshift(entry);
+    entries.push(entry);
+  }
+  if (data[normalizedPath].length > MAX_ENTRIES_PER_FILE) {
+    data[normalizedPath] = data[normalizedPath].slice(0, MAX_ENTRIES_PER_FILE);
+  }
+  saveNotebookData(data);
+  return entries;
+}
+function deleteNotebooks(notebookIds) {
+  var _a20;
+  const data = readNotebookData();
+  const idSet = new Set(notebookIds);
+  const deleted = [];
+  for (const [, entries] of Object.entries(data)) {
+    for (let i = entries.length - 1; i >= 0; i--) {
+      if (idSet.has(entries[i].id)) {
+        deleted.push(entries[i].id);
+        entries.splice(i, 1);
+        idSet.delete(((_a20 = entries[i]) == null ? void 0 : _a20.id) ?? "");
+      }
+    }
+    if (idSet.size === 0)
+      break;
+  }
+  if (deleted.length > 0) {
+    saveNotebookData(data);
+  }
+  return {
+    deleted,
+    notFound: notebookIds.filter((id) => !deleted.includes(id))
+  };
+}
 function getNotebookSnapshotFilePath() {
   const projectRoot = process.cwd();
   const projectName = path23.basename(projectRoot);
@@ -441038,6 +441105,7 @@ EXAMPLES:
 
 // dist/mcp/notebook.js
 async function executeNotebookTool(toolName, args2) {
+  var _a20;
   try {
     const legacyActionMap = {
       "notebook-add": "add",
@@ -441061,18 +441129,57 @@ async function executeNotebookTool(toolName, args2) {
     switch (action) {
       case "add": {
         const { filePath, note } = args2;
-        if (!filePath || !note) {
+        if (!filePath || note === void 0 || note === null) {
           return {
             content: [
               {
                 type: "text",
-                text: "Error: Both filePath and note are required"
+                text: 'Error: action=add requires both "filePath" and "note"'
               }
             ],
             isError: true
           };
         }
-        const entry = addNotebook(filePath, note);
+        let parsedNote = note;
+        if (typeof note === "string") {
+          try {
+            const parsed = JSON.parse(note);
+            if (Array.isArray(parsed)) {
+              parsedNote = parsed;
+            }
+          } catch {
+          }
+        }
+        if (Array.isArray(parsedNote)) {
+          const entries = addNotebooks(filePath, parsedNote);
+          try {
+            const context2 = getConversationContext();
+            if (context2) {
+              for (const entry2 of entries) {
+                recordNotebookAddition(context2.sessionId, context2.messageIndex, entry2.id);
+              }
+            }
+          } catch {
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  success: true,
+                  message: `${entries.length} notebook entries added for: ${((_a20 = entries[0]) == null ? void 0 : _a20.filePath) ?? filePath}`,
+                  entries: entries.map((e) => ({
+                    id: e.id,
+                    filePath: e.filePath,
+                    note: e.note,
+                    createdAt: e.createdAt
+                  }))
+                }, null, 2)
+              }
+            ]
+          };
+        }
+        const entry = addNotebook(filePath, parsedNote);
         try {
           const context2 = getConversationContext();
           if (context2) {
@@ -441136,12 +441243,12 @@ async function executeNotebookTool(toolName, args2) {
       }
       case "update": {
         const { notebookId, note } = args2;
-        if (!notebookId || !note) {
+        if (!notebookId || !note || typeof note !== "string") {
           return {
             content: [
               {
                 type: "text",
-                text: "Error: Both notebookId and note are required"
+                text: 'Error: action=update requires "notebookId" (string) and "note" (string)'
               }
             ],
             isError: true
@@ -441191,47 +441298,60 @@ async function executeNotebookTool(toolName, args2) {
       }
       case "delete": {
         const { notebookId } = args2;
-        if (!notebookId) {
+        if (notebookId === void 0 || notebookId === null) {
           return {
             content: [
               {
                 type: "text",
-                text: "Error: notebookId is required"
+                text: 'Error: action=delete requires "notebookId"'
               }
             ],
             isError: true
           };
         }
-        const entryToDelete = findNotebookById(notebookId);
-        const deleted = deleteNotebook(notebookId);
-        if (!deleted) {
+        const ids = Array.isArray(notebookId) ? notebookId : [notebookId];
+        const entriesToDelete = ids.map((id) => findNotebookById(id)).filter((e) => e !== null);
+        const result2 = ids.length === 1 ? (() => {
+          const deleted = deleteNotebook(ids[0]);
+          return {
+            deleted: deleted ? [ids[0]] : [],
+            notFound: deleted ? [] : [ids[0]]
+          };
+        })() : deleteNotebooks(ids);
+        try {
+          const context2 = getConversationContext();
+          if (context2) {
+            for (const entry of entriesToDelete) {
+              if (result2.deleted.includes(entry.id)) {
+                recordNotebookDeletion(context2.sessionId, context2.messageIndex, entry);
+              }
+            }
+          }
+        } catch {
+        }
+        if (result2.deleted.length === 0) {
           return {
             content: [
               {
                 type: "text",
                 text: JSON.stringify({
                   success: false,
-                  message: `Notebook entry not found: ${notebookId}`
+                  message: `Notebook entries not found: ${result2.notFound.join(", ")}`
                 }, null, 2)
               }
             ],
             isError: true
           };
         }
-        try {
-          const context2 = getConversationContext();
-          if (context2 && entryToDelete) {
-            recordNotebookDeletion(context2.sessionId, context2.messageIndex, entryToDelete);
-          }
-        } catch {
-        }
         return {
           content: [
             {
               type: "text",
               text: JSON.stringify({
                 success: true,
-                message: `Notebook entry deleted: ${notebookId}`
+                message: `${result2.deleted.length} notebook entries deleted`,
+                deleted: result2.deleted,
+                ...result2.notFound.length > 0 ? { notFound: result2.notFound } : {}
               }, null, 2)
             }
           ]
@@ -441244,7 +441364,7 @@ async function executeNotebookTool(toolName, args2) {
             content: [
               {
                 type: "text",
-                text: "Error: filePath is required"
+                text: 'Error: action=list requires "filePath"'
               }
             ],
             isError: true
@@ -441302,35 +441422,35 @@ var init_notebook = __esm({
     mcpTools9 = [
       {
         name: "notebook-manage",
-        description: `\u{1F4DD} Unified notebook management tool. Use required "action" field to operate code memory.
+        description: `Unified notebook management tool. Use required field "action" \u2014 one of query | list | add | update | delete.
 
-**Core Purpose:** Prevent new features from breaking existing functionality.
+PARALLEL CALLS ONLY: MUST pair with other tools (notebook-manage + filesystem-read/terminal-execute/etc).
+NEVER call notebook-manage alone \u2014 always combine with an action tool in the same turn.
 
-**Actions:**
-- query: Search entries by fuzzy file path pattern (default action to discover notes)
-- list: List all entries for one exact file path
-- add: Record a new note for a file
-- update: Update existing note by notebookId
-- delete: Delete outdated note by notebookId
+ACTIONS:
+- query: Search entries by fuzzy file path pattern. Optional "filePathPattern" and "topN".
+- list: List all entries for one exact file path. Required "filePath".
+- add: Record note(s) for a file. Required "filePath" and "note" (string or string[]). Batch adds share the same filePath.
+- update: Update note by ID. Required "notebookId" and "note".
+- delete: Remove note(s) by ID. Required "notebookId" (string or string[]).
 
-**When to add notes:**
-- After fixing bugs that could easily reoccur
-- Fragile code that new features might break
-- Non-obvious dependencies between components
-- Workarounds that shouldn't be "optimized away"
+BEST PRACTICES:
+- After fixing non-trivial bugs, record what caused it and why the fix works.
+- When discovering fragile dependencies or hidden coupling, record immediately.
+- When an existing note is outdated or incorrect, update/delete it immediately \u2014 do NOT leave stale notes.
+- Use query before modifying code to recall relevant notes.
 
-**Examples:**
-- "\u26A0\uFE0F validateInput() MUST be called first - new features broke this twice"
-- "Component X depends on null return - DO NOT change to empty array"
-- "setTimeout workaround for race condition - don't remove"
-- "Parser expects exact format - adding fields breaks backward compat"`,
+EXAMPLES:
+- notebook-manage({action:"query", filePathPattern:"auth"}) + filesystem-read(...)
+- notebook-manage({action:"add", filePath:"src/auth.ts", note:["validateInput() MUST be called first","Session token is nullable"]}) + filesystem-edit(...)
+- notebook-manage({action:"delete", notebookId:["id1","id2"]}) + filesystem-edit(...)`,
         inputSchema: {
           type: "object",
           properties: {
             action: {
               type: "string",
               enum: ["query", "list", "add", "update", "delete"],
-              description: "Operation to run: query | list | add | update | delete."
+              description: "Which operation to run on the notebook."
             },
             filePath: {
               type: "string",
@@ -441349,12 +441469,32 @@ var init_notebook = __esm({
               maximum: 50
             },
             notebookId: {
-              type: "string",
-              description: "For action=update/delete: notebook entry ID (from query/list)."
+              oneOf: [
+                {
+                  type: "string",
+                  description: "Single notebook entry ID"
+                },
+                {
+                  type: "array",
+                  items: { type: "string" },
+                  description: "Multiple IDs (same delete applies to all)"
+                }
+              ],
+              description: "For action=update or delete: entry id(s) from action=query/list."
             },
             note: {
-              type: "string",
-              description: "For action=add/update: brief and specific risk/constraint note."
+              oneOf: [
+                {
+                  type: "string",
+                  description: "For action=add: one note. For action=update: new note content."
+                },
+                {
+                  type: "array",
+                  items: { type: "string" },
+                  description: "For action=add only: batch add multiple notes for the same file."
+                }
+              ],
+              description: "For add: required (string or string[]). For update: required string."
             }
           },
           required: ["action"]
@@ -457684,8 +457824,17 @@ var init_LSPClient = __esm({
         return Boolean(this.connection && this.isInitialized && this.isProcessAlive && !this.isShuttingDown && stdin && !stdin.destroyed && !stdin.writableEnded);
       }
       markTransportClosed() {
+        if (!this.isProcessAlive && !this.isInitialized) {
+          return;
+        }
         this.isInitialized = false;
         this.isProcessAlive = false;
+        if (this.connection) {
+          try {
+            this.connection.dispose();
+          } catch {
+          }
+        }
       }
       constructor(config3) {
         Object.defineProperty(this, "config", {
@@ -458419,20 +458568,30 @@ var init_LSPManager = __esm({
         if (!client) {
           return null;
         }
+        let uri;
         try {
-          const uri = this.pathToUri(filePath);
+          uri = this.pathToUri(filePath);
           const content = await this.getDocumentContent(filePath);
           if (!content) {
             return null;
           }
           await client.openDocument(uri, content);
+          if (!client.isReady()) {
+            return null;
+          }
           const position = { line, character: column };
           const locations = await client.gotoDefinition(uri, position);
-          await client.closeDocument(uri);
           return locations.length > 0 ? locations[0] : null;
         } catch (error40) {
           console.debug("LSP findDefinition error:", error40);
           return null;
+        } finally {
+          if (uri) {
+            try {
+              await client.closeDocument(uri);
+            } catch {
+            }
+          }
         }
       }
       async findReferences(filePath, line, column, maxResults = 100) {
@@ -458444,20 +458603,30 @@ var init_LSPManager = __esm({
         if (!client) {
           return [];
         }
+        let uri;
         try {
-          const uri = this.pathToUri(filePath);
+          uri = this.pathToUri(filePath);
           const content = await this.getDocumentContent(filePath);
           if (!content) {
             return [];
           }
           await client.openDocument(uri, content);
+          if (!client.isReady()) {
+            return [];
+          }
           const position = { line, character: column };
           const locations = await client.findReferences(uri, position, false);
-          await client.closeDocument(uri);
           return locations.slice(0, maxResults);
         } catch (error40) {
           console.debug("LSP findReferences error:", error40);
           return [];
+        } finally {
+          if (uri) {
+            try {
+              await client.closeDocument(uri);
+            } catch {
+            }
+          }
         }
       }
       async getDocumentSymbols(filePath) {
@@ -458469,19 +458638,29 @@ var init_LSPManager = __esm({
         if (!client) {
           return null;
         }
+        let uri;
         try {
-          const uri = this.pathToUri(filePath);
+          uri = this.pathToUri(filePath);
           const content = await this.getDocumentContent(filePath);
           if (!content) {
             return null;
           }
           await client.openDocument(uri, content);
+          if (!client.isReady()) {
+            return null;
+          }
           const symbols2 = await client.documentSymbol(uri);
-          await client.closeDocument(uri);
           return symbols2;
         } catch (error40) {
           console.debug("LSP documentSymbol error:", error40);
           return null;
+        } finally {
+          if (uri) {
+            try {
+              await client.closeDocument(uri);
+            } catch {
+            }
+          }
         }
       }
       async getHoverInfo(filePath, line, column) {
@@ -458493,20 +458672,30 @@ var init_LSPManager = __esm({
         if (!client) {
           return null;
         }
+        let uri;
         try {
-          const uri = this.pathToUri(filePath);
+          uri = this.pathToUri(filePath);
           const content = await this.getDocumentContent(filePath);
           if (!content) {
             return null;
           }
           await client.openDocument(uri, content);
+          if (!client.isReady()) {
+            return null;
+          }
           const position = { line, character: column };
           const hover = await client.hover(uri, position);
-          await client.closeDocument(uri);
           return hover;
         } catch (error40) {
           console.debug("LSP hover error:", error40);
           return null;
+        } finally {
+          if (uri) {
+            try {
+              await client.closeDocument(uri);
+            } catch {
+            }
+          }
         }
       }
       async getDocumentContent(filePath) {
@@ -458641,6 +458830,8 @@ var init_HybridCodeSearchService = __esm({
         const timeoutMs = contextFile.endsWith(".cs") ? this.csharpLspTimeout : this.lspTimeout;
         const timeoutPromise = new Promise((resolve13) => setTimeout(() => resolve13(null), timeoutMs));
         const lspPromise = this.lspManager.findDefinition(contextFile, position.line, position.column);
+        lspPromise.catch(() => {
+        });
         const location = await Promise.race([lspPromise, timeoutPromise]);
         if (!location) {
           return null;
@@ -458662,6 +458853,8 @@ var init_HybridCodeSearchService = __esm({
         try {
           const timeoutPromise = new Promise((resolve13) => setTimeout(() => resolve13(null), this.lspTimeout));
           const lspPromise = this.lspManager.getDocumentSymbols(filePath);
+          lspPromise.catch(() => {
+          });
           const symbols2 = await Promise.race([lspPromise, timeoutPromise]);
           if (symbols2 && symbols2.length > 0) {
             return this.convertLSPSymbolsToCodeSymbols(symbols2, filePath);
@@ -467773,22 +467966,36 @@ function millisecondsToLabel(intervalMs) {
   }
   return `${intervalMs / 1e3}s`;
 }
+function parseDurationString(durationStr) {
+  const pattern = /(\d+)\s*([a-zA-Z]+)/g;
+  let match;
+  let totalMs = 0;
+  while ((match = pattern.exec(durationStr)) !== null) {
+    const value = Number.parseInt(match[1], 10);
+    const unit = match[2];
+    totalMs += unitToMilliseconds(value, unit);
+  }
+  if (totalMs <= 0) {
+    throw new Error("Invalid duration string.");
+  }
+  return totalMs;
+}
 function formatTimestamp(timestamp) {
   return new Date(timestamp).toLocaleString();
 }
 function parseLoopSchedule(rawArgs) {
   const args2 = (rawArgs == null ? void 0 : rawArgs.trim()) || "";
   if (!args2) {
-    throw new Error("Usage: /loop 5m <prompt> | /loop <prompt> every 2 hours | /loop list | /loop cancel <id> | /loop tasks");
+    throw new Error("Usage: /loop 5m <prompt> | /loop 8h30m <prompt> | /loop <prompt> every 2 hours | /loop list | /loop cancel <id> | /loop tasks");
   }
-  if (/^\d+\s*[a-zA-Z]+$/.test(args2)) {
+  if (/^(?:\d+\s*[a-zA-Z]+\s*)+\s*$/.test(args2)) {
     throw new Error("Loop prompt is required after the interval.");
   }
-  const prefixMatch = args2.match(/^(\d+)\s*([a-zA-Z]+)\s+([\s\S]+)$/);
-  if ((prefixMatch == null ? void 0 : prefixMatch[1]) && prefixMatch[2] && prefixMatch[3]) {
-    const intervalMs = unitToMilliseconds(Number.parseInt(prefixMatch[1], 10), prefixMatch[2]);
+  const prefixMatch = args2.match(/^((?:\d+\s*[a-zA-Z]+\s*)+?)\s+([\s\S]+)$/);
+  if ((prefixMatch == null ? void 0 : prefixMatch[1]) && prefixMatch[2]) {
+    const intervalMs = parseDurationString(prefixMatch[1]);
     return {
-      prompt: prefixMatch[3].trim(),
+      prompt: prefixMatch[2].trim(),
       intervalMs,
       intervalLabel: millisecondsToLabel(intervalMs)
     };
@@ -467965,7 +468172,7 @@ var init_loop = __esm({
     "use strict";
     init_commandExecutor();
     init_loopManager();
-    LOOP_USAGE = "Usage: /loop 5m <prompt> | /loop <prompt> every 2 hours | /loop list | /loop cancel <id> | /loop tasks";
+    LOOP_USAGE = "Usage: /loop 5m <prompt> | /loop 8h30m <prompt> | /loop <prompt> every 2 hours | /loop list | /loop cancel <id> | /loop tasks";
     registerCommand("loop", {
       execute: async (args2) => {
         const trimmedArgs = args2 == null ? void 0 : args2.trim();
@@ -602100,7 +602307,7 @@ var require_package3 = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "snow-ai",
-      version: "0.7.15",
+      version: "0.7.16",
       description: "Agentic coding in your terminal",
       license: "MIT",
       bin: {
@@ -603602,6 +603809,28 @@ process.emitWarning = function(warning, ...args2) {
     return;
   return originalEmitWarning.apply(process, [warning, ...args2]);
 };
+function isStreamDestroyedError(err) {
+  if (!(err instanceof Error))
+    return false;
+  const code = err.code;
+  if (code === "ERR_STREAM_DESTROYED" || code === "EPIPE")
+    return true;
+  const msg = err.message || "";
+  return msg.includes("stream was destroyed") || msg.includes("ERR_STREAM_DESTROYED") || msg.includes("write after end") || msg.includes("Cannot call write after a stream was destroyed");
+}
+process.on("uncaughtException", (err) => {
+  if (isStreamDestroyedError(err)) {
+    return;
+  }
+  console.error("Uncaught Exception:", err);
+  process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+  if (isStreamDestroyedError(reason)) {
+    return;
+  }
+  console.error("Unhandled Rejection:", reason);
+});
 var args = process.argv.slice(2);
 var isQuickCommand = args.some((arg) => arg === "--version" || arg === "-v" || arg === "--help" || arg === "-h" || arg === "--acp" || arg === "--sse" || arg === "--sse-daemon");
 if (!isQuickCommand) {

package/bundle/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.7.15",
+	"version": "0.7.16",
 	"description": "Agentic coding in your terminal",
 	"license": "MIT",
 	"bin": {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.7.15",
+	"version": "0.7.16",
 	"description": "Agentic coding in your terminal",
 	"license": "MIT",
 	"bin": {