@stefafafan/skm 0.1.0

package/dist/src/commands/rename.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRenameCommand = runRenameCommand;
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("../errors");
+const materialize_1 = require("../materialize");
+const manifest_1 = require("../manifest");
+const scope_1 = require("../scope");
+const store_1 = require("../store");
+const fs_1 = require("../fs");
+async function runRenameCommand(options) {
+    const scope = await (0, scope_1.resolveScope)({
+        cwd: options.cwd,
+        homeDir: options.homeDir,
+        xdgConfigHome: options.xdgConfigHome,
+        explicitScope: options.scope,
+    });
+    const manifest = await (0, manifest_1.readManifest)(scope.manifestPath);
+    const lockfile = await (0, manifest_1.readLockfile)(scope.lockfilePath);
+    const manifestEntry = manifest.skills[options.oldName];
+    const lockEntry = lockfile.skills[options.oldName];
+    if (!manifestEntry) {
+        throw new errors_1.SkmError(`Skill ${options.oldName} not found in ${scope.kind} scope`, 1);
+    }
+    if (manifest.skills[options.newName]) {
+        throw new errors_1.SkmError(`Skill ${options.newName} already exists in ${scope.kind} scope`, 5);
+    }
+    if (!lockEntry) {
+        throw new errors_1.SkmError(`Skill ${options.oldName} is missing lockfile state`, 2);
+    }
+    delete manifest.skills[options.oldName];
+    manifest.skills[options.newName] = manifestEntry;
+    delete lockfile.skills[options.oldName];
+    lockfile.skills[options.newName] = lockEntry;
+    await (0, manifest_1.writeManifest)(scope.manifestPath, manifest);
+    await (0, manifest_1.writeLockfile)(scope.lockfilePath, lockfile);
+    await (0, materialize_1.materializeSkill)({
+        canonicalName: options.newName,
+        sourceDir: (0, store_1.storePath)(scope.storeDir, lockEntry.integrity),
+        generatedSkillsDir: scope.generatedSkillsDir,
+        manifestSource: manifestEntry.source,
+        resolved: lockEntry.resolved,
+        strategy: manifestEntry.strategy ?? "wrap",
+    });
+    await (0, fs_1.removeIfExists)(node_path_1.default.join(scope.generatedSkillsDir, options.oldName));
+    return {
+        kind: "summary",
+        command: "rename",
+        scope: scope.kind,
+        summary: `Renamed ${options.oldName} to ${options.newName} in ${scope.kind} scope`,
+        skills: [
+            {
+                name: options.newName,
+                previousName: options.oldName,
+                status: "renamed",
+                source: manifestEntry.source,
+                requested: manifestEntry.requested,
+                resolved: lockEntry.resolved,
+                integrity: lockEntry.integrity,
+            },
+        ],
+    };
+}

package/dist/src/commands/update.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUpdateCommand = runUpdateCommand;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("../errors");
+const fs_1 = require("../fs");
+const hash_1 = require("../hash");
+const materialize_1 = require("../materialize");
+const manifest_1 = require("../manifest");
+const scope_1 = require("../scope");
+const source_1 = require("../source");
+const store_1 = require("../store");
+async function runUpdateCommand(options) {
+    const scope = await (0, scope_1.resolveScope)({
+        cwd: options.cwd,
+        homeDir: options.homeDir,
+        xdgConfigHome: options.xdgConfigHome,
+        explicitScope: options.scope,
+    });
+    const manifest = await (0, manifest_1.readManifest)(scope.manifestPath);
+    const lockfile = await (0, manifest_1.readLockfile)(scope.lockfilePath);
+    const names = options.canonicalName ? [options.canonicalName] : Object.keys(manifest.skills);
+    const tempRoot = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "skm-update-"));
+    const updatedSkills = [];
+    try {
+        let updatedCount = 0;
+        for (const name of names) {
+            const entry = manifest.skills[name];
+            if (!entry) {
+                continue;
+            }
+            const lockEntry = lockfile.skills[name];
+            if (!lockEntry) {
+                throw new errors_1.SkmError(`Skill ${name} is missing lockfile state`, 2);
+            }
+            const requestedRef = entry.requested ?? (0, source_1.defaultRequestedRef)((0, source_1.parseSource)(entry.source));
+            if ((0, source_1.isFixedRef)(requestedRef) && !options.force) {
+                updatedSkills.push({
+                    name,
+                    status: "skipped",
+                    source: entry.source,
+                    requested: requestedRef,
+                    resolved: lockEntry.resolved,
+                    integrity: lockEntry.integrity,
+                });
+                continue;
+            }
+            const fetched = await (0, source_1.fetchSkillToTempDir)({
+                source: (0, source_1.parseSource)(entry.source),
+                requestedRef,
+                githubBaseUrl: options.githubBaseUrl,
+            }, tempRoot);
+            const integrity = await (0, hash_1.hashDirectory)(fetched.skillDir);
+            const storeDir = await (0, store_1.storeSkill)(scope.storeDir, fetched.skillDir, integrity);
+            lockEntry.resolved = fetched.resolved;
+            lockEntry.integrity = integrity;
+            await (0, materialize_1.materializeSkill)({
+                canonicalName: name,
+                sourceDir: storeDir,
+                generatedSkillsDir: scope.generatedSkillsDir,
+                manifestSource: entry.source,
+                resolved: lockEntry.resolved,
+                strategy: entry.strategy ?? "wrap",
+            });
+            updatedSkills.push({
+                name,
+                status: "updated",
+                source: entry.source,
+                requested: requestedRef,
+                resolved: lockEntry.resolved,
+                integrity,
+            });
+            updatedCount += 1;
+        }
+        await (0, manifest_1.writeLockfile)(scope.lockfilePath, lockfile);
+        return {
+            kind: "summary",
+            command: "update",
+            scope: scope.kind,
+            summary: `Updated ${updatedCount} skill(s) in ${scope.kind} scope`,
+            skills: updatedSkills,
+        };
+    }
+    finally {
+        await (0, fs_1.removeIfExists)(tempRoot);
+    }
+}

package/dist/src/errors.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkmError = void 0;
+exports.isSkmError = isSkmError;
+class SkmError extends Error {
+    exitCode;
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.name = "SkmError";
+        this.exitCode = exitCode;
+    }
+}
+exports.SkmError = SkmError;
+function isSkmError(error) {
+    return error instanceof SkmError;
+}

package/dist/src/fs.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathExists = pathExists;
+exports.ensureDir = ensureDir;
+exports.removeIfExists = removeIfExists;
+exports.copyDirectory = copyDirectory;
+exports.listFilesRecursive = listFilesRecursive;
+exports.isDirectory = isDirectory;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+async function pathExists(targetPath) {
+    try {
+        await (0, promises_1.stat)(targetPath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+async function ensureDir(dirPath) {
+    await (0, promises_1.mkdir)(dirPath, { recursive: true });
+}
+async function removeIfExists(targetPath) {
+    await (0, promises_1.rm)(targetPath, { recursive: true, force: true });
+}
+async function copyDirectory(sourceDir, destinationDir) {
+    await removeIfExists(destinationDir);
+    await ensureDir(node_path_1.default.dirname(destinationDir));
+    await (0, promises_1.cp)(sourceDir, destinationDir, { recursive: true, preserveTimestamps: true });
+}
+async function listFilesRecursive(rootDir) {
+    const entries = await (0, promises_1.readdir)(rootDir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        const fullPath = node_path_1.default.join(rootDir, entry.name);
+        if (entry.isDirectory()) {
+            for (const nested of await listFilesRecursive(fullPath)) {
+                files.push(node_path_1.default.join(entry.name, nested));
+            }
+            continue;
+        }
+        if (entry.isFile() || entry.isSymbolicLink()) {
+            files.push(entry.name);
+        }
+    }
+    return files;
+}
+async function isDirectory(targetPath) {
+    try {
+        return (await (0, promises_1.lstat)(targetPath)).isDirectory();
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}

package/dist/src/git.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGit = runGit;
+exports.cloneAndCheckout = cloneAndCheckout;
+exports.readHeadCommit = readHeadCommit;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const errors_1 = require("./errors");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+async function runGit(args, cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", args, {
+            cwd,
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        return stdout;
+    }
+    catch (error) {
+        const execError = error;
+        const detail = execError.stderr?.trim() || execError.message;
+        throw new errors_1.SkmError(`git ${args.join(" ")} failed: ${detail}`, 3);
+    }
+}
+async function cloneAndCheckout(repoUrl, ref, targetDir) {
+    await runGit(["clone", "--quiet", repoUrl, targetDir]);
+    await runGit(["checkout", "--quiet", ref], targetDir);
+}
+async function readHeadCommit(repoDir) {
+    return (await runGit(["rev-parse", "HEAD"], repoDir)).trim();
+}

package/dist/src/hash.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashDirectory = hashDirectory;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const fs_1 = require("./fs");
+async function hashDirectory(dirPath) {
+    const hash = (0, node_crypto_1.createHash)("sha256");
+    const files = await (0, fs_1.listFilesRecursive)(dirPath);
+    for (const relativePath of files) {
+        hash.update(`path:${relativePath}\n`);
+        hash.update(await (0, promises_1.readFile)(node_path_1.default.join(dirPath, relativePath)));
+        hash.update("\n");
+    }
+    return `sha256-${hash.digest("base64")}`;
+}

package/dist/src/index.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const add_1 = require("./commands/add");
+const init_1 = require("./commands/init");
+const inspect_1 = require("./commands/inspect");
+const install_1 = require("./commands/install");
+const list_1 = require("./commands/list");
+const rename_1 = require("./commands/rename");
+const remove_1 = require("./commands/remove");
+const update_1 = require("./commands/update");
+const errors_1 = require("./errors");
+const output_1 = require("./output");
+const render_1 = require("./ui/render");
+async function main(argv, context) {
+    const parsed = parseArgv(argv);
+    const cwd = context?.cwd ?? process.cwd();
+    const env = context?.env ?? process.env;
+    const stdoutIsTTY = context?.stdoutIsTTY ?? process.stdout.isTTY ?? false;
+    const stdoutColumns = context?.stdoutColumns ?? process.stdout.columns;
+    try {
+        const output = await dispatch(parsed, cwd, env);
+        if (output) {
+            const renderedOutput = stdoutIsTTY
+                ? await (0, render_1.renderCliResultWithInk)(output, { columns: stdoutColumns })
+                : (0, output_1.renderCliResultAsText)(output);
+            process.stdout.write(renderedOutput.endsWith("\n") ? renderedOutput : `${renderedOutput}\n`);
+        }
+        return 0;
+    }
+    catch (error) {
+        if ((0, errors_1.isSkmError)(error)) {
+            process.stderr.write(`${error.message}\n`);
+            return error.exitCode;
+        }
+        const unknown = error;
+        process.stderr.write(`${unknown.message}\n`);
+        return 1;
+    }
+}
+function parseArgv(argv) {
+    const parsed = {
+        positional: [],
+        all: false,
+        force: false,
+        help: false,
+    };
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === undefined) {
+            continue;
+        }
+        if (token === "--global") {
+            parsed.scope = "global";
+            continue;
+        }
+        if (token === "--help" || token === "-h") {
+            parsed.help = true;
+            continue;
+        }
+        if (token === "--project") {
+            parsed.scope = "project";
+            continue;
+        }
+        if (token === "--all") {
+            parsed.all = true;
+            continue;
+        }
+        if (token === "--force") {
+            parsed.force = true;
+            continue;
+        }
+        if (token === "--as") {
+            parsed.alias = argv[index + 1];
+            index += 1;
+            continue;
+        }
+        if (token === "--ref") {
+            parsed.ref = argv[index + 1];
+            index += 1;
+            continue;
+        }
+        if (!parsed.command) {
+            parsed.command = token;
+            continue;
+        }
+        parsed.positional.push(token);
+    }
+    return parsed;
+}
+async function dispatch(parsed, cwd, env) {
+    if (parsed.command === "help") {
+        return buildHelpResult(parsed.positional[0]);
+    }
+    if (parsed.help) {
+        return buildHelpResult(parsed.command);
+    }
+    if (!parsed.command) {
+        return buildHelpResult();
+    }
+    const homeDir = env.HOME;
+    const githubBaseUrl = env.SKM_GITHUB_BASE_URL;
+    const xdgConfigHome = env.XDG_CONFIG_HOME;
+    switch (parsed.command) {
+        case "init":
+            return (0, init_1.runInitCommand)({
+                cwd,
+                homeDir,
+                xdgConfigHome,
+                scope: parsed.scope,
+                force: parsed.force,
+            });
+        case "add":
+            if (!parsed.positional[0]) {
+                throw new errors_1.SkmError("Usage: skm add <source>", 2);
+            }
+            return (0, add_1.runAddCommand)({
+                cwd,
+                homeDir,
+                xdgConfigHome,
+                scope: parsed.scope,
+                source: parsed.positional[0],
+                canonicalName: parsed.alias,
+                requestedRef: parsed.ref,
+                githubBaseUrl,
+            });
+        case "remove":
+            if (!parsed.positional[0]) {
+                throw new errors_1.SkmError("Usage: skm remove <name>", 2);
+            }
+            return (0, remove_1.runRemoveCommand)({
+                cwd,
+                homeDir,
+                xdgConfigHome,
+                scope: parsed.scope,
+                canonicalName: parsed.positional[0],
+            });
+        case "rename":
+            if (!parsed.positional[0] || !parsed.positional[1]) {
+                throw new errors_1.SkmError("Usage: skm rename <old-name> <new-name>", 2);
+            }
+            return (0, rename_1.runRenameCommand)({
+                cwd,
+                homeDir,
+                xdgConfigHome,
+                scope: parsed.scope,
+                oldName: parsed.positional[0],
+                newName: parsed.positional[1],
+            });
+        case "install":
+            return (0, install_1.runInstallCommand)({
+                cwd,
+                homeDir,
+                xdgConfigHome,
+                scope: parsed.scope,
+                githubBaseUrl,
+            });
+        case "update":
+            return (0, update_1.runUpdateCommand)({
+                cwd,
+                homeDir,
+                xdgConfigHome,
+                scope: parsed.scope,
+                canonicalName: parsed.positional[0],
+                force: parsed.force,
+                githubBaseUrl,
+            });
+        case "list":
+            return (0, list_1.runListCommand)({
+                cwd,
+                homeDir,
+                xdgConfigHome,
+                scope: parsed.scope,
+                all: parsed.all,
+            });
+        case "inspect":
+            if (!parsed.positional[0]) {
+                throw new errors_1.SkmError("Usage: skm inspect <name>", 2);
+            }
+            return (0, inspect_1.runInspectCommand)({
+                cwd,
+                homeDir,
+                xdgConfigHome,
+                scope: parsed.scope,
+                canonicalName: parsed.positional[0],
+            });
+        default:
+            throw new errors_1.SkmError(`Unknown command: ${parsed.command}`, 2);
+    }
+}
+function buildHelpResult(command) {
+    switch (command) {
+        case "add":
+            return {
+                kind: "help",
+                title: "skm add",
+                usage: "skm add <source> [--project|--global] [--as <name>] [--ref <ref>]",
+                sections: [
+                    {
+                        title: "Sources",
+                        lines: [
+                            "- GitHub tree URL: https://github.com/<owner>/<repo>/tree/<ref>/<path>",
+                            "- GitHub repository shorthand: <owner>/<repo>",
+                            "- GitHub repository URL: https://github.com/<owner>/<repo>",
+                        ],
+                    },
+                    {
+                        title: "Options",
+                        lines: [
+                            "- --as <name>  Set the local skill name for single-skill imports",
+                            "- --ref <ref>  Override the requested branch, tag, or commit",
+                            "- --project    Use project scope",
+                            "- --global     Use global scope",
+                        ],
+                    },
+                ],
+            };
+        case "init":
+            return {
+                kind: "help",
+                title: "skm init",
+                usage: "skm init [--project|--global] [--force]",
+                sections: [
+                    {
+                        title: "Options",
+                        lines: [
+                            "- --project  Initialize project scope",
+                            "- --global   Initialize global scope",
+                            "- --force    Rewrite existing manifest and lockfile",
+                        ],
+                    },
+                ],
+            };
+        case "remove":
+            return {
+                kind: "help",
+                title: "skm remove",
+                usage: "skm remove <name> [--project|--global]",
+                sections: [{ title: "Options", lines: ["- --project", "- --global"] }],
+            };
+        case "rename":
+            return {
+                kind: "help",
+                title: "skm rename",
+                usage: "skm rename <old-name> <new-name> [--project|--global]",
+                sections: [{ title: "Options", lines: ["- --project", "- --global"] }],
+            };
+        case "install":
+            return {
+                kind: "help",
+                title: "skm install",
+                usage: "skm install [--project|--global]",
+                sections: [{ title: "Options", lines: ["- --project", "- --global"] }],
+            };
+        case "update":
+            return {
+                kind: "help",
+                title: "skm update",
+                usage: "skm update [name] [--project|--global] [--force]",
+                sections: [
+                    {
+                        title: "Options",
+                        lines: [
+                            "- --project",
+                            "- --global",
+                            "- --force    Refresh even when the requested ref is already a fixed commit",
+                        ],
+                    },
+                ],
+            };
+        case "list":
+            return {
+                kind: "help",
+                title: "skm list",
+                usage: "skm list [--project|--global] [--all]",
+                sections: [
+                    {
+                        title: "Options",
+                        lines: [
+                            "- --all      Show both project and global entries when available",
+                            "- --project",
+                            "- --global",
+                        ],
+                    },
+                ],
+            };
+        case "inspect":
+            return {
+                kind: "help",
+                title: "skm inspect",
+                usage: "skm inspect <name> [--project|--global]",
+                sections: [{ title: "Options", lines: ["- --project", "- --global"] }],
+            };
+        default:
+            return {
+                kind: "help",
+                title: "skm",
+                usage: "skm <command>",
+                sections: [
+                    {
+                        title: "Commands",
+                        lines: [
+                            "- init",
+                            "- add <source>",
+                            "- remove <name>",
+                            "- rename <old-name> <new-name>",
+                            "- install",
+                            "- update [name]",
+                            "- list",
+                            "- inspect <name>",
+                            "- help [command]",
+                        ],
+                    },
+                    {
+                        title: "Global options",
+                        lines: ["- --help, -h", "- --project", "- --global"],
+                    },
+                ],
+            };
+    }
+}