@vxnus/siduri 0.0.5 → 0.0.7

package/dist/index.js

@@ -4,26 +4,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const node_crypto_1 = require("node:crypto");
+exports.runCreateWizard = runCreateWizard;
+exports.runCliDoctor = runCliDoctor;
+exports.runCliDb = runCliDb;
 const node_child_process_1 = require("node:child_process");
 const promises_1 = require("node:fs/promises");
-const node_os_1 = require("node:os");
 const node_path_1 = __importDefault(require("node:path"));
 const node_util_1 = require("node:util");
 const inquirer_1 = __importDefault(require("inquirer"));
-const e_knowledge_1 = require("@vxnus/e-knowledge");
+const discovery_1 = require("./discovery");
+const generator_1 = require("./generator");
+const doctor_1 = require("./doctor");
+const db_1 = require("./db");
 const execFile = (0, node_util_1.promisify)(node_child_process_1.execFile);
-const DEFAULT_REGISTRY_URL = 'https://e.vxnus.xyz/api/v1/knowledge';
-const CLI_VERSION = '0.0.5';
-const RUNTIME_DEPENDENCIES = {
-    '@vxnus/e': '^0.1.4',
-    '@vxnus/e-knowledge': '^0.1.4',
-    cors: '^2.8.5',
-    express: '^4.18.2',
-    pg: '^8.23.0',
-    ws: '^8.21.3',
-    zod: '^4.4.3',
-};
+const CLI_VERSION = '0.0.7';
 const colors = {
     cyan: '\u001b[36m',
     dim: '\u001b[2m',
@@ -32,8 +26,8 @@ const colors = {
     reset: '\u001b[0m',
 };
 function printHeader() {
-    console.log(`\n${colors.cyan}◈ SIDURI${colors.reset} ${colors.dim}companion setup${colors.reset}`);
-    console.log(`${colors.yellow}Experimental release 0.0.5${colors.reset} · configuration may change\n`);
+    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`);
 }
 function printSection(title) {
     console.log(`\n${colors.cyan}── ${title} ${'─'.repeat(Math.max(2, 42 - title.length))}${colors.reset}`);
@@ -41,35 +35,13 @@ function printSection(title) {
 function printSuccess(message) {
     console.log(`${colors.green}✓${colors.reset} ${message}`);
 }
-function runtimePath() {
-    const projectRuntime = node_path_1.default.join(process.cwd(), 'siduri-runtime.js');
-    return node_path_1.default.resolve(pathExists(projectRuntime) ? projectRuntime : node_path_1.default.join(__dirname, 'runtime.js'));
-}
-function pathExists(filePath) {
-    try {
-        require('node:fs').accessSync(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function startRuntime() {
-    const filePath = runtimePath();
-    if (!pathExists(filePath)) {
-        throw new Error('Siduri runtime bundle is missing. Reinstall the CLI or rebuild the package.');
-    }
-    await new Promise((resolve, reject) => {
-        const child = (0, node_child_process_1.spawn)(process.execPath, [filePath], { stdio: 'inherit', env: process.env });
-        child.once('error', reject);
-        child.once('exit', (code, signal) => {
-            if (signal)
-                process.exitCode = 1;
-            else if (code !== null)
-                process.exitCode = code;
-            resolve();
-        });
-    });
+function projectDirectoryName(value) {
+    const slug = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return slug || 'siduri';
 }
 async function withTask(label, task) {
     process.stdout.write(`${colors.dim}${label}${colors.reset}`);
@@ -93,351 +65,221 @@ async function withTask(label, task) {
 function nonEmpty(value) {
     return value.trim().length > 0 || 'Please enter a value.';
 }
-function urlValue(value) {
-    try {
-        const url = new URL(value);
-        return ['http:', 'https:'].includes(url.protocol) || 'Use an HTTP(S) URL.';
+async function runCreateWizard(targetDir) {
+    printHeader();
+    // 1. Discover manifests from installed or monorepo packages
+    const registry = discovery_1.OrganRegistry.discover();
+    const availableManifests = registry.getAll();
+    if (availableManifests.length === 0) {
+        throw new Error('No @siduri-x/* organ packages found. Please ensure organs are installed or in workspace.');
     }
-    catch {
-        return 'Use a valid HTTP(S) URL.';
+    printSection('Companion Details');
+    const basicAnswers = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Companion name:',
+            default: 'Siduri',
+            validate: nonEmpty,
+        },
+    ]);
+    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`);
+    // Brain is required by architecture contract for cognition
+    const brainManifest = registry.get('brain');
+    const nonBrainManifests = availableManifests.filter((m) => m.organType !== 'brain');
+    const organChoices = nonBrainManifests.map((m) => ({
+        name: `${m.displayName} (${m.name})`,
+        value: m.organType,
+        checked: m.organType === 'memory', // default memory checked
+    }));
+    const { selectedOrganTypes } = await inquirer_1.default.prompt({
+        type: 'checkbox',
+        name: 'selectedOrganTypes',
+        message: 'Select organs to install:',
+        choices: organChoices,
+    });
+    const selectedManifests = [];
+    if (brainManifest) {
+        selectedManifests.push(brainManifest);
     }
-}
-function safePart(value) {
-    return value.replace(/[^a-zA-Z0-9._-]/g, '_');
-}
-function projectDirectoryName(value) {
-    const slug = value
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '');
-    return slug || 'siduri';
-}
-async function getJson(url) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 15000);
-    let response;
-    try {
-        response = await fetch(url, { headers: { accept: 'application/json' }, signal: controller.signal });
+    for (const organType of selectedOrganTypes) {
+        const m = registry.get(organType);
+        if (m)
+            selectedManifests.push(m);
     }
-    finally {
-        clearTimeout(timeout);
+    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}`);
+    for (const m of selectedManifests) {
+        console.log(`    - ${m.displayName} (${colors.dim}${m.name}${colors.reset})`);
     }
-    if (!response.ok)
-        throw new Error(`${url} returned HTTP ${response.status}`);
-    return response.json();
-}
-async function findManifest(root) {
-    try {
-        await (0, promises_1.readFile)(node_path_1.default.join(root, 'manifest.json'), 'utf8');
-        return root;
+    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;
     }
-    catch {
-        // Archives may contain one top-level directory.
+    // 2. Generate Files
+    const files = (0, generator_1.generateInstanceFiles)({
+        name: companionName,
+        selectedManifests,
+    });
+    await (0, promises_1.mkdir)(projectDir, { recursive: true });
+    await (0, promises_1.mkdir)(node_path_1.default.join(projectDir, 'src'), { recursive: true });
+    await (0, promises_1.writeFile)(node_path_1.default.join(projectDir, 'package.json'), files['package.json'], 'utf8');
+    await (0, promises_1.writeFile)(node_path_1.default.join(projectDir, 'siduri.config.json'), files['siduri.config.json'], 'utf8');
+    await (0, promises_1.writeFile)(node_path_1.default.join(projectDir, 'siduri.schema.json'), files['siduri.schema.json'], 'utf8');
+    await (0, promises_1.writeFile)(node_path_1.default.join(projectDir, '.env.example'), files['.env.example'], 'utf8');
+    await (0, promises_1.writeFile)(node_path_1.default.join(projectDir, 'README.md'), files['README.md'], 'utf8');
+    await (0, promises_1.writeFile)(node_path_1.default.join(projectDir, 'src/index.js'), files['src/index.js'], 'utf8');
+    if (files.createAssetsBodyDir) {
+        await (0, promises_1.mkdir)(node_path_1.default.join(projectDir, 'assets/body/model'), { recursive: true });
     }
-    for (const entry of await (0, promises_1.readdir)(root, { withFileTypes: true })) {
-        if (!entry.isDirectory())
-            continue;
-        try {
-            await (0, promises_1.readFile)(node_path_1.default.join(root, entry.name, 'manifest.json'), 'utf8');
-            return node_path_1.default.join(root, entry.name);
-        }
-        catch {
-            // Continue searching immediate children.
-        }
+    printSuccess(`Generated standalone files at ${projectDir}`);
+    // 3. 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 });
+        });
+        printSuccess('Dependencies installed successfully.');
     }
-    throw new Error('Downloaded archive does not contain a manifest.json at its root');
-}
-async function installArchive(pack) {
-    const response = await fetch(pack.distribution.url);
-    if (!response.ok)
-        throw new Error(`Pack archive returned HTTP ${response.status}`);
-    const archive = Buffer.from(await response.arrayBuffer());
-    if (pack.distribution.checksum) {
-        const checksum = (0, node_crypto_1.createHash)('sha256').update(archive).digest('hex');
-        if (checksum !== pack.distribution.checksum) {
-            throw new Error(`Pack archive checksum mismatch for ${pack.id}@${pack.version}`);
-        }
+    catch (err) {
+        console.warn(`${colors.yellow}!${colors.reset} Notice: npm install had warnings or requires network: ${err.message}`);
     }
-    const work = await (0, promises_1.mkdtemp)(node_path_1.default.join((0, node_os_1.tmpdir)(), 'siduri-pack-'));
+    printSection('Instance Ready');
+    console.log(`\nYour 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`);
+}
+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`);
     try {
-        const archivePath = node_path_1.default.join(work, 'pack.tar.gz');
-        const extractedPath = node_path_1.default.join(work, 'extracted');
-        await (0, promises_1.writeFile)(archivePath, archive);
-        await (0, promises_1.mkdir)(extractedPath);
-        const { stdout: listing } = await execFile('tar', ['-tzf', archivePath]);
-        if (listing.split('\n').some((entry) => entry.startsWith('/') || entry.split('/').includes('..'))) {
-            throw new Error('Pack archive contains an unsafe path');
+        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`);
+        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}`);
+                for (const item of items) {
+                    if (item.status === 'PASS') {
+                        console.log(`  ${colors.green}✓${colors.reset} ${item.name} ${colors.dim}(${item.message || 'OK'})${colors.reset}`);
+                    }
+                    else if (item.status === 'OPTIONAL_MISSING') {
+                        console.log(`  ${colors.dim}○${colors.reset} ${item.name} ${colors.dim}(Optional, not set)${colors.reset}`);
+                    }
+                    else if (item.status === 'SKIPPED') {
+                        console.log(`  ${colors.dim}— ${item.name} (${item.message})${colors.reset}`);
+                    }
+                    else {
+                        console.log(`  ${colors.yellow}✗${colors.reset} ${item.name}`);
+                        if (item.organName) {
+                            console.log(`    ${colors.dim}Required by:${colors.reset} ${item.organName}`);
+                        }
+                        if (item.message) {
+                            console.log(`    ${colors.yellow}${item.message}${colors.reset}`);
+                        }
+                        if (item.remediation) {
+                            console.log(`    ${colors.dim}Remediation:${colors.reset} ${item.remediation}`);
+                        }
+                    }
+                }
+                console.log();
+            }
+        }
+        if (report.passed) {
+            console.log(`${colors.green}Result: PASS${colors.reset}\n`);
+            process.exitCode = 0;
+        }
+        else {
+            console.log(`${colors.yellow}Result: FAIL${colors.reset}\n`);
+            process.exitCode = 1;
         }
-        await execFile('tar', ['-xzf', archivePath, '-C', extractedPath, '--no-same-owner', '--no-same-permissions', '--no-absolute-names']);
-        const sourcePath = await findManifest(extractedPath);
-        const destination = node_path_1.default.join((0, node_os_1.homedir)(), '.siduri', 'knowledge', safePart(pack.publisher), safePart(pack.name), safePart(pack.version));
-        await (0, promises_1.mkdir)(node_path_1.default.dirname(destination), { recursive: true });
-        await (0, promises_1.rm)(destination, { recursive: true, force: true });
-        await (0, promises_1.cp)(sourcePath, destination, { recursive: true });
-        return destination;
     }
-    finally {
-        await (0, promises_1.rm)(work, { recursive: true, force: true });
+    catch (err) {
+        console.error(`\n${colors.yellow}Doctor Error:${colors.reset} ${err.message}\n`);
+        process.exitCode = 2;
     }
 }
-async function chooseHubPack(registryUrl) {
-    const { query } = await inquirer_1.default.prompt({
-        type: 'input',
-        name: 'query',
-        message: 'Search E Knowledge Hub or enter package ID (e.g. @vxnus/e-teyvat):',
-    });
-    const normalized = query.trim().replace(/^@/, '');
-    const [publisher, name] = normalized.split('/');
-    const result = publisher && name && !query.includes(' ')
-        ? await withTask('Searching E Knowledge Hub', () => getJson(`${registryUrl}/${encodeURIComponent(publisher)}/${encodeURIComponent(name)}`))
-        : await withTask('Searching E Knowledge Hub', () => getJson(`${registryUrl}?q=${encodeURIComponent(query)}&limit=20`));
-    const packs = 'packs' in result ? result.packs : [result];
-    if (packs.length === 0)
-        throw new Error(`No knowledge packs found for '${query}'`);
-    if (packs.length === 1)
-        return packs[0];
-    const { selected } = await inquirer_1.default.prompt({
-        type: 'list',
-        name: 'selected',
-        message: 'Select a knowledge pack:',
-        choices: packs.map((pack) => ({ name: `${pack.id} v${pack.version}`, value: pack.id })),
-    });
-    return packs.find((pack) => pack.id === selected);
-}
-async function configureKnowledge() {
-    const { mode } = await inquirer_1.default.prompt({
-        type: 'list',
-        name: 'mode',
-        message: 'Knowledge source?',
-        choices: [
-            { name: 'E Knowledge Hub', value: 'hub' },
-            { name: 'Installed local pack', value: 'local' },
-            { name: 'Hosted provider URL', value: 'remote' },
-            { name: 'Do not use knowledge', value: 'none' },
-        ],
-    });
-    if (mode === 'none')
-        return { provider: 'none' };
-    if (mode === 'local') {
-        const { packPath } = await inquirer_1.default.prompt({
-            type: 'input',
-            name: 'packPath',
-            message: 'Path to the installed E knowledge pack:',
-            default: './knowledge-pack',
-        });
-        const resolved = node_path_1.default.resolve(packPath);
-        const loaded = await withTask('Validating local knowledge pack', () => (0, e_knowledge_1.loadPack)(resolved));
-        printSuccess(`Knowledge ready · ${loaded.manifest.id} · revision ${loaded.revision.id}`);
-        return { provider: 'e-knowledge', packPath: resolved };
+async function runCliDb(subcommand, targetDir) {
+    printHeader();
+    if (subcommand !== 'push') {
+        console.log('Usage: siduri db push');
+        process.exitCode = 2;
+        return;
     }
-    if (mode === 'remote') {
-        const { baseUrl } = await inquirer_1.default.prompt({
-            type: 'input',
-            name: 'baseUrl',
-            message: 'Remote knowledge provider URL:',
-        });
-        const provider = (0, e_knowledge_1.createRemoteProvider)({ baseUrl, timeoutMs: 5000 });
-        const manifest = await withTask('Checking provider manifest', async () => {
-            if (!provider.manifest) {
-                throw new Error('Remote knowledge provider does not support manifest inspection');
+    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`);
+    try {
+        const res = await (0, db_1.runDbPush)({ projectDir: dir });
+        if (res.status === 'NOOP') {
+            console.log(`${colors.dim}— ${res.message}${colors.reset}\n`);
+        }
+        else {
+            printSuccess(res.message);
+            if (res.appliedMigrations.length > 0) {
+                console.log(`${colors.dim}Applied:${colors.reset} ${res.appliedMigrations.join(', ')}`);
             }
-            return provider.manifest();
-        });
-        printSuccess(`Provider ready · ${manifest.id}`);
-        return { provider: 'e-remote', baseUrl: baseUrl.replace(/\/+$/, ''), timeoutMs: 5000 };
-    }
-    const registryUrl = (process.env.E_REGISTRY_URL || process.env.SIDURI_KNOWLEDGE_REGISTRY_URL || DEFAULT_REGISTRY_URL).replace(/\/+$/, '');
-    const pack = await chooseHubPack(registryUrl);
-    if (pack.distribution.kind === 'archive') {
-        const { install } = await inquirer_1.default.prompt({
-            type: 'confirm',
-            name: 'install',
-            message: `Install ${pack.id} v${pack.version} locally?`,
-            default: true,
-        });
-        if (install) {
-            const packPath = await withTask(`Installing ${pack.id}@${pack.version}`, () => installArchive(pack));
-            const loaded = await withTask('Validating installed knowledge pack', () => (0, e_knowledge_1.loadPack)(packPath));
-            printSuccess(`Knowledge ready · ${loaded.manifest.id} · revision ${loaded.revision.id}`);
-            return { provider: 'e-knowledge', packPath };
+            console.log();
         }
+        process.exitCode = 0;
     }
-    if (pack.distribution.kind !== 'provider') {
-        throw new Error('Archive installation was declined and no hosted provider is available');
+    catch (err) {
+        console.error(`\n${colors.yellow}Database Migration Error:${colors.reset} ${err.message}\n`);
+        process.exitCode = 3;
     }
-    const provider = (0, e_knowledge_1.createRemoteProvider)({ baseUrl: pack.distribution.url, timeoutMs: 5000, manifest: pack });
-    await withTask('Checking provider manifest', async () => {
-        if (provider.manifest) {
-            return provider.manifest();
-        }
-        const cleanUrl = pack.distribution.url.replace(/\/+$/, '');
-        const res = await fetch(`${cleanUrl}/manifest`, { headers: { accept: 'application/json' } });
-        if (res.ok)
-            return res.json();
-        return pack;
-    });
-    printSuccess(`Provider ready · ${pack.id}`);
-    return { provider: 'e-hub', registryUrl, packId: pack.id, timeoutMs: 5000 };
 }
 async function main() {
-    const command = process.argv[2];
+    const args = process.argv.slice(2);
+    const command = args[0];
     if (command === '--version' || command === '-v') {
         console.log(CLI_VERSION);
         return;
     }
-    if (command === 'start') {
-        await startRuntime();
+    if (command === 'create') {
+        const targetDir = args[1];
+        await runCreateWizard(targetDir);
         return;
     }
-    if (command !== 'create') {
-        printHeader();
-        console.log('Usage: npx @vxnus/siduri create');
-        console.log('       npx @vxnus/siduri start');
-        console.log('       npx @vxnus/siduri --version');
+    if (command === 'doctor') {
+        const targetDir = args[1];
+        await runCliDoctor(targetDir);
+        return;
+    }
+    if (command === 'db') {
+        const subcommand = args[1];
+        const targetDir = args[2];
+        await runCliDb(subcommand, targetDir);
         return;
     }
     printHeader();
-    printSection('Companion');
-    const answers = await inquirer_1.default.prompt([
-        { type: 'input', name: 'name', message: 'Companion name:', default: 'Siduri', validate: nonEmpty },
-        {
-            type: 'list',
-            name: 'memoryEngine',
-            message: 'Memory database?',
-            choices: [
-                { name: 'PostgreSQL', value: 'postgres' },
-                { name: 'SQLite (future)', value: 'sqlite', disabled: 'Coming soon' },
-            ],
-        },
-    ]);
-    const { memoryDeployment } = await inquirer_1.default.prompt({
-        type: 'list',
-        name: 'memoryDeployment',
-        message: 'PostgreSQL deployment?',
-        choices: [
-            { name: 'Local PostgreSQL', value: 'local' },
-            { name: 'Neon', value: 'neon' },
-            { name: 'Supabase', value: 'supabase' },
-            { name: 'Other PostgreSQL provider', value: 'other' },
-        ],
-    });
-    const projectPath = node_path_1.default.resolve(process.cwd(), projectDirectoryName(answers.name));
-    await (0, promises_1.mkdir)(projectPath, { recursive: true });
-    printSuccess(`${answers.name} · PostgreSQL / ${memoryDeployment} · ${projectPath}`);
-    printSection('Brain · required');
-    const { brainProvider } = await inquirer_1.default.prompt({
-        type: 'list',
-        name: 'brainProvider',
-        message: 'Brain provider?',
-        choices: [
-            { name: 'OpenRouter (managed model routing)', value: 'openrouter' },
-            { name: 'OpenAI-compatible API (custom endpoint)', value: 'openai-compatible' },
-        ],
-    });
-    const brain = brainProvider === 'openrouter'
-        ? {
-            provider: 'openrouter',
-            model: (await inquirer_1.default.prompt({ type: 'input', name: 'model', message: 'Model ID:', default: 'openai/gpt-4o-mini', validate: nonEmpty })).model,
-            apiKeyEnv: 'OPENROUTER_API_KEY',
-        }
-        : await (async () => {
-            const values = await inquirer_1.default.prompt([
-                { type: 'input', name: 'baseUrl', message: 'OpenAI-compatible API base URL:', default: 'http://127.0.0.1:1234/v1', validate: urlValue },
-                { type: 'input', name: 'model', message: 'Model ID:', default: 'local-model', validate: nonEmpty },
-                { type: 'input', name: 'apiKeyEnv', message: 'API key environment variable:', default: 'OPENAI_COMPATIBLE_API_KEY', validate: nonEmpty },
-            ]);
-            return { provider: 'openai-compatible', ...values };
-        })();
-    printSuccess(`${brain.provider} · ${brain.model}`);
-    printSection('Optional organs');
-    const { voice } = await inquirer_1.default.prompt({
-        type: 'list',
-        name: 'voice',
-        message: 'Voice provider?',
-        choices: [
-            { name: 'VOICEVOX', value: 'voicevox' },
-            { name: 'Do not use voice', value: 'none' },
-        ],
-    });
-    const knowledge = await configureKnowledge();
-    const remaining = await inquirer_1.default.prompt([
-        { type: 'list', name: 'behavior', message: 'Behavior preset?', choices: [{ name: 'Calm', value: 'Calm' }, { name: 'Cheerful, Encouraging', value: 'Cheerful, Encouraging' }, { name: 'Do not use custom behavior', value: 'none' }] },
-        { type: 'list', name: 'body', message: 'Body provider?', choices: [{ name: 'Live2D Body (Renderer-agnostic)', value: 'live2d' }, { name: 'Do not use body', value: 'none' }] },
-        { type: 'list', name: 'vision', message: 'Vision provider?', choices: [{ name: 'OpenRouter vision', value: 'openrouter' }, { name: 'Do not use vision', value: 'none' }] },
-    ]);
-    const config = {
-        id: 'default',
-        name: answers.name,
-        brain,
-        voice: { provider: voice, speakerId: 1 },
-        memory: { provider: answers.memoryEngine, deployment: memoryDeployment },
-        knowledge,
-        behavior: { provider: remaining.behavior === 'none' ? 'none' : 'active_self', preset: remaining.behavior },
-        body: { provider: remaining.body },
-        vision: { provider: remaining.vision, model: 'gpt-4-vision' },
-    };
-    const configPath = node_path_1.default.join(projectPath, 'siduri.config.json');
-    try {
-        await (0, promises_1.readFile)(configPath, 'utf8');
-        const { overwrite } = await inquirer_1.default.prompt({
-            type: 'confirm',
-            name: 'overwrite',
-            message: `${node_path_1.default.basename(configPath)} already exists. Replace it?`,
-            default: false,
-        });
-        if (!overwrite) {
-            console.log('Configuration left unchanged.');
+    console.log('Usage: npx @vxnus/siduri create [directory]');
+    console.log('       npx @vxnus/siduri doctor [directory]');
+    console.log('       npx @vxnus/siduri db push [directory]');
+    console.log('       npx @vxnus/siduri --version\n');
+}
+if (require.main === module) {
+    main().catch((error) => {
+        if (error && typeof error === 'object' && 'name' in error && error.name === 'ExitPromptError') {
+            console.log('\nOperation cancelled.');
             return;
         }
-    }
-    catch {
-        // New configuration.
-    }
-    printSection('Review');
-    console.log(`  ${colors.dim}companion${colors.reset}  ${config.name}`);
-    console.log(`  ${colors.dim}brain${colors.reset}      ${config.brain.provider} · ${config.brain.model}`);
-    console.log(`  ${colors.dim}memory${colors.reset}     ${config.memory.provider}`);
-    console.log(`  ${colors.dim}voice${colors.reset}      ${config.voice.provider}`);
-    console.log(`  ${colors.dim}knowledge${colors.reset}  ${config.knowledge.provider}`);
-    console.log(`  ${colors.dim}behavior${colors.reset}   ${config.behavior.provider}`);
-    console.log(`  ${colors.dim}body${colors.reset}       ${config.body.provider}`);
-    console.log(`  ${colors.dim}vision${colors.reset}     ${config.vision.provider}`);
-    const { confirm } = await inquirer_1.default.prompt({
-        type: 'confirm',
-        name: 'confirm',
-        message: 'Write this Siduri configuration?',
-        default: true,
+        console.error(`\n${colors.yellow}!${colors.reset} ${error instanceof Error ? error.message : error}`);
+        process.exitCode = 1;
     });
-    if (!confirm) {
-        console.log('Configuration cancelled.');
-        return;
-    }
-    await (0, promises_1.writeFile)(configPath, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
-    printSuccess(`Configuration written · ${configPath}`);
-    await (0, promises_1.cp)(node_path_1.default.join(__dirname, 'runtime.js'), node_path_1.default.join(projectPath, 'siduri-runtime.js'));
-    await (0, promises_1.writeFile)(node_path_1.default.join(projectPath, 'package.json'), JSON.stringify({
-        name: projectDirectoryName(answers.name),
-        private: true,
-        version: '0.0.0',
-        scripts: { start: 'node siduri-runtime.js', dev: 'node siduri-runtime.js' },
-        dependencies: RUNTIME_DEPENDENCIES,
-    }, null, 2) + '\n', { mode: 0o600 });
-    const keyEnv = config.brain.apiKeyEnv || 'OPENROUTER_API_KEY';
-    await (0, promises_1.writeFile)(node_path_1.default.join(projectPath, '.env.example'), [
-        `${keyEnv}=`,
-        'DATABASE_URL=postgresql://postgres:postgres@localhost:5432/siduri',
-        '',
-    ].join('\n'), { mode: 0o600 });
-    await withTask('Installing Siduri runtime dependencies', () => execFile('npm', ['install', '--no-audit', '--no-fund'], { cwd: projectPath }).then(() => undefined));
-    printSuccess(`Siduri instance ready · ${projectPath}`);
-    console.log(`${colors.dim}Next: cd ${projectDirectoryName(answers.name)} && npm run start${colors.reset}\n`);
 }
-main().catch((error) => {
-    if (error && typeof error === 'object' && 'name' in error && error.name === 'ExitPromptError') {
-        console.log('\nConfiguration cancelled.');
-        return;
-    }
-    console.error(`\n${colors.yellow}!${colors.reset} ${error instanceof Error ? error.message : error}`);
-    process.exitCode = 1;
-});

package/dist/manifest.d.ts

@@ -0,0 +1,33 @@
+export interface OrganEnvironmentVar {
+    name: string;
+    required?: boolean;
+    secret?: boolean;
+    default?: string;
+    description?: string;
+}
+export interface OrganServiceRequirement {
+    name: string;
+    kind: 'database' | 'http_service' | 'process' | string;
+    optional?: boolean;
+    description?: string;
+}
+export interface OrganDatabaseRequirement {
+    engine: 'postgres' | 'sqlite' | string;
+    migrationsDir?: string;
+}
+export interface OrganManifest {
+    name: string;
+    organType: string;
+    version: string;
+    displayName: string;
+    description?: string;
+    entrypoint: string;
+    factory: string;
+    configKey: string;
+    configSchema: Record<string, any>;
+    environment: OrganEnvironmentVar[];
+    services: OrganServiceRequirement[];
+    database?: OrganDatabaseRequirement | null;
+    healthCheck?: string | null;
+}
+export declare function validateOrganManifest(manifest: unknown, sourcePath?: string): OrganManifest;