@kalera/munin-runtime 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> @kalera/munin-runtime@0.1.0 build /home/runner/work/munin-for-agents/munin-for-agents/packages/runtime
+> tsc -p tsconfig.json
+

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export interface ParsedCliArgs {
+    action: string;
+    payload: Record<string, unknown>;
+}
+export interface CliEnv {
+    baseUrl: string;
+    project: string;
+    apiKey?: string;
+    timeoutMs: number;
+    retries: number;
+    backoffMs: number;
+}
+export declare function parseCliArgs(argv: string[], usage: string): ParsedCliArgs;
+export declare function loadCliEnv(): CliEnv;
+export declare function executeWithRetry<T>(task: () => Promise<T>, retries: number, backoffMs: number): Promise<T>;
+export declare function safeError(error: unknown): Record<string, unknown>;
+export * from "./mcp-server.js";

package/dist/index.js

@@ -0,0 +1,71 @@
+const REDACT_KEYS = ["apiKey", "authorization", "token", "secret", "password"];
+export function parseCliArgs(argv, usage) {
+    const [action, payloadRaw] = argv;
+    if (!action) {
+        throw new Error(usage);
+    }
+    if (!payloadRaw) {
+        return { action, payload: {} };
+    }
+    try {
+        return {
+            action,
+            payload: JSON.parse(payloadRaw),
+        };
+    }
+    catch {
+        throw new Error("Payload must be valid JSON");
+    }
+}
+export function loadCliEnv() {
+    const baseUrl = process.env.MUNIN_BASE_URL;
+    if (!baseUrl) {
+        throw new Error("MUNIN_BASE_URL is required");
+    }
+    return {
+        baseUrl,
+        project: process.env.MUNIN_PROJECT ?? "default",
+        apiKey: process.env.MUNIN_API_KEY,
+        timeoutMs: Number(process.env.MUNIN_TIMEOUT_MS ?? 15000),
+        retries: Number(process.env.MUNIN_RETRIES ?? 3),
+        backoffMs: Number(process.env.MUNIN_BACKOFF_MS ?? 300),
+    };
+}
+export async function executeWithRetry(task, retries, backoffMs) {
+    let attempt = 0;
+    let lastError;
+    while (attempt <= retries) {
+        try {
+            return await task();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === retries) {
+                break;
+            }
+            const jitter = Math.floor(Math.random() * 100);
+            await sleep(backoffMs * 2 ** attempt + jitter);
+            attempt += 1;
+        }
+    }
+    throw lastError;
+}
+export function safeError(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: redactText(error.message),
+        };
+    }
+    return { message: redactText(String(error)) };
+}
+function redactText(text) {
+    return REDACT_KEYS.reduce((acc, key) => {
+        const pattern = new RegExp(`${key}\\s*[:=]\\s*[^\\s,]+`, "gi");
+        return acc.replace(pattern, `${key}=[REDACTED]`);
+    }, text);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export * from "./mcp-server.js";

package/dist/mcp-server.d.ts

@@ -0,0 +1 @@
+export declare function startMcpServer(): Promise<void>;

package/dist/mcp-server.js

@@ -0,0 +1,139 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { MuninClient } from "@kalera/munin-sdk";
+import { loadCliEnv, safeError } from "./index.js";
+export async function startMcpServer() {
+    const env = loadCliEnv();
+    const client = new MuninClient({
+        baseUrl: env.baseUrl,
+        project: env.project,
+        apiKey: env.apiKey,
+        timeoutMs: env.timeoutMs,
+    });
+    const server = new Server({
+        name: "munin-mcp-server",
+        version: "0.1.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+            tools: [
+                {
+                    name: "munin_store_memory",
+                    description: "Store or update a memory in Munin. Requires a unique key and the content.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            key: { type: "string", description: "Unique identifier for this memory" },
+                            content: { type: "string", description: "The content to remember" },
+                            title: { type: "string", description: "Optional title" },
+                            tags: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "List of tags, e.g. ['planning', 'frontend']"
+                            }
+                        },
+                        required: ["key", "content"],
+                    },
+                },
+                {
+                    name: "munin_retrieve_memory",
+                    description: "Retrieve a memory by its unique key.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            key: { type: "string", description: "Unique identifier" },
+                        },
+                        required: ["key"],
+                    },
+                },
+                {
+                    name: "munin_search_memories",
+                    description: "Search for memories using semantic search or keywords.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            query: { type: "string", description: "Search query" },
+                            tags: { type: "array", items: { type: "string" } },
+                            limit: { type: "number", description: "Max results (default: 10)" },
+                        },
+                        required: ["query"],
+                    },
+                },
+                {
+                    name: "munin_list_memories",
+                    description: "List all memories with pagination.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            limit: { type: "number" },
+                            offset: { type: "number" },
+                        },
+                    },
+                },
+                {
+                    name: "munin_recent_memories",
+                    description: "Get the most recently updated memories.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            limit: { type: "number" },
+                        },
+                    },
+                },
+            ],
+        };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        try {
+            const args = request.params.arguments || {};
+            let result;
+            switch (request.params.name) {
+                case "munin_store_memory":
+                    result = await client.store(args);
+                    break;
+                case "munin_retrieve_memory":
+                    result = await client.retrieve(args);
+                    break;
+                case "munin_search_memories":
+                    result = await client.search(args);
+                    break;
+                case "munin_list_memories":
+                    result = await client.list(args);
+                    break;
+                case "munin_recent_memories":
+                    result = await client.recent(args);
+                    break;
+                default:
+                    throw new Error(`Unknown tool: ${request.params.name}`);
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errObj = safeError(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error executing tool: ${JSON.stringify(errObj)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Munin MCP Server running on stdio");
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@kalera/munin-runtime",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.2"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@kalera/munin-sdk": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "test": "echo 'adapter-runtime tests: pending'"
+  }
+}

package/src/index.ts

@@ -0,0 +1,99 @@
+export interface ParsedCliArgs {
+  action: string;
+  payload: Record<string, unknown>;
+}
+
+export interface CliEnv {
+  baseUrl: string;
+  project: string;
+  apiKey?: string;
+  timeoutMs: number;
+  retries: number;
+  backoffMs: number;
+}
+
+const REDACT_KEYS = ["apiKey", "authorization", "token", "secret", "password"];
+
+export function parseCliArgs(argv: string[], usage: string): ParsedCliArgs {
+  const [action, payloadRaw] = argv;
+  if (!action) {
+    throw new Error(usage);
+  }
+
+  if (!payloadRaw) {
+    return { action, payload: {} };
+  }
+
+  try {
+    return {
+      action,
+      payload: JSON.parse(payloadRaw) as Record<string, unknown>,
+    };
+  } catch {
+    throw new Error("Payload must be valid JSON");
+  }
+}
+
+export function loadCliEnv(): CliEnv {
+  const baseUrl = process.env.MUNIN_BASE_URL;
+  if (!baseUrl) {
+    throw new Error("MUNIN_BASE_URL is required");
+  }
+
+  return {
+    baseUrl,
+    project: process.env.MUNIN_PROJECT ?? "default",
+    apiKey: process.env.MUNIN_API_KEY,
+    timeoutMs: Number(process.env.MUNIN_TIMEOUT_MS ?? 15000),
+    retries: Number(process.env.MUNIN_RETRIES ?? 3),
+    backoffMs: Number(process.env.MUNIN_BACKOFF_MS ?? 300),
+  };
+}
+
+export async function executeWithRetry<T>(
+  task: () => Promise<T>,
+  retries: number,
+  backoffMs: number,
+): Promise<T> {
+  let attempt = 0;
+  let lastError: unknown;
+
+  while (attempt <= retries) {
+    try {
+      return await task();
+    } catch (error) {
+      lastError = error;
+      if (attempt === retries) {
+        break;
+      }
+      const jitter = Math.floor(Math.random() * 100);
+      await sleep(backoffMs * 2 ** attempt + jitter);
+      attempt += 1;
+    }
+  }
+
+  throw lastError;
+}
+
+export function safeError(error: unknown): Record<string, unknown> {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: redactText(error.message),
+    };
+  }
+
+  return { message: redactText(String(error)) };
+}
+
+function redactText(text: string): string {
+  return REDACT_KEYS.reduce((acc, key) => {
+    const pattern = new RegExp(`${key}\\s*[:=]\\s*[^\\s,]+`, "gi");
+    return acc.replace(pattern, `${key}=[REDACTED]`);
+  }, text);
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export * from "./mcp-server.js";

package/src/mcp-server.ts

@@ -0,0 +1,152 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { MuninClient } from "@kalera/munin-sdk";
+import { loadCliEnv, safeError } from "./index.js";
+
+export async function startMcpServer() {
+  const env = loadCliEnv();
+
+  const client = new MuninClient({
+    baseUrl: env.baseUrl,
+    project: env.project,
+    apiKey: env.apiKey,
+    timeoutMs: env.timeoutMs,
+  });
+
+  const server = new Server(
+    {
+      name: "munin-mcp-server",
+      version: "0.1.0",
+    },
+    {
+      capabilities: {
+        tools: {},
+      },
+    }
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: [
+        {
+          name: "munin_store_memory",
+          description: "Store or update a memory in Munin. Requires a unique key and the content.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              key: { type: "string", description: "Unique identifier for this memory" },
+              content: { type: "string", description: "The content to remember" },
+              title: { type: "string", description: "Optional title" },
+              tags: { 
+                type: "array", 
+                items: { type: "string" }, 
+                description: "List of tags, e.g. ['planning', 'frontend']"
+              }
+            },
+            required: ["key", "content"],
+          },
+        },
+        {
+          name: "munin_retrieve_memory",
+          description: "Retrieve a memory by its unique key.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              key: { type: "string", description: "Unique identifier" },
+            },
+            required: ["key"],
+          },
+        },
+        {
+          name: "munin_search_memories",
+          description: "Search for memories using semantic search or keywords.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: { type: "string", description: "Search query" },
+              tags: { type: "array", items: { type: "string" } },
+              limit: { type: "number", description: "Max results (default: 10)" },
+            },
+            required: ["query"],
+          },
+        },
+        {
+          name: "munin_list_memories",
+          description: "List all memories with pagination.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              limit: { type: "number" },
+              offset: { type: "number" },
+            },
+          },
+        },
+        {
+          name: "munin_recent_memories",
+          description: "Get the most recently updated memories.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              limit: { type: "number" },
+            },
+          },
+        },
+      ],
+    };
+  });
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+      const args = request.params.arguments || {};
+      let result;
+
+      switch (request.params.name) {
+        case "munin_store_memory":
+          result = await client.store(args);
+          break;
+        case "munin_retrieve_memory":
+          result = await client.retrieve(args);
+          break;
+        case "munin_search_memories":
+          result = await client.search(args);
+          break;
+        case "munin_list_memories":
+          result = await client.list(args);
+          break;
+        case "munin_recent_memories":
+          result = await client.recent(args);
+          break;
+        default:
+          throw new Error(`Unknown tool: ${request.params.name}`);
+      }
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2),
+          },
+        ],
+      };
+    } catch (error) {
+      const errObj = safeError(error);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error executing tool: ${JSON.stringify(errObj)}`,
+          },
+        ],
+        isError: true,
+      };
+    }
+  });
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Munin MCP Server running on stdio");
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}