@agentskill.sh/cli 1.0.9 → 2.0.1

package/dist/installer.js

@@ -0,0 +1,145 @@
+import { writeFileSync, mkdirSync, symlinkSync, copyFileSync, readdirSync, statSync } from 'fs';
+import { join, dirname } from 'path';
+import { agents } from './agents.js';
+/**
+ * Sanitize a skill name into a filesystem-safe slug.
+ * Strips @owner/ prefix, lowercases, replaces non-alphanumeric with hyphens.
+ */
+export function sanitizeName(name) {
+    return name
+        .replace(/^@[^/]+\//, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+/**
+ * Resolve the target directory for a skill given an agent and scope.
+ */
+function resolveSkillDir(agentType, slug, global) {
+    const config = agents[agentType];
+    if (!config)
+        throw new Error(`Unknown agent: ${agentType}`);
+    const baseDir = global ? config.globalSkillsDir : join(process.cwd(), config.skillsDir);
+    return join(baseDir, sanitizeName(slug));
+}
+/**
+ * Write SKILL.md and supporting files to a target directory.
+ */
+function writeSkillFiles(targetDir, skillData) {
+    mkdirSync(targetDir, { recursive: true });
+    writeFileSync(join(targetDir, 'SKILL.md'), skillData.skillMd, 'utf-8');
+    const written = ['SKILL.md'];
+    if (skillData.skillFiles?.length) {
+        for (const file of skillData.skillFiles) {
+            if (file.path && file.content) {
+                const filePath = join(targetDir, file.path);
+                mkdirSync(dirname(filePath), { recursive: true });
+                writeFileSync(filePath, file.content, 'utf-8');
+                written.push(file.path);
+            }
+        }
+    }
+    return written;
+}
+/**
+ * Recursively copy all files from source to target directory.
+ */
+function copyDir(sourceDir, targetDir) {
+    mkdirSync(targetDir, { recursive: true });
+    for (const entry of readdirSync(sourceDir)) {
+        const src = join(sourceDir, entry);
+        const dst = join(targetDir, entry);
+        if (statSync(src).isDirectory()) {
+            copyDir(src, dst);
+        }
+        else {
+            copyFileSync(src, dst);
+        }
+    }
+}
+/**
+ * Install a skill to a single agent directory.
+ * Returns the path where the skill was installed.
+ */
+export function installSkillToAgent(skillData, agentType, options = {}) {
+    const dir = resolveSkillDir(agentType, skillData.slug, options.global ?? false);
+    try {
+        const files = writeSkillFiles(dir, skillData);
+        return { agent: agentType, dir, files, success: true };
+    }
+    catch (err) {
+        return {
+            agent: agentType,
+            dir,
+            files: [],
+            success: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+/**
+ * Install a skill to multiple agents.
+ *
+ * Strategy:
+ *   1. First agent gets the canonical (full) copy of all files.
+ *   2. Remaining agents get a directory symlink pointing to the canonical copy.
+ *   3. If symlink creation fails (permissions, cross-device, Windows), falls back to a full copy.
+ *
+ * Set options.mode = 'copy' to skip symlinks entirely.
+ */
+export function installToAgents(skillData, agentTypes, options = {}) {
+    if (agentTypes.length === 0) {
+        throw new Error('At least one agent must be specified');
+    }
+    const mode = options.mode ?? 'symlink';
+    const results = [];
+    // First agent: canonical full copy
+    const canonical = installSkillToAgent(skillData, agentTypes[0], options);
+    results.push(canonical);
+    if (!canonical.success)
+        return results;
+    // Remaining agents: symlink or copy
+    for (let i = 1; i < agentTypes.length; i++) {
+        const agentType = agentTypes[i];
+        const targetDir = resolveSkillDir(agentType, skillData.slug, options.global ?? false);
+        if (mode === 'symlink') {
+            try {
+                mkdirSync(dirname(targetDir), { recursive: true });
+                symlinkSync(canonical.dir, targetDir);
+                results.push({
+                    agent: agentType,
+                    dir: targetDir,
+                    files: canonical.files,
+                    success: true,
+                });
+            }
+            catch {
+                // Symlink failed, fall back to full copy
+                try {
+                    copyDir(canonical.dir, targetDir);
+                    results.push({
+                        agent: agentType,
+                        dir: targetDir,
+                        files: canonical.files,
+                        success: true,
+                    });
+                }
+                catch (err) {
+                    results.push({
+                        agent: agentType,
+                        dir: targetDir,
+                        files: [],
+                        success: false,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+        }
+        else {
+            // Copy mode: write full copy for each agent
+            results.push(installSkillToAgent(skillData, agentType, options));
+        }
+    }
+    return results;
+}

package/dist/skill-lock.d.ts

@@ -0,0 +1,19 @@
+import type { SkillLockFile } from './types.js';
+export declare const LOCK_VERSION = 1;
+/**
+ * Resolve the path to .skill-lock.json.
+ * Uses XDG_STATE_HOME if set, otherwise falls back to ~/.agents/.skill-lock.json.
+ */
+export declare function getLockPath(): string;
+/** Read and parse the lock file. Returns an empty lock if the file is missing or corrupt. */
+export declare function readLock(): SkillLockFile;
+/** Write the lock file to disk (creates parent directories if needed). */
+export declare function writeLock(lock: SkillLockFile): void;
+/** Add or update a skill entry in the lock file. */
+export declare function addToLock(slug: string, contentSha: string, agents: string[]): void;
+/** Remove a skill entry from the lock file. */
+export declare function removeFromLock(slug: string): void;
+/** Get the last saved agent selection (for remembering user choice across runs). */
+export declare function getLastSelectedAgents(): string[];
+/** Save the current agent selection to the lock file. */
+export declare function saveSelectedAgents(agents: string[]): void;

package/dist/skill-lock.js

@@ -0,0 +1,63 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+export const LOCK_VERSION = 1;
+/**
+ * Resolve the path to .skill-lock.json.
+ * Uses XDG_STATE_HOME if set, otherwise falls back to ~/.agents/.skill-lock.json.
+ */
+export function getLockPath() {
+    const stateHome = process.env.XDG_STATE_HOME;
+    if (stateHome) {
+        return join(stateHome, 'agentskill', '.skill-lock.json');
+    }
+    return join(homedir(), '.agents', '.skill-lock.json');
+}
+/** Read and parse the lock file. Returns an empty lock if the file is missing or corrupt. */
+export function readLock() {
+    const lockPath = getLockPath();
+    if (!existsSync(lockPath)) {
+        return { version: LOCK_VERSION, skills: {} };
+    }
+    try {
+        const raw = readFileSync(lockPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return { version: LOCK_VERSION, skills: {} };
+    }
+}
+/** Write the lock file to disk (creates parent directories if needed). */
+export function writeLock(lock) {
+    const lockPath = getLockPath();
+    mkdirSync(dirname(lockPath), { recursive: true });
+    writeFileSync(lockPath, JSON.stringify(lock, null, 2) + '\n', 'utf-8');
+}
+/** Add or update a skill entry in the lock file. */
+export function addToLock(slug, contentSha, agents) {
+    const lock = readLock();
+    lock.skills[slug] = {
+        slug,
+        contentSha,
+        installedAt: new Date().toISOString(),
+        agents,
+    };
+    writeLock(lock);
+}
+/** Remove a skill entry from the lock file. */
+export function removeFromLock(slug) {
+    const lock = readLock();
+    delete lock.skills[slug];
+    writeLock(lock);
+}
+/** Get the last saved agent selection (for remembering user choice across runs). */
+export function getLastSelectedAgents() {
+    const lock = readLock();
+    return lock.lastSelectedAgents ?? [];
+}
+/** Save the current agent selection to the lock file. */
+export function saveSelectedAgents(agents) {
+    const lock = readLock();
+    lock.lastSelectedAgents = agents;
+    writeLock(lock);
+}

package/dist/types.d.ts

@@ -0,0 +1,58 @@
+export interface AgentConfig {
+    name: string;
+    displayName: string;
+    /** Project-level skill directory (relative to cwd) */
+    skillsDir: string;
+    /** Global skill directory (absolute path) */
+    globalSkillsDir: string;
+    /** Whether to show in the universal agents list */
+    showInUniversalList?: boolean;
+    /** Detect if this agent is installed on the machine */
+    detectInstalled: () => Promise<boolean>;
+}
+export type AgentType = string;
+export interface SearchResult {
+    slug: string;
+    name: string;
+    owner: string;
+    description: string;
+    installCount: number;
+    securityScore: number | null;
+    contentQualityScore: number | null;
+}
+export interface SearchResponse {
+    results: SearchResult[];
+    total: number;
+    hasMore: boolean;
+}
+export interface InstallResponse {
+    slug: string;
+    name: string;
+    owner: string;
+    description: string;
+    skillMd: string;
+    skillFiles: {
+        path: string;
+        content: string;
+    }[];
+    skillFolder: string;
+    installPath: string;
+    contentSha: string | null;
+    securityScore: number | null;
+    contentQualityScore: number | null;
+    score: number;
+    ratingCount: number;
+    installCount: number;
+}
+export interface SkillLockEntry {
+    slug: string;
+    contentSha: string;
+    installedAt: string;
+    agents: string[];
+}
+export interface SkillLockFile {
+    version: number;
+    skills: Record<string, SkillLockEntry>;
+    lastSelectedAgents?: string[];
+}
+export type InstallMode = 'symlink' | 'copy';

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui.d.ts

@@ -0,0 +1,17 @@
+export declare const ORANGE: (str: string) => string;
+export declare const DIM: import("picocolors/types").Formatter;
+export declare const TEXT: (str: string) => string;
+export declare const BOLD: import("picocolors/types").Formatter;
+export declare const GREEN: import("picocolors/types").Formatter;
+export declare const LOGO: string;
+export declare function showLogo(): void;
+export declare function showBanner(): void;
+/**
+ * Truncate a string to a max length, appending ellipsis if needed.
+ * Ignores ANSI escape codes when measuring length.
+ */
+export declare function truncate(str: string, max: number): string;
+/**
+ * Pad a string to a target width, ignoring ANSI escape codes.
+ */
+export declare function padEnd(str: string, width: number): string;

package/dist/ui.js

@@ -0,0 +1,82 @@
+import pc from 'picocolors';
+// Brand orange: #E8613C approximated as 256-color (208 is closest)
+// picocolors doesn't support 256-color directly, so we use ANSI escape
+const ORANGE_CODE = '\x1b[38;5;208m';
+const RESET = '\x1b[0m';
+export const ORANGE = (str) => `${ORANGE_CODE}${str}${RESET}`;
+export const DIM = pc.dim;
+export const TEXT = (str) => str;
+export const BOLD = pc.bold;
+export const GREEN = pc.green;
+// Gradient grays from bright to dim for the ASCII logo
+const g1 = (s) => `\x1b[38;5;255m${s}${RESET}`; // brightest white
+const g2 = (s) => `\x1b[38;5;250m${s}${RESET}`;
+const g3 = (s) => `\x1b[38;5;245m${s}${RESET}`;
+const g4 = (s) => `\x1b[38;5;240m${s}${RESET}`;
+const g5 = (s) => `\x1b[38;5;236m${s}${RESET}`; // dimmest
+export const LOGO = [
+    g1('   ▄▀▄ ▄▀▀ ▄▀▀'),
+    g2('   █▀█ █ █ ▀▀█') + '   ' + DIM('agentskill.sh'),
+    g3('   ▀ ▀  ▀▀ ▀▀▀'),
+].join('\n');
+export function showLogo() {
+    console.log();
+    console.log(LOGO);
+    console.log();
+}
+export function showBanner() {
+    showLogo();
+    console.log(`  ${DIM('The package manager for AI agent skills')}`);
+    console.log();
+    console.log(`  ${BOLD('Commands:')}`);
+    console.log(`    ${ORANGE('search')} ${DIM('<query>')}        Search for skills`);
+    console.log(`    ${ORANGE('install')} ${DIM('<slug>')}        Install a skill`);
+    console.log(`    ${ORANGE('setup')}                 Install official skills`);
+    console.log(`    ${ORANGE('find')}                  Browse and discover skills`);
+    console.log(`    ${ORANGE('list')}                  Show installed skills`);
+    console.log(`    ${ORANGE('remove')} ${DIM('<slug>')}         Uninstall a skill`);
+    console.log(`    ${ORANGE('feedback')} ${DIM('<slug> <1-5>')} Rate a skill`);
+    console.log(`    ${ORANGE('update')}                Update installed skills`);
+    console.log();
+    console.log(`  ${DIM('Run')} npx @agentskill.sh/cli ${DIM('<command> for more info')}`);
+    console.log();
+}
+/**
+ * Truncate a string to a max length, appending ellipsis if needed.
+ * Ignores ANSI escape codes when measuring length.
+ */
+export function truncate(str, max) {
+    const stripped = stripAnsi(str);
+    if (stripped.length <= max)
+        return str;
+    // Walk the original string, counting only visible characters
+    let visible = 0;
+    let i = 0;
+    while (i < str.length && visible < max - 1) {
+        if (str[i] === '\x1b') {
+            // Skip ANSI escape sequence
+            const end = str.indexOf('m', i);
+            if (end !== -1) {
+                i = end + 1;
+                continue;
+            }
+        }
+        visible++;
+        i++;
+    }
+    return str.slice(0, i) + '\u2026';
+}
+/**
+ * Pad a string to a target width, ignoring ANSI escape codes.
+ */
+export function padEnd(str, width) {
+    const visibleLength = stripAnsi(str).length;
+    if (visibleLength >= width)
+        return str;
+    return str + ' '.repeat(width - visibleLength);
+}
+/** Strip ANSI escape codes from a string */
+function stripAnsi(str) {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\x1b\[[0-9;]*m/g, '');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentskill.sh/cli",
-  "version": "1.0.9",
+  "version": "2.0.1",
   "description": "Agent Skill CLI. Search, install, review, and manage AI agent skills from agentskill.sh.",
   "type": "module",
   "bin": {
@@ -40,5 +40,9 @@
   "devDependencies": {
     "@types/node": "^22.0.0",
     "typescript": "^5.7.0"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.2.0",
+    "picocolors": "^1.1.1"
   }
 }