netheriteai-code 0.3.4 → 0.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "netheriteai-code",
-  "version": "0.3.4",
+  "version": "0.3.7",
   "description": "NetheriteAI:Code by hurdacu. High-performance coding assistant.",
   "author": "hurdacu",
   "type": "module",

package/src/agent.js

@@ -160,6 +160,14 @@ export async function runAgentTurn({ workspaceRoot, model, history, userPrompt,
     }
     messages.push(assistantMessage);
 
+    // Keep history lean to avoid server overload
+    if (messages.length > 15) {
+      const systemMsg = messages[0];
+      const recent = messages.slice(-10);
+      messages.length = 0;
+      messages.push(systemMsg, ...recent);
+    }
+
     if (singleFileTurn) {
       const generated = extractGeneratedCode(assistant.content || "");
       if (generated?.code) {
@@ -255,15 +263,17 @@ export async function runAgentTurn({ workspaceRoot, model, history, userPrompt,
             });
           },
         });
+
         onEvent?.({
           type: "tool_result",
           name: toolCall.function.name,
           result,
         });
+
+        // Workaround: Use 'user' role instead of 'tool' because the remote server rejects 'tool' role.
         messages.push({
-          role: "tool",
-          tool_call_id: toolCall.id,
-          content: JSON.stringify(result),
+          role: "user",
+          content: `Observation from ${toolCall.function.name}:\n${JSON.stringify(result, null, 2)}`,
         });
       } catch (error) {
         onEvent?.({

package/src/cli.js

@@ -11,9 +11,12 @@ import { printTable, resolveWorkspaceRoot } from "./utils.js";
 
 const execFileAsync = promisify(execFile);
 
-const VERSION = "0.3.4";
+const VERSION = "0.3.7";
 
 async function handleAutoUpdate() {
+  // If we were just restarted by an update, don't check again
+  if (process.argv.includes("--no-update")) return;
+
   try {
     const latest = execSync("npm view netheriteai-code version", {
       encoding: "utf8",
@@ -52,7 +55,8 @@ async function handleAutoUpdate() {
       process.stdout.write(`\u001b[${y};${dx}H\u001b[1m${doneMsg}\u001b[0m`);
       process.stdout.write("\u001b[?1049l");
 
-      spawn(process.argv[0], process.argv.slice(1), { stdio: "inherit", detached: false });
+      // Pass the skip flag to the restarted process to prevent looping
+      spawn(process.argv[0], [...process.argv.slice(1), "--no-update"], { stdio: "inherit", detached: false });
       process.exit(0);
     }
   } catch {

package/src/ollama.js

@@ -3,9 +3,7 @@ import { promisify } from "node:util";
 
 const execFileAsync = promisify(execFile);
 const BASE_URL = process.env.NETHERITE_BASE_URL || "http://176.88.249.119:11434";
-const PREFERRED_DEFAULT_MODELS = [
-  "glm-5:cloud",
-];
+const PREFERRED_DEFAULT_MODELS = ["glm-5:cloud"];
 
 async function request(pathname, body, signal, retries = 3) {
   for (let i = 0; i < retries; i++) {
@@ -18,13 +16,10 @@ async function request(pathname, body, signal, retries = 3) {
       });
 
       if (response.ok) return response;
-      
-      // If 500 error, wait and retry
       if (response.status === 500 && i < retries - 1) {
         await new Promise(r => setTimeout(r, 1000));
         continue;
       }
-
       throw new Error("Server down");
     } catch (err) {
       if (err.name === "AbortError") throw err;
@@ -40,16 +35,14 @@ async function request(pathname, body, signal, retries = 3) {
 export async function listModels() {
   try {
     const response = await fetch(`${BASE_URL}/api/tags`);
-    if (!response.ok) {
-      throw new Error("Server down");
-    }
+    if (!response.ok) throw new Error("Server down");
     const json = await response.json();
-    return (json.models || []).map((model) => ({
-      name: model.name,
-      size: model.size,
-      modifiedAt: model.modified_at,
-      digest: model.digest,
-      details: model.details || {},
+    return (json.models || []).map(m => ({
+      name: m.name,
+      size: m.size,
+      modifiedAt: m.modified_at,
+      digest: m.digest,
+      details: m.details || {},
     }));
   } catch {
     throw new Error("Server down");
@@ -59,13 +52,9 @@ export async function listModels() {
 export async function pickDefaultModel() {
   try {
     const models = await listModels();
-    if (!models.length) {
-      throw new Error("Server down");
-    }
-    const preferredMatch = models.find((model) =>
-      PREFERRED_DEFAULT_MODELS.some((preferred) => preferred.toLowerCase() === model.name.toLowerCase()),
-    );
-    return preferredMatch ? preferredMatch.name : models[0].name;
+    if (!models.length) throw new Error("Server down");
+    const match = models.find(m => PREFERRED_DEFAULT_MODELS.some(p => p.toLowerCase() === m.name.toLowerCase()));
+    return match ? match.name : models[0].name;
   } catch {
     throw new Error("Server down");
   }
@@ -73,145 +62,81 @@ export async function pickDefaultModel() {
 
 export async function chat({ model, messages, tools, signal }) {
   const body = { model, messages, stream: false };
-  if (tools && tools.length) body.tools = tools;
-  
+  if (tools?.length && model !== "glm-5:cloud") body.tools = tools;
   const response = await request("/api/chat", body, signal);
   const json = await response.json();
-  return {
-    ...json.message,
-    reasoning: json.message?.thinking || "",
-  };
-}
-
-function createTaggedStreamParser({ onContent, onReasoning }) {
-  let buffer = "";
-  let inReasoning = false;
-  const openTag = "<think>";
-  const closeTag = "</think>";
-
-  function emitVisible(text) { if (text) onContent?.(text); }
-  function emitReasoning(text) { if (text) onReasoning?.(text); }
-
-  function flush(final = false) {
-    while (buffer.length) {
-      if (inReasoning) {
-        const closeIndex = buffer.indexOf(closeTag);
-        if (closeIndex !== -1) {
-          emitReasoning(buffer.slice(0, closeIndex));
-          buffer = buffer.slice(closeIndex + closeTag.length);
-          inReasoning = false;
-          continue;
-        }
-        if (final) {
-          emitReasoning(buffer);
-          buffer = "";
-          return;
-        }
-        if (buffer.length > closeTag.length) {
-          emitReasoning(buffer.slice(0, buffer.length - closeTag.length));
-          buffer = buffer.slice(buffer.length - closeTag.length);
-        }
-        return;
-      }
-
-      const openIndex = buffer.indexOf(openTag);
-      if (openIndex !== -1) {
-        emitVisible(buffer.slice(0, openIndex));
-        buffer = buffer.slice(openIndex + openTag.length);
-        inReasoning = true;
-        continue;
-      }
-      if (final) {
-        emitVisible(buffer);
-        buffer = "";
-        return;
-      }
-      if (buffer.length > openTag.length) {
-        emitVisible(buffer.slice(0, buffer.length - openTag.length));
-        buffer = buffer.slice(buffer.length - openTag.length);
-      }
-      return;
+  let content = json.message?.content || "";
+  let reasoning = json.message?.thinking || "";
+  
+  if (content.includes("<think>")) {
+    const parts = content.split(/<think>|<\/think>/);
+    if (parts.length >= 3) {
+      reasoning = parts[1];
+      content = (parts[0] + parts[2]).trim();
     }
   }
-
-  return {
-    push(text) { buffer += text; flush(false); },
-    finish() { flush(true); },
-  };
+  
+  return { ...json.message, content, reasoning };
 }
 
 export async function chatStream({ model, messages, tools, onChunk, onReasoningChunk, signal }) {
   const body = { model, messages, stream: true };
-  if (tools && tools.length && model !== "glm-5:cloud") body.tools = tools;
+  if (tools?.length && model !== "glm-5:cloud") body.tools = tools;
 
   const response = await request("/api/chat", body, signal);
-
-  if (!response.body) {
-    throw new Error("Server down");
-  }
+  if (!response.body) throw new Error("Server down");
 
   const decoder = new TextDecoder();
   let lineBuffer = "";
   let lastMessage = { role: "assistant", content: "", reasoning: "", tool_calls: [] };
-  const parser = createTaggedStreamParser({
-    onContent(text) {
-      lastMessage.content += text;
-      onChunk?.(text);
-    },
-    onReasoning(text) {
-      lastMessage.reasoning += text;
-      onReasoningChunk?.(text);
-    },
-  });
+  let inThinkTag = false;
 
   try {
-    // Use async iterator for better Node.js compatibility
     for await (const chunk of response.body) {
       lineBuffer += decoder.decode(chunk, { stream: true });
-      
       let lines = lineBuffer.split("\n");
       lineBuffer = lines.pop() || "";
-      
+
       for (const line of lines) {
         if (!line.trim()) continue;
         try {
           const json = JSON.parse(line);
-          const message = json.message || {};
-          if (message.thinking) {
-            lastMessage.reasoning += message.thinking;
-            onReasoningChunk?.(message.thinking);
-          }
-          if (message.content) {
-            parser.push(message.content);
+          const msg = json.message || {};
+          
+          if (msg.thinking) {
+            lastMessage.reasoning += msg.thinking;
+            onReasoningChunk?.(msg.thinking);
           }
-          if (message.tool_calls?.length) {
-            lastMessage.tool_calls = message.tool_calls;
-          }
-          if (message.role) {
-            lastMessage.role = message.role;
+
+          if (msg.content) {
+            let text = msg.content;
+            if (text.includes("<think>")) {
+              inThinkTag = true;
+              const [before, after] = text.split("<think>");
+              if (before) { lastMessage.content += before; onChunk?.(before); }
+              text = after || "";
+            }
+            if (inThinkTag && text.includes("</think>")) {
+              inThinkTag = false;
+              const [think, after] = text.split("</think>");
+              if (think) { lastMessage.reasoning += think; onReasoningChunk?.(think); }
+              text = after || "";
+            }
+
+            if (text) {
+              if (inThinkTag) {
+                lastMessage.reasoning += text;
+                onReasoningChunk?.(text);
+              } else {
+                lastMessage.content += text;
+                onChunk?.(text);
+              }
+            }
           }
-        } catch {
-          // Ignore parse errors from partial lines or server noise
-        }
-      }
-    }
-    
-    if (lineBuffer.trim()) {
-      try {
-        const json = JSON.parse(lineBuffer);
-        const message = json.message || {};
-        if (message.thinking) {
-          lastMessage.reasoning += message.thinking;
-          onReasoningChunk?.(message.thinking);
-        }
-        if (message.content) {
-          parser.push(message.content);
-        }
-        if (message.tool_calls?.length) {
-          lastMessage.tool_calls = message.tool_calls;
-        }
-      } catch {
-        // Final line noise
+
+          if (msg.tool_calls?.length) lastMessage.tool_calls = msg.tool_calls;
+          if (msg.role) lastMessage.role = msg.role;
+        } catch {}
       }
     }
   } catch (err) {
@@ -219,6 +144,5 @@ export async function chatStream({ model, messages, tools, onChunk, onReasoningC
     throw new Error("Server down");
   }
 
-  parser.finish();
   return lastMessage;
 }