@wingman-ai/gateway 0.1.0

package/dist/cli/services/skillRepository.js

@@ -0,0 +1,144 @@
+import { createLogger } from "../../logger.js";
+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 = 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;
+    }
+}
+export { SkillRepository };

package/dist/cli/services/skillService.cjs

@@ -0,0 +1,336 @@
+"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__, {
+    SkillService: ()=>SkillService
+});
+const promises_namespaceObject = require("node:fs/promises");
+const external_node_path_namespaceObject = require("node:path");
+const external_node_readline_promises_namespaceObject = require("node:readline/promises");
+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;
+}
+class SkillService {
+    getSkillsPath() {
+        return external_node_path_namespaceObject.join(this.workspace, this.skillsDirectory);
+    }
+    async browseSkills() {
+        try {
+            this.logger.info("Fetching available skills from repository...");
+            const skills = await this.repository.listAvailableSkills();
+            if ("interactive" === this.outputManager.getMode()) {
+                console.log("\nAvailable Skills:");
+                console.log("=================\n");
+                if (0 === skills.length) console.log("No skills found.");
+                else {
+                    for (const skill of skills){
+                        console.log(`  ${skill.name}`);
+                        console.log(`    ${skill.description}`);
+                        console.log();
+                    }
+                    console.log(`\nTo install a skill, run: wingman skill install <skill-name>`);
+                }
+            } else this.outputManager.emitEvent({
+                type: "skill-browse",
+                skills: skills.map((s)=>({
+                        name: s.name,
+                        description: s.description
+                    })),
+                timestamp: new Date().toISOString()
+            });
+        } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const logFile = (0, external_logger_cjs_namespaceObject.getLogFilePath)();
+            this.logger.error(`Failed to browse skills: ${errorMsg}`);
+            if ("interactive" === this.outputManager.getMode()) {
+                console.error(`\nError: ${errorMsg}`);
+                console.error(`Logs: ${logFile}`);
+            } else this.outputManager.emitEvent({
+                type: "agent-error",
+                error: errorMsg,
+                logFile,
+                timestamp: new Date().toISOString()
+            });
+            throw error;
+        }
+    }
+    async installSkill(skillName) {
+        try {
+            const nameRegex = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+            if (!nameRegex.test(skillName)) throw new Error(`Invalid skill name '${skillName}': must be lowercase alphanumeric with hyphens only`);
+            this.logger.info(`Installing skill: ${skillName}`);
+            const skillPath = external_node_path_namespaceObject.join(this.getSkillsPath(), skillName);
+            const exists = await this.skillExists(skillName);
+            if (exists) if ("interactive" === this.outputManager.getMode()) {
+                const shouldOverwrite = await this.promptForOverwrite(skillName);
+                if (!shouldOverwrite) return void console.log("\nInstallation cancelled.");
+                this.logger.info("Removing existing skill...");
+                await promises_namespaceObject.rm(skillPath, {
+                    recursive: true,
+                    force: true
+                });
+            } else throw new Error(`Skill '${skillName}' is already installed.`);
+            this.logger.info("Fetching skill metadata...");
+            const metadata = await this.repository.getSkillMetadata(skillName);
+            if ("interactive" === this.outputManager.getMode()) {
+                console.log(`\nInstalling skill: ${metadata.name}`);
+                console.log(`Description: ${metadata.description}`);
+            } else this.outputManager.emitEvent({
+                type: "skill-install-progress",
+                skill: skillName,
+                status: "downloading",
+                timestamp: new Date().toISOString()
+            });
+            this.logger.info("Downloading skill files...");
+            const files = await this.repository.downloadSkill(skillName);
+            await promises_namespaceObject.mkdir(this.getSkillsPath(), {
+                recursive: true
+            });
+            await promises_namespaceObject.mkdir(skillPath, {
+                recursive: true
+            });
+            this.logger.info(`Writing ${files.size} files...`);
+            for (const [relativePath, content] of files){
+                const filePath = external_node_path_namespaceObject.join(skillPath, relativePath);
+                const fileDir = external_node_path_namespaceObject.dirname(filePath);
+                await promises_namespaceObject.mkdir(fileDir, {
+                    recursive: true
+                });
+                await promises_namespaceObject.writeFile(filePath, content);
+            }
+            await this.validateSkillMd(skillPath);
+            if ("interactive" === this.outputManager.getMode()) console.log(`\n✓ Successfully installed skill ${skillName} to ${skillPath}`);
+            else this.outputManager.emitEvent({
+                type: "skill-install-complete",
+                skill: skillName,
+                path: skillPath,
+                timestamp: new Date().toISOString()
+            });
+        } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const logFile = (0, external_logger_cjs_namespaceObject.getLogFilePath)();
+            this.logger.error(`Failed to install skill: ${errorMsg}`);
+            if ("interactive" === this.outputManager.getMode()) {
+                console.error(`\nError: ${errorMsg}`);
+                console.error(`Logs: ${logFile}`);
+            } else this.outputManager.emitEvent({
+                type: "agent-error",
+                error: errorMsg,
+                logFile,
+                timestamp: new Date().toISOString()
+            });
+            throw error;
+        }
+    }
+    async listInstalledSkills() {
+        try {
+            const skillsPath = this.getSkillsPath();
+            try {
+                await promises_namespaceObject.access(skillsPath);
+            } catch  {
+                if ("interactive" === this.outputManager.getMode()) console.log("\nNo skills installed.");
+                else this.outputManager.emitEvent({
+                    type: "skill-list",
+                    skills: [],
+                    timestamp: new Date().toISOString()
+                });
+                return;
+            }
+            const entries = await promises_namespaceObject.readdir(skillsPath, {
+                withFileTypes: true
+            });
+            const skillDirs = entries.filter((entry)=>entry.isDirectory());
+            if (0 === skillDirs.length) {
+                if ("interactive" === this.outputManager.getMode()) console.log("\nNo skills installed.");
+                else this.outputManager.emitEvent({
+                    type: "skill-list",
+                    skills: [],
+                    timestamp: new Date().toISOString()
+                });
+                return;
+            }
+            const skills = [];
+            for (const dir of skillDirs){
+                const skillPath = external_node_path_namespaceObject.join(skillsPath, dir.name);
+                const skillMdPath = external_node_path_namespaceObject.join(skillPath, "SKILL.md");
+                try {
+                    const content = await promises_namespaceObject.readFile(skillMdPath, "utf-8");
+                    const metadata = this.parseSkillMetadata(content);
+                    skills.push({
+                        name: metadata.name,
+                        description: metadata.description,
+                        path: skillPath
+                    });
+                } catch  {
+                    this.logger.warn(`Skipping invalid skill directory: ${dir.name}`);
+                }
+            }
+            if ("interactive" === this.outputManager.getMode()) {
+                console.log("\nInstalled Skills:");
+                console.log("=================\n");
+                for (const skill of skills){
+                    console.log(`  ${skill.name}`);
+                    console.log(`    ${skill.description}`);
+                    console.log(`    Location: ${skill.path}`);
+                    console.log();
+                }
+            } else this.outputManager.emitEvent({
+                type: "skill-list",
+                skills: skills.map((s)=>({
+                        name: s.name,
+                        description: s.description,
+                        path: s.path
+                    })),
+                timestamp: new Date().toISOString()
+            });
+        } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const logFile = (0, external_logger_cjs_namespaceObject.getLogFilePath)();
+            this.logger.error(`Failed to list skills: ${errorMsg}`);
+            if ("interactive" === this.outputManager.getMode()) {
+                console.error(`\nError: ${errorMsg}`);
+                console.error(`Logs: ${logFile}`);
+            } else this.outputManager.emitEvent({
+                type: "agent-error",
+                error: errorMsg,
+                logFile,
+                timestamp: new Date().toISOString()
+            });
+            throw error;
+        }
+    }
+    async removeSkill(skillName) {
+        try {
+            const skillPath = external_node_path_namespaceObject.join(this.getSkillsPath(), skillName);
+            const exists = await this.skillExists(skillName);
+            if (!exists) throw new Error(`Skill '${skillName}' is not installed.`);
+            this.logger.info(`Removing skill: ${skillName}`);
+            await promises_namespaceObject.rm(skillPath, {
+                recursive: true,
+                force: true
+            });
+            if ("interactive" === this.outputManager.getMode()) console.log(`\n✓ Successfully removed skill ${skillName}`);
+            else this.outputManager.emitEvent({
+                type: "skill-remove",
+                skill: skillName,
+                timestamp: new Date().toISOString()
+            });
+        } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const logFile = (0, external_logger_cjs_namespaceObject.getLogFilePath)();
+            this.logger.error(`Failed to remove skill: ${errorMsg}`);
+            if ("interactive" === this.outputManager.getMode()) {
+                console.error(`\nError: ${errorMsg}`);
+                console.error(`Logs: ${logFile}`);
+            } else this.outputManager.emitEvent({
+                type: "agent-error",
+                error: errorMsg,
+                logFile,
+                timestamp: new Date().toISOString()
+            });
+            throw error;
+        }
+    }
+    async skillExists(skillName) {
+        const skillPath = external_node_path_namespaceObject.join(this.getSkillsPath(), skillName);
+        try {
+            await promises_namespaceObject.access(skillPath);
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    async promptForOverwrite(skillName) {
+        const rl = external_node_readline_promises_namespaceObject.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        try {
+            const answer = await rl.question(`\nSkill ${skillName} is already installed. Overwrite? (y/N): `);
+            return "y" === answer.toLowerCase() || "yes" === answer.toLowerCase();
+        } finally{
+            rl.close();
+        }
+    }
+    async validateSkillMd(skillPath) {
+        const skillMdPath = external_node_path_namespaceObject.join(skillPath, "SKILL.md");
+        try {
+            const content = await promises_namespaceObject.readFile(skillMdPath, "utf-8");
+            this.parseSkillMetadata(content);
+        } catch (error) {
+            throw new Error(`Invalid SKILL.md: ${error instanceof Error ? error.message : String(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];
+        let name = "";
+        let 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();
+            if ("name" === key) name = value;
+            else if ("description" === key) description = value;
+        }
+        if (!name) throw new Error("missing required field 'name'");
+        if (!description) throw new Error("missing required field 'description'");
+        return {
+            name,
+            description
+        };
+    }
+    constructor(repository, outputManager, logger, options){
+        _define_property(this, "workspace", void 0);
+        _define_property(this, "skillsDirectory", void 0);
+        _define_property(this, "repository", void 0);
+        _define_property(this, "outputManager", void 0);
+        _define_property(this, "logger", void 0);
+        this.repository = repository;
+        this.outputManager = outputManager;
+        this.logger = logger;
+        this.workspace = options.workspace;
+        this.skillsDirectory = options.skillsDirectory || "skills";
+    }
+}
+exports.SkillService = __webpack_exports__.SkillService;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "SkillService"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,48 @@
+import type { SkillServiceOptions } from "../types/skill.js";
+import type { SkillRepository } from "./skillRepository.js";
+import type { OutputManager } from "../core/outputManager.js";
+import { type Logger } from "../../logger.js";
+export declare class SkillService {
+    private readonly workspace;
+    private readonly skillsDirectory;
+    private readonly repository;
+    private readonly outputManager;
+    private readonly logger;
+    constructor(repository: SkillRepository, outputManager: OutputManager, logger: Logger, options: SkillServiceOptions);
+    /**
+     * Get the absolute path to the skills directory
+     */
+    private getSkillsPath;
+    /**
+     * Browse available skills from the repository
+     */
+    browseSkills(): Promise<void>;
+    /**
+     * Install a skill from the repository
+     */
+    installSkill(skillName: string): Promise<void>;
+    /**
+     * List installed skills
+     */
+    listInstalledSkills(): Promise<void>;
+    /**
+     * Remove an installed skill
+     */
+    removeSkill(skillName: string): Promise<void>;
+    /**
+     * Check if a skill exists locally
+     */
+    private skillExists;
+    /**
+     * Prompt user for overwrite confirmation
+     */
+    private promptForOverwrite;
+    /**
+     * Validate SKILL.md file
+     */
+    private validateSkillMd;
+    /**
+     * Parse SKILL.md metadata (same logic as repository)
+     */
+    private parseSkillMetadata;
+}