@aikdna/studio-core 1.0.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aikdna/studio-core",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "KDNA Studio Core — pure logic library for authoring, validating, and compiling KDNA domain judgment packages.",
   "type": "commonjs",
   "main": "src/index.js",

package/src/i18n/index.js

@@ -0,0 +1,138 @@
+/**
+ * I18N — Locale overlay creation, validation, and application.
+ *
+ * KDNA domains encode judgment. Localization changes language, not logic.
+ * Overlays translate text fields by referencing canonical IDs.
+ * Structural fields MUST NOT be changed by localization.
+ */
+
+const TEXT_FIELDS = ['one_sentence', 'full_statement', 'why', 'key_distinction', 'wrong', 'correct',
+  'failure_risk', 'essence', 'boundary', 'trigger_signal', 'question', 'scope', 'out_of_scope'];
+const ARRAY_TEXT_FIELDS = ['applies_when', 'does_not_apply_when', 'acceptable_exceptions'];
+
+const VALID_LOCALES = ['en', 'zh-CN', 'zh-TW', 'ja', 'ko', 'fr', 'de'];
+
+function createLocaleOverlay(project, locale) {
+  if (!VALID_LOCALES.includes(locale)) throw new Error(`Invalid locale: ${locale}`);
+
+  const overlay = { locale, base: 'en', spec_version: '1.0-rc', translations: {} };
+  const cards = project.cards || [];
+
+  for (const card of cards) {
+    if (!card.locked) continue;
+    const fields = card.fields || {};
+
+    for (const field of TEXT_FIELDS) {
+      if (fields[field] && typeof fields[field] === 'string' && fields[field].length > 3) {
+        overlay.translations[`${card.id}.${field}`] = `[TODO: ${locale}] ${fields[field]}`;
+      }
+    }
+    for (const field of ARRAY_TEXT_FIELDS) {
+      if (Array.isArray(fields[field])) {
+        fields[field].forEach((val, idx) => {
+          if (val && typeof val === 'string') {
+            overlay.translations[`${card.id}.${field}.${idx}`] = `[TODO: ${locale}] ${val}`;
+          }
+        });
+      }
+    }
+  }
+
+  return overlay;
+}
+
+function validateLocaleOverlay(project, overlay) {
+  const issues = [];
+  const cards = project.cards || [];
+  const cardIds = new Set(cards.map(c => c.id));
+
+  if (!overlay.locale) issues.push({ type: 'missing_locale', severity: 'blocking', message: 'Overlay must declare locale' });
+  if (!overlay.translations || Object.keys(overlay.translations).length === 0) {
+    issues.push({ type: 'empty', severity: 'warning', message: 'Overlay has no translations' });
+    return { valid: false, issues };
+  }
+
+  // Validate referenced IDs exist
+  for (const key of Object.keys(overlay.translations)) {
+    const cardId = key.split('.')[0];
+    if (!cardIds.has(cardId)) {
+      issues.push({ type: 'unknown_id', severity: 'blocking', message: `Overlay references unknown card: ${cardId}` });
+    }
+  }
+
+  // Check for TODO placeholders
+  const todoCount = Object.values(overlay.translations).filter(v => v.includes('[TODO:')).length;
+  if (todoCount > 0) {
+    issues.push({ type: 'incomplete', severity: 'warning', message: `${todoCount} translations still have TODO placeholders` });
+  }
+
+  return { valid: issues.filter(i => i.severity === 'blocking').length === 0, issues };
+}
+
+function applyLocaleOverlay(domainFiles, overlay) {
+  if (!overlay || !overlay.translations) return domainFiles;
+  const localized = { ...domainFiles };
+
+  for (const [filename, content] of Object.entries(localized)) {
+    if (!filename.startsWith('KDNA_')) continue;
+    try {
+      const data = JSON.parse(content);
+      applyOverlayToObject(data, overlay.translations);
+      localized[filename] = JSON.stringify(data, null, 2);
+    } catch { /* skip non-JSON */ }
+  }
+
+  return localized;
+}
+
+function applyOverlayToObject(obj, translations, prefix = '') {
+  for (const key of Object.keys(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (typeof obj[key] === 'string') {
+      if (translations[fullKey] && !translations[fullKey].includes('[TODO:')) {
+        obj[key] = translations[fullKey];
+      }
+    } else if (Array.isArray(obj[key])) {
+      if (obj[key].every(v => typeof v === 'string')) {
+        obj[key] = obj[key].map((v, i) => {
+          const arrayKey = `${fullKey}.${i}`;
+          return (translations[arrayKey] && !translations[arrayKey].includes('[TODO:')) ? translations[arrayKey] : v;
+        });
+      } else {
+        obj[key].forEach((item, i) => {
+          if (typeof item === 'object' && item !== null) {
+            applyOverlayToObject(item, translations, `${fullKey}.${i}`);
+          } else if (item && item.id) {
+            applyOverlayToObject(item, translations, item.id);
+          }
+        });
+      }
+    } else if (typeof obj[key] === 'object' && obj[key] !== null) {
+      applyOverlayToObject(obj[key], translations, fullKey);
+    }
+  }
+}
+
+function computeI18nCoverage(project) {
+  const cards = project.cards || [];
+  const locked = cards.filter(c => c.locked);
+  if (locked.length === 0) return { level: 'L0', coverage: 0, translatable_fields: 0 };
+
+  const totalFields = locked.reduce((sum, c) => {
+    const fields = c.fields || {};
+    let count = 0;
+    for (const f of TEXT_FIELDS) { if (fields[f] && typeof fields[f] === 'string') count++; }
+    for (const f of ARRAY_TEXT_FIELDS) { if (Array.isArray(fields[f])) count += fields[f].filter(v => typeof v === 'string').length; }
+    return sum + count;
+  }, 0);
+
+  let level = 'L0';
+  if (totalFields > 0) level = 'L1'; // Assume card/readme localization
+  if (totalFields > 5) level = 'L2'; // Key fields covered
+  if (totalFields > 15) level = 'L3'; // Full coverage
+  if ((project.tests || []).length >= 5) level = 'L4'; // Has evals
+
+  return { level, coverage: Math.min(100, Math.round(locked.length * 10)), translatable_fields: totalFields };
+}
+
+module.exports = { createLocaleOverlay, validateLocaleOverlay, applyLocaleOverlay, computeI18nCoverage, VALID_LOCALES };

package/src/index.js

@@ -21,6 +21,7 @@ const cards = require('./cards');
 const compile = require('./compile');
 const evidence = require('./evidence');
 const governance = require('./governance');
+const i18n = require('./i18n');
 const packaging = require('./packaging');
 const pipeline = require('./pipeline');
 const project = require('./project');
@@ -42,6 +43,7 @@ module.exports = {
   provenance,
   pipeline,
   governance,
+  i18n,
 
   // Experimental
   evidence,

package/src/quality/index.js

@@ -13,6 +13,7 @@
 const contradiction = require('./contradiction');
 const { validateAllCards } = require('./validate-cards');
 const { validateGovernance } = require('../governance');
+const { computeI18nCoverage } = require('../i18n');
 
 function computeReadiness(project) {
   const cards = project.cards || [];
@@ -28,6 +29,15 @@ function computeReadiness(project) {
 
   // ── Governance check (v0.6.1) ───────────────────────────────────
   const govResult = validateGovernance(project);
+
+  // ── I18N check (v1.2.0) ─────────────────────────────────────────
+  const isOfficial = project.name?.startsWith('@aikdna/') || project.release?.official === true;
+  const i18nCoverage = computeI18nCoverage(project);
+  if (isOfficial && i18nCoverage.level === 'L0') {
+    blocking.push('I18N: official domains require at least L1 (KDNA_CARD.json + README in locales/zh-CN/)');
+  } else if (isOfficial && i18nCoverage.level === 'L1') {
+    warnings.push('I18N: L1 achieved (card + readme). Recommended: L2 overlay for publishable grade.');
+  }
   for (const issue of govResult.issues) {
     (issue.severity === 'blocking' ? blocking : warnings).push(`Governance: ${issue.message}`);
   }
@@ -114,7 +124,7 @@ function computeReadiness(project) {
     warnings.push('Governance checks not passed — publishable downgraded to tested');
   }
 
-  return buildResult(grade, blocking, warnings, project, { feynmanRatio, allFeynman, governance: govResult });
+  return buildResult(grade, blocking, warnings, project, { feynmanRatio, allFeynman, governance: govResult, i18n: i18nCoverage });
 }
 
 function buildResult(grade, blocking, warnings, project, detail = {}) {
@@ -128,6 +138,7 @@ function buildResult(grade, blocking, warnings, project, detail = {}) {
     warnings,
     score: Math.max(0, 100 - blocking.length * 15 - warnings.length * 3),
     governance: detail.governance || null,
+    i18n: detail.i18n || null,
     stats: {
       total_cards: (project.cards || []).length,
       locked_cards: lockedCount,
@@ -136,6 +147,7 @@ function buildResult(grade, blocking, warnings, project, detail = {}) {
       total_tests: (project.tests || []).length,
       rated_tests: ratedTests,
       feynman_ratio: detail.feynmanRatio !== undefined ? Math.round(detail.feynmanRatio * 100) + '%' : 'N/A',
+      i18n_level: detail.i18n?.level || 'L0',
     },
     next_step: grade === 'draft_grade' ? 'Lock at least 3 axioms with boundaries and 50% Feynman.' :
       grade === 'human_controlled' ? 'Add 5+ rated evals and 3+ self-checks.' :