@vxnus/siduri 0.0.6 → 0.0.8

package/dist/configurators/index.d.ts

@@ -0,0 +1,23 @@
+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 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,74 @@
+"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");
+__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);
+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 'memory':
+            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);
+        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,100 @@
+"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 { source } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'source',
+        message: 'Knowledge source?',
+        choices: [
+            { name: 'E Knowledge Hub (Search and attach remote factual pack)', value: 'e-hub' },
+            { name: 'Do not use knowledge', value: 'none' },
+        ],
+    });
+    if (source === 'none') {
+        return {
+            config: {
+                provider: 'none',
+            },
+            summary: {
+                Source: 'Do not use knowledge',
+            },
+        };
+    }
+    // E Knowledge Hub flow
+    while (true) {
+        const { packId } = await inquirer_1.default.prompt({
+            type: 'input',
+            name: 'packId',
+            message: 'Search E Knowledge Hub or enter package ID:',
+            default: '@vxnus/e-teyvat',
+            validate: (val) => val.trim().length > 0 || 'Please enter a package ID.',
+        });
+        const trimmedPackId = packId.trim();
+        let manifest;
+        try {
+            process.stdout.write('\u001b[2mSearching E Knowledge Hub...\u001b[0m');
+            manifest = await client.resolveProvider(trimmedPackId);
+            process.stdout.write('\r\u001b[32m✓\u001b[0m Checking provider manifest\n');
+        }
+        catch (err) {
+            process.stdout.write('\r\u001b[33m!\u001b[0m Provider resolution failed\n');
+            console.log(`\u001b[33mReason:\u001b[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 / Search another provider', value: 'retry' },
+                    { name: 'Do not use knowledge', value: 'skip' },
+                    { name: 'Cancel', value: 'cancel' },
+                ],
+            });
+            if (failureAction === 'retry') {
+                continue;
+            }
+            if (failureAction === 'skip') {
+                return {
+                    config: { provider: 'none' },
+                    summary: { Source: 'Do not use knowledge' },
+                };
+            }
+            throw new Error('Knowledge configuration cancelled.');
+        }
+        // Display provider summary
+        (0, knowledge_hub_1.displayKnowledgeProviderSummary)(manifest, trimmedPackId);
+        const { confirmProvider } = await inquirer_1.default.prompt({
+            type: 'list',
+            name: 'confirmProvider',
+            message: 'Use this knowledge provider?',
+            choices: [
+                { name: 'Yes, use this provider', value: 'yes' },
+                { name: 'Choose another provider', value: 'retry' },
+            ],
+        });
+        if (confirmProvider === 'yes') {
+            return {
+                config: {
+                    provider: 'e-hub',
+                    registryUrl: 'https://e.vxnus.xyz/api/v1/knowledge',
+                    packId: trimmedPackId,
+                },
+                summary: {
+                    Source: 'E Knowledge Hub',
+                    Provider: manifest.displayName || manifest.name,
+                    Package: trimmedPackId,
+                    Version: manifest.version,
+                },
+                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,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 {};