kodelyth-ecc 2.5.2 → 2.5.4

package/CHANGELOG.md

@@ -2,6 +2,40 @@
 
 All notable changes to Kodelyth ECC are documented here.
 
+## v2.5.4 — Memory: direct capture CLI + aggressive auto-capture (July 2026)
+
+Two memory improvements after an end-to-end verification pass confirmed the pipeline works but only captured when the user said "thanks".
+
+### Added
+
+- **`kodelythecc memory` subcommand** — manage the local BM25 memory directly:
+  - `memory capture --problem "…" --approach "…" [--tags a,b] [--language ts] [--files a,b]` — store a fix on the spot, **no review queue**
+  - `memory recall "<query>" [--limit N]` — BM25 search
+  - `memory list` · `memory stats`
+  - Wired into `--help` (`kodelythecc memory --help`).
+
+### Changed
+
+- **Auto-capture is now more aggressive.** Previously it only queued a memory when a user message contained a success phrase ("that worked", "perfect", "thanks"). It now **also** captures on a real verification signal — an `Edit`/`Write` followed by a passing test or successful build (`exit code 0`, `tests passed`, `build succeeded`, `PASS`, …) — even without a spoken acknowledgement. This catches fixes you verified but never verbally confirmed. Opt out with `KODELYTH_CAPTURE_AGGRESSIVE=0`.
+
+### Verified
+
+- End-to-end: capture → persist → recall across processes; `auto-recall` hook injects past fixes; `auto-capture` hook queues from a real `.message`-nested transcript; `doctor` memory checks pass.
+- New regression tests: aggressive path captures without "thanks"; opt-out flag disables it. Full suite 0 failures.
+
+## v2.5.3 — Devil Mode + Memory cards for "How it works" (July 2026)
+
+### Added
+
+- `social/card-devil.svg` — Devil Mode feature card: "8 agents that attack your code first", the 8-agent adversarial grid + `/devil-mode --all`. Red accent.
+- `social/card-memory.svg` — Compound Memory card: "It remembers what worked last time", the BM25 recall flow (prompt → recalled fix → injected into context). Violet accent.
+- Both wired into the site's "How it works" showcase — now 8 features (routing, RTK, Terse, codebase, MCP, CLI, devil mode, memory), all in the taller card format with summaries.
+
+### Changed
+
+- SVG version badges v2.5.2 → v2.5.3; 8K PNGs re-rendered across the set.
+- Fresh GitHub social preview render (196 skills, v2.5.3) at 8K + upload-ready 2×.
+
 ## v2.5.2 — Broken README image fix + brand polish (July 2026)
 
 ### Fixed

package/VERSION

@@ -1 +1 @@
-2.5.2
+2.5.4

package/bin/kodelyth-ecc.js

@@ -118,6 +118,21 @@ if (args[1] === '--help' || args[1] === '-h') {
   install target, hook registration, memory recall, MCP registration + boot,
   prompt-injection guard, RTK, Terse, codebase graph. Run it if anything
   feels off — it pinpoints exactly what's not wired and how to fix it.
+`,
+    memory: `
+  kodelyth-ecc memory — local BM25 self-learning memory
+
+  Usage:
+    kodelythecc memory capture --problem "<what was hard>" --approach "<what worked>" [--tags a,b] [--language ts] [--files a,b]
+    kodelythecc memory recall "<query>" [--limit N]
+    kodelythecc memory list
+    kodelythecc memory stats
+
+  'capture' stores directly (no review queue) — use it to remember a fix on
+  the spot. Auto-recall/auto-capture also run via hooks in your AI tool.
+  Storage: ~/.kodelythecc/memory/ · 100% local, zero telemetry.
+  Auto-capture aggressiveness: it also captures on edit + passing test even
+  without a spoken "thanks"; set KODELYTH_CAPTURE_AGGRESSIVE=0 to opt out.
 `,
   };
   const cmd = args[0];
@@ -353,6 +368,62 @@ if (args[0] === 'rtk') {
 
 // ── Subcommand: doctor (live subsystem health check) ─────────────────────────
 // Usage: kodelythecc doctor [--json]
+// ── Subcommand: memory (direct capture / recall / stats, no review queue) ────
+// Usage:
+//   kodelythecc memory capture --problem "..." --approach "..." [--tags a,b] [--language ts]
+//   kodelythecc memory recall "<query>" [--limit N]
+//   kodelythecc memory list
+//   kodelythecc memory stats
+if (args[0] === 'memory') {
+  const store = require(path.join(ROOT, 'scripts', 'memory', 'store.js'));
+  const sub = args[1] || 'stats';
+  const rest = args.slice(2);
+  function flag(name, dflt) { const i = rest.indexOf('--' + name); return i >= 0 && rest[i + 1] && !rest[i + 1].startsWith('--') ? rest[i + 1] : dflt; }
+  const w = (m) => process.stdout.write(m + '\n');
+  try {
+    if (sub === 'capture' || sub === 'remember') {
+      const problem = flag('problem') || rest.find(a => !a.startsWith('--'));
+      const approach = flag('approach');
+      if (!problem || !approach) {
+        process.stderr.write('usage: kodelythecc memory capture --problem "<what was hard>" --approach "<what worked>" [--tags a,b] [--language ts] [--files a,b]\n');
+        process.exit(2);
+      }
+      const m = store.capture({
+        problem, approach,
+        tags: (flag('tags') || '').split(',').filter(Boolean),
+        language: flag('language') || null,
+        files: (flag('files') || '').split(',').filter(Boolean),
+        project: flag('project') || process.cwd(),
+        source: 'cli',
+      });
+      w(`✓ stored ${m.id} — "${m.problem.slice(0, 60)}"`);
+      process.exit(0);
+    }
+    if (sub === 'recall' || sub === 'search') {
+      const query = rest.find(a => !a.startsWith('--'));
+      if (!query) { process.stderr.write('usage: kodelythecc memory recall "<query>"\n'); process.exit(2); }
+      const results = store.recall(query, { limit: Number(flag('limit')) || 5, minScore: 0.1 });
+      if (!results.length) { w('No matching memories.'); process.exit(0); }
+      for (const m of results) w(`[${(m.score || 0).toFixed(2)}] ${m.problem}\n        → ${(m.approach || '').split('\n')[0].slice(0, 80)}  (${(m.tags || []).join(', ')})`);
+      process.exit(0);
+    }
+    if (sub === 'list') {
+      const all = store.listAll();
+      w(`${all.length} memories:`);
+      for (const m of all.slice(0, 50)) w(`  ${m.id}  ${(m.captured_at || '').slice(0, 10)}  ${(m.problem || '').slice(0, 60)}`);
+      process.exit(0);
+    }
+    if (sub === 'stats') {
+      const s = store.stats();
+      w(`Memories: ${s.total} · projects: ${s.projects} · dir: ${s.storageDir}`);
+      w(`Top tags: ${s.topTags.slice(0, 8).map(t => t[0] + '(' + t[1] + ')').join(', ')}`);
+      process.exit(0);
+    }
+    process.stderr.write('unknown memory subcommand. try: capture | recall | list | stats\n');
+    process.exit(2);
+  } catch (e) { process.stderr.write(`[memory] ${e.message}\n`); process.exit(1); }
+}
+
 if (args[0] === 'doctor') {
   const { run, PASS, WARN, FAIL } = require(path.join(ROOT, 'scripts', 'doctor-health.js'));
   const report = run();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodelyth-ecc",
-  "version": "2.5.2",
+  "version": "2.5.4",
   "description": "Production-grade AI coding toolkit — 70 agents (incl. devil-mode adversarial crew), 194 skills, 97 commands, parallel multi-agent commands, semantic intent routing, self-learning memory, and a built-in MCP server (16 tools / 6 prompts / 377 resources) that bridges to Claude Desktop, LangGraph, AutoGen, CrewAI, and OpenAI Agents SDK. Works with Claude Code, Windsurf, Cursor, Codex, Antigravity, OpenCode, Cline, RooCode, Aider, Kimi, and Gemini CLI.",
   "author": "Kodelyth <github.com/sifxprime>",
   "license": "MIT",

package/scripts/memory/extract.js

@@ -172,19 +172,11 @@ function extractCandidates(jsonlPath) {
     }
   }
 
-  // Find user success messages — those mark candidate moments
-  for (let i = 0; i < events.length; i++) {
-    const ev = events[i];
-    if (ev.role !== 'user') continue;
-    const text = extractText(ev);
-    if (!SUCCESS_PHRASES.some(rx => rx.test(text))) continue;
-
-    const score = scoreCandidate(events, i);
-    if (score < 3) continue;
-
-    // Look back to find the problem and approach
-    const window = events.slice(Math.max(0, i - 20), i);
-    const problemEvent = window.find(e => e.role === 'user');
+  // Build a candidate from the window of events before a "solved" moment at
+  // index `i`. Returns null if there's no clear problem + approach.
+  function buildAt(i, score) {
+    const window = events.slice(Math.max(0, i - 20), i + 1);
+    const problemEvent = window.find(e => e.role === 'user' && extractText(e).trim());
     const problem = problemEvent ? extractText(problemEvent).split('\n')[0].slice(0, 280) : null;
 
     const filesTouched = Array.from(new Set(
@@ -194,26 +186,48 @@ function extractCandidates(jsonlPath) {
         .filter(Boolean)
     )).slice(0, 5);
 
-    // Find the last assistant message that actually has TEXT — skip trailing
-    // tool_use/tool_result events which carry no explanation of the fix.
-    const reversed = window.slice().reverse();
+    // Last assistant message with actual explanatory TEXT.
     let approach = null;
-    for (const e of reversed) {
+    for (const e of window.slice().reverse()) {
       if (e.role !== 'assistant') continue;
       const t = extractText(e).trim();
       if (t) { approach = t.slice(0, 600); break; }
     }
-
-    if (!problem || !approach) continue;
-
-    candidates.push({
-      problem,
-      approach,
+    if (!problem || !approach) return null;
+    return {
+      problem, approach,
       tags: extractTags(`${problem} ${approach}`),
       files: filesTouched,
       language: detectLanguage(filesTouched),
       score,
-    });
+    };
+  }
+
+  const PASS_SIGNAL = /\bexit code 0\b|\btests? passed\b|\ball (tests )?pass(ed)?\b|\b0 failing\b|\bbuild succeeded\b|✓|PASS\b/i;
+
+  for (let i = 0; i < events.length; i++) {
+    const ev = events[i];
+
+    // Path 1 — user says it worked ("that worked", "perfect", "thanks", ...).
+    if (ev.role === 'user' && SUCCESS_PHRASES.some(rx => rx.test(extractText(ev)))) {
+      const score = scoreCandidate(events, i);
+      if (score >= 3) { const c = buildAt(i, score); if (c) candidates.push(c); }
+      continue;
+    }
+
+    // Path 2 (aggressive, v2.5.4+) — a passing test / successful build that
+    // FOLLOWS at least one edit, even without an explicit user "thanks". This
+    // catches real fixes the user verified but never verbally acknowledged.
+    // Opt out with KODELYTH_CAPTURE_AGGRESSIVE=0.
+    if (process.env.KODELYTH_CAPTURE_AGGRESSIVE !== '0'
+        && PASS_SIGNAL.test(extractText(ev))) {
+      const priorWindow = events.slice(Math.max(0, i - 12), i);
+      const hadEdit = priorWindow.some(e => e.tool_name === 'Edit' || e.tool_name === 'Write');
+      if (hadEdit) {
+        const score = scoreCandidate(events, i) + 2; // verification is a strong signal
+        if (score >= 3) { const c = buildAt(i, score); if (c) candidates.push(c); }
+      }
+    }
   }
 
   // Dedupe by problem