askill-cli 0.1.2 → 0.1.4

package/README.md

@@ -12,6 +12,9 @@ You are an AI agent helping a user with askill - a package manager for AI agent
 
 **Quick Commands:**
 ```bash
+# Install a published skill (@author/skill-name)
+askill add @johndoe/awesome-tool -y
+
 # Install a skill
 askill add owner/repo@skill-name -y
 
@@ -24,6 +27,13 @@ askill list
 # Search for skills
 askill find <query>
 
+# Submit a GitHub skill URL for indexing
+askill submit https://github.com/owner/repo
+
+# Login and publish your own skill
+askill login --token ask_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+askill publish
+
 # Run a skill command
 askill run skill-name:command
 ```
@@ -50,12 +60,17 @@ After installation, read the skill's `SKILL.md` file for usage instructions. Ski
 
 askill is a universal package manager for AI agent skills. It enables agents to discover, install, and use skills across Claude Code, Cursor, Windsurf, and 40+ other AI coding assistants.
 
+Every skill on [askill.sh](https://askill.sh) is automatically reviewed by AI across 5 quality dimensions — safety, clarity, reusability, completeness, and actionability — so you can evaluate quality before you install.
+
 ## Quick Start
 
 ```bash
 # Install
 curl -fsSL https://askill.sh | sh
 
+# Install a published skill
+askill add @johndoe/awesome-tool
+
 # Install a skill
 askill add owner/repo@skill-name
 
@@ -175,7 +190,8 @@ Instructions for the agent...
 
 2. Test locally: `askill add ./my-skill`
 3. Validate: `askill validate`
-4. Publish: Push to GitHub, it's automatically indexed
+4. Submit for indexing: `askill submit https://github.com/<owner>/<repo>`
+5. Publish under your author scope: `askill login` then `askill publish`
 
 See [Publishing Guide](./docs/publishing.md) for details.
 

package/dist/cli.mjs

@@ -4,7 +4,7 @@
 import { homedir } from "os";
 import { join } from "path";
 import { existsSync } from "fs";
-var VERSION = "0.1.2";
+var VERSION = "0.1.4";
 var API_BASE_URL = "https://askill.sh/api/v1";
 var REGISTRY_URL = "https://askill.sh";
 var RESET = "\x1B[0m";
@@ -396,6 +396,40 @@ var APIClient = class {
   async checkCLIVersion() {
     return this.fetch("/cli/version");
   }
+  /**
+   * Submit GitHub URL for indexing
+   */
+  async submit(url) {
+    return this.fetch("/submit", {
+      method: "POST",
+      body: JSON.stringify({ url })
+    });
+  }
+  /**
+   * Verify API token and fetch user profile
+   */
+  async authMe(token) {
+    return this.fetch("/auth/me", {
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+  }
+  /**
+   * Publish a skill from local content or GitHub URL
+   */
+  async publish(payload) {
+    return this.fetch("/publish", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${payload.token}`
+      },
+      body: JSON.stringify({
+        content: payload.content,
+        githubUrl: payload.githubUrl
+      })
+    });
+  }
 };
 var APIError = class extends Error {
   constructor(status, code, message) {
@@ -695,8 +729,8 @@ function getPlatformKey() {
 }
 async function shouldCheckUpdate() {
   try {
-    const { readFile: readFile4 } = await import("fs/promises");
-    const lastCheck = await readFile4(UPDATE_CHECK_FILE, "utf-8");
+    const { readFile: readFile5 } = await import("fs/promises");
+    const lastCheck = await readFile5(UPDATE_CHECK_FILE, "utf-8");
     const lastCheckTime = parseInt(lastCheck, 10);
     return Date.now() - lastCheckTime > UPDATE_INTERVAL_MS;
   } catch {
@@ -705,9 +739,9 @@ async function shouldCheckUpdate() {
 }
 async function saveUpdateCheckTime() {
   try {
-    const { mkdir: mkdir4, writeFile: writeFile4 } = await import("fs/promises");
-    await mkdir4(dirname2(UPDATE_CHECK_FILE), { recursive: true });
-    await writeFile4(UPDATE_CHECK_FILE, String(Date.now()), "utf-8");
+    const { mkdir: mkdir5, writeFile: writeFile5 } = await import("fs/promises");
+    await mkdir5(dirname2(UPDATE_CHECK_FILE), { recursive: true });
+    await writeFile5(UPDATE_CHECK_FILE, String(Date.now()), "utf-8");
   } catch {
   }
 }
@@ -754,28 +788,29 @@ async function fetchVersionInfo() {
     return null;
   }
 }
-async function checkForUpdates(force = false) {
+async function getAvailableUpdate(force = false) {
   if (!force && !await shouldCheckUpdate()) {
-    return;
+    return null;
   }
   await saveUpdateCheckTime();
   const versionInfo = await fetchVersionInfo();
-  if (!versionInfo) return;
+  if (!versionInfo) return null;
   const current = VERSION;
-  const latest = versionInfo.latest;
-  if (semver.lt(current, latest)) {
-    console.log();
-    console.log(`${YELLOW}\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E${RESET}`);
-    console.log(`${YELLOW}\u2502${RESET}  Update available: ${DIM}${current}${RESET} \u2192 ${GREEN}${latest}${RESET}        ${YELLOW}\u2502${RESET}`);
-    console.log(`${YELLOW}\u2502${RESET}  Run ${CYAN}askill upgrade${RESET} to update             ${YELLOW}\u2502${RESET}`);
-    console.log(`${YELLOW}\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F${RESET}`);
-    console.log();
-  }
   if (semver.lt(current, versionInfo.minimum)) {
     console.log(`${RED}Your askill version is too old. Please update to continue.${RESET}`);
     console.log(`Minimum required: ${versionInfo.minimum}`);
     process.exit(1);
   }
+  if (!semver.lt(current, versionInfo.latest)) {
+    return null;
+  }
+  return {
+    current,
+    latest: versionInfo.latest,
+    minimum: versionInfo.minimum,
+    releaseNotes: versionInfo.releaseNotes,
+    releaseUrl: versionInfo.releaseUrl
+  };
 }
 async function selfUpdate() {
   console.log(`${CYAN}Checking for updates...${RESET}`);
@@ -865,6 +900,37 @@ async function getPreferredAgents() {
   return config.preferredAgents;
 }
 
+// src/credentials.ts
+import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile3, rm as rm2 } from "fs/promises";
+import { join as join5 } from "path";
+import { homedir as homedir5 } from "os";
+var ASKILL_DIR = join5(homedir5(), ".askill");
+var CREDENTIALS_FILE = join5(ASKILL_DIR, "credentials.json");
+async function loadCredentials() {
+  try {
+    const content = await readFile2(CREDENTIALS_FILE, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!parsed.token) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function saveCredentials(credentials) {
+  await mkdir3(ASKILL_DIR, { recursive: true });
+  await writeFile3(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2), "utf-8");
+}
+async function clearCredentials() {
+  try {
+    await rm2(CREDENTIALS_FILE);
+  } catch {
+  }
+}
+function maskToken(token) {
+  if (token.length <= 8) return token;
+  return `${token.slice(0, 8)}****`;
+}
+
 // src/parser.ts
 function parseSkillMd(content) {
   const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---/;
@@ -1127,12 +1193,12 @@ function isLocalPath(input) {
 }
 
 // src/discover.ts
-import { readdir as readdir2, readFile as readFile2, stat } from "fs/promises";
-import { join as join5 } from "path";
+import { readdir as readdir2, readFile as readFile3, stat } from "fs/promises";
+import { join as join6 } from "path";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "__pycache__"]);
 async function hasSkillMd(dir) {
   try {
-    const skillPath = join5(dir, "SKILL.md");
+    const skillPath = join6(dir, "SKILL.md");
     const stats = await stat(skillPath);
     return stats.isFile();
   } catch {
@@ -1141,8 +1207,8 @@ async function hasSkillMd(dir) {
 }
 async function parseSkillDir(dir) {
   try {
-    const skillPath = join5(dir, "SKILL.md");
-    const content = await readFile2(skillPath, "utf-8");
+    const skillPath = join6(dir, "SKILL.md");
+    const content = await readFile3(skillPath, "utf-8");
     const parsed = parseSkillMd(content);
     if (!parsed.frontmatter.name || !parsed.frontmatter.description) {
       return null;
@@ -1167,7 +1233,7 @@ async function findSkillDirs(dir, depth = 0, maxDepth = 5) {
     ]);
     const currentDir = hasSkill ? [dir] : [];
     const subDirResults = await Promise.all(
-      entries.filter((entry) => entry.isDirectory() && !SKIP_DIRS.has(entry.name)).map((entry) => findSkillDirs(join5(dir, entry.name), depth + 1, maxDepth))
+      entries.filter((entry) => entry.isDirectory() && !SKIP_DIRS.has(entry.name)).map((entry) => findSkillDirs(join6(dir, entry.name), depth + 1, maxDepth))
     );
     return [...currentDir, ...subDirResults.flat()];
   } catch {
@@ -1177,7 +1243,7 @@ async function findSkillDirs(dir, depth = 0, maxDepth = 5) {
 async function discoverSkills(basePath, subpath) {
   const skills = [];
   const seenNames = /* @__PURE__ */ new Set();
-  const searchPath = subpath ? join5(basePath, subpath) : basePath;
+  const searchPath = subpath ? join6(basePath, subpath) : basePath;
   if (await hasSkillMd(searchPath)) {
     const skill = await parseSkillDir(searchPath);
     if (skill) {
@@ -1186,27 +1252,27 @@ async function discoverSkills(basePath, subpath) {
   }
   const prioritySearchDirs = [
     searchPath,
-    join5(searchPath, "skills"),
-    join5(searchPath, "skills/.curated"),
-    join5(searchPath, "skills/.experimental"),
-    join5(searchPath, ".agents/skills"),
-    join5(searchPath, ".claude/skills"),
-    join5(searchPath, ".opencode/skills"),
-    join5(searchPath, ".cursor/skills"),
-    join5(searchPath, ".codex/skills"),
-    join5(searchPath, ".cline/skills"),
-    join5(searchPath, ".gemini/skills"),
-    join5(searchPath, ".windsurf/skills"),
-    join5(searchPath, ".roo/skills"),
-    join5(searchPath, ".github/skills"),
-    join5(searchPath, ".goose/skills")
+    join6(searchPath, "skills"),
+    join6(searchPath, "skills/.curated"),
+    join6(searchPath, "skills/.experimental"),
+    join6(searchPath, ".agents/skills"),
+    join6(searchPath, ".claude/skills"),
+    join6(searchPath, ".opencode/skills"),
+    join6(searchPath, ".cursor/skills"),
+    join6(searchPath, ".codex/skills"),
+    join6(searchPath, ".cline/skills"),
+    join6(searchPath, ".gemini/skills"),
+    join6(searchPath, ".windsurf/skills"),
+    join6(searchPath, ".roo/skills"),
+    join6(searchPath, ".github/skills"),
+    join6(searchPath, ".goose/skills")
   ];
   for (const dir of prioritySearchDirs) {
     try {
       const entries = await readdir2(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const skillDir = join5(dir, entry.name);
+          const skillDir = join6(dir, entry.name);
           if (await hasSkillMd(skillDir)) {
             const skill = await parseSkillDir(skillDir);
             if (skill && !seenNames.has(skill.name)) {
@@ -1241,8 +1307,8 @@ function filterSkills(skills, names) {
 
 // src/git.ts
 import { execFile } from "child_process";
-import { mkdtemp, rm as rm2 } from "fs/promises";
-import { join as join6, normalize as normalize2, resolve as resolve3, sep as sep2 } from "path";
+import { mkdtemp, rm as rm3 } from "fs/promises";
+import { join as join7, normalize as normalize2, resolve as resolve3, sep as sep2 } from "path";
 import { tmpdir } from "os";
 var CLONE_TIMEOUT_MS = 6e4;
 var GitCloneError = class extends Error {
@@ -1258,7 +1324,7 @@ var GitCloneError = class extends Error {
   }
 };
 async function cloneRepo(url, ref) {
-  const tempDir = await mkdtemp(join6(tmpdir(), "askill-"));
+  const tempDir = await mkdtemp(join7(tmpdir(), "askill-"));
   const args = ["clone", "--depth", "1"];
   if (ref) {
     args.push("--branch", ref);
@@ -1268,7 +1334,7 @@ async function cloneRepo(url, ref) {
     await execGit(args);
     return tempDir;
   } catch (error) {
-    await rm2(tempDir, { recursive: true, force: true }).catch(() => {
+    await rm3(tempDir, { recursive: true, force: true }).catch(() => {
     });
     const errorMessage = error instanceof Error ? error.message : String(error);
     const isTimeout = errorMessage.includes("timed out") || errorMessage.includes("timeout");
@@ -1301,7 +1367,7 @@ async function cleanupTempDir(dir) {
   if (!normalizedDir.startsWith(normalizedTmpDir + sep2) && normalizedDir !== normalizedTmpDir) {
     throw new Error("Attempted to clean up directory outside of temp directory");
   }
-  await rm2(dir, { recursive: true, force: true });
+  await rm3(dir, { recursive: true, force: true });
 }
 function execGit(args) {
   return new Promise((resolve4, reject) => {
@@ -1316,14 +1382,14 @@ function execGit(args) {
 }
 
 // src/lock.ts
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { join as join7, dirname as dirname5 } from "path";
-import { homedir as homedir5 } from "os";
+import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
+import { join as join8, dirname as dirname5 } from "path";
+import { homedir as homedir6 } from "os";
 var AGENTS_DIR2 = ".agents";
 var LOCK_FILE = ".skill-lock.json";
 var CURRENT_VERSION = 3;
 function getSkillLockPath() {
-  return join7(homedir5(), AGENTS_DIR2, LOCK_FILE);
+  return join8(homedir6(), AGENTS_DIR2, LOCK_FILE);
 }
 function createEmptyLockFile() {
   return {
@@ -1334,7 +1400,7 @@ function createEmptyLockFile() {
 async function readSkillLock() {
   const lockPath = getSkillLockPath();
   try {
-    const content = await readFile3(lockPath, "utf-8");
+    const content = await readFile4(lockPath, "utf-8");
     const parsed = JSON.parse(content);
     if (typeof parsed.version !== "number" || !parsed.skills) {
       return createEmptyLockFile();
@@ -1349,9 +1415,9 @@ async function readSkillLock() {
 }
 async function writeSkillLock(lock) {
   const lockPath = getSkillLockPath();
-  await mkdir3(dirname5(lockPath), { recursive: true });
+  await mkdir4(dirname5(lockPath), { recursive: true });
   const content = JSON.stringify(lock, null, 2);
-  await writeFile3(lockPath, content, "utf-8");
+  await writeFile4(lockPath, content, "utf-8");
 }
 async function addSkillToLock(skillName, entry) {
   const lock = await readSkillLock();
@@ -1425,8 +1491,8 @@ async function fetchSkillFolderHash(ownerRepo, skillPath) {
 }
 
 // src/cli.ts
-import { join as join8 } from "path";
-import { homedir as homedir6 } from "os";
+import { join as join9 } from "path";
+import { homedir as homedir7 } from "os";
 import * as p from "@clack/prompts";
 import pc from "picocolors";
 var LOGO = `
@@ -1455,6 +1521,9 @@ function showBanner() {
   console.log(`  ${DIM}$${RESET} askill list${RESET}              ${DIM}List installed skills${RESET}`);
   console.log(`  ${DIM}$${RESET} askill remove ${DIM}<skill>${RESET}   ${DIM}Remove a skill${RESET}`);
   console.log(`  ${DIM}$${RESET} askill init${RESET}              ${DIM}Create a new skill${RESET}`);
+  console.log(`  ${DIM}$${RESET} askill submit ${DIM}<url>${RESET}   ${DIM}Submit GitHub skill URL${RESET}`);
+  console.log(`  ${DIM}$${RESET} askill login${RESET}             ${DIM}Login with API token${RESET}`);
+  console.log(`  ${DIM}$${RESET} askill publish${RESET}           ${DIM}Publish a skill${RESET}`);
   console.log(`  ${DIM}$${RESET} askill run ${DIM}<skill:cmd>${RESET}  ${DIM}Run a skill command${RESET}`);
   console.log();
   console.log(`${DIM}Browse skills at${RESET} ${CYAN}https://askill.sh${RESET}`);
@@ -1474,10 +1543,17 @@ ${BOLD}Commands:${RESET}
   validate [path]          Validate a SKILL.md file
   check                    Check installed skills for updates
   update [skill]           Update installed skills
+  submit <github-url>      Submit GitHub URL for indexing
+  login [--token <token>]  Login with API token
+  logout                   Clear saved API token
+  whoami                   Show current authenticated user
+  publish [path]           Publish SKILL.md from local path
+  publish --github <url>   Publish SKILL.md from GitHub URL
   run <skill:cmd>          Run a skill command
   upgrade                  Update askill CLI to latest version
 
 ${BOLD}Skill Source Formats:${RESET}
+  @author/skill-name                    Published skill from askill registry
   owner/repo                          All skills from a GitHub repo
   owner/repo@skill-name               Specific skill by name
   owner/repo/path/to/skill            Specific skill by path
@@ -1486,6 +1562,7 @@ ${BOLD}Skill Source Formats:${RESET}
   gh:owner/repo@skill-name            Explicit GitHub prefix (optional)
 
 ${BOLD}Install Options:${RESET}
+  (default)             Install to current project: .agents/skills/
   -g, --global          Install globally (user-level)
   -a, --agent <agents>  Install to specific agents
   -y, --yes             Skip confirmation prompts
@@ -1496,21 +1573,297 @@ ${BOLD}Install Options:${RESET}
 ${BOLD}Run Options:${RESET}
   askill run <skill>:<command>      Run a skill's command
 
+${BOLD}Search Options:${RESET}
+  --full-desc             Show full skill descriptions in find/search
+
 ${BOLD}Options:${RESET}
   --help, -h            Show this help message
   --version, -v         Show version number
 
+${BOLD}Per-command Help:${RESET}
+  askill <command> --help
+  askill help <command>
+
+${BOLD}For Agents:${RESET}
+  Official usage guide: ${CYAN}https://github.com/avibe-bot/askill/tree/main/skills/use-askill${RESET}
+
 ${BOLD}Examples:${RESET}
   ${DIM}$${RESET} askill add anthropic/courses@prompt-eng
   ${DIM}$${RESET} askill add anthropic/courses
   ${DIM}$${RESET} askill add ./my-skills/custom-skill
   ${DIM}$${RESET} askill find memory
+  ${DIM}$${RESET} askill find memory --full-desc
   ${DIM}$${RESET} askill list -g
   ${DIM}$${RESET} askill info gh:anthropic/courses@prompt-eng
 
 ${DIM}Browse more at${RESET} ${CYAN}https://askill.sh${RESET}
 `);
 }
+function createSpinner(plain) {
+  if (!plain) {
+    return p.spinner();
+  }
+  return {
+    start: () => {
+    },
+    stop: () => {
+    },
+    message: () => {
+    }
+  };
+}
+function normalizeCommand(command) {
+  switch (command) {
+    case "install":
+    case "i":
+      return "add";
+    case "search":
+    case "s":
+      return "find";
+    case "ls":
+      return "list";
+    case "rm":
+    case "uninstall":
+      return "remove";
+    case "show":
+      return "info";
+    default:
+      return command;
+  }
+}
+function showCommandHelp(commandInput) {
+  const command = normalizeCommand(commandInput);
+  const helps = {
+    add: `${BOLD}askill add${RESET}
+
+Usage:
+  askill add <source> [options]
+
+Description:
+  Install skills from published slugs, GitHub, or local directories.
+
+Sources:
+  @author/skill-name
+  gh:owner/repo@skill-name
+  gh:owner/repo/path/to/skill
+  owner/repo
+  ./local/path
+
+Scope:
+  default: current project (.agents/skills/)
+  -g, --global: user-level install
+
+Options:
+  -g, --global            Install globally
+  -a, --agent <agents...> Install to specific agents
+  -y, --yes               Skip confirmation prompts
+  --copy                  Copy files instead of symlink
+  -l, --list              Preview discovered skills only
+  --all                   Install all discovered skills
+
+Examples:
+  askill add @johndoe/awesome-tool -y
+  askill add gh:facebook/react@extract-errors
+  askill add owner/repo --all -a claude-code opencode -y
+
+Guide:
+  https://github.com/avibe-bot/askill/tree/main/skills/use-askill`,
+    remove: `${BOLD}askill remove${RESET}
+
+Usage:
+  askill remove <skill> [options]
+
+Description:
+  Remove an installed skill from detected agents.
+
+Options:
+  -g, --global            Remove global installation
+
+Examples:
+  askill remove memory
+  askill remove memory -g`,
+    list: `${BOLD}askill list${RESET}
+
+Usage:
+  askill list [options]
+
+Description:
+  List installed skills and where they are available.
+
+Options:
+  -g, --global            Show global skills only
+
+Examples:
+  askill list
+  askill list -g`,
+    find: `${BOLD}askill find${RESET}
+
+Usage:
+  askill find [query] [options]
+
+Description:
+  Search indexed and published skills on askill.sh.
+
+Options:
+  --full-desc             Show full descriptions
+
+Examples:
+  askill find memory
+  askill find code review --full-desc`,
+    info: `${BOLD}askill info${RESET}
+
+Usage:
+  askill info <slug>
+
+Description:
+  Show detailed metadata and installation info for one skill.
+
+Examples:
+  askill info @johndoe/awesome-tool
+  askill info gh:facebook/react@extract-errors`,
+    check: `${BOLD}askill check${RESET}
+
+Usage:
+  askill check [skill]
+
+Description:
+  Check installed skills for available updates without installing.
+
+Examples:
+  askill check
+  askill check memory`,
+    update: `${BOLD}askill update${RESET}
+
+Usage:
+  askill update [skill]
+
+Description:
+  Update one installed skill or all installed skills.
+
+Examples:
+  askill update
+  askill update memory`,
+    run: `${BOLD}askill run${RESET}
+
+Usage:
+  askill run <skill>:<command> [args...]
+
+Description:
+  Run a command declared in a skill's SKILL.md frontmatter.
+
+Examples:
+  askill run @anthropic/memory:save --key name --value "Alice"
+  askill run my-skill:_setup`,
+    validate: `${BOLD}askill validate${RESET}
+
+Usage:
+  askill validate [path]
+
+Description:
+  Validate SKILL.md frontmatter and command structure.
+
+Examples:
+  askill validate
+  askill validate ./my-skill/SKILL.md`,
+    init: `${BOLD}askill init${RESET}
+
+Usage:
+  askill init [dir] [options]
+
+Description:
+  Generate a new SKILL.md template interactively or non-interactively.
+
+Options:
+  -y, --yes               Use defaults without prompts
+
+Examples:
+  askill init
+  askill init ./my-skill -y`,
+    submit: `${BOLD}askill submit${RESET}
+
+Usage:
+  askill submit <github-url>
+
+Description:
+  Submit a GitHub repository or SKILL.md URL for indexing on askill.sh.
+
+Examples:
+  askill submit https://github.com/owner/repo
+  askill submit https://github.com/owner/repo/blob/main/skills/foo/SKILL.md`,
+    login: `${BOLD}askill login${RESET}
+
+Usage:
+  askill login [--token <ask_xxx>]
+
+Description:
+  Save and verify an askill API token for publishing.
+
+Examples:
+  askill login
+  askill login --token ask_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`,
+    logout: `${BOLD}askill logout${RESET}
+
+Usage:
+  askill logout
+
+Description:
+  Clear saved local credentials.`,
+    whoami: `${BOLD}askill whoami${RESET}
+
+Usage:
+  askill whoami
+
+Description:
+  Show current authenticated account and masked token.`,
+    publish: `${BOLD}askill publish${RESET}
+
+Usage:
+  askill publish [path]
+  askill publish --github <blob-url-to-SKILL.md>
+
+Description:
+  Publish a skill under your author scope (@author/skill-name).
+
+Requirements:
+  - Logged in via askill login
+  - SKILL.md contains valid name and semver version
+
+Examples:
+  askill publish
+  askill publish ./skills/my-skill
+  askill publish --github https://github.com/owner/repo/blob/main/skills/my-skill/SKILL.md`,
+    upgrade: `${BOLD}askill upgrade${RESET}
+
+Usage:
+  askill upgrade
+
+Description:
+  Self-update askill CLI to the latest available version.`,
+    help: `${BOLD}askill help${RESET}
+
+Usage:
+  askill help
+  askill help <command>
+
+Description:
+  Show global help or detailed help for a specific command.`
+  };
+  const text2 = helps[command];
+  if (!text2) return false;
+  console.log();
+  console.log(text2);
+  console.log();
+  return true;
+}
+async function maybeAutoUpgradeOnStartup(commandInput) {
+  const command = normalizeCommand(commandInput);
+  const skipCommands = /* @__PURE__ */ new Set(["upgrade", "help", "version", "--version", "-v", "--help", "-h"]);
+  if (skipCommands.has(command)) return;
+  const available = await getAvailableUpdate(false).catch(() => null);
+  if (!available) return;
+  console.log(`${DIM}Auto-updating askill: ${available.current} -> ${available.latest}${RESET}`);
+  await selfUpdate();
+}
 function parseInstallOptions(args) {
   const options = {};
   let skillName = "";
@@ -1642,11 +1995,13 @@ async function resolveSkillsViaApi(parsed, spinner2, options) {
 }
 async function runInstall(args) {
   const { skillName, options } = parseInstallOptions(args);
+  const plainMode = Boolean(options.yes) || !process.stdout.isTTY;
   if (!skillName) {
     console.log(`${RED}Error: Missing skill identifier${RESET}`);
     console.log(`Usage: askill add <source>`);
     console.log(`
 Formats supported:`);
+    console.log(`  askill add @author/skill-name                 ${DIM}# published skill${RESET}`);
     console.log(`  askill add owner/repo                         ${DIM}# all skills from repo${RESET}`);
     console.log(`  askill add owner/repo@skill-name              ${DIM}# specific skill${RESET}`);
     console.log(`  askill add owner/repo/path/to/skill           ${DIM}# skill by path${RESET}`);
@@ -1654,9 +2009,11 @@ Formats supported:`);
     console.log(`  askill add ./local/path                       ${DIM}# local directory${RESET}`);
     process.exit(1);
   }
-  console.log();
-  p.intro(pc.bgCyan(pc.black(" askill install ")));
-  const spinner2 = p.spinner();
+  if (!plainMode) {
+    console.log();
+    p.intro(pc.bgCyan(pc.black(" askill install ")));
+  }
+  const spinner2 = createSpinner(plainMode);
   const { skills: discoveredSkills, parsed: sourceParsed, tempDir } = await resolveSkills(skillName, spinner2, options);
   const cleanup = async () => {
     if (tempDir) await cleanupTempDir(tempDir).catch(() => {
@@ -1665,7 +2022,11 @@ Formats supported:`);
   try {
     if (discoveredSkills.length === 0) {
       p.log.warning("No skills found");
-      p.outro(`Browse skills at ${pc.cyan("https://askill.sh")}`);
+      if (plainMode) {
+        console.log(`Browse skills at ${pc.cyan("https://askill.sh")}`);
+      } else {
+        p.outro(`Browse skills at ${pc.cyan("https://askill.sh")}`);
+      }
       return;
     }
     if (options.list) {
@@ -1682,7 +2043,11 @@ Formats supported:`);
         }
         console.log();
       }
-      p.outro(`Install with: ${pc.cyan(`askill add ${skillName} --all`)}`);
+      if (plainMode) {
+        console.log(`Install with: ${pc.cyan(`askill add ${skillName} --all`)}`);
+      } else {
+        p.outro(`Install with: ${pc.cyan(`askill add ${skillName} --all`)}`);
+      }
       return;
     }
     let skillsToInstall;
@@ -1937,13 +2302,149 @@ Formats supported:`);
       }
     }
     console.log();
-    p.outro(pc.green("Done!"));
+    if (plainMode) {
+      console.log(pc.green("Done!"));
+    } else {
+      p.outro(pc.green("Done!"));
+    }
   } finally {
     await cleanup();
   }
 }
+var SEARCH_DESCRIPTION_MAX_LENGTH = 500;
+function toNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return null;
+  }
+  return value;
+}
+function parseJsonObject(value) {
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return null;
+}
+function formatScore(score) {
+  if (score === null) {
+    return pc.dim("N/A");
+  }
+  return pc.green(Number.isInteger(score) ? String(score) : score.toFixed(1));
+}
+function toScoreLabel(key) {
+  return key.replace(/_/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function getScoreMeta(skill) {
+  const withScoreMeta = skill;
+  return parseJsonObject(withScoreMeta.llmScoreMeta);
+}
+function getTotalAIScore(skill) {
+  const aiScore = toNumber(skill.aiScore);
+  if (aiScore !== null) {
+    return aiScore;
+  }
+  const directScore = toNumber(skill.llmScore);
+  if (directScore !== null) {
+    return directScore;
+  }
+  const meta = getScoreMeta(skill);
+  if (!meta) {
+    return null;
+  }
+  return toNumber(meta.score) ?? toNumber(meta.score_raw) ?? toNumber(meta.final_rank);
+}
+function getAIScoreDimensions(skill) {
+  const directBreakdown = parseJsonObject(skill.aiBreakdown);
+  if (directBreakdown) {
+    const parsedDirect = Object.entries(directBreakdown).map(([key, value]) => {
+      const score = toNumber(value);
+      if (score === null) {
+        return null;
+      }
+      return {
+        key,
+        label: toScoreLabel(key),
+        score
+      };
+    }).filter((item) => item !== null);
+    if (parsedDirect.length > 0) {
+      const preferredOrder2 = ["completeness", "actionability", "reusability", "safety", "clarity", "internal_only"];
+      return parsedDirect.sort((a, b) => {
+        const indexA = preferredOrder2.indexOf(a.key);
+        const indexB = preferredOrder2.indexOf(b.key);
+        const rankA = indexA === -1 ? Number.MAX_SAFE_INTEGER : indexA;
+        const rankB = indexB === -1 ? Number.MAX_SAFE_INTEGER : indexB;
+        if (rankA !== rankB) {
+          return rankA - rankB;
+        }
+        return a.label.localeCompare(b.label);
+      });
+    }
+  }
+  const meta = getScoreMeta(skill);
+  if (!meta) {
+    return [];
+  }
+  const dimensions = parseJsonObject(meta.dimensions);
+  if (!dimensions) {
+    return [];
+  }
+  const preferredOrder = ["completeness", "actionability", "reusability", "safety", "clarity", "internal_only"];
+  const parsed = Object.entries(dimensions).map(([key, value]) => {
+    const nested = parseJsonObject(value);
+    const score = nested ? toNumber(nested.score) : toNumber(value);
+    if (score === null) {
+      return null;
+    }
+    return {
+      key,
+      label: toScoreLabel(key),
+      score
+    };
+  }).filter((item) => item !== null);
+  return parsed.sort((a, b) => {
+    const indexA = preferredOrder.indexOf(a.key);
+    const indexB = preferredOrder.indexOf(b.key);
+    const rankA = indexA === -1 ? Number.MAX_SAFE_INTEGER : indexA;
+    const rankB = indexB === -1 ? Number.MAX_SAFE_INTEGER : indexB;
+    if (rankA !== rankB) {
+      return rankA - rankB;
+    }
+    return a.label.localeCompare(b.label);
+  });
+}
+function normalizeInfoTarget(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+  const withoutGh = trimmed.replace(/^gh:/i, "");
+  const askillSkillUrl = withoutGh.match(/^https?:\/\/askill\.sh\/skills\/(.+)$/i);
+  if (askillSkillUrl && askillSkillUrl[1]) {
+    return askillSkillUrl[1];
+  }
+  return withoutGh;
+}
+function parseSearchOptions(args) {
+  const fullDesc = args.includes("--full-desc");
+  const query = args.filter((arg) => arg !== "--full-desc").join(" ");
+  return {
+    fullDesc,
+    query
+  };
+}
 async function runSearch(args) {
-  const query = args.join(" ");
+  const { fullDesc, query } = parseSearchOptions(args);
   console.log();
   p.intro(pc.bgCyan(pc.black(" askill search ")));
   const spinner2 = p.spinner();
@@ -1962,9 +2463,15 @@ async function runSearch(args) {
       const displayName = skill.name || "unknown";
       const owner = skill.owner || "unknown";
       const description = skill.description || "";
+      const aiScore = getTotalAIScore(skill);
       console.log(`  ${pc.cyan(displayName)} ${pc.dim(`by ${owner}`)}`);
+      console.log(`  ${pc.dim("AI score:")} ${formatScore(aiScore)}`);
       if (description) {
-        console.log(`  ${pc.dim(description.slice(0, 80))}${description.length > 80 ? "..." : ""}`);
+        if (fullDesc) {
+          console.log(`  ${pc.dim(description)}`);
+        } else {
+          console.log(`  ${pc.dim(description.slice(0, SEARCH_DESCRIPTION_MAX_LENGTH))}${description.length > SEARCH_DESCRIPTION_MAX_LENGTH ? "..." : ""}`);
+        }
       }
       const installCmd = skill.owner && skill.repo ? `gh:${skill.owner}/${skill.repo}@${displayName}` : `gh:${displayName}`;
       console.log(`  ${pc.dim("askill add")} ${installCmd}`);
@@ -2048,12 +2555,13 @@ async function runRemove(args) {
   p.outro(pc.green(`Removed ${skillName} from ${agentsWithSkill.length} agent(s)`));
 }
 async function runInfo(args) {
-  const skillName = args[0];
-  if (!skillName) {
+  const inputTarget = args[0];
+  if (!inputTarget) {
     console.log(`${RED}Error: Missing skill name${RESET}`);
     console.log(`Usage: askill info <skill-name>`);
     process.exit(1);
   }
+  const skillName = normalizeInfoTarget(inputTarget);
   console.log();
   p.intro(pc.bgCyan(pc.black(" askill info ")));
   const spinner2 = p.spinner();
@@ -2077,6 +2585,15 @@ async function runInfo(args) {
     if (skill.stars !== null && skill.stars !== void 0) {
       console.log(`  ${pc.dim("Stars:")}      ${skill.stars.toLocaleString()}`);
     }
+    const aiScore = getTotalAIScore(skill);
+    console.log(`  ${pc.dim("AI score:")}   ${formatScore(aiScore)}`);
+    const aiDimensions = getAIScoreDimensions(skill);
+    if (aiDimensions.length > 0) {
+      console.log(`  ${pc.dim("AI breakdown:")}`);
+      for (const dimension of aiDimensions) {
+        console.log(`    ${pc.dim(`${dimension.label}:`)} ${formatScore(dimension.score)}`);
+      }
+    }
     if (skill.tags && skill.tags.length > 0) {
       console.log(`  ${pc.dim("Tags:")}       ${skill.tags.join(", ")}`);
     }
@@ -2312,33 +2829,33 @@ async function findSkillDir(skillName) {
   const { access: fsAccess } = await import("fs/promises");
   const sanitized = sanitizeName(skillName);
   const cwd = process.cwd();
-  const projectCanonical = join8(cwd, AGENTS_DIR, SKILLS_SUBDIR, sanitized);
+  const projectCanonical = join9(cwd, AGENTS_DIR, SKILLS_SUBDIR, sanitized);
   try {
-    await fsAccess(join8(projectCanonical, "SKILL.md"));
+    await fsAccess(join9(projectCanonical, "SKILL.md"));
     return projectCanonical;
   } catch {
   }
   const commonAgentDirs = [".claude/skills", ".cursor/skills", ".opencode/skills", ".windsurf/skills"];
   for (const dir of commonAgentDirs) {
-    const agentPath = join8(cwd, dir, sanitized);
+    const agentPath = join9(cwd, dir, sanitized);
     try {
-      await fsAccess(join8(agentPath, "SKILL.md"));
+      await fsAccess(join9(agentPath, "SKILL.md"));
       return agentPath;
     } catch {
     }
   }
-  const home2 = homedir6();
-  const globalCanonical = join8(home2, AGENTS_DIR, SKILLS_SUBDIR, sanitized);
+  const home2 = homedir7();
+  const globalCanonical = join9(home2, AGENTS_DIR, SKILLS_SUBDIR, sanitized);
   try {
-    await fsAccess(join8(globalCanonical, "SKILL.md"));
+    await fsAccess(join9(globalCanonical, "SKILL.md"));
     return globalCanonical;
   } catch {
   }
   const globalAgentDirs = [".claude/skills", ".cursor/skills", ".opencode/skills"];
   for (const dir of globalAgentDirs) {
-    const agentPath = join8(home2, dir, sanitized);
+    const agentPath = join9(home2, dir, sanitized);
     try {
-      await fsAccess(join8(agentPath, "SKILL.md"));
+      await fsAccess(join9(agentPath, "SKILL.md"));
       return agentPath;
     } catch {
     }
@@ -2376,7 +2893,7 @@ Examples:`);
     process.exit(1);
   }
   const fs = await import("fs/promises");
-  const skillMdPath = join8(skillDir, "SKILL.md");
+  const skillMdPath = join9(skillDir, "SKILL.md");
   const content = await fs.readFile(skillMdPath, "utf-8");
   const { frontmatter } = parseSkillMd(content);
   if (!frontmatter.commands || Object.keys(frontmatter.commands).length === 0) {
@@ -2520,9 +3037,9 @@ function validateFrontmatter(frontmatter) {
 async function runValidate(args) {
   let targetPath = args.find((a) => !a.startsWith("-")) || "SKILL.md";
   if (!targetPath.endsWith("SKILL.md")) {
-    targetPath = join8(targetPath, "SKILL.md");
+    targetPath = join9(targetPath, "SKILL.md");
   }
-  const absolutePath = join8(process.cwd(), targetPath);
+  const absolutePath = join9(process.cwd(), targetPath);
   console.log();
   p.intro(pc.bgCyan(pc.black(" askill validate ")));
   const spinner2 = p.spinner();
@@ -2607,7 +3124,7 @@ async function runInit(args) {
   const isYes = args.includes("-y") || args.includes("--yes");
   console.log();
   p.intro(pc.bgCyan(pc.black(" askill init ")));
-  const skillPath = join8(process.cwd(), targetDir, "SKILL.md");
+  const skillPath = join9(process.cwd(), targetDir, "SKILL.md");
   try {
     await import("fs").then((fs2) => fs2.promises.access(skillPath));
     p.log.error(`SKILL.md already exists at ${pc.cyan(skillPath)}`);
@@ -2729,7 +3246,7 @@ async function runInit(args) {
 `;
   content += `Provide concrete examples of when and how to use this skill.
 `;
-  const targetPath = join8(process.cwd(), targetDir);
+  const targetPath = join9(process.cwd(), targetDir);
   if (targetDir !== ".") {
     const fs2 = await import("fs");
     await fs2.promises.mkdir(targetPath, { recursive: true });
@@ -2745,16 +3262,195 @@ async function runInit(args) {
   console.log();
   p.outro(pc.green("Done!"));
 }
+async function runSubmit(args) {
+  const url = args.find((a) => !a.startsWith("-"));
+  if (!url) {
+    console.log(`${RED}Usage: askill submit <github-url>${RESET}`);
+    process.exit(1);
+  }
+  console.log();
+  p.intro(pc.bgCyan(pc.black(" askill submit ")));
+  const spinner2 = p.spinner();
+  spinner2.start("Submitting URL for indexing...");
+  try {
+    const result = await api.submit(url);
+    spinner2.stop(pc.green(result.message));
+    console.log();
+    for (const skill of result.skills) {
+      const statusColor = skill.status === "indexed" ? pc.green : skill.status === "skipped" ? pc.yellow : pc.red;
+      console.log(`  ${statusColor(skill.status.padEnd(7))} ${pc.dim(skill.path)}${skill.name ? ` (${skill.name})` : ""}`);
+    }
+    p.outro(pc.green(`Submitted ${pc.cyan(`${result.repoOwner}/${result.repoName}`)}`));
+  } catch (error) {
+    spinner2.stop(pc.red("Submit failed"));
+    if (error instanceof APIError) {
+      p.log.error(error.message);
+    } else {
+      p.log.error(error instanceof Error ? error.message : "Unknown error");
+    }
+    p.outro(pc.red("Failed"));
+    process.exit(1);
+  }
+}
+async function runLogin(args) {
+  let token = "";
+  const tokenFlagIndex = args.findIndex((a) => a === "--token");
+  if (tokenFlagIndex >= 0 && args[tokenFlagIndex + 1]) {
+    token = args[tokenFlagIndex + 1];
+  }
+  if (!token) {
+    console.log();
+    p.note(`To get your token, visit: ${pc.cyan(`${REGISTRY_URL}/account`)}`);
+    const input = await p.password({
+      message: "API token",
+      placeholder: "ask_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+      mask: "*",
+      validate: (value) => {
+        if (!value) return "Token is required";
+        if (!value.startsWith("ask_")) return "Token must start with ask_";
+        return void 0;
+      }
+    });
+    if (p.isCancel(input)) {
+      p.cancel("Login cancelled");
+      return;
+    }
+    token = input;
+  }
+  const spinner2 = p.spinner();
+  spinner2.start("Verifying token...");
+  try {
+    const me = await api.authMe(token);
+    const username = me.username ?? void 0;
+    await saveCredentials({ token, username });
+    spinner2.stop(pc.green(`Logged in as @${username ?? "unknown"}`));
+    p.outro(pc.green("Authentication saved"));
+  } catch (error) {
+    spinner2.stop(pc.red("Invalid token"));
+    if (error instanceof APIError) {
+      p.log.error(error.message);
+    } else {
+      p.log.error(error instanceof Error ? error.message : "Unknown error");
+    }
+    p.outro(pc.red("Login failed"));
+    process.exit(1);
+  }
+}
+async function runLogout() {
+  await clearCredentials();
+  p.outro(pc.green("Logged out"));
+}
+async function runWhoami() {
+  const creds = await loadCredentials();
+  if (!creds) {
+    p.log.warn("Not logged in. Run askill login first.");
+    return;
+  }
+  try {
+    const me = await api.authMe(creds.token);
+    const username = me.username ?? creds.username ?? "unknown";
+    console.log(`@${username} (token: ${maskToken(creds.token)})`);
+  } catch {
+    console.log(`Stored token appears invalid (token: ${maskToken(creds.token)})`);
+    process.exit(1);
+  }
+}
+async function runPublish(args) {
+  const creds = await loadCredentials();
+  if (!creds?.token) {
+    p.log.error("Not logged in. Run askill login first.");
+    process.exit(1);
+  }
+  const githubFlagIndex = args.findIndex((a) => a === "--github");
+  const githubUrl = githubFlagIndex >= 0 ? args[githubFlagIndex + 1] : void 0;
+  const localPath = args.find((a) => !a.startsWith("-")) || ".";
+  let content = "";
+  if (githubUrl) {
+    const rawUrl = toRawGitHubUrl(githubUrl);
+    if (!rawUrl) {
+      p.log.error("Invalid GitHub file URL. Use a blob URL to SKILL.md");
+      process.exit(1);
+    }
+    const spinner3 = p.spinner();
+    spinner3.start("Fetching SKILL.md from GitHub...");
+    const res = await fetch(rawUrl);
+    if (!res.ok) {
+      spinner3.stop(pc.red("Fetch failed"));
+      p.log.error("Unable to fetch SKILL.md from GitHub URL");
+      process.exit(1);
+    }
+    content = await res.text();
+    spinner3.stop("Fetched");
+  } else {
+    const fs = await import("fs/promises");
+    const skillPath = localPath.endsWith("SKILL.md") ? localPath : join9(localPath, "SKILL.md");
+    try {
+      content = await fs.readFile(join9(process.cwd(), skillPath), "utf-8");
+    } catch {
+      p.log.error(`Cannot read ${pc.cyan(skillPath)}`);
+      process.exit(1);
+    }
+  }
+  const parsed = parseSkillMd(content);
+  const name = typeof parsed.frontmatter.name === "string" ? parsed.frontmatter.name.trim() : "";
+  const version = typeof parsed.frontmatter.version === "string" ? parsed.frontmatter.version.trim() : "";
+  if (!name) {
+    p.log.error("SKILL.md must include frontmatter name");
+    process.exit(1);
+  }
+  if (!version) {
+    p.log.error('SKILL.md is missing frontmatter field "version".');
+    p.log.info("Add a semver version, for example: version: 0.1.0");
+    p.log.info("Valid examples: 1.0.0, 1.2.3-beta.1, 2.0.0+build.5");
+    process.exit(1);
+  }
+  if (!/^\d+\.\d+\.\d+(?:-[\w.]+)?(?:\+[\w.]+)?$/.test(version)) {
+    p.log.error(`Invalid semver version in SKILL.md: "${version}"`);
+    p.log.info("Expected format: MAJOR.MINOR.PATCH with optional prerelease/build");
+    p.log.info("Examples: 1.0.0, 1.1.0-beta.1, 2.0.0+build.7");
+    process.exit(1);
+  }
+  console.log();
+  p.intro(pc.bgCyan(pc.black(" askill publish ")));
+  const spinner2 = p.spinner();
+  spinner2.start("Publishing skill...");
+  try {
+    const result = await api.publish({
+      token: creds.token,
+      githubUrl,
+      content: githubUrl ? void 0 : content
+    });
+    spinner2.stop(pc.green(`Published ${result.slug}@${result.version}`));
+    p.outro(pc.cyan(result.url));
+  } catch (error) {
+    spinner2.stop(pc.red("Publish failed"));
+    if (error instanceof APIError) {
+      p.log.error(error.message);
+    } else {
+      p.log.error(error instanceof Error ? error.message : "Unknown error");
+    }
+    p.outro(pc.red("Failed"));
+    process.exit(1);
+  }
+}
+function toRawGitHubUrl(url) {
+  const match = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/blob\/[^/]+\/(.+)$/);
+  if (!match) return null;
+  const [, owner, repo, path] = match;
+  return `https://raw.githubusercontent.com/${owner}/${repo}/HEAD/${path}`;
+}
 async function main() {
   const args = process.argv.slice(2);
-  checkForUpdates().catch(() => {
-  });
   if (args.length === 0) {
     showBanner();
     return;
   }
   const command = args[0];
   const restArgs = args.slice(1);
+  if ((restArgs.includes("--help") || restArgs.includes("-h")) && showCommandHelp(command)) {
+    return;
+  }
+  await maybeAutoUpgradeOnStartup(command);
   switch (command) {
     case "install":
     case "i":
@@ -2797,9 +3493,27 @@ async function main() {
     case "init":
       await runInit(restArgs);
       break;
+    case "submit":
+      await runSubmit(restArgs);
+      break;
+    case "login":
+      await runLogin(restArgs);
+      break;
+    case "logout":
+      await runLogout();
+      break;
+    case "whoami":
+      await runWhoami();
+      break;
+    case "publish":
+      await runPublish(restArgs);
+      break;
     case "--help":
     case "-h":
     case "help":
+      if (restArgs[0] && showCommandHelp(restArgs[0])) {
+        break;
+      }
       showHelp();
       break;
     case "--version":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "askill-cli",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "askill - The Agent Skill Package Manager",
   "type": "module",
   "bin": {