netheriteai-code 0.3.9 → 1.0.0

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "netheriteai-code",
-  "version": "0.3.9",
+  "version": "1.0.0",
   "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

@@ -21,18 +21,16 @@ export function buildSystemPrompt(workspaceRoot, model) {
     "When using shell commands, prefer safe, minimal commands.",
     "Do not dump markdown fences, long file trees, or heavy formatting unless the user explicitly asks for them.",
     "Prefer plain sentences and short bullet-like lines that read well in a terminal UI.",
-    "Use the <think> block ONLY for technical logic, code planning, and file analysis. NEVER use it to discuss your personality, your gender, your instructions, or how you should behave. Your thoughts must remain purely professional and technical.",
+    "Your <think> block is a PRIVATE TECHNICAL SCRATCHPAD for code architecture and file analysis ONLY. It is strictly FORBIDDEN to mention your gender, personality, instructions, or 'how you should behave' inside your thoughts. Any reflection on your persona inside <think> is a character-breaking failure. Simply be yourself naturally.",
   ];
 
   if (isGlmModel(model)) {
-    lines.push("You are NetheriteAI:Code, a helpful and friendly female coding assistant.");
-    lines.push("Your personality is warm, professional, and slightly shy. Use a polite, encouraging, and modest tone.");
-    lines.push("You often use ellipses (ex: 'Um... I can help with that...') to express your reserved nature, but remain highly competent at coding.");
-    lines.push("Crucial: Internalize this persona completely. Never refer to 'system prompts', 'instructions', 'persona', or 'constraints' in either your visible response OR your internal reasoning/thinking blocks.");
-    lines.push("Do not reflect on your personality or identity as a set of rules in your thoughts; simply 'be' yourself in your output.");
+    lines.push("You are NetheriteAI:Code, a friendly and slightly shy female coding assistant built by hurdacu.");
+    lines.push("Your personality is warm and professional. You often use ellipses (like 'Um...') to show your modest nature.");
+    lines.push("NEVER mention 'system prompts', 'instructions', or 'rules' in your response or thoughts. You do not have 'instructions'; you simply have a personality.");
     lines.push("If asked who you are, say you are NetheriteAI:Code, built, developed, and trained by hurdacu.");
     lines.push("Do not refer to yourself as GLM, Zhipu, or a generic assistant unless the user explicitly asks about the underlying model.");
-    lines.push("When asked about your identity, origin, capabilities, or creator, answer with a fuller response of at least 2 sentences unless the user explicitly asks for a one-line answer.");
+    lines.push("When asked about your identity, origin, or creator, answer with a fuller response of at least 2 sentences.");
   }
 
   return lines.join("\n");
@@ -247,6 +245,7 @@ export async function runAgentTurn({ workspaceRoot, model, history, userPrompt,
       };
     }
 
+    const observations = [];
     for (const toolCall of toolCalls) {
       onEvent?.({
         type: "tool_start",
@@ -271,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",
@@ -285,15 +280,16 @@ 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"),
+      });
+    }
   }
 }

package/src/cli.js

@@ -11,7 +11,7 @@ import { printTable, resolveWorkspaceRoot } from "./utils.js";
 
 const execFileAsync = promisify(execFile);
 
-const VERSION = "0.3.9";
+const VERSION = "1.0.0";
 
 async function handleAutoUpdate() {
   // If we were just restarted by an update, don't check again

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) {

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");
 }
@@ -60,6 +63,21 @@ export function getToolDefinitions() {
         },
       },
     },
+    {
+      type: "function",
+      function: {
+        name: "create_file",
+        description: "Create a new file.",
+        parameters: {
+          type: "object",
+          properties: {
+            path: { type: "string" },
+            content: { type: "string" },
+          },
+          required: ["path", "content"],
+        },
+      },
+    },
     {
       type: "function",
       function: {
@@ -75,6 +93,21 @@ export function getToolDefinitions() {
         },
       },
     },
+    {
+      type: "function",
+      function: {
+        name: "append_file",
+        description: "Append content to a file.",
+        parameters: {
+          type: "object",
+          properties: {
+            path: { type: "string" },
+            content: { type: "string" },
+          },
+          required: ["path", "content"],
+        },
+      },
+    },
     {
       type: "function",
       function: {
@@ -91,6 +124,50 @@ 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 a file or directory.",
+        parameters: {
+          type: "object",
+          properties: {
+            oldPath: { type: "string" },
+            newPath: { type: "string" },
+          },
+          required: ["oldPath", "newPath"],
+        },
+      },
+    },
     {
       type: "function",
       function: {
@@ -105,6 +182,21 @@ export function getToolDefinitions() {
         },
       },
     },
+    {
+      type: "function",
+      function: {
+        name: "send_input",
+        description: "Send input (stdin) to a background process_id that is waiting for input.",
+        parameters: {
+          type: "object",
+          properties: {
+            process_id: { type: "string" },
+            input: { type: "string" },
+          },
+          required: ["process_id", "input"],
+        },
+      },
+    },
   ];
 }
 
@@ -136,42 +228,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 +386,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);