@agentlee5/agent-skills 1.0.0

package/mcp-server/src/index.ts

@@ -0,0 +1,355 @@
+#!/usr/bin/env node
+
+/*
+LEEWAY HEADER — DO NOT REMOVE
+
+REGION: LEEWAY.SKILLS.MCP
+TAG: LEEWAY.SKILLS.MCP.SERVER
+
+COLOR_ONION_HEX:
+NEON=#39FF14
+FLUO=#0DFF94
+PASTEL=#C7FFD8
+
+ICON_ASCII:
+family=lucide
+glyph=server
+
+5WH:
+WHAT = Leeway Skills MCP Server - Exposes all Leeway Skills as callable MCP tools
+WHY = Enables Agent Lee and other LLMs to use skills as first-class tools via MCP protocol
+WHO = Leeway Industries (By Leonard Jerome Lee)
+WHERE = mcp-server/src/index.ts
+WHEN = 2026
+HOW = Node.js MCP server that reads skill definitions and exposes them as callable tools
+
+AGENTS:
+SERVE
+EXECUTE
+INTROSPECT
+
+LICENSE:
+MIT
+*/
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
+    Tool
+} from "@modelcontextprotocol/sdk/types.js";
+import fs from "fs/promises";
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * SkillsTool - Maps a Leeway Skill to an MCP Tool
+ */
+export interface SkillsTool {
+  name: string;
+  category: string;
+  description: string;
+  capabilities: string[];
+  tags: string[];
+  skillPath: string;
+  version: string;
+}
+
+export interface SkillRegistryEntry {
+  name: string;
+  category: string;
+  path: string;
+  version?: string;
+  tags?: string[];
+  description: string;
+  capabilities?: string[];
+  enabled?: boolean;
+}
+
+export interface SkillRegistry {
+  skills?: SkillRegistryEntry[];
+}
+
+export interface ToolCallArguments {
+  instruction: string;
+  context?: Record<string, unknown>;
+  options?: Record<string, unknown>;
+}
+
+/**
+ * LeewaySkillsMCPServer - Main MCP server implementation
+ *
+ * Provides:
+ * - Tool listing (all available skills)
+ * - Tool invocation (execute skill logic)
+ * - Tool introspection (get skill metadata)
+ */
+export class LeewaySkillsMCPServer {
+  private server: Server;
+  private skills: Map<string, SkillsTool> = new Map();
+  private registryPath: string;
+
+  constructor() {
+    this.registryPath = path.resolve(
+      __dirname,
+      "../../scripts/skills-registry.json",
+    );
+
+    this.server = new Server(
+      {
+        name: "leeway-skills-mcp",
+        version: "1.0.0",
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      },
+    );
+
+    this.setupHandlers();
+  }
+
+  /**
+   * Load all skills from the registry
+   */
+  async loadSkills(): Promise<void> {
+    try {
+      const registryContent = await fs.readFile(this.registryPath, "utf-8");
+      const registry = JSON.parse(registryContent) as SkillRegistry;
+
+      if (registry.skills && Array.isArray(registry.skills)) {
+        registry.skills.forEach((skill) => {
+          if (skill.enabled) {
+            const skillId = skill.name.toLowerCase().replace(/\s+/g, "-");
+
+            this.skills.set(skillId, {
+              name: skill.name,
+              category: skill.category,
+              description: skill.description,
+              capabilities: skill.capabilities || [],
+              tags: skill.tags || [],
+              skillPath: skill.path,
+              version: skill.version || "1.0.0",
+            });
+          }
+        });
+      }
+
+      console.error(
+        `[Leeway Skills MCP] Loaded ${this.skills.size} skills from registry`,
+      );
+    } catch (error) {
+      console.error(
+        `[Leeway Skills MCP] Error loading skills registry:`,
+        error,
+      );
+    }
+  }
+
+  /**
+   * Setup MCP handlers
+   */
+  private setupHandlers(): void {
+    /**
+     * Handle tool listing
+     */
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      const tools: Tool[] = [];
+
+      for (const [skillId, skill] of this.skills) {
+        tools.push({
+          name: skillId,
+          description: `${skill.description}\n\nCategory: ${skill.category}\nCapabilities: ${skill.capabilities.join(", ")}`,
+          inputSchema: {
+            type: "object",
+            properties: {
+              instruction: {
+                type: "string",
+                description: `Detailed instruction for applying the ${skill.name} skill`,
+              },
+              context: {
+                type: "object",
+                description: "Additional context or code to analyze/generate",
+                properties: {
+                  code: { type: "string" },
+                  files: { type: "array", items: { type: "string" } },
+                  requirements: { type: "string" },
+                  framework: { type: "string" },
+                  language: { type: "string" },
+                },
+              },
+              options: {
+                type: "object",
+                description: "Skill-specific options and parameters",
+                additionalProperties: true,
+              },
+            },
+            required: ["instruction"],
+          },
+        });
+      }
+
+      return { tools };
+    });
+
+    /**
+     * Handle tool execution
+     */
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const toolName = request.params.name;
+      const skill = this.skills.get(toolName);
+
+      if (!skill) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Error: Skill "${toolName}" not found. Available skills: ${Array.from(this.skills.keys()).join(", ")}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      try {
+        const result = await this.executeSkill(
+          skill,
+          this.normalizeToolArgs(request.params.arguments),
+        );
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: result,
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Error executing skill "${toolName}": ${error instanceof Error ? error.message : String(error)}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    });
+  }
+
+  /**
+   * Execute a skill with given parameters
+   */
+  private async executeSkill(
+    skill: SkillsTool,
+    args: ToolCallArguments,
+  ): Promise<string> {
+    const { instruction, context = {}, options = {} } = args;
+
+    // Try to load the skill SKILL.md file for detailed instructions
+    let skillInstructions = "";
+    try {
+      const skillPath = path.resolve(
+        __dirname,
+        `../../${skill.skillPath}/SKILL.md`,
+      );
+      skillInstructions = await fs.readFile(skillPath, "utf-8");
+    } catch {
+      skillInstructions = `# ${skill.name}\n\n${skill.description}\n\nCapabilities: ${skill.capabilities.join(", ")}`;
+    }
+
+    // Build the skill execution prompt
+    const executionPrompt = `
+Executing the "${skill.name}" skill from Leeway Skills.
+
+SKILL DOCUMENTATION:
+${skillInstructions}
+
+USER INSTRUCTION:
+${instruction}
+
+CONTEXT PROVIDED:
+${JSON.stringify(context, null, 2)}
+
+OPTIONS:
+${JSON.stringify(options, null, 2)}
+
+Please execute this skill instruction using the skill's expertise and capabilities. 
+Provide structured, actionable output that can be directly used.
+Reference specific techniques from the skill documentation when applicable.
+`;
+
+    return executionPrompt;
+  }
+
+  private normalizeToolArgs(args: Record<string, unknown> | undefined): ToolCallArguments {
+    const instruction =
+      typeof args?.instruction === "string" ? args.instruction : "";
+    const context =
+      args?.context && typeof args.context === "object"
+        ? (args.context as Record<string, unknown>)
+        : {};
+    const options =
+      args?.options && typeof args.options === "object"
+        ? (args.options as Record<string, unknown>)
+        : {};
+
+    return { instruction, context, options };
+  }
+
+  /**
+   * Start the MCP server
+   */
+  async start(): Promise<void> {
+    await this.loadSkills();
+
+    // Connect transport
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+
+    console.error("[Leeway Skills MCP] Server started successfully");
+    console.error(`[Leeway Skills MCP] Serving ${this.skills.size} skills`);
+    console.error("[Leeway Skills MCP] Ready to accept tool calls from LLMs");
+  }
+}
+
+export async function startLeewaySkillsMCPServer(): Promise<LeewaySkillsMCPServer> {
+  const server = new LeewaySkillsMCPServer();
+  await server.start();
+  return server;
+}
+
+function isDirectExecution(): boolean {
+  if (!process.argv[1]) {
+    return false;
+  }
+
+  return import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href;
+}
+
+/**
+ * Main entry point
+ */
+async function main(): Promise<void> {
+  await startLeewaySkillsMCPServer();
+
+  // Handle graceful shutdown
+  process.on("SIGINT", () => {
+    console.error("[Leeway Skills MCP] Shutting down gracefully...");
+    process.exit(0);
+  });
+}
+
+if (isDirectExecution()) {
+  main().catch((error) => {
+    console.error("[Leeway Skills MCP] Fatal error:", error);
+    process.exit(1);
+  });
+}

package/mcp-server/src/install-badge-proof.ts

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+/*
+LEEWAY HEADER — DO NOT REMOVE
+
+REGION: LEEWAY.SKILLS.BADGE
+TAG: LEEWAY.SKILLS.BADGE.INSTALLER
+
+COLOR_ONION_HEX:
+NEON=#39FF14
+FLUO=#0DFF94
+PASTEL=#C7FFD8
+
+ICON_ASCII:
+family=lucide
+glyph=package-plus
+
+5WH:
+WHAT = CLI installer for the Leeway Skills badge proof bundle
+WHY = Makes it easy to drop a verified Leeway Skills badge into another application
+WHO = Leeway Industries (By Leonard Jerome Lee)
+WHERE = mcp-server/src/install-badge-proof.ts
+WHEN = 2026
+HOW = Parses CLI arguments, installs the badge bundle, and prints the integration output paths
+
+AGENTS:
+EXECUTE
+
+LICENSE:
+MIT
+*/
+
+import path from "path";
+import {
+  installLeewaySkillsBadgeBundle,
+  type InstallBadgeBundleOptions,
+} from "./badge-proof.js";
+
+function getArg(flag: string): string | undefined {
+  const index = process.argv.indexOf(flag);
+  if (index === -1) {
+    return undefined;
+  }
+
+  return process.argv[index + 1];
+}
+
+function hasFlag(flag: string): boolean {
+  return process.argv.includes(flag);
+}
+
+function getPositionalArgs(): string[] {
+  const rawArgs = process.argv.slice(2);
+  const positional: string[] = [];
+
+  for (let index = 0; index < rawArgs.length; index += 1) {
+    const arg = rawArgs[index];
+    if (arg.startsWith("--")) {
+      if (arg !== "--help") {
+        index += 1;
+      }
+      continue;
+    }
+
+    positional.push(arg);
+  }
+
+  return positional;
+}
+
+function printHelp(): void {
+  console.log(`Leeway Skills Badge Proof Installer
+
+Usage:
+  node dist/install-badge-proof.js --target <dir> [options]
+
+Options:
+  --target <dir>             Directory to receive the badge bundle
+  --app-name <name>          Application name shown in the badge proof
+  --app-version <version>    Application version stored in the proof manifest
+  --app-url <url>            Application URL stored in the proof manifest
+  --integration-method <id>  Integration method label, default: mcp-server
+  --asset-dir <name>         Asset subdirectory name, default: assets
+  --badge-file <name>        Output badge filename, default: leeway-skills-agent-badge.png
+  --help                     Show this help output
+`);
+}
+
+async function main(): Promise<void> {
+  if (hasFlag("--help")) {
+    printHelp();
+    return;
+  }
+
+  const positionalArgs = getPositionalArgs();
+  const targetArg = getArg("--target") ?? positionalArgs[0];
+  if (!targetArg) {
+    throw new Error("Missing required --target argument");
+  }
+
+  const options: InstallBadgeBundleOptions = {
+    targetDir: targetArg,
+    appName: getArg("--app-name") ?? positionalArgs[1],
+    appVersion: getArg("--app-version"),
+    appUrl: getArg("--app-url"),
+    integrationMethod:
+      getArg("--integration-method") ?? positionalArgs[2],
+    assetDirName: getArg("--asset-dir"),
+    badgeFileName: getArg("--badge-file"),
+  };
+
+  const result = await installLeewaySkillsBadgeBundle(options);
+
+  console.log("[Leeway Skills Badge] Bundle installed");
+  console.log(`  Target: ${result.targetDir}`);
+  console.log(`  Proof: ${result.files.proof}`);
+  console.log(`  Script: ${result.files.script}`);
+  console.log(`  Style: ${result.files.style}`);
+  console.log(`  Snippet: ${result.files.snippet}`);
+  console.log(`  Badge: ${result.files.badge}`);
+  console.log(
+    `  Active Skills: ${result.proof.leewaySkills.activeSkills} | Installed Skills: ${result.proof.leewaySkills.installedSkills}`,
+  );
+  console.log(
+    `  Snippet Preview: ${path.join(result.targetDir, "leeway-skills-badge.html")}`,
+  );
+}
+
+main().catch((error) => {
+  console.error("[Leeway Skills Badge] Fatal error:", error);
+  process.exit(1);
+});

package/mcp-server/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["node"],
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@agentlee5/agent-skills",
+  "version": "1.0.0",
+  "description": "Full Leeway Agent Skills application bundle for npm, including the MCP server, standards toolkit, skill library, workflows, badge assets, and governance automation.",
+  "type": "module",
+  "main": "./sdk/index.js",
+  "exports": {
+    ".": "./sdk/index.js",
+    "./paths": "./sdk/paths.js",
+    "./installer": "./sdk/application-installer.js",
+    "./badge-proof": "./mcp-server/dist/badge-proof.js",
+    "./mcp": "./mcp-server/dist/index.js",
+    "./standards": "./LeeWay-Standards/src/index.js",
+    "./registry.json": "./scripts/skills-registry.json",
+    "./skills-config.json": "./config/skills-config.json",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "leeway-agent-skills": "./bin/leeway-skills.js",
+    "leeway-agent-skills-mcp": "./bin/leeway-skills-mcp.js",
+    "leeway-agent-skills-badge": "./bin/leeway-skills-badge.js",
+    "leeway-agent-standards": "./bin/leeway-standards.js",
+    "leeway-skills": "./bin/leeway-skills.js",
+    "leeway-skills-mcp": "./bin/leeway-skills-mcp.js",
+    "leeway-skills-badge": "./bin/leeway-skills-badge.js",
+    "leeway-standards": "./bin/leeway-standards.js"
+  },
+  "scripts": {
+    "build": "npm --prefix mcp-server run build",
+    "prepack": "npm run build",
+    "pack:dry-run": "npm pack --dry-run",
+    "verify:package": "node ./bin/leeway-skills.js info"
+  },
+  "keywords": [
+    "leeway",
+    "skills",
+    "sdk",
+    "mcp",
+    "agent",
+    "ai",
+    "governance",
+    "workflows",
+    "badge"
+  ],
+  "author": "Leeway Industries (By Leonard Jerome Lee)",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.5.0"
+  },
+  "files": [
+    ".leeway/config.json",
+    "LeeWay-Standards/LICENSE",
+    "LeeWay-Standards/README.md",
+    "LeeWay-Standards/examples/",
+    "LeeWay-Standards/package.json",
+    "LeeWay-Standards/schemas/",
+    "LeeWay-Standards/src/",
+    "LICENSE",
+    "README.md",
+    "agent-config.yaml",
+    "agentbage.png.png",
+    "bin/",
+    "config/",
+    "documents/",
+    "mcp-server/README.md",
+    "mcp-server/dist/",
+    "mcp-server/package.json",
+    "mcp-server/src/",
+    "mcp-server/tsconfig.json",
+    "scripts/",
+    "sdk/",
+    "skills/"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "local"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}