@wingman-ai/gateway 0.1.0

package/dist/cli/services/skillService.js

@@ -0,0 +1,302 @@
+import { access, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { getLogFilePath } 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;
+}
+class SkillService {
+    getSkillsPath() {
+        return 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 = 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 = 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 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 mkdir(this.getSkillsPath(), {
+                recursive: true
+            });
+            await mkdir(skillPath, {
+                recursive: true
+            });
+            this.logger.info(`Writing ${files.size} files...`);
+            for (const [relativePath, content] of files){
+                const filePath = join(skillPath, relativePath);
+                const fileDir = dirname(filePath);
+                await mkdir(fileDir, {
+                    recursive: true
+                });
+                await 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 = 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 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 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 = join(skillsPath, dir.name);
+                const skillMdPath = join(skillPath, "SKILL.md");
+                try {
+                    const content = await 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 = 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 = 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 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 = 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 = join(this.getSkillsPath(), skillName);
+        try {
+            await access(skillPath);
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    async promptForOverwrite(skillName) {
+        const rl = 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 = join(skillPath, "SKILL.md");
+        try {
+            const content = await 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";
+    }
+}
+export { SkillService };

package/dist/cli/types/gateway.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/types/gateway.d.ts

@@ -0,0 +1,18 @@
+import type { LogLevel } from "../../logger.js";
+/**
+ * Gateway command arguments
+ */
+export interface GatewayCommandArgs {
+    subcommand: string;
+    args: string[];
+    verbosity: LogLevel;
+    host?: string;
+    port?: number;
+    daemon?: boolean;
+    auth?: boolean;
+    token?: string;
+    url?: string;
+    name?: string;
+    lines?: number;
+    errors?: boolean;
+}

package/dist/cli/types/init.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/types/init.d.ts

@@ -0,0 +1,13 @@
+import type { LogLevel } from "../../logger.js";
+import type { OutputMode } from "../types.js";
+/**
+ * Init command arguments
+ */
+export interface InitCommandArgs {
+    subcommand: string;
+    args: string[];
+    verbosity: LogLevel;
+    outputMode: OutputMode;
+    options: Record<string, unknown>;
+    agent?: string;
+}

package/dist/cli/types/provider.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/types/provider.d.ts

@@ -0,0 +1,9 @@
+import type { OutputMode } from "../types.js";
+import type { LogLevel } from "../../logger.js";
+export interface ProviderCommandArgs {
+    subcommand: string;
+    args: string[];
+    verbosity: LogLevel;
+    outputMode: OutputMode;
+    options: Record<string, unknown>;
+}

package/dist/cli/types/skill.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/types/skill.d.ts

@@ -0,0 +1,71 @@
+import type { OutputMode } from "../types.js";
+import type { LogLevel } from "../../logger.js";
+/**
+ * Skill metadata parsed from SKILL.md frontmatter
+ */
+export interface SkillMetadata {
+    name: string;
+    description: string;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+    allowedTools?: string;
+}
+/**
+ * Skill information with additional context
+ */
+export interface SkillInfo {
+    name: string;
+    description: string;
+    path: string;
+    metadata?: SkillMetadata;
+}
+/**
+ * Installed skill information
+ */
+export interface InstalledSkill {
+    name: string;
+    description: string;
+    path: string;
+}
+/**
+ * GitHub API response for directory contents
+ */
+export interface GitHubContentItem {
+    name: string;
+    path: string;
+    sha: string;
+    size: number;
+    url: string;
+    html_url: string;
+    git_url: string;
+    download_url: string | null;
+    type: "file" | "dir";
+    content?: string;
+    encoding?: string;
+}
+/**
+ * Command arguments for skill commands
+ */
+export interface SkillCommandArgs {
+    subcommand: string;
+    args: string[];
+    verbosity: LogLevel;
+    outputMode: OutputMode;
+}
+/**
+ * Options for skill repository operations
+ */
+export interface SkillRepositoryOptions {
+    repositoryOwner?: string;
+    repositoryName?: string;
+    githubToken?: string;
+}
+/**
+ * Options for skill service operations
+ */
+export interface SkillServiceOptions {
+    workspace: string;
+    skillsDirectory?: string;
+    outputMode: OutputMode;
+}

package/dist/cli/types.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});