fix(eliza): Complete rules from official instructions.txt source

- Add missing 'xnone' keyword (critical fallback rule)
- Generate correct rules from official Weizenbaum instructions.txt
- All 36 keywords now present, matching Python eliza_solution.ipynb
- Fix array substitution handling (i'm → i am, you're → you are)
- Add punctuation handling methods matching Python implementation
- Use xnone keyword for fallback instead of random fallback array
- Add scripts to compare and generate rules from official source

Fixes #26, #28

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: jeremymanning

demos/01-eliza/data/eliza-rules.json

@@ -13,8 +13,14 @@
     "machine": "computer",
     "computers": "computer",
     "were": "was",
-    "you're": "you are",
-    "i'm": "i am",
+    "you're": [
+      "you",
+      "are"
+    ],
+    "i'm": [
+      "i",
+      "am"
+    ],
     "same": "alike"
   },
   "postSubstitutions": {
@@ -26,7 +32,10 @@
     "i": "you",
     "you": "me",
     "my": "your",
-    "i'm": "you are"
+    "i'm": [
+      "you",
+      "are"
+    ]
   },
   "synonyms": {
     "belief": [
@@ -89,6 +98,20 @@
     "That will be $200."
   ],
   "rules": [
+    {
+      "keyword": "xnone",
+      "patterns": [
+        {
+          "pattern": "*",
+          "responses": [
+            "I'm not sure I understand you fully.",
+            "Please go on.",
+            "What does that suggest to you ?",
+            "Do you feel strongly about discussing such things ?"
+          ]
+        }
+      ]
+    },
     {
       "keyword": "sorry",
       "patterns": [
@@ -586,13 +609,14 @@
           ]
         },
         {
-          "pattern": "$ * my *",
+          "pattern": "* my *",
           "responses": [
             "Your (2) .",
             "Let's discuss your (2) further .",
             "What does your (2) mean to you ?",
             "Tell me more about your (2) ."
-          ]
+          ],
+          "save": true
         },
         {
           "pattern": "* my *",
@@ -761,8 +785,7 @@
             "Really, always ?"
           ]
         }
-      ],
-      "rank": 1
+      ]
     },
     {
       "keyword": "alike",

demos/01-eliza/js/eliza-engine.js

@@ -185,7 +185,7 @@ export class ElizaEngine {
     } else {
       // No match found
 
-      // Try to use memory if available
+      // Step 7: Try to use memory if available (matching Python solution)
       if (this.memoryStack.length > 0) {
         const memory = this.memoryStack.pop();
         // Recursively call getResponse with the memory, forcing saveOverride=true
@@ -199,17 +199,42 @@ export class ElizaEngine {
         return memoryResponse;
       }
 
-      // Use fallback if no memory available
-      response = this.fallbacks[Math.floor(Math.random() * this.fallbacks.length)];
-      // Convert to uppercase to match original ELIZA behavior
-      response = response.toUpperCase();
-      matchInfo = {
-        keyword: 'fallback',
-        pattern: 'none',
-        rank: 0,
-        template: response,
-        captures: []
-      };
+      // Step 8: Use xnone keyword as fallback (matching Python solution exactly)
+      // The Python solution does: words = self.respond('xnone')
+      const xnoneRule = this.rules.find(r => r.keyword === 'xnone');
+      if (xnoneRule && xnoneRule.patterns && xnoneRule.patterns.length > 0) {
+        const xnonePattern = xnoneRule.patterns[0];
+        const patternKey = 'xnone:*';
+
+        if (!this.responseIndices[patternKey]) {
+          this.responseIndices[patternKey] = 0;
+        }
+
+        const responseIndex = this.responseIndices[patternKey];
+        response = xnonePattern.responses[responseIndex];
+
+        // Cycle to next response
+        this.responseIndices[patternKey] =
+          (responseIndex + 1) % xnonePattern.responses.length;
+
+        matchInfo = {
+          keyword: 'xnone',
+          pattern: '*',
+          rank: 0,
+          template: response,
+          captures: []
+        };
+      } else {
+        // Ultimate fallback if xnone rule is missing
+        response = this.fallbacks[Math.floor(Math.random() * this.fallbacks.length)];
+        matchInfo = {
+          keyword: 'fallback',
+          pattern: 'none',
+          rank: 0,
+          template: response,
+          captures: []
+        };
+      }
     }
 
     // Add to conversation history

demos/01-eliza/js/pattern-matcher.js

@@ -5,6 +5,40 @@
 export class PatternMatcher {
   constructor() {
     this.debugMode = false;
+    // Punctuation that splits input - matches Python solution exactly
+    // 'but' is treated as a clause separator (like the Python solution)
+    this.punctuation = [',', ':', ';', '!', '.', '?', 'but'];
+  }
+
+  /**
+   * Strip punctuation characters from a word
+   */
+  stripPunctuation(word) {
+    return word.replace(/[,:;!.?]/g, '');
+  }
+
+  /**
+   * Parse punctuation: truncate at first punctuation occurrence
+   * Following the Python solution's parse_punctuation method
+   */
+  parsePunctuation(words) {
+    const result = [];
+    for (const word of words) {
+      // Check if word is a punctuation separator (like 'but')
+      if (this.punctuation.includes(word.toLowerCase())) {
+        break;
+      }
+      // Check if word contains punctuation - strip it and potentially stop
+      const stripped = this.stripPunctuation(word);
+      if (stripped) {
+        result.push(stripped);
+      }
+      // If word ended with punctuation, stop processing
+      if (word !== stripped && /[,:;!.?]$/.test(word)) {
+        break;
+      }
+    }
+    return result;
   }
 
   /**
@@ -18,8 +52,10 @@ export class PatternMatcher {
       const regex = new RegExp('\\b' + from + '\\b', 'gi');
       if (regex.test(result)) {
         const oldResult = result;
-        result = result.replace(regex, to);
-        steps.push({ from, to, before: oldResult, after: result });
+        // Handle array replacements (e.g., "i'm" → ["i", "am"])
+        const replacement = Array.isArray(to) ? to.join(' ') : to;
+        result = result.replace(regex, replacement);
+        steps.push({ from, to: replacement, before: oldResult, after: result });
       }
     }
 
@@ -47,9 +83,11 @@ export class PatternMatcher {
         const oldResult = result;
         // Use a unique placeholder that won't match any substitution pattern
         const placeholder = `__POSTSUB_${placeholderIndex++}__`;
-        placeholders.set(placeholder, to);
+        // Handle array replacements (e.g., "i'm" → ["you", "are"])
+        const replacement = Array.isArray(to) ? to.join(' ') : to;
+        placeholders.set(placeholder, replacement);
         result = result.replace(regex, placeholder);
-        steps.push({ from, to, before: oldResult.trim(), after: result.trim() });
+        steps.push({ from, to: replacement, before: oldResult.trim(), after: result.trim() });
       }
     }
 
@@ -98,12 +136,15 @@ export class PatternMatcher {
    * Returns: { matched: true, captures: [[], [], ['unhappy'], []] }
    */
   matchPattern(input, pattern, synonyms) {
-    // Split input into words, stripping punctuation
-    const inputWords = input.toLowerCase()
-      .replace(/[.,!?;:]/g, ' ')
+    // Split input into words, preserving punctuation for now
+    const rawWords = input.toLowerCase()
       .split(/\s+/)
       .filter(w => w.length > 0);
 
+    // Strip punctuation from each word for matching purposes
+    const inputWords = rawWords.map(w => this.stripPunctuation(w))
+      .filter(w => w.length > 0);
+
     // Split pattern into parts
     const patternParts = pattern.toLowerCase()
       .split(/\s+/)