pacs-core 0.1.0

package/src/memory-store.js

@@ -0,0 +1,226 @@
+/**
+ * PACS Core — Memory Store Module
+ * Encrypted read/write for memory.enc, routing.enc, core-rules.enc
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('./crypto');
+
+const STORAGE_DIR = path.join(process.env.HOME || process.env.USERPROFILE, '.openclaw', 'pacs');
+
+// Encrypted file names
+const FILES = {
+  MEMORY: 'memory.enc',
+  ROUTING: 'routing.enc',
+  CORE_RULES: 'core-rules.enc',
+};
+
+/**
+ * Ensure the PACS storage directory exists.
+ */
+function ensureStorageDir() {
+  if (!fs.existsSync(STORAGE_DIR)) {
+    fs.mkdirSync(STORAGE_DIR, { recursive: true });
+  }
+  return STORAGE_DIR;
+}
+
+/**
+ * Get the full path to a storage file.
+ * @param {string} filename - One of the FILES constants
+ * @returns {string} Full path
+ */
+function getFilePath(filename) {
+  return path.join(STORAGE_DIR, filename);
+}
+
+/**
+ * Read and decrypt a storage file.
+ * Returns null if file doesn't exist.
+ * @param {string} filename - Storage file name (from FILES constants)
+ * @returns {object|null} Parsed JSON or null
+ */
+function read(filename) {
+  const filePath = getFilePath(filename);
+
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  try {
+    const encrypted = fs.readFileSync(filePath, 'utf8');
+    const decrypted = crypto.decrypt(encrypted);
+    return JSON.parse(decrypted);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return null;
+    }
+    throw new Error(`Failed to read encrypted file ${filename}: ${err.message}`);
+  }
+}
+
+/**
+ * Encrypt and write data to a storage file.
+ * @param {string} filename - Storage file name
+ * @param {object} data - Data to encrypt and save (will be JSON-stringified)
+ */
+function write(filename, data) {
+  ensureStorageDir();
+  const filePath = getFilePath(filename);
+  const json = JSON.stringify(data, null, 2);
+  const encrypted = crypto.encrypt(json);
+  fs.writeFileSync(filePath, encrypted, 'utf8');
+}
+
+/**
+ * Read memory store.
+ * @returns {object} Memory object or empty structure
+ */
+function readMemory() {
+  return read(FILES.MEMORY) || { facts: [], private: [], learnedAt: {} };
+}
+
+/**
+ * Write memory store.
+ * @param {object} memory - Memory object
+ */
+function writeMemory(memory) {
+  write(FILES.MEMORY, memory);
+}
+
+/**
+ * Read routing store.
+ * @returns {object} Routing object or empty structure
+ */
+function readRouting() {
+  return read(FILES.ROUTING) || { hints: [], agents: [] };
+}
+
+/**
+ * Write routing store.
+ * @param {object} routing - Routing object
+ */
+function writeRouting(routing) {
+  write(FILES.ROUTING, routing);
+}
+
+/**
+ * Read core rules store.
+ * @returns {object} Core rules or empty structure
+ */
+function readCoreRules() {
+  return read(FILES.CORE_RULES) || { rules: [] };
+}
+
+/**
+ * Write core rules store.
+ * @param {object} rules - Core rules object
+ */
+function writeCoreRules(rules) {
+  write(FILES.CORE_RULES, rules);
+}
+
+/**
+ * Add a fact to memory.
+ * @param {string} fact - The fact to store
+ * @param {boolean} isPrivate - Whether to mark as private
+ * @returns {object} Updated memory
+ */
+function addFact(fact, isPrivate = false) {
+  const memory = readMemory();
+
+  // Avoid duplicates
+  if (!memory.facts.includes(fact)) {
+    memory.facts.push(fact);
+    memory.learnedAt[fact] = new Date().toISOString();
+    if (isPrivate) {
+      memory.private.push(fact);
+    }
+    writeMemory(memory);
+  }
+
+  return memory;
+}
+
+/**
+ * Remove a fact from memory.
+ * @param {string} fact - The fact to forget
+ * @returns {object} Updated memory
+ */
+function removeFact(fact) {
+  const memory = readMemory();
+
+  memory.facts = memory.facts.filter((f) => f !== fact);
+  delete memory.learnedAt[fact];
+  memory.private = memory.private.filter((f) => f !== fact);
+
+  writeMemory(memory);
+  return memory;
+}
+
+/**
+ * Search facts in memory (simple substring search).
+ * @param {string} query - Search query
+ * @returns {string[]} Matching facts
+ */
+function searchFacts(query) {
+  const memory = readMemory();
+  const q = query.toLowerCase();
+  return memory.facts.filter((f) => f.toLowerCase().includes(q));
+}
+
+/**
+ * Add a routing hint.
+ * @param {string} hint - Routing hint (e.g. "finance → finance-agent")
+ */
+function addRoutingHint(hint) {
+  const routing = readRouting();
+  if (!routing.hints.includes(hint)) {
+    routing.hints.push(hint);
+    writeRouting(routing);
+  }
+  return routing;
+}
+
+/**
+ * Add a core rule.
+ * @param {string} rule - Rule text
+ */
+function addRule(rule) {
+  const rules = readCoreRules();
+  if (!rules.rules.includes(rule)) {
+    rules.rules.push(rule);
+    writeCoreRules(rules);
+  }
+  return rules;
+}
+
+/**
+ * Get the storage directory path.
+ * @returns {string} Storage directory
+ */
+function getStorageDir() {
+  return STORAGE_DIR;
+}
+
+module.exports = {
+  FILES,
+  STORAGE_DIR,
+  ensureStorageDir,
+  getFilePath,
+  read,
+  write,
+  readMemory,
+  writeMemory,
+  readRouting,
+  writeRouting,
+  readCoreRules,
+  writeCoreRules,
+  addFact,
+  removeFact,
+  searchFacts,
+  addRoutingHint,
+  addRule,
+  getStorageDir,
+};

package/src/openclaw-bridge.cjs

@@ -0,0 +1,214 @@
+/**
+ * PACS Core — OpenClaw Bridge Module (CJS wrapper)
+ * Integrates PACS with the OpenClaw agent framework
+ *
+ * Modes:
+ *   - "standalone": PACS runs independently, OpenClaw is just the UI
+ *   - "integrated":  PACS and OpenClaw agents coexist, PACS gets first pick
+ */
+
+'use strict';
+
+const { containsTrigger, detectLearnMode } = require('./trigger-parser.js');
+const memoryStore = require('./memory-store.js');
+
+/** @type {object|null} */
+let _openClawConfig = null;
+
+/** @type {object|null} OpenClaw agent API (when available) */
+let _openClawAgents = null;
+
+/**
+ * PACS keywords / command prefixes that indicate a PACS query.
+ * @type {string[]}
+ */
+const PACS_TRIGGERS = ['MERKE', 'SUCHE', 'LERNE', 'AGENT', 'ROUTING', 'REGELN', 'MEMORY'];
+
+/**
+ * Detect whether a user message is a PACS command or a general OpenClaw task.
+ * @param {string} message
+ * @returns {boolean}
+ */
+function isPACSQuery(message) {
+  if (!message || typeof message !== 'string') return false;
+  const upper = message.trim().toUpperCase();
+  if (PACS_TRIGGERS.some((t) => upper.startsWith(t))) return true;
+  if (containsTrigger(message)) return true;
+  if (detectLearnMode(message)) return true;
+  return false;
+}
+
+/**
+ * Initialize PACS inside OpenClaw.
+ * @param {object} openClawConfig - { pacs: { enabled, mode } }
+ * @param {object} [openClawAgentApi] - Optional OpenClaw agent API for fallback
+ */
+function init(openClawConfig = {}, openClawAgentApi = null) {
+  _openClawConfig = openClawConfig;
+  _openClawAgents = openClawAgentApi;
+  const pacsConfig = openClawConfig.pacs || {};
+  const mode = pacsConfig.mode || 'integrated';
+  const enabled = pacsConfig.enabled !== false;
+  if (!enabled) {
+    console.warn('[PACS Bridge] PACS is disabled in config.');
+    return { ok: false, reason: 'disabled' };
+  }
+  console.log(`[PACS Bridge] Initialized in "${mode}" mode.`);
+  return { ok: true, mode };
+}
+
+/**
+ * Main entry — PACS processes the user message, routes to agents, returns response.
+ * @param {string} userMessage
+ * @returns {Promise<object>} { response, routedTo, fallback }
+ */
+async function query(userMessage) {
+  if (!isPACSQuery(userMessage)) {
+    return fallbackToOpenClawAgents(userMessage);
+  }
+
+  const mode = (_openClawConfig?.pacs?.mode) || 'integrated';
+
+  try {
+    const upper = userMessage.trim().toUpperCase();
+
+    // --- MERKE / learn a fact ---
+    if (upper.startsWith('MERKE') || upper.startsWith('LERNE')) {
+      const fact = userMessage
+        .replace(/^(MERKE|LERNE)\s*/i, '')
+        .trim();
+      if (fact) {
+        memoryStore.addFact(fact);
+        return { response: `✓ Merke: ${fact}`, routedTo: 'PACS-memory', fallback: false };
+      }
+    }
+
+    // --- SUCHE / search memory ---
+    if (upper.startsWith('SUCHE')) {
+      const q = userMessage.replace(/^(SUCHE|SUCH)\s*/i, '').trim();
+      const results = memoryStore.searchFacts(q);
+      if (results.length === 0) {
+        return { response: `Keine Ergebnisse für "${q}".`, routedTo: 'PACS-memory', fallback: false };
+      }
+      return {
+        response: `Gefunden:\n${results.map((r, i) => `${i + 1}. ${r}`).join('\n')}`,
+        routedTo: 'PACS-memory',
+        fallback: false,
+      };
+    }
+
+    // --- AGENT commands (basic) ---
+    if (upper.startsWith('AGENT')) {
+      return handleAgentCommand(userMessage);
+    }
+
+    // --- Learn mode ---
+    if (detectLearnMode(userMessage)) {
+      return handleLearnModeCommand(userMessage);
+    }
+
+    return {
+      response: 'PACS verstanden, aber keine passende Aktion gefunden.',
+      routedTo: null,
+      fallback: false,
+    };
+  } catch (err) {
+    console.error('[PACS Bridge] query error:', err);
+    return { response: `Fehler: ${err.message}`, routedTo: null, fallback: false };
+  }
+}
+
+/**
+ * Fallback: delegate to OpenClaw's built-in agents when PACS has no match.
+ * @param {string} message
+ * @returns {Promise<object>}
+ */
+async function fallbackToOpenClawAgents(message) {
+  if (!_openClawAgents) {
+    return {
+      response: 'Kein OpenClaw-Agent verfügbar (Bridge nicht mit OpenClaw-API verbunden).',
+      routedTo: null,
+      fallback: true,
+    };
+  }
+  try {
+    const result = await _openClawAgents.dispatch(message);
+    return {
+      response: result.response || result,
+      routedTo: result.agent || 'openclaw-default',
+      fallback: true,
+    };
+  } catch (err) {
+    return { response: `OpenClaw-Fallback fehlgeschlagen: ${err.message}`, routedTo: null, fallback: true };
+  }
+}
+
+async function handleAgentCommand(message) {
+  const upper = message.trim().toUpperCase();
+  const AgentRegistry = (await import('./agent-registry.js')).default;
+
+  if (upper === 'AGENT LIST' || upper === 'AGENT LISTE') {
+    const agents = AgentRegistry.listAgents();
+    if (agents.length === 0) {
+      return { response: 'Keine Agenten registriert.', routedTo: 'PACS-registry', fallback: false };
+    }
+    const lines = agents.map((a) => `• ${a.name} (${a.domain}) — ${a.status}`);
+    return { response: `Agenten:\n${lines.join('\n')}`, routedTo: 'PACS-registry', fallback: false };
+  }
+
+  const addMatch = message.match(/^AGENT\s+ADD\s+(\w+)\s*(.*)/i);
+  if (addMatch) {
+    const [, name, rest] = addMatch;
+    const agent = AgentRegistry.registerAgent(name, { domain: 'custom', description: rest.trim() });
+    return { response: `✓ Agent "${name}" registriert.`, routedTo: 'PACS-registry', fallback: false };
+  }
+
+  const removeMatch = message.match(/^AGENT\s+REMOVE\s+(\w+)/i);
+  if (removeMatch) {
+    const removed = AgentRegistry.removeAgent(removeMatch[1]);
+    return {
+      response: removed ? `✓ Agent "${removeMatch[1]}" entfernt.` : `Agent "${removeMatch[1]}" nicht gefunden.`,
+      routedTo: 'PACS-registry',
+      fallback: false,
+    };
+  }
+
+  return {
+    response: 'Unbekannter AGENT-Befehl. Verfügbar: AGENT LIST, AGENT ADD <name>, AGENT REMOVE <name>',
+    routedTo: 'PACS-registry',
+    fallback: false,
+  };
+}
+
+async function handleLearnModeCommand(message) {
+  const LearnMode = (await import('./learn-mode.js')).default;
+  const upper = message.trim().toUpperCase();
+
+  if (upper.includes('GET') || upper === 'LERNE MODUS') {
+    return { response: `Learn-Mode: ${LearnMode.getLearnMode()}`, routedTo: 'PACS-learn-mode', fallback: false };
+  }
+
+  const setMatch = message.match(/SET\s+(SAFE|EXPLICIT|AUTO)/i);
+  if (setMatch) {
+    const newMode = setMatch[1].toLowerCase();
+    LearnMode.setLearnMode(newMode);
+    return { response: `✓ Learn-Mode gesetzt auf: ${newMode}`, routedTo: 'PACS-learn-mode', fallback: false };
+  }
+
+  return {
+    response: 'Unbekannter LERNE-Befehl. Nutze: LERNE MODUS GET oder LERNE MODUS SET <safe|explicit|auto>',
+    routedTo: 'PACS-learn-mode',
+    fallback: false,
+  };
+}
+
+function status() {
+  return {
+    initialized: _openClawConfig !== null,
+    mode: _openClawConfig?.pacs?.mode || 'integrated',
+    enabled: _openClawConfig?.pacs?.enabled !== false,
+    openClawConnected: _openClawAgents !== null,
+  };
+}
+
+module.exports = { init, query, isPACSQuery, fallbackToOpenClawAgents, status };