@kurokeita/add-skill 1.7.0 → 1.8.0

package/dist/src/commands/add.js

@@ -1,253 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-import { cancel, confirm, intro, isCancel, multiselect, note, outro, spinner, } from "@clack/prompts";
-import fs from "fs-extra";
-import pc from "picocolors";
-import { fetchSkillFromGitHub } from "../utils/github.js";
-import { getTargetPaths, PLATFORM_LABELS, TYPE_DIRS, } from "../utils/paths.js";
-import { convertToGeminiCommandTOML } from "../utils/toml.js";
-function getPlatformOptions(type) {
-    const paths = getTargetPaths(type);
-    return Object.entries(paths).map(([platform, pathStr]) => ({
-        label: PLATFORM_LABELS[platform],
-        value: platform,
-        hint: pathStr.replace(os.homedir(), "~"),
-    }));
-}
-async function installItem(itemName, overwrite, sourcePath, targetBaseDir) {
-    const targetPath = path.join(targetBaseDir, itemName);
-    if (!(await fs.pathExists(sourcePath))) {
-        throw new Error(`Item '${itemName}' not found at ${sourcePath}`);
-    }
-    if (!overwrite && (await fs.pathExists(targetPath))) {
-        return false;
-    }
-    await fs.ensureDir(targetBaseDir);
-    await fs.copy(sourcePath, targetPath, { overwrite });
-    return true;
-}
-export async function add(type, url) {
-    intro(pc.bgCyan(pc.black(` AI Manager : Add ${type} `)));
-    // Normalize type
-    const normalizedType = type.toLowerCase().endsWith("s")
-        ? type.slice(0, -1)
-        : type;
-    if (!TYPE_DIRS[normalizedType]) {
-        cancel(`Unknown type: ${type}. Supported: skill, agent, workflow`);
-        process.exit(1);
-    }
-    let tempDir = null;
-    let selectedItems = [];
-    try {
-        // 1. Determine Source (Local vs GitHub)
-        if (url) {
-            const s = spinner();
-            s.start(`Fetching ${normalizedType} from GitHub...`);
-            try {
-                const result = await fetchSkillFromGitHub(url);
-                tempDir = result.tempDir;
-                selectedItems = [result.skillName];
-                s.stop(pc.green(`Fetched ${normalizedType}: ${result.skillName}`));
-            }
-            catch (e) {
-                s.stop(pc.red("Failed to fetch"));
-                throw e;
-            }
-        }
-        else {
-            // Local Selection Logic
-            const sourceDir = TYPE_DIRS[normalizedType];
-            if (!(await fs.pathExists(sourceDir))) {
-                cancel(`${normalizedType} directory not found!`);
-                process.exit(1);
-            }
-            const entries = await fs.readdir(sourceDir, { withFileTypes: true });
-            const availableItems = entries
-                .filter((entry) => entry.isDirectory() ||
-                ((normalizedType === "workflow" || normalizedType === "agent") &&
-                    entry.isFile() &&
-                    entry.name.endsWith(".md")))
-                .map((entry) => ({ label: entry.name, value: entry.name }))
-                .sort((a, b) => a.label.localeCompare(b.label));
-            if (availableItems.length === 0) {
-                cancel(`No ${normalizedType}s found in directory.`);
-                process.exit(0);
-            }
-            // Select Items
-            const items = await multiselect({
-                message: `Select ${normalizedType}s to install:`,
-                options: availableItems,
-                required: true,
-            });
-            if (isCancel(items)) {
-                cancel("Operation cancelled.");
-                process.exit(0);
-            }
-            selectedItems = items;
-        }
-        // 2. Select Platforms
-        // Filter platform options based on support for the type
-        const supportedPaths = getTargetPaths(normalizedType);
-        const currentPlatformOptions = getPlatformOptions(normalizedType);
-        if (currentPlatformOptions.length === 0) {
-            cancel(`No supported platforms found for type '${normalizedType}'.`);
-            process.exit(1);
-        }
-        const platforms = await multiselect({
-            message: "Select target platforms:",
-            options: currentPlatformOptions,
-            required: true,
-        });
-        if (isCancel(platforms)) {
-            console.log("Cleaning up...");
-            if (tempDir)
-                await fs.remove(tempDir);
-            cancel("Operation cancelled.");
-            process.exit(0);
-        }
-        const selectedPlatforms = platforms;
-        // 3. Check for existing items
-        const existingItems = [];
-        for (const platform of selectedPlatforms) {
-            const targetBase = supportedPaths[platform];
-            if (!targetBase)
-                continue;
-            for (const item of selectedItems) {
-                const targetPath = path.join(targetBase, item);
-                if (await fs.pathExists(targetPath)) {
-                    existingItems.push({ item, platform });
-                }
-            }
-        }
-        let overwrite = true;
-        if (existingItems.length > 0) {
-            const limit = 5;
-            const displayList = existingItems
-                .slice(0, limit)
-                .map((e) => `${pc.bold(e.item)} (${e.platform})`)
-                .join(", ");
-            const remainder = existingItems.length - limit;
-            const message = remainder > 0
-                ? `The following items already exist: ${displayList}, and ${remainder} others.`
-                : `The following items already exist: ${displayList}.`;
-            note(message, "Attention");
-            const shouldOverwrite = await confirm({
-                message: "Do you want to overwrite existing items?",
-                initialValue: false,
-            });
-            if (isCancel(shouldOverwrite)) {
-                if (tempDir)
-                    await fs.remove(tempDir);
-                cancel("Operation cancelled.");
-                process.exit(0);
-            }
-            overwrite = shouldOverwrite;
-        }
-        // 4. Confirmation Note
-        note(`Installing ${selectedItems.length} ${normalizedType}s to ${selectedPlatforms.length} platforms...`, "Summary");
-        // 5. Installation Loop with Spinner
-        const s = spinner();
-        s.start("Installing...");
-        const errors = [];
-        let installedCount = 0;
-        let skippedCount = 0;
-        for (const platform of selectedPlatforms) {
-            const targetBase = supportedPaths[platform];
-            if (!targetBase)
-                continue;
-            for (const item of selectedItems) {
-                const message = `Installing ${pc.bold(item)} to ${pc.cyan(platform)}...`;
-                s.message(message);
-                try {
-                    if (url && tempDir) {
-                        // We already fetched it, check if it was a file
-                        // Wait, fetchSkillFromGitHub returned isFile, but add command logic separated fetch from install loop.
-                        // We need to store isFile state from fetch if using URL.
-                        // However, selectedItems only stores strings.
-                        // Let's assume if it is a URL, we re-verify or change logic slightly.
-                        // Better: modify fetch logic above to store isFile.
-                    }
-                    // Re-implementing logic to be consistent with import.ts
-                    // But wait, add command handles multiple items if LOCAL.
-                    // If URL, it is single item `selectedItems = [result.skillName]`.
-                    let currentSourcePath;
-                    if (url && tempDir) {
-                        // For URL fetch, we need to know if it was a file.
-                        // We can check if tempDir/item exists as file.
-                        const potentialFile = path.join(tempDir, item);
-                        if ((await fs.pathExists(potentialFile)) &&
-                            (await fs.stat(potentialFile)).isFile()) {
-                            currentSourcePath = potentialFile;
-                        }
-                        else {
-                            currentSourcePath = tempDir;
-                        }
-                    }
-                    else {
-                        // Local source
-                        const src = path.join(TYPE_DIRS[normalizedType], item);
-                        if ((await fs.stat(src)).isFile()) {
-                            currentSourcePath = src;
-                        }
-                        else {
-                            currentSourcePath = src; // direct path to dir
-                        }
-                    }
-                    let targetItemName = item;
-                    if (platform === "windsurf" && normalizedType === "agent") {
-                        targetItemName = path.join(path.parse(item).name, "AGENTS.md");
-                    }
-                    // Gemini Workflow Conversion
-                    if (platform === "gemini" &&
-                        normalizedType === "workflow" &&
-                        currentSourcePath.endsWith(".md")) {
-                        const targetPath = path.join(targetBase, item.replace(/\.md$/, ".toml"));
-                        if (!overwrite && (await fs.pathExists(targetPath))) {
-                            skippedCount++;
-                        }
-                        else {
-                            const content = await fs.readFile(currentSourcePath, "utf-8");
-                            const tomlContent = convertToGeminiCommandTOML(content);
-                            await fs.ensureDir(targetBase);
-                            await fs.writeFile(targetPath, tomlContent);
-                            installedCount++;
-                        }
-                        continue;
-                    }
-                    const installed = await installItem(targetItemName, overwrite, currentSourcePath, targetBase);
-                    if (installed) {
-                        installedCount++;
-                    }
-                    else {
-                        skippedCount++;
-                    }
-                }
-                catch (err) {
-                    const errorMessage = err instanceof Error ? err.message : String(err);
-                    errors.push(`${item} -> ${platform}: ${errorMessage}`);
-                }
-            }
-        }
-        // Cleanup
-        if (tempDir) {
-            await fs.remove(tempDir);
-        }
-        if (errors.length > 0) {
-            s.stop(pc.yellow(`Completed with errors. Installed: ${installedCount}, Skipped: ${skippedCount}, Errors: ${errors.length}`));
-            console.error(pc.red("\nErrors encountered:"));
-            for (const e of errors) {
-                console.error(pc.red(`- ${e}`));
-            }
-        }
-        else {
-            s.stop(pc.green(`Successfully installed ${installedCount} ${normalizedType}s. (${skippedCount} skipped)`));
-        }
-        outro("You're all set!");
-    }
-    catch (error) {
-        if (tempDir)
-            await fs.remove(tempDir);
-        cancel(`An error occurred: ${error}`);
-        process.exit(1);
-    }
-}

package/dist/src/commands/import.js

@@ -1,116 +0,0 @@
-import path from "node:path";
-import { cancel, confirm, intro, isCancel, outro, spinner, } from "@clack/prompts";
-import fs from "fs-extra";
-import pc from "picocolors";
-import { fetchSkillFromGitHub } from "../utils/github.js";
-import { TYPE_DIRS } from "../utils/paths.js";
-export async function importItem(type, url) {
-    intro(pc.bgCyan(pc.black(` AI Manager : Import ${type} `)));
-    // Normalize type
-    const normalizedType = type.toLowerCase().endsWith("s")
-        ? type.slice(0, -1)
-        : type;
-    const targetBaseDir = TYPE_DIRS[normalizedType];
-    if (!targetBaseDir) {
-        cancel(`Unknown type: ${type}. Supported: skill, agent, workflow`);
-        process.exit(1);
-    }
-    if (!url) {
-        cancel("GitHub URL is required.");
-        process.exit(1);
-    }
-    let tempDir = null;
-    try {
-        // 1. Fetch Item (using fetchSkillFromGitHub as generic fetcher)
-        const s = spinner();
-        s.start(`Fetching ${normalizedType} from GitHub...`);
-        let itemName = "";
-        let isFile = false;
-        try {
-            const result = await fetchSkillFromGitHub(url);
-            tempDir = result.tempDir;
-            if (!tempDir)
-                throw new Error("Failed to create temp directory");
-            itemName = result.skillName; // reuse property or rename if possible. assuming generic repo structure
-            isFile = result.isFile;
-            s.stop(pc.green(`Fetched: ${itemName}`));
-        }
-        catch (e) {
-            s.stop(pc.red("Failed to fetch"));
-            throw e;
-        }
-        // 2. Determine Target
-        const shouldFlatten = (normalizedType === "agent" || normalizedType === "workflow") && !isFile;
-        const targetPath = shouldFlatten
-            ? targetBaseDir
-            : path.join(targetBaseDir, itemName);
-        // 3. Check Existence & Confirm Overwrite
-        if (shouldFlatten) {
-            const srcFiles = await fs.readdir(tempDir);
-            const conflicts = [];
-            for (const file of srcFiles) {
-                if (await fs.pathExists(path.join(targetBaseDir, file))) {
-                    conflicts.push(file);
-                }
-            }
-            if (conflicts.length > 0) {
-                const limit = 5;
-                const displayList = conflicts.slice(0, limit).join(", ");
-                const remainder = conflicts.length - limit;
-                const message = remainder > 0
-                    ? `Files ${displayList} (and ${remainder} others) already exist in ${targetBaseDir}. Overwrite?`
-                    : `Files ${displayList} already exist in ${targetBaseDir}. Overwrite?`;
-                const shouldOverwrite = await confirm({
-                    message,
-                    initialValue: false,
-                });
-                if (isCancel(shouldOverwrite) || !shouldOverwrite) {
-                    if (tempDir)
-                        await fs.remove(tempDir);
-                    cancel("Operation cancelled.");
-                    process.exit(0);
-                }
-            }
-        }
-        else if (await fs.pathExists(targetPath)) {
-            const shouldOverwrite = await confirm({
-                message: `${normalizedType} '${itemName}' already exists in the repo. Overwrite?`,
-                initialValue: false,
-            });
-            if (isCancel(shouldOverwrite) || !shouldOverwrite) {
-                if (tempDir)
-                    await fs.remove(tempDir);
-                cancel("Operation cancelled.");
-                process.exit(0);
-            }
-        }
-        // 4. Move/Copy to Target Directory
-        s.start(`Importing ${itemName} to ${targetBaseDir}...`);
-        await fs.ensureDir(targetBaseDir);
-        if (isFile) {
-            await fs.copy(path.join(tempDir, itemName), targetPath, {
-                overwrite: true,
-            });
-        }
-        else {
-            if (shouldFlatten) {
-                await fs.copy(tempDir, targetBaseDir, { overwrite: true });
-            }
-            else {
-                await fs.copy(tempDir, targetPath, { overwrite: true });
-            }
-        }
-        s.stop(pc.green(`Successfully imported ${itemName}!`));
-        // Cleanup
-        if (tempDir) {
-            await fs.remove(tempDir);
-        }
-        outro(`${normalizedType} available at: ${targetPath}`);
-    }
-    catch (error) {
-        if (tempDir)
-            await fs.remove(tempDir);
-        cancel(`An error occurred: ${error}`);
-        process.exit(1);
-    }
-}

package/dist/src/commands/list.js

@@ -1,92 +0,0 @@
-import fs from "fs-extra";
-import pc from "picocolors";
-import { getTargetPaths, TYPE_DIRS } from "../utils/paths.js";
-export async function list(type, options) {
-    try {
-        const typesToList = type
-            ? [type.toLowerCase()]
-            : ["skill", "agent", "workflow"];
-        for (const t of typesToList) {
-            // Handle plural/singular input for convenience
-            const normalizedType = t.endsWith("s") ? t.slice(0, -1) : t;
-            if (options?.local) {
-                // List installed items locally
-                console.log(pc.bold(pc.blue(`Installed ${normalizedType}s (Local):`)));
-                const targetPaths = getTargetPaths(normalizedType);
-                let foundAny = false;
-                for (const [platform, pathStr] of Object.entries(targetPaths)) {
-                    const fullPath = pathStr;
-                    if (await fs.pathExists(fullPath)) {
-                        const entries = await fs.readdir(fullPath, {
-                            withFileTypes: true,
-                        });
-                        const items = entries
-                            .filter((entry) => entry.isDirectory() ||
-                            // For local items, agents/workflows might be directories OR .md files depending on how they were installed/flattened.
-                            // Usually flattened -> directory (if unpacked) or file (if generic).
-                            // Existing add logic:
-                            // Agents/Workflows can be flattened (unpacked to base) or not.
-                            // If flattened, they are files in the base dir? No, unpacked to base means they are files/dirs IN the base dir.
-                            // Wait, if I import "agent-a" (dir) and flatten, it copies contents of agent-a to agents/.
-                            // So "agents/skill.md" might exist.
-                            // The user requirement says "list all installed agents/skills/workflows".
-                            // In local global_skills (antigravity), they are directories.
-                            // In local global_agents, they might be directories or .md files.
-                            // Let's list directories and .md files.
-                            (entry.isFile() && entry.name.endsWith(".md")))
-                            .map((entry) => entry.name)
-                            .sort();
-                        if (items.length > 0) {
-                            foundAny = true;
-                            console.log(pc.cyan(`  ${platform}:`));
-                            for (const item of items) {
-                                console.log(`    - ${item}`);
-                            }
-                        }
-                    }
-                }
-                if (!foundAny) {
-                    console.log(pc.dim(`  No installed ${normalizedType}s found.`));
-                }
-                console.log(""); // Newline for separation
-            }
-            else {
-                // List available items in repo (existing logic)
-                if (!TYPE_DIRS[normalizedType]) {
-                    if (type) {
-                        console.error(pc.red(`Unknown type: ${type}. Supported types: skill, agent, workflow`));
-                    }
-                    continue;
-                }
-                const dirPath = TYPE_DIRS[normalizedType];
-                if (!(await fs.pathExists(dirPath))) {
-                    if (type) {
-                        console.log(pc.yellow(`No ${t} directory found at: ${dirPath}`));
-                    }
-                    continue;
-                }
-                const entries = await fs.readdir(dirPath, { withFileTypes: true });
-                const items = entries
-                    .filter((entry) => entry.isDirectory() ||
-                    (normalizedType !== "skill" &&
-                        entry.isFile() &&
-                        entry.name.endsWith(".md")))
-                    .map((entry) => entry.name)
-                    .sort();
-                if (items.length > 0) {
-                    console.log(pc.bold(pc.blue(`Available ${normalizedType}s:`)));
-                    for (const item of items) {
-                        console.log(`- ${item}`);
-                    }
-                    console.log(pc.dim(`Total: ${items.length} ${normalizedType}s\n`));
-                }
-                else if (type) {
-                    console.log(pc.dim(`No ${normalizedType}s found.`));
-                }
-            }
-        }
-    }
-    catch (error) {
-        console.error(pc.red("Error listing items:"), error);
-    }
-}

package/dist/src/commands/remove.js

@@ -1,118 +0,0 @@
-import path from "node:path";
-import { cancel, confirm, intro, isCancel, multiselect, outro, spinner, } from "@clack/prompts";
-import fs from "fs-extra";
-import pc from "picocolors";
-import { getTargetPaths, PLATFORM_LABELS, } from "../utils/paths.js";
-export async function remove(type) {
-    intro(pc.bgCyan(pc.black(` AI Manager : Remove ${type} `)));
-    // Normalize type
-    const normalizedType = type.toLowerCase().endsWith("s")
-        ? type.slice(0, -1)
-        : type;
-    const targetPaths = getTargetPaths(normalizedType);
-    // 1. Collect unique installed items across all platforms
-    const uniqueItems = new Set();
-    const s = spinner();
-    s.start("Scanning for installed items...");
-    for (const pathStr of Object.values(targetPaths)) {
-        if (await fs.pathExists(pathStr)) {
-            const entries = await fs.readdir(pathStr, {
-                withFileTypes: true,
-            });
-            for (const entry of entries) {
-                if (entry.isDirectory() ||
-                    (normalizedType === "workflow" &&
-                        entry.isFile() &&
-                        entry.name.endsWith(".md")) ||
-                    (normalizedType === "agent" &&
-                        entry.isFile() &&
-                        entry.name.endsWith(".md"))) {
-                    uniqueItems.add(entry.name);
-                }
-            }
-        }
-    }
-    s.stop(`Found ${uniqueItems.size} unique installed ${normalizedType}s.`);
-    if (uniqueItems.size === 0) {
-        cancel(`No installed ${normalizedType}s found.`);
-        process.exit(0);
-    }
-    // Sort explicitly
-    const sortedItems = Array.from(uniqueItems).sort();
-    // 2. Select Items
-    const itemSelections = await multiselect({
-        message: `Select ${normalizedType}s to remove:`,
-        options: sortedItems.map((item) => ({ value: item, label: item })),
-        required: true,
-    });
-    if (isCancel(itemSelections)) {
-        cancel("Operation cancelled.");
-        process.exit(0);
-    }
-    const selectedItems = itemSelections;
-    // 3. Select Platforms
-    // Only show platforms relevant to the type
-    const platformOptions = Object.entries(targetPaths).map(([platform]) => ({
-        label: PLATFORM_LABELS[platform],
-        value: platform,
-    }));
-    const platformSelections = await multiselect({
-        message: "Select platforms to remove from:",
-        options: platformOptions,
-        required: true,
-    });
-    if (isCancel(platformSelections)) {
-        cancel("Operation cancelled.");
-        process.exit(0);
-    }
-    const selectedPlatforms = platformSelections;
-    // 4. Confirmation
-    const confirmDelete = await confirm({
-        message: `Are you sure you want to remove ${selectedItems.length} item(s) from ${selectedPlatforms.length} platform(s)?`,
-        initialValue: false,
-    });
-    if (isCancel(confirmDelete) || !confirmDelete) {
-        cancel("Operation cancelled.");
-        process.exit(0);
-    }
-    // 5. Deletion Loop
-    const sDel = spinner();
-    sDel.start("Removing items...");
-    let removedCount = 0;
-    let notFoundCount = 0;
-    const errors = [];
-    for (const platform of selectedPlatforms) {
-        const targetBase = targetPaths[platform];
-        if (!targetBase)
-            continue;
-        for (const item of selectedItems) {
-            const targetPath = path.join(targetBase, item);
-            // Check if exists before trying to remove, to correctly count "removed" vs "not found"
-            if (await fs.pathExists(targetPath)) {
-                sDel.message(`Removing ${pc.bold(item)} from ${pc.cyan(platform)}...`);
-                try {
-                    await fs.remove(targetPath);
-                    removedCount++;
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    errors.push(`${item} (${platform}): ${msg}`);
-                }
-            }
-            else {
-                notFoundCount++;
-            }
-        }
-    }
-    if (errors.length > 0) {
-        sDel.stop(pc.yellow(`Completed with errors. Removed: ${removedCount}, Not Found: ${notFoundCount}, Errors: ${errors.length}`));
-        console.error(pc.red("\nErrors encountered:"));
-        for (const e of errors) {
-            console.error(pc.red(`- ${e}`));
-        }
-    }
-    else {
-        sDel.stop(pc.green(`Successfully removed ${removedCount} items. (${notFoundCount} not found)`));
-    }
-    outro("Done!");
-}

package/dist/src/utils/github.js

@@ -1,65 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-import fs from "fs-extra";
-export async function fetchSkillFromGitHub(url) {
-    const regex = /github\.com\/([^/]+)\/([^/]+)\/(?:tree|blob)\/([^/]+)\/(.+)/;
-    const match = url.match(regex);
-    if (!match) {
-        throw new Error("Invalid GitHub URL. Format: https://github.com/owner/repo/tree/branch/path/to/skill or blob/branch/path/to/file");
-    }
-    const [, owner, repo, ref, skillPath] = match;
-    const skillName = path.basename(skillPath);
-    const initialApiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/${skillPath}?ref=${ref}`;
-    const tempDir = path.join(os.tmpdir(), "ai-agents-install", skillName);
-    await fs.ensureDir(tempDir);
-    await fs.emptyDir(tempDir);
-    let isFile = false;
-    async function downloadDirectory(apiUrl, localDir) {
-        const response = await fetch(apiUrl, {
-            headers: {
-                "User-Agent": "ai-agents-cli",
-                Accept: "application/vnd.github.v3+json",
-            },
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to fetch from GitHub (${response.status}): ${response.statusText}`);
-        }
-        const data = await response.json();
-        // Handle single file response
-        if (!Array.isArray(data) && data.type === "file") {
-            isFile = true;
-            const item = data;
-            if (item.download_url) {
-                const fileContentResponse = await fetch(item.download_url);
-                if (!fileContentResponse.ok) {
-                    throw new Error(`Failed to download ${item.name}: ${fileContentResponse.statusText}`);
-                }
-                const content = await fileContentResponse.text();
-                await fs.writeFile(path.join(localDir, item.name), content);
-            }
-            return;
-        }
-        if (!Array.isArray(data)) {
-            throw new Error("Invalid response from GitHub API. Expected directory listing or file object.");
-        }
-        const files = data;
-        for (const item of files) {
-            if (item.type === "file" && item.download_url) {
-                const fileContentResponse = await fetch(item.download_url);
-                if (!fileContentResponse.ok) {
-                    console.warn(`Failed to download ${item.name}: ${fileContentResponse.statusText}`);
-                    continue;
-                }
-                const content = await fileContentResponse.text();
-                await fs.writeFile(path.join(localDir, item.name), content);
-            }
-            else if (item.type === "dir") {
-                const newLocalDir = path.join(localDir, item.name);
-                await fs.ensureDir(newLocalDir);
-                await downloadDirectory(item.url, newLocalDir);
-            }
-        }
-    }
-    await downloadDirectory(initialApiUrl, tempDir);
-    return { tempDir, skillName, isFile };
-}