@noir-ai/cli 1.3.0-beta.6 → 1.4.0-beta.1

package/dist/{chunk-3QMQXBII.js → chunk-YES5UCU5.js}

@@ -1,13 +1,287 @@
 #!/usr/bin/env node
-import {
-  EXIT,
-  NoirCliError,
-  error,
-  log,
-  success,
-  table,
-  warn
-} from "./chunk-OF4OO5W6.js";
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/output.ts
+import Table from "cli-table3";
+import { CommanderError } from "commander";
+import ora from "ora";
+
+// src/theme.ts
+import pc from "picocolors";
+var FORCE = pc.createColors(true);
+var c = {
+  /** Green — success / healthy. */
+  ok: (s) => useColor() ? FORCE.green(s) : s,
+  /** Yellow — degraded but usable. */
+  warn: (s) => useColor() ? FORCE.yellow(s) : s,
+  /** Red — reserved strictly for ERROR. Never a table header. */
+  error: (s) => useColor() ? FORCE.red(s) : s,
+  /** Cyan — informational / brand-neutral accent for labels. */
+  info: (s) => useColor() ? FORCE.cyan(s) : s,
+  /** Blue — the Midnight Cobalt brand role (banner / accent). */
+  accent: (s) => useColor() ? FORCE.blue(s) : s,
+  /** Dim — secondary text, table borders when color is on. */
+  dim: (s) => useColor() ? FORCE.dim(s) : s,
+  /** Bold — emphasis (table headers compose this with `info`). */
+  bold: (s) => useColor() ? FORCE.bold(s) : s
+};
+var BADGE_SYMBOL = {
+  ok: "\u2713",
+  warn: "\u26A0",
+  error: "\u2717",
+  info: "\u2139"
+};
+function badge(state, label = state) {
+  const text = `${BADGE_SYMBOL[state]} ${label}`;
+  switch (state) {
+    case "ok":
+      return c.ok(text);
+    case "warn":
+      return c.warn(text);
+    case "error":
+      return c.error(text);
+    case "info":
+      return c.info(text);
+  }
+}
+function envFlagSet(name) {
+  const v = process.env[name];
+  return v !== void 0 && v !== "";
+}
+function isCiEnv() {
+  const v = process.env.CI;
+  if (v === void 0 || v === "") return false;
+  return v !== "0" && v !== "false";
+}
+function useColor() {
+  if (envFlagSet("NO_COLOR")) return false;
+  if (process.env.CLICOLOR_FORCE === "1") return true;
+  if (isCiEnv()) return false;
+  return pc.isColorSupported;
+}
+function accessibleMode() {
+  return envFlagSet("NOIR_ACCESSIBLE");
+}
+function terminalWidth() {
+  const fromEnv = process.env.COLUMNS;
+  if (fromEnv !== void 0 && fromEnv !== "") {
+    const n = Number(fromEnv);
+    if (Number.isInteger(n) && n > 0) return Math.max(n, 20);
+  }
+  const cols = process.stdout.columns;
+  if (typeof cols === "number" && cols > 0) return Math.max(cols, 20);
+  return 80;
+}
+
+// src/output.ts
+var EXIT = {
+  OK: 0,
+  ERROR: 1,
+  USAGE: 2,
+  NOT_FOUND: 3,
+  DAEMON_DOWN: 4,
+  CANCELLED: 5
+};
+var NoirCliError = class extends Error {
+  exitCode;
+  constructor(exitCode, message) {
+    super(message);
+    this.name = "NoirCliError";
+    this.exitCode = exitCode;
+  }
+};
+var NOIR_ERROR_CODE = "noir.error";
+function isJsonMode(opts) {
+  return opts.json === true;
+}
+function isQuietMode(opts) {
+  return opts.quiet === true;
+}
+function isNoInput(opts = {}) {
+  return opts.noInput === true || opts.input === false;
+}
+function envFlagSet2(name) {
+  const v = process.env[name];
+  return v !== void 0 && v !== "";
+}
+function isInteractive(opts = {}) {
+  if (isJsonMode(opts) || isNoInput(opts)) return false;
+  if (isCiEnv() || envFlagSet2("NO_COLOR")) return false;
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+function resolveInteractive() {
+  if (flaggedNonInteractiveCli()) return false;
+  return isInteractive();
+}
+function flaggedNonInteractiveCli() {
+  const v = process.env.NOIR_NON_INTERACTIVE;
+  return v !== void 0 && v !== "";
+}
+function json(obj) {
+  process.stdout.write(`${JSON.stringify(obj)}
+`);
+}
+function log(msg2, opts = {}) {
+  if (isJsonMode(opts) || isQuietMode(opts)) return;
+  process.stderr.write(`${msg2}
+`);
+}
+function info(msg2, opts = {}) {
+  if (isJsonMode(opts) || isQuietMode(opts)) return;
+  process.stderr.write(`${c.info(msg2)}
+`);
+}
+function success(msg2, opts = {}) {
+  if (isJsonMode(opts) || isQuietMode(opts)) return;
+  process.stderr.write(`${c.ok(msg2)}
+`);
+}
+function warn(msg2, opts = {}) {
+  if (isJsonMode(opts)) return;
+  process.stderr.write(`${c.warn(msg2)}
+`);
+}
+function error(msg2, opts = {}) {
+  if (isJsonMode(opts)) return;
+  process.stderr.write(`${c.error(msg2)}
+`);
+}
+function tip(msg2, opts = {}) {
+  if (isJsonMode(opts) || opts.noTips === true) return;
+  process.stderr.write(`${c.warn(msg2)}
+`);
+}
+function table(rows, cols, opts = {}) {
+  if (isJsonMode(opts)) return;
+  if (rows.length === 0) {
+    info("(no rows)", opts);
+    return;
+  }
+  const t = new Table({
+    head: cols.map((col) => c.bold(c.info(col))),
+    // Empty arrays ⇒ cli-table3 applies NO @colors/colors wrap (neither the
+    // default red header nor a colored border). All color is ours, via theme.
+    style: { head: [], border: [] },
+    colWidths: computeColWidths(rows, cols),
+    wordWrap: true,
+    truncate: "\u2026"
+  });
+  for (const row of rows) {
+    t.push(cols.map((col) => formatCell(row[col])));
+  }
+  process.stderr.write(`${t.toString()}
+`);
+}
+function computeColWidths(rows, cols) {
+  const n = cols.length;
+  if (n === 0) return [];
+  const headerLen = cols.map((col) => col.length);
+  const natural = cols.map((col, i) => {
+    let max = Math.max(headerLen[i] ?? col.length, 3);
+    for (const row of rows) {
+      const len = formatCell(row[col]).length;
+      if (len > max) max = len;
+    }
+    return max;
+  });
+  const contentBudget = Math.max(n * 4, terminalWidth() - 3 * n - 1);
+  const naturalSum = natural.reduce((a, b) => a + b, 0);
+  if (naturalSum <= contentBudget) {
+    return natural.map((w) => w + 2);
+  }
+  const content = natural.slice();
+  let sum = naturalSum;
+  const floor = headerLen.map((h) => Math.max(h, 3));
+  while (sum > contentBudget) {
+    let idx = -1;
+    let widest = -1;
+    for (let i = 0; i < n; i++) {
+      const c2 = content[i] ?? 0;
+      const f = floor[i] ?? 3;
+      if (c2 > f && c2 > widest) {
+        widest = c2;
+        idx = i;
+      }
+    }
+    if (idx === -1) break;
+    const overshoot = sum - contentBudget;
+    const reducible = (content[idx] ?? 0) - (floor[idx] ?? 3);
+    const cut = Math.min(overshoot, reducible);
+    content[idx] = (content[idx] ?? 0) - cut;
+    sum -= cut;
+  }
+  return content.map((w) => w + 2);
+}
+function formatCell(value) {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  return JSON.stringify(value);
+}
+function definitionList(rows, opts = {}) {
+  table(
+    rows.map((r) => ({ Field: r.label, Value: formatCell(r.value) })),
+    ["Field", "Value"],
+    opts
+  );
+}
+function fail(exitCode, message, opts = {}) {
+  if (isJsonMode(opts)) {
+    process.stdout.write(`${JSON.stringify({ ok: false, error: { code: exitCode, message } })}
+`);
+  } else if (message.length > 0) {
+    process.stderr.write(`${message}
+`);
+  }
+  throw new CommanderError(exitCode, NOIR_ERROR_CODE, message);
+}
+function requireInteractive(opts, hint) {
+  if (!isInteractive(opts)) {
+    fail(
+      EXIT.USAGE,
+      `${hint} needs an interactive terminal, but input is disabled (non-TTY, --no-input, --json, CI, or NO_COLOR). Re-run in a TTY or supply the value as a flag.`,
+      opts
+    );
+  }
+}
+function commanderExitCode(err) {
+  switch (err.code) {
+    case "commander.helpDisplayed":
+    case "commander.versionDisplayed":
+    case "commander.version":
+      return EXIT.OK;
+    case "commander.unknownCommand":
+      return EXIT.NOT_FOUND;
+    default:
+      return EXIT.USAGE;
+  }
+}
+function inferExitCode(err) {
+  if (err instanceof NoirCliError) return err.exitCode;
+  if (err instanceof CommanderError) {
+    if (err.code.startsWith("noir.")) return err.exitCode;
+    return commanderExitCode(err);
+  }
+  return EXIT.ERROR;
+}
+function handleError(err) {
+  if (err instanceof NoirCliError) {
+    if (err.message.length > 0) process.stderr.write(`${err.message}
+`);
+  } else if (err instanceof CommanderError) {
+  } else {
+    process.stderr.write(`noir: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+  process.exitCode = inferExitCode(err);
+}
 
 // src/commands/doctor.ts
 import { spawnSync } from "child_process";
@@ -286,13 +560,13 @@ function checkRulesMdBudget(checks, root, project) {
 function summarize(checks) {
   let ok = 0;
   let warnN = 0;
-  let fail = 0;
-  for (const c of checks) {
-    if (c.status === "ok") ok++;
-    else if (c.status === "warn") warnN++;
-    else fail++;
+  let fail2 = 0;
+  for (const c2 of checks) {
+    if (c2.status === "ok") ok++;
+    else if (c2.status === "warn") warnN++;
+    else fail2++;
   }
-  return { ok, warn: warnN, fail };
+  return { ok, warn: warnN, fail: fail2 };
 }
 function checkHostArtifacts(checks, root, project) {
   if (!project) {
@@ -531,24 +805,28 @@ function relOr(abs, root) {
 function joinRoot(root, relPath) {
   return `${root}/${relPath}`;
 }
+function severityBadge(s) {
+  const state = s === "fail" ? "error" : s;
+  return badge(state, s.toUpperCase());
+}
 function renderHuman(payload, opts) {
   log(
     `noir doctor \u2014 ${payload.checks.length} check${payload.checks.length === 1 ? "" : "s"}`,
     opts
   );
   table(
-    payload.checks.map((c) => ({
-      Check: c.name,
-      Status: c.status.toUpperCase(),
-      Detail: c.detail
+    payload.checks.map((c2) => ({
+      Check: c2.name,
+      Status: severityBadge(c2.status),
+      Detail: c2.detail
     })),
     ["Check", "Status", "Detail"],
     opts
   );
-  const { ok, warn: warnN, fail } = payload.summary;
-  if (fail > 0) {
+  const { ok, warn: warnN, fail: fail2 } = payload.summary;
+  if (fail2 > 0) {
     error(
-      `${fail} critical check${fail === 1 ? "" : "s"} failed (${warnN} warning${warnN === 1 ? "" : "s"}, ${ok} ok)`,
+      `${fail2} critical check${fail2 === 1 ? "" : "s"} failed (${warnN} warning${warnN === 1 ? "" : "s"}, ${ok} ok)`,
       opts
     );
   } else if (warnN > 0) {
@@ -600,35 +878,365 @@ async function doctor(opts = {}) {
   }
 }
 
-// src/serve.ts
-import { loadProjectInfo as loadProjectInfo2 } from "@noir-ai/core";
-import { ensureDaemonRunning, startStdioServer } from "@noir-ai/daemon";
-async function serve(opts) {
-  const project = loadProjectInfo2(process.cwd());
-  if (opts.stdio) {
-    await startStdioServer({ project, transport: "stdio", daemon: false });
-    return;
+// src/conflict.ts
+function flaggedNonInteractive() {
+  const v = process.env.NOIR_NON_INTERACTIVE;
+  return v !== void 0 && v !== "";
+}
+function buildConflictOpts(input = {}) {
+  if (input.force === true) {
+    return { conflictPolicy: "overwrite" };
   }
-  try {
-    const { url } = await ensureDaemonRunning({
-      project,
-      idleTimeoutSec: project.config.daemon.idleTimeoutSec
+  if (input.interactive === false) {
+    return { conflictPolicy: "preserve" };
+  }
+  if (input.interactive === true) {
+    return { conflictPolicy: "preserve", onConflict: clackConflictResolver };
+  }
+  if (flaggedNonInteractive() || !isInteractive()) {
+    return { conflictPolicy: "preserve" };
+  }
+  return { conflictPolicy: "preserve", onConflict: clackConflictResolver };
+}
+function renderDiffPreview(ctx) {
+  const { lineDiff: ld } = __require("@noir-ai/create");
+  const lines = ld(ctx.existing, ctx.proposed);
+  if (lines.length === 0) return;
+  const out = [`noir: conflict in ${ctx.relPath}`];
+  for (const dl of lines) {
+    if (dl.type === "add") out.push(c.ok(`+ ${dl.line}`));
+    else if (dl.type === "del") out.push(c.error(`- ${dl.line}`));
+    else out.push(c.dim(`  ${dl.line}`));
+  }
+  process.stderr.write(`${out.join("\n")}
+`);
+}
+async function clackConflictResolver(ctx) {
+  renderDiffPreview(ctx);
+  const clack = await import("@clack/prompts");
+  const options = [
+    {
+      value: "replace",
+      label: "Replace",
+      hint: "overwrite with the template (discard your edits)"
+    },
+    { value: "rename", label: "Rename", hint: "keep yours as <file>.local; write the template" },
+    {
+      value: "duplicate",
+      label: "Create duplicate",
+      hint: "write template to <file>.noir; keep yours"
+    },
+    { value: "preserve", label: "Keep mine", hint: "skip; leave your file unchanged" },
+    { value: "cancel", label: "Cancel", hint: "abort the scaffold" }
+  ];
+  if (ctx.mergedWithMarkers !== void 0) {
+    options.splice(4, 0, {
+      value: "merge",
+      label: "Merge (with conflict markers)",
+      hint: "write the 3-way merge with <<<<<<< / ||||||| / ======= / >>>>>>> markers"
     });
+  }
+  const choice = await clack.select({
+    message: `${ctx.relPath} was edited and differs from the Noir template.`,
+    initialValue: "preserve",
+    options
+  });
+  if (clack.isCancel(choice)) return "cancel";
+  const resolution = choice;
+  const mode = ctx.mode ?? "regenerate";
+  if (mode === "regenerate") {
+    const remember = await clack.select({
+      message: `Apply "${labelFor(resolution)}" to all remaining conflicts this run?`,
+      initialValue: "no",
+      options: [
+        { value: "yes", label: "Yes", hint: "reuse this choice for the rest of this run" },
+        { value: "no", label: "No", hint: "prompt again for each conflict" }
+      ]
+    });
+    if (!clack.isCancel(remember) && remember === "yes") {
+      return { resolution, applyToAll: true };
+    }
+  }
+  return resolution;
+}
+function labelFor(resolution) {
+  switch (resolution) {
+    case "replace":
+      return "Replace";
+    case "rename":
+      return "Rename";
+    case "duplicate":
+      return "Create duplicate";
+    case "preserve":
+      return "Keep mine";
+    case "merge":
+      return "Merge (with conflict markers)";
+    case "cancel":
+      return "Cancel";
+  }
+}
+
+// src/dedup-write.ts
+import { createHash } from "crypto";
+import { mkdirSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+var HOST_CONTEXT_RELS = /* @__PURE__ */ new Set(["CLAUDE.md", "AGENTS.md", "GEMINI.md", ".noir/rules/RULES.md"]);
+var ACTION_THRESHOLD = 0.95;
+var INFO_THRESHOLD = 0.85;
+var EMBEDDER_PING_TIMEOUT_MS = 5e3;
+var DEDUP_CACHE_VERSION = 1;
+async function checkWritePathDedup(root, res, opts) {
+  const result = { found: [], conflicts: [] };
+  const writtenHostFiles = res.written.filter((p) => HOST_CONTEXT_RELS.has(p));
+  if (writtenHostFiles.length === 0) return result;
+  const cache = loadCache(root);
+  const embed = await resolveEmbedder(opts, cache);
+  if (embed === void 0) return result;
+  const cachedEmbed = makeCachedEmbed(cache, embed);
+  for (const proposedRel of writtenHostFiles) {
+    const proposedAbs = join2(root, proposedRel);
+    let proposedText;
+    try {
+      proposedText = readFileSync2(proposedAbs, "utf8");
+    } catch {
+      continue;
+    }
+    if (proposedText.trim().length === 0) continue;
+    const candidates = collectDedupCandidates(root).filter((c2) => c2.path !== proposedRel);
+    if (candidates.length === 0) continue;
+    const ctx = await import("@noir-ai/context");
+    const proposed = { path: proposedRel, text: proposedText };
+    let best;
+    try {
+      best = await ctx.findNearestDuplicate(
+        proposed,
+        candidates,
+        async (t) => cachedEmbed(t),
+        INFO_THRESHOLD
+      );
+    } catch (e) {
+      process.stderr.write(
+        `${c.dim(`noir: semantic-dedup skipped for ${proposedRel} (${errMsg(e)}).`)}
+`
+      );
+      continue;
+    }
+    if (best === null) continue;
+    const matchedRel = best.a === proposedRel ? best.b : best.a;
+    const sim = best.similarity;
+    result.found.push({ proposedRel, matchedRel, similarity: sim });
+    if (sim >= ACTION_THRESHOLD) {
+      if (opts.interactive) {
+        await promptDedupAction(root, proposedRel, matchedRel, proposedText, sim);
+      } else {
+        process.stderr.write(
+          `${c.warn("noir: near-duplicate")} ${proposedRel} \u2248 ${matchedRel} (cosine ${sim.toFixed(2)}); creating anyway.
+`
+        );
+      }
+    } else {
+      process.stderr.write(
+        `${c.dim(`noir: hint  ${proposedRel} looks similar to existing ${matchedRel} (cosine ${sim.toFixed(2)}).`)}
+`
+      );
+    }
+    const matchedText = safeRead(join2(root, matchedRel));
+    result.conflicts.push({
+      path: proposedRel,
+      mode: "artifact",
+      similarity: sim,
+      existingSha: sha256Hex12(matchedText ?? ""),
+      proposedSha: sha256Hex12(proposedText),
+      resolution: "preserve"
+    });
+  }
+  saveCache(root, cache);
+  return result;
+}
+async function resolveEmbedder(opts, cache) {
+  const ctx = await import("@noir-ai/context");
+  let modelId;
+  if (opts.project !== void 0) {
+    const cfg = ctx.resolveEmbedderConfig(opts.project.config.context);
+    if (cfg.kind === "none") {
+      process.stderr.write(`${c.dim("noir: semantic-dedup skipped (embedder kind=none).")}
+`);
+      return void 0;
+    }
+    modelId = cfg.kind === "local" ? cfg.model ?? ctx.DEFAULT_LOCAL_MODEL : cfg.model ?? cfg.kind;
+    if (modelId !== void 0 && cache.model !== modelId) {
+      cache.model = modelId;
+      cache.entries = {};
+    }
+  }
+  if (opts.embed !== void 0) return opts.embed;
+  if (modelId === void 0) return void 0;
+  let embed;
+  try {
+    const project = opts.project;
+    if (project === void 0) return void 0;
+    const cfg = ctx.resolveEmbedderConfig(project.config.context);
+    embed = ctx.createEmbedFn(cfg).embed;
+  } catch (e) {
     process.stderr.write(
-      `Noir daemon available at ${url}. (For HTTP clients, use this URL in .mcp.json.)
+      `${c.dim(`noir: semantic-dedup skipped (embedder unavailable: ${errMsg(e)}).`)}
 `
     );
-  } catch (err) {
+    return void 0;
+  }
+  const ping = await withTimeout(
+    embed("ping").then(() => true),
+    EMBEDDER_PING_TIMEOUT_MS
+  );
+  if (ping !== true) {
     process.stderr.write(
-      `Noir daemon unavailable (${err instanceof Error ? err.message : String(err)}); falling back to stdio.
+      `${c.dim("noir: semantic-dedup skipped (embedder load too slow or unavailable).")}
 `
     );
-    await startStdioServer({ project, transport: "stdio", daemon: false });
+    return void 0;
   }
+  return embed;
+}
+async function promptDedupAction(root, proposedRel, matchedRel, proposedText, sim) {
+  const clack = await import("@clack/prompts");
+  const choice = await clack.select({
+    message: `${proposedRel} is near-duplicate of existing ${matchedRel} (cosine ${sim.toFixed(2)}). Create anyway?`,
+    initialValue: "create",
+    options: [
+      {
+        value: "create",
+        label: "Create anyway",
+        hint: "keep the new file as-is (default)"
+      },
+      { value: "skip", label: "Skip", hint: `delete ${proposedRel}; keep ${matchedRel}` },
+      {
+        value: "replace",
+        label: "Replace existing",
+        hint: `overwrite ${matchedRel} with this content`
+      },
+      {
+        value: "mirror",
+        label: "Mirror into existing",
+        hint: `append this content to ${matchedRel}`
+      }
+    ]
+  });
+  if (clack.isCancel(choice)) return;
+  if (choice === "skip") {
+    try {
+      rmSync(join2(root, proposedRel), { force: true });
+    } catch {
+    }
+  } else if (choice === "replace") {
+    try {
+      writeFileSync(join2(root, matchedRel), proposedText, "utf8");
+    } catch {
+    }
+  } else if (choice === "mirror") {
+    try {
+      const existing = readFileSync2(join2(root, matchedRel), "utf8");
+      writeFileSync(
+        join2(root, matchedRel),
+        `${existing}
+
+<!-- mirrored from ${proposedRel} -->
+${proposedText}
+`,
+        "utf8"
+      );
+    } catch {
+    }
+  }
+}
+function emptyCache() {
+  return { version: DEDUP_CACHE_VERSION, model: "", entries: {} };
+}
+function cachePath(root) {
+  return join2(root, ".noir", "dedup-cache.json");
+}
+function loadCache(root) {
+  try {
+    const raw = readFileSync2(cachePath(root), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== DEDUP_CACHE_VERSION) return emptyCache();
+    if (typeof parsed.entries !== "object" || parsed.entries === null) return emptyCache();
+    return {
+      version: DEDUP_CACHE_VERSION,
+      model: typeof parsed.model === "string" ? parsed.model : "",
+      entries: parsed.entries
+    };
+  } catch {
+    return emptyCache();
+  }
+}
+function saveCache(root, cache) {
+  try {
+    mkdirSync(join2(root, ".noir"), { recursive: true });
+    writeFileSync(cachePath(root), JSON.stringify(cache), "utf8");
+  } catch {
+  }
+}
+function makeCachedEmbed(cache, embed) {
+  return async (text) => {
+    const key = createHash("sha256").update(text, "utf8").digest("hex");
+    const cached = cache.entries[key];
+    if (cached !== void 0) return Float32Array.from(cached.v);
+    const v = await embed(text);
+    cache.entries[key] = { v: Array.from(v) };
+    return v;
+  };
+}
+function sha256Hex12(text) {
+  return createHash("sha256").update(text, "utf8").digest("hex").slice(0, 12);
+}
+function safeRead(abs) {
+  try {
+    return readFileSync2(abs, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function withTimeout(p, ms) {
+  return new Promise((resolve) => {
+    const t = setTimeout(() => resolve(void 0), ms);
+    p.then(
+      (v) => {
+        clearTimeout(t);
+        resolve(v);
+      },
+      () => {
+        clearTimeout(t);
+        resolve(void 0);
+      }
+    );
+  });
+}
+function errMsg(e) {
+  return e instanceof Error ? e.message : String(e);
 }
 
 export {
+  c,
+  badge,
+  useColor,
+  accessibleMode,
+  EXIT,
+  NoirCliError,
+  isInteractive,
+  resolveInteractive,
+  json,
+  log,
+  info,
+  warn,
+  tip,
+  table,
+  definitionList,
+  fail,
+  requireInteractive,
+  inferExitCode,
+  handleError,
   doctor,
-  serve
+  buildConflictOpts,
+  checkWritePathDedup
 };
-//# sourceMappingURL=chunk-3QMQXBII.js.map
+//# sourceMappingURL=chunk-YES5UCU5.js.map