@lovelybunch/api 1.0.53 → 1.0.55

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

@@ -1,8 +1,9 @@
 import { homedir } from 'os';
-import { join } from 'path';
-import { existsSync, readFileSync } from 'fs';
+import { join, resolve as pathResolve, basename } from 'path';
+import { existsSync, readFileSync, promises as fs } from 'fs';
 import { fileURLToPath } from 'url';
-import { proposalsTool, listProposalsTool, validateProposalData } from '@lovelybunch/mcp';
+import { proposalsTool, listProposalsTool, validateProposalData, knowledgeTool, normalizeKnowledgeMetadata } from '@lovelybunch/mcp';
+import matter from 'gray-matter';
 import { FileStorageAdapter } from '../../../../lib/storage/file-storage.js';
 import { getAuthorInfo } from '../../../../lib/user-preferences.js';
 // Function to get global config API key as fallback
@@ -33,7 +34,7 @@ function getGlobalApiKey(provider) {
 }
 export async function POST(c) {
     try {
-        const { message: userMessage, history, model, context, contextContent, agentPersona, systemPrompt: systemOverride, maxTokens, enableTools } = await c.req.json();
+        const { message: userMessage, history, model, context, contextContent, agentPersona, systemPrompt: systemOverride, maxTokens, enableTools, attachedContextFiles } = await c.req.json();
         if (!userMessage) {
             return c.json({ error: "Message is required" }, 400);
         }
@@ -58,8 +59,20 @@ export async function POST(c) {
             {
                 type: "function",
                 function: proposalsTool
+            },
+            {
+                type: "function",
+                function: knowledgeTool
             }
         ] : null;
+        const contextMessages = Array.isArray(attachedContextFiles)
+            ? attachedContextFiles
+                .filter((file) => file && typeof file.content === 'string' && file.content.trim().length > 0)
+                .map((file) => ({
+                role: 'system',
+                content: `Context from ${file.name || file.path || 'reference'}:\n${file.content}`
+            }))
+            : [];
         // Compose the message list: system + history (preferred) or single message
         let messagesPayload;
         if (Array.isArray(history) && history.length > 0) {
@@ -67,12 +80,14 @@ export async function POST(c) {
             const sanitized = history.filter(m => m && (m.role === 'user' || m.role === 'assistant') && typeof m.content === 'string');
             messagesPayload = [
                 { role: 'system', content: systemPrompt },
+                ...contextMessages,
                 ...sanitized,
             ];
         }
         else {
             messagesPayload = [
                 { role: 'system', content: systemPrompt },
+                ...contextMessages,
                 { role: 'user', content: userMessage },
             ];
         }
@@ -181,6 +196,9 @@ async function executeToolCalls(toolCalls) {
             else if (functionName === 'list_proposals') {
                 result = await executeListProposalsToolDirect(functionArgs, storage);
             }
+            else if (functionName === 'knowledge_documents') {
+                result = await executeKnowledgeToolDirect(functionArgs);
+            }
             results.push({
                 tool_call_id: toolCall.id,
                 content: JSON.stringify({
@@ -382,6 +400,229 @@ async function executeListProposalsToolDirect(args, storage) {
         return { success: false, error: error.message || 'Failed to list proposals' };
     }
 }
+async function executeKnowledgeToolDirect(args) {
+    const { operation, filename, title, content, metadata, summary } = args;
+    try {
+        const knowledgePath = getKnowledgeBasePath();
+        await fs.mkdir(knowledgePath, { recursive: true });
+        switch (operation) {
+            case 'list': {
+                const documents = await listKnowledgeDocuments(knowledgePath);
+                return {
+                    success: true,
+                    data: documents,
+                    message: `Found ${documents.length} knowledge documents`
+                };
+            }
+            case 'get': {
+                if (!filename) {
+                    return { success: false, error: 'Filename is required for get operation' };
+                }
+                const document = await readKnowledgeDocument(knowledgePath, filename);
+                if (!document) {
+                    return { success: false, error: 'Knowledge document not found' };
+                }
+                return {
+                    success: true,
+                    data: document,
+                    message: `Loaded knowledge document ${document.filename}`
+                };
+            }
+            case 'create': {
+                if (!title || !content) {
+                    return { success: false, error: 'Title and content are required for create operation' };
+                }
+                const targetFilename = resolveKnowledgeFilename(filename, title);
+                const filePath = join(knowledgePath, targetFilename);
+                try {
+                    await fs.access(filePath);
+                    return { success: false, error: 'A knowledge document with this filename already exists' };
+                }
+                catch {
+                    // File does not exist
+                }
+                const normalizedMetadata = normalizeKnowledgeMetadata({
+                    version: '1.0',
+                    summary,
+                    ...metadata
+                });
+                const markdown = matter.stringify(content, normalizedMetadata);
+                await fs.writeFile(filePath, markdown, 'utf-8');
+                return {
+                    success: true,
+                    data: {
+                        filename: targetFilename,
+                        title,
+                        metadata: normalizedMetadata,
+                        content
+                    },
+                    message: `Created knowledge document ${targetFilename}`
+                };
+            }
+            case 'update': {
+                if (!filename || !content) {
+                    return { success: false, error: 'Filename and content are required for update operation' };
+                }
+                const currentFilename = resolveKnowledgeFilename(filename, title || 'knowledge-entry');
+                const currentPath = join(knowledgePath, currentFilename);
+                let existingDocument = null;
+                try {
+                    existingDocument = await readKnowledgeDocument(knowledgePath, currentFilename);
+                }
+                catch (error) {
+                    if (error.code === 'ENOENT') {
+                        return { success: false, error: 'Knowledge document not found' };
+                    }
+                    throw error;
+                }
+                if (!existingDocument) {
+                    return { success: false, error: 'Knowledge document not found' };
+                }
+                const nextTitle = title || existingDocument.title;
+                const shouldRename = Boolean(title && slugify(title) !== slugify(existingDocument.title));
+                const nextFilename = shouldRename ? resolveKnowledgeFilename(undefined, nextTitle) : currentFilename;
+                const nextPath = join(knowledgePath, nextFilename);
+                if (nextFilename !== currentFilename) {
+                    try {
+                        await fs.access(nextPath);
+                        return { success: false, error: 'A document with the requested title already exists' };
+                    }
+                    catch {
+                        // Safe to rename
+                    }
+                }
+                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);
+                }
+                return {
+                    success: true,
+                    data: {
+                        filename: nextFilename,
+                        title: nextTitle,
+                        metadata: mergedMetadata,
+                        content
+                    },
+                    message: `Updated knowledge document ${nextFilename}`
+                };
+            }
+            case 'preview_update': {
+                if (!filename) {
+                    return { success: false, error: 'Filename is required for preview update operation' };
+                }
+                const currentFilename = resolveKnowledgeFilename(filename, filename);
+                const existingDocument = await readKnowledgeDocument(knowledgePath, currentFilename);
+                if (!existingDocument) {
+                    return { success: false, error: 'Knowledge document not found' };
+                }
+                const proposedTitle = title || existingDocument.title;
+                const previewMetadata = normalizeKnowledgeMetadata({
+                    ...existingDocument.metadata,
+                    ...metadata,
+                    summary
+                });
+                return {
+                    success: true,
+                    data: {
+                        filename: currentFilename,
+                        title: proposedTitle,
+                        metadata: previewMetadata,
+                        originalContent: existingDocument.content,
+                        proposedContent: content || existingDocument.content,
+                        summary: summary || null
+                    },
+                    message: `Prepared preview for ${currentFilename}`
+                };
+            }
+            default:
+                return { success: false, error: `Unknown operation: ${operation}` };
+        }
+    }
+    catch (error) {
+        console.error('Error executing knowledge tool:', error);
+        return { success: false, error: error.message || 'Knowledge tool execution failed' };
+    }
+}
+function getKnowledgeBasePath() {
+    let basePath;
+    if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
+        basePath = process.env.GAIT_DEV_ROOT;
+    }
+    else if (process.env.GAIT_DATA_PATH) {
+        basePath = pathResolve(process.env.GAIT_DATA_PATH, '.nut');
+    }
+    else {
+        basePath = pathResolve(process.cwd(), '.nut');
+    }
+    return join(basePath, '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 resolveKnowledgeFilename(input, fallbackTitle) {
+    if (input && input.trim().length > 0) {
+        const trimmed = basename(input.trim());
+        if (trimmed.endsWith('.md')) {
+            return trimmed;
+        }
+        return `${slugify(trimmed)}.md`;
+    }
+    const fallback = fallbackTitle && fallbackTitle.trim().length > 0
+        ? basename(fallbackTitle.trim())
+        : 'knowledge-entry';
+    return `${slugify(fallback)}.md`;
+}
+function extractKnowledgeTitle(content, fallback) {
+    const headingMatch = content.match(/^#\s+(.+)$/m);
+    if (headingMatch && headingMatch[1]) {
+        return headingMatch[1].trim();
+    }
+    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 = resolveKnowledgeFilename(filename, filename);
+    const filePath = join(basePath, actualFilename);
+    const raw = await fs.readFile(filePath, 'utf-8');
+    const { data, content } = matter(raw);
+    const metadata = normalizeKnowledgeMetadata(data);
+    const title = extractKnowledgeTitle(content, actualFilename);
+    return {
+        filename: actualFilename,
+        title,
+        metadata,
+        content
+    };
+}
+async function listKnowledgeDocuments(basePath) {
+    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;
+        }
+    }));
+    return documents
+        .filter((doc) => doc !== null)
+        .sort((a, b) => a.filename.localeCompare(b.filename));
+}
 function readSharedPrompt(name) {
     // Try multiple candidate paths depending on cwd when running via Turbo
     const moduleDir = fileURLToPath(new URL('.', import.meta.url));

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

@@ -1,7 +1,8 @@
 import { Hono } from 'hono';
 import { promises as fs } from 'fs';
 import path from 'path';
-import { proposalsTool, listProposalsTool, validateProposalData } from '@lovelybunch/mcp';
+import matter from 'gray-matter';
+import { proposalsTool, listProposalsTool, validateProposalData, knowledgeTool, normalizeKnowledgeMetadata } from '@lovelybunch/mcp';
 import { FileStorageAdapter } from '../../../../lib/storage/file-storage.js';
 import { getAuthorInfo } from '../../../../lib/user-preferences.js';
 const app = new Hono();
@@ -43,7 +44,8 @@ app.get('/', async (c) => {
         // Add built-in tools (include full JSON schema for parameters)
         const builtInTools = {
             change_proposals: proposalsTool,
-            list_proposals: listProposalsTool
+            list_proposals: listProposalsTool,
+            knowledge_documents: knowledgeTool
         };
         return c.json({
             success: true,
@@ -66,7 +68,8 @@ app.get('/schema', async (c) => {
         const schema = {
             tools: {
                 change_proposals: proposalsTool,
-                list_proposals: listProposalsTool
+                list_proposals: listProposalsTool,
+                knowledge_documents: knowledgeTool
             }
         };
         return c.json(schema);
@@ -92,6 +95,9 @@ app.post('/execute', async (c) => {
         if (tool === 'list_proposals') {
             return await executeListProposalsTool(c, args);
         }
+        if (tool === 'knowledge_documents') {
+            return await executeKnowledgeTool(c, args);
+        }
         return c.json({ success: false, error: 'Unknown tool' }, 400);
     }
     catch (error) {
@@ -295,6 +301,218 @@ async function executeListProposalsTool(c, args) {
         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;
+    try {
+        const knowledgePath = getKnowledgePath();
+        await fs.mkdir(knowledgePath, { recursive: true });
+        switch (operation) {
+            case 'list': {
+                const documents = await listKnowledgeDocuments(knowledgePath);
+                return c.json({
+                    success: true,
+                    data: documents,
+                    message: `Found ${documents.length} knowledge documents`
+                });
+            }
+            case 'get': {
+                if (!filename) {
+                    return c.json({ success: false, error: 'Filename is required for get operation' }, 400);
+                }
+                const document = await readKnowledgeDocument(knowledgePath, filename);
+                if (!document) {
+                    return c.json({ success: false, error: 'Knowledge document not found' }, 404);
+                }
+                return c.json({ success: true, data: document, message: `Loaded knowledge document ${document.filename}` });
+            }
+            case 'create': {
+                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);
+                }
+                catch {
+                    // File does not exist, safe to create
+                }
+                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 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 {
+                        // OK to rename
+                    }
+                }
+                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);
+                if (!existingDocument) {
+                    return c.json({ success: false, error: 'Knowledge document not found' }, 404);
+                }
+                const proposedTitle = title || existingDocument.title;
+                const previewMetadata = normalizeKnowledgeMetadata({
+                    ...existingDocument.metadata,
+                    ...metadata,
+                    summary
+                });
+                return c.json({
+                    success: true,
+                    data: {
+                        filename: currentFilename,
+                        title: proposedTitle,
+                        metadata: previewMetadata,
+                        originalContent: existingDocument.content,
+                        proposedContent: content || existingDocument.content,
+                        summary: summary || null
+                    },
+                    message: `Prepared preview for ${currentFilename}`
+                });
+            }
+            default:
+                return c.json({ success: false, error: `Unknown operation: ${operation}` }, 400);
+        }
+    }
+    catch (error) {
+        console.error('Error executing knowledge tool:', error);
+        return c.json({ success: false, error: error.message || 'Knowledge tool execution failed' }, 500);
+    }
+}
+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();
+    }
+    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 = await fs.readFile(filePath, 'utf-8');
+    const { data, content } = matter(raw);
+    const metadata = normalizeKnowledgeMetadata(data);
+    const title = extractTitle(content, actualFilename);
+    return {
+        filename: actualFilename,
+        title,
+        metadata,
+        content
+    };
+}
+async function listKnowledgeDocuments(basePath) {
+    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;
+        }
+        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));
+}
 /**
  * GET /api/v1/mcp/raw-config
  * Returns the raw MCP configuration for editing in settings UI

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovelybunch/api",
-  "version": "1.0.53",
+  "version": "1.0.55",
   "type": "module",
   "main": "dist/server-with-static.js",
   "exports": {
@@ -32,9 +32,9 @@
   "dependencies": {
     "@hono/node-server": "^1.13.7",
     "@hono/node-ws": "^1.0.6",
-    "@lovelybunch/core": "^1.0.53",
-    "@lovelybunch/mcp": "^1.0.53",
-    "@lovelybunch/types": "^1.0.53",
+    "@lovelybunch/core": "^1.0.55",
+    "@lovelybunch/mcp": "^1.0.55",
+    "@lovelybunch/types": "^1.0.55",
     "dotenv": "^17.2.1",
     "fuse.js": "^7.0.0",
     "gray-matter": "^4.0.3",