@aikdna/kdna-core 0.1.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aikdna/kdna-core",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "KDNA core library — pure logic for loading, validating, linting, and rendering KDNA domain cognition packages. Zero Node.js dependencies.",
   "type": "commonjs",
   "main": "src/index.js",

package/src/compose.js

@@ -0,0 +1,123 @@
+/**
+ * KDNA Compose — Multi-domain composition logic.
+ *
+ * Merges judgment constraints from multiple domains into a single
+ * agent context. Domains contribute independently; conflicts are
+ * surfaced, not silently resolved.
+ */
+
+const { formatContext } = require('./loader');
+
+/**
+ * Compose multiple loaded domains into a single agent context string.
+ *
+ * Each domain contributes its own section. If two domains define
+ * conflicting axioms or banned terms, both are included — the agent
+ * must report the conflict, not pick one.
+ *
+ * @param {Array<{core:object, patterns:object}>} domains
+ * @param {object} [options]
+ * @param {string} [options.separator] — section separator
+ * @returns {string}
+ */
+function composeContext(domains, options = {}) {
+  if (!domains || !domains.length) return '';
+
+  const separator = options.separator || '\n\n---\n\n';
+
+  return domains
+    .filter((d) => d && d.core && d.patterns)
+    .map((d) => formatContext(d))
+    .filter((ctx) => ctx)
+    .join(separator);
+}
+
+/**
+ * Match user input against domain trigger_signals to determine
+ * which domains should be activated.
+ *
+ * Each domain can define trigger_signals in its core (array of
+ * keywords or phrases). This function checks if any signal matches
+ * the input and returns the list of matching domain indices.
+ *
+ * @param {string} input — user task description
+ * @param {Array<{id:string, core:{trigger_signals?:string[]}}>} domains
+ * @returns {number[]} — indices of matching domains
+ */
+function classifySignals(input, domains) {
+  if (!input || !domains || !domains.length) return [];
+
+  const lower = input.toLowerCase();
+  const active = [];
+
+  for (let i = 0; i < domains.length; i++) {
+    const domain = domains[i];
+    const signals = domain.core?.trigger_signals || [];
+
+    if (!signals.length) {
+      // No signals defined → domain is primary (always active)
+      active.push(i);
+      continue;
+    }
+
+    const matched = signals.some((signal) => lower.includes(signal.toLowerCase()));
+    if (matched) active.push(i);
+  }
+
+  return active;
+}
+
+/**
+ * Compose self-check items from multiple domains into a single
+ * checklist. Each domain's checks are prefixed with its domain name
+ * so conflicts are visible.
+ *
+ * @param {Array<{id:string, core:{meta:{domain:string}}, patterns:{self_check:string[]}}>} domains
+ * @returns {string[]}
+ */
+function composeChecks(domains) {
+  if (!domains || !domains.length) return [];
+
+  const checks = [];
+
+  for (const domain of domains) {
+    const name = domain.core?.meta?.domain || domain.id || 'unknown';
+    const items = domain.patterns?.self_check || [];
+
+    if (!items.length) continue;
+
+    if (domains.length === 1) {
+      checks.push(...items);
+    } else {
+      for (const item of items) {
+        checks.push(`[${name}] ${item}`);
+      }
+    }
+  }
+
+  return checks;
+}
+
+/**
+ * Load multiple domains from data maps and compose their context.
+ * Convenience function: loads each domain, then composes.
+ *
+ * @param {Array<object>} dataMaps — array of file data maps
+ * @param {object} [options] — passed to loadDomainFromFiles + composeContext
+ * @returns {{ domains: Array, context: string, activeIndices: number[] }}
+ */
+function loadAndCompose(dataMaps, options = {}) {
+  const { loadDomainFromFiles } = require('./loader');
+
+  const domains = dataMaps.map((dm) => loadDomainFromFiles(dm, options)).filter(Boolean);
+
+  const { input = '' } = options;
+  const activeIndices = classifySignals(input, domains);
+
+  const activeDomains = activeIndices.map((i) => domains[i]);
+  const context = composeContext(activeDomains, options);
+
+  return { domains, context, activeIndices };
+}
+
+module.exports = { composeContext, classifySignals, composeChecks, loadAndCompose };

package/src/index.js

@@ -5,10 +5,12 @@ const loader = require('./loader');
 const lint = require('./lint-pure');
 const validate = require('./validate-pure');
 const render = require('./render');
+const compose = require('./compose');
 
 module.exports = {
   ...loader,
   ...lint,
   ...validate,
   ...render,
+  ...compose,
 };

package/src/index.mjs

@@ -15,3 +15,5 @@ export { lintDomain } from './lint-pure.js';
 export { validateDomainSchema, validateCrossFile } from './validate-pure.js';
 
 export { renderPreviewHTML, escHtml, renderCard } from './render.js';
+
+export { composeContext, classifySignals, composeChecks, loadAndCompose } from './compose.js';

package/src/lint-pure.js

@@ -168,6 +168,25 @@ function lintDomain(dataMap) {
     (pat.self_check || []).forEach((s, i) => yesno(s, `KDNA_Patterns.json.self_check[${i}]`));
   }
 
+  // Anti-vagueness: axioms must be domain-specific, not generic platitudes
+  if (core && Array.isArray(core.axioms)) {
+    const vaguePhrases = [
+      'be helpful', 'be professional', 'be accurate', 'best practices',
+      'user-centric', 'customer-focused', 'excellence', 'innovation',
+      '以人为本', '用户至上', '最佳实践', '卓越',
+    ];
+    core.axioms.forEach((a, i) => {
+      const text = ((a.one_sentence || '') + ' ' + (a.full_statement || '')).toLowerCase();
+      vaguePhrases.forEach((phrase) => {
+        if (text.includes(phrase)) {
+          warnings.push(
+            `KDNA_Core.json.axioms[${i}]: axiom contains vague phrase "${phrase}" — axioms must be testable and domain-specific, not generic platitudes`,
+          );
+        }
+      });
+    });
+  }
+
   // Validate KDNA_Reasoning.json
   const rea = dataMap['KDNA_Reasoning.json'];
   if (rea) {

package/src/types.d.ts

@@ -252,3 +252,9 @@ export function validateCrossFile(dataMap: KDNAFileDataMap): ValidationResult;
 export function renderPreviewHTML(domain: LoadedDomain, manifest?: KDNAManifest): string;
 export function escHtml(s: string): string;
 export function renderCard(title: string, count: number | undefined, items: string): string;
+
+// Compose
+export function composeContext(domains: LoadedDomain[], options?: { separator?: string }): string;
+export function classifySignals(input: string, domains: Array<{ id: string; core: { trigger_signals?: string[] } }>): number[];
+export function composeChecks(domains: Array<{ id: string; core: { meta: { domain: string } }; patterns: { self_check: string[] } }>): string[];
+export function loadAndCompose(dataMaps: KDNAFileDataMap[], options?: LoadOptions & { separator?: string }): { domains: LoadedDomain[]; context: string; activeIndices: number[] };