siduri 1.0.0

package/dist/index.js

@@ -0,0 +1,607 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colors = exports.CLI_VERSION = void 0;
+exports.printHeader = printHeader;
+exports.printSection = printSection;
+exports.printSuccess = printSuccess;
+exports.projectDirectoryName = projectDirectoryName;
+exports.validateProjectDirectory = validateProjectDirectory;
+exports.formatReviewSummary = formatReviewSummary;
+exports.withTask = withTask;
+exports.runCreateWizard = runCreateWizard;
+exports.runCliDoctor = runCliDoctor;
+exports.runCliReset = runCliReset;
+exports.runCliDb = runCliDb;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const inquirer_1 = __importDefault(require("inquirer"));
+const discovery_1 = require("./discovery");
+const generator_1 = require("./generator");
+const doctor_1 = require("./doctor");
+const db_1 = require("./db");
+const configurators_1 = require("./configurators");
+const execFile = (0, node_util_1.promisify)(node_child_process_1.execFile);
+exports.CLI_VERSION = '2.1.0';
+const colors_1 = require("./colors");
+Object.defineProperty(exports, "colors", { enumerable: true, get: function () { return colors_1.colors; } });
+function printHeader() {
+    console.log(`\n${colors_1.colors.cyan}◈ SIDURI${colors_1.colors.reset} ${colors_1.colors.dim}companion setup (manifest-driven)${colors_1.colors.reset}`);
+    console.log(`${colors_1.colors.yellow}Version ${exports.CLI_VERSION}${colors_1.colors.reset} · composable standalone architecture\n`);
+}
+function printSection(title) {
+    console.log(`\n${colors_1.colors.cyan}── ${title} ${'─'.repeat(Math.max(2, 42 - title.length))}${colors_1.colors.reset}\n`);
+}
+function printSuccess(message) {
+    console.log(`${colors_1.colors.green}✓${colors_1.colors.reset} ${message}`);
+}
+function projectDirectoryName(value) {
+    return (value || '').trim() || 'Companion';
+}
+function validateProjectDirectory(value) {
+    const trimmed = (value || '').trim();
+    if (!trimmed) {
+        return 'Please enter a project directory.';
+    }
+    if (/^\d+$/.test(trimmed) || !isNaN(Number(trimmed))) {
+        return 'Project directory cannot be a number.';
+    }
+    const resolved = node_path_1.default.resolve(process.cwd(), trimmed);
+    if (node_fs_1.default.existsSync(resolved)) {
+        return `Directory "${trimmed}" already exists in the current directory.`;
+    }
+    return true;
+}
+function formatReviewSummary(projectDirName, selectedManifests, organSummaries) {
+    const lines = [];
+    lines.push(`\n${colors_1.colors.cyan}── Review ${projectDirName} ${'─'.repeat(Math.max(2, 42 - (projectDirName.length + 9)))}${colors_1.colors.reset}\n`);
+    lines.push(`  ${colors_1.colors.bold}Project${colors_1.colors.reset}`);
+    lines.push(`    ${colors_1.colors.dim}Directory:${colors_1.colors.reset} ${projectDirName}\n`);
+    for (const m of selectedManifests) {
+        const isRequired = m.organType === 'brain';
+        const tag = isRequired ? ` ${colors_1.colors.dim}· required${colors_1.colors.reset}` : '';
+        lines.push(`  ${colors_1.colors.bold}${m.displayName.split(' ')[0] || m.organType}${colors_1.colors.reset}${tag}`);
+        const summary = organSummaries[m.configKey] || organSummaries[m.organType] || {};
+        const entries = Object.entries(summary);
+        if (entries.length === 0) {
+            lines.push(`    ${colors_1.colors.dim}Provider:${colors_1.colors.reset} ${m.displayName}`);
+        }
+        else {
+            for (const [key, val] of entries) {
+                const valStr = String(val);
+                lines.push(`    ${colors_1.colors.dim}${key}:${colors_1.colors.reset}${' '.repeat(Math.max(1, 10 - key.length))}${valStr}`);
+            }
+        }
+        lines.push('');
+    }
+    lines.push(`${colors_1.colors.cyan}${'─'.repeat(46)}${colors_1.colors.reset}\n`);
+    return lines.join('\n');
+}
+async function withTask(label, task) {
+    process.stdout.write(`${colors_1.colors.dim}${label}${colors_1.colors.reset}`);
+    const frames = ['·', '•', '●', '•'];
+    let index = 0;
+    const timer = setInterval(() => {
+        process.stdout.write(`\r${colors_1.colors.dim}${label} ${frames[index++ % frames.length]}${colors_1.colors.reset}`);
+    }, 120);
+    try {
+        const result = await task();
+        clearInterval(timer);
+        process.stdout.write(`\r${colors_1.colors.green}✓${colors_1.colors.reset} ${label}\n`);
+        return result;
+    }
+    catch (error) {
+        clearInterval(timer);
+        process.stdout.write(`\r${colors_1.colors.yellow}!${colors_1.colors.reset} ${label}\n`);
+        throw error;
+    }
+}
+function nonEmpty(value) {
+    return value.trim().length > 0 || 'Please enter a value.';
+}
+async function runCreateWizard(targetDir, options) {
+    printHeader();
+    // 1. Discover manifests from installed or monorepo packages
+    const registry = discovery_1.OrganRegistry.discover();
+    const availableManifests = registry.getAll();
+    if (availableManifests.length === 0) {
+        throw new Error('No @sidurijs/* organ packages found. Please ensure organs are installed or in workspace.');
+    }
+    printSection('Project Details');
+    let projectDirName;
+    if (targetDir) {
+        const check = validateProjectDirectory(targetDir);
+        if (check !== true) {
+            console.warn(`${colors_1.colors.yellow}!${colors_1.colors.reset} Provided directory "${targetDir}" is invalid: ${check}\n`);
+            const dirAnswers = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'directory',
+                    message: 'Project directory:',
+                    default: 'Companion',
+                    validate: validateProjectDirectory,
+                },
+            ]);
+            projectDirName = dirAnswers.directory.trim();
+        }
+        else {
+            projectDirName = targetDir.trim();
+        }
+    }
+    else {
+        const dirAnswers = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'directory',
+                message: 'Project directory:',
+                default: 'Companion',
+                validate: validateProjectDirectory,
+            },
+        ]);
+        projectDirName = dirAnswers.directory.trim();
+    }
+    const projectDir = node_path_1.default.resolve(process.cwd(), projectDirName);
+    printSection('Organ Configuration');
+    console.log(`${colors_1.colors.dim}Configuring capability organs for ${projectDirName} sequentially from cognition to physical embodiment.${colors_1.colors.reset}\n`);
+    // Canonical organ presentation order: Cognition -> Memory/State -> Identity -> Embodiment & Peripheral
+    const canonicalOrder = ['brain', 'memory', 'knowledge', 'behavior', 'voice', 'body', 'mouth', 'hands', 'vision', 'ear', 'observation'];
+    const orderedManifests = [...availableManifests].sort((a, b) => {
+        const idxA = canonicalOrder.indexOf(a.organType);
+        const idxB = canonicalOrder.indexOf(b.organType);
+        const valA = idxA === -1 ? 99 : idxA;
+        const valB = idxB === -1 ? 99 : idxB;
+        return valA - valB;
+    });
+    const selectedManifests = [];
+    const organConfigs = {};
+    const organSummaries = {};
+    for (const m of orderedManifests) {
+        const isRequired = m.organType === 'brain';
+        const sectionTitle = isRequired ? `${m.displayName.split(' ')[0] || m.organType} · required` : m.displayName.split(' ')[0] || m.organType;
+        printSection(sectionTitle);
+        const res = await (0, configurators_1.configureOrgan)(m, {
+            companionName: projectDirName,
+            existingConfig: organConfigs[m.configKey],
+        });
+        if (res.config?.provider === 'none') {
+            continue;
+        }
+        selectedManifests.push(m);
+        organConfigs[m.configKey] = res.config;
+        organSummaries[m.configKey] = res.summary || {};
+    }
+    // 2. Final Review and Edit Loop
+    while (true) {
+        console.log(formatReviewSummary(projectDirName, selectedManifests, organSummaries));
+        const { reviewAction } = await inquirer_1.default.prompt({
+            type: 'list',
+            name: 'reviewAction',
+            message: `Create ${projectDirName} with this configuration?`,
+            choices: [
+                { name: 'Yes, create', value: 'create' },
+                { name: 'Go back and edit', value: 'edit' },
+                { name: 'Cancel', value: 'cancel' },
+            ],
+        });
+        if (reviewAction === 'cancel') {
+            console.log('Instance creation cancelled.');
+            return;
+        }
+        if (reviewAction === 'create') {
+            break;
+        }
+        if (reviewAction === 'edit') {
+            const editChoices = orderedManifests.map((m) => {
+                const isSelected = selectedManifests.some((sm) => sm.organType === m.organType);
+                return {
+                    name: `${m.displayName} (${isSelected ? 'Enabled' : 'Disabled / Skipped'})`,
+                    value: m.configKey,
+                };
+            });
+            editChoices.push({ name: 'Edit all organs in sequence', value: '__ALL__' });
+            editChoices.push({ name: 'Back to review', value: '__BACK__' });
+            const { organToEdit } = await inquirer_1.default.prompt({
+                type: 'list',
+                name: 'organToEdit',
+                message: 'Which organ would you like to edit?',
+                choices: editChoices,
+            });
+            if (organToEdit === '__BACK__') {
+                continue;
+            }
+            const organsToReconfigure = organToEdit === '__ALL__'
+                ? orderedManifests
+                : orderedManifests.filter((m) => m.configKey === organToEdit);
+            for (const m of organsToReconfigure) {
+                const isRequired = m.organType === 'brain';
+                const sectionTitle = isRequired ? `${m.displayName.split(' ')[0] || m.organType} · required` : m.displayName.split(' ')[0] || m.organType;
+                printSection(sectionTitle);
+                const res = await (0, configurators_1.configureOrgan)(m, {
+                    companionName: projectDirName,
+                    existingConfig: organConfigs[m.configKey],
+                });
+                if (res.config?.provider === 'none') {
+                    const idx = selectedManifests.findIndex((sm) => sm.organType === m.organType);
+                    if (idx !== -1)
+                        selectedManifests.splice(idx, 1);
+                    delete organConfigs[m.configKey];
+                    delete organSummaries[m.configKey];
+                }
+                else {
+                    if (!selectedManifests.some((sm) => sm.organType === m.organType)) {
+                        selectedManifests.push(m);
+                        selectedManifests.sort((a, b) => {
+                            const idxA = canonicalOrder.indexOf(a.organType);
+                            const idxB = canonicalOrder.indexOf(b.organType);
+                            return (idxA === -1 ? 99 : idxA) - (idxB === -1 ? 99 : idxB);
+                        });
+                    }
+                    organConfigs[m.configKey] = res.config;
+                    organSummaries[m.configKey] = res.summary || {};
+                }
+            }
+        }
+    }
+    // 4. Generate Instance Files
+    const files = (0, generator_1.generateInstanceFiles)({
+        name: projectDirName,
+        selectedManifests,
+        organConfigs,
+        localPath: options?.localPath,
+    });
+    await (0, promises_1.mkdir)(projectDir, { recursive: true });
+    await (0, promises_1.mkdir)(node_path_1.default.join(projectDir, 'src'), { recursive: true });
+    const publicDir = node_path_1.default.join(projectDir, 'public');
+    await (0, promises_1.mkdir)(publicDir, { recursive: true });
+    await (0, promises_1.writeFile)(node_path_1.default.join(projectDir, 'package.json'), files['package.json'], 'utf8');
+    await (0, promises_1.writeFile)(node_path_1.default.join(projectDir, 'siduri.config.json'), files['siduri.config.json'], 'utf8');
+    await (0, promises_1.writeFile)(node_path_1.default.join(projectDir, 'siduri.schema.json'), files['siduri.schema.json'], 'utf8');
+    await (0, promises_1.writeFile)(node_path_1.default.join(projectDir, '.env.example'), files['.env.example'], 'utf8');
+    await (0, promises_1.writeFile)(node_path_1.default.join(projectDir, 'README.md'), files['README.md'], 'utf8');
+    await (0, promises_1.writeFile)(node_path_1.default.join(projectDir, 'src/index.js'), files['src/index.js'], 'utf8');
+    // Copy full Next.js apps/web production build if present
+    const webDistCandidates = [
+        node_path_1.default.resolve(__dirname, 'web-dist'),
+        node_path_1.default.resolve(__dirname, '../dist/web-dist'),
+        node_path_1.default.resolve(__dirname, '../../apps/web/out'),
+        node_path_1.default.resolve(process.cwd(), 'apps/web/out'),
+    ];
+    const foundWebDist = webDistCandidates.find((p) => node_fs_1.default.existsSync(p));
+    if (foundWebDist) {
+        node_fs_1.default.cpSync(foundWebDist, publicDir, { recursive: true });
+    }
+    else {
+        await (0, promises_1.writeFile)(node_path_1.default.join(publicDir, 'index.html'), files['public/index.html'], 'utf8');
+    }
+    if (files.createAssetsDirs && files.createAssetsDirs.length > 0) {
+        for (const dir of files.createAssetsDirs) {
+            await (0, promises_1.mkdir)(node_path_1.default.join(projectDir, dir), { recursive: true });
+        }
+    }
+    else if (files.createAssetsBodyDir) {
+        await (0, promises_1.mkdir)(node_path_1.default.join(projectDir, 'assets/body'), { recursive: true });
+    }
+    // Write all additional generated files (such as assets/self/default.self or other assets)
+    const handledKeys = new Set([
+        'package.json',
+        'siduri.config.json',
+        'siduri.schema.json',
+        '.env.example',
+        'README.md',
+        'src/index.js',
+        'public/index.html',
+        'createAssetsDirs',
+        'createAssetsBodyDir',
+    ]);
+    for (const [relPath, content] of Object.entries(files)) {
+        if (handledKeys.has(relPath) || typeof content !== 'string')
+            continue;
+        const destPath = node_path_1.default.join(projectDir, relPath);
+        await (0, promises_1.mkdir)(node_path_1.default.dirname(destPath), { recursive: true });
+        await (0, promises_1.writeFile)(destPath, content, 'utf8');
+    }
+    // If local knowledge archive is configured with a download URL, automatically fetch and unpack it
+    const knowledgeConfig = organConfigs.knowledge || organConfigs['@sidurijs/knowledge'];
+    if (knowledgeConfig?.pack?.mode === 'local' && knowledgeConfig?.pack?.archiveUrl) {
+        const packRelDir = (knowledgeConfig.packPath || 'assets/knowledge/pack').replace(/^\.\//, '');
+        const packDest = node_path_1.default.join(projectDir, packRelDir);
+        try {
+            await withTask(`Downloading knowledge archive (${knowledgeConfig.pack.packId || 'pack'})`, async () => {
+                const res = await fetch(knowledgeConfig.pack.archiveUrl);
+                if (res.ok) {
+                    const tarPath = node_path_1.default.join(packDest, 'pack.tar.gz');
+                    const buffer = Buffer.from(await res.arrayBuffer());
+                    await (0, promises_1.writeFile)(tarPath, buffer);
+                    await execFile('tar', ['-xzf', tarPath, '-C', packDest]);
+                    await node_fs_1.default.promises.unlink(tarPath).catch(() => { });
+                }
+            });
+        }
+        catch (err) {
+            console.warn(`${colors_1.colors.yellow}!${colors_1.colors.reset} Notice: Could not download or unpack knowledge archive: ${err.message}`);
+        }
+    }
+    printSuccess(`Generated standalone files at ${projectDir}`);
+    // 5. Install dependencies from registry
+    try {
+        await withTask('Installing dependencies (npm install)', async () => {
+            await execFile('npm', ['install', '--no-audit', '--no-fund'], { cwd: projectDir });
+        });
+        printSuccess('Dependencies installed successfully.');
+    }
+    catch (err) {
+        console.warn(`\n${colors_1.colors.yellow}! Notice: npm install failed:${colors_1.colors.reset} ${err.stderr || err.message}`);
+        console.warn(`${colors_1.colors.dim}Run "npm install" manually inside ${projectDir} to complete installation.${colors_1.colors.reset}\n`);
+    }
+    printSection('Instance Ready');
+    console.log(`Your Siduri companion is ready! Next steps:\n`);
+    console.log(`  cd ${node_path_1.default.relative(process.cwd(), projectDir) || '.'}`);
+    console.log(`  cp .env.example .env          ${colors_1.colors.dim}# Fill in required API keys/credentials${colors_1.colors.reset}`);
+    console.log(`  npm run doctor                ${colors_1.colors.dim}# Run diagnostic health probes${colors_1.colors.reset}`);
+    console.log(`  npm start                     ${colors_1.colors.dim}# Start Web Companion & Memory Console at http://localhost:3000${colors_1.colors.reset}\n`);
+    const voiceConfig = organConfigs.voice || organConfigs['@sidurijs/voice'];
+    if (voiceConfig?.provider === 'voicevox') {
+        console.log(`  ${colors_1.colors.cyan}ℹ Voice Runtime:${colors_1.colors.reset} ${colors_1.colors.dim}VOICEVOX engine (~1.5GB) will auto-download to ~/.voicevox/engine/ and launch on port 50021 on first 'npm start' (if not already running).${colors_1.colors.reset}\n`);
+    }
+    else if (voiceConfig?.rvc?.enabled) {
+        console.log(`  ${colors_1.colors.cyan}ℹ Voice Model:${colors_1.colors.reset} ${colors_1.colors.dim}Place your RVC weights (.pth) in ${voiceConfig.rvc.modelPath} before starting voice synthesis.${colors_1.colors.reset}\n`);
+    }
+}
+async function runCliDoctor(targetDir) {
+    printHeader();
+    const dir = targetDir ? node_path_1.default.resolve(process.cwd(), targetDir) : process.cwd();
+    console.log(`${colors_1.colors.cyan}Siduri Doctor${colors_1.colors.reset}`);
+    console.log(`${colors_1.colors.dim}─────────────${colors_1.colors.reset}\n`);
+    try {
+        const report = await (0, doctor_1.runDoctor)({ projectDir: dir });
+        console.log(`${colors_1.colors.dim}Instance:${colors_1.colors.reset} ${report.instanceName}`);
+        console.log(`${colors_1.colors.dim}Organs:${colors_1.colors.reset}   ${report.configuredOrgans.join(', ')}\n`);
+        const categories = ['Environment', 'Services', 'Database', 'Health Probe'];
+        for (const cat of categories) {
+            const items = report.results.filter((r) => r.category === cat);
+            if (items.length > 0) {
+                console.log(`${colors_1.colors.cyan}${cat}${colors_1.colors.reset}`);
+                for (const item of items) {
+                    if (item.status === 'PASS') {
+                        console.log(`  ${colors_1.colors.green}✓${colors_1.colors.reset} ${item.name} ${colors_1.colors.dim}(${item.message || 'OK'})${colors_1.colors.reset}`);
+                    }
+                    else if (item.status === 'OPTIONAL_MISSING') {
+                        console.log(`  ${colors_1.colors.dim}○${colors_1.colors.reset} ${item.name} ${colors_1.colors.dim}(Optional, not set)${colors_1.colors.reset}`);
+                    }
+                    else if (item.status === 'SKIPPED') {
+                        console.log(`  ${colors_1.colors.dim}— ${item.name} (${item.message})${colors_1.colors.reset}`);
+                    }
+                    else {
+                        console.log(`  ${colors_1.colors.yellow}✗${colors_1.colors.reset} ${item.name}`);
+                        if (item.organName) {
+                            console.log(`    ${colors_1.colors.dim}Required by:${colors_1.colors.reset} ${item.organName}`);
+                        }
+                        if (item.message) {
+                            console.log(`    ${colors_1.colors.yellow}${item.message}${colors_1.colors.reset}`);
+                        }
+                        if (item.remediation) {
+                            console.log(`    ${colors_1.colors.dim}Remediation:${colors_1.colors.reset} ${item.remediation}`);
+                        }
+                    }
+                }
+                console.log();
+            }
+        }
+        if (report.passed) {
+            console.log(`${colors_1.colors.green}Result: PASS${colors_1.colors.reset}\n`);
+            process.exitCode = 0;
+        }
+        else {
+            console.log(`${colors_1.colors.yellow}Result: FAIL${colors_1.colors.reset}\n`);
+            process.exitCode = 1;
+        }
+    }
+    catch (err) {
+        console.error(`\n${colors_1.colors.yellow}Doctor Error:${colors_1.colors.reset} ${err.message}\n`);
+        process.exitCode = 2;
+    }
+}
+async function runCliReset(targetDir) {
+    printHeader();
+    const dir = targetDir ? node_path_1.default.resolve(process.cwd(), targetDir) : process.cwd();
+    console.log(`${colors_1.colors.cyan}Siduri State Reset${colors_1.colors.reset}`);
+    console.log(`${colors_1.colors.dim}──────────────────${colors_1.colors.reset}\n`);
+    try {
+        let dbPath = 'siduri.sqlite';
+        let companionId = 'default';
+        const configPath = node_path_1.default.join(dir, 'siduri.config.json');
+        if (node_fs_1.default.existsSync(configPath)) {
+            try {
+                const config = JSON.parse(node_fs_1.default.readFileSync(configPath, 'utf8'));
+                if (config.id)
+                    companionId = config.id;
+                if (config.organs?.memory?.dbPath)
+                    dbPath = config.organs.memory.dbPath;
+            }
+            catch { }
+        }
+        const fullDbPath = node_path_1.default.resolve(dir, dbPath);
+        if (!node_fs_1.default.existsSync(fullDbPath)) {
+            console.log(`${colors_1.colors.dim}No database file found at ${fullDbPath}. Already at clean slate.${colors_1.colors.reset}\n`);
+            process.exitCode = 0;
+            return;
+        }
+        const tables = [
+            'memory_claims',
+            'memory_events',
+            'self_directives',
+            'self_relationships',
+            'self_identity',
+            'self_personality',
+            'self_exemplars',
+            'life_entities',
+            'life_events',
+            'life_finance',
+            'life_inventory',
+            'life_preferences',
+            'life_schedule',
+            'life_tasks',
+            'system_logs',
+        ];
+        const { DatabaseSync } = await Promise.resolve().then(() => __importStar(require('node:sqlite')));
+        const db = new DatabaseSync(fullDbPath);
+        try {
+            for (const table of tables) {
+                try {
+                    db.prepare(`DELETE FROM ${table} WHERE companion_id = ?`).run(companionId);
+                }
+                catch {
+                    try {
+                        db.prepare(`DELETE FROM ${table}`).run();
+                    }
+                    catch { }
+                }
+                if (companionId !== 'default') {
+                    try {
+                        db.prepare(`DELETE FROM ${table} WHERE companion_id = "default"`).run();
+                    }
+                    catch { }
+                }
+            }
+            try {
+                db.exec('VACUUM');
+            }
+            catch { }
+        }
+        finally {
+            db.close();
+        }
+        printSuccess(`Companion state reset to blank slate:`);
+        console.log(`  ${colors_1.colors.dim}• Memory claims and events cleared${colors_1.colors.reset}`);
+        console.log(`  ${colors_1.colors.dim}• Self directives, identity, and relationships cleared${colors_1.colors.reset}`);
+        console.log(`  ${colors_1.colors.dim}• Life DB (entities, tasks, schedule, events) cleared${colors_1.colors.reset}`);
+        console.log(`  ${colors_1.colors.dim}• System logs cleared${colors_1.colors.reset}`);
+        console.log(`\nInstance is now in a clean blank slate state for testing.\n`);
+        process.exitCode = 0;
+    }
+    catch (err) {
+        console.error(`\n${colors_1.colors.yellow}Reset Error:${colors_1.colors.reset} ${err.message}\n`);
+        process.exitCode = 1;
+    }
+}
+async function runCliDb(subcommand, targetDir) {
+    printHeader();
+    if (subcommand === 'reset') {
+        await runCliReset(targetDir);
+        return;
+    }
+    if (subcommand !== 'push') {
+        console.log('Usage: siduri db push | siduri db reset');
+        process.exitCode = 2;
+        return;
+    }
+    const dir = targetDir ? node_path_1.default.resolve(process.cwd(), targetDir) : process.cwd();
+    console.log(`${colors_1.colors.cyan}Siduri Database Migrations${colors_1.colors.reset}`);
+    console.log(`${colors_1.colors.dim}──────────────────────────${colors_1.colors.reset}\n`);
+    try {
+        const res = await (0, db_1.runDbPush)({ projectDir: dir });
+        if (res.status === 'NOOP') {
+            console.log(`${colors_1.colors.dim}— ${res.message}${colors_1.colors.reset}\n`);
+        }
+        else {
+            printSuccess(res.message);
+            if (res.appliedMigrations.length > 0) {
+                console.log(`${colors_1.colors.dim}Applied:${colors_1.colors.reset} ${res.appliedMigrations.join(', ')}`);
+            }
+            console.log();
+        }
+        process.exitCode = 0;
+    }
+    catch (err) {
+        console.error(`\n${colors_1.colors.yellow}Database Migration Error:${colors_1.colors.reset} ${err.message}\n`);
+        process.exitCode = 3;
+    }
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    if (command === '--version' || command === '-v') {
+        console.log(exports.CLI_VERSION);
+        return;
+    }
+    if (command === 'create') {
+        const isLocal = args.includes('--local') || args.includes('--dev') || process.env.SIDURI_LOCAL_DEV === 'true';
+        const nonFlags = args.slice(1).filter((a) => !a.startsWith('--'));
+        const targetDir = nonFlags[0];
+        const localRepo = isLocal ? node_path_1.default.resolve(__dirname, '../..') : undefined;
+        await runCreateWizard(targetDir, { localPath: localRepo });
+        return;
+    }
+    if (command === 'reset') {
+        const targetDir = args[1];
+        await runCliReset(targetDir);
+        return;
+    }
+    if (command === 'doctor') {
+        const targetDir = args[1];
+        await runCliDoctor(targetDir);
+        return;
+    }
+    if (command === 'db') {
+        const subcommand = args[1];
+        const targetDir = args[2];
+        await runCliDb(subcommand, targetDir);
+        return;
+    }
+    printHeader();
+    console.log('Usage: npx siduri create [directory] [--local]');
+    console.log('       npx siduri reset [directory]');
+    console.log('       npx siduri doctor [directory]');
+    console.log('       npx siduri db push [directory]');
+    console.log('       npx siduri db reset [directory]');
+    console.log('       npx siduri --version\n');
+}
+if (require.main === module) {
+    main().catch((error) => {
+        if (error && typeof error === 'object' && 'name' in error && error.name === 'ExitPromptError') {
+            console.log('\nOperation cancelled.');
+            return;
+        }
+        console.error(`\n${colors_1.colors.yellow}!${colors_1.colors.reset} ${error instanceof Error ? error.message : error}`);
+        process.exitCode = 1;
+    });
+}

package/dist/manifest.d.ts

@@ -0,0 +1,33 @@
+export interface OrganEnvironmentVar {
+    name: string;
+    required?: boolean;
+    secret?: boolean;
+    default?: string;
+    description?: string;
+}
+export interface OrganServiceRequirement {
+    name: string;
+    kind: 'database' | 'http_service' | 'process' | string;
+    optional?: boolean;
+    description?: string;
+}
+export interface OrganDatabaseRequirement {
+    engine: 'sqlite' | string;
+    migrationsDir?: string;
+}
+export interface OrganManifest {
+    name: string;
+    organType: string;
+    version: string;
+    displayName: string;
+    description?: string;
+    entrypoint: string;
+    factory: string;
+    configKey: string;
+    configSchema: Record<string, any>;
+    environment: OrganEnvironmentVar[];
+    services: OrganServiceRequirement[];
+    database?: OrganDatabaseRequirement | null;
+    healthCheck?: string | null;
+}
+export declare function validateOrganManifest(manifest: unknown, sourcePath?: string): OrganManifest;

package/dist/manifest.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOrganManifest = validateOrganManifest;
+function validateOrganManifest(manifest, sourcePath) {
+    if (!manifest || typeof manifest !== 'object') {
+        throw new Error(`Invalid manifest at ${sourcePath || 'unknown'}: expected an object`);
+    }
+    const m = manifest;
+    if (!m.name || typeof m.name !== 'string' || !m.name.startsWith('@sidurijs/')) {
+        throw new Error(`Invalid manifest name in ${sourcePath || 'unknown'}: expected package name starting with @sidurijs/`);
+    }
+    if (!m.organType || typeof m.organType !== 'string') {
+        throw new Error(`Invalid manifest organType in ${sourcePath || m.name}`);
+    }
+    if (!m.version || typeof m.version !== 'string') {
+        throw new Error(`Invalid manifest version in ${sourcePath || m.name}`);
+    }
+    if (!m.displayName || typeof m.displayName !== 'string') {
+        throw new Error(`Invalid manifest displayName in ${sourcePath || m.name}`);
+    }
+    if (!m.entrypoint || typeof m.entrypoint !== 'string') {
+        throw new Error(`Invalid manifest entrypoint in ${sourcePath || m.name}`);
+    }
+    if (!m.factory || typeof m.factory !== 'string') {
+        throw new Error(`Invalid manifest factory in ${sourcePath || m.name}`);
+    }
+    if (!m.configKey || typeof m.configKey !== 'string') {
+        throw new Error(`Invalid manifest configKey in ${sourcePath || m.name}`);
+    }
+    if (!m.configSchema || typeof m.configSchema !== 'object') {
+        throw new Error(`Invalid manifest configSchema in ${sourcePath || m.name}`);
+    }
+    if (!Array.isArray(m.environment)) {
+        throw new Error(`Invalid manifest environment in ${sourcePath || m.name}: expected array`);
+    }
+    if (!Array.isArray(m.services)) {
+        throw new Error(`Invalid manifest services in ${sourcePath || m.name}: expected array`);
+    }
+    return m;
+}

package/dist/project-dir.test.d.ts

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