@aikdna/kdna-cli 0.16.4 → 0.16.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aikdna/kdna-cli",
-  "version": "0.16.4",
+  "version": "0.16.6",
   "description": "KDNA CLI — create, validate, install, and manage domain cognition packages for AI agents.",
   "type": "commonjs",
   "bin": {

package/src/cli.js

@@ -7,7 +7,14 @@
  */
 
 const { error, EXIT, setQuiet, setExitCodeOnly } = require('./cmds/_common');
-const { cmdValidate, cmdPack, cmdPackEncrypt, cmdUnpack, cmdUnpackEncrypt, cmdInspect } = require('./cmds/domain');
+const {
+  cmdValidate,
+  cmdPack,
+  cmdPackEncrypt,
+  cmdUnpack,
+  cmdUnpackEncrypt,
+  cmdInspect,
+} = require('./cmds/domain');
 const { cmdList, cmdRegistry } = require('./cmds/registry');
 const {
   cmdCompare,
@@ -24,12 +31,31 @@ const { cmdIdentity } = require('./cmds/identity');
 const { cmdSetup } = require('./cmds/setup');
 const { cmdDoctor } = require('./cmds/doctor');
 const { cmdTrace, cmdHistory } = require('./cmds/trace');
-const { cmdLicenseGenerate, cmdLicenseVerify, cmdLicenseBind, cmdLicenseShow, cmdLicenseInstall } = require('./cmds/license');
+const {
+  cmdLicenseGenerate,
+  cmdLicenseVerify,
+  cmdLicenseBind,
+  cmdLicenseShow,
+  cmdLicenseInstall,
+} = require('./cmds/license');
 const { cmdPreview, cmdProject, cmdEval, cmdExport, cmdDemo } = require('./cmds/legacy');
-const { cmdStudioScaffold, cmdCardsValidate, cmdLockVerify, cmdStudioCompile, cmdStudioReadiness } = require('./cmds/studio');
+const {
+  cmdStudioScaffold,
+  cmdCardsValidate,
+  cmdLockVerify,
+  cmdStudioCompile,
+  cmdStudioReadiness,
+} = require('./cmds/studio');
 const { cmdTestRun, cmdTestImport } = require('./cmds/test');
 const { cmdChangelog } = require('./cmds/changelog');
-const { cmdProposalCreate, cmdProposalValidate, cmdReview, cmdLockCard, cmdEvolution, cmdRegression } = require('./cmds/governance');
+const {
+  cmdProposalCreate,
+  cmdProposalValidate,
+  cmdReview,
+  cmdLockCard,
+  cmdEvolution,
+  cmdRegression,
+} = require('./cmds/governance');
 const { cmdBadgeCompute, cmdRegistryAudit, cmdPackage } = require('./cmds/badge');
 
 // ─── Main ─────────────────────────────────────────────────────────────
@@ -81,6 +107,8 @@ Agent Runtime:
 
 Testing & Verification:
   verify <name>                    3-layer: structure + trust + judgment
+  verify <name> --i18n               I18N verification: locales, overlays, card completeness
+  verify <name> --governance         Governance verification: risk_level, KDNA_CARD, provenance
   verify <name> --judgment --run-tests  Judgment validation with eval cases
   compare <name> --input "..."     With/without KDNA reasoning diff
   compare <name> --input "..." --report-md     Markdown report format
@@ -332,7 +360,10 @@ switch (cmd) {
     } else if (sub === 'validate') {
       cmdProposalValidate(args);
     } else {
-      error('Usage: kdna proposal create --from-test <run.json> --domain <path>\n       kdna proposal validate <proposal.json>', EXIT.INPUT_ERROR);
+      error(
+        'Usage: kdna proposal create --from-test <run.json> --domain <path>\n       kdna proposal validate <proposal.json>',
+        EXIT.INPUT_ERROR,
+      );
     }
     break;
   }
@@ -405,7 +436,9 @@ switch (cmd) {
     break;
   }
   case 'list': {
-    cmdList(args.includes('--available'), args.includes('--json'));
+    const localeIdx = args.indexOf('--locale');
+    const locale = localeIdx >= 0 ? args[localeIdx + 1] : null;
+    cmdList(args.includes('--available'), args.includes('--json'), locale);
     break;
   }
   case 'setup': {

package/src/cmds/registry.js

@@ -3,7 +3,7 @@ const path = require('path');
 const { CANONICAL_REGISTRY_URL, REGISTRY_CACHE, fetchRegistry } = require('../registry');
 const { error, readJson, loadRegistry, INSTALL_DIR, EXIT } = require('./_common');
 
-function cmdList(showAvailable, jsonMode = false) {
+function cmdList(showAvailable, jsonMode = false, locale = null) {
   if (showAvailable) {
     const domains = loadRegistry({ allowNetwork: true });
     if (!domains || !domains.length) {

package/src/verify.js

@@ -240,10 +240,16 @@ function checkJudgment(destDir) {
   } else if (hasScope || hasOutOfScope) {
     score.max += 2;
     score.total += 1;
-    issues.push({ severity: 'warn', msg: 'partial: README boundary declaration incomplete (missing Scope or Out-of-Scope section)' });
+    issues.push({
+      severity: 'warn',
+      msg: 'partial: README boundary declaration incomplete (missing Scope or Out-of-Scope section)',
+    });
   } else {
     score.max += 2;
-    issues.push({ severity: 'error', msg: 'README missing boundary declaration: require ## Scope + ## Out of Scope (or v2.1 Four Questions)' });
+    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
@@ -321,14 +327,20 @@ function checkJudgment(destDir) {
     } 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)` });
+      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 {
     score.max += 2;
-    issues.push({ severity: 'error', msg: 'evals/ directory missing: require ≥4 evaluation cases' });
+    issues.push({
+      severity: 'error',
+      msg: 'evals/ directory missing: require ≥4 evaluation cases',
+    });
   }
 
   // 6. judgment_version manifest field (REQUIRED)
@@ -367,6 +379,175 @@ function renderLayer(result) {
   }
 }
 
+// ─── I18N layer ──────────────────────────────────────────────────────
+
+function checkI18n(destDir) {
+  const issues = [];
+  const passed = [];
+  const manifest = readJson(path.join(destDir, 'kdna.json')) || {};
+  const languages = manifest.languages || [];
+  const i18nLevel = manifest.i18n_level || 'L0';
+
+  if (languages.length === 0) {
+    passed.push('i18n: no languages declared (L0 — monolingual)');
+    return { layer: 'i18n', passed: true, issues, results: passed };
+  }
+
+  passed.push(`languages declared: ${languages.join(', ')}`);
+  passed.push(`i18n level: ${i18nLevel}`);
+
+  const canonical = manifest.default_language || languages[0] || 'en';
+  for (const lang of languages) {
+    if (lang === canonical) continue;
+    const localeDir = path.join(destDir, 'locales', lang);
+
+    // L1: card + readme
+    if (['L1', 'L2', 'L3', 'L4'].includes(i18nLevel)) {
+      if (!fs.existsSync(path.join(localeDir, 'KDNA_CARD.json'))) {
+        issues.push({ severity: 'error', msg: `i18n: ${lang} KDNA_CARD.json missing` });
+      } else {
+        const card = readJson(path.join(localeDir, 'KDNA_CARD.json'));
+        if (card) {
+          passed.push(`locales/${lang}/KDNA_CARD.json OK`);
+          if (!card.display_name)
+            issues.push({ severity: 'warn', msg: `i18n: ${lang} card missing display_name` });
+          if (!card.intended_use?.length)
+            issues.push({ severity: 'warn', msg: `i18n: ${lang} card missing intended_use` });
+        }
+      }
+      if (!fs.existsSync(path.join(localeDir, 'README.md'))) {
+        issues.push({ severity: 'warn', msg: `i18n: ${lang} README.md missing` });
+      } else {
+        passed.push(`locales/${lang}/README.md OK`);
+      }
+    }
+
+    // L2: overlay files
+    if (['L2', 'L3', 'L4'].includes(i18nLevel)) {
+      const coreOverlay = path.join(localeDir, 'KDNA_Core.overlay.json');
+      if (!fs.existsSync(coreOverlay)) {
+        issues.push({ severity: 'error', msg: `i18n: ${lang} KDNA_Core.overlay.json missing` });
+      } else {
+        const overlay = readJson(coreOverlay);
+        if (overlay?.translations) {
+          const core = readJson(path.join(destDir, 'KDNA_Core.json'));
+          if (core?.axioms) {
+            const validIds = new Set(core.axioms.map((a) => a.id));
+            for (const key of Object.keys(overlay.translations)) {
+              const refId = key.split('.')[0];
+              if (!validIds.has(refId)) {
+                issues.push({
+                  severity: 'error',
+                  msg: `i18n: overlay refs unknown axiom: ${refId}`,
+                });
+              }
+            }
+          }
+          passed.push(
+            `locales/${lang}/KDNA_Core.overlay.json OK (${Object.keys(overlay.translations).length} translations)`,
+          );
+        }
+      }
+      if (!fs.existsSync(path.join(localeDir, 'KDNA_Patterns.overlay.json'))) {
+        issues.push({ severity: 'warn', msg: `i18n: ${lang} KDNA_Patterns.overlay.json missing` });
+      }
+    }
+  }
+
+  if (manifest.languages?.length && !manifest.i18n_level) {
+    issues.push({ severity: 'warn', msg: 'i18n: languages declared but i18n_level not set' });
+  }
+
+  return {
+    layer: 'i18n',
+    passed: issues.filter((i) => i.severity === 'error').length === 0,
+    issues,
+    results: passed.concat(issues.map((i) => i.msg)),
+    score: { total: passed.length, max: passed.length + issues.length },
+  };
+}
+
+// ─── Governance layer ───────────────────────────────────────────────
+
+function checkGovernance(destDir) {
+  const issues = [];
+  const passed = [];
+  const card = readJson(path.join(destDir, 'KDNA_CARD.json')) || {};
+
+  if (!readJson(path.join(destDir, 'KDNA_CARD.json'))) {
+    issues.push({ severity: 'error', msg: 'governance: KDNA_CARD.json missing — required' });
+    return { layer: 'governance', passed: false, issues, results: issues.map((i) => i.msg) };
+  }
+  passed.push('KDNA_CARD.json present');
+
+  if (!card.risk_level) {
+    issues.push({ severity: 'error', msg: 'governance: risk_level not declared (R0/R1/R2/R3)' });
+  } else if (!['R0', 'R1', 'R2', 'R3'].includes(card.risk_level)) {
+    issues.push({ severity: 'error', msg: `governance: invalid risk_level "${card.risk_level}"` });
+  } else {
+    passed.push(`risk_level: ${card.risk_level}`);
+  }
+
+  if (!card.intended_use?.length) {
+    issues.push({ severity: 'error', msg: 'governance: intended_use empty' });
+  } else {
+    passed.push(`intended_use: ${card.intended_use.length} entries`);
+  }
+
+  if (!card.out_of_scope?.length) {
+    issues.push({ severity: 'error', msg: 'governance: out_of_scope empty' });
+  } else {
+    passed.push(`out_of_scope: ${card.out_of_scope.length} entries`);
+  }
+
+  if (!card.known_limitations?.length) {
+    issues.push({ severity: 'warn', msg: 'governance: known_limitations empty' });
+  } else {
+    passed.push(`known_limitations: ${card.known_limitations.length} entries`);
+  }
+
+  if (['R1', 'R2', 'R3'].includes(card.risk_level) && !card.author_responsibility) {
+    issues.push({
+      severity: 'warn',
+      msg: `governance: risk ${card.risk_level} should declare author_responsibility`,
+    });
+  }
+
+  if (['R2', 'R3'].includes(card.risk_level)) {
+    if (!card.reviewed_by && !card.requires_expert_review) {
+      issues.push({
+        severity: 'error',
+        msg: `governance: risk ${card.risk_level} requires expert_review`,
+      });
+    }
+    if (!card.risk_warnings?.length) {
+      issues.push({
+        severity: 'error',
+        msg: `governance: risk ${card.risk_level} requires risk_warnings`,
+      });
+    }
+  }
+
+  if (!card.human_lock_summary)
+    issues.push({ severity: 'warn', msg: 'governance: human_lock_summary missing' });
+  else passed.push('human_lock_summary present');
+
+  if (!card.provenance) issues.push({ severity: 'warn', msg: 'governance: provenance missing' });
+  else passed.push('provenance present');
+
+  if (!card.quality_badge)
+    issues.push({ severity: 'warn', msg: 'governance: quality_badge missing' });
+  else passed.push(`quality_badge: ${card.quality_badge}`);
+
+  return {
+    layer: 'governance',
+    passed: issues.filter((i) => i.severity === 'error').length === 0,
+    issues,
+    results: passed.concat(issues.map((i) => i.msg)),
+    score: { total: passed.length, max: passed.length + issues.length },
+  };
+}
+
 // ─── Main ──────────────────────────────────────────────────────────────
 
 function cmdVerify(input, args = []) {
@@ -376,15 +557,23 @@ function cmdVerify(input, args = []) {
     structure: args.includes('--structure'),
     trust: args.includes('--trust'),
     judgment: args.includes('--judgment'),
+    i18n: args.includes('--i18n'),
+    governance: args.includes('--governance'),
   };
-  const all = !want.structure && !want.trust && !want.judgment;
+  const all = !want.structure && !want.trust && !want.judgment && !want.i18n && !want.governance;
   if (all) want.structure = want.trust = want.judgment = true;
 
   // Resolve name → installed path + scope/entry
   const parsed = parseName(input);
   if (!parsed) {
     if (jsonMode) {
-      console.log(JSON.stringify({ name: input, ok: false, error: `Invalid name "${input}". Use @scope/name or bare name.` }));
+      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.`);
     }
@@ -394,7 +583,13 @@ function cmdVerify(input, args = []) {
   const destDir = path.join(INSTALL_DIR, parsed.scope, parsed.ident);
   if (!fs.existsSync(destDir)) {
     if (jsonMode) {
-      console.log(JSON.stringify({ name: parsed.full, ok: false, error: `${parsed.full} is not installed. Run: kdna install ${input}` }));
+      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}`);
     }
@@ -418,6 +613,8 @@ function cmdVerify(input, args = []) {
   if (want.structure) results.push(checkStructure(destDir));
   if (want.trust) results.push(checkTrust(destDir, scope, entry));
   if (want.judgment) results.push(checkJudgment(destDir));
+  if (want.i18n) results.push(checkI18n(destDir));
+  if (want.governance) results.push(checkGovernance(destDir));
 
   // ── JSON output ──────────────────────────────────────────────────────
   if (jsonMode) {
@@ -434,6 +631,8 @@ function cmdVerify(input, args = []) {
     const structureResult = results.find((r) => r.layer === 'structure');
     const trustResult = results.find((r) => r.layer === 'trust');
     const judgmentResult = results.find((r) => r.layer === 'judgment');
+    const i18nResult = results.find((r) => r.layer === 'i18n');
+    const governanceResult = results.find((r) => r.layer === 'governance');
 
     let exitCode = EXIT.OK;
     if (structureResult && structureResult.issues.some((i) => i.severity === 'error')) {
@@ -444,12 +643,18 @@ function cmdVerify(input, args = []) {
       exitCode = EXIT.JUDGMENT_QUALITY_FAILED;
     }
 
-    console.log(JSON.stringify({
-      name: parsed.full,
-      path: destDir,
-      layers,
-      ok: exitCode === EXIT.OK,
-    }, null, 2));
+    console.log(
+      JSON.stringify(
+        {
+          name: parsed.full,
+          path: destDir,
+          layers,
+          ok: exitCode === EXIT.OK,
+        },
+        null,
+        2,
+      ),
+    );
     process.exit(exitCode);
   }