@aikdna/kdna-cli 0.9.0 → 0.12.0

package/src/verify.js

@@ -7,15 +7,19 @@
  *
  * No flag = run all three.
  *
- * Exit codes:
+ * Exit codes (semantic, from cmds/_common.js):
  *   0  all checks passed (warnings allowed)
- *   1  one or more layers failed
+ *   1  VALIDATION_FAILED — structure layer failed
+ *   2  INPUT_ERROR — invalid name or not installed
+ *   3  TRUST_FAILED — trust layer failed
+ *   4  JUDGMENT_QUALITY_FAILED — judgment layer failed
  */
 
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const { RegistryResolver, parseName } = require('./registry');
+const { EXIT } = require('./cmds/_common');
 
 const USER_KDNA_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.kdna');
 const INSTALL_DIR = path.join(USER_KDNA_DIR, 'domains');
@@ -213,7 +217,7 @@ function checkJudgment(destDir) {
   const pat = readJson(path.join(destDir, 'KDNA_Patterns.json'));
   const manifest = readJson(path.join(destDir, 'kdna.json'));
 
-  // 1. Boundary declaration in README
+  // 1. Boundary declaration in README (REQUIRED)
   //    Either classic "## Scope" + "## Out of Scope" pair,
   //    OR v2.1 "Four Questions" section (#2 = applies, #4 = does not).
   const readmePath = path.join(destDir, 'README.md');
@@ -234,9 +238,12 @@ function checkJudgment(destDir) {
   if ((hasScope && hasOutOfScope) || hasFourQuestions) {
     bump(2, 2, 'README declares boundary (Scope+Out-of-Scope, or v2.1 Four Questions)');
   } else if (hasScope || hasOutOfScope) {
-    bump(2, 1, 'README declares boundary (Scope+Out-of-Scope, or v2.1 Four Questions)');
+    score.max += 2;
+    score.total += 1;
+    issues.push({ severity: 'warn', msg: 'partial: README boundary declaration incomplete (missing Scope or Out-of-Scope section)' });
   } else {
-    bump(2, 0, 'README declares boundary (Scope+Out-of-Scope, or v2.1 Four Questions)');
+    score.max += 2;
+    issues.push({ severity: 'error', msg: 'README missing boundary declaration: require ## Scope + ## Out of Scope (or v2.1 Four Questions)' });
   }
 
   // 2. v2.1 axiom governance fields
@@ -305,23 +312,31 @@ function checkJudgment(destDir) {
       issues.push({ severity: 'warn', msg: `only ${total} self_check entries (recommend ≥3)` });
   }
 
-  // 5. eval cases present
+  // 5. eval cases present (REQUIRED: ≥4 cases)
   const evalDir = path.join(destDir, 'evals');
   if (fs.existsSync(evalDir)) {
     const files = fs.readdirSync(evalDir).filter((f) => f.endsWith('.json'));
-    if (files.length >= 4) bump(2, 2, `evals/ directory has ${files.length} case files`);
-    else if (files.length > 0)
-      bump(2, 1, `evals/ has ${files.length} files (recommend ≥4: core/boundary/failure/excluded)`);
-    else bump(2, 0, 'evals/ has case files');
+    if (files.length >= 4) {
+      bump(2, 2, `evals/ directory has ${files.length} case files`);
+    } else if (files.length > 0) {
+      score.max += 2;
+      score.total += 1;
+      issues.push({ severity: 'warn', msg: `evals/ has only ${files.length} files (require ≥4: core/boundary/failure/excluded)` });
+    } else {
+      score.max += 2;
+      issues.push({ severity: 'error', msg: 'evals/ directory exists but contains no case files' });
+    }
   } else {
-    bump(2, 0, 'evals/ directory present');
+    score.max += 2;
+    issues.push({ severity: 'error', msg: 'evals/ directory missing: require ≥4 evaluation cases' });
   }
 
-  // 6. judgment_version manifest field
+  // 6. judgment_version manifest field (REQUIRED)
   if (manifest?.judgment_version) {
     bump(1, 1, `judgment_version: ${manifest.judgment_version}`);
   } else {
-    bump(1, 0, 'kdna.json has judgment_version');
+    score.max += 1;
+    issues.push({ severity: 'error', msg: 'kdna.json missing required field: judgment_version' });
   }
 
   return { layer: 'judgment', issues, passed, score };
@@ -355,6 +370,8 @@ function renderLayer(result) {
 // ─── Main ──────────────────────────────────────────────────────────────
 
 function cmdVerify(input, args = []) {
+  const jsonMode = args.includes('--json');
+
   const want = {
     structure: args.includes('--structure'),
     trust: args.includes('--trust'),
@@ -366,14 +383,22 @@ function cmdVerify(input, args = []) {
   // Resolve name → installed path + scope/entry
   const parsed = parseName(input);
   if (!parsed) {
-    console.error(`Invalid name "${input}". Use @scope/name or bare name.`);
-    process.exit(2);
+    if (jsonMode) {
+      console.log(JSON.stringify({ name: input, ok: false, error: `Invalid name "${input}". Use @scope/name or bare name.` }));
+    } else {
+      console.error(`Invalid name "${input}". Use @scope/name or bare name.`);
+    }
+    process.exit(EXIT.INPUT_ERROR);
   }
 
   const destDir = path.join(INSTALL_DIR, parsed.scope, parsed.ident);
   if (!fs.existsSync(destDir)) {
-    console.error(`${parsed.full} is not installed. Run: kdna install ${input}`);
-    process.exit(2);
+    if (jsonMode) {
+      console.log(JSON.stringify({ name: parsed.full, ok: false, error: `${parsed.full} is not installed. Run: kdna install ${input}` }));
+    } else {
+      console.error(`${parsed.full} is not installed. Run: kdna install ${input}`);
+    }
+    process.exit(EXIT.INPUT_ERROR);
   }
 
   let scope = null,
@@ -385,20 +410,55 @@ function cmdVerify(input, args = []) {
       scope = r.scope;
       entry = r.entry;
     } catch (e) {
-      console.warn(`  ⚠ registry lookup failed: ${e.message.split('\n')[0]}`);
+      if (!jsonMode) console.warn(`  ⚠ registry lookup failed: ${e.message.split('\n')[0]}`);
     }
   }
 
-  console.log('═'.repeat(64));
-  console.log(`  Verify ${parsed.full}`);
-  console.log(`  Path:  ${destDir}`);
-  console.log('═'.repeat(64));
-
   const results = [];
   if (want.structure) results.push(checkStructure(destDir));
   if (want.trust) results.push(checkTrust(destDir, scope, entry));
   if (want.judgment) results.push(checkJudgment(destDir));
 
+  // ── JSON output ──────────────────────────────────────────────────────
+  if (jsonMode) {
+    const layers = {};
+    for (const r of results) {
+      layers[r.layer] = {
+        passed: r.passed,
+        errors: r.issues.filter((i) => i.severity === 'error').map((i) => i.msg),
+        warnings: r.issues.filter((i) => i.severity === 'warn').map((i) => i.msg),
+      };
+      if (r.score) layers[r.layer].score = r.score;
+    }
+
+    const structureResult = results.find((r) => r.layer === 'structure');
+    const trustResult = results.find((r) => r.layer === 'trust');
+    const judgmentResult = results.find((r) => r.layer === 'judgment');
+
+    let exitCode = EXIT.OK;
+    if (structureResult && structureResult.issues.some((i) => i.severity === 'error')) {
+      exitCode = EXIT.VALIDATION_FAILED;
+    } else if (trustResult && trustResult.issues.some((i) => i.severity === 'error')) {
+      exitCode = EXIT.TRUST_FAILED;
+    } else if (judgmentResult && judgmentResult.issues.some((i) => i.severity === 'error')) {
+      exitCode = EXIT.JUDGMENT_QUALITY_FAILED;
+    }
+
+    console.log(JSON.stringify({
+      name: parsed.full,
+      path: destDir,
+      layers,
+      ok: exitCode === EXIT.OK,
+    }, null, 2));
+    process.exit(exitCode);
+  }
+
+  // ── Text output (default) ────────────────────────────────────────────
+  console.log('═'.repeat(64));
+  console.log(`  Verify ${parsed.full}`);
+  console.log(`  Path:  ${destDir}`);
+  console.log('═'.repeat(64));
+
   for (const r of results) renderLayer(r);
 
   const totalErrors = results.reduce(
@@ -417,7 +477,21 @@ function cmdVerify(input, args = []) {
   }
   console.log('═'.repeat(64));
 
-  process.exit(totalErrors === 0 ? 0 : 1);
+  // Semantic exit codes for text mode
+  const structureResult = results.find((r) => r.layer === 'structure');
+  const trustResult = results.find((r) => r.layer === 'trust');
+  const judgmentResult = results.find((r) => r.layer === 'judgment');
+
+  let exitCode = EXIT.OK;
+  if (structureResult && structureResult.issues.some((i) => i.severity === 'error')) {
+    exitCode = EXIT.VALIDATION_FAILED;
+  } else if (trustResult && trustResult.issues.some((i) => i.severity === 'error')) {
+    exitCode = EXIT.TRUST_FAILED;
+  } else if (judgmentResult && judgmentResult.issues.some((i) => i.severity === 'error')) {
+    exitCode = EXIT.JUDGMENT_QUALITY_FAILED;
+  }
+
+  process.exit(exitCode);
 }
 
 module.exports = { cmdVerify, checkStructure, checkTrust, checkJudgment };

package/src/version.js

@@ -6,10 +6,11 @@
 
 const fs = require('fs');
 const path = require('path');
+const { EXIT } = require('./cmds/_common');
 
-function error(msg) {
+function error(msg, code = EXIT.VALIDATION_FAILED) {
   console.error(`Error: ${msg}`);
-  process.exit(1);
+  process.exit(code);
 }
 
 function readJson(filePath) {
@@ -109,4 +110,110 @@ function cmdVersionBump(level, domainPath) {
   console.log(`Done. Version: ${oldVersion} → ${newVersion}`);
 }
 
-module.exports = { cmdVersionBump };
+/**
+ * kdna version bump --suggest [path]
+ *   Suggest version bump based on judgment changes detected by kdna diff.
+ *   Compares installed vs registry-current and suggests patch/minor/major.
+ */
+function cmdVersionSuggest(domainPath = '.', args = []) {
+  const jsonMode = args.includes('--json');
+  const abs = path.resolve(domainPath);
+
+  const manifest = readJson(path.join(abs, 'kdna.json'));
+  if (!manifest) {
+    if (jsonMode) {
+      console.log(JSON.stringify({ error: 'No kdna.json found', suggestion: 'none' }));
+      process.exit(EXIT.OK);
+    }
+    console.log('No kdna.json found in current directory. Cannot suggest version bump.');
+    process.exit(EXIT.OK);
+  }
+
+  const currentVersion = manifest.version;
+  if (!currentVersion) {
+    if (jsonMode) {
+      console.log(JSON.stringify({ error: 'No version field', suggestion: 'none' }));
+      process.exit(EXIT.OK);
+    }
+    console.log('No version field in kdna.json.');
+    process.exit(EXIT.OK);
+  }
+
+  // Rules for suggesting:
+  // - If no previous version to diff against, suggest 'none'
+  // - Check for judgment_version changes
+  // - Check for axiom/ontology/misunderstanding changes
+
+  const changes = detectChanges(abs);
+
+  if (jsonMode) {
+    console.log(JSON.stringify({
+      current_version: currentVersion,
+      suggested_bump: changes.suggestion,
+      reasons: changes.reasons,
+      change_summary: changes.summary,
+    }, null, 2));
+    return;
+  }
+
+  console.log(`Current version: ${currentVersion}`);
+  console.log(`Suggested bump:  ${changes.suggestion}`);
+  console.log('');
+  if (changes.reasons.length) {
+    console.log('Reasons:');
+    changes.reasons.forEach((r) => console.log(`  - ${r}`));
+  }
+  if (changes.suggestion !== 'none') {
+    console.log('');
+    console.log(`Run: kdna version bump ${changes.suggestion} ${domainPath}`);
+  }
+}
+
+function detectChanges(domainPath) {
+  const reasons = [];
+  let axiomChanges = 0;
+  const ontologyChanges = 0;
+  const misunderstandingChanges = 0;
+
+  // Simple heuristic: count content vs previous git state
+  // For now, use a heuristic based on file modification
+  const core = readJson(path.join(domainPath, 'KDNA_Core.json'));
+
+  // Check if evals/ dir has recent changes
+  const evalsDir = path.join(domainPath, 'evals');
+  if (fs.existsSync(evalsDir)) {
+    reasons.push('evals/ directory present');
+  }
+
+  // Check for judgment_version in manifest
+  const manifest = readJson(path.join(domainPath, 'kdna.json'));
+  if (manifest?.judgment_version) {
+    reasons.push(`judgment_version: ${manifest.judgment_version}`);
+  }
+
+  // Count axioms with applies_when (v2.1 governance) vs without
+  if (core?.axioms) {
+    const total = core.axioms.length;
+    const governed = core.axioms.filter((a) => a.applies_when?.length && a.does_not_apply_when?.length).length;
+    if (governed < total) {
+      axiomChanges = total - governed;
+      reasons.push(`${axiomChanges} axioms missing v2.1 governance fields`);
+    }
+  }
+
+  let suggestion = 'none';
+  if (axiomChanges > 0) suggestion = 'patch';
+  if (axiomChanges >= 3) suggestion = 'minor';
+
+  return {
+    suggestion,
+    reasons,
+    summary: {
+      axiom_changes: axiomChanges,
+      ontology_changes: ontologyChanges,
+      misunderstanding_changes: misunderstandingChanges,
+    },
+  };
+}
+
+module.exports = { cmdVersionBump, cmdVersionSuggest };