@lovelybunch/api 1.0.70 → 1.0.71-alpha.0

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

@@ -1,10 +1,12 @@
 import { Hono } from 'hono';
-import { promises as fs } from 'fs';
+import { promises as fs, createReadStream } from 'fs';
 import path from 'path';
+import readline from 'readline';
 import matter from 'gray-matter';
-import { proposalsTool, listProposalsTool, validateProposalData, knowledgeTool, normalizeKnowledgeMetadata } from '@lovelybunch/mcp';
+import Fuse from 'fuse.js';
+import { getLogsDir } from '@lovelybunch/core';
+import { proposalsReadOnlyTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool } 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() {
@@ -42,10 +44,13 @@ app.get('/', async (c) => {
         }
         const names = Object.keys(externalServers);
         // Add built-in tools (include full JSON schema for parameters)
+        // Note: proposals is read-only, knowledge/project/architecture are read+write, events is read-only
         const builtInTools = {
-            change_proposals: proposalsTool,
-            list_proposals: listProposalsTool,
-            knowledge_documents: knowledgeTool
+            change_proposals: proposalsReadOnlyTool,
+            knowledge_documents: knowledgeTool,
+            activity_events: eventsTool,
+            project_context: projectContextTool,
+            architecture_context: architectureContextTool
         };
         return c.json({
             success: true,
@@ -65,11 +70,14 @@ app.get('/', async (c) => {
  */
 app.get('/schema', async (c) => {
     try {
+        // Note: proposals is read-only, knowledge/project/architecture are read+write, events is read-only
         const schema = {
             tools: {
-                change_proposals: proposalsTool,
-                list_proposals: listProposalsTool,
-                knowledge_documents: knowledgeTool
+                change_proposals: proposalsReadOnlyTool,
+                knowledge_documents: knowledgeTool,
+                activity_events: eventsTool,
+                project_context: projectContextTool,
+                architecture_context: architectureContextTool
             }
         };
         return c.json(schema);
@@ -92,12 +100,18 @@ app.post('/execute', async (c) => {
         if (tool === 'change_proposals') {
             return await executeProposalsTool(c, args);
         }
-        if (tool === 'list_proposals') {
-            return await executeListProposalsTool(c, args);
-        }
         if (tool === 'knowledge_documents') {
             return await executeKnowledgeTool(c, args);
         }
+        if (tool === 'activity_events') {
+            return await executeEventsTool(c, args);
+        }
+        if (tool === 'project_context') {
+            return await executeProjectContextTool(c, args);
+        }
+        if (tool === 'architecture_context') {
+            return await executeArchitectureContextTool(c, args);
+        }
         return c.json({ success: false, error: 'Unknown tool' }, 400);
     }
     catch (error) {
@@ -105,8 +119,9 @@ app.post('/execute', async (c) => {
         return c.json({ success: false, error: 'Tool execution failed' }, 500);
     }
 });
+// Proposals tool is READ-ONLY - only list and get operations are supported
 async function executeProposalsTool(c, args) {
-    const { operation, id, filters, proposal } = args;
+    const { operation, id, filters } = args;
     try {
         switch (operation) {
             case 'list': {
@@ -131,138 +146,11 @@ async function executeProposalsTool(c, args) {
                     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);
+                return c.json({
+                    success: false,
+                    error: `Proposals are read-only. Only 'list' and 'get' operations are supported. To create proposals, use a coding agent (Claude Code, Cursor, etc.) or the Proposals UI.`
+                }, 400);
         }
     }
     catch (error) {
@@ -270,49 +158,21 @@ async function executeProposalsTool(c, args) {
         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);
-    }
-}
 async function executeKnowledgeTool(c, args) {
-    const { operation, filename, title, content, metadata, summary } = args;
+    const { operation, filename, title, content, metadata, summary, query } = args;
     try {
         const knowledgePath = getKnowledgePath();
         await fs.mkdir(knowledgePath, { recursive: true });
         switch (operation) {
             case 'list': {
-                const documents = await listKnowledgeDocuments(knowledgePath);
+                const searchQuery = query && typeof query === 'string' ? query : undefined;
+                const documents = await listKnowledgeDocuments(knowledgePath, searchQuery);
                 return c.json({
                     success: true,
                     data: documents,
-                    message: `Found ${documents.length} knowledge documents`
+                    message: searchQuery
+                        ? `Found ${documents.length} knowledge documents matching "${searchQuery}"`
+                        : `Found ${documents.length} knowledge documents`
                 });
             }
             case 'get': {
@@ -449,6 +309,302 @@ async function executeKnowledgeTool(c, args) {
         return c.json({ success: false, error: error.message || 'Knowledge tool execution failed' }, 500);
     }
 }
+// Events tool is READ-ONLY - returns recent activity events
+async function executeEventsTool(c, args) {
+    const { operation, limit = 20, kind } = args;
+    if (operation !== 'list') {
+        return c.json({
+            success: false,
+            error: `Events are read-only. Only 'list' operation is supported.`
+        }, 400);
+    }
+    try {
+        const eventsDir = getLogsDir();
+        const currentFile = path.join(eventsDir, 'events-current.jsonl');
+        // Check if file exists
+        try {
+            await fs.access(currentFile);
+        }
+        catch {
+            return c.json({
+                success: true,
+                data: [],
+                message: 'No events found'
+            });
+        }
+        // Read all events from file
+        const allEvents = [];
+        const fileStream = createReadStream(currentFile);
+        const rl = readline.createInterface({
+            input: fileStream,
+            crlfDelay: Infinity,
+        });
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            try {
+                const event = JSON.parse(line);
+                // Apply kind filter if specified
+                if (kind && typeof kind === 'string') {
+                    if (!event.kind || !event.kind.startsWith(kind)) {
+                        continue;
+                    }
+                }
+                allEvents.push(event);
+            }
+            catch {
+                // Skip malformed lines
+                continue;
+            }
+        }
+        // Sort by seq descending (most recent first) and limit
+        const cappedLimit = Math.min(Math.max(1, limit), 100);
+        const sortedEvents = allEvents
+            .sort((a, b) => (b.seq || 0) - (a.seq || 0))
+            .slice(0, cappedLimit);
+        // Format events for readability
+        const formattedEvents = sortedEvents.map(event => ({
+            seq: event.seq,
+            kind: event.kind,
+            actor: event.actor,
+            subject: event.subject,
+            timestamp: event.ts,
+            level: event.level,
+            tags: event.tags,
+            summary: event.payload?.summary || event.payload?.message || event.payload?.title || undefined
+        }));
+        return c.json({
+            success: true,
+            data: formattedEvents,
+            message: kind
+                ? `Found ${formattedEvents.length} recent '${kind}' events`
+                : `Found ${formattedEvents.length} recent events`
+        });
+    }
+    catch (error) {
+        console.error('Error executing events tool:', error);
+        return c.json({ success: false, error: error.message || 'Events tool execution failed' }, 500);
+    }
+}
+// Project context tool - read/write the project definition document
+async function executeProjectContextTool(c, args) {
+    const { operation, content, old_text, new_text } = args;
+    try {
+        const contextPath = getContextPath();
+        const filePath = path.join(contextPath, 'project.md');
+        switch (operation) {
+            case 'get': {
+                try {
+                    const fileContent = await fs.readFile(filePath, 'utf-8');
+                    const parsed = matter(fileContent);
+                    return c.json({
+                        success: true,
+                        data: {
+                            content: parsed.content,
+                            frontmatter: parsed.data,
+                            raw: fileContent
+                        },
+                        message: 'Retrieved project context'
+                    });
+                }
+                catch (err) {
+                    if (err.code === 'ENOENT') {
+                        return c.json({
+                            success: true,
+                            data: { content: '', frontmatter: {}, raw: '' },
+                            message: 'Project context document does not exist yet. You can create it with an update operation.'
+                        });
+                    }
+                    throw err;
+                }
+            }
+            case 'append': {
+                if (!content) {
+                    return c.json({ success: false, error: 'Content is required for append operation' }, 400);
+                }
+                await fs.mkdir(contextPath, { recursive: true });
+                // Read existing content if file exists
+                let existingContent = '';
+                try {
+                    existingContent = await fs.readFile(filePath, 'utf-8');
+                }
+                catch (err) {
+                    if (err.code !== 'ENOENT')
+                        throw err;
+                }
+                // Append new content with a newline separator
+                const newContent = existingContent
+                    ? existingContent.trimEnd() + '\n\n' + content
+                    : content;
+                await fs.writeFile(filePath, newContent, 'utf-8');
+                return c.json({
+                    success: true,
+                    message: 'Appended content to project context document'
+                });
+            }
+            case 'replace_section': {
+                if (!old_text || !new_text) {
+                    return c.json({ success: false, error: 'Both old_text and new_text are required for replace_section operation' }, 400);
+                }
+                // Read existing content
+                let existingContent = '';
+                try {
+                    existingContent = await fs.readFile(filePath, 'utf-8');
+                }
+                catch (err) {
+                    if (err.code === 'ENOENT') {
+                        return c.json({ success: false, error: 'Project context document does not exist. Use append or update to create it first.' }, 404);
+                    }
+                    throw err;
+                }
+                // Check if old_text exists in the document
+                if (!existingContent.includes(old_text)) {
+                    return c.json({
+                        success: false,
+                        error: 'Could not find the specified text in the document. The text may have been paraphrased or changed.',
+                        fallback_markdown: new_text,
+                        suggestion: 'Here is the replacement text. You can copy it and manually edit the document at /context/project'
+                    }, 400);
+                }
+                // Replace the text
+                const updatedContent = existingContent.replace(old_text, new_text);
+                await fs.writeFile(filePath, updatedContent, 'utf-8');
+                return c.json({
+                    success: true,
+                    message: 'Replaced section in project context document'
+                });
+            }
+            case 'update': {
+                if (!content) {
+                    return c.json({ success: false, error: 'Content is required for update operation' }, 400);
+                }
+                await fs.mkdir(contextPath, { recursive: true });
+                await fs.writeFile(filePath, content, 'utf-8');
+                return c.json({
+                    success: true,
+                    message: 'Updated project context document'
+                });
+            }
+            default:
+                return c.json({ success: false, error: `Unknown operation: ${operation}. Use 'get', 'append', 'replace_section', or 'update'.` }, 400);
+        }
+    }
+    catch (error) {
+        console.error('Error executing project context tool:', error);
+        return c.json({ success: false, error: error.message || 'Project context tool execution failed' }, 500);
+    }
+}
+// Architecture context tool - read/write the architecture document
+async function executeArchitectureContextTool(c, args) {
+    const { operation, content, old_text, new_text } = args;
+    try {
+        const contextPath = getContextPath();
+        const filePath = path.join(contextPath, 'architecture.md');
+        switch (operation) {
+            case 'get': {
+                try {
+                    const fileContent = await fs.readFile(filePath, 'utf-8');
+                    const parsed = matter(fileContent);
+                    return c.json({
+                        success: true,
+                        data: {
+                            content: parsed.content,
+                            frontmatter: parsed.data,
+                            raw: fileContent
+                        },
+                        message: 'Retrieved architecture context'
+                    });
+                }
+                catch (err) {
+                    if (err.code === 'ENOENT') {
+                        return c.json({
+                            success: true,
+                            data: { content: '', frontmatter: {}, raw: '' },
+                            message: 'Architecture context document does not exist yet. You can create it with an update operation.'
+                        });
+                    }
+                    throw err;
+                }
+            }
+            case 'append': {
+                if (!content) {
+                    return c.json({ success: false, error: 'Content is required for append operation' }, 400);
+                }
+                await fs.mkdir(contextPath, { recursive: true });
+                // Read existing content if file exists
+                let existingContent = '';
+                try {
+                    existingContent = await fs.readFile(filePath, 'utf-8');
+                }
+                catch (err) {
+                    if (err.code !== 'ENOENT')
+                        throw err;
+                }
+                // Append new content with a newline separator
+                const newContent = existingContent
+                    ? existingContent.trimEnd() + '\n\n' + content
+                    : content;
+                await fs.writeFile(filePath, newContent, 'utf-8');
+                return c.json({
+                    success: true,
+                    message: 'Appended content to architecture context document'
+                });
+            }
+            case 'replace_section': {
+                if (!old_text || !new_text) {
+                    return c.json({ success: false, error: 'Both old_text and new_text are required for replace_section operation' }, 400);
+                }
+                // Read existing content
+                let existingContent = '';
+                try {
+                    existingContent = await fs.readFile(filePath, 'utf-8');
+                }
+                catch (err) {
+                    if (err.code === 'ENOENT') {
+                        return c.json({ success: false, error: 'Architecture context document does not exist. Use append or update to create it first.' }, 404);
+                    }
+                    throw err;
+                }
+                // Check if old_text exists in the document
+                if (!existingContent.includes(old_text)) {
+                    return c.json({
+                        success: false,
+                        error: 'Could not find the specified text in the document. The text may have been paraphrased or changed.',
+                        fallback_markdown: new_text,
+                        suggestion: 'Here is the replacement text. You can copy it and manually edit the document at /context/architecture'
+                    }, 400);
+                }
+                // Replace the text
+                const updatedContent = existingContent.replace(old_text, new_text);
+                await fs.writeFile(filePath, updatedContent, 'utf-8');
+                return c.json({
+                    success: true,
+                    message: 'Replaced section in architecture context document'
+                });
+            }
+            case 'update': {
+                if (!content) {
+                    return c.json({ success: false, error: 'Content is required for update operation' }, 400);
+                }
+                await fs.mkdir(contextPath, { recursive: true });
+                await fs.writeFile(filePath, content, 'utf-8');
+                return c.json({
+                    success: true,
+                    message: 'Updated architecture context document'
+                });
+            }
+            default:
+                return c.json({ success: false, error: `Unknown operation: ${operation}. Use 'get', 'append', 'replace_section', or 'update'.` }, 400);
+        }
+    }
+    catch (error) {
+        console.error('Error executing architecture context tool:', error);
+        return c.json({ success: false, error: error.message || 'Architecture context tool execution failed' }, 500);
+    }
+}
+function getContextPath() {
+    return path.join(resolveGaitPath(), 'context');
+}
 function getKnowledgePath() {
     return path.join(resolveGaitPath(), 'context', 'knowledge');
 }
@@ -496,22 +652,92 @@ async function readKnowledgeDocument(basePath, filename) {
         content
     };
 }
-async function listKnowledgeDocuments(basePath) {
+function extractSnippet(content, query, maxLength = 200) {
+    const lowerContent = content.toLowerCase();
+    const lowerQuery = query.toLowerCase();
+    const terms = lowerQuery.split(/\s+/);
+    // Find the first occurrence of any search term
+    let bestIndex = -1;
+    let matchedTerm = '';
+    for (const term of terms) {
+        const index = lowerContent.indexOf(term);
+        if (index !== -1 && (bestIndex === -1 || index < bestIndex)) {
+            bestIndex = index;
+            matchedTerm = term;
+        }
+    }
+    if (bestIndex === -1) {
+        // No match found, return beginning of content
+        return content.slice(0, maxLength) + (content.length > maxLength ? '...' : '');
+    }
+    // Extract snippet around the match
+    const start = Math.max(0, bestIndex - 60);
+    const end = Math.min(content.length, bestIndex + matchedTerm.length + 140);
+    let snippet = content.slice(start, end);
+    // Add ellipsis if needed
+    if (start > 0)
+        snippet = '...' + snippet;
+    if (end < content.length)
+        snippet = snippet + '...';
+    return snippet;
+}
+function findMatchedFields(doc, query) {
+    const lowerQuery = query.toLowerCase();
+    const terms = lowerQuery.split(/\s+/);
+    const matched = [];
+    const checkField = (value, fieldName) => {
+        if (value && terms.some(term => value.toLowerCase().includes(term))) {
+            matched.push(fieldName);
+        }
+    };
+    checkField(doc.title, 'title');
+    checkField(doc.content, 'content');
+    checkField(doc.metadata?.category, 'category');
+    checkField(doc.metadata?.summary, 'summary');
+    if (doc.metadata?.tags?.some(tag => terms.some(term => tag.toLowerCase().includes(term)))) {
+        matched.push('tags');
+    }
+    return matched;
+}
+async function listKnowledgeDocuments(basePath, query) {
     const files = await fs.readdir(basePath);
     const markdownFiles = files.filter(file => file.endsWith('.md'));
     const documents = await Promise.all(markdownFiles.map(async (file) => {
         try {
-            const doc = await readKnowledgeDocument(basePath, file);
-            return doc;
+            return await readKnowledgeDocument(basePath, file);
         }
         catch (error) {
             console.error(`Failed to read knowledge document ${file}:`, error);
             return null;
         }
     }));
-    return documents
-        .filter((doc) => doc !== null)
-        .sort((a, b) => a.filename.localeCompare(b.filename));
+    const validDocs = documents.filter((doc) => doc !== null);
+    // If no query, return all documents sorted by filename
+    if (!query?.trim()) {
+        return validDocs.sort((a, b) => a.filename.localeCompare(b.filename));
+    }
+    // Use Fuse.js for fuzzy search
+    const fuse = new Fuse(validDocs, {
+        keys: [
+            { name: 'title', weight: 2 },
+            { name: 'content', weight: 1 },
+            { name: 'metadata.summary', weight: 1.5 },
+            { name: 'metadata.category', weight: 1 },
+            { name: 'metadata.tags', weight: 1.5 }
+        ],
+        threshold: 0.4,
+        includeScore: true,
+        ignoreLocation: true,
+        minMatchCharLength: 2
+    });
+    const results = fuse.search(query);
+    // Enhance results with snippets and matched fields
+    return results.map(result => ({
+        ...result.item,
+        snippet: extractSnippet(result.item.content, query),
+        matchedIn: findMatchedFields(result.item, query),
+        score: result.score
+    }));
 }
 /**
  * GET /api/v1/mcp/raw-config

package/dist/routes/api/v1/resources/generate/route.d.ts

@@ -14,6 +14,6 @@ export declare function POST(c: Context): Promise<(Response & import("hono").Typ
     success: false;
     error: {
         code: string;
-        message: any;
+        message: string;
     };
 }, 500, "json">)>;