nemoris 0.1.0

package/src/skills/loader.js

@@ -0,0 +1,84 @@
+// src/skills/loader.js
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { parseToml } from "../config/toml-lite.js";
+
+export class SkillsLoader {
+  #skills = new Map();
+
+  async loadSkills(configDir) {
+    try {
+      const files = await readdir(configDir);
+      for (const file of files) {
+        if (!file.endsWith(".toml")) continue;
+        const content = await readFile(join(configDir, file), "utf8");
+        const parsed = parseToml(content);
+        const skill = extractSkill(parsed);
+        if (!skill.id) continue;
+        this.#skills.set(skill.id, skill);
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+
+  resolve(skillId) {
+    return this.#skills.get(skillId) ?? null;
+  }
+
+  isAgentAllowed(skillId, agentId) {
+    const skill = this.#skills.get(skillId);
+    if (!skill) return false;
+    return skill.agent_scope.includes(agentId);
+  }
+
+  listAll() {
+    return [...this.#skills.entries()];
+  }
+
+  compose(skillIds) {
+    const prompts = [];
+    const allTools = new Set();
+    let minMaxTokens = Infinity;
+    let minMaxToolCalls = Infinity;
+
+    for (const id of skillIds) {
+      const skill = this.#skills.get(id);
+      if (!skill) continue;
+      prompts.push(skill.context.prompt);
+      for (const t of skill.tools.required) allTools.add(t);
+      for (const t of skill.tools.optional) allTools.add(t);
+      if (skill.budget.max_tokens < minMaxTokens) minMaxTokens = skill.budget.max_tokens;
+      if (skill.budget.max_tool_calls < minMaxToolCalls) minMaxToolCalls = skill.budget.max_tool_calls;
+    }
+
+    return {
+      prompt: prompts.join("\n\n"),
+      tools: [...allTools],
+      budget: {
+        max_tokens: minMaxTokens === Infinity ? undefined : minMaxTokens,
+        max_tool_calls: minMaxToolCalls === Infinity ? undefined : minMaxToolCalls,
+      },
+    };
+  }
+}
+
+function extractSkill(parsed) {
+  const raw = parsed.skill ?? {};
+  return {
+    id: raw.id ?? null,
+    description: raw.description ?? "",
+    agent_scope: Array.isArray(raw.agent_scope) ? raw.agent_scope : (raw.agent_scope ? [raw.agent_scope] : []),
+    context: {
+      prompt: raw.context?.prompt ?? "",
+    },
+    tools: {
+      required: Array.isArray(raw.tools?.required) ? raw.tools.required : (raw.tools?.required ? [raw.tools.required] : []),
+      optional: Array.isArray(raw.tools?.optional) ? raw.tools.optional : (raw.tools?.optional ? [raw.tools.optional] : []),
+    },
+    budget: {
+      max_tokens: raw.budget?.max_tokens ?? 8192,
+      max_tool_calls: raw.budget?.max_tool_calls ?? 20,
+    },
+  };
+}

package/src/tools/catalog.json

@@ -0,0 +1,49 @@
+{
+  "github": {
+    "tier": "mcp",
+    "description": "GitHub operations via MCP",
+    "command": "npx",
+    "args": ["-y", "@modelcontextprotocol/server-github"],
+    "env": { "GITHUB_TOKEN": "env:NEMORIS_GITHUB_TOKEN" },
+    "env_prompts": { "NEMORIS_GITHUB_TOKEN": "GitHub personal access token" }
+  },
+  "supabase": {
+    "tier": "mcp",
+    "description": "Supabase database and auth operations",
+    "command": "npx",
+    "args": ["-y", "@supabase/mcp-server"],
+    "env": { "SUPABASE_URL": "env:NEMORIS_SUPABASE_URL", "SUPABASE_KEY": "env:NEMORIS_SUPABASE_KEY" },
+    "env_prompts": { "NEMORIS_SUPABASE_URL": "Supabase project URL", "NEMORIS_SUPABASE_KEY": "Supabase service role key" }
+  },
+  "slack": {
+    "tier": "mcp",
+    "description": "Slack messaging operations",
+    "command": "npx",
+    "args": ["-y", "@anthropic/mcp-server-slack"],
+    "env": { "SLACK_TOKEN": "env:NEMORIS_SLACK_TOKEN" },
+    "env_prompts": { "NEMORIS_SLACK_TOKEN": "Slack bot OAuth token" }
+  },
+  "filesystem": {
+    "tier": "mcp",
+    "description": "Extended filesystem operations",
+    "command": "npx",
+    "args": ["-y", "@modelcontextprotocol/server-filesystem"],
+    "env": {}
+  },
+  "claude_code": {
+    "tier": "cli",
+    "description": "Delegate complex coding tasks to Claude Code",
+    "command": "claude",
+    "args": ["-p", "--output-format", "json"],
+    "env": {},
+    "env_prompts": {}
+  },
+  "gemini_cli": {
+    "tier": "cli",
+    "description": "Delegate tasks to Gemini CLI",
+    "command": "gemini",
+    "args": [],
+    "env": {},
+    "env_prompts": {}
+  }
+}

package/src/tools/cli-delegate.js

@@ -0,0 +1,44 @@
+// src/tools/cli-delegate.js
+import { spawn } from "node:child_process";
+
+export function cliDelegate({ command, args = [], input = "", timeout = 120000, env = {} }) {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+
+    const child = spawn(command, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...env },
+      // Note: spawn() does not support timeout option — handled manually below
+    });
+
+    child.stdout.on("data", (d) => { stdout += d.toString(); });
+    child.stderr.on("data", (d) => { stderr += d.toString(); });
+
+    if (input) {
+      child.stdin.write(input);
+      child.stdin.end();
+    } else {
+      child.stdin.end();
+    }
+
+    const timer = setTimeout(() => {
+      child.kill();
+      resolve(`Error: command timed out after ${timeout}ms`);
+    }, timeout);
+
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) {
+        resolve(stdout || "(no output)");
+      } else {
+        resolve(`Exit ${code}:\n${stderr || stdout || "(no output)"}`);
+      }
+    });
+
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve(`Error: ${err.message}`);
+    });
+  });
+}

package/src/tools/mcp-client.js

@@ -0,0 +1,106 @@
+// src/tools/mcp-client.js
+import { spawn } from "node:child_process";
+
+export class McpClient {
+  #process = null;
+  #config;
+  #requestId = 0;
+  #pending = new Map();
+  #buffer = "";
+
+  constructor(config) {
+    this.#config = config;
+  }
+
+  async spawn() {
+    if (this.#process) return;
+    const { command, args = [], env = {} } = this.#config;
+    this.#process = spawn(command, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...env },
+    });
+
+    this.#process.stdout.on("data", (data) => {
+      this.#buffer += data.toString();
+      this.#drainBuffer();
+    });
+
+    this.#process.on("exit", () => {
+      this.#process = null;
+      for (const [, { reject }] of this.#pending) {
+        reject(new Error("MCP server exited unexpectedly"));
+      }
+      this.#pending.clear();
+    });
+
+    // Send initialize request per MCP protocol
+    await this.#send("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "nemoris", version: "0.1.0" },
+    });
+
+    // Send initialized notification (required by MCP protocol)
+    this.#process.stdin.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) + "\n");
+  }
+
+  async callTool(name, args) {
+    if (!this.#process) throw new Error("MCP server not running");
+    const result = await this.#send("tools/call", { name, arguments: args });
+    if (result.content && Array.isArray(result.content)) {
+      return result.content.map(c => c.text || JSON.stringify(c)).join("\n");
+    }
+    return JSON.stringify(result);
+  }
+
+  async listTools() {
+    if (!this.#process) throw new Error("MCP server not running");
+    const result = await this.#send("tools/list", {});
+    return result.tools || [];
+  }
+
+  isAlive() {
+    return this.#process !== null && !this.#process.killed;
+  }
+
+  kill() {
+    if (this.#process) {
+      this.#process.kill();
+      this.#process = null;
+    }
+  }
+
+  #send(method, params) {
+    const id = ++this.#requestId;
+    const message = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+    this.#process.stdin.write(message + "\n");
+
+    const timeout = this.#config.timeout || 30000;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.#pending.delete(id);
+        reject(new Error(`MCP request timed out after ${timeout}ms`));
+      }, timeout);
+      this.#pending.set(id, { resolve: (v) => { clearTimeout(timer); resolve(v); }, reject: (e) => { clearTimeout(timer); reject(e); } });
+    });
+  }
+
+  #drainBuffer() {
+    const lines = this.#buffer.split("\n");
+    this.#buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const msg = JSON.parse(line);
+        if (msg.id && this.#pending.has(msg.id)) {
+          const { resolve, reject } = this.#pending.get(msg.id);
+          this.#pending.delete(msg.id);
+          if (msg.error) reject(new Error(msg.error.message || "MCP error"));
+          else resolve(msg.result);
+        }
+      } catch {
+        // Non-JSON line — ignore
+      }
+    }
+  }
+}

package/src/tools/micro/cancel-task.js

@@ -0,0 +1,6 @@
+export function executeCancelTask(input, context) {
+  const { taskId } = input;
+  if (!taskId) throw new Error("taskId is required");
+  const task = context.taskContract.transition(taskId, "cancelled", context.callerAgentId);
+  return { status: "cancelled", taskId: task.task_id };
+}

package/src/tools/micro/complete-task.js

@@ -0,0 +1,6 @@
+export function executeCompleteTask(input, context) {
+  const { taskId, result } = input;
+  if (!taskId) throw new Error("taskId is required");
+  const task = context.taskContract.transition(taskId, "completed", context.callerAgentId, { result });
+  return { status: "completed", taskId: task.task_id };
+}

package/src/tools/micro/fail-task.js

@@ -0,0 +1,6 @@
+export function executeFailTask(input, context) {
+  const { taskId, error } = input;
+  if (!taskId) throw new Error("taskId is required");
+  const task = context.taskContract.transition(taskId, "failed", context.callerAgentId, { error });
+  return { status: "failed", taskId: task.task_id };
+}

package/src/tools/micro/http-fetch.js

@@ -0,0 +1,74 @@
+import { createToolResult } from "../tool-result-contract.js";
+import { inspectOutboundUrl } from "../../security/ssrf-check.js";
+
+const BRIEF_CAP = 3000; // chars in brief sent to LLM prompt
+const RAW_CAP = 1048576; // 1MB raw storage cap
+
+/**
+ * Build a useful brief from HTTP response content.
+ * - JSON arrays → first 20 items, serialised cleanly
+ * - JSON objects → pretty-printed (capped)
+ * - HTML → basic tag strip to text (capped)
+ * - Plain text → capped
+ */
+function buildBrief(status, statusText, contentType, text) {
+  const header = `HTTP ${status} ${statusText}`;
+  const isJson = contentType?.includes("application/json") || text.trimStart().startsWith("{") || text.trimStart().startsWith("[");
+  const isHtml = contentType?.includes("text/html") || text.trimStart().startsWith("<!") || text.trimStart().startsWith("<html");
+
+  if (isJson) {
+    try {
+      const parsed = JSON.parse(text);
+      let compact;
+      if (Array.isArray(parsed)) {
+        const slice = parsed.slice(0, 20);
+        compact = JSON.stringify(slice, null, 2);
+        const totalNote = parsed.length > 20 ? `\n[array length: ${parsed.length} — showing first 20]` : "";
+        return `${header}\n\n${compact.slice(0, BRIEF_CAP)}${totalNote}`;
+      } else {
+        compact = JSON.stringify(parsed, null, 2);
+        return `${header}\n\n${compact.slice(0, BRIEF_CAP)}${compact.length > BRIEF_CAP ? "\n[truncated]" : ""}`;
+      }
+    } catch {
+      // Fall through to plain text handling
+    }
+  }
+
+  if (isHtml) {
+    // Strip tags, collapse whitespace
+    const stripped = text
+      .replace(/<script[\s\S]*?<\/script>/gi, "")
+      .replace(/<style[\s\S]*?<\/style>/gi, "")
+      .replace(/<[^>]+>/g, " ")
+      .replace(/\s+/g, " ")
+      .trim();
+    return `${header}\n\n${stripped.slice(0, BRIEF_CAP)}${stripped.length > BRIEF_CAP ? "\n[truncated]" : ""}`;
+  }
+
+  return `${header}\n\n${text.slice(0, BRIEF_CAP)}${text.length > BRIEF_CAP ? "\n[truncated]" : ""}`;
+}
+
+export async function httpFetchTool({ url, method = "GET", body, headers = {} }, { fetchImpl = globalThis.fetch, lookupImpl } = {}) {
+  try {
+    const parsed = new URL(url);
+    const inspection = await inspectOutboundUrl(parsed, { lookupImpl });
+    if (!inspection.ok) {
+      return "Error: request blocked — target resolves to a private/reserved IP address.";
+    }
+    const opts = {
+      method,
+      headers: { "User-Agent": "Nemoris/0.1", ...headers },
+      signal: AbortSignal.timeout(30000),
+    };
+    if (body && method !== "GET") opts.body = body;
+    const resp = await fetchImpl(url, opts);
+    const contentType = resp.headers.get("content-type") || "";
+    const text = await resp.text();
+    const raw = text.length > RAW_CAP ? text.slice(0, RAW_CAP) + "\n[truncated]" : text;
+    const brief = buildBrief(resp.status, resp.statusText, contentType, text);
+
+    return createToolResult(brief, raw, [url, `http-${resp.status}`]);
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
+}

package/src/tools/micro/index.js

@@ -0,0 +1,36 @@
+import { readFileTool } from "./read-file.js";
+import { writeFileTool } from "./write-file.js";
+import { listDirTool } from "./list-dir.js";
+import { shellExecTool } from "./shell-exec.js";
+import { httpFetchTool } from "./http-fetch.js";
+import { executeTriggerJob } from "./trigger-job.js";
+import { executeCompleteTask } from "./complete-task.js";
+import { executeFailTask } from "./fail-task.js";
+import { executeCancelTask } from "./cancel-task.js";
+import { executeMemorySearch } from "./memory-search.js";
+import { writeMemoryTool } from "./write-memory.js";
+import { executeWebSearch } from "./web-search.js";
+import { lcmRecallHandler } from "./lcm-recall.js";
+import { loadSkillHandler } from "./load-skill.js";
+import { listSkillsHandler } from "./list-skills.js";
+
+export function registerMicroToolHandlers(registry, context = {}) {
+  registry.registerHandler("read_file", (input) => readFileTool(input, context));
+  registry.registerHandler("write_file", (input) => writeFileTool(input, context));
+  registry.registerHandler("list_dir", (input) => listDirTool(input, context));
+  registry.registerHandler("shell_exec", (input) => shellExecTool(input, context));
+  registry.registerHandler("http_fetch", (input) => httpFetchTool(input, context));
+  registry.registerHandler("trigger_job", (input) => executeTriggerJob(input, context));
+  registry.registerHandler("complete_task", (input) => executeCompleteTask(input, context));
+  registry.registerHandler("fail_task", (input) => executeFailTask(input, context));
+  registry.registerHandler("cancel_task", (input) => executeCancelTask(input, context));
+  registry.registerHandler("memory_search", (input) => executeMemorySearch(input, context));
+  registry.registerHandler("write_memory", (input) => writeMemoryTool(input, context));
+  registry.registerHandler("lcm_recall", (input) => lcmRecallHandler(input, context));
+  registry.registerHandler("load_skill", (input) => loadSkillHandler(input, context));
+  registry.registerHandler("list_skills", (input) => listSkillsHandler(input, context));
+  registry.registerHandler("web_search", (input) => executeWebSearch(input, {
+    fetchImpl: context.fetchImpl || globalThis.fetch,
+    apiKey: context.openRouterApiKey || process.env.OPENROUTER_API_KEY,
+  }));
+}

package/src/tools/micro/lcm-recall.js

@@ -0,0 +1,60 @@
+/**
+ * lcm_recall micro tool — search compacted conversation history.
+ *
+ * Returns a typed tool result contract: { brief, raw, index_terms }.
+ */
+
+import { createToolResult } from "../tool-result-contract.js";
+
+/**
+ * @param {{ query: string, limit?: number }} input
+ * @param {{ contextLedger: object, sessionId: string }} context
+ * @returns {Promise<import('../tool-result-contract.js').ToolResultContract>}
+ */
+export async function lcmRecallHandler(input, context) {
+  const { query, limit = 5 } = input;
+  const { contextLedger, sessionId } = context;
+
+  if (!query) throw new Error("lcm_recall requires a query parameter.");
+  if (!contextLedger) {
+    // Fallback if ledger is missing in context (e.g. some tests)
+    return createToolResult(
+      "ContextLedger not available. Cannot recall compacted context.",
+      JSON.stringify([]),
+      [query]
+    );
+  }
+
+  const summaries = contextLedger.getContextSummaries({ session_id: sessionId });
+  
+  const queryWords = query.toLowerCase().split(/\s+/).filter(Boolean);
+  
+  const matches = summaries.filter(s => {
+    const text = s.summary_text.toLowerCase();
+    return queryWords.every(word => text.includes(word));
+  }).slice(0, limit);
+
+  if (matches.length === 0) {
+    return createToolResult(
+      `No relevant compacted context found for "${query}".`,
+      JSON.stringify([]),
+      [query]
+    );
+  }
+
+  const briefLines = matches.map((s, i) => {
+    const dateStr = s.created_at || "unknown date";
+    return `${i + 1}. [Depth ${s.depth}] (${dateStr}) — ${s.summary_text}`;
+  });
+  
+  const brief = `Found ${matches.length} matching compacted summary(ies):\n${briefLines.join("\n")}`;
+  
+  const indexTerms = new Set([query]);
+  matches.forEach(s => {
+    s.summary_text.split(/\W+/).forEach(word => {
+      if (word.length > 3) indexTerms.add(word.toLowerCase());
+    });
+  });
+
+  return createToolResult(brief, JSON.stringify(matches), Array.from(indexTerms));
+}

package/src/tools/micro/list-dir.js

@@ -0,0 +1,17 @@
+import { readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+
+export async function listDirTool({ path }, context = {}) {
+  try {
+    const targetPath = path || context.workspaceRoot;
+    const entries = await readdir(targetPath);
+    const lines = [];
+    for (const entry of entries.sort()) {
+      const s = await stat(join(targetPath, entry));
+      lines.push(`${s.isDirectory() ? "d" : "-"} ${entry}`);
+    }
+    return lines.join("\n");
+  } catch (err) {
+    return `Error listing directory: ${err.message}`;
+  }
+}

package/src/tools/micro/list-skills.js

@@ -0,0 +1,46 @@
+import { readdir, access } from "node:fs/promises";
+import { join } from "node:path";
+import { createToolResult } from "../tool-result-contract.js";
+
+/**
+ * List all available skills by name.
+ *
+ * @param {Object} input - {}
+ * @param {Object} context - { workspaceRoot, installDir }
+ */
+export async function listSkillsHandler(_, { workspaceRoot, installDir }) {
+  const skillDirs = [
+    { path: join(workspaceRoot, "skills"), label: "workspace" },
+    { path: join(installDir, "skills"), label: "install" },
+  ];
+
+  const skillNames = new Set();
+
+  for (const { path } of skillDirs) {
+    try {
+      const entries = await readdir(path, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const skillName = entry.name;
+          const skillPath = join(path, skillName, "SKILL.md");
+          try {
+            await access(skillPath);
+            skillNames.add(skillName);
+          } catch {
+            // No SKILL.md here, skip
+          }
+        }
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+
+  if (skillNames.size === 0) {
+    return createToolResult("No skills found.", [], ["skills"]);
+  }
+
+  const sortedNames = Array.from(skillNames).sort();
+  const brief = "Available skills:\n" + sortedNames.join("\n");
+  return createToolResult(brief, sortedNames, ["skills", "list"]);
+}

package/src/tools/micro/load-skill.js

@@ -0,0 +1,38 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { createToolResult } from "../tool-result-contract.js";
+
+/**
+ * Load a skill by name to get instructions for a specific task.
+ * Skills provide step-by-step guidance for tools, APIs, and workflows.
+ *
+ * @param {Object} input - { name }
+ * @param {Object} context - { workspaceRoot, installDir }
+ */
+export async function loadSkillHandler({ name }, { workspaceRoot, installDir }) {
+  const skillPaths = [
+    join(workspaceRoot, "skills", name, "SKILL.md"),
+    join(installDir, "skills", name, "SKILL.md"),
+  ];
+
+  let content = null;
+  for (const skillPath of skillPaths) {
+    try {
+      content = await readFile(skillPath, "utf8");
+      break;
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+
+  if (content === null) {
+    return createToolResult(
+      `Skill '${name}' not found. Available skills can be listed with list_skills.`,
+      null,
+      [name]
+    );
+  }
+
+  const cappedContent = content.length > 6000 ? content.slice(0, 6000) + "\n[truncated]" : content;
+  return createToolResult(cappedContent, content, [name, "skill"]);
+}

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

@@ -0,0 +1,45 @@
+/**
+ * memory_search micro tool — semantic + lexical search across agent memory.
+ *
+ * Returns a typed tool result contract: { brief, raw, index_terms }.
+ */
+
+import { createToolResult } from "../tool-result-contract.js";
+
+/**
+ * @param {{ query: string, agentId?: string, limit?: number }} input
+ * @param {{ memoryStore: object, callerAgentId: string }} context
+ * @returns {Promise<import('../tool-result-contract.js').ToolResultContract>}
+ */
+export async function executeMemorySearch(input, context) {
+  const { query, agentId, limit = 5 } = input;
+  const { memoryStore, callerAgentId } = context;
+
+  if (!query) throw new Error("memory_search requires a query parameter.");
+
+  const targetAgent = agentId || callerAgentId;
+  const result = await memoryStore.query(targetAgent, query, { limit });
+
+  if (!result.items || result.items.length === 0) {
+    return createToolResult(
+      `No results found for "${query}" in ${targetAgent}'s memory.`,
+      JSON.stringify(result),
+      [query]
+    );
+  }
+
+  // Brief: concise list of titles + snippet (≤200 tokens target)
+  const briefLines = result.items.map((item, i) => {
+    const snippet = (item.content || item.summary || "").slice(0, 80);
+    return `${i + 1}. **${item.title || "untitled"}** — ${snippet}${snippet.length >= 80 ? "..." : ""}`;
+  });
+  const brief = `Found ${result.items.length} result(s) for "${query}":\n${briefLines.join("\n")}`;
+
+  // Index terms: query words + titles
+  const indexTerms = [
+    query,
+    ...result.items.map((item) => item.title).filter(Boolean),
+  ];
+
+  return createToolResult(brief, JSON.stringify(result), indexTerms);
+}

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

@@ -0,0 +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}`;
+  }
+}