@0dai-dev/cli 4.2.0 → 4.3.4

package/lib/commands/import_claude_code_agents.js

@@ -0,0 +1,367 @@
+"use strict";
+
+/**
+ * 0dai import claude-code-agents
+ *
+ * Reads Claude Code subagent files (markdown with YAML frontmatter) from
+ * `.claude/agents/` and converts each into a 0dai persona YAML in
+ * `ai/personas/`. The resulting persona records `imported_from: "claude-code"`
+ * so `0dai sync` can write the file back into `.claude/agents/` for round-trip
+ * fidelity.
+ *
+ * Usage:
+ *   0dai import claude-code-agents [--source DIR] [--target DIR] [--dry-run]
+ *
+ * No external YAML dependency — Claude Code subagents use a constrained
+ * frontmatter shape (flat key: value pairs) which we parse with a small
+ * line-oriented reader.
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const T = process.stdout.isTTY ? "\x1b[38;2;45;212;168m" : "";
+const R = process.stdout.isTTY ? "\x1b[0m" : "";
+const D = process.stdout.isTTY ? "\x1b[2m" : "";
+const E = process.stdout.isTTY ? "\x1b[31m" : "";
+const W = process.stdout.isTTY ? "\x1b[33m" : "";
+const log = (msg) => console.log(`${T}[0dai]${R} ${msg}`);
+
+function parseFrontmatter(text) {
+  if (typeof text !== "string") return null;
+  const lines = text.replace(/\r\n/g, "\n").split("\n");
+  if (lines[0].trim() !== "---") return null;
+
+  let endIdx = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trim() === "---") { endIdx = i; break; }
+  }
+  if (endIdx === -1) return null;
+
+  const frontmatter = {};
+  for (let i = 1; i < endIdx; i++) {
+    const raw = lines[i];
+    if (!raw.trim() || raw.trim().startsWith("#")) continue;
+    const m = raw.match(/^([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*(.*)$/);
+    if (!m) continue;
+    const key = m[1];
+    let value = m[2].trim();
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    if (key === "tools") {
+      frontmatter[key] = value
+        ? value.split(",").map((s) => s.trim()).filter(Boolean)
+        : [];
+    } else {
+      frontmatter[key] = value;
+    }
+  }
+
+  const body = lines.slice(endIdx + 1).join("\n").replace(/^\n+/, "").replace(/\s+$/, "");
+  return { frontmatter, body };
+}
+
+function serializePersona(persona) {
+  const lines = [];
+  const ordered = [
+    "managed", "name", "display_name", "description",
+    "imported_from", "imported_at", "source_file", "model", "tools",
+  ];
+  for (const key of ordered) {
+    if (!(key in persona)) continue;
+    const v = persona[key];
+    if (Array.isArray(v)) {
+      if (v.length === 0) {
+        lines.push(`${key}: []`);
+      } else {
+        const inline = v.map((item) => yamlScalar(item)).join(", ");
+        lines.push(`${key}: [${inline}]`);
+      }
+    } else if (typeof v === "boolean" || typeof v === "number") {
+      lines.push(`${key}: ${v}`);
+    } else {
+      lines.push(`${key}: ${yamlScalar(v)}`);
+    }
+  }
+
+  if (persona.system_prompt_addition) {
+    lines.push("");
+    lines.push("system_prompt_addition: |");
+    const body = String(persona.system_prompt_addition).replace(/\s+$/, "");
+    for (const ln of body.split("\n")) {
+      lines.push(ln ? `  ${ln}` : "");
+    }
+  }
+
+  return lines.join("\n") + "\n";
+}
+
+function yamlScalar(value) {
+  const s = String(value);
+  // Quote only when YAML would mis-parse: leading sigils that introduce
+  // flow/anchor/tag syntax, embedded `: ` (mapping), embedded `#` (comment),
+  // wrapping whitespace, or empty string. Hyphens mid-token are fine.
+  const needsQuote =
+    s === "" ||
+    /^\s|\s$/.test(s) ||
+    /^[\-?:&*!|>'"%@`{[]/.test(s) ||
+    /:\s|\s#/.test(s) ||
+    /[\n\r\t]/.test(s);
+  if (needsQuote) {
+    return `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  }
+  return s;
+}
+
+function parsePersonaYaml(text) {
+  const lines = text.replace(/\r\n/g, "\n").split("\n");
+  const out = {};
+  let i = 0;
+  while (i < lines.length) {
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("#")) { i++; continue; }
+    const blockMatch = raw.match(/^([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*\|\s*$/);
+    if (blockMatch) {
+      const key = blockMatch[1];
+      i++;
+      const body = [];
+      let baseIndent = null;
+      while (i < lines.length) {
+        const cur = lines[i];
+        if (cur.trim() === "") { body.push(""); i++; continue; }
+        const indentMatch = cur.match(/^(\s+)/);
+        if (!indentMatch) break;
+        if (baseIndent === null) baseIndent = indentMatch[1].length;
+        if (indentMatch[1].length < baseIndent) break;
+        body.push(cur.slice(baseIndent));
+        i++;
+      }
+      out[key] = body.join("\n").replace(/\s+$/, "");
+      continue;
+    }
+    const kv = raw.match(/^([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*(.*)$/);
+    if (kv) {
+      const key = kv[1];
+      let value = kv[2].trim();
+      if ((value.startsWith('"') && value.endsWith('"')) ||
+          (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+      }
+      if (value.startsWith("[") && value.endsWith("]")) {
+        const inner = value.slice(1, -1).trim();
+        out[key] = inner ? inner.split(",").map((s) => {
+          let v = s.trim();
+          if ((v.startsWith('"') && v.endsWith('"')) ||
+              (v.startsWith("'") && v.endsWith("'"))) v = v.slice(1, -1);
+          return v;
+        }) : [];
+      } else if (value === "true" || value === "false") {
+        out[key] = value === "true";
+      } else {
+        out[key] = value;
+      }
+    }
+    i++;
+  }
+  return out;
+}
+
+function agentToPersona(parsed, sourceRelPath, opts = {}) {
+  const fm = parsed.frontmatter || {};
+  const name = (fm.name || "").trim();
+  if (!name) {
+    return { error: "missing 'name' in frontmatter" };
+  }
+  const persona = {
+    managed: false,
+    name,
+    display_name: fm.display_name || titleCase(name),
+    description: fm.description || "",
+    imported_from: "claude-code",
+    imported_at: opts.now || new Date().toISOString(),
+    source_file: sourceRelPath,
+  };
+  if (fm.model) persona.model = fm.model;
+  if (Array.isArray(fm.tools) && fm.tools.length) persona.tools = fm.tools;
+  if (parsed.body) persona.system_prompt_addition = parsed.body;
+  return { persona };
+}
+
+function personaToClaudeAgent(persona) {
+  const fm = [];
+  fm.push(`name: ${persona.name}`);
+  if (persona.description) fm.push(`description: ${yamlScalar(persona.description)}`);
+  if (persona.model) fm.push(`model: ${persona.model}`);
+  if (Array.isArray(persona.tools) && persona.tools.length) {
+    fm.push(`tools: ${persona.tools.join(", ")}`);
+  }
+  const body = persona.system_prompt_addition || "";
+  return `---\n${fm.join("\n")}\n---\n\n${body}\n`;
+}
+
+function titleCase(slug) {
+  return slug
+    .split(/[-_]+/)
+    .map((s) => s ? s[0].toUpperCase() + s.slice(1) : "")
+    .join(" ");
+}
+
+function findSourceDir(target, explicit) {
+  if (explicit) return explicit;
+  const repoLocal = path.join(target, ".claude", "agents");
+  if (fs.existsSync(repoLocal) && fs.statSync(repoLocal).isDirectory()) {
+    return repoLocal;
+  }
+  const home = path.join(os.homedir(), ".claude", "agents");
+  if (fs.existsSync(home) && fs.statSync(home).isDirectory()) {
+    return home;
+  }
+  return null;
+}
+
+async function cmdImportClaudeCodeAgents(target, args = []) {
+  const opts = parseArgs(args);
+  const sourceDir = findSourceDir(target, opts.source);
+  const targetDir = opts.target || path.join(target, "ai", "personas");
+
+  if (!sourceDir) {
+    log(`${E}error:${R} no claude-code agents directory found`);
+    console.log(`  ${D}looked at: ${path.join(target, ".claude", "agents")}${R}`);
+    console.log(`  ${D}and: ${path.join(os.homedir(), ".claude", "agents")}${R}`);
+    console.log(`  ${D}use --source DIR to point at a non-default location${R}`);
+    process.exitCode = 1;
+    return { ok: false, error: "no-source-dir", imported: [], skipped: [] };
+  }
+
+  let entries;
+  try {
+    entries = fs.readdirSync(sourceDir);
+  } catch (err) {
+    log(`${E}error:${R} cannot read ${sourceDir}: ${err.message}`);
+    process.exitCode = 1;
+    return { ok: false, error: "read-failed", imported: [], skipped: [] };
+  }
+
+  const candidates = entries.filter((f) => /\.(md|yaml|yml)$/i.test(f));
+  if (candidates.length === 0) {
+    log(`no claude-code agents found in ${sourceDir}`);
+    return { ok: true, imported: [], skipped: [], sourceDir, targetDir };
+  }
+
+  const imported = [];
+  const skipped = [];
+  const seenNames = new Set();
+
+  for (const file of candidates.sort()) {
+    const full = path.join(sourceDir, file);
+    let raw;
+    try {
+      raw = fs.readFileSync(full, "utf8");
+    } catch (err) {
+      skipped.push({ file, reason: `read-failed: ${err.message}` });
+      continue;
+    }
+    const parsed = parseFrontmatter(raw);
+    if (!parsed) {
+      skipped.push({ file, reason: "invalid YAML frontmatter" });
+      continue;
+    }
+    const sourceRel = path.relative(target, full).replace(/\\/g, "/");
+    const result = agentToPersona(parsed, sourceRel, { now: opts.now });
+    if (result.error) {
+      skipped.push({ file, reason: result.error });
+      continue;
+    }
+    const persona = result.persona;
+    if (seenNames.has(persona.name)) {
+      skipped.push({ file, reason: `duplicate name '${persona.name}'` });
+      continue;
+    }
+    seenNames.add(persona.name);
+
+    const outPath = path.join(targetDir, `${persona.name}.yaml`);
+    const yaml = serializePersona(persona);
+    if (!opts.dryRun) {
+      fs.mkdirSync(targetDir, { recursive: true });
+      fs.writeFileSync(outPath, yaml, "utf8");
+    }
+    imported.push({ file, name: persona.name, outPath });
+  }
+
+  if (!opts.quiet) {
+    if (opts.dryRun) log(`${D}dry-run:${R} would import ${imported.length} persona(s) from ${sourceDir}`);
+    else log(`imported ${imported.length} persona(s) from ${sourceDir}`);
+    for (const it of imported) {
+      const rel = path.relative(target, it.outPath).replace(/\\/g, "/");
+      console.log(`  + ${it.name} ${D}-> ${rel}${R}`);
+    }
+    if (skipped.length) {
+      console.log(`  ${W}skipped ${skipped.length}:${R}`);
+      for (const s of skipped) console.log(`    - ${s.file}: ${s.reason}`);
+    }
+    console.log(`  ${D}total: ${imported.length} imported, ${skipped.length} skipped${R}`);
+    if (!opts.dryRun && imported.length) {
+      console.log(`  ${D}round-trip: 0dai sync will write back to .claude/agents/${R}`);
+    }
+  }
+
+  return { ok: true, imported, skipped, sourceDir, targetDir };
+}
+
+function parseArgs(args) {
+  const out = { dryRun: false, source: null, target: null, quiet: false };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--dry-run") out.dryRun = true;
+    else if (a === "--quiet" || a === "-q") out.quiet = true;
+    else if (a === "--source" || a === "--from") out.source = args[++i];
+    else if (a === "--target" || a === "--to") out.target = args[++i];
+    else if (a.startsWith("--source=")) out.source = a.slice("--source=".length);
+    else if (a.startsWith("--target=")) out.target = a.slice("--target=".length);
+  }
+  return out;
+}
+
+function syncImportedClaudeCodeAgents(target, opts = {}) {
+  const personaDir = path.join(target, "ai", "personas");
+  const agentDir = path.join(target, ".claude", "agents");
+  if (!fs.existsSync(personaDir)) return { written: [], skipped: [] };
+
+  const written = [];
+  const skipped = [];
+  for (const file of fs.readdirSync(personaDir)) {
+    if (!/\.ya?ml$/i.test(file)) continue;
+    const full = path.join(personaDir, file);
+    let raw;
+    try { raw = fs.readFileSync(full, "utf8"); } catch { continue; }
+    const persona = parsePersonaYaml(raw);
+    if (persona.imported_from !== "claude-code") continue;
+    if (!persona.name) {
+      skipped.push({ file, reason: "missing name" });
+      continue;
+    }
+    const outPath = path.join(agentDir, `${persona.name}.md`);
+    const md = personaToClaudeAgent(persona);
+    if (!opts.dryRun) {
+      fs.mkdirSync(agentDir, { recursive: true });
+      fs.writeFileSync(outPath, md, "utf8");
+    }
+    written.push({ name: persona.name, outPath });
+  }
+  return { written, skipped };
+}
+
+module.exports = {
+  cmdImportClaudeCodeAgents,
+  parseFrontmatter,
+  serializePersona,
+  parsePersonaYaml,
+  personaToClaudeAgent,
+  agentToPersona,
+  syncImportedClaudeCodeAgents,
+  findSourceDir,
+};