@lovelybunch/api 1.0.75-alpha.8 → 1.0.75

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

@@ -6,8 +6,8 @@ import readline from 'readline';
 import { ZodError } from 'zod';
 import { streamText, tool, jsonSchema, stepCountIs } from 'ai';
 import { createAnthropic } from '@ai-sdk/anthropic';
-import { getLogsDir, listProposals, getProposal, createProposal, updateProposal, deleteProposal, } from '@lovelybunch/core';
-import { proposalsFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool, roleContextTool } from '@lovelybunch/mcp';
+import { getLogsDir, listTasks, getTask, createTask, updateTask, deleteTask, } from '@lovelybunch/core';
+import { tasksFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool, roleContextTool, resourcesTool } from '@lovelybunch/mcp';
 import matter from 'gray-matter';
 import Fuse from 'fuse.js';
 import { FileStorageAdapter } from '../../../../lib/storage/file-storage.js';
@@ -96,11 +96,11 @@ export async function POST(c) {
         // Using tool<any, string>() to properly type jsonSchema-based tools
         const storage = new FileStorageAdapter();
         const aiTools = {
-            change_proposals: tool({
-                description: proposalsFullTool.description,
-                inputSchema: jsonSchema(proposalsFullTool.parameters),
+            tasks: tool({
+                description: tasksFullTool.description,
+                inputSchema: jsonSchema(tasksFullTool.parameters),
                 execute: async (args) => {
-                    const result = await executeProposalsToolDirect(args, storage);
+                    const result = await executeTasksToolDirect(args, storage);
                     return JSON.stringify(result);
                 },
             }),
@@ -144,6 +144,14 @@ export async function POST(c) {
                     return JSON.stringify(result);
                 },
             }),
+            resources: tool({
+                description: resourcesTool.description,
+                inputSchema: jsonSchema(resourcesTool.parameters),
+                execute: async (args) => {
+                    const result = await executeResourcesToolDirect(args);
+                    return JSON.stringify(result);
+                },
+            }),
         };
         // Debug logging
         console.log('AI Request Debug:', {
@@ -175,24 +183,44 @@ export async function POST(c) {
 // These are unchanged from the previous implementation. They handle the actual
 // business logic for each tool, called automatically by the AI SDK when the
 // LLM makes tool calls.
-async function executeProposalsToolDirect(args, _storage) {
-    const { operation, id, filters, proposal, updates } = args;
+async function executeTasksToolDirect(args, _storage) {
+    const { operation, id, filters, task, updates } = args;
     try {
         switch (operation) {
             case 'list': {
-                const proposals = await listProposals(filters || {});
+                const DEFAULT_LIST_LIMIT = 20;
+                const requestedLimit = filters?.limit;
+                const effectiveLimit = requestedLimit ?? DEFAULT_LIST_LIMIT;
+                const tasks = await listTasks(filters || {});
+                const totalCount = tasks.length;
+                const limited = tasks.slice(0, effectiveLimit);
+                // Return lightweight summaries to keep token usage manageable.
+                // The AI can use "get" with a specific task ID to retrieve full details.
+                const summaries = limited.map((t) => ({
+                    id: t.id,
+                    title: t.title,
+                    status: t.status,
+                    priority: t.metadata?.priority,
+                    tags: t.metadata?.tags,
+                    author: t.author ? { name: t.author.name, type: t.author.type } : undefined,
+                    createdAt: t.metadata?.createdAt,
+                    updatedAt: t.metadata?.updatedAt,
+                }));
                 return {
                     success: true,
-                    data: proposals,
-                    count: proposals.length,
-                    message: `Found ${proposals.length} tasks`
+                    data: summaries,
+                    count: summaries.length,
+                    totalCount,
+                    message: totalCount > effectiveLimit
+                        ? `Showing ${summaries.length} of ${totalCount} tasks (limit: ${effectiveLimit}). Use filters or increase limit to see more. Use "get" with a task ID for full details.`
+                        : `Found ${totalCount} tasks. Use "get" with a task ID for full details.`
                 };
             }
             case 'get': {
                 if (!id) {
                     return { success: false, error: 'Task ID is required for get operation' };
                 }
-                const result = await getProposal(id);
+                const result = await getTask(id);
                 if (!result) {
                     return { success: false, error: 'Task not found' };
                 }
@@ -203,10 +231,10 @@ async function executeProposalsToolDirect(args, _storage) {
                 };
             }
             case 'create': {
-                if (!proposal) {
+                if (!task) {
                     return { success: false, error: 'Task data is required for create operation' };
                 }
-                const created = await createProposal(proposal);
+                const created = await createTask(task);
                 return {
                     success: true,
                     data: created,
@@ -217,11 +245,11 @@ async function executeProposalsToolDirect(args, _storage) {
                 if (!id) {
                     return { success: false, error: 'Task ID is required for update operation' };
                 }
-                const updateData = updates || proposal;
+                const updateData = updates || task;
                 if (!updateData) {
                     return { success: false, error: 'Update data is required for update operation' };
                 }
-                const updated = await updateProposal(id, updateData);
+                const updated = await updateTask(id, updateData);
                 return {
                     success: true,
                     data: updated,
@@ -232,7 +260,7 @@ async function executeProposalsToolDirect(args, _storage) {
                 if (!id) {
                     return { success: false, error: 'Task ID is required for delete operation' };
                 }
-                const deleted = await deleteProposal(id);
+                const deleted = await deleteTask(id);
                 if (!deleted) {
                     return { success: false, error: 'Task not found' };
                 }
@@ -256,7 +284,7 @@ async function executeProposalsToolDirect(args, _storage) {
                 }))
             };
         }
-        console.error('Error executing proposals tool:', error);
+        console.error('Error executing tasks tool:', error);
         return { success: false, error: error.message || 'Tool execution failed' };
     }
 }
@@ -817,6 +845,319 @@ async function executeRoleContextToolDirect(args) {
         return { success: false, error: error.message || 'Role context tool execution failed' };
     }
 }
+// ─── Resources Tool ─────────────────────────────────────────────────────────
+// Uses internal HTTP calls to the same server's resource endpoints so that all
+// existing validation, thumbnail generation, and error handling is reused.
+function getInternalApiBase() {
+    const port = process.env.PORT ? parseInt(process.env.PORT) : 3001;
+    return `http://127.0.0.1:${port}`;
+}
+async function executeResourcesToolDirect(args) {
+    const { operation, query, type_filter, resource_id, prompt, model, aspect_ratio, text, voice, duration, resolution, url, tags, description } = args;
+    const apiBase = getInternalApiBase();
+    try {
+        switch (operation) {
+            case 'list': {
+                const response = await fetch(`${apiBase}/api/v1/resources`);
+                const result = await response.json();
+                if (!result.success || !result.data) {
+                    return { success: false, error: 'Failed to list resources' };
+                }
+                let resources = result.data;
+                // Apply type filter
+                if (type_filter) {
+                    const prefix = type_filter.toLowerCase();
+                    resources = resources.filter((r) => r.type?.toLowerCase().startsWith(prefix));
+                }
+                // Apply search filter
+                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 a concise summary to keep token usage reasonable
+                const summary = resources.map((r) => ({
+                    id: r.id,
+                    name: r.name,
+                    type: r.type,
+                    size: r.size,
+                    tags: r.metadata?.tags,
+                    description: r.metadata?.description
+                        ? (r.metadata.description.length > 100
+                            ? r.metadata.description.slice(0, 100) + '...'
+                            : r.metadata.description)
+                        : undefined,
+                }));
+                return {
+                    success: true,
+                    data: summary,
+                    count: summary.length,
+                    message: query
+                        ? `Found ${summary.length} resources matching "${query}"`
+                        : `Found ${summary.length} resources`
+                };
+            }
+            case 'get': {
+                if (!resource_id) {
+                    return { success: false, error: 'resource_id is required for get operation' };
+                }
+                const response = await fetch(`${apiBase}/api/v1/resources`);
+                const result = await response.json();
+                if (!result.success || !result.data) {
+                    return { success: false, error: 'Failed to fetch resources' };
+                }
+                const resource = result.data.find((r) => r.id === resource_id);
+                if (!resource) {
+                    return { success: false, error: `Resource '${resource_id}' not found` };
+                }
+                return {
+                    success: true,
+                    data: resource,
+                    message: `Retrieved resource ${resource.name} (${resource.id})`
+                };
+            }
+            case 'generate_image': {
+                if (!prompt) {
+                    return { success: false, error: 'prompt is required for generate_image operation' };
+                }
+                // Step 1: Generate the image via Replicate
+                const genBody = {
+                    prompt,
+                    model: model || 'nano-banana-pro',
+                    dimensions: aspect_ratio || '16:9',
+                    output_format: 'png',
+                };
+                const genResponse = await fetch(`${apiBase}/api/v1/resources/generate`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(genBody),
+                    signal: AbortSignal.timeout(300_000), // 5 min
+                });
+                const genResult = await genResponse.json();
+                if (!genResult.success || !genResult.data?.imageUrl) {
+                    const msg = genResult.error?.message || 'Image generation failed';
+                    return { success: false, error: msg };
+                }
+                // Step 2: Download and save to resources
+                const saved = await downloadAndSaveToResources(genResult.data.imageUrl, apiBase, { type: 'image', prompt, model: model || 'nano-banana-pro', tags, description });
+                return {
+                    success: true,
+                    data: saved,
+                    message: `Generated and saved image "${saved.name}" (${saved.id}). It is now available in the Resources section.`
+                };
+            }
+            case 'generate_audio': {
+                if (!text) {
+                    return { success: false, error: 'text is required for generate_audio operation' };
+                }
+                const audioBody = {
+                    text,
+                    voice_id: voice || 'English_Trustworth_Man',
+                    speed: 1,
+                    pitch: 0,
+                    emotion: 'auto',
+                    language_boost: 'English',
+                    audio_format: 'mp3',
+                };
+                const audioResponse = await fetch(`${apiBase}/api/v1/resources/generate-audio`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(audioBody),
+                    signal: AbortSignal.timeout(300_000),
+                });
+                const audioResult = await audioResponse.json();
+                if (!audioResult.success || !audioResult.data?.audioUrl) {
+                    const msg = audioResult.error?.message || 'Audio generation failed';
+                    return { success: false, error: msg };
+                }
+                const savedAudio = await downloadAndSaveToResources(audioResult.data.audioUrl, apiBase, { type: 'audio', prompt: text, model: 'minimax/speech-02-turbo', tags, description });
+                return {
+                    success: true,
+                    data: savedAudio,
+                    message: `Generated and saved audio "${savedAudio.name}" (${savedAudio.id}). It is now available in the Resources section.`
+                };
+            }
+            case 'generate_video': {
+                if (!prompt) {
+                    return { success: false, error: 'prompt is required for generate_video operation' };
+                }
+                const videoBody = {
+                    prompt,
+                    duration: duration || 8,
+                    resolution: resolution || '720p',
+                    aspect_ratio: aspect_ratio || '16:9',
+                    generate_audio: true,
+                };
+                const videoResponse = await fetch(`${apiBase}/api/v1/resources/generate-video`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(videoBody),
+                    signal: AbortSignal.timeout(300_000),
+                });
+                const videoResult = await videoResponse.json();
+                if (!videoResult.success || !videoResult.data?.videoUrl) {
+                    const msg = videoResult.error?.message || 'Video generation failed';
+                    return { success: false, error: msg };
+                }
+                const savedVideo = await downloadAndSaveToResources(videoResult.data.videoUrl, apiBase, { type: 'video', prompt, model: 'google/veo-3.1-fast', tags, description });
+                return {
+                    success: true,
+                    data: savedVideo,
+                    message: `Generated and saved video "${savedVideo.name}" (${savedVideo.id}). It is now available in the Resources section.`
+                };
+            }
+            case 'add_from_url': {
+                if (!url) {
+                    return { success: false, error: 'url is required for add_from_url operation' };
+                }
+                // Download the URL
+                const dlResponse = await fetch(url);
+                if (!dlResponse.ok) {
+                    return { success: false, error: `Failed to download URL: ${dlResponse.statusText}` };
+                }
+                const buffer = Buffer.from(await dlResponse.arrayBuffer());
+                const contentType = dlResponse.headers.get('content-type') || 'application/octet-stream';
+                // Derive filename from URL path
+                let fileName;
+                try {
+                    const urlPath = new URL(url).pathname;
+                    fileName = basename(urlPath);
+                    if (!fileName || fileName === '/') {
+                        fileName = `downloaded-${Date.now()}`;
+                    }
+                }
+                catch {
+                    fileName = `downloaded-${Date.now()}`;
+                }
+                // Add extension from content-type if missing
+                if (!fileName.includes('.')) {
+                    const extMap = {
+                        'image/png': '.png', 'image/jpeg': '.jpg', 'image/webp': '.webp',
+                        'image/gif': '.gif', 'image/svg+xml': '.svg',
+                        'audio/mpeg': '.mp3', 'audio/wav': '.wav', 'audio/ogg': '.ogg',
+                        'video/mp4': '.mp4', 'video/webm': '.webm',
+                        'application/pdf': '.pdf', 'application/json': '.json',
+                    };
+                    const ext = Object.entries(extMap).find(([ct]) => contentType.includes(ct))?.[1] || '.bin';
+                    fileName += ext;
+                }
+                const mimeType = contentType.split(';')[0].trim();
+                // Upload to resources via FormData
+                const formData = new FormData();
+                const blob = new Blob([buffer], { type: mimeType });
+                formData.set('file', blob, fileName);
+                if (tags)
+                    formData.set('tags', tags);
+                if (description)
+                    formData.set('description', description);
+                const uploadResponse = await fetch(`${apiBase}/api/v1/resources`, {
+                    method: 'POST',
+                    body: formData,
+                });
+                const uploadResult = await uploadResponse.json();
+                if (!uploadResult.success || !uploadResult.data) {
+                    return { success: false, error: uploadResult.error?.message || 'Upload failed' };
+                }
+                return {
+                    success: true,
+                    data: uploadResult.data,
+                    message: `Downloaded and saved "${uploadResult.data.name}" (${uploadResult.data.id}) from URL. It is now available in the Resources section.`
+                };
+            }
+            default:
+                return {
+                    success: false,
+                    error: `Unknown operation: ${operation}. Supported: list, get, generate_image, generate_audio, generate_video, add_from_url`
+                };
+        }
+    }
+    catch (error) {
+        console.error('Error executing resources tool:', error);
+        return { success: false, error: error.message || 'Resources tool execution failed' };
+    }
+}
+/**
+ * Download media from a URL and upload it to the resources API.
+ * Used by generation operations to auto-save generated content.
+ */
+async function downloadAndSaveToResources(mediaUrl, apiBase, meta) {
+    const response = await fetch(mediaUrl);
+    if (!response.ok) {
+        throw new Error(`Failed to download generated ${meta.type}`);
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const contentType = response.headers.get('content-type') || '';
+    // Determine extension from content-type
+    let extension = 'bin';
+    let mimeType = contentType.split(';')[0].trim();
+    if (meta.type === 'image') {
+        if (contentType.includes('png'))
+            extension = 'png';
+        else if (contentType.includes('jpeg') || contentType.includes('jpg'))
+            extension = 'jpg';
+        else if (contentType.includes('webp'))
+            extension = 'webp';
+        else
+            extension = 'png';
+        mimeType = mimeType || `image/${extension}`;
+    }
+    else if (meta.type === 'audio') {
+        if (contentType.includes('mp3') || contentType.includes('mpeg'))
+            extension = 'mp3';
+        else if (contentType.includes('wav'))
+            extension = 'wav';
+        else if (contentType.includes('ogg'))
+            extension = 'ogg';
+        else
+            extension = 'mp3';
+        mimeType = mimeType || `audio/${extension}`;
+    }
+    else if (meta.type === 'video') {
+        if (contentType.includes('mp4'))
+            extension = 'mp4';
+        else if (contentType.includes('webm'))
+            extension = 'webm';
+        else
+            extension = 'mp4';
+        mimeType = mimeType || `video/${extension}`;
+    }
+    const fileName = `generated-${meta.type}-${Date.now()}.${extension}`;
+    // Upload via FormData to the resources endpoint (triggers thumbnail generation, etc.)
+    const formData = new FormData();
+    const blob = new Blob([buffer], { type: mimeType });
+    formData.set('file', blob, fileName);
+    // Build description with generation metadata
+    const descParts = [];
+    if (meta.description)
+        descParts.push(meta.description);
+    if (meta.prompt)
+        descParts.push(`Generated with: "${meta.prompt}"`);
+    if (meta.model)
+        descParts.push(`Model: ${meta.model}`);
+    const fullDesc = descParts.join(' | ');
+    if (fullDesc)
+        formData.set('description', fullDesc);
+    // Build tags
+    const tagParts = [];
+    if (meta.tags)
+        tagParts.push(meta.tags);
+    tagParts.push('ai-generated', meta.type);
+    formData.set('tags', tagParts.join(', '));
+    if (meta.prompt)
+        formData.set('generationPrompt', meta.prompt);
+    if (meta.model)
+        formData.set('generationModel', meta.model);
+    const uploadResponse = await fetch(`${apiBase}/api/v1/resources`, {
+        method: 'POST',
+        body: formData,
+    });
+    const result = await uploadResponse.json();
+    if (!result.success || !result.data) {
+        throw new Error('Failed to save generated media to resources');
+    }
+    return result.data;
+}
 // ─── Helper Functions ────────────────────────────────────────────────────────
 function getContextBasePath() {
     let basePath;
@@ -842,7 +1183,7 @@ function getKnowledgeBasePath() {
     else {
         basePath = pathResolve(process.cwd(), '.nut');
     }
-    return join(basePath, 'context', 'knowledge');
+    return join(basePath, 'knowledge');
 }
 function slugify(value) {
     const slug = value

package/dist/routes/api/v1/chats/[id]/index.js

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

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

@@ -4,6 +4,13 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     error: string;
 }, 404, "json">)>;
+export declare function PUT(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+    chatId: string;
+    message: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;
 export declare function DELETE(c: Context): Promise<(Response & import("hono").TypedResponse<{
     success: true;
     message: string;

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

@@ -1,4 +1,4 @@
-import { readFile, unlink } from "fs/promises";
+import { readFile, writeFile, unlink } from "fs/promises";
 import { join, resolve } from "path";
 function getChatsPath() {
     let basePath;
@@ -30,6 +30,35 @@ export async function GET(c) {
         return c.json({ error: "Chat not found" }, 404);
     }
 }
+export async function PUT(c) {
+    try {
+        const id = c.req.param('id');
+        const filePath = join(CHATS_DIR, `${id}.json`);
+        // Read existing chat
+        const existing = JSON.parse(await readFile(filePath, 'utf8'));
+        const body = await c.req.json();
+        const { messages, model, context, title } = body;
+        const now = new Date().toISOString();
+        const updated = {
+            ...existing,
+            messages: messages ?? existing.messages,
+            model: model ?? existing.model,
+            context: context ?? existing.context,
+            title: title ?? existing.title,
+            updatedAt: now,
+        };
+        await writeFile(filePath, JSON.stringify(updated, null, 2));
+        return c.json({
+            success: true,
+            chatId: id,
+            message: "Chat updated successfully"
+        });
+    }
+    catch (error) {
+        console.error("Error updating chat:", error);
+        return c.json({ error: "Failed to update chat" }, 500);
+    }
+}
 export async function DELETE(c) {
     try {
         const id = c.req.param('id');

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

@@ -2,12 +2,10 @@ import { Hono } from 'hono';
 import project from './project/route.js';
 import architecture from './architecture/route.js';
 import role from './role/route.js';
-import knowledge from './knowledge/index.js';
 import images from './images/index.js';
 const context = new Hono();
 context.route('/project', project);
 context.route('/architecture', architecture);
 context.route('/role', role);
-context.route('/knowledge', knowledge);
 context.route('/images', images);
 export default context;

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

@@ -331,6 +331,22 @@ app.post('/branches/:branch/merge', async (c) => {
         catch { }
         const mergeStrategy = strategy?.strategy === 'squash' || strategy?.strategy === 'rebase' ? strategy.strategy : 'merge';
         const result = await mergeBranch(name, mergeStrategy);
+        // Determine target branch for notification
+        try {
+            const { runGit } = await import('../../../../lib/git.js');
+            const { stdout: branchOutput } = await runGit(['branch', '--show-current']);
+            const targetBranch = branchOutput.trim();
+            // Send Slack notification (non-blocking)
+            import('../../../../lib/slack/slack-service.js').then(({ getSlackService }) => {
+                getSlackService().sendNotification({
+                    type: 'git.merge',
+                    branch: name,
+                    targetBranch,
+                    message: `Merged ${name} into ${targetBranch} using ${mergeStrategy}`,
+                }).catch(err => console.warn('[git] Slack notification failed:', err));
+            }).catch(() => { });
+        }
+        catch { }
         return c.json({ success: true, data: { branch: name, strategy: mergeStrategy, result } });
     }
     catch (e) {
@@ -466,6 +482,13 @@ app.post('/push', async (c) => {
                     remote: remoteName,
                 }
             });
+            // Send Slack notification (non-blocking)
+            import('../../../../lib/slack/slack-service.js').then(({ getSlackService }) => {
+                getSlackService().sendNotification({
+                    type: 'git.push',
+                    branch: currentBranch,
+                }).catch(err => console.warn('[git] Slack notification failed:', err));
+            }).catch(() => { });
         }
         catch (logError) {
             console.error('Error logging push:', logError);

package/dist/routes/api/v1/knowledge/[filename]/index.d.ts

@@ -0,0 +1 @@
+export { default } from './route.js';

package/dist/routes/api/v1/knowledge/[filename]/index.js

@@ -0,0 +1 @@
+export { default } from './route.js';

package/dist/routes/api/v1/knowledge/[filename]/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;