@joelbonito/mcp-server 5.0.1

package/README.md

@@ -0,0 +1,134 @@
+# @joelbonito/mcp-server
+
+[![npm version](https://img.shields.io/npm/v/@joelbonito/mcp-server)](https://www.npmjs.com/package/@joelbonito/mcp-server)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/JoelBonito/inove-ai-framework/blob/main/LICENSE)
+
+MCP server for **Inove AI Framework** — 21 agents, 41 skills, and 22 workflows served via the Model Context Protocol.
+
+Zero disk usage per project. Auto-updates on every run. Setup in 30 seconds.
+
+## Quick Start
+
+### Claude Code
+
+```bash
+claude mcp add inove-ai -- npx -y @joelbonito/mcp-server
+```
+
+### Cursor / VS Code
+
+Add to `.cursor/mcp.json` or `.vscode/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "inove-ai": {
+      "command": "npx",
+      "args": ["-y", "@joelbonito/mcp-server"]
+    }
+  }
+}
+```
+
+### Windsurf / Cline
+
+Any MCP-compatible tool works — point it to `npx -y @joelbonito/mcp-server` as a stdio server.
+
+## What You Get
+
+### 8 Tools
+
+| Tool | Description |
+|------|-------------|
+| `list_agents` | List all 21 specialized agents |
+| `list_skills` | List all 41 modular skills |
+| `list_workflows` | List all 22 workflows |
+| `get_agent` | Get full agent content by name |
+| `get_skill` | Get skill content (SKILL.md + sub-files) |
+| `get_workflow` | Get workflow content by name |
+| `route_task` | Recommend agents + skills for a task description |
+| `search_content` | Full-text search across all content |
+
+### 6 Resources
+
+| URI | Description |
+|-----|-------------|
+| `inove://agents` | JSON list of all agents |
+| `inove://agents/{name}` | Full agent markdown |
+| `inove://skills/{name}` | Full skill markdown |
+| `inove://workflows/{name}` | Full workflow markdown |
+| `inove://architecture` | Architecture documentation |
+| `inove://instructions` | Framework instructions |
+
+### 22 Prompts
+
+One prompt per workflow: `define`, `debug`, `create`, `brainstorm`, `enhance`, `deploy`, `test`, `track`, `status`, `log`, `finish`, `orchestrate`, `plan`, `preview`, `ui-ux-pro-max`, `review`, `test-book`, `release`, `squad`, `context`, `readiness`, `journeys`.
+
+## Agents
+
+| Agent | Domain |
+|-------|--------|
+| `orchestrator` | Multi-agent coordination |
+| `project-planner` | Architecture, system design |
+| `product-manager` | Requirements, discovery |
+| `product-owner` | User stories, backlog, MVP |
+| `frontend-specialist` | React, UI/UX, Tailwind |
+| `backend-specialist` | APIs, Node.js, server |
+| `database-architect` | Schemas, queries, migrations |
+| `mobile-developer` | iOS, Android, React Native |
+| `security-auditor` | Auth, OWASP, compliance |
+| `penetration-tester` | Offensive security testing |
+| `debugger` | Root cause analysis |
+| `devops-engineer` | CI/CD, Docker, infra |
+| `test-engineer` | Test strategies, TDD |
+| `qa-automation-engineer` | E2E, Playwright, automation |
+| `performance-optimizer` | Speed, Core Web Vitals |
+| `seo-specialist` | SEO, visibility, ranking |
+| `documentation-writer` | Technical documentation |
+| `code-archaeologist` | Legacy code, refactoring |
+| `game-developer` | Game logic, engines |
+| `ux-researcher` | User flows, wireframes, usability |
+| `explorer-agent` | Codebase analysis |
+
+## Usage Examples
+
+```
+User: "Help me debug this React authentication bug"
+AI:   [calls route_task] → recommends debugger + security-auditor
+      [calls get_agent("debugger")] → loads persona + protocols
+      → Starts systematic debugging with root cause analysis
+```
+
+```
+User: "List available workflows"
+AI:   [calls list_workflows] → 22 workflows with descriptions
+      → Shows /define, /debug, /create, /deploy, etc.
+```
+
+## Requirements
+
+- Node.js >= 22
+- Any MCP-compatible AI tool
+
+## Development
+
+```bash
+git clone https://github.com/JoelBonito/inove-ai-framework.git
+cd inove-ai-framework/mcp-server
+npm install
+npm run dev      # Reads from .agents/ filesystem (hot reload)
+npm test         # 91 tests
+npm run build    # Bundles content + compiles TypeScript
+```
+
+## Architecture
+
+- **stdio transport** for local use via `npx`
+- **Cloudflare Workers** for remote SSE access
+- Content from `.agents/` is embedded at build-time into `registry.ts`
+- In dev mode, reads directly from the filesystem for instant feedback
+- Only 3 runtime dependencies: `@modelcontextprotocol/sdk`, `yaml`, `zod`
+
+## License
+
+MIT

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const SERVER_NAME = "inove-ai";
+export declare const SERVER_VERSION = "5.0.1";
+export declare const ROUTING_KEYWORDS: Record<string, string[]>;

package/dist/constants.js

@@ -0,0 +1,26 @@
+export const SERVER_NAME = "inove-ai";
+export const SERVER_VERSION = "5.0.1";
+export const ROUTING_KEYWORDS = {
+    "frontend-specialist": ["ui", "componente", "pagina", "frontend", "react", "tailwind", "css", "layout"],
+    "backend-specialist": ["api", "endpoint", "backend", "servidor", "server", "node", "express", "fastapi"],
+    "database-architect": ["database", "schema", "query", "migracao", "sql", "prisma", "drizzle"],
+    "mobile-developer": ["mobile", "ios", "android", "react native", "flutter", "app"],
+    "security-auditor": ["auth", "seguranca", "vulnerabilidade", "owasp", "security", "jwt"],
+    "debugger": ["bug", "erro", "nao funciona", "debug", "error", "crash"],
+    "qa-automation-engineer": ["teste", "e2e", "ci/cd", "test", "playwright", "jest"],
+    "devops-engineer": ["deploy", "docker", "infraestrutura", "ci", "cd", "kubernetes"],
+    "product-owner": ["requisitos", "user story", "backlog", "mvp", "product"],
+    "ux-researcher": ["ux", "user flow", "wireframe", "jornada", "usabilidade"],
+    "performance-optimizer": ["performance", "lento", "slow", "otimizar", "optimize", "lighthouse"],
+    "seo-specialist": ["seo", "meta tags", "sitemap", "ranking", "google"],
+    "documentation-writer": ["documentacao", "docs", "readme", "manual"],
+    "code-archaeologist": ["legacy", "refatorar", "refactor", "divida tecnica", "tech debt"],
+    "orchestrator": ["orquestrar", "multi-agente", "coordenar", "complexo"],
+    "project-planner": ["arquitetura", "architecture", "sistema", "design system"],
+    "product-manager": ["brief", "discovery", "requisito"],
+    "penetration-tester": ["pentest", "invasao", "exploit", "security test"],
+    "game-developer": ["game", "jogo", "unity", "godot"],
+    "test-engineer": ["unit test", "integration test", "tdd", "test strategy"],
+    "explorer-agent": ["analise", "codebase", "overview", "explore"],
+};
+//# sourceMappingURL=constants.js.map

package/dist/core/prompts.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ContentCache } from "../types.js";
+export declare function registerPrompts(server: McpServer, cache: ContentCache): void;

package/dist/core/prompts.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+export function registerPrompts(server, cache) {
+    for (const [name, workflow] of cache.workflows) {
+        server.prompt(name, workflow.meta.description || `Execute the /${name} workflow`, { topic: z.string().optional().describe("Topic or context for this workflow") }, ({ topic }) => ({
+            messages: [
+                {
+                    role: "assistant",
+                    content: {
+                        type: "text",
+                        text: workflow.raw,
+                    },
+                },
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: topic
+                            ? `Execute /${name} for: ${topic}`
+                            : `Execute /${name}`,
+                    },
+                },
+            ],
+        }));
+    }
+}
+//# sourceMappingURL=prompts.js.map

package/dist/core/resources.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ContentCache } from "../types.js";
+export declare function registerResources(server: McpServer, cache: ContentCache): void;

package/dist/core/resources.js

@@ -0,0 +1,45 @@
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+export function registerResources(server, cache) {
+    // Static: list of all agents as JSON
+    server.resource("agents-list", "inove://agents", { mimeType: "application/json", description: "List of all agents with name, description and skills" }, () => {
+        const list = [...cache.agents.values()].map((a) => ({
+            name: a.meta.name,
+            description: a.meta.description,
+            skills: a.meta.skills,
+        }));
+        return { contents: [{ uri: "inove://agents", text: JSON.stringify(list, null, 2), mimeType: "application/json" }] };
+    });
+    // Static: architecture doc
+    server.resource("architecture", "inove://architecture", { mimeType: "text/markdown", description: "Framework architecture documentation" }, () => ({
+        contents: [{ uri: "inove://architecture", text: cache.architecture, mimeType: "text/markdown" }],
+    }));
+    // Static: instructions doc
+    server.resource("instructions", "inove://instructions", { mimeType: "text/markdown", description: "Framework usage instructions" }, () => ({
+        contents: [{ uri: "inove://instructions", text: cache.instructions, mimeType: "text/markdown" }],
+    }));
+    // Template: individual agent
+    server.resource("agent", new ResourceTemplate("inove://agents/{name}", { list: undefined }), { mimeType: "text/markdown", description: "Full content of a specific agent" }, (uri, { name }) => {
+        const agent = cache.agents.get(name);
+        if (!agent) {
+            return { contents: [{ uri: uri.href, text: `Agent "${name}" not found`, mimeType: "text/plain" }] };
+        }
+        return { contents: [{ uri: uri.href, text: agent.raw, mimeType: "text/markdown" }] };
+    });
+    // Template: individual skill
+    server.resource("skill", new ResourceTemplate("inove://skills/{name}", { list: undefined }), { mimeType: "text/markdown", description: "Full content of a specific skill (SKILL.md + sub-files)" }, (uri, { name }) => {
+        const skill = cache.skills.get(name);
+        if (!skill) {
+            return { contents: [{ uri: uri.href, text: `Skill "${name}" not found`, mimeType: "text/plain" }] };
+        }
+        return { contents: [{ uri: uri.href, text: skill.raw, mimeType: "text/markdown" }] };
+    });
+    // Template: individual workflow
+    server.resource("workflow", new ResourceTemplate("inove://workflows/{name}", { list: undefined }), { mimeType: "text/markdown", description: "Full content of a specific workflow" }, (uri, { name }) => {
+        const workflow = cache.workflows.get(name);
+        if (!workflow) {
+            return { contents: [{ uri: uri.href, text: `Workflow "${name}" not found`, mimeType: "text/plain" }] };
+        }
+        return { contents: [{ uri: uri.href, text: workflow.raw, mimeType: "text/markdown" }] };
+    });
+}
+//# sourceMappingURL=resources.js.map

package/dist/core/tools.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ContentCache } from "../types.js";
+export declare function registerTools(server: McpServer, cache: ContentCache): void;

package/dist/core/tools.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { routeTask } from "../utils/routing.js";
+import { searchContent } from "../utils/search.js";
+export function registerTools(server, cache) {
+    // list_agents
+    server.tool("list_agents", "List all available agents with name, description and skills", {}, () => {
+        const list = [...cache.agents.values()].map((a) => ({
+            name: a.meta.name,
+            description: a.meta.description,
+            skills: a.meta.skills,
+        }));
+        return { content: [{ type: "text", text: JSON.stringify(list, null, 2) }] };
+    });
+    // list_skills
+    server.tool("list_skills", "List all available skills with name and description", {}, () => {
+        const list = [...cache.skills.values()].map((s) => ({
+            name: s.meta.name,
+            description: s.meta.description,
+        }));
+        return { content: [{ type: "text", text: JSON.stringify(list, null, 2) }] };
+    });
+    // list_workflows
+    server.tool("list_workflows", "List all available workflows (slash commands) with name and description", {}, () => {
+        const list = [...cache.workflows.entries()].map(([name, w]) => ({
+            name,
+            description: w.meta.description,
+        }));
+        return { content: [{ type: "text", text: JSON.stringify(list, null, 2) }] };
+    });
+    // get_agent
+    server.tool("get_agent", "Get full content of a specific agent by name", { name: z.string().min(1).max(100).describe("Agent name (e.g. 'debugger', 'frontend-specialist')") }, ({ name }) => {
+        const agent = cache.agents.get(name);
+        if (!agent) {
+            return { content: [{ type: "text", text: `Agent "${name}" not found. Use list_agents to see available agents.` }], isError: true };
+        }
+        return { content: [{ type: "text", text: agent.raw }] };
+    });
+    // get_skill
+    server.tool("get_skill", "Get full content of a specific skill (SKILL.md + sub-files concatenated)", { name: z.string().min(1).max(100).describe("Skill name (e.g. 'clean-code', 'mcp-builder')") }, ({ name }) => {
+        const skill = cache.skills.get(name);
+        if (!skill) {
+            return { content: [{ type: "text", text: `Skill "${name}" not found. Use list_skills to see available skills.` }], isError: true };
+        }
+        return { content: [{ type: "text", text: skill.raw }] };
+    });
+    // get_workflow
+    server.tool("get_workflow", "Get full content of a specific workflow (slash command)", { name: z.string().min(1).max(100).describe("Workflow name (e.g. 'define', 'debug', 'create')") }, ({ name }) => {
+        const workflow = cache.workflows.get(name);
+        if (!workflow) {
+            return { content: [{ type: "text", text: `Workflow "${name}" not found. Use list_workflows to see available workflows.` }], isError: true };
+        }
+        return { content: [{ type: "text", text: workflow.raw }] };
+    });
+    // route_task
+    server.tool("route_task", "Recommend the best agents and skills for a given task based on keyword analysis", { request: z.string().min(1).max(10000).describe("Description of the task (e.g. 'fix authentication bug', 'build a dashboard')") }, ({ request }) => {
+        const result = routeTask(request, cache);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    });
+    // search_content
+    server.tool("search_content", "Full-text search across all framework content (agents, skills, workflows)", {
+        query: z.string().min(1).max(5000).describe("Search query"),
+        scope: z.enum(["all", "agents", "skills", "workflows"]).default("all").describe("Scope to search in"),
+        max_results: z.number().int().min(1).max(50).default(10).describe("Maximum results to return"),
+    }, ({ query, scope, max_results }) => {
+        const results = searchContent(query, scope, max_results, cache);
+        return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+    });
+}
+//# sourceMappingURL=tools.js.map

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { SERVER_NAME, SERVER_VERSION } from "./constants.js";
+import { getCache } from "./loaders/cache.js";
+import { registerResources } from "./core/resources.js";
+import { registerTools } from "./core/tools.js";
+import { registerPrompts } from "./core/prompts.js";
+async function main() {
+    const cache = await getCache();
+    const server = new McpServer({
+        name: SERVER_NAME,
+        version: SERVER_VERSION,
+    });
+    registerResources(server, cache);
+    registerTools(server, cache);
+    registerPrompts(server, cache);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/loaders/agents.d.ts

@@ -0,0 +1,2 @@
+import type { Agent } from "../types.js";
+export declare function loadAllAgents(): Promise<Map<string, Agent>>;

package/dist/loaders/agents.js

@@ -0,0 +1,20 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { PATHS } from "../paths.js";
+import { parseAgentFrontmatter } from "./frontmatter.js";
+export async function loadAllAgents() {
+    const agents = new Map();
+    const files = await readdir(PATHS.agents);
+    const mdFiles = files.filter((f) => f.endsWith(".md"));
+    const results = await Promise.all(mdFiles.map(async (file) => {
+        const raw = await readFile(join(PATHS.agents, file), "utf-8");
+        const { meta, body } = parseAgentFrontmatter(raw);
+        const name = meta.name || file.replace(/\.md$/, "");
+        return [name, { meta: { ...meta, name }, body, raw }];
+    }));
+    for (const [name, agent] of results) {
+        agents.set(name, agent);
+    }
+    return agents;
+}
+//# sourceMappingURL=agents.js.map

package/dist/loaders/cache.d.ts

@@ -0,0 +1,3 @@
+import type { ContentCache } from "../types.js";
+export declare function getCache(): Promise<ContentCache>;
+export declare function resetCache(): void;

package/dist/loaders/cache.js

@@ -0,0 +1,39 @@
+import { readFile } from "node:fs/promises";
+import { IS_DEV, PATHS } from "../paths.js";
+import { loadAllAgents } from "./agents.js";
+import { loadAllSkills } from "./skills.js";
+import { loadAllWorkflows } from "./workflows.js";
+import { EmbeddedLoader } from "./embedded.js";
+// Store the Promise (not the result) to prevent concurrent load race conditions
+let cachePromise = null;
+async function loadFromFilesystem() {
+    const [agents, skills, workflows, architecture, instructions] = await Promise.all([
+        loadAllAgents(),
+        loadAllSkills(),
+        loadAllWorkflows(),
+        readFile(PATHS.architecture, "utf-8"),
+        readFile(PATHS.instructions, "utf-8"),
+    ]);
+    return { agents, skills, workflows, architecture, instructions };
+}
+async function loadFromEmbedded() {
+    const loader = new EmbeddedLoader();
+    const [agents, skills, workflows, architecture, instructions] = await Promise.all([
+        loader.loadAgents(),
+        loader.loadSkills(),
+        loader.loadWorkflows(),
+        loader.loadFile("ARCHITECTURE"),
+        loader.loadFile("INSTRUCTIONS"),
+    ]);
+    return { agents, skills, workflows, architecture, instructions };
+}
+export function getCache() {
+    if (!cachePromise) {
+        cachePromise = IS_DEV ? loadFromFilesystem() : loadFromEmbedded();
+    }
+    return cachePromise;
+}
+export function resetCache() {
+    cachePromise = null;
+}
+//# sourceMappingURL=cache.js.map

package/dist/loaders/embedded.d.ts

@@ -0,0 +1,7 @@
+import type { Agent, ContentLoader, Skill, Workflow } from "../types.js";
+export declare class EmbeddedLoader implements ContentLoader {
+    loadAgents(): Promise<Map<string, Agent>>;
+    loadSkills(): Promise<Map<string, Skill>>;
+    loadWorkflows(): Promise<Map<string, Workflow>>;
+    loadFile(path: string): Promise<string>;
+}

package/dist/loaders/embedded.js

@@ -0,0 +1,50 @@
+import { parseAgentFrontmatter, parseSkillFrontmatter, parseWorkflowFrontmatter } from "./frontmatter.js";
+// Dynamic import — registry.ts only exists after prebuild
+async function loadRegistry() {
+    return import("../registry.js");
+}
+export class EmbeddedLoader {
+    async loadAgents() {
+        const { EMBEDDED_AGENTS } = await loadRegistry();
+        const agents = new Map();
+        for (const [key, raw] of Object.entries(EMBEDDED_AGENTS)) {
+            const { meta, body } = parseAgentFrontmatter(raw);
+            const name = meta.name || key;
+            agents.set(name, { meta: { ...meta, name }, body, raw });
+        }
+        return agents;
+    }
+    async loadSkills() {
+        const { EMBEDDED_SKILLS } = await loadRegistry();
+        const skills = new Map();
+        for (const [key, data] of Object.entries(EMBEDDED_SKILLS)) {
+            const { meta, body } = parseSkillFrontmatter(data.skill);
+            const name = meta.name || key;
+            const subFiles = Object.entries(data.subFiles).map(([filename, content]) => ({ filename, content }));
+            let raw = data.skill;
+            for (const sub of subFiles) {
+                raw += `\n\n---\n\n# ${sub.filename}\n\n${sub.content}`;
+            }
+            skills.set(name, { meta: { ...meta, name }, body, subFiles, hasScripts: data.hasScripts, raw });
+        }
+        return skills;
+    }
+    async loadWorkflows() {
+        const { EMBEDDED_WORKFLOWS } = await loadRegistry();
+        const workflows = new Map();
+        for (const [name, raw] of Object.entries(EMBEDDED_WORKFLOWS)) {
+            const { meta, body } = parseWorkflowFrontmatter(raw);
+            workflows.set(name, { meta, body, raw });
+        }
+        return workflows;
+    }
+    async loadFile(path) {
+        const registry = await loadRegistry();
+        if (path === "ARCHITECTURE")
+            return registry.EMBEDDED_ARCHITECTURE;
+        if (path === "INSTRUCTIONS")
+            return registry.EMBEDDED_INSTRUCTIONS;
+        throw new Error(`Unknown embedded file: ${path}`);
+    }
+}
+//# sourceMappingURL=embedded.js.map

package/dist/loaders/frontmatter.d.ts

@@ -0,0 +1,17 @@
+import type { AgentMeta, SkillMeta, WorkflowMeta } from "../types.js";
+export declare function parseFrontmatter<T>(content: string): {
+    meta: T;
+    body: string;
+};
+export declare function parseAgentFrontmatter(content: string): {
+    meta: AgentMeta;
+    body: string;
+};
+export declare function parseSkillFrontmatter(content: string): {
+    meta: SkillMeta;
+    body: string;
+};
+export declare function parseWorkflowFrontmatter(content: string): {
+    meta: WorkflowMeta;
+    body: string;
+};

package/dist/loaders/frontmatter.js

@@ -0,0 +1,71 @@
+import YAML from "yaml";
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+export function parseFrontmatter(content) {
+    const match = content.match(FRONTMATTER_RE);
+    if (!match) {
+        return { meta: {}, body: content };
+    }
+    let meta;
+    try {
+        meta = YAML.parse(match[1]);
+    }
+    catch {
+        // Fallback: parse key-value pairs manually for YAML with unquoted special chars
+        const result = Object.create(null);
+        for (const line of match[1].split("\n")) {
+            const idx = line.indexOf(":");
+            if (idx > 0) {
+                const key = line.slice(0, idx).trim();
+                const val = line.slice(idx + 1).trim();
+                result[key] = val;
+            }
+        }
+        meta = result;
+    }
+    const body = match[2].trim();
+    return { meta, body };
+}
+function splitCsv(value) {
+    if (Array.isArray(value))
+        return value.map(String);
+    if (typeof value === "string") {
+        return value.split(",").map((s) => s.trim()).filter(Boolean);
+    }
+    return [];
+}
+export function parseAgentFrontmatter(content) {
+    const { meta, body } = parseFrontmatter(content);
+    return {
+        meta: {
+            name: String(meta.name ?? ""),
+            description: String(meta.description ?? ""),
+            tools: splitCsv(meta.tools),
+            model: String(meta.model ?? "inherit"),
+            skills: splitCsv(meta.skills),
+        },
+        body,
+    };
+}
+export function parseSkillFrontmatter(content) {
+    const { meta, body } = parseFrontmatter(content);
+    return {
+        meta: {
+            name: String(meta.name ?? ""),
+            description: String(meta.description ?? ""),
+            allowedTools: meta["allowed-tools"] ? splitCsv(meta["allowed-tools"]) : undefined,
+            version: meta.version != null ? String(meta.version) : undefined,
+            priority: meta.priority != null ? String(meta.priority) : undefined,
+        },
+        body,
+    };
+}
+export function parseWorkflowFrontmatter(content) {
+    const { meta, body } = parseFrontmatter(content);
+    return {
+        meta: {
+            description: String(meta.description ?? ""),
+        },
+        body,
+    };
+}
+//# sourceMappingURL=frontmatter.js.map

package/dist/loaders/skills.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from "../types.js";
+export declare function loadAllSkills(): Promise<Map<string, Skill>>;

package/dist/loaders/skills.js

@@ -0,0 +1,55 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { PATHS } from "../paths.js";
+import { parseSkillFrontmatter } from "./frontmatter.js";
+export async function loadAllSkills() {
+    const skills = new Map();
+    const entries = await readdir(PATHS.skills);
+    const results = await Promise.all(entries.map(async (entry) => {
+        const skillDir = join(PATHS.skills, entry);
+        const info = await stat(skillDir);
+        if (!info.isDirectory())
+            return null;
+        const skillFile = join(skillDir, "SKILL.md");
+        let skillContent;
+        try {
+            skillContent = await readFile(skillFile, "utf-8");
+        }
+        catch {
+            return null; // No SKILL.md — skip
+        }
+        const { meta, body } = parseSkillFrontmatter(skillContent);
+        const name = meta.name || entry;
+        // Load sub-files (other .md files in the directory)
+        const subFiles = [];
+        const dirFiles = await readdir(skillDir);
+        for (const f of dirFiles) {
+            if (f === "SKILL.md" || !f.endsWith(".md"))
+                continue;
+            const content = await readFile(join(skillDir, f), "utf-8");
+            subFiles.push({ filename: f, content });
+        }
+        // Check for scripts/ directory
+        let hasScripts = false;
+        try {
+            const scriptsDir = join(skillDir, "scripts");
+            const scriptsInfo = await stat(scriptsDir);
+            hasScripts = scriptsInfo.isDirectory();
+        }
+        catch {
+            // No scripts directory
+        }
+        // Build concatenated raw content
+        let raw = skillContent;
+        for (const sub of subFiles) {
+            raw += `\n\n---\n\n# ${sub.filename}\n\n${sub.content}`;
+        }
+        return [name, { meta: { ...meta, name }, body, subFiles, hasScripts, raw }];
+    }));
+    for (const result of results) {
+        if (result)
+            skills.set(result[0], result[1]);
+    }
+    return skills;
+}
+//# sourceMappingURL=skills.js.map

package/dist/loaders/workflows.d.ts

@@ -0,0 +1,2 @@
+import type { Workflow } from "../types.js";
+export declare function loadAllWorkflows(): Promise<Map<string, Workflow>>;

package/dist/loaders/workflows.js

@@ -0,0 +1,20 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { PATHS } from "../paths.js";
+import { parseWorkflowFrontmatter } from "./frontmatter.js";
+export async function loadAllWorkflows() {
+    const workflows = new Map();
+    const files = await readdir(PATHS.workflows);
+    const mdFiles = files.filter((f) => f.endsWith(".md"));
+    const results = await Promise.all(mdFiles.map(async (file) => {
+        const raw = await readFile(join(PATHS.workflows, file), "utf-8");
+        const { meta, body } = parseWorkflowFrontmatter(raw);
+        const name = file.replace(/\.md$/, "");
+        return [name, { meta, body, raw }];
+    }));
+    for (const [name, workflow] of results) {
+        workflows.set(name, workflow);
+    }
+    return workflows;
+}
+//# sourceMappingURL=workflows.js.map