@prave/cli 0.1.0

package/dist/commands/diff.js

@@ -0,0 +1,56 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import { api } from '../lib/api.js';
+import { CONFIG } from '../lib/config.js';
+import { loadCredentials } from '../lib/credentials.js';
+import { log } from '../utils/logger.js';
+/**
+ * `prave diff <slug>` — line-level comparison between the local
+ * ~/.claude/skills/<slug>/SKILL.md and the registry's current
+ * version. We use a tiny LCS-based diff so the CLI stays dep-light.
+ */
+export async function diffCommand(slug) {
+    const localPath = join(CONFIG.skillsDir, slug, 'SKILL.md');
+    let local = '';
+    try {
+        local = await readFile(localPath, 'utf8');
+    }
+    catch {
+        log.warn(`No local Skill at ${localPath} — run \`prave install ${slug}\` first.`);
+        return;
+    }
+    const session = await loadCredentials();
+    const { data: skill } = await api.get(`/api/v1/skills/${encodeURIComponent(slug)}`, Boolean(session));
+    const remote = skill.content ?? '';
+    if (local === remote) {
+        log.success(`${slug} is in sync with the registry.`);
+        return;
+    }
+    console.log(chalk.bold(`--- local  ${localPath}`));
+    console.log(chalk.bold(`+++ remote prave://${slug}`));
+    for (const line of unifiedDiff(local, remote))
+        console.log(line);
+}
+/** Tiny line diff: not a full Myers, but enough to spot drift visually. */
+function unifiedDiff(a, b) {
+    const aLines = a.split('\n');
+    const bLines = b.split('\n');
+    const out = [];
+    const max = Math.max(aLines.length, bLines.length);
+    for (let i = 0; i < max; i++) {
+        const l = aLines[i];
+        const r = bLines[i];
+        if (l === r) {
+            if (l !== undefined)
+                out.push(`  ${l}`);
+        }
+        else {
+            if (l !== undefined)
+                out.push(chalk.red(`- ${l}`));
+            if (r !== undefined)
+                out.push(chalk.green(`+ ${r}`));
+        }
+    }
+    return out;
+}

package/dist/commands/export.js

@@ -0,0 +1,24 @@
+import { writeFile } from 'node:fs/promises';
+import { api } from '../lib/api.js';
+import { loadCredentials } from '../lib/credentials.js';
+import { log } from '../utils/logger.js';
+/**
+ * `prave export <slug>` — print or save a Skill's SKILL.md to disk
+ * without touching ~/.claude/skills/. Useful for CI pipelines that want
+ * to bundle Skills into other repos.
+ */
+export async function exportCommand(slug, opts = {}) {
+    const session = await loadCredentials();
+    const { data: skill } = await api.get(`/api/v1/skills/${encodeURIComponent(slug)}`, Boolean(session));
+    const content = skill.content ?? '';
+    if (!content.trim()) {
+        log.warn(`${slug} has no content`);
+        return;
+    }
+    if (opts.out) {
+        await writeFile(opts.out, content, 'utf8');
+        log.success(`Wrote ${opts.out} (${content.length} bytes)`);
+        return;
+    }
+    process.stdout.write(content);
+}

package/dist/commands/import.js

@@ -0,0 +1,64 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { api } from '../lib/api.js';
+import { CONFIG } from '../lib/config.js';
+import { log } from '../utils/logger.js';
+/**
+ * Scans CONFIG.skillsDir for SKILL.md files. Without --upload, only prints
+ * the overview — no network call, no consent required.
+ */
+export async function importCommand(opts) {
+    const spinner = ora(`Scanning ${CONFIG.skillsDir}…`).start();
+    let entries = [];
+    try {
+        entries = await readdir(CONFIG.skillsDir);
+    }
+    catch {
+        spinner.fail(`Skills directory not found: ${CONFIG.skillsDir}`);
+        return;
+    }
+    const skills = [];
+    for (const name of entries) {
+        const dir = join(CONFIG.skillsDir, name);
+        if (!(await stat(dir).catch(() => null))?.isDirectory())
+            continue;
+        const skillFile = join(dir, 'SKILL.md');
+        try {
+            const content = await readFile(skillFile, 'utf8');
+            const { size } = await stat(skillFile);
+            skills.push({ slug: name, path: skillFile, content, sizeBytes: size });
+        }
+        catch {
+            /* no SKILL.md here */
+        }
+    }
+    spinner.succeed(`Found ${skills.length} local skills.`);
+    for (const s of skills) {
+        console.log(`  ${chalk.cyan('•')} ${s.slug} ${chalk.dim(`(${s.sizeBytes}B)`)}`);
+    }
+    if (!opts.upload) {
+        log.dim('\nRe-run with --upload to push these to your Prave account.');
+        return;
+    }
+    const visibility = opts.private ? 'private' : 'public';
+    const uploadSpinner = ora(`Uploading ${skills.length} skills as ${visibility}…`).start();
+    let ok = 0;
+    for (const s of skills) {
+        try {
+            await api.post('/api/v1/skills', {
+                name: s.slug,
+                slug: s.slug,
+                content: s.content,
+                visibility,
+                license: 'MIT',
+            }, true);
+            ok += 1;
+        }
+        catch (err) {
+            uploadSpinner.warn(`Failed: ${s.slug} — ${err.message}`);
+        }
+    }
+    uploadSpinner.succeed(`Uploaded ${ok}/${skills.length} skills.`);
+}

package/dist/commands/install.js

@@ -0,0 +1,91 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { api, ApiError } from '../lib/api.js';
+import { CONFIG } from '../lib/config.js';
+import { loadCredentials } from '../lib/credentials.js';
+import { log } from '../utils/logger.js';
+/**
+ * `prave install <slug>` — pulls SKILL.md to ~/.claude/skills/<slug>/.
+ *
+ *   • Resolves the dependency tree by default and installs each leaf
+ *     before the parent (deepest first). `--no-deps` skips this.
+ *   • Records an `installs` row server-side when a session is present
+ *     so the dashboard "Installs" tab + trending sort stay accurate.
+ *   • Detects paywall errors (402) early and prints a friendly hint
+ *     instead of letting the API error bubble.
+ */
+export async function installCommand(slug, opts = {}) {
+    const spinner = ora(`Resolving ${slug}…`).start();
+    try {
+        const slugs = opts.noDeps ? [slug] : await resolveOrder(slug);
+        spinner.text = `Installing ${slugs.length} skill${slugs.length === 1 ? '' : 's'}…`;
+        const session = await loadCredentials();
+        for (const s of slugs) {
+            spinner.text = `↓ ${s}`;
+            await pullOne(s, { hasSession: Boolean(session), force: Boolean(opts.force) });
+        }
+        spinner.succeed(`Installed ${slugs.length} skill${slugs.length === 1 ? '' : 's'} → ${CONFIG.skillsDir}`);
+        if (slugs.length > 1) {
+            log.dim(`   chain: ${slugs.join(' → ')}`);
+        }
+    }
+    catch (err) {
+        spinner.fail(formatError(err));
+        process.exitCode = 1;
+    }
+}
+async function pullOne(slug, ctx) {
+    const { data: skill } = await api.get(`/api/v1/skills/${encodeURIComponent(slug)}`, ctx.hasSession);
+    if (skill.price_cents > 0 && skill.purchased === false && skill.is_owner === false) {
+        throw new ApiError(`${chalk.bold(skill.slug)} is paid (${formatPrice(skill.price_cents, skill.currency)}). Buy it on prave.app first.`, 402);
+    }
+    if (!skill.content && !ctx.force) {
+        throw new ApiError(`${skill.slug} has no SKILL.md content yet`, 400);
+    }
+    const targetDir = join(CONFIG.skillsDir, skill.slug);
+    await mkdir(targetDir, { recursive: true });
+    await writeFile(join(targetDir, 'SKILL.md'), skill.content ?? '', 'utf8');
+    if (ctx.hasSession) {
+        await api
+            .post(`/api/v1/skills/${encodeURIComponent(skill.slug)}/install`, {}, true)
+            .catch(() => { });
+    }
+}
+async function resolveOrder(rootSlug) {
+    const session = await loadCredentials();
+    let tree = null;
+    try {
+        const res = await api.get(`/api/v1/skills/${encodeURIComponent(rootSlug)}/dependencies/tree`, Boolean(session));
+        tree = res.data;
+    }
+    catch {
+        return [rootSlug];
+    }
+    if (!tree?.nodes.length)
+        return [rootSlug];
+    if (tree.conflicts.length) {
+        log.warn(`${tree.conflicts.length} dependency conflict(s) — installing latest available`);
+    }
+    const ordered = tree.nodes
+        .filter((n) => !n.missing)
+        .sort((a, b) => b.depth - a.depth)
+        .map((n) => n.slug);
+    const seen = new Set();
+    const out = [];
+    for (const s of ordered)
+        if (!seen.has(s))
+            (seen.add(s), out.push(s));
+    if (!out.includes(rootSlug))
+        out.push(rootSlug);
+    return out;
+}
+function formatPrice(cents, currency) {
+    return `${(cents / 100).toFixed(2)} ${currency}`;
+}
+function formatError(err) {
+    if (err instanceof ApiError)
+        return err.message;
+    return err instanceof Error ? err.message : 'Install failed';
+}

package/dist/commands/list.js

@@ -0,0 +1,34 @@
+import { readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import { api } from '../lib/api.js';
+import { CONFIG } from '../lib/config.js';
+import { log } from '../utils/logger.js';
+export async function listCommand(opts) {
+    if (opts.remote) {
+        const { data: skills } = await api.get('/api/v1/skills?limit=50', true);
+        if (skills.length === 0) {
+            log.dim('No skills in your Prave account yet.');
+            return;
+        }
+        for (const s of skills) {
+            console.log(`  ${chalk.cyan('•')} ${s.slug} ${chalk.dim(`(${s.visibility})`)}`);
+        }
+        return;
+    }
+    try {
+        const entries = await readdir(CONFIG.skillsDir);
+        let count = 0;
+        for (const name of entries) {
+            const dir = join(CONFIG.skillsDir, name);
+            if ((await stat(dir).catch(() => null))?.isDirectory()) {
+                console.log(`  ${chalk.cyan('•')} ${name}`);
+                count += 1;
+            }
+        }
+        log.dim(`\n${count} local skill${count === 1 ? '' : 's'} in ${CONFIG.skillsDir}`);
+    }
+    catch {
+        log.warn(`No skills directory at ${CONFIG.skillsDir}`);
+    }
+}

package/dist/commands/login.js

@@ -0,0 +1,47 @@
+import { setTimeout as sleep } from 'node:timers/promises';
+import open from 'open';
+import ora from 'ora';
+import { api, ApiError } from '../lib/api.js';
+import { CONFIG } from '../lib/config.js';
+import { saveCredentials } from '../lib/credentials.js';
+import { log } from '../utils/logger.js';
+/**
+ * `prave login` — device-code flow against the Prave API / Supabase session.
+ */
+export async function loginCommand() {
+    const { data: start } = await api.post('/api/v1/cli/login');
+    const url = `${CONFIG.webUrl}${start.verification_url}`;
+    log.info('Opening browser to authorize this device…');
+    log.dim(url);
+    try {
+        await open(url);
+    }
+    catch {
+        log.warn('Could not auto-open browser. Open the URL above manually.');
+    }
+    const spinner = ora('Waiting for authorization…').start();
+    const deadline = Date.now() + CONFIG.pollTimeoutMs;
+    while (Date.now() < deadline) {
+        await sleep(CONFIG.pollIntervalMs);
+        try {
+            const { data, status } = await api.get(`/api/v1/cli/token?device_code=${start.device_code}`);
+            if (status === 202)
+                continue;
+            await saveCredentials({
+                access_token: data.access_token,
+                refresh_token: data.refresh_token,
+                user_id: data.user_id,
+            });
+            spinner.succeed('Logged in.');
+            return;
+        }
+        catch (err) {
+            if (err instanceof ApiError && err.status === 410) {
+                spinner.fail('Device code expired. Run `prave login` again.');
+                return;
+            }
+            // Any other error: keep polling until the deadline.
+        }
+    }
+    spinner.fail('Authorization timed out.');
+}

package/dist/commands/logout.js

@@ -0,0 +1,6 @@
+import { clearCredentials } from '../lib/credentials.js';
+import { log } from '../utils/logger.js';
+export async function logoutCommand() {
+    await clearCredentials();
+    log.success('Logged out.');
+}

package/dist/commands/search.js

@@ -0,0 +1,13 @@
+import chalk from 'chalk';
+import { api } from '../lib/api.js';
+import { log } from '../utils/logger.js';
+export async function searchCommand(query) {
+    const { data: skills } = await api.get(`/api/v1/skills?q=${encodeURIComponent(query)}&limit=25`);
+    if (skills.length === 0) {
+        log.dim(`No skills match "${query}".`);
+        return;
+    }
+    for (const s of skills) {
+        console.log(`  ${chalk.cyan('•')} ${s.slug}  ${chalk.dim(s.description ?? '')}  ${chalk.magenta(`↓ ${s.install_count}`)}`);
+    }
+}

package/dist/commands/sync.js

@@ -0,0 +1,48 @@
+import { readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { CONFIG } from '../lib/config.js';
+import { log } from '../utils/logger.js';
+import { installCommand } from './install.js';
+/**
+ * `prave sync` — re-pulls every locally installed Skill from the
+ * registry. Picks up SKILL.md edits without the user having to remember
+ * each slug. Skips deps (each top-level Skill already has its tree
+ * resolved on the original install).
+ */
+export async function syncCommand() {
+    const spinner = ora('Scanning local Skills…').start();
+    let entries = [];
+    try {
+        entries = await readdir(CONFIG.skillsDir);
+    }
+    catch {
+        spinner.warn(`No Skills directory at ${CONFIG.skillsDir}`);
+        return;
+    }
+    const slugs = [];
+    for (const name of entries) {
+        const dir = join(CONFIG.skillsDir, name);
+        if ((await stat(dir).catch(() => null))?.isDirectory())
+            slugs.push(name);
+    }
+    if (!slugs.length) {
+        spinner.warn('No installed Skills to sync.');
+        return;
+    }
+    spinner.succeed(`Found ${slugs.length} installed Skill${slugs.length === 1 ? '' : 's'}.`);
+    let updated = 0;
+    let failed = 0;
+    for (const slug of slugs) {
+        try {
+            await installCommand(slug, { noDeps: true });
+            updated++;
+        }
+        catch {
+            failed++;
+            console.log(chalk.red(`  ✗ ${slug}`));
+        }
+    }
+    log.dim(`\nSynced ${updated} · failed ${failed}`);
+}

package/dist/commands/uninstall.js

@@ -0,0 +1,21 @@
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import ora from 'ora';
+import { CONFIG } from '../lib/config.js';
+/**
+ * `prave uninstall <slug>` — removes ~/.claude/skills/<slug> recursively.
+ * No remote call: uninstalls are local-only; the install record stays
+ * for analytics + history.
+ */
+export async function uninstallCommand(slug) {
+    const dir = join(CONFIG.skillsDir, slug);
+    const spinner = ora(`Removing ${slug}…`).start();
+    try {
+        await rm(dir, { recursive: true, force: true });
+        spinner.succeed(`Removed ${dir}`);
+    }
+    catch (err) {
+        spinner.fail(`Couldn’t remove ${slug}: ${err.message}`);
+        process.exitCode = 1;
+    }
+}

package/dist/commands/whoami.js

@@ -0,0 +1,13 @@
+import { loadCredentials } from '../lib/credentials.js';
+import { log } from '../utils/logger.js';
+export async function whoamiCommand() {
+    const creds = await loadCredentials();
+    if (!creds) {
+        log.warn('Not logged in. Run `prave login`.');
+        process.exitCode = 1;
+        return;
+    }
+    log.kv('user_id', creds.user_id);
+    if (creds.email)
+        log.kv('email', creds.email);
+}

package/dist/index.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { diffCommand } from './commands/diff.js';
+import { exportCommand } from './commands/export.js';
+import { importCommand } from './commands/import.js';
+import { installCommand } from './commands/install.js';
+import { listCommand } from './commands/list.js';
+import { loginCommand } from './commands/login.js';
+import { logoutCommand } from './commands/logout.js';
+import { searchCommand } from './commands/search.js';
+import { syncCommand } from './commands/sync.js';
+import { uninstallCommand } from './commands/uninstall.js';
+import { whoamiCommand } from './commands/whoami.js';
+const program = new Command()
+    .name('prave')
+    .description('Prave — Developer platform for Claude Skills')
+    .version('0.1.0');
+program.command('login').description('Authenticate this machine').action(loginCommand);
+program.command('logout').description('Remove stored credentials').action(logoutCommand);
+program.command('whoami').description('Show the signed-in user').action(whoamiCommand);
+program
+    .command('import')
+    .description('Scan ~/.claude/skills/ — optionally upload to Prave')
+    .option('--upload', 'upload scanned skills')
+    .option('--private', 'upload as private (requires --upload)')
+    .action(importCommand);
+program
+    .command('install <slug>')
+    .description('Install a Skill into ~/.claude/skills/ (resolves deps)')
+    .option('--no-deps', 'skip transitive dependency resolution')
+    .option('--force', 'install even if SKILL.md is empty')
+    .action(installCommand);
+program
+    .command('uninstall <slug>')
+    .description('Remove a locally installed Skill')
+    .action(uninstallCommand);
+program
+    .command('sync')
+    .description('Pull updates for every locally installed Skill')
+    .action(syncCommand);
+program
+    .command('list')
+    .description('List installed Skills (default) or remote ones')
+    .option('--remote', 'list Skills from your Prave account')
+    .action(listCommand);
+program.command('search <query>').description('Search public Skills').action(searchCommand);
+program
+    .command('export <slug>')
+    .description('Print or save a Skill\'s SKILL.md without installing')
+    .option('-o, --out <file>', 'write to file instead of stdout')
+    .action(exportCommand);
+program
+    .command('diff <slug>')
+    .description('Show local vs registry diff for an installed Skill')
+    .action(diffCommand);
+program.parseAsync().catch((err) => {
+    console.error(err.message);
+    process.exit(1);
+});

package/dist/lib/api.js

@@ -0,0 +1,39 @@
+import { request } from 'undici';
+import { CONFIG } from './config.js';
+import { loadCredentials } from './credentials.js';
+export class ApiError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = 'ApiError';
+    }
+}
+async function call(method, path, body, withAuth = false) {
+    const headers = { 'Content-Type': 'application/json' };
+    if (withAuth) {
+        const creds = await loadCredentials();
+        if (!creds)
+            throw new ApiError('Not logged in. Run `prave login`.', 401);
+        headers.Authorization = `Bearer ${creds.access_token}`;
+    }
+    const { statusCode, body: resBody } = await request(`${CONFIG.apiUrl}${path}`, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    const text = await resBody.text();
+    if (statusCode === 204)
+        return { data: undefined, status: statusCode };
+    const payload = text ? JSON.parse(text) : { success: true, data: null, error: null };
+    if (statusCode >= 400 || payload.success === false) {
+        throw new ApiError(payload.error ?? `HTTP ${statusCode}`, statusCode);
+    }
+    return { data: payload.data, status: statusCode };
+}
+export const api = {
+    get: (path, withAuth = false) => call('GET', path, undefined, withAuth),
+    post: (path, body, withAuth = false) => call('POST', path, body, withAuth),
+    put: (path, body, withAuth = false) => call('PUT', path, body, withAuth),
+    del: (path, withAuth = false) => call('DELETE', path, undefined, withAuth),
+};

package/dist/lib/config.js

@@ -0,0 +1,12 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export const CONFIG = {
+    apiUrl: process.env.PRAVE_API_URL ?? 'https://api.prave.app',
+    webUrl: process.env.PRAVE_WEB_URL ?? 'https://prave.app',
+    skillsDir: process.env.CLAUDE_SKILLS_DIR ?? join(homedir(), '.claude', 'skills'),
+    praveDir: join(homedir(), '.prave'),
+    credentialsPath: join(homedir(), '.prave', 'credentials.json'),
+    configPath: join(homedir(), '.prave', 'config.json'),
+    pollIntervalMs: 2_000,
+    pollTimeoutMs: 10 * 60_000,
+};

package/dist/lib/credentials.js

@@ -0,0 +1,25 @@
+import { chmod, mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { CONFIG } from './config.js';
+export async function saveCredentials(creds) {
+    await mkdir(dirname(CONFIG.credentialsPath), { recursive: true });
+    await writeFile(CONFIG.credentialsPath, JSON.stringify(creds, null, 2), 'utf8');
+    await chmod(CONFIG.credentialsPath, 0o600);
+}
+export async function loadCredentials() {
+    try {
+        const raw = await readFile(CONFIG.credentialsPath, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function clearCredentials() {
+    try {
+        await unlink(CONFIG.credentialsPath);
+    }
+    catch {
+        /* already gone */
+    }
+}

package/dist/utils/logger.js

@@ -0,0 +1,9 @@
+import chalk from 'chalk';
+export const log = {
+    info: (msg) => console.log(msg),
+    success: (msg) => console.log(chalk.green('✓'), msg),
+    warn: (msg) => console.log(chalk.yellow('!'), msg),
+    error: (msg) => console.error(chalk.red('✗'), msg),
+    dim: (msg) => console.log(chalk.dim(msg)),
+    kv: (k, v) => console.log(chalk.dim(`${k.padEnd(14)}`), v),
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@prave/cli",
+  "version": "0.1.0",
+  "description": "Prave CLI — import, export, install, sync Claude Skills.",
+  "type": "module",
+  "bin": {
+    "prave": "dist/index.js"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "open": "^10.1.0",
+    "ora": "^8.0.1",
+    "undici": "^6.18.0",
+    "@prave/shared": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.7",
+    "tsx": "^4.11.0",
+    "typescript": "^5.4.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts --help",
+    "cli": "tsx src/index.ts",
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "tsc -p tsconfig.json --noEmit"
+  }
+}