@noir-ai/cli 1.11.2-beta.1 → 1.12.0-beta.1

package/dist/chunk-CT6TYLHN.js

@@ -1,1105 +0,0 @@
-#!/usr/bin/env node
-import {
-  EXIT,
-  NoirCliError,
-  badge,
-  c,
-  error,
-  isInteractive,
-  log,
-  resolveInteractive,
-  success,
-  table,
-  warn
-} from "./chunk-I2R55ACD.js";
-
-// 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 {
-  detectActiveMethod,
-  latestVersionFromCache,
-  loadProjectInfo,
-  NOIR_VERSION,
-  paths,
-  readInstallRecord,
-  readUpdateCache
-} 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 buildInstallCheck(opts) {
-  const { method, version, latestKnown } = opts;
-  const parts = [`method=${method}`];
-  if (version) parts.push(`v${version}`);
-  const advisory = [];
-  if (method !== "native") advisory.push("native recommended");
-  if (latestKnown && version && latestKnown !== version) advisory.push("update available");
-  const status = advisory.length > 0 ? "warn" : "ok";
-  if (advisory.length > 0) parts.push(advisory.join(" + "));
-  return {
-    name: "install",
-    status,
-    detail: parts.join(" \xB7 "),
-    method,
-    installedVersion: version,
-    latestKnown
-  };
-}
-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 fail = 0;
-  for (const c2 of checks) {
-    if (c2.status === "ok") ok++;
-    else if (c2.status === "warn") warnN++;
-    else fail++;
-  }
-  return { ok, warn: warnN, fail };
-}
-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 } = payload.summary;
-  if (fail > 0) {
-    error(
-      `${fail} critical check${fail === 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 scaffold2 = 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 installCheck = buildInstallCheck({
-    method: detectActiveMethod(),
-    version: readInstallRecord()?.version ?? null,
-    latestKnown: latestVersionFromCache(readUpdateCache(), "latest")
-  });
-  checks.push(installCheck);
-  const summary = summarize(checks);
-  const payload = {
-    noir: NOIR_VERSION,
-    checks,
-    summary,
-    scaffold: scaffold2,
-    rules,
-    host,
-    publish,
-    install: {
-      method: installCheck.method,
-      installedVersion: installCheck.installedVersion,
-      latestKnown: installCheck.latestKnown
-    }
-  };
-  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/conflict.ts
-import {
-  lineDiff
-} from "@noir-ai/create";
-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 lines = lineDiff(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";
-  const supportsApplyToAll = mode !== "managedBlock" && mode !== "managedBlocks";
-  if (supportsApplyToAll) {
-    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(
-      `${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);
-}
-
-// src/init.ts
-import { resolveAdapter as resolveAdapter2 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo2 } from "@noir-ai/core";
-import { scaffold } from "@noir-ai/create";
-import { emitSkillsToDir } from "@noir-ai/skills";
-async function init(root, opts) {
-  assertTransportUrl(opts);
-  const host = opts.host ?? "claude";
-  const interactive = resolveInteractive();
-  const conflictOpts = buildConflictOpts({ force: opts.force, interactive });
-  const dryRun = opts.dryRun === true || opts.preview === true;
-  const res = await scaffold({
-    root,
-    mode: "init",
-    host,
-    transport: opts.transport,
-    interactive,
-    ...opts.url !== void 0 ? { url: opts.url } : {},
-    ...opts.upgrade === true ? { upgrade: true } : {},
-    ...opts.force === true ? { force: true } : {},
-    ...dryRun ? { dryRun: true } : {},
-    ...conflictOpts
-  });
-  if (dryRun) {
-    reportPlannedWrites(res);
-    return res;
-  }
-  if (res.noop) return res;
-  await emitHostSkills(root, host, conflictOpts, interactive);
-  let projectInfo;
-  try {
-    projectInfo = loadProjectInfo2(root);
-  } catch {
-    projectInfo = void 0;
-  }
-  const dedup = await checkWritePathDedup(root, res, { interactive, project: projectInfo });
-  if (dedup.conflicts.length > 0) res.conflicts.push(...dedup.conflicts);
-  process.stderr.write(
-    `Noir initialized in ${root} (host: ${host}, transport: ${opts.transport}).
-`
-  );
-  process.stderr.write(
-    "Next: run `noir` to open the home menu (or `noir status` for a snapshot).\n"
-  );
-  return res;
-}
-function reportPlannedWrites(res) {
-  log("Dry run \u2014 no files were written.");
-  if (res.written.length > 0) {
-    log("Planned writes:");
-    for (const p of res.written) log(`  ${p}`);
-  }
-  if (res.skipped.length > 0) {
-    log("Would leave as-is (already present):");
-    for (const p of res.skipped) log(`  ${p}`);
-  }
-  if (res.identical.length > 0) {
-    log("Would rewrite (byte-identical, no-op):");
-    for (const p of res.identical) log(`  ${p}`);
-  }
-}
-async function emitHostSkills(root, host, conflictOpts, interactive) {
-  const adapter = resolveAdapter2(host);
-  const skillsDir = adapter.skillsDir?.({ root });
-  if (skillsDir === void 0) {
-    process.stderr.write(`host '${host}' has no skill emitter; skipping skills
-`);
-    return;
-  }
-  const target = host;
-  const skillOpts = {
-    includeIntegrations: true,
-    target,
-    conflictPolicy: conflictOpts.conflictPolicy,
-    interactive
-  };
-  if (conflictOpts.onConflict !== void 0) {
-    skillOpts.onConflict = conflictOpts.onConflict;
-  }
-  const summary = await emitSkillsToDir(skillsDir, skillOpts);
-  const relDir = skillsDir.replace(`${root}/`, "");
-  process.stderr.write(
-    `Emitted ${summary.emitted.length} Noir skills to ${relDir}/ (target: ${target}).
-`
-  );
-}
-function assertTransportUrl(opts) {
-  if (opts.transport === "streamable-http" && opts.url === void 0) {
-    throw new Error("--transport streamable-http requires --url");
-  }
-  if (opts.url !== void 0) {
-    assertLocalhostUrl(opts.url);
-  }
-}
-function assertLocalhostUrl(raw) {
-  let url;
-  try {
-    url = new URL(raw);
-  } catch {
-    throw new Error(`Invalid URL: ${raw}`);
-  }
-  if (!["http:", "https:"].includes(url.protocol)) {
-    throw new Error("Only http/https URLs are supported");
-  }
-  if (!["localhost", "127.0.0.1", "::1"].includes(url.hostname)) {
-    throw new Error(`Only localhost URLs are supported (got ${url.hostname})`);
-  }
-}
-
-export {
-  doctor,
-  buildConflictOpts,
-  checkWritePathDedup,
-  init,
-  reportPlannedWrites,
-  assertTransportUrl
-};
-//# sourceMappingURL=chunk-CT6TYLHN.js.map