nemoris 0.1.0 → 0.1.2

package/src/jobs/job-runner.js

@@ -1,78 +1,78 @@
-function nowIso() {
-  return new Date().toISOString();
-}
-
-export class JobRunner {
-  constructor({ memoryStore }) {
-    this.memoryStore = memoryStore;
-  }
-
-  async run(job, execute) {
-    const runId = `${job.id}:${Date.now()}`;
-    const agentId = job.agentId;
-
-    await this.memoryStore.appendEvent(agentId, {
-      title: `job:${job.id}:queued`,
-      content: `Run ${runId} queued`,
-      category: "job_state",
-      salience: 0.4
-    });
-
-    await this.memoryStore.saveCheckpoint(agentId, "latest", {
-      objective: job.taskType,
-      status: "running",
-      nextActions: [],
-      blockers: [],
-      runId
-    });
-
-    try {
-      const result = await execute({
-        runId,
-        budget: job.budget
-      });
-
-      await this.memoryStore.writeSummary(agentId, {
-        title: `job:${job.id}:summary`,
-        summary: result.summary,
-        content: result.output,
-        category: "job_summary",
-        salience: 0.72
-      });
-
-      await this.memoryStore.saveCheckpoint(agentId, "latest", {
-        objective: job.taskType,
-        status: "succeeded",
-        nextActions: result.nextActions || [],
-        blockers: []
-      });
-
-      return {
-        runId,
-        status: "succeeded",
-        result
-      };
-    } catch (error) {
-      await this.memoryStore.appendEvent(agentId, {
-        title: `job:${job.id}:failed`,
-        content: error.message,
-        category: "job_failure",
-        salience: 0.78
-      });
-
-      await this.memoryStore.saveCheckpoint(agentId, "latest", {
-        objective: job.taskType,
-        status: "failed",
-        nextActions: [],
-        blockers: [error.message],
-        failedAt: nowIso()
-      });
-
-      return {
-        runId,
-        status: "failed",
-        error: error.message
-      };
-    }
-  }
-}
+function nowIso() {
+  return new Date().toISOString();
+}
+
+export class JobRunner {
+  constructor({ memoryStore }) {
+    this.memoryStore = memoryStore;
+  }
+
+  async run(job, execute) {
+    const runId = `${job.id}:${Date.now()}`;
+    const agentId = job.agentId;
+
+    await this.memoryStore.appendEvent(agentId, {
+      title: `job:${job.id}:queued`,
+      content: `Run ${runId} queued`,
+      category: "job_state",
+      salience: 0.4
+    });
+
+    await this.memoryStore.saveCheckpoint(agentId, "latest", {
+      objective: job.taskType,
+      status: "running",
+      nextActions: [],
+      blockers: [],
+      runId
+    });
+
+    try {
+      const result = await execute({
+        runId,
+        budget: job.budget
+      });
+
+      await this.memoryStore.writeSummary(agentId, {
+        title: `job:${job.id}:summary`,
+        summary: result.summary,
+        content: result.output,
+        category: "job_summary",
+        salience: 0.72
+      });
+
+      await this.memoryStore.saveCheckpoint(agentId, "latest", {
+        objective: job.taskType,
+        status: "succeeded",
+        nextActions: result.nextActions || [],
+        blockers: []
+      });
+
+      return {
+        runId,
+        status: "succeeded",
+        result
+      };
+    } catch (error) {
+      await this.memoryStore.appendEvent(agentId, {
+        title: `job:${job.id}:failed`,
+        content: error.message,
+        category: "job_failure",
+        salience: 0.78
+      });
+
+      await this.memoryStore.saveCheckpoint(agentId, "latest", {
+        objective: job.taskType,
+        status: "failed",
+        nextActions: [],
+        blockers: [error.message],
+        failedAt: nowIso()
+      });
+
+      return {
+        runId,
+        status: "failed",
+        error: error.message
+      };
+    }
+  }
+}

package/src/mcp/consumer.js

@@ -1,129 +1,129 @@
-// src/mcp/consumer.js
-import { expandEnvRefs } from "../config/loader.js";
-import { McpClient } from "../tools/mcp-client.js";
-
-export class McpConsumer {
-  #clients = new Map();
-  #schemaCache = new Map();
-  #config;
-  #clientFactory;
-
-  constructor({ config, clientFactory }) {
-    this.#config = config;
-    this.#clientFactory = clientFactory || ((serverConfig) => new McpClient(serverConfig));
-  }
-
-  async ensureRunning(serverId) {
-    const existing = this.#clients.get(serverId);
-    if (existing && existing.isAlive()) return existing;
-
-    if (existing) {
-      this.#schemaCache.delete(serverId);
-    }
-
-    const serverConfig = this.#config.servers[serverId];
-    if (!serverConfig) throw new Error(`MCP server '${serverId}' not found in config`);
-
-    const resolvedEnv = {};
-    for (const [key, val] of Object.entries(serverConfig.env || {})) {
-      const raw = String(val);
-      const resolved = expandEnvRefs(raw);
-      const varMatch = raw.match(/\$\{([^}]+)\}/);
-      if (varMatch && !process.env[varMatch[1]]) {
-        console.warn(`[mcp:${serverId}] env var ${varMatch[1]} is not set`);
-      }
-      resolvedEnv[key] = resolved;
-    }
-
-    const client = this.#clientFactory({
-      command: serverConfig.command,
-      args: serverConfig.args || [],
-      env: resolvedEnv,
-      timeout: serverConfig.timeout || 30000,
-    });
-
-    await client.spawn();
-    this.#clients.set(serverId, client);
-    return client;
-  }
-
-  async callTool(serverId, toolName, args) {
-    let client;
-    try {
-      client = await this.ensureRunning(serverId);
-      return await client.callTool(toolName, args);
-    } catch (err) {
-      if (client && !client.isAlive()) {
-        this.#clients.delete(serverId);
-        const retryClient = await this.ensureRunning(serverId);
-        return await retryClient.callTool(toolName, args);
-      }
-      throw err;
-    }
-  }
-
-  async allSchemas() {
-    const schemas = [];
-    for (const serverId of Object.keys(this.#config.servers)) {
-      try {
-        const tools = await this.#getServerTools(serverId);
-        for (const tool of tools) {
-          schemas.push({
-            server: serverId,
-            name: `mcp:${serverId}.${tool.name}`,
-            description: tool.description || "",
-            inputSchema: tool.inputSchema || {},
-          });
-        }
-      } catch (err) {
-        console.warn(`[mcp:${serverId}] failed to start: ${err.message}`);
-      }
-    }
-    return schemas;
-  }
-
-  cachedSchemas() {
-    const schemas = [];
-    for (const [serverId, tools] of this.#schemaCache) {
-      for (const tool of tools) {
-        schemas.push({
-          server: serverId,
-          name: `mcp:${serverId}.${tool.name}`,
-          description: tool.description || "",
-          inputSchema: tool.inputSchema || {},
-        });
-      }
-    }
-    return schemas;
-  }
-
-  async shutdown() {
-    for (const [, client] of this.#clients) {
-      try {
-        client.kill();
-      } catch {
-        // Best-effort kill
-      }
-    }
-    this.#clients.clear();
-  }
-
-  healthSummary() {
-    const summary = [];
-    for (const serverId of Object.keys(this.#config.servers)) {
-      const client = this.#clients.get(serverId);
-      summary.push({ id: serverId, alive: Boolean(client?.isAlive()) });
-    }
-    return summary;
-  }
-
-  async #getServerTools(serverId) {
-    const cached = this.#schemaCache.get(serverId);
-    if (cached) return cached;
-
-    const client = await this.ensureRunning(serverId);
-    const tools = await client.listTools();
-    this.#schemaCache.set(serverId, tools);
-    return tools;
-  }
-}
+// src/mcp/consumer.js
+import { expandEnvRefs } from "../config/loader.js";
+import { McpClient } from "../tools/mcp-client.js";
+
+export class McpConsumer {
+  #clients = new Map();
+  #schemaCache = new Map();
+  #config;
+  #clientFactory;
+
+  constructor({ config, clientFactory }) {
+    this.#config = config;
+    this.#clientFactory = clientFactory || ((serverConfig) => new McpClient(serverConfig));
+  }
+
+  async ensureRunning(serverId) {
+    const existing = this.#clients.get(serverId);
+    if (existing && existing.isAlive()) return existing;
+
+    if (existing) {
+      this.#schemaCache.delete(serverId);
+    }
+
+    const serverConfig = this.#config.servers[serverId];
+    if (!serverConfig) throw new Error(`MCP server '${serverId}' not found in config`);
+
+    const resolvedEnv = {};
+    for (const [key, val] of Object.entries(serverConfig.env || {})) {
+      const raw = String(val);
+      const resolved = expandEnvRefs(raw);
+      const varMatch = raw.match(/\$\{([^}]+)\}/);
+      if (varMatch && !process.env[varMatch[1]]) {
+        console.warn(`[mcp:${serverId}] env var ${varMatch[1]} is not set`);
+      }
+      resolvedEnv[key] = resolved;
+    }
+
+    const client = this.#clientFactory({
+      command: serverConfig.command,
+      args: serverConfig.args || [],
+      env: resolvedEnv,
+      timeout: serverConfig.timeout || 30000,
+    });
+
+    await client.spawn();
+    this.#clients.set(serverId, client);
+    return client;
+  }
+
+  async callTool(serverId, toolName, args) {
+    let client;
+    try {
+      client = await this.ensureRunning(serverId);
+      return await client.callTool(toolName, args);
+    } catch (err) {
+      if (client && !client.isAlive()) {
+        this.#clients.delete(serverId);
+        const retryClient = await this.ensureRunning(serverId);
+        return await retryClient.callTool(toolName, args);
+      }
+      throw err;
+    }
+  }
+
+  async allSchemas() {
+    const schemas = [];
+    for (const serverId of Object.keys(this.#config.servers)) {
+      try {
+        const tools = await this.#getServerTools(serverId);
+        for (const tool of tools) {
+          schemas.push({
+            server: serverId,
+            name: `mcp:${serverId}.${tool.name}`,
+            description: tool.description || "",
+            inputSchema: tool.inputSchema || {},
+          });
+        }
+      } catch (err) {
+        console.warn(`[mcp:${serverId}] failed to start: ${err.message}`);
+      }
+    }
+    return schemas;
+  }
+
+  cachedSchemas() {
+    const schemas = [];
+    for (const [serverId, tools] of this.#schemaCache) {
+      for (const tool of tools) {
+        schemas.push({
+          server: serverId,
+          name: `mcp:${serverId}.${tool.name}`,
+          description: tool.description || "",
+          inputSchema: tool.inputSchema || {},
+        });
+      }
+    }
+    return schemas;
+  }
+
+  async shutdown() {
+    for (const [, client] of this.#clients) {
+      try {
+        client.kill();
+      } catch {
+        // Best-effort kill
+      }
+    }
+    this.#clients.clear();
+  }
+
+  healthSummary() {
+    const summary = [];
+    for (const serverId of Object.keys(this.#config.servers)) {
+      const client = this.#clients.get(serverId);
+      summary.push({ id: serverId, alive: Boolean(client?.isAlive()) });
+    }
+    return summary;
+  }
+
+  async #getServerTools(serverId) {
+    const cached = this.#schemaCache.get(serverId);
+    if (cached) return cached;
+
+    const client = await this.ensureRunning(serverId);
+    const tools = await client.listTools();
+    this.#schemaCache.set(serverId, tools);
+    return tools;
+  }
+}