pi-hermes-memory 0.3.0 → 0.3.2

package/README.md

@@ -18,6 +18,7 @@ Your Pi agent normally forgets everything when you close a session. This extensi
 | **Context Fencing** | Memory blocks are wrapped in `<memory-context>` tags so the LLM never treats stored facts as user instructions |
 | **Memory Aging** | Entries carry timestamps — consolidation knows which facts are stale and which are fresh |
 | **Project Memory** | Per-project memory (`~/.pi/agent/<project>/MEMORY.md`) alongside your global memory |
+| **Secret Detection** | API keys, tokens, SSH keys, and credential assignments are blocked from being persisted to memory |
 
 ## How It Works
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hermes-memory",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Your Pi agent remembers everything across sessions — your preferences, your stack, your corrections, and even how it solved problems. Zero-config install, works immediately. Persistent memory + procedural skills + auto-correction detection + security-first content scanning.",
   "type": "module",
   "main": "src/index.ts",

package/src/store/content-scanner.ts

@@ -18,13 +18,46 @@ const MEMORY_THREAT_PATTERNS: Array<{ pattern: RegExp; id: string }> = [
   { pattern: /\$HOME\/\.ssh|~\/\.ssh/i, id: "ssh_access" },
 ];
 
+/**
+ * Secret detection patterns — checks for credentials, API keys, tokens, and
+ * environment variable leaks that should never be persisted to memory.
+ * Ported from pk-pi-hermes-evolve engine.ts scanForSecrets().
+ */
+const SECRET_PATTERNS: Array<{ pattern: RegExp; id: string; severity: "high" | "medium" }> = [
+  // API keys
+  { pattern: /\bsk-ant-api\S{10,}\b/, id: "anthropic_api_key", severity: "high" },
+  { pattern: /\bsk-or-v1-\S{10,}\b/, id: "openrouter_api_key", severity: "high" },
+  { pattern: /\bsk-\S{20,}\b/, id: "openai_api_key", severity: "high" },
+  { pattern: /\bAKIA[0-9A-Z]{16}\b/, id: "aws_access_key", severity: "high" },
+  // Tokens
+  { pattern: /\bghp_\S{10,}\b/, id: "github_personal_token", severity: "high" },
+  { pattern: /\bghu_\S{10,}\b/, id: "github_user_token", severity: "high" },
+  { pattern: /\bxoxb-\S{10,}\b/, id: "slack_bot_token", severity: "high" },
+  { pattern: /\bxapp-\S{10,}\b/, id: "slack_app_token", severity: "high" },
+  { pattern: /\bntn_\S{10,}\b/, id: "notion_token", severity: "high" },
+  { pattern: /\bBearer\s+\S{20,}\b/, id: "bearer_auth_token", severity: "high" },
+  // SSH keys
+  { pattern: /-----BEGIN\s+(?:RSA\s+)?PRIVATE\sKEY-----/, id: "private_key_block", severity: "high" },
+  // Environment variable names that indicate secrets
+  { pattern: /\bANTHROPIC_API_KEY\b/, id: "env_anthropic_key", severity: "medium" },
+  { pattern: /\bOPENAI_API_KEY\b/, id: "env_openai_key", severity: "medium" },
+  { pattern: /\bOPENROUTER_API_KEY\b/, id: "env_openrouter_key", severity: "medium" },
+  { pattern: /\bGITHUB_TOKEN\b/, id: "env_github_token", severity: "medium" },
+  { pattern: /\bAWS_SECRET_ACCESS_KEY\b/, id: "env_aws_secret", severity: "medium" },
+  { pattern: /\bDATABASE_URL\b/, id: "env_database_url", severity: "medium" },
+  // Inline secret assignments (likely accidental paste)
+  { pattern: /\bpassword\s*[=:]\s*\S{6,}\b/i, id: "password_assignment", severity: "medium" },
+  { pattern: /\bsecret\s*[=:]\s*\S{6,}\b/i, id: "secret_assignment", severity: "medium" },
+  { pattern: /\btoken\s*[=:]\s*\S{10,}\b/i, id: "token_assignment", severity: "medium" },
+];
+
 const INVISIBLE_CHARS = new Set([
   '\u200b', '\u200c', '\u200d', '\u2060', '\ufeff',
   '\u202a', '\u202b', '\u202c', '\u202d', '\u202e',
 ]);
 
 /**
- * Scan memory content for injection/exfiltration patterns.
+ * Scan memory content for injection/exfiltration patterns AND secret leaks.
  * Returns an error string if blocked, or null if content is safe.
  */
 export function scanContent(content: string): string | null {
@@ -42,5 +75,27 @@ export function scanContent(content: string): string | null {
     }
   }
 
+  // Check secret patterns
+  for (const { pattern, id, severity } of SECRET_PATTERNS) {
+    if (pattern.test(content)) {
+      return `Blocked: content looks like a ${severity}-severity credential or secret ('${id}'). Never persist API keys, tokens, or passwords to memory. Use an .env file or secrets manager instead.`;
+    }
+  }
+
   return null;
 }
+
+/**
+ * Scan content for secrets only (no threat patterns).
+ * Returns an array of matched secret IDs, or empty array if none found.
+ * Useful for non-blocking warnings (e.g., pre-fill checks in interviews).
+ */
+export function scanSecrets(content: string): string[] {
+  const found: string[] = [];
+  for (const { pattern, id } of SECRET_PATTERNS) {
+    if (pattern.test(content)) {
+      found.push(id);
+    }
+  }
+  return found;
+}

package/src/store/memory-store.ts

@@ -92,6 +92,10 @@ export class MemoryStore {
   // ─── CRUD ───
 
   async add(target: "memory" | "user", content: string, signal?: AbortSignal): Promise<MemoryResult> {
+    return this._add(target, content, signal);
+  }
+
+  private async _add(target: "memory" | "user", content: string, signal?: AbortSignal, _retriesLeft = 1): Promise<MemoryResult> {
     content = content.trim();
     if (!content) return { success: false, error: "Content cannot be empty." };
 
@@ -113,27 +117,15 @@ export class MemoryStore {
 
     const newTotal = [...entries, encoded].join(ENTRY_DELIMITER).length;
     if (newTotal > limit) {
-      // Auto-consolidate if configured and consolidator available
-      if (this.config.autoConsolidate && this.consolidator) {
-        // Track consolidation attempts to prevent infinite recursion
-        // when the consolidator fails to free enough space
-        const beforeCount = entries.length;
+      // Auto-consolidate once if configured — limit retries to prevent infinite loops
+      if (this.config.autoConsolidate && this.consolidator && _retriesLeft > 0) {
         try {
           const result = await this.consolidator(target, signal);
           if (result.consolidated) {
             // CRITICAL: reload from disk — child process modified files, our arrays are stale
             await this.loadFromDisk();
-            // Guard: if consolidation didn't reduce entries, stop recursing
-            const afterEntries = this.entriesFor(target);
-            const afterCount = afterEntries.length;
-            if (afterCount >= beforeCount && afterCount > 0) {
-              return {
-                success: false,
-                error: `Memory at capacity and consolidation did not free enough space. Entry count unchanged at ${afterCount}.`,
-              };
-            }
-            // Retry the add with fresh data
-            return this.add(target, content, signal);
+            // Retry the add exactly once (retriesLeft = 0 means no more consolidation)
+            return this._add(target, content, signal, _retriesLeft - 1);
           }
         } catch {
           // Consolidation failed — fall through to error