@lovelybunch/api 1.0.76-alpha.0 → 1.0.76-alpha.10

package/dist/routes/api/v1/context/memory/route.js

@@ -0,0 +1,163 @@
+import { Hono } from 'hono';
+import { promises as fs } from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+import { findGaitDirectory } from '../../../../../lib/gait-path.js';
+import { getLogger, ContextKinds } from '@lovelybunch/core/logging';
+import { requireAuth } from '../../../../../middleware/auth.js';
+function generateSummary(content, maxLines = 3, maxChars = 200) {
+    const cleanContent = content
+        .replace(/^#+\s+/gm, '')
+        .replace(/[*_`]/g, '')
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+        .trim();
+    const lines = cleanContent.split('\n').filter(line => line.trim().length > 0);
+    const summary = lines.slice(0, maxLines).join(' ');
+    return summary.length > maxChars
+        ? summary.substring(0, maxChars) + '...'
+        : summary;
+}
+const app = new Hono();
+async function getMemoryPath() {
+    const gaitDir = await findGaitDirectory();
+    if (!gaitDir)
+        return null;
+    return path.join(gaitDir, 'context');
+}
+/**
+ * GET /api/v1/context/memory
+ */
+app.get('/', async (c) => {
+    try {
+        const memoryPath = await getMemoryPath();
+        if (!memoryPath) {
+            return c.json({ success: false, error: 'GAIT directory not found' }, 404);
+        }
+        await fs.mkdir(memoryPath, { recursive: true });
+        const filePath = path.join(memoryPath, 'memory.md');
+        try {
+            const fileContent = await fs.readFile(filePath, 'utf-8');
+            const { data, content } = matter(fileContent);
+            const title = content.match(/^#\s+(.+)$/m)?.[1] || 'Memory';
+            const document = {
+                filename: 'memory.md',
+                metadata: {
+                    ...data,
+                    updated: data.updated || new Date().toISOString().split('T')[0],
+                    type: 'memory',
+                    category: 'context',
+                    tags: data.tags || []
+                },
+                content,
+                title
+            };
+            return c.json({ success: true, document });
+        }
+        catch (fileError) {
+            const defaultContent = `# Memory
+
+This document stores persistent memory and learned context.
+
+## Key Decisions
+
+Important decisions made during the project.
+
+## Lessons Learned
+
+Insights and patterns discovered over time.
+
+## Preferences
+
+Remembered preferences and conventions.
+`;
+            const document = {
+                filename: 'memory.md',
+                metadata: {
+                    version: '1.0',
+                    updated: new Date().toISOString().split('T')[0],
+                    type: 'memory',
+                    category: 'context',
+                    tags: []
+                },
+                content: defaultContent,
+                title: 'Memory'
+            };
+            return c.json({ success: true, document });
+        }
+    }
+    catch (error) {
+        console.error('Error loading memory document:', error);
+        return c.json({ success: false, error: 'Failed to load memory document' }, 500);
+    }
+});
+/**
+ * PUT /api/v1/context/memory
+ */
+app.put('/', async (c) => {
+    try {
+        const body = await c.req.json();
+        if (!body.content) {
+            return c.json({ success: false, error: 'Content is required' }, 400);
+        }
+        const memoryPath = await getMemoryPath();
+        if (!memoryPath) {
+            return c.json({ success: false, error: 'GAIT directory not found' }, 404);
+        }
+        await fs.mkdir(memoryPath, { recursive: true });
+        const filePath = path.join(memoryPath, 'memory.md');
+        let currentData = {};
+        try {
+            const currentContent = await fs.readFile(filePath, 'utf-8');
+            const { data } = matter(currentContent);
+            currentData = data;
+        }
+        catch {
+            // File doesn't exist, use defaults
+        }
+        const updatedMetadata = {
+            ...currentData,
+            ...body.metadata,
+            updated: new Date().toISOString().split('T')[0],
+            type: 'memory',
+            category: 'context',
+            version: currentData.version || '1.0'
+        };
+        const fileContent = matter.stringify(body.content, updatedMetadata);
+        await fs.writeFile(filePath, fileContent, 'utf-8');
+        const title = body.title ||
+            body.content.match(/^#\s+(.+)$/m)?.[1] ||
+            'Memory';
+        try {
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : "human:unknown";
+            const logger = getLogger();
+            logger.log({
+                kind: ContextKinds.MEMORY_UPDATE,
+                actor,
+                subject: `context:memory.md`,
+                tags: ["context", "memory"],
+                payload: {
+                    title,
+                    summary: generateSummary(body.content),
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging memory update:', logError);
+        }
+        return c.json({
+            success: true,
+            document: {
+                filename: 'memory.md',
+                title,
+                metadata: updatedMetadata,
+                content: body.content
+            }
+        });
+    }
+    catch (error) {
+        console.error('Error updating memory document:', error);
+        return c.json({ success: false, error: 'Failed to update memory document' }, 500);
+    }
+});
+export default app;

package/dist/routes/api/v1/context/team/route.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default app;

package/dist/routes/api/v1/context/team/route.js

@@ -0,0 +1,159 @@
+import { Hono } from 'hono';
+import { promises as fs } from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+import { findGaitDirectory } from '../../../../../lib/gait-path.js';
+import { getLogger, ContextKinds } from '@lovelybunch/core/logging';
+import { requireAuth } from '../../../../../middleware/auth.js';
+function generateSummary(content, maxLines = 3, maxChars = 200) {
+    const cleanContent = content
+        .replace(/^#+\s+/gm, '')
+        .replace(/[*_`]/g, '')
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+        .trim();
+    const lines = cleanContent.split('\n').filter(line => line.trim().length > 0);
+    const summary = lines.slice(0, maxLines).join(' ');
+    return summary.length > maxChars
+        ? summary.substring(0, maxChars) + '...'
+        : summary;
+}
+const app = new Hono();
+async function getTeamPath() {
+    const gaitDir = await findGaitDirectory();
+    if (!gaitDir)
+        return null;
+    return path.join(gaitDir, 'context');
+}
+/**
+ * GET /api/v1/context/team
+ */
+app.get('/', async (c) => {
+    try {
+        const teamPath = await getTeamPath();
+        if (!teamPath) {
+            return c.json({ success: false, error: 'GAIT directory not found' }, 404);
+        }
+        await fs.mkdir(teamPath, { recursive: true });
+        const filePath = path.join(teamPath, 'team.md');
+        try {
+            const fileContent = await fs.readFile(filePath, 'utf-8');
+            const { data, content } = matter(fileContent);
+            const title = content.match(/^#\s+(.+)$/m)?.[1] || 'Team';
+            const document = {
+                filename: 'team.md',
+                metadata: {
+                    ...data,
+                    updated: data.updated || new Date().toISOString().split('T')[0],
+                    type: 'team',
+                    category: 'context',
+                    tags: data.tags || []
+                },
+                content,
+                title
+            };
+            return c.json({ success: true, document });
+        }
+        catch (fileError) {
+            const defaultContent = `# Team
+
+This document describes the team structure and members.
+
+## Team Members
+
+List team members, their roles, and responsibilities.
+
+## Communication
+
+Team communication channels and conventions.
+`;
+            const document = {
+                filename: 'team.md',
+                metadata: {
+                    version: '1.0',
+                    updated: new Date().toISOString().split('T')[0],
+                    type: 'team',
+                    category: 'context',
+                    tags: []
+                },
+                content: defaultContent,
+                title: 'Team'
+            };
+            return c.json({ success: true, document });
+        }
+    }
+    catch (error) {
+        console.error('Error loading team document:', error);
+        return c.json({ success: false, error: 'Failed to load team document' }, 500);
+    }
+});
+/**
+ * PUT /api/v1/context/team
+ */
+app.put('/', async (c) => {
+    try {
+        const body = await c.req.json();
+        if (!body.content) {
+            return c.json({ success: false, error: 'Content is required' }, 400);
+        }
+        const teamPath = await getTeamPath();
+        if (!teamPath) {
+            return c.json({ success: false, error: 'GAIT directory not found' }, 404);
+        }
+        await fs.mkdir(teamPath, { recursive: true });
+        const filePath = path.join(teamPath, 'team.md');
+        let currentData = {};
+        try {
+            const currentContent = await fs.readFile(filePath, 'utf-8');
+            const { data } = matter(currentContent);
+            currentData = data;
+        }
+        catch {
+            // File doesn't exist, use defaults
+        }
+        const updatedMetadata = {
+            ...currentData,
+            ...body.metadata,
+            updated: new Date().toISOString().split('T')[0],
+            type: 'team',
+            category: 'context',
+            version: currentData.version || '1.0'
+        };
+        const fileContent = matter.stringify(body.content, updatedMetadata);
+        await fs.writeFile(filePath, fileContent, 'utf-8');
+        const title = body.title ||
+            body.content.match(/^#\s+(.+)$/m)?.[1] ||
+            'Team';
+        try {
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : "human:unknown";
+            const logger = getLogger();
+            logger.log({
+                kind: ContextKinds.TEAM_UPDATE,
+                actor,
+                subject: `context:team.md`,
+                tags: ["context", "team"],
+                payload: {
+                    title,
+                    summary: generateSummary(body.content),
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging team update:', logError);
+        }
+        return c.json({
+            success: true,
+            document: {
+                filename: 'team.md',
+                title,
+                metadata: updatedMetadata,
+                content: body.content
+            }
+        });
+    }
+    catch (error) {
+        console.error('Error updating team document:', error);
+        return c.json({ success: false, error: 'Failed to update team document' }, 500);
+    }
+});
+export default app;

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

@@ -3,6 +3,7 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import matter from 'gray-matter';
 import filenameRoute from './[filename]/index.js';
+import { listKnowledge } from '@lovelybunch/core';
 import { getLogger, KnowledgeKinds } from '@lovelybunch/core/logging';
 import { requireAuth } from '../../../../middleware/auth.js';
 // Helper function to generate a simple summary from content
@@ -50,43 +51,36 @@ function generateFilename(title) {
 }
 /**
  * GET /api/v1/knowledge
- * Load all knowledge documents
+ * Load all knowledge documents.
+ *
+ * Query params:
+ *   q      - search/filter query (fuzzy match on title, content, tags, category)
+ *   full   - set to "true" to include the full markdown content (default: summary only)
+ *   limit  - max results per page (1-100)
+ *   offset - number of results to skip (for pagination, default: 0)
  */
 app.get('/', async (c) => {
     try {
-        const knowledgePath = getKnowledgePath();
-        // Ensure directory exists
-        await fs.mkdir(knowledgePath, { recursive: true });
-        const files = await fs.readdir(knowledgePath);
-        const documents = await Promise.all(files
-            .filter(file => file.endsWith('.md'))
-            .map(async (file) => {
-            const filePath = path.join(knowledgePath, file);
-            const [fileContent, stats] = await Promise.all([
-                fs.readFile(filePath, 'utf-8'),
-                fs.stat(filePath)
-            ]);
-            const { data, content } = matter(fileContent);
-            // Extract title from metadata, first heading, or use filename
-            const title = data.title ||
-                content.match(/^#\s+(.+)$/m)?.[1] ||
-                file.replace('.md', '').replace(/[_-]/g, ' ').replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase());
-            return {
-                filename: file,
-                metadata: {
-                    ...data,
-                    title, // Include title in metadata
-                    updated: stats.mtime.toISOString(),
-                    tags: data.tags || [],
-                    sources: data.sources || []
-                },
-                content,
-                title
-            };
-        }));
+        const query = c.req.query('q') || undefined;
+        const full = c.req.query('full') === 'true';
+        const limitParam = c.req.query('limit');
+        const limit = limitParam ? Math.min(Math.max(1, parseInt(limitParam, 10) || 20), 100) : undefined;
+        const offsetParam = c.req.query('offset');
+        const offset = offsetParam ? Math.max(0, parseInt(offsetParam, 10) || 0) : 0;
+        let documents = await listKnowledge({ query, full });
+        const totalCount = documents.length;
+        if (limit !== undefined || offset > 0) {
+            documents = documents.slice(offset, limit !== undefined ? offset + limit : undefined);
+        }
         return c.json({
             success: true,
-            documents: documents.sort((a, b) => a.filename.localeCompare(b.filename))
+            query,
+            full,
+            totalCount,
+            count: documents.length,
+            ...(limit !== undefined && { limit }),
+            offset,
+            documents,
         });
     }
     catch (error) {

package/dist/routes/api/v1/mail/route.d.ts

@@ -116,7 +116,7 @@ export declare function setMailStatusHandler(c: Context): Promise<(Response & im
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;
     error: any;
-}, 500 | 404, "json">)>;
+}, 404 | 500, "json">)>;
 /**
  * POST /api/v1/mail/:id/reply
  * Reply to an email
@@ -154,7 +154,7 @@ export declare function replyMailHandler(c: Context): Promise<(Response & import
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;
     error: any;
-}, 500 | 404, "json">)>;
+}, 404 | 500, "json">)>;
 /**
  * POST /api/v1/mail/send
  * Send an email (coming soon)
@@ -217,7 +217,7 @@ export declare function setMailActionHandler(c: Context): Promise<(Response & im
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;
     error: any;
-}, 500 | 404, "json">)>;
+}, 404 | 500, "json">)>;
 /**
  * GET /api/v1/mail/:id/processing
  * Get processing status and log tail for an email

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

@@ -3,10 +3,36 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import { ZodError } from 'zod';
 import { listTasks, getTask, createTask, updateTask, deleteTask, getContext, updateContext, appendContext, replaceContextSection, listKnowledge, getKnowledge, createKnowledge, updateKnowledge, listEvents, } from '@lovelybunch/core';
-import { tasksFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool, roleContextTool, resourcesTool } from '@lovelybunch/mcp';
+import { tasksFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool, roleContextTool, resourcesTool, listConnectorsTool, connectorRequestTool, resolveConnectorUrl } from '@lovelybunch/mcp';
 import { FileStorageAdapter } from '../../../../lib/storage/file-storage.js';
+import { homedir } from 'os';
+import { readFileSync, existsSync } from 'fs';
 const app = new Hono();
 const storage = new FileStorageAdapter();
+const COCONUT_HOST = 'https://app.coconut.dev';
+function getCallbackToken() {
+    try {
+        const platform = process.platform;
+        let configDir;
+        if (platform === 'win32') {
+            configDir = path.join(process.env.APPDATA || homedir(), 'coconuts');
+        }
+        else if (platform === 'darwin') {
+            configDir = path.join(homedir(), 'Library', 'Application Support', 'coconuts');
+        }
+        else {
+            configDir = path.join(process.env.XDG_CONFIG_HOME || path.join(homedir(), '.config'), 'coconuts');
+        }
+        const configFile = path.join(configDir, 'config.json');
+        if (!existsSync(configFile))
+            return null;
+        const config = JSON.parse(readFileSync(configFile, 'utf-8'));
+        return config.apiKeys?.callbackToken || null;
+    }
+    catch {
+        return null;
+    }
+}
 function resolveGaitPath() {
     let basePath;
     if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
@@ -86,7 +112,9 @@ app.get('/', async (c) => {
             project_context: projectContextTool,
             architecture_context: architectureContextTool,
             role_context: roleContextTool,
-            resources: resourcesTool
+            resources: resourcesTool,
+            list_connectors: listConnectorsTool,
+            connector_request: connectorRequestTool
         };
         return c.json({
             success: true,
@@ -115,7 +143,9 @@ app.get('/schema', async (c) => {
                 project_context: projectContextTool,
                 architecture_context: architectureContextTool,
                 role_context: roleContextTool,
-                resources: resourcesTool
+                resources: resourcesTool,
+                list_connectors: listConnectorsTool,
+                connector_request: connectorRequestTool
             }
         };
         return c.json(schema);
@@ -156,6 +186,12 @@ app.post('/execute', async (c) => {
         if (tool === 'resources') {
             return await executeResourcesTool(c, args);
         }
+        if (tool === 'list_connectors') {
+            return await executeListConnectorsTool(c);
+        }
+        if (tool === 'connector_request') {
+            return await executeConnectorRequestTool(c, args);
+        }
         return c.json({ success: false, error: 'Unknown tool' }, 400);
     }
     catch (error) {
@@ -260,10 +296,11 @@ async function executeKnowledgeTool(c, args) {
         switch (operation) {
             case 'list': {
                 const searchQuery = query && typeof query === 'string' ? query : undefined;
-                const documents = await listKnowledge({ query: searchQuery });
+                const documents = await listKnowledge({ query: searchQuery, full: false });
                 return c.json({
                     success: true,
                     data: documents,
+                    count: documents.length,
                     message: searchQuery
                         ? `Found ${documents.length} knowledge documents matching "${searchQuery}"`
                         : `Found ${documents.length} knowledge documents`
@@ -524,6 +561,135 @@ async function executeResourcesTool(c, args) {
         return c.json({ success: false, error: error.message || 'Resources tool execution failed' }, 500);
     }
 }
+async function executeListConnectorsTool(c) {
+    const token = getCallbackToken();
+    if (!token) {
+        return c.json({
+            success: false,
+            error: 'Callback token not configured. Set it via PUT /api/v1/config?type=global with { "apiKeys": { "callbackToken": "cpt_xxx" } }'
+        }, 400);
+    }
+    try {
+        const res = await fetch(`${COCONUT_HOST}/api/connectors/accounts`, {
+            headers: { 'X-Callback-Token': token }
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            return c.json({
+                success: false,
+                error: `Control plane returned ${res.status}: ${body || res.statusText}`
+            }, res.status >= 500 ? 502 : 400);
+        }
+        const data = await res.json();
+        const accounts = Array.isArray(data) ? data : (data.accounts ?? data.data ?? []);
+        return c.json({
+            success: true,
+            data: accounts,
+            count: accounts.length,
+            message: `Found ${accounts.length} connected service${accounts.length === 1 ? '' : 's'}`
+        });
+    }
+    catch (error) {
+        console.error('Error listing connectors:', error);
+        return c.json({ success: false, error: error.message || 'Failed to list connectors' }, 500);
+    }
+}
+async function executeConnectorRequestTool(c, args) {
+    const { app: appSlug, method, path: apiPath, body, headers: extraHeaders } = args;
+    if (!appSlug || !method || !apiPath) {
+        return c.json({ success: false, error: 'app, method, and path are required' }, 400);
+    }
+    const token = getCallbackToken();
+    if (!token) {
+        return c.json({
+            success: false,
+            error: 'Callback token not configured. Set it via PUT /api/v1/config?type=global with { "apiKeys": { "callbackToken": "cpt_xxx" } }'
+        }, 400);
+    }
+    try {
+        const accounts = await fetchConnectorAccounts(token);
+        const account = accounts.find((a) => a.appSlug === appSlug || a.appName?.toLowerCase() === appSlug.toLowerCase());
+        if (!account) {
+            return c.json({
+                success: false,
+                error: `No connected account found for "${appSlug}"`,
+                available: accounts.map((a) => a.appSlug || a.appName)
+            }, 404);
+        }
+        const url = resolveConnectorUrl(appSlug, apiPath);
+        if (!url) {
+            return c.json({
+                success: false,
+                error: `Unknown app "${appSlug}" and path is not a full URL. Use a full URL (https://...) or a known app slug.`
+            }, 400);
+        }
+        let parsedBody = undefined;
+        if (body) {
+            try {
+                parsedBody = typeof body === 'string' ? JSON.parse(body) : body;
+            }
+            catch {
+                return c.json({ success: false, error: 'Invalid JSON in body parameter' }, 400);
+            }
+        }
+        let parsedHeaders = {};
+        if (extraHeaders) {
+            try {
+                parsedHeaders = typeof extraHeaders === 'string' ? JSON.parse(extraHeaders) : extraHeaders;
+            }
+            catch {
+                return c.json({ success: false, error: 'Invalid JSON in headers parameter' }, 400);
+            }
+        }
+        const proxyPayload = {
+            accountId: account.accountId,
+            url,
+            method: method.toUpperCase()
+        };
+        if (parsedBody !== undefined)
+            proxyPayload.body = parsedBody;
+        if (Object.keys(parsedHeaders).length > 0)
+            proxyPayload.headers = parsedHeaders;
+        const proxyRes = await fetch(`${COCONUT_HOST}/api/connectors/proxy`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Callback-Token': token
+            },
+            body: JSON.stringify(proxyPayload)
+        });
+        if (!proxyRes.ok) {
+            const errBody = await proxyRes.text().catch(() => '');
+            return c.json({
+                success: false,
+                error: `Proxy request failed (${proxyRes.status}): ${errBody || proxyRes.statusText}`
+            }, proxyRes.status >= 500 ? 502 : 400);
+        }
+        const responseData = await proxyRes.json().catch(async () => {
+            return await proxyRes.text().catch(() => null);
+        });
+        return c.json({
+            success: true,
+            data: responseData,
+            message: `${method.toUpperCase()} ${apiPath} via ${appSlug}`
+        });
+    }
+    catch (error) {
+        console.error('Error executing connector request:', error);
+        return c.json({ success: false, error: error.message || 'Connector request failed' }, 500);
+    }
+}
+async function fetchConnectorAccounts(token) {
+    const res = await fetch(`${COCONUT_HOST}/api/connectors/accounts`, {
+        headers: { 'X-Callback-Token': token }
+    });
+    if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        throw new Error(`Failed to fetch accounts (${res.status}): ${body || res.statusText}`);
+    }
+    const data = await res.json();
+    return Array.isArray(data) ? data : (data.accounts ?? data.data ?? []);
+}
 /**
  * GET /api/v1/mcp/raw-config
  * Returns the raw MCP configuration for editing in settings UI