@kalera/munin-gemini 0.1.0

package/.turbo/turbo-build.log

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

package/README.md

@@ -0,0 +1,20 @@
+# Munin Adapter for Gemini CLI
+
+## Status
+
+- Phase: scaffold
+- Dispatch style: `callTool(name, args)`
+
+## Usage
+
+```ts
+import { createGeminiCliMuninAdapter } from "@kalera/munin-gemini";
+
+const adapter = createGeminiCliMuninAdapter({
+  baseUrl: process.env.MUNIN_BASE_URL!,
+  apiKey: process.env.MUNIN_API_KEY,
+  project: process.env.MUNIN_PROJECT ?? "default",
+});
+
+await adapter.callTool("list", { limit: 10 });
+```

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,26 @@
+import { executeWithRetry, loadCliEnv, parseCliArgs, safeError, } from "@kalera/munin-runtime";
+import { createGeminiCliMuninAdapter } from "./index.js";
+async function main() {
+    try {
+        const { action, payload } = parseCliArgs(process.argv.slice(2), "Usage: munin-gemini <tool-name> [payload-json]");
+        const env = loadCliEnv();
+        const adapter = createGeminiCliMuninAdapter({
+            baseUrl: env.baseUrl,
+            apiKey: env.apiKey,
+            project: env.project,
+            timeoutMs: env.timeoutMs,
+        });
+        const result = await executeWithRetry(async () => {
+            if (action === "capabilities") {
+                return { ok: true, data: await adapter.capabilities() };
+            }
+            return adapter.callTool(action, payload);
+        }, env.retries, env.backoffMs);
+        console.log(JSON.stringify(result, null, 2));
+    }
+    catch (error) {
+        console.error(JSON.stringify({ ok: false, error: safeError(error) }));
+        process.exitCode = 1;
+    }
+}
+void main();

package/dist/index.d.ts

@@ -0,0 +1,133 @@
+export declare function createGeminiCliMuninAdapter(config: {
+    baseUrl: string;
+    apiKey?: string;
+    project: string;
+    timeoutMs?: number;
+}): {
+    callTool: (name: string, args: Record<string, unknown>) => Promise<import("@kalera/munin-sdk").MuninResponse<unknown>>;
+    capabilities: () => Promise<import("@kalera/munin-sdk").MuninCapabilities>;
+};
+export declare const tools: ({
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            key: {
+                type: string;
+                description: string;
+            };
+            content: {
+                type: string;
+                description: string;
+            };
+            title: {
+                type: string;
+                description: string;
+            };
+            tags: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            query?: undefined;
+            limit?: undefined;
+            offset?: undefined;
+        };
+        required: string[];
+    };
+    execute: (args: any) => Promise<import("@kalera/munin-sdk").MuninResponse<unknown>>;
+} | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            key: {
+                type: string;
+                description: string;
+            };
+            content?: undefined;
+            title?: undefined;
+            tags?: undefined;
+            query?: undefined;
+            limit?: undefined;
+            offset?: undefined;
+        };
+        required: string[];
+    };
+    execute: (args: any) => Promise<import("@kalera/munin-sdk").MuninResponse<unknown>>;
+} | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            tags: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description?: undefined;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            key?: undefined;
+            content?: undefined;
+            title?: undefined;
+            offset?: undefined;
+        };
+        required: string[];
+    };
+    execute: (args: any) => Promise<import("@kalera/munin-sdk").MuninResponse<unknown>>;
+} | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            limit: {
+                type: string;
+                description?: undefined;
+            };
+            offset: {
+                type: string;
+            };
+            key?: undefined;
+            content?: undefined;
+            title?: undefined;
+            tags?: undefined;
+            query?: undefined;
+        };
+        required?: undefined;
+    };
+    execute: (args: any) => Promise<import("@kalera/munin-sdk").MuninResponse<unknown>>;
+} | {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            limit: {
+                type: string;
+                description?: undefined;
+            };
+            key?: undefined;
+            content?: undefined;
+            title?: undefined;
+            tags?: undefined;
+            query?: undefined;
+            offset?: undefined;
+        };
+        required?: undefined;
+    };
+    execute: (args: any) => Promise<import("@kalera/munin-sdk").MuninResponse<unknown>>;
+})[];

package/dist/index.js

@@ -0,0 +1,83 @@
+import { MuninClient } from "@kalera/munin-sdk";
+export function createGeminiCliMuninAdapter(config) {
+    const client = new MuninClient(config);
+    return {
+        callTool: async (name, args) => client.invoke(name, args, { ensureCapability: true }),
+        capabilities: () => client.capabilities(),
+    };
+}
+// Ensure defaults for Gemini CLI if run as an extension
+const baseUrl = process.env.MUNIN_BASE_URL || "http://127.0.0.1:3237";
+const project = process.env.MUNIN_PROJECT || "default";
+const apiKey = process.env.MUNIN_API_KEY;
+const extensionClient = new MuninClient({ baseUrl, project, apiKey });
+export const tools = [
+    {
+        name: "munin_store_memory",
+        description: "Store or update a memory in Munin. Requires a unique key and the content.",
+        parameters: {
+            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"],
+        },
+        execute: async (args) => await extensionClient.store(args),
+    },
+    {
+        name: "munin_retrieve_memory",
+        description: "Retrieve a memory by its unique key.",
+        parameters: {
+            type: "object",
+            properties: {
+                key: { type: "string", description: "Unique identifier" },
+            },
+            required: ["key"],
+        },
+        execute: async (args) => await extensionClient.retrieve(args),
+    },
+    {
+        name: "munin_search_memories",
+        description: "Search for memories using semantic search or keywords.",
+        parameters: {
+            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"],
+        },
+        execute: async (args) => await extensionClient.search(args),
+    },
+    {
+        name: "munin_list_memories",
+        description: "List all memories with pagination.",
+        parameters: {
+            type: "object",
+            properties: {
+                limit: { type: "number" },
+                offset: { type: "number" },
+            },
+        },
+        execute: async (args) => await extensionClient.list(args),
+    },
+    {
+        name: "munin_recent_memories",
+        description: "Get the most recently updated memories.",
+        parameters: {
+            type: "object",
+            properties: {
+                limit: { type: "number" },
+            },
+        },
+        execute: async (args) => await extensionClient.recent(args),
+    },
+];

package/gemini-extension.json

@@ -0,0 +1,9 @@
+{
+  "name": "kalera-munin",
+  "version": "0.1.0",
+  "description": "Kalera Munin - Long-Term Memory extension for Gemini CLI",
+  "main": "dist/index.js",
+  "permissions": {
+    "env": ["MUNIN_BASE_URL", "MUNIN_PROJECT", "MUNIN_API_KEY"]
+  }
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@kalera/munin-gemini",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "munin-gemini": "dist/cli.js"
+  },
+  "dependencies": {
+    "@kalera/munin-sdk": "0.1.0",
+    "@kalera/munin-runtime": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.2"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "test": "echo 'adapter-gemini-cli tests: pending'"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,38 @@
+import {
+  executeWithRetry,
+  loadCliEnv,
+  parseCliArgs,
+  safeError,
+} from "@kalera/munin-runtime";
+import { createGeminiCliMuninAdapter } from "./index.js";
+
+async function main() {
+  try {
+    const { action, payload } = parseCliArgs(
+      process.argv.slice(2),
+      "Usage: munin-gemini <tool-name> [payload-json]",
+    );
+    const env = loadCliEnv();
+
+    const adapter = createGeminiCliMuninAdapter({
+      baseUrl: env.baseUrl,
+      apiKey: env.apiKey,
+      project: env.project,
+      timeoutMs: env.timeoutMs,
+    });
+
+    const result = await executeWithRetry(async () => {
+      if (action === "capabilities") {
+        return { ok: true, data: await adapter.capabilities() };
+      }
+      return adapter.callTool(action, payload);
+    }, env.retries, env.backoffMs);
+
+    console.log(JSON.stringify(result, null, 2));
+  } catch (error) {
+    console.error(JSON.stringify({ ok: false, error: safeError(error) }));
+    process.exitCode = 1;
+  }
+}
+
+void main();

package/src/index.ts

@@ -0,0 +1,94 @@
+import { MuninClient } from "@kalera/munin-sdk";
+
+export function createGeminiCliMuninAdapter(config: {
+  baseUrl: string;
+  apiKey?: string;
+  project: string;
+  timeoutMs?: number;
+}) {
+  const client = new MuninClient(config);
+
+  return {
+    callTool: async (name: string, args: Record<string, unknown>) =>
+      client.invoke(name as any, args, { ensureCapability: true }),
+    capabilities: () => client.capabilities(),
+  };
+}
+
+// Ensure defaults for Gemini CLI if run as an extension
+const baseUrl = process.env.MUNIN_BASE_URL || "http://127.0.0.1:3237";
+const project = process.env.MUNIN_PROJECT || "default";
+const apiKey = process.env.MUNIN_API_KEY;
+
+const extensionClient = new MuninClient({ baseUrl, project, apiKey });
+
+export const tools = [
+  {
+    name: "munin_store_memory",
+    description: "Store or update a memory in Munin. Requires a unique key and the content.",
+    parameters: {
+      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"],
+    },
+    execute: async (args: any) => await extensionClient.store(args),
+  },
+  {
+    name: "munin_retrieve_memory",
+    description: "Retrieve a memory by its unique key.",
+    parameters: {
+      type: "object",
+      properties: {
+        key: { type: "string", description: "Unique identifier" },
+      },
+      required: ["key"],
+    },
+    execute: async (args: any) => await extensionClient.retrieve(args),
+  },
+  {
+    name: "munin_search_memories",
+    description: "Search for memories using semantic search or keywords.",
+    parameters: {
+      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"],
+    },
+    execute: async (args: any) => await extensionClient.search(args),
+  },
+  {
+    name: "munin_list_memories",
+    description: "List all memories with pagination.",
+    parameters: {
+      type: "object",
+      properties: {
+        limit: { type: "number" },
+        offset: { type: "number" },
+      },
+    },
+    execute: async (args: any) => await extensionClient.list(args),
+  },
+  {
+    name: "munin_recent_memories",
+    description: "Get the most recently updated memories.",
+    parameters: {
+      type: "object",
+      properties: {
+        limit: { type: "number" },
+      },
+    },
+    execute: async (args: any) => await extensionClient.recent(args),
+  },
+];

package/tsconfig.json

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