netheriteai-code 0.2.5 → 0.3.0

package/package.json

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

package/src/cli.js

@@ -338,6 +338,79 @@ async function runChatSession({ workspaceRoot, model, useTui, session }) {
   }
 }
 
+export async function main() {
+  await handleAutoUpdate();
+  const { positional, flags } = parseArgs(process.argv.slice(2));
+  const command = positional[0] || "tui";
+  const requestedWorkspaceRoot = resolveWorkspaceRoot(flags.dir || flags.d || process.cwd());
+
+  if (!fs.existsSync(requestedWorkspaceRoot)) {
+    throw new Error(`Workspace does not exist: ${requestedWorkspaceRoot}`);
+  }
+
+  if (command === "help" || flags.help || flags.h) {
+    printHelp();
+    return;
+  }
+
+  if (command === "tools") {
+    printToolList();
+    return;
+  }
+
+  let session = null;
+  let workspaceRoot = requestedWorkspaceRoot;
+
+  if (command === "session") {
+    const sessionId = positional[1];
+    if (!sessionId) {
+      throw new Error("Usage: netheritecode session <id>");
+    }
+    session = loadSessionById(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    workspaceRoot = session.workspaceRoot;
+  } else {
+    session = createSession(workspaceRoot);
+  }
+
+  const model = await resolveModel(flags.model || flags.m);
+  setSelectedModel(model);
+
+  if (command === "chat") {
+    await runChatSession({ workspaceRoot, model, useTui: false, session });
+    return;
+  }
+
+  if (command === "tui" || command === "session") {
+    await runChatSession({ workspaceRoot, model, useTui: true, session });
+    return;
+  }
+
+  if (!command.startsWith("-")) {
+    const prompt = positional.join(" ");
+    const result = await runAgentTurn({
+      workspaceRoot,
+      model,
+      history: session.messages,
+      userPrompt: prompt,
+    });
+    session.messages = result.messages;
+    saveSession(session);
+    console.log(result.reply);
+    return;
+  }
+
+  printHelp();
+}
+      break;
+    }
+    await submit(prompt);
+    rl.prompt();
+  }
+}
+
 export async function main() {
   const { positional, flags } = parseArgs(process.argv.slice(2));
   const command = positional[0] || "tui";

package/src/ollama.js

@@ -7,16 +7,6 @@ const PREFERRED_DEFAULT_MODELS = [
   "glm-5:cloud",
 ];
 
-function getThinkMode(model) {
-  const override = process.env.NETHERITEAI_THINK_MODE;
-  if (override === "true") return true;
-  if (override === "false") return false;
-  if (override === "medium" || override === "low" || override === "high") return override;
-  const name = String(model || "").toLowerCase();
-  if (name.includes("gpt-oss")) return "medium";
-  return true;
-}
-
 async function request(pathname, body, signal) {
   try {
     const response = await fetch(`${BASE_URL}${pathname}`, {
@@ -31,7 +21,8 @@ async function request(pathname, body, signal) {
     }
 
     return response;
-  } catch {
+  } catch (err) {
+    if (err.name === "AbortError") throw err;
     throw new Error("Server down");
   }
 }
@@ -64,26 +55,16 @@ export async function pickDefaultModel() {
     const preferredMatch = models.find((model) =>
       PREFERRED_DEFAULT_MODELS.some((preferred) => preferred.toLowerCase() === model.name.toLowerCase()),
     );
-    if (preferredMatch) {
-      return preferredMatch.name;
-    }
-
-    const familyMatch = models.find((model) => model.name.toLowerCase().startsWith("netheriteai"));
-    return familyMatch?.name || models[0].name;
+    return preferredMatch ? preferredMatch.name : models[0].name;
   } catch {
     throw new Error("Server down");
   }
 }
 
 export async function chat({ model, messages, tools, signal }) {
-  const body = {
-    model,
-    messages,
-    stream: false,
-  };
-  if (tools && tools.length) {
-    body.tools = tools;
-  }
+  const body = { model, messages, stream: false };
+  if (tools && tools.length) body.tools = tools;
+  
   const response = await request("/api/chat", body, signal);
   const json = await response.json();
   return {
@@ -98,13 +79,8 @@ function createTaggedStreamParser({ onContent, onReasoning }) {
   const openTag = "<think>";
   const closeTag = "</think>";
 
-  function emitVisible(text) {
-    if (text) onContent?.(text);
-  }
-
-  function emitReasoning(text) {
-    if (text) onReasoning?.(text);
-  }
+  function emitVisible(text) { if (text) onContent?.(text); }
+  function emitReasoning(text) { if (text) onReasoning?.(text); }
 
   function flush(final = false) {
     while (buffer.length) {
@@ -149,34 +125,23 @@ function createTaggedStreamParser({ onContent, onReasoning }) {
   }
 
   return {
-    push(text) {
-      buffer += text;
-      flush(false);
-    },
-    finish() {
-      flush(true);
-    },
+    push(text) { buffer += text; flush(false); },
+    finish() { flush(true); },
   };
 }
 
 export async function chatStream({ model, messages, tools, onChunk, onReasoningChunk, signal }) {
-  const body = {
-    model,
-    messages,
-    stream: true,
-  };
-  if (tools && tools.length) {
-    body.tools = tools;
-  }
+  const body = { model, messages, stream: true };
+  if (tools && tools.length) body.tools = tools;
+
   const response = await request("/api/chat", body, signal);
 
-  const reader = response.body?.getReader();
-  if (!reader) {
+  if (!response.body) {
     throw new Error("Server down");
   }
 
   const decoder = new TextDecoder();
-  let buffer = "";
+  let lineBuffer = "";
   let lastMessage = { role: "assistant", content: "", reasoning: "", tool_calls: [] };
   const parser = createTaggedStreamParser({
     onContent(text) {
@@ -189,17 +154,41 @@ export async function chatStream({ model, messages, tools, onChunk, onReasoningC
     },
   });
 
-  while (true) {
-    const { value, done } = await reader.read();
-    if (done) break;
-    buffer += decoder.decode(value, { stream: true });
-
-    let newlineIndex = buffer.indexOf("\n");
-    while (newlineIndex !== -1) {
-      const line = buffer.slice(0, newlineIndex).trim();
-      buffer = buffer.slice(newlineIndex + 1);
-      if (line) {
-        const json = JSON.parse(line);
+  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);
+          }
+          if (message.tool_calls?.length) {
+            lastMessage.tool_calls = message.tool_calls;
+          }
+          if (message.role) {
+            lastMessage.role = message.role;
+          }
+        } 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;
@@ -211,33 +200,15 @@ export async function chatStream({ model, messages, tools, onChunk, onReasoningC
         if (message.tool_calls?.length) {
           lastMessage.tool_calls = message.tool_calls;
         }
-        if (message.role) {
-          lastMessage.role = message.role;
-        }
+      } catch {
+        // Final line noise
       }
-      newlineIndex = buffer.indexOf("\n");
-    }
-  }
-
-  if (buffer.trim()) {
-    const json = JSON.parse(buffer.trim());
-    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;
-    }
-    if (message.role) {
-      lastMessage.role = message.role;
     }
+  } catch (err) {
+    if (err.name === "AbortError") throw err;
+    throw new Error("Server down");
   }
 
   parser.finish();
-
   return lastMessage;
 }

package/src/tools.js

@@ -38,12 +38,12 @@ export function getToolDefinitions() {
       type: "function",
       function: {
         name: "list_files",
-        description: "List files or folders inside the workspace.",
+        description: "List files in the workspace.",
         parameters: {
           type: "object",
           properties: {
-            path: { type: "string", description: "Relative path inside the workspace." },
-            recursive: { type: "boolean", description: "Whether to recurse into child directories." },
+            path: { type: "string" },
+            recursive: { type: "boolean" },
           },
         },
       },
@@ -52,56 +52,24 @@ export function getToolDefinitions() {
       type: "function",
       function: {
         name: "read_file",
-        description: "Read a text file inside the workspace.",
+        description: "Read a file.",
         parameters: {
           type: "object",
-          properties: {
-            path: { type: "string", description: "Relative file path." },
-          },
+          properties: { path: { type: "string" } },
           required: ["path"],
         },
       },
     },
-    {
-      type: "function",
-      function: {
-        name: "create_file",
-        description: "Create a new text file inside the workspace. Fails if the file already exists.",
-        parameters: {
-          type: "object",
-          properties: {
-            path: { type: "string", description: "Relative file path." },
-            content: { type: "string", description: "Initial file content." },
-          },
-          required: ["path", "content"],
-        },
-      },
-    },
     {
       type: "function",
       function: {
         name: "write_file",
-        description: "Create or overwrite a text file inside the workspace.",
-        parameters: {
-          type: "object",
-          properties: {
-            path: { type: "string", description: "Relative file path." },
-            content: { type: "string", description: "New file content." },
-          },
-          required: ["path", "content"],
-        },
-      },
-    },
-    {
-      type: "function",
-      function: {
-        name: "append_file",
-        description: "Append text to the end of a file inside the workspace, creating it if needed.",
+        description: "Create or overwrite a file.",
         parameters: {
           type: "object",
           properties: {
-            path: { type: "string", description: "Relative file path." },
-            content: { type: "string", description: "Text to append." },
+            path: { type: "string" },
+            content: { type: "string" },
           },
           required: ["path", "content"],
         },
@@ -111,126 +79,29 @@ export function getToolDefinitions() {
       type: "function",
       function: {
         name: "edit_file",
-        description: "Edit a text file by replacing an exact string match. Safer than overwriting the whole file.",
+        description: "Edit a file by replacing text.",
         parameters: {
           type: "object",
           properties: {
-            path: { type: "string", description: "Relative file path." },
-            oldText: { type: "string", description: "Exact text to replace." },
-            newText: { type: "string", description: "Replacement text." },
-            replaceAll: { type: "boolean", description: "Replace all occurrences instead of just the first." },
+            path: { type: "string" },
+            oldText: { type: "string" },
+            newText: { type: "string" },
           },
           required: ["path", "oldText", "newText"],
         },
       },
     },
-    {
-      type: "function",
-      function: {
-        name: "make_dir",
-        description: "Create a directory inside the workspace.",
-        parameters: {
-          type: "object",
-          properties: {
-            path: { type: "string", description: "Relative directory path." },
-          },
-          required: ["path"],
-        },
-      },
-    },
-    {
-      type: "function",
-      function: {
-        name: "remove_path",
-        description: "Remove a file or directory inside the workspace.",
-        parameters: {
-          type: "object",
-          properties: {
-            path: { type: "string", description: "Relative path to delete." },
-            recursive: { type: "boolean", description: "Allow recursive directory deletion." },
-          },
-          required: ["path"],
-        },
-      },
-    },
     {
       type: "function",
       function: {
         name: "run_command",
-        description: "Run a shell command inside the workspace and capture stdout/stderr.",
-        parameters: {
-          type: "object",
-          properties: {
-            command: { type: "string", description: "Executable name, for example `npm` or `git`." },
-            args: { type: "array", items: { type: "string" }, description: "Argument array." },
-            commandLine: {
-              type: "string",
-              description: "Optional raw shell command line. Use it for pipes, redirects, globs, and shell syntax.",
-            },
-          },
-        },
-      },
-    },
-    {
-      type: "function",
-      function: {
-        name: "batch_command",
-        description: "Run multiple shell commands sequentially in the workspace.",
-        parameters: {
-          type: "object",
-          properties: {
-            commands: {
-              type: "array",
-              items: {
-                type: "object",
-                properties: {
-                  command: { type: "string" },
-                  args: { type: "array", items: { type: "string" } },
-                  commandLine: { type: "string" },
-                },
-              },
-            },
-          },
-          required: ["commands"],
-        },
-      },
-    },
-    {
-      type: "function",
-      function: {
-        name: "todo_create",
-        description: "Create a todo item for the current workspace.",
-        parameters: {
-          type: "object",
-          properties: {
-            text: { type: "string" },
-          },
-          required: ["text"],
-        },
-      },
-    },
-    {
-      type: "function",
-      function: {
-        name: "todo_list",
-        description: "List todo items for the current workspace.",
-        parameters: {
-          type: "object",
-          properties: {},
-        },
-      },
-    },
-    {
-      type: "function",
-      function: {
-        name: "todo_complete",
-        description: "Mark a todo item complete by numeric id.",
+        description: "Run a shell command.",
         parameters: {
           type: "object",
           properties: {
-            id: { type: "number" },
+            commandLine: { type: "string" },
           },
-          required: ["id"],
+          required: ["commandLine"],
         },
       },
     },