nemoris 0.1.0 → 0.1.2

package/src/tools/micro/read-file.js

@@ -1,11 +1,11 @@
-import { readFile } from "node:fs/promises";
-import { assertWorkspacePath, resolveToolPath } from "./workspace-paths.js";
-
-export async function readFileTool({ path, encoding = "utf8" }, context = {}) {
-  try {
-    const targetPath = assertWorkspacePath(resolveToolPath(path, context.workspaceRoot), context, { mode: "read" });
-    return await readFile(targetPath, encoding);
-  } catch (err) {
-    return `Error reading file: ${err.message}`;
-  }
-}
+import { readFile } from "node:fs/promises";
+import { assertWorkspacePath, resolveToolPath } from "./workspace-paths.js";
+
+export async function readFileTool({ path, encoding = "utf8" }, context = {}) {
+  try {
+    const targetPath = assertWorkspacePath(resolveToolPath(path, context.workspaceRoot), context, { mode: "read" });
+    return await readFile(targetPath, encoding);
+  } catch (err) {
+    return `Error reading file: ${err.message}`;
+  }
+}

package/src/tools/micro/session-search.js

@@ -1,54 +1,54 @@
-/**
- * session_search micro tool — FTS5 search over conversation history.
- */
-import { createToolResult } from "../tool-result-contract.js";
-
-/**
- * @param {{ query: string, limit?: number }} input
- * @param {{ sessionSearch: object, sessionId: string }} context
- */
-export async function sessionSearchHandler(input, context) {
-  const { query, limit = 5 } = input;
-  const { sessionSearch, sessionId } = context;
-
-  if (!query) throw new Error("session_search requires a query parameter.");
-  if (!sessionSearch) {
-    return createToolResult(
-      "Session search not available.",
-      JSON.stringify([]),
-      [query]
-    );
-  }
-
-  const results = sessionSearch.search(query, { sessionId, limit });
-  const allResults = [
-    ...results.events.map(e => ({
-      source: "conversation",
-      kind: e.kind,
-      ts: e.ts,
-      snippet: e.snippet,
-    })),
-    ...results.summaries.map(s => ({
-      source: "summary",
-      snippet: s.snippet,
-    })),
-  ];
-
-  if (allResults.length === 0) {
-    return createToolResult(
-      `No results found for "${query}" in conversation history.`,
-      JSON.stringify([]),
-      [query]
-    );
-  }
-
-  const briefLines = allResults.slice(0, limit).map((r, i) => {
-    const prefix = r.source === "conversation"
-      ? `[${r.kind === "message_in" ? "You" : "Agent"}]`
-      : "[Summary]";
-    return `${i + 1}. ${prefix} ${r.snippet}`;
-  });
-
-  const brief = `Found ${allResults.length} result(s) for "${query}":\n${briefLines.join("\n")}`;
-  return createToolResult(brief, JSON.stringify(allResults), [query]);
-}
+/**
+ * session_search micro tool — FTS5 search over conversation history.
+ */
+import { createToolResult } from "../tool-result-contract.js";
+
+/**
+ * @param {{ query: string, limit?: number }} input
+ * @param {{ sessionSearch: object, sessionId: string }} context
+ */
+export async function sessionSearchHandler(input, context) {
+  const { query, limit = 5 } = input;
+  const { sessionSearch, sessionId } = context;
+
+  if (!query) throw new Error("session_search requires a query parameter.");
+  if (!sessionSearch) {
+    return createToolResult(
+      "Session search not available.",
+      JSON.stringify([]),
+      [query]
+    );
+  }
+
+  const results = sessionSearch.search(query, { sessionId, limit });
+  const allResults = [
+    ...results.events.map(e => ({
+      source: "conversation",
+      kind: e.kind,
+      ts: e.ts,
+      snippet: e.snippet,
+    })),
+    ...results.summaries.map(s => ({
+      source: "summary",
+      snippet: s.snippet,
+    })),
+  ];
+
+  if (allResults.length === 0) {
+    return createToolResult(
+      `No results found for "${query}" in conversation history.`,
+      JSON.stringify([]),
+      [query]
+    );
+  }
+
+  const briefLines = allResults.slice(0, limit).map((r, i) => {
+    const prefix = r.source === "conversation"
+      ? `[${r.kind === "message_in" ? "You" : "Agent"}]`
+      : "[Summary]";
+    return `${i + 1}. ${prefix} ${r.snippet}`;
+  });
+
+  const brief = `Found ${allResults.length} result(s) for "${query}":\n${briefLines.join("\n")}`;
+  return createToolResult(brief, JSON.stringify(allResults), [query]);
+}

package/src/tools/micro/shell-exec.js

@@ -1,43 +1,43 @@
-import { execFile } from "node:child_process";
-import { resolve } from "node:path";
-
-const BLOCKED_PATTERNS = [
-  /\brm\s+-\w*r\w*f/,
-  /\brm\s+-\w*f\w*r/,
-  /curl\s.*\|\s*sh/,
-  /wget\s.*\|\s*sh/,
-  /\beval\b/,
-  /\bsudo\b/,
-  />\s*\/dev\/sd/,
-  /mkfs\b/,
-  /dd\s+if=/,
-];
-
-export async function shellExecTool({ command, timeout = 5000 }, context = {}) {
-  const { workspaceRoot } = context;
-  if (!workspaceRoot) return "Error: shell_exec requires a workspace root context.";
-
-  for (const pattern of BLOCKED_PATTERNS) {
-    if (pattern.test(command)) {
-      return `Error: command blocked by security policy. Pattern matched: ${pattern.source}`;
-    }
-  }
-
-  const cwd = resolve(workspaceRoot);
-
-  return new Promise((res) => {
-    execFile("sh", ["-c", command], {
-      cwd,
-      timeout,
-      maxBuffer: 1048576,
-      env: { ...process.env, HOME: cwd },
-    }, (err, stdout, stderr) => {
-      if (err) {
-        if (err.killed) return res(`Error: command timed out after ${timeout}ms`);
-        return res(`Exit ${err.code || 1}:\n${stderr || err.message}`);
-      }
-      const output = [stdout, stderr].filter(Boolean).join("\n---stderr---\n");
-      res(output || "(no output)");
-    });
-  });
-}
+import { execFile } from "node:child_process";
+import { resolve } from "node:path";
+
+const BLOCKED_PATTERNS = [
+  /\brm\s+-\w*r\w*f/,
+  /\brm\s+-\w*f\w*r/,
+  /curl\s.*\|\s*sh/,
+  /wget\s.*\|\s*sh/,
+  /\beval\b/,
+  /\bsudo\b/,
+  />\s*\/dev\/sd/,
+  /mkfs\b/,
+  /dd\s+if=/,
+];
+
+export async function shellExecTool({ command, timeout = 5000 }, context = {}) {
+  const { workspaceRoot } = context;
+  if (!workspaceRoot) return "Error: shell_exec requires a workspace root context.";
+
+  for (const pattern of BLOCKED_PATTERNS) {
+    if (pattern.test(command)) {
+      return `Error: command blocked by security policy. Pattern matched: ${pattern.source}`;
+    }
+  }
+
+  const cwd = resolve(workspaceRoot);
+
+  return new Promise((res) => {
+    execFile("sh", ["-c", command], {
+      cwd,
+      timeout,
+      maxBuffer: 1048576,
+      env: { ...process.env, HOME: cwd },
+    }, (err, stdout, stderr) => {
+      if (err) {
+        if (err.killed) return res(`Error: command timed out after ${timeout}ms`);
+        return res(`Exit ${err.code || 1}:\n${stderr || err.message}`);
+      }
+      const output = [stdout, stderr].filter(Boolean).join("\n---stderr---\n");
+      res(output || "(no output)");
+    });
+  });
+}

package/src/tools/micro/trigger-job.js

@@ -1,79 +1,79 @@
-/**
- * trigger_job micro tool — dispatches a job to another agent.
- *
- * Two modes:
- * 1. Named job: looks up TOML job, converts to ad-hoc interactive job
- * 2. Ad-hoc message: creates one-shot interactive job from raw text
- *
- * Both go through the interactive drain loop, NOT the TOML scheduler tick.
- */
-
-let _seq = 0;
-
-/**
- * @param {{ targetAgent: string, jobName?: string, message?: string, completionTarget?: string }} input
- * @param {{ stateStore, callerAgentId, currentJobId, agents, jobs, getBreaker }} context
- * @returns {{ jobId: string, targetAgent: string, status: string }}
- */
-export function executeTriggerJob(input, context) {
-  const { targetAgent, jobName, message, completionTarget = "human" } = input;
-  const { stateStore, callerAgentId, currentJobId, agents, jobs, getBreaker } = context;
-
-  // Validate target agent exists
-  if (!agents[targetAgent]) {
-    throw new Error(`Unknown agent: ${targetAgent}. Cannot dispatch job to a non-existent agent.`);
-  }
-
-  // Check circuit breaker for target agent's provider
-  const breaker = getBreaker(targetAgent);
-  if (breaker.isOpen()) {
-    throw new Error(`Circuit breaker open for agent ${targetAgent}. Target agent's provider is currently unavailable.`);
-  }
-
-  // Build input text
-  let inputText;
-  if (jobName) {
-    const jobConfig = jobs[jobName];
-    if (jobConfig) {
-      inputText = `[Dispatched job: ${jobName}] ${jobConfig.objective || jobConfig.input || jobName}`;
-    } else {
-      inputText = `[Dispatched job: ${jobName}]`;
-    }
-  } else if (message) {
-    inputText = message;
-  } else {
-    throw new Error("trigger_job requires either jobName or message.");
-  }
-
-  // Generate job ID (seq suffix ensures uniqueness within same millisecond)
-  const jobId = `dispatch-${callerAgentId}-${targetAgent}-${Date.now()}-${_seq++}`;
-
-  // Enqueue through the interactive drain path
-  stateStore.enqueueDispatchJob({
-    jobId,
-    agentId: targetAgent,
-    input: inputText,
-    source: "agent_dispatch",
-    chatId: "",
-    triggeredBy: callerAgentId,
-    completionTarget,
-    triggerCorrelationId: currentJobId,
-  });
-
-  let taskId = null;
-  let envelopeId = null;
-
-  if (input.objective && context.taskContract) {
-    const task = context.taskContract.createTask({
-      ownerAgent: callerAgentId,
-      assignedAgent: targetAgent,
-      objective: input.objective,
-      deadlineMinutes: input.deadlineMinutes || 30,
-      escalationChain: input.escalationChain || ["assigned", "owner", "operator"],
-    });
-    taskId = task.task_id;
-    envelopeId = task.envelope_id;
-  }
-
-  return { jobId, targetAgent, status: "dispatched", taskId, envelopeId };
-}
+/**
+ * trigger_job micro tool — dispatches a job to another agent.
+ *
+ * Two modes:
+ * 1. Named job: looks up TOML job, converts to ad-hoc interactive job
+ * 2. Ad-hoc message: creates one-shot interactive job from raw text
+ *
+ * Both go through the interactive drain loop, NOT the TOML scheduler tick.
+ */
+
+let _seq = 0;
+
+/**
+ * @param {{ targetAgent: string, jobName?: string, message?: string, completionTarget?: string }} input
+ * @param {{ stateStore, callerAgentId, currentJobId, agents, jobs, getBreaker }} context
+ * @returns {{ jobId: string, targetAgent: string, status: string }}
+ */
+export function executeTriggerJob(input, context) {
+  const { targetAgent, jobName, message, completionTarget = "human" } = input;
+  const { stateStore, callerAgentId, currentJobId, agents, jobs, getBreaker } = context;
+
+  // Validate target agent exists
+  if (!agents[targetAgent]) {
+    throw new Error(`Unknown agent: ${targetAgent}. Cannot dispatch job to a non-existent agent.`);
+  }
+
+  // Check circuit breaker for target agent's provider
+  const breaker = getBreaker(targetAgent);
+  if (breaker.isOpen()) {
+    throw new Error(`Circuit breaker open for agent ${targetAgent}. Target agent's provider is currently unavailable.`);
+  }
+
+  // Build input text
+  let inputText;
+  if (jobName) {
+    const jobConfig = jobs[jobName];
+    if (jobConfig) {
+      inputText = `[Dispatched job: ${jobName}] ${jobConfig.objective || jobConfig.input || jobName}`;
+    } else {
+      inputText = `[Dispatched job: ${jobName}]`;
+    }
+  } else if (message) {
+    inputText = message;
+  } else {
+    throw new Error("trigger_job requires either jobName or message.");
+  }
+
+  // Generate job ID (seq suffix ensures uniqueness within same millisecond)
+  const jobId = `dispatch-${callerAgentId}-${targetAgent}-${Date.now()}-${_seq++}`;
+
+  // Enqueue through the interactive drain path
+  stateStore.enqueueDispatchJob({
+    jobId,
+    agentId: targetAgent,
+    input: inputText,
+    source: "agent_dispatch",
+    chatId: "",
+    triggeredBy: callerAgentId,
+    completionTarget,
+    triggerCorrelationId: currentJobId,
+  });
+
+  let taskId = null;
+  let envelopeId = null;
+
+  if (input.objective && context.taskContract) {
+    const task = context.taskContract.createTask({
+      ownerAgent: callerAgentId,
+      assignedAgent: targetAgent,
+      objective: input.objective,
+      deadlineMinutes: input.deadlineMinutes || 30,
+      escalationChain: input.escalationChain || ["assigned", "owner", "operator"],
+    });
+    taskId = task.task_id;
+    envelopeId = task.envelope_id;
+  }
+
+  return { jobId, targetAgent, status: "dispatched", taskId, envelopeId };
+}

package/src/tools/micro/web-search.js

@@ -1,58 +1,58 @@
-/**
- * web_search micro tool — searches the web via Perplexity sonar-pro on OpenRouter.
- *
- * Returns a typed tool result contract: { brief, raw, index_terms }.
- */
-
-import { createToolResult } from "../tool-result-contract.js";
-
-const OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions";
-const MODEL = "perplexity/sonar-pro";
-const MAX_BRIEF_CHARS = 800; // ~200 tokens
-
-/**
- * @param {{ query: string }} input
- * @param {{ fetchImpl?: Function, apiKey?: string }} context
- * @returns {Promise<import('../tool-result-contract.js').ToolResultContract>}
- */
-export async function executeWebSearch(input, context) {
-  const { query } = input;
-  const { fetchImpl = globalThis.fetch, apiKey } = context;
-
-  if (!query) throw new Error("web_search requires a query parameter.");
-  if (!apiKey) throw new Error("web_search requires an OPENROUTER_API_KEY.");
-
-  const res = await fetchImpl(OPENROUTER_URL, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      "authorization": `Bearer ${apiKey}`,
-      "http-referer": "https://nemoris-v2.local",
-      "x-title": "Nemoris V2",
-    },
-    body: JSON.stringify({
-      model: MODEL,
-      messages: [{ role: "user", content: query }],
-      max_tokens: 1024,
-    }),
-  });
-
-  if (!res.ok) {
-    const err = await res.json().catch(() => ({}));
-    throw new Error(err?.error?.message || `OpenRouter API error: ${res.status}`);
-  }
-
-  const data = await res.json();
-  const content = data?.choices?.[0]?.message?.content || "";
-  const citations = data?.citations || [];
-
-  // Brief: truncated content
-  const brief = content.length > MAX_BRIEF_CHARS
-    ? content.slice(0, MAX_BRIEF_CHARS) + "..."
-    : content;
-
-  // Raw: full response for caching
-  const raw = JSON.stringify({ content, citations, model: data.model, usage: data.usage });
-
-  return createToolResult(brief, raw, [query]);
-}
+/**
+ * web_search micro tool — searches the web via Perplexity sonar-pro on OpenRouter.
+ *
+ * Returns a typed tool result contract: { brief, raw, index_terms }.
+ */
+
+import { createToolResult } from "../tool-result-contract.js";
+
+const OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions";
+const MODEL = "perplexity/sonar-pro";
+const MAX_BRIEF_CHARS = 800; // ~200 tokens
+
+/**
+ * @param {{ query: string }} input
+ * @param {{ fetchImpl?: Function, apiKey?: string }} context
+ * @returns {Promise<import('../tool-result-contract.js').ToolResultContract>}
+ */
+export async function executeWebSearch(input, context) {
+  const { query } = input;
+  const { fetchImpl = globalThis.fetch, apiKey } = context;
+
+  if (!query) throw new Error("web_search requires a query parameter.");
+  if (!apiKey) throw new Error("web_search requires an OPENROUTER_API_KEY.");
+
+  const res = await fetchImpl(OPENROUTER_URL, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "authorization": `Bearer ${apiKey}`,
+      "http-referer": "https://nemoris-v2.local",
+      "x-title": "Nemoris V2",
+    },
+    body: JSON.stringify({
+      model: MODEL,
+      messages: [{ role: "user", content: query }],
+      max_tokens: 1024,
+    }),
+  });
+
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(err?.error?.message || `OpenRouter API error: ${res.status}`);
+  }
+
+  const data = await res.json();
+  const content = data?.choices?.[0]?.message?.content || "";
+  const citations = data?.citations || [];
+
+  // Brief: truncated content
+  const brief = content.length > MAX_BRIEF_CHARS
+    ? content.slice(0, MAX_BRIEF_CHARS) + "..."
+    : content;
+
+  // Raw: full response for caching
+  const raw = JSON.stringify({ content, citations, model: data.model, usage: data.usage });
+
+  return createToolResult(brief, raw, [query]);
+}

package/src/tools/micro/workspace-paths.js

@@ -1,39 +1,39 @@
-import { isAbsolute, resolve, relative, join } from "node:path";
-
-function normalizeRoot(root) {
-  return root ? resolve(root) : null;
-}
-
-export function resolveToolPath(inputPath, workspaceRoot) {
-  if (!inputPath || typeof inputPath !== "string") {
-    throw new Error("path is required.");
-  }
-  if (!workspaceRoot) {
-    return resolve(inputPath);
-  }
-  return isAbsolute(inputPath) ? resolve(inputPath) : resolve(join(workspaceRoot, inputPath));
-}
-
-export function isPathInsideRoot(filePath, rootPath) {
-  const normalizedRoot = normalizeRoot(rootPath);
-  if (!normalizedRoot) return false;
-  const resolvedPath = resolve(filePath);
-  const rel = relative(normalizedRoot, resolvedPath);
-  return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
-}
-
-export function assertWorkspacePath(filePath, context = {}, { mode = "read" } = {}) {
-  const { workspaceRoot, readableRoots = [] } = context;
-  if (!workspaceRoot) return filePath;
-
-  const allowedRoots = [workspaceRoot];
-  if (mode === "read") {
-    allowedRoots.push(...readableRoots);
-  }
-
-  if (allowedRoots.some((root) => isPathInsideRoot(filePath, root))) {
-    return filePath;
-  }
-
-  throw new Error(`${mode}_file blocked: path must stay inside the workspace.`);
-}
+import { isAbsolute, resolve, relative, join } from "node:path";
+
+function normalizeRoot(root) {
+  return root ? resolve(root) : null;
+}
+
+export function resolveToolPath(inputPath, workspaceRoot) {
+  if (!inputPath || typeof inputPath !== "string") {
+    throw new Error("path is required.");
+  }
+  if (!workspaceRoot) {
+    return resolve(inputPath);
+  }
+  return isAbsolute(inputPath) ? resolve(inputPath) : resolve(join(workspaceRoot, inputPath));
+}
+
+export function isPathInsideRoot(filePath, rootPath) {
+  const normalizedRoot = normalizeRoot(rootPath);
+  if (!normalizedRoot) return false;
+  const resolvedPath = resolve(filePath);
+  const rel = relative(normalizedRoot, resolvedPath);
+  return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+
+export function assertWorkspacePath(filePath, context = {}, { mode = "read" } = {}) {
+  const { workspaceRoot, readableRoots = [] } = context;
+  if (!workspaceRoot) return filePath;
+
+  const allowedRoots = [workspaceRoot];
+  if (mode === "read") {
+    allowedRoots.push(...readableRoots);
+  }
+
+  if (allowedRoots.some((root) => isPathInsideRoot(filePath, root))) {
+    return filePath;
+  }
+
+  throw new Error(`${mode}_file blocked: path must stay inside the workspace.`);
+}

package/src/tools/micro/write-file.js

@@ -1,14 +1,14 @@
-import { writeFile, mkdir } from "node:fs/promises";
-import { dirname } from "node:path";
-import { assertWorkspacePath, resolveToolPath } from "./workspace-paths.js";
-
-export async function writeFileTool({ path, content }, context = {}) {
-  try {
-    const targetPath = assertWorkspacePath(resolveToolPath(path, context.workspaceRoot), context, { mode: "write" });
-    await mkdir(dirname(targetPath), { recursive: true });
-    await writeFile(targetPath, content, "utf8");
-    return `Written ${content.length} bytes to ${targetPath}`;
-  } catch (err) {
-    return `Error writing file: ${err.message}`;
-  }
-}
+import { writeFile, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { assertWorkspacePath, resolveToolPath } from "./workspace-paths.js";
+
+export async function writeFileTool({ path, content }, context = {}) {
+  try {
+    const targetPath = assertWorkspacePath(resolveToolPath(path, context.workspaceRoot), context, { mode: "write" });
+    await mkdir(dirname(targetPath), { recursive: true });
+    await writeFile(targetPath, content, "utf8");
+    return `Written ${content.length} bytes to ${targetPath}`;
+  } catch (err) {
+    return `Error writing file: ${err.message}`;
+  }
+}