@lovelybunch/api 1.0.76-alpha.0 → 1.0.76-alpha.2

package/dist/lib/mcp-client.d.ts

@@ -0,0 +1,39 @@
+/**
+ * MCP Client helper for connecting to HTTP/SSE MCP servers
+ * Provides tool discovery and execution proxying
+ */
+export interface McpServerConfig {
+    name?: string;
+    type?: 'http' | 'sse' | 'stdio';
+    url?: string;
+    enabled?: boolean;
+    env?: Record<string, string>;
+}
+export interface DiscoveredTool {
+    name: string;
+    description?: string;
+    inputSchema?: object;
+    serverName: string;
+    serverUrl: string;
+}
+export interface ToolCallResult {
+    content: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+    isError?: boolean;
+    structuredContent?: unknown;
+}
+/**
+ * Connect to an HTTP/SSE MCP server and discover its available tools
+ */
+export declare function discoverToolsFromServer(serverName: string, config: McpServerConfig): Promise<DiscoveredTool[]>;
+/**
+ * Execute a tool on an HTTP/SSE MCP server
+ */
+export declare function executeToolOnServer(serverName: string, config: McpServerConfig, toolName: string, args: Record<string, unknown>): Promise<ToolCallResult>;
+/**
+ * Close all cached client connections (for cleanup)
+ */
+export declare function closeAllConnections(): void;

package/dist/lib/mcp-client.js

@@ -0,0 +1,131 @@
+/**
+ * MCP Client helper for connecting to HTTP/SSE MCP servers
+ * Provides tool discovery and execution proxying
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+// Cache for active client connections
+const clientCache = new Map();
+// Clean up stale connections after 5 minutes
+const CONNECTION_TTL_MS = 5 * 60 * 1000;
+/**
+ * Get or create a client connection to an MCP server
+ */
+async function getOrCreateClient(serverName, config) {
+    const cacheKey = `${serverName}:${config.url}`;
+    const cached = clientCache.get(cacheKey);
+    if (cached) {
+        cached.lastUsed = Date.now();
+        return cached.client;
+    }
+    const client = new Client({
+        name: 'coconut-api',
+        version: '1.0.0'
+    });
+    const url = new URL(config.url);
+    // Try StreamableHTTP first (newer), fall back to SSE (legacy)
+    let transport;
+    if (config.type === 'sse') {
+        // Explicitly SSE
+        transport = new SSEClientTransport(url);
+    }
+    else {
+        // Default to StreamableHTTP for 'http' type or unspecified
+        transport = new StreamableHTTPClientTransport(url);
+    }
+    await client.connect(transport);
+    clientCache.set(cacheKey, { client, lastUsed: Date.now() });
+    // Schedule cleanup
+    scheduleCleanup();
+    return client;
+}
+let cleanupScheduled = false;
+function scheduleCleanup() {
+    if (cleanupScheduled)
+        return;
+    cleanupScheduled = true;
+    setTimeout(() => {
+        cleanupScheduled = false;
+        const now = Date.now();
+        for (const [key, entry] of clientCache.entries()) {
+            if (now - entry.lastUsed > CONNECTION_TTL_MS) {
+                try {
+                    entry.client.close();
+                }
+                catch (e) {
+                    // Ignore close errors
+                }
+                clientCache.delete(key);
+            }
+        }
+        // Reschedule if there are still cached connections
+        if (clientCache.size > 0) {
+            scheduleCleanup();
+        }
+    }, CONNECTION_TTL_MS);
+}
+/**
+ * Connect to an HTTP/SSE MCP server and discover its available tools
+ */
+export async function discoverToolsFromServer(serverName, config) {
+    if (!config.url) {
+        throw new Error(`Server ${serverName} has no URL configured`);
+    }
+    if (config.enabled === false) {
+        return [];
+    }
+    try {
+        const client = await getOrCreateClient(serverName, config);
+        const toolsResult = await client.listTools();
+        return toolsResult.tools.map(tool => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+            serverName,
+            serverUrl: config.url
+        }));
+    }
+    catch (error) {
+        console.error(`Failed to discover tools from ${serverName}:`, error);
+        throw error;
+    }
+}
+/**
+ * Execute a tool on an HTTP/SSE MCP server
+ */
+export async function executeToolOnServer(serverName, config, toolName, args) {
+    if (!config.url) {
+        throw new Error(`Server ${serverName} has no URL configured`);
+    }
+    try {
+        const client = await getOrCreateClient(serverName, config);
+        const result = await client.callTool({
+            name: toolName,
+            arguments: args
+        });
+        return {
+            content: result.content,
+            isError: result.isError,
+            structuredContent: result.structuredContent
+        };
+    }
+    catch (error) {
+        console.error(`Failed to execute tool ${toolName} on ${serverName}:`, error);
+        throw error;
+    }
+}
+/**
+ * Close all cached client connections (for cleanup)
+ */
+export function closeAllConnections() {
+    for (const [key, entry] of clientCache.entries()) {
+        try {
+            entry.client.close();
+        }
+        catch (e) {
+            // Ignore close errors
+        }
+        clientCache.delete(key);
+    }
+}

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

@@ -1,11 +1,9 @@
-import { fileURLToPath } from 'url';
 import { homedir } from 'os';
 import { join, resolve as pathResolve, basename } from 'path';
 import { existsSync, readFileSync, promises as fs, createReadStream } from 'fs';
 import readline from 'readline';
-import { ZodError } from 'zod';
-import { getLogsDir, listProposals, getProposal, createProposal, updateProposal, deleteProposal, } from '@lovelybunch/core';
-import { proposalsFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool, roleContextTool } from '@lovelybunch/mcp';
+import { getLogsDir } from '@lovelybunch/core';
+import { proposalsReadOnlyTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool } from '@lovelybunch/mcp';
 import matter from 'gray-matter';
 import { FileStorageAdapter } from '../../../../lib/storage/file-storage.js';
 // Function to get global config API key as fallback
@@ -53,7 +51,7 @@ export async function POST(c) {
         // Execute all tool calls
         const toolResults = await executeToolCalls(toolCalls);
         // Build the system prompt
-        const baseSystem = getSystemPrompt();
+        const baseSystem = getSystemPrompt(context, contextContent);
         const systemPrompt = agentPersona
             ? `${baseSystem}\n\nThe following persona is authoritative and overrides general guidance above. You must strictly follow it.\n\n${agentPersona}`
             : baseSystem;
@@ -94,11 +92,11 @@ export async function POST(c) {
             ...toolResultMessages
         ];
         // Prepare tools for potential additional tool calls
-        // Note: proposals/knowledge/project/architecture are read+write, events is read-only
+        // Note: proposals is read-only, knowledge/project/architecture are read+write, events is read-only
         const tools = [
             {
                 type: "function",
-                function: proposalsFullTool
+                function: proposalsReadOnlyTool
             },
             {
                 type: "function",
@@ -115,10 +113,6 @@ export async function POST(c) {
             {
                 type: "function",
                 function: architectureContextTool
-            },
-            {
-                type: "function",
-                function: roleContextTool
             }
         ];
         // Accumulate all tool calls and results across multiple rounds
@@ -243,9 +237,6 @@ async function executeToolCalls(toolCalls) {
                     let argsStr = toolCall.function.arguments;
                     // Remove trailing commas before ] or }
                     argsStr = argsStr.replace(/,(\s*[}\]])/g, '$1');
-                    // Fix common LLM JSON issues:
-                    // 1. Remove control characters (except \n, \r, \t which are valid in JSON strings)
-                    argsStr = argsStr.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '');
                     // Try parsing the sanitized string
                     functionArgs = JSON.parse(argsStr);
                 }
@@ -259,16 +250,11 @@ async function executeToolCalls(toolCalls) {
                     arguments: toolCall.function?.arguments?.substring(0, 500),
                     error: parseError instanceof Error ? parseError.message : 'Unknown parse error'
                 });
-                // Provide a more helpful error message
-                const errorMsg = parseError instanceof Error ? parseError.message : 'JSON parse error';
-                const hint = errorMsg.includes('position')
-                    ? 'The content may contain unescaped quotes or special characters. Try updating with shorter/simpler content, or update one field at a time.'
-                    : 'Please retry with simpler content.';
                 return {
                     tool_call_id: toolCall.id,
                     content: JSON.stringify({
                         success: false,
-                        error: `Invalid tool arguments: ${errorMsg}. ${hint}`
+                        error: `Invalid tool arguments: ${parseError instanceof Error ? parseError.message : 'JSON parse error'}. Please retry with simpler content.`
                     })
                 };
             }
@@ -288,9 +274,6 @@ async function executeToolCalls(toolCalls) {
             else if (functionName === 'architecture_context') {
                 result = await executeArchitectureContextToolDirect(functionArgs);
             }
-            else if (functionName === 'role_context') {
-                result = await executeRoleContextToolDirect(functionArgs);
-            }
             return {
                 tool_call_id: toolCall.id,
                 content: JSON.stringify({
@@ -313,89 +296,38 @@ async function executeToolCalls(toolCalls) {
     });
     return Promise.all(resultPromises);
 }
-// Proposals tool - full CRUD operations using @lovelybunch/core
-async function executeProposalsToolDirect(args, _storage) {
-    const { operation, id, filters, proposal, updates } = args;
+// Proposals tool is READ-ONLY - only list and get operations are supported
+async function executeProposalsToolDirect(args, storage) {
+    const { operation, id, filters } = args;
     try {
         switch (operation) {
             case 'list': {
-                const proposals = await listProposals(filters || {});
+                const proposals = await storage.listCPs(filters || {});
                 return {
                     success: true,
                     data: proposals,
-                    count: proposals.length,
-                    message: `Found ${proposals.length} tasks`
+                    message: `Found ${proposals.length} proposals`
                 };
             }
             case 'get': {
                 if (!id) {
-                    return { success: false, error: 'Task ID is required for get operation' };
-                }
-                const result = await getProposal(id);
-                if (!result) {
-                    return { success: false, error: 'Task not found' };
+                    return { success: false, error: 'Proposal ID is required for get operation' };
                 }
-                return {
-                    success: true,
-                    data: result,
-                    message: `Retrieved task ${id}`
-                };
-            }
-            case 'create': {
+                const proposal = await storage.getCP(id);
                 if (!proposal) {
-                    return { success: false, error: 'Task data is required for create operation' };
-                }
-                const created = await createProposal(proposal);
-                return {
-                    success: true,
-                    data: created,
-                    message: `Created task ${created.id}`
-                };
-            }
-            case 'update': {
-                if (!id) {
-                    return { success: false, error: 'Task ID is required for update operation' };
+                    return { success: false, error: 'Proposal not found' };
                 }
-                const updateData = updates || proposal;
-                if (!updateData) {
-                    return { success: false, error: 'Update data is required for update operation' };
-                }
-                const updated = await updateProposal(id, updateData);
                 return {
                     success: true,
-                    data: updated,
-                    message: `Updated task ${id}`
-                };
-            }
-            case 'delete': {
-                if (!id) {
-                    return { success: false, error: 'Task ID is required for delete operation' };
-                }
-                const deleted = await deleteProposal(id);
-                if (!deleted) {
-                    return { success: false, error: 'Task not found' };
-                }
-                return {
-                    success: true,
-                    message: `Deleted task ${id}`
+                    data: proposal,
+                    message: `Retrieved proposal ${id}`
                 };
             }
             default:
-                return { success: false, error: `Unknown operation: ${operation}. Supported operations: list, get, create, update, delete` };
+                return { success: false, error: `Proposals are read-only. Only 'list' and 'get' operations are supported. To create proposals, use a coding agent (Claude Code, Cursor, etc.) or the Proposals UI.` };
         }
     }
     catch (error) {
-        // Handle Zod validation errors specially
-        if (error instanceof ZodError) {
-            return {
-                success: false,
-                error: 'Validation failed',
-                details: error.issues.map(e => ({
-                    path: e.path.join('.'),
-                    message: e.message
-                }))
-            };
-        }
         console.error('Error executing proposals tool:', error);
         return { success: false, error: error.message || 'Tool execution failed' };
     }
@@ -864,114 +796,6 @@ async function executeArchitectureContextToolDirect(args) {
         return { success: false, error: error.message || 'Architecture context tool execution failed' };
     }
 }
-// Role context tool - read/write the role definition document
-async function executeRoleContextToolDirect(args) {
-    const { operation, content, old_text, new_text } = args;
-    try {
-        const contextPath = getContextBasePath();
-        const filePath = join(contextPath, 'role.md');
-        switch (operation) {
-            case 'get': {
-                try {
-                    const fileContent = await fs.readFile(filePath, 'utf-8');
-                    const parsed = matter(fileContent);
-                    return {
-                        success: true,
-                        data: {
-                            content: parsed.content,
-                            frontmatter: parsed.data,
-                            raw: fileContent
-                        },
-                        message: 'Retrieved role context'
-                    };
-                }
-                catch (err) {
-                    if (err.code === 'ENOENT') {
-                        return {
-                            success: true,
-                            data: { content: '', frontmatter: {}, raw: '' },
-                            message: 'Role context document does not exist yet. You can create it with an update operation.'
-                        };
-                    }
-                    throw err;
-                }
-            }
-            case 'append': {
-                if (!content) {
-                    return { success: false, error: 'Content is required for append operation' };
-                }
-                await fs.mkdir(contextPath, { recursive: true });
-                // Read existing content if file exists
-                let existingContent = '';
-                try {
-                    existingContent = await fs.readFile(filePath, 'utf-8');
-                }
-                catch (err) {
-                    if (err.code !== 'ENOENT')
-                        throw err;
-                }
-                // Append new content with a newline separator
-                const newContent = existingContent
-                    ? existingContent.trimEnd() + '\n\n' + content
-                    : content;
-                await fs.writeFile(filePath, newContent, 'utf-8');
-                return {
-                    success: true,
-                    message: 'Appended content to role context document'
-                };
-            }
-            case 'replace_section': {
-                if (!old_text || !new_text) {
-                    return { success: false, error: 'Both old_text and new_text are required for replace_section operation' };
-                }
-                // Read existing content
-                let existingContent = '';
-                try {
-                    existingContent = await fs.readFile(filePath, 'utf-8');
-                }
-                catch (err) {
-                    if (err.code === 'ENOENT') {
-                        return { success: false, error: 'Role context document does not exist. Use append or update to create it first.' };
-                    }
-                    throw err;
-                }
-                // Check if old_text exists in the document
-                if (!existingContent.includes(old_text)) {
-                    return {
-                        success: false,
-                        error: 'Could not find the specified text in the document. The text may have been paraphrased or changed.',
-                        fallback_markdown: new_text,
-                        suggestion: 'Here is the replacement text. You can copy it and manually edit the document at /context/role'
-                    };
-                }
-                // Replace the text
-                const updatedContent = existingContent.replace(old_text, new_text);
-                await fs.writeFile(filePath, updatedContent, 'utf-8');
-                return {
-                    success: true,
-                    message: 'Replaced section in role context document'
-                };
-            }
-            case 'update': {
-                if (!content) {
-                    return { success: false, error: 'Content is required for update operation' };
-                }
-                await fs.mkdir(contextPath, { recursive: true });
-                await fs.writeFile(filePath, content, 'utf-8');
-                return {
-                    success: true,
-                    message: 'Updated role context document'
-                };
-            }
-            default:
-                return { success: false, error: `Unknown operation: ${operation}. Use 'get', 'append', 'replace_section', or 'update'.` };
-        }
-    }
-    catch (error) {
-        console.error('Error executing role context tool:', error);
-        return { success: false, error: error.message || 'Role context tool execution failed' };
-    }
-}
 function getContextBasePath() {
     let basePath;
     if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
@@ -1071,44 +895,37 @@ async function listKnowledgeDocuments(basePath, query) {
         doc.metadata?.summary?.toLowerCase().includes(lowerQuery))
         .sort((a, b) => a.filename.localeCompare(b.filename));
 }
-function readSharedPrompt(name) {
-    // Try multiple candidate paths depending on cwd when running via Turbo
-    const moduleDir = fileURLToPath(new URL('.', import.meta.url));
-    const candidates = [
-        // Monorepo root
-        join(process.cwd(), 'packages', 'shared', 'system-prompts', `${name}.md`),
-        // Relative to api package
-        join(moduleDir, '..', '..', '..', '..', 'shared', 'system-prompts', `${name}.md`),
-        join(process.cwd(), '..', 'shared', 'system-prompts', `${name}.md`),
-    ];
-    for (const p of candidates) {
-        try {
-            if (existsSync(p)) {
-                return readFileSync(p, 'utf-8');
-            }
-        }
-        catch { }
-    }
-    return null;
-}
-function readRoleContext() {
-    try {
-        const contextPath = getContextBasePath();
-        const rolePath = join(contextPath, 'role.md');
-        if (existsSync(rolePath)) {
-            return readFileSync(rolePath, 'utf-8');
-        }
-    }
-    catch { }
-    return null;
-}
-function getSystemPrompt() {
-    const basePrompt = readSharedPrompt('coconut-assistant') ||
-        `You are the Coconut 🥥 AI assistant for agent-native development workflows. You help developers with proposals, architecture decisions, planning, and execution.`;
-    // Add role context if it exists
-    const roleContent = readRoleContext();
-    if (roleContent) {
-        return `${basePrompt}\n\n## Your Role for This Instance\n\n${roleContent}`;
+function getSystemPrompt(context, contextContent) {
+    const basePrompt = `You are the Coconut 🥥 AI assistant for agent-native development workflows. You help developers with proposals, architecture decisions, planning, and execution.`;
+    switch (context) {
+        case "proposals":
+        case "proposals-edit":
+        case "proposals-view":
+            let proposalPrompt = `${basePrompt} You are currently in the proposals section. Help users:
+- Refine and improve their change proposals
+- Suggest implementation approaches
+- Identify potential challenges or risks
+- Break down complex changes into manageable steps
+- Provide feedback on proposal clarity and completeness`;
+            if (contextContent) {
+                proposalPrompt += `\n\nYou have access to the following proposal data:\n\n${contextContent}`;
+            }
+            return proposalPrompt;
+        case "context":
+            return `${basePrompt} You are currently in the context section (architecture, decisions, knowledge). Help users:
+- Analyze architectural decisions and patterns
+- Suggest improvements to documentation
+- Identify gaps in knowledge or decisions
+- Recommend best practices
+- Help maintain consistency across the project`;
+        case "settings":
+            return `${basePrompt} You are currently in the settings section. Help users:
+- Configure their Coconut environment
+- Set up integrations and workflows
+- Optimize their development process
+- Understand configuration options
+- Troubleshoot setup issues`;
+        default:
+            return `${basePrompt} Provide helpful, contextual assistance based on the user's current needs in their Coconut workflow.`;
     }
-    return basePrompt;
 }

package/dist/routes/api/v1/proposals/[id]/route.d.ts

@@ -9,11 +9,10 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
     success: true;
     data: {
         id: string;
-        title: string;
-        intent?: string;
+        intent: string;
         content?: string;
         author: {
-            type: import("@lovelybunch/core").AuthorType;
+            type: import("@lovelybunch/types").AuthorType;
             id: string;
             name: string;
             email?: string;
@@ -48,7 +47,7 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
             version: string;
             name: string;
             description: string;
-            type: import("@lovelybunch/core").FeatureFlagType;
+            type: import("@lovelybunch/types").FeatureFlagType;
             defaultValue: any;
             scopes: string[];
             targets: {
@@ -96,7 +95,7 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
                 minimumSampleSize: number;
                 testType: "two-tailed" | "one-tailed";
             };
-            status: import("@lovelybunch/core").ExperimentStatus;
+            status: import("@lovelybunch/types").ExperimentStatus;
             startedAt?: string;
             endedAt?: string;
         }[];
@@ -134,13 +133,7 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
             schedule?: string;
             rollbackPlan?: string;
         };
-        status: import("@lovelybunch/core").CPStatus;
-        comments?: {
-            id: string;
-            author: string;
-            content: string;
-            createdAt: string;
-        }[];
+        status: import("@lovelybunch/types").CPStatus;
         metadata: {
             createdAt: string;
             updatedAt: string;
@@ -173,11 +166,10 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
     success: true;
     data: {
         id: string;
-        title: string;
-        intent?: string;
+        intent: string;
         content?: string;
         author: {
-            type: import("@lovelybunch/core").AuthorType;
+            type: import("@lovelybunch/types").AuthorType;
             id: string;
             name: string;
             email?: string;
@@ -212,7 +204,7 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
             version: string;
             name: string;
             description: string;
-            type: import("@lovelybunch/core").FeatureFlagType;
+            type: import("@lovelybunch/types").FeatureFlagType;
             defaultValue: any;
             scopes: string[];
             targets: {
@@ -260,7 +252,7 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
                 minimumSampleSize: number;
                 testType: "two-tailed" | "one-tailed";
             };
-            status: import("@lovelybunch/core").ExperimentStatus;
+            status: import("@lovelybunch/types").ExperimentStatus;
             startedAt?: string;
             endedAt?: string;
         }[];
@@ -298,13 +290,7 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
             schedule?: string;
             rollbackPlan?: string;
         };
-        status: import("@lovelybunch/core").CPStatus;
-        comments?: {
-            id: string;
-            author: string;
-            content: string;
-            createdAt: string;
-        }[];
+        status: import("@lovelybunch/types").CPStatus;
         metadata: {
             createdAt: string;
             updatedAt: string;

package/dist/routes/api/v1/proposals/[id]/route.js

@@ -1,5 +1,6 @@
 import { FileStorageAdapter } from '../../../../../lib/storage/file-storage.js';
 import { getLogger } from '@lovelybunch/core/logging';
+import { getSlackService } from '../../../../../lib/slack/slack-service.js';
 const storage = new FileStorageAdapter();
 // Logger is lazily initialized inside handlers to use server config
 export async function GET(c) {
@@ -90,6 +91,14 @@ export async function PATCH(c) {
                     reason: null
                 }
             });
+            // Send Slack notification for status change (non-blocking)
+            getSlackService().sendNotification({
+                type: 'proposal.statusChange',
+                proposalId: id,
+                intent: updatedProposal?.intent || existing.intent,
+                status: newStatus,
+                previousStatus: oldStatus,
+            }).catch(err => console.warn('[proposals] Slack notification failed:', err));
         }
         return c.json({
             success: true,
@@ -134,7 +143,7 @@ export async function DELETE(c) {
                 tags: ['proposal'],
                 payload: {
                     id,
-                    title: proposal.title
+                    intent: proposal.intent
                 }
             });
         }