@nitrostack/cli 1.0.13 → 1.0.15

package/dist/pack/validate-project.js

@@ -0,0 +1,44 @@
+import path from 'path';
+import fs from 'fs-extra';
+export class PackValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PackValidationError';
+    }
+}
+function collectNitrostackPackages(packageJson) {
+    const packages = new Set();
+    const sections = [packageJson.dependencies, packageJson.devDependencies];
+    for (const section of sections) {
+        if (!section)
+            continue;
+        for (const pkg of Object.keys(section)) {
+            if (pkg.startsWith('@nitrostack/')) {
+                packages.add(pkg);
+            }
+        }
+    }
+    return Array.from(packages).sort();
+}
+/**
+ * Validate that the target directory is a NitroStack project.
+ */
+export async function validateNitrostackProject(cwd = process.cwd()) {
+    const projectRoot = path.resolve(cwd);
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    if (!(await fs.pathExists(packageJsonPath))) {
+        throw new PackValidationError('package.json not found in the current directory');
+    }
+    const packageJson = await fs.readJSON(packageJsonPath);
+    const nitrostackPackages = collectNitrostackPackages(packageJson);
+    if (nitrostackPackages.length === 0) {
+        throw new PackValidationError('No @nitrostack/* dependencies found in package.json. Run this command from a NitroStack project.');
+    }
+    const projectName = packageJson.name || path.basename(projectRoot);
+    return {
+        projectRoot,
+        packageJsonPath,
+        projectName,
+        nitrostackPackages,
+    };
+}

package/dist/pack/zipper.d.ts

@@ -0,0 +1,20 @@
+import type { IgnoreMatcher } from './ignore-matcher.js';
+export interface ZipCollectionResult {
+    filesIncluded: number;
+    includedPaths: string[];
+    excludedPaths: string[];
+}
+/**
+ * Collect relative file paths that should be included, and pruned excluded roots.
+ * Excluded directories are recorded once and not descended into.
+ * Symlinks are resolved via stat/realpath so:
+ * - symlink-to-directory is walked (not archived as a file)
+ * - cycles and targets outside the project root are skipped
+ */
+export declare function collectFilesToPack(projectRoot: string, matcher: IgnoreMatcher): Promise<ZipCollectionResult>;
+/**
+ * Create an optimized zip archive from the project directory.
+ */
+export declare function createOptimizedZip(projectRoot: string, outputPath: string, matcher: IgnoreMatcher): Promise<ZipCollectionResult>;
+export declare function getZipSizeBytes(outputPath: string): Promise<number>;
+//# sourceMappingURL=zipper.d.ts.map

package/dist/pack/zipper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zipper.d.ts","sourceRoot":"","sources":["../../src/pack/zipper.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAQD;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,mBAAmB,CAAC,CAsF9B;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,mBAAmB,CAAC,CAwB9B;AAED,wBAAsB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAGzE"}

package/dist/pack/zipper.js

@@ -0,0 +1,121 @@
+import path from 'path';
+import fs from 'fs';
+import { createWriteStream } from 'fs';
+import archiver from 'archiver';
+import { isPathIgnored } from './gitignore.js';
+/** True when realPath is the root or a descendant of rootReal. */
+function isInsideRoot(realPath, rootReal) {
+    const relative = path.relative(rootReal, realPath);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+/**
+ * Collect relative file paths that should be included, and pruned excluded roots.
+ * Excluded directories are recorded once and not descended into.
+ * Symlinks are resolved via stat/realpath so:
+ * - symlink-to-directory is walked (not archived as a file)
+ * - cycles and targets outside the project root are skipped
+ */
+export async function collectFilesToPack(projectRoot, matcher) {
+    const includedPaths = [];
+    const excludedPaths = [];
+    const visitedDirs = new Set();
+    let projectRootReal;
+    try {
+        projectRootReal = await fs.promises.realpath(projectRoot);
+    }
+    catch {
+        projectRootReal = path.resolve(projectRoot);
+    }
+    async function walk(currentDir) {
+        let currentReal;
+        try {
+            currentReal = await fs.promises.realpath(currentDir);
+        }
+        catch {
+            return;
+        }
+        if (visitedDirs.has(currentReal)) {
+            return;
+        }
+        if (!isInsideRoot(currentReal, projectRootReal)) {
+            return;
+        }
+        visitedDirs.add(currentReal);
+        let entries;
+        try {
+            entries = await fs.promises.readdir(currentDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            const absolutePath = path.join(currentDir, entry.name);
+            const relativePath = path.relative(projectRoot, absolutePath).split(path.sep).join('/');
+            let isDirectory = entry.isDirectory();
+            let isFile = entry.isFile();
+            if (entry.isSymbolicLink()) {
+                try {
+                    const realTarget = await fs.promises.realpath(absolutePath);
+                    if (!isInsideRoot(realTarget, projectRootReal)) {
+                        // Symlink escapes the project — skip
+                        continue;
+                    }
+                    const stats = await fs.promises.stat(absolutePath);
+                    isDirectory = stats.isDirectory();
+                    isFile = stats.isFile();
+                }
+                catch {
+                    // Broken symlink — skip
+                    continue;
+                }
+            }
+            if (isPathIgnored(matcher, projectRoot, absolutePath, isDirectory)) {
+                const displayPath = isDirectory ? `${relativePath}/` : relativePath;
+                excludedPaths.push(displayPath);
+                continue;
+            }
+            if (isDirectory) {
+                await walk(absolutePath);
+                continue;
+            }
+            if (isFile) {
+                includedPaths.push(relativePath);
+            }
+        }
+    }
+    await walk(projectRoot);
+    includedPaths.sort();
+    excludedPaths.sort();
+    return {
+        filesIncluded: includedPaths.length,
+        includedPaths,
+        excludedPaths,
+    };
+}
+/**
+ * Create an optimized zip archive from the project directory.
+ */
+export async function createOptimizedZip(projectRoot, outputPath, matcher) {
+    const collection = await collectFilesToPack(projectRoot, matcher);
+    const outputDir = path.dirname(outputPath);
+    await fs.promises.mkdir(outputDir, { recursive: true });
+    await new Promise((resolve, reject) => {
+        const output = createWriteStream(outputPath);
+        const archive = archiver('zip', { zlib: { level: 9 } });
+        output.on('close', () => resolve());
+        output.on('error', reject);
+        archive.on('error', reject);
+        archive.pipe(output);
+        for (const relativePath of collection.includedPaths) {
+            const absolutePath = path.join(projectRoot, relativePath);
+            archive.file(absolutePath, { name: relativePath });
+        }
+        void archive.finalize();
+    });
+    return collection;
+}
+export async function getZipSizeBytes(outputPath) {
+    const stats = await fs.promises.stat(outputPath);
+    return stats.size;
+}

package/dist/skills/clone.d.ts

@@ -0,0 +1,28 @@
+export declare const SKILLS_REPO_URL = "https://github.com/nitrocloudofficial/skills.git";
+/**
+ * Thrown when the skills repository cannot be cloned (git missing, network
+ * error, repository not found, etc.).  The caller should catch this and
+ * display a user-friendly warning rather than crashing the entire init flow.
+ */
+export declare class SkillsCloneError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+/**
+ * Clones the NitroStack skills repository into a unique temporary directory
+ * and returns the absolute path to that directory.
+ *
+ * The caller is responsible for cleaning up the directory when done:
+ * ```ts
+ * const tempDir = await cloneSkillsRepo();
+ * try {
+ *   // use tempDir …
+ * } finally {
+ *   await fs.remove(tempDir);
+ * }
+ * ```
+ *
+ * @throws {SkillsCloneError} when git is unavailable or the clone fails.
+ */
+export declare function cloneSkillsRepo(): Promise<string>;
+//# sourceMappingURL=clone.d.ts.map

package/dist/skills/clone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone.d.ts","sourceRoot":"","sources":["../../src/skills/clone.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,eAAe,qDAAqD,CAAC;AAElF;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;aACI,KAAK,CAAC,EAAE,OAAO;gBAAhD,OAAO,EAAE,MAAM,EAAkB,KAAK,CAAC,EAAE,OAAO,YAAA;CAI7D;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,MAAM,CAAC,CAiCvD"}

package/dist/skills/clone.js

@@ -0,0 +1,60 @@
+import os from 'os';
+import path from 'path';
+import crypto from 'crypto';
+import { execSync } from 'child_process';
+import fs from 'fs-extra';
+export const SKILLS_REPO_URL = 'https://github.com/nitrocloudofficial/skills.git';
+/**
+ * Thrown when the skills repository cannot be cloned (git missing, network
+ * error, repository not found, etc.).  The caller should catch this and
+ * display a user-friendly warning rather than crashing the entire init flow.
+ */
+export class SkillsCloneError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'SkillsCloneError';
+    }
+}
+/**
+ * Clones the NitroStack skills repository into a unique temporary directory
+ * and returns the absolute path to that directory.
+ *
+ * The caller is responsible for cleaning up the directory when done:
+ * ```ts
+ * const tempDir = await cloneSkillsRepo();
+ * try {
+ *   // use tempDir …
+ * } finally {
+ *   await fs.remove(tempDir);
+ * }
+ * ```
+ *
+ * @throws {SkillsCloneError} when git is unavailable or the clone fails.
+ */
+export async function cloneSkillsRepo() {
+    const uniqueId = crypto.randomBytes(6).toString('hex');
+    const tempDir = path.join(os.tmpdir(), `nitrostack-skills-${uniqueId}`);
+    try {
+        execSync(`git clone --depth 1 "${SKILLS_REPO_URL}" "${tempDir}"`, {
+            stdio: 'pipe',
+            timeout: 60_000,
+        });
+    }
+    catch (err) {
+        // Clean up any partial clone before throwing
+        try {
+            await fs.remove(tempDir);
+        }
+        catch {
+            // best-effort cleanup
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes('git: command not found') || message.includes("'git' is not recognized")) {
+            throw new SkillsCloneError('Git is not installed or not in PATH. Install Git from https://git-scm.com and try again.', err);
+        }
+        throw new SkillsCloneError(`Failed to clone skills repository: ${message.split('\n')[0]}`, err);
+    }
+    return tempDir;
+}

package/dist/skills/detect-agents.d.ts

@@ -0,0 +1,8 @@
+import type { AgentDescriptor } from './types.js';
+export declare const AGENTS: AgentDescriptor[];
+/**
+ * Runs all agent detectors in parallel and returns only the agents that are
+ * detected on the current machine.
+ */
+export declare function detectAgents(): Promise<AgentDescriptor[]>;
+//# sourceMappingURL=detect-agents.d.ts.map

package/dist/skills/detect-agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-agents.d.ts","sourceRoot":"","sources":["../../src/skills/detect-agents.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAkElD,eAAO,MAAM,MAAM,EAAE,eAAe,EAwDnC,CAAC;AAEF;;;GAGG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC,CAa/D"}

package/dist/skills/detect-agents.js

@@ -0,0 +1,129 @@
+import os from 'os';
+import path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs-extra';
+const execAsync = promisify(exec);
+/**
+ * Returns true when the given CLI command is available in the system PATH.
+ * Works cross-platform: uses `where` on Windows, `which` elsewhere.
+ */
+async function commandExists(cmd) {
+    try {
+        const whichCmd = process.platform === 'win32' ? `where ${cmd}` : `which ${cmd}`;
+        await execAsync(whichCmd);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Returns true when a directory exists at `dirPath`.
+ */
+function dirExists(dirPath) {
+    try {
+        return fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+const HOME = os.homedir();
+/**
+ * Helper to build an AgentDescriptor from a simpler specification,
+ * reducing duplicate boilerplate for detect() and getSkillsDir().
+ */
+function createAgentDescriptor(spec) {
+    return {
+        id: spec.id,
+        name: spec.name,
+        displayPath: `~/${spec.folderName}/skills`,
+        async detect() {
+            if (spec.customDetect) {
+                return spec.customDetect();
+            }
+            const hasCmd = spec.cmd ? await commandExists(spec.cmd) : false;
+            return hasCmd || dirExists(path.join(HOME, spec.folderName));
+        },
+        getSkillsDir(scope = 'global', projectDir = process.cwd()) {
+            if (spec.getSkillsDir) {
+                return spec.getSkillsDir(scope, projectDir);
+            }
+            const base = scope === 'project' ? projectDir : HOME;
+            return path.join(base, spec.folderName, 'skills');
+        },
+    };
+}
+export const AGENTS = [
+    // ── Original 5 agents (must keep indices 0-4 for tests) ───────────────────
+    createAgentDescriptor({
+        id: 'cursor',
+        name: 'Cursor Agent',
+        folderName: '.cursor',
+    }),
+    createAgentDescriptor({
+        id: 'codex',
+        name: 'Codex',
+        folderName: '.codex',
+        cmd: 'codex',
+    }),
+    createAgentDescriptor({
+        id: 'claude-code',
+        name: 'Claude Code',
+        folderName: '.claude',
+        cmd: 'claude',
+    }),
+    createAgentDescriptor({
+        id: 'gemini-cli',
+        name: 'Gemini CLI',
+        folderName: '.gemini',
+        cmd: 'gemini',
+    }),
+    createAgentDescriptor({
+        id: 'antigravity',
+        name: 'Google Antigravity',
+        folderName: '.antigravity',
+        cmd: 'agy',
+    }),
+    // ── Additional coding agents (limited to GitHub Copilot and OpenCode) ──────
+    createAgentDescriptor({
+        id: 'github-copilot',
+        name: 'GitHub Copilot Agent',
+        folderName: '.copilot',
+    }),
+    createAgentDescriptor({
+        id: 'opencode',
+        name: 'OpenCode Agent',
+        // OpenCode stores its config at ~/.config/opencode
+        folderName: '.config/opencode',
+        cmd: 'opencode',
+        getSkillsDir(scope = 'global', projectDir = process.cwd()) {
+            if (scope === 'project') {
+                return path.join(projectDir, '.opencode', 'skills');
+            }
+            return path.join(HOME, '.config', 'opencode', 'skills');
+        },
+    }),
+    createAgentDescriptor({
+        id: 'agents',
+        name: 'Workspace Agents',
+        folderName: '.agents',
+    }),
+];
+/**
+ * Runs all agent detectors in parallel and returns only the agents that are
+ * detected on the current machine.
+ */
+export async function detectAgents() {
+    const results = await Promise.all(AGENTS.map(async (agent) => {
+        try {
+            const found = await agent.detect();
+            return found ? agent : null;
+        }
+        catch {
+            return null;
+        }
+    }));
+    return results.filter((a) => a !== null);
+}

package/dist/skills/discover.d.ts

@@ -0,0 +1,12 @@
+import type { Skill } from './types.js';
+/**
+ * Discovers all skills inside the cloned repository.
+ *
+ * A "skill" is any immediate subdirectory of `<cloneDir>/skills/` whose name
+ * does not start with a dot.  Regular files and hidden directories are ignored.
+ *
+ * @param cloneDir - Absolute path to the root of the cloned repository.
+ * @returns Array of discovered skills, sorted alphabetically by name.
+ */
+export declare function discoverSkills(cloneDir: string): Promise<Skill[]>;
+//# sourceMappingURL=discover.d.ts.map

package/dist/skills/discover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover.d.ts","sourceRoot":"","sources":["../../src/skills/discover.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAgBxC;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAwBvE"}

package/dist/skills/discover.js

@@ -0,0 +1,45 @@
+import path from 'path';
+import fs from 'fs-extra';
+/**
+ * The subdirectory inside the cloned repository that contains individual skill
+ * folders.  Repository layout:
+ *
+ *   <clone>/
+ *     skills/
+ *       remotion/        ← one skill per subdirectory
+ *       mcp-best-practices/
+ *       …
+ *     src/
+ *     README.md
+ */
+const SKILLS_SUBDIR = 'skills';
+/**
+ * Discovers all skills inside the cloned repository.
+ *
+ * A "skill" is any immediate subdirectory of `<cloneDir>/skills/` whose name
+ * does not start with a dot.  Regular files and hidden directories are ignored.
+ *
+ * @param cloneDir - Absolute path to the root of the cloned repository.
+ * @returns Array of discovered skills, sorted alphabetically by name.
+ */
+export async function discoverSkills(cloneDir) {
+    const skillsRoot = path.join(cloneDir, SKILLS_SUBDIR);
+    if (!(await fs.pathExists(skillsRoot))) {
+        return [];
+    }
+    const entries = await fs.readdir(skillsRoot, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries) {
+        // Skip hidden entries (e.g. .DS_Store, .git)
+        if (entry.name.startsWith('.'))
+            continue;
+        // Only directories are treated as skills
+        if (!entry.isDirectory())
+            continue;
+        skills.push({
+            name: entry.name,
+            sourcePath: path.join(skillsRoot, entry.name),
+        });
+    }
+    return skills.sort((a, b) => a.name.localeCompare(b.name));
+}

package/dist/skills/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Runs the full agent-skills installation flow.
+ *
+ * Steps:
+ *  1. Clone the skills repository into a temporary directory.
+ *  2. Discover all skills in the `skills/` subdirectory.
+ *  3. Detect supported AI agents installed on the machine.
+ *  4. Prompt the user to select which agents to install skills into.
+ *  5. Install the skills and report results.
+ *  6. Clean up the temporary clone.
+ *
+ * Graceful fallbacks:
+ *  - Git unavailable or clone fails → print warning and return.
+ *  - No agents detected → print warning and return.
+ *  - User selects no agents → return silently.
+ *  - Individual skill copy fails → reported per-agent, does not abort the run.
+ *
+ * @param force - When true, overwrite existing skill files.
+ */
+export declare function runSkillsFlow(force?: boolean, projectDir?: string): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/skills/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/skills/index.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,aAAa,CAAC,KAAK,GAAE,OAAe,EAAE,UAAU,GAAE,MAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CA4E7G"}

package/dist/skills/index.js

@@ -0,0 +1,97 @@
+import path from 'path';
+import fs from 'fs-extra';
+import chalk from 'chalk';
+import { cloneSkillsRepo, SkillsCloneError } from './clone.js';
+import { discoverSkills } from './discover.js';
+import { AGENTS } from './detect-agents.js';
+import { installSkills } from './installer.js';
+import { printSkillsHeader, printCloned, printSkillList, printInstalling, printSuccess, printCloneError, } from './ui.js';
+/**
+ * Runs the full agent-skills installation flow.
+ *
+ * Steps:
+ *  1. Clone the skills repository into a temporary directory.
+ *  2. Discover all skills in the `skills/` subdirectory.
+ *  3. Detect supported AI agents installed on the machine.
+ *  4. Prompt the user to select which agents to install skills into.
+ *  5. Install the skills and report results.
+ *  6. Clean up the temporary clone.
+ *
+ * Graceful fallbacks:
+ *  - Git unavailable or clone fails → print warning and return.
+ *  - No agents detected → print warning and return.
+ *  - User selects no agents → return silently.
+ *  - Individual skill copy fails → reported per-agent, does not abort the run.
+ *
+ * @param force - When true, overwrite existing skill files.
+ */
+export async function runSkillsFlow(force = false, projectDir = process.cwd()) {
+    printSkillsHeader();
+    // ── Step 1: Clone ──────────────────────────────────────────────────────────
+    let tempDir;
+    try {
+        tempDir = await cloneSkillsRepo();
+    }
+    catch (err) {
+        const message = err instanceof SkillsCloneError
+            ? err.message
+            : err instanceof Error
+                ? err.message
+                : String(err);
+        printCloneError(message);
+        return;
+    }
+    try {
+        printCloned();
+        // ── Step 2: Discover skills ──────────────────────────────────────────────
+        const skills = await discoverSkills(tempDir);
+        if (skills.length === 0) {
+            console.log(chalk.dim('  No skills found in the repository.\n'));
+            return;
+        }
+        printSkillList(skills);
+        // ── Step 3: Install Project-Level Skills ─────────────────────────────────
+        // Installs the skills for all 6 agents by default at project scope
+        const results = await installSkills(AGENTS, skills, force, 'project', projectDir);
+        printInstalling(results);
+        // Read the skills version from the cloned repository's package.json
+        let skillsVersion = '1.0.0';
+        const skillsPackageJsonPath = path.join(tempDir, 'package.json');
+        if (await fs.pathExists(skillsPackageJsonPath)) {
+            try {
+                const pkgJson = await fs.readJSON(skillsPackageJsonPath);
+                if (pkgJson.version) {
+                    skillsVersion = pkgJson.version;
+                }
+            }
+            catch {
+                // Ignore read errors
+            }
+        }
+        // Write skills version to the project's package.json
+        const projectPackageJsonPath = path.join(projectDir, 'package.json');
+        if (await fs.pathExists(projectPackageJsonPath)) {
+            try {
+                const projectPkgJson = await fs.readJSON(projectPackageJsonPath);
+                if (!projectPkgJson.nitrostack) {
+                    projectPkgJson.nitrostack = {};
+                }
+                projectPkgJson.nitrostack.skillsVersion = skillsVersion;
+                await fs.writeJSON(projectPackageJsonPath, projectPkgJson, { spaces: 2 });
+            }
+            catch {
+                // Ignore write errors
+            }
+        }
+        printSuccess();
+    }
+    finally {
+        // ── Cleanup: always remove the temp clone ────────────────────────────────
+        try {
+            await fs.remove(tempDir);
+        }
+        catch {
+            // best-effort; temp files will be cleaned by the OS
+        }
+    }
+}

package/dist/skills/installer.d.ts

@@ -0,0 +1,21 @@
+import type { AgentDescriptor, InstallResult, Skill } from './types.js';
+/**
+ * Installs all discovered skills into the skills directory of a single agent.
+ *
+ * - Creates the target directory if it does not exist.
+ * - Skips individual skills whose destination directory already exists,
+ *   unless `force` is true.
+ * - Preserves the full folder structure of each skill.
+ *
+ * @param agent  - The agent to install into.
+ * @param skills - All skills discovered from the repository.
+ * @param force  - When true, overwrite existing skill directories.
+ * @returns      InstallResult describing what was installed vs skipped.
+ */
+export declare function installSkillsForAgent(agent: AgentDescriptor, skills: Skill[], force: boolean, scope?: 'project' | 'global', projectDir?: string): Promise<InstallResult>;
+/**
+ * Installs skills into every selected agent sequentially.
+ * Sequential (rather than parallel) installation gives cleaner CLI progress output.
+ */
+export declare function installSkills(agents: AgentDescriptor[], skills: Skill[], force: boolean, scope?: 'project' | 'global', projectDir?: string): Promise<InstallResult[]>;
+//# sourceMappingURL=installer.d.ts.map

package/dist/skills/installer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installer.d.ts","sourceRoot":"","sources":["../../src/skills/installer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExE;;;;;;;;;;;;GAYG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,KAAK,EAAE,EACf,KAAK,EAAE,OAAO,EACd,KAAK,GAAE,SAAS,GAAG,QAAmB,EACtC,UAAU,GAAE,MAAsB,GACjC,OAAO,CAAC,aAAa,CAAC,CAwBxB;AAED;;;GAGG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,eAAe,EAAE,EACzB,MAAM,EAAE,KAAK,EAAE,EACf,KAAK,EAAE,OAAO,EACd,KAAK,GAAE,SAAS,GAAG,QAAmB,EACtC,UAAU,GAAE,MAAsB,GACjC,OAAO,CAAC,aAAa,EAAE,CAAC,CAS1B"}