pi-hermes-memory 0.7.3 → 0.7.4

package/README.md

@@ -119,7 +119,7 @@ System Prompt
 └─────────────────────────────────────────┘
 ```
 
-Set `"memoryPolicyStyle"` to `"compact"`, `"custom"`, or `"none"` to change only the policy text while keeping policy-only mode. Set `"memoryMode": "legacy-inject"` to restore the old behavior that injects MEMORY.md, USER.md, project memory, recent failures, and the skill index into the prompt.
+Set `"memoryPolicyStyle"` to `"full"`, `"compact"`, `"custom"`, or `"none"` to choose policy verbosity while keeping policy-only mode. Set `"memoryMode": "legacy-inject"` to restore the old behavior that injects MEMORY.md, USER.md, project memory, recent failures, and the skill index into the prompt.
 
 ## Failure Memory
 
@@ -385,6 +385,10 @@ Create `~/.pi/agent/hermes-memory-config.json`:
 | `reviewEnabled` | `true` | Enable/disable background learning loop |
 | `autoConsolidate` | `true` | Auto-merge when memory hits capacity |
 | `correctionDetection` | `true` | Detect user corrections and save immediately |
+| `correctionStrongPatterns` | unset | Optional case-insensitive regex sources replacing strong correction patterns; omitted preserves defaults, invalid entries are ignored |
+| `correctionWeakPatterns` | unset | Optional case-insensitive regex sources replacing weak correction patterns; omitted preserves defaults, invalid entries are ignored |
+| `correctionNegativePatterns` | unset | Optional case-insensitive regex sources replacing negative correction patterns; omitted preserves defaults, invalid entries are ignored |
+| `correctionDirectiveWords` | unset | Optional directive words replacing the weak-pattern directive words; omitted preserves defaults |
 | `failureInjectionEnabled` | `true` | Legacy mode only: enable/disable injecting recent failure memories into the system prompt |
 | `failureInjectionMaxAgeDays` | `7` | Legacy mode only: maximum age in days for injected failure memories |
 | `failureInjectionMaxEntries` | `5` | Legacy mode only: maximum number of failure memories to inject |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hermes-memory",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "description": "🧠 Persistent memory + 🔍 session search + 🛡️ secret scanning for Pi. Token-aware policy-only memory by default, SQLite FTS5 search, auto-consolidation, procedural skills. 368 tests. Ported from Hermes agent.",
   "type": "module",
   "main": "src/index.ts",

package/src/config.ts

@@ -45,16 +45,19 @@ export const DEFAULT_CONFIG_PATH = path.join(
   "hermes-memory-config.json",
 );
 
-export function loadConfig(): MemoryConfig {
+export function loadConfig(configPath = DEFAULT_CONFIG_PATH): MemoryConfig {
   try {
-    if (fs.existsSync(DEFAULT_CONFIG_PATH)) {
-      const raw = fs.readFileSync(DEFAULT_CONFIG_PATH, "utf-8");
+    if (fs.existsSync(configPath)) {
+      const raw = fs.readFileSync(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       // Merge: override defaults with user config
       const config: MemoryConfig = { ...DEFAULT_CONFIG };
       const isNonNegativeNumber = (value: unknown): value is number => (
         typeof value === "number" && Number.isFinite(value) && value >= 0
       );
+      const isStringArray = (value: unknown): value is string[] => (
+        Array.isArray(value) && value.every((item) => typeof item === "string")
+      );
       if (parsed.memoryMode === "policy-only" || parsed.memoryMode === "legacy-inject") config.memoryMode = parsed.memoryMode;
       if (
         parsed.memoryPolicyStyle === "full" ||
@@ -74,6 +77,10 @@ export function loadConfig(): MemoryConfig {
       if (isNonNegativeNumber(parsed.flushRecentMessages)) config.flushRecentMessages = parsed.flushRecentMessages;
       if (typeof parsed.autoConsolidate === "boolean") config.autoConsolidate = parsed.autoConsolidate;
       if (typeof parsed.correctionDetection === "boolean") config.correctionDetection = parsed.correctionDetection;
+      if (isStringArray(parsed.correctionStrongPatterns)) config.correctionStrongPatterns = parsed.correctionStrongPatterns;
+      if (isStringArray(parsed.correctionWeakPatterns)) config.correctionWeakPatterns = parsed.correctionWeakPatterns;
+      if (isStringArray(parsed.correctionNegativePatterns)) config.correctionNegativePatterns = parsed.correctionNegativePatterns;
+      if (isStringArray(parsed.correctionDirectiveWords)) config.correctionDirectiveWords = parsed.correctionDirectiveWords;
       if (typeof parsed.failureInjectionEnabled === "boolean") config.failureInjectionEnabled = parsed.failureInjectionEnabled;
       if (typeof parsed.failureInjectionMaxAgeDays === "number") config.failureInjectionMaxAgeDays = parsed.failureInjectionMaxAgeDays;
       if (typeof parsed.failureInjectionMaxEntries === "number") config.failureInjectionMaxEntries = parsed.failureInjectionMaxEntries;

package/src/constants.ts

@@ -182,6 +182,33 @@ export const CORRECTION_NEGATIVE_PATTERNS: RegExp[] = [
   /^stop.{0,5}(there|here|for now)/i,
 ];
 
+/** Directive words required after weak correction patterns */
+export const CORRECTION_DIRECTIVE_WORDS: string[] = [
+  "use",
+  "don't",
+  "dont",
+  "do",
+  "try",
+  "make",
+  "run",
+  "install",
+  "add",
+  "remove",
+  "delete",
+  "change",
+  "fix",
+  "put",
+  "set",
+  "write",
+  "go",
+  "stop",
+  "start",
+  "the",
+  "that",
+  "this",
+  "it",
+];
+
 // ─── Correction save prompt ───
 export const CORRECTION_SAVE_PROMPT = `The user just corrected you. Review what went wrong and save the correction to persistent memory.
 

package/src/handlers/correction-detector.ts

@@ -20,6 +20,7 @@ import {
   CORRECTION_STRONG_PATTERNS,
   CORRECTION_WEAK_PATTERNS,
   CORRECTION_NEGATIVE_PATTERNS,
+  CORRECTION_DIRECTIVE_WORDS,
   ENTRY_DELIMITER,
 } from "../constants.js";
 import type { MemoryConfig } from "../types.js";
@@ -38,23 +39,71 @@ function extractCorrectionDirective(text: string): string {
   return cleaned || text;
 }
 
+function compileCorrectionPatterns(
+  configured: string[] | undefined,
+  defaults: RegExp[],
+): RegExp[] {
+  if (configured === undefined) return defaults;
+
+  const patterns: RegExp[] = [];
+  for (const source of configured) {
+    try {
+      patterns.push(new RegExp(source, "i"));
+    } catch {
+      // Ignore invalid configured regex entries; valid entries still apply.
+    }
+  }
+  return patterns;
+}
+
+function escapeRegexLiteral(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function hasDirectiveWord(remainder: string, words: string[]): boolean {
+  if (words.length === 0) return false;
+  const source = words.map(escapeRegexLiteral).join("|");
+  return new RegExp(`\\b(${source})\\b`, "i").test(remainder);
+}
+
 /**
  * Check if a user message is a correction using the two-pass filter.
  * Returns true if the message should trigger an immediate save.
  */
-export function isCorrection(text: string): boolean {
+type CorrectionPatternConfig = Pick<MemoryConfig,
+  "correctionStrongPatterns" |
+  "correctionWeakPatterns" |
+  "correctionNegativePatterns" |
+  "correctionDirectiveWords"
+>;
+
+export function isCorrection(text: string, config?: CorrectionPatternConfig): boolean {
+  const negativePatterns = compileCorrectionPatterns(
+    config?.correctionNegativePatterns,
+    CORRECTION_NEGATIVE_PATTERNS,
+  );
+  const strongPatterns = compileCorrectionPatterns(
+    config?.correctionStrongPatterns,
+    CORRECTION_STRONG_PATTERNS,
+  );
+  const weakPatterns = compileCorrectionPatterns(
+    config?.correctionWeakPatterns,
+    CORRECTION_WEAK_PATTERNS,
+  );
+  const directiveWords = config?.correctionDirectiveWords ?? CORRECTION_DIRECTIVE_WORDS;
+
   // Check negative patterns first — suppress even if positive matches
-  for (const pattern of CORRECTION_NEGATIVE_PATTERNS) {
+  for (const pattern of negativePatterns) {
     if (pattern.test(text)) return false;
   }
 
   // Check strong patterns — always trigger
-  for (const pattern of CORRECTION_STRONG_PATTERNS) {
+  for (const pattern of strongPatterns) {
     if (pattern.test(text)) return true;
   }
 
   // Check weak patterns — only trigger if followed by a directive clause
-  for (const pattern of CORRECTION_WEAK_PATTERNS) {
+  for (const pattern of weakPatterns) {
     if (pattern.test(text)) {
       // Look for a directive after the weak pattern match
       // Directive = a verb or "the/that/this" in the remainder of the text
@@ -62,7 +111,7 @@ export function isCorrection(text: string): boolean {
       if (match && match.index === 0) {
         const remainder = text.slice(match[0].length).trim();
         // Simple heuristic: remainder contains something directive-ish
-        if (/\b(use|don'?t|do|try|make|run|install|add|remove|delete|change|fix|put|set|write|go|stop|start|the|that|this|it)\b/i.test(remainder)) {
+        if (hasDirectiveWord(remainder, directiveWords)) {
           return true;
         }
       }
@@ -91,7 +140,7 @@ export function setupCorrectionDetector(
     if (event.message.role !== "user") return;
     const text = getMessageText(event.message);
     if (!text) return;
-    if (isCorrection(text)) {
+    if (isCorrection(text, config)) {
       pendingCorrection = true;
     }
   });

package/src/types.ts

@@ -39,6 +39,14 @@ export interface MemoryConfig {
   autoConsolidate: boolean;
   /** Detect user corrections and trigger immediate memory save. Default: true */
   correctionDetection: boolean;
+  /** Override strong correction regex sources. Missing = defaults; [] = none. */
+  correctionStrongPatterns?: string[];
+  /** Override weak correction regex sources. Missing = defaults; [] = none. */
+  correctionWeakPatterns?: string[];
+  /** Override negative correction regex sources. Missing = defaults; [] = none. */
+  correctionNegativePatterns?: string[];
+  /** Override directive words used after weak correction patterns. Missing = defaults; [] = none. */
+  correctionDirectiveWords?: string[];
   /** Inject recent failure memories into the system prompt. Default: true */
   failureInjectionEnabled: boolean;
   /** Maximum age in days for injected failure memories. Default: 7 */