@lovelybunch/api 1.0.75-alpha.8 → 1.0.75

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

@@ -2,8 +2,8 @@ import { Hono } from 'hono';
 import { promises as fs } from 'fs';
 import path from 'path';
 import { ZodError } from 'zod';
-import { listProposals, getProposal, createProposal, updateProposal, deleteProposal, getContext, updateContext, appendContext, replaceContextSection, listKnowledge, getKnowledge, createKnowledge, updateKnowledge, listEvents, } from '@lovelybunch/core';
-import { proposalsFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool, roleContextTool } from '@lovelybunch/mcp';
+import { listTasks, getTask, createTask, updateTask, deleteTask, getContext, updateContext, appendContext, replaceContextSection, listKnowledge, getKnowledge, createKnowledge, updateKnowledge, listEvents, } from '@lovelybunch/core';
+import { tasksFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool, roleContextTool, resourcesTool } from '@lovelybunch/mcp';
 import { FileStorageAdapter } from '../../../../lib/storage/file-storage.js';
 const app = new Hono();
 const storage = new FileStorageAdapter();
@@ -78,14 +78,15 @@ app.get('/', async (c) => {
         }
         const names = Object.keys(externalServers);
         // Add built-in tools (include full JSON schema for parameters)
-        // Note: proposals now supports full CRUD, knowledge/project/architecture are read+write, events is read-only
+        // Note: tasks now supports full CRUD, knowledge/project/architecture are read+write, events is read-only
         const builtInTools = {
-            change_proposals: proposalsFullTool,
+            tasks: tasksFullTool,
             knowledge_documents: knowledgeTool,
             activity_events: eventsTool,
             project_context: projectContextTool,
             architecture_context: architectureContextTool,
-            role_context: roleContextTool
+            role_context: roleContextTool,
+            resources: resourcesTool
         };
         return c.json({
             success: true,
@@ -105,15 +106,16 @@ app.get('/', async (c) => {
  */
 app.get('/schema', async (c) => {
     try {
-        // Note: proposals now supports full CRUD, knowledge/project/architecture are read+write, events is read-only
+        // Note: tasks now supports full CRUD, knowledge/project/architecture are read+write, events is read-only
         const schema = {
             tools: {
-                change_proposals: proposalsFullTool,
+                tasks: tasksFullTool,
                 knowledge_documents: knowledgeTool,
                 activity_events: eventsTool,
                 project_context: projectContextTool,
                 architecture_context: architectureContextTool,
-                role_context: roleContextTool
+                role_context: roleContextTool,
+                resources: resourcesTool
             }
         };
         return c.json(schema);
@@ -133,8 +135,8 @@ app.post('/execute', async (c) => {
         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 === 'tasks') {
+            return await executeTasksTool(c, args);
         }
         if (tool === 'knowledge_documents') {
             return await executeKnowledgeTool(c, args);
@@ -151,6 +153,9 @@ app.post('/execute', async (c) => {
         if (tool === 'role_context') {
             return await executeRoleContextTool(c, args);
         }
+        if (tool === 'resources') {
+            return await executeResourcesTool(c, args);
+        }
         return c.json({ success: false, error: 'Unknown tool' }, 400);
     }
     catch (error) {
@@ -158,71 +163,71 @@ app.post('/execute', async (c) => {
         return c.json({ success: false, error: 'Tool execution failed' }, 500);
     }
 });
-// Proposals tool - full CRUD operations using @lovelybunch/core
-async function executeProposalsTool(c, args) {
-    const { operation, id, filters, proposal, updates } = args;
+// Tasks tool - full CRUD operations using @lovelybunch/core
+async function executeTasksTool(c, args) {
+    const { operation, id, filters, task, updates } = args;
     try {
         switch (operation) {
             case 'list': {
-                const proposals = await listProposals(filters || {});
+                const tasks = await listTasks(filters || {});
                 return c.json({
                     success: true,
-                    data: proposals,
-                    count: proposals.length,
-                    message: `Found ${proposals.length} proposals`
+                    data: tasks,
+                    count: tasks.length,
+                    message: `Found ${tasks.length} tasks`
                 });
             }
             case 'get': {
                 if (!id) {
-                    return c.json({ success: false, error: 'Proposal ID is required for get operation' }, 400);
+                    return c.json({ success: false, error: 'Task ID is required for get operation' }, 400);
                 }
-                const result = await getProposal(id);
+                const result = await getTask(id);
                 if (!result) {
-                    return c.json({ success: false, error: 'Proposal not found' }, 404);
+                    return c.json({ success: false, error: 'Task not found' }, 404);
                 }
                 return c.json({
                     success: true,
                     data: result,
-                    message: `Retrieved proposal ${id}`
+                    message: `Retrieved task ${id}`
                 });
             }
             case 'create': {
-                if (!proposal) {
-                    return c.json({ success: false, error: 'Proposal data is required for create operation' }, 400);
+                if (!task) {
+                    return c.json({ success: false, error: 'Task data is required for create operation' }, 400);
                 }
-                const created = await createProposal(proposal);
+                const created = await createTask(task);
                 return c.json({
                     success: true,
                     data: created,
-                    message: `Created proposal ${created.id}`
+                    message: `Created task ${created.id}`
                 }, 201);
             }
             case 'update': {
                 if (!id) {
-                    return c.json({ success: false, error: 'Proposal ID is required for update operation' }, 400);
+                    return c.json({ success: false, error: 'Task ID is required for update operation' }, 400);
                 }
-                const updateData = updates || proposal;
+                const updateData = updates || task;
                 if (!updateData) {
                     return c.json({ success: false, error: 'Update data is required for update operation' }, 400);
                 }
-                const updated = await updateProposal(id, updateData);
+                const updated = await updateTask(id, updateData);
                 return c.json({
                     success: true,
                     data: updated,
-                    message: `Updated proposal ${id}`
+                    message: `Updated task ${id}`
                 });
             }
             case 'delete': {
                 if (!id) {
-                    return c.json({ success: false, error: 'Proposal ID is required for delete operation' }, 400);
+                    return c.json({ success: false, error: 'Task ID is required for delete operation' }, 400);
                 }
-                const deleted = await deleteProposal(id);
+                const deleted = await deleteTask(id);
                 if (!deleted) {
-                    return c.json({ success: false, error: 'Proposal not found' }, 404);
+                    return c.json({ success: false, error: 'Task not found' }, 404);
                 }
                 return c.json({
                     success: true,
-                    message: `Deleted proposal ${id}`
+                    message: `Deleted task ${id}`
                 });
             }
             default:
@@ -244,7 +249,7 @@ async function executeProposalsTool(c, args) {
                 }))
             }, 400);
         }
-        console.error('Error executing proposals tool:', error);
+        console.error('Error executing tasks tool:', error);
         return c.json({ success: false, error: error.message || 'Tool execution failed' }, 500);
     }
 }
@@ -449,6 +454,76 @@ async function executeArchitectureContextTool(c, args) {
 async function executeRoleContextTool(c, args) {
     return executeContextTool(c, 'role', args);
 }
+// Resources tool executor — proxies to the resource API endpoints on the same server
+async function executeResourcesTool(c, args) {
+    const { operation, query, type_filter, resource_id, prompt, model, aspect_ratio, text, voice, duration, resolution, url, tags, description } = args;
+    const port = process.env.PORT ? parseInt(process.env.PORT) : 3001;
+    const apiBase = `http://127.0.0.1:${port}`;
+    try {
+        switch (operation) {
+            case 'list': {
+                const response = await fetch(`${apiBase}/api/v1/resources`);
+                const result = await response.json();
+                if (!result.success || !result.data) {
+                    return c.json({ success: false, error: 'Failed to list resources' }, 500);
+                }
+                let resources = result.data;
+                if (type_filter) {
+                    const prefix = type_filter.toLowerCase();
+                    resources = resources.filter((r) => r.type?.toLowerCase().startsWith(prefix));
+                }
+                if (query) {
+                    const q = query.toLowerCase();
+                    resources = resources.filter((r) => r.name?.toLowerCase().includes(q) ||
+                        r.metadata?.description?.toLowerCase().includes(q) ||
+                        r.metadata?.tags?.some((tag) => tag.toLowerCase().includes(q)));
+                }
+                return c.json({
+                    success: true,
+                    data: resources.map((r) => ({
+                        id: r.id, name: r.name, type: r.type, size: r.size,
+                        tags: r.metadata?.tags, description: r.metadata?.description
+                    })),
+                    count: resources.length,
+                    message: query ? `Found ${resources.length} resources matching "${query}"` : `Found ${resources.length} resources`
+                });
+            }
+            case 'get': {
+                if (!resource_id) {
+                    return c.json({ success: false, error: 'resource_id is required for get operation' }, 400);
+                }
+                const response = await fetch(`${apiBase}/api/v1/resources`);
+                const result = await response.json();
+                if (!result.success || !result.data) {
+                    return c.json({ success: false, error: 'Failed to fetch resources' }, 500);
+                }
+                const resource = result.data.find((r) => r.id === resource_id);
+                if (!resource) {
+                    return c.json({ success: false, error: `Resource '${resource_id}' not found` }, 404);
+                }
+                return c.json({ success: true, data: resource, message: `Retrieved resource ${resource.name}` });
+            }
+            // For write operations, return a not-implemented message since these require
+            // long-running Replicate calls that are better handled via the AI route's
+            // tool execution (which runs within streamText's tool loop).
+            case 'generate_image':
+            case 'generate_audio':
+            case 'generate_video':
+            case 'add_from_url': {
+                return c.json({
+                    success: false,
+                    error: `The '${operation}' operation is only available through the AI assistant chat. Use the assistant sidebar to generate or add resources.`
+                }, 400);
+            }
+            default:
+                return c.json({ success: false, error: `Unknown operation: ${operation}` }, 400);
+        }
+    }
+    catch (error) {
+        console.error('Error executing resources tool:', error);
+        return c.json({ success: false, error: error.message || 'Resources tool execution failed' }, 500);
+    }
+}
 /**
  * GET /api/v1/mcp/raw-config
  * Returns the raw MCP configuration for editing in settings UI

package/dist/routes/api/v1/slack/index.d.ts

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

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

@@ -0,0 +1,15 @@
+import { Hono } from 'hono';
+import { getConfig, updateConfig, testConnection, listChannels, sendTestNotification, sendExampleNotification } from './route.js';
+const slackRoutes = new Hono();
+// Configuration endpoints
+slackRoutes.get('/config', getConfig);
+slackRoutes.put('/config', updateConfig);
+// Connection testing
+slackRoutes.post('/test', testConnection);
+// Channel listing
+slackRoutes.get('/channels', listChannels);
+// Test notification
+slackRoutes.post('/notify', sendTestNotification);
+// Example notification for specific type
+slackRoutes.post('/notify/example', sendExampleNotification);
+export { slackRoutes };

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

@@ -0,0 +1,124 @@
+import { Context } from 'hono';
+/**
+ * GET /api/v1/slack/config
+ * Returns the current Slack configuration (tokens masked)
+ */
+export declare function getConfig(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        enabled: boolean;
+        channelId: string;
+        channelName: string;
+        siteUrl: string;
+        notifications: {
+            proposals: {
+                created: boolean;
+                statusChange: boolean;
+            };
+            jobs: {
+                completed: boolean;
+                failed: boolean;
+            };
+            git: {
+                push: boolean;
+                merge: boolean;
+            };
+        };
+        hasBotToken: boolean;
+        hasSigningSecret: boolean;
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: any;
+}, 500, "json">)>;
+/**
+ * PUT /api/v1/slack/config
+ * Updates Slack configuration
+ */
+export declare function updateConfig(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        enabled: boolean;
+        channelId: string;
+        channelName: string;
+        siteUrl: string;
+        notifications: {
+            proposals: {
+                created: boolean;
+                statusChange: boolean;
+            };
+            jobs: {
+                completed: boolean;
+                failed: boolean;
+            };
+            git: {
+                push: boolean;
+                merge: boolean;
+            };
+        };
+        hasBotToken: boolean;
+        hasSigningSecret: boolean;
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: any;
+}, 500, "json">)>;
+/**
+ * POST /api/v1/slack/test
+ * Tests the Slack connection using the configured bot token
+ */
+export declare function testConnection(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+    message: string;
+    teamName: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: any;
+}, 500, "json">)>;
+/**
+ * GET /api/v1/slack/channels
+ * Lists available Slack channels the bot can post to
+ */
+export declare function listChannels(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        id: string;
+        name: string;
+        isPrivate: boolean;
+        isMember: boolean;
+    }[];
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: any;
+}, 500, "json">)>;
+/**
+ * POST /api/v1/slack/notify
+ * Sends a test notification to the configured channel
+ */
+export declare function sendTestNotification(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+    message: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: any;
+}, 500, "json">)>;
+/**
+ * POST /api/v1/slack/notify/example
+ * Sends an example notification for a specific notification type
+ */
+export declare function sendExampleNotification(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    message: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: any;
+}, 500, "json">)>;

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

@@ -0,0 +1,192 @@
+import { getSlackService } from '../../../../lib/slack/slack-service.js';
+const VALID_NOTIFICATION_TYPES = [
+    'proposal.created',
+    'proposal.statusChange',
+    'job.completed',
+    'job.failed',
+    'git.push',
+    'git.merge',
+];
+/**
+ * GET /api/v1/slack/config
+ * Returns the current Slack configuration (tokens masked)
+ */
+export async function getConfig(c) {
+    try {
+        const slackService = getSlackService();
+        const config = await slackService.getConfigForDisplay();
+        return c.json({
+            success: true,
+            data: config,
+        });
+    }
+    catch (error) {
+        console.error('[slack/config] GET error:', error);
+        return c.json({
+            success: false,
+            error: error.message || 'Failed to load Slack configuration',
+        }, 500);
+    }
+}
+/**
+ * PUT /api/v1/slack/config
+ * Updates Slack configuration
+ */
+export async function updateConfig(c) {
+    try {
+        const body = await c.req.json();
+        const slackService = getSlackService();
+        // Build the update object, only including fields that were provided
+        const updates = {};
+        if (typeof body.enabled === 'boolean') {
+            updates.enabled = body.enabled;
+        }
+        if (typeof body.botToken === 'string') {
+            updates.botToken = body.botToken;
+        }
+        if (typeof body.signingSecret === 'string') {
+            updates.signingSecret = body.signingSecret;
+        }
+        if (typeof body.channelId === 'string') {
+            updates.channelId = body.channelId;
+        }
+        if (typeof body.channelName === 'string') {
+            updates.channelName = body.channelName;
+        }
+        if (typeof body.siteUrl === 'string') {
+            updates.siteUrl = body.siteUrl;
+        }
+        if (body.notifications && typeof body.notifications === 'object') {
+            updates.notifications = body.notifications;
+        }
+        const updated = await slackService.saveConfig(updates);
+        // Return the display version (tokens masked)
+        const displayConfig = await slackService.getConfigForDisplay();
+        return c.json({
+            success: true,
+            data: displayConfig,
+        });
+    }
+    catch (error) {
+        console.error('[slack/config] PUT error:', error);
+        return c.json({
+            success: false,
+            error: error.message || 'Failed to update Slack configuration',
+        }, 500);
+    }
+}
+/**
+ * POST /api/v1/slack/test
+ * Tests the Slack connection using the configured bot token
+ */
+export async function testConnection(c) {
+    try {
+        const slackService = getSlackService();
+        const result = await slackService.testConnection();
+        if (result.success) {
+            return c.json({
+                success: true,
+                message: `Connected to workspace: ${result.teamName}`,
+                teamName: result.teamName,
+            });
+        }
+        else {
+            return c.json({
+                success: false,
+                error: result.error || 'Connection test failed',
+            }, 400);
+        }
+    }
+    catch (error) {
+        console.error('[slack/test] POST error:', error);
+        return c.json({
+            success: false,
+            error: error.message || 'Failed to test Slack connection',
+        }, 500);
+    }
+}
+/**
+ * GET /api/v1/slack/channels
+ * Lists available Slack channels the bot can post to
+ */
+export async function listChannels(c) {
+    try {
+        const slackService = getSlackService();
+        const channels = await slackService.listChannels();
+        return c.json({
+            success: true,
+            data: channels,
+        });
+    }
+    catch (error) {
+        console.error('[slack/channels] GET error:', error);
+        return c.json({
+            success: false,
+            error: error.message || 'Failed to list Slack channels',
+        }, 500);
+    }
+}
+/**
+ * POST /api/v1/slack/notify
+ * Sends a test notification to the configured channel
+ */
+export async function sendTestNotification(c) {
+    try {
+        const slackService = getSlackService();
+        // Send a test notification
+        const success = await slackService.sendNotification({
+            type: 'proposal.created',
+            proposalId: 'test-notification',
+            intent: 'Test notification from Coconut',
+            author: 'System',
+        });
+        if (success) {
+            return c.json({
+                success: true,
+                message: 'Test notification sent successfully',
+            });
+        }
+        else {
+            return c.json({
+                success: false,
+                error: 'Failed to send notification. Check that Slack is enabled and a channel is selected.',
+            }, 400);
+        }
+    }
+    catch (error) {
+        console.error('[slack/notify] POST error:', error);
+        return c.json({
+            success: false,
+            error: error.message || 'Failed to send test notification',
+        }, 500);
+    }
+}
+/**
+ * POST /api/v1/slack/notify/example
+ * Sends an example notification for a specific notification type
+ */
+export async function sendExampleNotification(c) {
+    try {
+        const body = await c.req.json().catch(() => ({}));
+        const notificationType = body.type;
+        if (!notificationType || !VALID_NOTIFICATION_TYPES.includes(notificationType)) {
+            return c.json({
+                success: false,
+                error: `Invalid notification type. Must be one of: ${VALID_NOTIFICATION_TYPES.join(', ')}`,
+            }, 400);
+        }
+        const slackService = getSlackService();
+        await slackService.sendExampleNotification(notificationType);
+        return c.json({
+            success: true,
+            message: `Example ${notificationType} notification sent`,
+        });
+    }
+    catch (error) {
+        console.error('[slack/notify/example] POST error:', error);
+        return c.json({
+            success: false,
+            error: error.message || 'Failed to send example notification',
+        }, 500);
+    }
+}