@wingman-ai/gateway 0.1.0

package/dist/cli/index.cjs

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+"use strict";
+var __webpack_exports__ = {};
+const external_logger_cjs_namespaceObject = require("../logger.cjs");
+const loader_cjs_namespaceObject = require("./config/loader.cjs");
+const env_cjs_namespaceObject = require("../gateway/env.cjs");
+const outputManager_cjs_namespaceObject = require("./core/outputManager.cjs");
+const agent_cjs_namespaceObject = require("./commands/agent.cjs");
+const skill_cjs_namespaceObject = require("./commands/skill.cjs");
+const gateway_cjs_namespaceObject = require("./commands/gateway.cjs");
+const provider_cjs_namespaceObject = require("./commands/provider.cjs");
+const init_cjs_namespaceObject = require("./commands/init.cjs");
+function parseArgs(argv) {
+    const args = argv.slice(2);
+    if (args.includes("--help") || args.includes("-h")) return {
+        command: "",
+        subcommand: "",
+        subcommandArgs: [],
+        help: true,
+        prompt: ""
+    };
+    const parsed = {
+        command: args[0] || "",
+        subcommand: args[1] || "",
+        subcommandArgs: args.slice(2),
+        agent: void 0,
+        verbosity: void 0,
+        outputMode: void 0,
+        help: false,
+        prompt: "",
+        commandOptions: {}
+    };
+    const promptParts = [];
+    for(let i = 1; i < args.length; i++){
+        const arg = args[i];
+        if ("--agent" === arg && i + 1 < args.length) {
+            parsed.agent = args[i + 1];
+            i++;
+        } else if (arg.startsWith("--agent=")) parsed.agent = arg.split("=")[1];
+        else if (arg.startsWith("--verbose=")) parsed.verbosity = arg.split("=")[1];
+        else if (arg.startsWith("--output=")) parsed.outputMode = arg.split("=")[1];
+        else if (arg.startsWith("-v")) {
+            const vCount = arg.split("").filter((c)=>"v" === c).length;
+            parsed.verbosity = vCount >= 2 ? "debug" : "info";
+        } else if (arg.startsWith("--")) {
+            const [key, value] = arg.slice(2).split("=");
+            if (void 0 !== value) parsed.commandOptions[key] = value;
+            else if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+                parsed.commandOptions[key] = args[i + 1];
+                i++;
+            } else parsed.commandOptions[key] = true;
+        } else promptParts.push(arg);
+    }
+    parsed.prompt = promptParts.join(" ");
+    return parsed;
+}
+function determineVerbosity(cliVerbosity, configLevel) {
+    if (cliVerbosity) {
+        const validLevels = [
+            "debug",
+            "info",
+            "warn",
+            "error",
+            "silent"
+        ];
+        if (validLevels.includes(cliVerbosity)) return cliVerbosity;
+    }
+    return configLevel;
+}
+function showHelp() {
+    console.log(`
+Wingman CLI - AI coding assistant
+
+Usage:
+  wingman agent --agent <name> [options] <prompt>
+  wingman init [options]
+  wingman skill <subcommand> [args]
+  wingman provider <subcommand> [options]
+  wingman gateway <subcommand> [options]
+
+Commands:
+  agent                        Invoke a specific agent directly
+  init                         Create a starter config + agent (onboarding)
+  skill browse                 Browse available skills from repository
+  skill install <name>         Install a skill
+  skill list                   List installed skills
+  skill remove <name>          Remove an installed skill
+  provider login <provider>    Store provider credentials
+  provider logout <provider>   Remove stored provider credentials
+  provider status              Show provider configuration status
+  gateway start                Start the gateway server
+  gateway stop                 Stop the gateway server
+  gateway status               Show gateway status
+  gateway join <url>           Join a gateway as a node
+
+Options:
+  --agent <name>      Agent name to invoke (required for agent command)
+  --local             Run agent locally instead of via gateway
+  --gateway <url>     Gateway URL (default from config)
+  --token <token>     Gateway auth token
+  --password <value>  Gateway auth password
+  --output=<mode>     Output mode (interactive|json), overrides auto-detect
+  -v, -vv             Verbosity level (v=info, vv=debug)
+  --verbose=<level>   Set log level (debug|info|warn|error|silent)
+  -h, --help          Show this help message
+
+Examples:
+  wingman agent --agent researcher "what is quantum computing"
+  wingman agent --agent coder -vv "add a login function"
+  wingman agent --agent coder --local "fix the tests"
+  wingman agent --agent coder --gateway ws://localhost:18789/ws --token sk-... "ship it"
+  wingman init
+  wingman skill browse
+  wingman skill install pdf
+  wingman skill list
+  wingman provider status
+  wingman provider login copilot --token="<token>"
+  wingman gateway start
+  wingman gateway join ws://localhost:3000/ws --name="agent-1"
+
+Available agents:
+  Run "wingman agent" without a prompt to list all available agents.
+  
+For gateway help:
+  wingman gateway --help
+  `);
+}
+async function main() {
+    try {
+        const parsed = parseArgs(process.argv);
+        if (parsed.help || !parsed.command) {
+            showHelp();
+            process.exit(0);
+        }
+        const configLoader = new loader_cjs_namespaceObject.WingmanConfigLoader();
+        const config = configLoader.loadConfig();
+        let outputMode;
+        outputMode = "interactive" === parsed.outputMode || "json" === parsed.outputMode ? parsed.outputMode : "auto" === config.cli.outputMode ? outputManager_cjs_namespaceObject.OutputManager.detectMode() : config.cli.outputMode;
+        const verbosity = determineVerbosity(parsed.verbosity, config.logLevel);
+        if ("agent" === parsed.command) {
+            const commandArgs = {
+                agent: parsed.agent || config.defaultAgent,
+                verbosity,
+                outputMode,
+                prompt: parsed.prompt
+            };
+            const gatewayConfig = config.gateway;
+            const gatewayUrl = parsed.commandOptions?.gateway || parsed.commandOptions?.gatewayUrl || (gatewayConfig ? `ws://${gatewayConfig.host}:${gatewayConfig.port}/ws` : void 0);
+            const token = parsed.commandOptions?.token || gatewayConfig?.auth?.token || (0, env_cjs_namespaceObject.getGatewayTokenFromEnv)();
+            const password = parsed.commandOptions?.password || gatewayConfig?.auth?.password;
+            await (0, agent_cjs_namespaceObject.executeAgentCommand)(commandArgs, {
+                local: Boolean(parsed.commandOptions?.local),
+                gatewayUrl,
+                token,
+                password
+            });
+        } else if ("skill" === parsed.command) {
+            const commandArgs = {
+                subcommand: parsed.subcommand,
+                args: parsed.subcommandArgs,
+                verbosity,
+                outputMode
+            };
+            await (0, skill_cjs_namespaceObject.executeSkillCommand)(commandArgs);
+        } else if ("gateway" === parsed.command) {
+            const commandArgs = {
+                subcommand: parsed.subcommand,
+                args: parsed.subcommandArgs,
+                options: parsed.commandOptions || {}
+            };
+            await (0, gateway_cjs_namespaceObject.executeGatewayCommand)(commandArgs);
+        } else if ("provider" === parsed.command) {
+            const commandArgs = {
+                subcommand: parsed.subcommand,
+                args: parsed.subcommandArgs,
+                verbosity,
+                outputMode,
+                options: parsed.commandOptions || {}
+            };
+            await (0, provider_cjs_namespaceObject.executeProviderCommand)(commandArgs);
+        } else if ("init" === parsed.command || "onboard" === parsed.command) {
+            const commandArgs = {
+                subcommand: parsed.subcommand,
+                args: parsed.subcommandArgs,
+                verbosity,
+                outputMode,
+                options: parsed.commandOptions || {},
+                agent: parsed.agent
+            };
+            await (0, init_cjs_namespaceObject.executeInitCommand)(commandArgs);
+        } else {
+            const logFile = (0, external_logger_cjs_namespaceObject.getLogFilePath)();
+            (0, external_logger_cjs_namespaceObject.createLogger)(verbosity).error(`Unknown command: ${parsed.command}`);
+            console.error(`Unknown command: ${parsed.command}`);
+            console.error('Run "wingman --help" for usage information');
+            console.error(`Logs: ${logFile}`);
+            process.exit(1);
+        }
+    } catch (error) {
+        const logFile = (0, external_logger_cjs_namespaceObject.getLogFilePath)();
+        (0, external_logger_cjs_namespaceObject.createLogger)().error("Fatal error", error instanceof Error ? error.message : String(error));
+        console.error(`Fatal error: ${error instanceof Error ? error.message : String(error)}`);
+        console.error(`Logs: ${logFile}`);
+        process.exit(1);
+    }
+}
+main();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+import { createLogger, getLogFilePath } from "../logger.js";
+import { WingmanConfigLoader } from "./config/loader.js";
+import { getGatewayTokenFromEnv } from "../gateway/env.js";
+import { OutputManager } from "./core/outputManager.js";
+import { executeAgentCommand } from "./commands/agent.js";
+import { executeSkillCommand } from "./commands/skill.js";
+import { executeGatewayCommand } from "./commands/gateway.js";
+import { executeProviderCommand } from "./commands/provider.js";
+import { executeInitCommand } from "./commands/init.js";
+function parseArgs(argv) {
+    const args = argv.slice(2);
+    if (args.includes("--help") || args.includes("-h")) return {
+        command: "",
+        subcommand: "",
+        subcommandArgs: [],
+        help: true,
+        prompt: ""
+    };
+    const parsed = {
+        command: args[0] || "",
+        subcommand: args[1] || "",
+        subcommandArgs: args.slice(2),
+        agent: void 0,
+        verbosity: void 0,
+        outputMode: void 0,
+        help: false,
+        prompt: "",
+        commandOptions: {}
+    };
+    const promptParts = [];
+    for(let i = 1; i < args.length; i++){
+        const arg = args[i];
+        if ("--agent" === arg && i + 1 < args.length) {
+            parsed.agent = args[i + 1];
+            i++;
+        } else if (arg.startsWith("--agent=")) parsed.agent = arg.split("=")[1];
+        else if (arg.startsWith("--verbose=")) parsed.verbosity = arg.split("=")[1];
+        else if (arg.startsWith("--output=")) parsed.outputMode = arg.split("=")[1];
+        else if (arg.startsWith("-v")) {
+            const vCount = arg.split("").filter((c)=>"v" === c).length;
+            parsed.verbosity = vCount >= 2 ? "debug" : "info";
+        } else if (arg.startsWith("--")) {
+            const [key, value] = arg.slice(2).split("=");
+            if (void 0 !== value) parsed.commandOptions[key] = value;
+            else if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+                parsed.commandOptions[key] = args[i + 1];
+                i++;
+            } else parsed.commandOptions[key] = true;
+        } else promptParts.push(arg);
+    }
+    parsed.prompt = promptParts.join(" ");
+    return parsed;
+}
+function determineVerbosity(cliVerbosity, configLevel) {
+    if (cliVerbosity) {
+        const validLevels = [
+            "debug",
+            "info",
+            "warn",
+            "error",
+            "silent"
+        ];
+        if (validLevels.includes(cliVerbosity)) return cliVerbosity;
+    }
+    return configLevel;
+}
+function showHelp() {
+    console.log(`
+Wingman CLI - AI coding assistant
+
+Usage:
+  wingman agent --agent <name> [options] <prompt>
+  wingman init [options]
+  wingman skill <subcommand> [args]
+  wingman provider <subcommand> [options]
+  wingman gateway <subcommand> [options]
+
+Commands:
+  agent                        Invoke a specific agent directly
+  init                         Create a starter config + agent (onboarding)
+  skill browse                 Browse available skills from repository
+  skill install <name>         Install a skill
+  skill list                   List installed skills
+  skill remove <name>          Remove an installed skill
+  provider login <provider>    Store provider credentials
+  provider logout <provider>   Remove stored provider credentials
+  provider status              Show provider configuration status
+  gateway start                Start the gateway server
+  gateway stop                 Stop the gateway server
+  gateway status               Show gateway status
+  gateway join <url>           Join a gateway as a node
+
+Options:
+  --agent <name>      Agent name to invoke (required for agent command)
+  --local             Run agent locally instead of via gateway
+  --gateway <url>     Gateway URL (default from config)
+  --token <token>     Gateway auth token
+  --password <value>  Gateway auth password
+  --output=<mode>     Output mode (interactive|json), overrides auto-detect
+  -v, -vv             Verbosity level (v=info, vv=debug)
+  --verbose=<level>   Set log level (debug|info|warn|error|silent)
+  -h, --help          Show this help message
+
+Examples:
+  wingman agent --agent researcher "what is quantum computing"
+  wingman agent --agent coder -vv "add a login function"
+  wingman agent --agent coder --local "fix the tests"
+  wingman agent --agent coder --gateway ws://localhost:18789/ws --token sk-... "ship it"
+  wingman init
+  wingman skill browse
+  wingman skill install pdf
+  wingman skill list
+  wingman provider status
+  wingman provider login copilot --token="<token>"
+  wingman gateway start
+  wingman gateway join ws://localhost:3000/ws --name="agent-1"
+
+Available agents:
+  Run "wingman agent" without a prompt to list all available agents.
+  
+For gateway help:
+  wingman gateway --help
+  `);
+}
+async function main() {
+    try {
+        const parsed = parseArgs(process.argv);
+        if (parsed.help || !parsed.command) {
+            showHelp();
+            process.exit(0);
+        }
+        const configLoader = new WingmanConfigLoader();
+        const config = configLoader.loadConfig();
+        let outputMode;
+        outputMode = "interactive" === parsed.outputMode || "json" === parsed.outputMode ? parsed.outputMode : "auto" === config.cli.outputMode ? OutputManager.detectMode() : config.cli.outputMode;
+        const verbosity = determineVerbosity(parsed.verbosity, config.logLevel);
+        if ("agent" === parsed.command) {
+            const commandArgs = {
+                agent: parsed.agent || config.defaultAgent,
+                verbosity,
+                outputMode,
+                prompt: parsed.prompt
+            };
+            const gatewayConfig = config.gateway;
+            const gatewayUrl = parsed.commandOptions?.gateway || parsed.commandOptions?.gatewayUrl || (gatewayConfig ? `ws://${gatewayConfig.host}:${gatewayConfig.port}/ws` : void 0);
+            const token = parsed.commandOptions?.token || gatewayConfig?.auth?.token || getGatewayTokenFromEnv();
+            const password = parsed.commandOptions?.password || gatewayConfig?.auth?.password;
+            await executeAgentCommand(commandArgs, {
+                local: Boolean(parsed.commandOptions?.local),
+                gatewayUrl,
+                token,
+                password
+            });
+        } else if ("skill" === parsed.command) {
+            const commandArgs = {
+                subcommand: parsed.subcommand,
+                args: parsed.subcommandArgs,
+                verbosity,
+                outputMode
+            };
+            await executeSkillCommand(commandArgs);
+        } else if ("gateway" === parsed.command) {
+            const commandArgs = {
+                subcommand: parsed.subcommand,
+                args: parsed.subcommandArgs,
+                options: parsed.commandOptions || {}
+            };
+            await executeGatewayCommand(commandArgs);
+        } else if ("provider" === parsed.command) {
+            const commandArgs = {
+                subcommand: parsed.subcommand,
+                args: parsed.subcommandArgs,
+                verbosity,
+                outputMode,
+                options: parsed.commandOptions || {}
+            };
+            await executeProviderCommand(commandArgs);
+        } else if ("init" === parsed.command || "onboard" === parsed.command) {
+            const commandArgs = {
+                subcommand: parsed.subcommand,
+                args: parsed.subcommandArgs,
+                verbosity,
+                outputMode,
+                options: parsed.commandOptions || {},
+                agent: parsed.agent
+            };
+            await executeInitCommand(commandArgs);
+        } else {
+            const logFile = getLogFilePath();
+            createLogger(verbosity).error(`Unknown command: ${parsed.command}`);
+            console.error(`Unknown command: ${parsed.command}`);
+            console.error('Run "wingman --help" for usage information');
+            console.error(`Logs: ${logFile}`);
+            process.exit(1);
+        }
+    } catch (error) {
+        const logFile = getLogFilePath();
+        createLogger().error("Fatal error", error instanceof Error ? error.message : String(error));
+        console.error(`Fatal error: ${error instanceof Error ? error.message : String(error)}`);
+        console.error(`Logs: ${logFile}`);
+        process.exit(1);
+    }
+}
+main();

package/dist/cli/services/skillRepository.cjs

@@ -0,0 +1,178 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    SkillRepository: ()=>SkillRepository
+});
+const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const logger = (0, external_logger_cjs_namespaceObject.createLogger)();
+class SkillRepository {
+    async fetch(path) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            Accept: "application/vnd.github.v3+json",
+            "User-Agent": "wingman-cli"
+        };
+        if (this.token) headers.Authorization = `Bearer ${this.token}`;
+        const response = await fetch(url, {
+            headers
+        });
+        if (!response.ok) {
+            if (403 === response.status) {
+                const resetTime = response.headers.get("X-RateLimit-Reset");
+                const resetDate = resetTime ? new Date(1000 * Number.parseInt(resetTime)) : null;
+                throw new Error(`GitHub API rate limit exceeded. ${resetDate ? `Resets at ${resetDate.toLocaleString()}.` : ""} Set GITHUB_TOKEN environment variable for higher limits (5000/hour vs 60/hour).`);
+            }
+            if (404 === response.status) throw new Error(`Resource not found: ${path}`);
+            throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async listAvailableSkills() {
+        try {
+            const contents = await this.fetch(`/repos/${this.owner}/${this.repo}/contents/skills`);
+            const skills = [];
+            for (const item of contents)if ("dir" === item.type) try {
+                const metadata = await this.getSkillMetadata(item.name);
+                skills.push({
+                    name: item.name,
+                    description: metadata.description || "No description",
+                    path: item.path,
+                    metadata
+                });
+            } catch (error) {
+                logger.warn(`Could not read skill ${item.name}`, error instanceof Error ? error.message : String(error));
+            }
+            return skills;
+        } catch (error) {
+            if (error instanceof Error) throw new Error(`Failed to list skills: ${error.message}`);
+            throw error;
+        }
+    }
+    async getSkillMetadata(skillName) {
+        try {
+            const skillMdPath = `/repos/${this.owner}/${this.repo}/contents/skills/${skillName}/SKILL.md`;
+            const skillMd = await this.fetch(skillMdPath);
+            if ("file" !== skillMd.type || !skillMd.content) throw new Error("SKILL.md not found or invalid");
+            const content = Buffer.from(skillMd.content, "base64").toString("utf-8");
+            const metadata = this.parseSkillMetadata(content);
+            return metadata;
+        } catch (error) {
+            if (error instanceof Error) throw new Error(`Failed to fetch skill metadata for ${skillName}: ${error.message}`);
+            throw error;
+        }
+    }
+    parseSkillMetadata(content) {
+        const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---/;
+        const match = content.match(frontmatterRegex);
+        if (!match) throw new Error("Invalid SKILL.md format: missing YAML frontmatter");
+        const frontmatter = match[1];
+        const metadata = {
+            name: "",
+            description: ""
+        };
+        const lines = frontmatter.split("\n");
+        for (const line of lines){
+            const colonIndex = line.indexOf(":");
+            if (-1 === colonIndex) continue;
+            const key = line.substring(0, colonIndex).trim();
+            const value = line.substring(colonIndex + 1).trim();
+            switch(key){
+                case "name":
+                    metadata.name = value;
+                    break;
+                case "description":
+                    metadata.description = value;
+                    break;
+                case "license":
+                    metadata.license = value;
+                    break;
+                case "compatibility":
+                    metadata.compatibility = value;
+                    break;
+                case "allowed-tools":
+                    metadata.allowedTools = value;
+                    break;
+            }
+        }
+        if (!metadata.name) throw new Error("Invalid SKILL.md: missing required field 'name'");
+        if (!metadata.description) throw new Error("Invalid SKILL.md: missing required field 'description'");
+        const nameRegex = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+        if (!nameRegex.test(metadata.name)) throw new Error(`Invalid skill name '${metadata.name}': must be lowercase alphanumeric with hyphens only`);
+        return metadata;
+    }
+    async downloadSkill(skillName) {
+        try {
+            const files = new Map();
+            await this.downloadDirectory(`skills/${skillName}`, files, skillName);
+            return files;
+        } catch (error) {
+            if (error instanceof Error) throw new Error(`Failed to download skill ${skillName}: ${error.message}`);
+            throw error;
+        }
+    }
+    async downloadDirectory(path, files, skillName) {
+        const contents = await this.fetch(`/repos/${this.owner}/${this.repo}/contents/${path}`);
+        for (const item of contents)if ("file" === item.type) if (item.content) {
+            const content = Buffer.from(item.content, "base64");
+            const relativePath = item.path.replace(`skills/${skillName}/`, "");
+            files.set(relativePath, content);
+        } else {
+            const fileData = await this.fetch(item.url.replace(this.baseUrl, ""));
+            if (fileData.content && "base64" === fileData.encoding) {
+                const content = Buffer.from(fileData.content, "base64");
+                const relativePath = item.path.replace(`skills/${skillName}/`, "");
+                files.set(relativePath, content);
+            }
+        }
+        else if ("dir" === item.type) await this.downloadDirectory(item.path, files, skillName);
+    }
+    constructor(options = {}){
+        _define_property(this, "baseUrl", "https://api.github.com");
+        _define_property(this, "owner", void 0);
+        _define_property(this, "repo", void 0);
+        _define_property(this, "token", void 0);
+        this.owner = options.repositoryOwner || "anthropics";
+        this.repo = options.repositoryName || "skills";
+        this.token = options.githubToken || process.env.GITHUB_TOKEN || void 0;
+    }
+}
+exports.SkillRepository = __webpack_exports__.SkillRepository;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "SkillRepository"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/services/skillRepository.d.ts

@@ -0,0 +1,35 @@
+import type { SkillInfo, SkillMetadata, SkillRepositoryOptions } from "../types/skill.js";
+/**
+ * GitHub API client for interacting with the skills repository
+ */
+export declare class SkillRepository {
+    private readonly baseUrl;
+    private readonly owner;
+    private readonly repo;
+    private readonly token?;
+    constructor(options?: SkillRepositoryOptions);
+    /**
+     * Fetch data from GitHub API
+     */
+    private fetch;
+    /**
+     * List available skills from the repository
+     */
+    listAvailableSkills(): Promise<SkillInfo[]>;
+    /**
+     * Get skill metadata by fetching and parsing SKILL.md
+     */
+    getSkillMetadata(skillName: string): Promise<SkillMetadata>;
+    /**
+     * Parse SKILL.md content to extract YAML frontmatter
+     */
+    private parseSkillMetadata;
+    /**
+     * Download all files for a skill
+     */
+    downloadSkill(skillName: string): Promise<Map<string, string | Buffer>>;
+    /**
+     * Recursively download all files in a directory
+     */
+    private downloadDirectory;
+}