askill-cli 0.1.2 → 0.1.3

package/README.md

@@ -24,6 +24,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,6 +57,8 @@ 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
@@ -175,7 +184,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.3";
 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 {
   }
 }
@@ -865,6 +899,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 +1192,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 +1206,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 +1232,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 +1242,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 +1251,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 +1306,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 +1323,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 +1333,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 +1366,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 +1381,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 +1399,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 +1414,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 +1490,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 +1520,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,6 +1542,12 @@ ${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
 
@@ -1942,6 +2016,118 @@ Formats supported:`);
     await cleanup();
   }
 }
+var SEARCH_DESCRIPTION_MAX_LENGTH = 180;
+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);
+  });
+}
 async function runSearch(args) {
   const query = args.join(" ");
   console.log();
@@ -1962,9 +2148,11 @@ 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 ? "..." : ""}`);
+        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}`);
@@ -2077,6 +2265,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 +2509,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 +2573,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 +2717,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 +2804,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 +2926,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,6 +2942,175 @@ 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 || !/^\d+\.\d+\.\d+(?:-[\w.]+)?(?:\+[\w.]+)?$/.test(version)) {
+    p.log.error("SKILL.md must include a valid semver version");
+    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(() => {
@@ -2797,6 +3163,21 @@ 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":

package/package.json

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