@lovelybunch/api 1.0.73 → 1.0.74

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

@@ -1,11 +1,9 @@
 import { Hono } from 'hono';
-import { promises as fs, createReadStream } from 'fs';
+import { promises as fs } from 'fs';
 import path from 'path';
-import readline from 'readline';
-import matter from 'gray-matter';
-import Fuse from 'fuse.js';
-import { getLogsDir } from '@lovelybunch/core';
-import { proposalsReadOnlyTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool, roleContextTool } from '@lovelybunch/mcp';
+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 { FileStorageAdapter } from '../../../../lib/storage/file-storage.js';
 const app = new Hono();
 const storage = new FileStorageAdapter();
@@ -80,9 +78,9 @@ 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
+        // Note: proposals now supports full CRUD, knowledge/project/architecture are read+write, events is read-only
         const builtInTools = {
-            change_proposals: proposalsReadOnlyTool,
+            change_proposals: proposalsFullTool,
             knowledge_documents: knowledgeTool,
             activity_events: eventsTool,
             project_context: projectContextTool,
@@ -107,10 +105,10 @@ 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
+        // Note: proposals now supports full CRUD, knowledge/project/architecture are read+write, events is read-only
         const schema = {
             tools: {
-                change_proposals: proposalsReadOnlyTool,
+                change_proposals: proposalsFullTool,
                 knowledge_documents: knowledgeTool,
                 activity_events: eventsTool,
                 project_context: projectContextTool,
@@ -160,16 +158,17 @@ 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
+// Proposals tool - full CRUD operations using @lovelybunch/core
 async function executeProposalsTool(c, args) {
-    const { operation, id, filters } = args;
+    const { operation, id, filters, proposal, updates } = args;
     try {
         switch (operation) {
             case 'list': {
-                const proposals = await storage.listCPs(filters || {});
+                const proposals = await listProposals(filters || {});
                 return c.json({
                     success: true,
                     data: proposals,
+                    count: proposals.length,
                     message: `Found ${proposals.length} proposals`
                 });
             }
@@ -177,37 +176,86 @@ async function executeProposalsTool(c, args) {
                 if (!id) {
                     return c.json({ success: false, error: 'Proposal ID is required for get operation' }, 400);
                 }
-                const proposal = await storage.getCP(id);
-                if (!proposal) {
+                const result = await getProposal(id);
+                if (!result) {
                     return c.json({ success: false, error: 'Proposal not found' }, 404);
                 }
                 return c.json({
                     success: true,
-                    data: proposal,
+                    data: result,
                     message: `Retrieved proposal ${id}`
                 });
             }
+            case 'create': {
+                if (!proposal) {
+                    return c.json({ success: false, error: 'Proposal data is required for create operation' }, 400);
+                }
+                const created = await createProposal(proposal);
+                return c.json({
+                    success: true,
+                    data: created,
+                    message: `Created proposal ${created.id}`
+                }, 201);
+            }
+            case 'update': {
+                if (!id) {
+                    return c.json({ success: false, error: 'Proposal ID is required for update operation' }, 400);
+                }
+                const updateData = updates || proposal;
+                if (!updateData) {
+                    return c.json({ success: false, error: 'Update data is required for update operation' }, 400);
+                }
+                const updated = await updateProposal(id, updateData);
+                return c.json({
+                    success: true,
+                    data: updated,
+                    message: `Updated proposal ${id}`
+                });
+            }
+            case 'delete': {
+                if (!id) {
+                    return c.json({ success: false, error: 'Proposal ID is required for delete operation' }, 400);
+                }
+                const deleted = await deleteProposal(id);
+                if (!deleted) {
+                    return c.json({ success: false, error: 'Proposal not found' }, 404);
+                }
+                return c.json({
+                    success: true,
+                    message: `Deleted proposal ${id}`
+                });
+            }
             default:
                 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.`
+                    error: `Unknown operation: ${operation}. Supported operations: list, get, create, update, delete`
                 }, 400);
         }
     }
     catch (error) {
+        // Handle Zod validation errors specially
+        if (error instanceof ZodError) {
+            return c.json({
+                success: false,
+                error: 'Validation failed',
+                details: error.issues.map(e => ({
+                    path: e.path.join('.'),
+                    message: e.message
+                }))
+            }, 400);
+        }
         console.error('Error executing proposals tool:', error);
         return c.json({ success: false, error: error.message || 'Tool execution failed' }, 500);
     }
 }
+// Knowledge tool executor - uses core knowledge functions
 async function executeKnowledgeTool(c, 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 searchQuery = query && typeof query === 'string' ? query : undefined;
-                const documents = await listKnowledgeDocuments(knowledgePath, searchQuery);
+                const documents = await listKnowledge({ query: searchQuery });
                 return c.json({
                     success: true,
                     data: documents,
@@ -220,7 +268,7 @@ async function executeKnowledgeTool(c, args) {
                 if (!filename) {
                     return c.json({ success: false, error: 'Filename is required for get operation' }, 400);
                 }
-                const document = await readKnowledgeDocument(knowledgePath, filename);
+                const document = await getKnowledge(filename);
                 if (!document) {
                     return c.json({ success: false, error: 'Knowledge document not found' }, 404);
                 }
@@ -230,95 +278,48 @@ async function executeKnowledgeTool(c, args) {
                 if (!title || !content) {
                     return c.json({ success: false, error: 'Title and content are required for create operation' }, 400);
                 }
-                const targetFilename = resolveFilename(filename, title);
-                const filePath = path.join(knowledgePath, targetFilename);
                 try {
-                    await fs.access(filePath);
-                    return c.json({ success: false, error: 'A knowledge document with this filename already exists' }, 409);
+                    const created = await createKnowledge({ title, content, filename, summary, metadata });
+                    return c.json({
+                        success: true,
+                        data: created,
+                        message: `Created knowledge document ${created.filename}`
+                    }, 201);
                 }
-                catch {
-                    // File does not exist, safe to create
+                catch (err) {
+                    if (err.message?.includes('already exists')) {
+                        return c.json({ success: false, error: err.message }, 409);
+                    }
+                    throw err;
                 }
-                const normalizedMetadata = normalizeKnowledgeMetadata({
-                    version: '1.0',
-                    summary,
-                    ...metadata
-                });
-                const markdown = matter.stringify(content, normalizedMetadata);
-                await fs.writeFile(filePath, markdown, 'utf-8');
-                const created = {
-                    filename: targetFilename,
-                    title,
-                    metadata: normalizedMetadata,
-                    content
-                };
-                return c.json({
-                    success: true,
-                    data: created,
-                    message: `Created knowledge document ${targetFilename}`
-                }, 201);
             }
             case 'update': {
                 if (!filename || !content) {
                     return c.json({ success: false, error: 'Filename and content are required for update operation' }, 400);
                 }
-                const currentFilename = resolveFilename(filename, title || 'knowledge-entry');
-                const currentPath = path.join(knowledgePath, currentFilename);
-                let existingDocument = null;
                 try {
-                    existingDocument = await readKnowledgeDocument(knowledgePath, currentFilename);
-                }
-                catch (error) {
-                    if (error.code === 'ENOENT') {
-                        return c.json({ success: false, error: 'Knowledge document not found' }, 404);
-                    }
-                    throw error;
-                }
-                if (!existingDocument) {
-                    return c.json({ success: false, error: 'Knowledge document not found' }, 404);
+                    const updated = await updateKnowledge({ filename, content, title, summary, metadata });
+                    return c.json({
+                        success: true,
+                        data: updated,
+                        message: `Updated knowledge document ${updated.filename}`
+                    });
                 }
-                const nextTitle = title || existingDocument.title;
-                const shouldRename = Boolean(title && slugify(title) !== slugify(existingDocument.title));
-                const nextFilename = shouldRename ? resolveFilename(undefined, nextTitle) : currentFilename;
-                const nextPath = path.join(knowledgePath, nextFilename);
-                if (nextFilename !== currentFilename) {
-                    try {
-                        await fs.access(nextPath);
-                        return c.json({ success: false, error: 'A document with the requested title already exists' }, 409);
+                catch (err) {
+                    if (err.message?.includes('not found')) {
+                        return c.json({ success: false, error: err.message }, 404);
                     }
-                    catch {
-                        // OK to rename
+                    if (err.message?.includes('already exists')) {
+                        return c.json({ success: false, error: err.message }, 409);
                     }
+                    throw err;
                 }
-                const mergedMetadata = normalizeKnowledgeMetadata({
-                    ...existingDocument.metadata,
-                    ...metadata,
-                    summary,
-                    updated: new Date().toISOString().split('T')[0]
-                });
-                const markdown = matter.stringify(content, mergedMetadata);
-                await fs.writeFile(nextPath, markdown, 'utf-8');
-                if (nextFilename !== currentFilename) {
-                    await fs.unlink(currentPath);
-                }
-                const updated = {
-                    filename: nextFilename,
-                    title: nextTitle,
-                    metadata: mergedMetadata,
-                    content
-                };
-                return c.json({
-                    success: true,
-                    data: updated,
-                    message: `Updated knowledge document ${nextFilename}`
-                });
             }
             case 'preview_update': {
                 if (!filename) {
                     return c.json({ success: false, error: 'Filename is required for preview update operation' }, 400);
                 }
-                const currentFilename = resolveFilename(filename, filename);
-                const existingDocument = await readKnowledgeDocument(knowledgePath, currentFilename);
+                const existingDocument = await getKnowledge(filename);
                 if (!existingDocument) {
                     return c.json({ success: false, error: 'Knowledge document not found' }, 404);
                 }
@@ -331,14 +332,14 @@ async function executeKnowledgeTool(c, args) {
                 return c.json({
                     success: true,
                     data: {
-                        filename: currentFilename,
+                        filename: existingDocument.filename,
                         title: proposedTitle,
                         metadata: previewMetadata,
                         originalContent: existingDocument.content,
                         proposedContent: content || existingDocument.content,
                         summary: summary || null
                     },
-                    message: `Prepared preview for ${currentFilename}`
+                    message: `Prepared preview for ${existingDocument.filename}`
                 });
             }
             default:
@@ -350,7 +351,7 @@ 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
+// Events tool is READ-ONLY - uses core listEvents function
 async function executeEventsTool(c, args) {
     const { operation, limit = 20, kind } = args;
     if (operation !== 'list') {
@@ -360,66 +361,13 @@ async function executeEventsTool(c, args) {
         }, 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
-        }));
+        const events = await listEvents({ limit, kind });
         return c.json({
             success: true,
-            data: formattedEvents,
+            data: events,
             message: kind
-                ? `Found ${formattedEvents.length} recent '${kind}' events`
-                : `Found ${formattedEvents.length} recent events`
+                ? `Found ${events.length} recent '${kind}' events`
+                : `Found ${events.length} recent events`
         });
     }
     catch (error) {
@@ -427,319 +375,59 @@ async function executeEventsTool(c, args) {
         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) {
+// Generic context tool executor - uses core context functions
+async function executeContextTool(c, contextType, args) {
     const { operation, content, old_text, new_text } = args;
+    const typeName = contextType.charAt(0).toUpperCase() + contextType.slice(1);
     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');
+                const doc = await getContext(contextType);
+                const message = doc.raw
+                    ? `Retrieved ${contextType} context`
+                    : `${typeName} context document does not exist yet. You can create it with an update operation.`;
                 return c.json({
                     success: true,
-                    message: 'Updated architecture context document'
+                    data: doc,
+                    message
                 });
             }
-            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);
-    }
-}
-// Role context tool - read/write the role definition document
-async function executeRoleContextTool(c, args) {
-    const { operation, content, old_text, new_text } = args;
-    try {
-        const contextPath = getContextPath();
-        const filePath = path.join(contextPath, 'role.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 role context'
-                    });
-                }
-                catch (err) {
-                    if (err.code === 'ENOENT') {
-                        return c.json({
-                            success: true,
-                            data: { content: '', frontmatter: {}, raw: '' },
-                            message: 'Role 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');
+                await appendContext(contextType, content);
                 return c.json({
                     success: true,
-                    message: 'Appended content to role context document'
+                    message: `Appended content to ${contextType} 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: 'Role 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)) {
+                const result = await replaceContextSection(contextType, old_text, new_text);
+                if (!result.success) {
                     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/role'
-                    }, 400);
+                        error: result.error,
+                        fallback_markdown: result.fallbackMarkdown,
+                        suggestion: result.suggestion
+                    }, result.error?.includes('does not exist') ? 404 : 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 role context document'
+                    message: `Replaced section in ${contextType} 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');
+                await updateContext(contextType, content);
                 return c.json({
                     success: true,
-                    message: 'Updated role context document'
+                    message: `Updated ${contextType} context document`
                 });
             }
             default:
@@ -747,151 +435,19 @@ async function executeRoleContextTool(c, args) {
         }
     }
     catch (error) {
-        console.error('Error executing role context tool:', error);
-        return c.json({ success: false, error: error.message || 'Role context tool execution failed' }, 500);
-    }
-}
-function getContextPath() {
-    return path.join(resolveGaitPath(), 'context');
-}
-function getKnowledgePath() {
-    return path.join(resolveGaitPath(), 'context', 'knowledge');
-}
-function slugify(value) {
-    const slug = value
-        .toLowerCase()
-        .replace(/[^a-z0-9\s-]/g, '')
-        .replace(/\s+/g, '-')
-        .replace(/--+/g, '-')
-        .replace(/^-|-$/g, '');
-    return slug || 'knowledge-entry';
-}
-function resolveFilename(input, fallbackTitle) {
-    if (input && input.trim().length > 0) {
-        const trimmed = path.basename(input.trim());
-        if (trimmed.endsWith('.md')) {
-            return trimmed;
-        }
-        return `${slugify(trimmed)}.md`;
-    }
-    const fallback = fallbackTitle && fallbackTitle.trim().length > 0
-        ? path.basename(fallbackTitle.trim())
-        : 'knowledge-entry';
-    return `${slugify(fallback)}.md`;
-}
-function extractTitle(content, fallback) {
-    const headingMatch = content.match(/^#\s+(.+)$/m);
-    if (headingMatch && headingMatch[1]) {
-        return headingMatch[1].trim();
+        console.error(`Error executing ${contextType} context tool:`, error);
+        return c.json({ success: false, error: error.message || `${typeName} context tool execution failed` }, 500);
     }
-    const baseName = fallback.replace('.md', '').replace(/[_-]/g, ' ');
-    return baseName.replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.slice(1).toLowerCase());
 }
-async function readKnowledgeDocument(basePath, filename) {
-    const actualFilename = resolveFilename(filename, filename);
-    const filePath = path.join(basePath, actualFilename);
-    const [raw, stats] = await Promise.all([
-        fs.readFile(filePath, 'utf-8'),
-        fs.stat(filePath)
-    ]);
-    const { data, content } = matter(raw);
-    const metadata = normalizeKnowledgeMetadata(data);
-    // Use file mtime for updated timestamp instead of frontmatter
-    metadata.updated = stats.mtime.toISOString();
-    const title = extractTitle(content, actualFilename);
-    return {
-        filename: actualFilename,
-        title,
-        metadata,
-        content
-    };
-}
-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;
+// Wrapper functions for each context type (maintain API compatibility)
+async function executeProjectContextTool(c, args) {
+    return executeContextTool(c, 'project', args);
 }
-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 executeArchitectureContextTool(c, args) {
+    return executeContextTool(c, 'architecture', args);
 }
-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 {
-            return await readKnowledgeDocument(basePath, file);
-        }
-        catch (error) {
-            console.error(`Failed to read knowledge document ${file}:`, error);
-            return null;
-        }
-    }));
-    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
-    }));
+async function executeRoleContextTool(c, args) {
+    return executeContextTool(c, 'role', args);
 }
 /**
  * GET /api/v1/mcp/raw-config