autotel-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2889 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import * as path6 from "path";
+import { execSync } from "child_process";
+
+// src/lib/project.ts
+import * as path3 from "path";
+
+// src/lib/fs.ts
+import * as fs from "fs";
+import * as path from "path";
+import { randomBytes } from "crypto";
+function isPathWithinRoot(targetPath, rootPath) {
+  const resolvedTarget = path.resolve(targetPath);
+  const resolvedRoot = path.resolve(rootPath);
+  return resolvedTarget.startsWith(resolvedRoot + path.sep) || resolvedTarget === resolvedRoot;
+}
+function ensureDir(filePath) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+function readFileSafe(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function fileExists(filePath) {
+  try {
+    return fs.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+function dirExists(dirPath) {
+  try {
+    return fs.statSync(dirPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function createBackup(filePath) {
+  if (!fileExists(filePath)) {
+    return null;
+  }
+  const backupPath = `${filePath}.bak`;
+  fs.copyFileSync(filePath, backupPath);
+  return backupPath;
+}
+function atomicWrite(filePath, content, options) {
+  const resolvedPath = path.resolve(filePath);
+  if (!isPathWithinRoot(resolvedPath, options.root)) {
+    throw new Error(
+      `Path traversal detected: ${filePath} resolves outside root ${options.root}`
+    );
+  }
+  let backupPath = null;
+  if (options.backup && fileExists(resolvedPath)) {
+    backupPath = createBackup(resolvedPath);
+  }
+  ensureDir(resolvedPath);
+  const tempPath = `${resolvedPath}.${randomBytes(4).toString("hex")}.tmp`;
+  try {
+    fs.writeFileSync(tempPath, content, "utf8");
+    fs.renameSync(tempPath, resolvedPath);
+  } catch (error2) {
+    try {
+      fs.unlinkSync(tempPath);
+    } catch {
+    }
+    throw error2;
+  }
+  return { backupPath };
+}
+function readJsonSafe(filePath) {
+  const content = readFileSafe(filePath);
+  if (content === null) {
+    return null;
+  }
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function findUpward(startDir, filename, stopAtRoot = true) {
+  let currentDir = path.resolve(startDir);
+  const root = path.parse(currentDir).root;
+  while (currentDir !== root) {
+    const filePath = path.join(currentDir, filename);
+    if (fileExists(filePath)) {
+      return filePath;
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+    if (stopAtRoot && currentDir === root) {
+      break;
+    }
+  }
+  const rootFilePath = path.join(root, filename);
+  if (fileExists(rootFilePath)) {
+    return rootFilePath;
+  }
+  return null;
+}
+function findAllUpward(startDir, filenames) {
+  const found = /* @__PURE__ */ new Map();
+  let currentDir = path.resolve(startDir);
+  const root = path.parse(currentDir).root;
+  while (currentDir !== root) {
+    for (const filename of filenames) {
+      if (!found.has(filename)) {
+        const filePath = path.join(currentDir, filename);
+        if (fileExists(filePath)) {
+          found.set(filename, filePath);
+        }
+      }
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return found;
+}
+
+// src/lib/package-manager.ts
+import * as path2 from "path";
+var LOCKFILE_MAP = {
+  "pnpm-lock.yaml": "pnpm",
+  "bun.lockb": "bun",
+  "yarn.lock": "yarn",
+  "package-lock.json": "npm"
+};
+var LOCKFILES = ["pnpm-lock.yaml", "bun.lockb", "yarn.lock", "package-lock.json"];
+var PM_PRIORITY = ["pnpm", "bun", "yarn", "npm"];
+function detectPackageManager(startDir) {
+  const foundLockfiles = findAllUpward(startDir, LOCKFILES);
+  if (foundLockfiles.size === 0) {
+    return { packageManager: "npm", lockfilePath: null };
+  }
+  let closestLockfile = null;
+  let closestDepth = -1;
+  let closestPM = "npm";
+  for (const [lockfileName, lockfilePath] of foundLockfiles) {
+    const depth = lockfilePath.split(path2.sep).length;
+    const pm = LOCKFILE_MAP[lockfileName];
+    if (pm === void 0) continue;
+    if (depth > closestDepth || depth === closestDepth && PM_PRIORITY.indexOf(pm) < PM_PRIORITY.indexOf(closestPM)) {
+      closestDepth = depth;
+      closestLockfile = lockfilePath;
+      closestPM = pm;
+    }
+  }
+  return {
+    packageManager: closestPM,
+    lockfilePath: closestLockfile
+  };
+}
+function getInstallCommand(pm, packages, options = {}) {
+  const pkgList = packages.join(" ");
+  const { dev = false, workspaceRoot = false } = options;
+  switch (pm) {
+    case "pnpm": {
+      const devFlag = dev ? " -D" : "";
+      const wsFlag = workspaceRoot ? " -w" : "";
+      return `pnpm add${devFlag}${wsFlag} ${pkgList}`;
+    }
+    case "bun": {
+      const devFlag = dev ? " -d" : "";
+      return `bun add${devFlag} ${pkgList}`;
+    }
+    case "yarn": {
+      const devFlag = dev ? " -D" : "";
+      const wsFlag = workspaceRoot ? " -W" : "";
+      return `yarn add${devFlag}${wsFlag} ${pkgList}`;
+    }
+    case "npm":
+    default: {
+      const devFlag = dev ? " --save-dev" : "";
+      return `npm install${devFlag} ${pkgList}`;
+    }
+  }
+}
+function detectWorkspaceRoot(startDir) {
+  let currentDir = path2.resolve(startDir);
+  const root = path2.parse(currentDir).root;
+  while (currentDir !== root) {
+    if (fileExists(path2.join(currentDir, "pnpm-workspace.yaml"))) {
+      return { workspaceRoot: currentDir, workspaceType: "pnpm" };
+    }
+    if (fileExists(path2.join(currentDir, "lerna.json"))) {
+      return { workspaceRoot: currentDir, workspaceType: "lerna" };
+    }
+    const pkgJsonPath = path2.join(currentDir, "package.json");
+    const pkgJsonContent = readFileSafe(pkgJsonPath);
+    if (pkgJsonContent) {
+      try {
+        const pkgJson = JSON.parse(pkgJsonContent);
+        if (pkgJson.workspaces) {
+          const hasYarnLock = fileExists(path2.join(currentDir, "yarn.lock"));
+          return {
+            workspaceRoot: currentDir,
+            workspaceType: hasYarnLock ? "yarn" : "npm"
+          };
+        }
+      } catch {
+      }
+    }
+    const parentDir = path2.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return { workspaceRoot: null, workspaceType: null };
+}
+
+// src/lib/project.ts
+function findPackageJson(startDir) {
+  const packageJsonPath = findUpward(startDir, "package.json");
+  if (!packageJsonPath) {
+    return null;
+  }
+  return {
+    packageJsonPath,
+    packageRoot: path3.dirname(packageJsonPath)
+  };
+}
+function detectTypeScript(packageRoot) {
+  if (fileExists(path3.join(packageRoot, "tsconfig.json"))) {
+    return true;
+  }
+  const pkgJson = readJsonSafe(path3.join(packageRoot, "package.json"));
+  if (pkgJson) {
+    const deps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
+    if ("typescript" in deps) {
+      return true;
+    }
+  }
+  return false;
+}
+function detectEsm(packageJson) {
+  return packageJson.type === "module";
+}
+function buildWorkspaceInfo(packageRoot, cwd) {
+  const { workspaceRoot, workspaceType } = detectWorkspaceRoot(cwd);
+  return {
+    isMonorepo: workspaceRoot !== null && workspaceRoot !== packageRoot,
+    workspaceRoot,
+    packageRoot,
+    workspaceType
+  };
+}
+function discoverProject(cwd) {
+  const resolvedCwd = path3.resolve(cwd);
+  const pkgResult = findPackageJson(resolvedCwd);
+  if (!pkgResult) {
+    return null;
+  }
+  const { packageJsonPath, packageRoot } = pkgResult;
+  const packageJson = readJsonSafe(packageJsonPath);
+  if (!packageJson) {
+    return null;
+  }
+  const { packageManager, lockfilePath } = detectPackageManager(packageRoot);
+  const workspace = buildWorkspaceInfo(packageRoot, resolvedCwd);
+  const hasTypeScript = detectTypeScript(packageRoot);
+  const isEsm = detectEsm(packageJson);
+  return {
+    cwd: resolvedCwd,
+    packageRoot,
+    packageJson,
+    packageJsonPath,
+    packageManager,
+    lockfilePath,
+    workspace,
+    hasTypeScript,
+    isEsm
+  };
+}
+function getEntrypointCandidates(packageRoot) {
+  const candidates = [
+    "src/index.ts",
+    "src/main.ts",
+    "src/index.mts",
+    "src/main.mts",
+    "server.ts",
+    "app.ts",
+    "index.ts",
+    "src/index.js",
+    "src/main.js",
+    "server.js",
+    "app.js",
+    "index.js"
+  ];
+  return candidates.map((c) => path3.join(packageRoot, c)).filter((p) => fileExists(p));
+}
+function getInstrumentationPath(packageRoot, hasTypeScript) {
+  const srcDir = path3.join(packageRoot, "src");
+  const hasSrcDir = dirExists(srcDir) || fileExists(path3.join(packageRoot, "src", "index.ts")) || fileExists(path3.join(packageRoot, "src", "index.js"));
+  const dir = hasSrcDir ? path3.join(packageRoot, "src") : packageRoot;
+  const ext = hasTypeScript ? "mts" : "mjs";
+  return path3.join(dir, `instrumentation.${ext}`);
+}
+
+// src/lib/config-detector.ts
+import * as path4 from "path";
+
+// src/lib/code-builder.ts
+var CLI_HEADER = `/**
+ * autotel instrumentation - managed by autotel-cli
+ * Run \`autotel add <feature>\` to update this file
+ */`;
+var SECTION_MARKER = (name) => `// --- AUTOTEL:${name} ---`;
+function createCodeFile() {
+  return {
+    imports: [],
+    backendImports: [],
+    pluginImports: [],
+    subscriberImports: [],
+    backendConfig: null,
+    subscribersConfig: [],
+    pluginInit: []
+  };
+}
+function addImport(file, imp, section) {
+  switch (section) {
+    case "backend":
+      file.backendImports.push(imp);
+      break;
+    case "plugin":
+      file.pluginImports.push(imp);
+      break;
+    case "subscriber":
+      file.subscriberImports.push(imp);
+      break;
+    default:
+      file.imports.push(imp);
+  }
+}
+function setBackendConfig(file, config) {
+  file.backendConfig = config;
+}
+function addSubscriberConfig(file, config) {
+  file.subscribersConfig.push(config);
+}
+function addPluginInit(file, init) {
+  file.pluginInit.push(init);
+}
+function sortImports(imports) {
+  const sideEffect = [];
+  const external = [];
+  const relative3 = [];
+  for (const imp of imports) {
+    if (imp.sideEffect) {
+      if (imp.source === "autotel/register") {
+        sideEffect.unshift(imp);
+      } else {
+        sideEffect.push(imp);
+      }
+    } else if (imp.source.startsWith(".") || imp.source.startsWith("/")) {
+      relative3.push(imp);
+    } else {
+      external.push(imp);
+    }
+  }
+  const sortBySource = (a, b) => a.source.localeCompare(b.source);
+  external.sort(sortBySource);
+  relative3.sort(sortBySource);
+  return [...sideEffect, ...external, ...relative3];
+}
+function renderImport(imp) {
+  if (imp.sideEffect) {
+    return `import '${imp.source}';`;
+  }
+  const parts = [];
+  if (imp.default) {
+    parts.push(imp.default);
+  }
+  if (imp.specifiers && imp.specifiers.length > 0) {
+    const specifiers = imp.specifiers.join(", ");
+    parts.push(`{ ${specifiers} }`);
+  }
+  if (parts.length === 0) {
+    return `import '${imp.source}';`;
+  }
+  return `import ${parts.join(", ")} from '${imp.source}';`;
+}
+function renderImports(imports) {
+  if (imports.length === 0) {
+    return "";
+  }
+  const sorted = sortImports(imports);
+  return sorted.map(renderImport).join("\n");
+}
+function renderCodeFile(file) {
+  const lines = [];
+  lines.push(CLI_HEADER);
+  lines.push("");
+  const mainImports = sortImports(file.imports);
+  if (mainImports.length > 0) {
+    lines.push(renderImports(mainImports));
+    lines.push("");
+  }
+  if (file.backendImports.length > 0) {
+    lines.push(SECTION_MARKER("BACKEND"));
+    lines.push(renderImports(file.backendImports));
+    lines.push("");
+  }
+  if (file.pluginImports.length > 0) {
+    lines.push(SECTION_MARKER("PLUGINS"));
+    lines.push(renderImports(file.pluginImports));
+    lines.push("");
+  }
+  if (file.subscriberImports.length > 0) {
+    lines.push(SECTION_MARKER("SUBSCRIBERS"));
+    lines.push(renderImports(file.subscriberImports));
+    lines.push("");
+  }
+  lines.push("init({");
+  if (file.backendConfig) {
+    lines.push("  " + SECTION_MARKER("BACKEND_CONFIG"));
+    lines.push(`  ${file.backendConfig}`);
+  }
+  if (file.subscribersConfig.length > 0) {
+    lines.push("");
+    lines.push("  " + SECTION_MARKER("SUBSCRIBERS_CONFIG"));
+    lines.push("  subscribers: [");
+    for (const sub of file.subscribersConfig) {
+      lines.push(`    ${sub}`);
+    }
+    lines.push("  ],");
+  }
+  lines.push("});");
+  if (file.pluginInit.length > 0) {
+    lines.push("");
+    lines.push(SECTION_MARKER("PLUGIN_INIT"));
+    for (const init of file.pluginInit) {
+      lines.push(init);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function hasCliOwnershipHeader(content) {
+  return content.includes("autotel instrumentation - managed by autotel-cli");
+}
+function getSectionMarkers(content) {
+  const markers = [];
+  const regex = /\/\/ --- AUTOTEL:(\w+) ---/g;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    if (match[1]) {
+      markers.push(match[1]);
+    }
+  }
+  return markers;
+}
+
+// src/lib/config-detector.ts
+var INSTRUMENTATION_LOCATIONS = [
+  "src/instrumentation.mts",
+  "src/instrumentation.ts",
+  "src/instrumentation.mjs",
+  "src/instrumentation.js",
+  "instrumentation.mts",
+  "instrumentation.ts",
+  "instrumentation.mjs",
+  "instrumentation.js"
+];
+function findInstrumentationFile(packageRoot) {
+  for (const location of INSTRUMENTATION_LOCATIONS) {
+    const filePath = path4.join(packageRoot, location);
+    if (fileExists(filePath)) {
+      const content = readFileSafe(filePath);
+      if (content === null) {
+        continue;
+      }
+      const isCliOwned = hasCliOwnershipHeader(content);
+      const markerStrings = getSectionMarkers(content);
+      const sections = markerStrings.filter(
+        (m) => ["BACKEND", "PLUGINS", "SUBSCRIBERS", "BACKEND_CONFIG", "SUBSCRIBERS_CONFIG", "PLUGIN_INIT"].includes(m)
+      );
+      return {
+        path: filePath,
+        isCliOwned,
+        sections
+      };
+    }
+  }
+  return null;
+}
+function findAutotelYaml(packageRoot) {
+  const candidates = ["autotel.yaml", "autotel.yml", ".autotelrc.yaml", ".autotelrc.yml"];
+  for (const candidate of candidates) {
+    const filePath = path4.join(packageRoot, candidate);
+    if (fileExists(filePath)) {
+      return filePath;
+    }
+  }
+  return null;
+}
+function detectConfig(packageRoot) {
+  const instrumentationFile = findInstrumentationFile(packageRoot);
+  if (instrumentationFile?.isCliOwned) {
+    return {
+      found: true,
+      type: "cli-owned",
+      path: instrumentationFile.path,
+      instrumentationFile
+    };
+  }
+  if (instrumentationFile && !instrumentationFile.isCliOwned) {
+    return {
+      found: true,
+      type: "user-created",
+      path: instrumentationFile.path,
+      instrumentationFile
+    };
+  }
+  const yamlPath = findAutotelYaml(packageRoot);
+  if (yamlPath) {
+    return {
+      found: true,
+      type: "autotel-yaml",
+      path: yamlPath,
+      instrumentationFile: null
+    };
+  }
+  return {
+    found: false,
+    type: "none",
+    path: null,
+    instrumentationFile: null
+  };
+}
+function isFeatureConfigured(instrumentationFile, feature) {
+  switch (feature) {
+    case "backend":
+    case "platform":
+      return instrumentationFile.sections.includes("BACKEND") || instrumentationFile.sections.includes("BACKEND_CONFIG");
+    case "subscriber":
+      return instrumentationFile.sections.includes("SUBSCRIBERS") || instrumentationFile.sections.includes("SUBSCRIBERS_CONFIG");
+    case "plugin":
+      return instrumentationFile.sections.includes("PLUGINS") || instrumentationFile.sections.includes("PLUGIN_INIT");
+  }
+}
+
+// src/lib/env-generator.ts
+import * as path5 from "path";
+import { glob } from "glob";
+function generateEnvExample(envVars) {
+  if (envVars.length === 0) {
+    return "";
+  }
+  const lines = [
+    "# Autotel configuration",
+    "# Copy to .env and fill in values",
+    ""
+  ];
+  for (const envVar of envVars) {
+    lines.push(`# ${envVar.description}`);
+    if (envVar.sensitive) {
+      lines.push("# \u26A0\uFE0F SENSITIVE: Do not commit this value");
+    }
+    const value = envVar.example ?? "";
+    lines.push(`${envVar.name}=${value}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function parseEnvFile(content) {
+  const vars = /* @__PURE__ */ new Map();
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#") || trimmed === "") {
+      continue;
+    }
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex > 0) {
+      const key = trimmed.slice(0, eqIndex).trim();
+      let value = trimmed.slice(eqIndex + 1).trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      vars.set(key, value);
+    }
+  }
+  return vars;
+}
+async function findEnvFiles(packageRoot) {
+  const patterns = [".env", ".env.local", ".env.*"];
+  const files = [];
+  for (const pattern of patterns) {
+    try {
+      const matches = await glob(pattern, {
+        cwd: packageRoot,
+        absolute: true,
+        dot: true
+      });
+      files.push(...matches);
+    } catch {
+    }
+  }
+  return [...new Set(files)].filter((f) => fileExists(f));
+}
+async function checkEnvVarPresent(packageRoot, varName, specificFile) {
+  const files = specificFile ? [path5.resolve(packageRoot, specificFile)] : await findEnvFiles(packageRoot);
+  for (const file of files) {
+    const content = readFileSafe(file);
+    if (content === null) {
+      continue;
+    }
+    const vars = parseEnvFile(content);
+    if (vars.has(varName)) {
+      return { found: true, file };
+    }
+  }
+  return { found: false, file: null };
+}
+async function checkEnvVarsPresent(packageRoot, varNames, specificFile) {
+  const results = /* @__PURE__ */ new Map();
+  for (const varName of varNames) {
+    const result = await checkEnvVarPresent(packageRoot, varName, specificFile);
+    results.set(varName, result);
+  }
+  return results;
+}
+
+// src/lib/dependency-planner.ts
+function createDependencyPlan() {
+  return {
+    required: [],
+    optional: [],
+    devOnly: []
+  };
+}
+function mergePackages(target, source) {
+  for (const pkg of source) {
+    if (!target.includes(pkg)) {
+      target.push(pkg);
+    }
+  }
+}
+function addPresetToPlan(plan, preset) {
+  mergePackages(plan.required, preset.packages.required);
+  mergePackages(plan.optional, preset.packages.optional);
+  mergePackages(plan.devOnly, preset.packages.devOnly);
+}
+function addPresetsToPlan(plan, presets) {
+  for (const preset of presets) {
+    addPresetToPlan(plan, preset);
+  }
+}
+function getProdPackages(plan) {
+  return [...plan.required, ...plan.optional];
+}
+function getDevPackages(plan) {
+  return [...plan.devOnly];
+}
+function addCorePackages(plan) {
+  mergePackages(plan.required, ["autotel"]);
+}
+function addAutoInstrumentationPackages(plan, selection) {
+  if (selection === "none") {
+    return;
+  }
+  if (selection === "all") {
+    mergePackages(plan.required, ["@opentelemetry/auto-instrumentations-node"]);
+    return;
+  }
+  for (const name of selection) {
+    mergePackages(plan.required, [`@opentelemetry/instrumentation-${name}`]);
+  }
+}
+function buildDependencyPlan(options) {
+  const plan = createDependencyPlan();
+  addCorePackages(plan);
+  addPresetsToPlan(plan, options.presets);
+  addAutoInstrumentationPackages(plan, options.autoInstrumentations);
+  return plan;
+}
+
+// src/presets/backends/datadog.ts
+var datadogDirect = {
+  name: "Datadog (Direct)",
+  slug: "datadog",
+  type: "backend",
+  description: "Send traces directly to Datadog via OTLP HTTP",
+  protocol: "http",
+  exporter: "otlp-http",
+  packages: {
+    required: [
+      "autotel-backends",
+      "@opentelemetry/exporter-trace-otlp-http"
+    ],
+    optional: [
+      "@opentelemetry/sdk-logs",
+      "@opentelemetry/exporter-logs-otlp-http"
+    ],
+    devOnly: []
+  },
+  env: {
+    required: [
+      {
+        name: "DATADOG_API_KEY",
+        description: "Datadog API key for authentication",
+        example: "your-api-key",
+        sensitive: true
+      }
+    ],
+    optional: [
+      {
+        name: "DATADOG_SITE",
+        description: "Datadog region (e.g., datadoghq.eu for EU)",
+        example: "datadoghq.com",
+        sensitive: false
+      },
+      {
+        name: "DD_ENV",
+        description: "Environment tag (e.g., production, staging)",
+        example: "production",
+        sensitive: false
+      },
+      {
+        name: "DD_SERVICE",
+        description: "Service name override",
+        example: "my-service",
+        sensitive: false
+      },
+      {
+        name: "DD_VERSION",
+        description: "Version tag",
+        example: "1.0.0",
+        sensitive: false
+      }
+    ]
+  },
+  imports: [
+    {
+      source: "autotel-backends/datadog",
+      specifiers: ["createDatadogConfig"]
+    }
+  ],
+  configBlock: {
+    type: "backend",
+    code: `...createDatadogConfig({
+    apiKey: process.env.DATADOG_API_KEY,
+    site: process.env.DATADOG_SITE,
+  }),`,
+    section: "BACKEND_CONFIG"
+  },
+  nextSteps: [
+    "Set DATADOG_API_KEY environment variable",
+    "Optionally set DD_ENV, DD_SERVICE, DD_VERSION for unified service tagging"
+  ]
+};
+var datadogAgent = {
+  name: "Datadog (Agent)",
+  slug: "datadog-agent",
+  type: "backend",
+  description: "Send traces to Datadog via local agent",
+  protocol: "http",
+  exporter: "otlp-http",
+  packages: {
+    required: [
+      "autotel-backends",
+      "@opentelemetry/exporter-trace-otlp-http"
+    ],
+    optional: [
+      "@opentelemetry/sdk-logs",
+      "@opentelemetry/exporter-logs-otlp-http"
+    ],
+    devOnly: []
+  },
+  env: {
+    required: [],
+    optional: [
+      {
+        name: "DD_AGENT_HOST",
+        description: "Datadog Agent hostname",
+        example: "localhost",
+        sensitive: false
+      },
+      {
+        name: "DD_OTLP_PORT",
+        description: "OTLP receiver port on Agent",
+        example: "4318",
+        sensitive: false
+      },
+      {
+        name: "DD_ENV",
+        description: "Environment tag (e.g., production, staging)",
+        example: "production",
+        sensitive: false
+      },
+      {
+        name: "DD_SERVICE",
+        description: "Service name override",
+        example: "my-service",
+        sensitive: false
+      }
+    ]
+  },
+  imports: [
+    {
+      source: "autotel-backends/datadog",
+      specifiers: ["createDatadogAgentConfig"]
+    }
+  ],
+  configBlock: {
+    type: "backend",
+    code: `...createDatadogAgentConfig({
+    agentHost: process.env.DD_AGENT_HOST ?? 'localhost',
+    otlpPort: process.env.DD_OTLP_PORT ?? '4318',
+  }),`,
+    section: "BACKEND_CONFIG"
+  },
+  nextSteps: [
+    "Ensure Datadog Agent is running with OTLP receiver enabled",
+    "Agent handles authentication - no API key needed in app"
+  ]
+};
+
+// src/presets/backends/honeycomb.ts
+var honeycomb = {
+  name: "Honeycomb",
+  slug: "honeycomb",
+  type: "backend",
+  description: "Send traces to Honeycomb via OTLP gRPC",
+  protocol: "grpc",
+  exporter: "otlp-grpc",
+  packages: {
+    required: [
+      "autotel-backends",
+      "@opentelemetry/exporter-trace-otlp-grpc"
+    ],
+    optional: [
+      "@opentelemetry/sdk-logs",
+      "@opentelemetry/exporter-logs-otlp-grpc"
+    ],
+    devOnly: []
+  },
+  env: {
+    required: [
+      {
+        name: "HONEYCOMB_API_KEY",
+        description: "Honeycomb API key (Ingest Key)",
+        example: "your-api-key",
+        sensitive: true
+      }
+    ],
+    optional: [
+      {
+        name: "HONEYCOMB_DATASET",
+        description: "Dataset name (Classic accounts only)",
+        example: "my-dataset",
+        sensitive: false
+      },
+      {
+        name: "OTEL_SERVICE_NAME",
+        description: "Service name for traces",
+        example: "my-service",
+        sensitive: false
+      }
+    ]
+  },
+  imports: [
+    {
+      source: "autotel-backends/honeycomb",
+      specifiers: ["createHoneycombConfig"]
+    }
+  ],
+  configBlock: {
+    type: "backend",
+    code: `...createHoneycombConfig({
+    apiKey: process.env.HONEYCOMB_API_KEY,
+    dataset: process.env.HONEYCOMB_DATASET,
+  }),`,
+    section: "BACKEND_CONFIG"
+  },
+  nextSteps: [
+    "Set HONEYCOMB_API_KEY environment variable",
+    "Get your API key from Honeycomb Team Settings > API Keys"
+  ]
+};
+
+// src/presets/backends/otlp.ts
+var otlpHttp = {
+  name: "OTLP (HTTP)",
+  slug: "otlp-http",
+  type: "backend",
+  description: "Send traces to any OTLP-compatible endpoint via HTTP",
+  protocol: "http",
+  exporter: "otlp-http",
+  packages: {
+    required: [
+      "autotel-backends",
+      "@opentelemetry/exporter-trace-otlp-http"
+    ],
+    optional: [
+      "@opentelemetry/sdk-logs",
+      "@opentelemetry/exporter-logs-otlp-http"
+    ],
+    devOnly: []
+  },
+  env: {
+    required: [
+      {
+        name: "OTEL_EXPORTER_OTLP_ENDPOINT",
+        description: "OTLP endpoint URL",
+        example: "http://localhost:4318",
+        sensitive: false
+      }
+    ],
+    optional: [
+      {
+        name: "OTEL_EXPORTER_OTLP_HEADERS",
+        description: "Headers for authentication (key=value pairs)",
+        example: "Authorization=Bearer token",
+        sensitive: true
+      },
+      {
+        name: "OTEL_SERVICE_NAME",
+        description: "Service name for traces",
+        example: "my-service",
+        sensitive: false
+      }
+    ]
+  },
+  imports: [
+    {
+      source: "autotel-backends/otlp",
+      specifiers: ["createOtlpHttpConfig"]
+    }
+  ],
+  configBlock: {
+    type: "backend",
+    code: `...createOtlpHttpConfig({
+    endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+  }),`,
+    section: "BACKEND_CONFIG"
+  },
+  nextSteps: [
+    "Set OTEL_EXPORTER_OTLP_ENDPOINT to your collector or backend URL",
+    "Add authentication headers if required by your endpoint"
+  ]
+};
+var otlpGrpc = {
+  name: "OTLP (gRPC)",
+  slug: "otlp-grpc",
+  type: "backend",
+  description: "Send traces to any OTLP-compatible endpoint via gRPC",
+  protocol: "grpc",
+  exporter: "otlp-grpc",
+  packages: {
+    required: [
+      "autotel-backends",
+      "@opentelemetry/exporter-trace-otlp-grpc"
+    ],
+    optional: [
+      "@opentelemetry/sdk-logs",
+      "@opentelemetry/exporter-logs-otlp-grpc"
+    ],
+    devOnly: []
+  },
+  env: {
+    required: [
+      {
+        name: "OTEL_EXPORTER_OTLP_ENDPOINT",
+        description: "OTLP gRPC endpoint URL",
+        example: "http://localhost:4317",
+        sensitive: false
+      }
+    ],
+    optional: [
+      {
+        name: "OTEL_EXPORTER_OTLP_HEADERS",
+        description: "Headers for authentication (key=value pairs)",
+        example: "Authorization=Bearer token",
+        sensitive: true
+      },
+      {
+        name: "OTEL_SERVICE_NAME",
+        description: "Service name for traces",
+        example: "my-service",
+        sensitive: false
+      }
+    ]
+  },
+  imports: [
+    {
+      source: "autotel-backends/otlp",
+      specifiers: ["createOtlpGrpcConfig"]
+    }
+  ],
+  configBlock: {
+    type: "backend",
+    code: `...createOtlpGrpcConfig({
+    endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+  }),`,
+    section: "BACKEND_CONFIG"
+  },
+  nextSteps: [
+    "Set OTEL_EXPORTER_OTLP_ENDPOINT to your collector or backend URL",
+    "gRPC typically uses port 4317 (HTTP uses 4318)"
+  ]
+};
+var local = {
+  name: "Local/Console",
+  slug: "local",
+  type: "backend",
+  description: "Print traces to console (development only)",
+  protocol: "http",
+  exporter: "otlp-http",
+  packages: {
+    required: [],
+    optional: [],
+    devOnly: []
+  },
+  env: {
+    required: [],
+    optional: []
+  },
+  imports: [],
+  configBlock: {
+    type: "backend",
+    code: "// Local/console mode - no backend configured",
+    section: "BACKEND_CONFIG"
+  },
+  nextSteps: [
+    "Traces will be logged to console",
+    "Run `autotel add backend <provider>` to add a real backend"
+  ]
+};
+
+// src/presets/subscribers/posthog.ts
+var posthog = {
+  name: "PostHog",
+  slug: "posthog",
+  type: "subscriber",
+  description: "Send events to PostHog for product analytics",
+  packages: {
+    required: [
+      "autotel-subscribers",
+      "posthog-node"
+    ],
+    optional: [],
+    devOnly: []
+  },
+  env: {
+    required: [
+      {
+        name: "POSTHOG_API_KEY",
+        description: "PostHog Project API Key",
+        example: "phc_...",
+        sensitive: true
+      }
+    ],
+    optional: [
+      {
+        name: "POSTHOG_HOST",
+        description: "PostHog host URL (for self-hosted)",
+        example: "https://app.posthog.com",
+        sensitive: false
+      }
+    ]
+  },
+  imports: [
+    {
+      source: "autotel-subscribers/posthog",
+      specifiers: ["PostHogSubscriber"]
+    }
+  ],
+  configBlock: {
+    type: "subscriber",
+    code: `new PostHogSubscriber({
+      apiKey: process.env.POSTHOG_API_KEY,
+      host: process.env.POSTHOG_HOST,
+    }),`,
+    section: "SUBSCRIBERS_CONFIG"
+  },
+  nextSteps: [
+    "Set POSTHOG_API_KEY from PostHog Project Settings",
+    "Events will be sent to PostHog as custom events"
+  ]
+};
+
+// src/presets/subscribers/mixpanel.ts
+var mixpanel = {
+  name: "Mixpanel",
+  slug: "mixpanel",
+  type: "subscriber",
+  description: "Send events to Mixpanel for product analytics",
+  packages: {
+    required: [
+      "autotel-subscribers",
+      "mixpanel"
+    ],
+    optional: [],
+    devOnly: [
+      "@types/mixpanel"
+    ]
+  },
+  env: {
+    required: [
+      {
+        name: "MIXPANEL_TOKEN",
+        description: "Mixpanel Project Token",
+        example: "your-project-token",
+        sensitive: true
+      }
+    ],
+    optional: [
+      {
+        name: "MIXPANEL_API_HOST",
+        description: "Mixpanel API host (for EU data residency)",
+        example: "api-eu.mixpanel.com",
+        sensitive: false
+      }
+    ]
+  },
+  imports: [
+    {
+      source: "autotel-subscribers/mixpanel",
+      specifiers: ["MixpanelSubscriber"]
+    }
+  ],
+  configBlock: {
+    type: "subscriber",
+    code: `new MixpanelSubscriber({
+      token: process.env.MIXPANEL_TOKEN,
+    }),`,
+    section: "SUBSCRIBERS_CONFIG"
+  },
+  nextSteps: [
+    "Set MIXPANEL_TOKEN from Mixpanel Project Settings",
+    "Events will be tracked as Mixpanel events"
+  ]
+};
+var amplitude = {
+  name: "Amplitude",
+  slug: "amplitude",
+  type: "subscriber",
+  description: "Send events to Amplitude for product analytics",
+  packages: {
+    required: [
+      "autotel-subscribers",
+      "@amplitude/analytics-node"
+    ],
+    optional: [],
+    devOnly: []
+  },
+  env: {
+    required: [
+      {
+        name: "AMPLITUDE_API_KEY",
+        description: "Amplitude API Key",
+        example: "your-api-key",
+        sensitive: true
+      }
+    ],
+    optional: [
+      {
+        name: "AMPLITUDE_SERVER_URL",
+        description: "Amplitude server URL (for EU data center)",
+        example: "https://api.eu.amplitude.com/2/httpapi",
+        sensitive: false
+      }
+    ]
+  },
+  imports: [
+    {
+      source: "autotel-subscribers/amplitude",
+      specifiers: ["AmplitudeSubscriber"]
+    }
+  ],
+  configBlock: {
+    type: "subscriber",
+    code: `new AmplitudeSubscriber({
+      apiKey: process.env.AMPLITUDE_API_KEY,
+    }),`,
+    section: "SUBSCRIBERS_CONFIG"
+  },
+  nextSteps: [
+    "Set AMPLITUDE_API_KEY from Amplitude Project Settings",
+    "Events will be sent to Amplitude"
+  ]
+};
+var segment = {
+  name: "Segment",
+  slug: "segment",
+  type: "subscriber",
+  description: "Send events to Segment for routing to destinations",
+  packages: {
+    required: [
+      "autotel-subscribers",
+      "@segment/analytics-node"
+    ],
+    optional: [],
+    devOnly: []
+  },
+  env: {
+    required: [
+      {
+        name: "SEGMENT_WRITE_KEY",
+        description: "Segment Source Write Key",
+        example: "your-write-key",
+        sensitive: true
+      }
+    ],
+    optional: []
+  },
+  imports: [
+    {
+      source: "autotel-subscribers/segment",
+      specifiers: ["SegmentSubscriber"]
+    }
+  ],
+  configBlock: {
+    type: "subscriber",
+    code: `new SegmentSubscriber({
+      writeKey: process.env.SEGMENT_WRITE_KEY,
+    }),`,
+    section: "SUBSCRIBERS_CONFIG"
+  },
+  nextSteps: [
+    "Set SEGMENT_WRITE_KEY from your Segment Source settings",
+    "Configure destinations in Segment to route events"
+  ]
+};
+var slack = {
+  name: "Slack",
+  slug: "slack",
+  type: "subscriber",
+  description: "Send event notifications to Slack",
+  packages: {
+    required: [
+      "autotel-subscribers",
+      "@slack/web-api"
+    ],
+    optional: [],
+    devOnly: []
+  },
+  env: {
+    required: [
+      {
+        name: "SLACK_WEBHOOK_URL",
+        description: "Slack Incoming Webhook URL",
+        example: "https://hooks.slack.com/services/...",
+        sensitive: true
+      }
+    ],
+    optional: [
+      {
+        name: "SLACK_CHANNEL",
+        description: "Default channel for notifications",
+        example: "#alerts",
+        sensitive: false
+      }
+    ]
+  },
+  imports: [
+    {
+      source: "autotel-subscribers/slack",
+      specifiers: ["SlackSubscriber"]
+    }
+  ],
+  configBlock: {
+    type: "subscriber",
+    code: `new SlackSubscriber({
+      webhookUrl: process.env.SLACK_WEBHOOK_URL,
+      channel: process.env.SLACK_CHANNEL,
+    }),`,
+    section: "SUBSCRIBERS_CONFIG"
+  },
+  nextSteps: [
+    "Create an Incoming Webhook in your Slack workspace",
+    "Set SLACK_WEBHOOK_URL with the webhook URL"
+  ]
+};
+var webhook = {
+  name: "Webhook",
+  slug: "webhook",
+  type: "subscriber",
+  description: "Send events to a custom webhook endpoint",
+  packages: {
+    required: [
+      "autotel-subscribers"
+    ],
+    optional: [],
+    devOnly: []
+  },
+  env: {
+    required: [
+      {
+        name: "WEBHOOK_URL",
+        description: "Webhook endpoint URL",
+        example: "https://api.example.com/events",
+        sensitive: false
+      }
+    ],
+    optional: [
+      {
+        name: "WEBHOOK_SECRET",
+        description: "Shared secret for webhook signatures",
+        example: "your-secret",
+        sensitive: true
+      }
+    ]
+  },
+  imports: [
+    {
+      source: "autotel-subscribers/webhook",
+      specifiers: ["WebhookSubscriber"]
+    }
+  ],
+  configBlock: {
+    type: "subscriber",
+    code: `new WebhookSubscriber({
+      url: process.env.WEBHOOK_URL,
+      secret: process.env.WEBHOOK_SECRET,
+    }),`,
+    section: "SUBSCRIBERS_CONFIG"
+  },
+  nextSteps: [
+    "Set WEBHOOK_URL to your endpoint",
+    "Implement the webhook receiver to handle incoming events"
+  ]
+};
+
+// src/presets/plugins/mongoose.ts
+var mongoose = {
+  name: "Mongoose",
+  slug: "mongoose",
+  type: "plugin",
+  description: "Instrument Mongoose ODM for MongoDB tracing",
+  packages: {
+    required: [
+      "autotel-plugins"
+    ],
+    optional: [],
+    devOnly: []
+  },
+  env: {
+    required: [],
+    optional: []
+  },
+  imports: [
+    {
+      source: "autotel-plugins/mongoose",
+      specifiers: ["instrumentMongoose"]
+    },
+    {
+      source: "mongoose",
+      default: "mongoose"
+    }
+  ],
+  configBlock: {
+    type: "plugin",
+    code: "instrumentMongoose(mongoose);",
+    section: "PLUGIN_INIT"
+  },
+  nextSteps: [
+    "Mongoose operations will now be traced",
+    "Spans will include query, collection, and timing information"
+  ]
+};
+var drizzle = {
+  name: "Drizzle",
+  slug: "drizzle",
+  type: "plugin",
+  description: "Instrument Drizzle ORM for database tracing",
+  packages: {
+    required: [
+      "autotel-plugins"
+    ],
+    optional: [],
+    devOnly: []
+  },
+  env: {
+    required: [],
+    optional: []
+  },
+  imports: [
+    {
+      source: "autotel-plugins/drizzle",
+      specifiers: ["instrumentDrizzle"]
+    }
+  ],
+  configBlock: {
+    type: "plugin",
+    code: "// Call instrumentDrizzle(db) with your Drizzle instance",
+    section: "PLUGIN_INIT"
+  },
+  nextSteps: [
+    "Import instrumentDrizzle and call it with your Drizzle instance",
+    "Example: const db = instrumentDrizzle(drizzle(pool))"
+  ]
+};
+
+// src/presets/platforms/aws.ts
+var awsLambda = {
+  name: "AWS Lambda",
+  slug: "aws-lambda",
+  type: "platform",
+  description: "AWS Lambda support with cold start handling",
+  packages: {
+    required: [
+      "autotel-platforms",
+      "@opentelemetry/instrumentation-aws-lambda"
+    ],
+    optional: [],
+    devOnly: []
+  },
+  env: {
+    required: [],
+    optional: [
+      {
+        name: "AWS_LAMBDA_FUNCTION_NAME",
+        description: "Lambda function name (auto-set by AWS)",
+        example: "my-function",
+        sensitive: false
+      }
+    ]
+  },
+  imports: [
+    {
+      source: "autotel-platforms/aws",
+      specifiers: ["createLambdaConfig"]
+    }
+  ],
+  configBlock: {
+    type: "platform",
+    code: "...createLambdaConfig(),",
+    section: "BACKEND_CONFIG"
+  },
+  nextSteps: [
+    "Add the Lambda layer or bundle instrumentation with your function",
+    "Set OTEL_* environment variables in Lambda configuration"
+  ]
+};
+var cloudflare = {
+  name: "Cloudflare Workers",
+  slug: "cloudflare",
+  type: "platform",
+  description: "Cloudflare Workers support",
+  packages: {
+    required: [
+      "autotel-platforms"
+    ],
+    optional: [],
+    devOnly: []
+  },
+  env: {
+    required: [],
+    optional: []
+  },
+  imports: [
+    {
+      source: "autotel-platforms/cloudflare",
+      specifiers: ["createCloudflareConfig"]
+    }
+  ],
+  configBlock: {
+    type: "platform",
+    code: "...createCloudflareConfig(),",
+    section: "BACKEND_CONFIG"
+  },
+  nextSteps: [
+    "Workers have limited API support - some features may not be available",
+    "Use waitUntil() for async span flushing"
+  ]
+};
+var edge = {
+  name: "Edge Runtime",
+  slug: "edge",
+  type: "platform",
+  description: "Vercel Edge, Deno Deploy, and other edge runtimes",
+  packages: {
+    required: [
+      "autotel-platforms"
+    ],
+    optional: [],
+    devOnly: []
+  },
+  env: {
+    required: [],
+    optional: []
+  },
+  imports: [
+    {
+      source: "autotel-platforms/edge",
+      specifiers: ["createEdgeConfig"]
+    }
+  ],
+  configBlock: {
+    type: "platform",
+    code: "...createEdgeConfig(),",
+    section: "BACKEND_CONFIG"
+  },
+  nextSteps: [
+    "Edge runtimes have limited API support",
+    "Auto-instrumentation may not work - use manual instrumentation"
+  ]
+};
+
+// src/presets/index.ts
+var backends = /* @__PURE__ */ new Map([
+  ["datadog", datadogDirect],
+  ["datadog-agent", datadogAgent],
+  ["honeycomb", honeycomb],
+  ["otlp-http", otlpHttp],
+  ["otlp-grpc", otlpGrpc],
+  ["local", local]
+]);
+var subscribers = /* @__PURE__ */ new Map([
+  ["posthog", posthog],
+  ["mixpanel", mixpanel],
+  ["amplitude", amplitude],
+  ["segment", segment],
+  ["slack", slack],
+  ["webhook", webhook]
+]);
+var plugins = /* @__PURE__ */ new Map([
+  ["mongoose", mongoose],
+  ["drizzle", drizzle]
+]);
+var platforms = /* @__PURE__ */ new Map([
+  ["aws-lambda", awsLambda],
+  ["cloudflare", cloudflare],
+  ["edge", edge]
+]);
+var quickPresets = /* @__PURE__ */ new Map([
+  [
+    "node-datadog-pino",
+    {
+      name: "Node.js + Datadog + Pino",
+      slug: "node-datadog-pino",
+      description: "Standard Node.js setup with Datadog and Pino logging",
+      backend: "datadog",
+      logging: "pino",
+      autoInstrumentations: "all"
+    }
+  ],
+  [
+    "node-datadog-agent",
+    {
+      name: "Node.js + Datadog Agent",
+      slug: "node-datadog-agent",
+      description: "Node.js with Datadog Agent for local development",
+      backend: "datadog-agent",
+      logging: "pino",
+      autoInstrumentations: "all"
+    }
+  ],
+  [
+    "node-honeycomb",
+    {
+      name: "Node.js + Honeycomb",
+      slug: "node-honeycomb",
+      description: "Standard Node.js setup with Honeycomb",
+      backend: "honeycomb",
+      autoInstrumentations: "all"
+    }
+  ],
+  [
+    "node-otlp",
+    {
+      name: "Node.js + Generic OTLP",
+      slug: "node-otlp",
+      description: "Node.js with generic OTLP endpoint",
+      backend: "otlp-http",
+      autoInstrumentations: "all"
+    }
+  ]
+]);
+function getPreset(type, slug) {
+  switch (type) {
+    case "backend":
+      return backends.get(slug);
+    case "subscriber":
+      return subscribers.get(slug);
+    case "plugin":
+      return plugins.get(slug);
+    case "platform":
+      return platforms.get(slug);
+  }
+}
+function getPresetsByType(type) {
+  switch (type) {
+    case "backend":
+      return backends;
+    case "subscriber":
+      return subscribers;
+    case "plugin":
+      return plugins;
+    case "platform":
+      return platforms;
+  }
+}
+function getQuickPreset(slug) {
+  return quickPresets.get(slug);
+}
+function listPresetSlugs(type) {
+  return [...getPresetsByType(type).keys()];
+}
+
+// src/ui/prompts.ts
+import { select, checkbox, confirm, input } from "@inquirer/prompts";
+async function promptRuntime() {
+  return await select({
+    message: "What runtime are you using?",
+    choices: [
+      { value: "node", name: "Node.js" },
+      { value: "lambda", name: "AWS Lambda" },
+      { value: "cloudflare", name: "Cloudflare Workers" },
+      { value: "edge", name: "Edge Runtime (Vercel Edge, etc.)" }
+    ],
+    default: "node"
+  });
+}
+async function promptBackend(backends2) {
+  const choices = [
+    { value: "local", name: "Local/Console (development only)" },
+    ...[...backends2.entries()].map(([slug, preset]) => ({
+      value: slug,
+      name: `${preset.name} - ${preset.description}`
+    }))
+  ];
+  return await select({
+    message: "Where do you want to send telemetry?",
+    choices,
+    default: "local"
+  });
+}
+async function promptLogging() {
+  return await select({
+    message: "Which logging framework do you use?",
+    choices: [
+      { value: null, name: "None / Not sure" },
+      { value: "pino", name: "Pino" },
+      { value: "winston", name: "Winston" }
+    ],
+    default: null
+  });
+}
+async function promptDatabases(plugins2) {
+  const choices = [...plugins2.entries()].filter(([, preset]) => preset.type === "plugin").map(([slug, preset]) => ({
+    value: slug,
+    name: `${preset.name} - ${preset.description}`
+  }));
+  if (choices.length === 0) {
+    return [];
+  }
+  return await checkbox({
+    message: "Which databases/ORMs do you use? (space to select, enter to continue)",
+    choices
+  });
+}
+async function promptSubscribers(subscribers2) {
+  const choices = [...subscribers2.entries()].map(([slug, preset]) => ({
+    value: slug,
+    name: `${preset.name} - ${preset.description}`
+  }));
+  if (choices.length === 0) {
+    return [];
+  }
+  return await checkbox({
+    message: "Which event destinations? (space to select, enter to continue)",
+    choices
+  });
+}
+async function promptAutoInstrumentation() {
+  return await select({
+    message: "Auto-instrument common libraries?",
+    choices: [
+      { value: "all", name: "All (recommended) - http, express, pg, redis, etc." },
+      { value: "specific", name: "Let me choose specific ones" },
+      { value: "none", name: "None - I'll handle it manually" }
+    ],
+    default: "all"
+  });
+}
+async function promptStartupStyle(hasTypeScript) {
+  const choices = hasTypeScript ? [
+    { value: "node-esm", name: "Node ESM (node --import) - Recommended" },
+    { value: "tsx", name: "tsx (tsx --import) - For development" },
+    { value: "ts-node", name: "ts-node" },
+    { value: "nextjs", name: "Next.js" },
+    { value: "other", name: "Other / Manual" }
+  ] : [
+    { value: "node-esm", name: "Node ESM (node --import) - Recommended" },
+    { value: "nextjs", name: "Next.js" },
+    { value: "other", name: "Other / Manual" }
+  ];
+  return await select({
+    message: "How do you start your app?",
+    choices,
+    default: "node-esm"
+  });
+}
+async function promptExistingConfigAction() {
+  return await select({
+    message: "Existing instrumentation detected. What would you like to do?",
+    choices: [
+      { value: "update", name: "Update existing file (recommended)" },
+      { value: "new", name: "Create new file (src/autotel-config.mts)" },
+      { value: "abort", name: "Abort" }
+    ],
+    default: "update"
+  });
+}
+
+// src/ui/output.ts
+import chalk from "chalk";
+var STATUS = {
+  ok: chalk.green("[OK]"),
+  warn: chalk.yellow("[WARN]"),
+  error: chalk.red("[ERROR]"),
+  info: chalk.blue("[INFO]"),
+  skip: chalk.gray("[SKIP]")
+};
+function formatCheck(check) {
+  const lines = [];
+  const statusToken = STATUS[check.status];
+  lines.push(`  ${statusToken} ${check.message}`);
+  if (check.details && check.details.length > 0) {
+    for (const detail of check.details) {
+      lines.push(`         ${chalk.dim(detail)}`);
+    }
+  }
+  if (check.fix) {
+    lines.push(`         ${chalk.cyan("Fix:")} ${check.fix.cmd}`);
+  }
+  return lines;
+}
+function formatSummary(summary) {
+  const parts = [];
+  if (summary.ok > 0) {
+    parts.push(chalk.green(`${summary.ok} passed`));
+  }
+  if (summary.warnings > 0) {
+    parts.push(chalk.yellow(`${summary.warnings} warning${summary.warnings > 1 ? "s" : ""}`));
+  }
+  if (summary.errors > 0) {
+    parts.push(chalk.red(`${summary.errors} error${summary.errors > 1 ? "s" : ""}`));
+  }
+  if (summary.skipped > 0) {
+    parts.push(chalk.gray(`${summary.skipped} skipped`));
+  }
+  return `Summary: ${parts.join(", ")}`;
+}
+function formatFooter(options) {
+  const lines = [""];
+  if (options.detected) {
+    lines.push(chalk.dim(`Detected: ${options.detected}`));
+  }
+  if (options.wrote && options.wrote.length > 0) {
+    lines.push(chalk.dim(`Wrote: ${options.wrote.join(", ")}`));
+  }
+  if (options.next) {
+    lines.push(chalk.cyan(`Next: ${options.next}`));
+  }
+  return lines.join("\n");
+}
+function heading(text) {
+  console.log(chalk.bold(text));
+}
+function info(text) {
+  console.log(chalk.blue(text));
+}
+function success(text) {
+  console.log(chalk.green(text));
+}
+function warn(text) {
+  console.log(chalk.yellow(text));
+}
+function error(text) {
+  console.log(chalk.red(text));
+}
+function dim(text) {
+  console.log(chalk.dim(text));
+}
+function isVerbose() {
+  return process.env["AUTOTEL_VERBOSE"] === "true";
+}
+function verbose(text) {
+  if (isVerbose()) {
+    console.log(chalk.gray(`[verbose] ${text}`));
+  }
+}
+
+// src/ui/spinner.ts
+import ora from "ora";
+function createSpinner(text) {
+  const spinner = ora({
+    text,
+    spinner: "dots"
+  });
+  return {
+    start: (newText) => {
+      if (newText) spinner.text = newText;
+      spinner.start();
+    },
+    stop: () => spinner.stop(),
+    succeed: (newText) => spinner.succeed(newText),
+    fail: (newText) => spinner.fail(newText),
+    warn: (newText) => spinner.warn(newText),
+    info: (newText) => spinner.info(newText),
+    text: (newText) => {
+      spinner.text = newText;
+    }
+  };
+}
+function isCI() {
+  return !!(process.env["CI"] || process.env["CONTINUOUS_INTEGRATION"] || process.env["BUILD_NUMBER"] || process.env["GITHUB_ACTIONS"] || process.env["GITLAB_CI"] || process.env["CIRCLECI"] || process.env["TRAVIS"]);
+}
+
+// src/commands/init.ts
+async function runInit(options) {
+  const spinner = createSpinner();
+  if (options.verbose) {
+    process.env["AUTOTEL_VERBOSE"] = "true";
+  }
+  if (options.quiet) {
+    process.env["AUTOTEL_QUIET"] = "true";
+  }
+  spinner.start("Discovering project...");
+  const project = discoverProject(options.cwd);
+  if (!project) {
+    spinner.fail("No package.json found");
+    error("Run this command in a directory with a package.json, or use --cwd");
+    process.exit(1);
+  }
+  spinner.succeed(`Found ${project.packageJson.name ?? "project"}`);
+  verbose(`Package root: ${project.packageRoot}`);
+  verbose(`Package manager: ${project.packageManager}`);
+  const existingConfig = detectConfig(project.packageRoot);
+  if (existingConfig.found && !options.force) {
+    info(`Existing instrumentation detected at ${existingConfig.path}`);
+    if (options.yes || isCI()) {
+      warn("Use --force to overwrite existing config");
+      process.exit(0);
+    }
+    const action = await promptExistingConfigAction();
+    if (action === "abort") {
+      info("Aborted");
+      process.exit(0);
+    }
+  }
+  const selectedPresets = [];
+  let autoInstrumentations = "all";
+  let startupStyle = "node-esm";
+  if (options.preset) {
+    const quickPreset = getQuickPreset(options.preset);
+    if (quickPreset) {
+      info(`Using quick preset: ${quickPreset.name}`);
+      const backendPreset = getPreset("backend", quickPreset.backend);
+      if (backendPreset) {
+        selectedPresets.push(backendPreset);
+      }
+      if (quickPreset.subscribers) {
+        for (const sub of quickPreset.subscribers) {
+          const subPreset = getPreset("subscriber", sub);
+          if (subPreset) selectedPresets.push(subPreset);
+        }
+      }
+      if (quickPreset.plugins) {
+        for (const plug of quickPreset.plugins) {
+          const plugPreset = getPreset("plugin", plug);
+          if (plugPreset) selectedPresets.push(plugPreset);
+        }
+      }
+      autoInstrumentations = quickPreset.autoInstrumentations;
+    } else {
+      error(`Unknown preset: ${options.preset}`);
+      info("Available presets: node-datadog-pino, node-datadog-agent, node-honeycomb, node-otlp");
+      process.exit(1);
+    }
+  } else if (options.yes || isCI()) {
+    info("Using defaults (local backend, all auto-instrumentations)");
+    const localPreset = getPreset("backend", "local");
+    if (localPreset) {
+      selectedPresets.push(localPreset);
+    }
+  } else {
+    const runtime = await promptRuntime();
+    verbose(`Runtime: ${runtime}`);
+    const backendSlug = await promptBackend(backends);
+    const backendPreset = getPreset("backend", backendSlug);
+    if (backendPreset) {
+      selectedPresets.push(backendPreset);
+    }
+    await promptLogging();
+    const pluginSlugs = await promptDatabases(plugins);
+    for (const slug of pluginSlugs) {
+      const preset = getPreset("plugin", slug);
+      if (preset) selectedPresets.push(preset);
+    }
+    const subscriberSlugs = await promptSubscribers(subscribers);
+    for (const slug of subscriberSlugs) {
+      const preset = getPreset("subscriber", slug);
+      if (preset) selectedPresets.push(preset);
+    }
+    const autoChoice = await promptAutoInstrumentation();
+    if (autoChoice === "none") {
+      autoInstrumentations = "none";
+    } else if (autoChoice === "specific") {
+      autoInstrumentations = "all";
+    }
+    if (runtime === "node") {
+      startupStyle = await promptStartupStyle(project.hasTypeScript);
+    }
+  }
+  const codeFile = createCodeFile();
+  addImport(codeFile, { source: "autotel/register", sideEffect: true });
+  addImport(codeFile, { source: "autotel", specifiers: ["init"] });
+  for (const preset of selectedPresets) {
+    for (const imp of preset.imports) {
+      const section = preset.type === "backend" || preset.type === "platform" ? "backend" : preset.type === "plugin" ? "plugin" : preset.type === "subscriber" ? "subscriber" : void 0;
+      addImport(codeFile, imp, section);
+    }
+    if (preset.configBlock.section === "BACKEND_CONFIG") {
+      setBackendConfig(codeFile, preset.configBlock.code);
+    } else if (preset.configBlock.section === "SUBSCRIBERS_CONFIG") {
+      addSubscriberConfig(codeFile, preset.configBlock.code);
+    } else if (preset.configBlock.section === "PLUGIN_INIT") {
+      addPluginInit(codeFile, preset.configBlock.code);
+    }
+  }
+  if (!codeFile.backendConfig) {
+    setBackendConfig(codeFile, "// Local/console mode - no backend configured");
+  }
+  const instrumentationContent = renderCodeFile(codeFile);
+  const depPlan = buildDependencyPlan({
+    presets: selectedPresets,
+    autoInstrumentations
+  });
+  const envVars = [];
+  for (const preset of selectedPresets) {
+    envVars.push(...preset.env.required, ...preset.env.optional);
+  }
+  const envExampleContent = generateEnvExample(envVars);
+  const instrumentationPath = getInstrumentationPath(project.packageRoot, project.hasTypeScript);
+  const envExamplePath = path6.join(project.packageRoot, ".env.example");
+  if (options.dryRun) {
+    heading("\nDry run - no files will be written\n");
+    info(`Would write: ${path6.relative(project.cwd, instrumentationPath)}`);
+    console.log("---");
+    console.log(instrumentationContent);
+    console.log("---\n");
+    if (envExampleContent) {
+      info(`Would write: ${path6.relative(project.cwd, envExamplePath)}`);
+      console.log("---");
+      console.log(envExampleContent);
+      console.log("---\n");
+    }
+    const prodPkgs2 = getProdPackages(depPlan);
+    const devPkgs2 = getDevPackages(depPlan);
+    if (prodPkgs2.length > 0) {
+      const cmd = getInstallCommand(project.packageManager, prodPkgs2);
+      info(`Would run: ${cmd}`);
+    }
+    if (devPkgs2.length > 0) {
+      const cmd = getInstallCommand(project.packageManager, devPkgs2, { dev: true });
+      info(`Would run: ${cmd}`);
+    }
+    process.exit(0);
+  }
+  spinner.start("Writing instrumentation file...");
+  const { backupPath: instrBackup } = atomicWrite(instrumentationPath, instrumentationContent, {
+    root: project.packageRoot,
+    backup: options.force
+  });
+  if (instrBackup) {
+    verbose(`Backup created: ${instrBackup}`);
+  }
+  spinner.succeed(`Wrote ${path6.relative(project.cwd, instrumentationPath)}`);
+  if (envExampleContent && !fileExists(envExamplePath)) {
+    spinner.start("Writing .env.example...");
+    atomicWrite(envExamplePath, envExampleContent, { root: project.packageRoot });
+    spinner.succeed(`Wrote ${path6.relative(project.cwd, envExamplePath)}`);
+  }
+  const prodPkgs = getProdPackages(depPlan);
+  const devPkgs = getDevPackages(depPlan);
+  if (!options.noInstall && (prodPkgs.length > 0 || devPkgs.length > 0)) {
+    if (prodPkgs.length > 0) {
+      const cmd = getInstallCommand(project.packageManager, prodPkgs);
+      if (options.printInstallCmd) {
+        info(`Install command: ${cmd}`);
+      } else {
+        spinner.start("Installing dependencies...");
+        try {
+          execSync(cmd, { cwd: project.packageRoot, stdio: "pipe" });
+          spinner.succeed("Dependencies installed");
+        } catch {
+          spinner.fail("Failed to install dependencies");
+          error(`Run manually: ${cmd}`);
+        }
+      }
+    }
+    if (devPkgs.length > 0) {
+      const cmd = getInstallCommand(project.packageManager, devPkgs, { dev: true });
+      if (options.printInstallCmd) {
+        info(`Install command (dev): ${cmd}`);
+      } else {
+        spinner.start("Installing dev dependencies...");
+        try {
+          execSync(cmd, { cwd: project.packageRoot, stdio: "pipe" });
+          spinner.succeed("Dev dependencies installed");
+        } catch {
+          spinner.fail("Failed to install dev dependencies");
+          error(`Run manually: ${cmd}`);
+        }
+      }
+    }
+  } else if (options.noInstall && (prodPkgs.length > 0 || devPkgs.length > 0)) {
+    info("Skipping installation (--no-install)");
+    if (prodPkgs.length > 0) {
+      const cmd = getInstallCommand(project.packageManager, prodPkgs);
+      dim(`Run: ${cmd}`);
+    }
+    if (devPkgs.length > 0) {
+      const cmd = getInstallCommand(project.packageManager, devPkgs, { dev: true });
+      dim(`Run: ${cmd}`);
+    }
+  }
+  const relInstrPath = path6.relative(project.packageRoot, instrumentationPath);
+  let nextStepCmd;
+  switch (startupStyle) {
+    case "tsx":
+      nextStepCmd = `tsx --import ./${relInstrPath} src/index.ts`;
+      break;
+    case "node-esm":
+    default:
+      nextStepCmd = `node --import ./${relInstrPath} dist/index.js`;
+  }
+  const pmInfo = project.workspace.isMonorepo ? `${project.packageManager} workspace, package root ${project.packageRoot}` : `${project.packageManager}`;
+  const writtenFiles = [path6.relative(project.cwd, instrumentationPath)];
+  if (envExampleContent && !fileExists(envExamplePath)) {
+    writtenFiles.push(".env.example");
+  }
+  console.log(formatFooter({
+    detected: pmInfo,
+    wrote: writtenFiles,
+    next: nextStepCmd
+  }));
+  const allNextSteps = selectedPresets.flatMap((p) => p.nextSteps);
+  if (allNextSteps.length > 0) {
+    console.log("\nNext steps:");
+    for (const step of allNextSteps) {
+      console.log(`  - ${step}`);
+    }
+  }
+}
+
+// src/lib/dependency-auditor.ts
+import * as semver from "semver";
+function isPackageInstalled(packageJson, packageName) {
+  const deps = packageJson.dependencies ?? {};
+  const devDeps = packageJson.devDependencies ?? {};
+  if (deps[packageName]) {
+    return { installed: true, version: deps[packageName] ?? null, isDev: false };
+  }
+  if (devDeps[packageName]) {
+    return { installed: true, version: devDeps[packageName] ?? null, isDev: true };
+  }
+  return { installed: false, version: null, isDev: false };
+}
+function checkAutotelVersions(packageJson) {
+  const autotelPackages = ["autotel", "autotel-backends", "autotel-plugins", "autotel-subscribers"];
+  const installed = [];
+  for (const pkg of autotelPackages) {
+    const { installed: isInstalled, version } = isPackageInstalled(packageJson, pkg);
+    if (isInstalled && version) {
+      const cleanVersion = version.replace(/^[\^~]/, "");
+      const parsed = semver.parse(cleanVersion);
+      if (parsed) {
+        installed.push({ name: pkg, version: cleanVersion, major: parsed.major });
+      }
+    }
+  }
+  if (installed.length <= 1) {
+    return { compatible: true, packages: installed };
+  }
+  const majors = new Set(installed.map((p) => p.major));
+  const compatible = majors.size === 1;
+  return { compatible, packages: installed };
+}
+function getAutotelInfo(packageJson) {
+  const { installed, version } = isPackageInstalled(packageJson, "autotel");
+  return { installed, version };
+}
+
+// src/lib/esm-checker.ts
+import * as path7 from "path";
+function checkRegisterImportOrder(content) {
+  const lines = content.split("\n");
+  let registerLine = null;
+  let firstImportLine = null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]?.trim() ?? "";
+    if (line === "" || line.startsWith("//") || line.startsWith("/*") || line.startsWith("*")) {
+      continue;
+    }
+    if (line.startsWith("import ") || line.startsWith("import'") || line.startsWith('import"')) {
+      if (firstImportLine === null) {
+        firstImportLine = i + 1;
+      }
+      if (line.includes("autotel/register")) {
+        registerLine = i + 1;
+      }
+    }
+  }
+  if (registerLine === null) {
+    return { found: false, isFirst: false, lineNumber: null };
+  }
+  return {
+    found: true,
+    isFirst: registerLine === firstImportLine,
+    lineNumber: registerLine
+  };
+}
+function checkEsmHook(project) {
+  if (!project.isEsm) {
+    return {
+      status: "info",
+      message: "Project uses CommonJS; ESM hook check skipped",
+      details: [
+        "autotel works best with ESM projects",
+        'Consider adding "type": "module" to package.json'
+      ]
+    };
+  }
+  const entrypoints = getEntrypointCandidates(project.packageRoot);
+  if (entrypoints.length === 0) {
+    return {
+      status: "info",
+      message: "Could not find entrypoint files to verify",
+      details: [
+        "Ensure autotel/register is imported first in your entrypoint",
+        "Or use --import flag: node --import ./src/instrumentation.mts dist/index.js"
+      ]
+    };
+  }
+  for (const entrypoint of entrypoints) {
+    const content = readFileSafe(entrypoint);
+    if (content === null) continue;
+    const result = checkRegisterImportOrder(content);
+    if (result.found && !result.isFirst) {
+      return {
+        status: "warn",
+        message: `autotel/register import found but not first in ${path7.basename(entrypoint)}:${result.lineNumber}`,
+        details: [
+          "autotel/register must be the first import for instrumentation to work",
+          "Move it to the top of the file, before any other imports"
+        ]
+      };
+    }
+    if (result.found && result.isFirst) {
+      return {
+        status: "ok",
+        message: `autotel/register correctly imported first in ${path7.basename(entrypoint)}`
+      };
+    }
+  }
+  return {
+    status: "info",
+    message: "Could not verify autotel/register import order",
+    details: [
+      "Ensure autotel/register is first import in entrypoint",
+      "Or use the recommended approach: node --import ./src/instrumentation.mts"
+    ]
+  };
+}
+
+// src/commands/doctor.ts
+var CHECK_DEFINITIONS = [
+  { id: "autotel-installed", title: "Autotel installed", description: "Check if autotel is installed" },
+  { id: "peer-deps", title: "Peer dependencies", description: "Check if required peer dependencies are installed" },
+  { id: "esm-hook", title: "ESM hook setup", description: "Check if autotel/register is imported correctly" },
+  { id: "env-vars", title: "Environment variables", description: "Check if required env vars are present" },
+  { id: "version-compat", title: "Version compatibility", description: "Check autotel package versions match" },
+  { id: "config-found", title: "Configuration found", description: "Check if instrumentation config exists" }
+];
+async function inferBackend(packageRoot, deps) {
+  if (deps["autotel-backends"]) {
+    if (deps["@opentelemetry/exporter-trace-otlp-grpc"]) {
+      return getPreset("backend", "honeycomb") ?? null;
+    }
+    if (deps["@opentelemetry/exporter-trace-otlp-http"]) {
+      const ddVars = await checkEnvVarsPresent(packageRoot, ["DATADOG_API_KEY", "DD_API_KEY"]);
+      for (const [, result] of ddVars) {
+        if (result.found) {
+          return getPreset("backend", "datadog") ?? null;
+        }
+      }
+      return getPreset("backend", "otlp-http") ?? null;
+    }
+  }
+  return null;
+}
+async function runChecks(options, projectRoot) {
+  const project = discoverProject(projectRoot);
+  if (!project) {
+    return [{
+      id: "project",
+      title: "Project discovery",
+      level: "error",
+      status: "error",
+      message: "No package.json found"
+    }];
+  }
+  const checks = [];
+  const deps = { ...project.packageJson.dependencies, ...project.packageJson.devDependencies };
+  const autotelInfo = getAutotelInfo(project.packageJson);
+  if (autotelInfo.installed) {
+    checks.push({
+      id: "autotel-installed",
+      title: "Autotel installed",
+      level: "error",
+      status: "ok",
+      message: `autotel@${autotelInfo.version} is installed`
+    });
+  } else {
+    checks.push({
+      id: "autotel-installed",
+      title: "Autotel installed",
+      level: "error",
+      status: "error",
+      message: "autotel is not installed",
+      fix: {
+        cmd: getInstallCommand(project.packageManager, ["autotel"]),
+        description: "Install autotel package"
+      }
+    });
+  }
+  const config = detectConfig(project.packageRoot);
+  if (config.found) {
+    if (config.type === "cli-owned") {
+      checks.push({
+        id: "config-found",
+        title: "Configuration found",
+        level: "info",
+        status: "ok",
+        message: `CLI-owned instrumentation at ${config.path}`
+      });
+    } else if (config.type === "user-created") {
+      checks.push({
+        id: "config-found",
+        title: "Configuration found",
+        level: "info",
+        status: "ok",
+        message: `User-created instrumentation at ${config.path}`,
+        details: ["Add CLI header to enable auto-updates"]
+      });
+    } else {
+      checks.push({
+        id: "config-found",
+        title: "Configuration found",
+        level: "info",
+        status: "ok",
+        message: `Config found at ${config.path}`
+      });
+    }
+  } else {
+    checks.push({
+      id: "config-found",
+      title: "Configuration found",
+      level: "info",
+      status: "warn",
+      message: "No instrumentation config found",
+      details: [
+        "Run `autotel init` to create a CLI-owned config",
+        "Or add `import 'autotel/register'` and call `init()` manually"
+      ]
+    });
+  }
+  const inferredBackend = await inferBackend(project.packageRoot, deps);
+  const canInferPreset = inferredBackend !== null || config.type === "cli-owned";
+  if (canInferPreset && inferredBackend) {
+    const missingDeps = [];
+    for (const pkg of inferredBackend.packages.required) {
+      if (!deps[pkg]) {
+        missingDeps.push(pkg);
+      }
+    }
+    if (missingDeps.length > 0) {
+      checks.push({
+        id: "peer-deps",
+        title: "Peer dependencies",
+        level: "warning",
+        status: "warn",
+        message: "Missing peer dependencies required by selected backend",
+        details: missingDeps.map((d) => `Missing: ${d}`),
+        fix: {
+          cmd: getInstallCommand(project.packageManager, missingDeps),
+          description: "Install missing peer dependencies"
+        }
+      });
+    } else {
+      checks.push({
+        id: "peer-deps",
+        title: "Peer dependencies",
+        level: "warning",
+        status: "ok",
+        message: "All peer dependencies satisfied"
+      });
+    }
+  } else {
+    checks.push({
+      id: "peer-deps",
+      title: "Peer dependencies",
+      level: "warning",
+      status: "skip",
+      message: "Could not infer backend; skipping peer dep check",
+      details: [
+        "Run `autotel init` to create a CLI-owned config",
+        "Or add header marker to existing instrumentation"
+      ]
+    });
+  }
+  if (canInferPreset && inferredBackend && inferredBackend.env.required.length > 0) {
+    const requiredVarNames = inferredBackend.env.required.map((v) => v.name);
+    const envResults = await checkEnvVarsPresent(
+      project.packageRoot,
+      requiredVarNames,
+      options.envFile
+    );
+    const missingVars = [];
+    for (const [varName, result] of envResults) {
+      if (!result.found) {
+        missingVars.push(varName);
+      }
+    }
+    if (missingVars.length > 0) {
+      checks.push({
+        id: "env-vars",
+        title: "Environment variables",
+        level: "warning",
+        status: "warn",
+        message: "Missing required environment variables",
+        details: [
+          ...missingVars.map((v) => `Missing: ${v}`),
+          "Set in environment or deployment secrets"
+        ]
+      });
+    } else {
+      checks.push({
+        id: "env-vars",
+        title: "Environment variables",
+        level: "warning",
+        status: "ok",
+        message: "Required environment variables found"
+      });
+    }
+  } else if (!canInferPreset) {
+    checks.push({
+      id: "env-vars",
+      title: "Environment variables",
+      level: "warning",
+      status: "skip",
+      message: "Could not infer backend; skipping env check"
+    });
+  } else {
+    checks.push({
+      id: "env-vars",
+      title: "Environment variables",
+      level: "warning",
+      status: "ok",
+      message: "No required environment variables for this backend"
+    });
+  }
+  const versionCheck = checkAutotelVersions(project.packageJson);
+  if (versionCheck.packages.length > 1) {
+    if (versionCheck.compatible) {
+      checks.push({
+        id: "version-compat",
+        title: "Version compatibility",
+        level: "warning",
+        status: "ok",
+        message: "All autotel packages are compatible"
+      });
+    } else {
+      checks.push({
+        id: "version-compat",
+        title: "Version compatibility",
+        level: "warning",
+        status: "warn",
+        message: "Autotel packages have mismatched major versions",
+        details: versionCheck.packages.map((p) => `${p.name}@${p.version}`)
+      });
+    }
+  } else {
+    checks.push({
+      id: "version-compat",
+      title: "Version compatibility",
+      level: "warning",
+      status: "skip",
+      message: "Only one autotel package installed; skipping version check"
+    });
+  }
+  const esmCheck = checkEsmHook(project);
+  checks.push({
+    id: "esm-hook",
+    title: "ESM hook setup",
+    level: esmCheck.status === "warn" ? "warning" : "info",
+    status: esmCheck.status === "ok" ? "ok" : esmCheck.status === "warn" ? "warn" : esmCheck.status === "error" ? "error" : "skip",
+    message: esmCheck.message,
+    details: esmCheck.details
+  });
+  return checks;
+}
+function calculateSummary(checks) {
+  return {
+    ok: checks.filter((c) => c.status === "ok").length,
+    warnings: checks.filter((c) => c.status === "warn").length,
+    errors: checks.filter((c) => c.status === "error").length,
+    skipped: checks.filter((c) => c.status === "skip").length
+  };
+}
+function getExitCode(checks) {
+  const hasErrors = checks.some((c) => c.status === "error");
+  const hasWarnings = checks.some((c) => c.status === "warn");
+  if (hasErrors) return 2;
+  if (hasWarnings) return 1;
+  return 0;
+}
+async function runDoctor(options) {
+  if (options.verbose) {
+    process.env["AUTOTEL_VERBOSE"] = "true";
+  }
+  if (options.quiet) {
+    process.env["AUTOTEL_QUIET"] = "true";
+  }
+  if (options.listChecks) {
+    if (options.json) {
+      console.log(JSON.stringify(CHECK_DEFINITIONS, null, 2));
+    } else {
+      heading("Available checks:\n");
+      for (const check of CHECK_DEFINITIONS) {
+        console.log(`  ${check.id}`);
+        console.log(`    ${check.description}
+`);
+      }
+    }
+    return;
+  }
+  const spinner = createSpinner();
+  spinner.start("Scanning project...");
+  const project = discoverProject(options.cwd);
+  if (!project) {
+    spinner.fail("No package.json found");
+    error("Run this command in a directory with a package.json, or use --cwd");
+    process.exit(2);
+  }
+  spinner.text("Running checks...");
+  const checks = await runChecks(options, options.cwd);
+  const summary = calculateSummary(checks);
+  spinner.stop();
+  if (options.json) {
+    const result = {
+      project: project.packageRoot,
+      checks,
+      summary
+    };
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(getExitCode(checks));
+  }
+  heading(`autotel doctor
+`);
+  dim(`Scanning ${project.packageRoot}...
+`);
+  for (const check of checks) {
+    const lines = formatCheck(check);
+    for (const line of lines) {
+      console.log(line);
+    }
+  }
+  console.log("");
+  console.log(formatSummary(summary));
+  if (options.fix) {
+    const fixableChecks = checks.filter((c) => c.fix && c.status !== "ok");
+    if (fixableChecks.length === 0) {
+      info("\nNo fixes needed");
+    } else {
+      info(`
+Applying ${fixableChecks.length} fix(es)...`);
+      for (const check of fixableChecks) {
+        if (!check.fix) continue;
+        if (check.id === "autotel-installed" || check.id === "peer-deps") {
+          info(`Running: ${check.fix.cmd}`);
+          try {
+            const { execSync: execSync3 } = await import("child_process");
+            execSync3(check.fix.cmd, { cwd: project.packageRoot, stdio: "inherit" });
+            success(`Fixed: ${check.title}`);
+          } catch {
+            error(`Failed to fix: ${check.title}`);
+          }
+        } else {
+          dim(`Skipping auto-fix for ${check.id} (not safe to auto-fix)`);
+          dim(`Manual fix: ${check.fix.cmd}`);
+        }
+      }
+    }
+  }
+  process.exit(getExitCode(checks));
+}
+
+// src/commands/add.ts
+import { execSync as execSync2 } from "child_process";
+function formatPresetList(presets, json) {
+  if (json) {
+    const list = [...presets.entries()].map(([slug, preset]) => ({
+      slug,
+      name: preset.name,
+      description: preset.description,
+      requiredEnv: preset.env.required.map((e) => e.name)
+    }));
+    console.log(JSON.stringify(list, null, 2));
+    return;
+  }
+  for (const [slug, preset] of presets) {
+    console.log(`  ${slug}`);
+    console.log(`    ${preset.description}`);
+    if (preset.env.required.length > 0) {
+      const envNames = preset.env.required.map((e) => e.name).join(", ");
+      dim(`    Required env: ${envNames}`);
+    }
+    console.log("");
+  }
+}
+function showPresetHelp(preset) {
+  heading(`
+${preset.name}
+`);
+  console.log(preset.description);
+  console.log("");
+  heading("Packages:");
+  for (const pkg of preset.packages.required) {
+    console.log(`  ${pkg}`);
+  }
+  if (preset.packages.optional.length > 0) {
+    console.log("  Optional:");
+    for (const pkg of preset.packages.optional) {
+      console.log(`    ${pkg}`);
+    }
+  }
+  console.log("");
+  if (preset.env.required.length > 0) {
+    heading("Required Environment Variables:");
+    for (const envVar of preset.env.required) {
+      console.log(`  ${envVar.name}`);
+      console.log(`    ${envVar.description}`);
+      if (envVar.example) {
+        dim(`    Example: ${envVar.example}`);
+      }
+    }
+    console.log("");
+  }
+  if (preset.env.optional.length > 0) {
+    heading("Optional Environment Variables:");
+    for (const envVar of preset.env.optional) {
+      console.log(`  ${envVar.name}`);
+      console.log(`    ${envVar.description}`);
+    }
+    console.log("");
+  }
+  heading("Next Steps:");
+  for (const step of preset.nextSteps) {
+    console.log(`  - ${step}`);
+  }
+}
+function parsePresetType(type) {
+  const validTypes = ["backend", "subscriber", "plugin", "platform"];
+  if (validTypes.includes(type)) {
+    return type;
+  }
+  return null;
+}
+function addPresetToFile(content, preset) {
+  let result = content;
+  for (const imp of preset.imports) {
+    const importLine = imp.sideEffect ? `import '${imp.source}';` : imp.default ? `import ${imp.default} from '${imp.source}';` : `import { ${imp.specifiers?.join(", ")} } from '${imp.source}';`;
+    const importPattern = imp.sideEffect ? `import '${imp.source}'` : imp.default ? `from '${imp.source}'` : `from '${imp.source}'`;
+    if (!result.includes(importPattern)) {
+      const sectionMarker = preset.type === "backend" || preset.type === "platform" ? "// --- AUTOTEL:BACKEND ---" : preset.type === "plugin" ? "// --- AUTOTEL:PLUGINS ---" : preset.type === "subscriber" ? "// --- AUTOTEL:SUBSCRIBERS ---" : null;
+      if (sectionMarker && result.includes(sectionMarker)) {
+        result = result.replace(sectionMarker, `${sectionMarker}
+${importLine}`);
+      } else {
+        const initIndex = result.indexOf("init({");
+        if (initIndex > 0) {
+          result = result.slice(0, initIndex) + `${importLine}
+
+` + result.slice(initIndex);
+        }
+      }
+    }
+  }
+  const configCode = preset.configBlock.code;
+  const configSection = preset.configBlock.section;
+  if (configSection === "BACKEND_CONFIG") {
+    const backendMarker = "// --- AUTOTEL:BACKEND_CONFIG ---";
+    if (result.includes(backendMarker)) {
+      const markerIndex = result.indexOf(backendMarker);
+      const afterMarker = result.slice(markerIndex + backendMarker.length);
+      const nextMarkerMatch = afterMarker.match(/\n\s*(\/\/ --- AUTOTEL:|subscribers:|}\);)/);
+      const endIndex = nextMarkerMatch ? markerIndex + backendMarker.length + (nextMarkerMatch.index ?? 0) : markerIndex + backendMarker.length;
+      result = result.slice(0, markerIndex) + backendMarker + "\n  " + configCode + "\n" + result.slice(endIndex);
+    } else {
+      const initMatch = result.match(/init\(\{/);
+      if (initMatch && initMatch.index !== void 0) {
+        const insertPoint = initMatch.index + "init({".length;
+        result = result.slice(0, insertPoint) + "\n  " + backendMarker + "\n  " + configCode + result.slice(insertPoint);
+      }
+    }
+  } else if (configSection === "SUBSCRIBERS_CONFIG") {
+    const subscribersMatch = result.match(/subscribers:\s*\[([^\]]*)\]/s);
+    if (subscribersMatch) {
+      const existingSubscribers = subscribersMatch[1]?.trim();
+      const newSubscribers = existingSubscribers ? `${existingSubscribers}
+    ${configCode}` : `
+    ${configCode}
+  `;
+      result = result.replace(subscribersMatch[0], `subscribers: [${newSubscribers}]`);
+    } else {
+      const subscribersMarker = "// --- AUTOTEL:SUBSCRIBERS_CONFIG ---";
+      const initStart = result.indexOf("init({");
+      if (initStart !== -1) {
+        const afterInit = result.slice(initStart);
+        const closingMatch = afterInit.match(/}\);/);
+        if (closingMatch && closingMatch.index !== void 0) {
+          const insertPoint = initStart + closingMatch.index;
+          result = result.slice(0, insertPoint) + "\n  " + subscribersMarker + "\n  subscribers: [\n    " + configCode + "\n  ],\n" + result.slice(insertPoint);
+        }
+      }
+    }
+  } else if (configSection === "PLUGIN_INIT") {
+    const pluginMarker = "// --- AUTOTEL:PLUGIN_INIT ---";
+    if (result.includes(pluginMarker)) {
+      result = result.replace(pluginMarker, `${pluginMarker}
+${configCode}`);
+    } else {
+      result = result.trimEnd() + `
+
+${pluginMarker}
+${configCode}
+`;
+    }
+  }
+  return result;
+}
+async function runAdd(type, name, options) {
+  if (options.verbose) {
+    process.env["AUTOTEL_VERBOSE"] = "true";
+  }
+  if (options.quiet) {
+    process.env["AUTOTEL_QUIET"] = "true";
+  }
+  if (options.list && !type) {
+    heading("\nAvailable presets:\n");
+    heading("Backends:");
+    formatPresetList(getPresetsByType("backend"), options.json);
+    heading("Subscribers:");
+    formatPresetList(getPresetsByType("subscriber"), options.json);
+    heading("Plugins:");
+    formatPresetList(getPresetsByType("plugin"), options.json);
+    heading("Platforms:");
+    formatPresetList(getPresetsByType("platform"), options.json);
+    return;
+  }
+  if (!type) {
+    error("Usage: autotel add <type> <name>");
+    info("Types: backend, subscriber, plugin, platform");
+    info("Run `autotel add --list` to see all presets");
+    process.exit(1);
+  }
+  const presetType = parsePresetType(type);
+  if (!presetType) {
+    error(`Invalid type: ${type}`);
+    info("Valid types: backend, subscriber, plugin, platform");
+    process.exit(1);
+  }
+  if (options.list) {
+    heading(`
+${presetType} presets:
+`);
+    formatPresetList(getPresetsByType(presetType), options.json);
+    return;
+  }
+  if (!name) {
+    error(`Usage: autotel add ${type} <name>`);
+    info(`Available ${type}s: ${listPresetSlugs(presetType).join(", ")}`);
+    process.exit(1);
+  }
+  const preset = getPreset(presetType, name);
+  if (!preset) {
+    error(`Unknown ${type}: ${name}`);
+    info(`Available ${type}s: ${listPresetSlugs(presetType).join(", ")}`);
+    process.exit(1);
+  }
+  if (process.argv.includes("--help") || process.argv.includes("-h")) {
+    showPresetHelp(preset);
+    return;
+  }
+  const spinner = createSpinner();
+  spinner.start("Discovering project...");
+  const project = discoverProject(options.cwd);
+  if (!project) {
+    spinner.fail("No package.json found");
+    error("Run this command in a directory with a package.json, or use --cwd");
+    process.exit(1);
+  }
+  spinner.succeed(`Found ${project.packageJson.name ?? "project"}`);
+  const deps = { ...project.packageJson.dependencies, ...project.packageJson.devDependencies };
+  const allInstalled = preset.packages.required.every((pkg) => deps[pkg]);
+  const config = detectConfig(project.packageRoot);
+  let alreadyConfigured = false;
+  if (config.instrumentationFile) {
+    alreadyConfigured = isFeatureConfigured(config.instrumentationFile, presetType);
+  }
+  if (allInstalled && alreadyConfigured) {
+    success(`[OK] ${preset.name} is already installed and configured`);
+    return;
+  }
+  if (allInstalled) {
+    info(`Packages already installed`);
+  }
+  if (alreadyConfigured) {
+    info(`Already configured in instrumentation file`);
+  }
+  if (options.dryRun) {
+    heading("\nDry run - no changes will be made\n");
+    if (!allInstalled) {
+      const cmd = getInstallCommand(project.packageManager, preset.packages.required);
+      info(`Would run: ${cmd}`);
+    }
+    if (!alreadyConfigured) {
+      info(`Would update instrumentation file with ${preset.name} config`);
+    }
+    return;
+  }
+  if (!allInstalled && !options.noInstall) {
+    const missingPkgs = preset.packages.required.filter((pkg) => !deps[pkg]);
+    const cmd = getInstallCommand(project.packageManager, missingPkgs);
+    if (options.printInstallCmd) {
+      info(`Install command: ${cmd}`);
+    } else {
+      spinner.start("Installing packages...");
+      try {
+        execSync2(cmd, { cwd: project.packageRoot, stdio: "pipe" });
+        spinner.succeed("Packages installed");
+      } catch {
+        spinner.fail("Failed to install packages");
+        error(`Run manually: ${cmd}`);
+      }
+    }
+  }
+  if (!alreadyConfigured) {
+    if (!config.found || config.type === "none") {
+      warn("No instrumentation file found");
+      info("Run `autotel init` first to create one");
+      process.exit(1);
+    }
+    if (config.type === "user-created" && !options.force) {
+      warn("Instrumentation file exists but is not CLI-owned");
+      info("Use --force to modify, or add CLI header to the file");
+      process.exit(1);
+    }
+    const instrPath = config.path;
+    const content = readFileSafe(instrPath);
+    if (content) {
+      spinner.start("Updating instrumentation file...");
+      const updatedContent = addPresetToFile(content, preset);
+      atomicWrite(instrPath, updatedContent, {
+        root: project.packageRoot,
+        backup: options.force
+      });
+      spinner.succeed("Instrumentation file updated");
+    }
+  }
+  console.log(formatFooter({
+    detected: `${project.packageManager}`,
+    next: preset.nextSteps[0]
+  }));
+  if (preset.nextSteps.length > 1) {
+    console.log("\nAdditional steps:");
+    for (const step of preset.nextSteps.slice(1)) {
+      console.log(`  - ${step}`);
+    }
+  }
+}
+
+// src/cli.ts
+function createProgram() {
+  const program = new Command();
+  program.name("autotel").description("CLI for autotel - setup wizard, diagnostics, and incremental features").version("0.1.0");
+  const addGlobalOptions = (cmd) => {
+    return cmd.option("--cwd <path>", "Target directory", process.cwd()).option("--verbose", "Show detailed output").option("--quiet", "Only show warnings and errors");
+  };
+  const initCmd = new Command("init").description("Initialize autotel in your project").option("--dry-run", "Skip installation and print what would be done").option("--no-install", "Generate files only, skip package installation").option("--print-install-cmd", "Output the install command without running it").option("-y, --yes", "Accept defaults, non-interactive").option("--preset <name>", "Use a quick preset (e.g., node-datadog-pino)").option("--force", "Overwrite existing config (creates backup first)").option("--workspace-root", "Install at workspace root instead of package root").action(async (opts) => {
+    const options = {
+      cwd: opts.cwd ?? process.cwd(),
+      dryRun: opts.dryRun ?? false,
+      noInstall: opts.noInstall ?? false,
+      printInstallCmd: opts.printInstallCmd ?? false,
+      verbose: opts.verbose ?? false,
+      quiet: opts.quiet ?? false,
+      workspaceRoot: opts.workspaceRoot ?? false,
+      yes: opts.yes ?? false,
+      preset: opts.preset,
+      force: opts.force ?? false
+    };
+    if (options.dryRun) {
+      options.noInstall = true;
+      options.printInstallCmd = true;
+    }
+    await runInit(options);
+  });
+  addGlobalOptions(initCmd);
+  program.addCommand(initCmd);
+  const doctorCmd = new Command("doctor").description("Run diagnostics on your autotel setup").option("--json", "Output machine-readable JSON").option("--fix", "Auto-fix resolvable issues").option("--list-checks", "List all available checks").option("--env-file <path>", "Specify env file to check").action(async (opts) => {
+    const options = {
+      cwd: opts.cwd ?? process.cwd(),
+      dryRun: false,
+      noInstall: false,
+      printInstallCmd: false,
+      verbose: opts.verbose ?? false,
+      quiet: opts.quiet ?? false,
+      workspaceRoot: false,
+      json: opts.json ?? false,
+      fix: opts.fix ?? false,
+      listChecks: opts.listChecks ?? false,
+      envFile: opts.envFile
+    };
+    await runDoctor(options);
+  });
+  addGlobalOptions(doctorCmd);
+  program.addCommand(doctorCmd);
+  const addCmd = new Command("add").description("Add a backend, subscriber, plugin, or platform").argument("[type]", "Preset type (backend, subscriber, plugin, platform)").argument("[name]", "Preset name (e.g., datadog, posthog, mongoose)").option("--list", "List available presets for the given type").option("--dry-run", "Skip installation and print what would be done").option("--no-install", "Generate files only, skip package installation").option("--print-install-cmd", "Output the install command without running it").option("-y, --yes", "Accept defaults, non-interactive").option("--force", "Overwrite non-CLI-owned config (creates backup first)").option("--json", "Output machine-readable JSON (for --list)").option("--workspace-root", "Install at workspace root instead of package root").action(async (type, name, opts) => {
+    const options = {
+      cwd: opts.cwd ?? process.cwd(),
+      dryRun: opts.dryRun ?? false,
+      noInstall: opts.noInstall ?? false,
+      printInstallCmd: opts.printInstallCmd ?? false,
+      verbose: opts.verbose ?? false,
+      quiet: opts.quiet ?? false,
+      workspaceRoot: opts.workspaceRoot ?? false,
+      list: opts.list ?? false,
+      yes: opts.yes ?? false,
+      force: opts.force ?? false,
+      json: opts.json ?? false
+    };
+    if (options.dryRun) {
+      options.noInstall = true;
+      options.printInstallCmd = true;
+    }
+    await runAdd(type, name, options);
+  });
+  addGlobalOptions(addCmd);
+  program.addCommand(addCmd);
+  return program;
+}
+async function run() {
+  const program = createProgram();
+  await program.parseAsync(process.argv);
+}
+
+// src/index.ts
+run().catch((error2) => {
+  console.error("Error:", error2 instanceof Error ? error2.message : error2);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map