@lovelybunch/api 1.0.7

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

@@ -0,0 +1,198 @@
+import { Hono } from 'hono';
+import { promises as fs } from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+const app = new Hono();
+function getArchitecturePath() {
+    const basePath = process.env.GAIT_DATA_PATH ?
+        path.resolve(process.env.GAIT_DATA_PATH, '.gait') :
+        path.resolve(process.cwd(), '.gait');
+    return path.join(basePath, 'context');
+}
+/**
+ * GET /api/v1/context/architecture
+ * Load architecture document
+ */
+app.get('/', async (c) => {
+    try {
+        const architecturePath = getArchitecturePath();
+        // Ensure directory exists
+        await fs.mkdir(architecturePath, { recursive: true });
+        // Look for architecture.md file
+        const filePath = path.join(architecturePath, 'architecture.md');
+        try {
+            const fileContent = await fs.readFile(filePath, 'utf-8');
+            const { data, content } = matter(fileContent);
+            // Extract title from first heading or use default
+            const title = content.match(/^#\s+(.+)$/m)?.[1] || 'Architecture Overview';
+            const document = {
+                filename: 'architecture.md',
+                metadata: {
+                    ...data,
+                    updated: data.updated || new Date().toISOString().split('T')[0],
+                    type: 'architecture',
+                    category: 'design',
+                    tags: data.tags || []
+                },
+                content,
+                title
+            };
+            return c.json({
+                success: true,
+                document
+            });
+        }
+        catch (fileError) {
+            // If file doesn't exist, return default content
+            const defaultContent = `# Architecture Overview
+
+This document describes the overall architecture and design patterns used in this project.
+
+## System Architecture
+
+Describe the high-level system architecture, including major components and their relationships.
+
+## Design Patterns
+
+Document the key design patterns and architectural principles followed in this project.
+
+### Frontend Architecture
+
+- Component structure
+- State management
+- Routing approach
+- UI/UX patterns
+
+### Backend Architecture
+
+- API design
+- Data layer
+- Service architecture
+- Authentication & authorization
+
+## Data Flow
+
+Explain how data flows through the system, including:
+
+- Request/response cycles
+- Data transformations
+- Caching strategies
+- Error handling
+
+## Technology Decisions
+
+Document key technology choices and the reasoning behind them:
+
+- Framework selections
+- Database choices
+- Third-party integrations
+- Development tools
+
+## Deployment Architecture
+
+Describe the deployment strategy and infrastructure:
+
+- Environment setup
+- CI/CD pipeline
+- Monitoring and logging
+- Scaling considerations
+
+## Security Considerations
+
+Outline security measures and best practices:
+
+- Authentication mechanisms
+- Data protection
+- API security
+- Infrastructure security
+
+## Performance Considerations
+
+Document performance optimization strategies:
+
+- Caching layers
+- Database optimization
+- Frontend performance
+- Monitoring and metrics
+`;
+            const document = {
+                filename: 'architecture.md',
+                metadata: {
+                    version: '1.0',
+                    updated: new Date().toISOString().split('T')[0],
+                    type: 'architecture',
+                    category: 'design',
+                    tags: []
+                },
+                content: defaultContent,
+                title: 'Architecture Overview'
+            };
+            return c.json({
+                success: true,
+                document
+            });
+        }
+    }
+    catch (error) {
+        console.error('Error loading architecture document:', error);
+        return c.json({
+            success: false,
+            error: 'Failed to load architecture document'
+        }, 500);
+    }
+});
+/**
+ * PUT /api/v1/context/architecture
+ * Update architecture document
+ */
+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 architecturePath = getArchitecturePath();
+        await fs.mkdir(architecturePath, { recursive: true });
+        const filePath = path.join(architecturePath, 'architecture.md');
+        // Read current content if it exists
+        let currentData = {};
+        try {
+            const currentContent = await fs.readFile(filePath, 'utf-8');
+            const { data } = matter(currentContent);
+            currentData = data;
+        }
+        catch {
+            // File doesn't exist, use defaults
+        }
+        // Prepare updated metadata
+        const updatedMetadata = {
+            ...currentData,
+            ...body.metadata,
+            updated: new Date().toISOString().split('T')[0],
+            type: 'architecture',
+            category: 'design',
+            version: currentData.version || '1.0'
+        };
+        // Create the markdown content with frontmatter
+        const fileContent = matter.stringify(body.content, updatedMetadata);
+        await fs.writeFile(filePath, fileContent, 'utf-8');
+        // Extract updated title
+        const title = body.title ||
+            body.content.match(/^#\s+(.+)$/m)?.[1] ||
+            'Architecture Overview';
+        return c.json({
+            success: true,
+            document: {
+                filename: 'architecture.md',
+                title,
+                metadata: updatedMetadata,
+                content: body.content
+            }
+        });
+    }
+    catch (error) {
+        console.error('Error updating architecture document:', error);
+        return c.json({ success: false, error: 'Failed to update architecture document' }, 500);
+    }
+});
+export default app;

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

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

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

@@ -0,0 +1,9 @@
+import { Hono } from 'hono';
+import project from './project/route.js';
+import architecture from './architecture/route.js';
+import knowledge from './knowledge/index.js';
+const context = new Hono();
+context.route('/project', project);
+context.route('/architecture', architecture);
+context.route('/knowledge', knowledge);
+export default context;

package/dist/routes/api/v1/context/knowledge/[filename]/index.d.ts

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

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

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

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

@@ -0,0 +1,165 @@
+import { Hono } from 'hono';
+import { promises as fs } from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+const app = new Hono();
+function getKnowledgePath() {
+    const basePath = process.env.GAIT_DATA_PATH ?
+        path.resolve(process.env.GAIT_DATA_PATH, '.gait') :
+        path.resolve(process.cwd(), '.gait');
+    return path.join(basePath, 'context', '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/context/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 = await fs.readFile(filePath, 'utf-8');
+        const { data, content } = matter(fileContent);
+        // Extract title from first heading or use filename
+        const 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,
+                updated: data.updated || new Date().toISOString().split('T')[0],
+                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/context/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);
+        // Prepare updated content
+        const updatedContent = body.content !== undefined ? body.content : currentMarkdown;
+        const updatedMetadata = {
+            ...currentData,
+            ...body.metadata,
+            updated: new Date().toISOString().split('T')[0],
+            // 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;
+        if (body.title) {
+            newFilename = generateFilename(body.title);
+            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);
+        }
+        // Extract updated title
+        const title = body.title ||
+            updatedContent.match(/^#\s+(.+)$/m)?.[1] ||
+            newFilename.replace('.md', '').replace(/[_-]/g, ' ').replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase());
+        return c.json({
+            success: true,
+            document: {
+                filename: newFilename,
+                title,
+                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/context/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);
+        }
+        // Delete the file
+        await fs.unlink(filePath);
+        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/context/knowledge/index.d.ts

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

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

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

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

@@ -0,0 +1,121 @@
+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';
+const app = new Hono();
+function getKnowledgePath() {
+    const basePath = process.env.GAIT_DATA_PATH ?
+        path.resolve(process.env.GAIT_DATA_PATH, '.gait') :
+        path.resolve(process.cwd(), '.gait');
+    return path.join(basePath, 'context', '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/context/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 = await fs.readFile(filePath, 'utf-8');
+            const { data, content } = matter(fileContent);
+            // Extract title from first heading or use filename
+            const 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,
+                    updated: data.updated || new Date().toISOString().split('T')[0],
+                    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/context/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',
+            updated: now.toISOString().split('T')[0],
+            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');
+        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/context/project/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/project/route.js

@@ -0,0 +1,153 @@
+import { Hono } from 'hono';
+import { promises as fs } from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+const app = new Hono();
+function getProjectPath() {
+    const basePath = process.env.GAIT_DATA_PATH ?
+        path.resolve(process.env.GAIT_DATA_PATH, '.gait') :
+        path.resolve(process.cwd(), '.gait');
+    return path.join(basePath, 'context');
+}
+/**
+ * GET /api/v1/context/project
+ * Load project overview document
+ */
+app.get('/', async (c) => {
+    try {
+        const projectPath = getProjectPath();
+        // Ensure directory exists
+        await fs.mkdir(projectPath, { recursive: true });
+        // Look for project.md file
+        const filePath = path.join(projectPath, 'project.md');
+        try {
+            const fileContent = await fs.readFile(filePath, 'utf-8');
+            const { data, content } = matter(fileContent);
+            // Extract title from first heading or use default
+            const title = content.match(/^#\s+(.+)$/m)?.[1] || 'Project Overview';
+            const document = {
+                filename: 'project.md',
+                metadata: {
+                    ...data,
+                    updated: data.updated || new Date().toISOString().split('T')[0],
+                    type: 'project',
+                    category: 'overview',
+                    tags: data.tags || []
+                },
+                content,
+                title
+            };
+            return c.json({
+                success: true,
+                document
+            });
+        }
+        catch (fileError) {
+            // If file doesn't exist, return default content
+            const defaultContent = `# Project Overview
+
+This document provides an overview of the project, including its purpose, goals, and key information.
+
+## Purpose
+
+Describe the main purpose and objectives of this project.
+
+## Key Features
+
+- Feature 1
+- Feature 2
+- Feature 3
+
+## Technology Stack
+
+List the main technologies, frameworks, and tools used in this project.
+
+## Getting Started
+
+Provide instructions for setting up and running the project locally.
+
+## Documentation
+
+Links to additional documentation, guides, and resources.
+`;
+            const document = {
+                filename: 'project.md',
+                metadata: {
+                    version: '1.0',
+                    updated: new Date().toISOString().split('T')[0],
+                    type: 'project',
+                    category: 'overview',
+                    tags: []
+                },
+                content: defaultContent,
+                title: 'Project Overview'
+            };
+            return c.json({
+                success: true,
+                document
+            });
+        }
+    }
+    catch (error) {
+        console.error('Error loading project document:', error);
+        return c.json({
+            success: false,
+            error: 'Failed to load project document'
+        }, 500);
+    }
+});
+/**
+ * PUT /api/v1/context/project
+ * Update project overview document
+ */
+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 projectPath = getProjectPath();
+        await fs.mkdir(projectPath, { recursive: true });
+        const filePath = path.join(projectPath, 'project.md');
+        // Read current content if it exists
+        let currentData = {};
+        try {
+            const currentContent = await fs.readFile(filePath, 'utf-8');
+            const { data } = matter(currentContent);
+            currentData = data;
+        }
+        catch {
+            // File doesn't exist, use defaults
+        }
+        // Prepare updated metadata
+        const updatedMetadata = {
+            ...currentData,
+            ...body.metadata,
+            updated: new Date().toISOString().split('T')[0],
+            type: 'project',
+            category: 'overview',
+            version: currentData.version || '1.0'
+        };
+        // Create the markdown content with frontmatter
+        const fileContent = matter.stringify(body.content, updatedMetadata);
+        await fs.writeFile(filePath, fileContent, 'utf-8');
+        // Extract updated title
+        const title = body.title ||
+            body.content.match(/^#\s+(.+)$/m)?.[1] ||
+            'Project Overview';
+        return c.json({
+            success: true,
+            document: {
+                filename: 'project.md',
+                title,
+                metadata: updatedMetadata,
+                content: body.content
+            }
+        });
+    }
+    catch (error) {
+        console.error('Error updating project document:', error);
+        return c.json({ success: false, error: 'Failed to update project document' }, 500);
+    }
+});
+export default app;