kodelyth-ecc 1.8.0 → 1.8.2

package/tests/evolve/analyze.test.js

@@ -1,169 +0,0 @@
-// Tests for scripts/evolve/analyze.js
-'use strict';
-
-const test   = require('node:test');
-const assert = require('node:assert/strict');
-
-const A = require('../../scripts/evolve/analyze.js');
-
-const FAKE_MEMORY = {
-  id: 'm1',
-  problem: 'Tailwind v4 migration breaks arbitrary values',
-  approach: 'Regenerate config with @config and update postcss-import order',
-  tags: ['css', 'tailwind', 'migration'],
-  language: 'typescript',
-  source: 'manual',
-  captured_at: '2026-04-01T00:00:00Z',
-};
-
-// ── thresholds ──────────────────────────────────────────────────────────────
-
-test('exposes default thresholds', () => {
-  assert.ok(A.DEFAULT_REUSE_MIN_COUNT >= 1);
-  assert.ok(A.DEFAULT_REUSE_MIN_SESSIONS >= 1);
-  assert.ok(A.DEFAULT_MISS_MIN_COUNT >= 1);
-});
-
-// ── analyzeReuseForProposals ────────────────────────────────────────────────
-
-test('analyzeReuseForProposals: skips when below threshold', () => {
-  const reuseStats = {
-    entries: [{ id: 'm1', count: 1, sessions: ['s1'], projects: [] }],
-  };
-  const proposals = A.analyzeReuseForProposals({ reuseStats, memories: [FAKE_MEMORY] });
-  assert.equal(proposals.length, 0);
-});
-
-test('analyzeReuseForProposals: emits skill-upgrade when count + sessions clear thresholds', () => {
-  const reuseStats = {
-    entries: [{
-      id: 'm1', count: 4,
-      sessions: ['s1', 's2', 's3', 's4'],
-      projects: ['/p'],
-      firstSurfaced: '2026-04-01T...',
-      lastSurfaced:  '2026-05-01T...',
-    }],
-  };
-  const proposals = A.analyzeReuseForProposals({ reuseStats, memories: [FAKE_MEMORY] });
-  assert.equal(proposals.length, 1);
-  const p = proposals[0];
-  assert.equal(p.type, 'skill-upgrade');
-  assert.equal(p.evidence.memoryId, 'm1');
-  assert.equal(p.evidence.reuseCount, 4);
-  assert.match(p.proposal.target_path, /^skills\/tailwind-v4-migration/);
-  assert.match(p.proposal.diff, /## Problem/);
-  assert.match(p.proposal.diff, /Tailwind v4 migration/);
-});
-
-test('analyzeReuseForProposals: thresholds are configurable', () => {
-  const reuseStats = { entries: [{ id: 'm1', count: 2, sessions: ['s1'], projects: [] }] };
-  // Default: needs count>=3 AND sessions>=2 → skip
-  assert.equal(A.analyzeReuseForProposals({ reuseStats, memories: [FAKE_MEMORY] }).length, 0);
-  // Lower thresholds → emit
-  const proposals = A.analyzeReuseForProposals({
-    reuseStats, memories: [FAKE_MEMORY],
-    thresholds: { minCount: 1, minSessions: 1 },
-  });
-  assert.equal(proposals.length, 1);
-});
-
-test('analyzeReuseForProposals: skips memories not present in store', () => {
-  const reuseStats = { entries: [{ id: 'orphan', count: 5, sessions: ['s1', 's2'], projects: [] }] };
-  const proposals = A.analyzeReuseForProposals({ reuseStats, memories: [FAKE_MEMORY] });
-  assert.equal(proposals.length, 0);
-});
-
-test('analyzeReuseForProposals: deterministic ID across runs', () => {
-  const reuseStats = { entries: [{ id: 'm1', count: 4, sessions: ['s1', 's2', 's3', 's4'], projects: [] }] };
-  const a = A.analyzeReuseForProposals({ reuseStats, memories: [FAKE_MEMORY] })[0];
-  const b = A.analyzeReuseForProposals({ reuseStats, memories: [FAKE_MEMORY] })[0];
-  assert.equal(a.id, b.id);
-  assert.match(a.id, /^skill-[0-9a-f]{10}$/);
-});
-
-// ── clusterMisses ───────────────────────────────────────────────────────────
-
-test('clusterMisses: groups by ≥2 token overlap', () => {
-  const entries = [
-    { tokens: ['feature', 'flag', 'gradual', 'rollout'], count: 2, samples: [], hash: 'a' },
-    { tokens: ['feature', 'flag', 'percentage', 'enabled'], count: 1, samples: [], hash: 'b' },
-    { tokens: ['unrelated', 'topic', 'completely', 'different'], count: 1, samples: [], hash: 'c' },
-  ];
-  const clusters = A.clusterMisses(entries);
-  assert.equal(clusters.length, 2, 'two distinct clusters');
-  assert.equal(clusters[0].count, 3, 'feature/flag cluster aggregated count');
-});
-
-test('clusterMisses: single-overlap entries do NOT cluster', () => {
-  const entries = [
-    { tokens: ['alpha', 'beta', 'gamma', 'delta'], count: 1, samples: [], hash: 'a' },
-    { tokens: ['alpha', 'epsilon', 'zeta', 'eta'], count: 1, samples: [], hash: 'b' },
-  ];
-  const clusters = A.clusterMisses(entries);
-  assert.equal(clusters.length, 2);
-});
-
-// ── analyzeMissesForProposals ───────────────────────────────────────────────
-
-test('analyzeMissesForProposals: emits routing-addition when cluster exceeds thresholds', () => {
-  const missStats = {
-    entries: [
-      { tokens: ['feature', 'flag', 'gradual'], count: 2, samples: ['feature flag gradual rollout 1'], hash: 'a' },
-      { tokens: ['feature', 'flag', 'percent'], count: 1, samples: ['feature flag percent enabled'],   hash: 'b' },
-      { tokens: ['feature', 'flag', 'kill'],    count: 1, samples: ['feature flag kill switch'],       hash: 'c' },
-    ],
-  };
-  const proposals = A.analyzeMissesForProposals({ missStats });
-  assert.equal(proposals.length, 1);
-  const p = proposals[0];
-  assert.equal(p.type, 'routing-addition');
-  assert.equal(p.proposal.target_path, 'rules/common/agent-intent-routing.md');
-  assert.match(p.proposal.diff, /TODO-agent/);
-  assert.match(p.proposal.diff, /feature/);
-});
-
-test('analyzeMissesForProposals: skips clusters below threshold', () => {
-  const missStats = { entries: [{ tokens: ['x', 'y', 'z'], count: 1, samples: [], hash: 'a' }] };
-  const proposals = A.analyzeMissesForProposals({ missStats });
-  assert.equal(proposals.length, 0);
-});
-
-// ── analyzeAll ──────────────────────────────────────────────────────────────
-
-test('analyzeAll: combines reuse + miss proposals', () => {
-  const out = A.analyzeAll({
-    reuseStats: { entries: [{ id: 'm1', count: 4, sessions: ['s1', 's2', 's3', 's4'], projects: [] }] },
-    missStats:  { entries: [
-      { tokens: ['database', 'vacuum', 'job'], count: 2, samples: ['database vacuum job 1'], hash: 'a' },
-      { tokens: ['database', 'vacuum', 'big'], count: 1, samples: ['database vacuum big table'], hash: 'b' },
-      { tokens: ['database', 'vacuum', 'fast'], count: 1, samples: ['database vacuum fast'], hash: 'c' },
-    ] },
-    memories:   [FAKE_MEMORY],
-  });
-  const types = out.map(p => p.type).sort();
-  assert.deepEqual(types, ['routing-addition', 'skill-upgrade']);
-});
-
-test('analyzeAll: empty inputs → empty output', () => {
-  assert.deepEqual(
-    A.analyzeAll({ reuseStats: { entries: [] }, missStats: { entries: [] }, memories: [] }),
-    []
-  );
-});
-
-// ── slugify edge cases ─────────────────────────────────────────────────────
-
-test('_internals.slugify: empty fallback', () => {
-  assert.equal(A._internals.slugify(''), 'untitled');
-  assert.equal(A._internals.slugify(null), 'untitled');
-  assert.equal(A._internals.slugify(undefined), 'untitled');
-});
-
-test('_internals.slugify: caps length', () => {
-  const s = A._internals.slugify('a'.repeat(200));
-  assert.ok(s.length <= 60);
-});
-
-test('_internals.slugify: special chars normalized', () => {
-  assert.equal(A._internals.slugify('Hello, World! 2026'), 'hello-world-2026');
-});

package/tests/evolve/proposals.test.js

@@ -1,173 +0,0 @@
-// Tests for scripts/evolve/proposals.js
-'use strict';
-
-const test   = require('node:test');
-const assert = require('node:assert/strict');
-const fs     = require('node:fs');
-const os     = require('node:os');
-const path   = require('node:path');
-
-const P = require('../../scripts/evolve/proposals.js');
-
-function tmpDir() { return fs.mkdtempSync(path.join(os.tmpdir(), 'kodelyth-evolve-prop-')); }
-function cleanup(dir) { try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* */ } }
-
-const FAKE_PROPOSAL = {
-  id: 'skill-abc123',
-  type: 'skill-upgrade',
-  evidence: { memoryId: 'm1', reuseCount: 5 },
-  proposal: {
-    kind: 'create-skill',
-    target_path: 'skills/test-skill/SKILL.md',
-    diff: '# test skill\n\nbody\n',
-    rationale: 'because reuse',
-  },
-};
-
-// ── appendProposal ──────────────────────────────────────────────────────────
-
-test('appendProposal: rejects malformed input', () => {
-  const d = tmpDir();
-  try {
-    assert.throws(() => P.appendProposal({}, d), /must include id, type/);
-    assert.throws(() => P.appendProposal({ id: 'x' }, d), /must include id, type/);
-  } finally { cleanup(d); }
-});
-
-test('appendProposal: writes pending entry on first call', () => {
-  const d = tmpDir();
-  try {
-    const r = P.appendProposal(FAKE_PROPOSAL, d);
-    assert.equal(r.status, 'pending');
-    assert.ok(r.created_at);
-    const all = P.readLatest(d);
-    assert.equal(all.length, 1);
-    assert.equal(all[0].id, 'skill-abc123');
-  } finally { cleanup(d); }
-});
-
-test('appendProposal: idempotent on same id', () => {
-  const d = tmpDir();
-  try {
-    P.appendProposal(FAKE_PROPOSAL, d);
-    P.appendProposal(FAKE_PROPOSAL, d);
-    P.appendProposal(FAKE_PROPOSAL, d);
-    const all = P.readLatest(d);
-    assert.equal(all.length, 1, 'no duplicates');
-    const events = P.readAll(d);
-    assert.equal(events.length, 1, 'only one event written');
-  } finally { cleanup(d); }
-});
-
-// ── setStatus ───────────────────────────────────────────────────────────────
-
-test('setStatus: rejects invalid status', () => {
-  const d = tmpDir();
-  try {
-    P.appendProposal(FAKE_PROPOSAL, d);
-    assert.throws(() => P.setStatus('skill-abc123', 'banana', d), /invalid status/);
-  } finally { cleanup(d); }
-});
-
-test('setStatus: returns null for unknown id', () => {
-  const d = tmpDir();
-  try {
-    assert.equal(P.setStatus('does-not-exist', 'accepted', d), null);
-  } finally { cleanup(d); }
-});
-
-test('setStatus: transitions pending → accepted, preserves diff/evidence', () => {
-  const d = tmpDir();
-  try {
-    P.appendProposal(FAKE_PROPOSAL, d);
-    const r = P.setStatus('skill-abc123', 'accepted', d, { applied_path: '/tmp/foo.md' });
-    assert.equal(r.status, 'accepted');
-    assert.equal(r.applied_path, '/tmp/foo.md');
-
-    const cur = P.findById('skill-abc123', d);
-    assert.equal(cur.status, 'accepted');
-    assert.equal(cur.applied_path, '/tmp/foo.md');
-    // Original proposal data preserved.
-    assert.equal(cur.proposal.target_path, 'skills/test-skill/SKILL.md');
-    assert.equal(cur.evidence.reuseCount, 5);
-  } finally { cleanup(d); }
-});
-
-test('setStatus: pending → rejected → accepted preserves audit trail', () => {
-  const d = tmpDir();
-  try {
-    P.appendProposal(FAKE_PROPOSAL, d);
-    P.setStatus('skill-abc123', 'rejected', d, { note: 'no thanks' });
-    P.setStatus('skill-abc123', 'accepted', d, { applied_path: '/x' });
-    const events = P.readAll(d);
-    assert.equal(events.length, 3, '3 events: append, reject, accept');
-    assert.equal(P.findById('skill-abc123', d).status, 'accepted');
-  } finally { cleanup(d); }
-});
-
-// ── listByStatus / findById ─────────────────────────────────────────────────
-
-test('listByStatus: filters latest state', () => {
-  const d = tmpDir();
-  try {
-    P.appendProposal(FAKE_PROPOSAL, d);
-    P.appendProposal({ ...FAKE_PROPOSAL, id: 'skill-second' }, d);
-    P.setStatus('skill-second', 'accepted', d);
-    assert.equal(P.listByStatus('pending', d).length, 1);
-    assert.equal(P.listByStatus('accepted', d).length, 1);
-    assert.equal(P.listByStatus(null, d).length, 2);
-  } finally { cleanup(d); }
-});
-
-test('findById: returns null when absent', () => {
-  const d = tmpDir();
-  try {
-    assert.equal(P.findById('nope', d), null);
-  } finally { cleanup(d); }
-});
-
-// ── applyProposalToDisk ─────────────────────────────────────────────────────
-
-test('applyProposalToDisk: writes diff to target_path under repoRoot', () => {
-  const d = tmpDir();
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kodelyth-apply-'));
-  try {
-    P.appendProposal(FAKE_PROPOSAL, d);
-    const proposal = P.findById('skill-abc123', d);
-    const r = P.applyProposalToDisk(proposal, { repoRoot: root });
-    assert.equal(r.written, true);
-    assert.ok(fs.existsSync(r.path));
-    assert.equal(fs.readFileSync(r.path, 'utf8'), '# test skill\n\nbody\n');
-  } finally { cleanup(d); cleanup(root); }
-});
-
-test('applyProposalToDisk: refuses to overwrite without --overwrite', () => {
-  const d = tmpDir();
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kodelyth-apply-'));
-  try {
-    P.appendProposal(FAKE_PROPOSAL, d);
-    const proposal = P.findById('skill-abc123', d);
-    P.applyProposalToDisk(proposal, { repoRoot: root });
-    assert.throws(
-      () => P.applyProposalToDisk(proposal, { repoRoot: root }),
-      /refusing to overwrite/
-    );
-    // overwrite=true succeeds
-    const r = P.applyProposalToDisk({
-      ...proposal,
-      proposal: { ...proposal.proposal, diff: 'new content' },
-    }, { repoRoot: root, overwrite: true });
-    assert.equal(fs.readFileSync(r.path, 'utf8'), 'new content');
-  } finally { cleanup(d); cleanup(root); }
-});
-
-test('applyProposalToDisk: requires repoRoot', () => {
-  assert.throws(() => P.applyProposalToDisk(FAKE_PROPOSAL, {}), /repoRoot is required/);
-});
-
-test('applyProposalToDisk: rejects proposal without diff/target_path', () => {
-  assert.throws(
-    () => P.applyProposalToDisk({ id: 'x', proposal: {} }, { repoRoot: '/tmp' }),
-    /lacks diff or target_path/
-  );
-});

package/tests/evolve/stats.test.js

@@ -1,167 +0,0 @@
-// Tests for scripts/evolve/stats.js
-'use strict';
-
-const test   = require('node:test');
-const assert = require('node:assert/strict');
-const fs     = require('node:fs');
-const os     = require('node:os');
-const path   = require('node:path');
-
-const stats = require('../../scripts/evolve/stats.js');
-
-function tmpDir() { return fs.mkdtempSync(path.join(os.tmpdir(), 'kodelyth-evolve-stats-')); }
-function cleanup(dir) { try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* */ } }
-
-// ── recordSurface ────────────────────────────────────────────────────────────
-
-test('recordSurface: rejects missing memoryId', () => {
-  const d = tmpDir();
-  try {
-    assert.equal(stats.recordSurface({ sessionId: 's1' }, d), false);
-  } finally { cleanup(d); }
-});
-
-test('recordSurface: bumps count on first session, idempotent within same session', () => {
-  const d = tmpDir();
-  try {
-    assert.equal(stats.recordSurface({ memoryId: 'm1', sessionId: 's1', projectRoot: '/proj' }, d), true);
-    assert.equal(stats.recordSurface({ memoryId: 'm1', sessionId: 's1', projectRoot: '/proj' }, d), true);
-    assert.equal(stats.recordSurface({ memoryId: 'm1', sessionId: 's1', projectRoot: '/proj' }, d), true);
-
-    const r = stats.getReuseStats(d);
-    assert.equal(r.total_memories_tracked, 1);
-    assert.equal(r.total_surfaces, 1, 'same session should only count once');
-    assert.equal(r.entries[0].count, 1);
-    assert.deepEqual(r.entries[0].sessions, ['s1']);
-    assert.deepEqual(r.entries[0].projects, ['/proj']);
-  } finally { cleanup(d); }
-});
-
-test('recordSurface: bumps count on each new session', () => {
-  const d = tmpDir();
-  try {
-    for (let i = 0; i < 4; i++) {
-      stats.recordSurface({ memoryId: 'm1', sessionId: `s${i}` }, d);
-    }
-    const r = stats.getReuseStats(d);
-    assert.equal(r.entries[0].count, 4);
-    assert.equal(r.entries[0].sessions.length, 4);
-  } finally { cleanup(d); }
-});
-
-test('recordSurface: tracks distinct projects without duplicating', () => {
-  const d = tmpDir();
-  try {
-    stats.recordSurface({ memoryId: 'm1', sessionId: 's1', projectRoot: '/a' }, d);
-    stats.recordSurface({ memoryId: 'm1', sessionId: 's2', projectRoot: '/a' }, d);
-    stats.recordSurface({ memoryId: 'm1', sessionId: 's3', projectRoot: '/b' }, d);
-    const r = stats.getReuseStats(d);
-    assert.deepEqual(r.entries[0].projects, ['/a', '/b']);
-  } finally { cleanup(d); }
-});
-
-test('recordSurface: never throws on bad dir; returns false', () => {
-  // Create a file then pass a subpath of it as the dir — fails on all platforms
-  // because mkdirSync can't create a directory where a file already exists.
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'kodelyth-stats-bad-'));
-  const fileAsDir = path.join(tmp, 'not-a-dir');
-  fs.writeFileSync(fileAsDir, 'x');
-  try {
-    assert.equal(stats.recordSurface({ memoryId: 'm1', sessionId: 's1' }, path.join(fileAsDir, 'sub')), false);
-  } finally {
-    fs.rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
-// ── recordRoutingMiss ────────────────────────────────────────────────────────
-
-test('recordRoutingMiss: rejects empty prompt', () => {
-  const d = tmpDir();
-  try {
-    assert.equal(stats.recordRoutingMiss({ prompt: '', sessionId: 's1' }, d), false);
-    assert.equal(stats.recordRoutingMiss({ sessionId: 's1' }, d), false);
-  } finally { cleanup(d); }
-});
-
-test('recordRoutingMiss: appends one line per call', () => {
-  const d = tmpDir();
-  try {
-    stats.recordRoutingMiss({ prompt: 'how do I reset postgres replication',  sessionId: 's1' }, d);
-    stats.recordRoutingMiss({ prompt: 'postgres logical replication is stuck', sessionId: 's2' }, d);
-    const m = stats.getRoutingMissStats(d);
-    assert.equal(m.total_misses, 2);
-    assert.equal(m.unique_prompts, 2);
-    assert.ok(m.entries.every(e => Array.isArray(e.tokens) && e.tokens.length > 0));
-  } finally { cleanup(d); }
-});
-
-test('recordRoutingMiss: same prompt aggregates by hash', () => {
-  const d = tmpDir();
-  try {
-    stats.recordRoutingMiss({ prompt: 'identical prompt body', sessionId: 's1' }, d);
-    stats.recordRoutingMiss({ prompt: 'identical prompt body', sessionId: 's2' }, d);
-    stats.recordRoutingMiss({ prompt: 'identical prompt body', sessionId: 's3' }, d);
-    const m = stats.getRoutingMissStats(d);
-    assert.equal(m.total_misses, 3);
-    assert.equal(m.unique_prompts, 1);
-    assert.equal(m.entries[0].count, 3);
-  } finally { cleanup(d); }
-});
-
-test('recordRoutingMiss: caps stored prompt to 1000 chars', () => {
-  const d = tmpDir();
-  try {
-    const huge = 'x'.repeat(5000);
-    stats.recordRoutingMiss({ prompt: huge, sessionId: 's1' }, d);
-    const m = stats.getRoutingMissStats(d);
-    assert.equal(m.entries[0].samples[0].length, 1000);
-  } finally { cleanup(d); }
-});
-
-// ── empty / readback ────────────────────────────────────────────────────────
-
-test('readReuse on empty dir returns sane defaults', () => {
-  const d = tmpDir();
-  try {
-    const r = stats.readReuse(d);
-    assert.deepEqual(r.byMemory, {});
-    assert.equal(r.lastUpdated, null);
-  } finally { cleanup(d); }
-});
-
-test('getRoutingMissStats on empty dir returns empty arrays', () => {
-  const d = tmpDir();
-  try {
-    const m = stats.getRoutingMissStats(d);
-    assert.equal(m.total_misses, 0);
-    assert.equal(m.unique_prompts, 0);
-    assert.deepEqual(m.entries, []);
-  } finally { cleanup(d); }
-});
-
-test('resetAll clears both stores', () => {
-  const d = tmpDir();
-  try {
-    stats.recordSurface({ memoryId: 'm', sessionId: 's' }, d);
-    stats.recordRoutingMiss({ prompt: 'something here', sessionId: 's' }, d);
-    assert.equal(stats.resetAll(d), true);
-    assert.equal(stats.getReuseStats(d).total_memories_tracked, 0);
-    assert.equal(stats.getRoutingMissStats(d).total_misses, 0);
-  } finally { cleanup(d); }
-});
-
-// ── tokenize / hash ──────────────────────────────────────────────────────────
-
-test('_internals.tokenize lowercases and splits', () => {
-  const out = stats._internals.tokenize('Hello, World! foo-bar/baz');
-  assert.ok(out.includes('hello'));
-  assert.ok(out.includes('world'));
-  assert.ok(out.includes('foo-bar/baz') || out.includes('foo-bar') || out.includes('baz'));
-});
-
-test('_internals.hashPrompt is stable + 12 hex chars', () => {
-  const a = stats._internals.hashPrompt('hello');
-  const b = stats._internals.hashPrompt('hello');
-  assert.equal(a, b);
-  assert.match(a, /^[0-9a-f]{12}$/);
-});