@vxnus/siduri 0.0.4 → 0.0.6

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

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

package/dist/doctor-db.test.js

@@ -0,0 +1,135 @@
+"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') {
+                node_fs_1.default.writeFileSync(node_path_1.default.join(instanceDir, name), 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') {
+                node_fs_1.default.writeFileSync(node_path_1.default.join(instanceDir, name), 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') {
+                node_fs_1.default.writeFileSync(node_path_1.default.join(instanceDir, name), 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';
+    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,225 @@
+"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");
+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 = [];
+    // 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,18 @@
+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;
+    createAssetsBodyDir?: boolean;
+}
+export interface InstanceGeneratorOptions {
+    name: string;
+    id?: string;
+    selectedManifests: OrganManifest[];
+    organConfigs?: Record<string, any>;
+    coreVersion?: string;
+}
+export declare function generateInstanceFiles(options: InstanceGeneratorOptions): GeneratedInstanceFiles;

package/dist/generator.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateInstanceFiles = generateInstanceFiles;
+function getDefaultConfigForManifest(manifest) {
+    const schema = manifest.configSchema || {};
+    const props = schema.properties || {};
+    const config = {};
+    for (const [key, val] of Object.entries(props)) {
+        if (val.default !== undefined) {
+            config[key] = val.default;
+        }
+        else if (val.enum && val.enum.length > 0) {
+            config[key] = val.enum[0];
+        }
+        else if (val.type === 'string') {
+            config[key] = '';
+        }
+        else if (val.type === 'number') {
+            config[key] = 0;
+        }
+        else if (val.type === 'boolean') {
+            config[key] = false;
+        }
+        else if (val.type === 'array') {
+            config[key] = [];
+        }
+        else if (val.type === 'object') {
+            config[key] = {};
+        }
+    }
+    // Provide sensible defaults for known common keys if missing
+    if (manifest.organType === 'brain') {
+        config.provider = config.provider || 'openrouter';
+        config.model = config.model || 'anthropic/claude-3.5-sonnet';
+        config.apiKeyEnv = 'OPENROUTER_API_KEY';
+    }
+    else if (manifest.organType === 'memory') {
+        config.provider = config.provider || 'postgres';
+    }
+    else if (manifest.organType === 'voice') {
+        config.provider = config.provider || 'voicevox';
+        config.speakerId = config.speakerId || 1;
+        config.baseUrl = config.baseUrl || 'http://localhost:50021';
+    }
+    else if (manifest.organType === 'body') {
+        config.provider = config.provider || 'live2d';
+        config.initialExpression = config.initialExpression || 'neutral';
+    }
+    else if (manifest.organType === 'hands') {
+        config.defaultTimeoutMs = config.defaultTimeoutMs || 10000;
+        config.providers = config.providers || [];
+    }
+    else if (manifest.organType === 'knowledge') {
+        config.provider = config.provider || 'none';
+    }
+    else if (manifest.organType === 'behavior') {
+        config.provider = config.provider || 'active_self';
+    }
+    else if (manifest.organType === 'vision') {
+        config.provider = config.provider || 'openrouter';
+        config.model = config.model || 'gpt-4-vision';
+    }
+    return config;
+}
+function generateInstanceFiles(options) {
+    const instanceName = options.name || 'my-siduri';
+    const instanceId = options.id || 'default';
+    const coreVersion = options.coreVersion || '^1.0.0';
+    const manifests = options.selectedManifests;
+    // 1. package.json
+    const dependencies = {
+        '@siduri-x/core': coreVersion,
+    };
+    for (const m of manifests) {
+        dependencies[m.name] = `^${m.version || '1.0.0'}`;
+    }
+    const packageJsonObj = {
+        name: instanceName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'my-siduri',
+        private: true,
+        type: 'module',
+        scripts: {
+            start: 'node src/index.js',
+            dev: 'node --watch src/index.js',
+            doctor: 'siduri doctor',
+            db: 'siduri db',
+        },
+        dependencies,
+    };
+    const packageJson = JSON.stringify(packageJsonObj, null, 2) + '\n';
+    // 2. siduri.config.json
+    const organsConfig = {};
+    for (const m of manifests) {
+        const customConfig = options.organConfigs?.[m.configKey] || options.organConfigs?.[m.organType];
+        organsConfig[m.configKey] = customConfig || getDefaultConfigForManifest(m);
+    }
+    const configObj = {
+        $schema: './siduri.schema.json',
+        id: instanceId,
+        name: instanceName,
+        organs: organsConfig,
+    };
+    const siduriConfigJson = JSON.stringify(configObj, null, 2) + '\n';
+    // 3. siduri.schema.json
+    const organPropertiesSchema = {};
+    for (const m of manifests) {
+        organPropertiesSchema[m.configKey] = m.configSchema || { type: 'object' };
+    }
+    const schemaObj = {
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        title: `Siduri Configuration Schema (${instanceName})`,
+        type: 'object',
+        required: ['id', 'name', 'organs'],
+        additionalProperties: false,
+        properties: {
+            $schema: { type: 'string' },
+            id: { type: 'string', description: 'Unique companion isolation ID' },
+            name: { type: 'string', description: 'Display name of the companion' },
+            organs: {
+                type: 'object',
+                additionalProperties: false,
+                properties: organPropertiesSchema,
+            },
+        },
+    };
+    const siduriSchemaJson = JSON.stringify(schemaObj, null, 2) + '\n';
+    // 4. .env.example
+    const envLines = [];
+    for (const m of manifests) {
+        if (m.environment && m.environment.length > 0) {
+            envLines.push(`# ${m.displayName || m.name}`);
+            for (const envVar of m.environment) {
+                if (envVar.description) {
+                    envLines.push(`# ${envVar.description}${envVar.required ? ' (required)' : ' (optional)'}`);
+                }
+                const defaultVal = envVar.default || '';
+                envLines.push(`${envVar.name}=${defaultVal}`);
+            }
+            envLines.push('');
+        }
+    }
+    const envExample = envLines.length > 0 ? envLines.join('\n') : '# No external environment variables required\n';
+    // 5. src/index.js
+    const importLines = [
+        `import { readFile } from 'node:fs/promises';`,
+        `import { SiduriRuntime } from '@siduri-x/core';`,
+    ];
+    for (const m of manifests) {
+        importLines.push(`import { ${m.factory} } from '${m.name}';`);
+    }
+    const instantiationLines = [];
+    const organMapEntries = [];
+    for (const m of manifests) {
+        const varName = m.configKey;
+        instantiationLines.push(`const ${varName} = new ${m.factory}(config.organs.${m.configKey});`);
+        organMapEntries.push(`  ${varName},`);
+    }
+    const selectedDisplayNames = manifests.map((m) => m.displayName.split(' ')[0] || m.organType).join(', ');
+    const srcIndexJs = [
+        ...importLines,
+        '',
+        `const config = JSON.parse(`,
+        `  await readFile(new URL('../siduri.config.json', import.meta.url), 'utf8')`,
+        `);`,
+        '',
+        ...instantiationLines,
+        '',
+        `const runtime = new SiduriRuntime(config.id, config, {`,
+        ...organMapEntries,
+        `});`,
+        '',
+        `await runtime.initialize();`,
+        '',
+        `console.log(\`✓ Siduri [\${config.name}] initialized with [${selectedDisplayNames}].\`);`,
+        '',
+    ].join('\n');
+    // 6. README.md
+    const readmeLines = [
+        `# ${instanceName}`,
+        '',
+        `Standalone Siduri instance generated with explicitly composed organs:`,
+        '',
+        ...manifests.map((m) => `- **${m.displayName}** (\`${m.name}\`)`),
+        '',
+        '## Getting Started',
+        '',
+        '1. Install dependencies:',
+        '```bash',
+        'npm install',
+        '```',
+        '',
+        '2. Configure environment:',
+        '```bash',
+        'cp .env.example .env',
+        '```',
+    ];
+    const hasMemory = manifests.some((m) => m.organType === 'memory');
+    if (hasMemory) {
+        readmeLines.push('', '### Database Setup', 'This instance uses PostgreSQL Memory for durable claims and directives.', 'Ensure `DATABASE_URL` in `.env` is reachable, then run migrations:', '```bash', 'npx @vxnus/siduri db push', '```');
+    }
+    const hasBody = manifests.some((m) => m.organType === 'body');
+    if (hasBody) {
+        readmeLines.push('', '### Avatar Assets', 'Place your Live2D Cubism model assets into `./assets/body/model/`:', '- `model.model3.json`', '- `model.moc3`', '- textures directory');
+    }
+    readmeLines.push('', '## Running the Instance', '', 'Start the companion:', '```bash', 'npm start', '```', '', 'Run diagnostics:', '```bash', 'npm run doctor', '```', '');
+    const readmeMd = readmeLines.join('\n');
+    return {
+        'package.json': packageJson,
+        'siduri.config.json': siduriConfigJson,
+        'siduri.schema.json': siduriSchemaJson,
+        '.env.example': envExample,
+        'README.md': readmeMd,
+        'src/index.js': srcIndexJs,
+        createAssetsBodyDir: hasBody,
+    };
+}

package/dist/generator.test.d.ts

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