autotel-cli 0.1.0 → 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Jag Reehal 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -107,6 +107,47 @@ npx autotel add backend datadog --help
 - `--dry-run` - Skip installation and print what would be done
 - `--force` - Overwrite non-CLI-owned config (creates backup first)
 
+### `autotel codemod trace <path>`
+
+Wrap functions in `trace()` with a span name derived from the function/variable/method name. Use this to adopt autotel on existing code without changing function bodies.
+
+**Supported file types:** `.ts`, `.tsx`, `.js`, `.jsx`
+
+```bash
+# Single file (TypeScript or JavaScript)
+npx autotel codemod trace src/index.ts
+npx autotel codemod trace src/utils.js
+
+# Glob pattern - TypeScript only
+npx autotel codemod trace "src/**/*.ts"
+
+# Glob pattern - all supported files
+npx autotel codemod trace "src/**/*.{ts,tsx,js,jsx}"
+
+# Dry run - print what would change without writing
+npx autotel codemod trace "src/**/*.ts" --dry-run
+
+# Custom span name template: {name}, {file} (basename), {path} (relative)
+npx autotel codemod trace "src/**/*.ts" --name-pattern "{file}.{name}"
+
+# Skip functions whose name matches a regex (repeatable)
+npx autotel codemod trace "src/**/*.ts" --skip "^_" --skip "test|mock"
+
+# Print per-file summary (wrapped count, skipped)
+npx autotel codemod trace "src/**/*.ts" --print-files
+```
+
+**Options:**
+
+- `--dry-run` - Print changes without writing files
+- `--name-pattern <pattern>` - Span name template. Placeholders: `{name}`, `{file}`, `{path}`. Default: `{name}` only.
+- `--skip <regex>...` - Skip functions whose name matches (repeatable; combined as OR).
+- `--print-files` - Print per-file summary (e.g. `✔ path (N wrapped)`, `↷ path (skipped: reason)`).
+
+**Supported patterns:** Function declarations, arrow/function expressions in `const`/`let`/`var`, class and static methods (body wrap), object method shorthand, named default export function. Works with both TypeScript and JavaScript files. Span name defaults to function/variable/method name (or `ClassName.methodName` for methods).
+
+**Exclusions:** Generator functions (`function*`, `async function*`); getters/setters; constructors; CJS (`require('autotel')`); anonymous default export; class/object methods that use `super` in the body; `.d.ts` files; `node_modules/`. The codemod does not modify files when no eligible functions are found (no unused `trace` import added). The `{path}` placeholder uses the relative path from `--cwd` with forward slashes; moving files will change span names.
+
 ## Global Options
 
 All commands support these options:

package/dist/index.js

@@ -362,7 +362,7 @@ function addPluginInit(file, init) {
 function sortImports(imports) {
   const sideEffect = [];
   const external = [];
-  const relative3 = [];
+  const relative5 = [];
   for (const imp of imports) {
     if (imp.sideEffect) {
       if (imp.source === "autotel/register") {
@@ -371,15 +371,15 @@ function sortImports(imports) {
         sideEffect.push(imp);
       }
     } else if (imp.source.startsWith(".") || imp.source.startsWith("/")) {
-      relative3.push(imp);
+      relative5.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];
+  relative5.sort(sortBySource);
+  return [...sideEffect, ...external, ...relative5];
 }
 function renderImport(imp) {
   if (imp.sideEffect) {
@@ -406,9 +406,7 @@ function renderImports(imports) {
   return sorted.map(renderImport).join("\n");
 }
 function renderCodeFile(file) {
-  const lines = [];
-  lines.push(CLI_HEADER);
-  lines.push("");
+  const lines = [CLI_HEADER, ""];
   const mainImports = sortImports(file.imports);
   if (mainImports.length > 0) {
     lines.push(renderImports(mainImports));
@@ -2188,6 +2186,97 @@ function checkEsmHook(project) {
   };
 }
 
+// src/lib/logger-checker.ts
+import * as path8 from "path";
+import * as fs2 from "fs";
+var LOGGER_INSTRUMENTATION = {
+  winston: "@opentelemetry/instrumentation-winston",
+  bunyan: "@opentelemetry/instrumentation-bunyan",
+  pino: "@opentelemetry/instrumentation-pino"
+};
+function extractAutoInstrumentations(content) {
+  const instrumentations = [];
+  const arrayPattern = /autoInstrumentations\s*:\s*\[(.*?)\]/s;
+  const arrayMatch = content.match(arrayPattern);
+  if (arrayMatch && arrayMatch[1]) {
+    const items = arrayMatch[1].split(",").map((item) => item.trim().replaceAll(/['"]/g, "")).filter((item) => item.length > 0);
+    instrumentations.push(...items);
+  }
+  const objectPattern = /autoInstrumentations\s*:\s*\{([^}]+)\}/s;
+  const objectMatch = content.match(objectPattern);
+  if (objectMatch && objectMatch[1]) {
+    const props = objectMatch[1];
+    const enabledPattern = /(\w+)\s*:\s*\{[^}]*enabled\s*:\s*true[^}]*\}/g;
+    let enabledMatch;
+    while ((enabledMatch = enabledPattern.exec(props)) !== null) {
+      if (enabledMatch[1]) {
+        instrumentations.push(enabledMatch[1]);
+      }
+    }
+  }
+  return [...new Set(instrumentations)];
+}
+function findSourceFiles(packageRoot) {
+  const sourceFiles = [];
+  const srcDir = path8.join(packageRoot, "src");
+  const dirsToCheck = [packageRoot, srcDir].filter(
+    (dir) => fs2.existsSync(dir) && fs2.statSync(dir).isDirectory()
+  );
+  for (const dir of dirsToCheck) {
+    const files = fs2.readdirSync(dir, { recursive: true });
+    for (const file of files) {
+      if (typeof file !== "string") continue;
+      const filePath = path8.join(dir, file);
+      try {
+        if (fs2.statSync(filePath).isFile() && /\.(ts|js|mts|mjs|tsx|jsx)$/.test(file)) {
+          sourceFiles.push(filePath);
+        }
+      } catch {
+      }
+    }
+  }
+  return sourceFiles;
+}
+function checkLoggerInstrumentation(packageRoot, deps) {
+  const hasWinston = !!deps["winston"];
+  const hasBunyan = !!deps["bunyan"];
+  const hasPino = !!deps["pino"];
+  let logger = null;
+  if (hasWinston) logger = "winston";
+  else if (hasBunyan) logger = "bunyan";
+  else if (hasPino) logger = "pino";
+  if (!logger) {
+    return {
+      logger: null,
+      hasLogger: false,
+      hasInstrumentation: false,
+      configuredInCode: false,
+      instrumentationPackage: null
+    };
+  }
+  const instrumentationPackage = LOGGER_INSTRUMENTATION[logger];
+  const hasInstrumentation = !!deps[instrumentationPackage];
+  const sourceFiles = findSourceFiles(packageRoot);
+  let configuredInCode = false;
+  for (const filePath of sourceFiles) {
+    const content = readFileSafe(filePath);
+    if (!content) continue;
+    if (!content.includes("init(")) continue;
+    const instrumentations = extractAutoInstrumentations(content);
+    if (instrumentations.includes(logger)) {
+      configuredInCode = true;
+      break;
+    }
+  }
+  return {
+    logger,
+    hasLogger: true,
+    hasInstrumentation,
+    configuredInCode,
+    instrumentationPackage
+  };
+}
+
 // src/commands/doctor.ts
 var CHECK_DEFINITIONS = [
   { id: "autotel-installed", title: "Autotel installed", description: "Check if autotel is installed" },
@@ -2195,7 +2284,8 @@ var CHECK_DEFINITIONS = [
   { 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" }
+  { id: "config-found", title: "Configuration found", description: "Check if instrumentation config exists" },
+  { id: "logger-instrumentation", title: "Logger instrumentation", description: "Check if logger instrumentation packages are installed" }
 ];
 async function inferBackend(packageRoot, deps) {
   if (deps["autotel-backends"]) {
@@ -2423,6 +2513,61 @@ async function runChecks(options, projectRoot) {
     message: esmCheck.message,
     details: esmCheck.details
   });
+  const loggerCheck = checkLoggerInstrumentation(project.packageRoot, deps);
+  if (loggerCheck.hasLogger) {
+    if (loggerCheck.configuredInCode && !loggerCheck.hasInstrumentation) {
+      checks.push({
+        id: "logger-instrumentation",
+        title: "Logger instrumentation",
+        level: "warning",
+        status: "warn",
+        message: `${loggerCheck.logger} is configured but instrumentation package is missing`,
+        details: [
+          `${loggerCheck.logger} is used in autoInstrumentations but ${loggerCheck.instrumentationPackage} is not installed`,
+          `Install it: ${getInstallCommand(project.packageManager, [loggerCheck.instrumentationPackage])}`
+        ],
+        fix: {
+          cmd: getInstallCommand(project.packageManager, [loggerCheck.instrumentationPackage]),
+          description: `Install ${loggerCheck.instrumentationPackage}`
+        }
+      });
+    } else if (loggerCheck.hasInstrumentation && loggerCheck.configuredInCode) {
+      checks.push({
+        id: "logger-instrumentation",
+        title: "Logger instrumentation",
+        level: "info",
+        status: "ok",
+        message: `${loggerCheck.logger} instrumentation is properly configured`
+      });
+    } else if (loggerCheck.hasInstrumentation && !loggerCheck.configuredInCode) {
+      checks.push({
+        id: "logger-instrumentation",
+        title: "Logger instrumentation",
+        level: "info",
+        status: "ok",
+        message: `${loggerCheck.logger} instrumentation package is installed`,
+        details: [
+          `Add '${loggerCheck.logger}' to autoInstrumentations in your init() call to enable trace context injection`
+        ]
+      });
+    } else {
+      checks.push({
+        id: "logger-instrumentation",
+        title: "Logger instrumentation",
+        level: "info",
+        status: "skip",
+        message: `${loggerCheck.logger} is installed but not configured in code`
+      });
+    }
+  } else {
+    checks.push({
+      id: "logger-instrumentation",
+      title: "Logger instrumentation",
+      level: "info",
+      status: "skip",
+      message: "No logger packages detected (winston, bunyan, pino)"
+    });
+  }
   return checks;
 }
 function calculateSummary(checks) {
@@ -2806,6 +2951,346 @@ ${presetType} presets:
   }
 }
 
+// src/commands/codemod-trace.ts
+import * as path10 from "path";
+import { glob as glob2 } from "glob";
+
+// src/lib/codemod-trace.ts
+import * as path9 from "path";
+import { Project, SyntaxKind } from "ts-morph";
+var TRACE_IMPORT_MODULE = "autotel";
+function hasTraceImport(sourceFile) {
+  for (const imp of sourceFile.getImportDeclarations()) {
+    if (imp.getModuleSpecifierValue() !== TRACE_IMPORT_MODULE) continue;
+    for (const spec of imp.getNamedImports()) {
+      const name = spec.getName();
+      if (name === "trace") return true;
+      const alias = spec.getAliasNode()?.getText();
+      if (alias === "trace" || name === "trace") return true;
+    }
+  }
+  return false;
+}
+function addTraceImport(sourceFile) {
+  if (hasTraceImport(sourceFile)) return;
+  sourceFile.insertImportDeclaration(0, {
+    moduleSpecifier: TRACE_IMPORT_MODULE,
+    namedImports: ["trace"]
+  });
+}
+function expandNamePattern(pattern, name, filePath, cwd) {
+  const file = path9.basename(filePath, path9.extname(filePath));
+  const relPath = path9.relative(cwd, filePath).replaceAll("\\", "/");
+  return pattern.replaceAll("{name}", name).replaceAll("{file}", file).replaceAll("{path}", relPath);
+}
+function getSpanName(name, filePath, options) {
+  if (options.namePattern) {
+    return expandNamePattern(options.namePattern, name, filePath, process.cwd());
+  }
+  return name;
+}
+function shouldSkipName(name, options) {
+  if (!options.skip?.length) return false;
+  return options.skip.some((re) => re.test(name));
+}
+function isAlreadyWrapped(node) {
+  const text = node.getText();
+  const trimmed = text.trimStart();
+  return trimmed.startsWith("trace(");
+}
+function bodyContainsSuper(body) {
+  let found = false;
+  body.forEachDescendant((desc) => {
+    if (desc.getKind() === SyntaxKind.SuperKeyword) found = true;
+  });
+  return found;
+}
+function isGenerator(method) {
+  return method.isGenerator?.() ?? false;
+}
+function isInsideTraceCall(node) {
+  let current = node.getParent();
+  while (current) {
+    if (current.getKind() === SyntaxKind.CallExpression) {
+      const expr = current.getExpression?.();
+      if (expr?.getText() === "trace") return true;
+    }
+    current = current.getParent();
+  }
+  return false;
+}
+function transformFile(content, filePath, options) {
+  const skipped = [];
+  let wrappedCount = 0;
+  const project = new Project({ useInMemoryFileSystem: true });
+  const sourceFile = project.createSourceFile(filePath, content);
+  const edits = [];
+  function skip(name, reason) {
+    skipped.push({ name, reason });
+    return true;
+  }
+  const defaultDecls = sourceFile.getExportedDeclarations().get("default");
+  const defaultFn = defaultDecls?.[0] && (defaultDecls[0].getKind() === SyntaxKind.FunctionDeclaration || defaultDecls[0].getKind() === SyntaxKind.FunctionExpression) ? defaultDecls[0] : void 0;
+  const allFns = sourceFile.getFunctions().filter((f) => !f.isOverload());
+  const onlyDefaultExportFn = defaultFn && allFns.length === 1 && (allFns[0] === defaultFn || allFns[0].getStart() === defaultFn.getStart());
+  for (const fn of allFns) {
+    if (onlyDefaultExportFn) continue;
+    if (isInsideTraceCall(fn)) continue;
+    const name = fn.getName();
+    if (!name) continue;
+    const spanName = getSpanName(name, filePath, options);
+    if (shouldSkipName(spanName, options)) {
+      skip(spanName, "name match");
+      continue;
+    }
+    if (isAlreadyWrapped(fn)) {
+      skip(spanName, "already wrapped");
+      continue;
+    }
+    const mod = fn.getModifiers().map((m) => m.getText()).join(" ");
+    const modPrefix = mod ? mod + " " : "";
+    const fnText = fn.getText();
+    const rest = fnText.replace(/^function\s*\w*\s*/, "");
+    const newText = `${modPrefix}const ${name} = trace('${spanName}', function ${name}${rest};`;
+    edits.push({ node: fn, newText });
+    wrappedCount += 1;
+  }
+  if (defaultFn) {
+    const name = defaultFn.getName?.();
+    if (!name) {
+      skip("(default export)", "anonymous default export");
+    } else {
+      const spanName = getSpanName(name, filePath, options);
+      if (shouldSkipName(spanName, options)) {
+        skip(spanName, "name match");
+      } else {
+        const fn = defaultFn;
+        const params = fn.getParameters?.() ?? [];
+        const paramsText = params.map((p) => p.getText()).join(", ");
+        const body = fn.getBody?.();
+        const bodyText = body?.getText() ?? "{}";
+        const decl = `const ${name} = trace('${spanName}', function ${name}(${paramsText}) ${bodyText};`;
+        const full = decl + "\nexport default " + name + ";";
+        edits.push({ node: defaultFn, newText: full });
+        wrappedCount += 1;
+      }
+    }
+  }
+  for (const stmt of sourceFile.getVariableStatements()) {
+    for (const decl of stmt.getDeclarationList().getDeclarations()) {
+      const init = decl.getInitializer();
+      if (!init) continue;
+      const kind = init.getKind();
+      const isArrow = kind === SyntaxKind.ArrowFunction;
+      const isFnExpr = kind === SyntaxKind.FunctionExpression;
+      const isCall = kind === SyntaxKind.CallExpression;
+      if (isCall) {
+        const callExpr = init;
+        const exprText = callExpr.getExpression().getText();
+        if (exprText === "trace") {
+          const name2 = decl.getName();
+          if (typeof name2 === "string") {
+            const spanName2 = getSpanName(name2, filePath, options);
+            skipped.push({ name: spanName2, reason: "already wrapped" });
+          }
+          continue;
+        }
+      }
+      if (!isArrow && !isFnExpr) continue;
+      const name = decl.getName();
+      if (typeof name !== "string") continue;
+      const spanName = getSpanName(name, filePath, options);
+      if (shouldSkipName(spanName, options)) {
+        skip(spanName, "name match");
+        continue;
+      }
+      if (isAlreadyWrapped(init)) {
+        skipped.push({ name: spanName, reason: "already wrapped" });
+        continue;
+      }
+      const initText = init.getText();
+      const newInit = `trace('${spanName}', ${initText})`;
+      edits.push({ node: init, newText: newInit });
+      wrappedCount += 1;
+    }
+  }
+  for (const clazz of sourceFile.getClasses()) {
+    const className = clazz.getName();
+    if (!className) continue;
+    for (const _ctor of clazz.getConstructors()) {
+      skipped.push({ name: `${className}.constructor`, reason: "constructor" });
+    }
+    for (const method of clazz.getMethods()) {
+      const getter = method.getFirstChildByKind(SyntaxKind.GetKeyword);
+      const setter = method.getFirstChildByKind(SyntaxKind.SetKeyword);
+      if (getter || setter) {
+        skip(method.getName() ?? "(getter/setter)", "getter/setter");
+        continue;
+      }
+      if (isGenerator(method)) {
+        skip(`${className}.${method.getName()}`, "generator");
+        continue;
+      }
+      const methodName = method.getName();
+      const spanName = getSpanName(`${className}.${methodName}`, filePath, options);
+      if (shouldSkipName(spanName, options)) {
+        skip(spanName, "name match");
+        continue;
+      }
+      const body = method.getBody();
+      if (!body) continue;
+      if (bodyContainsSuper(body)) {
+        skip(spanName, "super");
+        continue;
+      }
+      const bodyText = body.getText();
+      const innerBody = bodyText.slice(1, -1).trim();
+      const isAsync = method.isAsync();
+      const prefix = isAsync ? "async " : "";
+      const newBody = `{
+  return trace('${spanName}', ${prefix}() => {
+${innerBody}
+})();
+}`;
+      edits.push({ node: body, newText: newBody });
+      wrappedCount += 1;
+    }
+  }
+  for (const stmt of sourceFile.getVariableStatements()) {
+    for (const decl of stmt.getDeclarationList().getDeclarations()) {
+      const init = decl.getInitializer();
+      if (!init || init.getKind() !== SyntaxKind.ObjectLiteralExpression) continue;
+      const obj = init;
+      for (const prop of obj.getProperties()) {
+        if (prop.getKind() !== SyntaxKind.MethodDeclaration) continue;
+        const method = prop;
+        const methodName = method.getName();
+        const spanName = getSpanName(methodName, filePath, options);
+        if (shouldSkipName(spanName, options)) {
+          skip(spanName, "name match");
+          continue;
+        }
+        if (method.isGenerator?.()) {
+          skip(spanName, "generator");
+          continue;
+        }
+        const body = method.getBody();
+        if (!body) continue;
+        if (bodyContainsSuper(body)) {
+          skip(spanName, "super");
+          continue;
+        }
+        const bodyText = body.getText();
+        const innerBody = bodyText.slice(1, -1).trim();
+        const newBody = `{
+  return trace('${spanName}', () => {
+${innerBody}
+})();
+}`;
+        edits.push({ node: body, newText: newBody });
+        wrappedCount += 1;
+      }
+    }
+  }
+  edits.sort((a, b) => b.node.getStart() - a.node.getStart());
+  for (const { node, newText } of edits) {
+    node.replaceWithText(newText);
+  }
+  if (wrappedCount > 0 && !hasTraceImport(sourceFile)) {
+    addTraceImport(sourceFile);
+  }
+  const modified = sourceFile.getFullText();
+  const changed = wrappedCount > 0;
+  return {
+    modified: changed ? modified : content,
+    changed,
+    wrappedCount,
+    skipped
+  };
+}
+
+// src/commands/codemod-trace.ts
+var CODEMOD_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
+var GLOB_META = /[*?[\]]/;
+async function resolveCodemodFiles(pathArg, cwd) {
+  const isGlob = GLOB_META.test(pathArg);
+  if (!isGlob) {
+    const absolute = path10.isAbsolute(pathArg) ? pathArg : path10.resolve(cwd, pathArg);
+    if (fileExists(absolute)) {
+      const ext = path10.extname(absolute);
+      if (CODEMOD_EXTENSIONS.has(ext) && !absolute.endsWith(".d.ts")) {
+        return [absolute];
+      }
+      return [];
+    }
+  }
+  const pattern = path10.isAbsolute(pathArg) ? pathArg : path10.join(cwd, pathArg);
+  const matches = await glob2(pattern, {
+    cwd,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/*.d.ts"]
+  });
+  return matches.filter((f) => {
+    const ext = path10.extname(f);
+    return CODEMOD_EXTENSIONS.has(ext) && !f.endsWith(".d.ts");
+  });
+}
+async function runCodemodTrace(options) {
+  const { path: pathArg, cwd, dryRun, namePattern, skip, printFiles, verbose: verbose2, quiet } = options;
+  const files = await resolveCodemodFiles(pathArg, cwd);
+  if (files.length === 0) {
+    if (!quiet) {
+      error(`No matching files found for: ${pathArg}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const skipRegExps = skip?.map((s) => new RegExp(s)) ?? [];
+  const transformOptions = { namePattern, skip: skipRegExps.length > 0 ? skipRegExps : void 0 };
+  let totalWrapped = 0;
+  let totalChanged = 0;
+  for (const filePath of files) {
+    const content = readFileSafe(filePath);
+    if (content === null) {
+      if (verbose2) dim(`Skip ${filePath} (unreadable)`);
+      continue;
+    }
+    let result;
+    try {
+      result = transformFile(content, filePath, transformOptions);
+    } catch (error2) {
+      if (!quiet) {
+        error(`Failed to transform ${filePath}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+      }
+      if (verbose2 && error2 instanceof Error && error2.stack) dim(error2.stack);
+      process.exitCode = 1;
+      continue;
+    }
+    const relativePath = path10.relative(cwd, filePath);
+    if (result.changed) {
+      totalWrapped += result.wrappedCount;
+      totalChanged += 1;
+      if (!dryRun) {
+        const fs3 = await import("fs");
+        fs3.writeFileSync(filePath, result.modified, "utf8");
+      }
+    }
+    const showSummary = printFiles || dryRun || result.changed;
+    if (showSummary && !quiet) {
+      if (result.changed) {
+        console.log(`\u2714 ${relativePath} (${result.wrappedCount} wrapped)`);
+      } else if (result.skipped.length > 0) {
+        const reasons = [...new Set(result.skipped.map((s) => s.reason))].join("; ");
+        console.log(`\u21B7 ${relativePath} (skipped: ${reasons})`);
+      }
+    }
+  }
+  if (dryRun && totalChanged > 0 && !quiet) {
+    console.log("");
+    dim(`Dry run: ${totalChanged} file(s) would be updated, ${totalWrapped} function(s) wrapped.`);
+  }
+}
+
 // src/cli.ts
 function createProgram() {
   const program = new Command();
@@ -2874,6 +3359,27 @@ function createProgram() {
   });
   addGlobalOptions(addCmd);
   program.addCommand(addCmd);
+  const codemodCmd = new Command("codemod").description("Codemod commands for adopting autotel");
+  const traceCmd = new Command("trace").description("Wrap functions in trace() with span name from function/variable/method name").argument("<path>", "File path or glob (e.g. src/index.ts, src/**/*.ts)").option("--dry-run", "Print changes without writing files").option("--name-pattern <pattern>", "Span name template: {name}, {file}, {path}").option("--skip <regex>...", "Skip functions whose name matches (repeatable)").option("--print-files", "Print per-file summary (wrapped count, skipped)").action(async (pathArg, opts) => {
+    const options = {
+      cwd: opts.cwd ?? process.cwd(),
+      dryRun: opts.dryRun ?? false,
+      noInstall: false,
+      printInstallCmd: false,
+      verbose: opts.verbose ?? false,
+      quiet: opts.quiet ?? false,
+      workspaceRoot: false,
+      path: pathArg,
+      namePattern: opts.namePattern,
+      skip: Array.isArray(opts.skip) && opts.skip.length > 0 ? opts.skip : void 0,
+      printFiles: opts.printFiles ?? false
+    };
+    await runCodemodTrace(options);
+  });
+  addGlobalOptions(traceCmd);
+  codemodCmd.addCommand(traceCmd);
+  addGlobalOptions(codemodCmd);
+  program.addCommand(codemodCmd);
   return program;
 }
 async function run() {