@spences10/pi-skills 0.0.8 → 0.0.9

package/dist/index.js

@@ -1,722 +1,3 @@
-import { show_picker_modal, show_settings_modal, show_text_modal, } from '@spences10/pi-tui-modal';
-import { create_skills_manager, } from './manager.js';
 export { create_skills_manager } from './manager.js';
-const ENABLED = '● enabled';
-const DISABLED = '○ disabled';
-const SYNC = '↻ sync';
-const IMPORTED_LABEL = '✓ imported';
-function sort_skills(skills) {
-    return [...skills].sort((a, b) => {
-        const by_name = a.name.localeCompare(b.name);
-        if (by_name !== 0)
-            return by_name;
-        const by_source = a.source.localeCompare(b.source);
-        if (by_source !== 0)
-            return by_source;
-        return a.key.localeCompare(b.key);
-    });
-}
-function find_matching_imported_skill(managed_skills, skill) {
-    const exact_match = managed_skills.find((candidate) => candidate.import_meta?.source === skill.source &&
-        (candidate.import_meta.upstream_skill_path ===
-            skill.skillPath ||
-            candidate.import_meta.upstream_base_dir === skill.baseDir));
-    if (exact_match)
-        return exact_match;
-    return managed_skills.find((candidate) => candidate.import_meta?.source === skill.source &&
-        candidate.name === skill.name);
-}
-function get_importable_state(managed_skills, skill) {
-    const imported = find_matching_imported_skill(managed_skills, skill);
-    if (imported?.import_meta) {
-        const version_changed = Boolean(skill.plugin?.version &&
-            imported.import_meta.upstream_version &&
-            skill.plugin.version !== imported.import_meta.upstream_version);
-        const sha_changed = Boolean(skill.plugin?.gitCommitSha &&
-            imported.import_meta.upstream_git_commit_sha &&
-            skill.plugin.gitCommitSha !==
-                imported.import_meta.upstream_git_commit_sha);
-        if (version_changed || sha_changed) {
-            return {
-                label: 'sync',
-                detail: 'Press Enter to sync the imported copy and reload',
-                action: 'sync',
-            };
-        }
-        return {
-            label: 'imported',
-            detail: `Already imported to ${imported.baseDir}`,
-            action: null,
-        };
-    }
-    const managed_conflict = managed_skills.find((candidate) => candidate.name === skill.name);
-    if (managed_conflict) {
-        return {
-            label: 'managed',
-            detail: `Already managed at ${managed_conflict.baseDir}`,
-            action: null,
-        };
-    }
-    return {
-        label: 'import',
-        detail: 'Press Enter to import into pi-native skills and reload',
-        action: 'import',
-    };
-}
-function to_setting_item(skill) {
-    const detail_lines = [
-        `${skill.source} • ${skill.key}`,
-        skill.description,
-        skill.baseDir,
-    ];
-    if (skill.import_meta?.upstream_version) {
-        detail_lines.push(`upstream: ${skill.import_meta.upstream_version}${skill.import_meta.upstream_git_commit_sha ? ` • ${skill.import_meta.upstream_git_commit_sha.slice(0, 12)}` : ''}`);
-    }
-    return {
-        id: skill.key,
-        label: skill.name,
-        description: detail_lines.join('\n'),
-        currentValue: skill.enabled ? ENABLED : DISABLED,
-        values: [ENABLED, DISABLED],
-    };
-}
-function to_importable_setting_item(managed_skills, skill) {
-    const state = get_importable_state(managed_skills, skill);
-    const detail_lines = [
-        `${skill.source} • ${skill.key}`,
-        skill.description,
-        skill.baseDir,
-    ];
-    if (skill.plugin?.version) {
-        detail_lines.push(`plugin: ${skill.plugin.version}${skill.plugin.gitCommitSha ? ` • ${skill.plugin.gitCommitSha.slice(0, 12)}` : ''}`);
-    }
-    if (state.action === 'import') {
-        return {
-            id: skill.key,
-            label: skill.name,
-            description: detail_lines.join('\n'),
-            currentValue: DISABLED,
-            values: [ENABLED, DISABLED],
-        };
-    }
-    if (state.action === 'sync') {
-        detail_lines.push('enter to sync');
-        return {
-            id: skill.key,
-            label: skill.name,
-            description: detail_lines.join('\n'),
-            currentValue: SYNC,
-            values: [SYNC],
-        };
-    }
-    detail_lines.push(state.detail);
-    return {
-        id: skill.key,
-        label: skill.name,
-        description: detail_lines.join('\n'),
-        currentValue: IMPORTED_LABEL,
-    };
-}
-function sets_equal(a, b) {
-    if (a.size !== b.size)
-        return false;
-    for (const value of a) {
-        if (!b.has(value))
-            return false;
-    }
-    return true;
-}
-async function show_skills_home_modal(ctx, managed_count, importable_count) {
-    return await show_picker_modal(ctx, {
-        title: 'Skills',
-        subtitle: `${managed_count} managed • ${importable_count} importable`,
-        items: [
-            {
-                value: 'manage',
-                label: 'Manage skills',
-                description: 'Enable, disable, import, and sync skills',
-            },
-            {
-                value: 'browse',
-                label: 'Browse details',
-                description: 'Open read-only detail views for discovered skills',
-            },
-            {
-                value: 'import',
-                label: 'Import skill',
-                description: 'Copy an external skill into Pi-native storage',
-            },
-            {
-                value: 'sync',
-                label: 'Sync imported skill',
-                description: 'Update an imported skill from its upstream source',
-            },
-            {
-                value: 'refresh',
-                label: 'Refresh discovery',
-                description: 'Rescan managed and importable skills',
-            },
-            {
-                value: 'defaults',
-                label: 'Default policy',
-                description: 'Choose whether new skills default enabled or disabled',
-            },
-        ],
-        footer: 'enter opens • esc close/back',
-    });
-}
-async function show_skills_manager_modal(ctx, mgr) {
-    const discovered = sort_skills(mgr.discover());
-    const importable = sort_skills(mgr.discover_importable());
-    if (discovered.length === 0 && importable.length === 0) {
-        ctx.ui.notify('No managed or importable skills found');
-        return false;
-    }
-    const initial_enabled = new Set(discovered
-        .filter((skill) => skill.enabled)
-        .map((skill) => skill.key));
-    const current_enabled = new Set(initial_enabled);
-    const queued_imports = new Set();
-    let reload_notice = null;
-    const managed_items = discovered.map(to_setting_item);
-    const importable_items = importable.map((skill) => to_importable_setting_item(discovered, skill));
-    const all_items = [];
-    if (managed_items.length > 0) {
-        all_items.push({
-            id: '__header_managed__',
-            label: `── Managed (${managed_items.length}) ──`,
-            description: '',
-            currentValue: '',
-        });
-        all_items.push(...managed_items);
-    }
-    if (importable_items.length > 0) {
-        all_items.push({
-            id: '__header_importable__',
-            label: `── Importable (${importable_items.length}) ──`,
-            description: '',
-            currentValue: '',
-        });
-        all_items.push(...importable_items);
-    }
-    const metadata_by_id = new Map(all_items.map((item) => [item.id, item.description ?? '']));
-    for (const item of all_items) {
-        if (!item.id.startsWith('__header_'))
-            item.description = '';
-    }
-    const managed_keys = new Set(discovered.map((skill) => skill.key));
-    const importable_map = new Map(importable.map((skill) => [skill.key, skill]));
-    await show_settings_modal(ctx, {
-        title: 'Skills',
-        subtitle: () => {
-            const enabled = current_enabled.size;
-            const disabled = discovered.length - enabled;
-            const queued = queued_imports.size;
-            const parts = [`${enabled} enabled`, `${disabled} disabled`];
-            if (importable.length > 0)
-                parts.push(`${importable.length} importable`);
-            if (queued > 0)
-                parts.push(`${queued} queued for import`);
-            return parts.join(' • ');
-        },
-        items: all_items,
-        max_visible: Math.min(Math.max(all_items.length + 4, 8), 12),
-        enable_search: true,
-        metadata: (item) => item ? metadata_by_id.get(item.id)?.split('\n') : undefined,
-        on_change: (id, new_value) => {
-            if (id.startsWith('__header_'))
-                return;
-            if (managed_keys.has(id)) {
-                if (new_value === ENABLED) {
-                    current_enabled.add(id);
-                    mgr.enable(id);
-                }
-                else {
-                    current_enabled.delete(id);
-                    mgr.disable(id);
-                }
-                return;
-            }
-            const import_skill = importable_map.get(id);
-            if (!import_skill)
-                return;
-            const state = get_importable_state(discovered, import_skill);
-            if (state.action === 'import') {
-                if (new_value === ENABLED)
-                    queued_imports.add(id);
-                else
-                    queued_imports.delete(id);
-                return;
-            }
-            if (state.action !== 'sync')
-                return;
-            const imported_skill = find_matching_imported_skill(discovered, import_skill);
-            if (!imported_skill) {
-                ctx.ui.notify(`Imported copy for ${import_skill.name} was not found`, 'warning');
-                return;
-            }
-            try {
-                const result = mgr.sync_skill(imported_skill.key);
-                if (result.changed) {
-                    reload_notice = `Synced ${import_skill.name}. Reloading...`;
-                    return true;
-                }
-                ctx.ui.notify(`${import_skill.name} is already up to date.`, 'info');
-            }
-            catch (error) {
-                ctx.ui.notify(error instanceof Error ? error.message : String(error), 'warning');
-            }
-        },
-    });
-    if (queued_imports.size > 0) {
-        const imported_names = [];
-        for (const key of queued_imports) {
-            try {
-                mgr.import_skill(key);
-                imported_names.push(key);
-            }
-            catch (error) {
-                ctx.ui.notify(error instanceof Error ? error.message : String(error), 'warning');
-            }
-        }
-        if (imported_names.length > 0) {
-            reload_notice = `Imported ${imported_names.length} skill(s). Reloading...`;
-        }
-    }
-    if (reload_notice) {
-        ctx.ui.notify(reload_notice, 'info');
-        await ctx.reload();
-        return true;
-    }
-    if (!sets_equal(initial_enabled, current_enabled)) {
-        ctx.ui.notify('Reloading to apply updated skills...', 'info');
-        await ctx.reload();
-        return true;
-    }
-    return false;
-}
-function skill_status(skill) {
-    if (skill.kind === 'external')
-        return 'importable';
-    return skill.enabled ? 'enabled' : 'disabled';
-}
-function format_skill_detail(skill) {
-    const lines = [
-        `# ${skill.name}`,
-        '',
-        `Status: ${skill_status(skill)}`,
-        `Source: ${skill.source}`,
-        `Key: ${skill.key}`,
-        `Kind: ${skill.kind}`,
-        '',
-        skill.description,
-        '',
-        `Base directory: ${skill.baseDir}`,
-        `Skill file: ${skill.skillPath}`,
-    ];
-    if (skill.plugin) {
-        lines.push('', 'Plugin', `- ID: ${skill.plugin.pluginId}`, `- Version: ${skill.plugin.version}`, `- Install path: ${skill.plugin.installPath}`);
-        if (skill.plugin.gitCommitSha) {
-            lines.push(`- Commit: ${skill.plugin.gitCommitSha}`);
-        }
-    }
-    if (skill.import_meta) {
-        lines.push('', 'Import metadata', `- Upstream source: ${skill.import_meta.source}`, `- Imported at: ${skill.import_meta.imported_at}`, `- Last synced at: ${skill.import_meta.last_synced_at}`, `- Upstream path: ${skill.import_meta.upstream_skill_path}`);
-        if (skill.import_meta.upstream_version) {
-            lines.push(`- Upstream version: ${skill.import_meta.upstream_version}`);
-        }
-        if (skill.import_meta.upstream_git_commit_sha) {
-            lines.push(`- Upstream commit: ${skill.import_meta.upstream_git_commit_sha}`);
-        }
-    }
-    return lines.join('\n');
-}
-function format_skill_list(skills) {
-    if (skills.length === 0)
-        return 'No skills found.';
-    return sort_skills(skills)
-        .map((skill) => `${skill_status(skill).padEnd(10)} ${skill.name} (${skill.key})`)
-        .join('\n');
-}
-function find_skill(skills, key_or_name) {
-    const query = key_or_name.trim();
-    const exact_key = skills.find((skill) => skill.key === query);
-    if (exact_key)
-        return exact_key;
-    const exact_name = skills.filter((skill) => skill.name === query);
-    if (exact_name.length === 1)
-        return exact_name[0];
-    if (exact_name.length > 1) {
-        throw new Error(`Multiple skills named ${query}. Use an exact key instead.`);
-    }
-    const lower = query.toLowerCase();
-    const fuzzy = skills.filter((skill) => skill.key.toLowerCase() === lower ||
-        skill.name.toLowerCase() === lower);
-    if (fuzzy.length === 1)
-        return fuzzy[0];
-    if (fuzzy.length > 1) {
-        throw new Error(`Multiple skills matched ${query}. Use an exact key instead.`);
-    }
-    throw new Error(`Unknown skill: ${query}`);
-}
-async function pick_skill(ctx, options) {
-    return await show_picker_modal(ctx, {
-        title: options.title,
-        subtitle: options.subtitle,
-        items: options.skills.map((skill) => ({
-            value: skill.key,
-            label: skill.name,
-            description: `${skill_status(skill)} • ${skill.source} • ${skill.key}`,
-        })),
-        empty_message: options.empty_message,
-    });
-}
-async function show_skill_detail_modal(ctx, skill) {
-    await show_text_modal(ctx, {
-        title: skill.name,
-        subtitle: `${skill_status(skill)} • ${skill.source}`,
-        text: format_skill_detail(skill),
-    });
-}
-async function show_skill_list_modal(ctx, mgr) {
-    while (true) {
-        const skills = sort_skills([
-            ...mgr.discover(),
-            ...mgr.discover_importable(),
-        ]);
-        const key = await pick_skill(ctx, {
-            title: 'Browse skills',
-            subtitle: `${mgr.discover().length} managed • ${mgr.discover_importable().length} importable`,
-            skills,
-            empty_message: 'No skills found',
-        });
-        if (!key)
-            return;
-        await show_skill_detail_modal(ctx, find_skill(skills, key));
-    }
-}
-async function show_refresh_summary(ctx, mgr) {
-    mgr.refresh();
-    await show_text_modal(ctx, {
-        title: 'Skills refreshed',
-        text: `${mgr.discover().length} managed skills\n${mgr.discover_importable().length} importable skills found`,
-    });
-}
-async function show_defaults_modal(ctx, mgr) {
-    const selected = await show_picker_modal(ctx, {
-        title: 'Skill default policy',
-        subtitle: 'Choose how newly discovered skills start',
-        items: [
-            {
-                value: 'all-enabled',
-                label: 'All enabled',
-                description: 'New skills are enabled by default',
-            },
-            {
-                value: 'all-disabled',
-                label: 'All disabled',
-                description: 'New skills require explicit enablement',
-            },
-        ],
-    });
-    if (!selected)
-        return;
-    mgr.set_defaults(selected);
-    await show_text_modal(ctx, {
-        title: 'Skill defaults updated',
-        text: `Default policy: ${selected}`,
-    });
-}
-// Default export for Pi Package / additionalExtensionPaths loading
-export default async function skills(pi) {
-    const mgr = create_skills_manager();
-    const subs = [
-        'list',
-        'show',
-        'import',
-        'sync',
-        'refresh',
-        'defaults',
-    ];
-    pi.registerCommand('skills', {
-        description: 'Manage pi-native skills and import external skills',
-        getArgumentCompletions: (prefix) => {
-            const parts = prefix.trimStart().split(/\s+/);
-            const has_trailing_space = /\s$/.test(prefix);
-            if (parts.length <= 1 && !has_trailing_space) {
-                return subs
-                    .filter((s) => s.startsWith(parts[0] || ''))
-                    .map((s) => ({ value: s, label: s }));
-            }
-            if (parts[0] === 'show') {
-                const q = parts.slice(1).join(' ').toLowerCase();
-                return sort_skills([
-                    ...mgr.discover(),
-                    ...mgr.discover_importable(),
-                ])
-                    .filter((s) => s.key.toLowerCase().includes(q) ||
-                    s.name.toLowerCase().includes(q))
-                    .slice(0, 20)
-                    .map((s) => ({
-                    value: `${parts[0]} ${s.key}`,
-                    label: s.key,
-                }));
-            }
-            if (parts[0] === 'import') {
-                const q = parts.slice(1).join(' ').toLowerCase();
-                return sort_skills(mgr.discover_importable())
-                    .filter((s) => s.key.toLowerCase().includes(q) ||
-                    s.name.toLowerCase().includes(q))
-                    .slice(0, 20)
-                    .map((s) => ({
-                    value: `${parts[0]} ${s.key}`,
-                    label: s.key,
-                }));
-            }
-            if (parts[0] === 'sync') {
-                const q = parts.slice(1).join(' ').toLowerCase();
-                return sort_skills(mgr
-                    .discover()
-                    .filter((skill) => Boolean(skill.import_meta)))
-                    .filter((s) => s.key.toLowerCase().includes(q) ||
-                    s.name.toLowerCase().includes(q))
-                    .slice(0, 20)
-                    .map((s) => ({
-                    value: `${parts[0]} ${s.key}`,
-                    label: s.key,
-                }));
-            }
-            return null;
-        },
-        handler: async (args, ctx) => {
-            const trimmed = args.trim();
-            if (!trimmed && ctx.hasUI) {
-                while (true) {
-                    const managed_count = mgr.discover().length;
-                    const importable_count = mgr.discover_importable().length;
-                    const selected = await show_skills_home_modal(ctx, managed_count, importable_count);
-                    if (!selected)
-                        return;
-                    if (selected === 'manage') {
-                        if (await show_skills_manager_modal(ctx, mgr))
-                            return;
-                    }
-                    else if (selected === 'browse') {
-                        await show_skill_list_modal(ctx, mgr);
-                    }
-                    else if (selected === 'import') {
-                        const key = await pick_skill(ctx, {
-                            title: 'Import skill',
-                            subtitle: 'Copy an external skill into Pi-native storage',
-                            skills: sort_skills(mgr.discover_importable()),
-                            empty_message: 'No importable skills found',
-                        });
-                        if (!key)
-                            continue;
-                        try {
-                            const result = mgr.import_skill(key);
-                            ctx.ui.notify(`Imported ${key} to ${result.skillDir}. Reloading...`, 'info');
-                            await ctx.reload();
-                            return;
-                        }
-                        catch (error) {
-                            ctx.ui.notify(error instanceof Error
-                                ? error.message
-                                : String(error), 'warning');
-                        }
-                    }
-                    else if (selected === 'sync') {
-                        const key = await pick_skill(ctx, {
-                            title: 'Sync imported skill',
-                            subtitle: 'Update an imported skill from its upstream source',
-                            skills: sort_skills(mgr
-                                .discover()
-                                .filter((skill) => Boolean(skill.import_meta))),
-                            empty_message: 'No imported skills found',
-                        });
-                        if (!key)
-                            continue;
-                        try {
-                            const result = mgr.sync_skill(key);
-                            if (result.changed) {
-                                ctx.ui.notify(`Synced ${key}. Reloading...`, 'info');
-                                await ctx.reload();
-                                return;
-                            }
-                            await show_text_modal(ctx, {
-                                title: 'Skill already up to date',
-                                text: `${key} is already up to date.`,
-                            });
-                        }
-                        catch (error) {
-                            ctx.ui.notify(error instanceof Error
-                                ? error.message
-                                : String(error), 'warning');
-                        }
-                    }
-                    else if (selected === 'refresh') {
-                        await show_refresh_summary(ctx, mgr);
-                    }
-                    else if (selected === 'defaults') {
-                        await show_defaults_modal(ctx, mgr);
-                    }
-                }
-            }
-            const [sub, ...rest] = (trimmed || 'list').split(/\s+/);
-            const arg = rest.join(' ');
-            switch (sub) {
-                case 'list': {
-                    const skills = [
-                        ...mgr.discover(),
-                        ...mgr.discover_importable(),
-                    ];
-                    if (ctx.hasUI) {
-                        await show_skill_list_modal(ctx, mgr);
-                    }
-                    else {
-                        ctx.ui.notify(format_skill_list(skills));
-                    }
-                    break;
-                }
-                case 'show': {
-                    const skills = [
-                        ...mgr.discover(),
-                        ...mgr.discover_importable(),
-                    ];
-                    let target = arg;
-                    if (!target && ctx.hasUI) {
-                        target =
-                            (await pick_skill(ctx, {
-                                title: 'Show skill details',
-                                subtitle: 'Open a read-only skill detail view',
-                                skills: sort_skills(skills),
-                                empty_message: 'No skills found',
-                            })) ?? '';
-                        if (!target)
-                            return;
-                    }
-                    if (!target) {
-                        ctx.ui.notify('Usage: /skills show <key|name>', 'warning');
-                        return;
-                    }
-                    try {
-                        const skill = find_skill(skills, target);
-                        if (ctx.hasUI) {
-                            await show_skill_detail_modal(ctx, skill);
-                        }
-                        else {
-                            ctx.ui.notify(format_skill_detail(skill));
-                        }
-                    }
-                    catch (error) {
-                        ctx.ui.notify(error instanceof Error ? error.message : String(error), 'warning');
-                    }
-                    break;
-                }
-                case 'import': {
-                    let target = arg;
-                    if (!target && ctx.hasUI) {
-                        target =
-                            (await pick_skill(ctx, {
-                                title: 'Import skill',
-                                subtitle: 'Copy an external skill into Pi-native storage',
-                                skills: sort_skills(mgr.discover_importable()),
-                                empty_message: 'No importable skills found',
-                            })) ?? '';
-                        if (!target)
-                            return;
-                    }
-                    if (!target) {
-                        ctx.ui.notify('Usage: /skills import <key|name>', 'warning');
-                        return;
-                    }
-                    try {
-                        const result = mgr.import_skill(target);
-                        ctx.ui.notify(`Imported ${target} to ${result.skillDir}. Reloading...`, 'info');
-                        await ctx.reload();
-                        return;
-                    }
-                    catch (error) {
-                        ctx.ui.notify(error instanceof Error ? error.message : String(error), 'warning');
-                        return;
-                    }
-                }
-                case 'sync': {
-                    let target = arg;
-                    if (!target && ctx.hasUI) {
-                        target =
-                            (await pick_skill(ctx, {
-                                title: 'Sync imported skill',
-                                subtitle: 'Update an imported skill from its upstream source',
-                                skills: sort_skills(mgr
-                                    .discover()
-                                    .filter((skill) => Boolean(skill.import_meta))),
-                                empty_message: 'No imported skills found',
-                            })) ?? '';
-                        if (!target)
-                            return;
-                    }
-                    if (!target) {
-                        ctx.ui.notify('Usage: /skills sync <key|name>', 'warning');
-                        return;
-                    }
-                    try {
-                        const result = mgr.sync_skill(target);
-                        if (result.changed) {
-                            ctx.ui.notify(`Synced ${target}. Reloading...`, 'info');
-                            await ctx.reload();
-                            return;
-                        }
-                        if (ctx.hasUI) {
-                            await show_text_modal(ctx, {
-                                title: 'Skill already up to date',
-                                text: `${target} is already up to date.`,
-                            });
-                        }
-                        else {
-                            ctx.ui.notify(`${target} is already up to date.`, 'info');
-                        }
-                        return;
-                    }
-                    catch (error) {
-                        ctx.ui.notify(error instanceof Error ? error.message : String(error), 'warning');
-                        return;
-                    }
-                }
-                case 'refresh': {
-                    if (ctx.hasUI) {
-                        await show_refresh_summary(ctx, mgr);
-                        break;
-                    }
-                    mgr.refresh();
-                    ctx.ui.notify(`Rescanned: ${mgr.discover().length} managed skills, ${mgr.discover_importable().length} importable skills found`);
-                    break;
-                }
-                case 'defaults': {
-                    if (!arg && ctx.hasUI) {
-                        await show_defaults_modal(ctx, mgr);
-                        break;
-                    }
-                    if (arg !== 'all-enabled' && arg !== 'all-disabled') {
-                        ctx.ui.notify('Usage: /skills defaults <all-enabled|all-disabled>', 'warning');
-                        return;
-                    }
-                    mgr.set_defaults(arg);
-                    if (ctx.hasUI) {
-                        await show_text_modal(ctx, {
-                            title: 'Skill defaults updated',
-                            text: `Default policy: ${arg}`,
-                        });
-                    }
-                    else {
-                        ctx.ui.notify(`Default policy: ${arg}`);
-                    }
-                    break;
-                }
-                default:
-                    ctx.ui.notify(`Unknown: ${sub}. Use: ${subs.join(', ')}`, 'warning');
-            }
-        },
-    });
-}
+export { default } from './commands.js';
 //# sourceMappingURL=index.js.map