pacs-core 0.1.0

package/phase2-test.mjs

@@ -0,0 +1,53 @@
+/**
+ * PACS Phase 2 — Quick Test
+ * Run from pacs root: node phase2-test.mjs
+ */
+
+import AgentRegistry from './src/agent-registry.js';
+import InterAgentBus from './src/inter-agent-bus.js';
+import AgentCreator from './src/agent-creator.js';
+
+console.log('=== Test 1: Agent Registry ===');
+const a1 = AgentRegistry.registerAgent('test-agent-1', { domain: 'dev', capabilities: ['coding', 'analysis'] });
+console.log('Registered:', a1.name, '| domain:', a1.domain);
+
+const a2 = AgentRegistry.registerAgent('test-agent-2', { domain: 'finance', capabilities: ['analysis'] });
+console.log('Registered:', a2.name);
+
+const list = AgentRegistry.listAgents();
+console.log('Total agents:', list.length, '| Names:', list.map(a => a.name).join(', '));
+
+const found = AgentRegistry.getAgent('test-agent-1');
+console.log('Get test-agent-1:', found ? found.domain : 'NOT FOUND');
+
+console.log('\n=== Test 2: Agent Creator (text) ===');
+const a3 = AgentCreator.createFromText('Erstelle einen Agenten für Finanzen mit Analyse und Planung');
+console.log('Created from text:', a3.name, '| domain:', a3.domain, '| caps:', a3.capabilities.join(', '));
+
+console.log('\n=== Test 3: Agent Creator (MD) ===');
+const md = `---
+name: marketing-test
+domain: marketing
+status: active
+---
+Marketing agent for campaigns`;
+const a4 = AgentCreator.createFromMD(md);
+console.log('Created from MD:', a4.name, '| domain:', a4.domain);
+
+console.log('\n=== Test 4: Inter-Agent Bus ===');
+const msg = InterAgentBus.emit('orchestrator', 'test-agent-1', 'Hello agent!');
+console.log('Emit:', msg.id.slice(0,8), '... from:', msg.from, 'to:', msg.to, 'type:', msg.type);
+
+const bcast = InterAgentBus.broadcast('orchestrator', 'System check');
+console.log('Broadcast:', bcast.id.slice(0,8), '... to:', bcast.to);
+
+const msgs = InterAgentBus.getMessages('test-agent-1');
+console.log('Messages for test-agent-1:', msgs.length);
+
+// Cleanup
+AgentRegistry.removeAgent('test-agent-1');
+AgentRegistry.removeAgent('test-agent-2');
+AgentRegistry.removeAgent(a3.name);
+AgentRegistry.removeAgent(a4.name);
+console.log('\nCleanup done.');
+console.log('\n✅ All tests passed!');

package/src/agent-creator.js

@@ -0,0 +1,178 @@
+/**
+ * PACS Core — Agent Creator Module
+ * Creates agents from natural language text or MD definitions
+ */
+
+import { registerAgent } from './agent-registry.js';
+import triggerParser from './trigger-parser.js';
+
+/**
+ * Map of domain keywords to domain names.
+ * @type {Record<string, string>}
+ */
+const DOMAIN_KEYWORDS = {
+  finance: ['finanz', 'geld', 'budget', 'invest', 'kosten', 'rechnung', 'bank', 'steuer', 'bilanz', 'cashflow', 'buchhalt'],
+  marketing: ['marketing', 'werbung', 'seo', 'social media', 'content', 'kampagne', 'crm', 'kunde', 'conversion'],
+  dev: ['code', 'programmier', 'entwickl', 'api', 'database', 'backend', 'frontend', 'test', 'deploy', 'git'],
+  design: ['design', 'ui', 'ux', 'grafik', 'logo', 'farbe', 'layout', 'figma'],
+  hr: ['personal', 'mitarbeiter', 'recruit', 'lohn', 'urlaub', 'team'],
+  legal: ['recht', 'vertrag', 'agb', 'dsgvo', 'gesetz', 'jurist'],
+  operations: ['oper', 'prozess', 'workflow', 'automatis', 'integration'],
+  strategy: ['strateg', 'vision', 'planning', 'roadmap', 'ziele'],
+};
+
+/**
+ * Capability keywords mapping.
+ * @type {Record<string, string[]>}
+ */
+const CAPABILITY_KEYWORDS = {
+  research: ['recherchier', 'such', 'analysier', 'find'],
+  writing: ['schreib', 'text', 'dokument', 'artikel', 'blog'],
+  coding: ['code', 'programmier', 'implementier', 'entwickl'],
+  analysis: ['analysier', 'auswert', 'bewert', 'pruef'],
+  planning: ['plan', 'organisier', 'koordinier'],
+  communication: ['kommunizier', 'schreib', 'antworte', 'pr\u00e4sentier'],
+  automation: ['automatisier', 'skript', 'workflow'],
+  data: ['daten', 'tabelle', 'statistik', 'csv', 'excel'],
+};
+
+/**
+ * Extract domain from natural language text.
+ * @param {string} text
+ * @returns {string}
+ */
+function extractDomain(text) {
+  const lower = text.toLowerCase();
+  for (const [domain, keywords] of Object.entries(DOMAIN_KEYWORDS)) {
+    if (keywords.some((kw) => lower.includes(kw))) {
+      return domain;
+    }
+  }
+  return 'general';
+}
+
+/**
+ * Extract capabilities from natural language text.
+ * @param {string} text
+ * @returns {string[]}
+ */
+function extractCapabilities(text) {
+  const lower = text.toLowerCase();
+  const found = [];
+  for (const [cap, keywords] of Object.entries(CAPABILITY_KEYWORDS)) {
+    if (keywords.some((kw) => lower.includes(kw))) {
+      found.push(cap);
+    }
+  }
+  return found;
+}
+
+/**
+ * Infer agent name from text.
+ * @param {string} text
+ * @returns {string}
+ */
+function inferName(text) {
+  // Try to find "Agent name" or similar patterns
+  const namePatterns = [
+    /(?:agent[ey]?|bot|helfer)\s+(?:f[ü|u]r|named?|called?)\s+"?([^",\n.]+)"?/i,
+    /(?:erstelle|kreiere|baue)\s+(?:einen|eine|ein)?\s*(?:agent|bot|helfer)\s*(?:f[ü|u]r|named?)?\s*"?([^",\n.]+)"?/i,
+    /(?:finanz|marketing|dev|hr|legal)\s*(?:agent|bot|helfer)/i,
+  ];
+
+  for (const pattern of namePatterns) {
+    const match = text.match(pattern);
+    if (match) {
+      return match[1].trim().replace(/[^a-zA-Z0-9_-]/g, '-').toLowerCase();
+    }
+  }
+
+  // Fall back to domain-based name
+  const domain = extractDomain(text);
+  return `${domain}-agent-${Date.now().toString(36).slice(-4)}`;
+}
+
+/**
+ * Create an agent from natural language text.
+ * @param {string} text - e.g. "Erstelle einen Agenten für Finanzen"
+ * @returns {object} The registered agent
+ */
+export function createFromText(text) {
+  const domain = extractDomain(text);
+  const capabilities = extractCapabilities(text);
+  const name = inferName(text);
+
+  // Check if trigger parser finds any intent
+  const parsed = triggerParser.parse(text);
+
+  const agent = registerAgent(name, {
+    domain,
+    capabilities,
+    description: text.slice(0, 200),
+    metadata: {
+      source: 'text',
+      originalText: text,
+      parsedTrigger: parsed ? parsed.trigger.id : null,
+    },
+  });
+
+  return agent;
+}
+
+/**
+ * Parse a markdown agent definition and register it.
+ * Supports a simple structured MD format:
+ * ---
+ * name: agent-name
+ * domain: finance
+ * status: active
+ * ---
+ * Optional description text here.
+ * @param {string} mdContent
+ * @returns {object} The registered agent
+ */
+export function createFromMD(mdContent) {
+  // Split on --- frontmatter
+  const fmMatch = mdContent.match(/^---\s*\n([\s\S]*?)\n---/);
+  let metadata = {};
+  let description = '';
+
+  if (fmMatch) {
+    // Parse frontmatter
+    const fmLines = fmMatch[1].split('\n');
+    for (const line of fmLines) {
+      const colonIdx = line.indexOf(':');
+      if (colonIdx > 0) {
+        const key = line.slice(0, colonIdx).trim();
+        const value = line.slice(colonIdx + 1).trim();
+        metadata[key] = value;
+      }
+    }
+    description = mdContent.slice(fmMatch[0].length).trim();
+  } else {
+    description = mdContent;
+  }
+
+  const name = metadata.name || inferName(description);
+
+  const agent = registerAgent(name, {
+    domain: metadata.domain || extractDomain(description),
+    capabilities: metadata.capabilities
+      ? metadata.capabilities.split(',').map((c) => c.trim())
+      : extractCapabilities(description),
+    status: metadata.status || 'active',
+    description: description.slice(0, 500),
+    metadata: {
+      source: 'markdown',
+      originalMD: mdContent,
+      ...metadata,
+    },
+  });
+
+  return agent;
+}
+
+export default {
+  createFromText,
+  createFromMD,
+};

package/src/agent-registry.js

@@ -0,0 +1,165 @@
+/**
+ * PACS Core — Agent Registry Module
+ * Manages agent definitions with encrypted persistence
+ */
+
+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 AGENTS_FILE = 'agents.enc';
+
+/**
+ * Generate a short unique ID.
+ * @returns {string}
+ */
+function generateId() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 7);
+}
+
+/**
+ * Get the agents store path.
+ * @returns {string}
+ */
+function getAgentsPath() {
+  return memoryStore.getFilePath(AGENTS_FILE);
+}
+
+/**
+ * Read all agents from encrypted store.
+ * @returns {object} Agent store
+ */
+function readAgentsStore() {
+  try {
+    return memoryStore.read(AGENTS_FILE) || { agents: [] };
+  } catch {
+    return { agents: [] };
+  }
+}
+
+/**
+ * Write agents to encrypted store.
+ * @param {object} store - { agents: [] }
+ */
+function writeAgentsStore(store) {
+  memoryStore.write(AGENTS_FILE, store);
+}
+
+/**
+ * Register a new agent or update an existing one.
+ * @param {string} name - Unique agent name
+ * @param {object} definition - Agent definition
+ * @returns {object} Registered agent
+ */
+export function registerAgent(name, definition = {}) {
+  const store = readAgentsStore();
+
+  const now = new Date().toISOString();
+  const existing = store.agents.find((a) => a.name === name);
+
+  const agent = {
+    id: existing ? existing.id : generateId(),
+    name,
+    domain: definition.domain || 'general',
+    capabilities: definition.capabilities || [],
+    status: definition.status || 'active',
+    lastActive: now,
+    createdAt: existing ? existing.createdAt : now,
+    description: definition.description || '',
+    metadata: definition.metadata || {},
+  };
+
+  // Replace or add
+  store.agents = store.agents.filter((a) => a.name !== name);
+  store.agents.push(agent);
+  writeAgentsStore(store);
+
+  return agent;
+}
+
+/**
+ * Get an agent by name.
+ * @param {string} name
+ * @returns {object|null}
+ */
+export function getAgent(name) {
+  const store = readAgentsStore();
+  const agent = store.agents.find((a) => a.name === name);
+  if (agent) {
+    // Touch lastActive on access
+    agent.lastActive = new Date().toISOString();
+    writeAgentsStore(store);
+  }
+  return agent || null;
+}
+
+/**
+ * List all agents, optionally filtered.
+ * @param {object} [filter] - { status, domain }
+ * @returns {object[]}
+ */
+export function listAgents(filter = {}) {
+  const store = readAgentsStore();
+  let agents = store.agents;
+
+  if (filter.status) {
+    agents = agents.filter((a) => a.status === filter.status);
+  }
+  if (filter.domain) {
+    agents = agents.filter((a) => a.domain === filter.domain);
+  }
+
+  return agents;
+}
+
+/**
+ * Remove an agent by name.
+ * @param {string} name
+ * @returns {boolean} True if removed
+ */
+export function removeAgent(name) {
+  const store = readAgentsStore();
+  const before = store.agents.length;
+  store.agents = store.agents.filter((a) => a.name !== name);
+  if (store.agents.length < before) {
+    writeAgentsStore(store);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Update agent fields.
+ * @param {string} name
+ * @param {object} updates
+ * @returns {object|null}
+ */
+export function updateAgent(name, updates) {
+  const store = readAgentsStore();
+  const idx = store.agents.findIndex((a) => a.name === name);
+  if (idx === -1) return null;
+
+  const agent = store.agents[idx];
+  const allowed = ['domain', 'capabilities', 'status', 'description', 'metadata'];
+  for (const key of allowed) {
+    if (updates[key] !== undefined) {
+      agent[key] = updates[key];
+    }
+  }
+  agent.lastActive = new Date().toISOString();
+
+  store.agents[idx] = agent;
+  writeAgentsStore(store);
+  return agent;
+}
+
+export default {
+  registerAgent,
+  getAgent,
+  listAgents,
+  removeAgent,
+  updateAgent,
+};

package/src/bootstrap.js

@@ -0,0 +1,245 @@
+/**
+ * PACS Core — Bootstrap Module
+ * Creates ~/.openclaw/pacs/ directory structure with sample encrypted files.
+ * Run with: npm run bootstrap
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('./crypto');
+const memoryStore = require('./memory-store');
+const triggerParser = require('./trigger-parser');
+
+const PACS_DIR = path.join(process.env.HOME || process.env.USERPROFILE, '.openclaw', 'pacs');
+
+/**
+ * Print colored console output.
+ */
+function log(msg, color = 'INFO') {
+  const colors = {
+    INFO: '\x1b[36m',
+    OK: '\x1b[32m',
+    WARN: '\x1b[33m',
+    ERROR: '\x1b[31m',
+    RESET: '\x1b[0m',
+  };
+  console.log(`${colors[color] || ''}[PACS Bootstrap]${colors.RESET} ${msg}`);
+}
+
+/**
+ * Check if PACS_ENCRYPTION_KEY is set.
+ */
+function checkEncryptionKey() {
+  if (!process.env.PACS_ENCRYPTION_KEY) {
+    log('PACS_ENCRYPTION_KEY is not set.', 'WARN');
+    log('Generating a temporary key for bootstrap only.', 'WARN');
+    log('IMPORTANT: Set your own key for production use:', 'WARN');
+    const key = crypto.generateKey();
+    console.log(`  export PACS_ENCRYPTION_KEY=\"${key}\"`);
+    console.log('');
+    // Set for this session only
+    process.env.PACS_ENCRYPTION_KEY = key;
+  } else {
+    log(`Encryption key: ✓ (${process.env.PACS_ENCRYPTION_KEY.slice(0, 8)}...)`, 'OK');
+  }
+}
+
+/**
+ * Create the PACS directory structure.
+ */
+function createDirectories() {
+  if (!fs.existsSync(PACS_DIR)) {
+    fs.mkdirSync(PACS_DIR, { recursive: true });
+    log(`Created: ${PACS_DIR}`, 'OK');
+  } else {
+    log(`Directory exists: ${PACS_DIR}`, 'INFO');
+  }
+
+  // Create subdirectories
+  const subdirs = ['triggers', 'backups'];
+  for (const subdir of subdirs) {
+    const dir = path.join(PACS_DIR, subdir);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+      log(`Created: ${dir}`, 'OK');
+    }
+  }
+}
+
+/**
+ * Copy triggers.json to PACS directory.
+ */
+function installTriggers() {
+  const source = path.join(__dirname, 'triggers.json');
+  const target = path.join(PACS_DIR, 'triggers', 'triggers.json');
+
+  if (fs.existsSync(target)) {
+    log(`triggers.json already installed`, 'INFO');
+  } else {
+    fs.copyFileSync(source, target);
+    log(`Installed: ${target}`, 'OK');
+  }
+}
+
+/**
+ * Create sample encrypted memory file.
+ */
+function createSampleMemory() {
+  const memory = {
+    facts: [
+      'Ich spreche am liebsten Deutsch',
+      'Arbeite gerne mit klaren Strukturen',
+      'Wichtig: Datenschutz bei privaten Daten',
+    ],
+    private: [],
+    learnedAt: {},
+    _bootstrap: true,
+    _created: new Date().toISOString(),
+  };
+
+  try {
+    memoryStore.writeMemory(memory);
+    log(`Created sample memory`, 'OK');
+  } catch (err) {
+    if (err.message.includes('environment variable')) {
+      log(`Skipped memory creation (no encryption key)`, 'WARN');
+    } else {
+      throw err;
+    }
+  }
+}
+
+/**
+ * Create sample routing file.
+ */
+function createSampleRouting() {
+  const routing = {
+    hints: [
+      'finance → finance-agent',
+      'code → code-agent',
+      'quick → fast-agent',
+    ],
+    agents: [],
+    _bootstrap: true,
+    _created: new Date().toISOString(),
+  };
+
+  try {
+    memoryStore.writeRouting(routing);
+    log(`Created sample routing`, 'OK');
+  } catch (err) {
+    if (err.message.includes('environment variable')) {
+      log(`Skipped routing creation (no encryption key)`, 'WARN');
+    } else {
+      throw err;
+    }
+  }
+}
+
+/**
+ * Create sample core rules file.
+ */
+function createSampleCoreRules() {
+  const rules = {
+    rules: [
+      'Antworte in der Sprache des Users',
+      ' Sei präzise und strukturiert',
+      'Private Daten niemals weitergeben oder exportieren',
+    ],
+    _bootstrap: true,
+    _created: new Date().toISOString(),
+  };
+
+  try {
+    memoryStore.writeCoreRules(rules);
+    log(`Created sample core rules`, 'OK');
+  } catch (err) {
+    if (err.message.includes('environment variable')) {
+      log(`Skipped rules creation (no encryption key)`, 'WARN');
+    } else {
+      throw err;
+    }
+  }
+}
+
+/**
+ * Create a README in the PACS directory.
+ */
+function createPacsReadme() {
+  const readme = `# PACS — Personal AI Control System
+
+## Directory Structure
+\`\`\`
+~/.openclaw/pacs/
+├── memory.enc       # Encrypted user facts
+├── routing.enc      # Encrypted routing hints
+├── core-rules.enc   # Encrypted AI behavior rules
+└── triggers/
+    └── triggers.json  # Plaintext trigger definitions
+\`\`\`
+
+## Security
+- All .enc files are encrypted with AES-256-GCM
+- Key is in PACS_ENCRYPTION_KEY env variable only
+- Never share your encryption key
+- Private facts are excluded from exports
+
+## Commands
+Run: \`node src/trigger-parser.js\` to test parsing.
+Run: \`node src/memory-store.js\` to test storage.
+
+## Learn More
+See: README.md (project root)
+`;
+
+  const readmePath = path.join(PACS_DIR, 'README.md');
+  fs.writeFileSync(readmePath, readme, 'utf8');
+  log(`Created: ${readmePath}`, 'OK');
+}
+
+/**
+ * Print setup instructions.
+ */
+function printInstructions() {
+  console.log('');
+  log('=== Bootstrap Complete ===', 'OK');
+  console.log('');
+  console.log('Next steps:');
+  console.log('  1. Set your encryption key:');
+  console.log(`     export PACS_ENCRYPTION_KEY="$(openssl rand -hex 32)"`);
+  console.log('');
+  console.log('  2. Test the module:');
+  console.log('     npm test');
+  console.log('');
+  console.log(`  3. PACS home: ${PACS_DIR}`);
+  console.log('');
+  console.log('Phase 1 complete. Phase 2 will add:');
+  console.log('  - Agent routing engine');
+  console.log('  - Learning loop with confirmation prompts');
+  console.log('  - OpenClaw integration bridge');
+}
+
+/**
+ * Main bootstrap function.
+ */
+function bootstrap() {
+  console.log('');
+  log('PACS Core — Bootstrap (Phase 1)', 'INFO');
+  console.log('');
+
+  checkEncryptionKey();
+  createDirectories();
+  installTriggers();
+  createSampleMemory();
+  createSampleRouting();
+  createSampleCoreRules();
+  createPacsReadme();
+  printInstructions();
+}
+
+// Run if called directly
+if (require.main === module) {
+  bootstrap();
+}
+
+module.exports = { bootstrap, PACS_DIR };