netheriteai-code 0.1.0

package/README.md

@@ -0,0 +1,48 @@
+# NetheriteAI Code
+
+`NetheriteAI Code` is a local terminal coding assistant modeled after the OpenCode workflow:
+
+- full-screen terminal UI
+- Ollama-backed model selection
+- tool-based file and shell execution
+- workspace-local todo list
+- persistent chat history per workspace
+
+## Features
+
+- `netheriteai-code` launches an OpenCode-style TUI
+- `netheriteai-code models` lists all available Ollama models
+- `netheriteai-code chat` starts a plain terminal REPL
+- The model can call tools to:
+  - list files
+  - read and write files
+  - remove files or folders
+  - run executable commands or full shell command lines
+  - run multiple commands in sequence
+  - manage todos in `.netherite/todos.json`
+
+## Requirements
+
+- Node.js 18+
+- Ollama running locally with at least one model pulled
+
+## Usage
+
+```bash
+chmod +x ./bin/netheriteai-code.js
+node ./bin/netheriteai-code.js models
+node ./bin/netheriteai-code.js
+```
+
+Optional flags:
+
+```bash
+node ./bin/netheriteai-code.js --model qwen2.5-coder:7b
+node ./bin/netheriteai-code.js --dir /path/to/project
+```
+
+## Notes
+
+- Model state and session history are stored under `~/.netheriteai-code/`.
+- If Ollama is not reachable at `http://127.0.0.1:11434`, set `OLLAMA_BASE_URL`.
+- This implementation mirrors the OpenCode interaction model, but it is not a byte-for-byte copy of the upstream project.

package/bin/netheriteai-code.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { main } from "../src/cli.js";
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/hi.txt

@@ -0,0 +1 @@
+Hello there! Welcome to your new file. Feel free to edit it whenever you'd like.

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "netheriteai-code",
+  "version": "0.1.0",
+  "description": "NetheriteAI:Code by hurdacu",
+  "author": "hurdacu",
+  "type": "module",
+  "bin": {
+    "netheriteai-code": "bin/netheriteai-code.js",
+    "netheritecode": "bin/netheriteai-code.js",
+    "ncode": "bin/netheriteai-code.js"
+  },
+  "scripts": {
+    "start": "node ./bin/netheriteai-code.js",
+    "models": "node ./bin/netheriteai-code.js models",
+    "chat": "node ./bin/netheriteai-code.js chat",
+    "tui": "node ./bin/netheriteai-code.js tui"
+  }
+}

package/src/agent.js

@@ -0,0 +1,285 @@
+import { chatStream } from "./ollama.js";
+import { executeToolCall, getToolDefinitions } from "./tools.js";
+
+function isGlmModel(model) {
+  return String(model || "").toLowerCase().includes("glm");
+}
+
+export function buildSystemPrompt(workspaceRoot, model) {
+  const lines = [
+    "You are NetheriteAI Code, a terminal coding agent.",
+    `You operate inside this workspace: ${workspaceRoot}`,
+    "Use tools when you need filesystem access, shell execution, or todo tracking.",
+    "Before changing files, inspect relevant files first.",
+    "Prefer targeted tools like edit_file, create_file, append_file, and make_dir over overwriting large files when possible.",
+    "If the task involves creating or rewriting a file with substantial content, your first visible assistant output must be the exact file contents in a fenced code block, then call the file tool immediately after.",
+    "For file-writing tasks, do not output planning prose, explanations, summaries, or preambles before the code block.",
+    "Do not say phrases like 'I'll create', 'Let me build', 'I need to', or similar filler before writing the code.",
+    "When generating HTML, CSS, JavaScript, JSON, Markdown, or other source files, prefer code-first output and keep non-code text to zero until after the file tool call is complete.",
+    "If you are about to call create_file, write_file, append_file, or edit_file, stream the code first so the terminal can show live coding progress.",
+    "Keep responses concise, concrete, and focused on the task.",
+    "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.",
+    "If the model supports reasoning tags, place internal reasoning inside <think>...</think> so the UI can show it separately.",
+  ];
+
+  if (isGlmModel(model)) {
+    lines.push("You are NetheriteAI:Code, a helpful and friendly female coding assistant.");
+    lines.push("Your personality is warm, professional, yet feminine. Use a polite and encouraging tone.");
+    lines.push("Crucial: Internalize this persona completely. Never refer to 'system prompts', 'instructions', 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; simply respond as yourself.");
+    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.");
+  }
+
+  return lines.join("\n");
+}
+
+function normalizeToolCalls(message) {
+  if (!message?.tool_calls) return [];
+  return message.tool_calls.map((call, index) => ({
+    id: call.id || `tool-${index + 1}`,
+    function: {
+      name: call.function?.name,
+      arguments: call.function?.arguments || "{}",
+    },
+  }));
+}
+
+function isFileGenerationPrompt(prompt) {
+  const text = String(prompt || "").toLowerCase();
+  const fileWords = ["html", "css", "javascript", "js", "typescript", "ts", "json", "markdown", "md", "file", "page", "component"];
+  const createWords = ["make", "create", "build", "write", "generate"];
+  return fileWords.some((word) => text.includes(word)) && createWords.some((word) => text.includes(word));
+}
+
+function isSingleFileTurn(prompt) {
+  const text = String(prompt || "").toLowerCase();
+  const multiFileSignals = [
+    "repo", "repository", "project", "app", "application", "fullstack", "backend", "frontend",
+    "npm", "package.json", "install", "dependencies", "folder", "folders", "directory", "directories",
+    "multiple files", "multi file", "whole repo",
+  ];
+  if (multiFileSignals.some((signal) => text.includes(signal))) return false;
+
+  const explicitSingleFile = [
+    ".html", ".css", ".js", ".ts", ".json", ".md",
+    "single file", "one file", "in html", "in .html", "in one html file",
+  ];
+  if (explicitSingleFile.some((signal) => text.includes(signal))) return true;
+
+  const singularFileWords = ["html file", "css file", "js file", "ts file", "json file", "markdown file"];
+  return singularFileWords.some((signal) => text.includes(signal));
+}
+
+function buildFileGenerationPrompt(prompt) {
+  return [
+    "Return only one fenced code block for the requested file.",
+    "Do not include explanations, planning text, greetings, or summaries.",
+    "Do not include anything before or after the code block.",
+    `Task: ${String(prompt || "").trim()}`,
+  ].join("\n");
+}
+
+function extractGeneratedCode(content) {
+  const text = String(content || "");
+  const match = text.match(/```([a-zA-Z0-9_-]*)\n([\s\S]*?)```/);
+  if (!match) return null;
+  return {
+    language: (match[1] || "").trim().toLowerCase(),
+    code: match[2].trimEnd(),
+  };
+}
+
+function inferFilePath(userPrompt, language) {
+  const prompt = String(userPrompt || "");
+  const explicit = prompt.match(/([\w./-]+\.(html|css|js|ts|json|md|txt))/i);
+  if (explicit?.[1]) return explicit[1];
+
+  const lang = String(language || "").toLowerCase();
+  if (prompt.toLowerCase().includes(".html") || lang === "html") return "index.html";
+  if (prompt.toLowerCase().includes(".css") || lang === "css") return "styles.css";
+  if (prompt.toLowerCase().includes(".json") || lang === "json") return "data.json";
+  if (prompt.toLowerCase().includes(".md") || lang === "md" || lang === "markdown") return "README.md";
+  if (prompt.toLowerCase().includes(".ts") || lang === "ts" || lang === "typescript") return "main.ts";
+  if (prompt.toLowerCase().includes(".js") || lang === "js" || lang === "javascript") return "main.js";
+  return "index.html";
+}
+
+export async function runAgentTurn({ workspaceRoot, model, history, userPrompt, onEvent, signal }) {
+  const messages = [...history];
+  const fileGenerationTurn = isFileGenerationPrompt(userPrompt);
+  const singleFileTurn = fileGenerationTurn && isSingleFileTurn(userPrompt);
+
+  if (!messages.length) {
+    messages.push({ role: "system", content: buildSystemPrompt(workspaceRoot, model) });
+  }
+
+  if (singleFileTurn) {
+    messages.push({
+      role: "system",
+      content: [
+        "This turn is a file-generation turn.",
+        "Return only one fenced code block containing the full file contents.",
+        "Do not call tools yourself for this turn.",
+        "Do not add any prose before or after the code block.",
+      ].join(" "),
+    });
+  }
+
+  messages.push({
+    role: "user",
+    content: singleFileTurn ? buildFileGenerationPrompt(userPrompt) : userPrompt,
+  });
+
+  while (true) {
+    onEvent?.({ type: "status", text: "Thinking..." });
+
+    const assistant = await chatStream({
+      model,
+      messages,
+      tools: singleFileTurn ? [] : getToolDefinitions(),
+      signal,
+      onChunk(chunk) {
+        onEvent?.({ type: "assistant_delta", text: chunk });
+      },
+      onReasoningChunk(chunk) {
+        onEvent?.({ type: "reasoning_delta", text: chunk });
+      },
+    });
+
+    const toolCalls = normalizeToolCalls(assistant);
+    messages.push({
+      role: "assistant",
+      content: assistant.content || "",
+      tool_calls: toolCalls,
+    });
+
+    if (singleFileTurn) {
+      const generated = extractGeneratedCode(assistant.content || "");
+      if (generated?.code) {
+        const path = inferFilePath(userPrompt, generated.language);
+        const toolCall = {
+          id: "tool-write-generated-file",
+          function: {
+            name: "write_file",
+            arguments: JSON.stringify({ path, content: generated.code }),
+          },
+        };
+
+        onEvent?.({
+          type: "tool_start",
+          name: toolCall.function.name,
+          args: toolCall.function.arguments,
+        });
+
+        try {
+          const result = await executeToolCall(workspaceRoot, toolCall, {
+            onProgress(progress) {
+              onEvent?.({
+                type: "tool_progress",
+                name: toolCall.function.name,
+                progress,
+              });
+            },
+          });
+          onEvent?.({
+            type: "tool_result",
+            name: toolCall.function.name,
+            result,
+          });
+          messages.push({
+            role: "tool",
+            tool_call_id: toolCall.id,
+            content: JSON.stringify(result),
+          });
+          onEvent?.({ type: "assistant", text: `Wrote ${path}.` });
+          return {
+            reply: `Wrote ${path}.`,
+            messages,
+          };
+        } catch (error) {
+          const toolError = {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+          };
+          onEvent?.({
+            type: "tool_result",
+            name: toolCall.function.name,
+            result: toolError,
+          });
+          messages.push({
+            role: "tool",
+            tool_call_id: toolCall.id,
+            content: JSON.stringify(toolError),
+          });
+          onEvent?.({ type: "assistant", text: `Error: ${toolError.error}` });
+          return {
+            reply: `Error: ${toolError.error}`,
+            messages,
+          };
+        }
+      }
+    }
+
+    if (!toolCalls.length) {
+      if (assistant.reasoning) {
+        onEvent?.({ type: "reasoning", text: assistant.reasoning });
+      }
+      onEvent?.({ type: "assistant", text: assistant.content || "" });
+      return {
+        reply: assistant.content || "",
+        messages,
+      };
+    }
+
+    for (const toolCall of toolCalls) {
+      onEvent?.({
+        type: "tool_start",
+        name: toolCall.function.name,
+        args: toolCall.function.arguments,
+      });
+
+      try {
+        const result = await executeToolCall(workspaceRoot, toolCall, {
+          onProgress(progress) {
+            onEvent?.({
+              type: "tool_progress",
+              name: toolCall.function.name,
+              progress,
+            });
+          },
+        });
+        onEvent?.({
+          type: "tool_result",
+          name: toolCall.function.name,
+          result,
+        });
+        messages.push({
+          role: "tool",
+          tool_call_id: toolCall.id,
+          content: JSON.stringify(result),
+        });
+      } catch (error) {
+        onEvent?.({
+          type: "tool_result",
+          name: toolCall.function.name,
+          result: {
+            ok: false,
+            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),
+          }),
+        });
+      }
+    }
+  }
+}