@aikdna/kdna-cli 0.9.0

package/src/registry.js

@@ -0,0 +1,258 @@
+/**
+ * RegistryResolver — KDNA v0.7 registry client.
+ *
+ * Responsibilities:
+ *   1. Resolve names: bare → @aikdna/bare, validate @scope/name format
+ *   2. Route lookups to the right registry (official vs private)
+ *   3. Cache registry metadata locally
+ *   4. Surface scope trust info to install/publish
+ *
+ * Schema v2.0 — see kdna-registry/SCHEMA.md
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const USER_KDNA_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.kdna');
+const REGISTRY_DIR = path.join(USER_KDNA_DIR, 'registry');
+const CONFIG_FILE = path.join(USER_KDNA_DIR, 'config.json');
+
+const DEFAULT_OFFICIAL_SCOPE = '@aikdna';
+const CANONICAL_REGISTRY_URL =
+  process.env.KDNA_REGISTRY_URL ||
+  'https://raw.githubusercontent.com/knowledge-dna/kdna-registry/main/domains.json';
+
+const NAME_RE = /^@([a-z][a-z0-9-]*)\/([a-z][a-z0-9_]*)$/;
+const BARE_NAME_RE = /^[a-z][a-z0-9_]*$/;
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(file, data) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(data, null, 2) + '\n');
+}
+
+// ─── Name parsing ───────────────────────────────────────────────────────
+
+/**
+ * Parse a name string into { scope, ident, full }.
+ * - "@aikdna/writing" → { scope: "@aikdna", ident: "writing", full: "@aikdna/writing" }
+ * - "writing" → expanded to default official scope → @aikdna/writing
+ * Returns null if invalid.
+ */
+function parseName(input) {
+  if (typeof input !== 'string') return null;
+  const trimmed = input.trim();
+
+  const scoped = trimmed.match(NAME_RE);
+  if (scoped) {
+    return {
+      scope: `@${scoped[1]}`,
+      ident: scoped[2],
+      full: trimmed,
+      wasShort: false,
+    };
+  }
+
+  if (BARE_NAME_RE.test(trimmed)) {
+    const scope = DEFAULT_OFFICIAL_SCOPE;
+    return {
+      scope,
+      ident: trimmed,
+      full: `${scope}/${trimmed}`,
+      wasShort: true,
+    };
+  }
+
+  return null;
+}
+
+// ─── Config (multi-registry routing) ────────────────────────────────────
+
+function loadConfig() {
+  const cfg = readJson(CONFIG_FILE) || {};
+  return {
+    default_scope: cfg.default_scope || DEFAULT_OFFICIAL_SCOPE,
+    registries: cfg.registries || {},
+  };
+}
+
+// ─── Registry source ────────────────────────────────────────────────────
+
+class RegistrySource {
+  constructor(url, cacheFile) {
+    this.url = url;
+    this.cacheFile = cacheFile;
+  }
+
+  fetch() {
+    const raw = execFileSync('curl', ['-fsSL', this.url], { encoding: 'utf8', timeout: 30000 });
+    const data = JSON.parse(raw);
+    writeJson(this.cacheFile, data);
+    return data;
+  }
+
+  load({ allowNetwork = false, refresh = false } = {}) {
+    if (!refresh) {
+      const cached = readJson(this.cacheFile);
+      if (cached) return cached;
+    }
+    if (allowNetwork) {
+      try {
+        return this.fetch();
+      } catch {
+        const cached = readJson(this.cacheFile);
+        if (cached) return cached;
+      }
+    }
+    return null;
+  }
+}
+
+// ─── Resolver ───────────────────────────────────────────────────────────
+
+class RegistryResolver {
+  constructor({ allowNetwork = true, refresh = false } = {}) {
+    this.allowNetwork = allowNetwork;
+    this.refresh = refresh;
+    this.config = loadConfig();
+    this._sources = new Map();
+    this._registries = new Map();
+  }
+
+  _sourceForScope(scopeName) {
+    if (this._sources.has(scopeName)) return this._sources.get(scopeName);
+
+    const cfgEntry = this.config.registries[scopeName];
+    let url, cacheName;
+
+    if (cfgEntry) {
+      url = typeof cfgEntry === 'string' ? cfgEntry : cfgEntry.url;
+      cacheName = `${scopeName.replace('@', '')}.json`;
+    } else {
+      // Default: all unknown scopes route to canonical official registry
+      url = CANONICAL_REGISTRY_URL;
+      cacheName = 'domains.json';
+    }
+
+    const cacheFile = path.join(REGISTRY_DIR, cacheName);
+    const source = new RegistrySource(url, cacheFile);
+    this._sources.set(scopeName, source);
+    return source;
+  }
+
+  _loadRegistryForScope(scopeName) {
+    if (this._registries.has(scopeName)) return this._registries.get(scopeName);
+    const source = this._sourceForScope(scopeName);
+    const data = source.load({ allowNetwork: this.allowNetwork, refresh: this.refresh });
+    this._registries.set(scopeName, data);
+    return data;
+  }
+
+  /**
+   * Get a scope descriptor from its registry.
+   * Returns { type, trust_pubkey, registry_url, verified } or null.
+   */
+  getScope(scopeName) {
+    const reg = this._loadRegistryForScope(scopeName);
+    if (!reg || !reg.scopes) return null;
+    return reg.scopes[scopeName] || null;
+  }
+
+  /**
+   * Resolve a name (bare or @scope/name) into:
+   *   { parsed, scope, entry, registry }
+   * Throws on any failure with a clear message.
+   */
+  resolve(input) {
+    const parsed = parseName(input);
+    if (!parsed) {
+      throw new Error(
+        `Invalid name "${input}". Use @scope/name (e.g. @aikdna/writing) or a bare name for the official scope.`,
+      );
+    }
+
+    const registry = this._loadRegistryForScope(parsed.scope);
+    if (!registry) {
+      throw new Error(
+        `Cannot load registry for scope ${parsed.scope}. Network unavailable and no cache.`,
+      );
+    }
+
+    if (registry.schema_version && registry.schema_version !== '2.0') {
+      throw new Error(
+        `Registry schema_version ${registry.schema_version} not supported. This CLI requires 2.0.`,
+      );
+    }
+
+    const scope = registry.scopes?.[parsed.scope];
+    if (!scope) {
+      throw new Error(`Scope ${parsed.scope} not registered in registry.`);
+    }
+
+    const entry = (registry.domains || []).find((d) => d.name === parsed.full);
+    if (!entry) {
+      const sameScope = (registry.domains || [])
+        .filter((d) => d.name.startsWith(parsed.scope + '/'))
+        .map((d) => d.name);
+      const hint = sameScope.length
+        ? `\nKnown ${parsed.scope}/ domains: ${sameScope.join(', ')}`
+        : '';
+      throw new Error(`Domain ${parsed.full} not found in registry.${hint}`);
+    }
+
+    if (entry.yanked) {
+      const reason = entry.yanked_reason ? `\nReason: ${entry.yanked_reason}` : '';
+      const when = entry.yanked_at ? ` (yanked ${entry.yanked_at.slice(0, 10)})` : '';
+      const replace = entry.replaced_by ? `\nTry: kdna install ${entry.replaced_by}` : '';
+      throw new Error(`${entry.name}@${entry.version} has been yanked${when}.${reason}${replace}`);
+    }
+
+    return { parsed, scope, entry, registry };
+  }
+
+  /**
+   * List all domains across registries already loaded (does not trigger network for other scopes).
+   * For now this is just the official registry's domains.
+   */
+  listAllDomains() {
+    const reg = this._loadRegistryForScope(DEFAULT_OFFICIAL_SCOPE);
+    return reg?.domains || [];
+  }
+}
+
+// ─── Backwards-compatible helpers (used by remaining v0.6 code paths) ──
+
+function loadRegistry(options = {}) {
+  const resolver = new RegistryResolver({
+    allowNetwork: options.allowNetwork ?? false,
+    refresh: options.refresh ?? false,
+  });
+  return resolver.listAllDomains();
+}
+
+function fetchRegistry() {
+  const source = new RegistrySource(
+    CANONICAL_REGISTRY_URL,
+    path.join(REGISTRY_DIR, 'domains.json'),
+  );
+  const data = source.fetch();
+  return data.domains || [];
+}
+
+module.exports = {
+  RegistryResolver,
+  parseName,
+  loadRegistry,
+  fetchRegistry,
+  CANONICAL_REGISTRY_URL,
+  REGISTRY_CACHE: path.join(REGISTRY_DIR, 'domains.json'),
+  DEFAULT_OFFICIAL_SCOPE,
+};

package/src/search.js

@@ -0,0 +1,73 @@
+/**
+ * kdna search <keyword> — Search registry by keyword.
+ *
+ * Matches against: name, description, core_insight, keywords[],
+ * domain_field, judgment_patterns. Case-insensitive substring search.
+ */
+
+const { RegistryResolver } = require('./registry');
+
+function matchScore(d, q) {
+  const ql = q.toLowerCase();
+  let score = 0;
+
+  // Higher weight for stronger signals
+  if ((d.name || '').toLowerCase().includes(ql)) score += 10;
+  if ((d.id || '').toLowerCase().includes(ql)) score += 8;
+  if ((d.keywords || []).some((k) => (k || '').toLowerCase().includes(ql))) score += 6;
+  if ((d.core_insight || '').toLowerCase().includes(ql)) score += 4;
+  if ((d.description || '').toLowerCase().includes(ql)) score += 3;
+  if ((d.domain_field || []).some((f) => (f || '').toLowerCase().includes(ql))) score += 2;
+  if ((d.judgment_patterns || []).some((p) => (p || '').toLowerCase().includes(ql))) score += 2;
+
+  return score;
+}
+
+function cmdSearch(query) {
+  if (!query) {
+    console.error('Usage: kdna search <keyword>');
+    console.error('       kdna search "content strategy"');
+    process.exit(1);
+  }
+
+  const resolver = new RegistryResolver({ allowNetwork: true });
+  const domains = resolver.listAllDomains() || [];
+
+  if (!domains.length) {
+    console.log('No registry entries found. Run: kdna registry refresh');
+    return;
+  }
+
+  const matches = domains
+    .map((d) => ({ d, score: matchScore(d, query) }))
+    .filter((m) => m.score > 0)
+    .sort((a, b) => b.score - a.score);
+
+  if (!matches.length) {
+    console.log(`No domains match "${query}".`);
+    console.log('');
+    console.log('Try:');
+    console.log('  kdna list --available     # show everything');
+    return;
+  }
+
+  console.log(`Found ${matches.length} matching domain(s) for "${query}":`);
+  console.log('');
+
+  for (const { d, score } of matches) {
+    const yanked = d.yanked ? ' [yanked]' : '';
+    const dep = d.deprecated ? ' [deprecated]' : '';
+    console.log(
+      `  ${(d.name || d.id || '?').padEnd(36)} v${d.version || '?'}  ${(d.type || 'domain').padEnd(8)}  score:${score}${yanked}${dep}`,
+    );
+    if (d.description) console.log(`    ${d.description}`);
+    if (d.core_insight) console.log(`    » ${d.core_insight}`);
+    console.log('');
+  }
+
+  console.log(
+    `To install: kdna install <name>     # e.g. kdna install ${matches[0].d.name || matches[0].d.id}`,
+  );
+}
+
+module.exports = { cmdSearch };

package/src/setup.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+/**
+ * kdna setup — One-command KDNA installation.
+ *
+ * Detects the user's AI agent, installs the kdna-loader skill (the only
+ * KDNA skill), creates the data directory, and initializes the local
+ * registry cache. Zero domains are installed by default — domains are
+ * a separate `kdna install <name>` action.
+ *
+ * The kdna-loader skill teaches the agent how to discover and use KDNA
+ * domains via the kdna CLI's available/match/load commands. Domains
+ * themselves are not skills.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const USER_KDNA_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.kdna');
+const DOMAINS_DIR = path.join(USER_KDNA_DIR, 'domains');
+const CLUSTERS_DIR = path.join(USER_KDNA_DIR, 'clusters');
+const SKILLS_REPO = 'https://raw.githubusercontent.com/knowledge-dna/kdna-skills/main';
+
+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',
+  },
+];
+
+function log(msg) {
+  console.log(`\x1b[32m✓\x1b[0m ${msg}`);
+}
+function warn(msg) {
+  console.log(`\x1b[33m⚠\x1b[0m ${msg}`);
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function detectAgents() {
+  return AGENTS.filter((a) => fs.existsSync(a.dir));
+}
+
+// v2.1 marker — written into SKILL.md so we can detect outdated copies
+const V2_1_MARKER = 'kdna available';
+
+async function downloadSkill(agent) {
+  const skillDir = path.join(agent.dir, agent.skillsDir, 'kdna-loader');
+  ensureDir(skillDir);
+  const dest = path.join(skillDir, 'SKILL.md');
+
+  // 1. Try remote (source of truth)
+  try {
+    const res = await fetch(`${SKILLS_REPO}/kdna-loader/SKILL.md`);
+    if (res.ok) {
+      const content = await res.text();
+      if (content.includes(V2_1_MARKER)) {
+        fs.writeFileSync(dest, content);
+        return { ok: true, source: 'remote' };
+      }
+    }
+  } catch {
+    /* network failure — try fallback */
+  }
+
+  // 2. Fall back to bundled copy (works offline)
+  const local = path.join(__dirname, '..', 'skills', 'kdna-loader', 'SKILL.md');
+  if (fs.existsSync(local)) {
+    fs.copyFileSync(local, dest);
+    return { ok: true, source: 'bundled fallback' };
+  }
+
+  return { ok: false };
+}
+
+function cleanLegacySkills(agent) {
+  // Pre-v0.9 we also installed kdna-create. Remove any stale copy.
+  const legacy = path.join(agent.dir, agent.skillsDir, 'kdna-create');
+  if (fs.existsSync(legacy)) {
+    try {
+      fs.rmSync(legacy, { recursive: true, force: true });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+async function cmdSetup() {
+  console.log('');
+  console.log('KDNA Setup');
+  console.log('═'.repeat(40));
+  console.log('');
+
+  // 1. CLI version
+  const pkg = require(path.join(__dirname, '..', 'package.json'));
+  log(`KDNA CLI v${pkg.version}`);
+
+  // 2. KDNA data root
+  ensureDir(DOMAINS_DIR);
+  ensureDir(CLUSTERS_DIR);
+  log(`Data root: ${USER_KDNA_DIR}/`);
+
+  // 2b. Clean legacy (un-scoped) domain directories from pre-v0.7
+  if (fs.existsSync(DOMAINS_DIR)) {
+    const legacy = fs.readdirSync(DOMAINS_DIR).filter((e) => {
+      if (e.startsWith('@') || e.startsWith('.')) return false;
+      try {
+        return fs.statSync(path.join(DOMAINS_DIR, e)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+    if (legacy.length) {
+      console.log('');
+      warn(
+        `Removing ${legacy.length} legacy (un-scoped) domain director${legacy.length > 1 ? 'ies' : 'y'}:`,
+      );
+      for (const d of legacy) {
+        const dPath = path.join(DOMAINS_DIR, d);
+        try {
+          fs.rmSync(dPath, { recursive: true, force: true });
+          log(`  removed ~/.kdna/domains/${d}/`);
+        } catch (e) {
+          warn(`  could not remove ~/.kdna/domains/${d}/ — ${e.message}`);
+          console.log(`    To remove manually:  rm -rf ~/.kdna/domains/${d}/`);
+        }
+      }
+      console.log('  Re-install with: kdna install @aikdna/<name>');
+      console.log('');
+    }
+  }
+
+  // 3. Detect agents
+  const detected = detectAgents();
+
+  if (!detected.length) {
+    warn('No supported AI agents detected.');
+    console.log('  Supported: OpenCode (~/.agents), Codex (~/.codex),');
+    console.log('  Claude Code (~/.claude), Cursor (~/.cursor),');
+    console.log('  Gemini Antigravity (~/.gemini/antigravity)');
+    console.log('');
+    console.log('  When you install one, re-run: kdna setup');
+    console.log('');
+  } else {
+    log(`Detected agents: ${detected.map((a) => a.name).join(', ')}`);
+
+    for (const agent of detected) {
+      const result = await downloadSkill(agent);
+      if (result.ok) {
+        log(`kdna-loader → ${agent.name}  (${result.source})`);
+      } else {
+        warn(`Failed to install kdna-loader for ${agent.name}`);
+      }
+      if (cleanLegacySkills(agent)) {
+        log(`removed legacy kdna-create from ${agent.name}`);
+      }
+    }
+  }
+
+  console.log('');
+  console.log('Setup complete. KDNA is ready.');
+  console.log('');
+  console.log('Next steps:');
+  console.log('  1. Install a domain:    kdna install @aikdna/writing');
+  console.log('  2. Verify it:           kdna verify @aikdna/writing');
+  console.log('  3. Browse the registry: kdna list --available');
+  console.log('  4. In your agent, ask any judgment-related question.');
+  console.log('     The kdna-loader skill will discover installed domains');
+  console.log('     and apply them silently when relevant.');
+  console.log('');
+}
+
+module.exports = { cmdSetup, detectAgents };