feat: make ATTW an optional dependency with auto-install prompt

package.json

@@ -54,7 +54,6 @@
   },
   "homepage": "https://github.com/e18e/cli#readme",
   "dependencies": {
-    "@arethetypeswrong/core": "^0.18.2",
     "@clack/prompts": "^1.0.0-alpha.6",
     "@publint/pack": "^0.1.2",
     "debug": "^4.4.3",
@@ -68,7 +67,11 @@
     "semver": "^7.7.3",
     "tinyglobby": "^0.2.15"
   },
+  "optionalPeerDependencies": {
+    "@arethetypeswrong/core": "^0.18.2"
+  },
   "devDependencies": {
+    "@arethetypeswrong/core": "^0.18.2",
     "@eslint/js": "^9.37.0",
     "@types/debug": "^4.1.12",
     "@types/node": "^24.7.2",

src/analyze/attw.ts

@@ -1,22 +1,27 @@
+import type {ReportPluginResult, Options} from '../types.js';
+import type {FileSystem} from '../file-system.js';
+import type {ResolutionKind} from '@arethetypeswrong/core';
+import {TarballFileSystem} from '../tarball-file-system.js';
 import {
   checkPackage,
   createPackageFromTarballData
 } from '@arethetypeswrong/core';
 import {groupProblemsByKind} from '@arethetypeswrong/core/utils';
-import type {ResolutionKind} from '@arethetypeswrong/core';
 import {filterProblems, problemKindInfo} from '@arethetypeswrong/core/problems';
-import type {ReportPluginResult, Options} from '../types.js';
-import type {FileSystem} from '../file-system.js';
-import {TarballFileSystem} from '../tarball-file-system.js';
 
 export async function runAttw(
   fileSystem: FileSystem,
-  _options?: Options
+  options?: Options
 ): Promise<ReportPluginResult> {
   const result: ReportPluginResult = {
     messages: []
   };
 
+  // Only run attw when explicitly enabled
+  if (!options?.attw) {
+    return result;
+  }
+
   // Only run attw when TypeScript is configured
   const hasTypeScriptConfig = await fileSystem.fileExists('/tsconfig.json');
   if (!hasTypeScriptConfig) {

src/commands/analyze.meta.ts

@@ -28,6 +28,11 @@ export const meta = {
       array: true,
       description:
         'Path(s) to custom manifest file(s) for module replacements analysis'
+    },
+    attw: {
+      type: 'boolean',
+      default: false,
+      description: 'Enable Are The Types Wrong analysis'
     }
   }
 } as const;

src/commands/analyze.ts

@@ -6,6 +6,11 @@ import {meta} from './analyze.meta.js';
 import {report} from '../index.js';
 import type {PackType} from '../types.js';
 import {enableDebug} from '../logger.js';
+import {
+  isPackageInstalled,
+  promptToInstall,
+  installPackage
+} from '../utils/dependency-check.js';
 
 function formatBytes(bytes: number) {
   const units = ['B', 'KB', 'MB', 'GB'];
@@ -24,6 +29,7 @@ export async function run(ctx: CommandContext<typeof meta.args>) {
   const [_commandName, providedPath] = ctx.positionals;
   let pack: PackType = ctx.values.pack;
   const logLevel = ctx.values['log-level'];
+  let attwEnabled = ctx.values.attw;
   let root: string | undefined = undefined;
 
   // Enable debug output based on log level
@@ -33,6 +39,32 @@ export async function run(ctx: CommandContext<typeof meta.args>) {
 
   prompts.intro('Analyzing...');
 
+  // Check for optional dependencies if features are enabled
+  if (attwEnabled) {
+    const attwPackage = '@arethetypeswrong/core';
+    if (!isPackageInstalled(attwPackage)) {
+      const shouldInstall = await promptToInstall(attwPackage);
+
+      if (shouldInstall) {
+        const installed = await installPackage(attwPackage);
+        if (installed) {
+          prompts.log.info('Restarting analysis with ATTW enabled...');
+          // Continue with analysis now that ATTW is installed
+        } else {
+          prompts.log.warn(
+            'Installation failed. Please install the package manually and run the command again.'
+          );
+          process.exit(1);
+        }
+      } else {
+        prompts.log.warn(
+          `ATTW analysis will be skipped because ${c.cyan(attwPackage)} is not installed.`
+        );
+        attwEnabled = false;
+      }
+    }
+  }
+
   const allowedPackChoices: ReadonlyArray<string> = meta.args.pack.choices;
   if (typeof pack === 'string' && !allowedPackChoices.includes(pack)) {
     prompts.cancel(
@@ -83,7 +115,8 @@ export async function run(ctx: CommandContext<typeof meta.args>) {
   const {stats, messages} = await report({
     root,
     pack,
-    manifest: customManifests
+    manifest: customManifests,
+    attw: attwEnabled
   });
 
   prompts.log.info('Summary');

src/types.ts

@@ -14,6 +14,7 @@ export interface Options {
   root?: string;
   pack?: PackType;
   manifest?: string[];
+  attw?: boolean;
 }
 
 export interface StatLike<T> {

src/utils/dependency-check.ts

@@ -0,0 +1,79 @@
+import {createRequire} from 'node:module';
+import {spawn} from 'node:child_process';
+import {detect, resolveCommand} from 'package-manager-detector';
+import * as p from '@clack/prompts';
+import c from 'picocolors';
+
+const require = createRequire(import.meta.url);
+
+/**
+ * Checks if a package is installed and can be imported
+ */
+export function isPackageInstalled(packageName: string): boolean {
+  try {
+    // Check only in current directory's node_modules, not parent directories
+    const {resolve} = require('node:path');
+    const localPath = resolve('./node_modules', packageName);
+    require.resolve(localPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Prompts the user to install a missing package
+ * Returns true if user wants to proceed with installation
+ */
+export async function promptToInstall(packageName: string): Promise<boolean> {
+  p.log.warn(
+    `${c.yellow('Optional dependency not found:')} ${c.bold(packageName)}`
+  );
+  p.log.message(`This package is required for the feature you've enabled.`, {
+    spacing: 0
+  });
+
+  const shouldInstall = await p.confirm({
+    message: `Would you like to install ${c.cyan(packageName)} now?`
+  });
+
+  if (p.isCancel(shouldInstall)) {
+    return false;
+  }
+
+  return shouldInstall;
+}
+
+/**
+ * Automatically installs a package using the detected package manager
+ */
+export async function installPackage(packageName: string): Promise<boolean> {
+  const detected = await detect();
+  const agent = detected?.agent || 'npm';
+
+  const resolved = resolveCommand(agent, 'add', [packageName]);
+
+  if (!resolved) {
+    p.log.error(`Failed to resolve install command for ${c.cyan(agent)}`);
+    return false;
+  }
+
+  p.log.info(`Installing ${c.cyan(packageName)} with ${c.cyan(agent)}...`);
+
+  return new Promise((resolve) => {
+    const child = spawn(resolved.command, resolved.args, {
+      stdio: 'inherit',
+      cwd: process.cwd()
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        p.log.success(`Successfully installed ${c.cyan(packageName)}!`);
+        resolve(true);
+      } else {
+        p.log.error(`Failed to install ${c.cyan(packageName)}`);
+        resolve(false);
+      }
+    });
+  });
+}