clean.cjs

#!/usr/bin/env node

const fs = require("fs");
const path = require("path");
const readline = require("readline");
const { execSync } = require("child_process");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

function question(query) {
  return new Promise((resolve) => rl.question(query, resolve));
}

async function cleanProject() {
  console.log("\n🧹 Project Cleanup\n");
  console.log("This will prepare the template for your own project.\n");

  // 1. Compute project name
  const projectName = path.basename(process.cwd());
  const npmName = projectName
    .toLowerCase()
    .replace(/[^a-z0-9-~]/g, "-")
    .replace(/^-+|-+$/g, "")
    .replace(/-+/g, "-");

  // 2. Load package.json
  const packageJsonPath = path.join(process.cwd(), "package.json");
  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));

  packageJson.name = npmName;
  packageJson.version = "1.0.0";
  packageJson.description = "";
  packageJson.keywords = [];
  packageJson.author = "";
  packageJson.repository = "";

  // 3. Remove Git history and reinitialize automatically
  console.log("Removing Git history...\n");
  const gitPath = path.join(process.cwd(), ".git");
  if (fs.existsSync(gitPath)) {
    execSync(`rm -rf "${gitPath}"`, { stdio: "ignore" });
    console.log("Deleted: .git/");

    // Reinitialize git
    try {
      execSync("git init", { stdio: "ignore" });
      console.log("Initialized: new git repository\n");
    } catch (err) {
      console.log("Warning: Could not initialize git repository\n");
    }
  }

  // 4. Check if tests exist before asking
  const hasTests =
    fs.existsSync(path.join(process.cwd(), "jest.config.ts")) ||
    fs.existsSync(path.join(process.cwd(), "tests")) ||
    fs.existsSync(path.join(process.cwd(), "src", "tests")) ||
    fs.existsSync(path.join(process.cwd(), "src", "__tests__")) ||
    fs.existsSync(path.join(process.cwd(), "__tests__")) ||
    (packageJson.devDependencies &&
      (packageJson.devDependencies["jest"] ||
        packageJson.devDependencies["@types/jest"] ||
        packageJson.devDependencies["ts-jest"]));

  let removeTests = false;

  if (hasTests) {
    const keepTests = await question("Keep tests? (y/n): ");
    console.log("");
    removeTests =
      keepTests.toLowerCase().trim() !== "y" &&
      keepTests.toLowerCase().trim() !== "yes";
  } else {
    console.log("No tests found, skipping test removal...\n");
  }

  if (removeTests) {
    const testPackages = ["@jest/globals", "@types/jest", "jest", "ts-jest"];
    testPackages.forEach((pkg) => {
      if (packageJson.devDependencies?.[pkg]) {
        delete packageJson.devDependencies[pkg];
      }
    });

    if (packageJson.scripts) {
      delete packageJson.scripts.test;
      delete packageJson.scripts["test:watch"];
    }

    const jestConfigPath = path.join(process.cwd(), "jest.config.ts");
    if (fs.existsSync(jestConfigPath)) {
      fs.unlinkSync(jestConfigPath);
      console.log("Deleted: jest.config.ts");
    }

    const testsPaths = [
      path.join(process.cwd(), "tests"),
      path.join(process.cwd(), "src", "tests"),
      path.join(process.cwd(), "src", "__tests__"),
      path.join(process.cwd(), "__tests__"),
    ];

    for (const testsPath of testsPaths) {
      if (fs.existsSync(testsPath)) {
        execSync(`rm -rf "${testsPath}"`, { stdio: "ignore" });
        console.log(`Deleted: ${path.relative(process.cwd(), testsPath)}/`);
      }
    }

    const tsconfigPath = path.join(process.cwd(), "tsconfig.json");
    if (fs.existsSync(tsconfigPath)) {
      let tsconfigContent = fs.readFileSync(tsconfigPath, "utf8");
      tsconfigContent = tsconfigContent.replace(/"jest",?/g, "");
      fs.writeFileSync(tsconfigPath, tsconfigContent, "utf8");
    }
  }

  // 5. Remove template-specific files
  console.log("\nRemoving template-specific files...\n");

  // Remove LICENSE
  const licensePath = path.join(process.cwd(), "LICENSE");
  if (fs.existsSync(licensePath)) {
    fs.unlinkSync(licensePath);
    console.log("Deleted: LICENSE");
  }

  // Remove FUNDING.yml
  const fundingPath = path.join(process.cwd(), ".github", "FUNDING.yml");
  if (fs.existsSync(fundingPath)) {
    fs.unlinkSync(fundingPath);
    console.log("Deleted: .github/FUNDING.yml");

    // Remove .github folder if empty
    const githubDir = path.join(process.cwd(), ".github");
    if (fs.existsSync(githubDir) && fs.readdirSync(githubDir).length === 0) {
      fs.rmdirSync(githubDir);
      console.log("Deleted: .github/");
    }
  }

  // Remove pnpm-lock.yaml
  const lockPath = path.join(process.cwd(), "pnpm-lock.yaml");
  if (fs.existsSync(lockPath)) {
    fs.unlinkSync(lockPath);
    console.log("Deleted: pnpm-lock.yaml");
  }

  // Remove assets folder
  const assetsPath = path.join(process.cwd(), "assets");
  if (fs.existsSync(assetsPath)) {
    execSync(`rm -rf "${assetsPath}"`, { stdio: "ignore" });
    console.log("Deleted: assets/");
  }

  // Remove example code (src/lib/math.ts)
  const mathPath = path.join(process.cwd(), "src", "lib", "math.ts");
  if (fs.existsSync(mathPath)) {
    fs.unlinkSync(mathPath);
    console.log("Deleted: src/lib/math.ts");
  }

  // Remove test files (math.test.ts in all possible locations)
  const mathTestPaths = [
    path.join(process.cwd(), "src", "tests", "math.test.ts"),
    path.join(process.cwd(), "src", "__tests__", "math.test.ts"),
    path.join(process.cwd(), "tests", "math.test.ts"),
    path.join(process.cwd(), "__tests__", "math.test.ts"),
  ];

  for (const testPath of mathTestPaths) {
    if (fs.existsSync(testPath)) {
      fs.unlinkSync(testPath);
      console.log(`Deleted: ${path.relative(process.cwd(), testPath)}`);
    }
  }

  // 6. Clean index.ts properly
  const indexPath = path.join(process.cwd(), "src", "index.ts");
  if (fs.existsSync(indexPath)) {
    let indexContent = fs.readFileSync(indexPath, "utf8");

    // Remove math imports
    indexContent = indexContent.replace(
      /import\s*\{[^}]*\}\s*from\s*["']@\/lib\/math\.js["'];?\s*/g,
      ""
    );

    // Remove math function calls
    indexContent = indexContent.replace(
      /console\.log\(add\([^)]*\)\);?\s*/g,
      ""
    );
    indexContent = indexContent.replace(
      /console\.log\(sub\([^)]*\)\);?\s*/g,
      ""
    );
    indexContent = indexContent.replace(
      /console\.log\(subtract\([^)]*\)\);?\s*/g,
      ""
    );

    // Remove any orphaned closing parentheses or semicolons
    indexContent = indexContent.replace(/^\s*\);?\s*$/gm, "");

    // Clean up multiple empty lines
    indexContent = indexContent.replace(/\n{3,}/g, "\n\n");

    // Trim and ensure single newline at end
    indexContent = indexContent.trim();

    // If file is empty or only has whitespace, add basic content
    if (!indexContent || indexContent.length === 0) {
      indexContent = 'console.log("Hello from Node TypeScript Starter!");';
    }

    fs.writeFileSync(indexPath, indexContent + "\n", "utf8");
    console.log("Cleaned: src/index.ts");
  }

  // 7. Empty README.md completely (handle both README.MD and README.md)
  const readmePath =
    path.join(process.cwd(), "README.MD") ||
    path.join(process.cwd(), "README.md");

  if (fs.existsSync(readmePath)) {
    // Delete the file first, then create new one
    fs.unlinkSync(readmePath);
    fs.writeFileSync(readmePath, `# ${projectName}\n`, "utf8");
    console.log("Cleared: README.md");
  }

  // 8. Rename .env.example -> .env
  const envExamplePath = path.join(process.cwd(), ".env.example");
  const envPath = path.join(process.cwd(), ".env");
  if (fs.existsSync(envExamplePath)) {
    fs.renameSync(envExamplePath, envPath);
    console.log("Renamed: .env.example → .env");
  }

  // 9. Update package.json scripts to use .env instead of .env.example
  if (packageJson.scripts) {
    Object.keys(packageJson.scripts).forEach((key) => {
      packageJson.scripts[key] = packageJson.scripts[key].replace(
        /\.env\.example/g,
        ".env"
      );
    });
  }

  // 10. Save updated package.json
  fs.writeFileSync(
    packageJsonPath,
    JSON.stringify(packageJson, null, 2) + "\n",
    "utf8"
  );
  console.log("Updated: package.json");

  // 11. Delete this cleanup script
  const cleanScriptPath = path.join(process.cwd(), "clean.ts");
  if (fs.existsSync(cleanScriptPath)) {
    fs.unlinkSync(cleanScriptPath);
    console.log("Deleted: clean.ts (this script)");

    // Remove clean script from package.json
    if (packageJson.scripts?.clean) {
      delete packageJson.scripts.clean;
      fs.writeFileSync(
        packageJsonPath,
        JSON.stringify(packageJson, null, 2) + "\n",
        "utf8"
      );
    }
  }

  // 12. Ask to install packages
  const installPackages = await question("\nInstall packages? (y/n): ");
  console.log("");
  if (
    installPackages.toLowerCase().trim() === "y" ||
    installPackages.toLowerCase().trim() === "yes"
  ) {
    console.log("Installing packages...\n");
    execSync("pnpm install", { stdio: "inherit" });
  }

  console.log("\n✨ Cleanup complete! Your project is ready.\n");
  console.log("What was removed:");
  console.log("  ✓ Git history (reinitialized fresh repository)");
  console.log("  ✓ LICENSE");
  console.log("  ✓ FUNDING.yml");
  console.log("  ✓ Example code (math.ts and math.test.ts)");
  console.log("  ✓ Assets folder");
  console.log("  ✓ Template README (cleared to just project title)");
  console.log("  ✓ This cleanup script\n");

  rl.close();
}

cleanProject().catch((err) => {
  console.error("Error:", err.message);
  rl.close();
  process.exit(1);
});