@siduri-x/self 2.0.0

package/dist/types.d.ts

@@ -0,0 +1,84 @@
+import { SelfIdentity, PersonalityTraits, SelfDirective, SelfRelationship } from '@siduri-x/core';
+export type { SelfIdentity, PersonalityTraits, SelfDirective, SelfRelationship, };
+export interface SelfRepository {
+    getIdentity(companionId: string): Promise<SelfIdentity | undefined>;
+    setIdentity(identity: SelfIdentity): Promise<void>;
+    getPersonality(companionId: string): Promise<PersonalityTraits>;
+    setPersonality(companionId: string, traits: PersonalityTraits): Promise<void>;
+    getActiveDirectives(companionId: string): Promise<SelfDirective[]>;
+    commitDirectives(companionId: string, directives: SelfDirective[]): Promise<void>;
+    disableDirective(id: string): Promise<void>;
+    getRelationship(companionId: string, entityId: string): Promise<SelfRelationship | null>;
+    updateRelationship(companionId: string, rel: SelfRelationship): Promise<void>;
+}
+export interface SelfPackageAuthor {
+    name: string;
+    url?: string;
+    signature?: string;
+}
+export interface SelfPackageDirective {
+    id: string;
+    priority: number;
+    directive: string;
+    category?: 'behavioral' | 'guardrail' | 'relational';
+}
+export interface SelfDialogueExample {
+    user: string;
+    assistant: string;
+}
+export interface SelfPackageManifest {
+    specVersion: string;
+    kind: 'self';
+    id: string;
+    name: string;
+    version: string;
+    author: SelfPackageAuthor;
+    license?: string;
+    identity: {
+        name: string;
+        archetype?: string;
+        origin?: string;
+    };
+    personality: PersonalityTraits;
+    directives: SelfPackageDirective[];
+    guardrails?: string[];
+    dialogueExamples?: SelfDialogueExample[];
+}
+export interface ScanResult {
+    safe: boolean;
+    reason?: string;
+}
+export interface ScannedDirective extends SelfPackageDirective {
+    scanResult: ScanResult;
+    approvedByDefault: boolean;
+}
+export interface SelfPackageParseResult {
+    manifest?: SelfPackageManifest;
+    scannedDirectives: ScannedDirective[];
+    isValid: boolean;
+    errors: string[];
+}
+export interface SelfCompilationContext {
+    companionId: string;
+    identity?: SelfIdentity;
+    personality?: PersonalityTraits;
+    directives: SelfDirective[];
+    interlocutorEntityId?: string;
+    relationship?: SelfRelationship | null;
+    guardrails?: string[];
+    now?: string;
+}
+export interface ActiveSelfProjection {
+    identityBlock?: string;
+    personalityBlock?: string;
+    winningDirectives: SelfDirective[];
+    relationshipBlock?: string;
+    guardrailsBlock?: string;
+    identityFacts: string[];
+    relationshipFacts: string[];
+    behavioralRules: string[];
+    activeIds: string[];
+    excludedIds: string[];
+    diagnostics: Record<string, string>;
+    render(): string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/jest.config.json

@@ -0,0 +1,5 @@
+{
+  "preset": "ts-jest",
+  "testEnvironment": "node",
+  "testPathIgnorePatterns": ["/node_modules/", "/dist/"]
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@siduri-x/self",
+  "version": "2.0.0",
+  "description": "Siduri Self domain: Identity, personality, directional relationships, directives, ActiveSelfCompiler, and .self asset parser",
+  "license": "Apache-2.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@siduri-x/core": "2.0.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^26.2.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.12",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vxnus-studio/siduri-x",
+    "directory": "packages/self"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w",
+    "test": "jest --config jest.config.json"
+  }
+}

package/src/active-self-compiler.ts

@@ -0,0 +1,184 @@
+import {
+  SelfDirective,
+  BehaviorOrgan,
+  BehaviorContext,
+  ActiveSelfProjection as CoreActiveSelfProjection,
+} from '@siduri-x/core';
+import {
+  SelfCompilationContext,
+  ActiveSelfProjection,
+  SelfIdentity,
+  PersonalityTraits,
+  SelfRelationship,
+} from './types';
+import { scanDirective } from './safety-scanner';
+
+export class ActiveSelfCompiler implements BehaviorOrgan {
+  async compileProjection(context: SelfCompilationContext | BehaviorContext): Promise<ActiveSelfProjection & CoreActiveSelfProjection> {
+    const rawContext = context as any;
+    const companionId: string | undefined = rawContext.companionId;
+    const identity: SelfIdentity | undefined = rawContext.identity;
+    const personality: PersonalityTraits | undefined = rawContext.personality;
+    const relationship: SelfRelationship | undefined = rawContext.relationship;
+    const guardrails: string[] = Array.isArray(rawContext.guardrails) ? rawContext.guardrails : [];
+    const directives: SelfDirective[] = Array.isArray(rawContext.directives) ? rawContext.directives : [];
+    const nowIso: string | undefined = rawContext.now;
+
+    const now = nowIso ? new Date(nowIso) : new Date();
+
+    // 1. Identify superseded directives
+    const supersededIds = new Set<string>();
+    for (const d of directives) {
+      if (d.status === 'ACTIVE' && d.supersedesId) {
+        supersededIds.add(d.supersedesId);
+      }
+    }
+
+    const winningDirectives: SelfDirective[] = [];
+    const excludedIds: string[] = [];
+    const diagnostics: Record<string, string> = {};
+
+    // 2. Filter directives
+    for (const d of directives) {
+      // Isolation check
+      if (companionId && d.companionId && d.companionId !== companionId) {
+        excludedIds.push(d.id);
+        diagnostics[d.id] = 'companion_mismatch';
+        continue;
+      }
+
+      // Status check
+      if (d.status !== 'ACTIVE') {
+        excludedIds.push(d.id);
+        diagnostics[d.id] = `state_${String(d.status).toLowerCase()}`;
+        continue;
+      }
+
+      // Superseded check
+      if (d.id && supersededIds.has(d.id)) {
+        excludedIds.push(d.id);
+        diagnostics[d.id] = 'superseded_directive';
+        continue;
+      }
+
+      // Temporal checks if dates are present
+      const anyD = d as any;
+      if (anyD.validFrom && new Date(anyD.validFrom) > now) {
+        excludedIds.push(d.id);
+        diagnostics[d.id] = 'valid_from_in_future';
+        continue;
+      }
+      if (anyD.validUntil && new Date(anyD.validUntil) < now) {
+        excludedIds.push(d.id);
+        diagnostics[d.id] = 'expired_valid_until';
+        continue;
+      }
+
+      // Prompt injection safety scan
+      const scan = scanDirective(d.directive);
+      if (!scan.safe) {
+        excludedIds.push(d.id);
+        diagnostics[d.id] = scan.reason || 'unsafe_directive';
+        continue;
+      }
+
+      winningDirectives.push(d);
+    }
+
+    // 3. Sort by priority descending
+    winningDirectives.sort((a, b) => (b.priority ?? 50) - (a.priority ?? 50));
+
+    // 4. Build Identity Block
+    const identityFacts: string[] = [];
+    let identityBlock: string | undefined;
+    if (identity) {
+      const parts = [`Name: ${identity.name}`];
+      if (identity.archetype) {
+        parts.push(`Archetype: ${identity.archetype}`);
+      }
+      identityBlock = parts.join(' | ');
+      identityFacts.push(identityBlock);
+    }
+
+    // 5. Build Personality Block
+    let personalityBlock: string | undefined;
+    if (personality) {
+      personalityBlock = [
+        `Warmth: ${personality.warmth.toFixed(2)}`,
+        `Formality: ${personality.formality.toFixed(2)}`,
+        `Sarcasm: ${personality.sarcasm.toFixed(2)}`,
+        `Verbosity: ${personality.verbosity.toFixed(2)}`,
+        `Curiosity: ${personality.curiosity.toFixed(2)}`,
+      ].join(' | ');
+    }
+
+    // 6. Build Relationship Block
+    const relationshipFacts: string[] = [];
+    let relationshipBlock: string | undefined;
+    if (relationship) {
+      const lines = [
+        `Toward ${relationship.entityId} (${relationship.entityType}): Trust=${relationship.trustScore.toFixed(2)}, Familiarity=${relationship.familiarity.toFixed(2)}`,
+      ];
+      if (relationship.interactionConventions && relationship.interactionConventions.length > 0) {
+        lines.push(`Conventions: ${relationship.interactionConventions.join(', ')}`);
+      }
+      relationshipBlock = lines.join('\n');
+      relationshipFacts.push(relationshipBlock);
+    }
+
+    // 7. Build Behavioral Rules & Guardrails
+    const behavioralRules: string[] = winningDirectives.map((d) => d.directive);
+    let guardrailsBlock: string | undefined;
+    if (guardrails.length > 0) {
+      guardrailsBlock = guardrails.map((g) => `- ${g}`).join('\n');
+    }
+
+    const activeIds: string[] = winningDirectives.map((d) => d.id);
+
+    return {
+      identityFacts,
+      relationshipFacts,
+      behavioralRules,
+      activeIds,
+      excludedIds,
+      diagnostics,
+      winningDirectives,
+      identityBlock,
+      personalityBlock,
+      relationshipBlock,
+      guardrailsBlock,
+      render(): string {
+        const sections: string[] = ['<active_self>'];
+
+        if (identityBlock) {
+          sections.push(`Identity:\n- ${identityBlock}`);
+        }
+
+        if (personalityBlock) {
+          sections.push(`Personality Spectrum:\n- ${personalityBlock}`);
+        }
+
+        if (relationshipBlock) {
+          sections.push(`Relationship Stance:\n${relationshipBlock}`);
+        }
+
+        if (winningDirectives.length > 0) {
+          const dirLines = winningDirectives.map((d) => `- [Priority ${d.priority}] ${d.directive}`);
+          sections.push(`Behavioral Directives:\n${dirLines.join('\n')}`);
+        }
+
+        if (guardrailsBlock) {
+          sections.push(`Guardrails:\n${guardrailsBlock}`);
+        }
+
+        sections.push('</active_self>');
+        return sections.join('\n\n');
+      },
+    };
+  }
+
+  async compile(context: SelfCompilationContext | BehaviorContext): Promise<string> {
+    const projection = await this.compileProjection(context);
+    return projection.render();
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './safety-scanner';
+export * from './self-repository';
+export * from './active-self-compiler';
+export * from './self-parser';

package/src/safety-scanner.ts

@@ -0,0 +1,150 @@
+import { ScanResult } from './types';
+
+export interface SafetyPatternConfig {
+  overridePattern: RegExp;
+  negationPattern: RegExp;
+  disclosurePattern: RegExp;
+  escalationPhrases: RegExp[];
+  approvalTampering: RegExp[];
+  safetyDisable: RegExp[];
+  structuralHeuristics: Array<{ pattern: RegExp; reason: string }>;
+}
+
+// ── Layer 1: Unicode normalization & deobfuscation ──────────────────────
+
+const INVISIBLE_CHARS = /[\u200B\u200C\u200D\u2060\uFEFF\u00AD\u034F\u17B4\u17B5\u180E\u2061-\u2064\u206A-\u206F]/g;
+
+const LEET_MAP: Record<string, string> = {
+  '0': 'o', '1': 'i', '3': 'e', '4': 'a', '5': 's',
+  '7': 't', '@': 'a', '$': 's', '!': 'i',
+};
+
+const CONFUSABLE_MAP: Record<string, string> = {
+  '\u0430': 'a', '\u0435': 'e', '\u043E': 'o', '\u0440': 'p', '\u0441': 'c',
+  '\u0443': 'y', '\u0445': 'x', '\u0456': 'i', '\u0458': 'j', '\u04BB': 'h',
+  '\u0261': 'g', '\u03B1': 'a', '\u03BF': 'o', '\u03B5': 'e',
+  // Fullwidth Latin
+  '\uFF41': 'a', '\uFF42': 'b', '\uFF43': 'c', '\uFF44': 'd', '\uFF45': 'e',
+  '\uFF46': 'f', '\uFF47': 'g', '\uFF48': 'h', '\uFF49': 'i', '\uFF4A': 'j',
+  '\uFF4B': 'k', '\uFF4C': 'l', '\uFF4D': 'm', '\uFF4E': 'n', '\uFF4F': 'o',
+  '\uFF50': 'p', '\uFF51': 'q', '\uFF52': 'r', '\uFF53': 's', '\uFF54': 't',
+  '\uFF55': 'u', '\uFF56': 'v', '\uFF57': 'w', '\uFF58': 'x', '\uFF59': 'y',
+  '\uFF5A': 'z',
+};
+
+export function normalizeText(input: string): string {
+  let text = input;
+  text = text.replace(INVISIBLE_CHARS, '');
+  text = text.replace(/./g, (ch) => CONFUSABLE_MAP[ch] ?? ch);
+  text = text.toLowerCase();
+  text = text.replace(/[013457@$!]/g, (ch) => LEET_MAP[ch] ?? ch);
+  text = text.replace(/\b([a-z])(?:\s+[a-z]){2,}\b/g, (match) =>
+    match.replace(/\s+/g, '')
+  );
+  text = text.replace(/\s+/g, ' ').trim();
+  return text;
+}
+
+// ── Layer 2: Multi-category pattern bank ─────────────────────────────────
+
+const OVERRIDE_VERBS = '(?:ignore|override|bypass|skip|circumvent|disregard|forget|violate|break|disable|remove|deactivate|nullify|suspend|suppress|eliminate|drop|abandon|dismiss|disobey)';
+const NEGATION_VERBS = '(?:do not follow|don\'t follow|stop following|stop enforcing|never follow|never enforce|cease following|quit following)';
+const SAFETY_NOUNS = '(?:system|policy|policies|rules?|approval|permissions?|restrictions?|guidelines?|constraints?|guardrails?|instructions?|authorization|gating|safety|safeguards?|boundaries|limits?|protections?)';
+
+const DISCLOSURE_VERBS = '(?:reveal|expose|leak|dump|show|output|print|display|disclose|share|repeat back|read out|recite|reproduce|echo|emit|return|give me)';
+const SECRET_NOUNS = '(?:secret|token|api key|private memory|system prompt|initial prompt|hidden instructions?|internal state|configuration|prompt text|original instructions?|base prompt)';
+
+const ESCALATION_PHRASES = [
+  /\b(?:developer|admin|unrestricted|unfiltered|unlimited|god|root|sudo|superuser)\s*mode\b/,
+  /\b(?:jailbreak|jail break|jailbroken)\b/,
+  /\byou are now\b.{0,40}\b(?:unrestricted|unfiltered|without limits|without restrictions|without rules|without guidelines|free from)\b/,
+  /\byour (?:new|real|actual|true)\s+(?:instructions?|prompt|rules?|policy|guidelines?)\b/,
+  /\bfrom now on you (?:will|must|should|shall)\b.{0,60}\b(?:obey|comply|follow all|do whatever|do anything|never refuse)\b/,
+  /\bpretend\b.{0,40}\b(?:no restrictions|no rules|no limits|no guidelines|no constraints|unrestricted|unfiltered)\b/,
+  /\bact as if\b.{0,40}\b(?:permissions?|restrictions?|rules?|policy|guidelines?|constraints?)\b.{0,20}\b(?:don't|do not|doesn't|does not|did not|didn't)\b/,
+  /\byou have\s+(?:full|complete|total|unlimited|unrestricted)\s+(?:\w+\s+)?(?:access|permissions?|authorization|control)\b/,
+  /\btreat\s+(?:all|every)\b.{0,40}\b(?:operator|admin|owner|administrator)\b/,
+];
+
+const APPROVAL_TAMPERING = [
+  /\b(?:auto(?:-|\s)?approve|automatically approve|always approve|approve\s+all|approve\s+every)\b/,
+  /\b(?:always accept|never reject|never deny|never refuse|skip\s+approval|bypass\s+approval)\b/,
+  /\b(?:treat as approved|mark as active|activate all|force activate|directly activate)\b/,
+  /\b(?:without\s+(?:approval|review|verification|confirmation|checking|authorization))\b/,
+];
+
+const SAFETY_DISABLE = [
+  /\b(?:turn off|shut off|switch off|power off|deactivate|disable|remove|delete|erase|clear|wipe|purge)\b.{0,30}\b(?:safety|security|filter|filtering|moderation|censorship|guardrails?)\b/,
+  /\b(?:no\s+(?:safety|security|content)\s+(?:filter|filtering|check|checks|moderation|restrictions))\b/,
+  /\b(?:without\s+(?:safety|security|content)\s+(?:filter|filtering|check|checks|moderation|restrictions))\b/,
+];
+
+const OVERRIDE_PATTERN = new RegExp(`\\b${OVERRIDE_VERBS}\\b.{0,60}\\b${SAFETY_NOUNS}\\b`, 'i');
+const NEGATION_PATTERN = new RegExp(`\\b${NEGATION_VERBS}\\b.{0,60}\\b${SAFETY_NOUNS}\\b`, 'i');
+const DISCLOSURE_PATTERN = new RegExp(`\\b${DISCLOSURE_VERBS}\\b.{0,60}\\b${SECRET_NOUNS}\\b`, 'i');
+
+// ── Layer 3: Structural heuristics ───────────────────────────────────────
+
+const STRUCTURAL_HEURISTICS = [
+  { pattern: /\byour\s+new\s+(?:system\s+)?(?:policy|rules?|instructions?|guidelines?|prompt)\s+(?:is|are|will be|should be)\b/i, reason: 'policy_redefinition' },
+  { pattern: /\b(?:when|if|after|once)\b.{0,60}\b(?:ignore|stop|disable|bypass|override|forget|drop|abandon)\b.{0,40}\b(?:safety|rules?|policy|guidelines?|restrictions?|guardrails?)\b/i, reason: 'conditional_unsafe_trigger' },
+  { pattern: /\b(?:respond|reply|answer|act|behave)\b.{0,30}\b(?:as if you were|as though you are|like you are|pretending to be)\b.{0,40}\b(?:unfiltered|unrestricted|evil|uncensored|without limits)\b/i, reason: 'identity_swap' },
+  { pattern: /\b(?:obey\s+all|do\s+whatever|do\s+anything|comply\s+with\s+(?:any|all|every)|always\s+comply|never\s+refuse|never\s+decline|never\s+deny\s+a\s+request)\b/i, reason: 'blanket_obedience' },
+  { pattern: /\b(?:execute|run|invoke|call|trigger)\b.{0,20}\b(?:any|all|every)\b.{0,30}\b(?:tool|command|action|function|operation)\b.{0,40}\b(?:without|no)\b.{0,20}\b(?:check|auth|approval|verification|restriction)\b/i, reason: 'unauthorized_execution' },
+];
+
+export const DEFAULT_SAFETY_PATTERNS: SafetyPatternConfig = {
+  overridePattern: OVERRIDE_PATTERN,
+  negationPattern: NEGATION_PATTERN,
+  disclosurePattern: DISCLOSURE_PATTERN,
+  escalationPhrases: ESCALATION_PHRASES,
+  approvalTampering: APPROVAL_TAMPERING,
+  safetyDisable: SAFETY_DISABLE,
+  structuralHeuristics: STRUCTURAL_HEURISTICS,
+};
+
+export function scanDirective(raw: string, patterns: SafetyPatternConfig = DEFAULT_SAFETY_PATTERNS): ScanResult {
+  if (!raw || raw.trim() === '') {
+    return { safe: true };
+  }
+
+  const text = normalizeText(raw);
+
+  if (patterns.overridePattern.test(text)) {
+    return { safe: false, reason: 'unsafe_override' };
+  }
+
+  if (patterns.negationPattern.test(text)) {
+    return { safe: false, reason: 'unsafe_negation' };
+  }
+
+  if (patterns.disclosurePattern.test(text)) {
+    return { safe: false, reason: 'unsafe_disclosure' };
+  }
+
+  for (const pattern of patterns.escalationPhrases) {
+    if (pattern.test(text)) {
+      return { safe: false, reason: 'unsafe_escalation' };
+    }
+  }
+
+  for (const pattern of patterns.approvalTampering) {
+    if (pattern.test(text)) {
+      return { safe: false, reason: 'unsafe_approval_tampering' };
+    }
+  }
+
+  for (const pattern of patterns.safetyDisable) {
+    if (pattern.test(text)) {
+      return { safe: false, reason: 'unsafe_safety_disable' };
+    }
+  }
+
+  for (const { pattern, reason } of patterns.structuralHeuristics) {
+    if (pattern.test(text)) {
+      return { safe: false, reason };
+    }
+  }
+
+  return { safe: true };
+}