netheriteai-code 0.1.0

package/src/cli.js

@@ -0,0 +1,405 @@
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { runAgentTurn } from "./agent.js";
+import { listModels, pickDefaultModel } from "./ollama.js";
+import { createSession, loadSessionById, saveSession, getSelectedModel, setSelectedModel } from "./state.js";
+import { runTui } from "./tui.js";
+import { printTable, resolveWorkspaceRoot } from "./utils.js";
+
+const execFileAsync = promisify(execFile);
+
+function displayModelName(model) {
+  const name = String(model || "");
+  if (name.toLowerCase().includes("glm5") || name.toLowerCase().includes("glm-5")) return "NetheriteAI:Code";
+  return name;
+}
+
+function makeSessionTitle(prompt, maxLength = 36) {
+  const text = String(prompt || "").trim().replace(/\s+/g, " ");
+  if (!text) return "";
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+
+function getLastAssistantMessage(session) {
+  const transcript = Array.isArray(session.transcript) ? session.transcript : [];
+  for (let index = transcript.length - 1; index >= 0; index -= 1) {
+    if (transcript[index]?.role === "assistant" && transcript[index]?.text?.trim()) {
+      return transcript[index].text;
+    }
+  }
+
+  const messages = Array.isArray(session.messages) ? session.messages : [];
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (messages[index]?.role === "assistant" && messages[index]?.content?.trim()) {
+      return messages[index].content;
+    }
+  }
+
+  return "";
+}
+
+async function copyTextToClipboard(text) {
+  const value = String(text || "");
+  const attempts = process.platform === "darwin"
+    ? [["pbcopy", []]]
+    : process.platform === "win32"
+      ? [["clip", []], ["powershell.exe", ["-NoProfile", "-Command", "Set-Clipboard -Value ([Console]::In.ReadToEnd())"]]]
+      : [["wl-copy", []], ["xclip", ["-selection", "clipboard"]], ["xsel", ["--clipboard", "--input"]]];
+
+  for (const [command, args] of attempts) {
+    try {
+      await execFileAsync(command, args, {
+        input: value,
+        encoding: "utf8",
+        maxBuffer: 1024 * 1024,
+      });
+      return;
+    } catch {
+      // try next clipboard command
+    }
+  }
+
+  throw new Error("Clipboard command not available. Install wl-copy, xclip, or xsel.");
+}
+
+function parseArgs(argv) {
+  const args = [...argv];
+  const positional = [];
+  const flags = {};
+
+  while (args.length) {
+    const current = args.shift();
+    if (!current) continue;
+    if (current.startsWith("--")) {
+      const key = current.slice(2);
+      const value = args[0] && !args[0].startsWith("-") ? args.shift() : true;
+      flags[key] = value;
+    } else if (current.startsWith("-")) {
+      const key = current.slice(1);
+      const value = args[0] && !args[0].startsWith("-") ? args.shift() : true;
+      flags[key] = value;
+    } else {
+      positional.push(current);
+    }
+  }
+
+  return { positional, flags };
+}
+
+function printHelp() {
+  console.log(`NetheriteAI:Code
+  by hurdacu
+
+Usage:
+  netheriteai-code [tui] [--model <name>] [--dir <path>]
+  netheriteai-code session <id>
+  netheriteai-code chat [--model <name>] [--dir <path>]
+  netheriteai-code tools
+
+Commands:
+  tui     Launch the terminal UI (default)
+  session Resume a saved session by id
+  chat    Start a plain REPL chat session
+  tools   List the AI toolset exposed to NetheriteAI
+`);
+}
+
+async function resolveModel(cliModel) {
+  return cliModel || "glm-5:cloud";
+}
+
+function printToolList() {
+  console.log(`Built-in tools
+
+- list_files(path=".", recursive=false)
+- read_file(path)
+- create_file(path, content)
+- write_file(path, content)
+- append_file(path, content)
+- edit_file(path, oldText, newText, replaceAll=false)
+- make_dir(path)
+- remove_path(path, recursive=false)
+- run_command(command|commandLine, args=[])
+- batch_command(commands[])
+- todo_create(text)
+- todo_list()
+- todo_complete(id)
+`);
+}
+
+function slashHelp() {
+  return [
+    "Slash commands",
+    "/help - show available slash commands",
+    "/compact - forget prior AI context but keep the transcript visible",
+    "/copy - copy the last AI message to the clipboard",
+    "/model - show current model",
+    "/model <name> - switch model",
+    "/clear - clear visible messages but keep AI memory",
+    "/new - clear visible messages and AI memory",
+    "/pwd - show current workspace",
+  ].join("\n");
+}
+
+async function handleSlashCommand({ prompt, workspaceRoot, session, ui, setModel }) {
+  const [command, ...rest] = prompt.trim().split(/\s+/);
+  const arg = rest.join(" ").trim();
+
+  if (command === "/help") {
+    return { handled: true, message: slashHelp() };
+  }
+
+  if (command === "/pwd") {
+    return { handled: true, message: workspaceRoot };
+  }
+
+  if (command === "/clear") {
+    session.transcript = [];
+    saveSession(session);
+    ui?.onClearTranscript?.();
+    return { handled: true };
+  }
+
+  if (command === "/new") {
+    session.messages = [];
+    session.transcript = [];
+    session.title = "";
+    saveSession(session);
+    ui?.onResetSession?.();
+    return { handled: true };
+  }
+
+  if (command === "/compact") {
+    session.messages = [];
+    saveSession(session);
+    return { handled: true, message: "Compacted session. The AI context was cleared." };
+  }
+
+  if (command === "/copy") {
+    const lastAssistantMessage = getLastAssistantMessage(session);
+    if (!lastAssistantMessage) {
+      return { handled: true, message: "No AI message available to copy." };
+    }
+    await copyTextToClipboard(lastAssistantMessage);
+    return { handled: true, message: "Copied the last AI message to the clipboard." };
+  }
+
+  if (command === "/model" && !arg) {
+    if (ui?.onPicker) {
+      ui.onPicker({
+        title: "Select Model",
+        items: [{ label: "NetheriteAI:Code (glm-5:cloud)", value: "glm-5:cloud" }],
+        onSelect(value) {
+          setSelectedModel(value);
+          setModel(value);
+          return `Switched model to ${displayModelName(value)}`;
+        },
+      });
+      return { handled: true };
+    }
+    return { handled: true, message: `Current model: ${displayModelName(getSelectedModel() || "not set")}` };
+  }
+
+  if (command === "/model" && arg) {
+    setSelectedModel(arg);
+    return { handled: true, message: `Switched model to ${displayModelName(arg)}`, model: arg };
+  }
+
+  return { handled: false };
+}
+
+async function runChatSession({ workspaceRoot, model, useTui, session }) {
+  let activeModel = model;
+
+  function persistSession() {
+    session.workspaceRoot = workspaceRoot;
+    saveSession(session);
+  }
+
+  async function submit(prompt, ui) {
+    if (!session.title) {
+      session.title = makeSessionTitle(prompt);
+      ui?.onTitleChange?.(session.title);
+      persistSession();
+    }
+
+    if (prompt.trim().startsWith("/")) {
+      const slash = await handleSlashCommand({
+        prompt,
+        workspaceRoot,
+        session,
+        ui,
+        setModel(value) {
+          activeModel = value;
+        },
+      });
+      if (slash.handled) {
+        if (slash.model) {
+          activeModel = slash.model;
+        }
+        if (slash.message) {
+          ui?.onAssistant?.(slash.message);
+          if (!useTui) {
+            console.log(`\n${slash.message}\n`);
+          }
+        }
+        return;
+      }
+    }
+
+    const result = await runAgentTurn({
+      workspaceRoot,
+      model: activeModel,
+      history: session.messages,
+      userPrompt: prompt,
+      signal: ui?.signal,
+      onEvent(event) {
+        if (event.type === "status") {
+          ui?.onStatus?.(event.text);
+        } else if (event.type === "tool_start") {
+          ui?.onToolStart?.(event);
+        } else if (event.type === "tool_progress") {
+          ui?.onToolProgress?.(event);
+        } else if (event.type === "tool_result") {
+          ui?.onToolResult?.(event);
+        } else if (event.type === "assistant_delta") {
+          ui?.onStream?.(event.text);
+        } else if (event.type === "reasoning_delta") {
+          ui?.onReasoning?.(event.text);
+        } else if (event.type === "reasoning") {
+          ui?.onReasoningDone?.(event.text);
+        } else if (event.type === "assistant") {
+          ui?.onAssistant?.(event.text);
+        }
+      },
+    });
+    session.messages = result.messages;
+    persistSession();
+    if (!useTui) {
+      console.log(`\n${result.reply}\n`);
+    }
+  }
+
+  if (useTui) {
+    const exitInfo = await runTui({
+      model: activeModel,
+      getModel: () => activeModel,
+      agentName: "NetheriteAI:Code",
+      providerName: "NetheriteAI",
+      version: "0.1.0",
+      workspaceLabel: workspaceRoot,
+      sessionId: session.id,
+      initialSessionTitle: session.title,
+      initialTranscript: session.transcript || [],
+      onTranscriptChange(transcript) {
+        session.transcript = transcript;
+        persistSession();
+      },
+      onTitleChange(title) {
+        session.title = title;
+        persistSession();
+      },
+      onSubmit: submit,
+    });
+    persistSession();
+    if (exitInfo?.reason === "interrupt") {
+      console.log(`\nYou can access this session by executing \u001b[38;2;83;149;255mnetheritecode session ${session.id}\u001b[0m\n`);
+    }
+    return;
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: `${path.basename(workspaceRoot)} > `,
+  });
+
+  console.log(`NetheriteAI:Code  model=${displayModelName(model)}  provider=NetheriteAI  by hurdacu`);
+  console.log(`Workspace: ${workspaceRoot}`);
+  console.log("Type `exit` to quit.\n");
+  rl.prompt();
+
+  for await (const line of rl) {
+    const prompt = line.trim();
+    if (!prompt) {
+      rl.prompt();
+      continue;
+    }
+    if (prompt === "exit" || prompt === "quit") {
+      rl.close();
+      break;
+    }
+    await submit(prompt);
+    rl.prompt();
+  }
+}
+
+export async function main() {
+  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();
+}

package/src/ollama.js

@@ -0,0 +1,252 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const OLLAMA_BASE_URL = process.env.OLLAMA_BASE_URL || "http://176.88.249.119:11434";
+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) {
+  const response = await fetch(`${OLLAMA_BASE_URL}${pathname}`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body),
+    signal,
+  });
+
+  if (!response.ok) {
+    throw new Error(`NetheriteAI request failed: ${response.status} ${response.statusText}`);
+  }
+
+  return response;
+}
+
+export async function listModels() {
+  try {
+    const response = await fetch(`${OLLAMA_BASE_URL}/api/tags`);
+    if (!response.ok) {
+      throw new Error(`NetheriteAI request failed: ${response.status} ${response.statusText}`);
+    }
+    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 || {},
+    }));
+  } catch {
+    try {
+      const { stdout } = await execFileAsync("ollama", ["list"], { encoding: "utf8" });
+      const lines = stdout.trim().split("\n").slice(1).filter(Boolean);
+      return lines.map((line) => {
+        const parts = line.trim().split(/\s{2,}/);
+        return {
+          name: parts[0] || "",
+          size: parts[2] || "",
+          modifiedAt: parts[3] || "",
+          digest: parts[1] || "",
+          details: {},
+        };
+      });
+    } catch {
+      throw new Error(
+        "Could not connect to NetheriteAI. Start it with `ollama serve`, or set OLLAMA_BASE_URL if it runs elsewhere.",
+      );
+    }
+  }
+}
+
+export async function pickDefaultModel() {
+  const models = await listModels();
+  if (!models.length) {
+    throw new Error("No NetheriteAI models found. Pull one with `ollama pull <model>` first.");
+  }
+  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;
+}
+
+export async function chat({ model, messages, tools, signal }) {
+  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 {
+    ...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;
+    }
+  }
+
+  return {
+    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 response = await request("/api/chat", body, signal);
+
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("NetheriteAI stream did not provide a readable body.");
+  }
+
+  const decoder = new TextDecoder();
+  let buffer = "";
+  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);
+    },
+  });
+
+  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);
+        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;
+        }
+      }
+      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;
+    }
+  }
+
+  parser.finish();
+
+  return lastMessage;
+}