pacs-core 0.1.0

package/src/openclaw-bridge.js

@@ -0,0 +1,304 @@
+/**
+ * PACS Core — OpenClaw Bridge Module
+ * 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
+ */
+
+import { parse, containsTrigger, detectLearnMode } from './trigger-parser.js';
+import { listAgents, getAgent, registerAgent } from './agent-registry.js';
+import { searchFacts, addFact, readMemory } from './memory-store.js';
+import LearnMode from './learn-mode.js';
+import RoutingEngine from './routing-engine.js';
+import AgentCreator from './agent-creator.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}
+ */
+export function isPACSQuery(message) {
+  if (!message || typeof message !== 'string') return false;
+  const upper = message.trim().toUpperCase();
+  // Explicit trigger words
+  if (PACS_TRIGGERS.some((t) => upper.startsWith(t))) return true;
+  // Trigger-parser detection
+  if (containsTrigger(message)) return true;
+  // Learn mode intent
+  if (detectLearnMode(message)) return true;
+  return false;
+}
+
+/**
+ * Initialize PACS inside OpenClaw.
+ * Call once at OpenClaw startup.
+ *
+ * @param {object} openClawConfig - { pacs: { enabled, mode } }
+ * @param {object} [openClawAgentApi] - Optional OpenClaw agent API for fallback
+ */
+export 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 }
+ */
+export async function query(userMessage) {
+  if (!isPACSQuery(userMessage)) {
+    return fallbackToOpenClawAgents(userMessage);
+  }
+
+  const mode = (_openClawConfig?.pacs?.mode) || 'integrated';
+
+  try {
+    const trigger = parse(userMessage);
+    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) {
+        addFact(fact);
+        return {
+          response: `✓ Merke: ${fact}`,
+          routedTo: 'PACS-memory',
+          fallback: false,
+        };
+      }
+    }
+
+    // --- SUCHE / search memory ---
+    if (upper.startsWith('SUCHE')) {
+      const query2 = userMessage
+        .replace(/^(SUCHE|SUCH)\s*/i, '')
+        .trim();
+      const results = searchFacts(query2);
+      if (results.length === 0) {
+        return {
+          response: `Keine Ergebnisse für "${query2}".`,
+          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 ---
+    if (upper.startsWith('AGENT')) {
+      return handleAgentCommand(userMessage);
+    }
+
+    // --- Learn mode ---
+    if (detectLearnMode(userMessage)) {
+      return handleLearnModeCommand(userMessage);
+    }
+
+    // --- Routing engine ---
+    const routingEngine = new RoutingEngine();
+    const route = routingEngine.route(userMessage);
+    if (route && route.agent) {
+      return {
+        response: `→ Agent "${route.agent}" (Confidence: ${route.confidence})`,
+        routedTo: route.agent,
+        fallback: false,
+      };
+    }
+
+    // No PACS handler — fallback to OpenClaw agents
+    if (mode === 'integrated') {
+      return fallbackToOpenClawAgents(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>}
+ */
+export async function fallbackToOpenClawAgents(message) {
+  if (!_openClawAgents) {
+    return {
+      response: 'Kein OpenClaw-Agent verfügbar (Bridge nicht mit OpenClaw-API verbunden).',
+      routedTo: null,
+      fallback: true,
+    };
+  }
+
+  try {
+    // Delegate to OpenClaw's main agent dispatcher
+    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,
+    };
+  }
+}
+
+/**
+ * Handle AGENT subcommands (list, add, remove).
+ * @param {string} message
+ * @returns {object}
+ */
+function handleAgentCommand(message) {
+  const upper = message.trim().toUpperCase();
+
+  if (upper === 'AGENT LIST' || upper === 'AGENT LISTE') {
+    const agents = 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,
+    };
+  }
+
+  // AGENT ADD <name> ...
+  const addMatch = message.match(/^AGENT\s+ADD\s+(\w+)\s*(.*)/i);
+  if (addMatch) {
+    const [, name, rest] = addMatch;
+    const agent = registerAgent(name, { domain: 'custom', description: rest.trim() });
+    return {
+      response: `✓ Agent "${name}" registriert.`,
+      routedTo: 'PACS-registry',
+      fallback: false,
+    };
+  }
+
+  // AGENT REMOVE <name>
+  const removeMatch = message.match(/^AGENT\s+REMOVE\s+(\w+)/i);
+  if (removeMatch) {
+    const { removeAgent } = require('./agent-registry.js');
+    const removed = 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,
+  };
+}
+
+/**
+ * Handle learn-mode subcommands.
+ * @param {string} message
+ * @returns {object}
+ */
+function handleLearnModeCommand(message) {
+  const upper = message.trim().toUpperCase();
+
+  if (upper.includes('GET') || upper === 'LERNE MODUS') {
+    const mode = LearnMode.getLearnMode();
+    return {
+      response: `Learn-Mode: ${mode}`,
+      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,
+  };
+}
+
+/**
+ * Get current bridge status.
+ * @returns {object}
+ */
+export function status() {
+  return {
+    initialized: _openClawConfig !== null,
+    mode: _openClawConfig?.pacs?.mode || 'integrated',
+    enabled: _openClawConfig?.pacs?.enabled !== false,
+    openClawConnected: _openClawAgents !== null,
+  };
+}
+
+export default {
+  init,
+  query,
+  isPACSQuery,
+  fallbackToOpenClawAgents,
+  status,
+};

package/src/routing-engine.js

@@ -0,0 +1,221 @@
+/**
+ * PACS Core — Routing Engine
+ * Routes incoming user tasks to the correct agent(s) with scoring
+ */
+
+import crypto from './crypto.js';
+import memoryStore from './memory-store.js';
+import agentRegistry from './agent-registry.js';
+
+// Domain keyword maps for zero-config routing
+const DOMAIN_KEYWORDS = {
+  finance: ['finanzen', 'geld', 'budget', 'kosten', 'einnahmen', 'ausgaben', 'steuer', 'bank', 'investment', 'aktien', 'buchhaltung', 'rechnung', 'lohn', 'gehalt', 'finance', 'money', 'budget', 'cost', 'income', 'expense', 'tax', 'investment', 'stock', 'accounting', 'invoice', 'salary', ' payment'],
+  code: ['code', 'programm', 'skript', 'entwickle', 'debug', 'api', 'frontend', 'backend', 'database', 'funktion', 'software', 'github', 'git', 'deploy', 'build', 'compile', 'node', 'javascript', 'python', 'rust', 'java', 'c++', 'sql', 'html', 'css', 'react', 'nextjs', 'vite', 'typescript'],
+  social: ['social', 'instagram', 'facebook', 'twitter', 'linkedin', 'youtube', 'tiktok', 'post', 'posting', 'content', 'marketing', 'kampagne', 'werbung', 'community', '粉丝', '粉丝', 'engagement', 'follower', ' viral'],
+  assistant: ['hilf', 'help', 'organisiere', 'organize', 'plane', 'plan', 'todo', 'aufgabe', 'task', 'meeting', 'kalender', 'calendar', 'email', 'termin', 'reminder', 'erinnerung', 'todoist', 'notion'],
+  research: ['recherche', 'research', 'suche', 'search', 'analyse', 'analysis', 'studie', 'study', 'wettbewerb', 'competition', 'benchmark', 'vergleich', 'compare', 'trends', 'markt', 'market'],
+  health: ['gesundheit', 'health', 'fitness', 'sport', 'ernährung', 'diet', 'arbeit', 'work', 'stress', ' burnout', 'schlaf', 'sleep', 'meditation', 'yoga', 'arzt', 'doctor'],
+  home: ['smart home', 'haus', 'home', 'iot', 'automation', 'heizung', 'heating', 'licht', 'light', 'kamera', 'camera', 'tür', 'door', 'alarmanlage', 'alarm'],
+  travel: ['reise', 'travel', 'urlaub', 'vacation', 'flug', 'flight', 'hotel', 'booking', 'airbnb', 'restaurant', 'trip', 'planung', 'planning'],
+};
+
+const AGENT_ALIASES = {
+  finance: ['finance', 'finance-agent', 'buchhaltung', 'accounting', 'finanzen-agent'],
+  code: ['code', 'code-agent', 'coder', 'developer', 'dev-agent', 'entwickler'],
+  social: ['social', 'social-agent', 'marketing', 'content', 'socialmedia', 'social-media'],
+  assistant: ['assistant', 'assistent', 'haushalt', 'organizer', 'todo', 'tasks'],
+  research: ['research', 'researcher', 'analyse', 'analyst', 'recherche'],
+  health: ['health', 'fitness', 'gesundheit', 'wellness'],
+  home: ['home', 'smarthome', 'iot', 'automation'],
+  travel: ['travel', 'reise', 'trip', 'planner'],
+};
+
+// All-agent trigger patterns
+const ALL_AGENTS_PATTERNS = [
+  /alle\s+agenten/i,
+  /all[ei]\s+agents/i,
+  /every\s+agent/i,
+  /alle\s*i/i,
+  /^alle$/i,
+  /^all$/i,
+];
+
+/**
+ * Score how well an agent matches a user message.
+ * @param {object} agent - Agent definition
+ * @param {string} message - User message
+ * @param {string[]} routingHints - Loaded routing hints
+ * @returns {number} Score 0-1
+ */
+function scoreAgent(agent, message, routingHints = []) {
+  const msg = message.toLowerCase();
+  let score = 0;
+  const domain = (agent.domain || '').toLowerCase();
+  const capabilities = (agent.capabilities || []).map((c) => c.toLowerCase());
+  const description = (agent.description || '').toLowerCase();
+
+  // 1. Check routing hints (highest weight)
+  for (const hint of routingHints) {
+    const hintLower = hint.toLowerCase();
+    // Hint format: "finance → finance-agent" or "finance" alone
+    const [hintTopic, hintTarget] = hintLower.split('→').map((s) => s.trim());
+    if (hintTarget && hintTarget.includes(agent.name.toLowerCase())) {
+      if (msg.includes(hintTopic)) {
+        score += 0.5;
+      }
+    } else if (hintLower.includes(agent.name.toLowerCase())) {
+      // Direct name mention in hint
+      score += 0.3;
+    }
+  }
+
+  // 2. Domain keyword match
+  const domainTerms = DOMAIN_KEYWORDS[domain] || [];
+  for (const term of domainTerms) {
+    if (msg.includes(term)) {
+      score += 0.15;
+    }
+  }
+
+  // 3. Capability match
+  for (const cap of capabilities) {
+    if (msg.includes(cap)) {
+      score += 0.1;
+    }
+  }
+
+  // 4. Description match
+  for (const term of msg.split(/\s+/)) {
+    if (term.length > 3 && description.includes(term)) {
+      score += 0.05;
+    }
+  }
+
+  // 5. Exact name/alias mention in message
+  const agentTerms = [agent.name, ...(AGENT_ALIASES[domain] || [])];
+  for (const term of agentTerms) {
+    if (msg.includes(term.toLowerCase())) {
+      score += 0.2;
+    }
+  }
+
+  return Math.min(score, 1.0);
+}
+
+/**
+ * Route a user message to the best matching agents.
+ * @param {string} userMessage - The user's input
+ * @returns {object} { task, plan: [{agent, mode, score}], confidence }
+ */
+export function route(userMessage) {
+  if (!userMessage || typeof userMessage !== 'string') {
+    return { task: userMessage || '', plan: [], confidence: 0 };
+  }
+
+  const routing = memoryStore.readRouting();
+  const hints = routing.hints || [];
+  const agents = agentRegistry.listAgents({ status: 'active' });
+
+  // Handle "all agents" query
+  if (ALL_AGENTS_PATTERNS.some((p) => p.test(userMessage))) {
+    return {
+      task: userMessage,
+      plan: agents.map((a) => ({ agent: a.name, mode: 'parallel', score: 1 })),
+      confidence: 1,
+    };
+  }
+
+  // Handle "who handles X" query
+  const whoMatches = userMessage.match(/wer\s+ist\s+(?:für|zuständig|der|die)\s+(.+?)\??$/i);
+  if (whoMatches) {
+    const topic = whoMatches[1].trim();
+    const scores = agents.map((a) => ({
+      agent: a.name,
+      score: scoreAgent(a, topic, hints),
+    }));
+    scores.sort((a, b) => b.score - a.score);
+    const best = scores[0];
+    if (best && best.score > 0) {
+      return {
+        task: userMessage,
+        plan: [{ agent: best.agent, mode: 'single', score: best.score }],
+        confidence: best.score,
+      };
+    }
+  }
+
+  // Score all agents
+  const scored = agents.map((a) => ({
+    agent: a.name,
+    score: scoreAgent(a, userMessage, hints),
+  }));
+
+  // Sort by score descending
+  scored.sort((a, b) => b.score - a.score);
+
+  // Filter to relevant agents (score > 0.05)
+  const relevant = scored.filter((s) => s.score > 0.05);
+
+  if (relevant.length === 0) {
+    return { task: userMessage, plan: [], confidence: 0 };
+  }
+
+  const topScore = relevant[0].score;
+  const confidence = topScore;
+
+  return {
+    task: userMessage,
+    plan: relevant.map((s) => ({ agent: s.agent, mode: 'parallel', score: s.score })),
+    confidence,
+  };
+}
+
+/**
+ * Route for parallel execution — agents that can work simultaneously.
+ * @param {string} userMessage
+ * @returns {object} { task, plan: [{agent, mode}], confidence }
+ */
+export function routeParallel(userMessage) {
+  const result = route(userMessage);
+
+  // Filter to agents with score >= 0.3 for parallel
+  const parallelPlan = result.plan.filter((p) => p.score >= 0.3);
+
+  return {
+    task: result.task,
+    plan: parallelPlan.length > 0
+      ? parallelPlan.map((p) => ({ agent: p.agent, mode: 'parallel' }))
+      : result.plan.slice(0, 1).map((p) => ({ agent: p.agent, mode: 'parallel' })),
+    confidence: result.confidence,
+  };
+}
+
+/**
+ * Route for sequential execution — agents that must go in order.
+ * @param {string} userMessage
+ * @returns {object} { task, plan: [{agent, mode}], confidence }
+ */
+export function routeSequential(userMessage) {
+  const result = route(userMessage);
+
+  // For sequential, take top 3 agents ordered by score
+  const sequentialPlan = result.plan.slice(0, 3);
+
+  return {
+    task: result.task,
+    plan: sequentialPlan.map((p) => ({ agent: p.agent, mode: 'sequential' })),
+    confidence: result.confidence,
+  };
+}
+
+/**
+ * Get the responsible agent(s) for a specific topic.
+ * @param {string} topic
+ * @returns {string[]} Agent names
+ */
+export function whoHandles(topic) {
+  const result = route(topic);
+  return result.plan.filter((p) => p.score > 0.1).map((p) => p.agent);
+}
+
+export default { route, routeParallel, routeSequential, whoHandles };