@sidurijs/self 1.0.0

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 };
+}

package/src/self-parser.ts

@@ -0,0 +1,295 @@
+import {
+  SelfPackageManifest,
+  SelfPackageParseResult,
+  ScannedDirective,
+  PersonalityTraits,
+} from './types';
+import { scanDirective } from './safety-scanner';
+
+/**
+ * Lightweight YAML to JS object parser supporting basic nested maps, lists, and primitives
+ * suitable for .self manifest schemas. Falls back to JSON.parse if the text starts with '{'.
+ */
+export function parseYamlOrJson(content: string): any {
+  const trimmed = content.trim();
+  if (trimmed.startsWith('{')) {
+    return JSON.parse(trimmed);
+  }
+
+  const lines = content.split('\n');
+  const root: any = {};
+  const stack: Array<{ indent: number; obj: any; key?: string; isList?: boolean }> = [
+    { indent: -1, obj: root },
+  ];
+
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i];
+    // Remove comments
+    const commentIdx = rawLine.indexOf('#');
+    const line = (commentIdx >= 0 ? rawLine.slice(0, commentIdx) : rawLine).replace(/\r$/, '');
+    if (!line.trim()) continue;
+
+    const indent = line.search(/\S/);
+    const text = line.trim();
+
+    // Pop stack to match current indentation
+    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
+      stack.pop();
+    }
+
+    const currentParent = stack[stack.length - 1];
+
+    // Check if line is a list item: "- something"
+    if (text.startsWith('- ')) {
+      const listContent = text.slice(2).trim();
+
+      // Ensure parent has an array for current key or parent itself is list
+      let targetArray: any[];
+      if (Array.isArray(currentParent.obj)) {
+        targetArray = currentParent.obj;
+      } else if (currentParent.key) {
+        const parentFrame = stack.length > 1 ? stack[stack.length - 2] : null;
+        if (parentFrame && parentFrame.obj[currentParent.key] === currentParent.obj && Object.keys(currentParent.obj).length === 0) {
+          targetArray = [];
+          parentFrame.obj[currentParent.key] = targetArray;
+          currentParent.obj = targetArray;
+        } else if (Array.isArray(currentParent.obj[currentParent.key])) {
+          targetArray = currentParent.obj[currentParent.key];
+        } else {
+          targetArray = [];
+          currentParent.obj[currentParent.key] = targetArray;
+        }
+      } else {
+        targetArray = [];
+      }
+
+      // Check if list item has inline key-value (e.g. "- id: 'dir-01'")
+      const colonIdx = listContent.indexOf(':');
+      if (colonIdx > 0 && !listContent.startsWith('"') && !listContent.startsWith("'")) {
+        const itemKey = listContent.slice(0, colonIdx).trim();
+        const itemVal = parsePrimitive(listContent.slice(colonIdx + 1).trim());
+        const itemObj: any = {};
+        if (itemVal !== undefined && itemVal !== '') {
+          itemObj[itemKey] = itemVal;
+        } else {
+          itemObj[itemKey] = {};
+        }
+        targetArray.push(itemObj);
+        stack.push({ indent, obj: itemObj, isList: false });
+      } else {
+        // Plain list item (scalar)
+        targetArray.push(parsePrimitive(listContent));
+      }
+      continue;
+    }
+
+    // Key-value pair: "key: value"
+    const colonIdx = text.indexOf(':');
+    if (colonIdx > 0) {
+      const key = text.slice(0, colonIdx).trim();
+      const valStr = text.slice(colonIdx + 1).trim();
+
+      let targetObj = currentParent.obj;
+      if (Array.isArray(targetObj)) {
+        targetObj = targetObj[targetObj.length - 1];
+      }
+
+      if (valStr === '' || valStr === undefined) {
+        // Nested map or upcoming list
+        const childObj: any = {};
+        targetObj[key] = childObj;
+        stack.push({ indent, obj: childObj, key, isList: false });
+      } else {
+        targetObj[key] = parsePrimitive(valStr);
+      }
+    }
+  }
+
+  return root;
+}
+
+function parsePrimitive(val: string): any {
+  if (val === '') return '';
+  if (val === 'true') return true;
+  if (val === 'false') return false;
+  if (val === 'null') return null;
+
+  // Quoted string
+  if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+    return val.slice(1, -1);
+  }
+
+  // Number
+  const num = Number(val);
+  if (!isNaN(num) && val.trim() !== '') {
+    return num;
+  }
+
+  return val;
+}
+
+export class SelfPackageParser {
+  static parse(rawContent: string): SelfPackageParseResult {
+    const errors: string[] = [];
+    let data: any;
+
+    try {
+      data = parseYamlOrJson(rawContent);
+    } catch (err: any) {
+      return {
+        isValid: false,
+        errors: [`Failed to parse .self file: ${err.message}`],
+        scannedDirectives: [],
+      };
+    }
+
+    if (!data || typeof data !== 'object') {
+      return {
+        isValid: false,
+        errors: ['Invalid .self file format: Root must be an object'],
+        scannedDirectives: [],
+      };
+    }
+
+    // 1. Spec & Kind
+    if (data.specVersion !== '1.0.0' && data.specVersion !== '2.0.0') {
+      errors.push(`Unsupported or missing specVersion: "${data.specVersion}" (expected "1.0.0" or "2.0.0")`);
+    }
+    if (data.kind !== 'self') {
+      errors.push(`Invalid kind: "${data.kind}" (expected "self")`);
+    }
+    if (!data.id || typeof data.id !== 'string') {
+      errors.push('Missing required string field: "id"');
+    }
+    if (!data.name || typeof data.name !== 'string') {
+      errors.push('Missing required string field: "name"');
+    }
+    if (!data.version || typeof data.version !== 'string') {
+      errors.push('Missing required string field: "version"');
+    }
+
+    // 2. Author
+    if (!data.author || typeof data.author !== 'object' || !data.author.name) {
+      errors.push('Missing required field: "author" with "name"');
+    }
+
+    // 3. Identity
+    if (!data.identity || typeof data.identity !== 'object' || !data.identity.name) {
+      errors.push('Missing required field: "identity" with "name"');
+    }
+
+    // 4. Personality validation (Optional in v2.0 / LLM-native mode)
+    const p = data.personality;
+    let traits: PersonalityTraits | undefined;
+
+    if (p !== undefined && p !== null) {
+      if (typeof p !== 'object') {
+        errors.push('Field "personality" must be an object if provided');
+      } else {
+        traits = {};
+        const keys: Array<keyof PersonalityTraits> = ['warmth', 'formality', 'sarcasm', 'verbosity', 'curiosity'];
+        for (const k of keys) {
+          if (p[k] !== undefined) {
+            if (typeof p[k] !== 'number' || p[k] < 0.0 || p[k] > 1.0) {
+              errors.push(`Personality trait "${k}" must be a number between 0.0 and 1.0`);
+            } else {
+              traits[k] = p[k];
+            }
+          }
+        }
+      }
+    }
+
+    // 5. Relationships validation (Optional)
+    const relationships = Array.isArray(data.relationships)
+      ? data.relationships
+          .filter((r: any) => r && typeof r === 'object' && r.entityId)
+          .map((r: any) => ({
+            entityId: String(r.entityId),
+            role: String(r.role || 'user'),
+            stance: String(r.stance || 'neutral'),
+            conventions: Array.isArray(r.conventions) ? r.conventions.map(String) : undefined,
+          }))
+      : undefined;
+
+    // 6. Dialogue Examples validation (Optional)
+    const dialogueExamples = Array.isArray(data.dialogueExamples)
+      ? data.dialogueExamples
+          .filter((ex: any) => ex && typeof ex === 'object' && ex.user && ex.assistant)
+          .map((ex: any) => ({
+            user: String(ex.user),
+            assistant: String(ex.assistant),
+          }))
+      : undefined;
+
+    // 7. Directives validation & scanning
+    const scannedDirectives: ScannedDirective[] = [];
+    if (!Array.isArray(data.directives)) {
+      errors.push('Missing required array field: "directives"');
+    } else {
+      for (let i = 0; i < data.directives.length; i++) {
+        const d = data.directives[i];
+        if (!d || typeof d !== 'object' || !d.directive) {
+          errors.push(`Directive at index ${i} is missing "directive" string`);
+          continue;
+        }
+
+        const scan = scanDirective(d.directive);
+        scannedDirectives.push({
+          id: d.id || `dir-${i + 1}`,
+          priority: typeof d.priority === 'number' ? d.priority : 50,
+          directive: d.directive,
+          category: d.category || 'behavioral',
+          scopeActor: d.scopeActor,
+          supersedesId: d.supersedesId,
+          scanResult: scan,
+          approvedByDefault: scan.safe,
+        });
+      }
+    }
+
+    const isValid = errors.length === 0;
+
+    let manifest: SelfPackageManifest | undefined;
+    if (isValid) {
+      manifest = {
+        specVersion: data.specVersion,
+        kind: 'self',
+        id: data.id,
+        name: data.name,
+        version: data.version,
+        author: {
+          name: data.author.name,
+          url: data.author.url,
+          signature: data.author.signature,
+        },
+        license: data.license,
+        identity: {
+          name: data.identity.name,
+          archetype: data.identity.archetype,
+          origin: data.identity.origin,
+          ethos: data.identity.ethos,
+        },
+        personality: traits,
+        relationships,
+        directives: scannedDirectives.map((sd) => ({
+          id: sd.id,
+          priority: sd.priority,
+          directive: sd.directive,
+          category: sd.category,
+          scopeActor: sd.scopeActor,
+          supersedesId: sd.supersedesId,
+        })),
+        guardrails: Array.isArray(data.guardrails) ? data.guardrails : undefined,
+        dialogueExamples,
+      };
+    }
+
+    return {
+      manifest,
+      scannedDirectives,
+      isValid,
+      errors,
+    };
+  }
+}

package/src/self-repository.ts

@@ -0,0 +1,117 @@
+import {
+  SiduriDatabase,
+  SelfIdentity,
+  PersonalityTraits,
+  SelfDirective,
+  SelfRelationship,
+  SelfDialogueExample,
+} from '@sidurijs/core';
+import { SelfRepository } from './types';
+
+export interface SqliteSelfRepositoryOptions {
+  db?: SiduriDatabase;
+  dbPath?: string;
+}
+
+export const DEFAULT_PERSONALITY_TRAITS: PersonalityTraits = {
+  warmth: 0.5,
+  formality: 0.5,
+  sarcasm: 0.5,
+  verbosity: 0.5,
+  curiosity: 0.5,
+};
+
+export class SqliteSelfRepository implements SelfRepository {
+  private db: SiduriDatabase;
+  private ownsDb: boolean;
+
+  constructor(options: SqliteSelfRepositoryOptions = {}) {
+    if (options.db) {
+      this.db = options.db;
+      this.ownsDb = false;
+    } else {
+      this.db = new SiduriDatabase({ dbPath: options.dbPath });
+      this.ownsDb = true;
+    }
+  }
+
+  async getIdentity(companionId: string): Promise<SelfIdentity | undefined> {
+    return this.db.getIdentity(companionId);
+  }
+
+  async setIdentity(identity: SelfIdentity): Promise<void> {
+    this.db.setIdentity(identity);
+  }
+
+  async getPersonality(companionId: string): Promise<PersonalityTraits> {
+    const traits = this.db.getPersonality(companionId);
+    return traits || { ...DEFAULT_PERSONALITY_TRAITS };
+  }
+
+  async setPersonality(companionId: string, traits: PersonalityTraits): Promise<void> {
+    this.db.setPersonality(companionId, traits);
+  }
+
+  async getActiveDirectives(companionId: string): Promise<SelfDirective[]> {
+    return this.db.getActiveDirectives(companionId);
+  }
+
+  async commitDirectives(companionId: string, directives: SelfDirective[]): Promise<void> {
+    for (const d of directives) {
+      this.db.commitDirective({
+        ...d,
+        companionId,
+      });
+    }
+  }
+
+  async approveDirective(id: string, companionId?: string): Promise<void> {
+    this.db.approveDirective(id, companionId);
+  }
+
+  async rejectDirective(id: string, companionId?: string): Promise<void> {
+    this.db.rejectDirective(id, companionId);
+  }
+
+  async revokeDirective(id: string, companionId?: string): Promise<void> {
+    this.db.revokeDirective(id, companionId);
+  }
+
+  async expireDirective(id: string, companionId?: string): Promise<void> {
+    this.db.expireDirective(id, companionId);
+  }
+
+  async disableDirective(id: string, companionId?: string): Promise<void> {
+    this.db.disableDirective(id, companionId);
+  }
+
+  async getRelationships(companionId: string): Promise<SelfRelationship[]> {
+    return this.db.getRelationships(companionId);
+  }
+
+  async getRelationship(companionId: string, entityId: string): Promise<SelfRelationship | null> {
+    const rel = this.db.getRelationship(companionId, entityId);
+    return rel ?? null;
+  }
+
+  async updateRelationship(companionId: string, rel: SelfRelationship): Promise<void> {
+    this.db.upsertRelationship({
+      ...rel,
+      companionId,
+    });
+  }
+
+  async getExemplars(companionId: string): Promise<SelfDialogueExample[]> {
+    return this.db.getExemplars(companionId);
+  }
+
+  async setExemplars(companionId: string, exemplars: SelfDialogueExample[]): Promise<void> {
+    this.db.setExemplars(companionId, exemplars);
+  }
+
+  close(): void {
+    if (this.ownsDb) {
+      this.db.close();
+    }
+  }
+}