wispy-cli 1.1.1 → 1.1.2

package/core/engine.mjs

@@ -1009,6 +1009,9 @@ export class WispyEngine {
 
   destroy() {
     try { this.mcpManager.disconnectAll(); } catch {}
+    try { this.sessions.destroyAll?.(); } catch {}
+    try { this.subagents.killAll?.(); } catch {}
+    try { this.audit.close?.(); } catch {}
   }
 }
 

package/core/providers.mjs

@@ -345,7 +345,7 @@ export class ProviderRegistry {
     if (this._provider === "openrouter") headers["HTTP-Referer"] = "https://wispy.dev";
 
     const supportsTools = !["ollama"].includes(this._provider);
-    const body = { model, messages: openaiMessages, temperature: 0.7, max_tokens: 4096 };
+    const body = { model, messages: openaiMessages, temperature: 0.7, max_tokens: 4096, stream: true };
     if (supportsTools && tools.length > 0) {
       body.tools = tools.map(t => ({
         type: "function",
@@ -364,24 +364,65 @@ export class ProviderRegistry {
       throw new Error(`OpenAI API error ${response.status}: ${err.slice(0, 300)}`);
     }
 
-    const data = await response.json();
-    const choice = data.choices?.[0];
-    if (!choice) throw new Error("No response from OpenAI");
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let fullText = "";
+    const toolCallsMap = {};
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6).trim();
+        if (!data || data === "[DONE]") continue;
+
+        try {
+          const event = JSON.parse(data);
+          const delta = event.choices?.[0]?.delta;
+          if (!delta) continue;
+
+          // Text content
+          if (delta.content) {
+            fullText += delta.content;
+            opts.onChunk?.(delta.content);
+          }
+
+          // Tool calls (streamed as incremental chunks)
+          if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              const idx = tc.index ?? 0;
+              if (!toolCallsMap[idx]) {
+                toolCallsMap[idx] = { id: tc.id ?? `call_${idx}`, name: "", arguments: "" };
+              }
+              if (tc.id) toolCallsMap[idx].id = tc.id;
+              if (tc.function?.name) toolCallsMap[idx].name += tc.function.name;
+              if (tc.function?.arguments) toolCallsMap[idx].arguments += tc.function.arguments;
+            }
+          }
+        } catch { /* skip malformed chunks */ }
+      }
+    }
 
-    if (choice.message?.tool_calls?.length > 0) {
-      const calls = choice.message.tool_calls.map(tc => ({
+    const toolCalls = Object.values(toolCallsMap);
+    if (toolCalls.length > 0) {
+      const calls = toolCalls.map(tc => ({
         id: tc.id,
-        name: tc.function.name,
-        args: JSON.parse(tc.function.arguments),
+        name: tc.name,
+        args: (() => { try { return JSON.parse(tc.arguments); } catch { return {}; } })(),
       }));
       this._sessionTokens.output += this._estimateTokens(JSON.stringify(calls));
       return { type: "tool_calls", calls };
     }
 
-    const text = choice.message?.content ?? "";
-    this._sessionTokens.output += this._estimateTokens(text);
-    opts.onChunk?.(text);
-    return { type: "text", text };
+    this._sessionTokens.output += this._estimateTokens(fullText);
+    return { type: "text", text: fullText };
   }
 
   formatCost() {

package/core/tools.mjs

@@ -337,10 +337,18 @@ export class ToolRegistry {
     try {
       const serverUrl = `http://127.0.0.1:${DEFAULT_SERVER_PORT}`;
       if (name === "read_file") {
+        // Resolve path relative to process.cwd() before sending to server
+        let resolvedPath = args.path.replace(/^~/, os.homedir());
+        if (!path.isAbsolute(resolvedPath)) {
+          resolvedPath = path.resolve(process.cwd(), resolvedPath);
+        }
+        if (process.env.WISPY_DEBUG) {
+          process.stderr.write(`[wispy] read_file via server: "${args.path}" → "${resolvedPath}"\n`);
+        }
         const resp = await fetch(`${serverUrl}/api/node-filesystem-actions`, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ subAction: "read_file", path: args.path }),
+          body: JSON.stringify({ subAction: "read_file", path: resolvedPath }),
           signal: AbortSignal.timeout(10_000),
         });
         const data = await resp.json();
@@ -386,7 +394,13 @@ export class ToolRegistry {
     try {
       switch (name) {
         case "read_file": {
-          const filePath = args.path.replace(/^~/, os.homedir());
+          let filePath = args.path.replace(/^~/, os.homedir());
+          if (!path.isAbsolute(filePath)) {
+            filePath = path.resolve(process.cwd(), filePath);
+          }
+          if (process.env.WISPY_DEBUG) {
+            process.stderr.write(`[wispy] read_file: "${args.path}" → "${filePath}"\n`);
+          }
           const content = await readFile(filePath, "utf8");
           const truncated = content.length > 10_000
             ? content.slice(0, 10_000) + `\n\n... (truncated, ${content.length} chars total)`
@@ -395,7 +409,10 @@ export class ToolRegistry {
         }
 
         case "write_file": {
-          const filePath = args.path.replace(/^~/, os.homedir());
+          let filePath = args.path.replace(/^~/, os.homedir());
+          if (!path.isAbsolute(filePath)) {
+            filePath = path.resolve(process.cwd(), filePath);
+          }
           const dir = path.dirname(filePath);
           await mkdir(dir, { recursive: true });
           await writeFile(filePath, args.content, "utf8");
@@ -453,7 +470,10 @@ export class ToolRegistry {
         }
 
         case "file_edit": {
-          const filePath = args.path.replace(/^~/, os.homedir());
+          let filePath = args.path.replace(/^~/, os.homedir());
+          if (!path.isAbsolute(filePath)) {
+            filePath = path.resolve(process.cwd(), filePath);
+          }
           const content = await readFile(filePath, "utf8");
           if (!content.includes(args.old_text)) {
             return { success: false, error: `Text not found in ${filePath}` };

package/lib/wispy-repl.mjs

@@ -865,8 +865,11 @@ async function runOneShot(engine, message) {
     } else {
       console.error(red(`\n❌ ${err.message.slice(0, 200)}`));
     }
+    engine.destroy();
     process.exit(1);
   }
+  engine.destroy();
+  process.exit(0);
 }
 
 // ---------------------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wispy-cli",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "🌿 Wispy — AI workspace assistant with multi-agent orchestration and multi-channel bot support",
   "license": "MIT",
   "author": "Minseo & Poropo",