@lovelybunch/api 1.0.7

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

@@ -0,0 +1,133 @@
+import { Hono } from 'hono';
+import { promises as fs } from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+const app = new Hono();
+function getAgentsPath() {
+    const basePath = process.env.GAIT_DATA_PATH ?
+        path.resolve(process.env.GAIT_DATA_PATH, '.gait') :
+        path.resolve(process.cwd(), '.gait');
+    return path.join(basePath, 'agents');
+}
+function generateFilename(name) {
+    // Convert name to filename-safe format
+    return name
+        .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/agents
+ * Load all agent documents
+ */
+app.get('/', async (c) => {
+    try {
+        const agentsPath = getAgentsPath();
+        // Ensure directory exists
+        await fs.mkdir(agentsPath, { recursive: true });
+        const files = await fs.readdir(agentsPath);
+        const agents = await Promise.all(files
+            .filter(file => file.endsWith('.md'))
+            .map(async (file) => {
+            const filePath = path.join(agentsPath, file);
+            const fileContent = await fs.readFile(filePath, 'utf-8');
+            try {
+                const { data, content } = matter(fileContent);
+                // Extract title from name in frontmatter or use filename
+                const title = data.name ||
+                    file.replace('.md', '').replace(/[_-]/g, ' ').replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase());
+                return {
+                    filename: file,
+                    metadata: {
+                        name: data.name || title,
+                        description: data.description || '',
+                        color: data.color,
+                        tools: data.tools,
+                        ...data
+                    },
+                    content,
+                    title
+                };
+            }
+            catch (error) {
+                console.warn(`Error parsing agent ${file}:`, error instanceof Error ? error.message : String(error));
+                // Return a basic structure for files that can't be parsed
+                const title = file.replace('.md', '').replace(/[_-]/g, ' ').replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase());
+                return {
+                    filename: file,
+                    metadata: {
+                        name: title,
+                        description: 'Error parsing agent metadata',
+                        color: 'red'
+                    },
+                    content: fileContent,
+                    title
+                };
+            }
+        }));
+        return c.json({
+            success: true,
+            documents: agents.sort((a, b) => a.filename.localeCompare(b.filename))
+        });
+    }
+    catch (error) {
+        console.error('Error loading agent documents:', error);
+        return c.json({
+            success: false,
+            error: 'Failed to load agent documents',
+            documents: []
+        }, 500);
+    }
+});
+/**
+ * POST /api/v1/agents
+ * Create a new agent document
+ */
+app.post('/', async (c) => {
+    try {
+        const body = await c.req.json();
+        if (!body.name || !body.description) {
+            return c.json({ success: false, error: 'Name and description are required' }, 400);
+        }
+        const agentsPath = getAgentsPath();
+        await fs.mkdir(agentsPath, { recursive: true });
+        const filename = generateFilename(body.name);
+        const filePath = path.join(agentsPath, filename);
+        // Check if file already exists
+        try {
+            await fs.access(filePath);
+            return c.json({ success: false, error: 'An agent with this name already exists' }, 409);
+        }
+        catch {
+            // File doesn't exist, which is what we want
+        }
+        // Prepare frontmatter - filter out undefined values
+        const frontmatter = Object.fromEntries(Object.entries({
+            name: body.name,
+            description: body.description,
+            color: body.metadata?.color || 'blue',
+            tools: body.metadata?.tools,
+            ...body.metadata
+        }).filter(([_, value]) => value !== undefined));
+        // 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.name,
+                metadata: frontmatter,
+                content: body.content
+            }
+        }, 201);
+    }
+    catch (error) {
+        console.error('Error creating agent document:', error);
+        return c.json({ success: false, error: 'Failed to create agent document' }, 500);
+    }
+});
+export default app;

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

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

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

@@ -0,0 +1,8 @@
+import { Context } from 'hono';
+export declare function POST(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">) | (Response & import("hono").TypedResponse<{
+    response: any;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;

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

@@ -0,0 +1,86 @@
+export async function POST(c) {
+    try {
+        const { message, model, context, contextContent } = await c.req.json();
+        if (!message) {
+            return c.json({ error: "Message is required" }, 400);
+        }
+        const openRouterKey = process.env.OPENROUTER_API_KEY;
+        if (!openRouterKey) {
+            return c.json({ error: "OpenRouter API key not configured" }, 500);
+        }
+        const systemPrompt = getSystemPrompt(context, contextContent);
+        const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${openRouterKey}`,
+                "Content-Type": "application/json",
+                "HTTP-Referer": process.env.NEXT_PUBLIC_SITE_URL || "http://localhost:3001",
+                "X-Title": "GAIT AI Assistant",
+            },
+            body: JSON.stringify({
+                model: model || "anthropic/claude-3-sonnet",
+                messages: [
+                    {
+                        role: "system",
+                        content: systemPrompt,
+                    },
+                    {
+                        role: "user",
+                        content: message,
+                    },
+                ],
+                temperature: 0.7,
+                max_tokens: 1000,
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            console.error("OpenRouter API error:", error);
+            return c.json({ error: "Failed to get AI response" }, 500);
+        }
+        const data = await response.json();
+        const aiResponse = data.choices?.[0]?.message?.content;
+        if (!aiResponse) {
+            return c.json({ error: "No response from AI model" }, 500);
+        }
+        return c.json({ response: aiResponse });
+    }
+    catch (error) {
+        console.error("AI API error:", error);
+        return c.json({ error: "Internal server error" }, 500);
+    }
+}
+function getSystemPrompt(context, contextContent) {
+    const basePrompt = `You are an AI assistant integrated into GAIT (Git-Adjacent Intent Tracking), a source control management system for agent-native development. You help developers with proposals, architecture decisions, and project planning.`;
+    switch (context) {
+        case "proposals":
+        case "proposals-edit":
+        case "proposals-view":
+            let proposalPrompt = `${basePrompt} You are currently in the proposals section. Help users:
+- Refine and improve their change proposals
+- Suggest implementation approaches
+- Identify potential challenges or risks
+- Break down complex changes into manageable steps
+- Provide feedback on proposal clarity and completeness`;
+            if (contextContent) {
+                proposalPrompt += `\n\nYou have access to the following proposal data:\n\n${contextContent}`;
+            }
+            return proposalPrompt;
+        case "context":
+            return `${basePrompt} You are currently in the context section (architecture, decisions, knowledge). Help users:
+- Analyze architectural decisions and patterns
+- Suggest improvements to documentation
+- Identify gaps in knowledge or decisions
+- Recommend best practices
+- Help maintain consistency across the project`;
+        case "settings":
+            return `${basePrompt} You are currently in the settings section. Help users:
+- Configure their GAIT environment
+- Set up integrations and workflows
+- Optimize their development process
+- Understand configuration options
+- Troubleshoot setup issues`;
+        default:
+            return `${basePrompt} Provide helpful, contextual assistance based on the user's current needs in their GAIT workflow.`;
+    }
+}

package/dist/routes/api/v1/chats/[id]/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/chats/[id]/index.js

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

package/dist/routes/api/v1/chats/[id]/route.d.ts

@@ -0,0 +1,12 @@
+import { Context } from 'hono';
+export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    chat: any;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 404, "json">)>;
+export declare function DELETE(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+    message: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;

package/dist/routes/api/v1/chats/[id]/route.js

@@ -0,0 +1,31 @@
+import { readFile, unlink } from "fs/promises";
+import { join } from "path";
+const CHATS_DIR = join(process.cwd(), ".gait", "chats");
+export async function GET(c) {
+    try {
+        const id = c.req.param('id');
+        const filePath = join(CHATS_DIR, `${id}.json`);
+        const content = await readFile(filePath, 'utf8');
+        const chat = JSON.parse(content);
+        return c.json({ chat });
+    }
+    catch (error) {
+        console.error("Error reading chat:", error);
+        return c.json({ error: "Chat not found" }, 404);
+    }
+}
+export async function DELETE(c) {
+    try {
+        const id = c.req.param('id');
+        const filePath = join(CHATS_DIR, `${id}.json`);
+        await unlink(filePath);
+        return c.json({
+            success: true,
+            message: "Chat deleted successfully"
+        });
+    }
+    catch (error) {
+        console.error("Error deleting chat:", error);
+        return c.json({ error: "Failed to delete chat" }, 500);
+    }
+}

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

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

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

@@ -0,0 +1,32 @@
+import { Context } from 'hono';
+export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    chats: {
+        id: string;
+        title: string;
+        messages: {
+            role: "user" | "assistant" | "system";
+            content: string;
+            timestamp: string;
+        }[];
+        model: string;
+        context?: {
+            type: string;
+            content: string | null;
+            displayId?: string;
+            contextFiles?: string;
+        };
+        createdAt: string;
+        updatedAt: string;
+    }[];
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;
+export declare function POST(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    chatId: string;
+    message: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;

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

@@ -0,0 +1,67 @@
+import { writeFile, readdir, readFile, mkdir } from "fs/promises";
+import { join } from "path";
+const CHATS_DIR = join(process.cwd(), ".gait", "chats");
+export async function GET(c) {
+    try {
+        // Ensure chats directory exists
+        await mkdir(CHATS_DIR, { recursive: true });
+        const files = await readdir(CHATS_DIR);
+        const chatFiles = files.filter(f => f.endsWith('.json'));
+        const chats = await Promise.all(chatFiles.map(async (file) => {
+            const content = await readFile(join(CHATS_DIR, file), 'utf8');
+            return JSON.parse(content);
+        }));
+        // Sort by updatedAt descending
+        chats.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+        return c.json({ chats });
+    }
+    catch (error) {
+        console.error("Error reading chats:", error);
+        return c.json({ error: "Failed to read chats" }, 500);
+    }
+}
+export async function POST(c) {
+    try {
+        const body = await c.req.json();
+        const { messages, model, context, title } = body;
+        if (!messages || !Array.isArray(messages)) {
+            return c.json({ error: "Messages array is required" }, 400);
+        }
+        // Ensure chats directory exists
+        await mkdir(CHATS_DIR, { recursive: true });
+        const chatId = `chat-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const now = new Date().toISOString();
+        const chat = {
+            id: chatId,
+            title: title || generateChatTitle(messages),
+            messages: messages.map((msg) => ({
+                ...msg,
+                timestamp: msg.timestamp || now
+            })),
+            model: model || "anthropic/claude-sonnet-4",
+            context,
+            createdAt: now,
+            updatedAt: now
+        };
+        await writeFile(join(CHATS_DIR, `${chatId}.json`), JSON.stringify(chat, null, 2));
+        return c.json({
+            success: true,
+            chatId,
+            message: "Chat saved successfully"
+        });
+    }
+    catch (error) {
+        console.error("Error saving chat:", error);
+        return c.json({ error: "Failed to save chat" }, 500);
+    }
+}
+function generateChatTitle(messages) {
+    // Find the first user message
+    const firstUserMessage = messages.find(msg => msg.role === "user");
+    if (firstUserMessage) {
+        // Truncate to first 50 characters and add ellipsis if needed
+        const content = firstUserMessage.content.trim();
+        return content.length > 50 ? content.substring(0, 50) + "..." : content;
+    }
+    return "New Chat";
+}

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

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

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

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

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

@@ -0,0 +1,9 @@
+import { Context } from 'hono';
+export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    data: any;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;

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

@@ -0,0 +1,29 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+async function getConfigPath() {
+    // Use the same approach as FileStorageAdapter for consistency
+    const basePath = process.env.GAIT_DATA_PATH ?
+        path.resolve(process.env.GAIT_DATA_PATH, '.gait') :
+        path.resolve(process.cwd(), '.gait');
+    return path.join(basePath, 'config.json');
+}
+export async function GET(c) {
+    try {
+        const configPath = await getConfigPath();
+        if (!configPath) {
+            return c.json({ error: 'GAIT directory not found' }, 404);
+        }
+        const content = await fs.readFile(configPath, 'utf-8');
+        const config = JSON.parse(content);
+        return c.json({
+            success: true,
+            data: config
+        });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return c.json({ error: 'Config file not found' }, 404);
+        }
+        return c.json({ error: 'Failed to read config' }, 500);
+    }
+}

package/dist/routes/api/v1/context/[...path]/route.d.ts

@@ -0,0 +1,16 @@
+import { NextRequest } from 'next/server';
+export declare function GET(request: NextRequest, { params }: {
+    params: {
+        path: string[];
+    };
+}): Promise<any>;
+export declare function PUT(request: NextRequest, { params }: {
+    params: {
+        path: string[];
+    };
+}): Promise<any>;
+export declare function DELETE(request: NextRequest, { params }: {
+    params: {
+        path: string[];
+    };
+}): Promise<any>;

package/dist/routes/api/v1/context/[...path]/route.js

@@ -0,0 +1,107 @@
+import { NextResponse } from 'next/server';
+import { promises as fs } from 'fs';
+import path from 'path';
+async function getContextPath(relativePath) {
+    // Use the same approach as FileStorageAdapter for consistency
+    const basePath = process.env.GAIT_DATA_PATH ?
+        path.resolve(process.env.GAIT_DATA_PATH, '.gait') :
+        path.resolve(process.cwd(), '.gait');
+    const contextDir = path.join(basePath, 'context');
+    const contextPath = path.join(contextDir, ...relativePath);
+    return { contextPath, contextDir };
+}
+export async function GET(request, { params }) {
+    try {
+        const pathInfo = await getContextPath(params.path);
+        if (!pathInfo) {
+            return NextResponse.json({ error: 'GAIT directory not found' }, { status: 404 });
+        }
+        const { contextPath: filePath, contextDir } = pathInfo;
+        // Security check - ensure path is within context directory
+        if (!filePath.startsWith(contextDir)) {
+            return NextResponse.json({ error: 'Access denied' }, { status: 403 });
+        }
+        // Check if it's a directory or file
+        const stat = await fs.stat(filePath);
+        if (stat.isDirectory()) {
+            // Return directory listing
+            const files = await fs.readdir(filePath);
+            const fileList = await Promise.all(files.map(async (file) => {
+                const fileStats = await fs.stat(path.join(filePath, file));
+                return {
+                    name: file,
+                    isDirectory: fileStats.isDirectory(),
+                    size: fileStats.size,
+                    modified: fileStats.mtime
+                };
+            }));
+            return NextResponse.json({ files: fileList });
+        }
+        else {
+            // Return file content
+            const content = await fs.readFile(filePath, 'utf-8');
+            return new NextResponse(content, {
+                headers: {
+                    'Content-Type': 'text/plain; charset=utf-8',
+                },
+            });
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return NextResponse.json({ error: 'File not found' }, { status: 404 });
+        }
+        console.error('Error reading context file:', error);
+        return NextResponse.json({ error: 'Failed to read context file' }, { status: 500 });
+    }
+}
+export async function PUT(request, { params }) {
+    try {
+        const pathInfo = await getContextPath(params.path);
+        if (!pathInfo) {
+            return NextResponse.json({ error: 'GAIT directory not found' }, { status: 404 });
+        }
+        const { contextPath: filePath, contextDir } = pathInfo;
+        // Security check - ensure path is within context directory
+        if (!filePath.startsWith(contextDir)) {
+            return NextResponse.json({ error: 'Access denied' }, { status: 403 });
+        }
+        const content = await request.text();
+        // Basic validation for markdown files
+        if (filePath.endsWith('.md') && !content.startsWith('---')) {
+            return NextResponse.json({ error: 'Markdown files must start with YAML frontmatter (---)' }, { status: 400 });
+        }
+        // Ensure the directory exists
+        const dir = path.dirname(filePath);
+        await fs.mkdir(dir, { recursive: true });
+        // Write the file
+        await fs.writeFile(filePath, content, 'utf-8');
+        return NextResponse.json({ success: true });
+    }
+    catch (error) {
+        console.error('Error updating context file:', error);
+        return NextResponse.json({ error: 'Failed to update context file' }, { status: 500 });
+    }
+}
+export async function DELETE(request, { params }) {
+    try {
+        const pathInfo = await getContextPath(params.path);
+        if (!pathInfo) {
+            return NextResponse.json({ error: 'GAIT directory not found' }, { status: 404 });
+        }
+        const { contextPath: filePath, contextDir } = pathInfo;
+        // Security check - ensure path is within context directory
+        if (!filePath.startsWith(contextDir)) {
+            return NextResponse.json({ error: 'Access denied' }, { status: 403 });
+        }
+        await fs.unlink(filePath);
+        return NextResponse.json({ success: true });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return NextResponse.json({ error: 'File not found' }, { status: 404 });
+        }
+        console.error('Error deleting context file:', error);
+        return NextResponse.json({ error: 'Failed to delete context file' }, { status: 500 });
+    }
+}

package/dist/routes/api/v1/context/architecture/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;