@aikdna/kdna-cli 0.9.0 → 0.11.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');
@@ -355,6 +359,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 +372,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 +399,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 +466,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 };