@iflow-mcp/back1ply-agent-skill-loader 1.0.2

package/25014_process.log

@@ -0,0 +1,4 @@
+[2026-03-17 12:11:54] [✓] 步骤1: 获取项目 - Fork并克隆GitHub项目成功
+[2026-03-17 12:12:12] [✓] 步骤2: 阅读代码 - 项目分析完成，确认为Node.js MCP服务端项目
+[2026-03-17 12:13:04] [✓] 步骤3: 本地测试 - 成功检测到5个工具，本地测试通过
+[2026-03-17 12:14:45] [✓] 步骤4: 推送iflow分支 - 成功推送到远程仓库

package/ARCHITECTURE.md

@@ -0,0 +1,47 @@
+# Architecture & Context 🏗️
+
+This document provides technical context for AI agents working on this codebase.
+
+## System Overview
+
+**Agent Skill Loader** is a Node.js-based MCP Server. It does not maintain a persistent database; it scans the file system in real-time (or near real-time) to discover "Skills".
+
+### Core Definitions
+
+*   **Skill**: A directory containing a `SKILL.md` file. The `SKILL.md` contains the instructions (system prompt fragment) for the AI.
+*   **Skill Library**: A root directory containing multiple Skill directories.
+
+## Logic Flow (`src/index.ts`)
+
+1.  **Initialization**:
+    *   The server starts using `StdioServerTransport`.
+    *   It loads configuration from `.env`.
+    *   It reads `MCP_SKILL_PATHS` to determine where to scan.
+
+2.  **Tool: `list_skills`**:
+    *   Recursively scans `SEARCH_PATHS`.
+    *   Looks for `SKILL.md`.
+    *   Parses frontmatter (YAML-style) to extract `description`.
+    *   Returns a simplified JSON list to save context tokens.
+
+3.  **Tool: `read_skill`**:
+    *   Finds the specific skill by name.
+    *   Reads `SKILL.md`.
+    *   Returns the raw text Content.
+
+4.  **Tool: `install_skill`**:
+    *   Locates the source directory.
+    *   **Security**: Validates that target path is within current workspace.
+    *   Uses `fs.cpSync` to recursively copy the content to the User's active workspace.
+
+## Key Design Decisions
+
+*   **Recursive Scanning**: We scan subdirectories to find skills, allowing for categorized folder structures (e.g., `dax/skills/writing-dax-measures`).
+*   **No Database**: To keep it lightweight and stateless, we scan the FS. Performance is acceptable for <1000 skills.
+*   **TypeScript**: Used for type safety with the MCP SDK.
+
+## Development Guidelines
+
+*   **Building**: `npm run build` runs `tsc`.
+*   **Modifying Tools**: Add new tools in `src/index.ts` using `server.tool()`.
+*   **Error Handling**: All filesystem operations should be wrapped in try/catch blocks to prevent server crashes.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 back1ply
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,118 @@
+# Agent Skill Loader 🧠
+
+[![npm version](https://img.shields.io/npm/v/agent-skill-loader)](https://www.npmjs.com/package/agent-skill-loader)
+[![MCP Registry](https://img.shields.io/badge/MCP-Registry-green)](https://registry.modelcontextprotocol.io)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.4-blue)](https://www.typescriptlang.org/)
+[![MCP](https://img.shields.io/badge/MCP-Compatible-purple)](https://modelcontextprotocol.io)
+
+**Agent Skill Loader** is a Model Context Protocol (MCP) server that acts as a bridge between your static Claude Code Skills library and dynamic AI agents (like Antigravity, Claude Desktop, or Cursor).
+
+It allows agents to "learn" skills on demand without requiring you to manually copy files into every project.
+
+## 🚀 Features
+
+*   **Discovery**: `list_skills` - Scans your configured skill directories.
+*   **Dynamic Learning**: `read_skill` - Fetches the `SKILL.md` content for the agent to read.
+*   **Persistence**: `install_skill` - Copies the skill permanently to your project if needed.
+*   **Configuration**: `manage_search_paths` - Add/remove skill directories at runtime.
+*   **Troubleshooting**: `debug_info` - Diagnose configuration and path issues.
+
+## 🛠️ Setup
+
+### Prerequisites
+- Node.js >= 18
+
+### Option A: Install from npm (Recommended)
+```bash
+npm install -g agent-skill-loader
+```
+
+Then register in `.mcp.json`:
+```json
+"agent-skill-loader": {
+  "command": "agent-skill-loader"
+}
+```
+
+### Option B: Build from Source
+```bash
+git clone https://github.com/back1ply/agent-skill-loader.git
+cd agent-skill-loader
+npm install
+npm run build
+```
+
+Then register in `.mcp.json`:
+```json
+"agent-skill-loader": {
+  "command": "node",
+  "args": ["<path-to-repo>/build/index.js"]
+}
+```
+
+## 📂 Configuration
+
+The server automatically detects its workspace and aggregates skill paths from:
+
+1.  **Default**: `%USERPROFILE%\.claude\plugins\cache` (Standard location)
+2.  **Dynamic Config**: `skill-paths.json` (Located in the project root)
+
+### Dynamic Path Management
+You do not need to manually edit config files. Use the tool to manage paths at runtime:
+*   **Add**: `manage_search_paths(operation="add", path="F:\\My\\Deep\\Skills")`
+*   **Remove**: `manage_search_paths(operation="remove", path="...")`
+*   **List**: `manage_search_paths(operation="list")` creates/updates `skill-paths.json`.
+
+## 🤖 Usage
+
+### For Agents
+The agent will see five tools:
+*   `list_skills()`: Returns a JSON list of available skills.
+*   `read_skill(skill_name)`: Returns the markdown instructions.
+*   `install_skill(skill_name, target_path?)`: Copies the folder to `.agent/skills/<name>`. For security, `target_path` must be within the current workspace.
+*   `manage_search_paths(operation, path?)`: Add, remove, or list skill search paths.
+*   `debug_info()`: Returns diagnostic information (paths, status, warnings).
+
+### Example Agent Prompt
+> "I need to write a DAX measure but I'm not sure about the best practices."
+
+The agent will automatically call `list_skills`, find `writing-dax-measures`, call `read_skill`, and then answer you with expert knowledge.
+
+## 🔧 Troubleshooting
+
+If skills aren't being discovered, use `debug_info()` to see:
+*   **search_paths**: Which directories are being scanned
+*   **path_status**: Whether each path exists and is readable
+*   **warnings**: Any errors encountered during scanning (permission denied, empty files, etc.)
+
+Example output:
+```json
+{
+  "workspace_root": "C:/projects/agent-skill-loader",
+  "search_paths": {
+    "base": ["C:/Users/pc/.claude/plugins/cache"],
+    "dynamic": ["F:/My/Skills"],
+    "effective": ["C:/Users/pc/.claude/plugins/cache", "F:/My/Skills"]
+  },
+  "path_status": [
+    { "path": "C:/Users/pc/.claude/plugins/cache", "exists": true, "readable": true },
+    { "path": "F:/My/Skills", "exists": false, "readable": false }
+  ],
+  "skills_found": 12,
+  "warnings": [
+    { "path": "F:/My/Skills", "reason": "Directory does not exist" }
+  ]
+}
+```
+
+## 📦 Project Structure
+
+*   `src/index.ts`: Main server logic.
+*   `build/`: Compiled JavaScript output.
+*   `package.json`: Dependencies (`@modelcontextprotocol/sdk`, `zod`).
+
+## 🤝 Contributing
+
+To add new skills, simply add a folder with a `SKILL.md` file to one of the watched directories. The server picks them up automatically (no restart required for new files, though caching implementation may vary).

package/build/index.js

@@ -0,0 +1,364 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import * as fs from "fs";
+import * as path from "path";
+import { findSkillsInDir, getPathStatus } from "./utils.js";
+// Load environment variables manually (dotenv v17 outputs to stdout which corrupts MCP)
+function loadEnvFile() {
+    try {
+        const envPath = path.join(process.cwd(), ".env");
+        if (fs.existsSync(envPath)) {
+            const content = fs.readFileSync(envPath, "utf-8");
+            for (const line of content.split(/\r?\n/)) {
+                const trimmed = line.trim();
+                if (trimmed && !trimmed.startsWith("#")) {
+                    const eqIndex = trimmed.indexOf("=");
+                    if (eqIndex > 0) {
+                        const key = trimmed.slice(0, eqIndex).trim();
+                        let value = trimmed.slice(eqIndex + 1).trim();
+                        // Remove surrounding quotes if present
+                        if ((value.startsWith('"') && value.endsWith('"')) ||
+                            (value.startsWith("'") && value.endsWith("'"))) {
+                            value = value.slice(1, -1);
+                        }
+                        if (!process.env[key]) {
+                            process.env[key] = value;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Silently ignore .env loading errors
+    }
+}
+loadEnvFile();
+// --- Configuration ---
+import * as os from "os";
+import { fileURLToPath } from 'url';
+// --- Workspace & Config Logic ---
+// Auto-detect workspace root (project root)
+// We are in /build/index.js, so project root is one level up
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const AUTO_DETECTED_ROOT = path.resolve(__dirname, "..");
+function getWorkspaceRoot() {
+    // Allow override, else use auto-detected
+    return process.env.MCP_WORKSPACE_ROOT || AUTO_DETECTED_ROOT;
+}
+function getBasePaths() {
+    // 1. Always start with default path
+    const defaultPath = path.join(os.homedir(), ".claude", "plugins", "cache");
+    const paths = [defaultPath];
+    // 2. Add process.env paths if present
+    let envPaths = process.env.MCP_SKILL_PATHS;
+    if (envPaths) {
+        try {
+            const parsed = JSON.parse(envPaths);
+            if (Array.isArray(parsed)) {
+                paths.push(...parsed);
+            }
+            else {
+                // Assume separated string
+                paths.push(...envPaths.split(/;|,/).map((p) => p.trim()).filter(Boolean));
+            }
+        }
+        catch {
+            // Not valid JSON, assume separated string
+            paths.push(...envPaths.split(/;|,/).map((p) => p.trim()).filter(Boolean));
+        }
+    }
+    // Deduplicate
+    return Array.from(new Set(paths));
+}
+function getDynamicPaths() {
+    const basePaths = getBasePaths();
+    const cwd = getWorkspaceRoot();
+    const configPath = path.join(cwd, "skill-paths.json");
+    let dynamicPaths = [];
+    if (fs.existsSync(configPath)) {
+        try {
+            const content = fs.readFileSync(configPath, "utf-8");
+            const parsed = JSON.parse(content);
+            if (Array.isArray(parsed)) {
+                dynamicPaths = parsed;
+            }
+        }
+        catch (err) {
+            console.error("Error reading skill-paths.json:", err);
+        }
+    }
+    // Deduplicate
+    return Array.from(new Set([...basePaths, ...dynamicPaths]));
+}
+// --- Types ---
+// --- Helpers ---
+function getDynamicPathsOnly() {
+    const cwd = getWorkspaceRoot();
+    const configPath = path.join(cwd, "skill-paths.json");
+    if (fs.existsSync(configPath)) {
+        try {
+            const content = fs.readFileSync(configPath, "utf-8");
+            const parsed = JSON.parse(content);
+            if (Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    return [];
+}
+function scanAllPaths() {
+    let allSkills = [];
+    let allWarnings = [];
+    const searchPaths = getDynamicPaths();
+    for (const searchPath of searchPaths) {
+        const result = findSkillsInDir(searchPath);
+        allSkills = allSkills.concat(result.skills);
+        allWarnings = allWarnings.concat(result.warnings);
+    }
+    return { skills: allSkills, warnings: allWarnings };
+}
+function getAllSkills() {
+    return scanAllPaths().skills;
+}
+function getAllWarnings() {
+    return scanAllPaths().warnings;
+}
+// --- Server Setup ---
+const server = new McpServer({
+    name: "agent-skill-loader",
+    version: "1.0.0",
+});
+// --- Tools ---
+// 1. list_skills - Lists all available skills from configured directories
+server.tool("list_skills", "Returns a JSON list of all available skills with their names, descriptions, and source directories. Use this to discover what skills are available before reading or installing them.", {}, async () => {
+    const skills = getAllSkills();
+    // Debug: include examined paths if no skills found OR always for now
+    if (skills.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: "No skills found",
+                        env_var: process.env.MCP_SKILL_PATHS,
+                        parsed_paths: getDynamicPaths(),
+                        cwd: process.cwd()
+                    }, null, 2)
+                }
+            ]
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(skills.map((s) => ({
+                    name: s.name,
+                    description: s.description,
+                    source_root: s.source,
+                })), null, 2),
+            },
+        ],
+    };
+});
+// 2. read_skill - Fetches the full SKILL.md content for a skill
+server.tool("read_skill", "Fetches and returns the full SKILL.md content for a specific skill. The content includes instructions and context that can be used to learn the skill's capabilities.", {
+    skill_name: z
+        .string()
+        .describe("The name of the skill to read (e.g., 'writing-dax-measures')"),
+}, async ({ skill_name }) => {
+    const skills = getAllSkills();
+    const skill = skills.find((s) => s.name === skill_name);
+    if (!skill) {
+        return {
+            content: [{ type: "text", text: `Skill '${skill_name}' not found.` }],
+            isError: true,
+        };
+    }
+    const skillMdPath = path.join(skill.path, "SKILL.md");
+    try {
+        const content = fs.readFileSync(skillMdPath, "utf-8");
+        return {
+            content: [{ type: "text", text: content }],
+        };
+    }
+    catch (err) {
+        return {
+            content: [
+                { type: "text", text: `Failed to read skill: ${err.message}` },
+            ],
+            isError: true,
+        };
+    }
+});
+// 3. install_skill - Copies a skill to the target workspace
+server.tool("install_skill", "Copies an entire skill directory (including SKILL.md and any supporting files) to the target workspace. By default, installs to .agent/skills/<skill_name> in the current working directory.", {
+    skill_name: z.string().describe("Name of the skill to install"),
+    target_path: z
+        .string()
+        .optional()
+        .describe("Destination path within current workspace. Defaults to .agent/skills/<skill_name>. Must be within the current working directory for security."),
+}, async ({ skill_name, target_path }) => {
+    const skills = getAllSkills();
+    const skill = skills.find((s) => s.name === skill_name);
+    if (!skill) {
+        return {
+            content: [{ type: "text", text: `Skill '${skill_name}' not found.` }],
+            isError: true,
+        };
+    }
+    // Default target: .agent/skills/name
+    const cwd = getWorkspaceRoot();
+    let dest;
+    if (target_path) {
+        dest = path.resolve(cwd, target_path);
+        // Security: Ensure target path is within current working directory
+        const normalizedDest = path.normalize(dest);
+        const normalizedCwd = path.normalize(cwd);
+        if (!normalizedDest.startsWith(normalizedCwd)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Security error: Target path must be within the current workspace (${cwd}). Received: ${dest}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    else {
+        dest = path.join(cwd, ".agent", "skills", skill.name);
+    }
+    try {
+        fs.cpSync(skill.path, dest, { recursive: true, force: true });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully installed skill '${skill_name}' to '${dest}'`,
+                },
+            ],
+        };
+    }
+    catch (err) {
+        return {
+            content: [
+                { type: "text", text: `Failed to install skill: ${err.message}` },
+            ],
+            isError: true,
+        };
+    }
+});
+// 4. manage_search_paths - Runtime management of skill paths
+server.tool("manage_search_paths", "Add, remove, or list dynamic skill search paths without restarting the server. Persists to skill-paths.json in the workspace root.", {
+    operation: z.enum(["add", "remove", "list"]).describe("Operation to perform"),
+    path: z.string().optional().describe("Absolute path to add or remove (not required for 'list')"),
+}, async ({ operation, path: inputPath }) => {
+    const cwd = getWorkspaceRoot();
+    const configPath = path.join(cwd, "skill-paths.json");
+    // Read current config
+    let currentPaths = [];
+    if (fs.existsSync(configPath)) {
+        try {
+            currentPaths = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            if (!Array.isArray(currentPaths))
+                currentPaths = [];
+        }
+        catch {
+            currentPaths = [];
+        }
+    }
+    if (operation === "list") {
+        const globalPaths = getBasePaths();
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        dynamic: currentPaths,
+                        global: globalPaths,
+                        effective: Array.from(new Set([...globalPaths, ...currentPaths]))
+                    }, null, 2)
+                }]
+        };
+    }
+    if (!inputPath) {
+        return {
+            content: [{ type: "text", text: "Path argument is required for add/remove operations." }],
+            isError: true
+        };
+    }
+    // Normalize input path
+    // Remove "file:///" prefix if present (common agent error)
+    const cleanPath = inputPath.replace(/^file:\/\/\/?/, "");
+    // On Windows, if it looks like /c:/..., make it c:/...
+    // But path.resolve usually handles normal paths well.
+    const absPath = path.resolve(cleanPath);
+    if (operation === "add") {
+        if (!currentPaths.includes(absPath)) {
+            currentPaths.push(absPath);
+            fs.writeFileSync(configPath, JSON.stringify(currentPaths, null, 2));
+            return {
+                content: [{ type: "text", text: `Added path: ${absPath}` }]
+            };
+        }
+        return {
+            content: [{ type: "text", text: `Path already exists: ${absPath}` }]
+        };
+    }
+    if (operation === "remove") {
+        const initialLen = currentPaths.length;
+        currentPaths = currentPaths.filter(p => p !== absPath);
+        if (currentPaths.length !== initialLen) {
+            fs.writeFileSync(configPath, JSON.stringify(currentPaths, null, 2));
+            return {
+                content: [{ type: "text", text: `Removed path: ${absPath}` }]
+            };
+        }
+        return {
+            content: [{ type: "text", text: `Path not found in config: ${absPath}` }]
+        };
+    }
+    return { content: [{ type: "text", text: "Invalid operation" }], isError: true };
+});
+// 5. debug_info - Diagnostic information for troubleshooting
+server.tool("debug_info", "Returns diagnostic information about server configuration, search paths, and any warnings from the last scan. Use this when skills aren't being found or to verify configuration.", {}, async () => {
+    const effectivePaths = getDynamicPaths();
+    const scanResult = scanAllPaths();
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    workspace_root: getWorkspaceRoot(),
+                    search_paths: {
+                        base: getBasePaths(),
+                        dynamic: getDynamicPathsOnly(),
+                        effective: effectivePaths
+                    },
+                    path_status: getPathStatus(effectivePaths),
+                    env: {
+                        MCP_SKILL_PATHS: process.env.MCP_SKILL_PATHS || null,
+                        MCP_WORKSPACE_ROOT: process.env.MCP_WORKSPACE_ROOT || null
+                    },
+                    skills_found: scanResult.skills.length,
+                    warnings: scanResult.warnings
+                }, null, 2)
+            }]
+    };
+});
+// --- Start Server ---
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error("Server error:", error);
+    process.exit(1);
+});

package/build/utils.js

@@ -0,0 +1,79 @@
+import * as fs from "fs";
+import * as path from "path";
+// --- Configuration ---
+export const DO_NOT_SCAN = ["node_modules", ".git", "dist", "build"];
+export function extractDescription(content) {
+    const match = content.match(/^description:\s*(.+)$/m);
+    return match ? match[1].trim() : "No description provided.";
+}
+export function findSkillsInDir(startPath) {
+    const skills = [];
+    const warnings = [];
+    if (!fs.existsSync(startPath)) {
+        warnings.push({ path: startPath, reason: "Directory does not exist" });
+        return { skills, warnings };
+    }
+    function scan(currentPath) {
+        let entries;
+        try {
+            entries = fs.readdirSync(currentPath, { withFileTypes: true });
+        }
+        catch (e) {
+            warnings.push({
+                path: currentPath,
+                reason: `Cannot read directory: ${e.code || e.message}`
+            });
+            return;
+        }
+        // Check if this directory is a skill (has SKILL.md)
+        const skillFile = entries.find((e) => e.isFile() && e.name === "SKILL.md");
+        if (skillFile) {
+            const fullPath = path.join(currentPath, skillFile.name);
+            try {
+                const content = fs.readFileSync(fullPath, "utf-8");
+                if (!content.trim()) {
+                    warnings.push({ path: fullPath, reason: "SKILL.md is empty" });
+                    return;
+                }
+                skills.push({
+                    name: path.basename(currentPath),
+                    description: extractDescription(content),
+                    path: currentPath,
+                    source: startPath,
+                });
+            }
+            catch (err) {
+                warnings.push({
+                    path: fullPath,
+                    reason: `Cannot read SKILL.md: ${err.code || err.message}`
+                });
+            }
+            // If we found a skill, we assume subdirectories are part of the skill
+            return;
+        }
+        // Otherwise, recurse
+        for (const entry of entries) {
+            if (entry.isDirectory() && !DO_NOT_SCAN.includes(entry.name)) {
+                scan(path.join(currentPath, entry.name));
+            }
+        }
+    }
+    scan(startPath);
+    return { skills, warnings };
+}
+export function getPathStatus(paths) {
+    return paths.map((p) => {
+        const exists = fs.existsSync(p);
+        let readable = false;
+        if (exists) {
+            try {
+                fs.accessSync(p, fs.constants.R_OK);
+                readable = true;
+            }
+            catch {
+                readable = false;
+            }
+        }
+        return { path: p, exists, readable };
+    });
+}

package/glama.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://glama.ai/mcp/schemas/server.json",
+  "maintainers": [
+    "back1ply"
+  ]
+}

package/language.json

@@ -0,0 +1 @@
+nodejs

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@iflow-mcp/back1ply-agent-skill-loader",
+  "version": "1.0.2",
+  "mcpName": "io.github.back1ply/agent-skill-loader",
+  "type": "module",
+  "description": "MCP Server to expose Claude Code Skills to agents",
+  "main": "build/index.js",
+  "bin": {
+    "iflow-mcp-back1ply-agent-skill-loader": "build/index.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "skills",
+    "claude"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "start": "node build/index.js",
+    "dev": "tsc --watch",
+    "test": "vitest"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.1",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.12",
+    "typescript": "^5.4.5",
+    "vitest": "^4.0.17"
+  }
+}

package/package_name

@@ -0,0 +1 @@
+@iflow-mcp/back1ply-agent-skill-loader

package/push_info.json

@@ -0,0 +1,5 @@
+{
+  "push_platform": "github",
+  "fork_url": "https://github.com/iflow-mcp/back1ply-agent-skill-loader",
+  "fork_branch": "iflow"
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "./build",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
+}