@lovelybunch/api 1.0.75-alpha.4 → 1.0.75-alpha.6

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

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

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

@@ -4,6 +4,8 @@ import { existsSync, readFileSync, promises as fs, createReadStream } from 'fs';
 import { fileURLToPath } from 'url';
 import readline from 'readline';
 import { ZodError } from 'zod';
+import { streamText, tool, jsonSchema, stepCountIs } from 'ai';
+import { createAnthropic } from '@ai-sdk/anthropic';
 import { getLogsDir, listProposals, getProposal, createProposal, updateProposal, deleteProposal, } from '@lovelybunch/core';
 import { proposalsFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool, roleContextTool } from '@lovelybunch/mcp';
 import matter from 'gray-matter';
@@ -37,279 +39,142 @@ function getGlobalApiKey(provider) {
 }
 export async function POST(c) {
     try {
-        const { message: userMessage, history, model, context, contextContent, agentPersona, systemPrompt: systemOverride, maxTokens, enableTools, attachedContextFiles, stream } = await c.req.json();
+        const { message: userMessage, history, context, contextContent, skillPersona, agentPersona, systemPrompt: systemOverride, attachedContextFiles } = await c.req.json();
         if (!userMessage) {
             return c.json({ error: "Message is required" }, 400);
         }
         // Prefer global config key (set via CLI/UI), fallback to env var
-        let openRouterKey = getGlobalApiKey('openrouter') || process.env.OPENROUTER_API_KEY;
-        if (!openRouterKey) {
+        const apiKey = getGlobalApiKey('anthropic') || process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
             return c.json({
-                error: "OpenRouter API key not configured",
-                hint: "Set via 'coconut config set-key -p openrouter -k <KEY>' (or 'nut config set-key -p openrouter -k <KEY>'), or set OPENROUTER_API_KEY env var"
+                error: "Anthropic API key not configured",
+                hint: "Set via 'coconut config set-key -p anthropic -k <KEY>' (or 'nut config set-key -p anthropic -k <KEY>'), or set ANTHROPIC_API_KEY env var"
             }, 500);
         }
+        // Initialize Anthropic model via AI SDK
+        const anthropicClient = createAnthropic({ apiKey });
+        const model = anthropicClient('claude-sonnet-4-5-20250929');
         const baseSystem = systemOverride || getSystemPrompt();
-        const systemPrompt = agentPersona
-            ? `${baseSystem}\n\nThe following persona is authoritative and overrides general guidance above. You must strictly follow it.\n\n${agentPersona}`
+        const persona = skillPersona || agentPersona; // Support both new and legacy field names
+        const systemPrompt = persona
+            ? `${baseSystem}\n\nThe following persona is authoritative and overrides general guidance above. You must strictly follow it.\n\n${persona}`
             : baseSystem;
-        // Prepare tools for function calling
-        // Note: proposals/knowledge/project/architecture are read+write, events is read-only
-        const tools = enableTools ? [
-            {
-                type: "function",
-                function: proposalsFullTool
-            },
-            {
-                type: "function",
-                function: knowledgeTool
-            },
-            {
-                type: "function",
-                function: eventsTool
-            },
-            {
-                type: "function",
-                function: projectContextTool
-            },
-            {
-                type: "function",
-                function: architectureContextTool
-            },
-            {
-                type: "function",
-                function: roleContextTool
+        // Build context messages from attached files
+        const contextMessages = [];
+        if (Array.isArray(attachedContextFiles)) {
+            for (const file of attachedContextFiles) {
+                if (file && typeof file.content === 'string' && file.content.trim().length > 0) {
+                    contextMessages.push({
+                        role: 'user',
+                        content: `[ATTACHED CONTEXT - FULL CONTENT INCLUDED BELOW - DO NOT USE TOOLS TO FETCH THIS FILE]\nDocument: ${file.name || file.path || 'reference'}\nType: ${file.type || 'context'}\n\n--- BEGIN CONTENT ---\n${file.content}\n--- END CONTENT ---`
+                    });
+                    // Add a brief assistant acknowledgment so the conversation alternates correctly
+                    contextMessages.push({
+                        role: 'assistant',
+                        content: `I've noted the attached context document "${file.name || 'reference'}". I'll reference it as needed.`
+                    });
+                }
             }
-        ] : null;
-        const contextMessages = Array.isArray(attachedContextFiles)
-            ? attachedContextFiles
-                .filter((file) => file && typeof file.content === 'string' && file.content.trim().length > 0)
-                .map((file) => ({
-                role: 'system',
-                content: `[ATTACHED CONTEXT - FULL CONTENT INCLUDED BELOW - DO NOT USE TOOLS TO FETCH THIS FILE]\nDocument: ${file.name || file.path || 'reference'}\nType: ${file.type || 'context'}\n\n--- BEGIN CONTENT ---\n${file.content}\n--- END CONTENT ---`
-            }))
-            : [];
-        // Compose the message list: system + history (preferred) or single message
+        }
+        // Compose the message list: history (preferred) or single message
         let messagesPayload;
         if (Array.isArray(history) && history.length > 0) {
-            // sanitize roles to user/assistant only, preserve order
-            const sanitized = history.filter(m => m && (m.role === 'user' || m.role === 'assistant') && typeof m.content === 'string');
+            // Sanitize roles to user/assistant only, preserve order
+            const sanitized = history.filter((m) => m && (m.role === 'user' || m.role === 'assistant') && typeof m.content === 'string');
             messagesPayload = [
-                { role: 'system', content: systemPrompt },
                 ...contextMessages,
                 ...sanitized,
             ];
         }
         else {
             messagesPayload = [
-                { role: 'system', content: systemPrompt },
                 ...contextMessages,
                 { role: 'user', content: userMessage },
             ];
         }
-        const requestBody = {
-            model: model || "openai/gpt-4o",
-            messages: messagesPayload,
-            temperature: 0.7,
-            max_tokens: typeof maxTokens === 'number' ? Math.max(256, Math.min(8000, Math.floor(maxTokens))) : 8000,
-            stream: stream === true,
+        // Define tools with execute functions using AI SDK tool()
+        // Using tool<any, string>() to properly type jsonSchema-based tools
+        const storage = new FileStorageAdapter();
+        const aiTools = {
+            change_proposals: tool({
+                description: proposalsFullTool.description,
+                inputSchema: jsonSchema(proposalsFullTool.parameters),
+                execute: async (args) => {
+                    const result = await executeProposalsToolDirect(args, storage);
+                    return JSON.stringify(result);
+                },
+            }),
+            knowledge_documents: tool({
+                description: knowledgeTool.description,
+                inputSchema: jsonSchema(knowledgeTool.parameters),
+                execute: async (args) => {
+                    const result = await executeKnowledgeToolDirect(args);
+                    return JSON.stringify(result);
+                },
+            }),
+            activity_events: tool({
+                description: eventsTool.description,
+                inputSchema: jsonSchema(eventsTool.parameters),
+                execute: async (args) => {
+                    const result = await executeEventsToolDirect(args);
+                    return JSON.stringify(result);
+                },
+            }),
+            project_context: tool({
+                description: projectContextTool.description,
+                inputSchema: jsonSchema(projectContextTool.parameters),
+                execute: async (args) => {
+                    const result = await executeProjectContextToolDirect(args);
+                    return JSON.stringify(result);
+                },
+            }),
+            architecture_context: tool({
+                description: architectureContextTool.description,
+                inputSchema: jsonSchema(architectureContextTool.parameters),
+                execute: async (args) => {
+                    const result = await executeArchitectureContextToolDirect(args);
+                    return JSON.stringify(result);
+                },
+            }),
+            role_context: tool({
+                description: roleContextTool.description,
+                inputSchema: jsonSchema(roleContextTool.parameters),
+                execute: async (args) => {
+                    const result = await executeRoleContextToolDirect(args);
+                    return JSON.stringify(result);
+                },
+            }),
         };
-        // Add tools if enabled
-        if (tools) {
-            requestBody.tools = tools;
-            requestBody.tool_choice = "auto";
-        }
         // Debug logging
         console.log('AI Request Debug:', {
-            enableTools,
-            tools: tools ? tools.length : 'null',
-            hasToolChoice: !!requestBody.tool_choice,
-            model: requestBody.model
+            toolCount: Object.keys(aiTools).length,
+            messageCount: messagesPayload.length,
+            model: 'claude-sonnet-4-5-20250929'
         });
-        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": "Coconut AI Assistant",
-            },
-            body: JSON.stringify(requestBody),
+        // Use AI SDK streamText - handles the entire LLM + tool loop automatically
+        const result = streamText({
+            model,
+            system: systemPrompt,
+            messages: messagesPayload,
+            tools: aiTools,
+            stopWhen: stepCountIs(5), // Max 5 tool-use rounds
+            temperature: 0.7,
+            maxOutputTokens: 8000,
         });
-        if (!response.ok) {
-            const errorText = await response.text();
-            console.error("OpenRouter API error:", {
-                status: response.status,
-                statusText: response.statusText,
-                error: errorText,
-                model: requestBody.model
-            });
-            // Try to parse error for more detail
-            let errorDetail = "Failed to get AI response";
-            try {
-                const errorJson = JSON.parse(errorText);
-                errorDetail = errorJson.error?.message || errorJson.error || errorDetail;
-            }
-            catch {
-                // Use raw text if not JSON
-                if (errorText.length < 200) {
-                    errorDetail = errorText || errorDetail;
-                }
-            }
-            return c.json({ error: errorDetail, status: response.status }, response.status);
-        }
-        // Handle streaming response
-        if (stream === true && response.body) {
-            return c.newResponse(response.body, {
-                status: 200,
-                headers: {
-                    'Content-Type': 'text/event-stream',
-                    'Cache-Control': 'no-cache',
-                    'Connection': 'keep-alive',
-                },
-            });
-        }
-        const data = await response.json();
-        const aiMessage = data.choices?.[0]?.message;
-        if (!aiMessage) {
-            console.error("No AI message in response:", {
-                model: requestBody.model,
-                choices: data.choices,
-                error: data.error
-            });
-            const errorDetail = data.error?.message || data.error || "No response from AI model";
-            return c.json({ error: errorDetail }, 500);
-        }
-        // Handle tool calls
-        if (aiMessage.tool_calls && aiMessage.tool_calls.length > 0) {
-            const toolResults = await executeToolCalls(aiMessage.tool_calls);
-            // Add tool results to the conversation and get final response
-            const messagesWithTools = [
-                ...messagesPayload,
-                aiMessage,
-                ...toolResults.map(result => ({
-                    role: 'tool',
-                    content: result.content,
-                    tool_call_id: result.tool_call_id
-                }))
-            ];
-            // Get final response from AI with tool results
-            // Use lower max_tokens for tool result synthesis (typically just needs to summarize)
-            const finalResponse = 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": "Coconut AI Assistant",
-                },
-                body: JSON.stringify({
-                    model: model || "openai/gpt-4o",
-                    messages: messagesWithTools,
-                    temperature: 0.5, // Lower temperature for more consistent tool result summaries
-                    max_tokens: 2000, // Reduced from 8000 - tool summaries don't need to be as long
-                }),
-            });
-            if (!finalResponse.ok) {
-                const error = await finalResponse.text();
-                console.error("OpenRouter API error for final response:", error);
-                return c.json({ error: "Failed to get final AI response" }, 500);
-            }
-            const finalData = await finalResponse.json();
-            const finalMessage = finalData.choices?.[0]?.message;
-            return c.json({
-                response: finalMessage?.content || "Tool execution completed",
-                toolCalls: aiMessage.tool_calls,
-                toolResults: toolResults
-            });
-        }
-        return c.json({ response: aiMessage.content });
+        // Return a plain text stream response
+        // toTextStreamResponse() streams text-delta events as UTF-8 chunks,
+        // ignoring tool calls, tool results, and other non-text events
+        return result.toTextStreamResponse();
     }
     catch (error) {
         console.error("AI API error:", error);
         return c.json({ error: "Internal server error" }, 500);
     }
 }
-async function executeToolCalls(toolCalls) {
-    const storage = new FileStorageAdapter();
-    // Execute all tool calls in parallel for better performance
-    const resultPromises = toolCalls.map(async (toolCall) => {
-        try {
-            // Handle both function calling formats
-            const functionName = toolCall.function?.name || toolCall.name;
-            let functionArgs;
-            if (toolCall.function?.arguments) {
-                try {
-                    // Try to sanitize common JSON issues before parsing
-                    let argsStr = toolCall.function.arguments;
-                    // Remove trailing commas before ] or }
-                    argsStr = argsStr.replace(/,(\s*[}\]])/g, '$1');
-                    // Fix common LLM JSON issues:
-                    // Remove control characters (except \n, \r, \t which are valid in JSON strings)
-                    argsStr = argsStr.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '');
-                    functionArgs = JSON.parse(argsStr);
-                }
-                catch (parseError) {
-                    // LLM may generate invalid JSON with unescaped characters in long content
-                    const errorMsg = parseError instanceof Error ? parseError.message : 'Unknown parse error';
-                    const hint = errorMsg.includes('position')
-                        ? 'The content may contain unescaped quotes or special characters. Try updating with shorter/simpler content, or update one field at a time.'
-                        : 'Please retry with simpler content.';
-                    return {
-                        tool_call_id: toolCall.id,
-                        content: JSON.stringify({
-                            success: false,
-                            error: `Invalid tool arguments: ${errorMsg}. ${hint}`
-                        })
-                    };
-                }
-            }
-            else {
-                functionArgs = toolCall.arguments;
-            }
-            let result = { success: false, error: 'Unknown tool' };
-            // Execute tools directly instead of making HTTP requests
-            if (functionName === 'change_proposals') {
-                result = await executeProposalsToolDirect(functionArgs, storage);
-            }
-            else if (functionName === 'knowledge_documents') {
-                result = await executeKnowledgeToolDirect(functionArgs);
-            }
-            else if (functionName === 'activity_events') {
-                result = await executeEventsToolDirect(functionArgs);
-            }
-            else if (functionName === 'project_context') {
-                result = await executeProjectContextToolDirect(functionArgs);
-            }
-            else if (functionName === 'architecture_context') {
-                result = await executeArchitectureContextToolDirect(functionArgs);
-            }
-            else if (functionName === 'role_context') {
-                result = await executeRoleContextToolDirect(functionArgs);
-            }
-            return {
-                tool_call_id: toolCall.id,
-                content: JSON.stringify({
-                    success: result.success,
-                    data: result.data,
-                    message: result.message,
-                    error: result.error
-                })
-            };
-        }
-        catch (error) {
-            return {
-                tool_call_id: toolCall.id,
-                content: JSON.stringify({
-                    success: false,
-                    error: error instanceof Error ? error.message : 'Unknown error'
-                })
-            };
-        }
-    });
-    return Promise.all(resultPromises);
-}
-// Proposals tool - full CRUD operations using @lovelybunch/core
+// ─── Tool Execution Functions ────────────────────────────────────────────────
+// These are unchanged from the previous implementation. They handle the actual
+// business logic for each tool, called automatically by the AI SDK when the
+// LLM makes tool calls.
 async function executeProposalsToolDirect(args, _storage) {
     const { operation, id, filters, proposal, updates } = args;
     try {
@@ -381,7 +246,6 @@ async function executeProposalsToolDirect(args, _storage) {
         }
     }
     catch (error) {
-        // Handle Zod validation errors specially
         if (error instanceof ZodError) {
             return {
                 success: false,
@@ -953,6 +817,7 @@ async function executeRoleContextToolDirect(args) {
         return { success: false, error: error.message || 'Role context tool execution failed' };
     }
 }
+// ─── Helper Functions ────────────────────────────────────────────────────────
 function getContextBasePath() {
     let basePath;
     if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
@@ -1017,14 +882,14 @@ async function readKnowledgeDocument(basePath, filename) {
         fs.stat(filePath)
     ]);
     const { data, content } = matter(raw);
-    const metadata = normalizeKnowledgeMetadata(data);
+    const normalizedMeta = normalizeKnowledgeMetadata(data);
     // Use file mtime for updated timestamp instead of frontmatter
-    metadata.updated = stats.mtime.toISOString();
+    normalizedMeta.updated = stats.mtime.toISOString();
     const title = extractKnowledgeTitle(content, actualFilename);
     return {
         filename: actualFilename,
         title,
-        metadata,
+        metadata: normalizedMeta,
         content
     };
 }

package/dist/routes/api/v1/skills/[id]/index.d.ts

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

package/dist/routes/api/v1/skills/[id]/index.js

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

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

@@ -0,0 +1,199 @@
+import { Hono } from 'hono';
+import { promises as fs } from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+const app = new Hono();
+function generateSkillId(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/--+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+function getSkillsPath() {
+    let basePath;
+    if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
+        basePath = process.env.GAIT_DEV_ROOT;
+    }
+    else if (process.env.GAIT_DATA_PATH) {
+        basePath = path.resolve(process.env.GAIT_DATA_PATH, '.nut');
+    }
+    else {
+        basePath = path.resolve(process.cwd(), '.nut');
+    }
+    return path.join(basePath, 'skills');
+}
+/**
+ * GET /api/v1/skills/:id
+ * Load a specific skill document
+ */
+app.get('/', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const skillsPath = getSkillsPath();
+        const skillFile = path.join(skillsPath, id, 'SKILL.md');
+        const fileContent = await fs.readFile(skillFile, 'utf-8');
+        const { data, content } = matter(fileContent);
+        const nestedMeta = typeof data.metadata === 'object' ? data.metadata : undefined;
+        const document = {
+            id,
+            name: data.name || id,
+            description: data.description || '',
+            license: data.license,
+            compatibility: data.compatibility,
+            allowedTools: data['allowed-tools'] || data.allowedTools,
+            metadata: {
+                name: data.name || id,
+                description: data.description || '',
+                license: data.license,
+                compatibility: data.compatibility,
+                allowedTools: data['allowed-tools'] || data.allowedTools,
+                ...(nestedMeta || {}),
+                metadata: nestedMeta,
+            },
+            content,
+        };
+        return c.json({
+            success: true,
+            document
+        });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return c.json({ success: false, error: 'Skill document not found' }, 404);
+        }
+        console.error('Error loading skill document:', error);
+        return c.json({ success: false, error: 'Failed to load skill document' }, 500);
+    }
+});
+/**
+ * PUT /api/v1/skills/:id
+ * Update a specific skill document
+ */
+app.put('/', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const body = await c.req.json();
+        const skillsPath = getSkillsPath();
+        const skillDir = path.join(skillsPath, id);
+        const skillFile = path.join(skillDir, 'SKILL.md');
+        // Check if skill exists
+        try {
+            await fs.access(skillFile);
+        }
+        catch {
+            return c.json({ success: false, error: 'Skill document not found' }, 404);
+        }
+        // Read current content
+        const currentContent = await fs.readFile(skillFile, 'utf-8');
+        const { data: currentData, content: currentMarkdown } = matter(currentContent);
+        // Merge updates
+        const updatedContent = body.content !== undefined ? body.content : currentMarkdown;
+        const updatedDescription = body.description !== undefined ? body.description : (currentData.description || '');
+        const updatedLicense = body.license !== undefined ? body.license : currentData.license;
+        const updatedCompatibility = body.compatibility !== undefined ? body.compatibility : currentData.compatibility;
+        const updatedAllowedTools = body.allowedTools !== undefined ? body.allowedTools : (currentData['allowed-tools'] || currentData.allowedTools);
+        // Merge metadata
+        const currentMeta = typeof currentData.metadata === 'object' && currentData.metadata !== null ? currentData.metadata : {};
+        const updatedMeta = body.metadata
+            ? { ...currentMeta, ...body.metadata }
+            : currentMeta;
+        // Handle name change (directory rename)
+        let newId = id;
+        let newDir = skillDir;
+        if (body.name && body.name !== currentData.name) {
+            newId = generateSkillId(body.name);
+            newDir = path.join(skillsPath, newId);
+            if (newId !== id) {
+                try {
+                    await fs.access(path.join(newDir, 'SKILL.md'));
+                    return c.json({ success: false, error: 'A skill with this name already exists' }, 409);
+                }
+                catch {
+                    // Doesn't exist, proceed with rename
+                }
+            }
+        }
+        // Build updated frontmatter
+        const frontmatter = {
+            name: newId,
+            description: updatedDescription,
+        };
+        if (updatedLicense)
+            frontmatter.license = updatedLicense;
+        if (updatedCompatibility)
+            frontmatter.compatibility = updatedCompatibility;
+        if (updatedAllowedTools)
+            frontmatter['allowed-tools'] = updatedAllowedTools;
+        // Clean metadata
+        const cleanMeta = {};
+        for (const [key, value] of Object.entries(updatedMeta)) {
+            if (value !== undefined && value !== null) {
+                cleanMeta[key] = value;
+            }
+        }
+        if (Object.keys(cleanMeta).length > 0) {
+            frontmatter.metadata = cleanMeta;
+        }
+        const fileContent = matter.stringify(updatedContent, frontmatter);
+        if (newId !== id) {
+            // Create new directory and write file
+            await fs.mkdir(newDir, { recursive: true });
+            await fs.writeFile(path.join(newDir, 'SKILL.md'), fileContent, 'utf-8');
+            // Remove old directory
+            await fs.rm(skillDir, { recursive: true, force: true });
+        }
+        else {
+            await fs.writeFile(skillFile, fileContent, 'utf-8');
+        }
+        return c.json({
+            success: true,
+            document: {
+                id: newId,
+                name: newId,
+                description: updatedDescription,
+                metadata: {
+                    name: newId,
+                    description: updatedDescription,
+                    ...frontmatter,
+                    ...(typeof cleanMeta === 'object' ? cleanMeta : {}),
+                },
+                content: updatedContent
+            }
+        });
+    }
+    catch (error) {
+        console.error('Error updating skill document:', error);
+        return c.json({ success: false, error: 'Failed to update skill document' }, 500);
+    }
+});
+/**
+ * DELETE /api/v1/skills/:id
+ * Delete a specific skill document (removes entire skill directory)
+ */
+app.delete('/', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const skillsPath = getSkillsPath();
+        const skillDir = path.join(skillsPath, id);
+        // Check if skill exists
+        try {
+            await fs.access(path.join(skillDir, 'SKILL.md'));
+        }
+        catch {
+            return c.json({ success: false, error: 'Skill document not found' }, 404);
+        }
+        // Remove entire skill directory
+        await fs.rm(skillDir, { recursive: true, force: true });
+        return c.json({
+            success: true,
+            message: 'Skill document deleted successfully'
+        });
+    }
+    catch (error) {
+        console.error('Error deleting skill document:', error);
+        return c.json({ success: false, error: 'Failed to delete skill document' }, 500);
+    }
+});
+export default app;

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

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

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

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

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