kodelyth-ecc 1.4.0 → 1.4.1

package/.github/workflows/ci.yml

@@ -34,13 +34,12 @@ jobs:
       - name: Run test suite
         run: node tests/run-all.js
 
-      - name: Verify dashboard server syntax
-        run: node --check dashboard/server.js
-
-      - name: Verify all readers syntax
+      - name: Verify memory module syntax
         run: |
-          node --input-type=module < dashboard/lib/aggregator.js || true
-          for f in dashboard/lib/readers/*.js; do
-            node --check "$f" && echo "OK: $f"
-          done
+          node --check scripts/memory/store.js
+          node --check scripts/memory/inject.js
+          node --check scripts/memory/extract.js
+          node --check scripts/memory/cli.js
+          node --check hooks/memory/inject-start.js
+          node --check hooks/memory/capture-stop.js
         shell: bash

package/CHANGELOG.md

@@ -2,6 +2,38 @@
 
 All notable changes to Kodelyth ECC are documented here.
 
+## v1.4.1 — Auto Chat Detection for Memory (May 2026)
+
+### Added
+- **`UserPromptSubmit` hook: `hooks/memory/auto-recall.js`** — watches every prompt in real-time, runs BM25 search against your memory, and injects relevant matches into the AI's context **before it responds**
+- **Per-session repeat suppression** — never surfaces the same memory twice in one session (state at `~/.kodelyth/memory/session-surfaced-<id>.json`)
+- **Smart skip filters** — skips trivial prompts (`ok`, `yes`, `thanks`), agent invocations (`use foo`, `@bar`, `/help`), and prompts under 12 chars
+- **9 new tests** for the auto-recall hook (47 total passing — 26 existing + 12 memory + 9 auto-recall)
+
+### How it changes the experience
+Before v1.4.1: memory only injected once at session start, then the AI had to consciously decide to query it.
+
+After v1.4.1: every meaningful prompt the user types triggers an instant memory check. Relevant past solutions appear in the AI's context for that turn, automatically. No agent invocation needed. No `/memory recall` needed.
+
+### Example
+```
+You:  "I need to add Stripe webhooks for subscription renewals"
+       └─ Auto-recall fires → finds your March 2026 memory →
+          injects: "raw body parser, validate with constructEvent,
+                   test with stripe-cli not curl"
+AI:   "I checked your memory — you solved this exact problem in March.
+       The approach that worked was raw body parser before
+       signature validation. Want me to apply the same pattern?"
+```
+
+You never typed `/memory recall`. The AI just knew.
+
+### Honest limits
+- The hook fires on Claude Code's `UserPromptSubmit` event. Other platforms (Cursor, Codex, Windsurf, Antigravity) don't currently expose an equivalent pre-prompt hook — auto-recall there is limited to SessionStart injection.
+- Repeat suppression is per-session-id. If your platform doesn't pass a stable session_id, the same memory may surface twice across sessions (still better than none).
+
+---
+
 ## v1.4.0 — Local Self-Learning Memory (May 2026)
 
 ### Added — Kodelyth Memory

package/README.md

@@ -8,10 +8,11 @@
 ![Antigravity](https://img.shields.io/badge/Antigravity-Ready-00ADD8)
 ![Cursor](https://img.shields.io/badge/Cursor-Ready-3b82f6)
 ![Codex](https://img.shields.io/badge/Codex-Ready-10b981)
-![Version](https://img.shields.io/badge/version-1.4.0-orange)
+![Version](https://img.shields.io/badge/version-1.4.1-orange)
 ![Agents](https://img.shields.io/badge/Agents-59-brightgreen)
 ![Skills](https://img.shields.io/badge/Skills-188-brightgreen)
 ![Memory](https://img.shields.io/badge/Local%20Memory-on-blueviolet)
+![Auto Recall](https://img.shields.io/badge/Auto%20Chat%20Recall-on-blueviolet)
 
 </div>
 
@@ -180,7 +181,8 @@ Session 2 (August, new project):
 | **Capture** | A Stop hook scans your session JSONL, extracts (problem, approach, gotchas, tags). Queues for your review — never auto-stores. |
 | **Storage** | `~/.kodelyth/memory/memories.jsonl` — append-only log on your disk only. Override with `KODELYTH_MEMORY_DIR`. |
 | **Retrieval** | BM25 keyword + tag search. Pure JS, sub-millisecond, no embeddings, no network. |
-| **Injection** | A SessionStart hook builds a cache-friendly context block: stable prefix (your patterns + recent project memories) → variable suffix (relevant to current task). |
+| **Session-start injection** | A SessionStart hook builds a cache-friendly context block: stable prefix (your patterns + recent project memories) → variable suffix (relevant to current task). |
+| **Auto chat detection** *(v1.4.1)* | A `UserPromptSubmit` hook watches every message you type, runs BM25 search on it, and injects relevant memories **before the AI responds**. Per-session repeat suppression. Skips trivial / agent-command prompts. |
 | **Cost win** | The stable prefix sits in the prompt cache. Anthropic charges 10% on cached tokens (5-min TTL); OpenAI auto-caches prefixes ≥1024 tokens. Long sessions become dramatically cheaper. |
 
 ### Privacy
@@ -453,7 +455,13 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for templates, checklists, and the full K
 
 ## Changelog
 
-See [CHANGELOG.md](CHANGELOG.md). v1.4.0 highlights:
+See [CHANGELOG.md](CHANGELOG.md). v1.4.1 highlights:
+
+- **Added:** Auto chat detection — `UserPromptSubmit` hook watches every prompt, auto-injects relevant memories
+- **Added:** Per-session repeat suppression (no memory shown twice in same session)
+- **Added:** 9 new tests (47 total passing)
+
+v1.4.0 highlights:
 
 - **Added:** `kodelyth-memory` — local self-learning memory (BM25, zero deps, cache-friendly)
 - **Added:** SessionStart hook injects relevant past memories; Stop hook queues candidates for review

package/VERSION

@@ -1 +1 @@
-1.4.0
+1.4.1

package/hooks/hooks.json

@@ -139,6 +139,21 @@
         "id": "pre:mcp-health-check"
       }
     ],
+    "UserPromptSubmit": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/memory/auto-recall.js\"",
+            "async": false,
+            "timeout": 3
+          }
+        ],
+        "description": "Kodelyth Memory: auto-detect topic from each user prompt and inject relevant past memories before the AI responds (suppresses repeats per session)",
+        "id": "kodelyth:user-prompt:memory-auto-recall"
+      }
+    ],
     "PreCompact": [
       {
         "matcher": "*",

package/hooks/memory/auto-recall.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+// =============================================================================
+// Kodelyth ECC — Auto Chat Detection (Memory Auto-Recall)
+//
+// Triggered on UserPromptSubmit (every message the user sends).
+// Reads the prompt, searches memory in real-time, and injects relevant
+// matches as additional context BEFORE the AI sees the prompt.
+//
+// Behaviour:
+//   - Skips on prompts that are too short (< 12 chars) or trivial ("ok", "yes")
+//   - Skips on prompts that look like agent commands (`use foo`, `@bar`)
+//   - Skips when no memory exists yet
+//   - Suppresses repeats: never re-surfaces the same memory twice in a session
+//     (state file: ~/.kodelyth/memory/session-surfaced-<sessionId>.json)
+//   - Always exits 0 — never blocks the prompt because memory is unavailable
+// =============================================================================
+
+'use strict';
+
+const fs   = require('fs');
+const os   = require('os');
+const path = require('path');
+
+const MIN_PROMPT_CHARS    = 12;
+const MIN_TOKENS          = 2;
+const MAX_RECALLED        = 3;
+const MIN_SCORE           = 1.0;       // Higher than passive inject — we want strong signal
+const TRIVIAL_PROMPTS     = new Set(['ok', 'yes', 'no', 'thanks', 'thx', 'sure', 'go', 'cool', 'k']);
+const SKIP_PATTERN        = /^\s*(use\s+|@|\/|invoke\s+)/i;
+
+let payload = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { payload += chunk; });
+process.stdin.on('end', main);
+setTimeout(() => { if (!process.stdin.readableEnded) main(); }, 200);
+
+function main() {
+  try {
+    const data        = payload ? safeJson(payload) : {};
+    const userPrompt  = (data.prompt || data.user_prompt || data.text || '').trim();
+    const sessionId   = data.session_id || 'unknown';
+    const projectRoot = data.cwd || process.cwd();
+
+    if (!shouldRecall(userPrompt)) return done({});
+
+    // Lazy require so the hook doesn't crash if memory module breaks
+    const { recallForProject } = require(path.join(__dirname, '..', '..', 'scripts', 'memory', 'store'));
+
+    const matches = recallForProject(projectRoot, userPrompt, {
+      limit:    MAX_RECALLED * 2,   // grab extra so we can filter out repeats
+      minScore: MIN_SCORE,
+    });
+    if (matches.length === 0) return done({});
+
+    // Filter out memories already surfaced this session
+    const surfacedFile = surfacedStatePath(sessionId);
+    const surfaced     = loadSurfaced(surfacedFile);
+    const fresh        = matches.filter(m => !surfaced.has(m.id)).slice(0, MAX_RECALLED);
+    if (fresh.length === 0) return done({});
+
+    // Mark the freshly surfaced memories so they don't re-appear this session
+    for (const m of fresh) surfaced.add(m.id);
+    saveSurfaced(surfacedFile, surfaced);
+
+    const block = formatBlock(fresh, userPrompt);
+    done({
+      additionalContext: block,
+      meta: {
+        source:        'kodelyth-memory:auto-recall',
+        recalledCount: fresh.length,
+        surfacedTotal: surfaced.size,
+      },
+    });
+  } catch (err) {
+    process.stderr.write(`kodelyth-memory auto-recall: ${err.message}\n`);
+    done({});
+  }
+}
+
+function shouldRecall(prompt) {
+  if (!prompt || prompt.length < MIN_PROMPT_CHARS)        return false;
+  if (TRIVIAL_PROMPTS.has(prompt.toLowerCase().trim()))   return false;
+  if (SKIP_PATTERN.test(prompt))                          return false;
+  // Token gate — need at least N meaningful words
+  const meaningful = prompt
+    .toLowerCase()
+    .split(/\s+/)
+    .filter(w => w.length >= 4);
+  return meaningful.length >= MIN_TOKENS;
+}
+
+function formatBlock(memories, userPrompt) {
+  const lines = [];
+  lines.push('## Kodelyth Memory — relevant past solutions');
+  lines.push('');
+  lines.push(`Auto-detected from your message: "${userPrompt.slice(0, 100).replace(/\n/g, ' ')}${userPrompt.length > 100 ? '...' : ''}"`);
+  lines.push('');
+  for (const m of memories) {
+    lines.push(`- **${m.problem}**`);
+    if (m.approach) lines.push(`  Approach: ${m.approach.split('\n')[0].slice(0, 240)}`);
+    if (m.gotchas?.length) lines.push(`  Gotcha: ${m.gotchas[0].slice(0, 200)}`);
+    if (m.tags?.length) lines.push(`  Tags: ${m.tags.slice(0, 5).join(', ')}`);
+    lines.push(`  (memory id: ${m.id} · captured ${m.captured_at?.slice(0, 10)})`);
+  }
+  lines.push('');
+  lines.push('> Surface these to the user before answering only if they are genuinely relevant to the current task. If not, ignore silently — do not force-fit a memory.');
+  return lines.join('\n');
+}
+
+function surfacedStatePath(sessionId) {
+  const dir = process.env.KODELYTH_MEMORY_DIR
+    || path.join(os.homedir(), '.kodelyth', 'memory');
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  return path.join(dir, `session-surfaced-${sessionId}.json`);
+}
+
+function loadSurfaced(file) {
+  try {
+    if (!fs.existsSync(file)) return new Set();
+    return new Set(JSON.parse(fs.readFileSync(file, 'utf8')));
+  } catch {
+    return new Set();
+  }
+}
+
+function saveSurfaced(file, set) {
+  try {
+    fs.writeFileSync(file, JSON.stringify(Array.from(set)));
+  } catch {
+    /* non-fatal */
+  }
+}
+
+function safeJson(s) {
+  try { return JSON.parse(s); } catch { return {}; }
+}
+
+function done(obj) {
+  if (Object.keys(obj).length > 0) process.stdout.write(JSON.stringify(obj));
+  process.exit(0);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kodelyth-ecc",
-  "version": "1.4.0",
-  "description": "Production-grade AI coding toolkit — 59 agents, 188 skills, 79 commands, god-tier intent routing, local self-learning memory. Works with Claude Code, Windsurf, Cursor, Codex, Antigravity, and OpenCode.",
+  "version": "1.4.1",
+  "description": "Production-grade AI coding toolkit — 59 agents, 188 skills, 80 commands, god-tier intent routing, local self-learning memory with auto chat detection. Works with Claude Code, Windsurf, Cursor, Codex, Antigravity, and OpenCode.",
   "author": "Kodelyth <github.com/sifxprime>",
   "license": "MIT",
   "repository": {
@@ -21,6 +21,7 @@
     "llm",
     "memory",
     "self-learning",
+    "auto-recall",
     "kodelyth"
   ],
   "bin": {

package/tests/memory/auto-recall.test.js

@@ -0,0 +1,132 @@
+// Tests for hooks/memory/auto-recall.js — UserPromptSubmit auto chat detection
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs   = require('fs');
+const os   = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const TMP = fs.mkdtempSync(path.join(os.tmpdir(), 'kodelyth-recall-'));
+process.env.KODELYTH_MEMORY_DIR = TMP;
+
+const HOOK = path.join(__dirname, '..', '..', 'hooks', 'memory', 'auto-recall.js');
+const store = require('../../scripts/memory/store');
+
+function runHook(payload) {
+  const res = spawnSync(process.execPath, [HOOK], {
+    input:    JSON.stringify(payload),
+    encoding: 'utf8',
+    env:      { ...process.env, KODELYTH_MEMORY_DIR: TMP },
+    timeout:  5000,
+  });
+  return { stdout: res.stdout || '', stderr: res.stderr || '', status: res.status };
+}
+
+// Seed memory once
+store.capture({
+  problem:  'Stripe webhook signature failed in production',
+  approach: 'Switched body parser from json to raw, validated with constructEvent',
+  tags:     ['payments', 'stripe', 'webhooks'],
+  project:  '/test/payments',
+  language: 'typescript',
+});
+store.capture({
+  problem:  'Redis cluster split-brain after AZ failover',
+  approach: 'Configured min-slaves-to-write to 2 to prevent stale primary writes',
+  tags:     ['redis', 'cluster', 'reliability'],
+  project:  '/test/payments',
+  language: 'typescript',
+});
+
+test('auto-recall: returns nothing for empty prompt', () => {
+  const r = runHook({ prompt: '', cwd: '/test/payments', session_id: 's1' });
+  assert.equal(r.status, 0);
+  assert.equal(r.stdout, '');
+});
+
+test('auto-recall: skips trivial prompts', () => {
+  for (const trivial of ['ok', 'yes', 'thanks', 'cool']) {
+    const r = runHook({ prompt: trivial, cwd: '/test/payments', session_id: 's-trivial' });
+    assert.equal(r.stdout, '', `should skip "${trivial}"`);
+  }
+});
+
+test('auto-recall: skips agent invocation prompts', () => {
+  for (const cmd of ['use debug-detective', '@code-reviewer', '/help', 'invoke security-reviewer']) {
+    const r = runHook({ prompt: cmd, cwd: '/test/payments', session_id: 's-cmd' });
+    assert.equal(r.stdout, '', `should skip "${cmd}"`);
+  }
+});
+
+test('auto-recall: skips short prompts', () => {
+  const r = runHook({ prompt: 'fix bug', cwd: '/test/payments', session_id: 's-short' });
+  assert.equal(r.stdout, '');
+});
+
+test('auto-recall: surfaces relevant memory for a real query', () => {
+  const r = runHook({
+    prompt: 'I need to add Stripe webhooks for subscription renewal events',
+    cwd:    '/test/payments',
+    session_id: 's-fire-1',
+  });
+  assert.equal(r.status, 0);
+  assert.ok(r.stdout.length > 0, 'should produce output');
+  const out = JSON.parse(r.stdout);
+  assert.ok(out.additionalContext.includes('Stripe webhook'));
+  assert.equal(out.meta.source, 'kodelyth-memory:auto-recall');
+  assert.equal(out.meta.recalledCount, 1);
+});
+
+test('auto-recall: suppresses repeat in same session', () => {
+  // First call surfaces the memory
+  runHook({
+    prompt: 'help with stripe webhook integration',
+    cwd:    '/test/payments',
+    session_id: 's-repeat',
+  });
+  // Second call same topic — should NOT surface again
+  const r2 = runHook({
+    prompt: 'about that stripe webhook problem, what about retries',
+    cwd:    '/test/payments',
+    session_id: 's-repeat',
+  });
+  assert.equal(r2.stdout, '', 'repeat should be suppressed');
+});
+
+test('auto-recall: surfaces different memory for different topic in same session', () => {
+  runHook({
+    prompt: 'how do I handle stripe webhook errors',
+    cwd:    '/test/payments',
+    session_id: 's-multi',
+  });
+  // Different topic — redis — should surface
+  const r2 = runHook({
+    prompt: 'redis cluster is acting weird after failover today',
+    cwd:    '/test/payments',
+    session_id: 's-multi',
+  });
+  assert.ok(r2.stdout.length > 0, 'different topic should surface');
+  const out = JSON.parse(r2.stdout);
+  assert.ok(out.additionalContext.toLowerCase().includes('redis'));
+});
+
+test('auto-recall: returns nothing when no memory matches', () => {
+  const r = runHook({
+    prompt: 'what is the meaning of life and quantum entanglement',
+    cwd:    '/test/payments',
+    session_id: 's-nomatch',
+  });
+  assert.equal(r.stdout, '');
+});
+
+test('auto-recall: never crashes on malformed payload', () => {
+  const res = spawnSync(process.execPath, [HOOK], {
+    input:    'not-json-at-all',
+    encoding: 'utf8',
+    env:      { ...process.env, KODELYTH_MEMORY_DIR: TMP },
+    timeout:  3000,
+  });
+  assert.equal(res.status, 0, 'must exit 0 even on garbage input');
+});