@aikdna/kdna-cli 0.9.0 → 0.11.0

package/src/cmds/badge.js

@@ -0,0 +1,244 @@
+/**
+ * KDNA Quality Badge & Registry commands — Phase 7.
+ *
+ *   kdna badge compute <domain> [--json]
+ *   kdna registry audit --scope <scope> [--json]
+ *   kdna package <domain> --format=kdna
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { error, readJson, EXIT } = require('./_common');
+const { RegistryResolver } = require('../registry');
+
+// ─── Badge Compute ─────────────────────────────────────────────────────
+
+function cmdBadgeCompute(domainPath, args = []) {
+  const jsonMode = args.includes('--json');
+  const abs = path.resolve(domainPath);
+
+  if (!fs.existsSync(abs)) error(`Domain not found: ${abs}`, EXIT.INPUT_ERROR);
+
+  const core = readJson(path.join(abs, 'KDNA_Core.json'));
+  const pat = readJson(path.join(abs, 'KDNA_Patterns.json'));
+  const manifest = readJson(path.join(abs, 'kdna.json'));
+
+  if (!core) error(`No KDNA_Core.json in ${abs}`, EXIT.INPUT_ERROR);
+
+  const axiomCount = (core.axioms || []).length;
+  const lockedAxioms = (core.axioms || []).filter(
+    (a) => a.applies_when?.length && a.does_not_apply_when?.length && a.failure_risk,
+  ).length;
+  const misCount = (pat?.misunderstandings || []).length;
+  const selfCheckCount = (pat?.self_check || []).length;
+
+  // Count eval cases
+  const evalsDir = path.join(abs, 'evals');
+  let evalCount = 0;
+  let humanPassCount = 0;
+  if (fs.existsSync(evalsDir)) {
+    for (const f of fs.readdirSync(evalsDir)) {
+      if (!f.endsWith('.json')) continue;
+      const evalData = readJson(path.join(evalsDir, f));
+      if (evalData?.cases) {
+        evalCount += evalData.cases.length;
+        humanPassCount += evalData.cases.filter((c) => c.human_pass === true).length;
+      }
+    }
+  }
+  const humanPassRate = evalCount > 0 ? humanPassCount / evalCount : 0;
+
+  // Regression check
+  const regressionPassed = fs.existsSync(path.join(abs, 'evals')); // simplified
+
+  // Determine badge level
+  let badge = 'draft';
+  const criteria = [];
+
+  if (axiomCount >= 3 && lockedAxioms >= 3 && misCount >= 2 && selfCheckCount >= 3) {
+    badge = 'declared';
+    criteria.push('minimum content: 3 axioms, 2 misunderstandings, 3 self-checks');
+  }
+  if (lockedAxioms >= axiomCount && evalCount >= 5 && humanPassRate >= 0.6) {
+    badge = 'tested';
+    criteria.push(`${lockedAxioms}/${axiomCount} axioms governed`);
+    criteria.push(`${evalCount} eval cases`);
+    criteria.push(`human pass rate: ${Math.round(humanPassRate * 100)}%`);
+  }
+  if (lockedAxioms >= axiomCount && evalCount >= 10 && humanPassRate >= 0.8 && regressionPassed) {
+    badge = 'trusted';
+    criteria.push(`${evalCount} eval cases (≥10)`);
+    criteria.push(`human pass rate: ${Math.round(humanPassRate * 100)}% (≥80%)`);
+    criteria.push('regression test passed');
+  }
+
+  const result = {
+    quality_badge: badge,
+    evidence: {
+      axioms: { total: axiomCount, locked: lockedAxioms },
+      misunderstandings: misCount,
+      self_checks: selfCheckCount,
+      eval_count: evalCount,
+      human_pass_rate: Math.round(humanPassRate * 100) / 100,
+      regression_passed: regressionPassed,
+    },
+    criteria,
+  };
+
+  if (jsonMode) {
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(badge === 'draft' ? EXIT.JUDGMENT_QUALITY_FAILED : EXIT.OK);
+  }
+
+  console.log(`Quality Badge: ${badge.toUpperCase()}`);
+  console.log(`  Domain: ${manifest?.name || path.basename(abs)}`);
+  console.log('');
+  console.log('  Evidence:');
+  console.log(`    Axioms:                ${axiomCount} total, ${lockedAxioms} governed`);
+  console.log(`    Misunderstandings:     ${misCount}`);
+  console.log(`    Self-checks:           ${selfCheckCount}`);
+  console.log(`    Eval cases:            ${evalCount}`);
+  console.log(`    Human pass rate:       ${Math.round(humanPassRate * 100)}%`);
+  console.log(`    Regression:            ${regressionPassed ? '✓ passed' : '— not run'}`);
+  console.log('');
+  console.log('  Criteria met:');
+  criteria.forEach((c) => console.log(`    ✓ ${c}`));
+}
+
+// ─── Registry Audit ────────────────────────────────────────────────────
+
+function cmdRegistryAudit(args = []) {
+  const jsonMode = args.includes('--json');
+  const scopeIdx = args.indexOf('--scope');
+  const scope = scopeIdx >= 0 ? args[scopeIdx + 1] : null;
+
+  if (!scope) {
+    error('Usage: kdna registry audit --scope <@scope> [--json]', EXIT.INPUT_ERROR);
+  }
+
+  const resolver = new RegistryResolver({ allowNetwork: true });
+  const allDomains = resolver.listAllDomains() || [];
+  const scopeDomains = allDomains.filter((d) => {
+    const name = d.name || d.id || '';
+    return name.startsWith(scope);
+  });
+
+  if (!scopeDomains.length) {
+    if (jsonMode) {
+      console.log(JSON.stringify({ scope, domains: [], note: 'No domains found in this scope' }));
+      process.exit(EXIT.OK);
+    }
+    console.log(`No domains found in scope: ${scope}`);
+    return;
+  }
+
+  const audit = {
+    scope,
+    total: scopeDomains.length,
+    domains: scopeDomains.map((d) => ({
+      name: d.name || d.id,
+      version: d.version || null,
+      type: d.type || 'domain',
+      status: d.status || 'experimental',
+      yanked: d.yanked || false,
+      deprecated: d.deprecated || false,
+      has_kdna_url: !!d.kdna_url,
+      has_signature: !!d.signature,
+      has_sha256: !!d.sha256,
+    })),
+    issues: [],
+  };
+
+  // Detect issues
+  const yanked = scopeDomains.filter((d) => d.yanked);
+  const deprecated = scopeDomains.filter((d) => d.deprecated);
+  const noPackage = scopeDomains.filter((d) => !d.kdna_url);
+  const noSignature = scopeDomains.filter((d) => !d.signature);
+
+  if (yanked.length) audit.issues.push(`${yanked.length} yanked domain(s)`);
+  if (deprecated.length) audit.issues.push(`${deprecated.length} deprecated domain(s)`);
+  if (noPackage.length) audit.issues.push(`${noPackage.length} domain(s) without .kdna package`);
+  if (noSignature.length) audit.issues.push(`${noSignature.length} domain(s) without signature`);
+
+  audit.healthy = audit.issues.length === 0;
+
+  if (jsonMode) {
+    console.log(JSON.stringify(audit, null, 2));
+    process.exit(audit.healthy ? EXIT.OK : EXIT.VALIDATION_FAILED);
+  }
+
+  console.log(`Registry audit: ${scope}`);
+  console.log(`  Total domains:     ${audit.total}`);
+  console.log(`  Healthy:           ${audit.healthy ? '✓ yes' : '✗ no'}`);
+  console.log('');
+
+  if (audit.issues.length) {
+    console.log('  Issues:');
+    audit.issues.forEach((i) => console.log(`    ⚠ ${i}`));
+    console.log('');
+  }
+
+  console.log('  Domains:');
+  for (const d of audit.domains) {
+    const flags = [];
+    if (d.yanked) flags.push('yanked');
+    if (d.deprecated) flags.push('deprecated');
+    if (!d.has_kdna_url) flags.push('no-package');
+    console.log(`    ${d.name.padEnd(36)} v${d.version || '?'}  ${flags.length ? `[${flags.join(', ')}]` : '✓'}`);
+  }
+}
+
+// ─── Package ────────────────────────────────────────────────────────────
+
+function cmdPackage(domainPath, args = []) {
+  const abs = path.resolve(domainPath);
+
+  if (!fs.existsSync(abs) || !fs.statSync(abs).isDirectory()) {
+    error(`Not a directory: ${abs}`, EXIT.INPUT_ERROR);
+  }
+
+  const formatIdx = args.indexOf('--format');
+  const format = formatIdx >= 0 ? args[formatIdx + 1] : 'kdna';
+
+  if (!['kdna'].includes(format)) {
+    error(`Unsupported format: ${format}. Use --format=kdna`, EXIT.INPUT_ERROR);
+  }
+
+  const manifest = readJson(path.join(abs, 'kdna.json'));
+  if (!manifest) error(`No kdna.json found in ${abs}. Run: kdna pack`, EXIT.INPUT_ERROR);
+
+  const domainName = manifest.name?.split('/')?.[1] || path.basename(abs);
+  const outFile = path.join(abs, 'dist', `${domainName}-${manifest.version || '0.1.0'}.kdna`);
+
+  // Reuse pack logic from domain.js
+  const { cmdPack } = require('./domain');
+  const outDir = path.join(abs, 'dist');
+
+  // Build package summary
+  const core = readJson(path.join(abs, 'KDNA_Core.json'));
+  const pat = readJson(path.join(abs, 'KDNA_Patterns.json'));
+
+  const pkg = {
+    name: manifest.name || domainName,
+    version: manifest.version || '0.1.0',
+    format,
+    assets: {
+      axioms: (core?.axioms || []).length,
+      ontology: (core?.ontology || []).length,
+      misunderstandings: (pat?.misunderstandings || []).length,
+      self_checks: (pat?.self_check || []).length,
+      scenarios: readJson(path.join(abs, 'KDNA_Scenarios.json'))?.scenes?.length || 0,
+      cases: readJson(path.join(abs, 'KDNA_Cases.json'))?.cases?.length || 0,
+    },
+    files: fs.readdirSync(abs).filter((f) => f.endsWith('.json') || f === 'README.md' || f === 'LICENSE'),
+  };
+
+  // Actually pack
+  fs.mkdirSync(outDir, { recursive: true });
+  cmdPack(abs, outDir);
+
+  console.log(JSON.stringify(pkg, null, 2));
+  console.log(`\nPackage built: ${outFile}`);
+}
+
+module.exports = { cmdBadgeCompute, cmdRegistryAudit, cmdPackage };

package/src/cmds/changelog.js

@@ -0,0 +1,226 @@
+/**
+ * kdna changelog <domain> --from <v1> --to <v2>
+ *   Generate a judgment changelog between two versions.
+ *
+ * Reuses the diff engine from src/diff.js to compute changes,
+ * then renders a human-readable markdown changelog.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { error, EXIT } = require('./_common');
+const { loadJudgment } = require('../diff');
+const { RegistryResolver } = require('../registry');
+
+const TMP_DIR = '/tmp';
+
+function downloadVersion(entry, version, destDir) {
+  const { execSync, execFileSync } = require('child_process');
+  const tmpFile = `${destDir}.kdna.tmp`;
+  try {
+    execFileSync('curl', ['-fsSL', '--retry', '2', '-o', tmpFile, entry.kdna_url], {
+      timeout: 60000,
+      stdio: 'pipe',
+    });
+  } catch (e) {
+    const stderr = e.stderr?.toString().trim() || e.message;
+    error(`Failed to download: ${stderr}`, EXIT.PROVIDER_ERROR);
+  }
+  fs.mkdirSync(destDir, { recursive: true });
+  try {
+    execSync(`unzip -q -o "${tmpFile}" -d "${destDir}"`, { stdio: 'pipe' });
+  } catch {
+    const script = `import zipfile\nzf = zipfile.ZipFile(${JSON.stringify(tmpFile)}, 'r')\nzf.extractall(${JSON.stringify(destDir)})`;
+    execSync(`python3 -c ${JSON.stringify(script)}`, { stdio: 'pipe' });
+  }
+  fs.unlinkSync(tmpFile);
+  return destDir;
+}
+
+function cmdChangelog(args = []) {
+  const jsonMode = args.includes('--json');
+  const positional = args.filter((a) => !a.startsWith('--'));
+  const domainInput = positional[1];
+  const fromIdx = args.indexOf('--from');
+  const toIdx = args.indexOf('--to');
+  const fromVersion = fromIdx >= 0 ? args[fromIdx + 1] : null;
+  const toVersion = toIdx >= 0 ? args[toIdx + 1] : null;
+
+  if (!domainInput || !fromVersion || !toVersion) {
+    error(
+      'Usage:\n' +
+        '  kdna changelog <domain> --from <version> --to <version> [--json]\n' +
+        '\n' +
+        'Generates a judgment changelog between two domain versions.\n' +
+        'Versions are fetched from the registry.',
+      EXIT.INPUT_ERROR,
+    );
+  }
+
+  // Resolve domain from registry
+  let parsed;
+  try {
+    const { parseName } = require('../registry');
+    parsed = parseName(domainInput);
+  } catch {
+    error(`Invalid domain name: ${domainInput}`, EXIT.INPUT_ERROR);
+  }
+  if (!parsed) error(`Cannot parse "${domainInput}"`, EXIT.INPUT_ERROR);
+
+  const resolver = new RegistryResolver({ allowNetwork: true });
+  let entry;
+  try {
+    ({ entry } = resolver.resolve(parsed.full));
+  } catch (e) {
+    error(e.message, EXIT.REGISTRY_ERROR);
+  }
+
+  // Download both versions
+  const tmpOld = path.join(TMP_DIR, `kdna-changelog-${Date.now()}-old`);
+  const tmpNew = path.join(TMP_DIR, `kdna-changelog-${Date.now()}-new`);
+
+  if (!jsonMode) console.log(`Fetching ${parsed.full}@${fromVersion}...`);
+  downloadVersion(entry, fromVersion, tmpOld);
+  if (!jsonMode) console.log(`Fetching ${parsed.full}@${toVersion}...`);
+  downloadVersion(entry, toVersion, tmpNew);
+
+  const oldJ = loadJudgment(tmpOld);
+  const newJ = loadJudgment(tmpNew);
+
+  // Diff maps
+  const axioms = diffSummary(oldJ.axioms || {}, newJ.axioms || {}, 'one_sentence');
+  const ontology = diffSummary(oldJ.ontology || {}, newJ.ontology || {}, 'concept');
+  const misunderstandings = diffSummary(oldJ.misunderstandings || {}, newJ.misunderstandings || {}, 'wrong');
+  const bannedTerms = diffList(Object.keys(oldJ.banned_terms || {}), Object.keys(newJ.banned_terms || {}));
+  const stances = diffList(oldJ.stances || [], newJ.stances || []);
+
+  // Version bump suggestion
+  const hasRemoved = Object.values(axioms).some((a) => a.status === 'removed') ||
+                     Object.values(misunderstandings).some((m) => m.status === 'removed');
+  const hasAdded = Object.values(axioms).some((a) => a.status === 'added') ||
+                   Object.values(misunderstandings).some((m) => m.status === 'added');
+  const hasChanged = Object.values(axioms).some((a) => a.status === 'changed') ||
+                     Object.values(misunderstandings).some((m) => m.status === 'changed');
+  let recommendedBump = 'none';
+  if (hasRemoved) recommendedBump = 'major';
+  else if (hasAdded || hasChanged) recommendedBump = 'minor';
+  else if (stances.added.length || stances.removed.length) recommendedBump = 'patch';
+
+  // Cleanup
+  try { fs.rmSync(tmpOld, { recursive: true, force: true }); } catch { /* cleanup */ }
+  try { fs.rmSync(tmpNew, { recursive: true, force: true }); } catch { /* cleanup */ }
+
+  // Output
+  const changelog = {
+    domain: parsed.full,
+    from: fromVersion,
+    to: toVersion,
+    judgment_version: {
+      before: oldJ.judgment_version || null,
+      after: newJ.judgment_version || null,
+    },
+    changes: {
+      axioms,
+      ontology,
+      misunderstandings,
+      banned_terms: bannedTerms,
+      stances,
+    },
+    recommended_version_bump: recommendedBump,
+  };
+
+  if (jsonMode) {
+    console.log(JSON.stringify(changelog, null, 2));
+    return;
+  }
+
+  // Human-readable markdown
+  console.log(`# ${parsed.full} changelog`);
+  console.log(`## ${fromVersion} → ${toVersion}`);
+  console.log('');
+  if (oldJ.judgment_version || newJ.judgment_version) {
+    console.log(`Judgment version: ${oldJ.judgment_version || '(none)'} → ${newJ.judgment_version || '(none)'}`);
+    console.log('');
+  }
+
+  renderSection('Axioms', axioms);
+  renderSection('Ontology', ontology);
+  renderSection('Misunderstandings', misunderstandings);
+  if (bannedTerms.added.length || bannedTerms.removed.length) {
+    console.log('### Banned Terms');
+    for (const t of bannedTerms.added) console.log(`- **Added:** "${t}"`);
+    for (const t of bannedTerms.removed) console.log(`- **Removed:** "${t}"`);
+    console.log('');
+  }
+  if (stances.added.length || stances.removed.length) {
+    console.log('### Stances');
+    for (const s of stances.added) console.log(`- **Added:** "${s}"`);
+    for (const s of stances.removed) console.log(`- **Removed:** "${s}"`);
+    console.log('');
+  }
+
+  const changeCount = Object.values(changelog.changes).reduce((sum, v) => {
+    if (Array.isArray(v)) return sum + (v.added?.length || 0) + (v.removed?.length || 0);
+    return sum + Object.values(v || {}).filter((x) => x.status !== 'unchanged').length;
+  }, 0);
+
+  console.log(`---`);
+  if (changeCount === 0) {
+    console.log(`No judgment changes detected.`);
+  } else {
+    console.log(`**Recommended version bump: \`${recommendedBump}\`**`);
+  }
+}
+
+function diffSummary(oldMap, newMap, labelField) {
+  const result = {};
+  const oldIds = new Set(Object.keys(oldMap));
+  const newIds = new Set(Object.keys(newMap));
+
+  for (const id of newIds) {
+    if (!oldIds.has(id)) {
+      const item = newMap[id];
+      result[id] = { status: 'added', label: item[labelField] || id };
+    }
+  }
+  for (const id of oldIds) {
+    if (!newIds.has(id)) {
+      const item = oldMap[id];
+      result[id] = { status: 'removed', label: item[labelField] || id };
+    } else {
+      const oldItem = oldMap[id];
+      const newItem = newMap[id];
+      if (JSON.stringify(oldItem) !== JSON.stringify(newItem)) {
+        result[id] = { status: 'changed', label: newItem[labelField] || id };
+      } else {
+        result[id] = { status: 'unchanged', label: newItem[labelField] || id };
+      }
+    }
+  }
+  return result;
+}
+
+function diffList(oldList, newList) {
+  const oldSet = new Set(oldList);
+  const newSet = new Set(newList);
+  return {
+    added: newList.filter((s) => !oldSet.has(s)),
+    removed: oldList.filter((s) => !newSet.has(s)),
+  };
+}
+
+function renderSection(title, items) {
+  const added = Object.entries(items).filter(([, v]) => v.status === 'added');
+  const removed = Object.entries(items).filter(([, v]) => v.status === 'removed');
+  const changed = Object.entries(items).filter(([, v]) => v.status === 'changed');
+
+  if (!added.length && !removed.length && !changed.length) return;
+
+  console.log(`### ${title}`);
+  for (const [, v] of added) console.log(`- **Added:** ${v.label}`);
+  for (const [, v] of removed) console.log(`- **Removed:** ${v.label}`);
+  for (const [, v] of changed) console.log(`- **Changed:** ${v.label}`);
+  console.log('');
+}
+
+module.exports = { cmdChangelog };