@vxnus/siduri 0.0.7 → 0.0.9

package/dist/configurators/memory.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureMemory = configureMemory;
+const inquirer_1 = __importDefault(require("inquirer"));
+async function configureMemory(_context) {
+    const { database } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'database',
+        message: 'Memory database?',
+        choices: [
+            { name: 'PostgreSQL (FTS relational claims with ACID durability)', value: 'postgres' },
+        ],
+    });
+    const { deployment } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'deployment',
+        message: 'PostgreSQL deployment target?',
+        choices: [
+            { name: 'Supabase (Hosted Postgres with connection pooling)', value: 'supabase' },
+            { name: 'Neon (Serverless Postgres with branch-per-companion)', value: 'neon' },
+            { name: 'Local PostgreSQL (Docker or system service)', value: 'local' },
+            { name: 'Other PostgreSQL URL', value: 'other' },
+        ],
+    });
+    const deploymentDisplayNames = {
+        supabase: 'Supabase',
+        neon: 'Neon',
+        local: 'Local PostgreSQL',
+        other: 'Other PostgreSQL',
+    };
+    return {
+        config: {
+            provider: database,
+            deployment,
+        },
+        summary: {
+            Database: 'PostgreSQL',
+            Deploy: deploymentDisplayNames[deployment] || deployment,
+        },
+    };
+}

package/dist/configurators/observation.d.ts

@@ -0,0 +1,2 @@
+import { OrganConfiguratorContext, OrganConfigurationResult } from './types';
+export declare function configureObservation(_context: OrganConfiguratorContext): Promise<OrganConfigurationResult>;

package/dist/configurators/observation.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureObservation = configureObservation;
+async function configureObservation(_context) {
+    return {
+        config: {},
+        summary: {
+            Provider: 'Grounded Observation Ingest',
+            Deduplication: 'Cryptographic SHA-256 Hashing',
+        },
+    };
+}

package/dist/configurators/types.d.ts

@@ -0,0 +1,12 @@
+import { OrganManifest } from '../manifest';
+export interface OrganConfigurationResult {
+    config: Record<string, unknown>;
+    summary?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface OrganConfiguratorContext {
+    companionName: string;
+    manifest: OrganManifest;
+    existingConfig?: Record<string, unknown>;
+}
+export type OrganConfigurator = (context: OrganConfiguratorContext) => Promise<OrganConfigurationResult>;

package/dist/configurators/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/configurators/vision.d.ts

@@ -0,0 +1,2 @@
+import { OrganConfiguratorContext, OrganConfigurationResult } from './types';
+export declare function configureVision(_context: OrganConfiguratorContext): Promise<OrganConfigurationResult>;

package/dist/configurators/vision.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureVision = configureVision;
+const inquirer_1 = __importDefault(require("inquirer"));
+async function configureVision(_context) {
+    const { model } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'model',
+        message: 'Vision model:',
+        choices: [
+            { name: 'GPT-4 Vision / GPT-4o (Multimodal OCR & Object Inspection)', value: 'gpt-4-vision' },
+            { name: 'Claude 3.5 Sonnet Vision', value: 'anthropic/claude-3.5-sonnet' },
+            { name: 'Custom Vision Model', value: 'custom' },
+        ],
+    });
+    let selectedModel = model;
+    if (model === 'custom') {
+        const { customModel } = await inquirer_1.default.prompt({
+            type: 'input',
+            name: 'customModel',
+            message: 'Vision Model ID:',
+            default: 'gpt-4-vision',
+        });
+        selectedModel = customModel.trim();
+    }
+    return {
+        config: {
+            provider: 'openrouter',
+            model: selectedModel,
+        },
+        summary: {
+            Provider: 'OpenRouter Vision',
+            Model: selectedModel,
+        },
+    };
+}

package/dist/configurators/voice.d.ts

@@ -0,0 +1,2 @@
+import { OrganConfiguratorContext, OrganConfigurationResult } from './types';
+export declare function configureVoice(_context: OrganConfiguratorContext): Promise<OrganConfigurationResult>;

package/dist/configurators/voice.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureVoice = configureVoice;
+const inquirer_1 = __importDefault(require("inquirer"));
+async function configureVoice(_context) {
+    const { provider } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'provider',
+        message: 'Voice provider?',
+        choices: [
+            { name: 'VOICEVOX (Local high-fidelity neural speech synthesis engine)', value: 'voicevox' },
+            { name: 'None (Disable voice synthesis)', value: 'none' },
+        ],
+    });
+    if (provider === 'none') {
+        return {
+            config: { provider: 'none' },
+            summary: { Provider: 'None (Voice disabled)' },
+        };
+    }
+    const answers = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'baseUrl',
+            message: 'VOICEVOX Engine Base URL:',
+            default: 'http://localhost:50021',
+        },
+        {
+            type: 'input',
+            name: 'speakerId',
+            message: 'Default Speaker ID (e.g. 1 for Zundamon, 2 for Shikoku Metan):',
+            default: '1',
+            validate: (v) => !isNaN(parseInt(v, 10)) || 'Speaker ID must be an integer.',
+        },
+    ]);
+    const speakerId = parseInt(answers.speakerId, 10) || 1;
+    return {
+        config: {
+            provider: 'voicevox',
+            baseUrl: answers.baseUrl.trim(),
+            speakerId,
+            maxQueueDepth: 50,
+        },
+        summary: {
+            Provider: 'VOICEVOX',
+            'Speaker ID': speakerId,
+            'Base URL': answers.baseUrl.trim(),
+        },
+    };
+}

package/dist/configurators.test.d.ts

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

package/dist/configurators.test.js

@@ -0,0 +1,275 @@
+"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', speakerId: '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('Body configurator configures Live2D and expression', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'live2d' })
+                .mockResolvedValueOnce({ initialExpression: 'happy' });
+            const result = await (0, body_1.configureBody)({ companionName: 'Sparkle', manifest: bodyManifest });
+            expect(result.config.provider).toBe('live2d');
+            expect(result.config.initialExpression).toBe('happy');
+        });
+        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 { VoicevoxAdapter } from '@siduri-x/voice'");
+        });
+    });
+});

package/dist/doctor-db.test.js

@@ -44,7 +44,9 @@ describe('Phase 4: Diagnostics and Database Provisioning Tests', () => {
         });
         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);
+                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)
@@ -73,7 +75,9 @@ describe('Phase 4: Diagnostics and Database Provisioning Tests', () => {
         });
         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);
+                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
@@ -102,7 +106,9 @@ describe('Phase 4: Diagnostics and Database Provisioning Tests', () => {
         });
         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);
+                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

package/dist/generator.d.ts

@@ -6,6 +6,8 @@ export interface GeneratedInstanceFiles {
     '.env.example': string;
     'README.md': string;
     'src/index.js': string;
+    'public/index.html': string;
+    'docker-compose.yml'?: string;
     createAssetsBodyDir?: boolean;
 }
 export interface InstanceGeneratorOptions {