@pasko70/pibo 1.9.9 → 1.9.11

package/dist/mcp/python-runtime.js

@@ -0,0 +1,131 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdir, rm } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { ErrorCode, formatCliError } from './errors.js';
+function getPiboHome() {
+    return process.env.PIBO_HOME || join(homedir(), '.pibo');
+}
+export function getPythonRuntimePaths(name, spec) {
+    const rootDir = join(getPiboHome(), 'mcp-tools', name);
+    const venvDir = join(rootDir, '.venv');
+    const binDir = process.platform === 'win32' ? 'Scripts' : 'bin';
+    const executable = process.platform === 'win32'
+        ? `${spec.executableName}.exe`
+        : spec.executableName;
+    return {
+        rootDir,
+        venvDir,
+        pythonPath: join(venvDir, binDir, process.platform === 'win32' ? 'python.exe' : 'python'),
+        executablePath: join(venvDir, binDir, executable),
+    };
+}
+function runBuffered(command, args) {
+    return new Promise((resolve) => {
+        const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        const chunks = [];
+        child.stdout.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+        child.stderr.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+        child.on('error', (error) => {
+            resolve({ ok: false, output: error.message });
+        });
+        child.on('close', (code) => {
+            resolve({
+                ok: code === 0,
+                output: Buffer.concat(chunks).toString('utf-8').trim(),
+            });
+        });
+    });
+}
+function runInherited(command, args) {
+    return new Promise((resolve, reject) => {
+        console.log(`Running: ${command} ${args.join(' ')}`);
+        const child = spawn(command, args, {
+            stdio: 'inherit',
+            env: process.env,
+        });
+        child.on('error', (error) => {
+            reject(new Error(formatCliError({
+                code: ErrorCode.CLIENT_ERROR,
+                type: 'PYTHON_RUNTIME_COMMAND_FAILED',
+                message: `Failed to run command: ${command}`,
+                details: error.message,
+                suggestion: 'Install uv first, then rerun the command.',
+            })));
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(formatCliError({
+                code: ErrorCode.CLIENT_ERROR,
+                type: 'PYTHON_RUNTIME_COMMAND_FAILED',
+                message: `Command failed with exit code ${code ?? 'unknown'}`,
+                details: `${command} ${args.join(' ')}`,
+                suggestion: 'Fix the setup error above, then rerun the install command.',
+            })));
+        });
+    });
+}
+export async function printPythonRuntimeDoctor(name, spec) {
+    const paths = getPythonRuntimePaths(name, spec);
+    const uv = await runBuffered('uv', ['--version']);
+    const python = uv.ok
+        ? await runBuffered('uv', ['python', 'find', spec.pythonVersion])
+        : { ok: false, output: 'skipped because uv is missing' };
+    console.log(`${name}`);
+    console.log(`  uv: ${uv.ok ? uv.output || 'ok' : `missing (${uv.output})`}`);
+    console.log(`  python ${spec.pythonVersion}: ${python.ok ? python.output || 'ok' : `missing (${python.output})`}`);
+    console.log(`  runtime: ${paths.rootDir}`);
+    console.log(`  venv: ${existsSync(paths.venvDir) ? 'present' : 'missing'}`);
+    console.log(`  executable: ${existsSync(paths.executablePath) ? paths.executablePath : 'missing'}`);
+    if (!uv.ok) {
+        console.log('');
+        console.log('Install uv first:');
+        console.log('  macOS/Linux: curl -LsSf https://astral.sh/uv/install.sh | sh');
+        console.log('  Windows PowerShell: irm https://astral.sh/uv/install.ps1 | iex');
+    }
+    if (uv.ok && !python.ok) {
+        console.log('');
+        console.log(`Install Python ${spec.pythonVersion}+ first:`);
+        console.log('  Ubuntu/Debian: sudo apt update && sudo apt install -y python3 python3-venv');
+        console.log('  macOS: brew install python');
+        console.log('  Windows PowerShell: winget install Python.Python.3.12');
+        console.log('');
+        console.log('Then rerun:');
+        console.log(`  pibo mcp registry doctor ${name}`);
+    }
+}
+export async function installPythonRuntime(name, spec) {
+    const uv = await runBuffered('uv', ['--version']);
+    if (!uv.ok) {
+        throw new Error(formatCliError({
+            code: ErrorCode.CLIENT_ERROR,
+            type: 'PYTHON_RUNTIME_UV_MISSING',
+            message: 'uv was not found on PATH',
+            details: uv.output,
+            suggestion: 'Install uv first. macOS/Linux: curl -LsSf https://astral.sh/uv/install.sh | sh. Windows PowerShell: irm https://astral.sh/uv/install.ps1 | iex.',
+        }));
+    }
+    const paths = getPythonRuntimePaths(name, spec);
+    await mkdir(paths.rootDir, { recursive: true });
+    await runInherited('uv', ['venv', paths.venvDir, '--python', spec.pythonVersion]);
+    await runInherited('uv', [
+        'pip',
+        'install',
+        '--python',
+        paths.pythonPath,
+        spec.packageName,
+    ]);
+    if (spec.postInstallArgs?.length) {
+        await runInherited(paths.executablePath, spec.postInstallArgs);
+    }
+    return paths;
+}
+export async function removePythonRuntime(name, spec) {
+    const paths = getPythonRuntimePaths(name, spec);
+    await rm(paths.rootDir, { recursive: true, force: true });
+    console.log(`Removed runtime: ${paths.rootDir}`);
+}

package/dist/mcp/registry.js

@@ -0,0 +1,116 @@
+import { configCommand } from './config-command.js';
+import { ErrorCode, formatCliError } from './errors.js';
+import { getPythonRuntimePaths, installPythonRuntime, printPythonRuntimeDoctor, removePythonRuntime, } from './python-runtime.js';
+const REGISTRY = [];
+function findRegistryEntry(name) {
+    return REGISTRY.find((entry) => entry.name === name);
+}
+function buildServerConfig(entry) {
+    const paths = getPythonRuntimePaths(entry.name, entry.runtime);
+    return {
+        command: paths.executablePath,
+        args: entry.serverArgs,
+        ...(entry.serverEnv ? { env: entry.serverEnv } : {}),
+        ...(entry.agentDescription
+            ? { pibo: { description: entry.agentDescription, descriptionSource: 'registry' } }
+            : {}),
+    };
+}
+function printRegistryHelp() {
+    console.log(`
+MCP server registry
+
+Commands:
+  pibo mcp registry list                         List built-in MCP server presets
+  pibo mcp registry show <name>                  Show one preset
+  pibo mcp registry doctor <name>                Check runtime prerequisites
+  pibo mcp registry install <name>               Install setup deps and add preset to mcp_servers.json
+  pibo mcp registry install <name> --no-setup    Only add preset to mcp_servers.json
+  pibo mcp registry remove <name>                Remove config and local runtime
+  pibo mcp registry help                         Show this help
+`);
+}
+function printEntry(entry) {
+    const paths = getPythonRuntimePaths(entry.name, entry.runtime);
+    console.log(`${entry.name}`);
+    console.log(`  ${entry.description}`);
+    console.log('');
+    console.log('Runtime:');
+    console.log(`  package: ${entry.runtime.packageName}`);
+    console.log(`  python: ${entry.runtime.pythonVersion}`);
+    console.log(`  path: ${paths.rootDir}`);
+    console.log('');
+    console.log('Server config:');
+    console.log(JSON.stringify(buildServerConfig(entry), null, 2));
+    if (entry.notes.length > 0) {
+        console.log('');
+        console.log('Notes:');
+        for (const note of entry.notes) {
+            console.log(`  - ${note}`);
+        }
+    }
+}
+async function installEntry(entry, options) {
+    if (options.runSetup !== false) {
+        await installPythonRuntime(entry.name, entry.runtime);
+    }
+    await configCommand({
+        action: 'add',
+        name: entry.name,
+        serverJson: JSON.stringify(buildServerConfig(entry)),
+        configPath: options.configPath,
+    });
+}
+export async function registryCommand(options) {
+    if (options.action === 'help') {
+        printRegistryHelp();
+        return;
+    }
+    if (options.action === 'list') {
+        if (REGISTRY.length === 0) {
+            console.log('No registry entries are currently bundled.');
+            return;
+        }
+        for (const entry of REGISTRY) {
+            console.log(`${entry.name}\t${entry.description}`);
+        }
+        return;
+    }
+    if (!options.name) {
+        throw new Error(formatCliError({
+            code: ErrorCode.CLIENT_ERROR,
+            type: 'MISSING_ARGUMENT',
+            message: `registry ${options.action} requires <name>`,
+            suggestion: 'Run pibo mcp registry list to see available presets.',
+        }));
+    }
+    const entry = findRegistryEntry(options.name);
+    if (!entry) {
+        throw new Error(formatCliError({
+            code: ErrorCode.CLIENT_ERROR,
+            type: 'MCP_REGISTRY_ENTRY_NOT_FOUND',
+            message: `Registry entry "${options.name}" not found`,
+            details: REGISTRY.length > 0
+                ? `Available entries: ${REGISTRY.map((item) => item.name).join(', ')}`
+                : 'No registry entries are currently bundled.',
+        }));
+    }
+    if (options.action === 'show') {
+        printEntry(entry);
+        return;
+    }
+    if (options.action === 'doctor') {
+        await printPythonRuntimeDoctor(entry.name, entry.runtime);
+        return;
+    }
+    if (options.action === 'install') {
+        await installEntry(entry, options);
+        return;
+    }
+    await configCommand({
+        action: 'remove',
+        name: entry.name,
+        configPath: options.configPath,
+    });
+    await removePythonRuntime(entry.name, entry.runtime);
+}

package/dist/mcp/version.js

@@ -0,0 +1,5 @@
+/**
+ * Version constant - single source of truth
+ * This file is auto-updated by scripts/release.sh
+ */
+export const VERSION = '0.3.0';

package/dist/pi-packages/cli.js

@@ -0,0 +1,92 @@
+import { Command } from "commander";
+import { inspectPiPackageSource, parsePiPackageSource } from "./metadata.js";
+import { findPiPackage, listPiPackages, removePiPackage, upsertPiPackage } from "./store.js";
+export async function runPiPackagesCli(argv = process.argv) {
+    if (argv[2] === "--help" || argv[2] === "-h" || argv.length <= 2) {
+        printPiPackagesDiscovery();
+        return;
+    }
+    const program = new Command();
+    program.name("pibo pi-packages").description("Register Pi Coding Agent packages for Pibo profiles").helpOption(false);
+    program.command("list").description("List registered Pi packages").action(() => {
+        const packages = listPiPackages();
+        if (packages.length === 0) {
+            console.log("No Pi packages registered.");
+            console.log("Next: pibo pi-packages add <source>");
+            return;
+        }
+        for (const pkg of packages) {
+            console.log(`${pkg.name.padEnd(24)} ${pkg.installStatus.padEnd(10)} ${(pkg.resourceTypes.join(", ") || "unknown").padEnd(20)} ${pkg.installSpec}`);
+        }
+    });
+    program.command("add").argument("<source>").description("Register a pi.dev package URL or local path").action(async (source) => {
+        const pkg = upsertPiPackage(await inspectPiPackageSource(source));
+        console.log(`Added Pi package ${pkg.name}`);
+        console.log(`  source: ${pkg.source}`);
+        console.log(`  install: ${pkg.installSpec}`);
+        console.log(`  status: ${pkg.installStatus}`);
+        console.log(`Next: pibo pi-packages inspect ${pkg.id}`);
+    });
+    program.command("inspect").argument("<name-or-id>").description("Inspect one registered Pi package").action((nameOrId) => {
+        const pkg = findPiPackage(nameOrId);
+        if (!pkg) {
+            process.exitCode = 1;
+            console.error(`Unknown Pi package "${nameOrId}"`);
+            return;
+        }
+        console.log(JSON.stringify(pkg, null, 2));
+    });
+    program.command("remove").argument("<name-or-id>").description("Remove a registered Pi package").action((nameOrId) => {
+        const removed = removePiPackage(nameOrId);
+        if (!removed) {
+            process.exitCode = 1;
+            console.error(`Unknown Pi package "${nameOrId}"`);
+            return;
+        }
+        console.log(`Removed Pi package ${removed.name}`);
+    });
+    program.command("doctor").description("Check registered Pi package sources").action(async () => {
+        const packages = listPiPackages();
+        if (packages.length === 0) {
+            console.log("No Pi packages registered.");
+            return;
+        }
+        for (const pkg of packages) {
+            const diagnostics = [];
+            try {
+                await parsePiPackageSource(pkg.source);
+            }
+            catch (error) {
+                diagnostics.push(error instanceof Error ? error.message : String(error));
+            }
+            if (pkg.installPath && !pkg.installPath.startsWith("npm:")) {
+                try {
+                    await parsePiPackageSource(pkg.installPath);
+                }
+                catch (error) {
+                    diagnostics.push(error instanceof Error ? error.message : String(error));
+                }
+            }
+            const status = diagnostics.length || pkg.installStatus === "error" || pkg.installStatus === "missing" ? "error" : "ok";
+            console.log(`${pkg.name}\t${status}\t${pkg.installSpec}`);
+            for (const diagnostic of [...pkg.diagnostics.map((item) => item.message), ...diagnostics]) {
+                console.log(`  ${diagnostic}`);
+            }
+        }
+    });
+    await program.parseAsync(argv);
+}
+function printPiPackagesDiscovery() {
+    console.log(`pibo pi-packages - registered Pi Coding Agent packages
+
+Commands:
+  list                 List registered packages
+  add <source>         Register a pi.dev URL or local path
+  inspect <name-or-id> Show package metadata
+  remove <name-or-id>  Remove a registration
+  doctor               Check package sources
+
+Next:
+  pibo pi-packages list
+`);
+}

package/dist/pi-packages/installer.js

@@ -0,0 +1,70 @@
+import { execFile } from "node:child_process";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export async function installOrResolvePiPackage(parsed, cwd = process.cwd()) {
+    if (parsed.kind === "local") {
+        if (!parsed.path || !existsSync(parsed.path)) {
+            return {
+                installStatus: "missing",
+                diagnostics: [{ type: "error", message: `Local Pi package path does not exist: ${parsed.path ?? parsed.source}` }],
+            };
+        }
+        return {
+            installStatus: "installed",
+            installPath: parsed.path,
+            diagnostics: [{ type: "info", message: `Resolved local Pi package path: ${parsed.path}` }],
+        };
+    }
+    const packageName = parsed.packageName ?? parsed.name;
+    const installRoot = npmPackageInstallRoot(cwd, packageName);
+    const installPath = resolve(installRoot, "node_modules", ...packageName.split("/"));
+    try {
+        ensureNpmInstallProject(installRoot);
+        await execFileAsync("npm", ["install", packageName, "--prefix", installRoot, "--omit=dev"], {
+            cwd: installRoot,
+            timeout: 120000,
+            maxBuffer: 1024 * 1024,
+        });
+        if (!existsSync(installPath)) {
+            return {
+                installStatus: "missing",
+                installPath,
+                diagnostics: [{ type: "error", message: `npm install completed but package path is missing: ${installPath}` }],
+            };
+        }
+        return {
+            installStatus: "installed",
+            installPath,
+            diagnostics: [{ type: "info", message: `Installed npm Pi package ${packageName} into ${installRoot}` }],
+        };
+    }
+    catch (error) {
+        return {
+            installStatus: "error",
+            installPath: existsSync(installPath) ? installPath : undefined,
+            diagnostics: [{
+                    type: "error",
+                    message: `Could not install npm Pi package ${packageName}: ${error instanceof Error ? error.message : String(error)}`,
+                }],
+        };
+    }
+}
+export function npmPackageInstallRoot(cwd, packageName) {
+    return resolve(cwd, ".pibo/pi-packages/npm", encodePackageName(packageName));
+}
+function ensureNpmInstallProject(installRoot) {
+    mkdirSync(installRoot, { recursive: true });
+    const packageJsonPath = resolve(installRoot, "package.json");
+    if (!existsSync(packageJsonPath)) {
+        writeFileSync(packageJsonPath, `${JSON.stringify({ name: "pibo-pi-package", private: true }, null, 2)}\n`, "utf-8");
+    }
+    const gitIgnorePath = resolve(dirname(packageJsonPath), ".gitignore");
+    if (!existsSync(gitIgnorePath)) {
+        writeFileSync(gitIgnorePath, "*\n!.gitignore\n", "utf-8");
+    }
+}
+function encodePackageName(packageName) {
+    return encodeURIComponent(packageName).replace(/%/g, "_");
+}

package/dist/pi-packages/metadata.js

@@ -0,0 +1,231 @@
+import { execFile } from "node:child_process";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { basename, extname, resolve } from "node:path";
+import { promisify } from "node:util";
+import { DefaultPackageManager, getAgentDir, SettingsManager, } from "@earendil-works/pi-coding-agent";
+import { installOrResolvePiPackage } from "./installer.js";
+const execFileAsync = promisify(execFile);
+export async function inspectPiPackageSource(source, cwd = process.cwd()) {
+    const parsed = await parsePiPackageSource(source, cwd);
+    const diagnostics = [...parsed.diagnostics];
+    const install = await installOrResolvePiPackage(parsed, cwd);
+    diagnostics.push(...install.diagnostics);
+    const registryMetadata = parsed.kind === "npm"
+        ? await readNpmMetadata(parsed.packageName ?? parsed.name, diagnostics)
+        : {};
+    const localMetadata = install.installPath
+        ? readLocalMetadata(install.installPath, diagnostics)
+        : parsed.path ? readLocalMetadata(parsed.path, diagnostics) : {};
+    const metadata = mergePackageMetadata(registryMetadata, localMetadata, parsed.name);
+    const resolved = install.installPath
+        ? await resolvePackageResources(install.installPath, cwd, diagnostics)
+        : emptyResolvedPaths();
+    const resourceTypes = mergeResourceTypes(resourceTypesFromManifest(metadata.pi), resourceTypesFromResolvedPaths(resolved));
+    if (resourceTypes.length === 0) {
+        diagnostics.push({
+            type: "warning",
+            message: "No Pi package resources were discovered from the manifest or package layout.",
+        });
+    }
+    return {
+        id: metadata.name ?? parsed.name,
+        name: metadata.name ?? parsed.name,
+        description: metadata.description,
+        source: parsed.source,
+        installSpec: parsed.installSpec,
+        version: metadata.version,
+        repositoryUrl: repositoryUrl(metadata.repository),
+        resourceTypes,
+        extensionPaths: pathsOrUndefined(resolved.extensions),
+        skillNames: namesOrUndefined(resolved.skills),
+        promptNames: namesOrUndefined(resolved.prompts),
+        themeNames: namesOrUndefined(resolved.themes),
+        installStatus: install.installStatus,
+        installPath: install.installPath,
+        enabled: true,
+        diagnostics,
+    };
+}
+export async function parsePiPackageSource(source, cwd = process.cwd()) {
+    const trimmed = source.trim();
+    if (!trimmed)
+        throw new Error("Pi package source is required");
+    if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+        let url;
+        try {
+            url = new URL(trimmed);
+        }
+        catch {
+            throw new Error("Invalid Pi package URL");
+        }
+        if (url.origin !== "https://pi.dev" || !url.pathname.startsWith("/packages/")) {
+            throw new Error("Unsupported Pi package URL.\nExpected a URL starting with https://pi.dev/packages/ or a local path.");
+        }
+        const encodedName = url.pathname.slice("/packages/".length);
+        if (!encodedName) {
+            throw new Error("Pi package URL must point to a package detail page, for example https://pi.dev/packages/pi-web-access");
+        }
+        const packageName = decodeURIComponent(encodedName).replace(/\/+$/, "");
+        validatePackageName(packageName);
+        return {
+            kind: "npm",
+            name: packageName,
+            packageName,
+            source: `https://pi.dev/packages/${packageName}`,
+            installSpec: `npm:${packageName}`,
+            diagnostics: [],
+        };
+    }
+    const path = resolve(cwd, trimmed);
+    if (!existsSync(path))
+        throw new Error(`Local Pi package path does not exist: ${path}`);
+    const stats = statSync(path);
+    const name = stats.isFile() ? basename(path, extname(path)) : basename(path);
+    return {
+        kind: "local",
+        name,
+        path,
+        source: path,
+        installSpec: path,
+        diagnostics: [],
+    };
+}
+async function readNpmMetadata(packageName, diagnostics) {
+    try {
+        const { stdout } = await execFileAsync("npm", ["view", packageName, "--json"], {
+            timeout: 20000,
+            maxBuffer: 1024 * 1024,
+        });
+        const parsed = JSON.parse(stdout);
+        return normalizePackageJson(parsed);
+    }
+    catch (error) {
+        diagnostics.push({
+            type: "warning",
+            message: `Could not read npm metadata for ${packageName}: ${error instanceof Error ? error.message : String(error)}`,
+        });
+        return { name: packageName };
+    }
+}
+function readLocalMetadata(path, diagnostics) {
+    const stats = statSync(path);
+    if (stats.isFile()) {
+        return {
+            name: basename(path, extname(path)),
+            pi: { extensions: [path] },
+        };
+    }
+    const packageJsonPath = resolve(path, "package.json");
+    if (!existsSync(packageJsonPath)) {
+        diagnostics.push({ type: "info", message: "Local directory has no package.json; Pi package conventions will be used." });
+        return { name: basename(path) };
+    }
+    try {
+        return normalizePackageJson(JSON.parse(readFileSync(packageJsonPath, "utf-8")));
+    }
+    catch (error) {
+        diagnostics.push({
+            type: "warning",
+            message: `Could not read local package.json: ${error instanceof Error ? error.message : String(error)}`,
+        });
+        return { name: basename(path) };
+    }
+}
+async function resolvePackageResources(resourceSource, cwd, diagnostics) {
+    const packageManager = new DefaultPackageManager({
+        cwd,
+        agentDir: getAgentDir(),
+        settingsManager: SettingsManager.create(cwd, getAgentDir()),
+    });
+    try {
+        return await packageManager.resolveExtensionSources([resourceSource], { temporary: true });
+    }
+    catch (error) {
+        diagnostics.push({
+            type: "error",
+            message: `Could not resolve Pi package resources: ${error instanceof Error ? error.message : String(error)}`,
+        });
+        return emptyResolvedPaths();
+    }
+}
+function validatePackageName(packageName) {
+    if (!packageName)
+        throw new Error("Pi package URL must include a package name");
+    const parts = packageName.split("/");
+    if (packageName.startsWith("@")) {
+        if (parts.length !== 2 || !parts[0].slice(1) || !parts[1]) {
+            throw new Error("Scoped Pi package URLs must look like https://pi.dev/packages/@scope/package-name");
+        }
+        return;
+    }
+    if (parts.length !== 1 || !parts[0]) {
+        throw new Error("Pi package URL must include a single package name or scoped package name");
+    }
+}
+function normalizePackageJson(value) {
+    const candidate = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+    return {
+        name: stringField(candidate.name),
+        version: stringField(candidate.version),
+        description: stringField(candidate.description),
+        repository: candidate.repository,
+        pi: candidate.pi,
+    };
+}
+function mergePackageMetadata(primary, fallback, defaultName) {
+    return {
+        name: fallback.name ?? primary.name ?? defaultName,
+        version: fallback.version ?? primary.version,
+        description: fallback.description ?? primary.description,
+        repository: fallback.repository ?? primary.repository,
+        pi: fallback.pi ?? primary.pi,
+    };
+}
+function emptyResolvedPaths() {
+    return { extensions: [], skills: [], prompts: [], themes: [] };
+}
+function stringField(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function repositoryUrl(value) {
+    if (typeof value === "string")
+        return value;
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        const url = value.url;
+        return typeof url === "string" ? url : undefined;
+    }
+    return undefined;
+}
+function resourceTypesFromManifest(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return [];
+    const manifest = value;
+    const pairs = [
+        ["extensions", "extension"],
+        ["skills", "skill"],
+        ["prompts", "prompt"],
+        ["themes", "theme"],
+    ];
+    return pairs.flatMap(([key, type]) => Array.isArray(manifest[key]) && manifest[key].length > 0 ? [type] : []);
+}
+function resourceTypesFromResolvedPaths(paths) {
+    return [
+        ...(paths.extensions.length ? ["extension"] : []),
+        ...(paths.skills.length ? ["skill"] : []),
+        ...(paths.prompts.length ? ["prompt"] : []),
+        ...(paths.themes.length ? ["theme"] : []),
+    ];
+}
+function mergeResourceTypes(...groups) {
+    const order = ["extension", "skill", "prompt", "theme"];
+    const selected = new Set(groups.flat());
+    return order.filter((type) => selected.has(type));
+}
+function pathsOrUndefined(resources) {
+    const paths = [...new Set(resources.map((resource) => resource.path))];
+    return paths.length ? paths : undefined;
+}
+function namesOrUndefined(resources) {
+    const names = [...new Set(resources.map((resource) => basename(resource.path).replace(/\.[^.]+$/, "")))];
+    return names.length ? names : undefined;
+}