autotel-cli 0.11.1 → 0.12.0

package/dist/index.js

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 import { Command } from "commander";
 import * as fs from "node:fs";
-import * as path from "node:path";
+import { readFileSync } from "node:fs";
+import * as path$1 from "node:path";
+import path from "node:path";
 import { execSync } from "node:child_process";
-import { randomBytes } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { glob } from "glob";
 import chalk from "chalk";
 import { checkbox, confirm, select } from "@inquirer/prompts";
@@ -12,20 +14,23 @@ import * as semver from "semver";
 import { Project, SyntaxKind } from "ts-morph";
 import { fileURLToPath } from "node:url";
 import { buildCollectorGuide, buildInstrumentationGuide, clearSemanticConventionCache, collectUsage, detectAnomalies, discoverLogFields, discoverServices, discoverTraceFields, findRootCause, getCollectorComponentReadme, getCollectorComponentSchema, getModelStats, getSemanticConventionNamespace, listCollectorComponents, listCollectorVersions, listModels, listSemanticConventionNamespaces, listToolUsage, pickErrorMessage, rankExpensiveTraces, rankSlowTraces, refreshCollectorCatalog, resolveCollectorVersion, scoreSpan, suggestCollectorConfig, suggestInstrumentationFixes, toLogSearchQuery, toMetricSearchQuery, toSpanSearchQuery, toTraceSearchQuery, validateCollectorComponentConfig, validateOtlpReceiverConfig } from "autotel-mcp";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { appendFile, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
 //#region src/lib/fs.ts
 /**
 * Check if a path is within the allowed root directory
 */
 function isPathWithinRoot(targetPath, rootPath) {
-	const resolvedTarget = path.resolve(targetPath);
-	const resolvedRoot = path.resolve(rootPath);
-	return resolvedTarget.startsWith(resolvedRoot + path.sep) || resolvedTarget === resolvedRoot;
+	const resolvedTarget = path$1.resolve(targetPath);
+	const resolvedRoot = path$1.resolve(rootPath);
+	return resolvedTarget.startsWith(resolvedRoot + path$1.sep) || resolvedTarget === resolvedRoot;
 }
 /**
 * Ensure parent directory exists
 */
 function ensureDir(filePath) {
-	const dir = path.dirname(filePath);
+	const dir = path$1.dirname(filePath);
 	if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
 }
 /**
@@ -71,7 +76,7 @@ function createBackup(filePath) {
 * Atomic write - write to temp file then rename
 */
 function atomicWrite(filePath, content, options) {
-	const resolvedPath = path.resolve(filePath);
+	const resolvedPath = path$1.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);
@@ -104,17 +109,17 @@ function readJsonSafe(filePath) {
 * Find a file by walking up the directory tree
 */
 function findUpward(startDir, filename, stopAtRoot = true) {
-	let currentDir = path.resolve(startDir);
-	const root = path.parse(currentDir).root;
+	let currentDir = path$1.resolve(startDir);
+	const root = path$1.parse(currentDir).root;
 	while (currentDir !== root) {
-		const filePath = path.join(currentDir, filename);
+		const filePath = path$1.join(currentDir, filename);
 		if (fileExists(filePath)) return filePath;
-		const parentDir = path.dirname(currentDir);
+		const parentDir = path$1.dirname(currentDir);
 		if (parentDir === currentDir) break;
 		currentDir = parentDir;
 		if (stopAtRoot && currentDir === root) break;
 	}
-	const rootFilePath = path.join(root, filename);
+	const rootFilePath = path$1.join(root, filename);
 	if (fileExists(rootFilePath)) return rootFilePath;
 	return null;
 }
@@ -123,14 +128,14 @@ function findUpward(startDir, filename, stopAtRoot = true) {
 */
 function findAllUpward(startDir, filenames) {
 	const found = /* @__PURE__ */ new Map();
-	let currentDir = path.resolve(startDir);
-	const root = path.parse(currentDir).root;
+	let currentDir = path$1.resolve(startDir);
+	const root = path$1.parse(currentDir).root;
 	while (currentDir !== root) {
 		for (const filename of filenames) if (!found.has(filename)) {
-			const filePath = path.join(currentDir, filename);
+			const filePath = path$1.join(currentDir, filename);
 			if (fileExists(filePath)) found.set(filename, filePath);
 		}
-		const parentDir = path.dirname(currentDir);
+		const parentDir = path$1.dirname(currentDir);
 		if (parentDir === currentDir) break;
 		currentDir = parentDir;
 	}
@@ -179,7 +184,7 @@ function detectPackageManager(startDir) {
 	let closestDepth = -1;
 	let closestPM = "npm";
 	for (const [lockfileName, lockfilePath] of foundLockfiles) {
-		const depth = lockfilePath.split(path.sep).length;
+		const depth = lockfilePath.split(path$1.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)) {
@@ -210,28 +215,28 @@ function getInstallCommand(pm, packages, options = {}) {
 * Detect workspace root markers
 */
 function detectWorkspaceRoot(startDir) {
-	let currentDir = path.resolve(startDir);
-	const root = path.parse(currentDir).root;
+	let currentDir = path$1.resolve(startDir);
+	const root = path$1.parse(currentDir).root;
 	while (currentDir !== root) {
-		if (fileExists(path.join(currentDir, "pnpm-workspace.yaml"))) return {
+		if (fileExists(path$1.join(currentDir, "pnpm-workspace.yaml"))) return {
 			workspaceRoot: currentDir,
 			workspaceType: "pnpm"
 		};
-		if (fileExists(path.join(currentDir, "lerna.json"))) return {
+		if (fileExists(path$1.join(currentDir, "lerna.json"))) return {
 			workspaceRoot: currentDir,
 			workspaceType: "lerna"
 		};
-		const pkgJsonContent = readFileSafe(path.join(currentDir, "package.json"));
+		const pkgJsonContent = readFileSafe(path$1.join(currentDir, "package.json"));
 		if (pkgJsonContent) try {
 			if (JSON.parse(pkgJsonContent).workspaces) {
-				const hasYarnLock = fileExists(path.join(currentDir, "yarn.lock"));
+				const hasYarnLock = fileExists(path$1.join(currentDir, "yarn.lock"));
 				return {
 					workspaceRoot: currentDir,
 					workspaceType: hasYarnLock ? "yarn" : "npm"
 				};
 			}
 		} catch {}
-		const parentDir = path.dirname(currentDir);
+		const parentDir = path$1.dirname(currentDir);
 		if (parentDir === currentDir) break;
 		currentDir = parentDir;
 	}
@@ -250,15 +255,15 @@ function findPackageJson(startDir) {
 	if (!packageJsonPath) return null;
 	return {
 		packageJsonPath,
-		packageRoot: path.dirname(packageJsonPath)
+		packageRoot: path$1.dirname(packageJsonPath)
 	};
 }
 /**
 * Detect if project uses TypeScript
 */
 function detectTypeScript(packageRoot) {
-	if (fileExists(path.join(packageRoot, "tsconfig.json"))) return true;
-	const pkgJson = readJsonSafe(path.join(packageRoot, "package.json"));
+	if (fileExists(path$1.join(packageRoot, "tsconfig.json"))) return true;
+	const pkgJson = readJsonSafe(path$1.join(packageRoot, "package.json"));
 	if (pkgJson) {
 		if ("typescript" in {
 			...pkgJson.dependencies,
@@ -289,7 +294,7 @@ function buildWorkspaceInfo(packageRoot, cwd) {
 * Discover project context from a directory
 */
 function discoverProject(cwd) {
-	const resolvedCwd = path.resolve(cwd);
+	const resolvedCwd = path$1.resolve(cwd);
 	const pkgResult = findPackageJson(resolvedCwd);
 	if (!pkgResult) return null;
 	const { packageJsonPath, packageRoot } = pkgResult;
@@ -325,15 +330,15 @@ function getEntrypointCandidates(packageRoot) {
 		"server.js",
 		"app.js",
 		"index.js"
-	].map((c) => path.join(packageRoot, c)).filter((p) => fileExists(p));
+	].map((c) => path$1.join(packageRoot, c)).filter((p) => fileExists(p));
 }
 /**
 * Get instrumentation file path based on project conventions
 */
 function getInstrumentationPath(packageRoot, hasTypeScript) {
-	const dir = dirExists(path.join(packageRoot, "src")) || fileExists(path.join(packageRoot, "src", "index.ts")) || fileExists(path.join(packageRoot, "src", "index.js")) ? path.join(packageRoot, "src") : packageRoot;
+	const dir = dirExists(path$1.join(packageRoot, "src")) || fileExists(path$1.join(packageRoot, "src", "index.ts")) || fileExists(path$1.join(packageRoot, "src", "index.js")) ? path$1.join(packageRoot, "src") : packageRoot;
 	const ext = hasTypeScript ? "mts" : "mjs";
-	return path.join(dir, `instrumentation.${ext}`);
+	return path$1.join(dir, `instrumentation.${ext}`);
 }
 //#endregion
 //#region src/lib/code-builder.ts
@@ -559,7 +564,7 @@ const INSTRUMENTATION_LOCATIONS = [
 */
 function findInstrumentationFile(packageRoot) {
 	for (const location of INSTRUMENTATION_LOCATIONS) {
-		const filePath = path.join(packageRoot, location);
+		const filePath = path$1.join(packageRoot, location);
 		if (fileExists(filePath)) {
 			const content = readFileSafe(filePath);
 			if (content === null) continue;
@@ -589,7 +594,7 @@ function findAutotelYaml(packageRoot) {
 		".autotelrc.yaml",
 		".autotelrc.yml"
 	]) {
-		const filePath = path.join(packageRoot, candidate);
+		const filePath = path$1.join(packageRoot, candidate);
 		if (fileExists(filePath)) return filePath;
 	}
 	return null;
@@ -700,7 +705,7 @@ async function findEnvFiles(packageRoot) {
 * Check if env var is present in any env file
 */
 async function checkEnvVarPresent(packageRoot, varName, specificFile) {
-	const files = specificFile ? [path.resolve(packageRoot, specificFile)] : await findEnvFiles(packageRoot);
+	const files = specificFile ? [path$1.resolve(packageRoot, specificFile)] : await findEnvFiles(packageRoot);
 	for (const file of files) {
 		const content = readFileSafe(file);
 		if (content === null) continue;
@@ -741,6 +746,10 @@ const DEP_TO_PRESET = {
 	"@tanstack/start": "tanstack",
 	"@tanstack/start-server": "tanstack",
 	"@tanstack/start-client": "tanstack",
+	"@nestjs/core": "nestjs",
+	"@sveltejs/kit": "sveltekit",
+	elysia: "elysia",
+	nuxt: "nuxt",
 	"posthog-node": "posthog",
 	"@posthog/node": "posthog",
 	mixpanel: "mixpanel",
@@ -752,7 +761,6 @@ const DEP_TO_PRESET = {
 	"drizzle-orm": "drizzle",
 	express: "auto-instr",
 	fastify: "auto-instr",
-	"@nestjs/core": "auto-instr",
 	next: "auto-instr",
 	pg: "auto-instr",
 	mysql: "auto-instr",
@@ -858,7 +866,7 @@ function collectEnvKeys(opts) {
 	const sources = [];
 	const tryRead = (name, requiresConsent) => {
 		if (requiresConsent && !opts.envConsent) return;
-		const content = readFileSafe(path.join(opts.packageRoot, name));
+		const content = readFileSafe(path$1.join(opts.packageRoot, name));
 		if (content === null) return;
 		sources.push(name);
 		for (const k of parseEnvKeys(content)) keys.add(k);
@@ -892,7 +900,7 @@ function detectBackend(opts) {
 	};
 }
 function detectPlatform(packageRoot) {
-	if (fileExists(path.join(packageRoot, "wrangler.toml")) || fileExists(path.join(packageRoot, "wrangler.jsonc")) || fileExists(path.join(packageRoot, "wrangler.json"))) return "cloudflare";
+	if (fileExists(path$1.join(packageRoot, "wrangler.toml")) || fileExists(path$1.join(packageRoot, "wrangler.jsonc")) || fileExists(path$1.join(packageRoot, "wrangler.json"))) return "cloudflare";
 	return null;
 }
 /**
@@ -901,7 +909,7 @@ function detectPlatform(packageRoot) {
 function detectInProject(opts) {
 	const { project } = opts;
 	let rootPkg = null;
-	if (project.workspace.workspaceRoot !== null && project.workspace.workspaceRoot !== project.packageRoot) rootPkg = readJsonSafe(path.join(project.workspace.workspaceRoot, "package.json"));
+	if (project.workspace.workspaceRoot !== null && project.workspace.workspaceRoot !== project.packageRoot) rootPkg = readJsonSafe(path$1.join(project.workspace.workspaceRoot, "package.json"));
 	const deps = mergeDeps(project.packageJson, rootPkg);
 	const detectedPackages = [];
 	const presetSet = /* @__PURE__ */ new Set();
@@ -944,7 +952,7 @@ function detectInProject(opts) {
 * to read it). .env.example is committed and doesn't trigger this.
 */
 function envFilesRequireConsent(packageRoot) {
-	return fileExists(path.join(packageRoot, ".env")) || fileExists(path.join(packageRoot, ".env.local"));
+	return fileExists(path$1.join(packageRoot, ".env")) || fileExists(path$1.join(packageRoot, ".env.local"));
 }
 //#endregion
 //#region src/presets/backends/datadog.ts
@@ -1802,6 +1810,120 @@ const tanstack = {
 	]
 };
 //#endregion
+//#region src/presets/plugins/nestjs.ts
+const nestjs = {
+	name: "NestJS",
+	slug: "nestjs",
+	type: "plugin",
+	description: "Request-scoped logging via AutotelInterceptor",
+	packages: {
+		required: ["autotel-adapters"],
+		optional: [],
+		devOnly: []
+	},
+	env: {
+		required: [],
+		optional: []
+	},
+	imports: [{
+		source: "autotel-adapters/nestjs",
+		specifiers: ["AutotelInterceptor"]
+	}, {
+		source: "@nestjs/core",
+		specifiers: ["APP_INTERCEPTOR"]
+	}],
+	configBlock: {
+		type: "plugin",
+		code: `// Register globally in AppModule providers:
+// { provide: APP_INTERCEPTOR, useClass: AutotelInterceptor }`,
+		section: "PLUGIN_INIT"
+	},
+	nextSteps: ["Register AutotelInterceptor via APP_INTERCEPTOR in AppModule", "Call useLogger() from controllers/services inside requests"]
+};
+//#endregion
+//#region src/presets/plugins/sveltekit.ts
+const sveltekit = {
+	name: "SvelteKit",
+	slug: "sveltekit",
+	type: "plugin",
+	description: "Server handle hook with request-scoped Autotel logger",
+	packages: {
+		required: ["autotel-adapters"],
+		optional: [],
+		devOnly: []
+	},
+	env: {
+		required: [],
+		optional: []
+	},
+	imports: [{
+		source: "autotel-adapters/sveltekit",
+		specifiers: ["autotelHandle"]
+	}],
+	configBlock: {
+		type: "plugin",
+		code: `// src/hooks.server.ts
+// export const handle = autotelHandle();`,
+		section: "PLUGIN_INIT"
+	},
+	nextSteps: ["Export autotelHandle() from src/hooks.server.ts", "Use useLogger() in +server.ts routes and server loads"]
+};
+//#endregion
+//#region src/presets/plugins/elysia.ts
+const elysia = {
+	name: "Elysia",
+	slug: "elysia",
+	type: "plugin",
+	description: "Route handler wrapper with request-scoped logger",
+	packages: {
+		required: ["autotel-adapters"],
+		optional: [],
+		devOnly: []
+	},
+	env: {
+		required: [],
+		optional: []
+	},
+	imports: [{
+		source: "autotel-adapters/elysia",
+		specifiers: ["withAutotelHandler", "useLogger"]
+	}],
+	configBlock: {
+		type: "plugin",
+		code: `// app.get('/health', withAutotelHandler(async ({ path }) => {
+//   useLogger().set({ route: path });
+//   return { ok: true };
+// }));`,
+		section: "PLUGIN_INIT"
+	},
+	nextSteps: ["Wrap route handlers with withAutotelHandler()", "Call useLogger() inside handlers for request-scoped context"]
+};
+//#endregion
+//#region src/presets/plugins/nuxt.ts
+const nuxt = {
+	name: "Nuxt",
+	slug: "nuxt",
+	type: "plugin",
+	description: "Nuxt module exposing Nitro Autotel adapters",
+	packages: {
+		required: ["autotel-nuxt", "autotel-adapters"],
+		optional: [],
+		devOnly: []
+	},
+	env: {
+		required: [],
+		optional: []
+	},
+	imports: [],
+	configBlock: {
+		type: "plugin",
+		code: `// nuxt.config.ts
+// export default defineNuxtConfig({ modules: ['autotel-nuxt'] });`,
+		section: "PLUGIN_INIT"
+	},
+	nextSteps: ["Add modules: ['autotel-nuxt'] to nuxt.config.ts", "Wrap server/api handlers with withAutotelEventHandler from autotel-nuxt/runtime/nitro"]
+};
+//#endregion
 //#region src/presets/platforms/aws.ts
 /**
 * AWS Lambda platform preset
@@ -1926,7 +2048,11 @@ const plugins = /* @__PURE__ */ new Map([
 	["sentry", sentry],
 	["hono", hono],
 	["mcp", mcp],
-	["tanstack", tanstack]
+	["tanstack", tanstack],
+	["nestjs", nestjs],
+	["sveltekit", sveltekit],
+	["elysia", elysia],
+	["nuxt", nuxt]
 ]);
 /**
 * Platform presets registry
@@ -2061,12 +2187,12 @@ function buildPlanFromDetection(opts) {
 	}
 	const instrumentationPath = getInstrumentationPath(project.packageRoot, project.hasTypeScript);
 	const filesToWrite = [{
-		path: path.relative(project.cwd, instrumentationPath),
+		path: path$1.relative(project.cwd, instrumentationPath),
 		action: fileExists(instrumentationPath) ? "merge" : "create"
 	}];
-	const envExamplePath = path.join(project.packageRoot, ".env.example");
+	const envExamplePath = path$1.join(project.packageRoot, ".env.example");
 	if (envVars.length > 0 && !fileExists(envExamplePath)) filesToWrite.push({
-		path: path.relative(project.cwd, envExamplePath),
+		path: path$1.relative(project.cwd, envExamplePath),
 		action: "create"
 	});
 	const nextSteps = presets.flatMap((p) => p.nextSteps);
@@ -2425,10 +2551,10 @@ function printJson(data) {
 	}
 }
 function writeArtifactFile(filePath, content) {
-	const resolved = path.resolve(filePath);
+	const resolved = path$1.resolve(filePath);
 	if (outputRoot !== null) atomicWrite(resolved, content, { root: outputRoot });
 	else {
-		fs.mkdirSync(path.dirname(resolved), { recursive: true });
+		fs.mkdirSync(path$1.dirname(resolved), { recursive: true });
 		fs.writeFileSync(resolved, content, "utf8");
 	}
 }
@@ -2789,7 +2915,7 @@ function applyPlan(args) {
 	if (codeFile.backendConfig === null) setBackendConfig(codeFile, "// Local/console mode - no backend configured");
 	const newContent = renderCodeFile(codeFile);
 	const instrumentationPath = resolveInstrumentationPath(project);
-	const envExamplePath = path.join(project.packageRoot, ".env.example");
+	const envExamplePath = path$1.join(project.packageRoot, ".env.example");
 	const existing = readFileSafe(instrumentationPath);
 	if (existing !== null) {
 		const parsed = parseInstrumentation(existing);
@@ -2809,24 +2935,24 @@ function applyPlan(args) {
 		].map((i) => i.source));
 		const addedAuto = diffAutoInstrumentations(parsed, codeFile.autoInstrumentations);
 		const contentChanged = existing !== newContent;
-		if (addedImports.length === 0 && addedAuto.length === 0 && parsed.cliOwned && !contentChanged) result.wroteFiles.push(`${path.relative(project.cwd, instrumentationPath)} (no changes)`);
+		if (addedImports.length === 0 && addedAuto.length === 0 && parsed.cliOwned && !contentChanged) result.wroteFiles.push(`${path$1.relative(project.cwd, instrumentationPath)} (no changes)`);
 		else {
 			atomicWrite(instrumentationPath, newContent, {
 				root: project.packageRoot,
 				backup: true
 			});
-			result.wroteFiles.push(path.relative(project.cwd, instrumentationPath));
+			result.wroteFiles.push(path$1.relative(project.cwd, instrumentationPath));
 		}
 	} else {
 		atomicWrite(instrumentationPath, newContent, { root: project.packageRoot });
-		result.wroteFiles.push(path.relative(project.cwd, instrumentationPath));
+		result.wroteFiles.push(path$1.relative(project.cwd, instrumentationPath));
 	}
 	const envVars = [];
 	for (const p of presets) envVars.push(...p.env.required, ...p.env.optional);
 	const envExampleContent = generateEnvExample(envVars);
 	if (envExampleContent.length > 0 && !fileExists(envExamplePath)) {
 		atomicWrite(envExamplePath, envExampleContent, { root: project.packageRoot });
-		result.wroteFiles.push(path.relative(project.cwd, envExamplePath));
+		result.wroteFiles.push(path$1.relative(project.cwd, envExamplePath));
 	}
 	const prod = plan.packagesToInstall.prod;
 	const dev = plan.packagesToInstall.dev;
@@ -2862,10 +2988,10 @@ function applyPlan(args) {
 	return result;
 }
 function resolveInstrumentationPath(project) {
-	const srcDir = path.join(project.packageRoot, "src");
-	const dir = fs.existsSync(srcDir) || fileExists(path.join(project.packageRoot, "src", "index.ts")) || fileExists(path.join(project.packageRoot, "src", "index.js")) ? srcDir : project.packageRoot;
+	const srcDir = path$1.join(project.packageRoot, "src");
+	const dir = fs.existsSync(srcDir) || fileExists(path$1.join(project.packageRoot, "src", "index.ts")) || fileExists(path$1.join(project.packageRoot, "src", "index.js")) ? srcDir : project.packageRoot;
 	const ext = project.hasTypeScript ? "mts" : "mjs";
-	return path.join(dir, `instrumentation.${ext}`);
+	return path$1.join(dir, `instrumentation.${ext}`);
 }
 function resolvePreset(slug) {
 	for (const type of [
@@ -3007,12 +3133,12 @@ function checkEsmHook(project) {
 		const result = checkRegisterImportOrder(content);
 		if (result.found && !result.isFirst) return {
 			status: "warn",
-			message: `autotel/register import found but not first in ${path.basename(entrypoint)}:${result.lineNumber}`,
+			message: `autotel/register import found but not first in ${path$1.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 ${path.basename(entrypoint)}`
+			message: `autotel/register correctly imported first in ${path$1.basename(entrypoint)}`
 		};
 	}
 	return {
@@ -3059,12 +3185,12 @@ function extractAutoInstrumentations(content) {
 */
 function findSourceFiles(packageRoot) {
 	const sourceFiles = [];
-	const dirsToCheck = [packageRoot, path.join(packageRoot, "src")].filter((dir) => fs.existsSync(dir) && fs.statSync(dir).isDirectory());
+	const dirsToCheck = [packageRoot, path$1.join(packageRoot, "src")].filter((dir) => fs.existsSync(dir) && fs.statSync(dir).isDirectory());
 	for (const dir of dirsToCheck) {
 		const files = fs.readdirSync(dir, { recursive: true });
 		for (const file of files) {
 			if (typeof file !== "string") continue;
-			const filePath = path.join(dir, file);
+			const filePath = path$1.join(dir, file);
 			try {
 				if (fs.statSync(filePath).isFile() && /\.(ts|js|mts|mjs|tsx|jsx)$/.test(file)) sourceFiles.push(filePath);
 			} catch {}
@@ -3746,8 +3872,8 @@ function addTraceImport(sourceFile) {
 	});
 }
 function expandNamePattern(pattern, name, filePath, cwd) {
-	const file = path.basename(filePath, path.extname(filePath));
-	const relPath = path.relative(cwd, filePath).replaceAll("\\", "/");
+	const file = path$1.basename(filePath, path$1.extname(filePath));
+	const relPath = path$1.relative(cwd, filePath).replaceAll("\\", "/");
 	return pattern.replaceAll("{name}", name).replaceAll("{file}", file).replaceAll("{path}", relPath);
 }
 function getSpanName(name, filePath, options) {
@@ -3979,19 +4105,19 @@ const GLOB_META = /[*?[\]]/;
 */
 async function resolveCodemodFiles(pathArg, cwd) {
 	if (!GLOB_META.test(pathArg)) {
-		const absolute = path.isAbsolute(pathArg) ? pathArg : path.resolve(cwd, pathArg);
+		const absolute = path$1.isAbsolute(pathArg) ? pathArg : path$1.resolve(cwd, pathArg);
 		if (fileExists(absolute)) {
-			const ext = path.extname(absolute);
+			const ext = path$1.extname(absolute);
 			if (CODEMOD_EXTENSIONS.has(ext) && !absolute.endsWith(".d.ts")) return [absolute];
 			return [];
 		}
 	}
-	return (await glob(path.isAbsolute(pathArg) ? pathArg : path.join(cwd, pathArg), {
+	return (await glob(path$1.isAbsolute(pathArg) ? pathArg : path$1.join(cwd, pathArg), {
 		cwd,
 		absolute: true,
 		ignore: ["**/node_modules/**", "**/*.d.ts"]
 	})).filter((f) => {
-		const ext = path.extname(f);
+		const ext = path$1.extname(f);
 		return CODEMOD_EXTENSIONS.has(ext) && !f.endsWith(".d.ts");
 	});
 }
@@ -4028,7 +4154,7 @@ async function runCodemodTrace(options) {
 			process.exitCode = 1;
 			continue;
 		}
-		const relativePath = path.relative(cwd, filePath);
+		const relativePath = path$1.relative(cwd, filePath);
 		if (result.changed) {
 			totalWrapped += result.wrappedCount;
 			totalChanged += 1;
@@ -4633,6 +4759,38 @@ const INVESTIGATE_COMMANDS = [
 	})
 ];
 COMMANDS.push(...INVESTIGATE_COMMANDS);
+COMMANDS.push(...[
+	{
+		name: "telemetry",
+		description: "Manage opt-in CLI usage telemetry (parent)",
+		mutating: false,
+		flags: []
+	},
+	{
+		name: "telemetry status",
+		description: "Show telemetry consent status",
+		mutating: false,
+		flags: []
+	},
+	{
+		name: "telemetry enable",
+		description: "Enable telemetry for this tool",
+		mutating: true,
+		flags: []
+	},
+	{
+		name: "telemetry disable",
+		description: "Disable telemetry and purge undelivered events",
+		mutating: true,
+		flags: []
+	},
+	{
+		name: "telemetry disclosure",
+		description: "Print telemetry disclosure markdown",
+		mutating: false,
+		flags: []
+	}
+]);
 function getCommand(name) {
 	return COMMANDS.find((c) => c.name === name);
 }
@@ -4714,14 +4872,14 @@ function configure(opts) {
 }
 function readSelfVersion() {
 	try {
-		let dir = path.dirname(fileURLToPath(import.meta.url));
+		let dir = path$1.dirname(fileURLToPath(import.meta.url));
 		for (let i = 0; i < 5; i++) {
-			const candidate = path.join(dir, "package.json");
+			const candidate = path$1.join(dir, "package.json");
 			if (fs.existsSync(candidate)) {
 				const pkg = JSON.parse(fs.readFileSync(candidate, "utf8"));
 				if (pkg.name === "autotel-cli") return String(pkg.version ?? "0.0.0");
 			}
-			dir = path.dirname(dir);
+			dir = path$1.dirname(dir);
 		}
 	} catch {}
 	return "0.0.0";
@@ -6187,6 +6345,291 @@ function registerSecurityCommands(program) {
 	program.addCommand(securityCmd);
 }
 //#endregion
+//#region ../autotel-telemetry/dist/index.js
+function getTelemetryDir(toolName) {
+	const safe = toolName.replaceAll(/[^a-zA-Z0-9._-]/g, "-");
+	return path.join(homedir(), ".autotel", "telemetry", safe);
+}
+var TelemetryOutbox = class {
+	dir;
+	filePath;
+	constructor(options) {
+		this.dir = getTelemetryDir(options.toolName);
+		this.filePath = path.join(this.dir, "outbox.ndjson");
+	}
+	async append(event) {
+		await mkdir(this.dir, { recursive: true });
+		await appendFile(this.filePath, `${JSON.stringify(event)}\n`, "utf8");
+	}
+	async readAll() {
+		try {
+			return (await readFile(this.filePath, "utf8")).split("\n").filter(Boolean).map((line) => JSON.parse(line));
+		} catch {
+			return [];
+		}
+	}
+	async purge() {
+		try {
+			await unlink(this.filePath);
+		} catch {}
+	}
+};
+function resolveConsent(toolName) {
+	if (process.env.DO_NOT_TRACK === "1") return false;
+	if (process.env.AUTOTEL_TELEMETRY === "0") return false;
+	if (process.env.AUTOTEL_TELEMETRY === "1") return true;
+	const pref = readPreferenceSync(toolName);
+	if (pref === "disabled") return false;
+	if (pref === "enabled") return true;
+	return false;
+}
+function readPreferenceSync(toolName) {
+	try {
+		const raw = readFileSync(path.join(getTelemetryDir(toolName), "preference.json"), "utf8");
+		return JSON.parse(raw).preference ?? "unset";
+	} catch {
+		return "unset";
+	}
+}
+async function writePreference(toolName, preference) {
+	const dir = getTelemetryDir(toolName);
+	await mkdir(dir, { recursive: true });
+	await writeFile(path.join(dir, "preference.json"), JSON.stringify({ preference }), "utf8");
+}
+async function purgeOutbox(toolName) {
+	await new TelemetryOutbox({ toolName }).purge();
+}
+function createNoopDrain() {
+	return async () => {};
+}
+function createDebugDrain() {
+	return async (events) => {
+		if (process.env.AUTOTEL_TELEMETRY_DEBUG === "1") for (const event of events) console.error("[autotel-telemetry]", JSON.stringify(event));
+	};
+}
+function createHttpDrain(endpoint) {
+	return async (events) => {
+		if (events.length === 0) return;
+		const response = await fetch(endpoint, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({ events })
+		});
+		if (!response.ok) throw new Error(`Telemetry delivery failed with HTTP ${response.status}`);
+	};
+}
+function composeDrains(...drains) {
+	return async (events) => {
+		await Promise.all(drains.map((drain) => drain(events)));
+	};
+}
+function resolveEndpoint(explicit) {
+	return explicit ?? process.env.AUTOTEL_TELEMETRY_ENDPOINT;
+}
+const SENSITIVE_PATTERN = /(?:token|secret|password|key|auth|credential|api[_-]?key|private)/i;
+function sanitizeFlags(argv, allowlistedStringFlags = []) {
+	const out = {};
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === void 0 || !arg.startsWith("-")) continue;
+		const key = arg.replace(/^-+/, "").split("=")[0] ?? arg;
+		if (SENSITIVE_PATTERN.test(key)) {
+			out[key] = { present: true };
+			continue;
+		}
+		if (arg.includes("=")) {
+			const [, rawValue] = arg.split("=");
+			if (rawValue === void 0) continue;
+			if (/^\d+$/.test(rawValue)) out[key] = Number(rawValue);
+			else if (allowlistedStringFlags.includes(key)) out[key] = rawValue;
+			else out[key] = { present: true };
+			continue;
+		}
+		const next = argv[i + 1];
+		if (next && !next.startsWith("-")) if (/^\d+$/.test(next)) {
+			out[key] = Number(next);
+			i++;
+		} else if (allowlistedStringFlags.includes(key)) {
+			out[key] = next;
+			i++;
+		} else {
+			out[key] = { present: true };
+			i++;
+		}
+		else out[key] = true;
+	}
+	return out;
+}
+function sanitizeCustom(fields) {
+	const out = {};
+	for (const [key, value] of Object.entries(fields)) if (typeof value === "boolean" || typeof value === "number") out[key] = value;
+	else if (value !== null && value !== void 0) out[key] = { present: true };
+	return out;
+}
+const runStorage = new AsyncLocalStorage();
+let activeHandle = null;
+var InternalTelemetry = class {
+	enabled;
+	outbox;
+	drain;
+	options;
+	constructor(options, enabled) {
+		this.options = options;
+		this.enabled = enabled;
+		this.outbox = new TelemetryOutbox({ toolName: options.name });
+		const endpoint = resolveEndpoint(options.endpoint);
+		const drains = [createDebugDrain(), endpoint ? createHttpDrain(endpoint) : createNoopDrain()];
+		this.drain = composeDrains(...drains);
+	}
+	set(fields) {
+		const ctx = runStorage.getStore();
+		if (!ctx || !this.enabled) return;
+		ctx.custom = sanitizeCustom({
+			...ctx.custom,
+			...fields
+		});
+	}
+	async finish(outcome) {
+		if (!this.enabled || !resolveConsent(this.options.name)) return;
+		const ctx = runStorage.getStore();
+		if (!ctx) return;
+		const event = {
+			tool: this.options.name,
+			version: this.options.version,
+			command: ctx.command,
+			outcome,
+			durationMs: Date.now() - ctx.startedAt,
+			flags: ctx.flags,
+			custom: Object.keys(ctx.custom).length > 0 ? ctx.custom : void 0,
+			ci: Boolean(process.env.CI),
+			machineId: hashMachineId()
+		};
+		try {
+			await this.outbox.append(event);
+			const pending = await this.outbox.readAll();
+			await this.drain(pending);
+			await this.outbox.purge();
+		} catch {}
+	}
+	async flush() {
+		if (!this.enabled || !resolveConsent(this.options.name)) return;
+		await Promise.race([(async () => {
+			const pending = await this.outbox.readAll();
+			await this.drain(pending);
+			await this.outbox.purge();
+		})(), new Promise((resolve) => setTimeout(resolve, 500))]);
+	}
+};
+function hashMachineId() {
+	const seed = `${process.platform}:${process.arch}:${process.env.USER ?? "unknown"}`;
+	return createHash("sha256").update(seed).digest("hex").slice(0, 16);
+}
+function createTelemetry(options) {
+	activeHandle = new InternalTelemetry(options, resolveConsent(options.name));
+	return activeHandle;
+}
+async function runWithTelemetry(options, command, argv, fn) {
+	const handle = createTelemetry(options);
+	const ctx = {
+		command,
+		startedAt: Date.now(),
+		custom: {},
+		flags: sanitizeFlags(argv, options.allowlistedStringFlags)
+	};
+	return runStorage.run(ctx, async () => {
+		let outcome = "success";
+		try {
+			return await fn();
+		} catch (error) {
+			outcome = "failure";
+			throw error;
+		} finally {
+			if (handle.enabled) await handle.finish(outcome);
+		}
+	});
+}
+function withCommanderTelemetry(program, options) {
+	const originalParse = program.parseAsync.bind(program);
+	program.parseAsync = async (argv) => {
+		const command = argv[2] ?? "help";
+		return runWithTelemetry({
+			name: options?.name ?? program.name(),
+			version: options?.version ?? program.version(),
+			...options
+		}, command, argv.slice(3), () => originalParse(argv));
+	};
+	return program;
+}
+function getTelemetryStatus(toolName) {
+	return {
+		enabled: resolveConsent(toolName),
+		preference: readPreferenceSync(toolName)
+	};
+}
+async function enableTelemetry(toolName) {
+	await writePreference(toolName, "enabled");
+}
+async function disableTelemetry(toolName) {
+	await writePreference(toolName, "disabled");
+	await purgeOutbox(toolName);
+}
+function generateDisclosure(options) {
+	const json = {
+		tool: options.name,
+		version: options.version,
+		collected: [
+			"command",
+			"outcome",
+			"durationMs",
+			"sanitized flags",
+			"optional custom counters"
+		],
+		notCollected: [
+			"raw argv strings",
+			"paths",
+			"tokens",
+			"secrets"
+		],
+		optOut: [
+			"DO_NOT_TRACK=1",
+			"AUTOTEL_TELEMETRY=0",
+			"autotel telemetry disable"
+		]
+	};
+	return {
+		markdown: `# ${options.name} telemetry disclosure
+
+Collects one structured event per command: command name, outcome, duration, sanitized flags, and optional counters via \`telemetry.set()\`.
+
+Does not collect raw paths, tokens, or secret-shaped flag values.
+
+Opt out with \`DO_NOT_TRACK=1\`, \`AUTOTEL_TELEMETRY=0\`, or \`autotel telemetry disable\`.
+`,
+		json
+	};
+}
+//#endregion
+//#region src/commands/telemetry.ts
+async function runTelemetryStatus(toolName) {
+	const status = getTelemetryStatus(toolName);
+	console.log(JSON.stringify(status, null, 2));
+}
+async function runTelemetryEnable(toolName) {
+	await enableTelemetry(toolName);
+	console.log(`Telemetry enabled for ${toolName}`);
+}
+async function runTelemetryDisable(toolName) {
+	await disableTelemetry(toolName);
+	console.log(`Telemetry disabled for ${toolName}`);
+}
+function runTelemetryDisclosure(toolName, version) {
+	const disclosure = generateDisclosure({
+		name: toolName,
+		version
+	});
+	console.log(disclosure.markdown);
+}
+//#endregion
 //#region src/cli.ts
 /**
 * Create the CLI program
@@ -6325,6 +6768,20 @@ function createProgram() {
 	registerScoreCommands(program);
 	registerCollectorCommands(program);
 	registerSecurityCommands(program);
+	const telemetryCmd = new Command("telemetry").description("Manage opt-in CLI usage telemetry");
+	telemetryCmd.command("status").description("Show telemetry consent status").action(async () => {
+		await runTelemetryStatus("autotel");
+	});
+	telemetryCmd.command("enable").description("Enable telemetry for this tool").action(async () => {
+		await runTelemetryEnable("autotel");
+	});
+	telemetryCmd.command("disable").description("Disable telemetry and purge undelivered events").action(async () => {
+		await runTelemetryDisable("autotel");
+	});
+	telemetryCmd.command("disclosure").description("Print telemetry disclosure markdown").action(() => {
+		runTelemetryDisclosure("autotel", program.version());
+	});
+	program.addCommand(telemetryCmd);
 	return program;
 }
 /**
@@ -6337,7 +6794,11 @@ function createProgram() {
 * which the top-level handler in `index.ts` converts to an envelope.
 */
 async function run() {
-	const program = createProgram();
+	const base = createProgram();
+	const program = withCommanderTelemetry(base, {
+		name: "autotel",
+		version: base.version()
+	});
 	program.exitOverride();
 	const argvJoined = process.argv.slice(2).join(" ");
 	const isJsonOnly = process.argv.includes("--json") || /^(schema|commands|examples|version|health|capabilities|discover|query|trace|diagnose|topology|correlate|llm|semconv|score|collector)\b/.test(argvJoined);