pacs-core 0.1.0

package/src/test.js

@@ -0,0 +1,298 @@
+/**
+ * PACS Core — Test Script
+ * Run with: npm test
+ * Requires PACS_ENCRYPTION_KEY to be set.
+ */
+
+const crypto = require('./crypto');
+const memoryStore = require('./memory-store');
+const triggerParser = require('./trigger-parser');
+
+// Set test key globally
+if (!process.env.PACS_ENCRYPTION_KEY) {
+  process.env.PACS_ENCRYPTION_KEY = 'test-key-for-testing-only-32chars';
+}
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`  ✓ ${name}`);
+    passed++;
+  } catch (err) {
+    console.log(`  ✗ ${name}`);
+    console.log(`    Error: ${err.message}`);
+    failed++;
+  }
+}
+
+function assertEqual(actual, expected, msg) {
+  if (actual !== expected) {
+    throw new Error(`${msg}: expected ${expected}, got ${actual}`);
+  }
+}
+
+function assertMatch(str, regex, msg) {
+  if (!regex.test(str)) {
+    throw new Error(`${msg}: "${str}" did not match ${regex}`);
+  }
+}
+
+async function runTests() {
+  console.log('');
+  console.log('[PACS Test Suite]');
+  console.log('');
+
+  // Set a test key if none is set
+  if (!process.env.PACS_ENCRYPTION_KEY) {
+    process.env.PACS_ENCRYPTION_KEY = 'test-key-for-testing-only-32chars';
+  }
+
+  console.log('1. Crypto Module');
+  test('encrypt() produces a colon-separated string', () => {
+    const encrypted = crypto.encrypt('hello world');
+    assertMatch(encrypted, /^[^:]+:[^:]+:[^:]+$/, 'encrypted format');
+  });
+
+  test('decrypt() recovers plaintext', () => {
+    const encrypted = crypto.encrypt('hello world');
+    const decrypted = crypto.decrypt(encrypted);
+    assertEqual(decrypted, 'hello world', 'decrypted value');
+  });
+
+  test('generateKey() produces 64-char hex', () => {
+    const key = crypto.generateKey();
+    assertEqual(key.length, 64, 'key length');
+    assertMatch(key, /^[a-f0-9]+$/, 'hex format');
+  });
+
+  test('encrypt with custom password works', () => {
+    const encrypted = crypto.encrypt('secret', 'my-password');
+    const decrypted = crypto.decrypt(encrypted, 'my-password');
+    assertEqual(decrypted, 'secret', 'custom password decrypt');
+  });
+
+  console.log('');
+  console.log('2. Trigger Parser Module');
+
+  test('parse() detects MERKE trigger', () => {
+    const result = triggerParser.parse('MERKE: Ich spreche Deutsch');
+    if (!result) throw new Error('expected trigger');
+    assertEqual(result.trigger.id, 'MERKE', 'trigger id');
+    assertEqual(result.payload, 'Ich spreche Deutsch', 'payload');
+  });
+
+  test('parse() detects LEARN alias', () => {
+    const result = triggerParser.parse('LEARN: I prefer English');
+    if (!result) throw new Error('expected trigger');
+    assertEqual(result.trigger.id, 'MERKE', 'trigger id (LEARN alias)');
+  });
+
+  test('parse() returns null for plain text', () => {
+    const result = triggerParser.parse('Hello, how are you?');
+    if (result !== null) throw new Error('expected null');
+  });
+
+  test('detectLearnMode() detects auto mode', () => {
+    const mode = triggerParser.detectLearnMode('AI: lern automatisch');
+    assertEqual(mode, 'auto', 'learn mode');
+  });
+
+  test('detectLearnMode() detects on-demand mode', () => {
+    const mode = triggerParser.detectLearnMode('AI: nur auf Befehl');
+    assertEqual(mode, 'onDemand', 'learn mode');
+  });
+
+  test('getHelpText() returns non-empty string', () => {
+    const help = triggerParser.getHelpText();
+    if (typeof help !== 'string' || help.length === 0) {
+      throw new Error('help text is empty');
+    }
+  });
+
+  console.log('');
+  console.log('3. Memory Store Module');
+
+  test('readMemory() returns object', () => {
+    const mem = memoryStore.readMemory();
+    if (typeof mem !== 'object') throw new Error('expected object');
+  });
+
+  test('addFact() adds to memory', () => {
+    const mem = memoryStore.addFact('Test fact 123xyz');
+    if (!mem.facts.includes('Test fact 123xyz')) {
+      throw new Error('fact not added');
+    }
+    // Cleanup
+    memoryStore.removeFact('Test fact 123xyz');
+  });
+
+  test('searchFacts() finds matching facts', () => {
+    memoryStore.addFact('UniqueSearchTermABC123');
+    const results = memoryStore.searchFacts('UniqueSearchTermABC123');
+    if (!results.includes('UniqueSearchTermABC123')) {
+      throw new Error('search failed');
+    }
+    memoryStore.removeFact('UniqueSearchTermABC123');
+  });
+
+  console.log('');
+  console.log('');
+  console.log(`Results: ${passed} passed, ${failed} failed`);
+  console.log('');
+
+  if (failed > 0) {
+    process.exit(1);
+  }
+}
+
+async function runPhase2Tests() {
+  const { RoutingEngine, LearningLoop, LearnMode } = await import('./index.js');
+
+  console.log('4. Routing Engine Module');
+
+  test('route() returns object with plan array', () => {
+    const result = RoutingEngine.route('Organisiere meine Finanzen');
+    if (!result || !Array.isArray(result.plan)) throw new Error('expected plan array');
+    if (typeof result.confidence !== 'number') throw new Error('expected confidence number');
+  });
+
+  test('route() returns plan with agent names', () => {
+    const result = RoutingEngine.route('Code review und Finanzen');
+    if (result.plan.length === 0) throw new Error('expected at least one agent');
+    for (const p of result.plan) {
+      if (typeof p.agent !== 'string') throw new Error('expected agent string');
+    }
+  });
+
+  test('routeParallel() returns parallel mode plan', () => {
+    const result = RoutingEngine.routeParallel('Marketing und Code');
+    if (!result.plan.every((p) => p.mode === 'parallel')) {
+      throw new Error('all plans should be parallel');
+    }
+  });
+
+  test('routeSequential() returns sequential mode plan', () => {
+    const result = RoutingEngine.routeSequential('Plan my week and send emails');
+    if (!result.plan.every((p) => p.mode === 'sequential')) {
+      throw new Error('all plans should be sequential');
+    }
+  });
+
+  test('whoHandles() returns array of agent names', () => {
+    const handlers = RoutingEngine.whoHandles('Steuererklärung');
+    if (!Array.isArray(handlers)) throw new Error('expected array');
+  });
+
+  console.log('');
+  console.log('5. Learn Mode Module');
+
+  test('getMode() returns a valid mode string', () => {
+    const mode = LearnMode.getMode();
+    if (!['safe', 'explicit', 'auto'].includes(mode)) {
+      throw new Error(`unexpected mode: ${mode}`);
+    }
+  });
+
+  test('setMode() accepts valid modes', () => {
+    LearnMode.setMode('explicit');
+    const m = LearnMode.getMode();
+    if (m !== 'explicit') throw new Error('mode not set to explicit');
+  });
+
+  test('setMode() rejects invalid modes', () => {
+    let threw = false;
+    try {
+      LearnMode.setMode('invalid-mode');
+    } catch {
+      threw = true;
+    }
+    if (!threw) throw new Error('expected error for invalid mode');
+  });
+
+  test('getModeDescription() returns non-empty string', () => {
+    const desc = LearnMode.getModeDescription();
+    if (!desc || desc.length < 5) throw new Error('description too short');
+  });
+
+  // Restore default
+  LearnMode.setMode('safe');
+
+  console.log('');
+  console.log('6. Learning Loop Module');
+
+  test('shouldRemember() detects explicit MERKE trigger', () => {
+    const result = LearningLoop.shouldRemember('MERKE: Ich spreche Deutsch');
+    if (!result.should) throw new Error('expected should=true for MERKE trigger');
+    if (result.fact !== 'Ich spreche Deutsch') throw new Error('wrong fact extracted');
+  });
+
+  test('shouldRemember() returns false for questions', () => {
+    const result = LearningLoop.shouldRemember('Was ist meine Steuernummer?');
+    if (result.should) throw new Error('expected should=false for question');
+  });
+
+  test('shouldRemember() returns false for noise', () => {
+    const result = LearningLoop.shouldRemember('Hi');
+    if (result.should) throw new Error('expected should=false for noise');
+  });
+
+  test('shouldRemember() detects personal fact in safe mode', () => {
+    LearnMode.setMode('safe');
+    const result = LearningLoop.shouldRemember('Ich heiße Max und arbeite bei Google');
+    // May or may not trigger depending on heuristics — just check structure
+    if (typeof result.should !== 'boolean') throw new Error('expected boolean should');
+  });
+
+  test('shouldRemember() returns false in explicit mode for non-trigger', () => {
+    LearnMode.setMode('explicit');
+    const result = LearningLoop.shouldRemember('Ich bin Entwickler bei Acme Corp');
+    if (result.should) throw new Error('expected should=false in explicit mode without MERKE');
+    LearnMode.setMode('safe');
+  });
+
+  test('promptConfirmation() returns DE confirmation', () => {
+    const prompt = LearningLoop.promptConfirmation('Ich spreche Deutsch', 'DE');
+    if (!prompt.includes('Soll ich mir das merken')) throw new Error('wrong DE prompt');
+  });
+
+  test('promptConfirmation() returns EN confirmation', () => {
+    const prompt = LearningLoop.promptConfirmation('I prefer English', 'EN');
+    if (!prompt.includes('Should I remember')) throw new Error('wrong EN prompt');
+  });
+
+  test('storeConfirmed() adds fact to memory', () => {
+    const uniqueFact = `Test fact ${Date.now()} unique`;
+    LearningLoop.storeConfirmed('test-user', uniqueFact);
+    const found = memoryStore.searchFacts(uniqueFact);
+    if (!found.includes(uniqueFact)) throw new Error('fact not stored');
+    memoryStore.removeFact(uniqueFact);
+  });
+
+  test('rejectLearning() adds to rejected list', () => {
+    const uniqueFact = `Rejected ${Date.now()}`;
+    LearningLoop.rejectLearning('test-user', uniqueFact);
+    const wasR = LearningLoop.wasRejected(uniqueFact);
+    if (!wasR) throw new Error('expected fact to be marked rejected');
+  });
+
+  console.log('');
+  console.log(`Results: ${passed} passed, ${failed} failed`);
+  console.log('');
+
+  if (failed > 0) {
+    process.exit(1);
+  }
+}
+
+runTests().catch((err) => {
+  console.error('Test error:', err);
+  process.exit(1);
+});
+
+runPhase2Tests().catch((err) => {
+  console.error('Phase 2 test error:', err);
+  process.exit(1);
+});

package/src/trigger-parser.js

@@ -0,0 +1,187 @@
+/**
+ * PACS Core — Trigger Parser Module
+ * Parses plaintext trigger commands from triggers.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+let triggersCache = null;
+
+/**
+ * Load triggers from triggers.json.
+ * Cached after first load.
+ * @returns {object} Parsed triggers.json
+ */
+function loadTriggers() {
+  if (triggersCache) {
+    return triggersCache;
+  }
+
+  const triggerPath = path.join(__dirname, 'triggers.json');
+
+  if (!fs.existsSync(triggerPath)) {
+    throw new Error(`triggers.json not found at ${triggerPath}`);
+  }
+
+  const raw = fs.readFileSync(triggerPath, 'utf8');
+  triggersCache = JSON.parse(raw);
+  return triggersCache;
+}
+
+/**
+ * Get all trigger definitions.
+ * @returns {object[]} Array of trigger objects
+ */
+function getAllTriggers() {
+  return loadTriggers().triggers;
+}
+
+/**
+ * Get learn mode configurations.
+ * @returns {object} Learn modes
+ */
+function getLearnModes() {
+  return loadTriggers().learnModes;
+}
+
+/**
+ * Find a trigger by its ID or alias.
+ * @param {string} input - The command string (e.g. "MERKE:", "LEARN:")
+ * @returns {object|null} Trigger object or null
+ */
+function findTrigger(input) {
+  if (!input || typeof input !== 'string') {
+    return null;
+  }
+
+  const normalized = input.trim().toUpperCase().replace(/^:\s*/, '').replace(/:$/, '');
+  const triggers = getAllTriggers();
+
+  for (const trigger of triggers) {
+    // Check main ID
+    if (trigger.id.toUpperCase() === normalized) {
+      return trigger;
+    }
+    // Check aliases
+    for (const alias of trigger.aliases) {
+      if (alias.toUpperCase() === normalized) {
+        return trigger;
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Parse a trigger command from a message.
+ * Extracts the trigger type and its payload.
+ * @param {string} message - The full message text
+ * @returns {object|null} { trigger: object, payload: string } or null
+ */
+function parse(message) {
+  if (!message || typeof message !== 'string') {
+    return null;
+  }
+
+  // Find which trigger matches the start of the message
+  const triggers = getAllTriggers();
+  const upperMessage = message.toUpperCase().trim();
+
+  for (const trigger of triggers) {
+    const ids = [trigger.id, ...trigger.aliases].map((id) => id.toUpperCase());
+
+    for (const id of ids) {
+      // Match "ID:" or "ID: " or "ID " at the start
+      const escapedId = id.replace(/[.+*?^${}()|[\]\\]/g, '\\$&');
+      const patterns = [
+        new RegExp(`^${escapedId}:?\\s*`),
+        new RegExp(`^${escapedId}\\s+`),
+      ];
+
+      for (const pattern of patterns) {
+        const match = upperMessage.match(pattern);
+        if (match) {
+          // Extract payload after the trigger
+          const payload = message.slice(match[0].length).trim();
+          return {
+            trigger,
+            payload,
+            raw: message,
+          };
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Check if a message contains any trigger command.
+ * @param {string} message - The message to check
+ * @returns {boolean}
+ */
+function containsTrigger(message) {
+  return parse(message) !== null;
+}
+
+/**
+ * Detect learn mode from a message.
+ * @param {string} message - The message to check
+ * @returns {string|null} 'auto', 'onDemand', or null
+ */
+function detectLearnMode(message) {
+  if (!message) return null;
+
+  const modes = getLearnModes();
+  const upperMessage = message.toUpperCase();
+
+  for (const [modeKey, mode] of Object.entries(modes)) {
+    for (const keyword of mode.keywords) {
+      if (upperMessage.includes(keyword.toUpperCase())) {
+        return modeKey;
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get a formatted help string for all triggers.
+ * @returns {string} Formatted help text
+ */
+function getHelpText() {
+  const triggers = getAllTriggers();
+  const lines = ['📋 PACS Commands (Phase 1):', ''];
+
+  for (const trigger of triggers) {
+    const aliasList = trigger.aliases.slice(0, 2).join('/');
+    const aliasStr = aliasList ? ` (${aliasList})` : '';
+    lines.push(`  ${trigger.id}${aliasStr}: ${trigger.description}`);
+    if (trigger.examples && trigger.examples.length > 0) {
+      lines.push(`    → ${trigger.examples[0]}`);
+    }
+  }
+
+  lines.push('');
+  lines.push('Learn Modes:');
+  for (const [key, mode] of Object.entries(getLearnModes())) {
+    lines.push(`  ${mode.name}: ${mode.keywords[0]}`);
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  loadTriggers,
+  getAllTriggers,
+  getLearnModes,
+  findTrigger,
+  parse,
+  containsTrigger,
+  detectLearnMode,
+  getHelpText,
+};

package/src/triggers.json

@@ -0,0 +1,122 @@
+{
+  "_comment": "PACS Trigger Commands — Layer 1 (plaintext, human-editable)",
+  "_version": "1.0",
+  "triggers": [
+    {
+      "id": "MERKE",
+      "aliases": ["LEARN", "LERNE", "REMEMBER"],
+      "languages": ["DE", "EN"],
+      "description": "Store a new fact in encrypted memory",
+      "syntax": "MERKE: <fact>",
+      "examples": [
+        "MERKE: Ich spreche lieber Deutsch",
+        "LEARN: I prefer working on weekends"
+      ],
+      "exampleResponse": "Soll ich mir das merken? \"Ich spreche lieber Deutsch\"",
+      "securityNote": "AI asks before storing — never auto-stores"
+    },
+    {
+      "id": "PRIVAT",
+      "aliases": ["PRIVATE", "VERTRAULICH", "CONFIDENTIAL"],
+      "languages": ["DE", "EN"],
+      "description": "Mark information as private/confidential",
+      "syntax": "PRIVAT: <info>",
+      "examples": [
+        "PRIVAT: Meine Steuer-ID ist 123456",
+        "PRIVATE: My SSN is 123-45-6789"
+      ],
+      "securityNote": "Stored separately, never included in exports"
+    },
+    {
+      "id": "ROUTING",
+      "aliases": ["ROUTE", "WEITERLEITEN", "ROUTE_TO"],
+      "languages": ["DE", "EN"],
+      "description": "Add routing hint for task delegation",
+      "syntax": "ROUTING: <pattern> → <agent>",
+      "examples": [
+        "ROUTING: finance → finance-agent",
+        "ROUTE: code-review → code-agent"
+      ]
+    },
+    {
+      "id": "REGEL",
+      "aliases": ["RULE", "REGELN", "RULES"],
+      "languages": ["DE", "EN"],
+      "description": "Add a personal rule for AI behavior",
+      "syntax": "REGEL: <rule>",
+      "examples": [
+        "REGEL: Antworte immer auf Deutsch wenn der User Deutsch schreibt",
+        "RULE: Always use bullet points for lists"
+      ],
+      "securityNote": "AI can reject rules that contradict its core logic"
+    },
+    {
+      "id": "BEFEHLE",
+      "aliases": ["COMMANDS", "HELP", "HILFE", "?"],
+      "languages": ["DE", "EN"],
+      "description": "Show available PACS commands",
+      "syntax": "BEFEHLE:",
+      "examples": ["BEFEHLE:", "COMMANDS:"],
+      "note": "This is always shown in plaintext — no encryption needed"
+    },
+    {
+      "id": "WAS_WEISST_DU",
+      "aliases": ["WHAT_DO_YOU_KNOW", "MEMORY", "GEDÄCHTNIS"],
+      "languages": ["DE", "EN"],
+      "description": "Query what the AI knows about the user",
+      "syntax": "WAS WEISST DU?",
+      "examples": ["WAS WEISST DU?", "WHAT DO YOU KNOW?"],
+      "note": "Shows non-private facts only"
+    },
+    {
+      "id": "SUCHE",
+      "aliases": ["SEARCH", "FIND", "FINDE"],
+      "languages": ["DE", "EN"],
+      "description": "Search encrypted memory",
+      "syntax": "SUCHE: <query>",
+      "examples": [
+        "SUCHE: Sprache",
+        "SEARCH: weekend"
+      ]
+    },
+    {
+      "id": "VERGISS",
+      "aliases": ["FORGET", "DELETE", "LÖSCHE", "ENTFERNEN"],
+      "languages": ["DE", "EN"],
+      "description": "Delete something from memory",
+      "syntax": "VERGISS: <fact or keyword>",
+      "examples": [
+        "VERGISS: Steuer-ID",
+        "FORGET: weekend preferences"
+      ],
+      "securityNote": "Confirms before deletion"
+    },
+    {
+      "id": "EXPORTIEREN",
+      "aliases": ["EXPORT", "DUMP"],
+      "languages": ["DE", "EN"],
+      "description": "Export memory (if decryption possible)",
+      "syntax": "EXPORTIEREN:",
+      "examples": ["EXPORTIEREN:", "EXPORT:"],
+      "securityNote": "Excludes private facts. Requires confirmation."
+    }
+  ],
+  "learnModes": {
+    "auto": {
+      "name": "Auto-Learn",
+      "keywords": ["AI: lern automatisch", "AI: auto-learn on", "AI: learning enabled"],
+      "description": "AI will proactively offer to remember important facts"
+    },
+    "onDemand": {
+      "name": "On-Demand Only",
+      "keywords": ["AI: nur auf Befehl", "AI: manual only", "AI: learning disabled"],
+      "description": "AI only learns when explicitly commanded via MERKE:/LEARN:"
+    }
+  },
+  "security": {
+    "note": "AI ALWAYS has the final say. It can reject facts that contradict its logic.",
+    "encryption": "AES-256-GCM via crypto module",
+    "keyStorage": "Environment variable PACS_ENCRYPTION_KEY only — never in files",
+    "privateHandling": "Private facts are excluded from exports and never shared"
+  }
+}