@vxnus/siduri 0.0.6 → 0.0.8

package/dist/index.js

@@ -4,6 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.colors = exports.CLI_VERSION = void 0;
+exports.printHeader = printHeader;
+exports.printSection = printSection;
+exports.printSuccess = printSuccess;
+exports.projectDirectoryName = projectDirectoryName;
+exports.formatReviewSummary = formatReviewSummary;
+exports.withTask = withTask;
 exports.runCreateWizard = runCreateWizard;
 exports.runCliDoctor = runCliDoctor;
 exports.runCliDb = runCliDb;
@@ -16,24 +23,26 @@ const discovery_1 = require("./discovery");
 const generator_1 = require("./generator");
 const doctor_1 = require("./doctor");
 const db_1 = require("./db");
+const configurators_1 = require("./configurators");
 const execFile = (0, node_util_1.promisify)(node_child_process_1.execFile);
-const CLI_VERSION = '0.0.6';
-const colors = {
+exports.CLI_VERSION = '0.0.8';
+exports.colors = {
     cyan: '\u001b[36m',
     dim: '\u001b[2m',
     green: '\u001b[32m',
     yellow: '\u001b[33m',
+    bold: '\u001b[1m',
     reset: '\u001b[0m',
 };
 function printHeader() {
-    console.log(`\n${colors.cyan}◈ SIDURI${colors.reset} ${colors.dim}companion setup (manifest-driven)${colors.reset}`);
-    console.log(`${colors.yellow}Version ${CLI_VERSION}${colors.reset} · composable standalone architecture\n`);
+    console.log(`\n${exports.colors.cyan}◈ SIDURI${exports.colors.reset} ${exports.colors.dim}companion setup (manifest-driven)${exports.colors.reset}`);
+    console.log(`${exports.colors.yellow}Version ${exports.CLI_VERSION}${exports.colors.reset} · composable standalone architecture\n`);
 }
 function printSection(title) {
-    console.log(`\n${colors.cyan}── ${title} ${'─'.repeat(Math.max(2, 42 - title.length))}${colors.reset}`);
+    console.log(`\n${exports.colors.cyan}── ${title} ${'─'.repeat(Math.max(2, 42 - title.length))}${exports.colors.reset}\n`);
 }
 function printSuccess(message) {
-    console.log(`${colors.green}✓${colors.reset} ${message}`);
+    console.log(`${exports.colors.green}✓${exports.colors.reset} ${message}`);
 }
 function projectDirectoryName(value) {
     const slug = value
@@ -43,22 +52,47 @@ function projectDirectoryName(value) {
         .replace(/^-+|-+$/g, '');
     return slug || 'siduri';
 }
+function formatReviewSummary(companionName, selectedManifests, organSummaries) {
+    const lines = [];
+    lines.push(`\n${exports.colors.cyan}── Review ${companionName} ${'─'.repeat(Math.max(2, 42 - (companionName.length + 9)))}${exports.colors.reset}\n`);
+    lines.push(`  ${exports.colors.bold}Companion${exports.colors.reset}`);
+    lines.push(`    ${exports.colors.dim}Name:${exports.colors.reset}     ${companionName}\n`);
+    for (const m of selectedManifests) {
+        const isRequired = m.organType === 'brain';
+        const tag = isRequired ? ` ${exports.colors.dim}· required${exports.colors.reset}` : '';
+        lines.push(`  ${exports.colors.bold}${m.displayName.split(' ')[0] || m.organType}${exports.colors.reset}${tag}`);
+        const summary = organSummaries[m.configKey] || organSummaries[m.organType] || {};
+        const entries = Object.entries(summary);
+        if (entries.length === 0) {
+            lines.push(`    ${exports.colors.dim}Provider:${exports.colors.reset} ${m.displayName}`);
+        }
+        else {
+            for (const [key, val] of entries) {
+                const valStr = String(val);
+                lines.push(`    ${exports.colors.dim}${key}:${exports.colors.reset}${' '.repeat(Math.max(1, 10 - key.length))}${valStr}`);
+            }
+        }
+        lines.push('');
+    }
+    lines.push(`${exports.colors.cyan}${'─'.repeat(46)}${exports.colors.reset}\n`);
+    return lines.join('\n');
+}
 async function withTask(label, task) {
-    process.stdout.write(`${colors.dim}${label}${colors.reset}`);
+    process.stdout.write(`${exports.colors.dim}${label}${exports.colors.reset}`);
     const frames = ['·', '•', '●', '•'];
     let index = 0;
     const timer = setInterval(() => {
-        process.stdout.write(`\r${colors.dim}${label} ${frames[index++ % frames.length]}${colors.reset}`);
+        process.stdout.write(`\r${exports.colors.dim}${label} ${frames[index++ % frames.length]}${exports.colors.reset}`);
     }, 120);
     try {
         const result = await task();
         clearInterval(timer);
-        process.stdout.write(`\r${colors.green}✓${colors.reset} ${label}\n`);
+        process.stdout.write(`\r${exports.colors.green}✓${exports.colors.reset} ${label}\n`);
         return result;
     }
     catch (error) {
         clearInterval(timer);
-        process.stdout.write(`\r${colors.yellow}!${colors.reset} ${label}\n`);
+        process.stdout.write(`\r${exports.colors.yellow}!${exports.colors.reset} ${label}\n`);
         throw error;
     }
 }
@@ -86,7 +120,7 @@ async function runCreateWizard(targetDir) {
     const companionName = basicAnswers.name;
     const projectDir = targetDir ? node_path_1.default.resolve(process.cwd(), targetDir) : node_path_1.default.resolve(process.cwd(), projectDirectoryName(companionName));
     printSection('Organ Selection');
-    console.log(`${colors.dim}Select any combination of organs to compose into your standalone instance.${colors.reset}\n`);
+    console.log(`${exports.colors.dim}Select any combination of organs to compose into your standalone instance.${exports.colors.reset}\n`);
     // Brain is required by architecture contract for cognition
     const brainManifest = registry.get('brain');
     const nonBrainManifests = availableManifests.filter((m) => m.organType !== 'brain');
@@ -110,28 +144,77 @@ async function runCreateWizard(targetDir) {
         if (m)
             selectedManifests.push(m);
     }
-    printSection('Review Composition');
-    console.log(`  ${colors.dim}Companion Name:${colors.reset}  ${companionName}`);
-    console.log(`  ${colors.dim}Target Path:${colors.reset}     ${projectDir}`);
-    console.log(`  ${colors.dim}Core Protocol:${colors.reset}   @siduri-x/core`);
-    console.log(`  ${colors.dim}Selected Organs:${colors.reset}`);
+    // 2. Interactive Organ Configuration Stage
+    const organConfigs = {};
+    const organSummaries = {};
     for (const m of selectedManifests) {
-        console.log(`    - ${m.displayName} (${colors.dim}${m.name}${colors.reset})`);
+        const isRequired = m.organType === 'brain';
+        const sectionTitle = isRequired ? `${m.displayName.split(' ')[0] || m.organType} · required` : m.displayName.split(' ')[0] || m.organType;
+        printSection(sectionTitle);
+        const res = await (0, configurators_1.configureOrgan)(m, {
+            companionName,
+            existingConfig: organConfigs[m.configKey],
+        });
+        organConfigs[m.configKey] = res.config;
+        organSummaries[m.configKey] = res.summary || {};
     }
-    const { confirm } = await inquirer_1.default.prompt({
-        type: 'confirm',
-        name: 'confirm',
-        message: 'Generate standalone Siduri instance with these organs?',
-        default: true,
-    });
-    if (!confirm) {
-        console.log('Instance creation cancelled.');
-        return;
+    // 3. Final Review and Edit Loop
+    while (true) {
+        console.log(formatReviewSummary(companionName, selectedManifests, organSummaries));
+        const { reviewAction } = await inquirer_1.default.prompt({
+            type: 'list',
+            name: 'reviewAction',
+            message: `Create ${companionName} with this configuration?`,
+            choices: [
+                { name: 'Yes, create', value: 'create' },
+                { name: 'Go back and edit', value: 'edit' },
+                { name: 'Cancel', value: 'cancel' },
+            ],
+        });
+        if (reviewAction === 'cancel') {
+            console.log('Instance creation cancelled.');
+            return;
+        }
+        if (reviewAction === 'create') {
+            break;
+        }
+        if (reviewAction === 'edit') {
+            const editChoices = selectedManifests.map((m) => ({
+                name: `Edit ${m.displayName}`,
+                value: m.configKey,
+            }));
+            editChoices.push({ name: 'Edit all organs in sequence', value: '__ALL__' });
+            editChoices.push({ name: 'Back to review', value: '__BACK__' });
+            const { organToEdit } = await inquirer_1.default.prompt({
+                type: 'list',
+                name: 'organToEdit',
+                message: 'Which organ would you like to edit?',
+                choices: editChoices,
+            });
+            if (organToEdit === '__BACK__') {
+                continue;
+            }
+            const organsToReconfigure = organToEdit === '__ALL__'
+                ? selectedManifests
+                : selectedManifests.filter((m) => m.configKey === organToEdit);
+            for (const m of organsToReconfigure) {
+                const isRequired = m.organType === 'brain';
+                const sectionTitle = isRequired ? `${m.displayName.split(' ')[0] || m.organType} · required` : m.displayName.split(' ')[0] || m.organType;
+                printSection(sectionTitle);
+                const res = await (0, configurators_1.configureOrgan)(m, {
+                    companionName,
+                    existingConfig: organConfigs[m.configKey],
+                });
+                organConfigs[m.configKey] = res.config;
+                organSummaries[m.configKey] = res.summary || {};
+            }
+        }
     }
-    // 2. Generate Files
+    // 4. Generate Instance Files
     const files = (0, generator_1.generateInstanceFiles)({
         name: companionName,
         selectedManifests,
+        organConfigs,
     });
     await (0, promises_1.mkdir)(projectDir, { recursive: true });
     await (0, promises_1.mkdir)(node_path_1.default.join(projectDir, 'src'), { recursive: true });
@@ -145,7 +228,7 @@ async function runCreateWizard(targetDir) {
         await (0, promises_1.mkdir)(node_path_1.default.join(projectDir, 'assets/body/model'), { recursive: true });
     }
     printSuccess(`Generated standalone files at ${projectDir}`);
-    // 3. Install packages if not in dry-run
+    // 5. Install packages if not in dry-run
     try {
         await withTask('Installing dependencies (npm install)', async () => {
             await execFile('npm', ['install', '--no-audit', '--no-fund'], { cwd: projectDir });
@@ -153,48 +236,48 @@ async function runCreateWizard(targetDir) {
         printSuccess('Dependencies installed successfully.');
     }
     catch (err) {
-        console.warn(`${colors.yellow}!${colors.reset} Notice: npm install had warnings or requires network: ${err.message}`);
+        console.warn(`${exports.colors.yellow}!${exports.colors.reset} Notice: npm install had warnings or requires network: ${err.message}`);
     }
     printSection('Instance Ready');
-    console.log(`\nYour Siduri companion is ready! Next steps:\n`);
+    console.log(`Your Siduri companion is ready! Next steps:\n`);
     console.log(`  cd ${node_path_1.default.relative(process.cwd(), projectDir) || '.'}`);
-    console.log(`  cp .env.example .env   ${colors.dim}# Fill in required API keys/credentials${colors.reset}`);
-    console.log(`  npm start              ${colors.dim}# Start your standalone companion${colors.reset}\n`);
+    console.log(`  cp .env.example .env   ${exports.colors.dim}# Fill in required API keys/credentials${exports.colors.reset}`);
+    console.log(`  npm start              ${exports.colors.dim}# Start your standalone companion${exports.colors.reset}\n`);
 }
 async function runCliDoctor(targetDir) {
     printHeader();
     const dir = targetDir ? node_path_1.default.resolve(process.cwd(), targetDir) : process.cwd();
-    console.log(`${colors.cyan}Siduri Doctor${colors.reset}`);
-    console.log(`${colors.dim}─────────────${colors.reset}\n`);
+    console.log(`${exports.colors.cyan}Siduri Doctor${exports.colors.reset}`);
+    console.log(`${exports.colors.dim}─────────────${exports.colors.reset}\n`);
     try {
         const report = await (0, doctor_1.runDoctor)({ projectDir: dir });
-        console.log(`${colors.dim}Instance:${colors.reset} ${report.instanceName}`);
-        console.log(`${colors.dim}Organs:${colors.reset}   ${report.configuredOrgans.join(', ')}\n`);
+        console.log(`${exports.colors.dim}Instance:${exports.colors.reset} ${report.instanceName}`);
+        console.log(`${exports.colors.dim}Organs:${exports.colors.reset}   ${report.configuredOrgans.join(', ')}\n`);
         const categories = ['Environment', 'Services', 'Database', 'Health Probe'];
         for (const cat of categories) {
             const items = report.results.filter((r) => r.category === cat);
             if (items.length > 0) {
-                console.log(`${colors.cyan}${cat}${colors.reset}`);
+                console.log(`${exports.colors.cyan}${cat}${exports.colors.reset}`);
                 for (const item of items) {
                     if (item.status === 'PASS') {
-                        console.log(`  ${colors.green}✓${colors.reset} ${item.name} ${colors.dim}(${item.message || 'OK'})${colors.reset}`);
+                        console.log(`  ${exports.colors.green}✓${exports.colors.reset} ${item.name} ${exports.colors.dim}(${item.message || 'OK'})${exports.colors.reset}`);
                     }
                     else if (item.status === 'OPTIONAL_MISSING') {
-                        console.log(`  ${colors.dim}○${colors.reset} ${item.name} ${colors.dim}(Optional, not set)${colors.reset}`);
+                        console.log(`  ${exports.colors.dim}○${exports.colors.reset} ${item.name} ${exports.colors.dim}(Optional, not set)${exports.colors.reset}`);
                     }
                     else if (item.status === 'SKIPPED') {
-                        console.log(`  ${colors.dim}— ${item.name} (${item.message})${colors.reset}`);
+                        console.log(`  ${exports.colors.dim}— ${item.name} (${item.message})${exports.colors.reset}`);
                     }
                     else {
-                        console.log(`  ${colors.yellow}✗${colors.reset} ${item.name}`);
+                        console.log(`  ${exports.colors.yellow}✗${exports.colors.reset} ${item.name}`);
                         if (item.organName) {
-                            console.log(`    ${colors.dim}Required by:${colors.reset} ${item.organName}`);
+                            console.log(`    ${exports.colors.dim}Required by:${exports.colors.reset} ${item.organName}`);
                         }
                         if (item.message) {
-                            console.log(`    ${colors.yellow}${item.message}${colors.reset}`);
+                            console.log(`    ${exports.colors.yellow}${item.message}${exports.colors.reset}`);
                         }
                         if (item.remediation) {
-                            console.log(`    ${colors.dim}Remediation:${colors.reset} ${item.remediation}`);
+                            console.log(`    ${exports.colors.dim}Remediation:${exports.colors.reset} ${item.remediation}`);
                         }
                     }
                 }
@@ -202,16 +285,16 @@ async function runCliDoctor(targetDir) {
             }
         }
         if (report.passed) {
-            console.log(`${colors.green}Result: PASS${colors.reset}\n`);
+            console.log(`${exports.colors.green}Result: PASS${exports.colors.reset}\n`);
             process.exitCode = 0;
         }
         else {
-            console.log(`${colors.yellow}Result: FAIL${colors.reset}\n`);
+            console.log(`${exports.colors.yellow}Result: FAIL${exports.colors.reset}\n`);
             process.exitCode = 1;
         }
     }
     catch (err) {
-        console.error(`\n${colors.yellow}Doctor Error:${colors.reset} ${err.message}\n`);
+        console.error(`\n${exports.colors.yellow}Doctor Error:${exports.colors.reset} ${err.message}\n`);
         process.exitCode = 2;
     }
 }
@@ -223,24 +306,24 @@ async function runCliDb(subcommand, targetDir) {
         return;
     }
     const dir = targetDir ? node_path_1.default.resolve(process.cwd(), targetDir) : process.cwd();
-    console.log(`${colors.cyan}Siduri Database Migrations${colors.reset}`);
-    console.log(`${colors.dim}──────────────────────────${colors.reset}\n`);
+    console.log(`${exports.colors.cyan}Siduri Database Migrations${exports.colors.reset}`);
+    console.log(`${exports.colors.dim}──────────────────────────${exports.colors.reset}\n`);
     try {
         const res = await (0, db_1.runDbPush)({ projectDir: dir });
         if (res.status === 'NOOP') {
-            console.log(`${colors.dim}— ${res.message}${colors.reset}\n`);
+            console.log(`${exports.colors.dim}— ${res.message}${exports.colors.reset}\n`);
         }
         else {
             printSuccess(res.message);
             if (res.appliedMigrations.length > 0) {
-                console.log(`${colors.dim}Applied:${colors.reset} ${res.appliedMigrations.join(', ')}`);
+                console.log(`${exports.colors.dim}Applied:${exports.colors.reset} ${res.appliedMigrations.join(', ')}`);
             }
             console.log();
         }
         process.exitCode = 0;
     }
     catch (err) {
-        console.error(`\n${colors.yellow}Database Migration Error:${colors.reset} ${err.message}\n`);
+        console.error(`\n${exports.colors.yellow}Database Migration Error:${exports.colors.reset} ${err.message}\n`);
         process.exitCode = 3;
     }
 }
@@ -248,7 +331,7 @@ async function main() {
     const args = process.argv.slice(2);
     const command = args[0];
     if (command === '--version' || command === '-v') {
-        console.log(CLI_VERSION);
+        console.log(exports.CLI_VERSION);
         return;
     }
     if (command === 'create') {
@@ -279,7 +362,7 @@ if (require.main === module) {
             console.log('\nOperation cancelled.');
             return;
         }
-        console.error(`\n${colors.yellow}!${colors.reset} ${error instanceof Error ? error.message : error}`);
+        console.error(`\n${exports.colors.yellow}!${exports.colors.reset} ${error instanceof Error ? error.message : error}`);
         process.exitCode = 1;
     });
 }

package/dist/providers/knowledge-hub.d.ts

@@ -0,0 +1,37 @@
+export interface KnowledgeHubCapabilities {
+    search?: boolean;
+    retrieval?: boolean;
+    contextInjection?: boolean;
+    semanticSearch?: boolean;
+    lexicalSearch?: boolean;
+    [key: string]: unknown;
+}
+export interface KnowledgeHubManifest {
+    name: string;
+    displayName?: string;
+    publisher?: string;
+    package?: string;
+    version: string;
+    description?: string;
+    capabilities?: KnowledgeHubCapabilities | string[];
+    distribution?: {
+        kind?: string;
+        url?: string;
+    };
+    source?: string;
+    environment?: Array<{
+        name: string;
+        required?: boolean;
+        description?: string;
+    }>;
+}
+export declare const KNOWN_KNOWLEDGE_PACKS: Record<string, KnowledgeHubManifest>;
+export declare function validateKnowledgeManifest(raw: unknown, packId?: string): KnowledgeHubManifest;
+export declare function extractCapabilitiesList(capabilities?: KnowledgeHubCapabilities | string[]): string[];
+export declare class KnowledgeHubClient {
+    private registryUrl;
+    private timeoutMs;
+    constructor(registryUrl?: string, timeoutMs?: number);
+    resolveProvider(packId: string): Promise<KnowledgeHubManifest>;
+}
+export declare function displayKnowledgeProviderSummary(manifest: KnowledgeHubManifest, packId: string): void;

package/dist/providers/knowledge-hub.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnowledgeHubClient = exports.KNOWN_KNOWLEDGE_PACKS = void 0;
+exports.validateKnowledgeManifest = validateKnowledgeManifest;
+exports.extractCapabilitiesList = extractCapabilitiesList;
+exports.displayKnowledgeProviderSummary = displayKnowledgeProviderSummary;
+exports.KNOWN_KNOWLEDGE_PACKS = {
+    '@vxnus/e-teyvat': {
+        name: 'e-teyvat',
+        displayName: 'E Teyvat',
+        publisher: 'vxnus',
+        package: '@vxnus/e-teyvat',
+        version: '1.2.0',
+        description: 'Teyvat knowledge provider for Siduri.',
+        capabilities: ['Search', 'Retrieval', 'Context injection'],
+        distribution: {
+            kind: 'provider',
+            url: 'https://teyvat.e.vxnus.xyz',
+        },
+        source: 'E Knowledge Hub',
+    },
+};
+function validateKnowledgeManifest(raw, packId) {
+    if (!raw || typeof raw !== 'object') {
+        throw new Error(`Invalid knowledge manifest: expected object.`);
+    }
+    const m = raw;
+    if (!m.name || typeof m.name !== 'string') {
+        throw new Error(`Invalid knowledge manifest: missing 'name' field.`);
+    }
+    if (!m.version || typeof m.version !== 'string') {
+        throw new Error(`Invalid knowledge manifest: missing 'version' field.`);
+    }
+    return {
+        name: m.name,
+        displayName: m.displayName || m.name,
+        publisher: m.publisher,
+        package: m.package || packId || m.name,
+        version: m.version,
+        description: m.description || 'Knowledge pack provider',
+        capabilities: m.capabilities || ['Search', 'Retrieval'],
+        distribution: m.distribution,
+        source: m.source || 'E Knowledge Hub',
+        environment: m.environment || [],
+    };
+}
+function extractCapabilitiesList(capabilities) {
+    if (!capabilities) {
+        return ['Search', 'Retrieval'];
+    }
+    if (Array.isArray(capabilities)) {
+        return capabilities.map((c) => String(c));
+    }
+    const result = [];
+    if (capabilities.lexicalSearch || capabilities.search)
+        result.push('Search');
+    result.push('Retrieval');
+    if (capabilities.contextInjection)
+        result.push('Context injection');
+    if (capabilities.semanticSearch)
+        result.push('Semantic search');
+    if (capabilities.structuredEntities)
+        result.push('Structured entities');
+    if (capabilities.relations)
+        result.push('Entity relations');
+    if (capabilities.revisions)
+        result.push('Content revisions');
+    for (const [key, val] of Object.entries(capabilities)) {
+        if (val === true && !['search', 'retrieval', 'contextInjection', 'semanticSearch', 'lexicalSearch', 'structuredEntities', 'relations', 'revisions'].includes(key)) {
+            result.push(key);
+        }
+    }
+    return result.length > 0 ? result : ['Search', 'Retrieval'];
+}
+class KnowledgeHubClient {
+    registryUrl;
+    timeoutMs;
+    constructor(registryUrl = 'https://e.vxnus.xyz/api/v1/knowledge', timeoutMs = 5000) {
+        this.registryUrl = registryUrl.replace(/\/+$/, '');
+        this.timeoutMs = timeoutMs;
+    }
+    async resolveProvider(packId) {
+        const trimmed = packId.trim();
+        const match = trimmed.match(/^@([^/]+)\/([^/]+)$/);
+        if (!match) {
+            throw new Error(`Invalid package ID format "${packId}". Expected format: @publisher/name (e.g. @vxnus/e-teyvat)`);
+        }
+        const publisher = match[1];
+        const name = match[2];
+        const url = `${this.registryUrl}/${encodeURIComponent(publisher)}/${encodeURIComponent(name)}`;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: { Accept: 'application/json' },
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                // Check offline/built-in catalog fallback for known pack IDs
+                if (exports.KNOWN_KNOWLEDGE_PACKS[trimmed]) {
+                    return exports.KNOWN_KNOWLEDGE_PACKS[trimmed];
+                }
+                throw new Error(`HTTP ${response.status}: ${response.statusText} for ${packId}`);
+            }
+            const body = await response.json();
+            return validateKnowledgeManifest(body, trimmed);
+        }
+        catch (err) {
+            // If network fails and known pack exists, use fallback
+            if (exports.KNOWN_KNOWLEDGE_PACKS[trimmed]) {
+                return exports.KNOWN_KNOWLEDGE_PACKS[trimmed];
+            }
+            throw new Error(`Failed to resolve package "${packId}" from E Knowledge Hub: ${err.message}`);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+exports.KnowledgeHubClient = KnowledgeHubClient;
+function displayKnowledgeProviderSummary(manifest, packId) {
+    const cyan = '\u001b[36m';
+    const dim = '\u001b[2m';
+    const reset = '\u001b[0m';
+    console.log(`\n${cyan}── Knowledge Provider ────────────────────────${reset}\n`);
+    console.log(`  ${dim}Name:${reset}        ${manifest.displayName || manifest.name}`);
+    console.log(`  ${dim}Package:${reset}     ${packId}`);
+    console.log(`  ${dim}Version:${reset}     ${manifest.version}`);
+    if (manifest.description) {
+        console.log(`\n  ${dim}Description:${reset}`);
+        console.log(`  ${manifest.description}`);
+    }
+    const caps = extractCapabilitiesList(manifest.capabilities);
+    console.log(`\n  ${dim}Capabilities:${reset}`);
+    for (const cap of caps) {
+        console.log(`    • ${cap}`);
+    }
+    console.log(`\n  ${dim}Source:${reset}`);
+    console.log(`    ${manifest.source || 'E Knowledge Hub'}\n`);
+}

package/dist/providers/openrouter.d.ts

@@ -0,0 +1,32 @@
+export interface ModelOption {
+    id: string;
+    name: string;
+    description?: string;
+    contextLength?: number;
+}
+export interface ModelProvider {
+    listModels(): Promise<ModelOption[]>;
+}
+export declare const CURATED_OPENROUTER_MODELS: ModelOption[];
+export declare class OpenRouterModelProvider implements ModelProvider {
+    private apiUrl;
+    private timeoutMs;
+    constructor(apiUrl?: string, timeoutMs?: number);
+    listModels(): Promise<ModelOption[]>;
+}
+export type ModelSelectionResult = {
+    type: 'selected';
+    modelId: string;
+    modelName: string;
+} | {
+    type: 'manual';
+    modelId: string;
+} | {
+    type: 'switch_provider';
+} | {
+    type: 'cancel';
+};
+/**
+ * Interactive model selector with search, pagination, and robust error recovery.
+ */
+export declare function promptOpenRouterModelSelection(provider?: ModelProvider): Promise<ModelSelectionResult>;