@vxnus/siduri 0.0.6 → 0.0.8

package/dist/builtin-manifests.d.ts

@@ -0,0 +1,2 @@
+import { OrganManifest } from './manifest';
+export declare const BUILTIN_ORGAN_MANIFESTS: OrganManifest[];

package/dist/builtin-manifests.js

@@ -0,0 +1,433 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILTIN_ORGAN_MANIFESTS = void 0;
+exports.BUILTIN_ORGAN_MANIFESTS = [
+    {
+        name: '@siduri-x/behavior',
+        organType: 'behavior',
+        version: '1.0.0',
+        displayName: 'Behavior (Active Self Directives)',
+        description: 'Atomic directive state machine and personality projection compiler',
+        entrypoint: './dist/index.js',
+        factory: 'ActiveSelfCompiler',
+        configKey: 'behavior',
+        configSchema: {
+            type: 'object',
+            required: ['provider'],
+            properties: {
+                provider: {
+                    type: 'string',
+                    enum: ['active_self', 'none']
+                },
+                preset: {
+                    type: 'string'
+                }
+            }
+        },
+        environment: [],
+        services: [],
+        database: null,
+        healthCheck: null
+    },
+    {
+        name: '@siduri-x/body',
+        organType: 'body',
+        version: '1.0.0',
+        displayName: 'Body (Live2D & Avatar State)',
+        description: 'Renderer-agnostic avatar expression and embodiment event adapter',
+        entrypoint: './dist/index.js',
+        factory: 'NeutralBodyOrgan',
+        configKey: 'body',
+        configSchema: {
+            type: 'object',
+            required: ['provider'],
+            properties: {
+                provider: {
+                    type: 'string',
+                    enum: ['live2d', 'none']
+                },
+                initialExpression: {
+                    type: 'string',
+                    default: 'neutral'
+                }
+            }
+        },
+        environment: [],
+        services: [],
+        database: null,
+        healthCheck: null
+    },
+    {
+        name: '@siduri-x/brain',
+        organType: 'brain',
+        version: '1.0.0',
+        displayName: 'Brain (Cognition & Planning)',
+        description: 'Provider-neutral LLM reasoning, response planning, and proposal generation',
+        entrypoint: './dist/index.js',
+        factory: 'OpenRouterBrain',
+        configKey: 'brain',
+        configSchema: {
+            type: 'object',
+            required: ['provider', 'model'],
+            properties: {
+                provider: {
+                    type: 'string',
+                    enum: ['openrouter', 'openai-compatible']
+                },
+                model: {
+                    type: 'string'
+                },
+                apiKey: {
+                    type: 'string'
+                },
+                apiKeyEnv: {
+                    type: 'string',
+                    default: 'OPENROUTER_API_KEY'
+                },
+                baseUrl: {
+                    type: 'string'
+                }
+            }
+        },
+        environment: [
+            {
+                name: 'OPENROUTER_API_KEY',
+                required: false,
+                secret: true,
+                description: 'API key for OpenRouter managed routing'
+            },
+            {
+                name: 'OPENAI_COMPATIBLE_API_KEY',
+                required: false,
+                secret: true,
+                description: 'API key for OpenAI-compatible endpoint'
+            }
+        ],
+        services: [
+            {
+                name: 'LLM Inference API',
+                kind: 'http_service',
+                optional: false
+            }
+        ],
+        database: null,
+        healthCheck: 'probeBrainHealth'
+    },
+    {
+        name: '@siduri-x/ear',
+        organType: 'ear',
+        version: '1.0.0',
+        displayName: 'Ear (Perception Ingress)',
+        description: 'Multi-modal sensory input ingestion, transcription bounds, and mime validation',
+        entrypoint: './dist/index.js',
+        factory: 'DefaultEarOrgan',
+        configKey: 'ear',
+        configSchema: {
+            type: 'object',
+            properties: {
+                defaultSource: {
+                    type: 'string',
+                    default: 'text_chat'
+                },
+                maxTextLength: {
+                    type: 'number',
+                    default: 4000
+                },
+                maxAudioBytes: {
+                    type: 'number',
+                    default: 10485760
+                }
+            }
+        },
+        environment: [],
+        services: [],
+        database: null,
+        healthCheck: null
+    },
+    {
+        name: '@siduri-x/hands',
+        organType: 'hands',
+        version: '1.0.0',
+        displayName: 'Hands (MCP Tool Execution)',
+        description: 'Model Context Protocol tool management and cryptographically authorized action execution',
+        entrypoint: './dist/index.js',
+        factory: 'DefaultHandsOrgan',
+        configKey: 'hands',
+        configSchema: {
+            type: 'object',
+            properties: {
+                defaultTimeoutMs: {
+                    type: 'number',
+                    default: 10000
+                },
+                providers: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        required: ['serverName'],
+                        properties: {
+                            serverName: {
+                                type: 'string'
+                            },
+                            baseUrl: {
+                                type: 'string'
+                            },
+                            command: {
+                                type: 'string'
+                            },
+                            args: {
+                                type: 'array',
+                                items: {
+                                    type: 'string'
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        environment: [
+            {
+                name: 'ACTION_POLICY_SECRET',
+                required: false,
+                secret: true,
+                description: 'HMAC secret key for signing and verifying action execution capabilities (required in production)'
+            }
+        ],
+        services: [],
+        database: null,
+        healthCheck: 'probeHandsHealth'
+    },
+    {
+        name: '@siduri-x/knowledge',
+        organType: 'knowledge',
+        version: '1.0.0',
+        displayName: 'Knowledge (E-Compatible Cited Facts)',
+        description: 'Factual context retrieval from local or hosted E Knowledge packs',
+        entrypoint: './dist/index.js',
+        factory: 'EKnowledgeAdapter',
+        configKey: 'knowledge',
+        configSchema: {
+            type: 'object',
+            required: ['provider'],
+            properties: {
+                provider: {
+                    type: 'string',
+                    enum: ['e-knowledge', 'e-remote', 'e-hub', 'none']
+                },
+                packPath: {
+                    type: 'string'
+                },
+                baseUrl: {
+                    type: 'string'
+                },
+                registryUrl: {
+                    type: 'string'
+                },
+                packId: {
+                    type: 'string'
+                },
+                timeoutMs: {
+                    type: 'number',
+                    default: 5000
+                },
+                preferredMode: {
+                    type: 'string',
+                    enum: ['lexical', 'semantic', 'hybrid'],
+                    default: 'lexical'
+                }
+            }
+        },
+        environment: [
+            {
+                name: 'SIDURI_KNOWLEDGE_PACK',
+                required: false,
+                secret: false,
+                description: 'Path to local E knowledge pack'
+            },
+            {
+                name: 'SIDURI_KNOWLEDGE_REGISTRY_URL',
+                required: false,
+                secret: false,
+                default: 'https://e.vxnus.xyz/api/v1/knowledge',
+                description: 'URL of the E Knowledge Hub registry'
+            }
+        ],
+        services: [
+            {
+                name: 'E Knowledge Hub',
+                kind: 'http_service',
+                optional: true
+            }
+        ],
+        database: null,
+        healthCheck: null
+    },
+    {
+        name: '@siduri-x/memory',
+        organType: 'memory',
+        version: '1.0.0',
+        displayName: 'Memory (PostgreSQL FTS Claims)',
+        description: 'Relational semantic claims with Full-Text Search and companion isolation',
+        entrypoint: './dist/index.js',
+        factory: 'PostgresMemoryOrgan',
+        configKey: 'memory',
+        configSchema: {
+            type: 'object',
+            required: ['provider'],
+            properties: {
+                provider: {
+                    type: 'string',
+                    enum: ['postgres']
+                },
+                deployment: {
+                    type: 'string',
+                    enum: ['local', 'neon', 'supabase', 'other']
+                },
+                connectionString: {
+                    type: 'string'
+                },
+                maxConnections: {
+                    type: 'number',
+                    default: 10
+                }
+            }
+        },
+        environment: [
+            {
+                name: 'DATABASE_URL',
+                required: true,
+                secret: true,
+                default: 'postgresql://postgres:postgres@localhost:5432/siduri',
+                description: 'PostgreSQL connection string'
+            }
+        ],
+        services: [
+            {
+                name: 'PostgreSQL Database',
+                kind: 'database',
+                optional: false
+            }
+        ],
+        database: {
+            engine: 'postgres',
+            migrationsDir: './migrations'
+        },
+        healthCheck: 'probeMemoryHealth'
+    },
+    {
+        name: '@siduri-x/observation',
+        organType: 'observation',
+        version: '1.0.0',
+        displayName: 'Observation (Grounded Observation Ingestion)',
+        description: 'Cryptographically hashed video/image observation ingest and duplicate detection',
+        entrypoint: './dist/index.js',
+        factory: 'FixtureObservationOrgan',
+        configKey: 'observation',
+        configSchema: {
+            type: 'object',
+            properties: {}
+        },
+        environment: [],
+        services: [],
+        database: null,
+        healthCheck: null
+    },
+    {
+        name: '@siduri-x/vision',
+        organType: 'vision',
+        version: '1.0.0',
+        displayName: 'Vision (Visual Perception & OCR)',
+        description: 'Image inspection, cropping, and multi-pass OCR perception adapter',
+        entrypoint: './dist/index.js',
+        factory: 'OpenRouterVisionAdapter',
+        configKey: 'vision',
+        configSchema: {
+            type: 'object',
+            required: ['provider'],
+            properties: {
+                provider: {
+                    type: 'string',
+                    enum: ['openrouter', 'none']
+                },
+                model: {
+                    type: 'string',
+                    default: 'gpt-4-vision'
+                },
+                apiKey: {
+                    type: 'string'
+                },
+                baseUrl: {
+                    type: 'string'
+                }
+            }
+        },
+        environment: [
+            {
+                name: 'OPENROUTER_API_KEY',
+                required: false,
+                secret: true,
+                description: 'API key for vision model inference'
+            }
+        ],
+        services: [
+            {
+                name: 'Vision Inference API',
+                kind: 'http_service',
+                optional: false
+            }
+        ],
+        database: null,
+        healthCheck: null
+    },
+    {
+        name: '@siduri-x/voice',
+        organType: 'voice',
+        version: '1.0.0',
+        displayName: 'Voice (VOICEVOX Speech Synthesis)',
+        description: 'Queued speech synthesis and audio rendering lifecycle adapter',
+        entrypoint: './dist/index.js',
+        factory: 'VoicevoxAdapter',
+        configKey: 'voice',
+        configSchema: {
+            type: 'object',
+            required: ['provider'],
+            properties: {
+                provider: {
+                    type: 'string',
+                    enum: ['voicevox', 'none']
+                },
+                speakerId: {
+                    type: 'number',
+                    default: 1
+                },
+                baseUrl: {
+                    type: 'string',
+                    default: 'http://localhost:50021'
+                },
+                maxQueueDepth: {
+                    type: 'number',
+                    default: 50
+                }
+            }
+        },
+        environment: [
+            {
+                name: 'VOICEVOX_URL',
+                required: false,
+                secret: false,
+                default: 'http://localhost:50021',
+                description: 'Base URL of the running VOICEVOX engine'
+            }
+        ],
+        services: [
+            {
+                name: 'VOICEVOX Engine',
+                kind: 'http_service',
+                optional: false
+            }
+        ],
+        database: null,
+        healthCheck: null
+    }
+];

package/dist/clean-machine-e2e.test.js

@@ -24,7 +24,7 @@ describe('Phase 5: Clean-Machine Distribution & E2E Integration Suite', () => {
         { filter: '@siduri-x/body', tarName: 'siduri-x-body-1.0.0.tgz', isOrgan: true },
         { filter: '@siduri-x/voice', tarName: 'siduri-x-voice-1.0.0.tgz', isOrgan: true },
         { filter: '@siduri-x/observation', tarName: 'siduri-x-observation-1.0.0.tgz', isOrgan: true },
-        { filter: '@vxnus/siduri', tarName: 'vxnus-siduri-0.0.6.tgz', isOrgan: false },
+        { filter: '@vxnus/siduri', tarName: 'vxnus-siduri-0.0.8.tgz', isOrgan: false },
     ];
     beforeAll(() => {
         // 1. Prepare clean directories

package/dist/configurators/behavior.d.ts

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

package/dist/configurators/behavior.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureBehavior = configureBehavior;
+const inquirer_1 = __importDefault(require("inquirer"));
+async function configureBehavior(_context) {
+    const { preset } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'preset',
+        message: 'Personality projection preset:',
+        choices: [
+            { name: 'Calm & Precise (Default)', value: 'calm_precise' },
+            { name: 'Cheerful & Enthusiastic', value: 'cheerful' },
+            { name: 'Analytical & Methodical', value: 'analytical' },
+            { name: 'Custom Directive State Machine', value: 'custom' },
+        ],
+    });
+    const presetLabels = {
+        calm_precise: 'Calm & Precise',
+        cheerful: 'Cheerful & Enthusiastic',
+        analytical: 'Analytical & Methodical',
+        custom: 'Custom Directives',
+    };
+    return {
+        config: {
+            provider: 'active_self',
+            preset,
+        },
+        summary: {
+            Provider: 'Active Self Directives',
+            Preset: presetLabels[preset] || preset,
+        },
+    };
+}

package/dist/configurators/body.d.ts

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

package/dist/configurators/body.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.configureBody = configureBody;
+const inquirer_1 = __importDefault(require("inquirer"));
+async function configureBody(_context) {
+    const { provider } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'provider',
+        message: 'Body avatar provider?',
+        choices: [
+            { name: 'Live2D Cubism (Interactive avatar motion & expression state)', value: 'live2d' },
+            { name: 'None (Headless / No visual body)', value: 'none' },
+        ],
+    });
+    if (provider === 'none') {
+        return {
+            config: { provider: 'none' },
+            summary: { Provider: 'None (Headless)' },
+        };
+    }
+    const { initialExpression } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'initialExpression',
+        message: 'Initial avatar expression:',
+        choices: [
+            { name: 'Neutral', value: 'neutral' },
+            { name: 'Happy / Cheerful', value: 'happy' },
+            { name: 'Calm', value: 'calm' },
+        ],
+    });
+    return {
+        config: {
+            provider: 'live2d',
+            initialExpression,
+        },
+        summary: {
+            Provider: 'Live2D',
+            Expression: initialExpression,
+        },
+    };
+}

package/dist/configurators/brain.d.ts

@@ -0,0 +1,6 @@
+import { OrganConfiguratorContext, OrganConfigurationResult } from './types';
+import { ModelProvider } from '../providers/openrouter';
+export interface BrainConfiguratorOptions {
+    modelProvider?: ModelProvider;
+}
+export declare function configureBrain(_context: OrganConfiguratorContext, options?: BrainConfiguratorOptions): Promise<OrganConfigurationResult>;

package/dist/configurators/brain.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureBrain = configureBrain;
+const inquirer_1 = __importDefault(require("inquirer"));
+const openrouter_1 = require("../providers/openrouter");
+async function configureBrain(_context, options = {}) {
+    const modelProvider = options.modelProvider || new openrouter_1.OpenRouterModelProvider();
+    while (true) {
+        const { provider } = await inquirer_1.default.prompt({
+            type: 'list',
+            name: 'provider',
+            message: 'Brain provider?',
+            choices: [
+                { name: 'OpenRouter (Managed Routing & Broad Model Access)', value: 'openrouter' },
+                { name: 'OpenAI-compatible / Custom endpoint (Ollama, vLLM, Azure, OpenAI)', value: 'openai-compatible' },
+            ],
+        });
+        if (provider === 'openrouter') {
+            const selection = await (0, openrouter_1.promptOpenRouterModelSelection)(modelProvider);
+            if (selection.type === 'switch_provider') {
+                continue;
+            }
+            if (selection.type === 'cancel') {
+                throw new Error('Brain configuration cancelled.');
+            }
+            const modelId = selection.modelId;
+            return {
+                config: {
+                    provider: 'openrouter',
+                    model: modelId,
+                    apiKeyEnv: 'OPENROUTER_API_KEY',
+                },
+                summary: {
+                    Provider: 'OpenRouter',
+                    Model: modelId,
+                },
+            };
+        }
+        if (provider === 'openai-compatible') {
+            const answers = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'baseUrl',
+                    message: 'Endpoint Base URL:',
+                    default: 'https://api.openai.com/v1',
+                    validate: (v) => v.trim().length > 0 || 'Base URL is required.',
+                },
+                {
+                    type: 'input',
+                    name: 'model',
+                    message: 'Model ID (e.g. gpt-4o, llama3, mistral):',
+                    default: 'gpt-4o',
+                    validate: (v) => v.trim().length > 0 || 'Model ID is required.',
+                },
+                {
+                    type: 'input',
+                    name: 'apiKeyEnv',
+                    message: 'API Key environment variable name:',
+                    default: 'OPENAI_COMPATIBLE_API_KEY',
+                },
+            ]);
+            return {
+                config: {
+                    provider: 'openai-compatible',
+                    model: answers.model.trim(),
+                    baseUrl: answers.baseUrl.trim(),
+                    apiKeyEnv: answers.apiKeyEnv.trim() || 'OPENAI_COMPATIBLE_API_KEY',
+                },
+                summary: {
+                    Provider: 'OpenAI-compatible',
+                    Model: answers.model.trim(),
+                    'Base URL': answers.baseUrl.trim(),
+                },
+            };
+        }
+    }
+}

package/dist/configurators/ear.d.ts

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

package/dist/configurators/ear.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureEar = configureEar;
+const inquirer_1 = __importDefault(require("inquirer"));
+async function configureEar(_context) {
+    const { defaultSource } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'defaultSource',
+        message: 'Perception ingress channel:',
+        choices: [
+            { name: 'Text Chat (Standard multimodal chat ingress)', value: 'text_chat' },
+            { name: 'Audio Streaming Ingress', value: 'audio_stream' },
+        ],
+    });
+    return {
+        config: {
+            defaultSource,
+            maxTextLength: 4000,
+            maxAudioBytes: 10485760,
+        },
+        summary: {
+            'Default Ingress': defaultSource === 'text_chat' ? 'Text Chat' : 'Audio Stream',
+        },
+    };
+}

package/dist/configurators/hands.d.ts

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

package/dist/configurators/hands.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureHands = configureHands;
+const inquirer_1 = __importDefault(require("inquirer"));
+async function configureHands(_context) {
+    const { timeoutSeconds } = await inquirer_1.default.prompt({
+        type: 'input',
+        name: 'timeoutSeconds',
+        message: 'MCP Tool execution timeout (seconds):',
+        default: '10',
+        validate: (v) => (!isNaN(Number(v)) && Number(v) > 0) || 'Timeout must be a positive number.',
+    });
+    const timeoutMs = Math.round(Number(timeoutSeconds) * 1000);
+    return {
+        config: {
+            defaultTimeoutMs: timeoutMs,
+            providers: [],
+        },
+        summary: {
+            'Default Timeout': `${timeoutSeconds}s`,
+            'MCP Execution': 'Active Policy HMAC Protected',
+        },
+    };
+}