@aikdna/kdna-cli 0.9.0 → 0.12.0

package/src/cmds/cluster.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const { error, readJson } = require('./_common');
+const { error, readJson, EXIT } = require('./_common');
 const {
   loadCluster,
   classifySignalsAcrossDomains,
@@ -29,6 +29,15 @@ function cmdCluster(args) {
   } else if (sub === 'match') {
     if (!target) error('Usage: kdna cluster match <cluster.json> --input "<task>"');
     cmdClusterMatch(target, args);
+  } else if (sub === 'compose') {
+    if (!target) error('Usage: kdna cluster compose <cluster.json> --input "<task>" [--profile=compact] [--json]');
+    cmdClusterCompose(target, args);
+  } else if (sub === 'conflicts') {
+    if (!target) error('Usage: kdna cluster conflicts <cluster.json> --input "<task>" [--json]');
+    cmdClusterConflicts(target, args);
+  } else if (sub === 'graph') {
+    if (!target) error('Usage: kdna cluster graph <cluster.json> [--format=dot|json]');
+    cmdClusterGraph(target, args);
   } else if (sub === 'apply') {
     error(
       'kdna cluster apply was removed in v0.9.\n' +
@@ -42,12 +51,15 @@ function cmdCluster(args) {
         '       kdna cluster init <name>\n' +
         '       kdna cluster info <cluster.json>\n' +
         '       kdna cluster match <cluster.json> --input "<task>"\n' +
-        '       kdna cluster load <cluster.json> --input "<task>"',
+        '       kdna cluster load <cluster.json> --input "<task>"\n' +
+        '       kdna cluster compose <cluster.json> --input "<task>"\n' +
+        '       kdna cluster conflicts <cluster.json> --input "<task>"\n' +
+        '       kdna cluster graph <cluster.json>',
     );
   }
 }
 
-function cmdClusterInfo(target, format = 'human') {
+function cmdClusterInfo(target, _format = 'human') {
   const abs = path.resolve(target);
   if (!fs.existsSync(abs)) error(`Cluster manifest not found: ${abs}`);
 
@@ -232,4 +244,203 @@ function cmdClusterMatch(target, args = []) {
   });
 }
 
+/**
+ * Compose: classify input signals, then compose context with source attribution.
+ * Unlike load (which includes trace), compose focuses on the composed context.
+ */
+function cmdClusterCompose(target, args = []) {
+  const jsonMode = args.includes('--json');
+  const abs = path.resolve(target);
+  if (!fs.existsSync(abs)) error(`Cluster manifest not found: ${abs}`);
+
+  const profileIdx = args.indexOf('--profile');
+  let profile = 'compact';
+  if (profileIdx >= 0) {
+    const val = args[profileIdx + 1];
+    if (val && !val.startsWith('--')) profile = val;
+  }
+
+  const inputIdx = args.indexOf('--input');
+  const input = inputIdx >= 0 ? args[inputIdx + 1] : '';
+  if (!input) error('Usage: kdna cluster compose <cluster.json> --input "<task>"');
+
+  const manifest = readJson(abs);
+  if (!manifest || !manifest.cluster_id) error('Not a valid cluster manifest');
+
+  const domains = loadClusterDomains(manifest);
+
+  const classification = classifySignalsAcrossDomains(input, domains);
+  const { context } = composeContextWithAttribution(classification.selected);
+
+  if (jsonMode) {
+    console.log(JSON.stringify({
+      cluster: manifest.cluster_id,
+      input: input.slice(0, 200),
+      selected: classification.selected.map((d) => ({
+        id: d.id,
+        role: d.role,
+        reason: d.reason,
+      })),
+      excluded: classification.excluded.map((d) => ({
+        id: d.id,
+        reason: d.reason,
+      })),
+      context,
+    }, null, 2));
+    return;
+  }
+
+  console.log(`Cluster: ${manifest.cluster_id}`);
+  console.log(`Profile: ${profile}`);
+  console.log(`Input:   ${input.slice(0, 100)}${input.length > 100 ? '...' : ''}`);
+  console.log('');
+  console.log(`Selected: ${classification.selected.length} | Excluded: ${classification.excluded.length}`);
+  console.log('');
+  console.log('─'.repeat(64));
+  console.log(context);
+  console.log('─'.repeat(64));
+}
+
+/**
+ * Conflicts: detect conflicts between selected domains for given input.
+ */
+function cmdClusterConflicts(target, args = []) {
+  const jsonMode = args.includes('--json');
+  const abs = path.resolve(target);
+  if (!fs.existsSync(abs)) error(`Cluster manifest not found: ${abs}`);
+
+  const inputIdx = args.indexOf('--input');
+  const input = inputIdx >= 0 ? args[inputIdx + 1] : '';
+  if (!input) error('Usage: kdna cluster conflicts <cluster.json> --input "<task>"');
+
+  const manifest = readJson(abs);
+  if (!manifest || !manifest.cluster_id) error('Not a valid cluster manifest');
+
+  const domains = loadClusterDomains(manifest);
+  const classification = classifySignalsAcrossDomains(input, domains);
+  const conflicts = detectDomainConflicts(classification.selected);
+
+  if (jsonMode) {
+    console.log(JSON.stringify({
+      cluster: manifest.cluster_id,
+      input: input.slice(0, 200),
+      selected: classification.selected.map((d) => ({ id: d.id, role: d.role })),
+      conflicts: conflicts.map((c) => ({
+        type: c.type,
+        domains: c.domains,
+        description: c.description,
+        severity: c.severity || 'warn',
+      })),
+      conflict_count: conflicts.length,
+      safe: conflicts.length === 0,
+    }, null, 2));
+    process.exit(conflicts.length ? EXIT.HUMAN_LOCK_REQUIRED : EXIT.OK);
+  }
+
+  console.log(`Cluster: ${manifest.cluster_id}`);
+  console.log(`Input:   ${input.slice(0, 100)}${input.length > 100 ? '...' : ''}`);
+  console.log(`Selected: ${classification.selected.length} domains | Conflicts: ${conflicts.length}`);
+  console.log('');
+
+  if (!conflicts.length) {
+    console.log('✓ No conflicts detected.');
+    return;
+  }
+
+  for (const c of conflicts) {
+    const severity = c.severity === 'error' ? '✗' : '⚠';
+    console.log(`${severity} [${c.type}] ${c.domains.join(' vs ')}`);
+    console.log(`  ${c.description}`);
+    console.log('');
+  }
+}
+
+/**
+ * Graph: output the domain relationship graph from a cluster manifest.
+ */
+function cmdClusterGraph(target, args = []) {
+  const abs = path.resolve(target);
+  if (!fs.existsSync(abs)) error(`Cluster manifest not found: ${abs}`);
+
+  const manifest = readJson(abs);
+  if (!manifest || !manifest.cluster_id) error('Not a valid cluster manifest');
+
+  const formatIdx = args.indexOf('--format');
+  let format = 'dot';
+  if (formatIdx >= 0) {
+    const val = args[formatIdx + 1];
+    if (val && ['dot', 'json'].includes(val)) format = val;
+  }
+
+  if (format === 'json') {
+    const graph = {
+      cluster: manifest.cluster_id,
+      version: manifest.version || '?',
+      type: manifest.type || 'horizontal',
+      nodes: (manifest.domains || []).map((d) => ({
+        id: d.id || d.role,
+        role: d.role,
+        required: d.required !== false,
+      })),
+      edges: (manifest.relationships || []).map((r) => ({
+        from: r.from,
+        to: r.to,
+        type: r.type,
+      })),
+    };
+    console.log(JSON.stringify(graph, null, 2));
+    return;
+  }
+
+  // DOT format output
+  console.log(`digraph "${manifest.cluster_id}" {`);
+  console.log('  rankdir=LR;');
+  console.log(`  label="${manifest.cluster_id} v${manifest.version || '?'}";`);
+  console.log('  fontsize=14;');
+  console.log('');
+
+  // Nodes
+  for (const d of manifest.domains || []) {
+    const shape = d.role === 'primary' ? 'box' : d.role === 'critic' ? 'diamond' : 'ellipse';
+    const required = d.required !== false ? ',style=filled,fillcolor="#e8f0fe"' : ',style=dashed';
+    console.log(`  "${d.id || d.role}" [label="${d.id || d.role}\\n[${d.role}]",shape=${shape}${required}];`);
+  }
+
+  // Edges
+  if (manifest.relationships) {
+    console.log('');
+    for (const r of manifest.relationships) {
+      const style = r.type === 'conflicts' ? ',style=dashed,color=red' :
+                    r.type === 'extends' ? ',style=bold' : '';
+      console.log(`  "${r.from}" -> "${r.to}" [label="${r.type}"${style}];`);
+    }
+  }
+
+  console.log('}');
+}
+
+/**
+ * Shared domain loader for cluster commands.
+ */
+function loadClusterDomains(manifest) {
+  const INSTALL_DIR = path.join(
+    process.env.HOME || process.env.USERPROFILE || '.',
+    '.kdna',
+    'domains',
+  );
+
+  return (manifest.domains || []).map((d) => {
+    const domainId = d.id;
+    if (!domainId) return null;
+    const [scope, ident] = domainId.startsWith('@')
+      ? [domainId.slice(0, domainId.indexOf('/')), domainId.slice(domainId.indexOf('/') + 1)]
+      : ['@aikdna', domainId];
+    const dir = path.join(INSTALL_DIR, scope, ident);
+    const core = readJson(path.join(dir, 'KDNA_Core.json'));
+    const pat = readJson(path.join(dir, 'KDNA_Patterns.json'));
+    if (!core || !pat) return null;
+    return { id: domainId, role: d.role, required: d.required !== false, core, patterns: pat };
+  }).filter(Boolean);
+}
+
 module.exports = { cmdCluster };

package/src/cmds/doctor.js

@@ -0,0 +1,233 @@
+const fs = require('fs');
+const path = require('path');
+const { EXIT, error } = require('./_common');
+const USER_KDNA_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.kdna');
+const INSTALL_DIR = path.join(USER_KDNA_DIR, 'domains');
+
+const AGENTS = [
+  { name: 'OpenCode', dir: path.join(process.env.HOME || '', '.agents'), skillsDir: 'skills' },
+  { name: 'Codex', dir: path.join(process.env.HOME || '', '.codex'), skillsDir: 'skills' },
+  { name: 'Claude Code', dir: path.join(process.env.HOME || '', '.claude'), skillsDir: 'skills' },
+  { name: 'Cursor', dir: path.join(process.env.HOME || '', '.cursor'), skillsDir: 'skills' },
+  { name: 'Gemini Antigravity', dir: path.join(process.env.HOME || '', '.gemini', 'antigravity'), skillsDir: 'skills' },
+];
+
+const V2_1_MARKER = 'kdna available';
+
+function detectAgents() {
+  return AGENTS.filter((a) => fs.existsSync(a.dir));
+}
+
+function checkAgentSkill(agent) {
+  const skillPath = path.join(agent.dir, agent.skillsDir, 'kdna-loader', 'SKILL.md');
+  if (!fs.existsSync(skillPath)) return { installed: false, version: null, path: skillPath };
+
+  try {
+    const content = fs.readFileSync(skillPath, 'utf8');
+    const isV2 = content.includes(V2_1_MARKER);
+    return {
+      installed: true,
+      version: isV2 ? 'v2026.05' : 'outdated',
+      path: skillPath,
+    };
+  } catch {
+    return { installed: false, version: null, path: skillPath };
+  }
+}
+
+function cmdDoctor(args) {
+  const json = args.includes('--json');
+  const quiet = args.includes('--quiet');
+  const agentsOnly = args.includes('--agents');
+  const domainsOnly = args.includes('--domains');
+
+  const checks = [];
+
+  if (!agentsOnly) {
+    // 1. Node.js version
+    const nodeVersion = process.version;
+    const major = parseInt(nodeVersion.slice(1).split('.')[0], 10);
+    checks.push({
+      name: 'Node.js',
+      status: major >= 18 ? 'ok' : 'fail',
+      detail: `${nodeVersion} (${major >= 18 ? '>=18 required' : 'requires >=18'})`,
+    });
+
+    // 2. @aikdna/kdna-core available
+    let coreVersion = null;
+    try {
+      const corePkg = require.resolve('@aikdna/kdna-core/package.json');
+      coreVersion = JSON.parse(fs.readFileSync(corePkg, 'utf8')).version;
+      checks.push({ name: '@aikdna/kdna-core', status: 'ok', detail: `v${coreVersion}` });
+    } catch {
+      checks.push({ name: '@aikdna/kdna-core', status: 'fail', detail: 'not installed' });
+    }
+
+    // 3. ~/.kdna/ exists
+    if (fs.existsSync(USER_KDNA_DIR)) {
+      checks.push({ name: 'KDNA data directory', status: 'ok', detail: USER_KDNA_DIR });
+    } else {
+      checks.push({ name: 'KDNA data directory', status: 'warn', detail: '~/.kdna/ not found' });
+    }
+
+    // 4. ~/.kdna/domains/ exists and has domains
+    if (fs.existsSync(INSTALL_DIR)) {
+      const domains = fs
+        .readdirSync(INSTALL_DIR, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .reduce((acc, scopeDir) => {
+          if (scopeDir.name.startsWith('@')) {
+            try {
+              return acc + fs.readdirSync(path.join(INSTALL_DIR, scopeDir.name)).length;
+            } catch {
+              return acc;
+            }
+          }
+          return acc + 1;
+        }, 0);
+      checks.push({
+        name: 'Installed domains',
+        status: domains > 0 ? 'ok' : 'warn',
+        detail: `${domains} domain${domains !== 1 ? 's' : ''} installed`,
+      });
+    } else {
+      checks.push({ name: 'Domains directory', status: 'warn', detail: '~/.kdna/domains/ not found' });
+    }
+  }
+
+  if (!domainsOnly) {
+    // 5. Agent integration check
+    const detected = detectAgents();
+    for (const agent of AGENTS) {
+      const agentDirExists = fs.existsSync(agent.dir);
+      const skill = agentDirExists ? checkAgentSkill(agent) : { installed: false, version: null, path: null };
+
+      let status, detail;
+      if (!agentDirExists) {
+        status = 'warn';
+        detail = 'agent not detected';
+      } else if (skill.installed && skill.version === 'v2026.05') {
+        status = 'ok';
+        detail = `kdna-loader installed (${skill.version})`;
+      } else if (skill.installed && skill.version === 'outdated') {
+        status = 'warn';
+        detail = 'kdna-loader outdated (run kdna setup --force)';
+      } else {
+        status = 'warn';
+        detail = 'kdna-loader not installed (run kdna setup)';
+      }
+
+      checks.push({
+        name: `Agent: ${agent.name}`,
+        status,
+        detail,
+        agent: agent.name,
+        skillInstalled: skill.installed,
+        skillVersion: skill.version,
+        skillPath: skill.path,
+      });
+    }
+  }
+
+  if (!agentsOnly && !domainsOnly) {
+    // 6. Identity key available
+    const identityDir = path.join(USER_KDNA_DIR, 'identity');
+    const identityDirOfficial = path.join(USER_KDNA_DIR, 'identity-official');
+    const hasIdentity =
+      (fs.existsSync(identityDir) && fs.readdirSync(identityDir).length > 0) ||
+      (fs.existsSync(identityDirOfficial) && fs.readdirSync(identityDirOfficial).length > 0);
+    checks.push({
+      name: 'Signing identity',
+      status: hasIdentity ? 'ok' : 'warn',
+      detail: hasIdentity ? 'key available' : 'no identity (run: kdna identity init)',
+    });
+
+    // 7. Registry cache
+    const registryCache = path.join(USER_KDNA_DIR, 'registry-cache.json');
+    if (fs.existsSync(registryCache)) {
+      try {
+        const stat = fs.statSync(registryCache);
+        const ageMs = Date.now() - stat.mtimeMs;
+        const ageH = Math.round(ageMs / 3600000);
+        const fresh = ageH < 24;
+        checks.push({
+          name: 'Registry cache',
+          status: fresh ? 'ok' : 'warn',
+          detail: `updated ${ageH < 1 ? '<1h' : ageH + 'h'} ago`,
+        });
+      } catch {
+        checks.push({ name: 'Registry cache', status: 'warn', detail: 'cannot read cache' });
+      }
+    } else {
+      checks.push({ name: 'Registry cache', status: 'warn', detail: 'not cached (run: kdna registry refresh)' });
+    }
+
+    // 8. Schema files available
+    let schemaCount = 0;
+    try {
+      const schemaDir = path.join(
+        path.dirname(require.resolve('@aikdna/kdna-core/package.json')),
+        'schema',
+      );
+      schemaCount = fs.readdirSync(schemaDir).filter((f) => f.endsWith('.schema.json')).length;
+      checks.push({
+        name: 'Schema files',
+        status: schemaCount >= 6 ? 'ok' : 'warn',
+        detail: `${schemaCount} schemas`,
+      });
+    } catch {
+      checks.push({ name: 'Schema files', status: 'fail', detail: 'not found' });
+    }
+
+    // 9. Project .kdna/config.json
+    const projectConfig = path.join(process.cwd(), '.kdna', 'config.json');
+    if (fs.existsSync(projectConfig)) {
+      checks.push({ name: 'Project config', status: 'ok', detail: projectConfig });
+    } else {
+      checks.push({ name: 'Project config', status: 'warn', detail: 'No .kdna/config.json in current project' });
+    }
+  }
+
+  // ── Output ───────────────────────────────────────────────────────
+
+  if (json) {
+    const result = {
+      checks: checks.map((c) => ({
+        name: c.name,
+        status: c.status,
+        detail: c.detail,
+        ...(c.agent && { agent: c.agent, skillInstalled: c.skillInstalled, skillVersion: c.skillVersion }),
+      })),
+      ok: checks.filter((c) => c.status === 'ok').length,
+      warnings: checks.filter((c) => c.status === 'warn').length,
+      failures: checks.filter((c) => c.status === 'fail').length,
+      healthy: checks.every((c) => c.status !== 'fail'),
+    };
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(result.healthy ? 0 : EXIT.VALIDATION_FAILED);
+  }
+
+  if (!quiet) {
+    for (const c of checks) {
+      const mark = c.status === 'ok' ? '✓' : c.status === 'warn' ? '⚠' : '✗';
+      console.log(`${mark} ${c.name}: ${c.detail}`);
+    }
+
+    const ok = checks.filter((c) => c.status === 'ok').length;
+    const warns = checks.filter((c) => c.status === 'warn').length;
+    const fails = checks.filter((c) => c.status === 'fail').length;
+    console.log('');
+    if (fails > 0) {
+      console.log(`${ok}/${checks.length} checks passed (${fails} failure${fails !== 1 ? 's' : ''}, ${warns} warning${warns !== 1 ? 's' : ''})`);
+    } else if (warns > 0) {
+      console.log(`${ok}/${checks.length} checks passed (${warns} warning${warns !== 1 ? 's' : ''})`);
+    } else {
+      console.log(`${ok}/${checks.length} checks passed`);
+    }
+  }
+
+  const hasFail = checks.some((c) => c.status === 'fail');
+  process.exit(hasFail ? EXIT.VALIDATION_FAILED : EXIT.OK);
+}
+
+module.exports = { cmdDoctor };