@lovelybunch/api 1.0.35 → 1.0.38

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

@@ -1,7 +1,11 @@
 import { Hono } from 'hono';
 import { promises as fs } from 'fs';
 import path from 'path';
+import { proposalsTool, listProposalsTool, validateProposalData } from '@lovelybunch/mcp';
+import { FileStorageAdapter } from '../../../../lib/storage/file-storage.js';
+import { getAuthorInfo } from '../../../../lib/user-preferences.js';
 const app = new Hono();
+const storage = new FileStorageAdapter();
 function resolveGaitPath() {
     let basePath;
     if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
@@ -17,25 +21,317 @@ function resolveGaitPath() {
 }
 /**
  * GET /api/v1/mcp
- * Returns the list of MCP server names defined in .gait/mcp/config.json
+ * Returns the list of MCP server names and available tools
  */
 app.get('/', async (c) => {
     try {
         const gaitPath = resolveGaitPath();
         const mcpConfigPath = path.join(gaitPath, 'mcp', 'config.json');
-        const raw = await fs.readFile(mcpConfigPath, 'utf-8');
-        const json = JSON.parse(raw);
-        const map = json.mcpServers || {};
-        const names = Object.keys(map);
-        return c.json({ success: true, servers: names, mcpServers: map });
+        let externalServers = {};
+        try {
+            const raw = await fs.readFile(mcpConfigPath, 'utf-8');
+            const json = JSON.parse(raw);
+            externalServers = json.mcpServers || {};
+        }
+        catch (err) {
+            // If file missing, continue with empty external servers
+            if (err.code !== 'ENOENT') {
+                console.error('Error reading MCP config:', err);
+            }
+        }
+        const names = Object.keys(externalServers);
+        // Add built-in tools
+        const builtInTools = {
+            proposals: proposalsTool,
+            listProposals: listProposalsTool
+        };
+        return c.json({
+            success: true,
+            servers: names,
+            mcpServers: externalServers,
+            tools: builtInTools
+        });
     }
     catch (err) {
-        // If file missing, respond with empty list rather than 500
-        if (err && err.code === 'ENOENT') {
-            return c.json({ success: true, servers: [] });
+        console.error('Error loading MCP servers:', err);
+        return c.json({ success: false, error: 'Failed to load MCP servers', servers: [], tools: {} }, 500);
+    }
+});
+/**
+ * POST /api/v1/mcp/execute
+ * Execute a tool call
+ */
+app.post('/execute', async (c) => {
+    try {
+        const { tool, arguments: args } = await c.req.json();
+        if (!tool || !args) {
+            return c.json({ success: false, error: 'Tool and arguments are required' }, 400);
+        }
+        if (tool === 'change_proposals') {
+            return await executeProposalsTool(c, args);
+        }
+        if (tool === 'list_proposals') {
+            return await executeListProposalsTool(c, args);
+        }
+        return c.json({ success: false, error: 'Unknown tool' }, 400);
+    }
+    catch (error) {
+        console.error('Error executing tool:', error);
+        return c.json({ success: false, error: 'Tool execution failed' }, 500);
+    }
+});
+async function executeProposalsTool(c, args) {
+    const { operation, id, filters, proposal } = args;
+    try {
+        switch (operation) {
+            case 'list': {
+                const proposals = await storage.listCPs(filters || {});
+                return c.json({
+                    success: true,
+                    data: proposals,
+                    message: `Found ${proposals.length} proposals`
+                });
+            }
+            case 'get': {
+                if (!id) {
+                    return c.json({ success: false, error: 'Proposal ID is required for get operation' }, 400);
+                }
+                const proposal = await storage.getCP(id);
+                if (!proposal) {
+                    return c.json({ success: false, error: 'Proposal not found' }, 404);
+                }
+                return c.json({
+                    success: true,
+                    data: proposal,
+                    message: `Retrieved proposal ${id}`
+                });
+            }
+            case 'create': {
+                if (!proposal) {
+                    return c.json({ success: false, error: 'Proposal data is required for create operation' }, 400);
+                }
+                const validatedProposal = validateProposalData(proposal);
+                const now = new Date();
+                const authorInfo = await getAuthorInfo();
+                // Ensure planSteps are properly structured
+                const planSteps = (validatedProposal.planSteps || []).map((step, index) => {
+                    if (typeof step === 'string') {
+                        return {
+                            id: `step-${index + 1}`,
+                            description: step,
+                            status: 'pending'
+                        };
+                    }
+                    return {
+                        id: step.id || `step-${index + 1}`,
+                        description: step.description || '',
+                        status: step.status || 'pending',
+                        command: step.command,
+                        expectedOutcome: step.expectedOutcome,
+                        output: step.output,
+                        error: step.error,
+                        executedAt: step.executedAt
+                    };
+                });
+                const newProposal = {
+                    id: `cp-${Date.now()}`,
+                    intent: validatedProposal.intent || '',
+                    content: validatedProposal.content || '',
+                    author: {
+                        id: validatedProposal.author?.id || 'current-user',
+                        name: validatedProposal.author?.name || authorInfo.name || 'Unknown User',
+                        email: validatedProposal.author?.email || authorInfo.email || '',
+                        type: validatedProposal.author?.type || 'human'
+                    },
+                    planSteps,
+                    evidence: validatedProposal.evidence || [],
+                    policies: validatedProposal.policies || [],
+                    featureFlags: validatedProposal.featureFlags || [],
+                    experiments: validatedProposal.experiments || [],
+                    telemetryContracts: validatedProposal.telemetryContracts || [],
+                    releasePlan: validatedProposal.releasePlan || { strategy: 'immediate' },
+                    status: validatedProposal.status || 'draft',
+                    metadata: {
+                        createdAt: now,
+                        updatedAt: now,
+                        reviewers: validatedProposal.metadata?.reviewers || [],
+                        aiInteractions: validatedProposal.metadata?.aiInteractions || [],
+                        tags: validatedProposal.metadata?.tags || [],
+                        priority: validatedProposal.metadata?.priority || 'medium'
+                    },
+                    productSpecRef: validatedProposal.productSpecRef
+                };
+                // Debug logging to identify undefined values
+                console.log('Proposal data before storage:', JSON.stringify(newProposal, null, 2));
+                await storage.createCP(newProposal);
+                return c.json({
+                    success: true,
+                    data: newProposal,
+                    message: `Created proposal ${newProposal.id}`
+                });
+            }
+            case 'update': {
+                if (!id) {
+                    return c.json({ success: false, error: 'Proposal ID is required for update operation' }, 400);
+                }
+                if (!proposal) {
+                    return c.json({ success: false, error: 'Proposal data is required for update operation' }, 400);
+                }
+                const existing = await storage.getCP(id);
+                if (!existing) {
+                    return c.json({ success: false, error: 'Proposal not found' }, 404);
+                }
+                const validatedUpdates = validateProposalData(proposal);
+                // Ensure planSteps are properly structured if they're being updated
+                let planSteps = existing.planSteps;
+                if (validatedUpdates.planSteps) {
+                    planSteps = validatedUpdates.planSteps.map((step, index) => {
+                        if (typeof step === 'string') {
+                            return {
+                                id: `step-${index + 1}`,
+                                description: step,
+                                status: 'pending'
+                            };
+                        }
+                        return {
+                            id: step.id || `step-${index + 1}`,
+                            description: step.description || '',
+                            status: step.status || 'pending',
+                            command: step.command,
+                            expectedOutcome: step.expectedOutcome,
+                            output: step.output,
+                            error: step.error,
+                            executedAt: step.executedAt
+                        };
+                    });
+                }
+                const updatedProposal = {
+                    ...existing,
+                    ...validatedUpdates,
+                    planSteps,
+                    metadata: {
+                        ...existing.metadata,
+                        ...validatedUpdates.metadata,
+                        updatedAt: new Date()
+                    }
+                };
+                await storage.updateCP(id, updatedProposal);
+                return c.json({
+                    success: true,
+                    data: updatedProposal,
+                    message: `Updated proposal ${id}`
+                });
+            }
+            case 'delete': {
+                if (!id) {
+                    return c.json({ success: false, error: 'Proposal ID is required for delete operation' }, 400);
+                }
+                const existing = await storage.getCP(id);
+                if (!existing) {
+                    return c.json({ success: false, error: 'Proposal not found' }, 404);
+                }
+                await storage.deleteCP(id);
+                return c.json({
+                    success: true,
+                    message: `Deleted proposal ${id}`
+                });
+            }
+            default:
+                return c.json({ success: false, error: 'Invalid operation' }, 400);
+        }
+    }
+    catch (error) {
+        console.error('Error executing proposals tool:', error);
+        return c.json({ success: false, error: error.message || 'Tool execution failed' }, 500);
+    }
+}
+async function executeListProposalsTool(c, args) {
+    const { filters } = args;
+    try {
+        const proposals = await storage.listCPs(filters || {});
+        // Return only metadata, not full content
+        const metadataOnly = proposals.map(proposal => ({
+            id: proposal.id,
+            intent: proposal.intent,
+            status: proposal.status,
+            priority: proposal.metadata?.priority || 'medium',
+            tags: proposal.metadata?.tags || [],
+            author: {
+                name: proposal.author.name,
+                email: proposal.author.email
+            },
+            createdAt: proposal.metadata.createdAt,
+            updatedAt: proposal.metadata.updatedAt,
+            reviewers: proposal.metadata.reviewers || [],
+            productSpecRef: proposal.productSpecRef
+        }));
+        return c.json({
+            success: true,
+            data: metadataOnly,
+            message: `Found ${metadataOnly.length} proposals`
+        });
+    }
+    catch (error) {
+        console.error('Error executing list proposals tool:', error);
+        return c.json({ success: false, error: error.message || 'Failed to list proposals' }, 500);
+    }
+}
+/**
+ * GET /api/v1/mcp/raw-config
+ * Returns the raw MCP configuration for editing in settings UI
+ */
+app.get('/raw-config', async (c) => {
+    try {
+        const gaitPath = resolveGaitPath();
+        const mcpConfigPath = path.join(gaitPath, 'mcp', 'config.json');
+        try {
+            const configData = await fs.readFile(mcpConfigPath, 'utf-8');
+            const config = JSON.parse(configData);
+            return c.json(config);
+        }
+        catch (error) {
+            // If file doesn't exist or is invalid, return empty config
+            if (error.code === 'ENOENT') {
+                return c.json({});
+            }
+            console.error('Error reading MCP config for settings:', error);
+            return c.json({});
+        }
+    }
+    catch (error) {
+        console.error('Error reading MCP raw config:', error);
+        return c.json({ error: 'Failed to read MCP configuration' }, 500);
+    }
+});
+/**
+ * PUT /api/v1/mcp/raw-config
+ * Updates the raw MCP configuration from settings UI
+ */
+app.put('/raw-config', async (c) => {
+    try {
+        const body = await c.req.json();
+        const gaitPath = resolveGaitPath();
+        const mcpConfigPath = path.join(gaitPath, 'mcp', 'config.json');
+        // Ensure directory exists
+        const mcpDir = path.dirname(mcpConfigPath);
+        try {
+            await fs.access(mcpDir);
+        }
+        catch {
+            await fs.mkdir(mcpDir, { recursive: true });
         }
-        console.error('Error reading MCP config:', err);
-        return c.json({ success: false, error: 'Failed to load MCP servers', servers: [] }, 500);
+        // Validate the configuration structure
+        if (typeof body !== 'object') {
+            return c.json({ error: 'Invalid configuration format' }, 400);
+        }
+        // Write the configuration to file
+        const configData = JSON.stringify(body, null, 2);
+        await fs.writeFile(mcpConfigPath, configData, 'utf-8');
+        return c.json({ message: 'MCP configuration updated successfully' });
+    }
+    catch (error) {
+        console.error('Error updating MCP raw config:', error);
+        return c.json({ error: 'Failed to update MCP configuration' }, 500);
     }
 });
 export default app;

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

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default app;

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

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import config from '../config/index.js';
+const app = new Hono();
+app.route('/config', config);
+export default app;

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

@@ -16,6 +16,7 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
             id: string;
             name: string;
             email?: string;
+            role?: string;
         };
         productSpecRef?: string;
         planSteps: {
@@ -173,6 +174,7 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
             id: string;
             name: string;
             email?: string;
+            role?: string;
         };
         productSpecRef?: string;
         planSteps: {

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

@@ -10,6 +10,7 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
             id: string;
             name: string;
             email?: string;
+            role?: string;
         };
         productSpecRef?: string;
         planSteps: {
@@ -167,6 +168,7 @@ export declare function POST(c: Context): Promise<(Response & import("hono").Typ
             id: string;
             name: string;
             email?: string;
+            role?: string;
         };
         productSpecRef?: string;
         planSteps: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovelybunch/api",
-  "version": "1.0.35",
+  "version": "1.0.38",
   "type": "module",
   "main": "dist/server-with-static.js",
   "exports": {
@@ -32,8 +32,9 @@
   "dependencies": {
     "@hono/node-server": "^1.13.7",
     "@hono/node-ws": "^1.0.6",
-    "@lovelybunch/core": "^1.0.35",
-    "@lovelybunch/types": "^1.0.35",
+    "@lovelybunch/core": "^1.0.38",
+    "@lovelybunch/mcp": "^1.0.35",
+    "@lovelybunch/types": "^1.0.38",
     "dotenv": "^17.2.1",
     "fuse.js": "^7.0.0",
     "gray-matter": "^4.0.3",