@neat.is/core 0.2.5

package/dist/cli.js

@@ -0,0 +1,1175 @@
+#!/usr/bin/env node
+import {
+  ProjectNameCollisionError,
+  addProject,
+  listProjects,
+  removeProject,
+  setStatus
+} from "./chunk-WX55TLUT.js";
+import {
+  buildSearchIndex
+} from "./chunk-XOOCA5T7.js";
+import {
+  buildApi
+} from "./chunk-T2U4U256.js";
+import {
+  DEFAULT_PROJECT,
+  PolicyViolationsLog,
+  Projects,
+  addCallEdges,
+  addConfigNodes,
+  addDatabasesAndCompat,
+  addInfra,
+  addServiceAliases,
+  addServiceNodes,
+  discoverServices,
+  ensureCompatLoaded,
+  evaluateAllPolicies,
+  extractFromDirectory,
+  getGraph,
+  loadGraphFromDisk,
+  loadPolicyFile,
+  makeErrorSpanWriter,
+  makeSpanHandler,
+  pathsForProject,
+  promoteFrontierNodes,
+  resetGraph,
+  saveGraphToDisk,
+  startPersistLoop,
+  startStalenessLoop
+} from "./chunk-6SFEITLJ.js";
+import {
+  buildOtelReceiver,
+  startOtelGrpcReceiver
+} from "./chunk-I5IMCXRO.js";
+
+// src/cli.ts
+import path4 from "path";
+import { promises as fs3 } from "fs";
+
+// src/watch.ts
+import path from "path";
+import chokidar from "chokidar";
+
+// src/extract/retire.ts
+import { Provenance } from "@neat.is/types";
+function retireEdgesByFile(graph, file) {
+  const normalized = file.split("\\").join("/");
+  const toDrop = [];
+  graph.forEachEdge((id, attrs) => {
+    const edge = attrs;
+    if (edge.provenance !== Provenance.EXTRACTED) return;
+    if (!edge.evidence?.file) return;
+    if (edge.evidence.file === normalized) toDrop.push(id);
+  });
+  for (const id of toDrop) graph.dropEdge(id);
+  return toDrop.length;
+}
+
+// src/watch.ts
+var ALL_PHASES = [
+  "services",
+  "aliases",
+  "databases",
+  "configs",
+  "calls",
+  "infra"
+];
+function classifyChange(relPath) {
+  const phases = /* @__PURE__ */ new Set();
+  const base = path.basename(relPath).toLowerCase();
+  const segments = relPath.split(path.sep).map((s) => s.toLowerCase());
+  if (base === "package.json" || base === "requirements.txt" || base === "pyproject.toml" || base === "setup.py") {
+    phases.add("services");
+    phases.add("aliases");
+    phases.add("databases");
+  }
+  if (base === ".env" || base.startsWith(".env.") || base === "schema.prisma" || /^knexfile\.(?:js|ts|cjs|mjs)$/.test(base) || /^ormconfig\.(?:js|ts|json|ya?ml)$/.test(base)) {
+    phases.add("databases");
+    phases.add("configs");
+  }
+  if (base === "dockerfile" || /^docker-compose.*\.ya?ml$/.test(base) || base.endsWith(".tf") || segments.includes("k8s") || segments.includes("kustomize") || segments.includes("manifests")) {
+    phases.add("infra");
+    phases.add("aliases");
+  }
+  if (/\.(?:js|jsx|mjs|cjs|ts|tsx|py)$/.test(base)) {
+    phases.add("calls");
+  }
+  if (/\.ya?ml$/.test(base) && !/^docker-compose.*\.ya?ml$/.test(base)) {
+    phases.add("databases");
+    phases.add("configs");
+  }
+  return phases;
+}
+async function runExtractPhases(graph, scanPath, phases) {
+  const started = Date.now();
+  await ensureCompatLoaded();
+  const services = await discoverServices(scanPath);
+  let nodesAdded = 0;
+  let edgesAdded = 0;
+  if (phases.has("services")) {
+    nodesAdded += addServiceNodes(graph, services);
+  }
+  if (phases.has("aliases")) {
+    await addServiceAliases(graph, scanPath, services);
+  }
+  if (phases.has("databases")) {
+    const r = await addDatabasesAndCompat(graph, services, scanPath);
+    nodesAdded += r.nodesAdded;
+    edgesAdded += r.edgesAdded;
+  }
+  if (phases.has("configs")) {
+    const r = await addConfigNodes(graph, services, scanPath);
+    nodesAdded += r.nodesAdded;
+    edgesAdded += r.edgesAdded;
+  }
+  if (phases.has("calls")) {
+    const r = await addCallEdges(graph, services);
+    nodesAdded += r.nodesAdded;
+    edgesAdded += r.edgesAdded;
+  }
+  if (phases.has("infra")) {
+    const r = await addInfra(graph, scanPath, services);
+    nodesAdded += r.nodesAdded;
+    edgesAdded += r.edgesAdded;
+  }
+  const frontiersPromoted = promoteFrontierNodes(graph);
+  return {
+    phases: ALL_PHASES.filter((p) => phases.has(p)),
+    nodesAdded,
+    edgesAdded,
+    frontiersPromoted,
+    durationMs: Date.now() - started
+  };
+}
+var IGNORED_WATCH_PATHS = [
+  /(?:^|[\\/])node_modules[\\/]/,
+  /(?:^|[\\/])\.git[\\/]/,
+  /(?:^|[\\/])dist[\\/]/,
+  /(?:^|[\\/])build[\\/]/,
+  /(?:^|[\\/])\.turbo[\\/]/,
+  /(?:^|[\\/])\.next[\\/]/,
+  /(?:^|[\\/])neat-out[\\/]/,
+  /[\\/]?\.DS_Store$/
+];
+function shouldIgnore(absPath) {
+  return IGNORED_WATCH_PATHS.some((re) => re.test(absPath));
+}
+async function startWatch(graph, opts) {
+  const debounceMs = opts.debounceMs ?? 1e3;
+  await loadGraphFromDisk(graph, opts.outPath);
+  const policyFilePath = path.join(opts.scanPath, "policy.json");
+  const policyViolationsPath = path.join(path.dirname(opts.outPath), "policy-violations.ndjson");
+  let policies = [];
+  try {
+    policies = await loadPolicyFile(policyFilePath);
+    if (policies.length > 0) {
+      console.log(`policies: loaded ${policies.length} from ${policyFilePath}`);
+    }
+  } catch (err) {
+    console.warn(`policies: failed to load ${policyFilePath} \u2014 ${err.message}`);
+  }
+  const policyLog = new PolicyViolationsLog(policyViolationsPath);
+  const onPolicyTrigger = async (g) => {
+    if (policies.length === 0) return;
+    try {
+      const violations = evaluateAllPolicies(g, policies, { now: () => Date.now() });
+      for (const v of violations) await policyLog.append(v);
+    } catch (err) {
+      console.warn(`policies: evaluation failed \u2014 ${err.message}`);
+    }
+  };
+  const initial = await runExtractPhases(graph, opts.scanPath, new Set(ALL_PHASES));
+  console.log(
+    `extract: ${initial.nodesAdded} new nodes, ${initial.edgesAdded} new edges (graph total ${graph.order}/${graph.size})`
+  );
+  await onPolicyTrigger(graph);
+  const stopPersist = startPersistLoop(graph, opts.outPath);
+  const stopStaleness = startStalenessLoop(graph, {
+    staleEventsPath: opts.staleEventsPath,
+    onPolicyTrigger
+  });
+  const host = opts.host ?? "0.0.0.0";
+  const port = opts.port ?? 8080;
+  const otelPort = opts.otelPort ?? 4318;
+  const cachePath = opts.embeddingsCachePath ?? path.join(path.dirname(opts.outPath), "embeddings.json");
+  let searchIndex;
+  try {
+    searchIndex = await buildSearchIndex(graph, { cachePath });
+    console.log(`semantic_search: ${searchIndex.provider} provider`);
+  } catch (err) {
+    console.warn(
+      `semantic_search: index build failed (${err.message}); falling back to inline substring`
+    );
+  }
+  const projectName = opts.project ?? DEFAULT_PROJECT;
+  const registry = new Projects();
+  registry.set(projectName, {
+    graph,
+    scanPath: opts.scanPath,
+    paths: {
+      // Paths are derived from the explicit options the watch caller passes
+      // — pathsForProject is only used to fill in the embeddings/snapshot
+      // fields so the registry shape is complete.
+      ...pathsForProject(projectName, path.dirname(opts.outPath)),
+      snapshotPath: opts.outPath,
+      errorsPath: opts.errorsPath,
+      staleEventsPath: opts.staleEventsPath
+    },
+    searchIndex
+  });
+  const api = await buildApi({ projects: registry });
+  await api.listen({ port, host });
+  console.log(`neat-core listening on http://${host}:${port}`);
+  console.log(`  scan path:     ${opts.scanPath} (watching for changes)`);
+  console.log(`  snapshot path: ${opts.outPath}`);
+  console.log(`  errors log:    ${opts.errorsPath}`);
+  const onSpan = makeSpanHandler({
+    graph,
+    errorsPath: opts.errorsPath,
+    writeErrorEventInline: false,
+    onPolicyTrigger
+  });
+  const onErrorSpanSync = makeErrorSpanWriter(opts.errorsPath);
+  const otelHttp = await buildOtelReceiver({ onSpan, onErrorSpanSync });
+  await otelHttp.listen({ port: otelPort, host });
+  console.log(`neat-core OTLP receiver on http://${host}:${otelPort}/v1/traces`);
+  let grpcReceiver = null;
+  if (opts.otelGrpc) {
+    const grpcPort = opts.otelGrpcPort ?? 4317;
+    const onSpanGrpc = makeSpanHandler({
+      graph,
+      errorsPath: opts.errorsPath,
+      onPolicyTrigger
+    });
+    const r = await startOtelGrpcReceiver({ onSpan: onSpanGrpc, host, port: grpcPort });
+    console.log(`neat-core OTLP/gRPC receiver on ${r.address}`);
+    grpcReceiver = r;
+  }
+  const pending = /* @__PURE__ */ new Set();
+  const pendingPaths = /* @__PURE__ */ new Set();
+  let timer = null;
+  let inflight = null;
+  const flush = async () => {
+    if (pending.size === 0) return;
+    const phases = new Set(pending);
+    const paths = new Set(pendingPaths);
+    pending.clear();
+    pendingPaths.clear();
+    try {
+      let retired = 0;
+      for (const p of paths) retired += retireEdgesByFile(graph, p);
+      const result = await runExtractPhases(graph, opts.scanPath, phases);
+      console.log(
+        `[watch] re-extract phases=${result.phases.join(",")} retired=${retired} +${result.nodesAdded}n/+${result.edgesAdded}e in ${result.durationMs}ms`
+      );
+      if (searchIndex) {
+        try {
+          await searchIndex.refresh(graph);
+        } catch (err) {
+          console.warn("[watch] semantic_search refresh failed", err);
+        }
+      }
+      await onPolicyTrigger(graph);
+    } catch (err) {
+      console.error("[watch] re-extract failed", err);
+    }
+  };
+  const schedule = () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      inflight = (inflight ?? Promise.resolve()).then(flush);
+    }, debounceMs);
+  };
+  const onPath = (absPath) => {
+    if (shouldIgnore(absPath)) return;
+    const rel = path.relative(opts.scanPath, absPath);
+    if (!rel || rel.startsWith("..")) return;
+    pendingPaths.add(rel.split(path.sep).join("/"));
+    const phases = classifyChange(rel);
+    if (phases.size === 0) {
+      for (const p of ALL_PHASES) pending.add(p);
+    } else {
+      for (const p of phases) pending.add(p);
+    }
+    schedule();
+  };
+  const watcher = chokidar.watch(opts.scanPath, {
+    ignoreInitial: true,
+    ignored: (p) => shouldIgnore(p),
+    persistent: true,
+    awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 }
+  });
+  watcher.on("add", onPath);
+  watcher.on("change", onPath);
+  watcher.on("unlink", onPath);
+  watcher.on("addDir", onPath);
+  watcher.on("unlinkDir", onPath);
+  let stopped = false;
+  const stop = async () => {
+    if (stopped) return;
+    stopped = true;
+    if (timer) clearTimeout(timer);
+    timer = null;
+    if (inflight) {
+      try {
+        await inflight;
+      } catch {
+      }
+    }
+    await watcher.close();
+    stopStaleness();
+    stopPersist();
+    await api.close();
+    await otelHttp.close();
+    if (grpcReceiver) await grpcReceiver.stop();
+  };
+  return { api, stop };
+}
+
+// src/installers/javascript.ts
+import { promises as fs } from "fs";
+import path2 from "path";
+var SDK_PACKAGES = [
+  { name: "@opentelemetry/api", version: "^1.9.0" },
+  { name: "@opentelemetry/sdk-node", version: "^0.57.0" },
+  { name: "@opentelemetry/auto-instrumentations-node", version: "^0.55.0" }
+];
+var AUTO_INSTRUMENT_REQUIRE = "--require @opentelemetry/auto-instrumentations-node/register";
+var OTEL_ENV = {
+  // null target — NEAT does not write `.env` itself; the user sets the env
+  // var in their orchestration layer.
+  file: null,
+  key: "OTEL_EXPORTER_OTLP_ENDPOINT",
+  value: "http://localhost:4318"
+};
+async function readPackageJson(serviceDir) {
+  try {
+    const raw = await fs.readFile(path2.join(serviceDir, "package.json"), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function detect(serviceDir) {
+  const pkg = await readPackageJson(serviceDir);
+  return pkg !== null && typeof pkg.name === "string";
+}
+function rewriteStartScript(start) {
+  if (start.includes(AUTO_INSTRUMENT_REQUIRE)) return start;
+  if (/^\s*node\b/.test(start)) {
+    return start.replace(/^\s*node\b\s*/, `node ${AUTO_INSTRUMENT_REQUIRE} `);
+  }
+  return `node ${AUTO_INSTRUMENT_REQUIRE} -- ${start}`;
+}
+async function plan(serviceDir) {
+  const pkg = await readPackageJson(serviceDir);
+  const manifestPath = path2.join(serviceDir, "package.json");
+  const empty = {
+    language: "javascript",
+    serviceDir,
+    dependencyEdits: [],
+    entrypointEdits: [],
+    envEdits: []
+  };
+  if (!pkg) return empty;
+  const existingDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+  const dependencyEdits = [];
+  for (const sdk of SDK_PACKAGES) {
+    if (sdk.name in existingDeps) continue;
+    dependencyEdits.push({
+      file: manifestPath,
+      kind: "add",
+      name: sdk.name,
+      version: sdk.version
+    });
+  }
+  const entrypointEdits = [];
+  const startScript = pkg.scripts?.start;
+  if (typeof startScript === "string" && startScript.trim().length > 0) {
+    const rewritten = rewriteStartScript(startScript);
+    if (rewritten !== startScript) {
+      entrypointEdits.push({ file: manifestPath, before: startScript, after: rewritten });
+    }
+  }
+  if (dependencyEdits.length === 0 && entrypointEdits.length === 0) {
+    return empty;
+  }
+  return {
+    language: "javascript",
+    serviceDir,
+    dependencyEdits,
+    entrypointEdits,
+    envEdits: [OTEL_ENV]
+  };
+}
+async function apply(installPlan) {
+  const touched = /* @__PURE__ */ new Set();
+  for (const e of installPlan.dependencyEdits) touched.add(e.file);
+  for (const e of installPlan.entrypointEdits) touched.add(e.file);
+  if (touched.size === 0) return;
+  const originals = /* @__PURE__ */ new Map();
+  for (const file of touched) {
+    try {
+      originals.set(file, await fs.readFile(file, "utf8"));
+    } catch {
+    }
+  }
+  try {
+    for (const file of touched) {
+      const raw = originals.get(file) ?? "";
+      const pkg = JSON.parse(raw);
+      pkg.dependencies = pkg.dependencies ?? {};
+      for (const dep of installPlan.dependencyEdits) {
+        if (dep.file !== file) continue;
+        if (dep.kind === "add") {
+          pkg.dependencies[dep.name] = dep.version;
+        } else {
+          delete pkg.dependencies[dep.name];
+        }
+      }
+      for (const ep of installPlan.entrypointEdits) {
+        if (ep.file !== file) continue;
+        pkg.scripts = pkg.scripts ?? {};
+        if (pkg.scripts.start === ep.before) {
+          pkg.scripts.start = ep.after;
+        }
+      }
+      const newRaw = JSON.stringify(pkg, null, 2) + "\n";
+      const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+      await fs.writeFile(tmp, newRaw, "utf8");
+      await fs.rename(tmp, file);
+    }
+  } catch (err) {
+    await rollback(installPlan, originals);
+    throw err;
+  }
+}
+async function rollback(installPlan, originals) {
+  const restored = [];
+  for (const [file, raw] of originals.entries()) {
+    try {
+      await fs.writeFile(file, raw, "utf8");
+      restored.push(file);
+    } catch {
+    }
+  }
+  const lines = [
+    "# neat-rollback.patch",
+    "",
+    `# Generated after a partial apply failure in the ${installPlan.language} installer.`,
+    "# Files listed below were restored to their pre-apply contents.",
+    "",
+    ...restored.map((f) => `restored: ${f}`),
+    ""
+  ];
+  const rollbackPath = path2.join(installPlan.serviceDir, "neat-rollback.patch");
+  await fs.writeFile(rollbackPath, lines.join("\n"), "utf8");
+}
+var javascriptInstaller = {
+  name: "javascript",
+  detect,
+  plan,
+  apply
+};
+
+// src/installers/python.ts
+import { promises as fs2 } from "fs";
+import path3 from "path";
+var SDK_PACKAGES2 = [
+  { name: "opentelemetry-distro", version: ">=0.49b0" },
+  { name: "opentelemetry-exporter-otlp", version: ">=1.28.0" }
+];
+var OTEL_ENV2 = {
+  file: null,
+  key: "OTEL_EXPORTER_OTLP_ENDPOINT",
+  value: "http://localhost:4318"
+};
+async function exists(p) {
+  try {
+    await fs2.stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detect2(serviceDir) {
+  const markers = ["requirements.txt", "pyproject.toml", "setup.py"];
+  for (const m of markers) {
+    if (await exists(path3.join(serviceDir, m))) return true;
+  }
+  return false;
+}
+function reqPackageName(line) {
+  const stripped = line.split("#")[0]?.trim() ?? "";
+  const head = stripped.split(/[\s;]/)[0] ?? "";
+  return head.replace(/[<>=!~].*$/, "").toLowerCase();
+}
+async function planRequirementsTxtEdits(serviceDir) {
+  const file = path3.join(serviceDir, "requirements.txt");
+  if (!await exists(file)) return null;
+  const raw = await fs2.readFile(file, "utf8");
+  const presentNames = new Set(
+    raw.split(/\r?\n/).map(reqPackageName).filter((n) => n.length > 0)
+  );
+  const missing = SDK_PACKAGES2.filter((p) => !presentNames.has(p.name.toLowerCase()));
+  return { manifest: file, missing: [...missing] };
+}
+async function planProcfileEdits(serviceDir) {
+  const procfile = path3.join(serviceDir, "Procfile");
+  if (!await exists(procfile)) return [];
+  const raw = await fs2.readFile(procfile, "utf8");
+  const edits = [];
+  for (const line of raw.split(/\r?\n/)) {
+    if (line.length === 0) continue;
+    const m = line.match(/^([a-zA-Z0-9_-]+):\s*(.+)$/);
+    if (!m) continue;
+    const cmd = m[2];
+    if (!/^python\b/.test(cmd)) continue;
+    if (cmd.startsWith("opentelemetry-instrument ")) continue;
+    const after = `${m[1]}: opentelemetry-instrument ${cmd}`;
+    edits.push({ file: procfile, before: line, after });
+  }
+  return edits;
+}
+async function plan2(serviceDir) {
+  const empty = {
+    language: "python",
+    serviceDir,
+    dependencyEdits: [],
+    entrypointEdits: [],
+    envEdits: []
+  };
+  const dependencyEdits = [];
+  const reqs = await planRequirementsTxtEdits(serviceDir);
+  if (reqs) {
+    for (const sdk of reqs.missing) {
+      dependencyEdits.push({
+        file: reqs.manifest,
+        kind: "add",
+        name: sdk.name,
+        version: sdk.version
+      });
+    }
+  }
+  const entrypointEdits = await planProcfileEdits(serviceDir);
+  if (dependencyEdits.length === 0 && entrypointEdits.length === 0) {
+    return empty;
+  }
+  return {
+    language: "python",
+    serviceDir,
+    dependencyEdits,
+    entrypointEdits,
+    envEdits: [OTEL_ENV2]
+  };
+}
+async function applyRequirementsTxt(manifest, edits, original) {
+  const newlines = edits.filter((e) => e.kind === "add").map((e) => `${e.name}${e.version}`);
+  const trailing = original.endsWith("\n") ? "" : "\n";
+  const next = `${original}${trailing}${newlines.join("\n")}
+`;
+  const tmp = `${manifest}.${process.pid}.${Date.now()}.tmp`;
+  await fs2.writeFile(tmp, next, "utf8");
+  await fs2.rename(tmp, manifest);
+}
+async function applyProcfile(procfile, edits, original) {
+  let next = original;
+  for (const e of edits) {
+    if (!next.includes(e.before)) continue;
+    next = next.replace(e.before, e.after);
+  }
+  const tmp = `${procfile}.${process.pid}.${Date.now()}.tmp`;
+  await fs2.writeFile(tmp, next, "utf8");
+  await fs2.rename(tmp, procfile);
+}
+async function apply2(installPlan) {
+  const touched = /* @__PURE__ */ new Set();
+  for (const e of installPlan.dependencyEdits) touched.add(e.file);
+  for (const e of installPlan.entrypointEdits) touched.add(e.file);
+  if (touched.size === 0) return;
+  const originals = /* @__PURE__ */ new Map();
+  for (const file of touched) {
+    try {
+      originals.set(file, await fs2.readFile(file, "utf8"));
+    } catch {
+    }
+  }
+  try {
+    for (const file of touched) {
+      const raw = originals.get(file);
+      if (raw === void 0) {
+        throw new Error(`python installer: cannot read ${file} during apply`);
+      }
+      const base = path3.basename(file);
+      if (base === "requirements.txt") {
+        const edits = installPlan.dependencyEdits.filter((e) => e.file === file);
+        if (edits.length > 0) await applyRequirementsTxt(file, edits, raw);
+      } else if (base === "Procfile") {
+        const edits = installPlan.entrypointEdits.filter((e) => e.file === file);
+        if (edits.length > 0) await applyProcfile(file, edits, raw);
+      }
+    }
+  } catch (err) {
+    await rollback2(installPlan, originals);
+    throw err;
+  }
+}
+async function rollback2(installPlan, originals) {
+  const restored = [];
+  for (const [file, raw] of originals.entries()) {
+    try {
+      await fs2.writeFile(file, raw, "utf8");
+      restored.push(file);
+    } catch {
+    }
+  }
+  const lines = [
+    "# neat-rollback.patch",
+    "",
+    `# Generated after a partial apply failure in the ${installPlan.language} installer.`,
+    "# Files listed below were restored to their pre-apply contents.",
+    "",
+    ...restored.map((f) => `restored: ${f}`),
+    ""
+  ];
+  const rollbackPath = path3.join(installPlan.serviceDir, "neat-rollback.patch");
+  await fs2.writeFile(rollbackPath, lines.join("\n"), "utf8");
+}
+var pythonInstaller = {
+  name: "python",
+  detect: detect2,
+  plan: plan2,
+  apply: apply2
+};
+
+// src/installers/shared.ts
+function isEmptyPlan(plan3) {
+  return plan3.dependencyEdits.length === 0 && plan3.entrypointEdits.length === 0 && plan3.envEdits.length === 0;
+}
+
+// src/installers/index.ts
+var FORBIDDEN_LOCKFILES = /* @__PURE__ */ new Set([
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "poetry.lock",
+  "Pipfile.lock",
+  "Gemfile.lock",
+  "Cargo.lock",
+  "go.sum"
+]);
+var INSTALLERS = [javascriptInstaller, pythonInstaller];
+async function pickInstaller(serviceDir) {
+  for (const inst of INSTALLERS) {
+    if (await inst.detect(serviceDir)) return inst;
+  }
+  return null;
+}
+function renderPatch(sections) {
+  if (sections.length === 0) {
+    return [
+      "# neat install plan",
+      "",
+      "No SDK installers matched the discovered services. Two reasons this",
+      "normally happens:",
+      "  - the project uses a language NEAT does not yet instrument",
+      "    (Java / Ruby / .NET / Go / Rust are out of MVP scope per ADR-047);",
+      "  - the SDK is already installed, so the installer returned an empty",
+      "    plan.",
+      "",
+      "You can re-run `neat init --apply` later to pick up new services.",
+      ""
+    ].join("\n");
+  }
+  const lines = ["# neat install plan", ""];
+  for (const section of sections) {
+    const { installer, plan: plan3 } = section;
+    lines.push(`## ${installer} (${plan3.language}) \u2014 ${plan3.serviceDir}`);
+    lines.push("");
+    if (plan3.dependencyEdits.length > 0) {
+      lines.push("### dependencies");
+      for (const dep of plan3.dependencyEdits) {
+        const base = dep.file.split(/[\\/]/).pop() ?? dep.file;
+        if (FORBIDDEN_LOCKFILES.has(base)) {
+          throw new Error(
+            `installer "${installer}" produced a dependency edit against a lockfile (${dep.file}); lockfiles must never be touched (ADR-047).`
+          );
+        }
+        lines.push(`- ${dep.kind} ${dep.name}@${dep.version} in ${dep.file}`);
+      }
+      lines.push("");
+    }
+    if (plan3.entrypointEdits.length > 0) {
+      lines.push("### entrypoint");
+      for (const e of plan3.entrypointEdits) {
+        lines.push(`- ${e.file}`);
+        lines.push(`    - before: ${e.before}`);
+        lines.push(`    - after:  ${e.after}`);
+      }
+      lines.push("");
+    }
+    if (plan3.envEdits.length > 0) {
+      lines.push("### env");
+      for (const env of plan3.envEdits) {
+        const target = env.file ?? "(set in your orchestration layer)";
+        lines.push(`- ${env.key}=${env.value} \u2192 ${target}`);
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/cli.ts
+function usage() {
+  console.log("usage: neat <command> [args] [--project <name>]");
+  console.log("");
+  console.log("commands:");
+  console.log("  init <path>    One-time install: discover, extract, register, plan SDK install.");
+  console.log("                 Snapshot lands in <path>/neat-out/graph.json by default");
+  console.log("                 (or <path>/neat-out/<project>.json for non-default).");
+  console.log("                 Flags:");
+  console.log("                   --apply       run the SDK install patch in place");
+  console.log("                   --dry-run     write only neat.patch; do not register or snapshot");
+  console.log("                   --no-install  skip SDK install planning entirely");
+  console.log("  watch <path>   Start neat-core, watch <path>, re-extract on changes.");
+  console.log("                 PORT (default 8080), OTEL_PORT (4318), HOST (0.0.0.0)");
+  console.log("                 control listeners. NEAT_OTLP_GRPC=true also opens 4317.");
+  console.log("  list           List every project registered in the machine-level registry.");
+  console.log("  pause <name>   Mark a project paused \u2014 daemon stops watching until resumed.");
+  console.log("  resume <name>  Mark a project active again.");
+  console.log("  uninstall <name>");
+  console.log("                 Remove a project from the registry. Does not touch");
+  console.log("                 neat-out/, policy.json, or any user file.");
+  console.log("  skill          Install or print the Claude Code MCP drop-in.");
+  console.log("                 Flags:");
+  console.log("                   --print-config   print the JSON snippet to stdout");
+  console.log("                   --apply          merge mcpServers.neat into ~/.claude.json");
+  console.log("");
+  console.log("flags:");
+  console.log('  --project <name>   Name the project this command targets. Default: "default".');
+}
+function parseArgs(rest) {
+  const positional = [];
+  let project = null;
+  let apply3 = false;
+  let dryRun = false;
+  let noInstall = false;
+  let printConfig = false;
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === "--project") {
+      const next = rest[i + 1];
+      if (!next) {
+        console.error("neat: --project requires a value");
+        process.exit(2);
+      }
+      project = next;
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--project=")) {
+      project = arg.slice("--project=".length);
+      continue;
+    }
+    if (arg === "--apply") {
+      apply3 = true;
+      continue;
+    }
+    if (arg === "--dry-run") {
+      dryRun = true;
+      continue;
+    }
+    if (arg === "--no-install") {
+      noInstall = true;
+      continue;
+    }
+    if (arg === "--print-config") {
+      printConfig = true;
+      continue;
+    }
+    positional.push(arg);
+  }
+  return { project, apply: apply3, dryRun, noInstall, printConfig, positional };
+}
+function summarise(nodes, edges) {
+  const byNode = /* @__PURE__ */ new Map();
+  for (const n of nodes) byNode.set(n.type, (byNode.get(n.type) ?? 0) + 1);
+  const byEdge = /* @__PURE__ */ new Map();
+  for (const e of edges) byEdge.set(e.type, (byEdge.get(e.type) ?? 0) + 1);
+  const nodeLines = [...byNode.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([t, c]) => `    ${t}: ${c}`);
+  const edgeLines = [...byEdge.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([t, c]) => `    ${t}: ${c}`);
+  return ["nodes:", ...nodeLines, "edges:", ...edgeLines].join("\n");
+}
+function formatIncompat(inc) {
+  if (inc.kind === "node-engine") {
+    const range = inc.declaredNodeEngine ? ` (engines.node="${inc.declaredNodeEngine}")` : "";
+    return `${inc.package}@${inc.packageVersion ?? "?"} requires Node ${inc.requiredNodeVersion}${range} \u2014 ${inc.reason}`;
+  }
+  if (inc.kind === "package-conflict") {
+    const found = inc.foundVersion ? `@${inc.foundVersion}` : " (missing)";
+    return `${inc.package}@${inc.packageVersion ?? "?"} requires ${inc.requires.name}>=${inc.requires.minVersion}; found ${inc.requires.name}${found} \u2014 ${inc.reason}`;
+  }
+  if (inc.kind === "deprecated-api") {
+    return `${inc.package}@${inc.packageVersion ?? "?"} is deprecated \u2014 ${inc.reason}`;
+  }
+  return `${inc.driver}@${inc.driverVersion} vs ${inc.engine} ${inc.engineVersion} \u2014 ${inc.reason}`;
+}
+function findIncompatibilities(nodes) {
+  return nodes.filter(
+    (n) => n.type === "ServiceNode" && Array.isArray(n.incompatibilities) && (n.incompatibilities ?? []).length > 0
+  );
+}
+function printBanner() {
+  console.log("\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557");
+  console.log("\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D");
+  console.log("\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551   \u2588\u2588\u2551   ");
+  console.log("\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551   \u2588\u2588\u2551   ");
+  console.log("\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551   \u2588\u2588\u2551   ");
+  console.log("\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D   \u255A\u2550\u255D   ");
+  console.log("");
+  console.log("  Network Expressive Architecting Tool");
+  console.log("  neat.is  \xB7  v0.2.5  \xB7  BSL 1.1");
+  console.log("");
+}
+function printDiscoveryReport(opts, services) {
+  const languages = [...new Set(services.map((s) => s.node.language))].sort();
+  const mode = opts.dryRun ? "dry-run" : opts.apply ? "apply" : "patch-only";
+  printBanner();
+  console.log("=== neat init: discovery ===");
+  console.log(`scan path: ${opts.scanPath}`);
+  console.log(`project:   ${opts.project}`);
+  console.log(`mode:      ${mode}`);
+  console.log(`services:  ${services.length}`);
+  for (const s of services) {
+    const where = s.node.repoPath && s.node.repoPath.length > 0 ? s.node.repoPath : ".";
+    console.log(`  - ${s.node.name} (${s.node.language}) \u2014 ${where}`);
+  }
+  console.log(`languages: ${languages.length > 0 ? languages.join(", ") : "(none)"}`);
+  if (opts.noInstall) {
+    console.log("install:   skipped (--no-install)");
+  } else if (opts.dryRun) {
+    console.log("install:   patch will be written to neat.patch; nothing else.");
+  } else if (opts.apply) {
+    console.log("install:   patch will be applied in place. Run `npm install` afterwards.");
+  } else {
+    console.log("install:   patch will be written to neat.patch for review.");
+  }
+  console.log("");
+}
+async function buildPatchSections(services) {
+  const sections = [];
+  for (const svc of services) {
+    const installer = await pickInstaller(svc.dir);
+    if (!installer) continue;
+    const plan3 = await installer.plan(svc.dir);
+    if (isEmptyPlan(plan3)) continue;
+    sections.push({ installer: installer.name, plan: plan3 });
+  }
+  return sections;
+}
+async function runInit(opts) {
+  const written = [];
+  const stat = await fs3.stat(opts.scanPath).catch(() => null);
+  if (!stat || !stat.isDirectory()) {
+    console.error(`neat init: ${opts.scanPath} is not a directory`);
+    return { exitCode: 2, writtenFiles: written };
+  }
+  const services = await discoverServices(opts.scanPath);
+  printDiscoveryReport(opts, services);
+  const sections = opts.noInstall ? [] : await buildPatchSections(services);
+  const patch = renderPatch(sections);
+  const patchPath = path4.join(opts.scanPath, "neat.patch");
+  if (opts.dryRun) {
+    await fs3.writeFile(patchPath, patch, "utf8");
+    written.push(patchPath);
+    console.log(`dry-run: patch written to ${patchPath}`);
+    console.log("rerun without --dry-run to register and snapshot.");
+    return { exitCode: 0, writtenFiles: written };
+  }
+  const graphKey = opts.projectExplicit ? opts.project : DEFAULT_PROJECT;
+  resetGraph(graphKey);
+  const graph = getGraph(graphKey);
+  const result = await extractFromDirectory(graph, opts.scanPath);
+  await saveGraphToDisk(graph, opts.outPath);
+  written.push(opts.outPath);
+  const languages = [...new Set(services.map((s) => s.node.language))].sort();
+  try {
+    await addProject({
+      name: opts.project,
+      path: opts.scanPath,
+      languages,
+      status: "active"
+    });
+  } catch (err) {
+    if (err instanceof ProjectNameCollisionError) {
+      console.error(`neat init: ${err.message}`);
+      console.error("pass --project <other-name> to register under a different name.");
+      return { exitCode: 1, writtenFiles: written };
+    }
+    throw err;
+  }
+  if (!opts.noInstall) {
+    if (opts.apply) {
+      for (const section of sections) {
+        const installer = INSTALLERS.find((i) => i.name === section.installer);
+        if (!installer) continue;
+        await installer.apply(section.plan);
+      }
+      if (sections.length > 0) {
+        console.log("");
+        console.log("patch applied. Run `npm install` (or your language equivalent) to refresh lockfiles.");
+      }
+    } else {
+      await fs3.writeFile(patchPath, patch, "utf8");
+      written.push(patchPath);
+    }
+  }
+  const nodes = [];
+  graph.forEachNode((_id, attrs) => nodes.push(attrs));
+  const edges = [];
+  graph.forEachEdge((_id, attrs) => edges.push(attrs));
+  console.log("");
+  console.log("=== neat init: summary ===");
+  console.log(`snapshot: ${opts.outPath}`);
+  console.log(`added: ${result.nodesAdded} nodes, ${result.edgesAdded} edges`);
+  console.log(`total:  ${graph.order} nodes, ${graph.size} edges`);
+  console.log(summarise(nodes, edges));
+  const incompatibilities = findIncompatibilities(nodes);
+  if (incompatibilities.length > 0) {
+    console.log("");
+    console.log(`incompatibilities found in ${incompatibilities.length} service(s):`);
+    for (const svc of incompatibilities) {
+      for (const inc of svc.incompatibilities ?? []) {
+        console.log(`  ${svc.name}: ${formatIncompat(inc)}`);
+      }
+    }
+  }
+  return { exitCode: 0, writtenFiles: written };
+}
+var CLAUDE_SKILL_CONFIG = {
+  mcpServers: {
+    neat: {
+      type: "stdio",
+      command: "npx",
+      args: ["-y", "@neat.is/mcp"],
+      env: {
+        NEAT_API_URL: "http://localhost:8080"
+      }
+    }
+  }
+};
+function claudeConfigPath() {
+  const override = process.env.NEAT_CLAUDE_CONFIG;
+  if (override && override.length > 0) return path4.resolve(override);
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  return path4.join(home, ".claude.json");
+}
+async function runSkill(opts) {
+  const snippet = JSON.stringify(CLAUDE_SKILL_CONFIG, null, 2) + "\n";
+  if (opts.printConfig) {
+    process.stdout.write(snippet);
+    return { exitCode: 0 };
+  }
+  if (opts.apply) {
+    const target = claudeConfigPath();
+    let existing = {};
+    try {
+      existing = JSON.parse(await fs3.readFile(target, "utf8"));
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        console.error(`neat skill: failed to read ${target} \u2014 ${err.message}`);
+        return { exitCode: 1 };
+      }
+    }
+    const mcp = existing.mcpServers ?? {};
+    const merged = {
+      ...existing,
+      mcpServers: { ...mcp, neat: CLAUDE_SKILL_CONFIG.mcpServers.neat }
+    };
+    await fs3.mkdir(path4.dirname(target), { recursive: true });
+    await fs3.writeFile(target, JSON.stringify(merged, null, 2) + "\n", "utf8");
+    console.log(`neat skill: wrote mcpServers.neat to ${target}`);
+    console.log("restart Claude Code to pick up the new MCP server.");
+    return { exitCode: 0 };
+  }
+  console.log("neat skill \u2014 Claude Code MCP drop-in for NEAT");
+  console.log("");
+  console.log("  --print-config   print the JSON snippet to stdout");
+  console.log("  --apply          merge mcpServers.neat into ~/.claude.json");
+  console.log("");
+  console.log("Manual install: copy mcpServers.neat from --print-config into ~/.claude.json,");
+  console.log("then restart Claude Code. See packages/claude-skill/SKILL.md for the tool list.");
+  return { exitCode: 0 };
+}
+async function main() {
+  const [, , cmd, ...rest] = process.argv;
+  if (!cmd || cmd === "-h" || cmd === "--help") {
+    usage();
+    process.exit(0);
+  }
+  const parsed = parseArgs(rest);
+  const { positional, apply: apply3, dryRun, noInstall } = parsed;
+  const project = parsed.project ?? DEFAULT_PROJECT;
+  if (cmd === "init") {
+    const target = positional[0];
+    if (!target) {
+      console.error("neat init: missing <path>");
+      usage();
+      process.exit(2);
+    }
+    if (apply3 && dryRun) {
+      console.error("neat init: --apply and --dry-run are mutually exclusive");
+      process.exit(2);
+    }
+    const scanPath = path4.resolve(target);
+    const projectExplicit = parsed.project !== null;
+    const projectName = projectExplicit ? project : path4.basename(scanPath);
+    const projectKey = projectExplicit ? project : DEFAULT_PROJECT;
+    const fallback = pathsForProject(projectKey, path4.join(scanPath, "neat-out")).snapshotPath;
+    const outPath = path4.resolve(process.env.NEAT_OUT_PATH ?? fallback);
+    const result = await runInit({
+      scanPath,
+      outPath,
+      project: projectName,
+      projectExplicit,
+      apply: apply3,
+      dryRun,
+      noInstall
+    });
+    if (result.exitCode !== 0) process.exit(result.exitCode);
+    return;
+  }
+  if (cmd === "watch") {
+    const target = positional[0];
+    if (!target) {
+      console.error("neat watch: missing <path>");
+      usage();
+      process.exit(2);
+    }
+    const scanPath = path4.resolve(target);
+    const stat = await fs3.stat(scanPath).catch(() => null);
+    if (!stat || !stat.isDirectory()) {
+      console.error(`neat watch: ${scanPath} is not a directory`);
+      process.exit(2);
+    }
+    const projectPaths = pathsForProject(project, path4.join(scanPath, "neat-out"));
+    const outPath = path4.resolve(process.env.NEAT_OUT_PATH ?? projectPaths.snapshotPath);
+    const errorsPath = path4.resolve(
+      process.env.NEAT_ERRORS_PATH ?? path4.join(path4.dirname(outPath), path4.basename(projectPaths.errorsPath))
+    );
+    const staleEventsPath = path4.resolve(
+      process.env.NEAT_STALE_EVENTS_PATH ?? path4.join(path4.dirname(outPath), path4.basename(projectPaths.staleEventsPath))
+    );
+    const embeddingsCachePath = process.env.NEAT_EMBEDDINGS_CACHE_PATH ? path4.resolve(process.env.NEAT_EMBEDDINGS_CACHE_PATH) : void 0;
+    const handle = await startWatch(getGraph(project), {
+      scanPath,
+      outPath,
+      errorsPath,
+      staleEventsPath,
+      project,
+      ...embeddingsCachePath ? { embeddingsCachePath } : {},
+      host: process.env.HOST ?? "0.0.0.0",
+      port: Number(process.env.PORT ?? 8080),
+      otelPort: Number(process.env.OTEL_PORT ?? 4318),
+      otelGrpc: process.env.NEAT_OTLP_GRPC === "true",
+      otelGrpcPort: process.env.NEAT_OTLP_GRPC_PORT ? Number(process.env.NEAT_OTLP_GRPC_PORT) : void 0
+    });
+    let shuttingDown = false;
+    const shutdown = (signal) => {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      console.log(`neat watch: ${signal} received, stopping\u2026`);
+      void handle.stop().catch((err) => {
+        console.error("neat watch: shutdown error", err);
+      });
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+    return;
+  }
+  if (cmd === "list") {
+    const projects = await listProjects();
+    if (projects.length === 0) {
+      console.log("no projects registered. run `neat init <path>` to register one.");
+      return;
+    }
+    for (const p of projects) {
+      const seen = p.lastSeenAt ? p.lastSeenAt : "never";
+      const langs = p.languages.length > 0 ? p.languages.join(",") : "-";
+      console.log(`${p.name}	${p.status}	${langs}	${p.path}	last-seen=${seen}`);
+    }
+    return;
+  }
+  if (cmd === "pause") {
+    const name = positional[0];
+    if (!name) {
+      console.error("neat pause: missing <name>");
+      usage();
+      process.exit(2);
+    }
+    try {
+      const entry2 = await setStatus(name, "paused");
+      console.log(`paused: ${entry2.name} (${entry2.path})`);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+    return;
+  }
+  if (cmd === "resume") {
+    const name = positional[0];
+    if (!name) {
+      console.error("neat resume: missing <name>");
+      usage();
+      process.exit(2);
+    }
+    try {
+      const entry2 = await setStatus(name, "active");
+      console.log(`resumed: ${entry2.name} (${entry2.path})`);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+    return;
+  }
+  if (cmd === "skill") {
+    const result = await runSkill({ apply: parsed.apply, printConfig: parsed.printConfig });
+    if (result.exitCode !== 0) process.exit(result.exitCode);
+    return;
+  }
+  if (cmd === "uninstall") {
+    const name = positional[0];
+    if (!name) {
+      console.error("neat uninstall: missing <name>");
+      usage();
+      process.exit(2);
+    }
+    const removed = await removeProject(name);
+    if (!removed) {
+      console.error(`neat uninstall: no project named "${name}"`);
+      process.exit(1);
+    }
+    console.log(`unregistered: ${removed.name} (${removed.path})`);
+    console.log("note: neat-out/, policy.json, and other files at the project path were left in place.");
+    return;
+  }
+  console.error(`neat: unknown command "${cmd}"`);
+  usage();
+  process.exit(1);
+}
+var entry = process.argv[1] ?? "";
+if (/[\\/]cli\.(?:cjs|js)$/.test(entry) || entry.endsWith("/cli") || entry.endsWith("/neat")) {
+  main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}
+export {
+  CLAUDE_SKILL_CONFIG,
+  runInit,
+  runSkill
+};
+//# sourceMappingURL=cli.js.map