@vxnus/siduri 2.0.6 → 2.0.7

package/dist/builtin-manifests.js

@@ -6,8 +6,8 @@ exports.BUILTIN_ORGAN_MANIFESTS = [
         name: '@siduri-x/self',
         organType: 'behavior',
         version: '2.0.2',
-        displayName: 'Behavior & Self (Personality Directives)',
-        description: 'Atomic directive state machine and personality projection compiler',
+        displayName: 'Self & Persona (Identity & Directives)',
+        description: 'Autonomous persona compiler, relational stances, and .self asset loader',
         entrypoint: './dist/index.js',
         factory: 'ActiveSelfCompiler',
         configKey: 'behavior',
@@ -19,7 +19,20 @@ exports.BUILTIN_ORGAN_MANIFESTS = [
                     type: 'string',
                     enum: ['active_self', 'none']
                 },
-                preset: {
+                mode: {
+                    type: 'string',
+                    enum: ['blank_slate', 'custom']
+                },
+                archetype: {
+                    type: 'string'
+                },
+                ethos: {
+                    type: 'string'
+                },
+                directive: {
+                    type: 'string'
+                },
+                selfPath: {
                     type: 'string'
                 }
             }

package/dist/configurators/behavior.js

@@ -6,31 +6,74 @@ 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({
+    const companionName = _context.companionName || 'Companion';
+    const companionSlug = companionName.toLowerCase().replace(/[^a-z0-9_-]/g, '') || 'default';
+    const { personaMode } = await inquirer_1.default.prompt({
         type: 'list',
-        name: 'preset',
-        message: 'Personality projection preset:',
+        name: 'personaMode',
+        message: 'Define base persona now or later?',
         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' },
+            {
+                name: 'Later (Start as a pure blank slate; evolve via interaction or add .self later)',
+                value: 'later',
+            },
+            {
+                name: 'Now (Define archetype, ethos, and generate base .self persona asset)',
+                value: 'now',
+            },
         ],
+        default: 'later',
     });
-    const presetLabels = {
-        calm_precise: 'Calm & Precise',
-        cheerful: 'Cheerful & Enthusiastic',
-        analytical: 'Analytical & Methodical',
-        custom: 'Custom Directives',
-    };
+    if (personaMode === 'later') {
+        return {
+            config: {
+                provider: 'active_self',
+                mode: 'blank_slate',
+            },
+            summary: {
+                Persona: 'Blank Slate (Evolve via interaction)',
+                Directives: 'Zero predeclared biases',
+            },
+        };
+    }
+    const personaAnswers = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'archetype',
+            message: 'Companion archetype or role:',
+            default: 'Knowledge Assistant & Research Partner',
+        },
+        {
+            type: 'input',
+            name: 'ethos',
+            message: 'Core ethos & speaking demeanor:',
+            default: 'Direct technical candor, thoughtful, concise, and loyal',
+        },
+        {
+            type: 'input',
+            name: 'directive',
+            message: 'Primary behavioral directive or rule:',
+            default: 'Speak concisely and stay in character without sycophantic filler',
+        },
+    ]);
+    const archetype = personaAnswers.archetype.trim() || 'Knowledge Assistant & Research Partner';
+    const ethos = personaAnswers.ethos.trim() || 'Direct technical candor, thoughtful, concise, and loyal';
+    const directive = personaAnswers.directive.trim() || 'Speak concisely and stay in character without sycophantic filler';
+    const selfPath = `./assets/self/${companionSlug}.self`;
     return {
         config: {
             provider: 'active_self',
-            preset,
+            mode: 'custom',
+            archetype,
+            ethos,
+            directive,
+            selfPath,
         },
         summary: {
-            Provider: 'Active Self Directives',
-            Preset: presetLabels[preset] || preset,
+            Persona: 'Configured (.self asset)',
+            Archetype: archetype,
+            Ethos: ethos,
+            'Self Asset': selfPath,
         },
     };
 }

package/dist/configurators.test.js

@@ -315,11 +315,26 @@ describe('Guided Manifest-Driven Configuration UX Specification Tests', () => {
             expect(result.config.provider).toBe('none');
             expect(result.summary?.Provider).toBe('None (Hands disabled)');
         });
-        test('Behavior configurator configures active self personality preset', async () => {
-            inquirer_1.default.prompt.mockResolvedValueOnce({ preset: 'cheerful' });
+        test('Behavior configurator configures blank slate mode when later is chosen', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ personaMode: 'later' });
             const result = await (0, behavior_1.configureBehavior)({ companionName: 'Sparkle', manifest: behaviorManifest });
             expect(result.config.provider).toBe('active_self');
-            expect(result.config.preset).toBe('cheerful');
+            expect(result.config.mode).toBe('blank_slate');
+            expect(result.summary?.Persona).toBe('Blank Slate (Evolve via interaction)');
+        });
+        test('Behavior configurator configures custom persona asset when now is chosen', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ personaMode: 'now' })
+                .mockResolvedValueOnce({
+                archetype: 'System Sentinel',
+                ethos: 'Snarky and loyal',
+                directive: 'No sycophantic greetings',
+            });
+            const result = await (0, behavior_1.configureBehavior)({ companionName: 'Sparkle', manifest: behaviorManifest });
+            expect(result.config.provider).toBe('active_self');
+            expect(result.config.mode).toBe('custom');
+            expect(result.config.archetype).toBe('System Sentinel');
+            expect(result.config.selfPath).toBe('./assets/self/sparkle.self');
         });
         test('Vision configurator configures OpenRouter vision model', async () => {
             inquirer_1.default.prompt.mockResolvedValueOnce({ model: 'gpt-4-vision' });

package/dist/generator.d.ts

@@ -9,6 +9,7 @@ export interface GeneratedInstanceFiles {
     'public/index.html': string;
     createAssetsBodyDir?: boolean;
     createAssetsDirs?: string[];
+    [key: string]: string | boolean | string[] | undefined;
 }
 export interface InstanceGeneratorOptions {
     name: string;

package/dist/generator.js

@@ -73,6 +73,7 @@ function getDefaultConfigForManifest(manifest) {
 }
 function generateInstanceFiles(options) {
     const instanceName = options.name || 'my-siduri';
+    const companionSlug = instanceName.toLowerCase().replace(/[^a-z0-9_-]/g, '') || 'default';
     const instanceId = options.id || 'default';
     const coreVersion = options.coreVersion || '^2.0.3';
     const manifests = options.selectedManifests;
@@ -172,7 +173,7 @@ function generateInstanceFiles(options) {
     ];
     for (const m of manifests) {
         if (m.name === '@siduri-x/self') {
-            importLines.push(`import { ActiveSelfCompiler, SqliteSelfRepository } from '@siduri-x/self';`);
+            importLines.push(`import { ActiveSelfCompiler, SqliteSelfRepository, SelfPackageParser } from '@siduri-x/self';`);
         }
         else {
             importLines.push(`import { ${m.factory} } from '${m.name}';`);
@@ -184,6 +185,19 @@ function generateInstanceFiles(options) {
         if (m.name === '@siduri-x/self') {
             instantiationLines.push(`const self = new SqliteSelfRepository({ dbPath: path.resolve(rootDir, 'siduri.sqlite') });`);
             instantiationLines.push(`const behavior = new ActiveSelfCompiler(config.organs.behavior);`);
+            instantiationLines.push(`const selfFile = path.resolve(rootDir, config.organs.behavior?.selfPath || 'assets/self/${companionSlug}.self');`);
+            instantiationLines.push(`try {`);
+            instantiationLines.push(`  const selfRaw = await readFile(selfFile, 'utf8').catch(() => null);`);
+            instantiationLines.push(`  if (selfRaw) {`);
+            instantiationLines.push(`    const parsedSelf = SelfPackageParser.parse(selfRaw);`);
+            instantiationLines.push(`    if (parsedSelf.isValid && parsedSelf.manifest) {`);
+            instantiationLines.push(`      await self.setIdentity({ companionId: config.id || 'default', name: parsedSelf.manifest.identity?.name || config.name, archetype: parsedSelf.manifest.identity?.archetype, version: parsedSelf.manifest.version || '1.0.0', updatedAt: new Date().toISOString() });`);
+            instantiationLines.push(`      if (parsedSelf.manifest.directives) {`);
+            instantiationLines.push(`        await self.commitDirectives(config.id || 'default', parsedSelf.manifest.directives.map((d) => ({ id: d.id, companionId: config.id || 'default', directive: d.directive, category: (d.category || 'behavioral'), status: 'ACTIVE', priority: d.priority || 50, createdAt: new Date().toISOString() })));`);
+            instantiationLines.push(`      }`);
+            instantiationLines.push(`    }`);
+            instantiationLines.push(`  }`);
+            instantiationLines.push(`} catch {}`);
             organMapEntries.push(`  behavior,`);
             organMapEntries.push(`  self,`);
         }
@@ -665,7 +679,6 @@ function generateInstanceFiles(options) {
     }
     readmeLines.push('', '## Getting Started', '', '### 1. Install Dependencies', '```bash', 'npm install', '```', '', '### 2. Configure Environment', '```bash', 'cp .env.example .env', '```', 'Fill in your LLM API key (e.g. `OPENROUTER_API_KEY`) and any other service credentials in `.env`.');
     readmeLines.push('', '### 3. Diagnostics & Health Probe', 'Verify all environment variables, schema conformance, services, and organ connections:', '```bash', 'npm run doctor', '```', '', '### 4. Start Companion & Web Console', 'Launch your companion runtime and Web UI / Memory Control Panel:', '```bash', 'npm start', '```', 'Then open `http://localhost:3000` in your browser.');
-    const companionSlug = instanceName.toLowerCase().replace(/[^a-z0-9_-]/g, '') || 'default';
     const createAssetsDirs = [];
     if (hasBody) {
         createAssetsDirs.push(`assets/body/${companionSlug}`);
@@ -681,6 +694,38 @@ function generateInstanceFiles(options) {
         createAssetsDirs.push(cleanPackDir);
         readmeLines.push('', '### Knowledge Pack Assets', `Local knowledge pack files reside in \`./${cleanPackDir}/\`.`);
     }
+    const behaviorConfig = options.organConfigs?.behavior || options.organConfigs?.['@siduri-x/self'];
+    let selfPersonaFile = null;
+    if (manifests.some((m) => m.organType === 'behavior')) {
+        createAssetsDirs.push('assets/self');
+        if (behaviorConfig?.mode === 'custom' || behaviorConfig?.archetype) {
+            const selfRelPath = `assets/self/${companionSlug}.self`;
+            const selfContent = [
+                `specVersion: "2.0.0"`,
+                `kind: "self"`,
+                `id: "${companionSlug}-self"`,
+                `name: "${instanceName} Persona"`,
+                `version: "1.0.0"`,
+                `author:`,
+                `  name: "Operator"`,
+                `license: "MIT"`,
+                ``,
+                `identity:`,
+                `  name: "${instanceName}"`,
+                `  archetype: "${(behaviorConfig.archetype || 'Knowledge Assistant & Research Partner').replace(/"/g, '\\"')}"`,
+                `  origin: "Constructed companion"`,
+                `  ethos: "${(behaviorConfig.ethos || 'Direct technical candor, thoughtful, concise, and loyal').replace(/"/g, '\\"')}"`,
+                ``,
+                `directives:`,
+                `  - id: "dir-01"`,
+                `    category: "behavioral"`,
+                `    directive: "${(behaviorConfig.directive || 'Speak concisely and stay in character without sycophantic filler').replace(/"/g, '\\"')}"`,
+                ``,
+            ].join('\n');
+            selfPersonaFile = { path: selfRelPath, content: selfContent };
+            readmeLines.push('', '### Self & Persona Assets', `Companion persona manifest resides in \`./${selfRelPath}\`.`);
+        }
+    }
     readmeLines.push('');
     const readmeMd = readmeLines.join('\n');
     const webHtml = (0, web_template_1.generateWebHtml)(instanceName, manifests);
@@ -695,5 +740,8 @@ function generateInstanceFiles(options) {
         createAssetsBodyDir: hasBody,
         createAssetsDirs,
     };
+    if (selfPersonaFile) {
+        result[selfPersonaFile.path] = selfPersonaFile.content;
+    }
     return result;
 }

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { OrganManifest } from './manifest';
-export declare const CLI_VERSION = "2.0.6";
+export declare const CLI_VERSION = "2.0.7";
 export declare const colors: {
     cyan: string;
     dim: string;

package/dist/index.js

@@ -26,7 +26,7 @@ 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.0.6';
+exports.CLI_VERSION = '2.0.7';
 exports.colors = {
     cyan: '\u001b[36m',
     dim: '\u001b[2m',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vxnus/siduri",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "description": "Experimental CLI for installing and configuring Siduri companions",
   "license": "Apache-2.0",
   "repository": {