@vxnus/siduri 0.1.8 → 0.1.10

package/dist/generator.test.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generator_1 = require("./generator");
+describe('Instance Generator Composition Invariants (Phase 3)', () => {
+    const MOCK_MANIFESTS = {
+        brain: {
+            name: '@siduri-x/brain',
+            organType: 'brain',
+            version: '1.0.0',
+            displayName: 'Brain (Cognition & Planning)',
+            entrypoint: './dist/index.js',
+            factory: 'OpenRouterBrain',
+            configKey: 'brain',
+            configSchema: { type: 'object', properties: { provider: { type: 'string' }, model: { type: 'string' } } },
+            environment: [{ name: 'OPENROUTER_API_KEY', required: true, secret: true }],
+            services: [{ name: 'LLM Inference', kind: 'http_service' }],
+        },
+        hands: {
+            name: '@siduri-x/hands',
+            organType: 'hands',
+            version: '1.0.0',
+            displayName: 'Hands (MCP Tool Execution)',
+            entrypoint: './dist/index.js',
+            factory: 'DefaultHandsOrgan',
+            configKey: 'hands',
+            configSchema: { type: 'object', properties: { defaultTimeoutMs: { type: 'number' } } },
+            environment: [{ name: 'ACTION_POLICY_SECRET', required: true, secret: true }],
+            services: [],
+        },
+        memory: {
+            name: '@siduri-x/memory',
+            organType: 'memory',
+            version: '1.0.0',
+            displayName: 'Memory (PostgreSQL FTS Claims)',
+            entrypoint: './dist/index.js',
+            factory: 'PostgresMemoryOrgan',
+            configKey: 'memory',
+            configSchema: { type: 'object', properties: { provider: { type: 'string' } } },
+            environment: [{ name: 'DATABASE_URL', required: true, secret: true }],
+            services: [{ name: 'PostgreSQL', kind: 'database' }],
+            database: { engine: 'postgres', migrationsDir: './migrations' },
+        },
+        body: {
+            name: '@siduri-x/body',
+            organType: 'body',
+            version: '1.0.0',
+            displayName: 'Body (Live2D & Avatar State)',
+            entrypoint: './dist/index.js',
+            factory: 'NeutralBodyOrgan',
+            configKey: 'body',
+            configSchema: { type: 'object', properties: { provider: { type: 'string' } } },
+            environment: [],
+            services: [],
+        },
+        voice: {
+            name: '@siduri-x/voice',
+            organType: 'voice',
+            version: '1.0.0',
+            displayName: 'Voice (VOICEVOX Speech Synthesis)',
+            entrypoint: './dist/index.js',
+            factory: 'VoiceAdapter',
+            configKey: 'voice',
+            configSchema: { type: 'object', properties: { provider: { type: 'string' } } },
+            environment: [{ name: 'VOICEVOX_URL', default: 'http://localhost:50021' }],
+            services: [{ name: 'VOICEVOX', kind: 'http_service' }],
+        },
+    };
+    test('Composition A: Brain only', () => {
+        const files = (0, generator_1.generateInstanceFiles)({
+            name: 'brain-only-agent',
+            selectedManifests: [MOCK_MANIFESTS.brain],
+        });
+        const pkg = JSON.parse(files['package.json']);
+        expect(pkg.dependencies['@siduri-x/core']).toBeDefined();
+        expect(pkg.dependencies['@siduri-x/brain']).toBeDefined();
+        expect(pkg.dependencies['@siduri-x/memory']).toBeUndefined();
+        expect(pkg.dependencies['@siduri-x/hands']).toBeUndefined();
+        expect(pkg.dependencies['@siduri-x/voice']).toBeUndefined();
+        expect(pkg.dependencies['@siduri-x/body']).toBeUndefined();
+        // src/index.js
+        expect(files['src/index.js']).toContain("import { OpenRouterBrain } from '@siduri-x/brain'");
+        expect(files['src/index.js']).not.toContain('@siduri-x/hands');
+        expect(files['src/index.js']).not.toContain('@siduri-x/memory');
+        expect(files['src/index.js']).not.toContain('siduri-runtime.js');
+        // siduri.config.json
+        const config = JSON.parse(files['siduri.config.json']);
+        expect(config.organs.brain).toBeDefined();
+        expect(config.organs.hands).toBeUndefined();
+        expect(config.organs.memory).toBeUndefined();
+        // .env.example
+        expect(files['.env.example']).toContain('OPENROUTER_API_KEY');
+        expect(files['.env.example']).not.toContain('DATABASE_URL');
+        expect(files['.env.example']).not.toContain('ACTION_POLICY_SECRET');
+        // No body asset scaffold
+        expect(files.createAssetsBodyDir).toBe(false);
+    });
+    test('Composition B: Brain + Hands', () => {
+        const files = (0, generator_1.generateInstanceFiles)({
+            name: 'coding-agent',
+            selectedManifests: [MOCK_MANIFESTS.brain, MOCK_MANIFESTS.hands],
+        });
+        const pkg = JSON.parse(files['package.json']);
+        expect(pkg.dependencies['@siduri-x/core']).toBeDefined();
+        expect(pkg.dependencies['@siduri-x/brain']).toBeDefined();
+        expect(pkg.dependencies['@siduri-x/hands']).toBeDefined();
+        expect(pkg.dependencies['@siduri-x/memory']).toBeUndefined();
+        // src/index.js
+        expect(files['src/index.js']).toContain("import { OpenRouterBrain } from '@siduri-x/brain'");
+        expect(files['src/index.js']).toContain("import { DefaultHandsOrgan } from '@siduri-x/hands'");
+        expect(files['src/index.js']).not.toContain('@siduri-x/memory');
+        // .env.example
+        expect(files['.env.example']).toContain('OPENROUTER_API_KEY');
+        expect(files['.env.example']).toContain('ACTION_POLICY_SECRET');
+        expect(files['.env.example']).not.toContain('DATABASE_URL');
+        expect(files.createAssetsBodyDir).toBe(false);
+    });
+    test('Composition C: Brain + Memory', () => {
+        const files = (0, generator_1.generateInstanceFiles)({
+            name: 'memory-agent',
+            selectedManifests: [MOCK_MANIFESTS.brain, MOCK_MANIFESTS.memory],
+        });
+        const pkg = JSON.parse(files['package.json']);
+        expect(pkg.dependencies['@siduri-x/core']).toBeDefined();
+        expect(pkg.dependencies['@siduri-x/brain']).toBeDefined();
+        expect(pkg.dependencies['@siduri-x/memory']).toBeDefined();
+        expect(pkg.dependencies['@siduri-x/hands']).toBeUndefined();
+        // .env.example
+        expect(files['.env.example']).toContain('OPENROUTER_API_KEY');
+        expect(files['.env.example']).toContain('DATABASE_URL');
+        expect(files['.env.example']).not.toContain('ACTION_POLICY_SECRET');
+        // README mentions database
+        expect(files['README.md']).toContain('DATABASE_URL');
+        expect(files['README.md']).toContain('npx @vxnus/siduri db push');
+    });
+    test('Composition D: Full with Body', () => {
+        const files = (0, generator_1.generateInstanceFiles)({
+            name: 'companion-full',
+            selectedManifests: [
+                MOCK_MANIFESTS.brain,
+                MOCK_MANIFESTS.memory,
+                MOCK_MANIFESTS.hands,
+                MOCK_MANIFESTS.body,
+                MOCK_MANIFESTS.voice,
+            ],
+        });
+        const pkg = JSON.parse(files['package.json']);
+        expect(pkg.dependencies['@siduri-x/core']).toBeDefined();
+        expect(pkg.dependencies['@siduri-x/brain']).toBeDefined();
+        expect(pkg.dependencies['@siduri-x/memory']).toBeDefined();
+        expect(pkg.dependencies['@siduri-x/hands']).toBeDefined();
+        expect(pkg.dependencies['@siduri-x/body']).toBeDefined();
+        expect(pkg.dependencies['@siduri-x/voice']).toBeDefined();
+        // Body & voice asset directories requested
+        expect(files.createAssetsBodyDir).toBe(true);
+        expect(files.createAssetsDirs).toContain('assets/body/companion-full');
+        expect(files.createAssetsDirs).toContain('assets/voice/companion-full');
+        // README mentions Live2D model assets & prerequisites
+        expect(files['README.md']).toContain('assets/body/companion-full');
+        expect(files['README.md']).toContain('assets/voice/companion-full');
+        expect(files['README.md']).toContain('Prerequisites');
+        // Docker compose generated for memory (voicevox is auto-downloaded at runtime)
+        expect(files['docker-compose.yml']).toBeDefined();
+        expect(files['docker-compose.yml']).toContain('postgres:15');
+        expect(files['README.md']).toContain('Voicevox engine executable will be securely auto-downloaded');
+        expect(pkg.scripts['services:up']).toBe('docker compose up -d');
+        expect(pkg.scripts['services:down']).toBe('docker compose down');
+    });
+    test('Composition E: Brain only has no docker-compose.yml', () => {
+        const files = (0, generator_1.generateInstanceFiles)({
+            name: 'brain-solo',
+            selectedManifests: [MOCK_MANIFESTS.brain],
+        });
+        expect(files['docker-compose.yml']).toBeUndefined();
+        const pkg = JSON.parse(files['package.json']);
+        expect(pkg.scripts['services:up']).toBeUndefined();
+        expect(files['public/index.html']).toBeDefined();
+        expect(files['public/index.html']).toContain('Memory Console');
+        expect(files['public/index.html']).toContain('Companion Chat');
+    });
+    test('Generated runtime server template enforces loopback binding, safe health, and path containment', () => {
+        const files = (0, generator_1.generateInstanceFiles)({
+            name: 'secure-companion',
+            selectedManifests: [MOCK_MANIFESTS.brain, MOCK_MANIFESTS.memory],
+        });
+        const srcIndexJs = files['src/index.js'];
+        // 1. Explicit loopback binding 127.0.0.1
+        expect(srcIndexJs).toContain("server.listen(Number(PORT), '127.0.0.1'");
+        expect(srcIndexJs).toContain("http://127.0.0.1:");
+        // 2. Minimal /health endpoint without config.organs or secrets
+        expect(srcIndexJs).toContain("pathname === '/health'");
+        expect(srcIndexJs).not.toContain('organs: config.organs');
+        // 3. Strict path traversal containment
+        expect(srcIndexJs).toContain('relative.startsWith(\'..\')');
+        expect(srcIndexJs).toContain('path.isAbsolute(relative)');
+        expect(srcIndexJs).toContain('decodeURIComponent');
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { OrganManifest } from './manifest';
+export declare const CLI_VERSION = "0.1.10";
+export declare const colors: {
+    cyan: string;
+    dim: string;
+    green: string;
+    yellow: string;
+    bold: string;
+    reset: string;
+};
+export declare function printHeader(): void;
+export declare function printSection(title: string): void;
+export declare function printSuccess(message: string): void;
+export declare function projectDirectoryName(value: string): string;
+export declare function formatReviewSummary(companionName: string, selectedManifests: OrganManifest[], organSummaries: Record<string, Record<string, unknown>>): string;
+export declare function withTask<T>(label: string, task: () => Promise<T>): Promise<T>;
+export declare function runCreateWizard(targetDir?: string): Promise<void>;
+export declare function runCliDoctor(targetDir?: string): Promise<void>;
+export declare function runCliDb(subcommand?: string, targetDir?: string): Promise<void>;

package/dist/index.js

@@ -0,0 +1,401 @@
+#!/usr/bin/env node
+"use strict";
+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;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const inquirer_1 = __importDefault(require("inquirer"));
+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);
+exports.CLI_VERSION = '0.1.10';
+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${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${exports.colors.cyan}── ${title} ${'─'.repeat(Math.max(2, 42 - title.length))}${exports.colors.reset}\n`);
+}
+function printSuccess(message) {
+    console.log(`${exports.colors.green}✓${exports.colors.reset} ${message}`);
+}
+function projectDirectoryName(value) {
+    const slug = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .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(`${exports.colors.dim}${label}${exports.colors.reset}`);
+    const frames = ['·', '•', '●', '•'];
+    let index = 0;
+    const timer = setInterval(() => {
+        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${exports.colors.green}✓${exports.colors.reset} ${label}\n`);
+        return result;
+    }
+    catch (error) {
+        clearInterval(timer);
+        process.stdout.write(`\r${exports.colors.yellow}!${exports.colors.reset} ${label}\n`);
+        throw error;
+    }
+}
+function nonEmpty(value) {
+    return value.trim().length > 0 || 'Please enter a value.';
+}
+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.');
+    }
+    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(`${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');
+    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);
+    }
+    for (const organType of selectedOrganTypes) {
+        const m = registry.get(organType);
+        if (m)
+            selectedManifests.push(m);
+    }
+    // 2. Interactive Organ Configuration Stage
+    const organConfigs = {};
+    const organSummaries = {};
+    for (const m of selectedManifests) {
+        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 || {};
+    }
+    // 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 || {};
+            }
+        }
+    }
+    // 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 });
+    const publicDir = node_path_1.default.join(projectDir, 'public');
+    await (0, promises_1.mkdir)(publicDir, { 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');
+    // Copy full Next.js apps/web production build if present
+    const webDistCandidates = [
+        node_path_1.default.resolve(__dirname, 'web-dist'),
+        node_path_1.default.resolve(__dirname, '../dist/web-dist'),
+        node_path_1.default.resolve(__dirname, '../../apps/web/out'),
+        node_path_1.default.resolve(process.cwd(), 'apps/web/out'),
+    ];
+    const foundWebDist = webDistCandidates.find((p) => node_fs_1.default.existsSync(p));
+    if (foundWebDist) {
+        node_fs_1.default.cpSync(foundWebDist, publicDir, { recursive: true });
+    }
+    else {
+        await (0, promises_1.writeFile)(node_path_1.default.join(publicDir, 'index.html'), files['public/index.html'], 'utf8');
+    }
+    if (files['docker-compose.yml']) {
+        await (0, promises_1.writeFile)(node_path_1.default.join(projectDir, 'docker-compose.yml'), files['docker-compose.yml'], 'utf8');
+    }
+    if (files.createAssetsDirs && files.createAssetsDirs.length > 0) {
+        for (const dir of files.createAssetsDirs) {
+            await (0, promises_1.mkdir)(node_path_1.default.join(projectDir, dir), { recursive: true });
+        }
+    }
+    else if (files.createAssetsBodyDir) {
+        await (0, promises_1.mkdir)(node_path_1.default.join(projectDir, 'assets/body'), { recursive: true });
+    }
+    printSuccess(`Generated standalone files at ${projectDir}`);
+    // 5. Install dependencies from registry
+    try {
+        await withTask('Installing dependencies (npm install)', async () => {
+            await execFile('npm', ['install', '--no-audit', '--no-fund'], { cwd: projectDir });
+        });
+        printSuccess('Dependencies installed successfully.');
+    }
+    catch (err) {
+        console.warn(`${exports.colors.yellow}!${exports.colors.reset} Notice: npm install had warnings or requires network: ${err.message}`);
+    }
+    printSection('Instance Ready');
+    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          ${exports.colors.dim}# Fill in required API keys/credentials${exports.colors.reset}`);
+    if (files['docker-compose.yml']) {
+        console.log(`  npm run services:up           ${exports.colors.dim}# Start local Docker services (PostgreSQL / VOICEVOX)${exports.colors.reset}`);
+    }
+    const hasMemory = selectedManifests.some((m) => m.organType === 'memory');
+    if (hasMemory) {
+        console.log(`  npx @vxnus/siduri db push     ${exports.colors.dim}# Push PostgreSQL memory schema${exports.colors.reset}`);
+    }
+    console.log(`  npm run doctor                ${exports.colors.dim}# Run diagnostic health probes${exports.colors.reset}`);
+    console.log(`  npm start                     ${exports.colors.dim}# Start Web Companion & Memory Console at http://localhost:3000${exports.colors.reset}\n`);
+}
+async function runCliDoctor(targetDir) {
+    printHeader();
+    const dir = targetDir ? node_path_1.default.resolve(process.cwd(), targetDir) : process.cwd();
+    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(`${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(`${exports.colors.cyan}${cat}${exports.colors.reset}`);
+                for (const item of items) {
+                    if (item.status === 'PASS') {
+                        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(`  ${exports.colors.dim}○${exports.colors.reset} ${item.name} ${exports.colors.dim}(Optional, not set)${exports.colors.reset}`);
+                    }
+                    else if (item.status === 'SKIPPED') {
+                        console.log(`  ${exports.colors.dim}— ${item.name} (${item.message})${exports.colors.reset}`);
+                    }
+                    else {
+                        console.log(`  ${exports.colors.yellow}✗${exports.colors.reset} ${item.name}`);
+                        if (item.organName) {
+                            console.log(`    ${exports.colors.dim}Required by:${exports.colors.reset} ${item.organName}`);
+                        }
+                        if (item.message) {
+                            console.log(`    ${exports.colors.yellow}${item.message}${exports.colors.reset}`);
+                        }
+                        if (item.remediation) {
+                            console.log(`    ${exports.colors.dim}Remediation:${exports.colors.reset} ${item.remediation}`);
+                        }
+                    }
+                }
+                console.log();
+            }
+        }
+        if (report.passed) {
+            console.log(`${exports.colors.green}Result: PASS${exports.colors.reset}\n`);
+            process.exitCode = 0;
+        }
+        else {
+            console.log(`${exports.colors.yellow}Result: FAIL${exports.colors.reset}\n`);
+            process.exitCode = 1;
+        }
+    }
+    catch (err) {
+        console.error(`\n${exports.colors.yellow}Doctor Error:${exports.colors.reset} ${err.message}\n`);
+        process.exitCode = 2;
+    }
+}
+async function runCliDb(subcommand, targetDir) {
+    printHeader();
+    if (subcommand !== 'push') {
+        console.log('Usage: siduri db push');
+        process.exitCode = 2;
+        return;
+    }
+    const dir = targetDir ? node_path_1.default.resolve(process.cwd(), targetDir) : process.cwd();
+    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(`${exports.colors.dim}— ${res.message}${exports.colors.reset}\n`);
+        }
+        else {
+            printSuccess(res.message);
+            if (res.appliedMigrations.length > 0) {
+                console.log(`${exports.colors.dim}Applied:${exports.colors.reset} ${res.appliedMigrations.join(', ')}`);
+            }
+            console.log();
+        }
+        process.exitCode = 0;
+    }
+    catch (err) {
+        console.error(`\n${exports.colors.yellow}Database Migration Error:${exports.colors.reset} ${err.message}\n`);
+        process.exitCode = 3;
+    }
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    if (command === '--version' || command === '-v') {
+        console.log(exports.CLI_VERSION);
+        return;
+    }
+    if (command === 'create') {
+        const targetDir = args[1];
+        await runCreateWizard(targetDir);
+        return;
+    }
+    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();
+    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;
+        }
+        console.error(`\n${exports.colors.yellow}!${exports.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;