siduri 1.0.0

package/dist/configurators/ear.js

@@ -0,0 +1,43 @@
+"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 { choice } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'choice',
+        message: 'Ear (Sensory Input & Perception Ingress):',
+        choices: [
+            {
+                name: 'Enabled (Recommended: Active sensory bounds & audio/text ingress validation)',
+                value: 'enabled',
+            },
+            {
+                name: 'None (Skip / Disable sensory ingress)',
+                value: 'none',
+            },
+        ],
+        default: 'enabled',
+    });
+    if (choice === 'none') {
+        return {
+            config: { provider: 'none' },
+            summary: { Provider: 'None (Ear disabled)' },
+        };
+    }
+    return {
+        config: {
+            defaultSource: 'text_chat',
+            maxTextLength: 4000,
+            maxAudioBytes: 10485760,
+        },
+        summary: {
+            Status: 'Enabled (Active sensory guard & audio/text ingress)',
+            'Max Text': '4,000 characters',
+            'Max Audio': '10 MB',
+        },
+    };
+}

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,43 @@
+"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 { provider } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'provider',
+        message: 'Hands tool execution engine?',
+        choices: [
+            { name: 'MCP Client (Model Context Protocol & signed capability tokens)', value: 'mcp' },
+            { name: 'None (Skip / No external tool execution)', value: 'none' },
+        ],
+        default: 'none',
+    });
+    if (provider === 'none') {
+        return {
+            config: { provider: 'none' },
+            summary: { Provider: 'None (Hands disabled)' },
+        };
+    }
+    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',
+        },
+    };
+}

package/dist/configurators/index.d.ts

@@ -0,0 +1,24 @@
+import { OrganManifest } from '../manifest';
+import { OrganConfigurationResult } from './types';
+import { BrainConfiguratorOptions } from './brain';
+import { KnowledgeConfiguratorOptions } from './knowledge';
+export * from './types';
+export * from './brain';
+export * from './knowledge';
+export * from './memory';
+export * from './voice';
+export * from './body';
+export * from './hands';
+export * from './behavior';
+export * from './vision';
+export * from './ear';
+export * from './observation';
+export * from './mouth';
+export interface ConfigureOrganOptions {
+    brainOptions?: BrainConfiguratorOptions;
+    knowledgeOptions?: KnowledgeConfiguratorOptions;
+}
+export declare function configureOrgan(manifest: OrganManifest, context: {
+    companionName: string;
+    existingConfig?: Record<string, unknown>;
+}, options?: ConfigureOrganOptions): Promise<OrganConfigurationResult>;

package/dist/configurators/index.js

@@ -0,0 +1,78 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureOrgan = configureOrgan;
+const brain_1 = require("./brain");
+const knowledge_1 = require("./knowledge");
+const memory_1 = require("./memory");
+const voice_1 = require("./voice");
+const body_1 = require("./body");
+const hands_1 = require("./hands");
+const behavior_1 = require("./behavior");
+const vision_1 = require("./vision");
+const ear_1 = require("./ear");
+const observation_1 = require("./observation");
+const mouth_1 = require("./mouth");
+__exportStar(require("./types"), exports);
+__exportStar(require("./brain"), exports);
+__exportStar(require("./knowledge"), exports);
+__exportStar(require("./memory"), exports);
+__exportStar(require("./voice"), exports);
+__exportStar(require("./body"), exports);
+__exportStar(require("./hands"), exports);
+__exportStar(require("./behavior"), exports);
+__exportStar(require("./vision"), exports);
+__exportStar(require("./ear"), exports);
+__exportStar(require("./observation"), exports);
+__exportStar(require("./mouth"), exports);
+async function configureOrgan(manifest, context, options = {}) {
+    const ctx = {
+        companionName: context.companionName,
+        manifest,
+        existingConfig: context.existingConfig,
+    };
+    switch (manifest.organType) {
+        case 'brain':
+            return (0, brain_1.configureBrain)(ctx, options.brainOptions);
+        case 'knowledge':
+            return (0, knowledge_1.configureKnowledge)(ctx, options.knowledgeOptions);
+        case 'archive':
+            return (0, memory_1.configureMemory)(ctx);
+        case 'voice':
+            return (0, voice_1.configureVoice)(ctx);
+        case 'body':
+            return (0, body_1.configureBody)(ctx);
+        case 'hands':
+            return (0, hands_1.configureHands)(ctx);
+        case 'behavior':
+            return (0, behavior_1.configureBehavior)(ctx);
+        case 'vision':
+            return (0, vision_1.configureVision)(ctx);
+        case 'ear':
+            return (0, ear_1.configureEar)(ctx);
+        case 'observation':
+            return (0, observation_1.configureObservation)(ctx);
+        case 'mouth':
+            return (0, mouth_1.configureMouth)(ctx);
+        default:
+            return {
+                config: ctx.existingConfig || {},
+                summary: {
+                    Provider: manifest.displayName,
+                },
+            };
+    }
+}

package/dist/configurators/knowledge.d.ts

@@ -0,0 +1,6 @@
+import { OrganConfiguratorContext, OrganConfigurationResult } from './types';
+import { KnowledgeHubClient } from '../providers/knowledge-hub';
+export interface KnowledgeConfiguratorOptions {
+    client?: KnowledgeHubClient;
+}
+export declare function configureKnowledge(_context: OrganConfiguratorContext, options?: KnowledgeConfiguratorOptions): Promise<OrganConfigurationResult>;

package/dist/configurators/knowledge.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureKnowledge = configureKnowledge;
+const inquirer_1 = __importDefault(require("inquirer"));
+const knowledge_hub_1 = require("../providers/knowledge-hub");
+async function configureKnowledge(_context, options = {}) {
+    const client = options.client || new knowledge_hub_1.KnowledgeHubClient();
+    const config = {
+        provider: 'unified',
+        dbPath: 'siduri.sqlite',
+        lifeDatabase: true,
+    };
+    const summary = {
+        'Life Database': 'Enabled (siduri.sqlite)',
+    };
+    // 1. Life Database is the sovereign default. Ask whether to attach an external knowledge pack
+    const { useExternalPack } = await inquirer_1.default.prompt({
+        type: 'confirm',
+        name: 'useExternalPack',
+        message: 'Attach an external knowledge pack from E Knowledge Hub?',
+        default: false,
+    });
+    if (!useExternalPack) {
+        summary['E-Pack'] = 'None';
+        return { config, summary };
+    }
+    // 2. Discover and resolve E Knowledge Hub package
+    while (true) {
+        const promptRes = await inquirer_1.default.prompt({
+            type: 'input',
+            name: 'packId',
+            message: 'Enter package ID (@publisher/name):',
+            default: '@vxnus/e-teyvat',
+            validate: (val) => val.trim().length > 0 || 'Please enter a package ID.',
+        });
+        const target = (promptRes.packId || promptRes.query || '').trim();
+        let manifest;
+        try {
+            process.stdout.write('\x1b[2mResolving knowledge metadata...\x1b[0m');
+            manifest = await client.resolveProvider(target);
+            process.stdout.write('\r\x1b[32m✓\x1b[0m Knowledge metadata resolved\n');
+        }
+        catch (err) {
+            process.stdout.write('\r\x1b[33m!\x1b[0m Knowledge resolution failed\n');
+            console.log(`\x1b[33mReason:\x1b[0m ${err.message}\n`);
+            const { failureAction } = await inquirer_1.default.prompt({
+                type: 'list',
+                name: 'failureAction',
+                message: 'What would you like to do?',
+                choices: [
+                    { name: 'Try again / Enter another package ID', value: 'retry' },
+                    { name: 'Continue without external pack (Life DB only)', value: 'skip' },
+                    { name: 'Cancel', value: 'cancel' },
+                ],
+            });
+            if (failureAction === 'retry')
+                continue;
+            if (failureAction === 'skip') {
+                summary['E-Pack'] = 'None';
+                return { config, summary };
+            }
+            throw new Error('Knowledge configuration cancelled.');
+        }
+        // Display provider summary
+        (0, knowledge_hub_1.displayKnowledgeProviderSummary)(manifest, target);
+        // Determine connection type: User selects strictly 1 mode (Remote OR Local)
+        let connectionType;
+        const isHybrid = manifest.distributionType === 'both';
+        const isLocalOnly = manifest.distributionType === 'local' || manifest.distribution?.kind === 'archive';
+        if (isHybrid) {
+            const { selectedMode } = await inquirer_1.default.prompt({
+                type: 'list',
+                name: 'selectedMode',
+                message: 'This pack offers both remote and local options. Select connection type:',
+                choices: [
+                    {
+                        name: `Remote (Stream directly from ${manifest.distribution?.url || 'provider'} without local storage)`,
+                        value: 'remote',
+                    },
+                    {
+                        name: 'Local (Download archive and run offline on this machine)',
+                        value: 'local',
+                    },
+                ],
+            });
+            connectionType = selectedMode;
+        }
+        else if (isLocalOnly) {
+            connectionType = 'local';
+        }
+        else {
+            connectionType = 'remote';
+        }
+        if (connectionType === 'remote') {
+            config.provider = 'e-hub';
+            config.registryUrl = 'https://e.vxnus.xyz/api/v1/knowledge';
+            config.packId = target;
+            config.pack = {
+                provider: 'e-hub',
+                mode: 'remote',
+                packId: target,
+                registryUrl: 'https://e.vxnus.xyz/api/v1/knowledge',
+                baseUrl: manifest.distribution?.url,
+                preferredMode: 'lexical',
+            };
+            if (manifest.distribution?.url) {
+                config.baseUrl = manifest.distribution.url;
+            }
+            summary.Source = 'E Knowledge Hub';
+            summary.Provider = manifest.displayName || manifest.name;
+            summary.Package = target;
+            summary.Version = manifest.version;
+            summary['E-Pack'] = `${manifest.displayName || manifest.name} (Remote)`;
+        }
+        else {
+            // Local archive: stored in our defined path inside companion assets (user doesn't type path)
+            const packSlug = target.replace(/^@/, '').replace(/[/_]/g, '-');
+            const packDir = `./assets/knowledge/${packSlug}`;
+            config.provider = 'e-knowledge';
+            config.packPath = packDir;
+            config.packId = target;
+            config.pack = {
+                provider: 'e-knowledge',
+                mode: 'local',
+                packId: target,
+                packPath: packDir,
+                archiveUrl: manifest.distribution?.url,
+                checksum: manifest.distribution?.checksum,
+                preferredMode: 'lexical',
+            };
+            summary.Source = 'E Knowledge Hub';
+            summary.Provider = manifest.displayName || manifest.name;
+            summary.Package = target;
+            summary.Version = manifest.version;
+            summary['E-Pack'] = `${manifest.displayName || manifest.name} (Local @ ${packDir})`;
+        }
+        return {
+            config,
+            summary,
+            metadata: { manifest },
+        };
+    }
+}

package/dist/configurators/memory.d.ts

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

package/dist/configurators/memory.js

@@ -0,0 +1,26 @@
+"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 { provider } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'provider',
+        message: 'Memory storage engine?',
+        choices: [
+            { name: 'SQLite (Unified zero-config WAL + FTS5 full-text indexing)', value: 'sqlite' },
+        ],
+    });
+    return {
+        config: {
+            provider,
+        },
+        summary: {
+            Database: 'SQLite (WAL + FTS5)',
+            Storage: 'siduri.sqlite',
+        },
+    };
+}

package/dist/configurators/mouth.d.ts

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

package/dist/configurators/mouth.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureMouth = configureMouth;
+const inquirer_1 = __importDefault(require("inquirer"));
+async function configureMouth(_context) {
+    const { provider } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'provider',
+        message: 'Mouth output delivery channel?',
+        choices: [
+            { name: 'Web Streaming (Server-Sent Events, Live2D visemes & SSML)', value: 'web' },
+            { name: 'None (Silent / Disable speech streaming output)', value: 'none' },
+        ],
+        default: 'web',
+    });
+    if (provider === 'none') {
+        return {
+            config: { provider: 'none' },
+            summary: { Provider: 'None (Mouth disabled)' },
+        };
+    }
+    return {
+        config: {
+            defaultMedium: 'web',
+            maxTextLength: 8000,
+        },
+        summary: {
+            'Delivery Medium': 'Web SSE Streaming',
+            'Max Text Length': '8000 chars',
+        },
+    };
+}

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,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureObservation = configureObservation;
+const inquirer_1 = __importDefault(require("inquirer"));
+async function configureObservation(_context) {
+    const { provider } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'provider',
+        message: 'Screen observation & continuous frame ingest:',
+        choices: [
+            {
+                name: 'None (Disabled as default - Work in progress)',
+                value: 'none',
+            },
+            {
+                name: 'Experimental Frame Ingest (Prototype - requires active vision)',
+                value: 'fixture',
+            },
+        ],
+        default: 'none',
+    });
+    if (provider === 'none') {
+        return {
+            config: { provider: 'none' },
+            summary: { Provider: 'Disabled (Work in progress)' },
+        };
+    }
+    return {
+        config: {},
+        summary: {
+            Provider: 'Experimental Frame Ingest (Work in progress)',
+            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,47 @@
+"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' },
+            { name: 'None (Skip / Disable visual perception)', value: 'none' },
+        ],
+        default: 'none',
+    });
+    if (model === 'none') {
+        return {
+            config: { provider: 'none' },
+            summary: { Provider: 'None (Vision disabled)' },
+        };
+    }
+    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>;