@neat.is/core 0.3.5 → 0.3.7

package/dist/cli.cjs

@@ -258,8 +258,7 @@ function parseOtlpRequest(body) {
   }
   return out;
 }
-function loadProtobufDecoder() {
-  if (exportTraceServiceRequestType) return exportTraceServiceRequestType;
+function loadProtoRoot() {
   const here = import_node_path35.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
   const protoRoot = import_node_path35.default.resolve(here, "..", "proto");
   const root = new import_protobufjs.default.Root();
@@ -268,11 +267,32 @@ function loadProtobufDecoder() {
     "opentelemetry/proto/collector/trace/v1/trace_service.proto",
     { keepCase: true }
   );
+  return root;
+}
+function loadProtobufDecoder() {
+  if (exportTraceServiceRequestType) return exportTraceServiceRequestType;
+  const root = loadProtoRoot();
   exportTraceServiceRequestType = root.lookupType(
     "opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest"
   );
   return exportTraceServiceRequestType;
 }
+function loadProtobufResponseEncoder() {
+  if (exportTraceServiceResponseType) return exportTraceServiceResponseType;
+  const root = loadProtoRoot();
+  exportTraceServiceResponseType = root.lookupType(
+    "opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse"
+  );
+  return exportTraceServiceResponseType;
+}
+function encodeProtobufResponseBody() {
+  if (cachedProtobufResponseBody) return cachedProtobufResponseBody;
+  const Type = loadProtobufResponseEncoder();
+  const msg = Type.create({});
+  const encoded = Type.encode(msg).finish();
+  cachedProtobufResponseBody = Buffer.from(encoded);
+  return cachedProtobufResponseBody;
+}
 async function decodeProtobufBody(buf) {
   const Type = loadProtobufDecoder();
   const decoded = Type.decode(buf).toJSON();
@@ -319,7 +339,9 @@ async function buildOtelReceiver(opts) {
   app.post("/v1/traces", async (req, reply) => {
     const ct = (req.headers["content-type"] ?? "").toString().split(";")[0].trim().toLowerCase();
     let body;
+    let responseFlavor;
     if (ct === "application/x-protobuf") {
+      responseFlavor = "protobuf";
       try {
         body = await decodeProtobufBody(req.body);
       } catch (err) {
@@ -328,6 +350,7 @@ async function buildOtelReceiver(opts) {
         });
       }
     } else if (!ct || ct === "application/json") {
+      responseFlavor = "json";
       body = req.body ?? {};
     } else {
       return reply.code(415).send({ error: `unsupported content-type: ${ct}` });
@@ -345,7 +368,11 @@ async function buildOtelReceiver(opts) {
       }
     }
     enqueue(spans);
-    return reply.code(200).send({ partialSuccess: {} });
+    if (responseFlavor === "protobuf") {
+      const buf = encodeProtobufResponseBody();
+      return reply.code(200).header("content-type", "application/x-protobuf").send(buf);
+    }
+    return reply.code(200).header("content-type", "application/json").send({ partialSuccess: {} });
   });
   const decorated = app;
   decorated.flushPending = async () => {
@@ -355,7 +382,7 @@ async function buildOtelReceiver(opts) {
   };
   return decorated;
 }
-var import_node_path35, import_node_url2, import_fastify2, import_protobufjs, exportTraceServiceRequestType;
+var import_node_path35, import_node_url2, import_fastify2, import_protobufjs, exportTraceServiceRequestType, exportTraceServiceResponseType, cachedProtobufResponseBody;
 var init_otel = __esm({
   "src/otel.ts"() {
     "use strict";
@@ -365,6 +392,8 @@ var init_otel = __esm({
     import_fastify2 = __toESM(require("fastify"), 1);
     import_protobufjs = __toESM(require("protobufjs"), 1);
     exportTraceServiceRequestType = null;
+    exportTraceServiceResponseType = null;
+    cachedProtobufResponseBody = null;
   }
 });
 
@@ -1663,7 +1692,7 @@ function buildErrorEventForReceiver(span) {
     service: span.service,
     traceId: span.traceId,
     spanId: span.spanId,
-    errorMessage: span.exception?.message ?? span.name ?? "unknown error",
+    errorMessage: span.exception?.message ?? "unknown error",
     ...span.exception?.type ? { exceptionType: span.exception.type } : {},
     ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
     ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
@@ -1755,7 +1784,7 @@ async function handleSpan(ctx, span) {
         service: span.service,
         traceId: span.traceId,
         spanId: span.spanId,
-        errorMessage: span.exception?.message ?? span.name ?? "unknown error",
+        errorMessage: span.exception?.message ?? "unknown error",
         ...span.exception?.type ? { exceptionType: span.exception.type } : {},
         ...span.exception?.stacktrace ? { exceptionStacktrace: span.exception.stacktrace } : {},
         ...Object.keys(attrs).length > 0 ? { attributes: attrs } : {},
@@ -5911,15 +5940,69 @@ init_cjs_shims();
 init_cjs_shims();
 var import_node_fs23 = require("fs");
 var import_node_path38 = __toESM(require("path"), 1);
+
+// src/installers/templates.ts
+init_cjs_shims();
+var OTEL_INIT_HEADER = "// Generated by `neat init --apply` (ADR-069). OpenTelemetry auto-instrumentation hook.";
+var OTEL_INIT_CJS = `${OTEL_INIT_HEADER}
+// Loads .env.neat (OTEL_SERVICE_NAME, OTEL_EXPORTER_OTLP_ENDPOINT) before
+// the auto-instrumentation hook attaches. Configure via the env file.
+const path = require('node:path')
+try {
+  require('dotenv').config({ path: path.join(__dirname, '.env.neat') })
+} catch (err) {
+  // dotenv unavailable \u2014 fall through to process.env.
+}
+require('@opentelemetry/auto-instrumentations-node/register')
+`;
+var OTEL_INIT_ESM = `${OTEL_INIT_HEADER}
+// Loads .env.neat (OTEL_SERVICE_NAME, OTEL_EXPORTER_OTLP_ENDPOINT) before
+// the auto-instrumentation hook attaches. Configure via the env file.
+import { fileURLToPath } from 'node:url'
+import path from 'node:path'
+import dotenv from 'dotenv'
+
+const here = path.dirname(fileURLToPath(import.meta.url))
+dotenv.config({ path: path.join(here, '.env.neat') })
+
+await import('@opentelemetry/auto-instrumentations-node/register')
+`;
+var OTEL_INIT_TS = `${OTEL_INIT_HEADER}
+// Loads .env.neat (OTEL_SERVICE_NAME, OTEL_EXPORTER_OTLP_ENDPOINT) before
+// the auto-instrumentation hook attaches. Configure via the env file.
+import { fileURLToPath } from 'node:url'
+import path from 'node:path'
+import dotenv from 'dotenv'
+
+const here = path.dirname(fileURLToPath(import.meta.url))
+dotenv.config({ path: path.join(here, '.env.neat') })
+
+await import('@opentelemetry/auto-instrumentations-node/register')
+`;
+function renderEnvNeat(serviceName) {
+  return [
+    "# Generated by `neat init --apply` (ADR-069).",
+    `OTEL_SERVICE_NAME=${serviceName}`,
+    "OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318",
+    ""
+  ].join("\n");
+}
+
+// src/installers/javascript.ts
 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" }
+  { name: "@opentelemetry/auto-instrumentations-node", version: "^0.55.0" },
+  // ADR-069 §5 — dotenv is the fourth dep. The generated otel-init loads
+  // .env.neat through it so OTEL_SERVICE_NAME and the endpoint are in scope
+  // before the auto-instrumentation hook attaches.
+  { name: "dotenv", version: "^16.4.5" }
 ];
-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.
+  // ADR-069 §4 — endpoint moves into the per-package .env.neat (written
+  // by the apply phase). The envEdits surface stays for the dry-run
+  // patch render: it documents the key/value the user can inspect in the
+  // generated .env.neat.
   file: null,
   key: "OTEL_EXPORTER_OTLP_ENDPOINT",
   value: "http://localhost:4318"
@@ -5932,16 +6015,134 @@ async function readPackageJson(serviceDir) {
     return null;
   }
 }
+async function exists2(p) {
+  try {
+    await import_node_fs23.promises.stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
 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} `);
+var INDEX_EXTENSIONS = [".ts", ".tsx", ".js", ".mjs", ".cjs"];
+var INDEX_CANDIDATES = INDEX_EXTENSIONS.map((ext) => `index${ext}`);
+var SRC_INDEX_CANDIDATES = INDEX_EXTENSIONS.map((ext) => `src/index${ext}`);
+var SRC_NAMED_CANDIDATES = ["server", "main", "app"].flatMap(
+  (name) => INDEX_EXTENSIONS.map((ext) => `src/${name}${ext}`)
+);
+var SCRIPT_LAUNCHERS = /* @__PURE__ */ new Set([
+  "node",
+  "ts-node",
+  "tsx",
+  "ts-node-dev",
+  "nodemon",
+  "npx",
+  "pnpm",
+  "yarn",
+  "npm",
+  "cross-env",
+  "dotenv",
+  "--"
+]);
+function looksLikeEntryPath(token) {
+  if (token.length === 0) return false;
+  if (token.startsWith("-")) return false;
+  if (token.includes("=")) return false;
+  if (token.includes("/")) return true;
+  return /\.(?:m?[jt]sx?|c[jt]s)$/.test(token);
+}
+function scriptHasShellChain(script) {
+  return /(?:&&|\|\||;|\|(?!\|))/.test(script);
+}
+function entryFromScript(script) {
+  if (!script) return void 0;
+  if (scriptHasShellChain(script)) return void 0;
+  const tokens = script.split(/\s+/).filter((t) => t.length > 0);
+  for (const token of tokens) {
+    const lower = token.toLowerCase();
+    if (SCRIPT_LAUNCHERS.has(lower)) continue;
+    const cleaned = token.startsWith("./") ? token.slice(2) : token;
+    if (looksLikeEntryPath(cleaned)) return cleaned;
+  }
+  return void 0;
+}
+async function resolveEntry(serviceDir, pkg) {
+  if (typeof pkg.main === "string" && pkg.main.length > 0) {
+    const candidate = import_node_path38.default.resolve(serviceDir, pkg.main);
+    if (await exists2(candidate)) return candidate;
+  }
+  if (pkg.bin) {
+    let binEntry;
+    if (typeof pkg.bin === "string") {
+      binEntry = pkg.bin;
+    } else if (pkg.name && typeof pkg.bin[pkg.name] === "string") {
+      binEntry = pkg.bin[pkg.name];
+    } else {
+      const first = Object.values(pkg.bin)[0];
+      if (typeof first === "string") binEntry = first;
+    }
+    if (binEntry) {
+      const candidate = import_node_path38.default.resolve(serviceDir, binEntry);
+      if (await exists2(candidate)) return candidate;
+    }
+  }
+  const startEntry = entryFromScript(pkg.scripts?.start);
+  if (startEntry) {
+    const candidate = import_node_path38.default.resolve(serviceDir, startEntry);
+    if (await exists2(candidate)) return candidate;
+  }
+  const devEntry = entryFromScript(pkg.scripts?.dev);
+  if (devEntry) {
+    const candidate = import_node_path38.default.resolve(serviceDir, devEntry);
+    if (await exists2(candidate)) return candidate;
+  }
+  for (const rel of SRC_INDEX_CANDIDATES) {
+    const candidate = import_node_path38.default.join(serviceDir, rel);
+    if (await exists2(candidate)) return candidate;
+  }
+  for (const rel of SRC_NAMED_CANDIDATES) {
+    const candidate = import_node_path38.default.join(serviceDir, rel);
+    if (await exists2(candidate)) return candidate;
+  }
+  for (const name of INDEX_CANDIDATES) {
+    const candidate = import_node_path38.default.join(serviceDir, name);
+    if (await exists2(candidate)) return candidate;
   }
-  return `node ${AUTO_INSTRUMENT_REQUIRE} -- ${start}`;
+  return null;
+}
+function dispatchEntry(entryFile, pkg) {
+  const ext = import_node_path38.default.extname(entryFile).toLowerCase();
+  if (ext === ".ts" || ext === ".tsx") return "ts";
+  if (ext === ".mjs") return "esm";
+  if (ext === ".cjs") return "cjs";
+  return pkg.type === "module" ? "esm" : "cjs";
+}
+function otelInitFilename(flavor) {
+  if (flavor === "ts") return "otel-init.ts";
+  if (flavor === "esm") return "otel-init.mjs";
+  return "otel-init.cjs";
+}
+function otelInitContents(flavor) {
+  if (flavor === "ts") return OTEL_INIT_TS;
+  if (flavor === "esm") return OTEL_INIT_ESM;
+  return OTEL_INIT_CJS;
+}
+function injectionLine(flavor, entryFile, otelInitFile) {
+  let rel = import_node_path38.default.relative(import_node_path38.default.dirname(entryFile), otelInitFile);
+  if (!rel.startsWith(".")) rel = `./${rel}`;
+  rel = rel.split(import_node_path38.default.sep).join("/");
+  if (flavor === "cjs") return `require('${rel}')`;
+  if (flavor === "esm") return `import '${rel}'`;
+  const tsRel = rel.replace(/\.ts$/, "");
+  return `import '${tsRel}'`;
+}
+function lineIsOtelInjection(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) return false;
+  return /(?:require\(|import\s+)['"]\.\/otel-init[^'"]*['"]/.test(trimmed);
 }
 async function plan(serviceDir) {
   const pkg = await readPackageJson(serviceDir);
@@ -5951,9 +6152,17 @@ async function plan(serviceDir) {
     serviceDir,
     dependencyEdits: [],
     entrypointEdits: [],
-    envEdits: []
+    envEdits: [],
+    generatedFiles: []
   };
   if (!pkg) return empty;
+  const entryFile = await resolveEntry(serviceDir, pkg);
+  if (!entryFile) {
+    return { ...empty, libOnly: true };
+  }
+  const flavor = dispatchEntry(entryFile, pkg);
+  const otelInitFile = import_node_path38.default.join(import_node_path38.default.dirname(entryFile), otelInitFilename(flavor));
+  const envNeatFile = import_node_path38.default.join(serviceDir, ".env.neat");
   const existingDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
   const dependencyEdits = [];
   for (const sdk of SDK_PACKAGES) {
@@ -5966,14 +6175,37 @@ async function plan(serviceDir) {
     });
   }
   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 });
+  try {
+    const raw = await import_node_fs23.promises.readFile(entryFile, "utf8");
+    const lines = raw.split(/\r?\n/);
+    const firstReal = lines[0]?.startsWith("#!") ? lines[1] ?? "" : lines[0] ?? "";
+    if (!lineIsOtelInjection(firstReal)) {
+      const inject = injectionLine(flavor, entryFile, otelInitFile);
+      entrypointEdits.push({
+        file: entryFile,
+        before: firstReal,
+        after: inject
+      });
     }
+  } catch {
+    return { ...empty, libOnly: true };
+  }
+  const generatedFiles = [];
+  if (!await exists2(otelInitFile)) {
+    generatedFiles.push({
+      file: otelInitFile,
+      contents: otelInitContents(flavor),
+      skipIfExists: true
+    });
   }
-  if (dependencyEdits.length === 0 && entrypointEdits.length === 0) {
+  if (!await exists2(envNeatFile)) {
+    generatedFiles.push({
+      file: envNeatFile,
+      contents: renderEnvNeat(pkg.name ?? import_node_path38.default.basename(serviceDir)),
+      skipIfExists: true
+    });
+  }
+  if (dependencyEdits.length === 0 && entrypointEdits.length === 0 && generatedFiles.length === 0) {
     return empty;
   }
   return {
@@ -5981,53 +6213,129 @@ async function plan(serviceDir) {
     serviceDir,
     dependencyEdits,
     entrypointEdits,
-    envEdits: [OTEL_ENV]
+    envEdits: [OTEL_ENV],
+    generatedFiles,
+    entryFile,
+    libOnly: false
   };
 }
+function isAllowedWritePath(serviceDir, target) {
+  const rel = import_node_path38.default.relative(serviceDir, target);
+  if (rel.startsWith("..")) return false;
+  const base = import_node_path38.default.basename(target);
+  if (base === "package.json") return true;
+  if (base === ".env.neat") return true;
+  if (/^otel-init\.(?:js|cjs|mjs|ts)$/.test(base)) return true;
+  return false;
+}
+async function writeAtomic(file, contents) {
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  await import_node_fs23.promises.writeFile(tmp, contents, "utf8");
+  await import_node_fs23.promises.rename(tmp, file);
+}
 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 { serviceDir } = installPlan;
+  if (installPlan.libOnly) {
+    return {
+      serviceDir,
+      outcome: "lib-only",
+      reason: "no resolvable entry point",
+      writtenFiles: []
+    };
+  }
+  if (installPlan.dependencyEdits.length === 0 && installPlan.entrypointEdits.length === 0 && (installPlan.generatedFiles?.length ?? 0) === 0) {
+    return {
+      serviceDir,
+      outcome: "already-instrumented",
+      writtenFiles: []
+    };
+  }
+  const allTargets = /* @__PURE__ */ new Set();
+  for (const d of installPlan.dependencyEdits) allTargets.add(d.file);
+  for (const e of installPlan.entrypointEdits) allTargets.add(e.file);
+  for (const g of installPlan.generatedFiles ?? []) allTargets.add(g.file);
+  for (const target of allTargets) {
+    const isEntryEdit = installPlan.entrypointEdits.some((e) => e.file === target);
+    if (isEntryEdit) continue;
+    if (!isAllowedWritePath(serviceDir, target)) {
+      throw new Error(
+        `javascript installer: refusing to write outside the allowed path set (ADR-069 \xA77): ${target}`
+      );
+    }
+  }
   const originals = /* @__PURE__ */ new Map();
-  for (const file of touched) {
-    try {
-      originals.set(file, await import_node_fs23.promises.readFile(file, "utf8"));
-    } catch {
+  const createdFiles = [];
+  for (const target of allTargets) {
+    if (await exists2(target)) {
+      try {
+        originals.set(target, await import_node_fs23.promises.readFile(target, "utf8"));
+      } catch {
+      }
     }
   }
+  const writtenFiles = [];
   try {
-    for (const file of touched) {
-      const raw = originals.get(file) ?? "";
+    const manifestTargets = installPlan.dependencyEdits.reduce((acc, e) => {
+      acc.add(e.file);
+      return acc;
+    }, /* @__PURE__ */ new Set());
+    for (const file of manifestTargets) {
+      const raw = originals.get(file);
+      if (raw === void 0) {
+        throw new Error(`javascript installer: cannot read ${file} during apply`);
+      }
       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;
+          if (!(dep.name in (pkg.dependencies ?? {}))) {
+            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 import_node_fs23.promises.writeFile(tmp, newRaw, "utf8");
-      await import_node_fs23.promises.rename(tmp, file);
+      await writeAtomic(file, newRaw);
+      writtenFiles.push(file);
+    }
+    for (const gen of installPlan.generatedFiles ?? []) {
+      if (gen.skipIfExists && await exists2(gen.file)) {
+        continue;
+      }
+      await writeAtomic(gen.file, gen.contents);
+      if (!originals.has(gen.file)) createdFiles.push(gen.file);
+      writtenFiles.push(gen.file);
+    }
+    for (const ep of installPlan.entrypointEdits) {
+      const raw = originals.get(ep.file);
+      if (raw === void 0) {
+        throw new Error(`javascript installer: cannot read entry ${ep.file} during apply`);
+      }
+      const lines = raw.split(/\r?\n/);
+      const hasShebang = lines[0]?.startsWith("#!") ?? false;
+      const insertAt = hasShebang ? 1 : 0;
+      const firstReal = lines[insertAt] ?? "";
+      if (lineIsOtelInjection(firstReal)) continue;
+      lines.splice(insertAt, 0, ep.after);
+      const newRaw = lines.join("\n");
+      await writeAtomic(ep.file, newRaw);
+      writtenFiles.push(ep.file);
     }
   } catch (err) {
-    await rollback(installPlan, originals);
+    await rollback(installPlan, originals, createdFiles);
     throw err;
   }
+  return {
+    serviceDir,
+    outcome: "instrumented",
+    writtenFiles
+  };
 }
-async function rollback(installPlan, originals) {
+async function rollback(installPlan, originals, createdFiles) {
   const restored = [];
+  const removed = [];
   for (const [file, raw] of originals.entries()) {
     try {
       await import_node_fs23.promises.writeFile(file, raw, "utf8");
@@ -6035,6 +6343,13 @@ async function rollback(installPlan, originals) {
     } catch {
     }
   }
+  for (const file of createdFiles) {
+    try {
+      await import_node_fs23.promises.unlink(file);
+      removed.push(file);
+    } catch {
+    }
+  }
   const lines = [
     "# neat-rollback.patch",
     "",
@@ -6042,6 +6357,7 @@ async function rollback(installPlan, originals) {
     "# Files listed below were restored to their pre-apply contents.",
     "",
     ...restored.map((f) => `restored: ${f}`),
+    ...removed.map((f) => `removed:  ${f}`),
     ""
   ];
   const rollbackPath = import_node_path38.default.join(installPlan.serviceDir, "neat-rollback.patch");
@@ -6067,7 +6383,7 @@ var OTEL_ENV2 = {
   key: "OTEL_EXPORTER_OTLP_ENDPOINT",
   value: "http://localhost:4318"
 };
-async function exists2(p) {
+async function exists3(p) {
   try {
     await import_node_fs24.promises.stat(p);
     return true;
@@ -6078,7 +6394,7 @@ async function exists2(p) {
 async function detect2(serviceDir) {
   const markers = ["requirements.txt", "pyproject.toml", "setup.py"];
   for (const m of markers) {
-    if (await exists2(import_node_path39.default.join(serviceDir, m))) return true;
+    if (await exists3(import_node_path39.default.join(serviceDir, m))) return true;
   }
   return false;
 }
@@ -6089,7 +6405,7 @@ function reqPackageName(line) {
 }
 async function planRequirementsTxtEdits(serviceDir) {
   const file = import_node_path39.default.join(serviceDir, "requirements.txt");
-  if (!await exists2(file)) return null;
+  if (!await exists3(file)) return null;
   const raw = await import_node_fs24.promises.readFile(file, "utf8");
   const presentNames = new Set(
     raw.split(/\r?\n/).map(reqPackageName).filter((n) => n.length > 0)
@@ -6099,7 +6415,7 @@ async function planRequirementsTxtEdits(serviceDir) {
 }
 async function planProcfileEdits(serviceDir) {
   const procfile = import_node_path39.default.join(serviceDir, "Procfile");
-  if (!await exists2(procfile)) return [];
+  if (!await exists3(procfile)) return [];
   const raw = await import_node_fs24.promises.readFile(procfile, "utf8");
   const edits = [];
   for (const line of raw.split(/\r?\n/)) {
@@ -6166,10 +6482,13 @@ async function applyProcfile(procfile, edits, original) {
   await import_node_fs24.promises.rename(tmp, procfile);
 }
 async function apply2(installPlan) {
+  const { serviceDir } = 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;
+  if (touched.size === 0) {
+    return { serviceDir, outcome: "already-instrumented", writtenFiles: [] };
+  }
   const originals = /* @__PURE__ */ new Map();
   for (const file of touched) {
     try {
@@ -6177,6 +6496,7 @@ async function apply2(installPlan) {
     } catch {
     }
   }
+  const writtenFiles = [];
   try {
     for (const file of touched) {
       const raw = originals.get(file);
@@ -6186,16 +6506,23 @@ async function apply2(installPlan) {
       const base = import_node_path39.default.basename(file);
       if (base === "requirements.txt") {
         const edits = installPlan.dependencyEdits.filter((e) => e.file === file);
-        if (edits.length > 0) await applyRequirementsTxt(file, edits, raw);
+        if (edits.length > 0) {
+          await applyRequirementsTxt(file, edits, raw);
+          writtenFiles.push(file);
+        }
       } else if (base === "Procfile") {
         const edits = installPlan.entrypointEdits.filter((e) => e.file === file);
-        if (edits.length > 0) await applyProcfile(file, edits, raw);
+        if (edits.length > 0) {
+          await applyProcfile(file, edits, raw);
+          writtenFiles.push(file);
+        }
       }
     }
   } catch (err) {
     await rollback2(installPlan, originals);
     throw err;
   }
+  return { serviceDir, outcome: "instrumented", writtenFiles };
 }
 async function rollback2(installPlan, originals) {
   const restored = [];
@@ -6228,7 +6555,7 @@ var pythonInstaller = {
 // src/installers/shared.ts
 init_cjs_shims();
 function isEmptyPlan(plan3) {
-  return plan3.dependencyEdits.length === 0 && plan3.entrypointEdits.length === 0 && plan3.envEdits.length === 0;
+  return plan3.dependencyEdits.length === 0 && plan3.entrypointEdits.length === 0 && plan3.envEdits.length === 0 && (plan3.generatedFiles?.length ?? 0) === 0;
 }
 
 // src/installers/index.ts
@@ -6270,8 +6597,18 @@ function renderPatch(sections) {
     const { installer, plan: plan3 } = section;
     lines.push(`## ${installer} (${plan3.language}) \u2014 ${plan3.serviceDir}`);
     lines.push("");
+    if (plan3.libOnly) {
+      lines.push("### skipped \u2014 no resolvable entry point (lib-only)");
+      lines.push("");
+      continue;
+    }
+    if (plan3.entryFile) {
+      lines.push(`entry: ${plan3.entryFile}`);
+      lines.push("");
+    }
     if (plan3.dependencyEdits.length > 0) {
       lines.push("### dependencies");
+      const byFile = /* @__PURE__ */ new Map();
       for (const dep of plan3.dependencyEdits) {
         const base = dep.file.split(/[\\/]/).pop() ?? dep.file;
         if (FORBIDDEN_LOCKFILES.has(base)) {
@@ -6279,24 +6616,41 @@ function renderPatch(sections) {
             `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}`);
+        const existing = byFile.get(dep.file) ?? [];
+        existing.push(dep);
+        byFile.set(dep.file, existing);
+      }
+      for (const [file, deps] of byFile) {
+        lines.push(`--- ${file}`);
+        for (const dep of deps) {
+          lines.push(`+ "${dep.name}": "${dep.version}"`);
+        }
+      }
+      lines.push("");
+    }
+    if (plan3.generatedFiles && plan3.generatedFiles.length > 0) {
+      lines.push("### generated files");
+      for (const gen of plan3.generatedFiles) {
+        lines.push(`--- (new file) ${gen.file}`);
+        for (const ln of gen.contents.split(/\r?\n/)) {
+          lines.push(`+ ${ln}`);
+        }
       }
       lines.push("");
     }
     if (plan3.entrypointEdits.length > 0) {
-      lines.push("### entrypoint");
+      lines.push("### entry-point injection");
       for (const e of plan3.entrypointEdits) {
-        lines.push(`- ${e.file}`);
-        lines.push(`    - before: ${e.before}`);
-        lines.push(`    - after:  ${e.after}`);
+        lines.push(`--- ${e.file}`);
+        lines.push(`+ ${e.after}`);
+        lines.push(`  ${e.before}`);
       }
       lines.push("");
     }
     if (plan3.envEdits.length > 0) {
-      lines.push("### env");
+      lines.push("### env (written to <package-dir>/.env.neat)");
       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(`- ${env.key}=${env.value}`);
       }
       lines.push("");
     }
@@ -7045,7 +7399,7 @@ async function buildPatchSections(services) {
     const installer = await pickInstaller(svc.dir);
     if (!installer) continue;
     const plan3 = await installer.plan(svc.dir);
-    if (isEmptyPlan(plan3)) continue;
+    if (isEmptyPlan(plan3) && !plan3.libOnly) continue;
     sections.push({ installer: installer.name, plan: plan3 });
   }
   return sections;
@@ -7098,14 +7452,28 @@ async function runInit(opts) {
   }
   if (!opts.noInstall) {
     if (opts.apply) {
+      let instrumented = 0;
+      let alreadyInstrumented = 0;
+      let libOnly = 0;
       for (const section of sections) {
         const installer = INSTALLERS.find((i) => i.name === section.installer);
         if (!installer) continue;
-        await installer.apply(section.plan);
+        const outcome = await installer.apply(section.plan);
+        if (outcome.outcome === "instrumented") {
+          instrumented++;
+          for (const f of outcome.writtenFiles) written.push(f);
+        } else if (outcome.outcome === "already-instrumented") {
+          alreadyInstrumented++;
+        } else if (outcome.outcome === "lib-only") {
+          libOnly++;
+        }
       }
       if (sections.length > 0) {
         console.log("");
-        console.log("patch applied. Run `npm install` (or your language equivalent) to refresh lockfiles.");
+        console.log(
+          `apply: instrumented ${instrumented}, already-instrumented ${alreadyInstrumented}, lib-only ${libOnly}`
+        );
+        console.log("Run `npm install` (or your language equivalent) to refresh lockfiles.");
       }
     } else {
       await import_node_fs25.promises.writeFile(patchPath, patch, "utf8");