dme-agent 7.4.1

package/src/install.mjs

@@ -0,0 +1,407 @@
+/**
+ * DME bootstrap installer — copies manifesto, system prompt, skills, rules
+ * into every major agent CLI surface.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { filterTargets } from "./targets.mjs";
+import { ok, fail, skip, info, warn, step, hr, box, table } from "./ui.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = path.resolve(__dirname, "..");
+const ASSETS = path.join(PKG_ROOT, "assets");
+
+const SKILL_NAMES = [
+  "dme-design",
+  "dme-shadcn",
+  "dme-research",
+  "dme-critique",
+  "dme-dashboard",
+  "dme-landing",
+  "dme-ux",
+];
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function readAsset(...parts) {
+  const p = path.join(ASSETS, ...parts);
+  if (!fs.existsSync(p)) return null;
+  return fs.readFileSync(p, "utf8");
+}
+
+function writeFile(filePath, content, { appendMarker } = {}) {
+  ensureDir(path.dirname(filePath));
+  if (appendMarker && fs.existsSync(filePath)) {
+    const existing = fs.readFileSync(filePath, "utf8");
+    if (existing.includes(appendMarker)) {
+      // replace block between markers
+      const re = new RegExp(
+        `${escapeRe(appendMarker)}[\\s\\S]*?${escapeRe(appendMarker.replace("BEGIN", "END"))}`,
+        "m"
+      );
+      const endMarker = appendMarker.replace("BEGIN", "END");
+      const block = `${appendMarker}\n${content.trim()}\n${endMarker}\n`;
+      if (re.test(existing)) {
+        fs.writeFileSync(filePath, existing.replace(re, block.trimEnd() + "\n"), "utf8");
+      } else {
+        fs.writeFileSync(
+          filePath,
+          existing.trimEnd() + "\n\n" + block,
+          "utf8"
+        );
+      }
+      return "updated";
+    }
+    const endMarker = appendMarker.replace("BEGIN", "END");
+    fs.writeFileSync(
+      filePath,
+      existing.trimEnd() +
+        "\n\n" +
+        `${appendMarker}\n${content.trim()}\n${endMarker}\n`,
+      "utf8"
+    );
+    return "appended";
+  }
+  fs.writeFileSync(filePath, content, "utf8");
+  return fs.existsSync(filePath) ? "written" : "written";
+}
+
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function copySkill(skillName, destRoot) {
+  const src = path.join(ASSETS, "skills", skillName, "SKILL.md");
+  if (!fs.existsSync(src)) return null;
+  const destDir = path.join(destRoot, skillName);
+  ensureDir(destDir);
+  const dest = path.join(destDir, "SKILL.md");
+  fs.copyFileSync(src, dest);
+  return dest;
+}
+
+function systemPrompt() {
+  return (
+    readAsset("agent", "DME-Agent-v7.4-SYSTEM.md") ||
+    readAsset("agent", "SYSTEM.md") ||
+    "# DME 7.4\n"
+  );
+}
+
+function compactPrompt() {
+  return readAsset("agent", "PROMPT-COMPACT.md") || systemPrompt();
+}
+
+function manifesto() {
+  return (
+    readAsset("manifesto", "DME-Agent-v7.4.md") ||
+    readAsset("manifesto", "MANIFESTO.md") ||
+    systemPrompt()
+  );
+}
+
+function agentProfile() {
+  return readAsset("agent", "dme-v7.4.md") || systemPrompt();
+}
+
+function cursorRule() {
+  return `---
+description: DME Agent 7.4 — Neominimal Identity Engine. Apply on any UI/UX/frontend work.
+globs:
+  - "**/*.{tsx,jsx,vue,svelte,css,html}"
+  - "**/components/**"
+  - "**/app/**"
+  - "**/pages/**"
+alwaysApply: false
+---
+
+${compactPrompt()}
+`;
+}
+
+function rulesSnippet() {
+  return compactPrompt();
+}
+
+/**
+ * @param {{ targets?: string[], force?: boolean, dryRun?: boolean, cwdProject?: boolean }} opts
+ */
+export async function installDme(opts = {}) {
+  const targets = filterTargets(opts.targets);
+  const results = [];
+  const total = 6;
+
+  console.log(step(1, total, "Reading DME 7.4 assets…"));
+  const sys = systemPrompt();
+  const compact = compactPrompt();
+  const full = manifesto();
+  const profile = agentProfile();
+
+  if (!sys || sys.length < 100) {
+    console.log(fail("System prompt asset missing or empty."));
+    return { ok: false, results };
+  }
+  console.log(ok(`Manifesto ${full.length} chars · system ${sys.length} chars`));
+  console.log(hr());
+
+  console.log(step(2, total, `Installing into ${targets.length} surfaces…`));
+
+  for (const t of targets) {
+    const row = { id: t.id, name: t.name, files: [], errors: [] };
+    try {
+      // skills
+      for (const skillDir of t.skillDirs) {
+        if (opts.dryRun) {
+          row.files.push(`[dry] skills → ${skillDir}`);
+          continue;
+        }
+        ensureDir(skillDir);
+        for (const skill of SKILL_NAMES) {
+          const dest = copySkill(skill, skillDir);
+          if (dest) row.files.push(dest);
+        }
+      }
+
+      // agent profiles
+      for (const af of t.agentFiles) {
+        if (opts.dryRun) {
+          row.files.push(`[dry] agent → ${af}`);
+          continue;
+        }
+        const content =
+          af.endsWith(".mdc") || af.includes("rules")
+            ? cursorRule()
+            : profile.includes("name: dme")
+              ? profile
+              : profile;
+        writeFile(af, af.includes("cursor") && af.endsWith(".md") ? profile : content);
+        // for agent md files use profile; for CLAUDE_DME use full system
+        if (af.includes("CLAUDE_DME") || af.includes("instructions")) {
+          writeFile(af, sys);
+        } else if (af.endsWith("dme-v7.4.md")) {
+          writeFile(af, profile);
+        }
+        row.files.push(af);
+      }
+
+      // rules — append or write dedicated
+      for (const rf of t.rulesFiles) {
+        if (opts.dryRun) {
+          row.files.push(`[dry] rules → ${rf}`);
+          continue;
+        }
+        ensureDir(path.dirname(rf));
+        const base = path.basename(rf).toLowerCase();
+
+        if (base === "dme-agent.mdc" || rf.endsWith(".mdc")) {
+          writeFile(rf, cursorRule());
+          row.files.push(rf);
+          continue;
+        }
+
+        if (
+          base === "claude.md" ||
+          base === "agents.md" ||
+          base === "agents.md" ||
+          base === ".cursorrules" ||
+          base === ".windsurfrules" ||
+          base === "gemini.md" ||
+          base === "copilot-instructions.md" ||
+          base === "dme-conventions.md" ||
+          base.endsWith("agents.md")
+        ) {
+          // append DME block to shared rules so we don't wipe user content
+          const marker = "<!-- DME-AGENT-7.4 BEGIN -->";
+          writeFile(rf, rulesSnippet(), { appendMarker: marker });
+          row.files.push(rf + " (merged)");
+          continue;
+        }
+
+        if (base.includes("dme") || base.includes("conventions")) {
+          writeFile(rf, sys);
+          row.files.push(rf);
+          continue;
+        }
+
+        writeFile(rf, compact);
+        row.files.push(rf);
+      }
+
+      // always drop full manifesto into target root if root exists or is under home config
+      if (!opts.dryRun && t.root) {
+        try {
+          ensureDir(t.root);
+          const manPath = path.join(t.root, "DME-Agent-v7.4.md");
+          writeFile(manPath, full);
+          row.files.push(manPath);
+          const sysPath = path.join(t.root, "DME-SYSTEM.md");
+          writeFile(sysPath, sys);
+          row.files.push(sysPath);
+        } catch {
+          /* ignore optional root */
+        }
+      }
+
+      results.push({ ...row, status: "ok" });
+      console.log(ok(`${t.name.padEnd(28)} ${row.files.length} paths`));
+    } catch (e) {
+      results.push({ ...row, status: "error", error: String(e?.message || e) });
+      console.log(fail(`${t.name}: ${e?.message || e}`));
+    }
+  }
+
+  console.log(hr());
+  console.log(step(3, total, "Project-local install (cwd)…"));
+  if (opts.cwdProject !== false) {
+    try {
+      const cwd = process.cwd();
+      const localRoots = [
+        path.join(cwd, ".grok", "skills"),
+        path.join(cwd, ".claude", "skills"),
+        path.join(cwd, ".cursor", "skills"),
+        path.join(cwd, ".agents", "skills"),
+      ];
+      for (const lr of localRoots) {
+        if (opts.dryRun) continue;
+        ensureDir(lr);
+        for (const skill of SKILL_NAMES) copySkill(skill, lr);
+      }
+      if (!opts.dryRun) {
+        writeFile(path.join(cwd, "AGENTS.dme.md"), compact);
+        writeFile(path.join(cwd, ".dme", "DME-Agent-v7.4.md"), full);
+        writeFile(path.join(cwd, ".dme", "SYSTEM.md"), sys);
+        // merge into AGENTS.md if present or create pointer
+        const agentsMd = path.join(cwd, "AGENTS.md");
+        writeFile(agentsMd, compact, {
+          appendMarker: "<!-- DME-AGENT-7.4 BEGIN -->",
+        });
+      }
+      console.log(ok(`Project skills + AGENTS.md in ${cwd}`));
+    } catch (e) {
+      console.log(warn(`Project install: ${e?.message || e}`));
+    }
+  } else {
+    console.log(skip("skipped (--no-project)"));
+  }
+
+  console.log(hr());
+  console.log(step(4, total, "Obsidian-ready manifesto…"));
+  if (!opts.dryRun) {
+    const obs = path.join(process.cwd(), "obsidian");
+    ensureDir(obs);
+    writeFile(path.join(obs, "DME-Agent-v7.4.md"), full);
+    console.log(ok(path.join(obs, "DME-Agent-v7.4.md")));
+  }
+
+  console.log(step(5, total, "Summary"));
+  const okN = results.filter((r) => r.status === "ok").length;
+  const errN = results.filter((r) => r.status === "error").length;
+  console.log(
+    table([
+      ["version", "7.4.1"],
+      ["targets ok", String(okN)],
+      ["errors", String(errN)],
+      ["skills", SKILL_NAMES.join(", ")],
+    ])
+  );
+
+  console.log(hr());
+  console.log(step(6, total, "Next"));
+  console.log(
+    box("DME is live", [
+      "Restart Claude / Cursor / Zed / Grok sessions",
+      "Slash: /dme-design  /dme-dashboard  /dme-landing",
+      "System: ask the agent to follow DME 7.4",
+      "Full doctrine: DME-Agent-v7.4.md in each root",
+    ])
+  );
+  console.log("");
+  console.log(info("dme doctor   — verify install"));
+  console.log(info("dme update   — re-sync latest assets"));
+  console.log(info("dme uninstall — remove DME blocks (safe merge)"));
+  console.log("");
+
+  return { ok: errN === 0, results };
+}
+
+export function doctor() {
+  const targets = filterTargets(["all"]);
+  console.log(step(1, 1, "Scanning DME install…"));
+  console.log(hr());
+  for (const t of targets) {
+    const hits = [];
+    for (const skillDir of t.skillDirs) {
+      for (const skill of SKILL_NAMES) {
+        const p = path.join(skillDir, skill, "SKILL.md");
+        if (fs.existsSync(p)) hits.push(skill);
+      }
+    }
+    for (const af of t.agentFiles) {
+      if (fs.existsSync(af)) hits.push(path.basename(af));
+    }
+    for (const rf of t.rulesFiles) {
+      if (fs.existsSync(rf)) {
+        const txt = fs.readFileSync(rf, "utf8");
+        if (txt.includes("DME") || txt.includes("7.4")) hits.push(path.basename(rf));
+      }
+    }
+    const man = path.join(t.root, "DME-Agent-v7.4.md");
+    if (fs.existsSync(man)) hits.push("manifesto");
+
+    if (hits.length) console.log(ok(`${t.name.padEnd(28)} ${hits.length} hits`));
+    else console.log(skip(`${t.name.padEnd(28)} not installed`));
+  }
+  console.log("");
+}
+
+export function uninstall() {
+  console.log(warn("Uninstall removes DME-named files and <!-- DME-AGENT-7.4 --> blocks."));
+  const targets = filterTargets(["all"]);
+  for (const t of targets) {
+    for (const skillDir of t.skillDirs) {
+      for (const skill of SKILL_NAMES) {
+        const dir = path.join(skillDir, skill);
+        if (fs.existsSync(dir)) {
+          fs.rmSync(dir, { recursive: true, force: true });
+          console.log(ok(`removed skill ${dir}`));
+        }
+      }
+    }
+    for (const af of t.agentFiles) {
+      if (fs.existsSync(af) && path.basename(af).includes("dme")) {
+        fs.unlinkSync(af);
+        console.log(ok(`removed ${af}`));
+      }
+    }
+    for (const rf of t.rulesFiles) {
+      if (!fs.existsSync(rf)) continue;
+      const base = path.basename(rf).toLowerCase();
+      if (base.includes("dme") || base.endsWith(".mdc")) {
+        fs.unlinkSync(rf);
+        console.log(ok(`removed ${rf}`));
+        continue;
+      }
+      let txt = fs.readFileSync(rf, "utf8");
+      const re =
+        /<!-- DME-AGENT-7\.4 BEGIN -->[\s\S]*?<!-- DME-AGENT-7\.4 END -->\n?/g;
+      if (re.test(txt)) {
+        txt = txt.replace(re, "");
+        fs.writeFileSync(rf, txt, "utf8");
+        console.log(ok(`stripped DME block from ${rf}`));
+      }
+    }
+    const man = path.join(t.root, "DME-Agent-v7.4.md");
+    const sys = path.join(t.root, "DME-SYSTEM.md");
+    for (const p of [man, sys]) {
+      if (fs.existsSync(p)) {
+        fs.unlinkSync(p);
+        console.log(ok(`removed ${p}`));
+      }
+    }
+  }
+  console.log(ok("Uninstall complete."));
+}

package/src/postinstall-hint.mjs

@@ -0,0 +1,16 @@
+/**
+ * Soft hint after npm install — never fails the install.
+ */
+try {
+  if (process.env.DME_SILENT === "1") process.exit(0);
+  const y = process.stdout.isTTY ? "\x1b[33m" : "";
+  const d = process.stdout.isTTY ? "\x1b[2m" : "";
+  const r = process.stdout.isTTY ? "\x1b[0m" : "";
+  console.log("");
+  console.log(`${y}  DME Agent installed.${r}`);
+  console.log(`${d}  Run:  npx dme-agent install${r}`);
+  console.log(`${d}  Or:   dme install${r}`);
+  console.log("");
+} catch {
+  /* ignore */
+}

package/src/targets.mjs

@@ -0,0 +1,179 @@
+/**
+ * Install targets for every major AI coding CLI / editor agent surface.
+ */
+
+import os from "node:os";
+import path from "node:path";
+
+const home = os.homedir();
+
+/**
+ * @typedef {object} Target
+ * @property {string} id
+ * @property {string} name
+ * @property {string} root
+ * @property {"claude"|"cursor"|"codex"|"zed"|"grok"|"windsurf"|"continue"|"aider"|"copilot"|"antigravity"|"generic"} kind
+ * @property {string[]} skillDirs
+ * @property {string[]} agentFiles
+ * @property {string[]} rulesFiles
+ * @property {boolean} [optional]
+ */
+
+/** @returns {Target[]} */
+export function getTargets() {
+  return [
+    {
+      id: "claude",
+      name: "Claude Code",
+      root: path.join(home, ".claude"),
+      kind: "claude",
+      skillDirs: [path.join(home, ".claude", "skills")],
+      agentFiles: [
+        path.join(home, ".claude", "agents", "dme-v7.4.md"),
+        path.join(home, ".claude", "CLAUDE_DME.md"),
+      ],
+      rulesFiles: [
+        path.join(home, ".claude", "CLAUDE.md"),
+        path.join(home, ".claude", "Agents.md"),
+      ],
+    },
+    {
+      id: "cursor",
+      name: "Cursor",
+      root: path.join(home, ".cursor"),
+      kind: "cursor",
+      skillDirs: [
+        path.join(home, ".cursor", "skills"),
+        path.join(home, ".cursor", "skills-cursor"),
+      ],
+      agentFiles: [path.join(home, ".cursor", "agents", "dme-v7.4.md")],
+      rulesFiles: [
+        path.join(home, ".cursor", "rules", "dme-agent.mdc"),
+        path.join(home, ".cursorrules"),
+      ],
+    },
+    {
+      id: "codex",
+      name: "OpenAI Codex CLI",
+      root: path.join(home, ".codex"),
+      kind: "codex",
+      skillDirs: [path.join(home, ".codex", "skills")],
+      agentFiles: [path.join(home, ".codex", "agents", "dme-v7.4.md")],
+      rulesFiles: [
+        path.join(home, ".codex", "AGENTS.md"),
+        path.join(home, ".codex", "instructions", "dme-v7.4.md"),
+      ],
+    },
+    {
+      id: "zed",
+      name: "Zed",
+      root: path.join(home, ".config", "zed"),
+      kind: "zed",
+      skillDirs: [path.join(home, ".config", "zed", "skills")],
+      agentFiles: [
+        path.join(home, ".config", "zed", "agents", "dme-v7.4.md"),
+      ],
+      rulesFiles: [
+        path.join(home, ".config", "zed", "rules", "dme.md"),
+        path.join(home, ".config", "zed", "AGENTS.md"),
+      ],
+    },
+    {
+      id: "grok",
+      name: "Grok / xAI",
+      root: path.join(home, ".grok"),
+      kind: "grok",
+      skillDirs: [path.join(home, ".grok", "skills")],
+      agentFiles: [
+        path.join(home, ".grok", "bundled", "agents", "dme-v7.4.md"),
+        path.join(home, ".grok", "agents", "dme-v7.4.md"),
+      ],
+      rulesFiles: [path.join(home, ".grok", "AGENTS.md")],
+    },
+    {
+      id: "windsurf",
+      name: "Windsurf",
+      root: path.join(home, ".codeium", "windsurf"),
+      kind: "windsurf",
+      skillDirs: [path.join(home, ".codeium", "windsurf", "skills")],
+      agentFiles: [
+        path.join(home, ".codeium", "windsurf", "agents", "dme-v7.4.md"),
+      ],
+      rulesFiles: [
+        path.join(home, ".codeium", "windsurf", "memories", "dme-v7.4.md"),
+        path.join(home, ".windsurfrules"),
+      ],
+      optional: true,
+    },
+    {
+      id: "continue",
+      name: "Continue.dev",
+      root: path.join(home, ".continue"),
+      kind: "continue",
+      skillDirs: [path.join(home, ".continue", "skills")],
+      agentFiles: [path.join(home, ".continue", "agents", "dme-v7.4.md")],
+      rulesFiles: [path.join(home, ".continue", "rules", "dme.md")],
+      optional: true,
+    },
+    {
+      id: "aider",
+      name: "Aider",
+      root: path.join(home, ".aider"),
+      kind: "aider",
+      skillDirs: [],
+      agentFiles: [],
+      rulesFiles: [
+        path.join(home, ".aider", "dme-CONVENTIONS.md"),
+        path.join(home, ".aider.conf.dme.yml"),
+      ],
+      optional: true,
+    },
+    {
+      id: "copilot",
+      name: "GitHub Copilot (chat instructions)",
+      root: path.join(home, ".copilot"),
+      kind: "copilot",
+      skillDirs: [],
+      agentFiles: [],
+      rulesFiles: [
+        path.join(home, ".github", "copilot-instructions.md"),
+        path.join(home, ".copilot", "dme-instructions.md"),
+      ],
+      optional: true,
+    },
+    {
+      id: "antigravity",
+      name: "Google Antigravity / Gemini CLI",
+      root: path.join(home, ".gemini"),
+      kind: "antigravity",
+      skillDirs: [path.join(home, ".gemini", "skills")],
+      agentFiles: [path.join(home, ".gemini", "agents", "dme-v7.4.md")],
+      rulesFiles: [
+        path.join(home, ".gemini", "GEMINI.md"),
+        path.join(home, ".gemini", "AGENTS.md"),
+      ],
+      optional: true,
+    },
+    {
+      id: "global-agents",
+      name: "Global AGENTS.md (home)",
+      root: home,
+      kind: "generic",
+      skillDirs: [
+        path.join(home, ".agents", "skills"),
+        path.join(home, ".config", "agents", "skills"),
+      ],
+      agentFiles: [path.join(home, ".agents", "dme-v7.4.md")],
+      rulesFiles: [path.join(home, "AGENTS.md")],
+      optional: true,
+    },
+  ];
+}
+
+export function filterTargets(ids) {
+  const all = getTargets();
+  if (!ids || ids.length === 0) return all;
+  const set = new Set(ids.map((x) => x.toLowerCase()));
+  if (set.has("all")) return all;
+  return all.filter((t) => set.has(t.id));
+}

package/src/ui.mjs

@@ -0,0 +1,93 @@
+/**
+ * Terminal UI — neominimal, readable, no emoji spam.
+ */
+
+const isWin = process.platform === "win32";
+const forceColor =
+  process.env.FORCE_COLOR === "1" ||
+  process.env.DME_COLOR === "1" ||
+  (process.stdout.isTTY && process.env.NO_COLOR !== "1");
+
+const c = {
+  reset: forceColor ? "\x1b[0m" : "",
+  bold: forceColor ? "\x1b[1m" : "",
+  dim: forceColor ? "\x1b[2m" : "",
+  yellow: forceColor ? "\x1b[33m" : "",
+  cyan: forceColor ? "\x1b[36m" : "",
+  green: forceColor ? "\x1b[32m" : "",
+  red: forceColor ? "\x1b[31m" : "",
+  white: forceColor ? "\x1b[37m" : "",
+  gray: forceColor ? "\x1b[90m" : "",
+  bg: forceColor ? "\x1b[40m" : "",
+  bgYellow: forceColor ? "\x1b[43m" : "",
+  black: forceColor ? "\x1b[30m" : "",
+};
+
+export const colors = c;
+
+export function banner(version = "7.4.1") {
+  const y = c.yellow;
+  const d = c.dim;
+  const r = c.reset;
+  const b = c.bold;
+  const lines = [
+    "",
+    `${y}${b}  ╔══════════════════════════════════════════════════╗${r}`,
+    `${y}${b}  ║${r}                                                  ${y}${b}║${r}`,
+    `${y}${b}  ║${r}   ${b}D M E   A G E N T${r}   ${d}v${version}${r}                    ${y}${b}║${r}`,
+    `${y}${b}  ║${r}   ${d}Neominimal Identity Engine${r}                   ${y}${b}║${r}`,
+    `${y}${b}  ║${r}                                                  ${y}${b}║${r}`,
+    `${y}${b}  ╚══════════════════════════════════════════════════╝${r}`,
+    `${d}  less, but better — with a face · shadcn first · UX for humans${r}`,
+    "",
+  ];
+  return lines.join("\n");
+}
+
+export function step(n, total, msg) {
+  return `${c.yellow}${c.bold}[${n}/${total}]${c.reset} ${msg}`;
+}
+
+export function ok(msg) {
+  return `${c.green}  ✓${c.reset} ${msg}`;
+}
+
+export function fail(msg) {
+  return `${c.red}  ✗${c.reset} ${msg}`;
+}
+
+export function skip(msg) {
+  return `${c.gray}  –${c.reset} ${c.dim}${msg}${c.reset}`;
+}
+
+export function info(msg) {
+  return `${c.cyan}  →${c.reset} ${msg}`;
+}
+
+export function warn(msg) {
+  return `${c.yellow}  !${c.reset} ${msg}`;
+}
+
+export function hr() {
+  return `${c.dim}  ────────────────────────────────────────────────${c.reset}`;
+}
+
+export function box(title, lines = []) {
+  const width = 52;
+  const top = `${c.yellow}  ┌${"─".repeat(width - 2)}┐${c.reset}`;
+  const mid = `${c.yellow}  │${c.reset} ${c.bold}${title.padEnd(width - 4)}${c.reset}${c.yellow}│${c.reset}`;
+  const body = lines.map(
+    (l) =>
+      `${c.yellow}  │${c.reset} ${String(l).slice(0, width - 4).padEnd(width - 4)}${c.yellow}│${c.reset}`
+  );
+  const bot = `${c.yellow}  └${"─".repeat(width - 2)}┘${c.reset}`;
+  return [top, mid, ...body, bot].join("\n");
+}
+
+export function table(rows) {
+  return rows
+    .map(([k, v]) => `  ${c.dim}${String(k).padEnd(16)}${c.reset}${v}`)
+    .join("\n");
+}
+
+export { isWin };