@vxnus/siduri 0.1.8 → 0.1.10

package/dist/configurators.test.js

@@ -0,0 +1,331 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const inquirer_1 = __importDefault(require("inquirer"));
+const discovery_1 = require("./discovery");
+const generator_1 = require("./generator");
+const index_1 = require("./index");
+const openrouter_1 = require("./providers/openrouter");
+const knowledge_hub_1 = require("./providers/knowledge-hub");
+const brain_1 = require("./configurators/brain");
+const knowledge_1 = require("./configurators/knowledge");
+const memory_1 = require("./configurators/memory");
+const voice_1 = require("./configurators/voice");
+const body_1 = require("./configurators/body");
+const hands_1 = require("./configurators/hands");
+const behavior_1 = require("./configurators/behavior");
+const vision_1 = require("./configurators/vision");
+// Mock inquirer.prompt
+jest.mock('inquirer', () => ({
+    prompt: jest.fn(),
+    Separator: jest.fn((label) => ({ type: 'separator', line: label })),
+}));
+describe('Guided Manifest-Driven Configuration UX Specification Tests', () => {
+    const registry = discovery_1.OrganRegistry.discover();
+    const brainManifest = registry.get('brain');
+    const knowledgeManifest = registry.get('knowledge');
+    const memoryManifest = registry.get('memory');
+    const voiceManifest = registry.get('voice');
+    const bodyManifest = registry.get('body');
+    const handsManifest = registry.get('hands');
+    const behaviorManifest = registry.get('behavior');
+    const visionManifest = registry.get('vision');
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('Discrepancy #1: OpenRouter Model Discovery & Brain Configurator', () => {
+        test('OpenRouter model provider parses model catalog correctly', async () => {
+            const mockModels = [
+                { id: 'openai/gpt-4o-mini', name: 'OpenAI: GPT-4o Mini', description: 'Fast model', context_length: 128000 },
+                { id: 'anthropic/claude-3.5-sonnet', name: 'Anthropic: Claude 3.5 Sonnet', context_length: 200000 },
+            ];
+            const globalFetch = global.fetch;
+            global.fetch = jest.fn().mockResolvedValue({
+                ok: true,
+                json: async () => ({ data: mockModels }),
+            });
+            const provider = new openrouter_1.OpenRouterModelProvider('https://mock-api.com/models');
+            const models = await provider.listModels();
+            expect(models.length).toBe(2);
+            expect(models[0].id).toBe('openai/gpt-4o-mini');
+            expect(models[0].name).toBe('OpenAI: GPT-4o Mini');
+            expect(models[1].id).toBe('anthropic/claude-3.5-sonnet');
+            global.fetch = globalFetch;
+        });
+        test('Brain configurator selects OpenRouter model and retains canonical model ID', async () => {
+            const mockProvider = {
+                listModels: jest.fn().mockResolvedValue([
+                    { id: 'openai/gpt-4o-mini', name: 'OpenAI: GPT-4o Mini' },
+                    { id: 'anthropic/claude-3.5-sonnet', name: 'Anthropic: Claude 3.5 Sonnet' },
+                ]),
+            };
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'openrouter' }) // Brain provider
+                .mockResolvedValueOnce({ selectedValue: 'openai/gpt-4o-mini' }); // Select model
+            const result = await (0, brain_1.configureBrain)({ companionName: 'Sparkle', manifest: brainManifest }, { modelProvider: mockProvider });
+            expect(result.config.provider).toBe('openrouter');
+            expect(result.config.model).toBe('openai/gpt-4o-mini');
+            expect(result.summary?.Model).toBe('openai/gpt-4o-mini');
+            expect(result.summary?.Provider).toBe('OpenRouter');
+        });
+        test('Brain configurator handles discovery failure with curated fallback models', async () => {
+            const failingProvider = {
+                listModels: jest.fn().mockRejectedValue(new Error('Network request failed')),
+            };
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'openrouter' }) // Brain provider
+                .mockResolvedValueOnce({ failureAction: 'curated' }) // Pick curated fallback
+                .mockResolvedValueOnce({ selectedValue: 'anthropic/claude-3.5-sonnet' }); // Select model
+            const result = await (0, brain_1.configureBrain)({ companionName: 'Sparkle', manifest: brainManifest }, { modelProvider: failingProvider });
+            expect(result.config.provider).toBe('openrouter');
+            expect(result.config.model).toBe('anthropic/claude-3.5-sonnet');
+        });
+        test('Brain configurator handles discovery failure with manual fallback entry', async () => {
+            const failingProvider = {
+                listModels: jest.fn().mockRejectedValue(new Error('Network request failed')),
+            };
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'openrouter' })
+                .mockResolvedValueOnce({ failureAction: 'manual' })
+                .mockResolvedValueOnce({ manualId: 'mistralai/mistral-large' });
+            const result = await (0, brain_1.configureBrain)({ companionName: 'Sparkle', manifest: brainManifest }, { modelProvider: failingProvider });
+            expect(result.config.provider).toBe('openrouter');
+            expect(result.config.model).toBe('mistralai/mistral-large');
+        });
+        test('Brain configurator supports OpenAI-compatible / Custom endpoint', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'openai-compatible' })
+                .mockResolvedValueOnce({
+                baseUrl: 'http://localhost:11434/v1',
+                model: 'llama3:latest',
+                apiKeyEnv: 'OLLAMA_API_KEY',
+            });
+            const result = await (0, brain_1.configureBrain)({ companionName: 'Sparkle', manifest: brainManifest });
+            expect(result.config.provider).toBe('openai-compatible');
+            expect(result.config.model).toBe('llama3:latest');
+            expect(result.config.baseUrl).toBe('http://localhost:11434/v1');
+            expect(result.config.apiKeyEnv).toBe('OLLAMA_API_KEY');
+        });
+    });
+    describe('Discrepancy #2 & #3: Knowledge Choices & Manifest Metadata Confirmation', () => {
+        test('Selecting "Do not use knowledge" sets provider: none and skips discovery', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ source: 'none' });
+            const result = await (0, knowledge_1.configureKnowledge)({
+                companionName: 'Sparkle',
+                manifest: knowledgeManifest,
+            });
+            expect(result.config.provider).toBe('none');
+            expect(result.summary?.Source).toBe('Do not use knowledge');
+        });
+        test('Selecting "E Knowledge Hub" discovers manifest, extracts capabilities, and confirms provider', async () => {
+            const mockClient = {
+                resolveProvider: jest.fn().mockResolvedValue({
+                    name: 'e-teyvat',
+                    displayName: 'E Teyvat',
+                    package: '@vxnus/e-teyvat',
+                    version: '1.2.0',
+                    description: 'Teyvat knowledge provider for Siduri.',
+                    capabilities: ['Search', 'Retrieval', 'Context injection'],
+                    source: 'E Knowledge Hub',
+                }),
+            };
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ source: 'e-hub' }) // Knowledge source
+                .mockResolvedValueOnce({ packId: '@vxnus/e-teyvat' }) // Package ID
+                .mockResolvedValueOnce({ confirmProvider: 'yes' }); // Confirm provider
+            const result = await (0, knowledge_1.configureKnowledge)({ companionName: 'Sparkle', manifest: knowledgeManifest }, { client: mockClient });
+            expect(result.config.provider).toBe('e-hub');
+            expect(result.config.packId).toBe('@vxnus/e-teyvat');
+            expect(result.summary?.Source).toBe('E Knowledge Hub');
+            expect(result.summary?.Provider).toBe('E Teyvat');
+            expect(result.summary?.Package).toBe('@vxnus/e-teyvat');
+            expect(result.summary?.Version).toBe('1.2.0');
+        });
+        test('Knowledge manifest validation enforces name and version', () => {
+            expect(() => (0, knowledge_hub_1.validateKnowledgeManifest)({})).toThrow('Invalid knowledge manifest');
+            expect(() => (0, knowledge_hub_1.validateKnowledgeManifest)({ name: 'test' })).toThrow('missing \'version\'');
+            const valid = (0, knowledge_hub_1.validateKnowledgeManifest)({
+                name: 'e-teyvat',
+                displayName: 'E Teyvat',
+                version: '1.0.0',
+                description: 'Teyvat lore',
+            }, '@vxnus/e-teyvat');
+            expect(valid.name).toBe('e-teyvat');
+            expect(valid.package).toBe('@vxnus/e-teyvat');
+            expect(valid.version).toBe('1.0.0');
+        });
+        test('extractCapabilitiesList formats object and array capabilities correctly', () => {
+            const arrayCaps = (0, knowledge_hub_1.extractCapabilitiesList)(['Search', 'Retrieval', 'Custom Tool']);
+            expect(arrayCaps).toEqual(['Search', 'Retrieval', 'Custom Tool']);
+            const objCaps = (0, knowledge_hub_1.extractCapabilitiesList)({
+                search: true,
+                retrieval: true,
+                contextInjection: true,
+                semanticSearch: true,
+            });
+            expect(objCaps).toContain('Search');
+            expect(objCaps).toContain('Retrieval');
+            expect(objCaps).toContain('Context injection');
+            expect(objCaps).toContain('Semantic search');
+        });
+        test('Knowledge Hub client fallback returns known pack for @vxnus/e-teyvat', async () => {
+            const client = new knowledge_hub_1.KnowledgeHubClient('https://invalid-non-existent-url.local/api');
+            const manifest = await client.resolveProvider('@vxnus/e-teyvat');
+            expect(manifest.package).toBe('@vxnus/e-teyvat');
+            expect(manifest.displayName).toBe('E Teyvat');
+            expect(manifest.version).toBe('1.2.0');
+        });
+    });
+    describe('Other Organ Configurators & Generic Router', () => {
+        test('Memory configurator configures PostgreSQL with Supabase deployment', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ database: 'postgres' })
+                .mockResolvedValueOnce({ deployment: 'supabase' });
+            const result = await (0, memory_1.configureMemory)({ companionName: 'Sparkle', manifest: memoryManifest });
+            expect(result.config.provider).toBe('postgres');
+            expect(result.config.deployment).toBe('supabase');
+            expect(result.summary?.Deploy).toBe('Supabase');
+        });
+        test('Voice configurator configures VOICEVOX engine and speaker ID', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'voicevox' })
+                .mockResolvedValueOnce({ baseUrl: 'http://localhost:50021' })
+                .mockResolvedValueOnce({ speaker: { id: 2, label: '四国めたん (Shikoku Metan) - ノーマル (Normal) (ID: 2)' } });
+            const result = await (0, voice_1.configureVoice)({ companionName: 'Sparkle', manifest: voiceManifest });
+            expect(result.config.provider).toBe('voicevox');
+            expect(result.config.speakerId).toBe(2);
+            expect(result.summary?.['Speaker ID']).toBe(2);
+        });
+        test('Voice configurator configures RVC with Base TTS Engine', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'rvc' })
+                .mockResolvedValueOnce({
+                modelPath: './assets/voice/sparkle/sparkle.pth',
+                indexPath: './assets/voice/sparkle/sparkle.index',
+                pitchShift: '12',
+                f0Method: 'rmvpe',
+                baseTts: 'edge-tts',
+                serviceUrl: 'http://localhost:50055',
+            });
+            const result = await (0, voice_1.configureVoice)({ companionName: 'Sparkle', manifest: voiceManifest });
+            expect(result.config.provider).toBe('edge-tts');
+            expect(result.config.rvc.enabled).toBe(true);
+            expect(result.config.rvc.pitchShift).toBe(12);
+            expect(result.summary?.['Base TTS']).toBe('edge-tts');
+        });
+        test('Voice configurator configures standalone Edge-TTS', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'edge-tts' })
+                .mockResolvedValueOnce({ voice: 'en-US-AriaNeural' });
+            const result = await (0, voice_1.configureVoice)({ companionName: 'Sparkle', manifest: voiceManifest });
+            expect(result.config.provider).toBe('edge-tts');
+            expect(result.config.voice).toBe('en-US-AriaNeural');
+            expect(result.summary?.Provider).toBe('Edge-TTS (Cloud Neural)');
+            expect(result.summary?.Voice).toBe('en-US-AriaNeural');
+        });
+        test('Voice configurator configures standalone Kokoro TTS', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'kokoro' })
+                .mockResolvedValueOnce({ baseUrl: 'http://localhost:8880', voice: 'af_heart', speed: '1.2' });
+            const result = await (0, voice_1.configureVoice)({ companionName: 'Sparkle', manifest: voiceManifest });
+            expect(result.config.provider).toBe('kokoro');
+            expect(result.config.baseUrl).toBe('http://localhost:8880');
+            expect(result.config.voice).toBe('af_heart');
+            expect(result.config.speed).toBe(1.2);
+            expect(result.summary?.Provider).toBe('Kokoro TTS (Local / Server)');
+        });
+        test('Voice configurator configures standalone Piper TTS', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'piper' })
+                .mockResolvedValueOnce({ baseUrl: 'http://localhost:5000', model: 'en_US-lessac', speakerId: '2' });
+            const result = await (0, voice_1.configureVoice)({ companionName: 'Sparkle', manifest: voiceManifest });
+            expect(result.config.provider).toBe('piper');
+            expect(result.config.baseUrl).toBe('http://localhost:5000');
+            expect(result.config.model).toBe('en_US-lessac');
+            expect(result.config.speakerId).toBe(2);
+            expect(result.summary?.Provider).toBe('Piper TTS (Local / Server)');
+        });
+        test('Body configurator configures Live2D, custom model path, and expression', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'live2d' })
+                .mockResolvedValueOnce({
+                modelSource: './assets/body/sparkle/model.model3.json',
+                initialExpression: 'happy',
+            });
+            const result = await (0, body_1.configureBody)({ companionName: 'Sparkle', manifest: bodyManifest });
+            expect(result.config.provider).toBe('live2d');
+            expect(result.config.modelPath).toBe('./assets/body/sparkle/model.model3.json');
+            expect(result.config.modelUrl).toBe('/assets/body/sparkle/model.model3.json');
+            expect(result.config.initialExpression).toBe('happy');
+            expect(result.summary?.['Model Path']).toBe('./assets/body/sparkle/model.model3.json');
+        });
+        test('Hands configurator configures MCP tool execution timeout', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ timeoutSeconds: '15' });
+            const result = await (0, hands_1.configureHands)({ companionName: 'Sparkle', manifest: handsManifest });
+            expect(result.config.defaultTimeoutMs).toBe(15000);
+        });
+        test('Behavior configurator configures active self personality preset', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ preset: 'cheerful' });
+            const result = await (0, behavior_1.configureBehavior)({ companionName: 'Sparkle', manifest: behaviorManifest });
+            expect(result.config.provider).toBe('active_self');
+            expect(result.config.preset).toBe('cheerful');
+        });
+        test('Vision configurator configures OpenRouter vision model', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ model: 'gpt-4-vision' });
+            const result = await (0, vision_1.configureVision)({ companionName: 'Sparkle', manifest: visionManifest });
+            expect(result.config.provider).toBe('openrouter');
+            expect(result.config.model).toBe('gpt-4-vision');
+        });
+    });
+    describe('Review Summary Formatting & Generator Integration', () => {
+        test('formatReviewSummary displays actual configuration values and metadata', () => {
+            const summaryOutput = (0, index_1.formatReviewSummary)('Sparkle', [brainManifest, memoryManifest, knowledgeManifest, voiceManifest], {
+                brain: { Provider: 'OpenRouter', Model: 'openai/gpt-4o-mini' },
+                memory: { Database: 'PostgreSQL', Deploy: 'Supabase' },
+                knowledge: { Source: 'E Knowledge Hub', Provider: 'E Teyvat', Package: '@vxnus/e-teyvat', Version: '1.2.0' },
+                voice: { Provider: 'VOICEVOX', 'Speaker ID': 1 },
+            });
+            expect(summaryOutput).toContain('Sparkle');
+            expect(summaryOutput).toContain('Brain');
+            expect(summaryOutput).toContain('OpenRouter');
+            expect(summaryOutput).toContain('openai/gpt-4o-mini');
+            expect(summaryOutput).toContain('Memory');
+            expect(summaryOutput).toContain('PostgreSQL');
+            expect(summaryOutput).toContain('Supabase');
+            expect(summaryOutput).toContain('Knowledge');
+            expect(summaryOutput).toContain('E Knowledge Hub');
+            expect(summaryOutput).toContain('E Teyvat');
+            expect(summaryOutput).toContain('@vxnus/e-teyvat');
+            expect(summaryOutput).toContain('Voice');
+            expect(summaryOutput).toContain('VOICEVOX');
+        });
+        test('generateInstanceFiles accurately embeds configured organ values in siduri.config.json', () => {
+            const organConfigs = {
+                brain: { provider: 'openrouter', model: 'openai/gpt-4o-mini', apiKeyEnv: 'OPENROUTER_API_KEY' },
+                memory: { provider: 'postgres', deployment: 'supabase' },
+                knowledge: { provider: 'e-hub', registryUrl: 'https://e.vxnus.xyz/api/v1/knowledge', packId: '@vxnus/e-teyvat' },
+                voice: { provider: 'voicevox', speakerId: 2, baseUrl: 'http://localhost:50021' },
+            };
+            const files = (0, generator_1.generateInstanceFiles)({
+                name: 'Sparkle',
+                selectedManifests: [brainManifest, memoryManifest, knowledgeManifest, voiceManifest],
+                organConfigs,
+            });
+            const config = JSON.parse(files['siduri.config.json']);
+            expect(config.name).toBe('Sparkle');
+            expect(config.organs.brain.provider).toBe('openrouter');
+            expect(config.organs.brain.model).toBe('openai/gpt-4o-mini');
+            expect(config.organs.memory.deployment).toBe('supabase');
+            expect(config.organs.knowledge.provider).toBe('e-hub');
+            expect(config.organs.knowledge.packId).toBe('@vxnus/e-teyvat');
+            expect(config.organs.voice.speakerId).toBe(2);
+            // Verify explicit imports in src/index.js
+            expect(files['src/index.js']).toContain("import { OpenRouterBrain } from '@siduri-x/brain'");
+            expect(files['src/index.js']).toContain("import { PostgresMemoryOrgan } from '@siduri-x/memory'");
+            expect(files['src/index.js']).toContain("import { EKnowledgeAdapter } from '@siduri-x/knowledge'");
+            expect(files['src/index.js']).toContain("import { VoiceAdapter } from '@siduri-x/voice'");
+        });
+    });
+});

package/dist/db.d.ts

@@ -0,0 +1,25 @@
+export declare function redactDatabaseUrl(url: string): string;
+export interface MigrationFile {
+    name: string;
+    fullPath: string;
+    sql: string;
+    checksum: string;
+}
+export interface MigrationRecord {
+    id: number;
+    name: string;
+    checksum: string;
+    applied_at: string;
+}
+export interface DbPushOptions {
+    projectDir?: string;
+    connectionString?: string;
+    env?: Record<string, string | undefined>;
+}
+export interface DbPushResult {
+    status: 'NOOP' | 'APPLIED' | 'UP_TO_DATE';
+    appliedMigrations: string[];
+    skippedMigrations: string[];
+    message: string;
+}
+export declare function runDbPush(options?: DbPushOptions): Promise<DbPushResult>;

package/dist/db.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactDatabaseUrl = redactDatabaseUrl;
+exports.runDbPush = runDbPush;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const pg_1 = require("pg");
+const discovery_1 = require("./discovery");
+function redactDatabaseUrl(url) {
+    try {
+        const parsed = new URL(url);
+        if (parsed.password) {
+            parsed.password = '***';
+        }
+        return parsed.toString();
+    }
+    catch {
+        return 'postgres://***:***@...';
+    }
+}
+async function runDbPush(options = {}) {
+    const projectDir = options.projectDir ? node_path_1.default.resolve(options.projectDir) : process.cwd();
+    const configPath = node_path_1.default.join(projectDir, 'siduri.config.json');
+    if (!node_fs_1.default.existsSync(configPath)) {
+        throw new Error(`siduri.config.json not found at ${projectDir}. Make sure you are in a Siduri instance directory.`);
+    }
+    const config = JSON.parse(node_fs_1.default.readFileSync(configPath, 'utf8'));
+    const configuredOrgans = config.organs || {};
+    // 1. Discover manifests of configured organs
+    const registry = discovery_1.OrganRegistry.discover([
+        node_path_1.default.join(projectDir, 'node_modules/@siduri-x'),
+        node_path_1.default.resolve(__dirname, '../../packages/organs'),
+        node_path_1.default.resolve(process.cwd(), 'packages/organs'),
+    ]);
+    const databaseOrgans = [];
+    for (const [key] of Object.entries(configuredOrgans)) {
+        const manifest = registry.get(key) || registry.getAll().find((m) => m.configKey === key || m.organType === key);
+        if (manifest && manifest.database && manifest.database.migrationsDir) {
+            // Resolve migrations directory relative to the organ package
+            const candidatePaths = [
+                node_path_1.default.resolve(projectDir, 'node_modules', manifest.name, manifest.database.migrationsDir),
+                node_path_1.default.resolve(__dirname, '../../packages/organs', manifest.organType, manifest.database.migrationsDir),
+                node_path_1.default.resolve(process.cwd(), 'packages/organs', manifest.organType, manifest.database.migrationsDir),
+            ];
+            const resolvedDir = candidatePaths.find((p) => node_fs_1.default.existsSync(p));
+            if (resolvedDir) {
+                databaseOrgans.push({
+                    organType: manifest.organType,
+                    manifest,
+                    migrationsDir: resolvedDir,
+                });
+            }
+        }
+    }
+    if (databaseOrgans.length === 0) {
+        return {
+            status: 'NOOP',
+            appliedMigrations: [],
+            skippedMigrations: [],
+            message: 'No database migrations are required by this instance.',
+        };
+    }
+    // 2. Resolve DATABASE_URL
+    const connectionString = options.connectionString ||
+        options.env?.DATABASE_URL ||
+        process.env.DATABASE_URL;
+    if (!connectionString) {
+        throw new Error('DATABASE_URL is required to run database migrations. Set it in .env or environment.');
+    }
+    const pool = new pg_1.Pool({
+        connectionString,
+        connectionTimeoutMillis: 5000,
+    });
+    const client = await pool.connect();
+    try {
+        // 3. Ensure migrations table exists
+        await client.query(`
+      CREATE TABLE IF NOT EXISTS siduri_migrations (
+        id SERIAL PRIMARY KEY,
+        name VARCHAR(255) UNIQUE NOT NULL,
+        checksum VARCHAR(64) NOT NULL,
+        applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      );
+    `);
+        // 4. Fetch applied migrations
+        const existingRes = await client.query('SELECT name, checksum FROM siduri_migrations ORDER BY id ASC;');
+        const appliedMap = new Map();
+        for (const row of existingRes.rows) {
+            appliedMap.set(row.name, row.checksum);
+        }
+        // 5. Gather all migration files across database organs in deterministic order
+        const allMigrationFiles = [];
+        for (const item of databaseOrgans) {
+            const files = node_fs_1.default.readdirSync(item.migrationsDir).filter((f) => f.endsWith('.sql')).sort();
+            for (const file of files) {
+                const fullPath = node_path_1.default.join(item.migrationsDir, file);
+                const sql = node_fs_1.default.readFileSync(fullPath, 'utf8');
+                const checksum = (0, node_crypto_1.createHash)('sha256').update(sql).digest('hex');
+                allMigrationFiles.push({
+                    name: `${item.organType}/${file}`,
+                    fullPath,
+                    sql,
+                    checksum,
+                });
+            }
+        }
+        allMigrationFiles.sort((a, b) => a.name.localeCompare(b.name));
+        const appliedList = [];
+        const skippedList = [];
+        for (const migration of allMigrationFiles) {
+            const recordedChecksum = appliedMap.get(migration.name);
+            if (recordedChecksum !== undefined) {
+                if (recordedChecksum !== migration.checksum) {
+                    throw new Error(`Migration checksum mismatch for ${migration.name}! Recorded: ${recordedChecksum.slice(0, 8)}, Current: ${migration.checksum.slice(0, 8)}. Refusing to apply modified migration.`);
+                }
+                skippedList.push(migration.name);
+            }
+            else {
+                // Apply migration in transaction
+                await client.query('BEGIN');
+                try {
+                    await client.query(migration.sql);
+                    await client.query('INSERT INTO siduri_migrations (name, checksum) VALUES ($1, $2)', [migration.name, migration.checksum]);
+                    await client.query('COMMIT');
+                    appliedList.push(migration.name);
+                }
+                catch (err) {
+                    await client.query('ROLLBACK');
+                    throw err;
+                }
+            }
+        }
+        const redacted = redactDatabaseUrl(connectionString);
+        const message = appliedList.length > 0
+            ? `Applied ${appliedList.length} migration(s) to ${redacted}`
+            : `Database schema up to date on ${redacted}`;
+        return {
+            status: appliedList.length > 0 ? 'APPLIED' : 'UP_TO_DATE',
+            appliedMigrations: appliedList,
+            skippedMigrations: skippedList,
+            message,
+        };
+    }
+    finally {
+        client.release();
+        await pool.end().catch(() => { });
+    }
+}

package/dist/discovery.d.ts

@@ -0,0 +1,13 @@
+import { OrganManifest } from './manifest';
+export declare class OrganRegistry {
+    private manifests;
+    constructor(manifests?: OrganManifest[]);
+    register(manifest: OrganManifest): void;
+    get(organType: string): OrganManifest | undefined;
+    getAll(): OrganManifest[];
+    getAvailableOrganTypes(): string[];
+    /**
+     * Discover installed or monorepo organ packages.
+     */
+    static discover(searchRoots?: string[]): OrganRegistry;
+}

package/dist/discovery.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrganRegistry = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const manifest_1 = require("./manifest");
+const builtin_manifests_1 = require("./builtin-manifests");
+class OrganRegistry {
+    manifests = new Map();
+    constructor(manifests) {
+        if (manifests) {
+            for (const m of manifests) {
+                this.manifests.set(m.organType, m);
+            }
+        }
+    }
+    register(manifest) {
+        const validated = (0, manifest_1.validateOrganManifest)(manifest);
+        this.manifests.set(validated.organType, validated);
+    }
+    get(organType) {
+        return this.manifests.get(organType);
+    }
+    getAll() {
+        return Array.from(this.manifests.values());
+    }
+    getAvailableOrganTypes() {
+        return Array.from(this.manifests.keys());
+    }
+    /**
+     * Discover installed or monorepo organ packages.
+     */
+    static discover(searchRoots) {
+        const registry = new OrganRegistry();
+        const rootsToScan = searchRoots && searchRoots.length > 0
+            ? searchRoots
+            : [
+                // 1. Monorepo organs folder relative to cli
+                node_path_1.default.resolve(__dirname, '../../packages/organs'),
+                // 2. Monorepo organs folder relative to cwd
+                node_path_1.default.resolve(process.cwd(), 'packages/organs'),
+                // 3. Node modules of current directory or global resolution
+                node_path_1.default.resolve(process.cwd(), 'node_modules/@siduri-x'),
+                node_path_1.default.resolve(__dirname, '../node_modules/@siduri-x'),
+            ];
+        const visitedDirs = new Set();
+        for (const root of rootsToScan) {
+            if (!node_fs_1.default.existsSync(root) || visitedDirs.has(root))
+                continue;
+            visitedDirs.add(root);
+            try {
+                const entries = node_fs_1.default.readdirSync(root, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory())
+                        continue;
+                    const candidateDir = node_path_1.default.join(root, entry.name);
+                    const manifestPath = node_path_1.default.join(candidateDir, 'organ-manifest.json');
+                    if (node_fs_1.default.existsSync(manifestPath)) {
+                        try {
+                            const raw = JSON.parse(node_fs_1.default.readFileSync(manifestPath, 'utf8'));
+                            const manifest = (0, manifest_1.validateOrganManifest)(raw, manifestPath);
+                            registry.register(manifest);
+                        }
+                        catch (err) {
+                            console.warn(`[Siduri CLI] Warning: failed to parse manifest at ${manifestPath}: ${err.message}`);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                // Continue scanning other roots
+            }
+        }
+        // If running in a standalone environment without local package folders (e.g. via npx in an empty directory),
+        // register canonical built-in @siduri-x/* organ manifests as fallback.
+        if (registry.getAll().length === 0) {
+            for (const builtinManifest of builtin_manifests_1.BUILTIN_ORGAN_MANIFESTS) {
+                registry.register(builtinManifest);
+            }
+        }
+        return registry;
+    }
+}
+exports.OrganRegistry = OrganRegistry;

package/dist/discovery.test.d.ts

@@ -0,0 +1 @@
+export {};