@lovelybunch/api 1.0.34 → 1.0.37

package/dist/routes/api/v1/ai/route.js

@@ -2,6 +2,7 @@ import { homedir } from 'os';
 import { join } from 'path';
 import { existsSync, readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
+import { proposalsTool, listProposalsTool } from '@lovelybunch/mcp';
 // Function to get global config API key as fallback
 function getGlobalApiKey(provider) {
     try {
@@ -30,8 +31,8 @@ function getGlobalApiKey(provider) {
 }
 export async function POST(c) {
     try {
-        const { message, history, model, context, contextContent, agentPersona, systemPrompt: systemOverride, maxTokens } = await c.req.json();
-        if (!message) {
+        const { message: userMessage, history, model, context, contextContent, agentPersona, systemPrompt: systemOverride, maxTokens, enableTools } = await c.req.json();
+        if (!userMessage) {
             return c.json({ error: "Message is required" }, 400);
         }
         // Try environment variable first, then global config
@@ -49,6 +50,17 @@ export async function POST(c) {
         const systemPrompt = agentPersona
             ? `${baseSystem}\n\nThe following persona is authoritative and overrides general guidance above. You must strictly follow it.\n\n${agentPersona}`
             : baseSystem;
+        // Prepare tools for function calling
+        const tools = enableTools ? [
+            {
+                type: "function",
+                function: listProposalsTool
+            },
+            {
+                type: "function",
+                function: proposalsTool
+            }
+        ] : null;
         // Compose the message list: system + history (preferred) or single message
         let messagesPayload;
         if (Array.isArray(history) && history.length > 0) {
@@ -62,9 +74,27 @@ export async function POST(c) {
         else {
             messagesPayload = [
                 { role: 'system', content: systemPrompt },
-                { role: 'user', content: message },
+                { role: 'user', content: userMessage },
             ];
         }
+        const requestBody = {
+            model: model || "openai/gpt-4o",
+            messages: messagesPayload,
+            temperature: 0.7,
+            max_tokens: typeof maxTokens === 'number' ? Math.max(256, Math.min(4000, Math.floor(maxTokens))) : 2000,
+        };
+        // Add tools if enabled
+        if (tools) {
+            requestBody.tools = tools;
+            requestBody.tool_choice = "auto";
+        }
+        // Debug logging
+        console.log('AI Request Debug:', {
+            enableTools,
+            tools: tools ? tools.length : 'null',
+            hasToolChoice: !!requestBody.tool_choice,
+            model: requestBody.model
+        });
         const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
             method: "POST",
             headers: {
@@ -73,12 +103,7 @@ export async function POST(c) {
                 "HTTP-Referer": process.env.NEXT_PUBLIC_SITE_URL || "http://localhost:3001",
                 "X-Title": "Coconut AI Assistant",
             },
-            body: JSON.stringify({
-                model: model || "anthropic/claude-3-sonnet",
-                messages: messagesPayload,
-                temperature: 0.7,
-                max_tokens: typeof maxTokens === 'number' ? Math.max(256, Math.min(4000, Math.floor(maxTokens))) : 2000,
-            }),
+            body: JSON.stringify(requestBody),
         });
         if (!response.ok) {
             const error = await response.text();
@@ -86,17 +111,101 @@ export async function POST(c) {
             return c.json({ error: "Failed to get AI response" }, 500);
         }
         const data = await response.json();
-        const aiResponse = data.choices?.[0]?.message?.content;
-        if (!aiResponse) {
+        const aiMessage = data.choices?.[0]?.message;
+        if (!aiMessage) {
             return c.json({ error: "No response from AI model" }, 500);
         }
-        return c.json({ response: aiResponse });
+        // Handle tool calls
+        if (aiMessage.tool_calls && aiMessage.tool_calls.length > 0) {
+            const toolResults = await executeToolCalls(aiMessage.tool_calls);
+            // Add tool results to the conversation and get final response
+            const messagesWithTools = [
+                ...messagesPayload,
+                aiMessage,
+                ...toolResults.map(result => ({
+                    role: 'tool',
+                    content: result.content,
+                    tool_call_id: result.tool_call_id
+                }))
+            ];
+            // Get final response from AI with tool results
+            const finalResponse = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+                method: "POST",
+                headers: {
+                    "Authorization": `Bearer ${openRouterKey}`,
+                    "Content-Type": "application/json",
+                    "HTTP-Referer": process.env.NEXT_PUBLIC_SITE_URL || "http://localhost:3001",
+                    "X-Title": "Coconut AI Assistant",
+                },
+                body: JSON.stringify({
+                    model: model || "openai/gpt-4o",
+                    messages: messagesWithTools,
+                    temperature: 0.7,
+                    max_tokens: typeof maxTokens === 'number' ? Math.max(256, Math.min(4000, Math.floor(maxTokens))) : 2000,
+                }),
+            });
+            if (!finalResponse.ok) {
+                const error = await finalResponse.text();
+                console.error("OpenRouter API error for final response:", error);
+                return c.json({ error: "Failed to get final AI response" }, 500);
+            }
+            const finalData = await finalResponse.json();
+            const finalMessage = finalData.choices?.[0]?.message;
+            return c.json({
+                response: finalMessage?.content || "Tool execution completed",
+                toolCalls: aiMessage.tool_calls,
+                toolResults: toolResults
+            });
+        }
+        return c.json({ response: aiMessage.content });
     }
     catch (error) {
         console.error("AI API error:", error);
         return c.json({ error: "Internal server error" }, 500);
     }
 }
+async function executeToolCalls(toolCalls) {
+    const results = [];
+    for (const toolCall of toolCalls) {
+        try {
+            // Handle both function calling formats
+            const functionName = toolCall.function?.name || toolCall.name;
+            const functionArgs = toolCall.function?.arguments ?
+                JSON.parse(toolCall.function.arguments) :
+                toolCall.arguments;
+            const response = await fetch(`${process.env.API_BASE_URL || 'http://localhost:3001'}/api/v1/mcp/execute`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    tool: functionName,
+                    arguments: functionArgs
+                })
+            });
+            const result = await response.json();
+            results.push({
+                tool_call_id: toolCall.id,
+                content: JSON.stringify({
+                    success: result.success,
+                    data: result.data,
+                    message: result.message,
+                    error: result.error
+                })
+            });
+        }
+        catch (error) {
+            results.push({
+                tool_call_id: toolCall.id,
+                content: JSON.stringify({
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Unknown error'
+                })
+            });
+        }
+    }
+    return results;
+}
 function readSharedPrompt(name) {
     // Try multiple candidate paths depending on cwd when running via Turbo
     const moduleDir = fileURLToPath(new URL('.', import.meta.url));

package/dist/routes/api/v1/config/index.js

@@ -1,5 +1,6 @@
 import { Hono } from 'hono';
-import { GET } from './route.js';
+import { GET, PUT } from './route.js';
 const config = new Hono();
 config.get('/', GET);
+config.put('/', PUT);
 export default config;

package/dist/routes/api/v1/config/route.d.ts

@@ -1,9 +1,19 @@
 import { Context } from 'hono';
 export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
-    error: string;
-}, 404, "json">) | (Response & import("hono").TypedResponse<{
     success: true;
     data: any;
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     error: string;
-}, 500, "json">)>;
+}, 500, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 404, "json">)>;
+export declare function PUT(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    message: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 405, "json">)>;

package/dist/routes/api/v1/config/route.js

@@ -1,29 +1,129 @@
 import { promises as fs } from 'fs';
 import path from 'path';
 import { findGaitDirectory } from '../../../../lib/gait-path.js';
+import { homedir } from 'os';
 async function getConfigPath() {
     const gaitDir = await findGaitDirectory();
     if (!gaitDir)
         return null;
     return path.join(gaitDir, 'config.json');
 }
+// Get global config directory (same logic as ConfigManager)
+function getGlobalConfigDir() {
+    const platform = process.platform;
+    if (platform === 'win32') {
+        return path.join(process.env.APPDATA || homedir(), 'coconuts');
+    }
+    else if (platform === 'darwin') {
+        return path.join(homedir(), 'Library', 'Application Support', 'coconuts');
+    }
+    else {
+        // Linux/Unix
+        return path.join(process.env.XDG_CONFIG_HOME || path.join(homedir(), '.config'), 'coconuts');
+    }
+}
+async function getGlobalConfigPath() {
+    const configDir = getGlobalConfigDir();
+    await fs.mkdir(configDir, { recursive: true });
+    return path.join(configDir, 'config.json');
+}
 export async function GET(c) {
-    try {
-        const configPath = await getConfigPath();
-        if (!configPath) {
-            return c.json({ error: 'GAIT directory not found' }, 404);
+    const url = new URL(c.req.url);
+    const type = url.searchParams.get('type');
+    if (type === 'global') {
+        // Return global CLI config (API keys)
+        try {
+            const configPath = await getGlobalConfigPath();
+            let config;
+            try {
+                const content = await fs.readFile(configPath, 'utf-8');
+                config = JSON.parse(content);
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    config = { apiKeys: {}, defaults: {} };
+                }
+                else {
+                    throw error;
+                }
+            }
+            return c.json({
+                success: true,
+                data: config
+            });
+        }
+        catch (error) {
+            return c.json({ error: 'Failed to read global config' }, 500);
         }
-        const content = await fs.readFile(configPath, 'utf-8');
-        const config = JSON.parse(content);
-        return c.json({
-            success: true,
-            data: config
-        });
     }
-    catch (error) {
-        if (error.code === 'ENOENT') {
-            return c.json({ error: 'Config file not found' }, 404);
+    else {
+        // Original GAIT project config logic
+        try {
+            const configPath = await getConfigPath();
+            if (!configPath) {
+                return c.json({ error: 'GAIT directory not found' }, 404);
+            }
+            const content = await fs.readFile(configPath, 'utf-8');
+            const config = JSON.parse(content);
+            return c.json({
+                success: true,
+                data: config
+            });
         }
-        return c.json({ error: 'Failed to read config' }, 500);
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return c.json({ error: 'Config file not found' }, 404);
+            }
+            return c.json({ error: 'Failed to read config' }, 500);
+        }
+    }
+}
+export async function PUT(c) {
+    const url = new URL(c.req.url);
+    const type = url.searchParams.get('type');
+    if (type === 'global') {
+        // Update global CLI config (API keys)
+        try {
+            const body = await c.req.json();
+            const { apiKeys, defaults } = body;
+            if (!apiKeys && !defaults) {
+                return c.json({ error: 'Missing apiKeys or defaults in request body' }, 400);
+            }
+            const configPath = await getGlobalConfigPath();
+            // Load existing config
+            let config;
+            try {
+                const content = await fs.readFile(configPath, 'utf-8');
+                config = JSON.parse(content);
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    config = { apiKeys: {}, defaults: {} };
+                }
+                else {
+                    throw error;
+                }
+            }
+            // Update config
+            if (apiKeys) {
+                config.apiKeys = { ...config.apiKeys, ...apiKeys };
+            }
+            if (defaults) {
+                config.defaults = { ...config.defaults, ...defaults };
+            }
+            // Save config
+            await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+            return c.json({
+                success: true,
+                message: 'Global configuration updated successfully'
+            });
+        }
+        catch (error) {
+            console.error('Error updating global config:', error);
+            return c.json({ error: 'Failed to update global config' }, 500);
+        }
+    }
+    else {
+        return c.json({ error: 'PUT not supported for project config' }, 405);
     }
 }

package/dist/routes/api/v1/context/architecture/route.js

@@ -2,11 +2,8 @@ import { Hono } from 'hono';
 import { promises as fs } from 'fs';
 import path from 'path';
 import matter from 'gray-matter';
-import { trimTrailingSlash } from 'hono/trailing-slash';
 import { findGaitDirectory } from '../../../../../lib/gait-path.js';
 const app = new Hono();
-// Handle trailing slashes consistently
-app.use('*', trimTrailingSlash());
 async function getArchitecturePath() {
     const gaitDir = await findGaitDirectory();
     if (!gaitDir)

package/dist/routes/api/v1/context/project/route.js

@@ -2,11 +2,8 @@ import { Hono } from 'hono';
 import { promises as fs } from 'fs';
 import path from 'path';
 import matter from 'gray-matter';
-import { trimTrailingSlash } from 'hono/trailing-slash';
 import { findGaitDirectory } from '../../../../../lib/gait-path.js';
 const app = new Hono();
-// Handle trailing slashes consistently
-app.use('*', trimTrailingSlash());
 async function getProjectPath() {
     const gaitDir = await findGaitDirectory();
     if (!gaitDir)