@stefafafan/skm 0.1.0

package/dist/src/manifest.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initManifest = initManifest;
+exports.initLockfile = initLockfile;
+exports.readManifest = readManifest;
+exports.writeManifest = writeManifest;
+exports.readLockfile = readLockfile;
+exports.writeLockfile = writeLockfile;
+exports.mergeSkillState = mergeSkillState;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+const fs_1 = require("./fs");
+async function initManifest(manifestPath, force) {
+    if (!force && (await (0, fs_1.pathExists)(manifestPath))) {
+        throw new errors_1.SkmError(`Manifest already exists at ${manifestPath}`, 5);
+    }
+    await writeManifest(manifestPath, {
+        skills: {},
+    });
+}
+async function initLockfile(lockfilePath, force) {
+    if (!force && (await (0, fs_1.pathExists)(lockfilePath))) {
+        throw new errors_1.SkmError(`Lockfile already exists at ${lockfilePath}`, 5);
+    }
+    await writeLockfile(lockfilePath, {
+        skills: {},
+    });
+}
+async function readManifest(manifestPath) {
+    if (!(await (0, fs_1.pathExists)(manifestPath))) {
+        throw new errors_1.SkmError(`Manifest not found at ${manifestPath}`, 2);
+    }
+    const raw = await (0, promises_1.readFile)(manifestPath, "utf8");
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new errors_1.SkmError(`Invalid manifest JSON at ${manifestPath}: ${error.message}`, 2);
+    }
+    if (!parsed ||
+        typeof parsed !== "object" ||
+        !("skills" in parsed) ||
+        typeof parsed.skills !== "object") {
+        throw new errors_1.SkmError(`Invalid manifest shape at ${manifestPath}`, 2);
+    }
+    return {
+        skills: parsed.skills,
+    };
+}
+async function writeManifest(manifestPath, manifest) {
+    await (0, fs_1.ensureDir)(node_path_1.default.dirname(manifestPath));
+    await (0, promises_1.writeFile)(manifestPath, `${JSON.stringify({ skills: manifest.skills }, null, 2)}\n`);
+}
+async function readLockfile(lockfilePath) {
+    if (!(await (0, fs_1.pathExists)(lockfilePath))) {
+        throw new errors_1.SkmError(`Lockfile not found at ${lockfilePath}`, 2);
+    }
+    const raw = await (0, promises_1.readFile)(lockfilePath, "utf8");
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new errors_1.SkmError(`Invalid lockfile JSON at ${lockfilePath}: ${error.message}`, 2);
+    }
+    if (!parsed ||
+        typeof parsed !== "object" ||
+        !("skills" in parsed) ||
+        typeof parsed.skills !== "object") {
+        throw new errors_1.SkmError(`Invalid lockfile shape at ${lockfilePath}`, 2);
+    }
+    return parsed;
+}
+async function writeLockfile(lockfilePath, lockfile) {
+    await (0, fs_1.ensureDir)(node_path_1.default.dirname(lockfilePath));
+    await (0, promises_1.writeFile)(lockfilePath, `${JSON.stringify(lockfile, null, 2)}\n`);
+}
+function mergeSkillState(manifest, lockfile) {
+    const merged = {};
+    for (const [name, entry] of Object.entries(manifest.skills)) {
+        merged[name] = {
+            ...entry,
+            resolved: lockfile.skills[name]?.resolved,
+            integrity: lockfile.skills[name]?.integrity,
+        };
+    }
+    return merged;
+}

package/dist/src/materialize.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.materializeSkill = materializeSkill;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+const fs_1 = require("./fs");
+async function materializeSkill(options) {
+    const outputDir = node_path_1.default.join(options.generatedSkillsDir, options.canonicalName);
+    await (0, fs_1.ensureDir)(options.generatedSkillsDir);
+    await (0, fs_1.removeIfExists)(outputDir);
+    if (options.strategy === "link") {
+        await (0, promises_1.symlink)(options.sourceDir, outputDir, process.platform === "win32" ? "junction" : "dir");
+        return outputDir;
+    }
+    await (0, fs_1.copyDirectory)(options.sourceDir, outputDir);
+    if (options.strategy === "wrap") {
+        const wrapped = await wrapSkillMarkdown(node_path_1.default.join(outputDir, "SKILL.md"), options.canonicalName, options.manifestSource, options.resolved);
+        await (0, promises_1.writeFile)(node_path_1.default.join(outputDir, "SKILL.md"), wrapped);
+    }
+    else if (!(await (0, fs_1.pathExists)(node_path_1.default.join(outputDir, "SKILL.md")))) {
+        throw new errors_1.SkmError(`Materialized skill at ${outputDir} is missing SKILL.md`, 4);
+    }
+    await (0, promises_1.writeFile)(node_path_1.default.join(outputDir, ".skm-meta.json"), `${JSON.stringify({
+        source: options.manifestSource,
+        resolved: options.resolved,
+        strategy: options.strategy,
+    }, null, 2)}\n`);
+    return outputDir;
+}
+async function wrapSkillMarkdown(skillMdPath, canonicalName, manifestSource, resolved) {
+    const raw = await (0, promises_1.readFile)(skillMdPath, "utf8");
+    const provenanceComment = `\n\n<!-- Generated by skm from ${manifestSource} @ ${resolved} -->\n`;
+    if (!raw.startsWith("---\n")) {
+        return [
+            "---",
+            `name: ${canonicalName}`,
+            "description: Materialized by skm",
+            "---",
+            "",
+            raw.trimEnd(),
+            provenanceComment.trimEnd(),
+            "",
+        ].join("\n");
+    }
+    const endIndex = raw.indexOf("\n---", 4);
+    if (endIndex === -1) {
+        return `${raw.trimEnd()}${provenanceComment}`;
+    }
+    const frontmatter = raw.slice(4, endIndex).split("\n");
+    const body = raw.slice(endIndex + 5).replace(/^\n/, "");
+    let replacedName = false;
+    const nextFrontmatter = frontmatter.map((line) => {
+        if (line.startsWith("name:")) {
+            replacedName = true;
+            return `name: ${canonicalName}`;
+        }
+        return line;
+    });
+    if (!replacedName) {
+        nextFrontmatter.unshift(`name: ${canonicalName}`);
+    }
+    return [
+        "---",
+        ...nextFrontmatter,
+        "---",
+        "",
+        body.trimEnd(),
+        provenanceComment.trimEnd(),
+        "",
+    ].join("\n");
+}

package/dist/src/output.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCliResultAsText = renderCliResultAsText;
+function renderCliResultAsText(result) {
+    switch (result.kind) {
+        case "summary":
+            return `${result.summary}\n`;
+        case "list": {
+            const lines = ["name\tscope\tsource\trequested\tresolved\teffective"];
+            for (const row of result.rows) {
+                lines.push([
+                    row.name,
+                    row.scope,
+                    row.source,
+                    row.requested ?? "",
+                    row.resolved ?? "",
+                    row.effective,
+                ].join("\t"));
+            }
+            return `${lines.join("\n")}\n`;
+        }
+        case "inspect":
+            return `${result.details.map((detail) => `${detail.label}: ${detail.value}`).join("\n")}\n\n`;
+        case "help": {
+            const lines = [result.title, "", `Usage: ${result.usage}`];
+            for (const section of result.sections) {
+                lines.push("", `${section.title}:`, ...section.lines);
+            }
+            return `${lines.join("\n")}\n`;
+        }
+    }
+}

package/dist/src/scope.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveScope = resolveScope;
+exports.findProjectRoot = findProjectRoot;
+exports.globalScope = globalScope;
+exports.projectScope = projectScope;
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+const fs_1 = require("./fs");
+async function resolveScope(options) {
+    const homeDir = options.homeDir ?? process.env.HOME;
+    if (!homeDir) {
+        throw new errors_1.SkmError("HOME is required to resolve scope", 2);
+    }
+    if (options.explicitScope === "project") {
+        const projectRoot = (await findProjectRoot(options.cwd)) ??
+            (options.allowCreateProject ? options.cwd : undefined);
+        if (!projectRoot) {
+            throw new errors_1.SkmError("Project scope requested but no skills.json was found", 2);
+        }
+        return projectScope(projectRoot);
+    }
+    if (options.explicitScope === "global") {
+        return globalScope(homeDir, options.xdgConfigHome);
+    }
+    const discoveredProjectRoot = await findProjectRoot(options.cwd);
+    if (discoveredProjectRoot) {
+        return projectScope(discoveredProjectRoot);
+    }
+    return globalScope(homeDir, options.xdgConfigHome);
+}
+async function findProjectRoot(startDir) {
+    let currentDir = node_path_1.default.resolve(startDir);
+    while (true) {
+        if (await (0, fs_1.pathExists)(node_path_1.default.join(currentDir, "skills.json"))) {
+            return currentDir;
+        }
+        const parentDir = node_path_1.default.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return undefined;
+        }
+        currentDir = parentDir;
+    }
+}
+function globalScope(homeDir, xdgConfigHome) {
+    const configRoot = xdgConfigHome
+        ? node_path_1.default.join(xdgConfigHome, "skm")
+        : node_path_1.default.join(homeDir, ".config", "skm");
+    return {
+        kind: "global",
+        rootDir: configRoot,
+        manifestPath: node_path_1.default.join(configRoot, "skills.json"),
+        lockfilePath: node_path_1.default.join(configRoot, "skills.lock.json"),
+        stateDir: configRoot,
+        storeDir: node_path_1.default.join(configRoot, "store"),
+        generatedSkillsDir: node_path_1.default.join(homeDir, ".agents", "skills"),
+    };
+}
+function projectScope(projectRoot) {
+    return {
+        kind: "project",
+        rootDir: projectRoot,
+        manifestPath: node_path_1.default.join(projectRoot, "skills.json"),
+        lockfilePath: node_path_1.default.join(projectRoot, "skills.lock.json"),
+        stateDir: node_path_1.default.join(projectRoot, ".skm"),
+        storeDir: node_path_1.default.join(projectRoot, ".skm", "store"),
+        generatedSkillsDir: node_path_1.default.join(projectRoot, ".agents", "skills"),
+    };
+}

package/dist/src/source.js

@@ -0,0 +1,156 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSource = parseSource;
+exports.fetchSkillToTempDir = fetchSkillToTempDir;
+exports.isFixedRef = isFixedRef;
+exports.defaultRequestedRef = defaultRequestedRef;
+exports.canonicalTreeUrl = canonicalTreeUrl;
+exports.checkoutSourceRepo = checkoutSourceRepo;
+exports.discoverSkillsInRepo = discoverSkillsInRepo;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const errors_1 = require("./errors");
+const fs_1 = require("./fs");
+const git_1 = require("./git");
+function parseSource(input) {
+    const parsedUrlSource = parseHttpsGitHubSource(input);
+    if (parsedUrlSource) {
+        return parsedUrlSource;
+    }
+    const githubRepoShorthandMatch = /^([^/\s]+)\/([^/\s]+)$/.exec(input);
+    if (githubRepoShorthandMatch) {
+        const owner = githubRepoShorthandMatch[1];
+        const repo = githubRepoShorthandMatch[2];
+        if (!owner || !repo) {
+            throw new errors_1.SkmError(`Invalid GitHub repository shorthand: ${input}`, 2);
+        }
+        return {
+            kind: "github-repo",
+            raw: input,
+            owner,
+            repo,
+        };
+    }
+    throw new errors_1.SkmError(`Unsupported source: ${input}`, 2);
+}
+async function fetchSkillToTempDir(options, tempRoot) {
+    if (options.source.kind !== "github-tree") {
+        throw new errors_1.SkmError(`Source ${options.source.raw} does not point to a single skill`, 2);
+    }
+    const workingRoot = tempRoot ?? (await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "skm-fetch-")));
+    const outputDir = node_path_1.default.join(workingRoot, options.source.defaultName);
+    const checkedOut = await checkoutSourceRepo(options, workingRoot);
+    const upstreamSkillDir = node_path_1.default.join(checkedOut.checkoutDir, options.source.subpath);
+    const skillMdPath = node_path_1.default.join(upstreamSkillDir, "SKILL.md");
+    if (!(await (0, fs_1.pathExists)(skillMdPath))) {
+        throw new errors_1.SkmError(`Skill source ${options.source.raw} is missing SKILL.md`, 4);
+    }
+    await (0, fs_1.copyDirectory)(upstreamSkillDir, outputDir);
+    await (0, fs_1.removeIfExists)(checkedOut.checkoutDir);
+    return {
+        skillDir: outputDir,
+        resolved: checkedOut.resolved,
+    };
+}
+function isFixedRef(ref) {
+    return /^[0-9a-f]{7,40}$/i.test(ref);
+}
+function defaultRequestedRef(source) {
+    return source.kind === "github-tree" ? source.ref : "main";
+}
+function canonicalTreeUrl(source, ref, subpath) {
+    return `${resolveCanonicalGithubBaseUrl(source)}/${source.owner}/${source.repo}/tree/${ref}/${subpath}`;
+}
+async function checkoutSourceRepo(options, tempRoot) {
+    const workingRoot = tempRoot ?? (await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "skm-fetch-")));
+    const checkoutDir = node_path_1.default.join(workingRoot, `checkout-${(0, node_crypto_1.randomUUID)()}`);
+    const repoUrl = resolveRepoUrl(options.source, options.githubBaseUrl);
+    await (0, fs_1.removeIfExists)(checkoutDir);
+    await (0, git_1.cloneAndCheckout)(repoUrl, options.requestedRef, checkoutDir);
+    return {
+        checkoutDir,
+        resolved: await (0, git_1.readHeadCommit)(checkoutDir),
+    };
+}
+async function discoverSkillsInRepo(repoDir) {
+    const discovered = new Map();
+    await walk(repoDir);
+    return [...discovered.values()].sort((left, right) => left.relativeDir.localeCompare(right.relativeDir));
+    async function walk(currentDir) {
+        const entries = await (0, promises_1.readdir)(currentDir, { withFileTypes: true });
+        const hasSkill = entries.some((entry) => entry.isFile() && entry.name === "SKILL.md");
+        if (hasSkill) {
+            const relativeDir = node_path_1.default.relative(repoDir, currentDir) || ".";
+            discovered.set(relativeDir, {
+                relativeDir,
+                canonicalName: node_path_1.default.basename(currentDir),
+                absoluteDir: currentDir,
+            });
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            await walk(node_path_1.default.join(currentDir, entry.name));
+        }
+    }
+}
+function resolveRepoUrl(source, githubBaseUrl = process.env.SKM_GITHUB_BASE_URL ?? "https://github.com") {
+    const trimmedBase = githubBaseUrl.replace(/\/$/, "");
+    if (trimmedBase.includes("://")) {
+        return `${trimmedBase}/${source.owner}/${source.repo}.git`;
+    }
+    return node_path_1.default.join(trimmedBase, source.owner, `${source.repo}.git`);
+}
+function parseHttpsGitHubSource(input) {
+    let url;
+    try {
+        url = new URL(input);
+    }
+    catch {
+        return undefined;
+    }
+    if (url.protocol !== "https:" || url.search || url.hash) {
+        return undefined;
+    }
+    const segments = url.pathname.split("/").filter(Boolean);
+    if (segments.length === 2) {
+        const [owner, repo] = segments;
+        if (!owner || !repo) {
+            throw new errors_1.SkmError(`Invalid GitHub repository URL: ${input}`, 2);
+        }
+        return {
+            kind: "github-repo",
+            raw: input,
+            owner,
+            repo,
+            urlBase: url.origin,
+        };
+    }
+    if (segments.length >= 5 && segments[2] === "tree") {
+        const [owner, repo, , ref, ...subpathSegments] = segments;
+        const subpath = subpathSegments.join("/");
+        if (!owner || !repo || !ref || !subpath) {
+            throw new errors_1.SkmError(`Invalid GitHub source: ${input}`, 2);
+        }
+        return {
+            kind: "github-tree",
+            raw: input,
+            owner,
+            repo,
+            urlBase: url.origin,
+            ref,
+            subpath,
+            defaultName: node_path_1.default.basename(subpath),
+        };
+    }
+    return undefined;
+}
+function resolveCanonicalGithubBaseUrl(source) {
+    return (source.urlBase ?? process.env.SKM_GITHUB_URL_BASE ?? "https://github.com").replace(/\/$/, "");
+}

package/dist/src/store.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.storeSkill = storeSkill;
+exports.storePath = storePath;
+const node_path_1 = __importDefault(require("node:path"));
+const fs_1 = require("./fs");
+async function storeSkill(storeDir, sourceDir, integrity) {
+    await (0, fs_1.ensureDir)(storeDir);
+    const destination = storePath(storeDir, integrity);
+    if (!(await (0, fs_1.pathExists)(destination))) {
+        await (0, fs_1.copyDirectory)(sourceDir, destination);
+    }
+    return destination;
+}
+function storePath(storeDir, integrity) {
+    return node_path_1.default.join(storeDir, integrity);
+}

package/dist/src/ui/render.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCliResultWithInk = renderCliResultWithInk;
+const react_1 = __importDefault(require("react"));
+const nativeImport = new Function("specifier", "return import(specifier);");
+async function loadInk() {
+    return nativeImport("ink");
+}
+async function renderCliResultWithInk(result, options) {
+    const ink = await loadInk();
+    return ink.renderToString(createResultView(ink, result), {
+        columns: options?.columns,
+    });
+}
+function createResultView(ink, result) {
+    switch (result.kind) {
+        case "summary":
+            return createSummaryView(ink, result);
+        case "list":
+            return createListView(ink, result);
+        case "inspect":
+            return createInspectView(ink, result);
+        case "help":
+            return createHelpView(ink, result);
+    }
+}
+function createSummaryView(ink, result) {
+    const { Box, Text } = ink;
+    return react_1.default.createElement(Box, { flexDirection: "column" }, react_1.default.createElement(Text, { color: "green", bold: true }, `[ok] ${result.command}`), react_1.default.createElement(Text, { dimColor: true }, `scope: ${result.scope}`), react_1.default.createElement(Text, null, result.summary), ...(result.skills && result.skills.length > 0
+        ? [
+            react_1.default.createElement(Text, { key: "skills-heading", bold: true }, "skills"),
+            ...result.skills.map((skill, index) => createSkillSummary(ink, skill, index)),
+        ]
+        : []), ...(result.details && result.details.length > 0
+        ? [
+            react_1.default.createElement(Text, { key: "details-heading", bold: true }, "details"),
+            ...result.details.map((detail, index) => createDetailRow(ink, detail, `detail-${index}`)),
+        ]
+        : []));
+}
+function createListView(ink, result) {
+    const { Box, Text } = ink;
+    return react_1.default.createElement(Box, { flexDirection: "column" }, react_1.default.createElement(Text, { color: "green", bold: true }, "Installed skills"), react_1.default.createElement(Text, { dimColor: true }, result.all ? "showing project and global scopes" : "showing active scope"), ...result.rows.flatMap((row, index) => [
+        react_1.default.createElement(Text, { key: `name-${index}`, bold: true }, `${row.name} [${row.effective}]`),
+        react_1.default.createElement(Box, { key: `row-${index}`, flexDirection: "column", marginLeft: 2 }, createDetailRow(ink, { label: "scope", value: row.scope }, `scope-${index}`), createDetailRow(ink, { label: "source", value: row.source }, `source-${index}`), createDetailRow(ink, { label: "requested", value: row.requested ?? "" }, `requested-${index}`), createDetailRow(ink, { label: "resolved", value: row.resolved ?? "" }, `resolved-${index}`)),
+    ]));
+}
+function createInspectView(ink, result) {
+    const { Box, Text } = ink;
+    return react_1.default.createElement(Box, { flexDirection: "column" }, react_1.default.createElement(Text, { color: "green", bold: true }, `[ok] inspect`), react_1.default.createElement(Text, { dimColor: true }, `scope: ${result.scope}`), react_1.default.createElement(Text, { bold: true }, result.name), ...result.details.map((detail, index) => createDetailRow(ink, detail, `inspect-${index}`)));
+}
+function createHelpView(ink, result) {
+    const { Box, Text } = ink;
+    return react_1.default.createElement(Box, { flexDirection: "column" }, react_1.default.createElement(Text, { color: "green", bold: true }, result.title), react_1.default.createElement(Text, null, `Usage: ${result.usage}`), ...result.sections.flatMap((section, index) => [
+        react_1.default.createElement(Text, { key: `section-title-${index}`, bold: true }, section.title),
+        ...section.lines.map((line, lineIndex) => react_1.default.createElement(Text, { key: `section-line-${index}-${lineIndex}` }, line)),
+    ]));
+}
+function createSkillSummary(ink, skill, index) {
+    const { Box, Text } = ink;
+    return react_1.default.createElement(Box, { key: `skill-${index}`, flexDirection: "column", marginLeft: 2 }, react_1.default.createElement(Text, { bold: true }, `${skill.name}${skill.status ? ` (${skill.status})` : ""}`), ...(skill.previousName
+        ? [
+            createDetailRow(ink, { label: "previous", value: skill.previousName }, `previous-${index}`),
+        ]
+        : []), ...(skill.source
+        ? [createDetailRow(ink, { label: "source", value: skill.source }, `skill-source-${index}`)]
+        : []), ...(skill.requested
+        ? [
+            createDetailRow(ink, { label: "requested", value: skill.requested }, `skill-requested-${index}`),
+        ]
+        : []), ...(skill.resolved
+        ? [
+            createDetailRow(ink, { label: "resolved", value: skill.resolved }, `skill-resolved-${index}`),
+        ]
+        : []));
+}
+function createDetailRow(ink, detail, key) {
+    const { Box, Text } = ink;
+    return react_1.default.createElement(Box, { key }, react_1.default.createElement(Text, { dimColor: true }, `${detail.label}: `), react_1.default.createElement(Text, null, detail.value));
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@stefafafan/skm",
+  "version": "0.1.0",
+  "author": "stefafafan",
+  "private": false,
+  "description": "A package manager for AI Agent Skills. Supports installation, version management, and renaming of skills. Can be used for both global and project specific skill management.",
+  "keywords": [
+    "agents",
+    "cli",
+    "developer-tools",
+    "skills"
+  ],
+  "homepage": "https://github.com/stefafafan/skm",
+  "bugs": {
+    "url": "https://github.com/stefafafan/skm/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stefafafan/skm.git"
+  },
+  "bin": {
+    "skm": "dist/src/cli.js"
+  },
+  "files": [
+    "dist/src/**/*",
+    "LICENSE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "ink": "^6.8.0",
+    "react": "^19.2.4"
+  },
+  "devDependencies": {
+    "@types/node": "^24.5.2",
+    "@types/react": "^19.2.14",
+    "oxfmt": "^0.41.0",
+    "oxlint": "^1.56.0",
+    "typescript": "^5.9.2"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "lint": "oxlint src test",
+    "lint:fix": "oxlint --fix src test",
+    "format": "oxfmt --write .",
+    "format:check": "oxfmt --check .",
+    "test": "pnpm run build && node --test \"dist/test/**/*.test.js\""
+  }
+}