tarsk 0.2.5 → 0.3.0

package/dist/routes/git.js

@@ -0,0 +1,668 @@
+import { Hono } from 'hono';
+import { spawn } from 'child_process';
+import { resolve } from 'path';
+import { PROVIDERS } from '../provider.js';
+import { createSession } from '@neovate/code';
+// Helper function to generate commit message using AI
+async function generateCommitMessageWithAI(diff, metadataManager, model, provider) {
+    // Truncate diff if too long (keep first 3000 chars)
+    const truncatedDiff = diff.length > 3000 ? diff.substring(0, 3000) + '\n...(truncated)' : diff;
+    const prompt = `Based on the following git diff, generate a concise, conventional commit message. Follow these guidelines:
+- Use conventional commit format: type(scope): description
+- Types: feat, fix, docs, style, refactor, test, chore
+- Keep it under 72 characters
+- Be specific and descriptive
+- Focus on what changed and why
+
+Git diff:
+${truncatedDiff}
+
+Generate only the commit message, nothing else:`;
+    let session = null;
+    try {
+        const providerKeys = await metadataManager.getProviderKeys();
+        let selectedProvider = null;
+        let apiKey = null;
+        let selectedModel = model;
+        // If provider is specified, use it
+        if (provider) {
+            selectedProvider = PROVIDERS.find(p => p.name.toLowerCase() === provider.toLowerCase()) || null;
+            if (selectedProvider) {
+                // Try environment variable first
+                if (selectedProvider.keyName) {
+                    apiKey = process.env[selectedProvider.keyName] || null;
+                }
+                // Fall back to configured key
+                if (!apiKey) {
+                    apiKey = providerKeys[selectedProvider.name] || null;
+                }
+            }
+        }
+        // If no provider specified or provider not found, use priority order
+        if (!selectedProvider || !apiKey) {
+            const providerPriority = ['Anthropic', 'OpenAI', 'OpenRouter', 'Groq', 'DeepSeek'];
+            // First try environment variables for priority providers
+            for (const providerName of providerPriority) {
+                const prov = PROVIDERS.find(p => p.name === providerName);
+                if (prov?.keyName) {
+                    const envKey = process.env[prov.keyName];
+                    if (envKey) {
+                        selectedProvider = prov;
+                        apiKey = envKey;
+                        break;
+                    }
+                }
+            }
+            // If no env key found, try configured keys
+            if (!selectedProvider || !apiKey) {
+                for (const providerName of providerPriority) {
+                    const prov = PROVIDERS.find(p => p.name === providerName);
+                    if (prov && providerKeys[prov.name]) {
+                        selectedProvider = prov;
+                        apiKey = providerKeys[prov.name];
+                        break;
+                    }
+                }
+            }
+            // Fallback to any available provider
+            if (!selectedProvider || !apiKey) {
+                for (const prov of PROVIDERS) {
+                    if (prov.api && prov.keyName) {
+                        const envKey = process.env[prov.keyName];
+                        if (envKey) {
+                            selectedProvider = prov;
+                            apiKey = envKey;
+                            break;
+                        }
+                        if (providerKeys[prov.name]) {
+                            selectedProvider = prov;
+                            apiKey = providerKeys[prov.name];
+                            break;
+                        }
+                    }
+                }
+            }
+            // Select default model if not provided
+            if (!selectedModel) {
+                const modelMap = {
+                    'Anthropic': 'claude-3-5-sonnet-20241022',
+                    'OpenAI': 'gpt-4o-mini',
+                    'OpenRouter': 'anthropic/claude-3.5-sonnet',
+                    'Groq': 'llama-3.3-70b-versatile',
+                    'DeepSeek': 'deepseek-chat',
+                };
+                selectedModel = modelMap[selectedProvider?.name || ''] || 'default';
+            }
+        }
+        if (!selectedProvider || !apiKey || !selectedProvider.api) {
+            throw new Error('No AI provider configured. Please configure an API key in settings.');
+        }
+        // Remove provider prefix from model if present
+        if (selectedModel && selectedProvider) {
+            selectedModel = selectedModel.replace(`${selectedProvider.name.toLowerCase()}/`, '');
+        }
+        const finalModel = selectedModel || 'default';
+        const providers = {
+            tarsk: {
+                api: selectedProvider.api,
+                options: { apiKey },
+                models: { [finalModel]: finalModel },
+            },
+        };
+        const sessionConfig = {
+            model: `tarsk/${finalModel}`,
+            cwd: process.cwd(),
+            productName: 'Tarsk.io',
+            providers,
+        };
+        session = await createSession(sessionConfig);
+        await session.send(prompt);
+        let commitMessage = '';
+        for await (const msg of session.receive()) {
+            if (msg?.type === 'message' || msg?.type === 'result') {
+                const content = typeof msg.text === 'string' ? msg.text :
+                    typeof msg.content === 'string' ? msg.content :
+                        JSON.stringify(msg.content);
+                commitMessage = content.trim();
+                if (msg?.type === 'result')
+                    break;
+            }
+        }
+        // Clean up the message (remove quotes if present)
+        commitMessage = commitMessage.replace(/^["']|["']$/g, '').trim();
+        return commitMessage || 'Update files';
+    }
+    catch (error) {
+        console.error('Failed to generate AI commit message:', error);
+        // Fallback to a simple message
+        return 'Update files';
+    }
+    finally {
+        if (session) {
+            try {
+                await session.close?.();
+            }
+            catch (closeError) {
+                console.error('Error closing session:', closeError);
+            }
+        }
+    }
+}
+export function createGitRoutes(metadataManager) {
+    const router = new Hono();
+    // GET /api/git/username - returns the git user.name from local git config
+    router.get('/username', async (c) => {
+        try {
+            const name = await new Promise((resolve, reject) => {
+                const proc = spawn('git', ['config', 'user.name']);
+                let out = '';
+                let err = '';
+                proc.stdout.on('data', (d) => { out += d.toString(); });
+                proc.stderr.on('data', (d) => { err += d.toString(); });
+                proc.on('close', (code) => {
+                    if (code === 0) {
+                        resolve(out.trim());
+                    }
+                    else {
+                        reject(new Error(err.trim() || `git exited ${code}`));
+                    }
+                });
+                proc.on('error', (_e) => reject(new Error('Failed to run git config')));
+            });
+            return c.json({ name });
+        }
+        catch {
+            // Silently return empty name if git config fails
+            return c.json({ name: '' });
+        }
+    });
+    // GET /api/git/status/:threadId - returns git status for a thread
+    router.get('/status/:threadId', async (c) => {
+        try {
+            const threadId = c.req.param('threadId');
+            const thread = await metadataManager.loadThreads().then(threads => threads.find(t => t.id === threadId));
+            if (!thread) {
+                return c.json({ error: 'Thread not found' }, 404);
+            }
+            const repoPath = thread.path;
+            if (!repoPath) {
+                return c.json({ error: 'Thread path not found' }, 404);
+            }
+            // Resolve absolute path - thread.path is already relative to process.cwd()
+            const absolutePath = resolve(repoPath);
+            // Check for uncommitted changes and count files
+            const { hasChanges, changedFilesCount } = await new Promise((resolve) => {
+                const proc = spawn('git', ['status', '--porcelain'], { cwd: absolutePath });
+                let out = '';
+                proc.stdout.on('data', (d) => { out += d.toString(); });
+                proc.on('close', () => {
+                    const lines = out.trim().split('\n').filter(line => line.length > 0);
+                    resolve({
+                        hasChanges: lines.length > 0,
+                        changedFilesCount: lines.length
+                    });
+                });
+                proc.on('error', () => resolve({ hasChanges: false, changedFilesCount: 0 }));
+            });
+            // Get current branch
+            const currentBranch = await new Promise((resolve) => {
+                const proc = spawn('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: absolutePath });
+                let out = '';
+                proc.stdout.on('data', (d) => { out += d.toString(); });
+                proc.on('close', () => {
+                    resolve(out.trim());
+                });
+                proc.on('error', () => resolve(''));
+            });
+            // Check if there are unpushed commits
+            const hasUnpushedCommits = await new Promise((resolve) => {
+                const proc = spawn('git', ['log', `origin/${currentBranch}..HEAD`, '--oneline'], { cwd: absolutePath });
+                let out = '';
+                proc.stdout.on('data', (d) => { out += d.toString(); });
+                proc.on('close', () => {
+                    resolve(out.trim().length > 0);
+                });
+                proc.on('error', () => resolve(false));
+            });
+            return c.json({
+                hasChanges,
+                changedFilesCount,
+                currentBranch,
+                hasUnpushedCommits
+            });
+        }
+        catch {
+            return c.json({ error: 'Failed to get git status' }, 500);
+        }
+    });
+    // POST /api/git/generate-commit-message/:threadId - generates AI commit message
+    router.post('/generate-commit-message/:threadId', async (c) => {
+        try {
+            const threadId = c.req.param('threadId');
+            const body = await c.req.json().catch(() => ({}));
+            const { model, provider } = body;
+            const thread = await metadataManager.loadThreads().then(threads => threads.find(t => t.id === threadId));
+            if (!thread) {
+                return c.json({ error: 'Thread not found' }, 404);
+            }
+            const repoPath = thread.path;
+            if (!repoPath) {
+                return c.json({ error: 'Thread path not found' }, 404);
+            }
+            // Resolve absolute path - thread.path is already relative to process.cwd()
+            const absolutePath = resolve(repoPath);
+            // Get git diff
+            const diff = await new Promise((resolve, reject) => {
+                const proc = spawn('git', ['diff', '--cached'], { cwd: absolutePath });
+                let out = '';
+                let err = '';
+                proc.stdout.on('data', (d) => { out += d.toString(); });
+                proc.stderr.on('data', (d) => { err += d.toString(); });
+                proc.on('close', (code) => {
+                    if (code === 0) {
+                        // If no staged changes, get unstaged diff
+                        if (!out.trim()) {
+                            const proc2 = spawn('git', ['diff'], { cwd: absolutePath });
+                            let out2 = '';
+                            proc2.stdout.on('data', (d) => { out2 += d.toString(); });
+                            proc2.on('close', () => resolve(out2));
+                            proc2.on('error', reject);
+                        }
+                        else {
+                            resolve(out);
+                        }
+                    }
+                    else {
+                        reject(new Error(err || 'Failed to get git diff'));
+                    }
+                });
+                proc.on('error', reject);
+            });
+            if (!diff.trim()) {
+                return c.json({ error: 'No changes to generate commit message for' }, 400);
+            }
+            // Use AI to generate commit message
+            const commitMessage = await generateCommitMessageWithAI(diff, metadataManager, model, provider);
+            return c.json({ message: commitMessage });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to generate commit message';
+            return c.json({ error: message }, 500);
+        }
+    });
+    // POST /api/git/commit/:threadId - commits changes
+    router.post('/commit/:threadId', async (c) => {
+        try {
+            const threadId = c.req.param('threadId');
+            const body = await c.req.json();
+            const { message } = body;
+            if (!message) {
+                return c.json({ error: 'Commit message is required' }, 400);
+            }
+            const thread = await metadataManager.loadThreads().then(threads => threads.find(t => t.id === threadId));
+            if (!thread) {
+                return c.json({ error: 'Thread not found' }, 404);
+            }
+            const repoPath = thread.path;
+            if (!repoPath) {
+                return c.json({ error: 'Thread path not found' }, 404);
+            }
+            // Resolve absolute path - thread.path is already relative to process.cwd()
+            const absolutePath = resolve(repoPath);
+            // Stage all changes
+            await new Promise((resolve, reject) => {
+                const proc = spawn('git', ['add', '-A'], { cwd: absolutePath });
+                proc.on('close', (code) => {
+                    if (code === 0)
+                        resolve();
+                    else
+                        reject(new Error('Failed to stage changes'));
+                });
+                proc.on('error', reject);
+            });
+            // Commit changes
+            await new Promise((resolve, reject) => {
+                const proc = spawn('git', ['commit', '-m', message], { cwd: absolutePath });
+                proc.on('close', (code) => {
+                    if (code === 0)
+                        resolve();
+                    else
+                        reject(new Error('Failed to commit changes'));
+                });
+                proc.on('error', reject);
+            });
+            return c.json({ success: true });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to commit changes';
+            return c.json({ error: message }, 500);
+        }
+    });
+    // POST /api/git/push/:threadId - pushes commits
+    router.post('/push/:threadId', async (c) => {
+        try {
+            const threadId = c.req.param('threadId');
+            const thread = await metadataManager.loadThreads().then(threads => threads.find(t => t.id === threadId));
+            if (!thread) {
+                return c.json({ error: 'Thread not found' }, 404);
+            }
+            const repoPath = thread.path;
+            if (!repoPath) {
+                return c.json({ error: 'Thread path not found' }, 404);
+            }
+            // Resolve absolute path - thread.path is already relative to process.cwd()
+            const absolutePath = resolve(repoPath);
+            // Get current branch
+            const currentBranch = await new Promise((resolve, reject) => {
+                const proc = spawn('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: absolutePath });
+                let out = '';
+                proc.stdout.on('data', (d) => { out += d.toString(); });
+                proc.on('close', () => resolve(out.trim()));
+                proc.on('error', reject);
+            });
+            // Push to origin
+            await new Promise((resolve, reject) => {
+                const proc = spawn('git', ['push', '-u', 'origin', currentBranch], { cwd: absolutePath });
+                let err = '';
+                proc.stderr.on('data', (d) => { err += d.toString(); });
+                proc.on('close', (code) => {
+                    if (code === 0)
+                        resolve();
+                    else
+                        reject(new Error(err || 'Failed to push changes'));
+                });
+                proc.on('error', reject);
+            });
+            return c.json({ success: true });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to push changes';
+            return c.json({ error: message }, 500);
+        }
+    });
+    // POST /api/git/generate-pr-info/:threadId - generates AI PR title and description
+    router.post('/generate-pr-info/:threadId', async (c) => {
+        try {
+            const threadId = c.req.param('threadId');
+            const body = await c.req.json().catch(() => ({}));
+            const { model, provider } = body;
+            const thread = await metadataManager.loadThreads().then(threads => threads.find(t => t.id === threadId));
+            if (!thread) {
+                return c.json({ error: 'Thread not found' }, 404);
+            }
+            const repoPath = thread.path;
+            if (!repoPath) {
+                return c.json({ error: 'Thread path not found' }, 404);
+            }
+            // Resolve absolute path - thread.path is already relative to process.cwd()
+            const absolutePath = resolve(repoPath);
+            // Get git diff - check both staged and unstaged changes
+            const diff = await new Promise((resolve, reject) => {
+                const proc = spawn('git', ['diff', 'HEAD'], { cwd: absolutePath });
+                let out = '';
+                let err = '';
+                proc.stdout.on('data', (d) => { out += d.toString(); });
+                proc.stderr.on('data', (d) => { err += d.toString(); });
+                proc.on('close', (code) => {
+                    if (code === 0) {
+                        resolve(out);
+                    }
+                    else {
+                        reject(new Error(err || 'Failed to get git diff'));
+                    }
+                });
+                proc.on('error', reject);
+            });
+            if (!diff.trim()) {
+                return c.json({ error: 'No changes to generate PR info for. Make sure you have uncommitted changes.' }, 400);
+            }
+            // Truncate diff if too long (keep first 3000 chars)
+            const truncatedDiff = diff.length > 3000 ? diff.substring(0, 3000) + '\n...(truncated)' : diff;
+            const prompt = `Based on the following git diff, generate a pull request title and description. Follow these guidelines:
+- Title: Concise, descriptive, under 72 characters
+- Description: Clear explanation of changes, why they were made, and any relevant context
+- Use markdown formatting for the description
+- Be professional and clear
+
+Git diff:
+${truncatedDiff}
+
+Generate the response in this exact format:
+TITLE: <title here>
+DESCRIPTION: <description here>`;
+            let session = null;
+            try {
+                const providerKeys = await metadataManager.getProviderKeys();
+                let selectedProvider = null;
+                let apiKey = null;
+                let selectedModel = model;
+                // If provider is specified, use it
+                if (provider) {
+                    selectedProvider = PROVIDERS.find(p => p.name.toLowerCase() === provider.toLowerCase()) || null;
+                    if (selectedProvider) {
+                        // Try environment variable first
+                        if (selectedProvider.keyName) {
+                            apiKey = process.env[selectedProvider.keyName] || null;
+                        }
+                        // Fall back to configured key
+                        if (!apiKey) {
+                            apiKey = providerKeys[selectedProvider.name] || null;
+                        }
+                    }
+                }
+                // If no provider specified or provider not found, use priority order
+                if (!selectedProvider || !apiKey) {
+                    const providerPriority = ['Anthropic', 'OpenAI', 'OpenRouter', 'Groq', 'DeepSeek'];
+                    // First try environment variables for priority providers
+                    for (const providerName of providerPriority) {
+                        const prov = PROVIDERS.find(p => p.name === providerName);
+                        if (prov?.keyName) {
+                            const envKey = process.env[prov.keyName];
+                            if (envKey) {
+                                selectedProvider = prov;
+                                apiKey = envKey;
+                                break;
+                            }
+                        }
+                    }
+                    // If no env key found, try configured keys
+                    if (!selectedProvider || !apiKey) {
+                        for (const providerName of providerPriority) {
+                            const prov = PROVIDERS.find(p => p.name === providerName);
+                            if (prov && providerKeys[prov.name]) {
+                                selectedProvider = prov;
+                                apiKey = providerKeys[prov.name];
+                                break;
+                            }
+                        }
+                    }
+                    // Fallback to any available provider
+                    if (!selectedProvider || !apiKey) {
+                        for (const prov of PROVIDERS) {
+                            if (prov.api && prov.keyName) {
+                                const envKey = process.env[prov.keyName];
+                                if (envKey) {
+                                    selectedProvider = prov;
+                                    apiKey = envKey;
+                                    break;
+                                }
+                                if (providerKeys[prov.name]) {
+                                    selectedProvider = prov;
+                                    apiKey = providerKeys[prov.name];
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    // Select default model if not provided
+                    if (!selectedModel) {
+                        const modelMap = {
+                            'Anthropic': 'claude-3-5-sonnet-20241022',
+                            'OpenAI': 'gpt-4o-mini',
+                            'OpenRouter': 'anthropic/claude-3.5-sonnet',
+                            'Groq': 'llama-3.3-70b-versatile',
+                            'DeepSeek': 'deepseek-chat',
+                        };
+                        selectedModel = modelMap[selectedProvider?.name || ''] || 'default';
+                    }
+                }
+                if (!selectedProvider || !apiKey || !selectedProvider.api) {
+                    throw new Error('No AI provider configured. Please configure an API key in settings.');
+                }
+                // Remove provider prefix from model if present
+                if (selectedModel && selectedProvider) {
+                    selectedModel = selectedModel.replace(`${selectedProvider.name.toLowerCase()}/`, '');
+                }
+                const finalModel = selectedModel || 'default';
+                const providers = {
+                    tarsk: {
+                        api: selectedProvider.api,
+                        options: { apiKey },
+                        models: { [finalModel]: finalModel },
+                    },
+                };
+                const sessionConfig = {
+                    model: `tarsk/${finalModel}`,
+                    cwd: process.cwd(),
+                    productName: 'Tarsk.io',
+                    providers,
+                };
+                session = await createSession(sessionConfig);
+                await session.send(prompt);
+                let prInfo = '';
+                for await (const msg of session.receive()) {
+                    if (msg?.type === 'message' || msg?.type === 'result') {
+                        const content = typeof msg.text === 'string' ? msg.text :
+                            typeof msg.content === 'string' ? msg.content :
+                                JSON.stringify(msg.content);
+                        prInfo = content.trim();
+                        if (msg?.type === 'result')
+                            break;
+                    }
+                }
+                // Parse the response
+                const titleMatch = prInfo.match(/TITLE:\s*(.+?)(?:\nDESCRIPTION:|$)/s);
+                const descriptionMatch = prInfo.match(/DESCRIPTION:\s*(.+?)$/s);
+                const title = titleMatch ? titleMatch[1].trim() : 'Update';
+                const description = descriptionMatch ? descriptionMatch[1].trim() : '';
+                return c.json({ title, description });
+            }
+            finally {
+                if (session) {
+                    try {
+                        await session.close?.();
+                    }
+                    catch (closeError) {
+                        console.error('Error closing session:', closeError);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to generate PR info';
+            return c.json({ error: message }, 500);
+        }
+    });
+    // GET /api/git/log/:threadId - fetches git commit history
+    router.get('/log/:threadId', async (c) => {
+        try {
+            const threadId = c.req.param('threadId');
+            const limit = c.req.query('limit') ? parseInt(c.req.query('limit')) : 50;
+            const thread = await metadataManager.loadThreads().then(threads => threads.find(t => t.id === threadId));
+            if (!thread) {
+                return c.json({ error: 'Thread not found' }, 404);
+            }
+            const repoPath = thread.path;
+            if (!repoPath) {
+                return c.json({ error: 'Thread path not found' }, 404);
+            }
+            // Resolve absolute path - thread.path is already relative to process.cwd()
+            const absolutePath = resolve(repoPath);
+            // Get git log
+            const commits = await new Promise((resolve, reject) => {
+                const proc = spawn('git', ['log', '--oneline', '-n', limit.toString(), '--format=%H|%s|%an|%ai'], { cwd: absolutePath });
+                let out = '';
+                let err = '';
+                proc.stdout.on('data', (d) => { out += d.toString(); });
+                proc.stderr.on('data', (d) => { err += d.toString(); });
+                proc.on('close', (code) => {
+                    if (code === 0) {
+                        const lines = out.trim().split('\n').filter(line => line.length > 0);
+                        const parsed = lines.map(line => {
+                            const parts = line.split('|');
+                            return {
+                                hash: parts[0] || '',
+                                message: parts[1] || '',
+                                author: parts[2] || '',
+                                date: parts[3] || ''
+                            };
+                        });
+                        resolve(parsed);
+                    }
+                    else {
+                        reject(new Error(err || 'Failed to get git log'));
+                    }
+                });
+                proc.on('error', reject);
+            });
+            return c.json({ commits });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to fetch git log';
+            return c.json({ error: message }, 500);
+        }
+    });
+    // POST /api/git/create-pr/:threadId - creates a pull request
+    router.post('/create-pr/:threadId', async (c) => {
+        try {
+            const threadId = c.req.param('threadId');
+            const body = await c.req.json();
+            const { title, description } = body;
+            const thread = await metadataManager.loadThreads().then(threads => threads.find(t => t.id === threadId));
+            if (!thread) {
+                return c.json({ error: 'Thread not found' }, 404);
+            }
+            const repoPath = thread.path;
+            if (!repoPath) {
+                return c.json({ error: 'Thread path not found' }, 404);
+            }
+            // Resolve absolute path - thread.path is already relative to process.cwd()
+            const absolutePath = resolve(repoPath);
+            // Get current branch
+            const currentBranch = await new Promise((resolve, reject) => {
+                const proc = spawn('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: absolutePath });
+                let out = '';
+                proc.stdout.on('data', (d) => { out += d.toString(); });
+                proc.on('close', () => resolve(out.trim()));
+                proc.on('error', reject);
+            });
+            // Try to create PR using gh CLI
+            const prUrl = await new Promise((resolve, reject) => {
+                const args = ['pr', 'create', '--title', title || currentBranch, '--body', description || ''];
+                const proc = spawn('gh', args, { cwd: absolutePath });
+                let out = '';
+                let err = '';
+                proc.stdout.on('data', (d) => { out += d.toString(); });
+                proc.stderr.on('data', (d) => { err += d.toString(); });
+                proc.on('close', (code) => {
+                    if (code === 0) {
+                        // Extract URL from output
+                        const urlMatch = out.match(/https:\/\/[^\s]+/);
+                        resolve(urlMatch ? urlMatch[0] : out.trim());
+                    }
+                    else {
+                        reject(new Error(err || 'Failed to create PR'));
+                    }
+                });
+                proc.on('error', () => reject(new Error('GitHub CLI (gh) not found. Please install it to create PRs.')));
+            });
+            return c.json({ success: true, prUrl });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to create PR';
+            return c.json({ error: message }, 500);
+        }
+    });
+    return router;
+}
+//# sourceMappingURL=git.js.map

package/dist/routes/models.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Model routes for the REST API
+ *
+ * Handles all model-related operations:
+ * - GET /api/models - Get available models for a provider
+ * - POST /api/models/:provider/:modelId/enable - Enable a model
+ * - POST /api/models/:provider/:modelId/disable - Disable a model
+ * - GET /api/models/enabled - Get all enabled models
+ */
+import { Hono } from 'hono';
+import { MetadataManager } from '../managers/metadata-manager.js';
+/**
+ * Creates model routes
+ * @param metadataManager - Manager for metadata persistence
+ * @returns Hono router with model routes
+ */
+export declare function createModelRoutes(metadataManager: MetadataManager): Hono;
+//# sourceMappingURL=models.d.ts.map