@sidurijs/self 1.0.0

package/dist/safety-scanner.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SAFETY_PATTERNS = void 0;
+exports.normalizeText = normalizeText;
+exports.scanDirective = scanDirective;
+// ── 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 = {
+    '0': 'o', '1': 'i', '3': 'e', '4': 'a', '5': 's',
+    '7': 't', '@': 'a', '$': 's', '!': 'i',
+};
+const CONFUSABLE_MAP = {
+    '\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',
+};
+function normalizeText(input) {
+    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' },
+];
+exports.DEFAULT_SAFETY_PATTERNS = {
+    overridePattern: OVERRIDE_PATTERN,
+    negationPattern: NEGATION_PATTERN,
+    disclosurePattern: DISCLOSURE_PATTERN,
+    escalationPhrases: ESCALATION_PHRASES,
+    approvalTampering: APPROVAL_TAMPERING,
+    safetyDisable: SAFETY_DISABLE,
+    structuralHeuristics: STRUCTURAL_HEURISTICS,
+};
+function scanDirective(raw, patterns = exports.DEFAULT_SAFETY_PATTERNS) {
+    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/dist/self-parser.d.ts

@@ -0,0 +1,9 @@
+import { SelfPackageParseResult } from './types';
+/**
+ * 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 declare function parseYamlOrJson(content: string): any;
+export declare class SelfPackageParser {
+    static parse(rawContent: string): SelfPackageParseResult;
+}

package/dist/self-parser.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelfPackageParser = void 0;
+exports.parseYamlOrJson = parseYamlOrJson;
+const safety_scanner_1 = require("./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 '{'.
+ */
+function parseYamlOrJson(content) {
+    const trimmed = content.trim();
+    if (trimmed.startsWith('{')) {
+        return JSON.parse(trimmed);
+    }
+    const lines = content.split('\n');
+    const root = {};
+    const stack = [
+        { 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;
+            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 = {};
+                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 = {};
+                targetObj[key] = childObj;
+                stack.push({ indent, obj: childObj, key, isList: false });
+            }
+            else {
+                targetObj[key] = parsePrimitive(valStr);
+            }
+        }
+    }
+    return root;
+}
+function parsePrimitive(val) {
+    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;
+}
+class SelfPackageParser {
+    static parse(rawContent) {
+        const errors = [];
+        let data;
+        try {
+            data = parseYamlOrJson(rawContent);
+        }
+        catch (err) {
+            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;
+        if (p !== undefined && p !== null) {
+            if (typeof p !== 'object') {
+                errors.push('Field "personality" must be an object if provided');
+            }
+            else {
+                traits = {};
+                const keys = ['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) => r && typeof r === 'object' && r.entityId)
+                .map((r) => ({
+                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) => ex && typeof ex === 'object' && ex.user && ex.assistant)
+                .map((ex) => ({
+                user: String(ex.user),
+                assistant: String(ex.assistant),
+            }))
+            : undefined;
+        // 7. Directives validation & scanning
+        const scannedDirectives = [];
+        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 = (0, safety_scanner_1.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;
+        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,
+        };
+    }
+}
+exports.SelfPackageParser = SelfPackageParser;

package/dist/self-repository.d.ts

@@ -0,0 +1,29 @@
+import { SiduriDatabase, SelfIdentity, PersonalityTraits, SelfDirective, SelfRelationship, SelfDialogueExample } from '@sidurijs/core';
+import { SelfRepository } from './types';
+export interface SqliteSelfRepositoryOptions {
+    db?: SiduriDatabase;
+    dbPath?: string;
+}
+export declare const DEFAULT_PERSONALITY_TRAITS: PersonalityTraits;
+export declare class SqliteSelfRepository implements SelfRepository {
+    private db;
+    private ownsDb;
+    constructor(options?: SqliteSelfRepositoryOptions);
+    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>;
+    approveDirective(id: string, companionId?: string): Promise<void>;
+    rejectDirective(id: string, companionId?: string): Promise<void>;
+    revokeDirective(id: string, companionId?: string): Promise<void>;
+    expireDirective(id: string, companionId?: string): Promise<void>;
+    disableDirective(id: string, companionId?: string): Promise<void>;
+    getRelationships(companionId: string): Promise<SelfRelationship[]>;
+    getRelationship(companionId: string, entityId: string): Promise<SelfRelationship | null>;
+    updateRelationship(companionId: string, rel: SelfRelationship): Promise<void>;
+    getExemplars(companionId: string): Promise<SelfDialogueExample[]>;
+    setExemplars(companionId: string, exemplars: SelfDialogueExample[]): Promise<void>;
+    close(): void;
+}

package/dist/self-repository.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteSelfRepository = exports.DEFAULT_PERSONALITY_TRAITS = void 0;
+const core_1 = require("@sidurijs/core");
+exports.DEFAULT_PERSONALITY_TRAITS = {
+    warmth: 0.5,
+    formality: 0.5,
+    sarcasm: 0.5,
+    verbosity: 0.5,
+    curiosity: 0.5,
+};
+class SqliteSelfRepository {
+    db;
+    ownsDb;
+    constructor(options = {}) {
+        if (options.db) {
+            this.db = options.db;
+            this.ownsDb = false;
+        }
+        else {
+            this.db = new core_1.SiduriDatabase({ dbPath: options.dbPath });
+            this.ownsDb = true;
+        }
+    }
+    async getIdentity(companionId) {
+        return this.db.getIdentity(companionId);
+    }
+    async setIdentity(identity) {
+        this.db.setIdentity(identity);
+    }
+    async getPersonality(companionId) {
+        const traits = this.db.getPersonality(companionId);
+        return traits || { ...exports.DEFAULT_PERSONALITY_TRAITS };
+    }
+    async setPersonality(companionId, traits) {
+        this.db.setPersonality(companionId, traits);
+    }
+    async getActiveDirectives(companionId) {
+        return this.db.getActiveDirectives(companionId);
+    }
+    async commitDirectives(companionId, directives) {
+        for (const d of directives) {
+            this.db.commitDirective({
+                ...d,
+                companionId,
+            });
+        }
+    }
+    async approveDirective(id, companionId) {
+        this.db.approveDirective(id, companionId);
+    }
+    async rejectDirective(id, companionId) {
+        this.db.rejectDirective(id, companionId);
+    }
+    async revokeDirective(id, companionId) {
+        this.db.revokeDirective(id, companionId);
+    }
+    async expireDirective(id, companionId) {
+        this.db.expireDirective(id, companionId);
+    }
+    async disableDirective(id, companionId) {
+        this.db.disableDirective(id, companionId);
+    }
+    async getRelationships(companionId) {
+        return this.db.getRelationships(companionId);
+    }
+    async getRelationship(companionId, entityId) {
+        const rel = this.db.getRelationship(companionId, entityId);
+        return rel ?? null;
+    }
+    async updateRelationship(companionId, rel) {
+        this.db.upsertRelationship({
+            ...rel,
+            companionId,
+        });
+    }
+    async getExemplars(companionId) {
+        return this.db.getExemplars(companionId);
+    }
+    async setExemplars(companionId, exemplars) {
+        this.db.setExemplars(companionId, exemplars);
+    }
+    close() {
+        if (this.ownsDb) {
+            this.db.close();
+        }
+    }
+}
+exports.SqliteSelfRepository = SqliteSelfRepository;

package/dist/self.test.d.ts

@@ -0,0 +1 @@
+export {};