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

package/dist/tui/chunk-YNEBQJXA.js

@@ -0,0 +1,1243 @@
+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/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" };
+  }
+  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";
+
+// src/commands/doctor.ts
+import { spawnSync } from "child_process";
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { dirname, join, relative } from "path";
+import { fileURLToPath } from "url";
+import { resolveAdapter } from "@noir-ai/adapters";
+import { loadProjectInfo, NOIR_VERSION, paths } from "@noir-ai/core";
+import { CURRENT_SCAFFOLD_VERSION, readScaffoldVersion } from "@noir-ai/create";
+import { pidAlive, readDaemonRecord } from "@noir-ai/daemon";
+import { resolveModelConfig } from "@noir-ai/model";
+async function probeOnnx() {
+  try {
+    const spec = "onnxruntime-node";
+    await import(spec);
+    return { ok: true, reason: "loadable" };
+  } catch (e) {
+    return { ok: false, reason: e instanceof Error ? e.message : String(e) };
+  }
+}
+function describeOnnx(o) {
+  if (o.ok) return "loadable";
+  if (/Cannot find (module|package)/i.test(o.reason)) {
+    return "not resolvable from CLI probe (best-effort)";
+  }
+  const r = o.reason.length > 60 ? `${o.reason.slice(0, 59)}\u2026` : o.reason;
+  return `probe failed: ${r}`;
+}
+function fmtUptime(sec) {
+  if (!Number.isFinite(sec) || sec < 0) return "unknown";
+  if (sec < 60) return `${sec}s`;
+  if (sec < 3600) return `${Math.floor(sec / 60)}m ${sec % 60}s`;
+  return `${Math.floor(sec / 3600)}h ${Math.floor(sec % 3600 / 60)}m`;
+}
+function msg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+async function checkRuntime(checks) {
+  checks.push({
+    name: "runtime",
+    status: "ok",
+    detail: `noir ${NOIR_VERSION} \xB7 node ${process.version} \xB7 ${process.platform}`
+  });
+}
+function checkConfig(root) {
+  const configPath = paths.config(root);
+  if (!existsSync(configPath)) {
+    return {
+      project: void 0,
+      result: {
+        name: "config",
+        status: "warn",
+        detail: `no .noir/config.yml in ${root} \u2014 run \`noir init\``
+      }
+    };
+  }
+  try {
+    const project = loadProjectInfo(root);
+    return {
+      project,
+      result: {
+        name: "config",
+        status: "ok",
+        detail: `host=${project.config.host} \xB7 mode=${project.config.mode}`
+      }
+    };
+  } catch (e) {
+    return {
+      project: void 0,
+      result: { name: "config", status: "fail", detail: `config parse error: ${msg(e)}` }
+    };
+  }
+}
+async function checkDaemon(checks) {
+  const rec = readDaemonRecord();
+  if (!rec) {
+    checks.push({
+      name: "daemon",
+      status: "warn",
+      detail: "not running (start with `noir daemon start`)"
+    });
+    return;
+  }
+  if (!pidAlive(rec.pid)) {
+    checks.push({
+      name: "daemon",
+      status: "warn",
+      detail: `stale record (pid ${rec.pid} not alive)`
+    });
+    return;
+  }
+  try {
+    const res = await fetch(`http://127.0.0.1:${rec.port}/health`);
+    const body = res.status === 200 ? await res.json() : null;
+    if (body && body.ok === true) {
+      checks.push({
+        name: "daemon",
+        status: "ok",
+        detail: `running (pid ${rec.pid}, port ${rec.port}, up ${fmtUptime(body.uptimeSec ?? 0)})`
+      });
+      return;
+    }
+    checks.push({
+      name: "daemon",
+      status: "warn",
+      detail: `record present but /health unreachable on port ${rec.port}`
+    });
+  } catch {
+    checks.push({
+      name: "daemon",
+      status: "warn",
+      detail: `record present but /health unreachable on port ${rec.port}`
+    });
+  }
+}
+async function checkNativeDeps(checks) {
+  const { vecAvailability } = await import("@noir-ai/store");
+  const vec = vecAvailability();
+  const onnx = await probeOnnx();
+  const vecOk = vec.ok === true;
+  const onnxOk = onnx.ok === true;
+  const status = vecOk ? onnxOk ? "ok" : "warn" : "fail";
+  checks.push({
+    name: "native deps",
+    status,
+    detail: `better-sqlite3+sqlite-vec: ${vecOk ? "loadable" : vec.ok === false ? vec.reason : "unknown"} \xB7 onnxruntime-node: ${describeOnnx(onnx)}`
+  });
+  return { vecOk };
+}
+async function checkStore(checks, project, root) {
+  if (!project) {
+    checks.push({ name: "store", status: "warn", detail: "skipped \u2014 not initialized" });
+    return;
+  }
+  const dbPath = paths.storeDb(root, project.id);
+  if (!existsSync(dbPath)) {
+    checks.push({
+      name: "store",
+      status: "warn",
+      detail: `not created yet \u2014 the store DB is created when the daemon first runs (\`noir daemon start\` or index content); expected at ${dbPath}`
+    });
+    return;
+  }
+  const { openStore } = await import("@noir-ai/store");
+  let store;
+  try {
+    store = await openStore({ projectId: project.id, root, readonly: true });
+    checks.push({
+      name: "store",
+      status: "ok",
+      detail: `opens readonly (db: ${paths.storeDb(root, project.id)})`
+    });
+  } catch (e) {
+    checks.push({ name: "store", status: "fail", detail: `open failed: ${msg(e)}` });
+  } finally {
+    if (store) {
+      try {
+        await Promise.resolve(store.close());
+      } catch {
+      }
+    }
+  }
+}
+function checkEmbedder(checks, project, vecOk) {
+  if (!project) {
+    checks.push({ name: "embedder", status: "warn", detail: "skipped \u2014 not initialized" });
+    return;
+  }
+  const emb = project.config.context.embedder;
+  const kind = emb.kind;
+  const model = typeof emb.model === "string" && emb.model.length > 0 ? emb.model : "<unset>";
+  if (kind === "none") {
+    checks.push({
+      name: "embedder",
+      status: "ok",
+      detail: `kind=none (BM25-only) \xB7 dim=${emb.dim}`
+    });
+    return;
+  }
+  if (!vecOk) {
+    checks.push({
+      name: "embedder",
+      status: "warn",
+      detail: `${kind}/${model} (${emb.dim}-dim) configured but vec native layer unavailable \u2014 search degrades to BM25`
+    });
+    return;
+  }
+  checks.push({
+    name: "embedder",
+    status: "ok",
+    detail: `${kind}/${model} (${emb.dim}-dim) \xB7 vec backend available`
+  });
+}
+function checkProvider(checks, project) {
+  if (!project) {
+    checks.push({ name: "provider", status: "warn", detail: "skipped \u2014 not initialized" });
+    return;
+  }
+  const resolved = resolveModelConfig(project.config.model);
+  const names = Object.keys(resolved.providers);
+  if (names.length === 0) {
+    checks.push({
+      name: "provider",
+      status: "ok",
+      detail: "none configured (offline mode; drafting degrades to templates)"
+    });
+    return;
+  }
+  const parts = [];
+  let missing = false;
+  for (const name of names) {
+    const p = resolved.providers[name];
+    if (!p) continue;
+    const key = p.hasKey ? "key present" : p.apiKeyEnv ? `missing ${p.apiKeyEnv}` : "anonymous";
+    if (!p.hasKey && p.apiKeyEnv) missing = true;
+    parts.push(`${name}/${p.model ?? "?"} (${key})`);
+  }
+  checks.push({
+    name: "provider",
+    status: missing ? "warn" : "ok",
+    detail: parts.join(" \xB7 ")
+  });
+}
+function checkScaffoldVersion(checks, root) {
+  const onDisk = readScaffoldVersion(root);
+  const current = CURRENT_SCAFFOLD_VERSION;
+  const drift = onDisk !== null && onDisk !== current;
+  const status = onDisk === null || drift ? "warn" : "ok";
+  const detail = onDisk === null ? "no .noir/scaffold-version stamp (run `noir init`)" : drift ? `on-disk ${onDisk} \u2260 current ${current} (run \`noir init --upgrade\`)` : `${onDisk} (up to date)`;
+  checks.push({ name: "scaffold version", status, detail });
+  return { onDisk, current, drift };
+}
+function checkRulesMdBudget(checks, root, project) {
+  if (!project) {
+    checks.push({ name: "rules budget", status: "warn", detail: "skipped \u2014 not initialized" });
+    return null;
+  }
+  const rulesPath = paths.rulesMd(root);
+  if (!existsSync(rulesPath)) {
+    checks.push({
+      name: "rules budget",
+      status: "ok",
+      detail: "no .noir/rules/RULES.md"
+    });
+    return null;
+  }
+  let content;
+  try {
+    content = readFileSync(rulesPath, "utf8");
+  } catch (e) {
+    checks.push({
+      name: "rules budget",
+      status: "warn",
+      detail: `RULES.md unreadable: ${msg(e)}`
+    });
+    return null;
+  }
+  const bytes = Buffer.byteLength(content, "utf8");
+  const lineCount = content.length === 0 ? 0 : content.split("\n").length - (content.endsWith("\n") ? 1 : 0);
+  const lengthBudgetKb = project.config.rules.lengthBudgetKb;
+  const budgetBytes = lengthBudgetKb * 1024;
+  const maxLines = 150;
+  const overBytes = bytes > budgetBytes;
+  const overLines = lineCount > maxLines;
+  const over = overBytes || overLines;
+  const status = over ? "warn" : "ok";
+  const kb = (n) => (n / 1024).toFixed(1);
+  const detail = over ? `OVER: ${kb(bytes)} KB / ${lengthBudgetKb} KB \xB7 ${lineCount}/${maxLines} lines \u2014 trim RULES.md (failure-backed clauses only) or raise rules.lengthBudgetKb` : `${kb(bytes)} KB / ${lengthBudgetKb} KB \xB7 ${lineCount}/${maxLines} lines (within budget)`;
+  checks.push({ name: "rules budget", status, detail });
+  return {
+    onDisk: { bytes, lines: lineCount },
+    budget: { kb: lengthBudgetKb, maxLines },
+    over
+  };
+}
+function summarize(checks) {
+  let ok = 0;
+  let warnN = 0;
+  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: fail2 };
+}
+function checkHostArtifacts(checks, root, project) {
+  if (!project) {
+    checks.push({ name: "host artifacts", status: "warn", detail: "skipped \u2014 not initialized" });
+    return null;
+  }
+  const host = project.config.host;
+  const adapter = resolveAdapter(host);
+  const ectx = { root };
+  const expected = [];
+  const emitsAgentsMd = host === "agents-md" || host === "cursor" || host === "opencode";
+  if (emitsAgentsMd) {
+    expected.push(relOr(adapter.agentsMdPath?.(ectx) ?? "AGENTS.md", root));
+  }
+  if (host === "claude") expected.push("CLAUDE.md");
+  else if (host === "gemini") expected.push("GEMINI.md");
+  expected.push(relOr(adapter.mcpConfigPath?.(ectx) ?? ".mcp.json", root));
+  const missing = expected.filter((p) => !existsSync(joinRoot(root, p)));
+  const status = missing.length === 0 ? "ok" : "warn";
+  const detail = missing.length === 0 ? `host=${host} \xB7 all ${expected.length} primary artifacts present` : `host=${host} \xB7 missing ${missing.join(", ")} (run \`noir sync\` to restore)`;
+  checks.push({ name: "host artifacts", status, detail });
+  return { active: host, expected, missing };
+}
+function checkNestedNoir(checks, root) {
+  const candidates = [
+    ".noir/.noir",
+    ".noir/CLAUDE.md",
+    ".noir/.mcp.json",
+    ".noir/.claude",
+    ".noir/.gitignore",
+    ".noir/.dockerignore",
+    ".noir/.npmignore",
+    ".noir/.prettierignore"
+  ];
+  const found = candidates.filter((rel) => existsSync(join(root, rel)));
+  const detected = found.length > 0;
+  checks.push({
+    name: "nested .noir",
+    status: detected ? "warn" : "ok",
+    detail: detected ? `nested Noir artifacts inside .noir/ (${found.join(", ")}) \u2014 likely from running \`noir init\` inside .noir/. Remove them; the real project is at ${root}.` : "no nested .noir/ artifacts"
+  });
+  return { detected, paths: found };
+}
+function collectDedupCandidates(root) {
+  const rels = ["CLAUDE.md", "AGENTS.md", "GEMINI.md", ".noir/rules/RULES.md"];
+  const out = [];
+  for (const rel of rels) {
+    const abs = join(root, rel);
+    if (!existsSync(abs)) continue;
+    let text;
+    try {
+      text = readFileSync(abs, "utf8");
+    } catch {
+      continue;
+    }
+    if (text.trim().length === 0) continue;
+    out.push({ path: rel, text });
+  }
+  return out;
+}
+async function checkSemanticDupDoctor(checks, root, project, opts = {}) {
+  if (!project) {
+    checks.push({ name: "semantic dup", status: "warn", detail: "skipped \u2014 not initialized" });
+    return;
+  }
+  const candidates = collectDedupCandidates(root);
+  if (candidates.length < 2) {
+    checks.push({
+      name: "semantic dup",
+      status: "ok",
+      detail: `${candidates.length} candidate file(s); nothing to compare`
+    });
+    return;
+  }
+  const ctx = await import("@noir-ai/context");
+  let embed = opts.embed;
+  if (!embed) {
+    const cfg = ctx.resolveEmbedderConfig(project.config.context);
+    if (cfg.kind === "none") {
+      checks.push({
+        name: "semantic dup",
+        status: "warn",
+        detail: "embedder kind=none \u2014 set context.embedder.kind=local to enable semantic dedup"
+      });
+      return;
+    }
+    try {
+      embed = ctx.createEmbedFn(cfg).embed;
+    } catch (e) {
+      checks.push({
+        name: "semantic dup",
+        status: "warn",
+        detail: `embedder unavailable \u2014 skipped (${msg(e)})`
+      });
+      return;
+    }
+  }
+  if (!embed) return;
+  const pairs = await ctx.findSemanticDuplicates(candidates, embed, ctx.DEFAULT_DUP_THRESHOLD);
+  checks.push({
+    name: "semantic dup",
+    status: pairs.length > 0 ? "warn" : "ok",
+    detail: pairs.length === 0 ? `no near-duplicates across ${candidates.length} file(s)` : `${pairs.length} near-duplicate pair${pairs.length === 1 ? "" : "s"}: ${pairs.map((p) => `${p.a}\u2248${p.b} (${p.similarity.toFixed(2)})`).join("; ")}`
+  });
+}
+function resolveWorkspacePackagesDir() {
+  let here = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 8; i++) {
+    const pkgPath = join(here, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        if (pkg.name === "@noir-ai/cli") {
+          const packagesDir = dirname(here);
+          if (existsSync(join(dirname(packagesDir), "pnpm-workspace.yaml"))) {
+            return packagesDir;
+          }
+          return null;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(here);
+    if (parent === here) break;
+    here = parent;
+  }
+  return null;
+}
+var SEMVER_ISH = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+function npmPackDryRun(cliPkgDir) {
+  const probe = spawnSync("npm", ["--version"], { encoding: "utf8", shell: true });
+  if (probe.status !== 0 || probe.error) {
+    return { error: probe.error ? probe.error.message : "npm not on PATH" };
+  }
+  const res = spawnSync("npm", ["pack", "--dry-run"], {
+    cwd: cliPkgDir,
+    encoding: "utf8",
+    shell: true
+  });
+  if (res.status !== 0 || res.error) {
+    return { error: res.error ? res.error.message : `npm pack exited ${res.status ?? "?"}` };
+  }
+  const out = `${res.stdout ?? ""}
+${res.stderr ?? ""}`;
+  const totalMatch = out.match(/total files:\s*(\d+)/i);
+  const fileCount = totalMatch?.[1] ? Number.parseInt(totalMatch[1], 10) : null;
+  const distIncluded = /\bdist\//.test(out);
+  return { fileCount, distIncluded };
+}
+function checkPublish(checks, packagesDir, opts = {}) {
+  if (packagesDir === null) {
+    checks.push({
+      name: "publish",
+      status: "ok",
+      detail: "skipped \u2014 not a monorepo checkout (no packages/* workspace)"
+    });
+    return null;
+  }
+  let entries = [];
+  try {
+    entries = readdirSync(packagesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch (e) {
+    checks.push({
+      name: "publish",
+      status: "warn",
+      detail: `could not read ${packagesDir}: ${msg(e)}`
+    });
+    return { checked: 0, issues: [`unreadable packages dir: ${msg(e)}`] };
+  }
+  const issues = [];
+  let checked = 0;
+  let cliDir = null;
+  for (const name of entries) {
+    const pkgPath = join(packagesDir, name, "package.json");
+    if (!existsSync(pkgPath)) continue;
+    let pkg;
+    try {
+      pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    } catch (e) {
+      issues.push(`${name}/package.json: unparseable (${msg(e)})`);
+      checked++;
+      continue;
+    }
+    checked++;
+    const pkgName = typeof pkg.name === "string" ? pkg.name : "";
+    if (!pkgName.startsWith("@noir-ai/")) {
+      issues.push(`${name}/package.json: name '${pkgName}' is not @noir-ai/*`);
+    }
+    const version = typeof pkg.version === "string" ? pkg.version : "";
+    if (!SEMVER_ISH.test(version)) {
+      issues.push(`${name}/package.json: version '${version}' is not semver`);
+    }
+    if (!Array.isArray(pkg.files) || pkg.files.length === 0) {
+      issues.push(`${name}/package.json: files missing or empty`);
+    }
+    if (pkgName === "@noir-ai/cli") {
+      if (pkg.bin == null || typeof pkg.bin === "object" && Object.keys(pkg.bin).length === 0) {
+        issues.push(`${name}/package.json: bin missing (cli package must declare a bin)`);
+      }
+      cliDir = join(packagesDir, name);
+    }
+  }
+  let packNote = "";
+  if (cliDir && opts.skipNpmPack !== true) {
+    const pack = npmPackDryRun(cliDir);
+    if ("error" in pack) {
+      packNote = ` \xB7 npm pack skipped (${pack.error})`;
+    } else {
+      const count = pack.fileCount == null ? "?" : String(pack.fileCount);
+      const dist = pack.distIncluded ? "dist/ included" : "dist/ NOT in tarball";
+      packNote = ` \xB7 npm pack: ${count} files, ${dist}`;
+      if (pack.distIncluded === false) {
+        issues.push("cli npm pack --dry-run: dist/ absent from the tarball");
+      }
+    }
+  }
+  const status = issues.length > 0 ? "warn" : "ok";
+  const detail = issues.length === 0 ? `${checked}/${entries.length} packages publish-ready${packNote}` : `${issues.length} issue${issues.length === 1 ? "" : "s"} across ${checked} package${checked === 1 ? "" : "s"}${packNote}`;
+  checks.push({ name: "publish", status, detail });
+  return { checked, issues };
+}
+function relOr(abs, root) {
+  const posix = abs.replace(/\\/g, "/");
+  if (posix.startsWith("/")) {
+    const rel = relative(root, abs).replace(/\\/g, "/");
+    if (rel.length === 0 || rel.startsWith("..") || rel.startsWith("/")) {
+      throw new Error(`doctor: host path '${abs}' is not under root '${root}'`);
+    }
+    return rel;
+  }
+  if (posix.split("/").some((seg) => seg === "..")) {
+    throw new Error(`doctor: host path '${abs}' escapes root '${root}'`);
+  }
+  return posix;
+}
+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((c2) => ({
+      Check: c2.name,
+      Status: severityBadge(c2.status),
+      Detail: c2.detail
+    })),
+    ["Check", "Status", "Detail"],
+    opts
+  );
+  const { ok, warn: warnN, fail: fail2 } = payload.summary;
+  if (fail2 > 0) {
+    error(
+      `${fail2} critical check${fail2 === 1 ? "" : "s"} failed (${warnN} warning${warnN === 1 ? "" : "s"}, ${ok} ok)`,
+      opts
+    );
+  } else if (warnN > 0) {
+    warn(`all critical checks passed (${warnN} warning${warnN === 1 ? "" : "s"}, ${ok} ok)`, opts);
+  } else {
+    success(`all ${ok} check${ok === 1 ? "" : "s"} passed`, opts);
+  }
+}
+async function doctor(opts = {}) {
+  const root = process.cwd();
+  const checks = [];
+  await checkRuntime(checks);
+  const { project, result: configResult } = checkConfig(root);
+  checks.push(configResult);
+  await checkDaemon(checks);
+  const { vecOk } = await checkNativeDeps(checks);
+  await checkStore(checks, project, root);
+  checkEmbedder(checks, project, vecOk);
+  checkProvider(checks, project);
+  const scaffold = checkScaffoldVersion(checks, root);
+  const rules = checkRulesMdBudget(checks, root, project);
+  const host = checkHostArtifacts(checks, root, project);
+  checkNestedNoir(checks, root);
+  if (opts.dedup === true) {
+    await checkSemanticDupDoctor(checks, root, project);
+  }
+  const publish = checkPublish(checks, resolveWorkspacePackagesDir());
+  const summary = summarize(checks);
+  const payload = {
+    noir: NOIR_VERSION,
+    checks,
+    summary,
+    scaffold,
+    rules,
+    host,
+    publish
+  };
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data: payload })}
+`);
+  } else {
+    renderHuman(payload, opts);
+  }
+  if (summary.fail > 0) {
+    throw new NoirCliError(
+      EXIT.ERROR,
+      opts.json === true ? "" : `noir doctor: ${summary.fail} critical check(s) failed`
+    );
+  }
+}
+
+// src/dedup-write.ts
+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(
+      `${c.dim(`noir: semantic-dedup skipped (embedder unavailable: ${errMsg(e)}).`)}
+`
+    );
+    return void 0;
+  }
+  const ping = await withTimeout(
+    embed("ping").then(() => true),
+    EMBEDDER_PING_TIMEOUT_MS
+  );
+  if (ping !== true) {
+    process.stderr.write(
+      `${c.dim("noir: semantic-dedup skipped (embedder load too slow or unavailable).")}
+`
+    );
+    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,
+  terminalWidth,
+  EXIT,
+  NoirCliError,
+  isInteractive,
+  resolveInteractive,
+  json,
+  log,
+  info,
+  warn,
+  tip,
+  table,
+  definitionList,
+  fail,
+  requireInteractive,
+  handleError,
+  doctor,
+  buildConflictOpts,
+  checkWritePathDedup
+};
+//# sourceMappingURL=chunk-YNEBQJXA.js.map