@lovelybunch/api 1.0.75-alpha.8 → 1.0.75

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

@@ -0,0 +1,254 @@
+import { Hono } from 'hono';
+import { promises as fs } from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+import { getLogger, KnowledgeKinds } from '@lovelybunch/core/logging';
+import { requireAuth } from '../../../../../middleware/auth.js';
+// Helper function to generate a simple summary from content
+function generateSummary(content, maxLines = 3, maxChars = 200) {
+    // Remove markdown formatting for cleaner summary
+    const cleanContent = content
+        .replace(/^#+\s+/gm, '') // Remove headings
+        .replace(/[*_`]/g, '') // Remove bold, italic, code
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1') // Convert links to text
+        .trim();
+    // Get first few lines
+    const lines = cleanContent.split('\n').filter(line => line.trim().length > 0);
+    const summary = lines.slice(0, maxLines).join(' ');
+    // Truncate if too long
+    return summary.length > maxChars
+        ? summary.substring(0, maxChars) + '...'
+        : summary;
+}
+const app = new Hono();
+function getKnowledgePath() {
+    let basePath;
+    if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
+        // Dev mode: use project root .nut directory
+        basePath = process.env.GAIT_DEV_ROOT;
+    }
+    else if (process.env.GAIT_DATA_PATH) {
+        // Production mode: use GAIT_DATA_PATH (set by CLI)
+        basePath = path.resolve(process.env.GAIT_DATA_PATH, '.nut');
+    }
+    else {
+        // Fallback: use current directory .nut
+        basePath = path.resolve(process.cwd(), '.nut');
+    }
+    return path.join(basePath, 'knowledge');
+}
+function generateFilename(title) {
+    // Convert title to filename-safe format
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, '') // Remove special characters
+        .replace(/\s+/g, '-') // Replace spaces with hyphens
+        .replace(/--+/g, '-') // Replace multiple hyphens with single
+        .replace(/^-|-$/g, '') // Remove leading/trailing hyphens
+        + '.md';
+}
+/**
+ * GET /api/v1/knowledge/:filename
+ * Load a specific knowledge document
+ */
+app.get('/:filename', async (c) => {
+    try {
+        const filename = c.req.param('filename');
+        const knowledgePath = getKnowledgePath();
+        const actualFilename = filename.endsWith('.md') ? filename : `${filename}.md`;
+        const filePath = path.join(knowledgePath, actualFilename);
+        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] ||
+            actualFilename.replace('.md', '').replace(/[_-]/g, ' ').replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase());
+        const document = {
+            filename: actualFilename,
+            metadata: {
+                ...data,
+                title, // Include title in metadata
+                updated: stats.mtime.toISOString(),
+                tags: data.tags || [],
+                sources: data.sources || []
+            },
+            content,
+            title
+        };
+        return c.json({
+            success: true,
+            document
+        });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return c.json({ success: false, error: 'Knowledge document not found' }, 404);
+        }
+        console.error('Error loading knowledge document:', error);
+        return c.json({ success: false, error: 'Failed to load knowledge document' }, 500);
+    }
+});
+/**
+ * PUT /api/v1/knowledge/:filename
+ * Update a specific knowledge document
+ */
+app.put('/:filename', async (c) => {
+    try {
+        const filename = c.req.param('filename');
+        const body = await c.req.json();
+        const knowledgePath = getKnowledgePath();
+        const actualFilename = filename.endsWith('.md') ? filename : `${filename}.md`;
+        const filePath = path.join(knowledgePath, actualFilename);
+        // Check if file exists
+        try {
+            await fs.access(filePath);
+        }
+        catch {
+            return c.json({ success: false, error: 'Knowledge document not found' }, 404);
+        }
+        // Read current content
+        const currentContent = await fs.readFile(filePath, 'utf-8');
+        const { data: currentData, content: currentMarkdown } = matter(currentContent);
+        // Extract current title from markdown content or metadata
+        const currentTitle = currentMarkdown.match(/^#\s+(.+)$/m)?.[1] ||
+            currentData.title ||
+            actualFilename.replace('.md', '').replace(/[_-]/g, ' ').replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase());
+        // Prepare updated content
+        const updatedContent = body.content !== undefined ? body.content : currentMarkdown;
+        // Determine if title has changed
+        const newTitle = body.title !== undefined ? body.title : currentTitle;
+        const titleChanged = body.title !== undefined && body.title !== currentTitle;
+        const updatedMetadata = {
+            ...currentData,
+            ...body.metadata,
+            title: newTitle, // Store title in metadata
+            updated: new Date().toISOString(),
+            // Ensure these are arrays
+            tags: body.metadata?.tags !== undefined ? body.metadata.tags : (currentData.tags || []),
+            sources: body.metadata?.sources !== undefined ? body.metadata.sources : (currentData.sources || [])
+        };
+        // Handle title change - might need to rename file
+        let newFilename = actualFilename;
+        let newFilePath = filePath;
+        // Only rename file if title explicitly changed
+        if (titleChanged) {
+            newFilename = generateFilename(newTitle);
+            newFilePath = path.join(knowledgePath, newFilename);
+            // Check if new filename conflicts with existing file (unless it's the same file)
+            if (newFilename !== actualFilename) {
+                try {
+                    await fs.access(newFilePath);
+                    return c.json({ success: false, error: 'A document with this title already exists' }, 409);
+                }
+                catch {
+                    // File doesn't exist, which is what we want
+                }
+            }
+        }
+        // Create the updated markdown content with frontmatter
+        const fileContent = matter.stringify(updatedContent, updatedMetadata);
+        // Write to new location (or same location if filename unchanged)
+        await fs.writeFile(newFilePath, fileContent, 'utf-8');
+        // If filename changed, delete old file
+        if (newFilename !== actualFilename) {
+            await fs.unlink(filePath);
+        }
+        // Log knowledge update event
+        try {
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : "human:unknown";
+            const logger = getLogger();
+            logger.log({
+                kind: KnowledgeKinds.UPDATE,
+                actor,
+                subject: `knowledge:${newFilename}`,
+                tags: ["knowledge", ...(updatedMetadata.tags || [])],
+                payload: {
+                    filename: newFilename,
+                    oldFilename: actualFilename !== newFilename ? actualFilename : undefined,
+                    title: newTitle,
+                    category: updatedMetadata.category,
+                    summary: generateSummary(updatedContent),
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging knowledge update:', logError);
+        }
+        return c.json({
+            success: true,
+            document: {
+                filename: newFilename,
+                title: newTitle,
+                metadata: updatedMetadata,
+                content: updatedContent
+            }
+        });
+    }
+    catch (error) {
+        console.error('Error updating knowledge document:', error);
+        return c.json({ success: false, error: 'Failed to update knowledge document' }, 500);
+    }
+});
+/**
+ * DELETE /api/v1/knowledge/:filename
+ * Delete a specific knowledge document
+ */
+app.delete('/:filename', async (c) => {
+    try {
+        const filename = c.req.param('filename');
+        const knowledgePath = getKnowledgePath();
+        const actualFilename = filename.endsWith('.md') ? filename : `${filename}.md`;
+        const filePath = path.join(knowledgePath, actualFilename);
+        // Check if file exists
+        try {
+            await fs.access(filePath);
+        }
+        catch {
+            return c.json({ success: false, error: 'Knowledge document not found' }, 404);
+        }
+        // Read file before deletion for logging
+        let title;
+        try {
+            const fileContent = await fs.readFile(filePath, 'utf-8');
+            const { content } = matter(fileContent);
+            title = content.match(/^#\s+(.+)$/m)?.[1];
+        }
+        catch {
+            // Ignore if we can't read the file
+        }
+        // Delete the file
+        await fs.unlink(filePath);
+        // Log knowledge deletion event
+        try {
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : "human:unknown";
+            const logger = getLogger();
+            logger.log({
+                kind: KnowledgeKinds.DELETE,
+                actor,
+                subject: `knowledge:${actualFilename}`,
+                tags: ["knowledge"],
+                payload: {
+                    filename: actualFilename,
+                    title,
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging knowledge deletion:', logError);
+        }
+        return c.json({
+            success: true,
+            message: 'Knowledge document deleted successfully'
+        });
+    }
+    catch (error) {
+        console.error('Error deleting knowledge document:', error);
+        return c.json({ success: false, error: 'Failed to delete knowledge document' }, 500);
+    }
+});
+export default app;

package/dist/routes/api/v1/knowledge/index.d.ts

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

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

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

package/dist/routes/api/v1/knowledge/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/knowledge/route.js

@@ -0,0 +1,176 @@
+import { Hono } from 'hono';
+import { promises as fs } from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+import filenameRoute from './[filename]/index.js';
+import { getLogger, KnowledgeKinds } from '@lovelybunch/core/logging';
+import { requireAuth } from '../../../../middleware/auth.js';
+// Helper function to generate a simple summary from content
+function generateSummary(content, maxLines = 3, maxChars = 200) {
+    // Remove markdown formatting for cleaner summary
+    const cleanContent = content
+        .replace(/^#+\s+/gm, '') // Remove headings
+        .replace(/[*_`]/g, '') // Remove bold, italic, code
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1') // Convert links to text
+        .trim();
+    // Get first few lines
+    const lines = cleanContent.split('\n').filter(line => line.trim().length > 0);
+    const summary = lines.slice(0, maxLines).join(' ');
+    // Truncate if too long
+    return summary.length > maxChars
+        ? summary.substring(0, maxChars) + '...'
+        : summary;
+}
+const app = new Hono();
+function getKnowledgePath() {
+    let basePath;
+    if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
+        // Dev mode: use project root .nut directory
+        basePath = process.env.GAIT_DEV_ROOT;
+    }
+    else if (process.env.GAIT_DATA_PATH) {
+        // Production mode: use GAIT_DATA_PATH (set by CLI)
+        basePath = path.resolve(process.env.GAIT_DATA_PATH, '.nut');
+    }
+    else {
+        // Fallback: use current directory .nut
+        basePath = path.resolve(process.cwd(), '.nut');
+    }
+    return path.join(basePath, 'knowledge');
+}
+function generateFilename(title) {
+    // Convert title to filename-safe format
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, '') // Remove special characters
+        .replace(/\s+/g, '-') // Replace spaces with hyphens
+        .replace(/--+/g, '-') // Replace multiple hyphens with single
+        .replace(/^-|-$/g, '') // Remove leading/trailing hyphens
+        + '.md';
+}
+/**
+ * GET /api/v1/knowledge
+ * Load all knowledge documents
+ */
+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
+            };
+        }));
+        return c.json({
+            success: true,
+            documents: documents.sort((a, b) => a.filename.localeCompare(b.filename))
+        });
+    }
+    catch (error) {
+        console.error('Error loading knowledge documents:', error);
+        return c.json({
+            success: false,
+            error: 'Failed to load knowledge documents',
+            documents: []
+        }, 500);
+    }
+});
+/**
+ * POST /api/v1/knowledge
+ * Create a new knowledge document
+ */
+app.post('/', async (c) => {
+    try {
+        const body = await c.req.json();
+        if (!body.title || !body.content) {
+            return c.json({ success: false, error: 'Title and content are required' }, 400);
+        }
+        const knowledgePath = getKnowledgePath();
+        await fs.mkdir(knowledgePath, { recursive: true });
+        const filename = generateFilename(body.title);
+        const filePath = path.join(knowledgePath, filename);
+        // Check if file already exists
+        try {
+            await fs.access(filePath);
+            return c.json({ success: false, error: 'A document with this title already exists' }, 409);
+        }
+        catch {
+            // File doesn't exist, which is what we want
+        }
+        // Prepare frontmatter
+        const now = new Date();
+        const frontmatter = {
+            version: '1.0',
+            title: body.title, // Store title in metadata
+            updated: now.toISOString(),
+            type: 'knowledge',
+            category: body.metadata?.category || 'general',
+            tags: body.metadata?.tags || [],
+            sources: body.metadata?.sources || [],
+            ...body.metadata
+        };
+        // Create the markdown content with frontmatter
+        const fileContent = matter.stringify(body.content, frontmatter);
+        await fs.writeFile(filePath, fileContent, 'utf-8');
+        // Log knowledge creation event
+        try {
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : "human:unknown";
+            const logger = getLogger();
+            logger.log({
+                kind: KnowledgeKinds.CREATE,
+                actor,
+                subject: `knowledge:${filename}`,
+                tags: ["knowledge", ...(frontmatter.tags || [])],
+                payload: {
+                    filename,
+                    title: body.title,
+                    category: frontmatter.category,
+                    summary: generateSummary(body.content),
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging knowledge creation:', logError);
+        }
+        return c.json({
+            success: true,
+            document: {
+                filename,
+                title: body.title,
+                metadata: frontmatter,
+                content: body.content
+            }
+        }, 201);
+    }
+    catch (error) {
+        console.error('Error creating knowledge document:', error);
+        return c.json({ success: false, error: 'Failed to create knowledge document' }, 500);
+    }
+});
+// Register filename route for individual documents
+app.route('/', filenameRoute);
+export default app;

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

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

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

@@ -0,0 +1,23 @@
+import { Hono } from 'hono';
+import { listMailHandler, getMailHandler, setMailStatusHandler, setMailActionHandler, replyMailHandler, sendMailHandler, deleteMailHandler, inboundWebhookHandler, getMailProcessingHandler, stopMailProcessingHandler, } from './route.js';
+const mailRoutes = new Hono();
+// Resend inbound webhook
+mailRoutes.post('/inbound', inboundWebhookHandler);
+// Send email (coming soon)
+mailRoutes.post('/send', sendMailHandler);
+// Processing status and control
+mailRoutes.get('/:id/processing', getMailProcessingHandler);
+mailRoutes.post('/:id/processing/stop', stopMailProcessingHandler);
+// Set email status (read/unread)
+mailRoutes.put('/:id/status', setMailStatusHandler);
+// Set agent action summary
+mailRoutes.put('/:id/action', setMailActionHandler);
+// Reply to email
+mailRoutes.post('/:id/reply', replyMailHandler);
+// List emails in folder
+mailRoutes.get('/:folder', listMailHandler);
+// Get specific email in folder
+mailRoutes.get('/:folder/:id', getMailHandler);
+// Delete email from folder
+mailRoutes.delete('/:folder/:id', deleteMailHandler);
+export { mailRoutes };