shuvmaki 0.4.26

package/bin.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+// CLI entrypoint with automatic restart capability.
+// Spawns the main CLI and restarts it on non-zero exit codes with throttling.
+// Exit codes 0, 130 (SIGINT), 143 (SIGTERM), or 64 (EXIT_NO_RESTART) terminate cleanly.
+
+import { spawn } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+const NODE_PATH = process.execPath
+const CLI_PATH = join(__dirname, 'dist', 'cli.js')
+
+let lastStart = 0
+
+async function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+async function run() {
+  while (true) {
+    const now = Date.now()
+    const elapsed = now - lastStart
+    if (elapsed < 5000) {
+      await sleep(5000 - elapsed)
+    }
+    lastStart = Date.now()
+
+    try {
+      const code = await new Promise((resolve) => {
+        const child = spawn(NODE_PATH, [CLI_PATH, ...process.argv.slice(2)], {
+          stdio: 'inherit'
+        })
+
+        child.on('exit', (code, signal) => {
+          if (signal) {
+            // Map signals to exit codes similar to bash
+            if (signal === 'SIGINT') resolve(130)
+            else if (signal === 'SIGTERM') resolve(143)
+            else resolve(1)
+          } else {
+            resolve(code || 0)
+          }
+        })
+
+        child.on('error', (err) => {
+          console.error('Failed to start process:', err)
+          resolve(1)
+        })
+      })
+
+      // Exit cleanly if the app ended OK or via SIGINT/SIGTERM
+      if (code === 0 || code === 130 || code === 143 || code === 64) {
+        process.exit(code)
+      }
+      // otherwise loop; the 5s throttle above will apply
+    } catch (err) {
+      console.error('Unexpected error:', err)
+      // Continue looping after error
+    }
+  }
+}
+
+run().catch(err => {
+  console.error('Fatal error:', err)
+  process.exit(1)
+})

package/dist/ai-tool-to-genai.js

@@ -0,0 +1,210 @@
+// AI SDK to Google GenAI tool converter.
+// Transforms Vercel AI SDK tool definitions into Google GenAI CallableTool format
+// for use with Gemini's function calling in the voice assistant.
+import { Type } from '@google/genai';
+import { z, toJSONSchema } from 'zod';
+/**
+ * Convert JSON Schema to GenAI Schema format
+ * Based on the actual implementation used by the GenAI package:
+ * https://github.com/googleapis/js-genai/blob/027f09db662ce6b30f737b10b4d2efcb4282a9b6/src/_transformers.ts#L294
+ */
+function jsonSchemaToGenAISchema(jsonSchema) {
+    const schema = {};
+    // Map JSON Schema type to GenAI Type
+    if (jsonSchema.type) {
+        switch (jsonSchema.type) {
+            case 'string':
+                schema.type = Type.STRING;
+                break;
+            case 'number':
+                schema.type = Type.NUMBER;
+                schema.format = jsonSchema.format || 'float';
+                break;
+            case 'integer':
+                schema.type = Type.INTEGER;
+                schema.format = jsonSchema.format || 'int32';
+                break;
+            case 'boolean':
+                schema.type = Type.BOOLEAN;
+                break;
+            case 'array':
+                schema.type = Type.ARRAY;
+                if (jsonSchema.items) {
+                    schema.items = jsonSchemaToGenAISchema(jsonSchema.items);
+                }
+                if (jsonSchema.minItems !== undefined) {
+                    schema.minItems = jsonSchema.minItems;
+                }
+                if (jsonSchema.maxItems !== undefined) {
+                    schema.maxItems = jsonSchema.maxItems;
+                }
+                break;
+            case 'object':
+                schema.type = Type.OBJECT;
+                if (jsonSchema.properties) {
+                    schema.properties = {};
+                    for (const [key, value] of Object.entries(jsonSchema.properties)) {
+                        schema.properties[key] = jsonSchemaToGenAISchema(value);
+                    }
+                }
+                if (jsonSchema.required) {
+                    schema.required = jsonSchema.required;
+                }
+                // Note: GenAI Schema doesn't have additionalProperties field
+                // We skip it for now
+                break;
+            default:
+                // For unknown types, keep as-is
+                schema.type = jsonSchema.type;
+        }
+    }
+    // Copy over common properties
+    if (jsonSchema.description) {
+        schema.description = jsonSchema.description;
+    }
+    if (jsonSchema.enum) {
+        schema.enum = jsonSchema.enum.map(String);
+    }
+    if (jsonSchema.default !== undefined) {
+        schema.default = jsonSchema.default;
+    }
+    if (jsonSchema.example !== undefined) {
+        schema.example = jsonSchema.example;
+    }
+    if (jsonSchema.nullable) {
+        schema.nullable = true;
+    }
+    // Handle anyOf/oneOf as anyOf in GenAI
+    if (jsonSchema.anyOf) {
+        schema.anyOf = jsonSchema.anyOf.map((s) => jsonSchemaToGenAISchema(s));
+    }
+    else if (jsonSchema.oneOf) {
+        schema.anyOf = jsonSchema.oneOf.map((s) => jsonSchemaToGenAISchema(s));
+    }
+    // Handle number/string specific properties
+    if (jsonSchema.minimum !== undefined) {
+        schema.minimum = jsonSchema.minimum;
+    }
+    if (jsonSchema.maximum !== undefined) {
+        schema.maximum = jsonSchema.maximum;
+    }
+    if (jsonSchema.minLength !== undefined) {
+        schema.minLength = jsonSchema.minLength;
+    }
+    if (jsonSchema.maxLength !== undefined) {
+        schema.maxLength = jsonSchema.maxLength;
+    }
+    if (jsonSchema.pattern) {
+        schema.pattern = jsonSchema.pattern;
+    }
+    return schema;
+}
+/**
+ * Convert AI SDK Tool to GenAI FunctionDeclaration
+ */
+export function aiToolToGenAIFunction(tool) {
+    // Extract the input schema - assume it's a Zod schema
+    const inputSchema = tool.inputSchema;
+    // Get the tool name from the schema or generate one
+    let toolName = 'tool';
+    let jsonSchema = {};
+    if (inputSchema) {
+        // Convert Zod schema to JSON Schema
+        jsonSchema = toJSONSchema(inputSchema);
+        // Extract name from Zod description if available
+        const description = inputSchema.description;
+        if (description) {
+            const nameMatch = description.match(/name:\s*(\w+)/);
+            if (nameMatch) {
+                toolName = nameMatch[1] || '';
+            }
+        }
+    }
+    // Convert JSON Schema to GenAI Schema
+    const genAISchema = jsonSchemaToGenAISchema(jsonSchema);
+    // Create the FunctionDeclaration
+    const functionDeclaration = {
+        name: toolName,
+        description: tool.description || jsonSchema.description || 'Tool function',
+        parameters: genAISchema,
+    };
+    return functionDeclaration;
+}
+/**
+ * Convert AI SDK Tool to GenAI CallableTool
+ */
+export function aiToolToCallableTool(tool, name) {
+    const toolName = name || 'tool';
+    return {
+        name,
+        async tool() {
+            const functionDeclaration = aiToolToGenAIFunction(tool);
+            if (name) {
+                functionDeclaration.name = name;
+            }
+            return {
+                functionDeclarations: [functionDeclaration],
+            };
+        },
+        async callTool(functionCalls) {
+            const parts = [];
+            for (const functionCall of functionCalls) {
+                // Check if this function call matches our tool
+                if (functionCall.name !== toolName &&
+                    name &&
+                    functionCall.name !== name) {
+                    continue;
+                }
+                // Execute the tool if it has an execute function
+                if (tool.execute) {
+                    try {
+                        const result = await tool.execute(functionCall.args || {}, {
+                            toolCallId: functionCall.id || '',
+                            messages: [],
+                        });
+                        // Convert the result to a Part
+                        parts.push({
+                            functionResponse: {
+                                id: functionCall.id,
+                                name: functionCall.name || toolName,
+                                response: {
+                                    output: result,
+                                },
+                            },
+                        });
+                    }
+                    catch (error) {
+                        // Handle errors
+                        parts.push({
+                            functionResponse: {
+                                id: functionCall.id,
+                                name: functionCall.name || toolName,
+                                response: {
+                                    error: error instanceof Error ? error.message : String(error),
+                                },
+                            },
+                        });
+                    }
+                }
+            }
+            return parts;
+        },
+    };
+}
+/**
+ * Helper to extract schema from AI SDK tool
+ */
+export function extractSchemaFromTool(tool) {
+    const inputSchema = tool.inputSchema;
+    if (!inputSchema) {
+        return {};
+    }
+    // Convert Zod schema to JSON Schema
+    return toJSONSchema(inputSchema);
+}
+/**
+ * Given an object of tools, creates an array of CallableTool
+ */
+export function callableToolsFromObject(tools) {
+    return Object.entries(tools).map(([name, tool]) => aiToolToCallableTool(tool, name));
+}

package/dist/ai-tool-to-genai.test.js

@@ -0,0 +1,267 @@
+import { describe, it, expect } from 'vitest';
+import { tool } from 'ai';
+import { z } from 'zod';
+import { Type } from '@google/genai';
+import { aiToolToGenAIFunction, aiToolToCallableTool, extractSchemaFromTool, } from './ai-tool-to-genai.js';
+describe('AI Tool to GenAI Conversion', () => {
+    it('should convert a simple Zod-based tool', () => {
+        const weatherTool = tool({
+            description: 'Get the current weather for a location',
+            inputSchema: z.object({
+                location: z.string().describe('The city name'),
+                unit: z.enum(['celsius', 'fahrenheit']).optional(),
+            }),
+            execute: async ({ location, unit }) => {
+                return {
+                    temperature: 72,
+                    unit: unit || 'fahrenheit',
+                    condition: 'sunny',
+                };
+            },
+        });
+        const genAIFunction = aiToolToGenAIFunction(weatherTool);
+        expect(genAIFunction).toMatchInlineSnapshot(`
+      {
+        "description": "Get the current weather for a location",
+        "name": "tool",
+        "parameters": {
+          "properties": {
+            "location": {
+              "description": "The city name",
+              "type": "STRING",
+            },
+            "unit": {
+              "enum": [
+                "celsius",
+                "fahrenheit",
+              ],
+              "type": "STRING",
+            },
+          },
+          "required": [
+            "location",
+          ],
+          "type": "OBJECT",
+        },
+      }
+    `);
+    });
+    it('should handle complex nested schemas', () => {
+        const complexTool = tool({
+            description: 'Process complex data',
+            inputSchema: z.object({
+                user: z.object({
+                    name: z.string(),
+                    age: z.number().int().min(0).max(150),
+                    email: z.string().email(),
+                }),
+                preferences: z.array(z.string()),
+                metadata: z.record(z.string(), z.unknown()).optional(),
+            }),
+            execute: async (input) => input,
+        });
+        const genAIFunction = aiToolToGenAIFunction(complexTool);
+        expect(genAIFunction.parameters).toMatchInlineSnapshot(`
+      {
+        "properties": {
+          "metadata": {
+            "type": "OBJECT",
+          },
+          "preferences": {
+            "items": {
+              "type": "STRING",
+            },
+            "type": "ARRAY",
+          },
+          "user": {
+            "properties": {
+              "age": {
+                "format": "int32",
+                "maximum": 150,
+                "minimum": 0,
+                "type": "INTEGER",
+              },
+              "email": {
+                "pattern": "^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$",
+                "type": "STRING",
+              },
+              "name": {
+                "type": "STRING",
+              },
+            },
+            "required": [
+              "name",
+              "age",
+              "email",
+            ],
+            "type": "OBJECT",
+          },
+        },
+        "required": [
+          "user",
+          "preferences",
+        ],
+        "type": "OBJECT",
+      }
+    `);
+    });
+    it('should extract schema from tool', () => {
+        const testTool = tool({
+            inputSchema: z.object({
+                test: z.string(),
+            }),
+            execute: async () => { },
+        });
+        const schema = extractSchemaFromTool(testTool);
+        expect(schema).toMatchInlineSnapshot(`
+      {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "additionalProperties": false,
+        "properties": {
+          "test": {
+            "type": "string",
+          },
+        },
+        "required": [
+          "test",
+        ],
+        "type": "object",
+      }
+    `);
+    });
+    it('should handle tools with no input schema', () => {
+        const simpleTool = tool({
+            description: 'Simple tool with no inputs',
+            inputSchema: z.object({}),
+            execute: async () => ({ result: 'done' }),
+        });
+        const genAIFunction = aiToolToGenAIFunction(simpleTool);
+        expect(genAIFunction).toMatchInlineSnapshot(`
+      {
+        "description": "Simple tool with no inputs",
+        "name": "tool",
+        "parameters": {
+          "properties": {},
+          "type": "OBJECT",
+        },
+      }
+    `);
+    });
+    it('should handle union types', () => {
+        const unionTool = tool({
+            description: 'Tool with union types',
+            inputSchema: z.object({
+                value: z.union([z.string(), z.number(), z.boolean()]),
+            }),
+            execute: async ({ value }) => ({ received: value }),
+        });
+        const genAIFunction = aiToolToGenAIFunction(unionTool);
+        expect(genAIFunction.parameters?.properties?.value).toMatchInlineSnapshot(`
+      {
+        "anyOf": [
+          {
+            "type": "STRING",
+          },
+          {
+            "format": "float",
+            "type": "NUMBER",
+          },
+          {
+            "type": "BOOLEAN",
+          },
+        ],
+      }
+    `);
+    });
+    it('should create a CallableTool', async () => {
+        const weatherTool = tool({
+            description: 'Get weather',
+            inputSchema: z.object({
+                location: z.string(),
+            }),
+            execute: async ({ location }) => ({
+                temperature: 72,
+                location,
+            }),
+        });
+        const callableTool = aiToolToCallableTool(weatherTool, 'weather');
+        // Test tool() method
+        const genAITool = await callableTool.tool();
+        expect(genAITool.functionDeclarations).toMatchInlineSnapshot(`
+      [
+        {
+          "description": "Get weather",
+          "name": "weather",
+          "parameters": {
+            "properties": {
+              "location": {
+                "type": "STRING",
+              },
+            },
+            "required": [
+              "location",
+            ],
+            "type": "OBJECT",
+          },
+        },
+      ]
+    `);
+        // Test callTool() method
+        const functionCall = {
+            id: 'call_123',
+            name: 'weather',
+            args: { location: 'San Francisco' },
+        };
+        const parts = await callableTool.callTool([functionCall]);
+        expect(parts).toMatchInlineSnapshot(`
+      [
+        {
+          "functionResponse": {
+            "id": "call_123",
+            "name": "weather",
+            "response": {
+              "output": {
+                "location": "San Francisco",
+                "temperature": 72,
+              },
+            },
+          },
+        },
+      ]
+    `);
+    });
+    it('should handle tool execution errors', async () => {
+        const errorTool = tool({
+            description: 'Tool that throws',
+            inputSchema: z.object({
+                trigger: z.boolean(),
+            }),
+            execute: async ({ trigger }) => {
+                if (trigger) {
+                    throw new Error('Tool execution failed');
+                }
+                return { success: true };
+            },
+        });
+        const callableTool = aiToolToCallableTool(errorTool, 'error_tool');
+        const functionCall = {
+            id: 'call_error',
+            name: 'error_tool',
+            args: { trigger: true },
+        };
+        const parts = await callableTool.callTool([functionCall]);
+        expect(parts).toMatchInlineSnapshot(`
+      [
+        {
+          "functionResponse": {
+            "id": "call_error",
+            "name": "error_tool",
+            "response": {
+              "error": "Tool execution failed",
+            },
+          },
+        },
+      ]
+    `);
+    });
+});

package/dist/channel-management.js

@@ -0,0 +1,97 @@
+// Discord channel and category management.
+// Creates and manages Kimaki project channels (text + voice pairs),
+// extracts channel metadata from topic tags, and ensures category structure.
+import { ChannelType, } from 'discord.js';
+import path from 'node:path';
+import { getDatabase } from './database.js';
+import { extractTagsArrays } from './xml.js';
+export async function ensureKimakiCategory(guild, botName) {
+    const categoryName = botName ? `Kimaki ${botName}` : 'Kimaki';
+    const existingCategory = guild.channels.cache.find((channel) => {
+        if (channel.type !== ChannelType.GuildCategory) {
+            return false;
+        }
+        return channel.name.toLowerCase() === categoryName.toLowerCase();
+    });
+    if (existingCategory) {
+        return existingCategory;
+    }
+    return guild.channels.create({
+        name: categoryName,
+        type: ChannelType.GuildCategory,
+    });
+}
+export async function ensureKimakiAudioCategory(guild, botName) {
+    const categoryName = botName ? `Kimaki Audio ${botName}` : 'Kimaki Audio';
+    const existingCategory = guild.channels.cache.find((channel) => {
+        if (channel.type !== ChannelType.GuildCategory) {
+            return false;
+        }
+        return channel.name.toLowerCase() === categoryName.toLowerCase();
+    });
+    if (existingCategory) {
+        return existingCategory;
+    }
+    return guild.channels.create({
+        name: categoryName,
+        type: ChannelType.GuildCategory,
+    });
+}
+export async function createProjectChannels({ guild, projectDirectory, appId, botName, }) {
+    const baseName = path.basename(projectDirectory);
+    const channelName = `${baseName}`
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .slice(0, 100);
+    const kimakiCategory = await ensureKimakiCategory(guild, botName);
+    const kimakiAudioCategory = await ensureKimakiAudioCategory(guild, botName);
+    const textChannel = await guild.channels.create({
+        name: channelName,
+        type: ChannelType.GuildText,
+        parent: kimakiCategory,
+        topic: `<kimaki><directory>${projectDirectory}</directory><app>${appId}</app></kimaki>`,
+    });
+    const voiceChannel = await guild.channels.create({
+        name: channelName,
+        type: ChannelType.GuildVoice,
+        parent: kimakiAudioCategory,
+    });
+    getDatabase()
+        .prepare('INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)')
+        .run(textChannel.id, projectDirectory, 'text');
+    getDatabase()
+        .prepare('INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type) VALUES (?, ?, ?)')
+        .run(voiceChannel.id, projectDirectory, 'voice');
+    return {
+        textChannelId: textChannel.id,
+        voiceChannelId: voiceChannel.id,
+        channelName,
+    };
+}
+export async function getChannelsWithDescriptions(guild) {
+    const channels = [];
+    guild.channels.cache
+        .filter((channel) => channel.isTextBased())
+        .forEach((channel) => {
+        const textChannel = channel;
+        const description = textChannel.topic || null;
+        let kimakiDirectory;
+        let kimakiApp;
+        if (description) {
+            const extracted = extractTagsArrays({
+                xml: description,
+                tags: ['kimaki.directory', 'kimaki.app'],
+            });
+            kimakiDirectory = extracted['kimaki.directory']?.[0]?.trim();
+            kimakiApp = extracted['kimaki.app']?.[0]?.trim();
+        }
+        channels.push({
+            id: textChannel.id,
+            name: textChannel.name,
+            description,
+            kimakiDirectory,
+            kimakiApp,
+        });
+    });
+    return channels;
+}