@yonpark/skillhub-cli 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yonghun Park
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,167 @@
+# SkillHub CLI (Gist Edition)
+
+SkillHub is a small CLI that syncs your local AI agent skills (managed by `npx skills`)
+with a single GitHub Gist. The Gist acts as a free, serverless backup so you can
+recreate your skill setup on any machine.
+
+## Features
+
+- **Login** with a GitHub Personal Access Token (classic) that has `gist` scope
+- **Sync** local skills with a remote Gist:
+  - Push new local skills up to Gist
+  - Pull missing skills down from Gist and install them globally
+  - Simple merge strategies (`union` and `latest`)
+
+## Installation
+
+From the project root:
+
+```bash
+npm install
+npm run build
+npm link        # optional, to get a global `skillhub` command
+```
+
+Alternatively, you can use `npx`:
+
+```bash
+npm run build
+npx skillhub-cli <command>
+```
+
+## Commands
+
+### `skillhub login`
+
+Registers a GitHub token locally so the CLI can talk to the Gist API.
+
+The command will:
+
+1. Prompt for a token:
+   - Create a **Personal Access Token (classic)** in GitHub
+   - Grant at least the **`gist`** scope
+2. Verify that the token is valid and can access Gists
+3. Store the token locally using [`conf`](https://www.npmjs.com/package/conf)
+
+If login fails, the CLI explains that the token is invalid or missing gist
+permissions, and you can paste a new one.
+
+### `skillhub sync`
+
+Synchronizes your local skills with the remote Gist.
+
+```bash
+skillhub sync
+skillhub sync --strategy union
+skillhub sync --strategy latest
+```
+
+#### What “sync” actually does
+
+1. **Read local skills**
+   - Runs `npx skills list -g` and parses the global skills:
+     - For example:
+       ```text
+       Global Skills
+
+       vercel-composition-patterns ~\.agents\skills\vercel-composition-patterns
+       vercel-react-best-practices ~\.agents\skills\vercel-react-best-practices
+       ```
+   - Falls back to `npx skills generate-lock` + searching for a
+     `skills-lock.json` file when necessary.
+
+2. **Read remote skills (from Gist)**
+   - Looks for a private Gist that contains `skillhub.json`
+   - If not found, creates a new Gist
+
+3. **Merge local vs remote**
+   - **`union` (default)**:
+     - Takes the set union of local and remote skill names
+     - Any skills only on Gist are installed locally
+     - Any skills only on local are written to Gist
+   - **`latest`**:
+     - Compares `updatedAt` timestamps in the payloads
+     - If remote is newer:
+       - Installs skills that are missing locally
+       - Gist is treated as the source of truth
+     - If local is newer (or timestamps are invalid):
+       - Overwrites the Gist with local data
+
+4. **Apply changes**
+   - For skills that exist remotely but not locally, SkillHub runs:
+     ```bash
+     npx skills add vercel-labs/agent-skills --skill "<skill-name>" -g -y
+     ```
+   - For skills that exist locally but not in the Gist, the CLI updates
+     `skillhub.json` in the Gist to reflect the union
+
+5. **Summary output**
+
+After a run you’ll see a short summary like:
+
+```text
+Uploaded 1 change, installed 0 skills
+Uploaded 0 changes, installed 4 skills (1 install failed – check logs)
+```
+
+## Gist Payload
+
+The Gist file `skillhub.json` currently uses a simple payload:
+
+```json
+{
+  "skills": ["vercel-composition-patterns", "vercel-react-best-practices"],
+  "updatedAt": "2026-01-29T07:27:53.844Z"
+}
+```
+
+- `skills`: list of skill names as reported by `skills list -g`
+- `updatedAt`: ISO timestamp when the payload was last written
+
+This keeps the format easy to inspect and edit directly in GitHub if needed.
+
+## Typical Workflows
+
+### First machine (create backup)
+
+```bash
+# 1) Install skills using the official CLI
+npx skills add vercel-labs/agent-skills --all -g -y
+
+# 2) Login once
+skillhub login
+
+# 3) Push your current skills to Gist
+skillhub sync
+```
+
+### New machine (restore from backup)
+
+```bash
+# 1) Install and build SkillHub CLI
+npm install
+npm run build
+npm link
+
+# 2) Login with the same GitHub account/token
+skillhub login
+
+# 3) Pull skills from Gist and install missing ones
+skillhub sync
+```
+
+## Notes and Limitations
+
+- The installer assumes your skills come from
+  `vercel-labs/agent-skills` and calls:
+  ```bash
+  npx skills add vercel-labs/agent-skills --skill "<skill-name>" -g -y
+  ```
+  If a skill name doesn’t exist in that repo, the install will fail but
+  the overall sync will continue.
+- The CLI currently focuses on **global** skills (`skills list -g`),
+  not project-scoped skills.
+- Error messages try to surface both:
+  - Which step failed (local list / lock file / install / Gist)
+  - The underlying CLI output for easier debugging
+

package/bin/skillhub.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+const path = require("path");
+
+const entryPath = path.resolve(__dirname, "..", "dist", "index.js");
+require(entryPath);

package/dist/commands/login.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLogin = runLogin;
+const config_1 = require("../service/config");
+const gistService_1 = require("../service/gistService");
+const TOKEN_PROMPT_MESSAGE = "Create a GitHub Personal Access Token (classic) with the `gist` scope, then paste it here:";
+async function runLogin() {
+    const { default: inquirer } = await import("inquirer");
+    const { token } = await inquirer.prompt([
+        {
+            type: "password",
+            name: "token",
+            message: TOKEN_PROMPT_MESSAGE,
+            mask: "*",
+            validate: (value) => value.trim().length > 0 ? true : "Please enter a token.",
+        },
+    ]);
+    const trimmedToken = token.trim();
+    try {
+        await (0, gistService_1.verifyToken)(trimmedToken);
+        await config_1.configStore.setToken(trimmedToken);
+        console.log("Login successful: token has been saved.");
+    }
+    catch (error) {
+        console.error([
+            "Login failed: token is invalid or cannot access the Gist API.",
+            "Please create a GitHub Personal Access Token (classic) with the `gist` scope and try again.",
+        ].join("\n"));
+        throw error;
+    }
+}

package/dist/commands/sync.js

@@ -0,0 +1,329 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSync = runSync;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const config_1 = require("../service/config");
+const gistService_1 = require("../service/gistService");
+const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+const SKILLS_LOCK_FILENAME = "skills-lock.json";
+const DEFAULT_STRATEGY = "union";
+const DEFAULT_SKILL_SOURCE_REPO = "vercel-labs/agent-skills";
+async function runSync(strategyInput) {
+    const strategy = parseStrategy(strategyInput);
+    const token = await config_1.configStore.getToken();
+    if (!token) {
+        throw new Error("You must login first. Run `skillhub login` and try again.");
+    }
+    const localSkills = await getLocalSkills();
+    const localPayload = {
+        skills: uniqueSortedSkills(localSkills),
+        updatedAt: new Date().toISOString(),
+    };
+    const octokit = (0, gistService_1.createOctokit)(token);
+    let gistId = await config_1.configStore.getGistId();
+    let remotePayload = null;
+    if (gistId) {
+        remotePayload = await safeGetPayload(octokit, gistId);
+        if (!remotePayload) {
+            gistId = undefined;
+        }
+    }
+    if (!gistId) {
+        const found = await (0, gistService_1.findSkillhubGist)(octokit);
+        if (found?.id) {
+            const foundId = found.id;
+            gistId = foundId;
+            await config_1.configStore.setGistId(foundId);
+            remotePayload = await safeGetPayload(octokit, foundId);
+        }
+    }
+    if (!gistId) {
+        const created = await (0, gistService_1.createSkillhubGist)(octokit, localPayload);
+        if (!created.id) {
+            throw new Error("Gist was created, but the ID could not be determined.");
+        }
+        await config_1.configStore.setGistId(created.id);
+        console.log("No existing SkillHub Gist found. A new one has been created.");
+        console.log(`Uploaded 1 change, installed 0 skills`);
+        return;
+    }
+    const resolvedRemote = remotePayload
+        ? {
+            ...remotePayload,
+            skills: normalizeSkills(remotePayload.skills ?? []),
+        }
+        : { skills: [], updatedAt: "" };
+    if (strategy === "latest") {
+        await applyLatestStrategy({
+            octokit,
+            gistId,
+            local: localPayload,
+            remote: resolvedRemote,
+        });
+        return;
+    }
+    await applyUnionStrategy({
+        octokit,
+        gistId,
+        local: localPayload,
+        remote: resolvedRemote,
+    });
+}
+function parseStrategy(input) {
+    if (input === "latest" || input === "union") {
+        return input;
+    }
+    return DEFAULT_STRATEGY;
+}
+async function getLocalSkills() {
+    // 1) Primary source: `skills list -g` output
+    // - generate-lock can be flaky (e.g. "already in lock file" without writing),
+    //   so we prefer parsing the list output when possible.
+    const listResult = await execAsync("npx skills list -g");
+    const listOutput = `${listResult.stdout ?? ""}\n${listResult.stderr ?? ""}`.trim();
+    // When there are no global skills, skills CLI prints:
+    // "No global skills found.\nTry listing project skills without -g"
+    // In that case we treat it as an empty list and avoid polluting Gist.
+    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;
+    }
+    // 2) Fallback: generate-lock + search for a skills-lock.json file
+    const { stdout, stderr } = await execAsync("npx skills generate-lock");
+    const output = `${stdout ?? ""}\n${stderr ?? ""}`.trim();
+    const candidatePaths = getCandidateSkillsLockPaths();
+    for (const lockPath of candidatePaths) {
+        const parsed = await tryReadSkillsLock(lockPath);
+        if (parsed) {
+            return parsed;
+        }
+    }
+    if (output.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:`,
+        output,
+    ].join("\n"));
+}
+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);
+    // Cross-platform candidates when we don't know exactly where the tool writes
+    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),
+    ];
+    // Windows-specific candidates
+    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];
+}
+async function tryReadSkillsLock(lockPath) {
+    try {
+        const raw = await promises_1.default.readFile(lockPath, "utf-8");
+        return parseSkillsLock(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function parseSkillsLock(raw) {
+    const parsed = JSON.parse(raw);
+    // skills-lock.json에서 source 정보 추출 시도
+    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 name = item.name || item.skill || String(item);
+                const source = item.source || item.repo || DEFAULT_SKILL_SOURCE_REPO;
+                return { name: String(name), source: String(source) };
+            }
+            return { name: String(item), source: DEFAULT_SKILL_SOURCE_REPO };
+        });
+    };
+    const fromSkills = parsed?.skills;
+    if (Array.isArray(fromSkills)) {
+        return extractSkills(fromSkills);
+    }
+    if (Array.isArray(parsed)) {
+        return extractSkills(parsed);
+    }
+    const fromInstalled = parsed?.installedSkills;
+    if (Array.isArray(fromInstalled)) {
+        return extractSkills(fromInstalled);
+    }
+    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;
+        // Example: "find-skills ~\\.agents\\skills\\find-skills"
+        // We only take the first token as the skill name
+        const [name] = line.split(/\s+/);
+        if (!name)
+            continue;
+        // Skip obvious path-like tokens as a safety net
+        if (name.includes("\\") || name.includes("/") || name.includes("~"))
+            continue;
+        // skills list 출력에는 source 정보가 없으므로 기본값 사용
+        skills.push({ name, source: DEFAULT_SKILL_SOURCE_REPO });
+    }
+    return uniqueSortedSkills(skills);
+}
+function normalizeSkills(skills) {
+    const bannedSubstrings = [
+        "No global skills found",
+        "Try listing project skills without -g",
+        "No project skills found",
+        "Try listing global skills",
+    ];
+    const normalized = skills
+        .map((skill) => {
+        if (typeof skill === "string") {
+            return { name: skill, source: DEFAULT_SKILL_SOURCE_REPO };
+        }
+        return skill;
+    })
+        .filter((skill) => !!skill.name &&
+        !bannedSubstrings.some((bad) => skill.name.includes(bad)));
+    return uniqueSortedSkills(normalized);
+}
+async function safeGetPayload(octokit, gistId) {
+    try {
+        return await (0, gistService_1.getSkillhubPayload)(octokit, gistId);
+    }
+    catch {
+        return null;
+    }
+}
+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);
+    });
+}
+async function installSkills(skills) {
+    const succeeded = [];
+    const failed = [];
+    for (const skill of skills) {
+        try {
+            const { stdout, stderr } = await execAsync(`npx skills add ${skill.source} --skill "${skill.name}" --global --yes`);
+            const output = `${stdout ?? ""}\n${stderr ?? ""}`.trim();
+            if (output) {
+                console.log(output);
+            }
+            succeeded.push(skill);
+        }
+        catch (error) {
+            const stdout = error?.stdout ?? "";
+            const stderr = error?.stderr ?? "";
+            const reason = `${stdout}\n${stderr}`.trim() || String(error);
+            failed.push({ skill, reason });
+            console.warn([
+                `스킬 설치 실패: ${skill.name} (from ${skill.source})`,
+                reason && `  └─ ${reason}`,
+            ]
+                .filter(Boolean)
+                .join("\n"));
+        }
+    }
+    return { succeeded, failed };
+}
+async function applyUnionStrategy(params) {
+    const localSkills = normalizeSkills(params.local.skills);
+    const remoteSkills = normalizeSkills(params.remote.skills);
+    const unionSkills = uniqueSortedSkills([...localSkills, ...remoteSkills]);
+    const missingLocally = unionSkills.filter((skill) => !localSkills.some((local) => local.name === skill.name && local.source === skill.source));
+    const payload = {
+        skills: unionSkills,
+        updatedAt: new Date().toISOString(),
+    };
+    const { succeeded, failed } = await installSkills(missingLocally);
+    await (0, gistService_1.updateSkillhubGist)(params.octokit, params.gistId, payload);
+    const uploadCount = areSameSkills(remoteSkills, unionSkills) ? 0 : 1;
+    const installCount = succeeded.length;
+    const failedCount = failed.length;
+    console.log(`업로드 ${uploadCount}건, 설치 ${installCount}건${failedCount ? ` (실패 ${failedCount}건은 로그 참고)` : ""}`);
+}
+async function applyLatestStrategy(params) {
+    const localTime = Date.parse(params.local.updatedAt);
+    const remoteTime = Date.parse(params.remote.updatedAt);
+    const isRemoteNewer = Number.isFinite(remoteTime) && remoteTime > localTime;
+    if (isRemoteNewer) {
+        const localSkills = normalizeSkills(params.local.skills);
+        const remoteSkills = normalizeSkills(params.remote.skills);
+        const missingLocally = remoteSkills.filter((skill) => !localSkills.some((local) => local.name === skill.name && local.source === skill.source));
+        const { succeeded, failed } = await installSkills(missingLocally);
+        const failedCount = failed.length;
+        console.log(`업로드 0건, 설치 ${succeeded.length}건${failedCount ? ` (실패 ${failedCount}건은 로그 참고)` : ""}`);
+        return;
+    }
+    await (0, gistService_1.updateSkillhubGist)(params.octokit, params.gistId, params.local);
+    console.log("업로드 1건, 설치 0건");
+}
+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);
+}

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const login_1 = require("./commands/login");
+const sync_1 = require("./commands/sync");
+const program = new commander_1.Command();
+program.name("skillhub").description("SkillHub CLI").version("0.1.0");
+program
+    .command("login")
+    .description("Login: register your GitHub PAT with gist access")
+    .action(async () => {
+    await (0, login_1.runLogin)();
+});
+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);
+});
+program.parseAsync(process.argv);

package/dist/service/config.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configStore = void 0;
+let configPromise = null;
+async function getConfig() {
+    if (!configPromise) {
+        configPromise = import("conf").then((module) => new module.default({ projectName: "skillhub" }));
+    }
+    return configPromise;
+}
+exports.configStore = {
+    async getToken() {
+        const config = await getConfig();
+        return config.get("githubToken");
+    },
+    async setToken(token) {
+        const config = await getConfig();
+        config.set("githubToken", token);
+    },
+    async getGistId() {
+        const config = await getConfig();
+        return config.get("gistId");
+    },
+    async setGistId(gistId) {
+        const config = await getConfig();
+        config.set("gistId", gistId);
+    },
+};

package/dist/service/gistService.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOctokit = createOctokit;
+exports.verifyToken = verifyToken;
+exports.findSkillhubGist = findSkillhubGist;
+exports.getSkillhubPayload = getSkillhubPayload;
+exports.createSkillhubGist = createSkillhubGist;
+exports.updateSkillhubGist = updateSkillhubGist;
+const rest_1 = require("@octokit/rest");
+const SKILLHUB_FILENAME = "skillhub.json";
+function createOctokit(token) {
+    return new rest_1.Octokit({ auth: token });
+}
+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 });
+}
+async function findSkillhubGist(octokit) {
+    const gists = await 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 file = Object.values(gist.data.files ?? {}).find((item) => item?.filename === SKILLHUB_FILENAME);
+    if (!file?.content) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(file.content);
+        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 skill;
+        });
+        return {
+            ...parsed,
+            skills: normalizedSkills,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function createSkillhubGist(octokit, payload) {
+    const response = await octokit.gists.create({
+        description: "SkillHub sync",
+        public: false,
+        files: {
+            [SKILLHUB_FILENAME]: {
+                content: JSON.stringify(payload, null, 2),
+            },
+        },
+    });
+    return response.data;
+}
+async function updateSkillhubGist(octokit, gistId, payload) {
+    await octokit.gists.update({
+        gist_id: gistId,
+        files: {
+            [SKILLHUB_FILENAME]: {
+                content: JSON.stringify(payload, null, 2),
+            },
+        },
+    });
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@yonpark/skillhub-cli",
+  "version": "0.1.2",
+  "description": "SkillHub CLI - sync skills with GitHub Gist",
+  "bin": {
+    "skillhub": "bin/skillhub.js"
+  },
+  "main": "dist/index.js",
+  "type": "commonjs",
+  "scripts": {
+    "build": "tsc && tsc-alias",
+    "start": "node dist/index.js",
+    "prepare": "npm run build"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yw9142/skillhub-cli.git"
+  },
+  "keywords": [
+    "cli",
+    "skills",
+    "agent",
+    "gist",
+    "sync"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@octokit/rest": "^20.0.2",
+    "commander": "^11.1.0",
+    "conf": "^12.0.0",
+    "inquirer": "^9.2.12"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.10",
+    "@types/inquirer": "^9.0.7",
+    "tsc-alias": "^1.8.8",
+    "typescript": "^5.3.3"
+  }
+}