siduri 1.0.0

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();
+        const manifests = registry.getAll();
+        expect(manifests.length).toBe(11);
+        const organTypes = registry.getAvailableOrganTypes().sort();
+        expect(organTypes).toEqual([
+            'archive',
+            'behavior',
+            'body',
+            'brain',
+            'ear',
+            'hands',
+            'knowledge',
+            'mouth',
+            'observation',
+            'vision',
+            'voice',
+        ]);
+    });
+    test('Generates valid instances from discovered manifests', () => {
+        const registry = discovery_1.OrganRegistry.discover();
+        // 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([
+            '@sidurijs/brain',
+            '@sidurijs/core',
+            '@sidurijs/hands',
+            '@sidurijs/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('archive')).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,52 @@
+"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();
+    const brain = registry.get('brain');
+    const hands = registry.get('hands');
+    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('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);
+            }
+        }
+        const doctorPass = await (0, doctor_1.runDoctor)({
+            projectDir: instanceDir,
+            env: { OPENROUTER_API_KEY: 'test-key-123' },
+        });
+        expect(doctorPass.passed).toBe(true);
+        const dbResult = await (0, db_1.runDbPush)({ projectDir: instanceDir });
+        expect(dbResult.status).toBe('NOOP');
+        expect(dbResult.message).toContain('SQLite manages schema natively.');
+    });
+});

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,266 @@
+"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 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();
+                let val = trimmed.slice(eqIdx + 1).trim();
+                if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+                    val = val.slice(1, -1);
+                }
+                if (val) {
+                    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 @sidurijs/${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 || []) {
+            const organConf = configuredOrgansMap[m.configKey] || configuredOrgansMap[m.organType];
+            const configuredUrl = organConf?.baseUrl || organConf?.url || effectiveEnv[`${service.name.toUpperCase()}_URL`];
+            if (configuredUrl && typeof configuredUrl === 'string' && configuredUrl.startsWith('http')) {
+                try {
+                    const controller = new AbortController();
+                    const timer = setTimeout(() => controller.abort(), 1000);
+                    await fetch(configuredUrl, { signal: controller.signal }).catch(() => { });
+                    clearTimeout(timer);
+                    results.push({
+                        category: 'Services',
+                        name: `${service.name} (${m.organType})`,
+                        status: 'PASS',
+                        organName: m.name,
+                        message: `Endpoint configured: ${configuredUrl}`,
+                    });
+                }
+                catch {
+                    results.push({
+                        category: 'Services',
+                        name: `${service.name} (${m.organType})`,
+                        status: 'OPTIONAL_MISSING',
+                        organName: m.name,
+                        message: `Service at ${configuredUrl} is not responding (optional local service)`,
+                        remediation: `Start ${service.name} or allow auto-download if applicable.`,
+                    });
+                }
+            }
+            else {
+                results.push({
+                    category: 'Services',
+                    name: `${service.name} (${m.organType})`,
+                    status: 'PASS',
+                    organName: m.name,
+                    message: 'Service requirement declared (managed locally)',
+                });
+            }
+        }
+    }
+    // 4. Database Check (only if an organ declares database requirement)
+    const dbOrgan = selectedManifests.find((m) => m.database !== null && m.database !== undefined);
+    if (dbOrgan) {
+        try {
+            const testDbPath = node_path_1.default.join(projectDir, '.doctor-sqlite-test.tmp');
+            node_fs_1.default.writeFileSync(testDbPath, '');
+            node_fs_1.default.unlinkSync(testDbPath);
+            results.push({
+                category: 'Database',
+                name: 'SQLite Database',
+                status: 'PASS',
+                organName: dbOrgan.name,
+                message: 'Local storage directory writeable; SQLite operational',
+            });
+        }
+        catch (err) {
+            results.push({
+                category: 'Database',
+                name: 'SQLite Database',
+                status: 'FAIL',
+                organName: dbOrgan.name,
+                message: `Storage directory write check failed: ${err.message}`,
+                remediation: 'Verify write permissions for the companion directory.',
+            });
+        }
+    }
+    else {
+        results.push({
+            category: 'Database',
+            name: 'SQLite 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,23 @@
+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[];
+    [key: string]: string | boolean | string[] | undefined;
+}
+export interface InstanceGeneratorOptions {
+    name: string;
+    id?: string;
+    selectedManifests: OrganManifest[];
+    organConfigs?: Record<string, any>;
+    coreVersion?: string;
+    cliVersion?: string;
+    localPath?: string;
+}
+export declare function generateInstanceFiles(options: InstanceGeneratorOptions): GeneratedInstanceFiles;