netheriteai-code 0.1.0

package/src/state.js

@@ -0,0 +1,100 @@
+import path from "node:path";
+import { getStateFile, loadJson, saveJson } from "./utils.js";
+
+const DEFAULT_STATE = {
+  selectedModel: "",
+  recentModels: [],
+  sessions: {},
+  workspaceSessions: {},
+};
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function makeSessionId() {
+  return `s_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+}
+
+export function loadState() {
+  const state = loadJson(getStateFile(), DEFAULT_STATE) || {};
+  return {
+    ...DEFAULT_STATE,
+    ...state,
+    recentModels: Array.isArray(state.recentModels) ? state.recentModels : [],
+    sessions: state.sessions && typeof state.sessions === "object" ? state.sessions : {},
+    workspaceSessions: state.workspaceSessions && typeof state.workspaceSessions === "object" ? state.workspaceSessions : {},
+  };
+}
+
+export function saveState(state) {
+  saveJson(getStateFile(), state);
+}
+
+export function getSessionKey(workspaceRoot) {
+  return path.resolve(workspaceRoot);
+}
+
+function normalizeSession(session, workspaceRoot, id) {
+  return {
+    id: session.id || id || makeSessionId(),
+    workspaceRoot: path.resolve(session.workspaceRoot || workspaceRoot || process.cwd()),
+    title: session.title || "",
+    createdAt: session.createdAt || nowIso(),
+    updatedAt: nowIso(),
+    messages: Array.isArray(session.messages) ? session.messages : [],
+    transcript: Array.isArray(session.transcript) ? session.transcript : [],
+  };
+}
+
+export function createSession(workspaceRoot) {
+  const session = normalizeSession({}, workspaceRoot);
+  saveSession(session);
+  return session;
+}
+
+export function loadSession(workspaceRoot) {
+  const state = loadState();
+  const key = getSessionKey(workspaceRoot);
+  const sessionId = state.workspaceSessions[key];
+  if (sessionId && state.sessions[sessionId]) {
+    return normalizeSession(state.sessions[sessionId], workspaceRoot, sessionId);
+  }
+  const legacy = state.sessions[key];
+  if (legacy && !legacy.id) {
+    const migrated = normalizeSession(legacy, workspaceRoot);
+    saveSession(migrated);
+    delete state.sessions[key];
+    saveState(state);
+    return migrated;
+  }
+  return createSession(workspaceRoot);
+}
+
+export function loadSessionById(sessionId) {
+  const state = loadState();
+  const session = state.sessions[sessionId];
+  if (!session) return null;
+  return normalizeSession(session, session.workspaceRoot, sessionId);
+}
+
+export function saveSession(session) {
+  const state = loadState();
+  const normalized = normalizeSession(session, session.workspaceRoot, session.id);
+  state.sessions[normalized.id] = normalized;
+  state.workspaceSessions[getSessionKey(normalized.workspaceRoot)] = normalized.id;
+  saveState(state);
+  return normalized;
+}
+
+export function getSelectedModel() {
+  const state = loadState();
+  return state.selectedModel || "";
+}
+
+export function setSelectedModel(model) {
+  const state = loadState();
+  state.selectedModel = model;
+  state.recentModels = [model, ...state.recentModels.filter((item) => item !== model)].slice(0, 10);
+  saveState(state);
+}

package/src/tools.js

@@ -0,0 +1,455 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import {
+  clampText,
+  ensureDir,
+  formatBytes,
+  loadJson,
+  relativeToRoot,
+  saveJson,
+  toAbsoluteInsideRoot,
+} from "./utils.js";
+
+function todoFile(root) {
+  return path.join(root, ".netherite", "todos.json");
+}
+
+function loadTodos(root) {
+  return loadJson(todoFile(root), []);
+}
+
+function saveTodos(root, todos) {
+  saveJson(todoFile(root), todos);
+}
+
+function statEntry(entryPath) {
+  const stats = fs.statSync(entryPath);
+  return {
+    type: stats.isDirectory() ? "dir" : "file",
+    size: stats.isDirectory() ? "-" : formatBytes(stats.size),
+    modifiedAt: stats.mtime.toISOString(),
+  };
+}
+
+export function getToolDefinitions() {
+  return [
+    {
+      type: "function",
+      function: {
+        name: "list_files",
+        description: "List files or folders inside 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." },
+          },
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: "read_file",
+        description: "Read a text file inside the workspace.",
+        parameters: {
+          type: "object",
+          properties: {
+            path: { type: "string", description: "Relative file path." },
+          },
+          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.",
+        parameters: {
+          type: "object",
+          properties: {
+            path: { type: "string", description: "Relative file path." },
+            content: { type: "string", description: "Text to append." },
+          },
+          required: ["path", "content"],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: "edit_file",
+        description: "Edit a text file by replacing an exact string match. Safer than overwriting the whole file.",
+        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." },
+          },
+          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.",
+        parameters: {
+          type: "object",
+          properties: {
+            id: { type: "number" },
+          },
+          required: ["id"],
+        },
+      },
+    },
+  ];
+}
+
+function listRecursive(root, basePath) {
+  const entries = [];
+  for (const entry of fs.readdirSync(basePath)) {
+    const absolute = path.join(basePath, entry);
+    const rel = relativeToRoot(root, absolute);
+    entries.push({
+      path: rel,
+      ...statEntry(absolute),
+    });
+    if (fs.statSync(absolute).isDirectory()) {
+      entries.push(...listRecursive(root, absolute));
+    }
+  }
+  return entries;
+}
+
+async function streamFilePreview(text, hooks = {}, maxLines = 12) {
+  const lines = String(text || "").replace(/\r/g, "").split("\n").slice(0, maxLines);
+  for (let index = 0; index < lines.length; index += 1) {
+    hooks.onProgress?.({ stream: "preview", text: `${lines[index]}\n` });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+  if (String(text || "").replace(/\r/g, "").split("\n").length > maxLines) {
+    hooks.onProgress?.({ stream: "preview", text: `... preview truncated\n` });
+  }
+}
+
+async function runSpawnedCommand(root, command, args = [], hooks = {}) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: root,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout?.on("data", (chunk) => {
+      const text = chunk.toString("utf8");
+      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.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve({
+          ok: true,
+          command,
+          args,
+          stdout: clampText(stdout),
+          stderr: clampText(stderr),
+        });
+        return;
+      }
+      reject(new Error((stderr || stdout || `${command} exited with code ${code}`).trim()));
+    });
+  });
+}
+
+async function runOneCommand(root, command, args = [], hooks = {}) {
+  return await runSpawnedCommand(root, command, args, hooks);
+}
+
+async function runShellLine(root, commandLine, hooks = {}) {
+  const result = await runSpawnedCommand(root, "bash", ["-lc", commandLine], hooks);
+  return {
+    ok: true,
+    commandLine,
+    stdout: result.stdout,
+    stderr: result.stderr,
+  };
+}
+
+export async function executeToolCall(root, toolCall, hooks = {}) {
+  const name = toolCall.function?.name || toolCall.name;
+  const rawArgs = toolCall.function?.arguments ?? toolCall.arguments ?? "{}";
+  const args = typeof rawArgs === "string" ? JSON.parse(rawArgs || "{}") : rawArgs;
+
+  switch (name) {
+    case "list_files": {
+      const target = toAbsoluteInsideRoot(root, args.path || ".");
+      const entries = args.recursive
+        ? listRecursive(root, target)
+        : fs.readdirSync(target).map((entry) => {
+            const absolute = path.join(target, entry);
+            return {
+              path: relativeToRoot(root, absolute),
+              ...statEntry(absolute),
+            };
+          });
+      return { entries };
+    }
+    case "read_file": {
+      const target = toAbsoluteInsideRoot(root, args.path);
+      const content = fs.readFileSync(target, "utf8");
+      return { path: args.path, content: clampText(content, 24000) };
+    }
+    case "create_file": {
+      const target = toAbsoluteInsideRoot(root, args.path);
+      if (fs.existsSync(target)) {
+        throw new Error(`File already exists: ${args.path}`);
+      }
+      ensureDir(path.dirname(target));
+      hooks.onProgress?.({ stream: "preview", text: `Creating ${args.path}\n` });
+      await streamFilePreview(args.content, hooks);
+      fs.writeFileSync(target, args.content, "utf8");
+      return { ok: true, path: args.path, bytesWritten: Buffer.byteLength(args.content, "utf8"), created: true };
+    }
+    case "write_file": {
+      const target = toAbsoluteInsideRoot(root, args.path);
+      ensureDir(path.dirname(target));
+      hooks.onProgress?.({ stream: "preview", text: `Writing ${args.path}\n` });
+      await streamFilePreview(args.content, hooks);
+      fs.writeFileSync(target, args.content, "utf8");
+      return { ok: true, path: args.path, bytesWritten: Buffer.byteLength(args.content, "utf8") };
+    }
+    case "append_file": {
+      const target = toAbsoluteInsideRoot(root, args.path);
+      ensureDir(path.dirname(target));
+      hooks.onProgress?.({ stream: "preview", text: `Appending ${args.path}\n` });
+      await streamFilePreview(args.content, hooks);
+      fs.appendFileSync(target, args.content, "utf8");
+      return { ok: true, path: args.path, bytesWritten: Buffer.byteLength(args.content, "utf8"), appended: true };
+    }
+    case "edit_file": {
+      const target = toAbsoluteInsideRoot(root, args.path);
+      const original = fs.readFileSync(target, "utf8");
+      if (!args.oldText.length) {
+        throw new Error("oldText must not be empty");
+      }
+      if (!original.includes(args.oldText)) {
+        throw new Error(`Target text not found in ${args.path}`);
+      }
+      const updated = args.replaceAll
+        ? original.split(args.oldText).join(args.newText)
+        : original.replace(args.oldText, args.newText);
+      hooks.onProgress?.({ stream: "preview", text: `Editing ${args.path}\n` });
+      await streamFilePreview(args.newText, hooks);
+      fs.writeFileSync(target, updated, "utf8");
+      return {
+        ok: true,
+        path: args.path,
+        replacements: args.replaceAll ? original.split(args.oldText).length - 1 : 1,
+        bytesWritten: Buffer.byteLength(updated, "utf8"),
+      };
+    }
+    case "make_dir": {
+      const target = toAbsoluteInsideRoot(root, args.path);
+      ensureDir(target);
+      return { ok: true, path: args.path, created: true };
+    }
+    case "remove_path": {
+      const target = toAbsoluteInsideRoot(root, args.path);
+      const stats = fs.statSync(target);
+      if (stats.isDirectory() && !args.recursive) {
+        throw new Error("Directory deletion requires recursive=true");
+      }
+      fs.rmSync(target, { recursive: Boolean(args.recursive), force: false });
+      return { ok: true, path: args.path };
+    }
+    case "run_command": {
+      if (args.commandLine) {
+        return await runShellLine(root, args.commandLine, hooks);
+      }
+      return await runOneCommand(root, args.command, args.args || [], hooks);
+    }
+    case "batch_command": {
+      const results = [];
+      for (const command of args.commands || []) {
+        if (command.commandLine) {
+          hooks.onProgress?.({ stream: "stdout", text: `$ ${command.commandLine}\n` });
+          results.push(await runShellLine(root, command.commandLine, hooks));
+        } else {
+          hooks.onProgress?.({ stream: "stdout", text: `$ ${[command.command, ...(command.args || [])].filter(Boolean).join(" ")}\n` });
+          results.push(await runOneCommand(root, command.command, command.args || [], hooks));
+        }
+      }
+      return { results };
+    }
+    case "todo_create": {
+      const todos = loadTodos(root);
+      const next = {
+        id: todos.length ? Math.max(...todos.map((item) => item.id)) + 1 : 1,
+        text: args.text,
+        done: false,
+        createdAt: new Date().toISOString(),
+      };
+      todos.push(next);
+      saveTodos(root, todos);
+      return next;
+    }
+    case "todo_list": {
+      return { todos: loadTodos(root) };
+    }
+    case "todo_complete": {
+      const todos = loadTodos(root);
+      const todo = todos.find((item) => item.id === args.id);
+      if (!todo) {
+        throw new Error(`Todo ${args.id} not found`);
+      }
+      todo.done = true;
+      todo.completedAt = new Date().toISOString();
+      saveTodos(root, todos);
+      return todo;
+    }
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}