shuvmaki 0.4.26

package/src/ai-tool-to-genai.test.ts

@@ -0,0 +1,296 @@
+import { describe, it, expect } from 'vitest'
+import { tool } from 'ai'
+import { z } from 'zod'
+import { Type } from '@google/genai'
+import type { FunctionDeclaration, FunctionCall } 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: 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: 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/src/ai-tool-to-genai.ts

@@ -0,0 +1,255 @@
+// 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 { Tool, jsonSchema as JsonSchemaType } from 'ai'
+import type {
+  FunctionDeclaration,
+  Schema,
+  Type as GenAIType,
+  Tool as GenAITool,
+  CallableTool,
+  FunctionCall,
+  Part,
+} from '@google/genai'
+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: any): Schema {
+  const schema: 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: any) => jsonSchemaToGenAISchema(s))
+  } else if (jsonSchema.oneOf) {
+    schema.anyOf = jsonSchema.oneOf.map((s: any) => 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: Tool<any, any>,
+): FunctionDeclaration {
+  // Extract the input schema - assume it's a Zod schema
+  const inputSchema = tool.inputSchema as z.ZodType<any>
+
+  // Get the tool name from the schema or generate one
+  let toolName = 'tool'
+  let jsonSchema: any = {}
+
+  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: 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: Tool<any, any>,
+  name: string,
+): CallableTool & { name: string } {
+  const toolName = name || 'tool'
+
+  return {
+    name,
+    async tool(): Promise<GenAITool> {
+      const functionDeclaration = aiToolToGenAIFunction(tool)
+      if (name) {
+        functionDeclaration.name = name
+      }
+
+      return {
+        functionDeclarations: [functionDeclaration],
+      }
+    },
+
+    async callTool(functionCalls: FunctionCall[]): Promise<Part[]> {
+      const parts: Part[] = []
+
+      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,
+                },
+              },
+            } as Part)
+          } catch (error) {
+            // Handle errors
+            parts.push({
+              functionResponse: {
+                id: functionCall.id,
+                name: functionCall.name || toolName,
+                response: {
+                  error: error instanceof Error ? error.message : String(error),
+                },
+              },
+            } as Part)
+          }
+        }
+      }
+
+      return parts
+    },
+  }
+}
+
+/**
+ * Helper to extract schema from AI SDK tool
+ */
+export function extractSchemaFromTool(tool: Tool<any, any>): any {
+  const inputSchema = tool.inputSchema as z.ZodType<any>
+
+  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: Record<string, Tool<any, any>>,
+): Array<CallableTool & { name: string }> {
+  return Object.entries(tools).map(([name, tool]) =>
+    aiToolToCallableTool(tool, name),
+  )
+}

package/src/channel-management.ts

@@ -0,0 +1,161 @@
+// 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,
+  type CategoryChannel,
+  type Guild,
+  type TextChannel,
+} from 'discord.js'
+import path from 'node:path'
+import { getDatabase } from './database.js'
+import { extractTagsArrays } from './xml.js'
+
+export async function ensureKimakiCategory(
+  guild: Guild,
+  botName?: string,
+): Promise<CategoryChannel> {
+  const categoryName = botName ? `Kimaki ${botName}` : 'Kimaki'
+
+  const existingCategory = guild.channels.cache.find(
+    (channel): channel is CategoryChannel => {
+      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: Guild,
+  botName?: string,
+): Promise<CategoryChannel> {
+  const categoryName = botName ? `Kimaki Audio ${botName}` : 'Kimaki Audio'
+
+  const existingCategory = guild.channels.cache.find(
+    (channel): channel is CategoryChannel => {
+      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,
+}: {
+  guild: Guild
+  projectDirectory: string
+  appId: string
+  botName?: string
+}): Promise<{ textChannelId: string; voiceChannelId: string; channelName: string }> {
+  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 type ChannelWithTags = {
+  id: string
+  name: string
+  description: string | null
+  kimakiDirectory?: string
+  kimakiApp?: string
+}
+
+export async function getChannelsWithDescriptions(
+  guild: Guild,
+): Promise<ChannelWithTags[]> {
+  const channels: ChannelWithTags[] = []
+
+  guild.channels.cache
+    .filter((channel) => channel.isTextBased())
+    .forEach((channel) => {
+      const textChannel = channel as TextChannel
+      const description = textChannel.topic || null
+
+      let kimakiDirectory: string | undefined
+      let kimakiApp: string | undefined
+
+      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
+}