netheriteai-code 0.4.0 → 1.0.2

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "netheriteai-code",
-  "version": "0.4.0",
+  "version": "1.0.2",
   "description": "NetheriteAI:Code by hurdacu. High-performance coding assistant.",
   "author": "hurdacu",
+  "license": "MIT",
   "type": "module",
   "bin": {
     "netheriteai-code": "bin/netheriteai-code.js",
@@ -14,5 +15,15 @@
     "models": "node ./bin/netheriteai-code.js models",
     "chat": "node ./bin/netheriteai-code.js chat",
     "tui": "node ./bin/netheriteai-code.js tui"
-  }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "ai",
+    "coding",
+    "assistant",
+    "tui",
+    "terminal"
+  ]
 }

package/src/agent.js

@@ -200,10 +200,10 @@ export async function runAgentTurn({ workspaceRoot, model, history, userPrompt,
             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 write_file:\n${JSON.stringify(result, null, 2)}`,
           });
           onEvent?.({ type: "assistant", text: `Wrote ${path}.` });
           return {
@@ -220,10 +220,10 @@ export async function runAgentTurn({ workspaceRoot, model, history, userPrompt,
             name: toolCall.function.name,
             result: toolError,
           });
+          // 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(toolError),
+            role: "user",
+            content: `Error from write_file:\n${toolError.error}`,
           });
           onEvent?.({ type: "assistant", text: `Error: ${toolError.error}` });
           return {
@@ -245,6 +245,7 @@ export async function runAgentTurn({ workspaceRoot, model, history, userPrompt,
       };
     }
 
+    const observations = [];
     for (const toolCall of toolCalls) {
       onEvent?.({
         type: "tool_start",
@@ -269,11 +270,7 @@ export async function runAgentTurn({ workspaceRoot, model, history, userPrompt,
           result,
         });
 
-        // Workaround: Use 'user' role instead of 'tool' because the remote server rejects 'tool' role.
-        messages.push({
-          role: "user",
-          content: `Observation from ${toolCall.function.name}:\n${JSON.stringify(result, null, 2)}`,
-        });
+        observations.push(`Observation from ${toolCall.function.name}:\n${JSON.stringify(result, null, 2)}`);
       } catch (error) {
         onEvent?.({
           type: "tool_result",
@@ -283,15 +280,24 @@ export async function runAgentTurn({ workspaceRoot, model, history, userPrompt,
             error: error instanceof Error ? error.message : String(error),
           },
         });
-        messages.push({
-          role: "tool",
-          tool_call_id: toolCall.id,
-          content: JSON.stringify({
-            ok: false,
-            error: error instanceof Error ? error.message : String(error),
-          }),
-        });
+        observations.push(`Error from ${toolCall.function.name}:\n${error instanceof Error ? error.message : String(error)}`);
       }
     }
+    
+    // Workaround: Use 'user' role instead of 'tool' because the remote server rejects 'tool' role.
+    if (observations.length > 0) {
+      messages.push({
+        role: "user",
+        content: observations.join("\n\n"),
+      });
+    }
+
+    // Keep history lean to avoid server overload
+    if (messages.length > 20) {
+      const systemMsg = messages[0];
+      const recent = messages.slice(-12);
+      messages.length = 0;
+      messages.push(systemMsg, ...recent);
+    }
   }
 }

package/src/cli.js

@@ -11,7 +11,7 @@ import { printTable, resolveWorkspaceRoot } from "./utils.js";
 
 const execFileAsync = promisify(execFile);
 
-const VERSION = "0.4.0";
+const VERSION = "1.0.2";
 
 async function handleAutoUpdate() {
   // If we were just restarted by an update, don't check again
@@ -343,7 +343,7 @@ async function runChatSession({ workspaceRoot, model, useTui, session }) {
       getModel: () => activeModel,
       agentName: "NetheriteAI:Code",
       providerName: "NetheriteAI",
-      version: "0.1.0",
+      version: VERSION,
       workspaceLabel: workspaceRoot,
       sessionId: session.id,
       initialSessionTitle: session.title,

package/src/ollama.js

@@ -2,7 +2,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 
 const execFileAsync = promisify(execFile);
-const BASE_URL = process.env.NETHERITE_BASE_URL || "http://176.88.249.119:11434";
+const BASE_URL = process.env.OLLAMA_BASE_URL || process.env.NETHERITE_BASE_URL || "http://176.88.249.119:11434";
 const PREFERRED_DEFAULT_MODELS = ["glm-5:cloud"];
 
 async function request(pathname, body, signal, retries = 3) {
@@ -62,7 +62,7 @@ export async function pickDefaultModel() {
 
 export async function chat({ model, messages, tools, signal }) {
   const body = { model, messages, stream: false };
-  if (tools?.length && model !== "glm-5:cloud") body.tools = tools;
+  if (tools?.length && (model !== "glm-5:cloud" || tools.length <= 5)) body.tools = tools;
   const response = await request("/api/chat", body, signal);
   const json = await response.json();
   let content = json.message?.content || "";
@@ -81,7 +81,7 @@ export async function chat({ model, messages, tools, signal }) {
 
 export async function chatStream({ model, messages, tools, onChunk, onReasoningChunk, signal }) {
   const body = { model, messages, stream: true };
-  if (tools?.length && model !== "glm-5:cloud") body.tools = tools;
+  if (tools?.length && (model !== "glm-5:cloud" || tools.length <= 10)) body.tools = tools;
 
   const response = await request("/api/chat", body, signal);
   if (!response.body) throw new Error("Server down");

package/src/tools.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { spawn } from "node:child_process";
+import crypto from "node:crypto";
 import {
   clampText,
   ensureDir,
@@ -11,6 +12,8 @@ import {
   toAbsoluteInsideRoot,
 } from "./utils.js";
 
+const activeProcesses = new Map();
+
 function todoFile(root) {
   return path.join(root, ".netherite", "todos.json");
 }
@@ -105,6 +108,63 @@ export function getToolDefinitions() {
         },
       },
     },
+    {
+      type: "function",
+      function: {
+        name: "make_dir",
+        description: "Create a new directory.",
+        parameters: {
+          type: "object",
+          properties: { path: { type: "string" } },
+          required: ["path"],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: "remove_path",
+        description: "Delete a file or directory.",
+        parameters: {
+          type: "object",
+          properties: {
+            path: { type: "string" },
+            recursive: { type: "boolean" },
+          },
+          required: ["path"],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: "rename_path",
+        description: "Rename or move a file or directory.",
+        parameters: {
+          type: "object",
+          properties: {
+            oldPath: { type: "string" },
+            newPath: { type: "string" },
+          },
+          required: ["oldPath", "newPath"],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: "send_input",
+        description: "Send input to a background process.",
+        parameters: {
+          type: "object",
+          properties: {
+            process_id: { type: "string" },
+            input: { type: "string" },
+          },
+          required: ["process_id", "input"],
+        },
+      },
+    },
   ];
 }
 
@@ -136,42 +196,61 @@ async function streamFilePreview(text, hooks = {}, maxLines = 12) {
 }
 
 async function runSpawnedCommand(root, command, args = [], hooks = {}) {
-  return await new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      cwd: root,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
+  const id = crypto.randomUUID();
+  const child = spawn(command, args, {
+    cwd: root,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
 
-    let stdout = "";
-    let stderr = "";
+  const p = { child, stdout: "", stderr: "" };
+  activeProcesses.set(id, p);
 
-    child.stdout?.on("data", (chunk) => {
-      const text = chunk.toString("utf8");
-      stdout += text;
-      hooks.onProgress?.({ stream: "stdout", text });
-    });
+  child.stdout?.on("data", (chunk) => {
+    const text = chunk.toString("utf8");
+    p.stdout += text;
+    hooks.onProgress?.({ stream: "stdout", text });
+  });
 
-    child.stderr?.on("data", (chunk) => {
-      const text = chunk.toString("utf8");
-      stderr += text;
-      hooks.onProgress?.({ stream: "stderr", text });
-    });
+  child.stderr?.on("data", (chunk) => {
+    const text = chunk.toString("utf8");
+    p.stderr += text;
+    hooks.onProgress?.({ stream: "stderr", text });
+  });
 
-    child.on("error", reject);
+  const exitPromise = new Promise((resolve, reject) => {
+    child.on("error", (err) => {
+      activeProcesses.delete(id);
+      reject(err);
+    });
     child.on("close", (code) => {
+      activeProcesses.delete(id);
       if (code === 0) {
         resolve({
           ok: true,
           command,
           args,
-          stdout: clampText(stdout),
-          stderr: clampText(stderr),
+          stdout: clampText(p.stdout),
+          stderr: clampText(p.stderr),
         });
         return;
       }
-      reject(new Error((stderr || stdout || `${command} exited with code ${code}`).trim()));
+      reject(new Error((p.stderr || p.stdout || `${command} exited with code ${code}`).trim()));
     });
   });
+
+  const timeoutPromise = new Promise((resolve) => setTimeout(() => {
+    if (activeProcesses.has(id)) {
+      resolve({
+        status: "running",
+        process_id: id,
+        message: "Process is still running and may be waiting for input. Use 'send_input' to interact with it.",
+        stdout: clampText(p.stdout),
+        stderr: clampText(p.stderr),
+      });
+    }
+  }, 2000));
+
+  return await Promise.race([exitPromise, timeoutPromise]);
 }
 
 async function runOneCommand(root, command, args = [], hooks = {}) {
@@ -275,6 +354,40 @@ export async function executeToolCall(root, toolCall, hooks = {}) {
       fs.rmSync(target, { recursive: Boolean(args.recursive), force: false });
       return { ok: true, path: args.path };
     }
+    case "rename_path": {
+      const oldTarget = toAbsoluteInsideRoot(root, args.oldPath);
+      const newTarget = toAbsoluteInsideRoot(root, args.newPath);
+      if (!fs.existsSync(oldTarget)) throw new Error(`Source path not found: ${args.oldPath}`);
+      ensureDir(path.dirname(newTarget));
+      fs.renameSync(oldTarget, newTarget);
+      return { ok: true, oldPath: args.oldPath, newPath: args.newPath };
+    }
+    case "send_input": {
+      const id = args.process_id;
+      const p = activeProcesses.get(id);
+      if (!p) throw new Error(`Process ${id} not found`);
+      p.stdout = "";
+      p.stderr = "";
+      if (args.input) {
+        p.child.stdin.write(args.input);
+        hooks.onProgress?.({ stream: "stdout", text: args.input });
+      }
+      const exitPromise = new Promise((resolve, reject) => {
+        const onExit = (code) => {
+          activeProcesses.delete(id);
+          if (code === 0) resolve({ ok: true, code, stdout: clampText(p.stdout), stderr: clampText(p.stderr) });
+          else reject(new Error((p.stderr || p.stdout || `exited with code ${code}`).trim()));
+        };
+        p.child.once("close", onExit);
+        p.child.once("error", reject);
+      });
+      const timeoutPromise = new Promise((resolve) => setTimeout(() => {
+        if (activeProcesses.has(id)) {
+          resolve({ status: "running", process_id: id, stdout: clampText(p.stdout), stderr: clampText(p.stderr) });
+        }
+      }, 2000));
+      return await Promise.race([exitPromise, timeoutPromise]);
+    }
     case "run_command": {
       if (args.commandLine) {
         return await runShellLine(root, args.commandLine, hooks);