@aikdna/studio-core 0.1.0 → 0.3.0

package/tests/milestone2.test.js

@@ -0,0 +1,285 @@
+const { test, describe } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { createProject } = require('../src/project');
+const { createCard, lockCard, transitionCard, createFeynmanRestatement, attachRestatementToLock } = require('../src/cards');
+const { computeReadiness } = require('../src/quality');
+const { detectContradictions } = require('../src/quality/contradiction');
+const { validateCard, validateAllCards } = require('../src/quality/validate-cards');
+const { compileDomain, generateReadme } = require('../src/compile');
+const { createTestCase, recordHumanRating } = require('../src/testlab');
+const { buildProvenance } = require('../src/provenance');
+
+function makeLockedCard(type, fields = {}, id = null) {
+  const card = createCard(type, fields, id);
+  transitionCard(card, 'revised', { by: 'tester' });
+  lockCard(card, {
+    by: 'tester',
+    statement: 'I confirm this judgment.',
+    checked: { applies_when: true, does_not_apply_when: true, failure_risk: true },
+  });
+  return card;
+}
+
+// ─── Quality Gates (4-grade scoring) ─────────────────────────────────
+
+describe('Quality Gates', () => {
+  test('draft_grade: empty project', () => {
+    const r = computeReadiness({ cards: [], tests: [] });
+    assert.equal(r.grade, 'draft_grade');
+    assert.equal(r.publishable, false);
+    assert.ok(r.blocking.length > 0);
+  });
+
+  test('draft_grade: no locked cards → nothing to compile', () => {
+    const project = createProject('test');
+    project.cards = [createCard('axiom', { one_sentence: 'Draft.' })];
+    const r = computeReadiness(project);
+    assert.equal(r.grade, 'draft_grade');
+    assert.ok(r.blocking.some(b => b.includes('nothing to compile') || b.includes('No locked cards')));
+  });
+
+  test('human_controlled: 3+ locked axioms with boundaries ', () => {
+    const project = createProject('test');
+    for (let i = 0; i < 3; i++) {
+      const ax = makeLockedCard('axiom', {
+        one_sentence: `Axiom ${i}: a specific testable judgment principle.`,
+        full_statement: `Full statement for axiom ${i} explaining what the agent should do differently.`,
+        why: 'Without this, agents would get this specific thing wrong.',
+        applies_when: [`situation ${i}a`, `situation ${i}b`],
+        does_not_apply_when: [`not when ${i}`],
+        failure_risk: `Risk ${i}: misapplying this could cause X.`,
+      });
+      attachRestatementToLock(ax, createFeynmanRestatement(ax, `Simple explanation for axiom ${i}: when you see this situation, do this instead of that, but only if the conditions are right.`));
+      project.cards.push(ax);
+    }
+    const r = computeReadiness(project);
+    assert.equal(r.grade, 'human_controlled');
+    assert.equal(r.stats.locked_axioms, 3);
+    assert.ok(r.score >= 70);
+  });
+
+  test('tested_grade: 5+ rated tests + 3+ self-checks', () => {
+    const project = createProject('test');
+    for (let i = 0; i < 3; i++) {
+      const ax = makeLockedCard('axiom', {
+        one_sentence: `Test axiom ${i}.`,
+        full_statement: `Full statement ${i} with enough detail for the agent.`,
+        why: 'Because.',
+        applies_when: ['when x'],
+        does_not_apply_when: ['when y'],
+        failure_risk: 'risk',
+      });
+      project.cards.push(ax);
+    }
+    for (let i = 0; i < 3; i++) {
+      const sc = makeLockedCard('self_check', { question: `Does the response satisfy condition ${i}?` });
+      project.cards.push(sc);
+    }
+    for (let i = 0; i < 6; i++) {
+      const tc = createTestCase(`input ${i}`);
+      recordHumanRating(tc, i < 4 ? 'with_kdna_better' : 'no_difference', 'tester');
+      project.tests.push(tc);
+    }
+    const r = computeReadiness(project);
+    assert.equal(r.grade, 'tested_grade');
+    assert.equal(r.stats.rated_tests, 6);
+  });
+
+  test('publishable_grade: 10+ eval cases, 3+ axioms, 5+ self-checks', () => {
+    const project = createProject('test');
+    for (let i = 0; i < 4; i++) {
+      project.cards.push(makeLockedCard('axiom', {
+        one_sentence: `Pub axiom ${i} with judgment.`,
+        full_statement: `Full statement ${i} with enough detail for the agent to act on.`,
+        why: 'Without this, agents default to wrong behavior.',
+        applies_when: ['when x'],
+        does_not_apply_when: ['when y'],
+        failure_risk: 'risk of misapplication',
+      }));
+    }
+    for (let i = 0; i < 5; i++) {
+      project.cards.push(makeLockedCard('self_check', { question: `Does the output pass criterion ${i}?` }));
+    }
+    for (let i = 0; i < 12; i++) {
+      const tc = createTestCase(`eval case ${i}`);
+      recordHumanRating(tc, 'with_kdna_better', 'tester');
+      project.tests.push(tc);
+    }
+    const r = computeReadiness(project);
+    assert.equal(r.grade, 'publishable_grade');
+    assert.equal(r.publishable, true);
+    assert.equal(r.blocking.length, 0);
+    assert.ok(r.score >= 75);
+  });
+});
+
+// ─── Anti-Vagueness Validation ──────────────────────────────────────
+
+describe('Card Validation', () => {
+  test('flags slogan-like axiom', () => {
+    const card = createCard('axiom', { one_sentence: 'Trust is important for teams.', full_statement: 'Trust matters.' });
+    const issues = validateCard(card);
+    assert.ok(issues.some(i => i.type === 'slogan' || i.type === 'too_short'));
+  });
+
+  test('flags SOP-like axiom', () => {
+    const card = createCard('axiom', {
+      one_sentence: 'First, you should always remember to follow these steps.',
+      full_statement: 'The process is to first identify the problem.',
+    });
+    const issues = validateCard(card);
+    assert.ok(issues.some(i => i.type === 'sop'));
+  });
+
+  test('flags straw-man misunderstanding', () => {
+    const card = createCard('misunderstanding', {
+      wrong: 'Some people say it is commonly thought that quality matters.',
+      correct: 'Actually it does matter.',
+      key_distinction: 'Quality is about getting things right the first time.',
+    });
+    const issues = validateCard(card);
+    assert.ok(issues.some(i => i.type === 'straw_man'));
+  });
+
+  test('flags generic self_check', () => {
+    const card = createCard('self_check', { question: 'Is this good?' });
+    const issues = validateCard(card);
+    assert.ok(issues.some(i => i.type === 'generic' || i.type === 'vague'));
+  });
+
+  test('validateAllCards aggregates per-card', () => {
+    const project = createProject('test');
+    project.cards = [
+      createCard('axiom', { one_sentence: 'Trust is key.', full_statement: 'Trust matters in everything.' }),
+      createCard('self_check', { question: 'Is it helpful?' }),
+    ];
+    const results = validateAllCards(project);
+    assert.equal(results.length, 2);
+    for (const r of results) {
+      assert.ok(r.card_id);
+      assert.ok(r.issues.length > 0);
+    }
+  });
+});
+
+// ─── Full 6-File Compile ────────────────────────────────────────────
+
+describe('Full Compile', () => {
+  test('produces Core + Patterns minimum', () => {
+    const project = createProject('test');
+    project.cards = [
+      makeLockedCard('axiom', { one_sentence: 'Test.', full_statement: 'Test full.', why: 'Because.', applies_when: ['x'], does_not_apply_when: ['y'], failure_risk: 'risk' }),
+    ];
+    const result = compileDomain(project);
+    assert.ok('KDNA_Core.json' in result.files);
+    assert.ok('KDNA_Patterns.json' in result.files);
+    assert.ok('kdna.json' in result.files);
+    assert.ok(result.stats.files_output >= 4); // Core + Patterns + Reasoning + Evolution minimum
+  });
+
+  test('excludes draft cards from output', () => {
+    const project = createProject('test');
+    project.cards = [
+      makeLockedCard('axiom', { one_sentence: 'Locked.', full_statement: 'FS.', why: 'B.', applies_when: ['x'], does_not_apply_when: ['y'], failure_risk: 'r' }),
+      createCard('axiom', { one_sentence: 'Draft.' }),
+    ];
+    const result = compileDomain(project);
+    assert.equal(result.stats.locked_cards, 1);
+    assert.equal(result.stats.excluded_cards, 1);
+    const core = JSON.parse(result.files['KDNA_Core.json']);
+    assert.equal(core.axioms.length, 1);
+  });
+
+  test('produces Scenarios when scenario cards locked', () => {
+    const project = createProject('test');
+    project.cards = [
+      makeLockedCard('scenario', { id: 'scene_01', name: 'User reports bug', trigger_signal: 'bug report', sub_scenarios: [] }, 'sc_001'),
+    ];
+    const result = compileDomain(project);
+    assert.ok('KDNA_Scenarios.json' in result.files);
+  });
+
+  test('produces Reasoning from axiom implications', () => {
+    const project = createProject('test');
+    project.cards = [
+      makeLockedCard('axiom', { one_sentence: 'Price objections are certainty deficits.', full_statement: 'When a buyer says too expensive, first diagnose which type of uncertainty is blocking them.', why: 'Without this axiom, agents default to offering discounts instead of diagnosing.', applies_when: ['price objection'], does_not_apply_when: ['explicit discount request'], failure_risk: 'Agent may seem evasive.' }),
+    ];
+    const result = compileDomain(project);
+    assert.ok('KDNA_Reasoning.json' in result.files);
+    const reasoning = JSON.parse(result.files['KDNA_Reasoning.json']);
+    assert.ok(reasoning.chains.length > 0);
+    assert.equal(reasoning.chains[0].so_what, 'Without this axiom, agents default to offering discounts instead of diagnosing.');
+  });
+
+  test('produces Evolution from audit logs', () => {
+    const project = createProject('test');
+    const card = makeLockedCard('axiom', { one_sentence: 'Evolution test.', full_statement: 'FS.', why: 'B.', applies_when: ['x'], does_not_apply_when: ['y'], failure_risk: 'r' });
+    project.cards = [card];
+    const result = compileDomain(project);
+    const evo = JSON.parse(result.files['KDNA_Evolution.json']);
+    assert.ok(evo.stages.length > 0);
+    assert.equal(evo.measurements[0].metric, 'locked_axioms');
+    assert.equal(evo.measurements[0].value, 1);
+  });
+});
+
+// ─── README Generation ──────────────────────────────────────────────
+
+describe('README Generation', () => {
+  test('generates README with 4 questions', () => {
+    const project = createProject('leadership_decisions', 'domain', { author: { name: 'Expert' } });
+    project.cards = [
+      makeLockedCard('axiom', {
+        one_sentence: 'Execution failure is decision failure in disguise.',
+        full_statement: 'When a team fails to execute, first check whether a real decision was ever made.',
+        why: 'Without this axiom, managers address symptoms while missing the root cause.',
+        applies_when: ['Team reports being stuck'],
+        does_not_apply_when: ['Clear decision exists'],
+        failure_risk: 'May cause over-scrutiny of decision quality when issue is resources.',
+      }),
+      makeLockedCard('misunderstanding', {
+        wrong: 'If the team is not executing, they lack motivation.',
+        correct: 'If the team is not executing, first check whether a decision with owner+deadline+criteria was made.',
+        key_distinction: 'Motivation gaps produce gradual decline. Decision voids produce sudden stalls.',
+      }),
+      makeLockedCard('self_check', { question: 'Did I verify that a concrete decision exists before diagnosing the team?' }),
+    ];
+    project.tests = [];
+    for (let i = 0; i < 6; i++) {
+      const tc = createTestCase(`test ${i}`);
+      recordHumanRating(tc, 'with_kdna_better', 'expert');
+      project.tests.push(tc);
+    }
+
+    const readme = generateReadme(project, {
+      description: 'Leadership decision-making judgment — diagnose whether execution failures are really decision voids.',
+      origin: '15 years of leadership coaching across 200+ teams.',
+    });
+
+    assert.ok(readme.includes('# leadership_decisions'));
+    assert.ok(readme.includes('## Where it comes from'));
+    assert.ok(readme.includes('## Where it applies'));
+    assert.ok(readme.includes('## How it is verified'));
+    assert.ok(readme.includes('## When it does NOT apply'));
+    assert.ok(readme.includes('15 years'));
+    assert.ok(readme.includes('quality_badge: tested'));
+  });
+});
+
+// ─── Provenance with Compile ────────────────────────────────────────
+
+describe('Provenance Integration', () => {
+  test('buildProvenance captures compile metadata', () => {
+    const project = createProject('test', 'domain', { author: { name: 'Author', id: 'auth_001' } });
+    project.cards = [
+      makeLockedCard('axiom', { one_sentence: 'T.', full_statement: 'FS.', why: 'B.', applies_when: ['x'], does_not_apply_when: ['y'], failure_risk: 'r' }),
+    ];
+    const compiled = compileDomain(project);
+    const prov = buildProvenance(project, compiled.files);
+    assert.equal(prov.author_id, 'auth_001');
+    assert.equal(prov.locked_card_count, 1);
+    assert.ok(prov.build_id.startsWith('build_'));
+    assert.ok(prov.content_fingerprint.startsWith('sha256:'));
+  });
+});

package/tests/milestone3.test.js

@@ -0,0 +1,156 @@
+const { test, describe } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { createProject } = require('../src/project');
+const { createCard, lockCard, transitionCard } = require('../src/cards');
+const { parseCompareOutput, createJudgmentDelta, compareDeltas, formatDeltaMarkdown, scoreDelta } = require('../src/testlab/delta');
+const { diffProjects, recommendVersionBump, generateChangelog, bumpVersion, markBreakingChange } = require('../src/versioning');
+
+function makeLockedCard(type, fields, id) {
+  const card = createCard(type, fields, id);
+  transitionCard(card, 'revised', { by: 'tester' });
+  lockCard(card, { by: 'tester', statement: 'ok', checked: { applies_when: true, does_not_apply_when: true, failure_risk: true } });
+  return card;
+}
+
+// ─── Judgment Delta ──────────────────────────────────────────────────
+
+describe('Judgment Delta', () => {
+  const DIFF_TEXT = `1. CLASSIFICATION: language_polishing → structural_diagnosis
+2. DIAGNOSIS: The root cause was identified as a missing argument rather than poor wording.
+3. ACTIONS: Suggested deletion more than rewriting — structural fix, not surface polish.
+4. BOUNDARY AWARENESS: SAME
+5. TERMINOLOGY: Used domain-specific terms like judgment_pressure and cognitive_hook.
+VERDICT: trajectory_changed`;
+
+  test('parseCompareOutput extracts axes', () => {
+    const result = parseCompareOutput(DIFF_TEXT);
+    assert.equal(result.verdict, 'trajectory_changed');
+    assert.ok(result.axes.classification);
+    assert.ok(result.axes.diagnosis);
+    assert.ok(result.axes.actions);
+    assert.ok(!result.axes.boundary_awareness); // SAME → omitted
+  });
+
+  test('scoreDelta counts changed axes', () => {
+    const axes = { classification: 'changed', diagnosis: 'changed', terminology: 'changed' };
+    const result = scoreDelta(axes);
+    assert.equal(result.score, 8); // 5 + 3
+    assert.equal(result.changed.length, 3);
+  });
+
+  test('createJudgmentDelta builds full report', () => {
+    const delta = createJudgmentDelta('@aikdna/writing', 'Help me improve this post',
+      'Generic response...', 'Domain-specific response...', DIFF_TEXT,
+      { model: 'claude-sonnet-4-5', triggeredAxioms: ['ax_001'], selfChecksPassed: 5 }
+    );
+    assert.equal(delta.meta.domain, '@aikdna/writing');
+    assert.equal(delta.verdict, 'trajectory_changed');
+    assert.ok(delta.score >= 8);
+    assert.ok(delta.summary.includes('dimensions'));
+    assert.ok(delta.scoring.D1_diagnostic_depth >= 5);
+  });
+
+  test('createJudgmentDelta handles no-change verdict', () => {
+    const noChangeText = '1. CLASSIFICATION: SAME\n2. DIAGNOSIS: SAME\nVERDICT: trajectory_unchanged';
+    const delta = createJudgmentDelta('test', 'input', 'a', 'b', noChangeText);
+    assert.equal(delta.verdict, 'trajectory_unchanged');
+    assert.equal(delta.score, 5);
+    assert.ok(delta.summary.includes('did not significantly alter'));
+  });
+
+  test('compareDeltas shows improvement', () => {
+    const d1 = createJudgmentDelta('test', 'input', 'a', 'b', DIFF_TEXT);
+    const betterText = DIFF_TEXT.replace('SAME', 'Improved boundary awareness with explicit scope limits');
+    const d2 = createJudgmentDelta('test', 'input', 'a', 'b', betterText);
+    const cmp = compareDeltas(d1, d2);
+    assert.ok(cmp.improved);
+  });
+
+  test('formatDeltaMarkdown produces readable report', () => {
+    const delta = createJudgmentDelta('@aikdna/writing', 'test input', 'a', 'b', DIFF_TEXT);
+    const md = formatDeltaMarkdown(delta);
+    assert.ok(md.includes('# KDNA Judgment Comparison Report'));
+    assert.ok(md.includes('## Judgment Diff'));
+    assert.ok(md.includes('## Scoring'));
+    assert.ok(md.includes('Verdict'));
+  });
+
+  test('parseCompareOutput handles legacy format', () => {
+    const legacyText = 'classification: changed\nterminology: domain_specific\nVERDICT: trajectory_changed';
+    const result = parseCompareOutput(legacyText);
+    assert.equal(result.verdict, 'trajectory_changed');
+    assert.ok(result.axes.classification);
+  });
+});
+
+// ─── Versioning ──────────────────────────────────────────────────────
+
+describe('Versioning', () => {
+  test('diffProjects detects added cards', () => {
+    const oldProject = createProject('test');
+    const newProject = createProject('test');
+    newProject.cards = [makeLockedCard('axiom', { one_sentence: 'New axiom.' }, 'ax_001')];
+    const diff = diffProjects(oldProject, newProject);
+    assert.equal(diff.added.length, 1);
+    assert.equal(diff.removed.length, 0);
+  });
+
+  test('diffProjects detects removed cards', () => {
+    const oldProject = createProject('test');
+    oldProject.cards = [makeLockedCard('axiom', { one_sentence: 'Old.' }, 'ax_001')];
+    const newProject = createProject('test');
+    const diff = diffProjects(oldProject, newProject);
+    assert.equal(diff.removed.length, 1);
+  });
+
+  test('diffProjects detects changed fields', () => {
+    const oldProject = createProject('test');
+    oldProject.cards = [makeLockedCard('axiom', { one_sentence: 'Old text.', full_statement: 'Old full.' }, 'ax_001')];
+    const newProject = createProject('test');
+    newProject.cards = [makeLockedCard('axiom', { one_sentence: 'New text.', full_statement: 'New full.' }, 'ax_001')];
+    const diff = diffProjects(oldProject, newProject);
+    assert.equal(diff.changed.length, 1);
+    assert.ok(diff.changed[0].changes.one_sentence);
+  });
+
+  test('recommendVersionBump: MAJOR for removed axiom', () => {
+    const diff = { added: [], removed: [{ type: 'axiom' }], changed: [], summary: { added_count: 0, removed_count: 1, changed_count: 0 } };
+    assert.equal(recommendVersionBump(diff), 'major');
+  });
+
+  test('recommendVersionBump: MINOR for added axiom', () => {
+    const diff = { added: [{ type: 'axiom' }], removed: [], changed: [], summary: { added_count: 1, removed_count: 0, changed_count: 0 } };
+    assert.equal(recommendVersionBump(diff), 'minor');
+  });
+
+  test('recommendVersionBump: PATCH for field changes', () => {
+    const diff = { added: [], removed: [], changed: [{}], summary: { added_count: 0, removed_count: 0, changed_count: 1 } };
+    assert.equal(recommendVersionBump(diff), 'minor');
+  });
+
+  test('bumpVersion increments correctly', () => {
+    assert.equal(bumpVersion('0.1.0', 'patch'), '0.1.1');
+    assert.equal(bumpVersion('0.1.0', 'minor'), '0.2.0');
+    assert.equal(bumpVersion('0.1.0', 'major'), '1.0.0');
+    assert.equal(bumpVersion('2.3.5', 'none'), '2.3.5');
+  });
+
+  test('generateChangelog produces markdown', () => {
+    const oldProject = createProject('test');
+    const newProject = createProject('test');
+    newProject.cards = [makeLockedCard('axiom', { one_sentence: 'New axiom for agent judgment.' }, 'ax_001')];
+    const diff = diffProjects(oldProject, newProject);
+    const changelog = generateChangelog(diff, '0.1.0', '0.2.0', { domain: 'test' });
+    assert.ok(changelog.includes('# test v0.2.0'));
+    assert.ok(changelog.includes('MINOR'));
+    assert.ok(changelog.includes('ax_001'));
+  });
+
+  test('markBreakingChange detects axiom removal', () => {
+    const diff = { added: [], removed: [{ type: 'axiom' }], changed: [], summary: { added_count: 0, removed_count: 1, changed_count: 0 } };
+    const result = markBreakingChange(diff);
+    assert.equal(result.breaking, true);
+    assert.ok(result.reason.includes('breaking change'));
+  });
+});