@lovelybunch/api 1.0.75-alpha.9 → 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, resourcesTool } 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,9 +78,9 @@ 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,
@@ -106,10 +106,10 @@ 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,
@@ -135,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);
@@ -163,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:
@@ -249,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);
     }
 }

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);
+    }
+}

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

@@ -0,0 +1,117 @@
+import { Context } from 'hono';
+export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: string;
+    };
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        id: string;
+        title: string;
+        intent?: string;
+        content?: string;
+        author: {
+            type: import("@lovelybunch/core").AuthorType;
+            id: string;
+            name: string;
+            email?: string;
+        };
+        productSpecRef?: string;
+        planSteps: {
+            id: string;
+            description: string;
+            command?: string;
+            expectedOutcome?: string;
+            status: "pending" | "in-progress" | "completed" | "failed";
+            output?: string;
+            error?: string;
+            executedAt?: string;
+        }[];
+        status: import("@lovelybunch/core").TaskStatus;
+        comments?: {
+            id: string;
+            author: string;
+            content: string;
+            createdAt: string;
+        }[];
+        metadata: {
+            createdAt: string;
+            updatedAt: string;
+            reviewers: string[];
+            tags?: string[];
+            priority?: "low" | "medium" | "high" | "critical";
+            readiness?: number;
+        };
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;
+export declare function PATCH(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        id: string;
+        title: string;
+        intent?: string;
+        content?: string;
+        author: {
+            type: import("@lovelybunch/core").AuthorType;
+            id: string;
+            name: string;
+            email?: string;
+        };
+        productSpecRef?: string;
+        planSteps: {
+            id: string;
+            description: string;
+            command?: string;
+            expectedOutcome?: string;
+            status: "pending" | "in-progress" | "completed" | "failed";
+            output?: string;
+            error?: string;
+            executedAt?: string;
+        }[];
+        status: import("@lovelybunch/core").TaskStatus;
+        comments?: {
+            id: string;
+            author: string;
+            content: string;
+            createdAt: string;
+        }[];
+        metadata: {
+            createdAt: string;
+            updatedAt: string;
+            reviewers: string[];
+            tags?: string[];
+            priority?: "low" | "medium" | "high" | "critical";
+            readiness?: number;
+        };
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;
+export declare function DELETE(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: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;