@prave/cli 0.2.1 → 0.3.3

package/dist/commands/conflicts.js

@@ -0,0 +1,50 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { api, ApiError } from '../lib/api.js';
+import { log } from '../utils/logger.js';
+function describe(c) {
+    const a = c.skill_a_name ?? c.skill_a_id;
+    const b = c.skill_b_name ?? c.skill_b_id;
+    switch (c.conflict_type) {
+        case 'trigger_overlap':
+            return `Both trigger on ${chalk.bold(a)} ↔ ${chalk.bold(b)}${c.conflict_detail ? chalk.dim(' — ' + c.conflict_detail) : ''}`;
+        case 'auto_invocation_collision':
+            return `Both auto-invoke ${chalk.bold(a)} ↔ ${chalk.bold(b)}${c.conflict_detail ? chalk.dim(' — ' + c.conflict_detail) : ''}`;
+        case 'dependency_conflict':
+            return `Requires ${chalk.bold(a)} but missing — ${chalk.bold(b)}${c.conflict_detail ? chalk.dim(' — ' + c.conflict_detail) : ''}`;
+        default:
+            return `${a} ↔ ${b}`;
+    }
+}
+export async function conflictsCommand(opts = {}) {
+    const spinner = ora('Detecting conflicts…').start();
+    try {
+        const { data: conflicts } = await api.get('/api/v1/intelligence/conflicts?refresh=true', true);
+        spinner.stop();
+        if (conflicts.length === 0) {
+            // Pull skill count for the empty state.
+            let total = 0;
+            try {
+                const { data: skills } = await api.get('/api/v1/intelligence/skills', true);
+                total = skills.length;
+            }
+            catch {
+                /* best-effort */
+            }
+            console.log(chalk.green(`✓ No conflicts detected in your ${total} skills.`));
+            return;
+        }
+        for (const c of conflicts) {
+            console.log(`${chalk.yellow('⚠️ ')} ${describe(c)}`);
+        }
+        if (opts.fix) {
+            console.log();
+            log.dim('Interactive fix coming soon — for now run `prave whatdoes <skill>` and adjust frontmatter manually.');
+        }
+    }
+    catch (err) {
+        spinner.stop();
+        log.error(err instanceof ApiError ? err.message : err.message);
+        process.exitCode = 1;
+    }
+}

package/dist/commands/deploy.js

@@ -0,0 +1,141 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { AGENT_REGISTRY } from '@prave/shared';
+import { api, ApiError } from '../lib/api.js';
+import { CONFIG } from '../lib/config.js';
+import { log } from '../utils/logger.js';
+function detectOsKey(detected) {
+    if (detected === 'windows')
+        return 'windows';
+    // mac + linux both use POSIX paths under "mac" in the registry.
+    return 'mac';
+}
+function expandHome(p, os) {
+    if (os === 'windows')
+        return p;
+    if (p.startsWith('~')) {
+        return join(homedir(), p.slice(1).replace(/^[\\/]/, ''));
+    }
+    return p;
+}
+async function readLocalSkill(slug) {
+    const path = join(CONFIG.skillsDir, slug, 'SKILL.md');
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+async function fetchRemoteSkill(slug) {
+    const { data } = await api.get(`/api/v1/skills/${encodeURIComponent(slug)}`, true);
+    if (!data.content) {
+        throw new ApiError(`Remote skill "${slug}" has no content.`, 404);
+    }
+    return data.content;
+}
+function describeContentForCursor(content, slug) {
+    // Has frontmatter? best-effort rename triggers: → globs:
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n?/);
+    if (fmMatch && fmMatch[1] !== undefined) {
+        const body = content.slice(fmMatch[0].length);
+        const fmInner = fmMatch[1].replace(/(^|\n)triggers:/g, '$1globs:');
+        return `---\n${fmInner}\n---\n${body}`;
+    }
+    // No frontmatter — synthesize
+    const trimmed = content.trim().replace(/\s+/g, ' ').slice(0, 200);
+    return `---\nname: ${slug}\ndescription: ${trimmed}\n---\n${content}`;
+}
+function buildDestPath(agent, basePath, os, slug) {
+    const expanded = expandHome(basePath, os);
+    if (agent === 'cursor') {
+        // .cursor/rules/<slug>.mdc — the basePath already points at .cursor/rules
+        return {
+            dir: expanded,
+            file: join(expanded, `${slug}.mdc`),
+            converted: true,
+            display: `${basePath.replace(/[\\/]+$/, '')}/${slug}.mdc`,
+        };
+    }
+    return {
+        dir: join(expanded, slug),
+        file: join(expanded, slug, 'SKILL.md'),
+        converted: false,
+        display: `${basePath.replace(/[\\/]+$/, '')}/${slug}/SKILL.md`,
+    };
+}
+export async function deployCommand(skillName, opts = {}) {
+    const start = Date.now();
+    let settings;
+    try {
+        const { data } = await api.get('/api/v1/settings/agents', true);
+        settings = data;
+    }
+    catch (err) {
+        log.error(err instanceof ApiError ? err.message : err.message);
+        process.exitCode = 1;
+        return;
+    }
+    const targetFilter = opts.agent && opts.agent.toLowerCase() !== 'all'
+        ? opts.agent.toLowerCase()
+        : null;
+    const targets = settings.enabled_agents.filter((a) => targetFilter === null || a === targetFilter);
+    if (targets.length === 0) {
+        log.warn('No matching agents enabled. Run `prave settings` to configure.');
+        return;
+    }
+    // Load source content (local first, fall back to remote).
+    let source = await readLocalSkill(skillName);
+    if (!source) {
+        try {
+            source = await fetchRemoteSkill(skillName);
+        }
+        catch (err) {
+            log.error(err instanceof ApiError ? err.message : err.message);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    const os = detectOsKey(settings.detected_os);
+    console.log(`Deploying "${chalk.bold(skillName)}" to ${targets.length} agent${targets.length === 1 ? '' : 's'}${opts.dryRun ? chalk.dim(' (dry-run)') : ''}…`);
+    const spinner = ora('Writing files…').start();
+    let okCount = 0;
+    for (const agent of targets) {
+        const meta = AGENT_REGISTRY[agent];
+        const paths = settings.skill_paths[agent] ?? meta.defaultPath;
+        const basePath = os === 'windows' ? paths.windows : paths.mac;
+        const dest = buildDestPath(agent, basePath, os, skillName);
+        const content = dest.converted
+            ? describeContentForCursor(source, skillName)
+            : source;
+        spinner.text = `→ ${meta.label}`;
+        if (opts.dryRun) {
+            okCount += 1;
+            continue;
+        }
+        try {
+            await mkdir(dest.dir, { recursive: true });
+            await writeFile(dest.file, content, 'utf8');
+            okCount += 1;
+        }
+        catch (err) {
+            spinner.warn(`Failed: ${meta.label} — ${err.message}`);
+        }
+    }
+    spinner.stop();
+    for (const agent of targets) {
+        const meta = AGENT_REGISTRY[agent];
+        const paths = settings.skill_paths[agent] ?? meta.defaultPath;
+        const basePath = os === 'windows' ? paths.windows : paths.mac;
+        const dest = buildDestPath(agent, basePath, os, skillName);
+        const tag = dest.converted ? chalk.dim(' (converted)') : '';
+        console.log(`${chalk.green('✓')} ${meta.label.padEnd(14)} → ${dest.display}${tag}`);
+    }
+    const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+    console.log(opts.dryRun
+        ? chalk.dim(`Dry-run complete in ${elapsed}s — ${okCount} agents would receive the skill.`)
+        : chalk.dim(`Deployed in ${elapsed}s`));
+}

package/dist/commands/find.js

@@ -0,0 +1,82 @@
+import { createInterface } from 'node:readline/promises';
+import chalk from 'chalk';
+import ora from 'ora';
+import { tokenTier } from '@prave/shared';
+import { api, ApiError } from '../lib/api.js';
+import { log } from '../utils/logger.js';
+const TIER_EMOJI = {
+    lean: '🟢',
+    medium: '🟡',
+    heavy: '🔴',
+};
+function formatTokens(n) {
+    if (n < 1000)
+        return `~${n}`;
+    return `~${(n / 1000).toFixed(1)}k`;
+}
+function renderResult(r, idx) {
+    const badge = r.source === 'local'
+        ? chalk.cyan('[local]')
+        : chalk.magenta('[marketplace]');
+    const tier = TIER_EMOJI[tokenTier(r.estimated_tokens)];
+    const slash = r.slash_command ? chalk.dim(` ${r.slash_command}`) : '';
+    const installs = r.source === 'marketplace' && typeof r.install_count === 'number'
+        ? chalk.dim(` · ${r.install_count} installs`)
+        : '';
+    console.log(`${chalk.bold(`${idx + 1}.`)} ${badge} ${chalk.bold(r.name)}${slash}  ${tier} ${chalk.dim(formatTokens(r.estimated_tokens))}${installs}`);
+    if (r.description)
+        log.dim(`   ${r.description}`);
+}
+export async function findCommand(query, opts = {}) {
+    const scope = opts.local
+        ? 'local'
+        : opts.marketplace
+            ? 'marketplace'
+            : 'both';
+    const spinner = ora(opts.smart ? 'Smart-searching…' : 'Searching…').start();
+    try {
+        let results;
+        if (opts.smart) {
+            const { data } = await api.post('/api/v1/intelligence/llm-search', { query }, true);
+            spinner.stop();
+            console.log(chalk.dim(`Task: ${data.task}`));
+            if (data.suggested_triggers.length > 0) {
+                log.dim(`Suggested triggers: ${data.suggested_triggers.join(', ')}`);
+            }
+            console.log();
+            results = data.results;
+        }
+        else {
+            const { data } = await api.post('/api/v1/intelligence/search', { query, scope }, true);
+            spinner.stop();
+            results = data;
+        }
+        if (results.length === 0) {
+            log.dim('No matches.');
+            return;
+        }
+        const top = results.slice(0, 5);
+        top.forEach((r, i) => renderResult(r, i));
+        if (opts.local)
+            return; // skip prompt when local-only
+        const installable = top.find((r) => r.source === 'marketplace' && !r.is_installed);
+        if (!installable)
+            return;
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            const answer = (await rl.question(`\nInstall ${chalk.bold(installable.slug)}? [y/N] `)).trim().toLowerCase();
+            if (answer === 'y' || answer === 'yes') {
+                const { installCommand } = await import('./install.js');
+                await installCommand(installable.slug, {});
+            }
+        }
+        finally {
+            rl.close();
+        }
+    }
+    catch (err) {
+        spinner.stop();
+        log.error(err instanceof ApiError ? err.message : err.message);
+        process.exitCode = 1;
+    }
+}

package/dist/commands/import.js

@@ -4,6 +4,7 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { api } from '../lib/api.js';
 import { CONFIG } from '../lib/config.js';
+import { loadCredentials } from '../lib/credentials.js';
 import { fetchMyPlan, formatUpgradeHint } from '../lib/plan.js';
 import { log } from '../utils/logger.js';
 /**
@@ -40,7 +41,19 @@ export async function importCommand(opts) {
         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.');
+        const creds = await loadCredentials();
+        if (creds && skills.length > 0) {
+            const analyzeSpinner = ora(`Analyzing ${skills.length} skills…`).start();
+            for (const s of skills) {
+                await api
+                    .post('/api/v1/intelligence/analyze', { content: s.content, file_path: s.path, agent_type: 'claude' }, true)
+                    .catch(() => { });
+            }
+            analyzeSpinner.succeed(`✓ Imported ${skills.length} skills. Run \`prave overview\` to see your full analysis.`);
+        }
+        else {
+            log.dim('\nRe-run with --upload to push these to your Prave account.');
+        }
         return;
     }
     // Plan gate: clamp the queue to the caller's import / private quota so
@@ -105,4 +118,12 @@ export async function importCommand(opts) {
     uploadSpinner.succeed(tail);
     if (gated > 0)
         log.dim(formatUpgradeHint('explorer'));
+    // Always analyze after upload — best effort, never blocks the user.
+    const analyzeSpinner = ora(`Analyzing ${queue.length} skills…`).start();
+    for (const s of queue) {
+        await api
+            .post('/api/v1/intelligence/analyze', { content: s.content, file_path: s.path, agent_type: 'claude' }, true)
+            .catch(() => { });
+    }
+    analyzeSpinner.succeed(`✓ Imported ${queue.length} skills. Run \`prave overview\` to see your full analysis.`);
 }

package/dist/commands/install.js

@@ -1,5 +1,6 @@
-import { mkdir, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { createInterface } from 'node:readline/promises';
 import chalk from 'chalk';
 import ora from 'ora';
 import { api, ApiError } from '../lib/api.js';
@@ -18,6 +19,7 @@ import { log } from '../utils/logger.js';
  */
 export async function installCommand(slug, opts = {}) {
     const spinner = ora(`Resolving ${slug}…`).start();
+    let installedSlugs = [];
     try {
         const slugs = opts.noDeps ? [slug] : await resolveOrder(slug);
         spinner.text = `Installing ${slugs.length} skill${slugs.length === 1 ? '' : 's'}…`;
@@ -26,6 +28,7 @@ export async function installCommand(slug, opts = {}) {
             spinner.text = `↓ ${s}`;
             await pullOne(s, { hasSession: Boolean(session), force: Boolean(opts.force) });
         }
+        installedSlugs = slugs;
         spinner.succeed(`Installed ${slugs.length} skill${slugs.length === 1 ? '' : 's'} → ${CONFIG.skillsDir}`);
         if (slugs.length > 1) {
             log.dim(`   chain: ${slugs.join(' → ')}`);
@@ -34,6 +37,35 @@ export async function installCommand(slug, opts = {}) {
     catch (err) {
         spinner.fail(formatError(err));
         process.exitCode = 1;
+        return;
+    }
+    const session = await loadCredentials();
+    if (!session)
+        return;
+    // Best-effort analyze pass on the freshly written files.
+    for (const s of installedSlugs) {
+        const path = join(CONFIG.skillsDir, s, 'SKILL.md');
+        try {
+            const content = await readFile(path, 'utf8');
+            await api
+                .post('/api/v1/intelligence/analyze', { content, file_path: path, agent_type: 'claude' }, true)
+                .catch(() => { });
+        }
+        catch {
+            /* file unreadable — skip */
+        }
+    }
+    // Offer to deploy to all configured agents.
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const ans = (await rl.question('\nDeploy to all configured agents? [y/N] ')).trim().toLowerCase();
+        if (ans === 'y' || ans === 'yes') {
+            const { deployCommand } = await import('./deploy.js');
+            await deployCommand(slug, {});
+        }
+    }
+    finally {
+        rl.close();
     }
 }
 async function pullOne(slug, ctx) {

package/dist/commands/list.js

@@ -1,10 +1,44 @@
 import { readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import chalk from 'chalk';
+import { tokenTier } from '@prave/shared';
 import { api } from '../lib/api.js';
 import { CONFIG } from '../lib/config.js';
 import { log } from '../utils/logger.js';
-export async function listCommand(opts) {
+const TIER_EMOJI = {
+    lean: '🟢',
+    medium: '🟡',
+    heavy: '🔴',
+};
+const AGENT_ICON = {
+    claude: '🤖',
+    codex: '🧪',
+    cursor: '🟪',
+    gemini: '✦',
+    cline: '🛠',
+    amp: '⚡',
+};
+function formatTokens(n) {
+    if (n < 1000)
+        return `~${n}`;
+    return `~${(n / 1000).toFixed(1)}k`;
+}
+async function readLocalSlugs() {
+    try {
+        const entries = await readdir(CONFIG.skillsDir);
+        const out = [];
+        for (const name of entries) {
+            const dir = join(CONFIG.skillsDir, name);
+            if ((await stat(dir).catch(() => null))?.isDirectory())
+                out.push(name);
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+export async function listCommand(opts = {}) {
     if (opts.remote) {
         const { data: skills } = await api.get('/api/v1/skills?limit=50', true);
         if (skills.length === 0) {
@@ -16,19 +50,82 @@ export async function listCommand(opts) {
         }
         return;
     }
+    const enriched = opts.verbose || opts.conflicts || opts.heavy;
+    const localSlugs = await readLocalSlugs();
+    if (!enriched) {
+        if (localSlugs.length === 0) {
+            log.warn(`No skills directory at ${CONFIG.skillsDir}`);
+            return;
+        }
+        for (const name of localSlugs) {
+            console.log(`  ${chalk.cyan('•')} ${name}`);
+        }
+        log.dim(`\n${localSlugs.length} local skill${localSlugs.length === 1 ? '' : 's'} in ${CONFIG.skillsDir}`);
+        return;
+    }
+    // Enriched path — pull intelligence and merge by slug (best-effort).
+    let metadata = [];
     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;
+        const { data } = await api.get('/api/v1/intelligence/skills', true);
+        metadata = data;
+    }
+    catch (err) {
+        log.warn(`Could not fetch intelligence — ${err.message}`);
+    }
+    const bySlug = new Map();
+    for (const m of metadata) {
+        const slug = m.name ?? deriveSlug(m.file_path);
+        if (slug && !bySlug.has(slug))
+            bySlug.set(slug, m);
+    }
+    let conflictSlugs = null;
+    if (opts.conflicts) {
+        try {
+            const { data: cs } = await api.get('/api/v1/intelligence/conflicts', true);
+            conflictSlugs = new Set();
+            const idToSlug = new Map();
+            for (const [slug, m] of bySlug)
+                idToSlug.set(m.id, slug);
+            for (const c of cs) {
+                const a = idToSlug.get(c.skill_a_id) ?? c.skill_a_name;
+                const b = idToSlug.get(c.skill_b_id) ?? c.skill_b_name;
+                if (a)
+                    conflictSlugs.add(a);
+                if (b)
+                    conflictSlugs.add(b);
             }
         }
-        log.dim(`\n${count} local skill${count === 1 ? '' : 's'} in ${CONFIG.skillsDir}`);
+        catch (err) {
+            log.warn(`Could not fetch conflicts — ${err.message}`);
+        }
     }
-    catch {
-        log.warn(`No skills directory at ${CONFIG.skillsDir}`);
+    const merged = localSlugs.map((slug) => ({ slug, meta: bySlug.get(slug) ?? null }));
+    let rows = merged;
+    if (opts.heavy) {
+        rows = rows.filter((r) => (r.meta?.estimated_tokens ?? 0) > 5000);
+    }
+    if (opts.conflicts && conflictSlugs) {
+        rows = rows.filter((r) => conflictSlugs.has(r.slug));
+    }
+    if (rows.length === 0) {
+        log.dim('No matching skills.');
+        return;
     }
+    for (const r of rows) {
+        if (!r.meta) {
+            console.log(`  ${chalk.cyan('•')} ${r.slug} ${chalk.dim('— no metadata yet')}`);
+            continue;
+        }
+        const slash = r.meta.slash_command ? chalk.dim(` ${r.meta.slash_command}`) : '';
+        const tier = TIER_EMOJI[tokenTier(r.meta.estimated_tokens)];
+        const agentIcon = AGENT_ICON[r.meta.agent_type] ?? '•';
+        console.log(`  ${chalk.cyan('•')} ${chalk.bold(r.slug)}${slash}  ${chalk.dim(formatTokens(r.meta.estimated_tokens))} ${tier}  [${agentIcon}]`);
+    }
+}
+function deriveSlug(filePath) {
+    const parts = filePath.split(/[\\/]/).filter(Boolean);
+    // .../<slug>/SKILL.md
+    if (parts.length >= 2)
+        return parts[parts.length - 2] ?? null;
+    return null;
 }

package/dist/commands/optimize.js

@@ -0,0 +1,60 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { api, ApiError } from '../lib/api.js';
+import { log } from '../utils/logger.js';
+function formatTokens(n) {
+    if (n < 1000)
+        return `~${n}`;
+    return `~${(n / 1000).toFixed(1)}k`;
+}
+function nameOf(s) {
+    return s.name ?? s.file_path;
+}
+export async function optimizeCommand(opts = {}) {
+    const spinner = ora('Analyzing your skill set…').start();
+    try {
+        const { data } = await api.get('/api/v1/intelligence/optimize', true);
+        spinner.stop();
+        console.log(chalk.bold('Underused (last 30 days)'));
+        if (data.underused.length === 0) {
+            log.dim('  (none)');
+        }
+        else {
+            for (const s of data.underused) {
+                console.log(`  ${chalk.cyan('•')} ${nameOf(s)} ${chalk.dim(formatTokens(s.estimated_tokens))}`);
+            }
+        }
+        console.log();
+        console.log(chalk.bold('Merge candidates'));
+        if (data.merge_candidates.length === 0) {
+            log.dim('  (none)');
+        }
+        else {
+            for (const m of data.merge_candidates) {
+                console.log(`  ${chalk.cyan('•')} ${nameOf(m.a)} ${chalk.dim('+')} ${nameOf(m.b)}`);
+                log.dim(`    ${m.reason}`);
+            }
+        }
+        console.log();
+        console.log(chalk.bold('Heavy skills (>5k tokens)'));
+        if (data.heavy.length === 0) {
+            log.dim('  (none)');
+        }
+        else {
+            for (const s of data.heavy) {
+                console.log(`  ${chalk.cyan('•')} ${nameOf(s)} ${chalk.dim(formatTokens(s.estimated_tokens))}`);
+            }
+        }
+        console.log();
+        console.log(chalk.bold(`Total estimated savings: ${formatTokens(data.total_savings_estimate_tokens)} tokens / session`));
+        if (opts.apply) {
+            console.log();
+            log.dim('Auto-apply not yet available — review the suggestions and adjust manually.');
+        }
+    }
+    catch (err) {
+        spinner.stop();
+        log.error(err instanceof ApiError ? err.message : err.message);
+        process.exitCode = 1;
+    }
+}

package/dist/commands/overview.js

@@ -0,0 +1,68 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { api, ApiError } from '../lib/api.js';
+import { log } from '../utils/logger.js';
+function formatThousands(n) {
+    if (n < 1000)
+        return `~${n}`;
+    return `~${Math.round(n / 1000)}k`;
+}
+function pad(s, width) {
+    if (s.length >= width)
+        return s;
+    return s + ' '.repeat(width - s.length);
+}
+export async function overviewCommand(opts = {}) {
+    if (opts.json) {
+        try {
+            const { data } = await api.get('/api/v1/intelligence/overview', true);
+            process.stdout.write(JSON.stringify(data, null, 2) + '\n');
+        }
+        catch (err) {
+            process.stdout.write(JSON.stringify({ error: err instanceof Error ? err.message : 'unknown' }) + '\n');
+            process.exitCode = 1;
+        }
+        return;
+    }
+    const spinner = ora('Fetching skill overview…').start();
+    try {
+        const { data: overview } = await api.get('/api/v1/intelligence/overview', true);
+        spinner.stop();
+        const inner = 38;
+        const top = '╔' + '═'.repeat(inner) + '╗';
+        const sep = '╠' + '═'.repeat(inner) + '╣';
+        const bottom = '╚' + '═'.repeat(inner) + '╝';
+        const row = (label, value, tail = '') => {
+            const body = `  ${pad(label, 18)}${pad(value, 14)}${tail}`;
+            return '║' + pad(body, inner) + '║';
+        };
+        const title = '║' + pad('  Prave Skill Overview', inner) + '║';
+        console.log(top);
+        console.log(title);
+        console.log(sep);
+        console.log(row('Total Skills:', String(overview.total_skills)));
+        console.log(row('Auto-trigger:', String(overview.auto_trigger_count)));
+        console.log(row('User-invocable:', String(overview.user_invocable_count)));
+        console.log(row('Est. total tokens:', formatThousands(overview.total_estimated_tokens)));
+        console.log(row('Conflicts found:', String(overview.conflict_count), overview.conflict_count > 0 ? chalk.yellow(' ⚠️') : ''));
+        console.log(bottom);
+        console.log();
+        log.dim('Run "prave conflicts" to see details.');
+        log.dim('Run "prave optimize" for recommendations.');
+        if (opts.agent) {
+            const target = opts.agent.toLowerCase();
+            const { data: skills } = await api.get('/api/v1/intelligence/skills', true);
+            const filtered = skills.filter((s) => s.agent_type === target);
+            console.log();
+            console.log(chalk.bold(`Skills for agent "${target}": ${filtered.length}`));
+            for (const s of filtered) {
+                console.log(`  ${chalk.cyan('•')} ${s.name ?? '(unnamed)'} ${chalk.dim(s.file_path)}`);
+            }
+        }
+    }
+    catch (err) {
+        spinner.stop();
+        log.error(err instanceof ApiError ? err.message : err.message);
+        process.exitCode = 1;
+    }
+}

package/dist/commands/settings.js

@@ -0,0 +1,177 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { createInterface } from 'node:readline/promises';
+import chalk from 'chalk';
+import { AGENT_REGISTRY, AGENT_TYPES } from '@prave/shared';
+import { api, ApiError } from '../lib/api.js';
+import { CONFIG } from '../lib/config.js';
+import { log } from '../utils/logger.js';
+function detectOs() {
+    if (process.platform === 'darwin')
+        return 'mac';
+    if (process.platform === 'win32')
+        return 'windows';
+    return 'linux';
+}
+async function loadLocalConfig() {
+    try {
+        const raw = await readFile(CONFIG.configPath, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+async function saveLocalConfig(settings) {
+    await mkdir(CONFIG.praveDir, { recursive: true });
+    const existing = await loadLocalConfig();
+    const next = { ...existing, agentSettings: settings };
+    await writeFile(CONFIG.configPath, JSON.stringify(next, null, 2), 'utf8');
+}
+async function fetchSettings() {
+    const { data } = await api.get('/api/v1/settings/agents', true);
+    return data;
+}
+async function patchSettings(patch) {
+    const { data } = await api.put('/api/v1/settings/agents', patch, true);
+    return data;
+}
+function isAgentType(s) {
+    return AGENT_TYPES.includes(s);
+}
+async function configureAgents(rl, current) {
+    console.log();
+    console.log(chalk.bold('Available agents:'));
+    for (const id of AGENT_TYPES) {
+        const meta = AGENT_REGISTRY[id];
+        const enabled = current.enabled_agents.includes(id) ? chalk.green('✓') : ' ';
+        console.log(`  ${enabled} ${chalk.cyan(meta.id.padEnd(8))} ${meta.label} ${chalk.dim('— ' + meta.description)}`);
+    }
+    const answer = (await rl.question(`\nEnter comma-separated agents to enable (default: ${current.enabled_agents.join(',') || 'claude'}): `)).trim();
+    let enabled = current.enabled_agents;
+    if (answer) {
+        const tokens = answer
+            .split(',')
+            .map((t) => t.trim().toLowerCase())
+            .filter(Boolean);
+        const invalid = tokens.filter((t) => !isAgentType(t));
+        if (invalid.length > 0) {
+            log.warn(`Unknown agents skipped: ${invalid.join(', ')}`);
+        }
+        enabled = tokens.filter(isAgentType);
+        if (enabled.length === 0) {
+            log.warn('No valid agents selected — keeping previous selection.');
+            return current;
+        }
+    }
+    const updated = await patchSettings({ enabled_agents: enabled });
+    await saveLocalConfig(updated);
+    log.success(`Enabled agents: ${updated.enabled_agents.join(', ')}`);
+    return updated;
+}
+async function configurePaths(rl, current) {
+    console.log();
+    console.log(chalk.bold('Skill paths (press enter to keep current):'));
+    const skill_paths = {};
+    for (const id of current.enabled_agents) {
+        const meta = AGENT_REGISTRY[id];
+        const existing = current.skill_paths[id] ?? meta.defaultPath;
+        console.log();
+        console.log(chalk.cyan(meta.label) + chalk.dim(` (${id})`));
+        const macAns = (await rl.question(`  mac     [${existing.mac}]: `)).trim();
+        const winAns = (await rl.question(`  windows [${existing.windows}]: `)).trim();
+        const next = {};
+        if (macAns)
+            next.mac = macAns;
+        if (winAns)
+            next.windows = winAns;
+        if (next.mac || next.windows) {
+            skill_paths[id] = next;
+        }
+    }
+    if (!skill_paths || Object.keys(skill_paths).length === 0) {
+        log.dim('No path changes.');
+        return current;
+    }
+    const updated = await patchSettings({ skill_paths });
+    await saveLocalConfig(updated);
+    log.success('Skill paths saved.');
+    return updated;
+}
+async function configureOs(rl, current) {
+    console.log();
+    const detected = detectOs();
+    console.log(`Detected OS: ${chalk.cyan(detected)}`);
+    console.log(`Current setting: ${chalk.cyan(current.detected_os ?? '(unset)')}`);
+    const ans = (await rl.question('Override OS [mac/windows/linux] (enter to keep): ')).trim().toLowerCase();
+    let target = detected;
+    if (ans === '') {
+        if (current.detected_os)
+            return current;
+        target = detected;
+    }
+    else if (ans === 'mac' || ans === 'windows' || ans === 'linux') {
+        target = ans;
+    }
+    else {
+        log.warn('Invalid OS — keeping current.');
+        return current;
+    }
+    const updated = await patchSettings({ detected_os: target });
+    await saveLocalConfig(updated);
+    log.success(`OS set to ${updated.detected_os}`);
+    return updated;
+}
+async function showAccount() {
+    console.log();
+    log.dim('Account info:');
+    log.dim(`  API: ${CONFIG.apiUrl}`);
+    log.dim(`  Credentials: ${CONFIG.credentialsPath}`);
+    log.dim(`  Local config: ${CONFIG.configPath}`);
+    log.dim('Run `prave whoami` for full identity, or `prave logout` to sign out.');
+}
+export async function settingsCommand() {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        let current;
+        try {
+            current = await fetchSettings();
+        }
+        catch (err) {
+            log.error(err instanceof ApiError ? err.message : err.message);
+            process.exitCode = 1;
+            return;
+        }
+        while (true) {
+            console.log();
+            console.log(chalk.bold('Prave Settings'));
+            console.log(`  ${chalk.cyan('1)')} Agent Configuration`);
+            console.log(`  ${chalk.cyan('2)')} Skill Paths`);
+            console.log(`  ${chalk.cyan('3)')} OS Settings`);
+            console.log(`  ${chalk.cyan('4)')} Account`);
+            console.log(`  ${chalk.cyan('5)')} Exit`);
+            const ans = (await rl.question('\nChoose [1-5]: ')).trim();
+            try {
+                if (ans === '1')
+                    current = await configureAgents(rl, current);
+                else if (ans === '2')
+                    current = await configurePaths(rl, current);
+                else if (ans === '3')
+                    current = await configureOs(rl, current);
+                else if (ans === '4')
+                    await showAccount();
+                else if (ans === '5' || ans === '' || ans.toLowerCase() === 'exit') {
+                    break;
+                }
+                else {
+                    log.warn('Unknown choice.');
+                }
+            }
+            catch (err) {
+                log.error(err instanceof ApiError ? err.message : err.message);
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/commands/whatdoes.js

@@ -0,0 +1,78 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { tokenTier } from '@prave/shared';
+import { api, ApiError } from '../lib/api.js';
+import { log } from '../utils/logger.js';
+const TIER_BADGE = {
+    lean: chalk.green('🟢 Lean'),
+    medium: chalk.yellow('🟡 Medium'),
+    heavy: chalk.red('🔴 Heavy'),
+};
+const RULE = '─────────────────────────────────────────';
+function formatTokens(n) {
+    if (n < 1000)
+        return `~${n}`;
+    return `~${(n / 1000).toFixed(1)}k`;
+}
+export async function whatdoesCommand(skillName) {
+    const spinner = ora(`Looking up ${skillName}…`).start();
+    try {
+        const { data } = await api.get(`/api/v1/intelligence/whatdoes/${encodeURIComponent(skillName)}`, true);
+        spinner.stop();
+        if (!data.found) {
+            log.warn('Skill not found.');
+            if (data.similar && data.similar.length > 0) {
+                log.dim('Did you mean:');
+                for (const s of data.similar) {
+                    console.log(`  ${chalk.cyan('•')} ${s.slug} ${chalk.dim(`— ${s.name}`)}`);
+                }
+            }
+            process.exitCode = 1;
+            return;
+        }
+        if (data.source === 'marketplace' && data.marketplace) {
+            const m = data.marketplace;
+            console.log(chalk.dim(RULE));
+            console.log(`📋 ${chalk.bold(m.name)} ${chalk.dim('— ' + (m.description ?? ''))}`);
+            console.log(chalk.dim(RULE));
+            console.log(`⭐ Rating:        ${m.rating ?? 'n/a'}`);
+            console.log(`📦 Installs:      ${m.install_count}`);
+            console.log(`🔖 Slug:          ${m.slug}`);
+            console.log(chalk.dim(RULE));
+            log.dim(`Run \`prave install ${m.slug}\` to install`);
+            return;
+        }
+        const meta = data.metadata;
+        if (!meta) {
+            log.warn('No metadata available for this skill.');
+            return;
+        }
+        const triggers = meta.triggers.length > 0
+            ? meta.triggers.map((t) => `"${t}"`).join(', ')
+            : 'none';
+        const tier = tokenTier(meta.estimated_tokens);
+        const userInvocable = meta.user_invocable
+            ? `Yes ${meta.slash_command ? chalk.dim(`(${meta.slash_command})`) : ''}`
+            : 'No';
+        const requires = meta.requires.length > 0 ? meta.requires.join(', ') : 'none';
+        const conflicts = data.conflicts.length > 0
+            ? data.conflicts
+                .map((c) => c.conflict_detail ?? c.conflict_type)
+                .join('; ')
+            : 'None detected';
+        console.log(chalk.dim(RULE));
+        console.log(`📋 ${chalk.bold(meta.name ?? skillName)} ${chalk.dim('— ' + (meta.description ?? ''))}`);
+        console.log(chalk.dim(RULE));
+        console.log(`🔥 Auto-triggers: ${triggers}`);
+        console.log(`👤 User-invocable: ${userInvocable}`);
+        console.log(`⚡ Est. tokens:   ${formatTokens(meta.estimated_tokens)}  ${TIER_BADGE[tier]}`);
+        console.log(`🔗 Requires:      ${requires}`);
+        console.log(`${data.conflicts.length > 0 ? chalk.yellow('⚠️ ') : '⚠️ '}Conflicts:     ${conflicts}`);
+        console.log(chalk.dim(RULE));
+    }
+    catch (err) {
+        spinner.stop();
+        log.error(err instanceof ApiError ? err.message : err.message);
+        process.exitCode = 1;
+    }
+}

package/dist/index.js

@@ -3,16 +3,23 @@ import { readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Command } from 'commander';
+import { conflictsCommand } from './commands/conflicts.js';
+import { deployCommand } from './commands/deploy.js';
 import { diffCommand } from './commands/diff.js';
 import { exportCommand } from './commands/export.js';
+import { findCommand } from './commands/find.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 { optimizeCommand } from './commands/optimize.js';
+import { overviewCommand } from './commands/overview.js';
 import { searchCommand } from './commands/search.js';
+import { settingsCommand } from './commands/settings.js';
 import { syncCommand } from './commands/sync.js';
 import { uninstallCommand } from './commands/uninstall.js';
+import { whatdoesCommand } from './commands/whatdoes.js';
 import { whoamiCommand } from './commands/whoami.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(resolve(__dirname, '..', 'package.json'), 'utf8'));
@@ -47,6 +54,9 @@ program
     .command('list')
     .description('List installed Skills (default) or remote ones')
     .option('--remote', 'list Skills from your Prave account')
+    .option('--verbose', 'show enriched intelligence (tokens, tier, agents)')
+    .option('--conflicts', 'only show skills involved in conflicts')
+    .option('--heavy', 'only show skills with >5k estimated tokens')
     .action(listCommand);
 program.command('search <query>').description('Search public Skills').action(searchCommand);
 program
@@ -58,6 +68,43 @@ program
     .command('diff <slug>')
     .description('Show local vs registry diff for an installed Skill')
     .action(diffCommand);
+program
+    .command('settings')
+    .description('Configure agent paths + enabled agents')
+    .action(settingsCommand);
+program
+    .command('whatdoes <skillname>')
+    .description("Inspect a skill's triggers, tokens, conflicts")
+    .action(whatdoesCommand);
+program
+    .command('overview')
+    .description('Summary of your skill set, conflicts, and token cost')
+    .option('--json', 'emit raw JSON for scripting')
+    .option('--agent <name>', 'filter the breakdown by agent')
+    .action(overviewCommand);
+program
+    .command('conflicts')
+    .description('Detect overlap, collisions, and missing dependencies')
+    .option('--fix', 'placeholder for interactive fix flow')
+    .action(conflictsCommand);
+program
+    .command('optimize')
+    .description('Recommendations: underused, mergeable, and heavy skills')
+    .option('--apply', 'placeholder for auto-apply')
+    .action(optimizeCommand);
+program
+    .command('find <query>')
+    .description('Smart skill search across local and marketplace')
+    .option('--local', 'only search local skills')
+    .option('--marketplace', 'only search the marketplace')
+    .option('--smart', 'use the LLM-assisted search endpoint')
+    .action(findCommand);
+program
+    .command('deploy <skillname>')
+    .description('Deploy a skill to one or all configured agents')
+    .option('--agent <agent>', 'target a single agent (default: all)')
+    .option('--dry-run', 'log destinations but write no files')
+    .action(deployCommand);
 program.parseAsync().catch((err) => {
     console.error(err.message);
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prave/cli",
-  "version": "0.2.1",
+  "version": "0.3.3",
   "description": "Prave CLI — import, export, install, sync Claude Skills.",
   "type": "module",
   "bin": {