pacs-core 0.1.0

package/src/inter-agent-bus.js

@@ -0,0 +1,187 @@
+/**
+ * PACS Core — Inter-Agent Bus Module
+ * Message passing between agents with encrypted persistence
+ */
+
+import crypto from './crypto.js';
+import memoryStore from './memory-store.js';
+
+const MESSAGES_FILE = 'messages.enc';
+
+/**
+ * Generate a short unique message ID.
+ * @returns {string}
+ */
+function generateMsgId() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 7);
+}
+
+/**
+ * Read messages store.
+ * @returns {object}
+ */
+function readMessagesStore() {
+  try {
+    return memoryStore.read(MESSAGES_FILE) || { messages: [], pendingRequests: {} };
+  } catch {
+    return { messages: [], pendingRequests: {} };
+  }
+}
+
+/**
+ * Write messages store.
+ * @param {object} store
+ */
+function writeMessagesStore(store) {
+  memoryStore.write(MESSAGES_FILE, store);
+}
+
+/**
+ * Send a message from one agent to another.
+ * @param {string} fromAgent - Sender name
+ * @param {string} toAgent - Recipient name (or '*' for broadcast)
+ * @param {string|object} message - Message content
+ * @returns {object} The stored message
+ */
+export function emit(fromAgent, toAgent, message) {
+  const store = readMessagesStore();
+  const msg = {
+    id: generateMsgId(),
+    from: fromAgent,
+    to: toAgent,
+    type: 'message',
+    payload: typeof message === 'string' ? message : JSON.stringify(message),
+    timestamp: new Date().toISOString(),
+  };
+  store.messages.push(msg);
+  writeMessagesStore(store);
+  return msg;
+}
+
+/**
+ * Broadcast a message to all agents.
+ * @param {string} fromAgent - Sender name
+ * @param {string|object} message - Message content
+ * @returns {object} The stored broadcast message
+ */
+export function broadcast(fromAgent, message) {
+  return emit(fromAgent, '*', message);
+}
+
+/**
+ * Send a request that expects a response.
+ * Returns a promise that resolves with the response.
+ * @param {string} fromAgent - Sender name
+ * @param {string} toAgent - Recipient name
+ * @param {string|object} question - Request payload
+ * @param {number} [timeoutMs=30000] - Timeout in milliseconds
+ * @returns {Promise<object>} Resolves to the response message
+ */
+export function request(fromAgent, toAgent, question, timeoutMs = 30000) {
+  return new Promise((resolve, reject) => {
+    const store = readMessagesStore();
+    const requestId = generateMsgId();
+
+    const msg = {
+      id: requestId,
+      from: fromAgent,
+      to: toAgent,
+      type: 'request',
+      payload: typeof question === 'string' ? question : JSON.stringify(question),
+      timestamp: new Date().toISOString(),
+    };
+
+    // Track pending request
+    store.pendingRequests[requestId] = { resolve, reject, expires: Date.now() + timeoutMs };
+    store.messages.push(msg);
+    writeMessagesStore(store);
+
+    // Timeout
+    setTimeout(() => {
+      const s = readMessagesStore();
+      if (s.pendingRequests[requestId]) {
+        delete s.pendingRequests[requestId];
+        writeMessagesStore(s);
+        reject(new Error(`Request timeout after ${timeoutMs}ms`));
+      }
+    }, timeoutMs);
+  });
+}
+
+/**
+ * Respond to a request.
+ * @param {string} requestId - Original request ID
+ * @param {string} fromAgent - Responder name
+ * @param {string|object} response - Response payload
+ * @returns {object|null} The response message or null if request not found
+ */
+export function respond(requestId, fromAgent, response) {
+  const store = readMessagesStore();
+
+  if (!store.pendingRequests[requestId]) {
+    return null;
+  }
+
+  const msg = {
+    id: generateMsgId(),
+    from: fromAgent,
+    to: store.messages.find((m) => m.id === requestId)?.from || 'unknown',
+    type: 'response',
+    inReplyTo: requestId,
+    payload: typeof response === 'string' ? response : JSON.stringify(response),
+    timestamp: new Date().toISOString(),
+  };
+
+  store.messages.push(msg);
+
+  const pending = store.pendingRequests[requestId];
+  pending.resolve(msg);
+  delete store.pendingRequests[requestId];
+  writeMessagesStore(store);
+
+  return msg;
+}
+
+/**
+ * Get messages for a specific agent.
+ * @param {string} agentName
+ * @param {object} [options] - { since, type, limit }
+ * @returns {object[]}
+ */
+export function getMessages(agentName, options = {}) {
+  const store = readMessagesStore();
+  let msgs = store.messages.filter(
+    (m) => m.to === agentName || m.to === '*' || m.from === agentName
+  );
+
+  if (options.since) {
+    msgs = msgs.filter((m) => new Date(m.timestamp) >= new Date(options.since));
+  }
+  if (options.type) {
+    msgs = msgs.filter((m) => m.type === options.type);
+  }
+  if (options.limit) {
+    msgs = msgs.slice(-options.limit);
+  }
+
+  return msgs;
+}
+
+/**
+ * Clear old messages (keep last N messages per agent pair).
+ * @param {number} [keepLast=1000]
+ */
+export function pruneMessages(keepLast = 1000) {
+  const store = readMessagesStore();
+  store.messages = store.messages.slice(-keepLast);
+  writeMessagesStore(store);
+}
+
+export default {
+  emit,
+  broadcast,
+  request,
+  respond,
+  getMessages,
+  pruneMessages,
+};

package/src/learn-mode.js

@@ -0,0 +1,97 @@
+/**
+ * PACS Core — Learn Mode Manager
+ * Manages the learn mode setting: "safe" | "explicit" | "auto"
+ * Settings stored in ~/.openclaw/pacs/settings.enc
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import crypto from './crypto.js';
+import memoryStore from './memory-store.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SETTINGS_FILE = 'settings.enc';
+const DEFAULT_MODE = 'safe';
+
+const VALID_MODES = ['safe', 'explicit', 'auto'];
+
+/**
+ * Get the settings file path.
+ * @returns {string}
+ */
+function getSettingsPath() {
+  return memoryStore.getFilePath(SETTINGS_FILE);
+}
+
+/**
+ * Read the settings file.
+ * @returns {object}
+ */
+function readSettings() {
+  const filePath = getSettingsPath();
+  if (!fs.existsSync(filePath)) {
+    return { learnMode: DEFAULT_MODE };
+  }
+  try {
+    const encrypted = fs.readFileSync(filePath, 'utf8');
+    const decrypted = crypto.decrypt(encrypted);
+    return JSON.parse(decrypted);
+  } catch {
+    return { learnMode: DEFAULT_MODE };
+  }
+}
+
+/**
+ * Write the settings file.
+ * @param {object} settings
+ */
+function writeSettings(settings) {
+  memoryStore.ensureStorageDir
+    ? memoryStore.ensureStorageDir()
+    : void 0;
+  const filePath = getSettingsPath();
+  const json = JSON.stringify(settings, null, 2);
+  const encrypted = crypto.encrypt(json);
+  fs.writeFileSync(filePath, encrypted, 'utf8');
+}
+
+/**
+ * Get the current learn mode.
+ * @returns {string} "safe" | "explicit" | "auto"
+ */
+export function getMode() {
+  const settings = readSettings();
+  return VALID_MODES.includes(settings.learnMode) ? settings.learnMode : DEFAULT_MODE;
+}
+
+/**
+ * Set the learn mode.
+ * @param {string} mode - "safe" | "explicit" | "auto"
+ * @returns {string} The mode that was set
+ */
+export function setMode(mode) {
+  if (!VALID_MODES.includes(mode)) {
+    throw new Error(`Invalid learn mode: ${mode}. Must be one of: ${VALID_MODES.join(', ')}`);
+  }
+  const settings = readSettings();
+  settings.learnMode = mode;
+  writeSettings(settings);
+  return mode;
+}
+
+/**
+ * Get a human-readable description of the current mode.
+ * @returns {string}
+ */
+export function getModeDescription() {
+  const mode = getMode();
+  const descriptions = {
+    safe: 'AI asks before storing anything ("Soll ich mir das merken?")',
+    explicit: 'AI only learns when explicitly commanded via MERKE:/LEARN:',
+    auto: 'AI auto-confirms after storing and reminds you what was learned',
+  };
+  return descriptions[mode] || descriptions.safe;
+}
+
+export default { getMode, setMode, getModeDescription };

package/src/learning-loop.js

@@ -0,0 +1,254 @@
+/**
+ * PACS Core — Learning Loop
+ * Handles SAFE learning mode: "Soll ich mir das merken?"
+ * Supports: "safe" (ask), "explicit" (only on command), "auto" (confirm after)
+ * Detection uses trigger-parser patterns + LLM inference patterns
+ */
+
+import triggerParser from './trigger-parser.js';
+import memoryStore from './memory-store.js';
+import learnMode from './learn-mode.js';
+
+// Triggers that signal something worth remembering
+const REMEMBER_TRIGGERS = [
+  /ich\s+(?:heiße|heiße|bin\s+[^.]+)|my\s+name\s+is/i,
+  /ich\s+(?:wohne|live|lebe|in)/i,
+  /ich\s+(?:arbeite|arbeite\s+bei|work\s+(?:at|for|as))/i,
+  /ich\s+(?:mag|like|preferiere|favorisiere)/i,
+  /ich\s+(?:hasse|dislike)/i,
+  /ich\s+(?:bin|am|im).*(?:gerade|currently|now)/i,
+  /^\s*(?:bisher|so\s+far|erfahrung|experience).*:?\s*/i,
+  /^\s*(?:präferenz|preference|favorite|liebling)/i,
+  /^\s*(?:wunsch|wish|want|would\s+like)/i,
+  /^\s*(?:merke|note|notiz|remember).*:?\s*/i,
+  /^\s*(?:info|information|fyi)/i,
+  /^\s*(?:das\s+ist|that\s+is|this\s+is).*(?:mein|my|mine)/i,
+  /^\s*(?:über\s+mich|about\s+me|about\s+me)/i,
+  /^\s*(?:hintergrund|background|context)/i,
+];
+
+// Patterns that indicate explicit forget request
+const FORGET_TRIGGERS = [
+  /^(?:vergiss|forget|lösche|delete|entferne).*:?\s*/i,
+  /^(?:nicht\s+(?:merken|erinnern)|don't\s+remember)/i,
+];
+
+// Patterns that suppress learning (noise, not facts)
+const NOISE_PATTERNS = [
+  /^(?:thanks?|danke|ok|okay|ja|yes|no|nein|yep|nope)\s*$/i,
+  /^(?:hi|hello|hey|greetings|hallo)\s*$/i,
+  /^(?:bye|goodbye|ttafn|see\s+you)\s*$/i,
+  /^(?:how\s+are\s+you|wie\s+geht)/i,
+  /^(?:what(?:'s|\s+is)\s+up|was\s+geht)/i,
+];
+
+// Question patterns — generally don't learn from questions
+const QUESTION_PATTERNS = [
+  /^\s*(?:was|wie|wer|wo|warum|weshalb|welche|r)/i,
+  /^\s*(?:what|how|who|where|why|which|when)/i,
+  /^\s*(?:can|could|would|should|will|is|are|do|does)\s+/i,
+  /[?!]\s*$/,
+];
+
+/**
+ * Check if a message is likely noise (not a fact worth learning).
+ * @param {string} message
+ * @returns {boolean}
+ */
+function isNoise(message) {
+  if (!message || typeof message !== 'string') return true;
+  const trimmed = message.trim();
+  if (trimmed.length < 3) return true;
+  return NOISE_PATTERNS.some((p) => p.test(trimmed));
+}
+
+/**
+ * Check if a message is a question (typically not learnable).
+ * @param {string} message
+ * @returns {boolean}
+ */
+function isQuestion(message) {
+  if (!message || typeof message !== 'string') return false;
+  return QUESTION_PATTERNS.some((p) => p.test(message.trim()));
+}
+
+/**
+ * Detect if a message is an explicit forget request.
+ * @param {string} message
+ * @returns {boolean}
+ */
+function isForgetRequest(message) {
+  if (!message || typeof message !== 'string') return false;
+  return FORGET_TRIGGERS.some((p) => p.test(message.trim()));
+}
+
+/**
+ * Detect if a message looks like a personal fact statement.
+ * Uses regex triggers and heuristics.
+ * @param {string} message
+ * @returns {boolean}
+ */
+function looksLikeFact(message) {
+  if (!message || typeof message !== 'string') return false;
+  const trimmed = message.trim();
+  if (isNoise(trimmed)) return false;
+  if (isQuestion(trimmed)) return false;
+  if (isForgetRequest(trimmed)) return false;
+  // Check trigger patterns
+  for (const pattern of REMEMBER_TRIGGERS) {
+    if (pattern.test(trimmed)) return true;
+  }
+  // Heuristic: first-person statement longer than 5 words
+  if (/^(?:ich|i|mein|my)\s+\S+\s+\S+/i.test(trimmed) && trimmed.split(/\s+/).length > 4) {
+    return true;
+  }
+  // Statements about preferences, facts, experiences
+  if (/\b(?:präferenz|prefer|preference|favorite|liebling|erfahrung|experience|intergrund|background)\b/i.test(trimmed)) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Detect the language of a message (simple heuristic).
+ * @param {string} message
+ * @returns {'DE'|'EN'} Language code
+ */
+function detectLanguage(message) {
+  if (!message || typeof message !== 'string') return 'EN';
+  const germanChars = /[äöüßÄÖÜ]/g;
+  const deMatches = message.match(germanChars);
+  if (deMatches && deMatches.length > 0) return 'DE';
+  // Check common German words
+  const germanWords = /\b(ich|du|der|die|das|und|ist|nicht|ein|eine|zu|mit|auf|für|von|werde|habe|hat|sein|aus|bei|nach|mit|auch|es|an|als|noch|so|dann|wenn|nur|kann|sein)\b/gi;
+  const deCount = (message.match(germanWords) || []).length;
+  if (deCount > 2) return 'DE';
+  return 'EN';
+}
+
+/**
+ * Determine if a user message should trigger the learning loop.
+ * @param {string} userMessage - The raw user message
+ * @returns {{should: boolean, reason: string, fact: string|null}}
+ */
+export function shouldRemember(userMessage) {
+  if (!userMessage || typeof userMessage !== 'string') {
+    return { should: false, reason: 'empty', fact: null };
+  }
+
+  // Check for explicit trigger commands first (MERKE, LEARN etc.)
+  const parsed = triggerParser.parse(userMessage);
+  if (parsed && parsed.trigger && parsed.trigger.id === 'MERKE') {
+    // Explicit learn command — always learn the payload
+    return {
+      should: true,
+      reason: 'explicit-trigger',
+      fact: parsed.payload,
+    };
+  }
+
+  // Check for forget request
+  if (isForgetRequest(userMessage)) {
+    return { should: false, reason: 'forget-request', fact: null };
+  }
+
+  // Check learn mode
+  const mode = learnMode.getMode();
+
+  // In explicit mode, only explicit triggers are allowed
+  if (mode === 'explicit') {
+    return { should: false, reason: 'explicit-mode', fact: null };
+  }
+
+  // In safe mode, detect facts and ask
+  if (mode === 'safe') {
+    if (looksLikeFact(userMessage)) {
+      return {
+        should: true,
+        reason: 'safe-detect',
+        fact: userMessage.trim(),
+      };
+    }
+    return { should: false, reason: 'not-a-fact', fact: null };
+  }
+
+  // In auto mode, detect facts and auto-store with confirmation
+  if (mode === 'auto') {
+    if (looksLikeFact(userMessage)) {
+      return {
+        should: true,
+        reason: 'auto-detect',
+        fact: userMessage.trim(),
+      };
+    }
+    return { should: false, reason: 'not-a-fact', fact: null };
+  }
+
+  return { should: false, reason: 'unknown-mode', fact: null };
+}
+
+/**
+ * Generate the confirmation prompt in the user's language.
+ * @param {string} fact - The fact to confirm
+ * @param {string} [lang] - Force language ('DE' | 'EN')
+ * @returns {string} The confirmation question
+ */
+export function promptConfirmation(fact, lang) {
+  const language = lang || detectLanguage(fact);
+
+  if (language === 'DE') {
+    return `Soll ich mir das merken? "${fact}"`;
+  }
+
+  return `Should I remember this? "${fact}"`;
+}
+
+/**
+ * Store a confirmed fact to encrypted memory.
+ * @param {string} userId - User identifier
+ * @param {string} fact - The confirmed fact
+ * @returns {object} Updated memory
+ */
+export function storeConfirmed(userId, fact) {
+  if (!fact || typeof fact !== 'string') {
+    throw new Error('Fact is required for storage');
+  }
+  return memoryStore.addFact(fact.trim(), false);
+}
+
+/**
+ * Mark a fact as rejected/ignored (never ask about it again).
+ * @param {string} userId - User identifier
+ * @param {string} fact - The rejected fact
+ * @returns {object} Updated memory (rejected list)
+ */
+export function rejectLearning(userId, fact) {
+  if (!fact || typeof fact !== 'string') {
+    throw new Error('Fact is required');
+  }
+
+  // Store in a special rejected facts list within memory
+  const memory = memoryStore.readMemory();
+  if (!memory.rejectedFacts) {
+    memory.rejectedFacts = [];
+  }
+  const trimmed = fact.trim();
+  if (!memory.rejectedFacts.includes(trimmed)) {
+    memory.rejectedFacts.push(trimmed);
+  }
+  memoryStore.writeMemory(memory);
+  return memory;
+}
+
+/**
+ * Check if a fact was previously rejected.
+ * @param {string} fact
+ * @returns {boolean}
+ */
+export function wasRejected(fact) {
+  if (!fact) return false;
+  const memory = memoryStore.readMemory();
+  return (memory.rejectedFacts || []).includes(fact.trim());
+}
+
+export default { shouldRemember, promptConfirmation, storeConfirmed, rejectLearning, wasRejected };