@aikdna/kdna-core 0.3.0 → 0.5.0

package/src/index.js

@@ -6,6 +6,8 @@ const lint = require('./lint-pure');
 const validate = require('./validate-pure');
 const render = require('./render');
 const compose = require('./compose');
+const assetReader = require('./asset-reader');
+const cryptoProfile = require('./crypto-profile');
 
 module.exports = {
   ...loader,
@@ -13,4 +15,6 @@ module.exports = {
   ...validate,
   ...render,
   ...compose,
+  ...assetReader,
+  ...cryptoProfile,
 };

package/src/index.mjs

@@ -17,3 +17,14 @@ export { validateDomainSchema, validateCrossFile } from './validate-pure.js';
 export { renderPreviewHTML, escHtml, renderCard } from './render.js';
 
 export { composeContext, composeContextWithAttribution, classifySignals, classifySignalsAcrossDomains, composeChecks, loadAndCompose, loadCluster, detectDomainConflicts, generateClusterTrace } from './compose.js';
+
+import assetReader from './asset-reader.js';
+import cryptoProfile from './crypto-profile.js';
+
+export const STANDARD_ENTRIES = assetReader.STANDARD_ENTRIES;
+export const createKdnaAssetReader = assetReader.createKdnaAssetReader;
+export const LICENSED_ENTRY_PROFILE = cryptoProfile.LICENSED_ENTRY_PROFILE;
+export const deriveLicensedEntryKey = cryptoProfile.deriveLicensedEntryKey;
+export const encryptLicensedEntry = cryptoProfile.encryptLicensedEntry;
+export const decryptLicensedEntry = cryptoProfile.decryptLicensedEntry;
+export const createLicensedDecryptEntry = cryptoProfile.createLicensedDecryptEntry;

package/src/lint-pure.js

@@ -29,6 +29,15 @@ const OLD_FIELD_HINTS = {
   judgment: 'via',
 };
 
+const KDNA_DOMAIN_FILES = new Set([
+  'KDNA_Core.json',
+  'KDNA_Patterns.json',
+  'KDNA_Scenarios.json',
+  'KDNA_Cases.json',
+  'KDNA_Reasoning.json',
+  'KDNA_Evolution.json',
+]);
+
 /**
  * Lint a KDNA domain from a map of parsed JSON objects.
  *
@@ -104,9 +113,7 @@ function lintDomain(dataMap) {
   }
 
   // Check file count
-  const kdnaFiles = Object.keys(dataMap).filter(
-    (f) => f.endsWith('.json') && f !== 'kdna.json',
-  );
+  const kdnaFiles = Object.keys(dataMap).filter((f) => KDNA_DOMAIN_FILES.has(f));
   if (kdnaFiles.length > 6) errors.push(`Domain has ${kdnaFiles.length} JSON files; KDNA allows at most 6.`);
 
   // Validate meta on all files
@@ -245,4 +252,152 @@ function lintDomain(dataMap) {
   return { errors, warnings };
 }
 
-module.exports = { lintDomain };
+/**
+ * Canonical enum tables for manifest validation.
+ * Single source of truth — keep in sync with schema/kdna-manifest-v1rc.json and specs/enum-tables.md.
+ */
+const VALID_STATUS = new Set(['draft', 'experimental', 'stable', 'deprecated', 'staging']);
+const VALID_BADGE = new Set(['untested', 'tested', 'validated', 'expert_reviewed', 'production_ready']);
+const VALID_ACCESS = new Set(['open', 'licensed', 'runtime']);
+const VALID_RISK = new Set(['R0', 'R1', 'R2', 'R3']);
+const VALID_I18N = new Set(['L0', 'L1', 'L2', 'L3']);
+
+const MANIFEST_REQUIRED = [
+  'kdna_spec', 'name', 'version', 'judgment_version',
+  'description', 'author', 'license', 'status',
+  'quality_badge', 'access', 'language',
+];
+
+/**
+ * Validate a kdna.json manifest against the canonical v1.0-rc schema.
+ *
+ * @param {Object} manifest — parsed kdna.json
+ * @returns {{ errors: string[], warnings: string[] }}
+ */
+function validateManifest(manifest) {
+  const errors = [];
+  const warnings = [];
+
+  if (!manifest || typeof manifest !== 'object') {
+    errors.push('kdna.json: missing or empty manifest');
+    return { errors, warnings };
+  }
+
+  // 1. Check spec_version is NOT in domain manifest (use kdna_spec only)
+  if ('spec_version' in manifest) {
+    errors.push(
+      'kdna.json: spec_version is deprecated in domain manifests. Use kdna_spec. ' +
+      '(spec_version is reserved for .kdna container manifests only.)',
+    );
+  }
+
+  // 2. Check required fields
+  for (const field of MANIFEST_REQUIRED) {
+    if (!(field in manifest) || manifest[field] === undefined || manifest[field] === '') {
+      errors.push(`kdna.json: missing required field "${field}"`);
+    }
+  }
+
+  // 3. Validate name format
+  if (manifest.name && !/^@[a-z][a-z0-9-]*\/[a-z][a-z0-9_]*$/.test(manifest.name)) {
+    errors.push(`kdna.json.name: invalid format "${manifest.name}". Expected @scope/name.`);
+  }
+
+  // 4. Validate enum fields
+  if (manifest.status && !VALID_STATUS.has(manifest.status)) {
+    errors.push(
+      `kdna.json.status: invalid value "${manifest.status}". ` +
+      `Valid: ${[...VALID_STATUS].join(', ')}`,
+    );
+  }
+  if (manifest.quality_badge && !VALID_BADGE.has(manifest.quality_badge)) {
+    errors.push(
+      `kdna.json.quality_badge: invalid value "${manifest.quality_badge}". ` +
+      `Valid: ${[...VALID_BADGE].join(', ')}`,
+    );
+  }
+  if (manifest.access && !VALID_ACCESS.has(manifest.access)) {
+    errors.push(
+      `kdna.json.access: invalid value "${manifest.access}". ` +
+      `Valid: ${[...VALID_ACCESS].join(', ')}`,
+    );
+  }
+  if (manifest.risk_level && !VALID_RISK.has(manifest.risk_level)) {
+    errors.push(
+      `kdna.json.risk_level: invalid value "${manifest.risk_level}". ` +
+      `Valid: ${[...VALID_RISK].join(', ')}`,
+    );
+  }
+  if (manifest.i18n_level && !VALID_I18N.has(manifest.i18n_level)) {
+    warnings.push(
+      `kdna.json.i18n_level: non-standard value "${manifest.i18n_level}". ` +
+      `Valid: ${[...VALID_I18N].join(', ')}`,
+    );
+  }
+
+  // 5. Deprecated status must have replaced_by
+  if (manifest.status === 'deprecated' && !manifest.replaced_by) {
+    errors.push('kdna.json: status is "deprecated" but replaced_by is missing');
+  }
+
+  // 6. Tested+ badge must have signature
+  const needsSig = ['tested', 'validated', 'expert_reviewed', 'production_ready'];
+  if (needsSig.includes(manifest.quality_badge) && !manifest.signature) {
+    warnings.push(
+      `kdna.json: quality_badge "${manifest.quality_badge}" should have a signature`,
+    );
+  }
+
+  // 7. Validate author
+  if (manifest.author) {
+    if (!manifest.author.name) errors.push('kdna.json.author: missing "name"');
+    if (!manifest.author.id) errors.push('kdna.json.author: missing "id"');
+    if (manifest.author.pubkey && !/^ed25519:[0-9a-f]{64}$/.test(manifest.author.pubkey)) {
+      warnings.push('kdna.json.author.pubkey: non-standard format. Expected ed25519:<64 hex chars>.');
+    }
+  }
+
+  // 8. Validate license
+  if (manifest.license && !manifest.license.type) {
+    errors.push('kdna.json.license: missing "type"');
+  }
+
+  // 9. Validate kdna_spec value
+  if (manifest.kdna_spec && manifest.kdna_spec !== '1.0-rc') {
+    warnings.push(
+      `kdna.json.kdna_spec: non-standard value "${manifest.kdna_spec}". Expected "1.0-rc".`,
+    );
+  }
+
+  // 10. Validate version format
+  if (manifest.version && !/^\d+\.\d+\.\d+/.test(manifest.version)) {
+    warnings.push(
+      `kdna.json.version: non-semver format "${manifest.version}". Expected MAJOR.MINOR.PATCH.`,
+    );
+  }
+
+  // 11. Check for removed fields
+  const removedFields = ['release_status', 'domain_field', 'judgment_patterns', 'files', 'registry'];
+  for (const field of removedFields) {
+    if (field in manifest) {
+      warnings.push(
+        `kdna.json: field "${field}" is not in the canonical domain manifest and should be removed`,
+      );
+    }
+  }
+
+  // 12. Check removed license sub-fields
+  if (manifest.license && typeof manifest.license === 'object') {
+    for (const field of ['commercial', 'allow_agent_use', 'allow_redistribution', 'allow_training']) {
+      if (field in manifest.license) {
+        warnings.push(
+          `kdna.json.license.${field}: license-type-specific field, not universal. Consider removing.`,
+        );
+      }
+    }
+  }
+
+  return { errors, warnings };
+}
+
+module.exports = { lintDomain, validateManifest };

package/src/loader.js

@@ -174,6 +174,16 @@ function detectOldFieldNames(obj, path = '', warnings = []) {
  * @param {object} domain — result from loadDomainFromData() or loadDomainFromFiles()
  * @returns {string}
  */
+function sanitize(str) {
+  if (typeof str !== 'string') return str;
+  return str
+    .replace(/^#{1,6}\s/gm, '\\# ')     // Escape leading # to prevent fake headers
+    .replace(/```/g, '\\`\\`\\`')        // Escape code blocks
+    .replace(/<\|/g, '&lt;|')            // Escape special tokens
+    .replace(/\b(ignore|forget|disregard)\s+(all\s+)?(previous|prior|above)\s+(instructions?|directives?|rules?|constraints?)\b/gi,
+      '[filtered: $&]');                 // Filter prompt injection patterns
+}
+
 function formatContext(domain) {
   if (!domain || !domain.core || !domain.patterns) return '';
 
@@ -193,13 +203,13 @@ function formatContext(domain) {
   }
 
   parts.push('## Domain Cognition (KDNA)');
-  parts.push(`Domain: ${core.meta.domain}`);
+  parts.push(`Domain: ${sanitize(core.meta.domain)}`);
   parts.push('');
 
   if (core.stances && core.stances.length) {
     parts.push('### Stances');
     for (const s of core.stances) {
-      parts.push(`- ${s}`);
+      parts.push(`- ${sanitize(s)}`);
     }
     parts.push('');
   }
@@ -207,8 +217,8 @@ function formatContext(domain) {
   if (core.axioms && core.axioms.length) {
     parts.push('### Axioms');
     for (const a of core.axioms) {
-      parts.push(`- **${a.one_sentence}** ${a.full_statement}`);
-      parts.push(`  *Why:* ${a.why}`);
+      parts.push(`- **${sanitize(a.one_sentence)}** ${sanitize(a.full_statement)}`);
+      parts.push(`  *Why:* ${sanitize(a.why)}`);
     }
     parts.push('');
   }
@@ -216,8 +226,8 @@ function formatContext(domain) {
   if (core.ontology && core.ontology.length) {
     parts.push('### Key Concepts');
     for (const c of core.ontology) {
-      parts.push(`- **${c.id.replace(/_/g, ' ')}** — ${c.one_sentence}`);
-      parts.push(`  Boundary: ${c.boundary}`);
+      parts.push(`- **${sanitize(c.id.replace(/_/g, ' '))}** — ${sanitize(c.one_sentence)}`);
+      parts.push(`  Boundary: ${sanitize(c.boundary)}`);
     }
     parts.push('');
   }
@@ -225,7 +235,7 @@ function formatContext(domain) {
   if (core.frameworks && core.frameworks.length) {
     parts.push('### Frameworks');
     for (const fw of core.frameworks) {
-      parts.push(`- **${fw.name}**: ${fw.when_to_use}`);
+      parts.push(`- **${sanitize(fw.name)}**: ${sanitize(fw.when_to_use)}`);
     }
     parts.push('');
   }
@@ -233,7 +243,7 @@ function formatContext(domain) {
   if (pat.terminology && pat.terminology.banned_terms && pat.terminology.banned_terms.length) {
     parts.push('### Avoid These Terms');
     for (const b of pat.terminology.banned_terms) {
-      parts.push(`- Avoid "${b.term}". ${b.why} Use "${b.replace_with}" instead.`);
+      parts.push(`- Avoid "${sanitize(b.term)}". ${sanitize(b.why)} Use "${sanitize(b.replace_with)}" instead.`);
     }
     parts.push('');
   }
@@ -241,8 +251,8 @@ function formatContext(domain) {
   if (pat.misunderstandings && pat.misunderstandings.length) {
     parts.push('### Watch For These Misunderstandings');
     for (const m of pat.misunderstandings) {
-      parts.push(`- **Wrong:** ${m.wrong}`);
-      parts.push(`  **Correct:** ${m.correct}`);
+      parts.push(`- **Wrong:** ${sanitize(m.wrong)}`);
+      parts.push(`  **Correct:** ${sanitize(m.correct)}`);
     }
     parts.push('');
   }
@@ -250,7 +260,7 @@ function formatContext(domain) {
   if (pat.self_check && pat.self_check.length) {
     parts.push('### Before Responding, Check');
     for (const s of pat.self_check) {
-      parts.push(`- [ ] ${s}`);
+      parts.push(`- [ ] ${sanitize(s)}`);
     }
     parts.push('');
   }
@@ -258,7 +268,7 @@ function formatContext(domain) {
   if (domain.scenarios && domain.scenarios.scenes) {
     parts.push('### Relevant Scenarios');
     for (const scene of domain.scenarios.scenes) {
-      parts.push(`- **${scene.name}**: ${scene.trigger_signal}`);
+      parts.push(`- **${sanitize(scene.name)}**: ${sanitize(scene.trigger_signal)}`);
     }
     parts.push('');
   }
@@ -266,7 +276,7 @@ function formatContext(domain) {
   if (domain.reasoning && domain.reasoning.reasoning_chains) {
     parts.push('### Reasoning Chains');
     for (const r of domain.reasoning.reasoning_chains) {
-      parts.push(`- **${r.one_sentence}** → ${r.so_what}`);
+      parts.push(`- **${sanitize(r.one_sentence)}** → ${sanitize(r.so_what)}`);
     }
     parts.push('');
   }
@@ -274,11 +284,11 @@ function formatContext(domain) {
   if (domain.cases && domain.cases.cases && domain.cases.cases.length) {
     parts.push('### Cases');
     for (const c of domain.cases.cases) {
-      parts.push(`- **${c.title}**`);
-      parts.push(`  Context: ${c.context}`);
-      parts.push(`  What happened: ${c.what_happened}`);
-      parts.push(`  Learned: ${c.what_was_learned}`);
-      parts.push(`  Pattern: ${c.structural_pattern}`);
+      parts.push(`- **${sanitize(c.title)}**`);
+      parts.push(`  Context: ${sanitize(c.context)}`);
+      parts.push(`  What happened: ${sanitize(c.what_happened)}`);
+      parts.push(`  Learned: ${sanitize(c.what_was_learned)}`);
+      parts.push(`  Pattern: ${sanitize(c.structural_pattern)}`);
     }
     parts.push('');
   }
@@ -288,7 +298,7 @@ function formatContext(domain) {
     if (evo.stages && evo.stages.length) {
       parts.push('### Growth Stages');
       for (const stage of evo.stages) {
-        parts.push(`- **${stage.name}**: ${stage.description}`);
+        parts.push(`- **${sanitize(stage.name)}**: ${sanitize(stage.description)}`);
       }
       parts.push('');
     }
@@ -296,7 +306,7 @@ function formatContext(domain) {
       parts.push('### Capability Layers');
       for (const layer of evo.evolution_layers) {
         parts.push(
-          `- **${layer.name}**: ${layer.capability} (${layer.from_stage} → ${layer.to_stage})`,
+          `- **${sanitize(layer.name)}**: ${sanitize(layer.capability)} (${sanitize(layer.from_stage)} → ${sanitize(layer.to_stage)})`,
         );
       }
       parts.push('');

package/src/types.d.ts

@@ -206,12 +206,23 @@ export interface KDNAManifest {
   kdna_spec: string;
   name: string;
   version: string;
-  status: 'experimental' | 'basic' | 'stable' | 'pro';
+  judgment_version?: string;
+  status: 'draft' | 'experimental' | 'stable' | 'deprecated' | 'basic' | 'pro';
   access: 'open' | 'licensed' | 'runtime';
-  language: string;
-  author: { name: string; id?: string };
+  language?: string;
+  default_language?: string;
+  languages?: string[];
+  author: { name: string; id?: string; pubkey?: string; public_key_pem?: string };
   license: { type: string; url?: string };
   description: string;
+  keywords?: string[];
+  encryption?: {
+    profile?: string;
+    encrypted_entries?: string[];
+    [key: string]: any;
+  };
+  content_digest?: string;
+  signature?: string;
 }
 
 export interface LintResult {
@@ -241,6 +252,167 @@ export function formatContext(domain: LoadedDomain): string;
 
 export const FILE_MAP: Record<string, string>;
 
+// Asset reader — direct .kdna API
+export const STANDARD_ENTRIES: string[];
+
+export interface KdnaAsset {
+  path: string | null;
+  size: number;
+  asset_digest: string;
+  entries: Map<string, unknown>;
+  readEntry(name: string): Uint8Array;
+}
+
+export interface KdnaAssetVerifyResult {
+  ok: boolean;
+  errors: string[];
+  warnings: string[];
+  entries: string[];
+  manifest: KDNAManifest | null;
+  asset_digest: string;
+  content_digest: string;
+  signature_valid: boolean | null;
+}
+
+export interface KdnaAssetIndexProfile {
+  profile: 'index';
+  manifest: KDNAManifest;
+  asset_digest: string;
+  content_digest: string;
+  entries: string[];
+  name: string | null;
+  version: string | null;
+  judgment_version: string | null;
+  keywords: string[];
+}
+
+export interface KdnaAssetLoadProfile {
+  profile: string;
+  manifest: KDNAManifest;
+  domain: LoadedDomain | null;
+  context: string | null;
+}
+
+export interface KdnaAssetReader {
+  openSync(input: string | Uint8Array): KdnaAsset;
+  open(input: string | Uint8Array): Promise<KdnaAsset>;
+  listEntriesSync(asset: KdnaAsset): string[];
+  listEntries(asset: KdnaAsset): Promise<string[]>;
+  readEntrySync(asset: KdnaAsset, entryName: string): Uint8Array;
+  readEntrySync(asset: KdnaAsset, entryName: string, encoding: string): string;
+  readEntry(asset: KdnaAsset, entryName: string): Promise<Uint8Array>;
+  readEntry(asset: KdnaAsset, entryName: string, encoding: string): Promise<string>;
+  readJsonSync(asset: KdnaAsset, entryName: string, options?: KdnaDecryptOptions): any;
+  readJson(asset: KdnaAsset, entryName: string, options?: KdnaDecryptOptions): Promise<any>;
+  readManifestSync(asset: KdnaAsset): KDNAManifest;
+  readManifest(asset: KdnaAsset): Promise<KDNAManifest>;
+  readDataMapSync(
+    asset: KdnaAsset,
+    entries?: string[],
+    options?: KdnaDecryptOptions,
+  ): KDNAFileDataMap;
+  readDataMap(
+    asset: KdnaAsset,
+    entries?: string[],
+    options?: KdnaDecryptOptions,
+  ): Promise<KDNAFileDataMap>;
+  contentDigestSync(asset: KdnaAsset): string;
+  contentDigest(asset: KdnaAsset): Promise<string>;
+  verifySync(
+    asset: KdnaAsset,
+    options?: {
+      asset_digest?: string;
+      content_digest?: string;
+      requireSignature?: boolean;
+      requireDecryption?: boolean;
+    } & KdnaDecryptOptions,
+  ): KdnaAssetVerifyResult;
+  verify(
+    asset: KdnaAsset,
+    options?: {
+      asset_digest?: string;
+      content_digest?: string;
+      requireSignature?: boolean;
+      requireDecryption?: boolean;
+    } & KdnaDecryptOptions,
+  ): Promise<KdnaAssetVerifyResult>;
+  loadProfileSync(
+    asset: KdnaAsset,
+    profile: 'index',
+    options?: { input?: string; context?: boolean } & KdnaDecryptOptions,
+  ): KdnaAssetIndexProfile;
+  loadProfileSync(
+    asset: KdnaAsset,
+    profile?: 'compact' | 'scenario' | 'full' | string,
+    options?: { input?: string; context?: boolean } & KdnaDecryptOptions,
+  ): KdnaAssetLoadProfile;
+  loadProfile(
+    asset: KdnaAsset,
+    profile: 'index',
+    options?: { input?: string; context?: boolean } & KdnaDecryptOptions,
+  ): Promise<KdnaAssetIndexProfile>;
+  loadProfile(
+    asset: KdnaAsset,
+    profile?: 'compact' | 'scenario' | 'full' | string,
+    options?: { input?: string; context?: boolean } & KdnaDecryptOptions,
+  ): Promise<KdnaAssetLoadProfile>;
+}
+
+export interface KdnaDecryptOptions {
+  decryptEntry?: (args: {
+    asset: KdnaAsset;
+    manifest: KDNAManifest;
+    entryName: string;
+    ciphertext: Uint8Array;
+  }) => string | Uint8Array | Promise<string | Uint8Array>;
+}
+
+export function createKdnaAssetReader(): KdnaAssetReader;
+
+export const LICENSED_ENTRY_PROFILE: string;
+
+export interface LicensedEntryEnvelope {
+  profile: string;
+  alg: 'AES-256-GCM';
+  kdf: 'scrypt-sha256';
+  salt: string;
+  iv: string;
+  tag: string;
+  ciphertext: string;
+}
+
+export function deriveLicensedEntryKey(options: {
+  licenseKey: string;
+  machineFingerprint: string;
+  salt: string | Uint8Array;
+  keyLength?: number;
+}): Uint8Array;
+
+export function encryptLicensedEntry(
+  plaintext: string | Uint8Array,
+  options: {
+    entryName: string;
+    manifest?: KDNAManifest;
+    licenseKey: string;
+    machineFingerprint: string;
+  },
+): LicensedEntryEnvelope;
+
+export function decryptLicensedEntry(
+  envelope: string | Uint8Array | LicensedEntryEnvelope,
+  options: {
+    entryName: string;
+    manifest?: KDNAManifest;
+    licenseKey: string;
+    machineFingerprint: string;
+  },
+): Uint8Array;
+
+export function createLicensedDecryptEntry(options: {
+  licenseKey: string;
+  machineFingerprint: string;
+}): NonNullable<KdnaDecryptOptions['decryptEntry']>;
+
 // Lint
 export function lintDomain(dataMap: KDNAFileDataMap): LintResult;
 

package/src/validate-pure.js

@@ -45,9 +45,6 @@ function validateDomainSchema(dataMap, schemaMap) {
     return { valid: true, errors: [], warnings };
   }
 
-  let validCount = 0;
-  let failCount = 0;
-
   for (const [file, schemaFile] of Object.entries(FILE_TO_SCHEMA)) {
     if (!dataMap[file]) continue;
     if (!schemaMap[schemaFile]) {
@@ -69,10 +66,7 @@ function validateDomainSchema(dataMap, schemaMap) {
     const validate = ajvInstance.compile(schema);
     const valid = validate(dataMap[file]);
 
-    if (valid) {
-      validCount++;
-    } else {
-      failCount++;
+    if (!valid) {
       for (const err of validate.errors || []) {
         const instancePath = err.instancePath || '/';
         errors.push(`${file}${instancePath}: ${err.message} (${err.keyword})`);