@ikyyofc/gemini-cli 3.0.2 → 3.0.4

package/index.js

@@ -25,8 +25,9 @@ import {
 import { setupGlobalProxy, proxyStatus, setProxyEnabled } from "./src/utils/proxy.js";
 import { Spinner } from "./src/utils/spinner.js";
 import {
-    listInstalledSkills, installSkill, removeSkill,
-    searchSkills, browseSkills, ensureSkillsDirs, loadSkills,
+    listInstalledSkills, installSkill, removeSkillNpx,
+    findSkills, listNpxSkills, updateSkill, initSkill,
+    ensureSkillsDirs, loadSkills,
 } from "./src/skills.js";
 
 // ─────────────────────────────────────────────────────────────────
@@ -240,131 +241,132 @@ async function handleCommand(input) {
             const sub  = tokens[1]?.toLowerCase();
             const rest = tokens.slice(2).join(" ").trim();
 
-            // /skill list
-            if (!sub || sub === "list") {
-                const list = listInstalledSkills();
-                if (!list.length) {
-                    printInfo("no skills installed  ·  use /skill add <id> to install");
-                    printInfo("browse skills at https://skills.sh");
+            // ── /skill list ──────────────────────────────────────
+            if (!sub || sub === "list" || sub === "ls") {
+                // Quick disk scan (instant, no npx)
+                const disk = listInstalledSkills();
+                if (!disk.length) {
+                    printInfo("no skills installed");
+                    printInfo("browse: https://skills.sh  ·  install: /skill add <owner/repo>");
                     break;
                 }
                 console.log("");
-                list.forEach(s => {
+                disk.forEach(s => {
                     const scope = s.global ? chalk.dim("global") : chalk.hex("#4EC9B0")("project");
                     console.log(
-                        "  " + chalk.hex("#FFD080").bold(s.slug.padEnd(28)) +
-                        chalk.dim(s.source.padEnd(30)) + scope
+                        "  " + chalk.hex("#FFD080").bold(s.name.padEnd(30)) +
+                        chalk.dim(s.slug.padEnd(26)) + scope
                     );
                 });
-                console.log(chalk.dim(`\n  ${list.length} skill(s) loaded into agent context\n`));
+                console.log(chalk.dim(`\n  ${disk.length} skill(s) active in agent context\n`));
                 break;
             }
 
-            // /skill add <id> [--global]
+            // ── /skill add <source> [--global] [--skill <name>] ──
             if (sub === "add" || sub === "install") {
-                const isGlobal = rest.includes("--global");
-                const id       = rest.replace("--global", "").trim();
-                if (!id) { printError("usage: /skill add <owner/repo/slug> [--global]"); break; }
+                const isGlobal    = rest.includes("--global") || rest.includes("-g");
+                const skillMatch  = rest.match(/--skill\s+"?([^"]+)"?/);
+                const skillName   = skillMatch?.[1] ?? null;
+                const all         = rest.includes("--all");
+                const source      = rest
+                    .replace(/--global|-g|--skill\s+"?[^"]*"?|--all/g, "")
+                    .trim();
+
+                if (!source) { printError("usage: /skill add <owner/repo> [--global] [--skill <name>] [--all]"); break; }
+
                 const sp = new Spinner();
-                sp.start(`installing ${id}…`, "#FFD080");
+                sp.start(`npx skills add ${source}…`, "#FFD080");
                 try {
-                    const result = await installSkill(id, isGlobal ? "global" : "project");
-                    sp.succeed(`installed: ${result.name}  →  ${result.dir}`);
-                    printInfo("skill will be active on next message");
+                    const { output } = await installSkill(source, { global: isGlobal, skill: skillName, all });
+                    sp.stop();
+                    if (output) output.split("\n").filter(Boolean).forEach(l => printInfo(l));
+                    printSuccess("skill installed — active on next message");
                 } catch (e) {
-                    sp.fail(e.message);
-                    printError(e.message);
+                    sp.stop();
+                    // Print full npx output so user sees what actually went wrong
+                    e.message.split("\n").filter(Boolean).forEach(l =>
+                        process.stdout.write(chalk.hex("#7A7A9A")("  " + l + "\n"))
+                    );
+                    printError("install failed");
                 }
                 break;
             }
 
-            // /skill remove <slug>
+            // ── /skill remove <slug> ──────────────────────────────
             if (sub === "remove" || sub === "rm") {
-                const slug = rest;
-                if (!slug) { printError("usage: /skill remove <slug>"); break; }
+                if (!rest) { printError("usage: /skill remove <slug>"); break; }
+                const sp = new Spinner();
+                sp.start(`removing ${rest}…`, "#FF9060");
                 try {
-                    const removed = removeSkill(slug);
-                    removed.forEach(r => printSuccess(`removed: ${r}`));
-                } catch (e) { printError(e.message); }
+                    const { output } = await removeSkillNpx(rest);
+                    sp.stop();
+                    if (output) output.split("\n").filter(Boolean).forEach(l => printInfo(l));
+                    printSuccess(`removed: ${rest}`);
+                } catch (e) {
+                    sp.fail(e.message.split("\n")[0]);
+                    printError(e.message.split("\n")[0]);
+                }
                 break;
             }
 
-            // /skill search <query>
-            if (sub === "search") {
-                if (!rest) { printError("usage: /skill search <query>"); break; }
+            // ── /skill find / search <query> ─────────────────────
+            if (sub === "find" || sub === "search") {
+                if (!rest) { printError("usage: /skill find <query>"); break; }
                 const sp = new Spinner();
                 sp.start(`searching "${rest}"…`, "#4A9EFF");
                 try {
-                    const results = await searchSkills(rest, 8);
+                    const output = await findSkills(rest);
                     sp.stop();
-                    if (!results.length) { printInfo("no results found"); break; }
-                    console.log("");
-                    results.forEach(r => {
-                        console.log(
-                            "  " + chalk.hex("#4A9EFF").bold(r.id.padEnd(48)) +
-                            chalk.dim(String(r.installs).padStart(8) + " installs")
-                        );
-                        if (r.name !== r.slug)
-                            console.log("  " + chalk.dim(" ".repeat(2) + r.name));
-                    });
-                    console.log(chalk.dim("\n  install: /skill add <id>\n"));
+                    if (output) {
+                        console.log("");
+                        output.split("\n").forEach(l => console.log("  " + l));
+                        console.log("");
+                    } else {
+                        printInfo("no results — try a different query");
+                    }
                 } catch (e) {
-                    sp.fail(e.message);
-                    printError(e.message);
+                    sp.fail(e.message.split("\n")[0]);
+                    printError(e.message.split("\n")[0]);
                 }
                 break;
             }
 
-            // /skill browse [trending|hot]
-            if (sub === "browse") {
-                const view = rest || "all-time";
-                const sp   = new Spinner();
-                sp.start(`fetching ${view}…`, "#4A9EFF");
+            // ── /skill update [slug] ──────────────────────────────
+            if (sub === "update") {
+                const sp = new Spinner();
+                sp.start(rest ? `updating ${rest}…` : "updating all skills…", "#4A9EFF");
                 try {
-                    const results = await browseSkills(view, 15);
+                    const { output } = await updateSkill(rest);
                     sp.stop();
-                    console.log("");
-                    results.forEach((r, i) => {
-                        console.log(
-                            "  " + chalk.dim(String(i+1).padStart(2) + ".") + " " +
-                            chalk.hex("#4A9EFF").bold(r.id.padEnd(46)) +
-                            chalk.dim(String(r.installs).padStart(8) + " installs")
-                        );
-                    });
-                    console.log(chalk.dim("\n  /skill browse trending  ·  /skill browse hot\n"));
+                    if (output) output.split("\n").filter(Boolean).forEach(l => printInfo(l));
+                    printSuccess("updated");
                 } catch (e) {
-                    sp.fail(e.message);
-                    printError(e.message);
+                    sp.fail(e.message.split("\n")[0]);
+                    printError(e.message.split("\n")[0]);
                 }
                 break;
             }
 
-            // /skill info <id>
-            if (sub === "info") {
-                if (!rest) { printError("usage: /skill info <id>"); break; }
+            // ── /skill init [name] ────────────────────────────────
+            if (sub === "init") {
                 const sp = new Spinner();
-                sp.start(`fetching ${rest}…`, "#4A9EFF");
+                sp.start("creating SKILL.md template…", "#4A9EFF");
                 try {
-                    const { default: ax } = await import("axios");
-                    const { data } = await ax.get(`https://skills.sh/api/v1/skills/${rest}`);
+                    const { output } = await initSkill(rest);
                     sp.stop();
-                    console.log("");
-                    printInfo(`id       ${data.id}`);
-                    printInfo(`source   ${data.source}`);
-                    printInfo(`installs ${data.installs}`);
-                    printInfo(`files    ${data.files?.length ?? 0}`);
-                    if (data.files?.length) {
-                        data.files.forEach(f => console.log(chalk.dim("           " + f.path)));
-                    }
-                    console.log(chalk.dim(`\n  /skill add ${data.id}\n`));
+                    if (output) output.split("\n").filter(Boolean).forEach(l => printInfo(l));
+                    printSuccess("SKILL.md created");
                 } catch (e) {
-                    sp.fail(e.message);
-                    printError(e.message);
+                    sp.fail(e.message.split("\n")[0]);
+                    printError(e.message.split("\n")[0]);
                 }
                 break;
             }
 
-            printInfo("usage: /skill [list | add | remove | search | browse | info]");
+            printInfo("usage: /skill [list | add | remove | find | update | init]");
+            printInfo("       /skill add vercel-labs/agent-skills");
+            printInfo("       /skill add anthropics/skills --skill frontend-design");
+            printInfo("       /skill add owner/repo --global");
             break;
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikyyofc/gemini-cli",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "description": "AI Agent CLI — native function calling · GEMINI.md context · extensions",
   "type": "module",
   "bin": { "gemini": "./index.js" },

package/src/skills.js

@@ -1,218 +1,204 @@
-// src/skills.js — Agent Skills Manager
-// Integrates with skills.sh registry
-// Skills are stored in .agents/ (project) or ~/.gemini/agents/ (global)
+// src/skills.js — Skills manager via npx skills CLI
+// All install/search/list/remove operations delegate to "npx skills"
+// which is the official skills.sh CLI (github.com/vercel-labs/skills)
+//
+// Skills directories (Gemini agent convention from skills.sh):
+//   Project:  ./.gemini/skills/     (committed with project)
+//   Global:   ~/.gemini/skills/     (across all projects)
+//   Custom:   ./.agents/            (manual / local skills)
 import fs   from "fs";
 import path from "path";
 import os   from "os";
-import axios from "axios";
+import { promisify } from "util";
+import { exec }      from "child_process";
 
-const API   = "https://skills.sh/api/v1";
-const GLOBAL_AGENTS_DIR = path.join(os.homedir(), ".gemini", "agents");
+const execAsync = promisify(exec);
 
-// ─────────────────────────────────────────────────────────────────
-//  Resolve skills directories
-//  Priority: .agents/ (project) → ~/.gemini/agents/ (global)
-// ─────────────────────────────────────────────────────────────────
-export function getSkillsDirs() {
-    const dirs = [];
-    const local = path.join(process.cwd(), ".agents");
-    if (fs.existsSync(local)) dirs.push(local);
-    if (fs.existsSync(GLOBAL_AGENTS_DIR)) dirs.push(GLOBAL_AGENTS_DIR);
-    return dirs;
-}
+// Directories where npx skills installs for Gemini agent
+const GLOBAL_SKILLS_DIR  = path.join(os.homedir(), ".gemini", "skills");
+const PROJECT_SKILLS_DIR = () => path.join(process.cwd(), ".gemini", "skills");
+const CUSTOM_SKILLS_DIR  = () => path.join(process.cwd(), ".agents");
 
 export function ensureSkillsDirs() {
-    fs.mkdirSync(GLOBAL_AGENTS_DIR, { recursive: true });
+    fs.mkdirSync(GLOBAL_SKILLS_DIR,  { recursive: true });
 }
 
 // ─────────────────────────────────────────────────────────────────
-//  Load all installed skills — returns array of { name, path, content }
-// ─────────────────────────────────────────────────────────────────
-export function loadSkills() {
-    const skills = [];
-    const seen   = new Set();
-
-    for (const dir of getSkillsDirs()) {
-        if (!fs.existsSync(dir)) continue;
-
-        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-            if (!entry.isDirectory()) continue;
-            const skillDir  = path.join(dir, entry.name);
-            const skillMd   = path.join(skillDir, "SKILL.md");
-            const metaFile  = path.join(skillDir, ".meta.json");
-
-            if (!fs.existsSync(skillMd)) continue;
-            if (seen.has(entry.name)) continue; // project-level takes priority
-            seen.add(entry.name);
-
-            let meta = {};
-            try { meta = JSON.parse(fs.readFileSync(metaFile, "utf8")); } catch {}
-
-            const content = fs.readFileSync(skillMd, "utf8");
-
-            // Also read any supporting files (examples, etc.)
-            const extras = fs.readdirSync(skillDir)
-                .filter(f => f !== "SKILL.md" && f !== ".meta.json" && f.endsWith(".md"))
-                .map(f => fs.readFileSync(path.join(skillDir, f), "utf8"))
-                .join("\n\n");
-
-            skills.push({
-                name:    meta.name  ?? entry.name,
-                slug:    meta.slug  ?? entry.name,
-                source:  meta.source ?? "local",
-                path:    skillDir,
-                content: content + (extras ? "\n\n" + extras : ""),
-                global:  dir === GLOBAL_AGENTS_DIR,
-            });
-        }
+//  Run npx skills with timeout
+// ─────────────────────────────────────────────────────────────────
+async function npxSkills(args, cwd = process.cwd(), timeout = 120_000) {
+    const cmd = `npx --yes skills ${args}`;
+    try {
+        const { stdout, stderr } = await execAsync(cmd, {
+            cwd,
+            timeout,
+            env: { ...process.env, NO_COLOR: "1", CI: "1" },
+        });
+        return { stdout: stdout.trim(), stderr: stderr.trim() };
+    } catch (err) {
+        // Expose actual npx output in the thrown error message
+        const detail = [err.stdout?.trim(), err.stderr?.trim()]
+            .filter(Boolean).join("\n") || err.message;
+        throw new Error(detail);
     }
+}
 
-    return skills;
+// ─────────────────────────────────────────────────────────────────
+//  Parse source: handles "owner/repo@skill-name" shorthand
+//  e.g. "anthropics/skills@frontend-design"
+//       → source="anthropics/skills", skill="frontend-design"
+// ─────────────────────────────────────────────────────────────────
+function parseSource(raw) {
+    const atIdx = raw.indexOf("@");
+    if (atIdx > 0 && !raw.startsWith("http") && !raw.startsWith("git@")) {
+        return {
+            source: raw.slice(0, atIdx),
+            skill:  raw.slice(atIdx + 1),
+        };
+    }
+    return { source: raw, skill: null };
 }
 
 // ─────────────────────────────────────────────────────────────────
-//  Build skills section for system prompt
+//  Install — npx skills add <source> [-y] [--global] [--skill name]
 // ─────────────────────────────────────────────────────────────────
-export function buildSkillsPrompt(skills) {
-    if (!skills.length) return null;
+export async function installSkill(rawSource, opts = {}) {
+    const { global = false, skill: explicitSkill = null, all = false } = opts;
+    const { source, skill: parsedSkill } = parseSource(rawSource);
+    const skillName = explicitSkill ?? parsedSkill;
 
-    const sections = skills.map(s =>
-        `### Skill: ${s.name}\n${s.content.trim()}`
-    ).join("\n\n---\n\n");
+    // Build args — let npx skills auto-detect agent (more reliable than -a gemini)
+    const parts = ["add", source, "-y"];
+    if (global)    parts.push("-g");
+    if (skillName) parts.push(`--skill "${skillName}"`);
+    if (all)       parts.push("--skill '*'");
+
+    const { stdout, stderr } = await npxSkills(parts.join(" "));
+    return { output: stdout || stderr };
+}
 
-    return `## INSTALLED SKILLS\n\nThe following skills provide additional knowledge and capabilities. Apply them when relevant:\n\n${sections}`;
+// ─────────────────────────────────────────────────────────────────
+//  List installed — npx skills list
+// ─────────────────────────────────────────────────────────────────
+export async function listNpxSkills(global = false) {
+    const args  = global ? "list -g" : "list";
+    const { stdout } = await npxSkills(args);
+    return stdout;
 }
 
 // ─────────────────────────────────────────────────────────────────
-//  API helpers
+//  Search — npx skills find <query>
 // ─────────────────────────────────────────────────────────────────
-async function apiFetch(path, params = {}) {
-    const url = `${API}${path}`;
-    const res = await axios.get(url, {
-        params,
-        headers: { "User-Agent": "gemini-cli/2.0" },
-        timeout: 15000,
-    });
-    return res.data;
+export async function findSkills(query) {
+    const { stdout } = await npxSkills(`find ${JSON.stringify(query)}`);
+    return stdout;
 }
 
 // ─────────────────────────────────────────────────────────────────
-//  Search skills
+//  Remove — npx skills remove <slug>
 // ─────────────────────────────────────────────────────────────────
-export async function searchSkills(query, limit = 10) {
-    const data = await apiFetch("/skills/search", { q: query, limit });
-    return data.data ?? [];
+export async function removeSkillNpx(slug) {
+    const { stdout, stderr } = await npxSkills(`remove ${slug} -y`);
+    return { output: stdout || stderr };
 }
 
-export async function browseSkills(view = "all-time", perPage = 20) {
-    const data = await apiFetch("/skills", { view, per_page: perPage });
-    return data.data ?? [];
+// ─────────────────────────────────────────────────────────────────
+//  Update — npx skills update [slug]
+// ─────────────────────────────────────────────────────────────────
+export async function updateSkill(slug = "") {
+    const args = slug ? `update ${slug} -y` : "update -y";
+    const { stdout, stderr } = await npxSkills(args);
+    return { output: stdout || stderr };
 }
 
 // ─────────────────────────────────────────────────────────────────
-//  Fetch skill files from API
-//  id format: "owner/repo/slug"  e.g. "vercel-labs/agent-skills/next-js-development"
+//  Init — npx skills init [name]   (creates a SKILL.md template)
 // ─────────────────────────────────────────────────────────────────
-export async function fetchSkill(id) {
-    const data = await apiFetch(`/skills/${id}`);
-    return data; // { id, slug, name?, files: [{ path, contents }] }
+export async function initSkill(name = "") {
+    const args = name ? `init "${name}"` : "init";
+    const { stdout, stderr } = await npxSkills(args);
+    return { output: stdout || stderr };
 }
 
 // ─────────────────────────────────────────────────────────────────
-//  Install a skill
-//  source: "owner/repo/slug" or just "owner/repo" (installs all)
-//  scope:  "project" | "global"
+//  Load skills for agent context injection
+//  Scans all skill directories and reads SKILL.md files
 // ─────────────────────────────────────────────────────────────────
-export async function installSkill(id, scope = "project") {
-    const skill = await fetchSkill(id);
+export function loadSkills() {
+    const skills = [];
+    const seen   = new Set();
 
-    if (!skill.files?.length) {
-        throw new Error(`Skill "${id}" has no files.`);
-    }
+    const scanDir = (dir, scope) => {
+        if (!fs.existsSync(dir)) return;
+
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory()) continue;
+
+            const skillDir = path.join(dir, entry.name);
+            const skillMd  = path.join(skillDir, "SKILL.md");
+            if (!fs.existsSync(skillMd)) continue;
 
-    const targetDir = scope === "global"
-        ? GLOBAL_AGENTS_DIR
-        : path.join(process.cwd(), ".agents");
+            const key = entry.name;
+            if (seen.has(key)) continue; // project takes priority over global
+            seen.add(key);
 
-    const slug    = skill.slug ?? id.split("/").pop();
-    const skillDir = path.join(targetDir, slug);
-    fs.mkdirSync(skillDir, { recursive: true });
+            const content = fs.readFileSync(skillMd, "utf8");
 
-    // Write all skill files
-    for (const file of skill.files) {
-        const filePath = path.join(skillDir, file.path);
-        fs.mkdirSync(path.dirname(filePath), { recursive: true });
-        fs.writeFileSync(filePath, file.contents ?? "", "utf8");
-    }
+            // Parse optional frontmatter name from SKILL.md
+            const nameMatch = content.match(/^#\s+(.+)$/m);
+            const name      = nameMatch?.[1]?.trim() ?? entry.name;
 
-    // Write metadata
-    fs.writeFileSync(path.join(skillDir, ".meta.json"), JSON.stringify({
-        id:        skill.id,
-        name:      skill.name ?? slug,
-        slug,
-        source:    skill.source,
-        installs:  skill.installs,
-        installedAt: new Date().toISOString(),
-        scope,
-    }, null, 2));
-
-    return { slug, name: skill.name ?? slug, dir: skillDir };
+            skills.push({ name, slug: entry.name, content, scope, path: skillDir });
+        }
+    };
+
+    // Priority: project (.gemini/skills/) > custom (.agents/) > global (~/.gemini/skills/)
+    scanDir(PROJECT_SKILLS_DIR(), "project");
+    scanDir(CUSTOM_SKILLS_DIR(),  "custom");
+    scanDir(GLOBAL_SKILLS_DIR,    "global");
+
+    return skills;
 }
 
 // ─────────────────────────────────────────────────────────────────
-//  Remove a skill
+//  Build skills section injected into agent system prompt
 // ─────────────────────────────────────────────────────────────────
-export function removeSkill(slug, scope = "both") {
-    const removed = [];
-
-    const dirs = scope === "global"
-        ? [GLOBAL_AGENTS_DIR]
-        : scope === "project"
-            ? [path.join(process.cwd(), ".agents")]
-            : [path.join(process.cwd(), ".agents"), GLOBAL_AGENTS_DIR];
+export function buildSkillsPrompt(skills) {
+    if (!skills.length) return null;
 
-    for (const dir of dirs) {
-        const skillDir = path.join(dir, slug);
-        if (fs.existsSync(skillDir)) {
-            fs.rmSync(skillDir, { recursive: true, force: true });
-            removed.push(skillDir);
-        }
-    }
+    const sections = skills.map(s =>
+        `### Skill: ${s.name}\n${s.content.trim()}`
+    ).join("\n\n---\n\n");
 
-    if (!removed.length) throw new Error(`Skill "${slug}" not found.`);
-    return removed;
+    return `## INSTALLED SKILLS\n\nApply the following skills when relevant to the current task:\n\n${sections}`;
 }
 
 // ─────────────────────────────────────────────────────────────────
-//  List installed skills with status
+//  Quick disk check — list installed skills without running npx
 // ─────────────────────────────────────────────────────────────────
 export function listInstalledSkills() {
     const result = [];
 
-    const checkDir = (dir, isGlobal) => {
+    const scanDir = (dir, isGlobal) => {
         if (!fs.existsSync(dir)) return;
         for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
             if (!entry.isDirectory()) continue;
             const skillDir = path.join(dir, entry.name);
-            const metaFile = path.join(skillDir, ".meta.json");
-            const hasSkillMd = fs.existsSync(path.join(skillDir, "SKILL.md"));
-            if (!hasSkillMd) continue;
-
-            let meta = {};
-            try { meta = JSON.parse(fs.readFileSync(metaFile, "utf8")); } catch {}
-
+            if (!fs.existsSync(path.join(skillDir, "SKILL.md"))) continue;
+            const content   = fs.readFileSync(path.join(skillDir, "SKILL.md"), "utf8");
+            const nameMatch = content.match(/^#\s+(.+)$/m);
             result.push({
                 slug:   entry.name,
-                name:   meta.name   ?? entry.name,
-                source: meta.source ?? "local",
+                name:   nameMatch?.[1]?.trim() ?? entry.name,
                 global: isGlobal,
                 dir:    skillDir,
-                installedAt: meta.installedAt ?? null,
             });
         }
     };
 
-    checkDir(path.join(process.cwd(), ".agents"), false);
-    checkDir(GLOBAL_AGENTS_DIR, true);
+    scanDir(PROJECT_SKILLS_DIR(), false);
+    scanDir(CUSTOM_SKILLS_DIR(),  false);
+    scanDir(GLOBAL_SKILLS_DIR,    true);
     return result;
 }