@vxnus/siduri 0.1.8 → 0.1.11

package/dist/discovery.test.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = __importDefault(require("node:path"));
+const discovery_1 = require("./discovery");
+const generator_1 = require("./generator");
+describe('Discovery & Dynamic Composition System Tests (Phase 3)', () => {
+    const rootOrgansDir = node_path_1.default.resolve(__dirname, '../../packages/organs');
+    test('Registry successfully discovers all 11 organ packages from workspace', () => {
+        const registry = discovery_1.OrganRegistry.discover([rootOrgansDir]);
+        const manifests = registry.getAll();
+        expect(manifests.length).toBe(11);
+        const organTypes = registry.getAvailableOrganTypes().sort();
+        expect(organTypes).toEqual([
+            'behavior',
+            'body',
+            'brain',
+            'ear',
+            'hands',
+            'knowledge',
+            'memory',
+            'mouth',
+            'observation',
+            'vision',
+            'voice',
+        ]);
+    });
+    test('Generates valid instances from discovered manifests', () => {
+        const registry = discovery_1.OrganRegistry.discover([rootOrgansDir]);
+        // Test Brain + Hands + Vision
+        const brain = registry.get('brain');
+        const hands = registry.get('hands');
+        const vision = registry.get('vision');
+        const files = (0, generator_1.generateInstanceFiles)({
+            name: 'robotics-agent',
+            selectedManifests: [brain, hands, vision],
+        });
+        const pkg = JSON.parse(files['package.json']);
+        expect(Object.keys(pkg.dependencies).sort()).toEqual([
+            '@siduri-x/brain',
+            '@siduri-x/core',
+            '@siduri-x/hands',
+            '@siduri-x/vision',
+        ]);
+        const schema = JSON.parse(files['siduri.schema.json']);
+        expect(Object.keys(schema.properties.organs.properties).sort()).toEqual(['brain', 'hands', 'vision']);
+        const config = JSON.parse(files['siduri.config.json']);
+        expect(Object.keys(config.organs).sort()).toEqual(['brain', 'hands', 'vision']);
+        expect(files['.env.example']).toContain('OPENROUTER_API_KEY');
+        expect(files['.env.example']).toContain('ACTION_POLICY_SECRET');
+        expect(files['.env.example']).not.toContain('DATABASE_URL');
+    });
+    test('Validates manifest contract integrity during discovery', () => {
+        expect(() => {
+            const invalidRegistry = new discovery_1.OrganRegistry();
+            invalidRegistry.register({});
+        }).toThrow(/Invalid manifest/);
+    });
+    test('Fallback to builtin organ manifests when scanning non-existent search roots', () => {
+        const registry = discovery_1.OrganRegistry.discover(['/non-existent-directory/empty']);
+        const manifests = registry.getAll();
+        expect(manifests.length).toBe(11);
+        expect(registry.get('brain')).toBeDefined();
+        expect(registry.get('memory')).toBeDefined();
+        expect(registry.get('mouth')).toBeDefined();
+    });
+});

package/dist/doctor-db.test.d.ts

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

package/dist/doctor-db.test.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const doctor_1 = require("./doctor");
+const db_1 = require("./db");
+const generator_1 = require("./generator");
+const discovery_1 = require("./discovery");
+describe('Phase 4: Diagnostics and Database Provisioning Tests', () => {
+    const rootOrgansDir = node_path_1.default.resolve(__dirname, '../../packages/organs');
+    const registry = discovery_1.OrganRegistry.discover([rootOrgansDir]);
+    const brain = registry.get('brain');
+    const hands = registry.get('hands');
+    const memory = registry.get('memory');
+    const testTempRoot = node_path_1.default.resolve(__dirname, '../temp-phase4-test');
+    beforeAll(() => {
+        if (node_fs_1.default.existsSync(testTempRoot)) {
+            node_fs_1.default.rmSync(testTempRoot, { recursive: true, force: true });
+        }
+        node_fs_1.default.mkdirSync(testTempRoot, { recursive: true });
+    });
+    afterAll(() => {
+        if (node_fs_1.default.existsSync(testTempRoot)) {
+            node_fs_1.default.rmSync(testTempRoot, { recursive: true, force: true });
+        }
+    });
+    test('redactDatabaseUrl redacts password and sensitive credentials', () => {
+        const raw = 'postgresql://myuser:supersecretpassword@db.example.com:5432/siduri_db';
+        const redacted = (0, db_1.redactDatabaseUrl)(raw);
+        expect(redacted).not.toContain('supersecretpassword');
+        expect(redacted).toContain('***');
+        expect(redacted).toContain('myuser');
+        expect(redacted).toContain('db.example.com:5432/siduri_db');
+    });
+    test('Test Matrix A: Brain only instance doctor and db push', async () => {
+        const instanceDir = node_path_1.default.join(testTempRoot, 'brain-only');
+        node_fs_1.default.mkdirSync(node_path_1.default.join(instanceDir, 'src'), { recursive: true });
+        const files = (0, generator_1.generateInstanceFiles)({
+            name: 'BrainOnlyInstance',
+            selectedManifests: [brain],
+        });
+        for (const [name, content] of Object.entries(files)) {
+            if (typeof content === 'string') {
+                const fullPath = node_path_1.default.join(instanceDir, name);
+                node_fs_1.default.mkdirSync(node_path_1.default.dirname(fullPath), { recursive: true });
+                node_fs_1.default.writeFileSync(fullPath, content);
+            }
+        }
+        // 1. Doctor without OPENROUTER_API_KEY -> FAIL (Brain Health Probe fails)
+        const doctorFail = await (0, doctor_1.runDoctor)({ projectDir: instanceDir, env: { OPENROUTER_API_KEY: '' } });
+        expect(doctorFail.passed).toBe(false);
+        expect(doctorFail.results.some((r) => r.category === 'Health Probe' && r.status === 'FAIL')).toBe(true);
+        // Database check must be SKIPPED
+        expect(doctorFail.results.some((r) => r.category === 'Database' && r.status === 'SKIPPED')).toBe(true);
+        // 2. Doctor with OPENROUTER_API_KEY -> PASS
+        const doctorPass = await (0, doctor_1.runDoctor)({
+            projectDir: instanceDir,
+            env: { OPENROUTER_API_KEY: 'test-key-123' },
+        });
+        expect(doctorPass.passed).toBe(true);
+        // 3. db push -> NOOP ("No database migrations are required...")
+        const dbResult = await (0, db_1.runDbPush)({ projectDir: instanceDir });
+        expect(dbResult.status).toBe('NOOP');
+        expect(dbResult.message).toContain('No database migrations are required');
+    });
+    test('Test Matrix B: Brain + Hands instance doctor and db push', async () => {
+        const instanceDir = node_path_1.default.join(testTempRoot, 'brain-hands');
+        node_fs_1.default.mkdirSync(node_path_1.default.join(instanceDir, 'src'), { recursive: true });
+        const files = (0, generator_1.generateInstanceFiles)({
+            name: 'BrainHandsInstance',
+            selectedManifests: [brain, hands],
+        });
+        for (const [name, content] of Object.entries(files)) {
+            if (typeof content === 'string') {
+                const fullPath = node_path_1.default.join(instanceDir, name);
+                node_fs_1.default.mkdirSync(node_path_1.default.dirname(fullPath), { recursive: true });
+                node_fs_1.default.writeFileSync(fullPath, content);
+            }
+        }
+        // Doctor checks both keys
+        const doctorRes = await (0, doctor_1.runDoctor)({
+            projectDir: instanceDir,
+            env: {
+                OPENROUTER_API_KEY: 'test-openrouter-key',
+                ACTION_POLICY_SECRET: 'test-policy-secret',
+            },
+        });
+        expect(doctorRes.passed).toBe(true);
+        expect(doctorRes.results.some((r) => r.name === 'OPENROUTER_API_KEY' && r.status === 'PASS')).toBe(true);
+        expect(doctorRes.results.some((r) => r.name === 'ACTION_POLICY_SECRET' && r.status === 'PASS')).toBe(true);
+        // Database check must be SKIPPED
+        expect(doctorRes.results.some((r) => r.category === 'Database' && r.status === 'SKIPPED')).toBe(true);
+        // db push returns NOOP
+        const dbResult = await (0, db_1.runDbPush)({ projectDir: instanceDir });
+        expect(dbResult.status).toBe('NOOP');
+    });
+    test('Test Matrix C: Brain + Memory instance requires DATABASE_URL', async () => {
+        const instanceDir = node_path_1.default.join(testTempRoot, 'brain-memory');
+        node_fs_1.default.mkdirSync(node_path_1.default.join(instanceDir, 'src'), { recursive: true });
+        const files = (0, generator_1.generateInstanceFiles)({
+            name: 'BrainMemoryInstance',
+            selectedManifests: [brain, memory],
+        });
+        for (const [name, content] of Object.entries(files)) {
+            if (typeof content === 'string') {
+                const fullPath = node_path_1.default.join(instanceDir, name);
+                node_fs_1.default.mkdirSync(node_path_1.default.dirname(fullPath), { recursive: true });
+                node_fs_1.default.writeFileSync(fullPath, content);
+            }
+        }
+        // 1. Doctor fails without DATABASE_URL
+        const doctorMissingDb = await (0, doctor_1.runDoctor)({
+            projectDir: instanceDir,
+            env: { OPENROUTER_API_KEY: 'test-key' },
+        });
+        expect(doctorMissingDb.passed).toBe(false);
+        expect(doctorMissingDb.results.some((r) => r.name === 'DATABASE_URL' && r.status === 'FAIL')).toBe(true);
+        // 2. db push fails clearly without DATABASE_URL
+        await expect((0, db_1.runDbPush)({ projectDir: instanceDir, env: {} })).rejects.toThrow(/DATABASE_URL is required/);
+    });
+    test('Test Matrix D: Diagnostics and Error Handling for invalid or missing configs', async () => {
+        // 1. Missing siduri.config.json
+        const nonExistentDir = node_path_1.default.join(testTempRoot, 'non-existent-dir');
+        await expect((0, doctor_1.runDoctor)({ projectDir: nonExistentDir })).rejects.toThrow(/siduri.config.json not found/);
+        await expect((0, db_1.runDbPush)({ projectDir: nonExistentDir })).rejects.toThrow(/siduri.config.json not found/);
+        // 2. Unreachable PostgreSQL host reported gracefully by doctor
+        const instDir = node_path_1.default.join(testTempRoot, 'brain-memory');
+        const doctorUnreachable = await (0, doctor_1.runDoctor)({
+            projectDir: instDir,
+            env: {
+                OPENROUTER_API_KEY: 'test-key',
+                DATABASE_URL: 'postgresql://postgres:postgres@127.0.0.1:59999/non_existent_db',
+            },
+        });
+        expect(doctorUnreachable.passed).toBe(false);
+        expect(doctorUnreachable.results.some((r) => r.category === 'Database' && r.status === 'FAIL')).toBe(true);
+    });
+});

package/dist/doctor.d.ts

@@ -0,0 +1,19 @@
+export interface DoctorCheckResult {
+    category: 'Environment' | 'Services' | 'Database' | 'Health Probe' | 'Configuration';
+    name: string;
+    status: 'PASS' | 'FAIL' | 'OPTIONAL_MISSING' | 'SKIPPED';
+    organName?: string;
+    message?: string;
+    remediation?: string;
+}
+export interface DoctorReport {
+    instanceName: string;
+    configuredOrgans: string[];
+    results: DoctorCheckResult[];
+    passed: boolean;
+}
+export interface DoctorOptions {
+    projectDir?: string;
+    env?: Record<string, string | undefined>;
+}
+export declare function runDoctor(options?: DoctorOptions): Promise<DoctorReport>;

package/dist/doctor.js

@@ -0,0 +1,249 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctor = runDoctor;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const discovery_1 = require("./discovery");
+const pg_1 = require("pg");
+const schema_validator_1 = require("./schema-validator");
+async function runDoctor(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.`);
+    }
+    // Load .env if present in projectDir
+    const envFile = node_path_1.default.join(projectDir, '.env');
+    const fileEnv = {};
+    if (node_fs_1.default.existsSync(envFile)) {
+        const lines = node_fs_1.default.readFileSync(envFile, 'utf8').split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const eqIdx = trimmed.indexOf('=');
+            if (eqIdx !== -1) {
+                const key = trimmed.slice(0, eqIdx).trim();
+                const val = trimmed.slice(eqIdx + 1).trim();
+                fileEnv[key] = val;
+            }
+        }
+    }
+    const effectiveEnv = {
+        ...process.env,
+        ...fileEnv,
+        ...(options.env || {}),
+    };
+    const config = JSON.parse(node_fs_1.default.readFileSync(configPath, 'utf8'));
+    const configuredOrgansMap = config.organs || {};
+    const organKeys = Object.keys(configuredOrgansMap);
+    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 selectedManifests = [];
+    const results = [];
+    // 0. Schema Validation Check
+    const schemaPath = node_path_1.default.join(projectDir, 'siduri.schema.json');
+    if (node_fs_1.default.existsSync(schemaPath)) {
+        try {
+            const schema = JSON.parse(node_fs_1.default.readFileSync(schemaPath, 'utf8'));
+            (0, schema_validator_1.validateCompanionConfig)(config, schema);
+            results.push({
+                category: 'Configuration',
+                name: 'Schema Conformance',
+                status: 'PASS',
+                message: 'siduri.config.json conforms to siduri.schema.json',
+            });
+        }
+        catch (err) {
+            results.push({
+                category: 'Configuration',
+                name: 'Schema Conformance',
+                status: 'FAIL',
+                message: err.message,
+                remediation: 'Update siduri.config.json to conform to the generated schema.',
+            });
+        }
+    }
+    // 1. Resolve manifests for selected organs
+    for (const organKey of organKeys) {
+        const m = registry.get(organKey) || registry.getAll().find((item) => item.configKey === organKey || item.organType === organKey);
+        if (!m) {
+            results.push({
+                category: 'Environment',
+                name: `Manifest resolution: ${organKey}`,
+                status: 'FAIL',
+                message: `Could not resolve package manifest for configured organ '${organKey}'.`,
+                remediation: `Ensure @siduri-x/${organKey} is installed in package.json and npm install has been run.`,
+            });
+        }
+        else {
+            selectedManifests.push(m);
+        }
+    }
+    // 2. Check Environment Variables (deduplicated)
+    const checkedEnvVars = new Set();
+    for (const m of selectedManifests) {
+        for (const envVar of m.environment || []) {
+            if (checkedEnvVars.has(envVar.name))
+                continue;
+            checkedEnvVars.add(envVar.name);
+            const val = effectiveEnv[envVar.name];
+            const isMissing = !val || val.trim() === '';
+            if (isMissing) {
+                if (envVar.required) {
+                    results.push({
+                        category: 'Environment',
+                        name: envVar.name,
+                        status: 'FAIL',
+                        organName: m.name,
+                        message: `Missing required environment variable '${envVar.name}'.`,
+                        remediation: `Set ${envVar.name} in .env or your shell environment. ${envVar.description || ''}`,
+                    });
+                }
+                else {
+                    results.push({
+                        category: 'Environment',
+                        name: envVar.name,
+                        status: 'OPTIONAL_MISSING',
+                        organName: m.name,
+                        message: `Optional variable '${envVar.name}' not set.`,
+                    });
+                }
+            }
+            else {
+                results.push({
+                    category: 'Environment',
+                    name: envVar.name,
+                    status: 'PASS',
+                    organName: m.name,
+                    message: 'Configured',
+                });
+            }
+        }
+    }
+    // 3. Check External Services
+    for (const m of selectedManifests) {
+        for (const service of m.services || []) {
+            results.push({
+                category: 'Services',
+                name: `${service.name} (${m.organType})`,
+                status: 'PASS',
+                organName: m.name,
+                message: 'Service requirement declared',
+            });
+        }
+    }
+    // 4. Database Check (only if an organ declares database requirement)
+    const dbOrgan = selectedManifests.find((m) => m.database !== null && m.database !== undefined);
+    if (dbOrgan) {
+        const dbUrl = effectiveEnv.DATABASE_URL;
+        if (!dbUrl) {
+            results.push({
+                category: 'Database',
+                name: 'PostgreSQL Connection',
+                status: 'FAIL',
+                organName: dbOrgan.name,
+                message: 'DATABASE_URL is not configured.',
+                remediation: 'Provide DATABASE_URL in .env (e.g. postgresql://postgres:postgres@localhost:5432/siduri)',
+            });
+        }
+        else {
+            const pool = new pg_1.Pool({ connectionString: dbUrl, connectionTimeoutMillis: 3000 });
+            try {
+                const client = await pool.connect();
+                await client.query('SELECT 1');
+                client.release();
+                await pool.end();
+                results.push({
+                    category: 'Database',
+                    name: 'PostgreSQL Connection',
+                    status: 'PASS',
+                    organName: dbOrgan.name,
+                    message: 'Connection successful',
+                });
+            }
+            catch (err) {
+                await pool.end().catch(() => { });
+                results.push({
+                    category: 'Database',
+                    name: 'PostgreSQL Connection',
+                    status: 'FAIL',
+                    organName: dbOrgan.name,
+                    message: `Connection failed: ${err.message}`,
+                    remediation: 'Check database host availability, port, credentials, and network accessibility.',
+                });
+            }
+        }
+    }
+    else {
+        results.push({
+            category: 'Database',
+            name: 'PostgreSQL Database',
+            status: 'SKIPPED',
+            message: 'Not required by current composition',
+        });
+    }
+    // 5. Organ Health Probes
+    for (const m of selectedManifests) {
+        if (m.healthCheck) {
+            try {
+                // Resolve package entrypoint
+                const candidateEntrypoints = [
+                    node_path_1.default.resolve(projectDir, 'node_modules', m.name, m.entrypoint),
+                    node_path_1.default.resolve(__dirname, '../../packages/organs', m.organType, m.entrypoint),
+                    node_path_1.default.resolve(process.cwd(), 'packages/organs', m.organType, m.entrypoint),
+                ];
+                const entryPath = candidateEntrypoints.find((p) => node_fs_1.default.existsSync(p));
+                if (entryPath) {
+                    const mod = require(entryPath);
+                    const probeFn = mod[m.healthCheck];
+                    if (typeof probeFn === 'function') {
+                        const organConf = configuredOrgansMap[m.configKey] || configuredOrgansMap[m.organType];
+                        const probeRes = await probeFn({ config: organConf, env: effectiveEnv });
+                        if (probeRes && probeRes.ok === false) {
+                            results.push({
+                                category: 'Health Probe',
+                                name: `${m.displayName} Probe`,
+                                status: 'FAIL',
+                                organName: m.name,
+                                message: probeRes.message || 'Health probe check failed',
+                                remediation: `Check ${m.displayName} configuration in siduri.config.json.`,
+                            });
+                        }
+                        else {
+                            results.push({
+                                category: 'Health Probe',
+                                name: `${m.displayName} Probe`,
+                                status: 'PASS',
+                                organName: m.name,
+                                message: probeRes?.message || 'Operational',
+                            });
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                results.push({
+                    category: 'Health Probe',
+                    name: `${m.displayName} Probe`,
+                    status: 'FAIL',
+                    organName: m.name,
+                    message: `Probe invocation failed: ${err.message}`,
+                });
+            }
+        }
+    }
+    const passed = results.every((r) => r.status !== 'FAIL');
+    return {
+        instanceName: config.name || 'Siduri Instance',
+        configuredOrgans: organKeys,
+        results,
+        passed,
+    };
+}

package/dist/generator.d.ts

@@ -0,0 +1,20 @@
+import { OrganManifest } from './manifest';
+export interface GeneratedInstanceFiles {
+    'package.json': string;
+    'siduri.config.json': string;
+    'siduri.schema.json': string;
+    '.env.example': string;
+    'README.md': string;
+    'src/index.js': string;
+    'public/index.html': string;
+    createAssetsBodyDir?: boolean;
+    createAssetsDirs?: string[];
+}
+export interface InstanceGeneratorOptions {
+    name: string;
+    id?: string;
+    selectedManifests: OrganManifest[];
+    organConfigs?: Record<string, any>;
+    coreVersion?: string;
+}
+export declare function generateInstanceFiles(options: InstanceGeneratorOptions): GeneratedInstanceFiles;