@yonpark/skillhub-cli 0.1.3 → 0.3.0

package/dist/core/syncCore.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTimestamp = parseTimestamp;
+exports.normalizeSkills = normalizeSkills;
+exports.uniqueSortedSkills = uniqueSortedSkills;
+exports.areSameSkills = areSameSkills;
+exports.buildMergePlan = buildMergePlan;
+exports.buildAutoPlan = buildAutoPlan;
+exports.buildPullPlan = buildPullPlan;
+exports.buildPushPlan = buildPushPlan;
+const DEFAULT_SKILL_SOURCE_REPO = "vercel-labs/agent-skills";
+const BANNED_SKILL_NAME_SUBSTRINGS = [
+    "No global skills found",
+    "Try listing project skills without -g",
+    "No project skills found",
+    "Try listing global skills",
+];
+function parseTimestamp(value) {
+    if (!value) {
+        return null;
+    }
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function normalizeSkills(skills) {
+    const normalized = skills
+        .map((skill) => {
+        if (typeof skill === "string") {
+            return { name: skill, source: DEFAULT_SKILL_SOURCE_REPO };
+        }
+        return {
+            name: String(skill?.name ?? ""),
+            source: String(skill?.source ?? DEFAULT_SKILL_SOURCE_REPO),
+        };
+    })
+        .filter((skill) => skill.name.length > 0 &&
+        !BANNED_SKILL_NAME_SUBSTRINGS.some((bad) => skill.name.includes(bad)));
+    return uniqueSortedSkills(normalized);
+}
+function uniqueSortedSkills(skills) {
+    const seen = new Set();
+    const result = [];
+    for (const skill of skills) {
+        const key = `${skill.source}:${skill.name}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            result.push(skill);
+        }
+    }
+    return result.sort((a, b) => {
+        if (a.source !== b.source) {
+            return a.source.localeCompare(b.source);
+        }
+        return a.name.localeCompare(b.name);
+    });
+}
+function areSameSkills(left, right) {
+    const leftSorted = uniqueSortedSkills(left);
+    const rightSorted = uniqueSortedSkills(right);
+    if (leftSorted.length !== rightSorted.length) {
+        return false;
+    }
+    return leftSorted.every((skill, index) => skill.name === rightSorted[index].name &&
+        skill.source === rightSorted[index].source);
+}
+function buildMergePlan(params) {
+    const localSkills = normalizeSkills(params.localPayload.skills);
+    const remoteSkills = normalizeSkills(params.remotePayload.skills);
+    const unionSkills = uniqueSortedSkills([...localSkills, ...remoteSkills]);
+    const installCandidates = unionSkills.filter((skill) => !localSkills.some((local) => local.name === skill.name && local.source === skill.source));
+    const uploadPayload = areSameSkills(remoteSkills, unionSkills)
+        ? null
+        : {
+            skills: unionSkills,
+            updatedAt: params.nowIso,
+        };
+    return {
+        mode: "merge",
+        localSkills,
+        remoteSkills,
+        installCandidates,
+        uploadPayload,
+    };
+}
+function buildAutoPlan(params) {
+    const localSkills = normalizeSkills(params.localPayload.skills);
+    const remoteSkills = normalizeSkills(params.remotePayload.skills);
+    const lastSyncTime = parseTimestamp(params.lastSyncAt) ?? 0;
+    const remoteTime = parseTimestamp(params.remotePayload.updatedAt);
+    const isRemoteNewer = remoteTime !== null && remoteTime > lastSyncTime;
+    if (isRemoteNewer) {
+        const installCandidates = remoteSkills.filter((skill) => !localSkills.some((local) => local.name === skill.name && local.source === skill.source));
+        return {
+            mode: "auto",
+            localSkills,
+            remoteSkills,
+            installCandidates,
+            uploadPayload: null,
+            isRemoteNewer,
+        };
+    }
+    const uploadPayload = areSameSkills(localSkills, remoteSkills)
+        ? null
+        : {
+            skills: localSkills,
+            updatedAt: params.nowIso,
+        };
+    return {
+        mode: "auto",
+        localSkills,
+        remoteSkills,
+        installCandidates: [],
+        uploadPayload,
+        isRemoteNewer,
+    };
+}
+function buildPullPlan(params) {
+    const localSkills = normalizeSkills(params.localPayload.skills);
+    const remoteSkills = normalizeSkills(params.remotePayload.skills);
+    const installCandidates = remoteSkills.filter((remote) => !localSkills.some((local) => local.name === remote.name && local.source === remote.source));
+    const removeCandidates = localSkills.filter((local) => !remoteSkills.some((remote) => remote.name === local.name && remote.source === local.source));
+    return {
+        mode: "pull",
+        localSkills,
+        remoteSkills,
+        installCandidates,
+        removeCandidates,
+    };
+}
+function buildPushPlan(params) {
+    const localSkills = normalizeSkills(params.localPayload.skills);
+    const remoteSkills = normalizeSkills(params.remotePayload.skills);
+    const uploadPayload = areSameSkills(localSkills, remoteSkills)
+        ? null
+        : {
+            skills: localSkills,
+            updatedAt: params.nowIso,
+        };
+    return {
+        mode: "push",
+        localSkills,
+        remoteSkills,
+        uploadPayload,
+    };
+}

package/dist/index.js

@@ -2,20 +2,117 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const login_1 = require("./commands/login");
+const logout_1 = require("./commands/logout");
+const status_1 = require("./commands/status");
 const sync_1 = require("./commands/sync");
+function getPackageVersion() {
+    try {
+        const pkg = require("../package.json");
+        return pkg.version || "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function withJsonErrorHandling(action) {
+    return async (options) => {
+        try {
+            await action(options);
+        }
+        catch (error) {
+            if (options.json) {
+                console.log(JSON.stringify({
+                    ok: false,
+                    error: errorMessage(error),
+                }, null, 2));
+                process.exitCode = 1;
+                return;
+            }
+            throw error;
+        }
+    };
+}
 const program = new commander_1.Command();
-program.name("skillhub").description("SkillHub CLI").version("0.1.0");
-program
+program.name("skillhub").description("SkillHub CLI").version(getPackageVersion());
+const authCommand = program.command("auth").description("Authentication commands");
+authCommand
     .command("login")
-    .description("Login: register your GitHub PAT with gist access")
+    .description("Register your GitHub PAT with gist access")
     .action(async () => {
     await (0, login_1.runLogin)();
 });
-program
+authCommand
+    .command("status")
+    .description("Show local auth/sync status")
+    .option("--json", "print output as JSON", false)
+    .action(withJsonErrorHandling(async (options) => {
+    await (0, status_1.runStatus)({ json: options.json });
+}));
+authCommand
+    .command("logout")
+    .description("Clear stored session data (token, gist id, last sync)")
+    .option("--yes", "skip confirmation prompt", false)
+    .option("--json", "print output as JSON", false)
+    .action(withJsonErrorHandling(async (options) => {
+    await (0, logout_1.runLogout)({ yes: options.yes, json: options.json });
+}));
+const syncCommand = program
     .command("sync")
-    .description("Sync: reconcile local skills with remote Gist backup")
-    .option("-s, --strategy <strategy>", "merge strategy (union|latest)", "union")
-    .action(async (options) => {
-    await (0, sync_1.runSync)(options.strategy);
+    .description("Sync local skills and remote Gist backup");
+syncCommand
+    .command("pull")
+    .description("Mirror remote skills into local skills (remote -> local)")
+    .option("--dry-run", "show planned changes without applying them", false)
+    .option("--yes", "skip deletion confirmation prompt", false)
+    .option("--json", "print output as JSON", false)
+    .action(withJsonErrorHandling(async (options) => {
+    await (0, sync_1.runSyncPull)({
+        dryRun: options.dryRun,
+        yes: options.yes,
+        json: options.json,
+    });
+}));
+syncCommand
+    .command("push")
+    .description("Mirror local skills into remote backup (local -> remote)")
+    .option("--dry-run", "show planned changes without applying them", false)
+    .option("--json", "print output as JSON", false)
+    .action(withJsonErrorHandling(async (options) => {
+    await (0, sync_1.runSyncPush)({
+        dryRun: options.dryRun,
+        json: options.json,
+    });
+}));
+syncCommand
+    .command("merge")
+    .description("Merge local and remote skills (union behavior)")
+    .option("--dry-run", "show planned changes without applying them", false)
+    .option("--json", "print output as JSON", false)
+    .action(withJsonErrorHandling(async (options) => {
+    await (0, sync_1.runSyncMerge)({
+        dryRun: options.dryRun,
+        json: options.json,
+    });
+}));
+syncCommand
+    .command("auto")
+    .description("Sync using remote.updatedAt and lastSyncAt comparison")
+    .option("--dry-run", "show planned changes without applying them", false)
+    .option("--json", "print output as JSON", false)
+    .action(withJsonErrorHandling(async (options) => {
+    await (0, sync_1.runSyncAuto)({
+        dryRun: options.dryRun,
+        json: options.json,
+    });
+}));
+syncCommand.action(() => {
+    syncCommand.outputHelp();
+    throw new Error("Missing sync mode. Use one of: pull, push, merge, auto.");
+});
+program.parseAsync(process.argv).catch((error) => {
+    console.error(`Error: ${errorMessage(error)}`);
+    process.exitCode = 1;
 });
-program.parseAsync(process.argv);

package/dist/service/config.js

@@ -25,4 +25,30 @@ exports.configStore = {
         const config = await getConfig();
         config.set("gistId", gistId);
     },
+    async getLastSyncAt() {
+        const config = await getConfig();
+        return config.get("lastSyncAt");
+    },
+    async setLastSyncAt(lastSyncAt) {
+        const config = await getConfig();
+        config.set("lastSyncAt", lastSyncAt);
+    },
+    async clearToken() {
+        const config = await getConfig();
+        config.delete("githubToken");
+    },
+    async clearGistId() {
+        const config = await getConfig();
+        config.delete("gistId");
+    },
+    async clearLastSyncAt() {
+        const config = await getConfig();
+        config.delete("lastSyncAt");
+    },
+    async clearSession() {
+        const config = await getConfig();
+        config.delete("githubToken");
+        config.delete("gistId");
+        config.delete("lastSyncAt");
+    },
 };

package/dist/service/gistService.js

@@ -2,33 +2,44 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOctokit = createOctokit;
 exports.verifyToken = verifyToken;
+exports.checkGistAccess = checkGistAccess;
 exports.findSkillhubGist = findSkillhubGist;
 exports.getSkillhubPayload = getSkillhubPayload;
 exports.createSkillhubGist = createSkillhubGist;
 exports.updateSkillhubGist = updateSkillhubGist;
 const rest_1 = require("@octokit/rest");
+const retry_1 = require("../utils/retry");
 const SKILLHUB_FILENAME = "skillhub.json";
+const DEFAULT_SKILL_SOURCE_REPO = "vercel-labs/agent-skills";
+const GITHUB_TIMEOUT_MS = 10000;
+function withGitHubRetry(label, fn) {
+    return (0, retry_1.retryAsync)(fn, { label, shouldRetry: retry_1.isTransientError });
+}
 function createOctokit(token) {
-    return new rest_1.Octokit({ auth: token });
+    return new rest_1.Octokit({
+        auth: token,
+        request: {
+            timeout: GITHUB_TIMEOUT_MS,
+        },
+    });
 }
 async function verifyToken(token) {
     const octokit = createOctokit(token);
-    await octokit.users.getAuthenticated();
-    // Also verify that the token can actually talk to the Gist API
-    // (this catches fine-grained tokens that don't have gist access).
-    await octokit.rest.gists.list({ per_page: 1 });
+    await withGitHubRetry("users.getAuthenticated", () => octokit.users.getAuthenticated());
+    await withGitHubRetry("gists.list", () => octokit.rest.gists.list({ per_page: 1 }));
+}
+async function checkGistAccess(octokit) {
+    await withGitHubRetry("gists.list", () => octokit.rest.gists.list({ per_page: 1 }));
 }
 async function findSkillhubGist(octokit) {
-    const gists = await octokit.paginate(octokit.rest.gists.list, {
-        per_page: 100,
-    });
+    const gists = await withGitHubRetry("gists.paginate", () => octokit.paginate(octokit.rest.gists.list, { per_page: 100 }));
     return gists.find((gist) => {
         const files = Object.values(gist.files ?? {});
         return files.some((file) => file?.filename === SKILLHUB_FILENAME);
     });
 }
 async function getSkillhubPayload(octokit, gistId) {
-    const gist = await octokit.gists.get({ gist_id: gistId });
+    const gist = await withGitHubRetry("gists.get", () => octokit.gists.get({ gist_id: gistId }));
     const file = Object.values(gist.data.files ?? {}).find((item) => item?.filename === SKILLHUB_FILENAME);
     if (!file?.content) {
         return null;
@@ -38,10 +49,9 @@ async function getSkillhubPayload(octokit, gistId) {
         if (!Array.isArray(parsed.skills)) {
             return null;
         }
-        // 하위 호환성: string[] 형식을 SkillInfo[] 형식으로 변환
         const normalizedSkills = parsed.skills.map((skill) => {
             if (typeof skill === "string") {
-                return { name: skill, source: "vercel-labs/agent-skills" };
+                return { name: skill, source: DEFAULT_SKILL_SOURCE_REPO };
             }
             return skill;
         });
@@ -55,7 +65,7 @@ async function getSkillhubPayload(octokit, gistId) {
     }
 }
 async function createSkillhubGist(octokit, payload) {
-    const response = await octokit.gists.create({
+    const response = await withGitHubRetry("gists.create", () => octokit.gists.create({
         description: "SkillHub sync",
         public: false,
         files: {
@@ -63,16 +73,16 @@ async function createSkillhubGist(octokit, payload) {
                 content: JSON.stringify(payload, null, 2),
             },
         },
-    });
+    }));
     return response.data;
 }
 async function updateSkillhubGist(octokit, gistId, payload) {
-    await octokit.gists.update({
+    await withGitHubRetry("gists.update", () => octokit.gists.update({
         gist_id: gistId,
         files: {
             [SKILLHUB_FILENAME]: {
                 content: JSON.stringify(payload, null, 2),
             },
         },
-    });
+    }));
 }

package/dist/service/skillsService.js

@@ -0,0 +1,227 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidSource = isValidSource;
+exports.getLocalSkills = getLocalSkills;
+exports.installSkills = installSkills;
+exports.removeSkills = removeSkills;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const syncCore_1 = require("../core/syncCore");
+const retry_1 = require("../utils/retry");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const SKILLS_LOCK_FILENAME = "skills-lock.json";
+const DEFAULT_SKILL_SOURCE_REPO = "vercel-labs/agent-skills";
+const NPX_COMMAND = process.platform === "win32" ? "npx.cmd" : "npx";
+const SOURCE_PATTERN = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+const COMMAND_TIMEOUT_MS = 120000;
+const COMMAND_MAX_BUFFER = 10 * 1024 * 1024;
+function stringifyCommandResult(result) {
+    return `${result.stdout ?? ""}\n${result.stderr ?? ""}`.trim();
+}
+async function runSkillsCommand(args, label) {
+    return (0, retry_1.retryAsync)(async () => {
+        return execFileAsync(NPX_COMMAND, ["skills", ...args], {
+            timeout: COMMAND_TIMEOUT_MS,
+            maxBuffer: COMMAND_MAX_BUFFER,
+            shell: process.platform === "win32",
+        });
+    }, { label, shouldRetry: retry_1.isTransientError });
+}
+function isValidSource(source) {
+    return SOURCE_PATTERN.test(source);
+}
+function getCandidateSkillsLockPaths() {
+    const cwdPath = node_path_1.default.resolve(process.cwd(), SKILLS_LOCK_FILENAME);
+    const homePath = node_path_1.default.resolve(node_os_1.default.homedir(), SKILLS_LOCK_FILENAME);
+    const homeConfigPaths = [
+        node_path_1.default.resolve(node_os_1.default.homedir(), ".config", "skills", SKILLS_LOCK_FILENAME),
+        node_path_1.default.resolve(node_os_1.default.homedir(), ".config", "skillhub", SKILLS_LOCK_FILENAME),
+        node_path_1.default.resolve(node_os_1.default.homedir(), ".skills", SKILLS_LOCK_FILENAME),
+    ];
+    const winAppData = process.env.APPDATA;
+    const winLocalAppData = process.env.LOCALAPPDATA;
+    const windowsConfigPaths = [
+        ...(winAppData
+            ? [node_path_1.default.resolve(winAppData, "skills", SKILLS_LOCK_FILENAME)]
+            : []),
+        ...(winLocalAppData
+            ? [node_path_1.default.resolve(winLocalAppData, "skills", SKILLS_LOCK_FILENAME)]
+            : []),
+    ];
+    return [cwdPath, homePath, ...homeConfigPaths, ...windowsConfigPaths];
+}
+function parseSkillsLock(raw) {
+    const parsed = JSON.parse(raw);
+    const extractSkills = (items) => {
+        return items.map((item) => {
+            if (typeof item === "string") {
+                return { name: item, source: DEFAULT_SKILL_SOURCE_REPO };
+            }
+            if (typeof item === "object" && item !== null) {
+                const objectItem = item;
+                const name = typeof objectItem.name === "string"
+                    ? objectItem.name
+                    : typeof objectItem.skill === "string"
+                        ? objectItem.skill
+                        : String(item);
+                const source = typeof objectItem.source === "string"
+                    ? objectItem.source
+                    : typeof objectItem.repo === "string"
+                        ? objectItem.repo
+                        : DEFAULT_SKILL_SOURCE_REPO;
+                return { name, source };
+            }
+            return { name: String(item), source: DEFAULT_SKILL_SOURCE_REPO };
+        });
+    };
+    if (Array.isArray(parsed?.skills)) {
+        return extractSkills(parsed.skills);
+    }
+    if (Array.isArray(parsed)) {
+        return extractSkills(parsed);
+    }
+    if (Array.isArray(parsed?.installedSkills)) {
+        return extractSkills(parsed.installedSkills);
+    }
+    return [];
+}
+function parseSkillsListOutput(output) {
+    const cleaned = output.replace(/\x1b\[[0-9;]*m/g, "");
+    const lines = cleaned.split(/\r?\n/).map((line) => line.trim());
+    const skills = [];
+    for (const line of lines) {
+        if (!line)
+            continue;
+        if (line === "Global Skills")
+            continue;
+        if (line.startsWith("Agents:"))
+            continue;
+        if (line.startsWith("No project skills found"))
+            continue;
+        if (line.startsWith("Try listing global skills"))
+            continue;
+        if (line.startsWith("No global skills found"))
+            continue;
+        if (line.startsWith("Try listing project skills without -g"))
+            continue;
+        const [name] = line.split(/\s+/);
+        if (!name)
+            continue;
+        if (name.includes("\\") || name.includes("/") || name.includes("~"))
+            continue;
+        skills.push({ name, source: DEFAULT_SKILL_SOURCE_REPO });
+    }
+    return (0, syncCore_1.normalizeSkills)(skills);
+}
+async function tryReadSkillsLock(lockPath) {
+    try {
+        const raw = await promises_1.default.readFile(lockPath, "utf-8");
+        return parseSkillsLock(raw);
+    }
+    catch {
+        return null;
+    }
+}
+async function getLocalSkills() {
+    const listResult = await runSkillsCommand(["list", "-g"], "skills list -g");
+    const listOutput = stringifyCommandResult(listResult);
+    if (listOutput.includes("No global skills found") ||
+        listOutput.includes("Try listing project skills without -g")) {
+        return [];
+    }
+    const fromList = parseSkillsListOutput(listOutput);
+    if (fromList.length > 0) {
+        return fromList;
+    }
+    const lockResult = await runSkillsCommand(["generate-lock"], "skills generate-lock");
+    const lockOutput = stringifyCommandResult(lockResult);
+    const candidatePaths = getCandidateSkillsLockPaths();
+    for (const lockPath of candidatePaths) {
+        const parsed = await tryReadSkillsLock(lockPath);
+        if (parsed) {
+            return (0, syncCore_1.normalizeSkills)(parsed);
+        }
+    }
+    if (lockOutput.includes("No installed skills found") ||
+        listOutput.includes("No project skills found")) {
+        return [];
+    }
+    throw new Error([
+        "Unable to construct local skills list.",
+        "- skills list -g output:",
+        listOutput,
+        "",
+        `- Searched ${SKILLS_LOCK_FILENAME} paths:`,
+        ...candidatePaths.map((p) => `  - ${p}`),
+        "",
+        "- npx skills generate-lock output:",
+        lockOutput,
+    ].join("\n"));
+}
+async function installSkills(skills, options = {}) {
+    const succeeded = [];
+    const failed = [];
+    for (const skill of skills) {
+        if (!isValidSource(skill.source)) {
+            const reason = `Invalid source "${skill.source}". Expected owner/repo format.`;
+            failed.push({ skill, reason });
+            if (options.verbose) {
+                console.warn(`Skill install failed: ${skill.name} (from ${skill.source})`);
+                console.warn(`  - ${reason}`);
+            }
+            continue;
+        }
+        try {
+            const result = await runSkillsCommand(["add", skill.source, "--skill", skill.name, "--global", "--yes"], `skills add ${skill.source} --skill ${skill.name}`);
+            const output = stringifyCommandResult(result);
+            if (options.verbose && output) {
+                console.log(output);
+            }
+            succeeded.push(skill);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            failed.push({ skill, reason });
+            if (options.verbose) {
+                console.warn(`Skill install failed: ${skill.name} (from ${skill.source})`);
+                console.warn(`  - ${reason}`);
+            }
+        }
+    }
+    return { succeeded, failed };
+}
+async function removeSkills(skills, options = {}) {
+    const succeeded = [];
+    const failed = [];
+    const seen = new Set();
+    for (const skill of skills) {
+        const key = `${skill.source}:${skill.name}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        try {
+            const result = await runSkillsCommand(["remove", "--skill", skill.name, "--global", "--yes"], `skills remove --skill ${skill.name}`);
+            const output = stringifyCommandResult(result);
+            if (options.verbose && output) {
+                console.log(output);
+            }
+            succeeded.push(skill);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            failed.push({ skill, reason });
+            if (options.verbose) {
+                console.warn(`Skill remove failed: ${skill.name} (from ${skill.source})`);
+                console.warn(`  - ${reason}`);
+            }
+        }
+    }
+    return { succeeded, failed };
+}

package/dist/utils/output.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitOutput = emitOutput;
+function emitOutput(payload, asJson, formatText) {
+    if (asJson) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    console.log(formatText(payload));
+}