@loom-framework/core 0.1.0-alpha.9 → 0.1.0-alpha.91

package/dist/backend/routes/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Routes - Barrel Export
+ */
+export { registerDataRoutes } from './data.js';
+export { registerHealthRoute } from './health.js';
+export { registerUploadRoutes, saveUploadedFile } from './upload.js';
+export { registerChatRoutes } from './chat.js';
+export type { ChatRouteOptions } from './chat.js';
+export { registerSkillRoutes } from './skills.js';
+export type { SkillRouteOptions } from './skills.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/backend/routes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/backend/routes/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,YAAY,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC"}

package/dist/backend/routes/index.js

@@ -0,0 +1,9 @@
+/**
+ * Routes - Barrel Export
+ */
+export { registerDataRoutes } from './data.js';
+export { registerHealthRoute } from './health.js';
+export { registerUploadRoutes, saveUploadedFile } from './upload.js';
+export { registerChatRoutes } from './chat.js';
+export { registerSkillRoutes } from './skills.js';
+//# sourceMappingURL=index.js.map

package/dist/backend/routes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/backend/routes/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAE/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC"}

package/dist/backend/routes/skills.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Skill Management Routes - REST API for managing skills in .claude/skills/
+ *
+ * POST /api/v1/skills         — Create a new skill
+ * GET  /api/v1/skills         — List all skills with metadata
+ * GET  /api/v1/skills/:skillName — Get skill details
+ * DELETE /api/v1/skills/:skillName — Delete a skill
+ * GET  /api/v1/skills/:skillName/file/:filePath — Get a file's content
+ * POST /api/v1/skills/:skillName/file — Upload/replace a file in a skill
+ */
+import type { FastifyInstance } from 'fastify';
+export interface SkillRouteOptions {
+    projectRoot: string;
+}
+export declare function registerSkillRoutes(fastify: FastifyInstance, options: SkillRouteOptions): void;
+//# sourceMappingURL=skills.d.ts.map

package/dist/backend/routes/skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../../../src/backend/routes/skills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AA2X/C,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,iBAAiB,GACzB,IAAI,CAoSN"}

package/dist/backend/routes/skills.js

@@ -0,0 +1,590 @@
+/**
+ * Skill Management Routes - REST API for managing skills in .claude/skills/
+ *
+ * POST /api/v1/skills         — Create a new skill
+ * GET  /api/v1/skills         — List all skills with metadata
+ * GET  /api/v1/skills/:skillName — Get skill details
+ * DELETE /api/v1/skills/:skillName — Delete a skill
+ * GET  /api/v1/skills/:skillName/file/:filePath — Get a file's content
+ * POST /api/v1/skills/:skillName/file — Upload/replace a file in a skill
+ */
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import AdmZip from 'adm-zip';
+// ── Schemas ──
+const skillNameParamSchema = {
+    type: 'object',
+    required: ['skillName'],
+    properties: {
+        skillName: { type: 'string', minLength: 1 },
+    },
+};
+const createSkillBodySchema = {
+    type: 'object',
+    required: ['name'],
+    properties: {
+        name: { type: 'string', minLength: 1, maxLength: 64 },
+        skillMd: { type: 'string' },
+        references: {
+            type: 'array',
+            items: {
+                type: 'object',
+                required: ['name', 'content'],
+                properties: {
+                    name: { type: 'string' },
+                    content: { type: 'string' },
+                },
+            },
+        },
+        scripts: {
+            type: 'array',
+            items: {
+                type: 'object',
+                required: ['name', 'content'],
+                properties: {
+                    name: { type: 'string' },
+                    content: { type: 'string' },
+                },
+            },
+        },
+        files: {
+            type: 'array',
+            items: {
+                type: 'object',
+                required: ['path', 'content'],
+                properties: {
+                    path: { type: 'string' },
+                    content: { type: 'string' },
+                },
+            },
+        },
+    },
+};
+const parseArchiveBodySchema = {
+    type: 'object',
+    required: ['data'],
+    properties: {
+        data: { type: 'string', minLength: 1 },
+    },
+};
+const uploadFileBodySchema = {
+    type: 'object',
+    required: ['filename', 'content'],
+    properties: {
+        filename: { type: 'string', minLength: 1 },
+        content: { type: 'string' },
+    },
+};
+// ── Helpers ─
+/**
+ * Parse YAML frontmatter from markdown content using simple regex.
+ */
+function parseFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!match)
+        return { metadata: {}, body: content };
+    try {
+        const metadata = {};
+        const lines = match[1].split('\n');
+        let currentKey = '';
+        let currentValues = [];
+        let inArray = false;
+        let inBlock = false;
+        let blockLines = [];
+        const flushBlock = () => {
+            if (inBlock && currentKey) {
+                metadata[currentKey] = blockLines.join('\n').trim();
+            }
+            inBlock = false;
+            blockLines = [];
+        };
+        for (const line of lines) {
+            if (inBlock) {
+                if (/^[ \t]+/.test(line) || (line === '' && blockLines.length > 0)) {
+                    blockLines.push(line.replace(/^[ \t]+/, ''));
+                    continue;
+                }
+                else {
+                    flushBlock();
+                }
+            }
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const arrayMatch = trimmed.match(/^-\s+(.+)$/);
+            if (inArray && arrayMatch) {
+                currentValues.push(arrayMatch[1].replace(/^['"]|['"]$/g, '').trim());
+                continue;
+            }
+            if (inArray && currentKey) {
+                metadata[currentKey] = currentValues;
+                inArray = false;
+                currentValues = [];
+            }
+            const kvMatch = trimmed.match(/^([a-zA-Z_-][a-zA-Z0-9_-]*):\s*(.*)$/);
+            if (kvMatch) {
+                currentKey = kvMatch[1];
+                let val = kvMatch[2].trim();
+                if ((val.startsWith("'") && val.endsWith("'")) || (val.startsWith('"') && val.endsWith('"'))) {
+                    val = val.slice(1, -1);
+                }
+                if (val === '|' || val === '>') {
+                    inBlock = true;
+                    blockLines = [];
+                    continue;
+                }
+                if (val === '[') {
+                    inArray = true;
+                    currentValues = [];
+                    continue;
+                }
+                if (val.startsWith('[') && val.endsWith(']')) {
+                    metadata[currentKey] = val.slice(1, -1).split(',').map((s) => s.trim().replace(/^['"]|['"]$/g, ''));
+                    currentKey = '';
+                    continue;
+                }
+                metadata[currentKey] = val;
+                currentKey = '';
+            }
+        }
+        if (inArray && currentKey) {
+            metadata[currentKey] = currentValues;
+        }
+        flushBlock();
+        return { metadata, body: match[2] || '' };
+    }
+    catch {
+        return { metadata: {}, body: content };
+    }
+}
+/**
+ * Recursively scan a directory for files, returning relative paths.
+ * Excludes SKILL.md (handled separately).
+ */
+async function scanDirFiles(dir, base) {
+    const results = [];
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return results;
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            const subFiles = await scanDirFiles(path.join(dir, entry.name), base);
+            results.push(...subFiles);
+        }
+        else {
+            const relPath = path.relative(base, path.join(dir, entry.name));
+            results.push(relPath);
+        }
+    }
+    return results;
+}
+/**
+ * Safely resolve a file path within a directory. Rejects '..' traversal.
+ */
+function safeResolve(baseDir, filePath) {
+    if (filePath.includes('..'))
+        return null;
+    const resolved = path.resolve(baseDir, filePath);
+    if (!resolved.startsWith(baseDir))
+        return null;
+    return resolved;
+}
+/**
+ * Validate skill name.
+ */
+function isValidSkillName(name) {
+    return /^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name);
+}
+/**
+ * Text file extensions that should be kept when parsing zip archives.
+ */
+const TEXT_EXTENSIONS = new Set([
+    '.md', '.json', '.yaml', '.yml', '.txt', '.ts', '.js', '.tsx', '.jsx',
+    '.xml', '.html', '.css', '.sh', '.py', '.rb', '.go', '.rs', '.java',
+    '.kt', '.swift', '.c', '.cpp', '.h', '.hpp', '.toml', '.ini', '.cfg',
+    '.env', '.gitignore', '.prettierrc', '.eslintrc', '.conf', '.properties',
+]);
+/**
+ * Check if a file path looks like a text file based on extension.
+ */
+function isTextFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (TEXT_EXTENSIONS.has(ext))
+        return true;
+    // Files with no extension but common names
+    const basename = path.basename(filePath).toLowerCase();
+    if (['readme', 'license', 'makefile', 'dockerfile', '.gitkeep', '.gitignore'].includes(basename))
+        return true;
+    if (basename.startsWith('.git'))
+        return true;
+    return false;
+}
+/**
+ * Parse a zip archive buffer and extract skill structure.
+ */
+function parseZipArchive(buffer) {
+    const zip = new AdmZip(buffer);
+    const entries = zip.getEntries();
+    // Collect valid file entries
+    const validEntries = entries.filter((entry) => {
+        if (entry.isDirectory)
+            return false;
+        const entryPath = entry.entryName;
+        // Skip macOS metadata
+        if (entryPath.startsWith('__MACOSX/'))
+            return false;
+        // Skip .DS_Store and hidden files in root
+        const parts = entryPath.split('/');
+        if (parts.some((p) => p.startsWith('.') && p !== '.gitkeep' && p !== '.gitignore'))
+            return false;
+        return true;
+    });
+    if (validEntries.length === 0) {
+        throw new Error('压缩包中没有任何有效文件');
+    }
+    // Detect common top-level directory prefix
+    let prefix = '';
+    const firstEntry = validEntries[0].entryName;
+    const slashIdx = firstEntry.indexOf('/');
+    if (slashIdx > 0) {
+        const candidate = firstEntry.substring(0, slashIdx + 1);
+        if (validEntries.every((e) => e.entryName.startsWith(candidate))) {
+            prefix = candidate;
+        }
+    }
+    // Strip prefix and collect files
+    const allFiles = [];
+    for (const entry of validEntries) {
+        let relPath = entry.entryName;
+        if (prefix && relPath.startsWith(prefix)) {
+            relPath = relPath.substring(prefix.length);
+        }
+        // Skip if empty after stripping prefix
+        if (!relPath)
+            continue;
+        // Only keep text files
+        if (!isTextFile(relPath))
+            continue;
+        const content = entry.getData().toString('utf-8');
+        allFiles.push({ path: relPath, content });
+    }
+    // Find SKILL.md
+    const skillMdEntry = allFiles.find((f) => f.path === 'SKILL.md');
+    if (!skillMdEntry) {
+        throw new Error('压缩包中未找到 SKILL.md 文件');
+    }
+    // Check for duplicate SKILL.md in subdirectories
+    const skillMdCount = allFiles.filter((f) => path.basename(f.path) === 'SKILL.md').length;
+    if (skillMdCount > 1) {
+        throw new Error('压缩包中包含多个 SKILL.md 文件，请确保只有一个');
+    }
+    // Extract skill name from frontmatter or directory name
+    const { metadata } = parseFrontmatter(skillMdEntry.content);
+    let skillName = metadata.name;
+    if (!skillName || typeof skillName !== 'string') {
+        // Fallback to directory name from prefix
+        if (prefix) {
+            skillName = prefix.replace(/\/$/, '');
+        }
+        else {
+            throw new Error('无法确定 Skill 名称，请在 SKILL.md 的 frontmatter 中指定 name 字段');
+        }
+    }
+    // Validate skill name
+    if (!isValidSkillName(skillName)) {
+        throw new Error(`Skill 名称 "${skillName}" 不合法，只能包含字母、数字、中划线和下划线，且以字母开头`);
+    }
+    // Separate SKILL.md from other files
+    const files = allFiles.filter((f) => f.path !== 'SKILL.md');
+    return { skillName, skillMd: skillMdEntry.content, files };
+}
+/**
+ * Get MIME type for a file extension.
+ */
+function getContentType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const types = {
+        '.md': 'text/markdown',
+        '.txt': 'text/plain',
+        '.json': 'application/json',
+        '.xml': 'application/xml',
+        '.yaml': 'text/yaml',
+        '.yml': 'text/yaml',
+        '.ts': 'text/typescript',
+        '.js': 'text/javascript',
+        '.html': 'text/html',
+        '.css': 'text/css',
+    };
+    return types[ext] || 'text/plain';
+}
+export function registerSkillRoutes(fastify, options) {
+    const skillsDir = path.join(options.projectRoot, '.claude', 'skills');
+    const ensureSkillsDir = async () => {
+        await fs.mkdir(skillsDir, { recursive: true });
+    };
+    // ── GET /api/v1/skills ──
+    fastify.get('/api/v1/skills', async (_request, reply) => {
+        await ensureSkillsDir();
+        let entries;
+        try {
+            entries = await fs.readdir(skillsDir, { withFileTypes: true });
+        }
+        catch {
+            return reply.send({ data: [] });
+        }
+        const skills = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const skillDir = path.join(skillsDir, entry.name);
+            const skillMdPath = path.join(skillDir, 'SKILL.md');
+            let metadata = {};
+            try {
+                const content = await fs.readFile(skillMdPath, 'utf-8');
+                metadata = parseFrontmatter(content).metadata;
+            }
+            catch {
+                // SKILL.md doesn't exist or is unreadable
+            }
+            // Scan subdirectories dynamically (any folder name, not just 'references')
+            let subDirs = [];
+            try {
+                const dirEntries = await fs.readdir(skillDir, { withFileTypes: true });
+                subDirs = dirEntries.filter((e) => e.isDirectory()).map((e) => e.name);
+            }
+            catch {
+                // ignore
+            }
+            skills.push({ name: entry.name, metadata, subDirs });
+        }
+        return reply.send({ data: skills });
+    });
+    // ── POST /api/v1/skills/parse-archive ──
+    fastify.post('/api/v1/skills/parse-archive', {
+        schema: { body: parseArchiveBodySchema },
+    }, async (request, reply) => {
+        const body = request.body;
+        let buffer;
+        try {
+            buffer = Buffer.from(body.data, 'base64');
+        }
+        catch {
+            return reply.status(400).send({ error: '无效的 base64 编码' });
+        }
+        try {
+            const result = parseZipArchive(buffer);
+            return reply.send({ data: result });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : '解析压缩包失败';
+            return reply.status(400).send({ error: msg });
+        }
+    });
+    // ── GET /api/v1/skills/:skillName ──
+    fastify.get('/api/v1/skills/:skillName', {
+        schema: { params: skillNameParamSchema },
+    }, async (request, reply) => {
+        const { skillName } = request.params;
+        const skillDir = path.join(skillsDir, skillName);
+        const exists = await fs.access(skillDir).then(() => true, () => false);
+        if (!exists) {
+            return reply.status(404).send({ error: `Skill "${skillName}" not found` });
+        }
+        let skillMd = '';
+        let metadata = {};
+        try {
+            skillMd = await fs.readFile(path.join(skillDir, 'SKILL.md'), 'utf-8');
+            metadata = parseFrontmatter(skillMd).metadata;
+        }
+        catch {
+            // SKILL.md doesn't exist
+        }
+        // Dynamically scan all files in subdirectories
+        const allFiles = await scanDirFiles(skillDir, skillDir);
+        const files = allFiles.map((p) => ({
+            name: path.basename(p),
+            path: p,
+        }));
+        return reply.send({ data: { name: skillName, metadata, skillMd, files } });
+    });
+    // ── GET /api/v1/skills/:skillName/archive ──
+    fastify.get('/api/v1/skills/:skillName/archive', {
+        schema: { params: skillNameParamSchema },
+    }, async (request, reply) => {
+        const { skillName } = request.params;
+        const skillDir = path.join(skillsDir, skillName);
+        const exists = await fs.access(skillDir).then(() => true, () => false);
+        if (!exists) {
+            return reply.status(404).send({ error: `Skill "${skillName}" not found` });
+        }
+        const zip = new AdmZip();
+        // Add SKILL.md
+        const skillMdPath = path.join(skillDir, 'SKILL.md');
+        try {
+            const skillMd = await fs.readFile(skillMdPath, 'utf-8');
+            zip.addFile('SKILL.md', Buffer.from(skillMd, 'utf-8'));
+        }
+        catch {
+            // SKILL.md doesn't exist, skip
+        }
+        // Add all other files, preserving directory structure
+        const allFiles = await scanDirFiles(skillDir, skillDir);
+        for (const filePath of allFiles) {
+            if (filePath === 'SKILL.md')
+                continue;
+            const resolvedPath = safeResolve(skillDir, filePath);
+            if (!resolvedPath)
+                continue;
+            try {
+                const content = await fs.readFile(resolvedPath);
+                // Store under skillName/ prefix for proper extraction
+                zip.addFile(`${skillName}/${filePath}`, content);
+            }
+            catch {
+                // skip unreadable files
+            }
+        }
+        // Also put SKILL.md under the prefix
+        zip.deleteFile('SKILL.md');
+        try {
+            const skillMd = await fs.readFile(skillMdPath, 'utf-8');
+            zip.addFile(`${skillName}/SKILL.md`, Buffer.from(skillMd, 'utf-8'));
+        }
+        catch {
+            // skip
+        }
+        const zipBuffer = zip.toBuffer();
+        reply.header('Content-Type', 'application/zip');
+        reply.header('Content-Disposition', `attachment; filename="${skillName}.zip"`);
+        return reply.send(zipBuffer);
+    });
+    // ── GET /api/v1/skills/:skillName/file/* ──
+    fastify.get('/api/v1/skills/:skillName/file/*', async (request, reply) => {
+        const { skillName } = request.params;
+        const filePath = request.params['*'];
+        const skillDir = path.join(skillsDir, skillName);
+        const exists = await fs.access(skillDir).then(() => true, () => false);
+        if (!exists) {
+            return reply.status(404).send({ error: `Skill "${skillName}" not found` });
+        }
+        const resolvedPath = safeResolve(skillDir, filePath);
+        if (!resolvedPath) {
+            return reply.status(400).send({ error: 'Invalid file path' });
+        }
+        const fileExists = await fs.access(resolvedPath).then(() => true, () => false);
+        if (!fileExists) {
+            return reply.status(404).send({ error: `File "${filePath}" not found` });
+        }
+        try {
+            const content = await fs.readFile(resolvedPath, 'utf-8');
+            return reply.send({ data: { content, path: filePath } });
+        }
+        catch (err) {
+            return reply.status(500).send({ error: `Failed to read file: ${err}` });
+        }
+    });
+    // ── POST /api/v1/skills ──
+    fastify.post('/api/v1/skills', {
+        schema: { body: createSkillBodySchema },
+    }, async (request, reply) => {
+        const body = request.body;
+        const { name, skillMd, references, scripts: scriptFiles, files: archiveFiles } = body;
+        if (!isValidSkillName(name)) {
+            return reply.status(400).send({ error: 'Invalid skill name. Use alphanumeric, hyphens, and underscores only.' });
+        }
+        const skillDir = path.join(skillsDir, name);
+        const exists = await fs.access(skillDir).then(() => true, () => false);
+        if (exists) {
+            return reply.status(409).send({ error: `Skill "${name}" already exists` });
+        }
+        await fs.mkdir(skillDir, { recursive: true });
+        const contentToWrite = skillMd || `---
+name: ${name}
+description: ''
+version: 1.0.0
+---
+
+# ${name}
+
+## Overview
+
+[Describe what this skill does]
+
+## Usage Scenarios
+
+- "User prompt" → [what the skill does]
+`;
+        await fs.writeFile(path.join(skillDir, 'SKILL.md'), contentToWrite, 'utf-8');
+        if (references && references.length > 0) {
+            const refDir = path.join(skillDir, 'references');
+            await fs.mkdir(refDir, { recursive: true });
+            for (const ref of references) {
+                const safePath = safeResolve(refDir, ref.name);
+                if (safePath) {
+                    await fs.mkdir(path.dirname(safePath), { recursive: true });
+                    await fs.writeFile(safePath, ref.content, 'utf-8');
+                }
+            }
+        }
+        if (scriptFiles && scriptFiles.length > 0) {
+            const scriptsDir = path.join(skillDir, 'scripts');
+            await fs.mkdir(scriptsDir, { recursive: true });
+            for (const script of scriptFiles) {
+                const safePath = safeResolve(scriptsDir, script.name);
+                if (safePath) {
+                    await fs.mkdir(path.dirname(safePath), { recursive: true });
+                    await fs.writeFile(safePath, script.content, 'utf-8');
+                }
+            }
+        }
+        if (archiveFiles && archiveFiles.length > 0) {
+            for (const file of archiveFiles) {
+                const safePath = safeResolve(skillDir, file.path);
+                if (safePath) {
+                    await fs.mkdir(path.dirname(safePath), { recursive: true });
+                    await fs.writeFile(safePath, file.content, 'utf-8');
+                }
+            }
+        }
+        const metadata = parseFrontmatter(contentToWrite).metadata;
+        return reply.code(201).send({ data: { name, metadata } });
+    });
+    // ── DELETE /api/v1/skills/:skillName ──
+    fastify.delete('/api/v1/skills/:skillName', {
+        schema: { params: skillNameParamSchema },
+    }, async (request, reply) => {
+        const { skillName } = request.params;
+        const skillDir = path.join(skillsDir, skillName);
+        const exists = await fs.access(skillDir).then(() => true, () => false);
+        if (!exists) {
+            return reply.status(404).send({ error: `Skill "${skillName}" not found` });
+        }
+        await fs.rm(skillDir, { recursive: true, force: true });
+        return reply.send({ success: true });
+    });
+    // ── POST /api/v1/skills/:skillName/file ──
+    fastify.post('/api/v1/skills/:skillName/file', {
+        schema: { params: skillNameParamSchema, body: uploadFileBodySchema },
+    }, async (request, reply) => {
+        const { skillName } = request.params;
+        const body = request.body;
+        const { filename, content } = body;
+        const skillDir = path.join(skillsDir, skillName);
+        const exists = await fs.access(skillDir).then(() => true, () => false);
+        if (!exists) {
+            return reply.status(404).send({ error: `Skill "${skillName}" not found` });
+        }
+        const resolvedPath = safeResolve(skillDir, filename);
+        if (!resolvedPath) {
+            return reply.status(400).send({ error: 'Invalid file path' });
+        }
+        await fs.mkdir(path.dirname(resolvedPath), { recursive: true });
+        await fs.writeFile(resolvedPath, content, 'utf-8');
+        return reply.send({ success: true, path: filename });
+    });
+}
+//# sourceMappingURL=skills.js.map