create-principles-disciple 1.0.0 → 1.74.0

package/plugin/dist/core/detection-funnel.js

@@ -0,0 +1,104 @@
+import { createHash } from 'crypto';
+import { shouldIgnorePainProtocolText } from './dictionary.js';
+/**
+ * A simple LRU Cache implementation using Map.
+ */
+class SimpleLRU {
+    cache;
+    maxSize;
+    constructor(maxSize = 100) {
+        this.cache = new Map();
+        this.maxSize = maxSize;
+    }
+    get(key) {
+        const item = this.cache.get(key);
+        if (item !== undefined) {
+            // Refresh: delete and re-insert
+            this.cache.delete(key);
+            this.cache.set(key, item);
+        }
+        return item;
+    }
+    set(key, value) {
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        else if (this.cache.size >= this.maxSize) {
+            // Remove the oldest (first) item
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey !== undefined) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(key, value);
+    }
+}
+/**
+ * Orchestrates the three-layer detection funnel for pain signals.
+ */
+export class DetectionFunnel {
+    cache = new SimpleLRU(100);
+    asyncQueue = [];
+    dictionary;
+    constructor(dictionary) {
+        this.dictionary = dictionary;
+    }
+    /**
+     * Detects pain in the given text using L1 (Exact), L2 (Cache), and L3 (Async).
+     */
+    detect(text) {
+        if (shouldIgnorePainProtocolText(text)) {
+            return { detected: false, source: 'l1_exact' };
+        }
+        // --- Layer 1: Exact Match (Sync) ---
+        const exactMatch = this.dictionary.match(text);
+        if (exactMatch) {
+            return {
+                detected: true,
+                severity: exactMatch.severity,
+                ruleId: exactMatch.ruleId,
+                source: 'l1_exact'
+            };
+        }
+        // --- Layer 2: LRU Cache (Sync) ---
+        const hash = DetectionFunnel.computeHash(text);
+        const cached = this.cache.get(hash);
+        if (cached) {
+            return {
+                detected: cached.detected,
+                severity: cached.severity,
+                source: 'l2_cache'
+            };
+        }
+        // --- Layer 3: Async Semantic Queue ---
+        this.enqueueAsync(text);
+        return {
+            detected: false,
+            source: 'l3_async_queued'
+        };
+    }
+    static computeHash(text) {
+        return createHash('sha256').update(text).digest('hex');
+    }
+    enqueueAsync(text) {
+        if (this.asyncQueue.length < 1000) {
+            this.asyncQueue.push(text);
+        }
+        // Worker will pick this up and perform semantic search via createMemorySearchTool
+    }
+    /**
+     * Internal method for the worker to update the cache after a semantic hit.
+     */
+    updateCache(text, result) {
+        const hash = DetectionFunnel.computeHash(text);
+        this.cache.set(hash, result);
+    }
+    /**
+     * Retrieves and clears the current asynchronous queue.
+     */
+    flushQueue() {
+        const queue = [...this.asyncQueue];
+        this.asyncQueue = [];
+        return queue;
+    }
+}

package/plugin/dist/core/detection-service.d.ts

@@ -0,0 +1,15 @@
+import { DetectionFunnel } from './detection-funnel.js';
+/**
+ * Singleton service to manage the Semantic Detection Funnel.
+ */
+export declare const DetectionService: {
+    /**
+     * Gets or initializes the Detection Funnel instance.
+     * @param stateDir The directory used to initialize the dictionary.
+     */
+    get(stateDir: string): DetectionFunnel;
+    /**
+     * Resets the singleton instance (primarily for testing).
+     */
+    reset(): void;
+};

package/plugin/dist/core/detection-service.js

@@ -0,0 +1,28 @@
+import { DetectionFunnel } from './detection-funnel.js';
+import { DictionaryService } from './dictionary-service.js';
+let instance = null;
+let lastStateDir = null;
+/**
+ * Singleton service to manage the Semantic Detection Funnel.
+ */
+export const DetectionService = {
+    /**
+     * Gets or initializes the Detection Funnel instance.
+     * @param stateDir The directory used to initialize the dictionary.
+     */
+    get(stateDir) {
+        if (!instance || lastStateDir !== stateDir) {
+            const dictionary = DictionaryService.get(stateDir);
+            instance = new DetectionFunnel(dictionary);
+            lastStateDir = stateDir;
+        }
+        return instance;
+    },
+    /**
+     * Resets the singleton instance (primarily for testing).
+     */
+    reset() {
+        instance = null;
+        lastStateDir = null;
+    }
+};

package/plugin/dist/core/dictionary-service.d.ts

@@ -0,0 +1,15 @@
+import { PainDictionary } from './dictionary.js';
+/**
+ * Singleton service to manage the Pain Dictionary.
+ */
+export declare const DictionaryService: {
+    /**
+     * Gets or initializes the Pain Dictionary instance.
+     * @param stateDir The directory where the dictionary JSON is stored.
+     */
+    get(stateDir: string): PainDictionary;
+    /**
+     * Resets the singleton instance (primarily for testing).
+     */
+    reset(): void;
+};

package/plugin/dist/core/dictionary-service.js

@@ -0,0 +1,26 @@
+import { PainDictionary } from './dictionary.js';
+let dictionary = null;
+let lastStateDir = null;
+/**
+ * Singleton service to manage the Pain Dictionary.
+ */
+export const DictionaryService = {
+    /**
+     * Gets or initializes the Pain Dictionary instance.
+     * @param stateDir The directory where the dictionary JSON is stored.
+     */
+    get(stateDir) {
+        if (!dictionary || lastStateDir !== stateDir) {
+            dictionary = new PainDictionary(stateDir);
+            dictionary.load();
+            lastStateDir = stateDir;
+        }
+        return dictionary;
+    },
+    /**
+     * Resets the singleton instance (primarily for testing).
+     */
+    reset() {
+        dictionary = null;
+    }
+};

package/plugin/dist/core/dictionary.d.ts

@@ -0,0 +1,38 @@
+export type RuleType = 'regex' | 'exact_match';
+export interface PainRule {
+    type: RuleType;
+    pattern?: string;
+    phrases?: string[];
+    severity: number;
+    hits: number;
+    status: 'active' | 'dormant' | 'archived';
+}
+export interface PainDictionaryData {
+    rules: Record<string, PainRule>;
+}
+export declare const PAIN_PROTOCOL_TOKENS: readonly ["[EVOLUTION_ACK]", "HEARTBEAT_OK", "HEARTBEAT_CHECK"];
+export declare function shouldIgnorePainProtocolText(text: string): boolean;
+export declare class PainDictionary {
+    private readonly stateDir;
+    private data;
+    private readonly store;
+    private readonly compiledRegex;
+    constructor(stateDir: string);
+    load(): void;
+    private compile;
+    getRule(id: string): PainRule | undefined;
+    getAllRules(): Record<string, PainRule>;
+    /**
+     * Adds a new rule or updates an existing one.
+     */
+    addRule(id: string, rule: Omit<PainRule, 'hits'>): void;
+    match(text: string): {
+        ruleId: string;
+        severity: number;
+    } | undefined;
+    flush(): void;
+    getStats(): {
+        totalRules: number;
+        totalHits: number;
+    };
+}

package/plugin/dist/core/dictionary.js

@@ -0,0 +1,148 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { JsonFileStore } from './file-store.js';
+export const PAIN_PROTOCOL_TOKENS = [
+    '[EVOLUTION_ACK]',
+    'HEARTBEAT_OK',
+    'HEARTBEAT_CHECK',
+];
+export function shouldIgnorePainProtocolText(text) {
+    const normalized = text.trim();
+    if (!normalized)
+        return false;
+    return PAIN_PROTOCOL_TOKENS.some((token) => normalized === token || normalized.startsWith(`${token} `) || normalized.includes(token));
+}
+const DEFAULT_RULES = {
+    'P_CONFUSION_ZH': {
+        type: 'regex',
+        pattern: '我(似乎|好像)(不确定|不太确定|不清楚|困惑)',
+        severity: 35,
+        hits: 0,
+        status: 'active'
+    },
+    'P_CONFUSION_EN': {
+        type: 'regex',
+        pattern: 'i am (not sure|unsure|confused|uncertain|struggling to)',
+        severity: 35,
+        hits: 0,
+        status: 'active'
+    },
+    'P_LOOP_ZH': {
+        type: 'regex',
+        pattern: '似乎(陷入了?循环|回到了?原点|原地打转)',
+        severity: 45,
+        hits: 0,
+        status: 'active'
+    },
+    'P_LOOP_EN': {
+        type: 'exact_match',
+        phrases: ['going in circles', 'back to square one', 'looping'],
+        severity: 45,
+        hits: 0,
+        status: 'active'
+    }
+};
+export class PainDictionary {
+    stateDir;
+    data = { rules: {} };
+    store;
+    compiledRegex = new Map();
+    constructor(stateDir) {
+        this.stateDir = stateDir;
+        const filePath = path.join(stateDir, 'pain_dictionary.json');
+        this.store = new JsonFileStore(filePath, () => ({ rules: { ...DEFAULT_RULES } }));
+    }
+    load() {
+        const filePath = path.join(this.stateDir, 'pain_dictionary.json');
+        const fileExisted = fs.existsSync(filePath);
+        const loaded = this.store.load();
+        // Check if we got real data (has at least one rule from file) or just defaults
+        const hasRules = loaded.rules && Object.keys(loaded.rules).length > 0;
+        if (hasRules) {
+            this.data = loaded;
+        }
+        else {
+            this.data = { rules: { ...DEFAULT_RULES } };
+            // Only overwrite if file didn't previously exist — preserve corrupt files
+            if (!fileExisted) {
+                console.log(`[PD:Dictionary] Dictionary not found, creating with default rules`);
+                this.flush();
+            }
+            else {
+                console.warn(`[PD:Dictionary] Dictionary corrupt or empty, preserving file and using defaults`);
+            }
+        }
+        this.compile();
+    }
+    compile() {
+        this.compiledRegex.clear();
+        for (const [id, rule] of Object.entries(this.data.rules)) {
+            if (rule.type === 'regex' && rule.pattern) {
+                this.compiledRegex.set(id, new RegExp(rule.pattern, 'i'));
+            }
+        }
+    }
+    getRule(id) {
+        return this.data.rules[id];
+    }
+    getAllRules() {
+        return this.data.rules;
+    }
+    /**
+     * Adds a new rule or updates an existing one.
+     */
+    addRule(id, rule) {
+        this.data.rules[id] = {
+            ...rule,
+            hits: this.data.rules[id]?.hits || 0
+        };
+        // Re-compile if it's a regex rule
+        if (rule.type === 'regex' && rule.pattern) {
+            this.compiledRegex.set(id, new RegExp(rule.pattern, 'i'));
+        }
+    }
+    match(text) {
+        if (shouldIgnorePainProtocolText(text))
+            return undefined;
+        let bestMatch = undefined;
+        for (const [id, rule] of Object.entries(this.data.rules)) {
+            if (rule.status !== 'active')
+                continue;
+            let matched = false;
+            if (rule.type === 'regex') {
+                const re = this.compiledRegex.get(id);
+                if (re) {
+                    re.lastIndex = 0;
+                    if (re.test(text))
+                        matched = true;
+                }
+            }
+            else if (rule.type === 'exact_match' && rule.phrases) {
+                const lowerText = text.toLowerCase();
+                if (rule.phrases.some(p => lowerText.includes(p.toLowerCase()))) {
+                    matched = true;
+                }
+            }
+            if (matched) {
+                rule.hits++;
+                if (!bestMatch || rule.severity > bestMatch.severity) {
+                    bestMatch = { ruleId: id, severity: rule.severity };
+                }
+            }
+        }
+        return bestMatch;
+    }
+    flush() {
+        this.store.save(this.data);
+    }
+    getStats() {
+        let totalHits = 0;
+        for (const rule of Object.values(this.data.rules)) {
+            totalHits += rule.hits || 0;
+        }
+        return {
+            totalRules: Object.keys(this.data.rules).length,
+            totalHits
+        };
+    }
+}

package/plugin/dist/core/empathy-keyword-matcher.d.ts

@@ -0,0 +1,5 @@
+import type { EmpathyKeywordStore } from '@principles/core/prompt-builder';
+export { matchEmpathyKeywords, createDefaultKeywordStore, applyKeywordUpdates, shouldTriggerOptimization, getKeywordStoreSummary, } from '@principles/core/prompt-builder';
+export type { EmpathyKeywordStore, EmpathyKeywordEntry, EmpathyKeywordStats, EmpathyMatchResult, EmpathyKeywordConfig, } from '@principles/core/prompt-builder';
+export declare function loadKeywordStore(stateDir: string, language?: 'zh' | 'en'): EmpathyKeywordStore;
+export declare function saveKeywordStore(stateDir: string, store: EmpathyKeywordStore): void;

package/plugin/dist/core/empathy-keyword-matcher.js

@@ -0,0 +1,40 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { atomicWriteFileSync } from '../utils/io.js';
+import { createDefaultKeywordStore } from '@principles/core/prompt-builder';
+export { matchEmpathyKeywords, createDefaultKeywordStore, applyKeywordUpdates, shouldTriggerOptimization, getKeywordStoreSummary, } from '@principles/core/prompt-builder';
+const KEYWORD_STORE_FILE = 'empathy_keywords.json';
+export function loadKeywordStore(stateDir, language) {
+    const filePath = path.join(stateDir, KEYWORD_STORE_FILE);
+    try {
+        if (!fs.existsSync(filePath)) {
+            const store = createDefaultKeywordStore(language);
+            saveKeywordStore(stateDir, store);
+            return store;
+        }
+        const raw = fs.readFileSync(filePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed.terms || !parsed.stats || !parsed.version) {
+            console.warn('[PD:Empathy] Invalid keyword store format, creating default');
+            const store = createDefaultKeywordStore(language);
+            saveKeywordStore(stateDir, store);
+            return store;
+        }
+        return parsed;
+    }
+    catch (e) {
+        console.warn(`[PD:Empathy] Failed to load keyword store: ${e}`);
+        const store = createDefaultKeywordStore(language);
+        saveKeywordStore(stateDir, store);
+        return store;
+    }
+}
+export function saveKeywordStore(stateDir, store) {
+    const filePath = path.join(stateDir, KEYWORD_STORE_FILE);
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    store.lastUpdated = new Date().toISOString();
+    atomicWriteFileSync(filePath, JSON.stringify(store, null, 2));
+}

package/plugin/dist/core/empathy-types.d.ts

@@ -0,0 +1,2 @@
+export type { EmpathyKeywordStore, EmpathyKeywordEntry, EmpathyKeywordStats, EmpathyMatchResult, EmpathyKeywordUpdate, EmpathyOptimizationResult, SeedKeywordEntry, EmpathyKeywordConfig, } from '@principles/core/prompt-builder';
+export { EMPATHY_SEED_KEYWORDS, DEFAULT_EMPATHY_KEYWORD_CONFIG, scoreToSeverity, severityToPenalty, normalizeSeverity, } from '@principles/core/prompt-builder';

package/plugin/dist/core/empathy-types.js

@@ -0,0 +1 @@
+export { EMPATHY_SEED_KEYWORDS, DEFAULT_EMPATHY_KEYWORD_CONFIG, scoreToSeverity, severityToPenalty, normalizeSeverity, } from '@principles/core/prompt-builder';

package/plugin/dist/core/event-log.d.ts

@@ -0,0 +1,73 @@
+import type { EventLogEntry, DailyStats, EmpathyEventStats, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, DiagnosisTaskEventData, HeartbeatDiagnosisEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, RuntimeV2ConfirmFirstGateEventData } from '../types/event-types.js';
+import type { PluginLogger } from '../openclaw-sdk.js';
+export declare class EventLog {
+    private readonly logsDir;
+    private readonly statsFile;
+    private readonly logger?;
+    private readonly statsCache;
+    private eventBuffer;
+    private readonly maxBufferSize;
+    private readonly flushIntervalMs;
+    private flushTimer?;
+    private currentEventsFile;
+    private currentDate;
+    private readonly painScoreSums;
+    constructor(stateDir: string, logger?: PluginLogger);
+    private getEventsFile;
+    private getTodayStr;
+    private ensureEventsFile;
+    private cleanupOldEventFiles;
+    recordToolCall(sessionId: string | undefined, data: ToolCallEventData): void;
+    recordPainSignal(sessionId: string | undefined, data: PainSignalEventData): void;
+    recordRuleMatch(sessionId: string | undefined, data: RuleMatchEventData): void;
+    recordRulePromotion(data: RulePromotionEventData): void;
+    recordHookExecution(data: HookExecutionEventData, opts?: {
+        flushImmediately?: boolean;
+    }): void;
+    recordGateBlock(sessionId: string | undefined, data: GateBlockEventData): void;
+    recordGateBypass(sessionId: string | undefined, data: GateBypassEventData): void;
+    recordPlanApproval(sessionId: string | undefined, data: PlanApprovalEventData): void;
+    recordEvolutionTask(data: EvolutionTaskEventData): void;
+    recordEvolutionTaskCompleted(data: EvolutionTaskEventData): void;
+    recordEmpathyRollback(sessionId: string | undefined, data: EmpathyRollbackEventData): void;
+    recordError(sessionId: string | undefined, message: string, context?: Record<string, unknown>): void;
+    recordWarn(sessionId: string | undefined, message: string, context?: Record<string, unknown>): void;
+    recordDiagnosisTask(data: DiagnosisTaskEventData): void;
+    recordHeartbeatDiagnosis(data: HeartbeatDiagnosisEventData): void;
+    recordDiagnosticianReport(data: DiagnosticianReportEventData): void;
+    recordPrincipleCandidate(data: PrincipleCandidateEventData): void;
+    recordRuleEnforced(data: RuleEnforcedEventData): void;
+    recordRuleHostEvaluated(data: RuleHostEvaluatedEventData): void;
+    recordRuleHostBlocked(data: RuleHostBlockedEventData): void;
+    recordRuleHostRequireApproval(data: RuleHostRequireApprovalEventData): void;
+    recordRuleHostAutoCorrectProposed(data: RuleHostAutoCorrectProposedEventData): void;
+    recordRuleHostAutoCorrectApplied(data: RuleHostAutoCorrectAppliedEventData): void;
+    recordRuntimeV2ActivationsInjected(data: RuntimeV2PromptActivationsInjectedEventData): void;
+    recordConfirmFirstGateBlocked(data: RuntimeV2ConfirmFirstGateEventData): void;
+    recordConfirmFirstGateApproved(data: RuntimeV2ConfirmFirstGateEventData): void;
+    private record;
+    private formatDate;
+    private loadStats;
+    private updateStats;
+    private startFlushTimer;
+    flush(): void;
+    getBufferedEvents(): EventLogEntry[];
+    private getEventDedupKey;
+    private readPersistedEvents;
+    private getMergedEvents;
+    private flushEvents;
+    private flushStats;
+    getDailyStats(date: string): DailyStats;
+    getEmpathyStats(range: 'today' | 'week' | 'session', sessionId?: string): EmpathyEventStats;
+    private aggregateSessionEmpathy;
+    rollbackEmpathyEvent(eventId: string, sessionId: string | undefined, reason: string, triggeredBy: 'user_command' | 'natural_language' | 'system'): number;
+    getLastEmpathyEventId(sessionId: string): string | null;
+    findLatestPainSignal(sessionId: string | undefined): PainSignalEventData | null;
+    dispose(): void;
+}
+export declare class EventLogService {
+    private static readonly instances;
+    static get(stateDir: string, logger?: PluginLogger): EventLog;
+    static flushAll(): void;
+    static disposeAll(): void;
+}