@lovelybunch/api 1.0.66 → 1.0.68

package/dist/routes/api/v1/events/stream/route.js

@@ -0,0 +1,132 @@
+/**
+ * Events streaming endpoint for real-time tailing
+ */
+import { streamSSE } from "hono/streaming";
+import { promises as fs } from "fs";
+import * as fsSync from "fs";
+import path from "path";
+import { findGaitDirectory } from "../../../../../lib/gait-path.js";
+import readline from "readline";
+/**
+ * Get the events directory path
+ */
+async function getEventsDir() {
+    const gaitDir = await findGaitDirectory();
+    if (!gaitDir)
+        return null;
+    return path.join(gaitDir, "logs");
+}
+/**
+ * GET /api/v1/events/stream?since_seq=
+ * Server-Sent Events stream for near real-time tails
+ */
+export async function GET(c) {
+    const eventsDir = await getEventsDir();
+    if (!eventsDir) {
+        return c.json({ error: "Events directory not found" }, 404);
+    }
+    const url = new URL(c.req.url);
+    const sinceSeq = parseInt(url.searchParams.get("since_seq") || "0", 10);
+    const currentFile = path.join(eventsDir, "events-current.jsonl");
+    return streamSSE(c, async (stream) => {
+        let lastSeq = sinceSeq;
+        let running = true;
+        // Send initial events from file
+        try {
+            const fileExists = await fs
+                .access(currentFile)
+                .then(() => true)
+                .catch(() => false);
+            if (fileExists) {
+                const fileStream = fsSync.createReadStream(currentFile);
+                const rl = readline.createInterface({
+                    input: fileStream,
+                    crlfDelay: Infinity,
+                });
+                for await (const line of rl) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const event = JSON.parse(line);
+                        if (event.seq > sinceSeq) {
+                            await stream.writeSSE({
+                                data: JSON.stringify(event),
+                            });
+                            lastSeq = Math.max(lastSeq, event.seq);
+                        }
+                    }
+                    catch (err) {
+                        // Skip malformed lines
+                        continue;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Ignore errors during initial load
+        }
+        // Poll for new events
+        // In a production implementation, this would use file watching (e.g., chokidar)
+        // For now, we'll poll every 1 second
+        const pollInterval = setInterval(async () => {
+            try {
+                const fileExists = await fs
+                    .access(currentFile)
+                    .then(() => true)
+                    .catch(() => false);
+                if (!fileExists)
+                    return;
+                const fileStream = fsSync.createReadStream(currentFile);
+                const rl = readline.createInterface({
+                    input: fileStream,
+                    crlfDelay: Infinity,
+                });
+                for await (const line of rl) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const event = JSON.parse(line);
+                        if (event.seq > lastSeq) {
+                            await stream.writeSSE({
+                                data: JSON.stringify(event),
+                            });
+                            lastSeq = event.seq;
+                        }
+                    }
+                    catch (err) {
+                        // Skip malformed lines
+                        continue;
+                    }
+                }
+            }
+            catch (error) {
+                // Continue polling even on errors
+            }
+        }, 1000);
+        // Send heartbeat keepalive every 15 seconds
+        const heartbeatInterval = setInterval(async () => {
+            try {
+                // Send empty event to keep connection alive
+                await stream.writeSSE({
+                    data: "",
+                    event: "heartbeat",
+                });
+            }
+            catch (error) {
+                clearInterval(heartbeatInterval);
+                clearInterval(pollInterval);
+                running = false;
+            }
+        }, 15000);
+        // Clean up on disconnect
+        c.req.raw.signal.addEventListener("abort", () => {
+            clearInterval(pollInterval);
+            clearInterval(heartbeatInterval);
+            running = false;
+        });
+        // Keep stream alive
+        while (running) {
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+    });
+}

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

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

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

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

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

@@ -0,0 +1,129 @@
+import { Hono } from 'hono';
+import { fileStorage } from '@lovelybunch/core';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+const execAsync = promisify(exec);
+const app = new Hono();
+// Check if Coconut is initialized
+app.get('/', async (c) => {
+    try {
+        const isInitialized = await fileStorage.isInitialized();
+        return c.json({ initialized: isInitialized });
+    }
+    catch (error) {
+        console.error('Error checking initialization status:', error);
+        return c.json({ error: 'Failed to check initialization status' }, 500);
+    }
+});
+// Initialize Coconut
+app.post('/', async (c) => {
+    try {
+        const body = await c.req.json();
+        const { name, description, initGit = false } = body;
+        if (!name || !description) {
+            return c.json({ error: 'Name and description are required' }, 400);
+        }
+        // Check if already initialized
+        const isInitialized = await fileStorage.isInitialized();
+        if (isInitialized) {
+            return c.json({ error: 'Coconut is already initialized' }, 400);
+        }
+        // Create configuration
+        const config = {
+            version: '1.0.0',
+            repository: {
+                name,
+                description,
+            },
+            policies: {
+                requireApproval: true,
+                minApprovers: 1,
+                allowSelfApproval: false,
+                autoMerge: false,
+            },
+            storage: {
+                type: 'file',
+                path: '.nut',
+            },
+        };
+        // Initialize storage
+        await fileStorage.init();
+        await fileStorage.saveConfig(config);
+        // Initialize git if requested
+        if (initGit) {
+            try {
+                const cwd = process.cwd();
+                // Check if git is already initialized
+                try {
+                    await execAsync('git rev-parse --git-dir', { cwd });
+                    // Git is already initialized, skip
+                }
+                catch {
+                    // Git is not initialized, initialize it
+                    await execAsync('git init', { cwd });
+                    await execAsync('git add .', { cwd });
+                }
+            }
+            catch (gitError) {
+                console.error('Git initialization failed:', gitError);
+                // Don't fail the whole operation if git fails
+                return c.json({
+                    success: true,
+                    message: 'Coconut initialized successfully, but git initialization failed',
+                    gitError: gitError instanceof Error ? gitError.message : 'Unknown error',
+                });
+            }
+        }
+        return c.json({
+            success: true,
+            message: 'Coconut initialized successfully',
+            config,
+        });
+    }
+    catch (error) {
+        console.error('Error initializing Coconut:', error);
+        return c.json({
+            error: 'Failed to initialize Coconut',
+            details: error instanceof Error ? error.message : 'Unknown error',
+        }, 500);
+    }
+});
+// Clone a repository
+app.post('/clone', async (c) => {
+    try {
+        const body = await c.req.json();
+        const { url } = body;
+        if (!url) {
+            return c.json({ error: 'Repository URL is required' }, 400);
+        }
+        // Validate URL format
+        const urlPattern = /^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/;
+        if (!urlPattern.test(url)) {
+            return c.json({ error: 'Invalid repository URL' }, 400);
+        }
+        const cwd = process.cwd();
+        try {
+            // Clone into current directory
+            await execAsync(`git clone ${url} .`, { cwd });
+            return c.json({
+                success: true,
+                message: 'Repository cloned successfully',
+            });
+        }
+        catch (cloneError) {
+            console.error('Git clone failed:', cloneError);
+            return c.json({
+                error: 'Failed to clone repository',
+                details: cloneError instanceof Error ? cloneError.message : 'Unknown error',
+            }, 500);
+        }
+    }
+    catch (error) {
+        console.error('Error cloning repository:', error);
+        return c.json({
+            error: 'Failed to clone repository',
+            details: error instanceof Error ? error.message : 'Unknown error',
+        }, 500);
+    }
+});
+export default app;

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

@@ -0,0 +1,8 @@
+import { Hono } from 'hono';
+import * as route from './route.js';
+const app = new Hono();
+// GET /api/v1/onboard/check - Check if .nut exists and onboarding is needed
+app.get('/check', route.GET_CHECK);
+// POST /api/v1/onboard/initialize - Initialize Coconut (empty or clone)
+app.post('/initialize', route.POST_INITIALIZE);
+export default app;

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

@@ -0,0 +1,13 @@
+import { Context } from 'hono';
+export declare function GET_CHECK(c: Context): Promise<Response & import("hono").TypedResponse<{
+    onboardCheckEnabled: boolean;
+    initialized: boolean;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>;
+export declare function POST_INITIALIZE(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    message: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: any;
+}, 500, "json">)>;

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

@@ -0,0 +1,311 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { findGaitDirectory } from '../../../../lib/gait-path.js';
+const execAsync = promisify(exec);
+export async function GET_CHECK(c) {
+    try {
+        // Check if COCONUT_ONBOARD_CHECK environment variable is set
+        const onboardCheckEnabled = process.env.COCONUT_ONBOARD_CHECK === 'true';
+        // Check if .nut directory exists
+        const gaitDir = await findGaitDirectory();
+        const initialized = gaitDir !== null;
+        return c.json({
+            onboardCheckEnabled,
+            initialized,
+        });
+    }
+    catch (error) {
+        console.error('Error checking onboarding status:', error);
+        return c.json({
+            onboardCheckEnabled: false,
+            initialized: true, // Default to initialized on error to avoid redirecting
+        });
+    }
+}
+export async function POST_INITIALIZE(c) {
+    try {
+        const data = await c.req.json();
+        // Get the current working directory (where the server was started)
+        const cwd = process.env.GAIT_DATA_PATH || process.cwd();
+        if (data.type === 'empty') {
+            // Create an empty Coconut project
+            if (!data.name || data.name.trim().length === 0) {
+                return c.json({ error: 'Project name is required' }, 400);
+            }
+            // Initialize .nut directory
+            const nutDir = path.join(cwd, '.nut');
+            // Check if .nut already exists
+            try {
+                await fs.access(nutDir);
+                return c.json({ error: '.nut directory already exists' }, 400);
+            }
+            catch {
+                // Directory doesn't exist, which is what we want
+            }
+            // Create directory structure
+            await fs.mkdir(nutDir, { recursive: true });
+            await fs.mkdir(path.join(nutDir, 'proposals'), { recursive: true });
+            await fs.mkdir(path.join(nutDir, 'agents'), { recursive: true });
+            await fs.mkdir(path.join(nutDir, 'context'), { recursive: true });
+            await fs.mkdir(path.join(nutDir, 'context', 'knowledge'), { recursive: true });
+            await fs.mkdir(path.join(nutDir, 'resources'), { recursive: true });
+            await fs.mkdir(path.join(nutDir, 'resources', 'files'), { recursive: true });
+            await fs.mkdir(path.join(nutDir, 'resources', 'thumbnails'), { recursive: true });
+            await fs.mkdir(path.join(nutDir, 'jobs'), { recursive: true });
+            await fs.mkdir(path.join(nutDir, '.schema'), { recursive: true });
+            // Create config.json
+            const config = {
+                version: '1.0',
+                project: {
+                    name: data.name.trim(),
+                    description: data.description?.trim() || '',
+                },
+                created: new Date().toISOString(),
+            };
+            await fs.writeFile(path.join(nutDir, 'config.json'), JSON.stringify(config, null, 2), 'utf-8');
+            // Create basic project.md
+            const projectMd = `---
+version: '1.0'
+updated: '${new Date().toISOString().split('T')[0]}'
+type: project
+status: active
+category: overview
+project:
+  name: ${data.name.trim()}
+  description: ${data.description?.trim() || 'A new Coconut project'}
+  version: '0.1.0'
+  stage: development
+goals:
+  primary: Build an amazing product
+  metrics: []
+  non_goals: []
+---
+# ${data.name.trim()}
+
+${data.description?.trim() || 'Welcome to your new Coconut project!'}
+
+## Getting Started
+
+This project was initialized with Coconut. Start by creating change proposals and working with AI agents to build your product.
+`;
+            await fs.writeFile(path.join(nutDir, 'context', 'project.md'), projectMd, 'utf-8');
+            // Create basic architecture.md
+            const architectureMd = `---
+version: '1.0'
+updated: '${new Date().toISOString().split('T')[0]}'
+type: architecture
+category: design
+stack:
+  runtime: node
+  framework: ''
+  language: typescript
+  database: ''
+  deployment: ''
+---
+# Architecture
+
+Document your system architecture here.
+
+## Stack
+
+Describe your technology stack and key architectural decisions.
+
+## Components
+
+Outline the major components of your system.
+`;
+            await fs.writeFile(path.join(nutDir, 'context', 'architecture.md'), architectureMd, 'utf-8');
+            // Initialize git repository
+            try {
+                await execAsync('git init', { cwd });
+                // Create .gitignore if it doesn't exist
+                const gitignorePath = path.join(cwd, '.gitignore');
+                let gitignoreContent = '';
+                try {
+                    gitignoreContent = await fs.readFile(gitignorePath, 'utf-8');
+                }
+                catch {
+                    // File doesn't exist, create it
+                }
+                // Add .nut/auth.json to .gitignore if not already there
+                if (!gitignoreContent.includes('.nut/auth.json')) {
+                    gitignoreContent += '\n# Coconut authentication (contains secrets)\n.nut/auth.json\n';
+                    await fs.writeFile(gitignorePath, gitignoreContent, 'utf-8');
+                }
+            }
+            catch (error) {
+                console.error('Failed to initialize git repository:', error);
+                // Continue even if git init fails
+            }
+            return c.json({
+                success: true,
+                message: `Coconut project "${data.name}" initialized successfully!`,
+            });
+        }
+        else if (data.type === 'clone') {
+            // Clone a repository
+            if (!data.repoUrl || data.repoUrl.trim().length === 0) {
+                return c.json({ error: 'Repository URL is required' }, 400);
+            }
+            // Validate that the current directory is empty or only has .git
+            const files = await fs.readdir(cwd);
+            const nonGitFiles = files.filter(f => f !== '.git' && f !== '.gitignore');
+            if (nonGitFiles.length > 0) {
+                return c.json({
+                    error: 'Current directory is not empty. Please run this in an empty directory or remove existing files.'
+                }, 400);
+            }
+            // Clone the repository into current directory
+            try {
+                await execAsync(`git clone "${data.repoUrl.trim()}" .`, { cwd });
+            }
+            catch (error) {
+                console.error('Failed to clone repository:', error);
+                return c.json({
+                    error: `Failed to clone repository: ${error.message}`
+                }, 500);
+            }
+            // Initialize .nut directory (similar to empty project but without git init)
+            const nutDir = path.join(cwd, '.nut');
+            // Check if .nut already exists in the cloned repo
+            try {
+                await fs.access(nutDir);
+                return c.json({
+                    success: true,
+                    message: 'Repository cloned successfully. Coconut is already initialized in this project.',
+                });
+            }
+            catch {
+                // Directory doesn't exist, initialize it
+            }
+            // Create directory structure
+            await fs.mkdir(nutDir, { recursive: true });
+            await fs.mkdir(path.join(nutDir, 'proposals'), { recursive: true });
+            await fs.mkdir(path.join(nutDir, 'agents'), { recursive: true });
+            await fs.mkdir(path.join(nutDir, 'context'), { recursive: true });
+            await fs.mkdir(path.join(nutDir, 'context', 'knowledge'), { recursive: true });
+            await fs.mkdir(path.join(nutDir, 'resources'), { recursive: true });
+            await fs.mkdir(path.join(nutDir, 'resources', 'files'), { recursive: true });
+            await fs.mkdir(path.join(nutDir, 'resources', 'thumbnails'), { recursive: true });
+            await fs.mkdir(path.join(nutDir, 'jobs'), { recursive: true });
+            await fs.mkdir(path.join(nutDir, '.schema'), { recursive: true });
+            // Try to extract project name from package.json if it exists
+            let projectName = 'Cloned Project';
+            let projectDescription = 'A project cloned from a Git repository';
+            try {
+                const packageJsonPath = path.join(cwd, 'package.json');
+                const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+                if (packageJson.name) {
+                    projectName = packageJson.name;
+                }
+                if (packageJson.description) {
+                    projectDescription = packageJson.description;
+                }
+            }
+            catch {
+                // package.json doesn't exist or couldn't be read
+            }
+            // Create config.json
+            const config = {
+                version: '1.0',
+                project: {
+                    name: projectName,
+                    description: projectDescription,
+                    clonedFrom: data.repoUrl.trim(),
+                },
+                created: new Date().toISOString(),
+            };
+            await fs.writeFile(path.join(nutDir, 'config.json'), JSON.stringify(config, null, 2), 'utf-8');
+            // Create basic project.md
+            const projectMd = `---
+version: '1.0'
+updated: '${new Date().toISOString().split('T')[0]}'
+type: project
+status: active
+category: overview
+project:
+  name: ${projectName}
+  description: ${projectDescription}
+  version: '0.1.0'
+  stage: development
+  repository: ${data.repoUrl.trim()}
+goals:
+  primary: Continue development with Coconut
+  metrics: []
+  non_goals: []
+---
+# ${projectName}
+
+${projectDescription}
+
+## About
+
+This project was cloned from: ${data.repoUrl.trim()}
+
+## Getting Started
+
+Start by creating change proposals and working with AI agents to enhance this codebase.
+`;
+            await fs.writeFile(path.join(nutDir, 'context', 'project.md'), projectMd, 'utf-8');
+            // Create basic architecture.md
+            const architectureMd = `---
+version: '1.0'
+updated: '${new Date().toISOString().split('T')[0]}'
+type: architecture
+category: design
+stack:
+  runtime: node
+  framework: ''
+  language: typescript
+  database: ''
+  deployment: ''
+---
+# Architecture
+
+Document your system architecture here.
+
+## Stack
+
+Describe your technology stack and key architectural decisions.
+
+## Components
+
+Outline the major components of your system.
+`;
+            await fs.writeFile(path.join(nutDir, 'context', 'architecture.md'), architectureMd, 'utf-8');
+            // Add .nut/auth.json to .gitignore
+            try {
+                const gitignorePath = path.join(cwd, '.gitignore');
+                let gitignoreContent = '';
+                try {
+                    gitignoreContent = await fs.readFile(gitignorePath, 'utf-8');
+                }
+                catch {
+                    // File doesn't exist, create it
+                }
+                if (!gitignoreContent.includes('.nut/auth.json')) {
+                    gitignoreContent += '\n# Coconut authentication (contains secrets)\n.nut/auth.json\n';
+                    await fs.writeFile(gitignorePath, gitignoreContent, 'utf-8');
+                }
+            }
+            catch (error) {
+                console.error('Failed to update .gitignore:', error);
+            }
+            return c.json({
+                success: true,
+                message: `Repository cloned and Coconut initialized successfully!`,
+            });
+        }
+        else {
+            return c.json({ error: 'Invalid onboarding type' }, 400);
+        }
+    }
+    catch (error) {
+        console.error('Onboarding initialization error:', error);
+        return c.json({
+            error: error.message || 'Failed to initialize Coconut'
+        }, 500);
+    }
+}

package/dist/routes/api/v1/onboarding/check/index.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/onboarding/check/index.js

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import { GET } from './route.js';
+const app = new Hono();
+app.get('/', GET);
+export default app;

package/dist/routes/api/v1/onboarding/check/route.d.ts

@@ -0,0 +1,12 @@
+import { Context } from 'hono';
+/**
+ * GET /api/v1/onboarding/check
+ * Check if .nut directory exists WITHOUT creating it
+ */
+export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+    initialized: boolean;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    message: any;
+}, 500, "json">)>;

package/dist/routes/api/v1/onboarding/check/route.js

@@ -0,0 +1,24 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+/**
+ * GET /api/v1/onboarding/check
+ * Check if .nut directory exists WITHOUT creating it
+ */
+export async function GET(c) {
+    try {
+        const cwd = process.env.GAIT_DATA_PATH || process.cwd();
+        const nutPath = join(cwd, '.nut');
+        const nutExists = existsSync(nutPath);
+        return c.json({
+            success: true,
+            initialized: nutExists,
+        });
+    }
+    catch (error) {
+        console.error('Error checking .nut directory:', error);
+        return c.json({
+            success: false,
+            message: error.message || 'Failed to check initialization status',
+        }, 500);
+    }
+}

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

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

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

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

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

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