@aikdna/kdna-cli 0.9.0

package/src/cmds/legacy.js

@@ -0,0 +1,83 @@
+const { error } = require('./_common');
+
+function cmdPreview() {
+  // Removed in v0.9 — no real user scenario for browser preview.
+  // To inspect a .kdna file, use: kdna inspect <path>
+  error(
+    'kdna preview was removed in v0.9.\n' +
+      'Use: kdna inspect <path>  to view a .kdna file or domain directory.',
+  );
+}
+
+function cmdProject() {
+  // Removed in v0.9 — project-level .kdna/config.json violated the
+  // "install ≠ load" safety model. KDNA loading is now a per-task
+  // decision made by the agent (via kdna-loader skill), not a
+  // project-level whitelist.
+  error(
+    'kdna project was removed in v0.9. The .kdna/config.json file is no\n' +
+      'longer read by the kdna-loader skill — it would have forced KDNA\n' +
+      'loading on tasks where the user did not ask for it.\n\n' +
+      'The agent now discovers KDNA on demand by reading ~/.kdna/domains/\n' +
+      'and matching the task against v2.1 applies_when fields.\n\n' +
+      'If you have stale .kdna/config.json files in your projects, you\n' +
+      'can delete them — nothing reads them anymore.',
+  );
+}
+
+function cmdEval() {
+  // Removed in v0.9 — overlapped with kdna compare without adding
+  // distinct value, and the agent-facing match/load commands cover
+  // the discovery path.
+  error(
+    'kdna eval was removed in v0.9.\n' +
+      'To compare with/without KDNA reasoning, use:\n' +
+      '  kdna compare <name> --input "<task>"\n' +
+      'To inspect a domain, use:\n' +
+      '  kdna info <name>',
+  );
+}
+
+function cmdSelect() {
+  // Removed in v0.9 — replaced by the agent-facing kdna-loader skill.
+  // The skill discovers KDNA via 'kdna available' and decides fit
+  // using v2.1 applies_when fields. The agent makes the selection.
+  error(
+    'kdna select was removed in v0.9.\n' +
+      'KDNA selection is now done by the kdna-loader skill (installed\n' +
+      'into your agent at ~/.claude/skills/kdna-loader/ etc.).\n\n' +
+      'To inspect what an agent would see, use:\n' +
+      '  kdna available --json\n' +
+      '  kdna match "<task>" --json',
+  );
+}
+
+function cmdExport() {
+  // Removed in v0.9 — was an alias for `kdna pack`.
+  error(
+    'kdna export was removed in v0.9 (it was an alias for pack).\n' +
+      'Use: kdna pack <path> [--output <dir>]',
+  );
+}
+
+function cmdDemo() {
+  // Removed in v0.9 — internal demo, not a user feature. To see
+  // before/after on a real input, use:
+  //   kdna compare <name> --input "<task>"   (requires LLM API key)
+  error(
+    'kdna demo was removed in v0.9.\n' +
+      'To see KDNA before/after on a real input, use:\n' +
+      '  kdna compare @aikdna/writing --input "<your task>"\n' +
+      '(requires ANTHROPIC_API_KEY, OPENAI_API_KEY, or an OpenAI-compatible\n' +
+      'endpoint in ~/.kdna/config.json)',
+  );
+}
+
+module.exports = {
+  cmdPreview,
+  cmdProject,
+  cmdEval,
+  cmdSelect,
+  cmdExport,
+  cmdDemo,
+};

package/src/cmds/quality.js

@@ -0,0 +1,87 @@
+const { error } = require('./_common');
+
+function cmdCompare(args) {
+  const { cmdCompare } = require('../compare');
+  const target = args.filter((a) => !a.startsWith('--'))[1];
+  if (!target || !args.includes('--input')) {
+    error(
+      'Usage:\n' +
+        '  kdna compare <name> --input "<text>"\n' +
+        '\n' +
+        'Runs your input through the LLM twice (with/without KDNA loaded),\n' +
+        'then diffs the reasoning trajectory. Requires ANTHROPIC_API_KEY or\n' +
+        'OPENAI_API_KEY in the environment.',
+    );
+  }
+  (async () => {
+    try {
+      await cmdCompare(target, args);
+    } catch (e) {
+      console.error(`Error: ${e.message}`);
+      process.exit(1);
+    }
+  })();
+}
+
+function cmdDiff(args) {
+  const { cmdDiff } = require('../diff');
+  const positional = args.filter((a) => !a.startsWith('--'));
+  const a = positional[1];
+  const b = positional[2];
+  if (!a) {
+    error(
+      'Usage:\n' +
+        '  kdna diff <name>@<v1> <name>@<v2>   Compare two versions\n' +
+        '  kdna diff <name>                     Installed vs registry-current\n' +
+        '\n' +
+        'Surfaces judgment-level diff: added/removed/changed axioms,\n' +
+        'misunderstandings, banned terms, stances.',
+    );
+  }
+  (async () => {
+    try {
+      await cmdDiff(a, b);
+    } catch (e) {
+      console.error(`Error: ${e.message}`);
+      process.exit(1);
+    }
+  })();
+}
+
+function cmdSearch(args) {
+  const { cmdSearch } = require('../search');
+  const query = args.slice(1).join(' ').trim();
+  cmdSearch(query);
+}
+
+function cmdAvailable(args) {
+  const { cmdAvailable } = require('../agent');
+  cmdAvailable(args);
+}
+
+function cmdMatch(args) {
+  const { cmdMatch } = require('../agent');
+  const positional = [];
+  const flags = [];
+  for (let i = 1; i < args.length; i++) {
+    if (args[i].startsWith('--')) flags.push(args[i]);
+    else positional.push(args[i]);
+  }
+  cmdMatch(positional.join(' ').trim(), flags);
+}
+
+function cmdLoad(args) {
+  const { cmdLoad } = require('../agent');
+  const target = args.filter((a) => !a.startsWith('--'))[1];
+  if (!target) error('Usage: kdna load <name> [--as=prompt|json|raw]');
+  cmdLoad(target, args);
+}
+
+module.exports = {
+  cmdCompare,
+  cmdDiff,
+  cmdSearch,
+  cmdAvailable,
+  cmdMatch,
+  cmdLoad,
+};

package/src/cmds/registry.js

@@ -0,0 +1,114 @@
+const fs = require('fs');
+const path = require('path');
+const { CANONICAL_REGISTRY_URL, REGISTRY_CACHE, fetchRegistry } = require('../registry');
+const { error, readJson, loadRegistry, INSTALL_DIR } = require('./_common');
+
+function cmdList(showAvailable) {
+  if (showAvailable) {
+    const domains = loadRegistry({ allowNetwork: true });
+    if (!domains || !domains.length) {
+      error('No registry found.');
+    }
+
+    console.log('Available KDNA domains:');
+    console.log(`Registry: ${REGISTRY_CACHE}`);
+    console.log('');
+    for (const d of domains) {
+      const name = d.name || d.id || '?';
+      const [scope, ident] = name.includes('/') ? name.split('/') : [null, name];
+      const installedPath = scope ? path.join(INSTALL_DIR, scope, ident) : null;
+      const installed = installedPath && fs.existsSync(installedPath) ? '[installed]' : '';
+      const yanked = d.yanked ? '[yanked] ' : '';
+      const dep = d.deprecated ? '[deprecated] ' : '';
+      console.log(
+        `  ${name.padEnd(36)} ${(d.version || '?').padEnd(8)} ${(d.type || 'domain').padEnd(8)} ${(d.status || '').padEnd(14)} ${yanked}${dep}${installed}`,
+      );
+      if (d.description) console.log(`    ${d.description}`);
+      console.log('');
+    }
+    return;
+  }
+
+  if (!fs.existsSync(INSTALL_DIR)) {
+    console.log('No domains installed.');
+    console.log(`Installation directory: ${INSTALL_DIR}`);
+    return;
+  }
+
+  // v0.7 layout: ~/.kdna/domains/@scope/name/
+  const scopes = fs.readdirSync(INSTALL_DIR).filter((d) => {
+    if (!d.startsWith('@')) return false;
+    try {
+      return fs.statSync(path.join(INSTALL_DIR, d)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+
+  const installed = [];
+  for (const scope of scopes) {
+    const sd = path.join(INSTALL_DIR, scope);
+    for (const ident of fs.readdirSync(sd)) {
+      if (ident.startsWith('.')) continue;
+      const full = path.join(sd, ident);
+      try {
+        if (!fs.statSync(full).isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      installed.push({ scope, ident, full });
+    }
+  }
+
+  // Detect and warn about legacy (un-scoped) installs
+  const legacy = fs.readdirSync(INSTALL_DIR).filter((d) => {
+    if (d.startsWith('@') || d.startsWith('.')) return false;
+    try {
+      return fs.statSync(path.join(INSTALL_DIR, d)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+  if (legacy.length) {
+    console.log('⚠ Legacy (un-scoped) directories detected — please remove + re-install:');
+    legacy.forEach((d) => console.log(`    ~/.kdna/domains/${d}/`));
+    console.log('');
+  }
+
+  if (!installed.length) {
+    console.log('No v0.7 domains installed.');
+    console.log(`Run: kdna install <name>      # e.g. kdna install writing`);
+    return;
+  }
+
+  console.log('Installed KDNA domains:');
+  console.log('');
+  for (const { scope, ident, full } of installed) {
+    const core = readJson(path.join(full, 'KDNA_Core.json'));
+    const manifest = readJson(path.join(full, 'kdna.json'));
+    const cluster = readJson(path.join(full, 'cluster.json'));
+    const name = `${scope}/${ident}`;
+    const version = manifest?.version || manifest?._source?.version || core?.meta?.version || '?';
+    const kind = cluster ? '[cluster]' : '';
+    const desc = manifest?.description || core?.meta?.purpose || '';
+    console.log(`  ${name.padEnd(36)} v${version} ${kind}`);
+    if (desc) console.log(`    ${desc}`);
+  }
+  console.log('');
+  console.log(`Location: ${INSTALL_DIR}`);
+}
+
+function cmdRegistry(subcommand) {
+  if (subcommand !== 'refresh') {
+    error('Usage: kdna registry refresh');
+  }
+  const domains = fetchRegistry();
+  console.log(`✓ Registry refreshed from ${CANONICAL_REGISTRY_URL}`);
+  console.log(`  Cache: ${REGISTRY_CACHE}`);
+  console.log(`  Domains: ${domains.length}`);
+}
+
+module.exports = {
+  cmdList,
+  cmdRegistry,
+};

package/src/cmds/setup.js

@@ -0,0 +1,8 @@
+function cmdSetup() {
+  const { cmdSetup } = require('../setup');
+  cmdSetup();
+}
+
+module.exports = {
+  cmdSetup,
+};

package/src/compare.js

@@ -0,0 +1,324 @@
+/**
+ * kdna compare <name> --input "<text>" — Reasoning trajectory diff.
+ *
+ * Runs the same prompt twice on a real LLM:
+ *   1. Without KDNA loaded (baseline)
+ *   2. With KDNA injected into the system prompt (treatment)
+ * Then asks a third call to diff the two responses along the
+ * judgment-trajectory axes the domain claims to change.
+ *
+ * Config file: ~/.kdna/config.json
+ *   {
+ *     "llm": {
+ *       "provider": "anthropic" | "openai",
+ *       "model": "<model-id>",
+ *       "api_key_env": "ANTHROPIC_API_KEY"
+ *     }
+ *   }
+ *
+ * MVP scope: no caching, no batch, no offline mode. One invocation = 3 API calls.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+
+const USER_KDNA_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.kdna');
+const INSTALL_DIR = path.join(USER_KDNA_DIR, 'domains');
+const CONFIG_FILE = path.join(USER_KDNA_DIR, 'config.json');
+
+const { parseName } = require('./registry');
+
+function readJson(p) {
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function error(msg) {
+  console.error(`Error: ${msg}`);
+  process.exit(1);
+}
+
+// ─── Config ─────────────────────────────────────────────────────────────
+
+function loadLlmConfig() {
+  const cfg = readJson(CONFIG_FILE) || {};
+  const llm = cfg.llm || {};
+  const provider = llm.provider || 'anthropic';
+  const model = llm.model || (provider === 'anthropic' ? 'claude-sonnet-4-5' : 'gpt-4o-mini');
+  const envName =
+    llm.api_key_env || (provider === 'anthropic' ? 'ANTHROPIC_API_KEY' : 'OPENAI_API_KEY');
+  const apiKey = process.env[envName] || llm.api_key || null;
+
+  // base_url lets users point the "openai" provider at any OpenAI-compatible
+  // endpoint (SiliconFlow, Groq, OpenRouter, local llama.cpp, etc.).
+  // Default: official endpoints for each provider.
+  const defaultBase =
+    provider === 'anthropic' ? 'https://api.anthropic.com' : 'https://api.openai.com';
+  const baseUrl = llm.base_url || defaultBase;
+
+  if (!apiKey) {
+    error(
+      `LLM API key not found. Set ${envName} in your environment, or edit ~/.kdna/config.json:\n` +
+        `  {\n` +
+        `    "llm": {\n` +
+        `      "provider": "anthropic" | "openai",\n` +
+        `      "model": "<model-id>",\n` +
+        `      "api_key_env": "${envName}",\n` +
+        `      "base_url": "https://...   (optional, for OpenAI-compatible endpoints)"\n` +
+        `    }\n` +
+        `  }`,
+    );
+  }
+  return { provider, model, apiKey, envName, baseUrl };
+}
+
+// Parse "https://host[:port]/path/prefix" → { host, port, basePath }
+function parseBaseUrl(url) {
+  const u = new URL(url);
+  return {
+    host: u.hostname,
+    port: u.port ? parseInt(u.port, 10) : 443,
+    basePath: u.pathname.replace(/\/$/, ''), // strip trailing slash
+  };
+}
+
+// ─── HTTP helpers ──────────────────────────────────────────────────────
+
+function httpsPost(host, port, pathPart, headers, body) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const req = https.request(
+      {
+        host,
+        port: port || 443,
+        path: pathPart,
+        method: 'POST',
+        headers: { ...headers, 'Content-Length': Buffer.byteLength(data) },
+      },
+      (res) => {
+        const chunks = [];
+        res.on('data', (c) => chunks.push(c));
+        res.on('end', () => {
+          const text = Buffer.concat(chunks).toString('utf8');
+          if (res.statusCode >= 400) {
+            reject(new Error(`HTTP ${res.statusCode}: ${text.slice(0, 500)}`));
+            return;
+          }
+          try {
+            resolve(JSON.parse(text));
+          } catch {
+            reject(new Error(`Bad JSON from ${host}: ${text.slice(0, 500)}`));
+          }
+        });
+      },
+    );
+    req.on('error', reject);
+    req.setTimeout(120000, () => req.destroy(new Error(`timeout after 120s`)));
+    req.write(data);
+    req.end();
+  });
+}
+
+async function callLlm(cfg, systemPrompt, userMessage) {
+  const { host, port, basePath } = parseBaseUrl(cfg.baseUrl);
+
+  if (cfg.provider === 'anthropic') {
+    const resp = await httpsPost(
+      host,
+      port,
+      `${basePath}/v1/messages`,
+      {
+        'content-type': 'application/json',
+        'anthropic-version': '2023-06-01',
+        'x-api-key': cfg.apiKey,
+      },
+      {
+        model: cfg.model,
+        max_tokens: 4096,
+        system: systemPrompt,
+        messages: [{ role: 'user', content: userMessage }],
+      },
+    );
+    return resp.content?.map((c) => c.text || '').join('') || '';
+  }
+  if (cfg.provider === 'openai') {
+    // For OpenAI-compatible endpoints the base may already include /v1 (e.g.
+    // SiliconFlow: https://api.siliconflow.cn/v1). Append /chat/completions
+    // if the basePath doesn't already end with /v1.
+    const endpoint = basePath.endsWith('/v1')
+      ? `${basePath}/chat/completions`
+      : `${basePath}/v1/chat/completions`;
+    const resp = await httpsPost(
+      host,
+      port,
+      endpoint,
+      {
+        'content-type': 'application/json',
+        authorization: `Bearer ${cfg.apiKey}`,
+      },
+      {
+        model: cfg.model,
+        max_tokens: 4096,
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: userMessage },
+        ],
+      },
+    );
+    return resp.choices?.[0]?.message?.content || '';
+  }
+  error(`Unknown provider: ${cfg.provider}`);
+}
+
+// ─── KDNA → system prompt ─────────────────────────────────────────────
+
+function buildKdnaPrompt(destDir) {
+  const core = readJson(path.join(destDir, 'KDNA_Core.json'));
+  const pat = readJson(path.join(destDir, 'KDNA_Patterns.json'));
+  const manifest = readJson(path.join(destDir, 'kdna.json'));
+
+  if (!core || !pat) return '';
+
+  const sections = [];
+  sections.push(`# Domain judgment loaded: ${manifest?.name || core?.meta?.domain}`);
+  sections.push(`# ${core?.meta?.purpose || ''}`);
+  sections.push('');
+
+  if (core.axioms) {
+    sections.push('## Axioms (judgment principles)');
+    for (const a of core.axioms) {
+      sections.push(`- **${a.one_sentence}** ${a.full_statement}`);
+      if (a.applies_when?.length) sections.push(`  - APPLIES WHEN: ${a.applies_when.join('; ')}`);
+      if (a.does_not_apply_when?.length)
+        sections.push(`  - DOES NOT APPLY WHEN: ${a.does_not_apply_when.join('; ')}`);
+      if (a.failure_risk) sections.push(`  - FAILURE RISK: ${a.failure_risk}`);
+    }
+    sections.push('');
+  }
+
+  if (pat.misunderstandings) {
+    sections.push('## Common misdiagnoses to avoid');
+    for (const m of pat.misunderstandings) {
+      sections.push(`- WRONG: ${m.wrong}`);
+      sections.push(`  CORRECT: ${m.correct}`);
+      if (m.key_distinction) sections.push(`  KEY DISTINCTION: ${m.key_distinction}`);
+    }
+    sections.push('');
+  }
+
+  if (pat.self_check?.length) {
+    sections.push('## Self-checks before answering');
+    pat.self_check.forEach((q, i) => sections.push(`${i + 1}. ${q}`));
+    sections.push('');
+  }
+
+  if (core.stances) {
+    sections.push('## Stances');
+    for (const s of core.stances) {
+      const txt = typeof s === 'string' ? s : s.stance;
+      if (txt) sections.push(`- ${txt}`);
+    }
+  }
+
+  return sections.join('\n');
+}
+
+// ─── Diff prompt ───────────────────────────────────────────────────────
+
+const DIFF_SYSTEM = `You are comparing two AI responses to the same user request. Your job is NOT to judge which is better, but to surface the difference in REASONING TRAJECTORY along these axes:
+
+1. CLASSIFICATION — how each response classifies the task
+2. DIAGNOSIS — root cause each response names (surface vs structural)
+3. ACTIONS — what each response actually suggests doing
+4. BOUNDARY AWARENESS — does either response recognize when something is outside its scope
+5. TERMINOLOGY — domain-specific terms one uses but the other doesn't
+
+For each axis, output:
+  <axis>: <one-line difference> | SAME if no meaningful difference
+
+End with a single line:
+  VERDICT: <one of: trajectory_changed | trajectory_unchanged | trajectory_degraded>
+
+Be terse. Quote at most 8 words from each response.`;
+
+function makeDiffPrompt(input, responseA, responseB) {
+  return `INPUT (same for both):
+${input}
+
+RESPONSE A (no KDNA loaded):
+${responseA}
+
+RESPONSE B (KDNA loaded):
+${responseB}
+
+Diff the reasoning trajectory.`;
+}
+
+// ─── Main ──────────────────────────────────────────────────────────────
+
+async function cmdCompare(input, args = []) {
+  const idxInput = args.indexOf('--input');
+  if (idxInput < 0 || !args[idxInput + 1]) {
+    error('Usage: kdna compare <name> --input "<text>"');
+  }
+  const userInput = args[idxInput + 1];
+
+  const parsed = parseName(input);
+  if (!parsed) error(`Invalid name "${input}".`);
+  const destDir = path.join(INSTALL_DIR, parsed.scope, parsed.ident);
+  if (!fs.existsSync(destDir)) {
+    error(`${parsed.full} not installed. Run: kdna install ${input}`);
+  }
+
+  const llm = loadLlmConfig();
+
+  console.log('═'.repeat(64));
+  console.log(`  kdna compare  ${parsed.full}`);
+  console.log(`  provider:     ${llm.provider} / ${llm.model}`);
+  console.log(`  input length: ${userInput.length} chars`);
+  console.log('═'.repeat(64));
+  console.log('');
+
+  const BASELINE_SYSTEM =
+    'You are a helpful assistant. Respond to the user request concisely and specifically.';
+  const kdnaPrompt = buildKdnaPrompt(destDir);
+  if (!kdnaPrompt) error('Could not build KDNA prompt — missing KDNA_Core or KDNA_Patterns.');
+  const TREATMENT_SYSTEM =
+    'You are a helpful assistant. The following domain judgment is loaded and you MUST apply it when relevant.\n\n' +
+    kdnaPrompt;
+
+  console.log('[1/3] Running baseline (no KDNA)...');
+  const responseA = await callLlm(llm, BASELINE_SYSTEM, userInput);
+  console.log(`      ${responseA.length} chars returned`);
+
+  console.log('[2/3] Running with KDNA loaded...');
+  const responseB = await callLlm(llm, TREATMENT_SYSTEM, userInput);
+  console.log(`      ${responseB.length} chars returned`);
+
+  console.log('[3/3] Diffing reasoning trajectories...');
+  const diffPrompt = makeDiffPrompt(userInput, responseA, responseB);
+  const diff = await callLlm(llm, DIFF_SYSTEM, diffPrompt);
+
+  console.log('');
+  console.log('─'.repeat(64));
+  console.log('  WITHOUT KDNA');
+  console.log('─'.repeat(64));
+  console.log(responseA);
+  console.log('');
+  console.log('─'.repeat(64));
+  console.log('  WITH KDNA');
+  console.log('─'.repeat(64));
+  console.log(responseB);
+  console.log('');
+  console.log('─'.repeat(64));
+  console.log('  REASONING TRAJECTORY DIFF');
+  console.log('─'.repeat(64));
+  console.log(diff);
+  console.log('');
+}
+
+module.exports = { cmdCompare, buildKdnaPrompt };