@empline/preflight 1.1.14 → 1.1.15

package/dist/checks/organization/file-cleanup-validation.js

@@ -0,0 +1,1121 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * File Cleanup Validation Preflight
+ *
+ * Detects and reports files/folders that can be safely removed:
+ * - Temporary report files
+ * - Old backup directories
+ * - Empty directories
+ * - Duplicate config files
+ * - Build artifacts that shouldn't be committed
+ * - Log files and debug outputs
+ *
+ * BLOCKING: Prevents builds when cleanup is needed
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tags = exports.description = exports.blocking = exports.category = exports.name = exports.id = void 0;
+exports.run = run;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const console_chars_1 = require("../../utils/console-chars");
+const universal_progress_reporter_1 = require("../system/universal-progress-reporter");
+// Check metadata
+exports.id = "organization/file-cleanup-validation";
+exports.name = "File Cleanup Validation";
+exports.category = "organization";
+exports.blocking = false;
+exports.description = "File Cleanup Validation Preflight";
+exports.tags = ["organization", "validation"];
+const projectRoot = process.cwd();
+// Patterns for files that should be cleaned up
+const CLEANUP_PATTERNS = {
+    // Temporary report files (root level)
+    TEMP_REPORTS: [
+        /^consistency_report\.txt$/,
+        /^coverage_final\.txt$/,
+        /^coverage_report_v\d+\.txt$/,
+        /^current_test_output\.txt$/,
+        /^current_violations.*\.txt$/,
+        /^design_report\.txt$/,
+        /^dry_report.*\.txt$/,
+        /^final_verification\.txt$/,
+        /^fix_log\.txt$/,
+        /^framework-clean-log\.txt$/,
+        /^gaps\.txt$/,
+        /^latest_coverage_report\.txt$/,
+        /^lint_.*\.txt$/,
+        /^lint-summary\.txt$/,
+        /^preflight_.*\.txt$/,
+        /^preflight_.*\.log$/,
+        /^prisma-check\.txt$/,
+        /^secrets\.log$/,
+        /^shared_report\.txt$/,
+        /^test_output.*\.txt$/,
+        /^tsc.*output.*\.txt$/,
+        /^unified_report\.txt$/,
+        /^cycles\.log$/,
+        /^tokenization-.*\.txt$/,
+        /^eslint-.*\.txt$/,
+        /^missing-.*\.txt$/,
+        /^nested-.*\.txt$/,
+        /^page-template-.*\.txt$/,
+        /^temp-.*\.txt$/,
+    ],
+    // Build artifacts that shouldn't be committed
+    BUILD_ARTIFACTS: [
+        /^\.tsbuildinfo$/,
+        /^tsconfig\..*\.tsbuildinfo$/,
+        /^debug-plugins\.(cjs|mjs)$/,
+        /^eng\.traineddata$/, // OCR training data
+        /^\.next\/trace$/,
+        /^\.next\/trace-build$/,
+        /^\.next\/turbopack$/,
+    ],
+    // Cache and temporary directories
+    CACHE_DIRS: [
+        /^\.next\/cache\/.*$/,
+        /^\.swc\/plugins\/.*$/,
+        /^node_modules\/\.cache\/.*$/,
+        /^test-results\/artifacts\/.*$/,
+    ],
+    // Old backup directories (older than 30 days)
+    OLD_BACKUPS: [
+        /^\.kiro\/steering-backup-\d{4}-\d{2}-\d{2}-\d{6}$/,
+        /^\.kiro\/feature-specs-backup-.*$/,
+        /^\.kiro\/specs-backup-.*$/,
+        /^\.kiro\/settings-backup-.*$/,
+        /^\.kiro\/hooks-backup-.*$/,
+        /^backups\/tmp$/,
+        /^backups\/.*\.bak$/,
+        /^backups\/.*\.backup$/,
+        /^backups\/reference-data\/.*\.json\.old$/,
+        /^backups\/prisma\/.*\.sql\.old$/,
+        /^backups\/pre-deployment\/.*\.old$/,
+        /^.*\.prisma\.backup$/,
+        /^.*\.json\.backup$/,
+        /^.*\.js\.backup$/,
+        /^.*\.ts\.backup$/,
+        /^.*\.tsx\.backup$/,
+        /^.*\.css\.backup$/,
+        /^.*\.md\.backup$/,
+        /^.*\.yml\.backup$/,
+        /^.*\.yaml\.backup$/,
+        /^.*\.config\.backup$/,
+    ],
+    // Report directories with old files
+    REPORT_DIRS: [
+        /^reports\/cleanup-report-\d+\.json$/,
+        /^reports\/eslint-errors\.json$/,
+        /^reports\/logs\/.*\.log$/,
+        /^reports\/logs\/.*\.txt$/,
+        /^reports\/logs\/.*\.json$/,
+        /^reports\/typecheck\/.*\.txt$/,
+        /^reports\/typecheck\/.*\.log$/,
+        /^reports\/analysis\/.*\.txt$/,
+        /^reports\/analysis\/.*\.json$/,
+        /^reports\/performance\/.*\.json$/,
+        /^reports\/security\/.*\.json$/,
+        /^reports\/accessibility\/.*\.json$/,
+        /^reports\/seo\/.*\.json$/,
+        /^reports\/bundle\/.*\.html$/,
+        /^reports\/coverage\/.*\.json$/,
+        /^reports\/lighthouse\/.*\.json$/,
+    ],
+    // Test artifacts and logs
+    TEST_ARTIFACTS: [
+        /^test-results\/.*\.log$/,
+        /^test-results\/junit\.xml$/,
+        /^test-results\/results\.json$/,
+        /^test-results\/e2e-slowest\.json$/,
+        /^test-results\/account-profile-targeted.*\.log$/,
+        /^test-results\/targeted-e2e\.log$/,
+        /^test-results\/dev-server\.log$/,
+        /^test-results\/artifacts\/.*$/,
+        /^test-results\/html\/.*$/,
+        /^playwright-report\/.*$/,
+        /^coverage\/.*$/,
+        /^storybook-static\/.*$/,
+        /^.*-test-report\.html$/,
+        /^.*-coverage\.json$/,
+        /^.*-trace\.zip$/,
+        /^.*-screenshots\.zip$/,
+        /^.*-videos\.zip$/,
+        /^mutation-testing-report\.html$/,
+        /^integration-test-logs\.txt$/,
+        /^e2e-test-artifacts\.zip$/,
+        /^performance-test-results\.json$/,
+    ],
+    // Development artifacts
+    DEV_ARTIFACTS: [
+        /^\.env\.vercel\.local$/,
+        /^\.env\.preview$/,
+        /^\.env\.playwright$/,
+        /^runtime-errors\.json$/,
+        /^\.playwright-storage\.json$/,
+        /^preflight-results\.json$/,
+        /^workspace-state\.json$/,
+        /^session-data\.json$/,
+        /^user-preferences\.json$/,
+        /^recent-files\.json$/,
+        /^search-history\.json$/,
+        /^command-history\.txt$/,
+        /^editor-state\.json$/,
+        /^breakpoints\.json$/,
+        /^debug-output\.txt$/,
+        /^debug-trace\.log$/,
+        /^memory-usage\.log$/,
+        /^cpu-profile\.json$/,
+        /^heap-snapshot\.heapsnapshot$/,
+        /^flame-graph\.html$/,
+        /^profiling-results\.json$/,
+        /^benchmark-results\.txt$/,
+        /^load-test-results\.json$/,
+        /^stress-test-output\.txt$/,
+    ],
+    // Package manager artifacts
+    PACKAGE_ARTIFACTS: [
+        /^pnpm-debug\.log.*$/,
+        /^npm-debug\.log.*$/,
+        /^yarn-debug\.log.*$/,
+        /^yarn-error\.log.*$/,
+        /^lerna-debug\.log.*$/,
+        /^\.pnpm-debug\.log$/,
+        /^\.npm-debug\.log$/,
+        /^\.yarn-integrity$/,
+        /^\.yarn-metadata\.json$/,
+    ],
+    // Empty or near-empty files
+    EMPTY_FILES: [
+        /^\.env\..*$/, // Check for empty env files
+        /^.*\.tmp$/,
+        /^.*\.temp$/,
+        /^.*\.bak$/,
+        /^.*\.backup$/,
+        /^.*\.old$/,
+        /^.*\.orig$/,
+        /^.*~$/,
+    ],
+    // Large files that might be artifacts (>50MB)
+    LARGE_FILES: [
+        /^.*\.(dump|sql\.gz|tar\.gz|zip|7z|rar)$/,
+        /^.*\.heapsnapshot$/,
+        /^.*\.cpuprofile$/,
+        /^.*\.trace$/,
+    ],
+    // IDE and editor artifacts
+    IDE_ARTIFACTS: [
+        /^\.DS_Store$/,
+        /^Thumbs\.db$/,
+        /^desktop\.ini$/,
+        /^\.vscode\/settings\.json\.backup$/,
+        /^\.idea\/workspace\.xml$/,
+        /^\.idea\/tasks\.xml$/,
+        /^\.idea\/usage\.statistics\.xml$/,
+        /^\.idea\/shelf\/.*$/,
+        /^\.vs\/.*$/,
+    ],
+    // Version control artifacts
+    VCS_ARTIFACTS: [
+        /^\.git\/hooks\/.*\.sample$/,
+        /^\.git\/logs\/.*$/,
+        /^\.git\/refs\/remotes\/.*$/,
+        /^\.gitignore\.backup$/,
+        /^\.gitattributes\.backup$/,
+    ],
+    // Documentation artifacts
+    DOC_ARTIFACTS: [
+        /^.*\.md\.backup$/,
+        /^.*\.md\.tmp$/,
+        /^README\.md\.old$/,
+        /^CHANGELOG\.md\.backup$/,
+        /^docs\/.*\.tmp$/,
+    ],
+};
+// Directories that should be checked for emptiness
+const CHECK_EMPTY_DIRS = [
+    "backups/tmp",
+    "reports/logs",
+    "reports/typecheck",
+    ".kiro/feature-specs",
+    ".kiro/specs",
+    "test-results/artifacts",
+    "coverage",
+    "playwright-report",
+    ".next/cache",
+    ".swc/plugins",
+    "node_modules/.cache",
+    "storybook-static",
+    "temp",
+    "tmp",
+    "logs",
+    "debug",
+    "profiling",
+    "benchmarks",
+    "artifacts",
+    "dist/temp",
+    "build/temp",
+    "public/temp",
+    "static/temp",
+    ".vercel/cache",
+    ".vs/temp",
+    ".vscode/temp",
+    "prisma/migrations/.tmp",
+    "prisma/temp",
+    ".git/hooks/temp",
+    ".github/temp",
+    "docs/temp",
+    "styles/temp",
+    "types/temp",
+    "contexts/temp",
+    "hooks/temp",
+    "email-templates/temp",
+    "scripts/temp",
+    "lib/temp",
+    "app/temp",
+    "components/temp",
+    "packages/temp",
+    "stories/temp",
+];
+// Additional directories to scan for cleanup
+const SCAN_DIRECTORIES = [
+    ".next",
+    ".swc",
+    "test-results",
+    "reports",
+    "backups",
+    "coverage",
+    "playwright-report",
+    "storybook-static",
+    ".kiro",
+    "node_modules/.cache",
+    ".vercel",
+    ".vs",
+    ".vscode",
+    "packages",
+    "scripts/temp",
+    "scripts/logs",
+    "lib/temp",
+    "app/temp",
+    "components/temp",
+    "prisma/migrations/.tmp",
+    "prisma/temp",
+    ".git/hooks",
+    ".git/logs",
+    ".github/temp",
+    "docs/temp",
+    "public/temp",
+    "styles/temp",
+    "types/temp",
+    "contexts/temp",
+    "hooks/temp",
+    "email-templates/temp",
+];
+// Files that are known to be safe to delete (whitelist)
+const SAFE_TO_DELETE = [
+    // Temporary reports
+    "consistency_report.txt",
+    "coverage_final.txt",
+    "coverage_report_v2.txt",
+    "current_test_output.txt",
+    "current_violations.txt",
+    "current_violations_v2.txt",
+    "design_report.txt",
+    "dry_report.txt",
+    "dry_report_clean.txt",
+    "dry_report_latest.txt",
+    "final_verification.txt",
+    "fix_log.txt",
+    "framework-clean-log.txt",
+    "gaps.txt",
+    "latest_coverage_report.txt",
+    "lint_listings.txt",
+    "lint_output.txt",
+    "lint_single.txt",
+    "lint-summary.txt",
+    "preflight_check_2.txt",
+    "preflight_colors_final.txt",
+    "preflight_colors_final_v2.txt",
+    "preflight_colors_v2.txt",
+    "preflight_colors_v3.txt",
+    "preflight_colors_v4.txt",
+    "preflight_final_check.txt",
+    "preflight_full_report.txt",
+    "preflight_log.txt",
+    "preflight_log_2.txt",
+    "preflight_log_3.txt",
+    "preflight_output.log",
+    "preflight_output.txt",
+    "preflight-results.json",
+    "violations.txt",
+    "violations_v2.txt",
+    "prisma-check.txt",
+    "secrets.log",
+    "shared_report.txt",
+    "test_output.txt",
+    "test_output_2.txt",
+    "test_output_3.txt",
+    "test_output_shipping.txt",
+    "tsc_output_3.txt",
+    "tsc-output.txt",
+    "tsc-output2.txt",
+    "unified_report.txt",
+    "cycles.log",
+    // Build artifacts
+    "debug-plugins.cjs",
+    "debug-plugins.mjs",
+    "eng.traineddata",
+    "tsconfig.preflight.blocking.tsbuildinfo",
+    "tsconfig.tsbuildinfo",
+    "tsconfig.typecheck.tsbuildinfo",
+    // Additional temporary files
+    "tokenization-report.txt",
+    "eslint-errors.txt",
+    "missing-imports.txt",
+    "nested-components.txt",
+    "page-template-violations.txt",
+    "temp-analysis.txt",
+    "build-errors.log",
+    "type-errors.log",
+    "migration-errors.log",
+    "seed-errors.log",
+    "deployment-errors.log",
+    "performance-report.txt",
+    "bundle-analysis.txt",
+    "dependency-audit.txt",
+    "security-scan.txt",
+    "accessibility-report.txt",
+    "seo-analysis.txt",
+    "lighthouse-report.json",
+    "webpack-bundle-analyzer-report.html",
+    "coverage-summary.json",
+    "test-results-summary.json",
+    "e2e-test-report.html",
+    "visual-regression-report.html",
+    "performance-budget-report.json",
+    "unused-dependencies.txt",
+    "duplicate-code-report.txt",
+    "code-complexity-report.txt",
+    "technical-debt-report.txt",
+    "refactoring-opportunities.txt",
+    // Development and debugging files
+    "debug-output.txt",
+    "debug-trace.log",
+    "memory-usage.log",
+    "cpu-profile.json",
+    "heap-snapshot.heapsnapshot",
+    "flame-graph.html",
+    "profiling-results.json",
+    "benchmark-results.txt",
+    "load-test-results.json",
+    "stress-test-output.txt",
+    // Build and deployment artifacts
+    "build-manifest.json",
+    "deployment-log.txt",
+    "rollback-plan.txt",
+    "migration-plan.txt",
+    "database-backup-log.txt",
+    "environment-diff.txt",
+    "config-validation.txt",
+    "health-check-results.json",
+    // Code analysis and quality reports
+    "sonarqube-report.json",
+    "codeclimate-report.json",
+    "eslint-report.html",
+    "prettier-check.txt",
+    "type-coverage-report.txt",
+    "import-analysis.json",
+    "circular-dependencies.txt",
+    "dead-code-report.txt",
+    "bundle-size-analysis.json",
+    // Testing artifacts
+    "jest-coverage.json",
+    "playwright-trace.zip",
+    "test-screenshots.zip",
+    "test-videos.zip",
+    "mutation-testing-report.html",
+    "integration-test-logs.txt",
+    "e2e-test-artifacts.zip",
+    "performance-test-results.json",
+    // Temporary workspace files
+    "workspace-state.json",
+    "session-data.json",
+    "user-preferences.json",
+    "recent-files.json",
+    "search-history.json",
+    "command-history.txt",
+    "editor-state.json",
+    "breakpoints.json",
+    // Package manager and dependency files
+    "npm-shrinkwrap.json.backup",
+    "package-lock.json.backup",
+    "yarn.lock.backup",
+    "pnpm-lock.yaml.backup",
+    "node_modules.tar.gz",
+    "dependencies-audit.json",
+    "outdated-packages.txt",
+    "security-audit.json",
+    // Reports/logs directory files (older than 7 days)
+    "eslint-result.json",
+    "final-check.txt",
+    "final-warnings.txt",
+    "improved-warnings.txt",
+    "remaining-warnings.txt",
+    "typescript-errors-remaining.txt",
+    "warnings-full.txt",
+    "warnings-verbose.txt",
+    "tsc-stderr.txt",
+    "tsc-stdout.txt",
+    // Additional analysis and build reports
+    "analysis_report.txt",
+    "build_analysis.txt",
+    "bundle_report.txt",
+    "component_analysis.txt",
+    "dependency_analysis.txt",
+    "import_analysis.txt",
+    "performance_analysis.txt",
+    "security_analysis.txt",
+    "type_analysis.txt",
+    "ui_analysis.txt",
+    "validation_report.txt",
+    "verification_report.txt",
+    "cleanup_report.txt",
+    "migration_report.txt",
+    "refactor_report.txt",
+    "optimization_report.txt",
+    "quality_report.txt",
+    "standards_report.txt",
+    "compliance_report.txt",
+    "audit_report.txt",
+    "review_report.txt",
+    "inspection_report.txt",
+    // Development server and runtime logs
+    "dev-server.log",
+    "next-dev.log",
+    "webpack-dev.log",
+    "vite-dev.log",
+    "turbo-dev.log",
+    "runtime-errors.log",
+    "console-output.log",
+    "network-requests.log",
+    "api-calls.log",
+    "database-queries.log",
+    // Backup and archive files (older than 60 days)
+    "schema.prisma.backup",
+    "package.json.backup",
+    "tsconfig.json.backup",
+    "next.config.js.backup",
+    "tailwind.config.ts.backup",
+    "eslint.config.mjs.backup",
+    "prettier.config.js.backup",
+    "jest.config.js.backup",
+    "playwright.config.ts.backup",
+    "vitest.config.ts.backup",
+    // Temporary build and deployment files
+    "build-cache.json",
+    "deployment-cache.json",
+    "upload-cache.json",
+    "download-cache.json",
+    "sync-cache.json",
+    "validation-cache.json",
+    "verification-cache.json",
+    "optimization-cache.json",
+    "compression-cache.json",
+    "minification-cache.json",
+    "recent-files.json",
+    "search-history.json",
+    "command-history.txt",
+    "editor-state.json",
+    "breakpoints.json",
+    // Package manager and dependency files
+    "npm-shrinkwrap.json.backup",
+    "package-lock.json.backup",
+    "yarn.lock.backup",
+    "pnpm-lock.yaml.backup",
+    "node_modules.tar.gz",
+    "dependencies-audit.json",
+    "outdated-packages.txt",
+    "security-audit.json",
+    // Test-results specific files (found in current repo)
+    "account-profile-targeted.log",
+    "account-profile-targeted2.log",
+    "account-profile-targeted3.log",
+    "account-profile-targeted4.log",
+    "account-profile-targeted5.log",
+    "account-profile-targeted6.log",
+    "account-profile-targeted7.log",
+    "dev-server.log",
+    "e2e-slowest.json",
+    "junit.xml",
+    "results.json",
+    "targeted-e2e.log",
+    // Next.js build artifacts (found in current repo)
+    "trace",
+    "trace-build",
+    "turbopack",
+    // Additional development artifacts
+    "preflight-results.json",
+    "playwright-storage.json",
+    "vercel-build.log",
+    "next-build.log",
+    "prisma-generate.log",
+    "migration-status.json",
+    "seed-status.json",
+    "backup-status.json",
+    "deployment-status.json",
+    // IDE and OS artifacts
+    ".DS_Store",
+    "Thumbs.db",
+    "desktop.ini",
+    ".directory",
+    "Icon\r",
+    "ehthumbs.db",
+    "ehthumbs_vista.db",
+    // Version control artifacts
+    ".gitignore.backup",
+    ".gitattributes.backup",
+    "git-hooks.backup",
+    // Documentation artifacts
+    "README.md.backup",
+    "CHANGELOG.md.backup",
+    "docs-backup.zip",
+    "api-docs.html",
+    "component-docs.html",
+    // Configuration backups
+    "tsconfig.json.backup",
+    "package.json.backup",
+    "next.config.js.backup",
+    "tailwind.config.ts.backup",
+    "eslint.config.mjs.backup",
+    "prettier.config.js.backup",
+    "jest.config.js.backup",
+    "playwright.config.ts.backup",
+    // Temporary analysis files
+    "bundle-analyzer-report.html",
+    "dependency-graph.json",
+    "import-map.json",
+    "component-usage.json",
+    "route-analysis.json",
+    "performance-metrics.json",
+    "accessibility-audit.json",
+    "seo-audit.json",
+    "security-audit-report.json",
+    // Build optimization artifacts
+    "webpack-stats.json",
+    "turbopack-stats.json",
+    "build-optimization.log",
+    "chunk-analysis.json",
+    "tree-shaking-report.json",
+    "code-splitting-report.json",
+];
+function getFileStats(filePath) {
+    try {
+        const stats = fs_1.default.statSync(filePath);
+        return {
+            sizeKB: Math.round(stats.size / 1024),
+            lastModified: stats.mtime,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function isDirectoryEmpty(dirPath) {
+    try {
+        const files = fs_1.default.readdirSync(dirPath);
+        return files.length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+function isOlderThanDays(filePath, days) {
+    const stats = getFileStats(filePath);
+    if (!stats)
+        return false;
+    const daysDiff = (Date.now() - stats.lastModified.getTime()) / (1000 * 60 * 60 * 24);
+    return daysDiff > days;
+}
+function scanForCleanupIssues() {
+    const issues = [];
+    let rootFiles = [];
+    // Check root directory for temporary files
+    try {
+        rootFiles = fs_1.default.readdirSync(projectRoot);
+        for (const file of rootFiles) {
+            const filePath = path_1.default.join(projectRoot, file);
+            const stats = getFileStats(filePath);
+            if (!stats)
+                continue;
+            // Check against cleanup patterns
+            for (const [category, patterns] of Object.entries(CLEANUP_PATTERNS)) {
+                for (const pattern of patterns) {
+                    if (pattern.test(file)) {
+                        const severity = SAFE_TO_DELETE.includes(file) ? "warning" : "error";
+                        issues.push({
+                            type: "file",
+                            path: file,
+                            reason: `Temporary ${category.toLowerCase().replace("_", " ")} file`,
+                            severity,
+                            sizeKB: stats.sizeKB,
+                            lastModified: stats.lastModified,
+                        });
+                        break;
+                    }
+                }
+            }
+            // Check for very large files that might be artifacts
+            if (stats.sizeKB > 10000) {
+                // > 10MB
+                issues.push({
+                    type: "file",
+                    path: file,
+                    reason: `Large file (${stats.sizeKB}KB) - possible build artifact`,
+                    severity: "warning",
+                    sizeKB: stats.sizeKB,
+                    lastModified: stats.lastModified,
+                });
+            }
+        }
+    }
+    catch (error) {
+        console.error("Error scanning root directory:", error);
+    }
+    // Recursively scan additional directories for cleanup opportunities
+    for (const scanDir of SCAN_DIRECTORIES) {
+        const fullScanPath = path_1.default.join(projectRoot, scanDir);
+        if (fs_1.default.existsSync(fullScanPath)) {
+            try {
+                scanDirectoryRecursively(fullScanPath, scanDir, issues);
+            }
+            catch (error) {
+                console.error(`Error scanning directory ${scanDir}:`, error);
+            }
+        }
+    }
+    // Check for old backup directories
+    try {
+        const kiroDir = path_1.default.join(projectRoot, ".kiro");
+        if (fs_1.default.existsSync(kiroDir)) {
+            const kiroContents = fs_1.default.readdirSync(kiroDir);
+            for (const item of kiroContents) {
+                if (item.startsWith("steering-backup-")) {
+                    const backupPath = path_1.default.join(kiroDir, item);
+                    if (isOlderThanDays(backupPath, 30)) {
+                        issues.push({
+                            type: "directory",
+                            path: `.kiro/${item}`,
+                            reason: "Old steering backup (>30 days)",
+                            severity: "warning",
+                        });
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error("Error scanning .kiro directory:", error);
+    }
+    // Check for empty directories
+    for (const dirPath of CHECK_EMPTY_DIRS) {
+        const fullPath = path_1.default.join(projectRoot, dirPath);
+        if (fs_1.default.existsSync(fullPath) && isDirectoryEmpty(fullPath)) {
+            issues.push({
+                type: "directory",
+                path: dirPath,
+                reason: "Empty directory",
+                severity: "info",
+            });
+        }
+    }
+    // Check reports directory for old files
+    try {
+        const reportsDir = path_1.default.join(projectRoot, "reports");
+        if (fs_1.default.existsSync(reportsDir)) {
+            const reportFiles = fs_1.default.readdirSync(reportsDir);
+            for (const file of reportFiles) {
+                if (file.startsWith("cleanup-report-") && file.endsWith(".json")) {
+                    const filePath = path_1.default.join(reportsDir, file);
+                    if (isOlderThanDays(filePath, 7)) {
+                        // Older than 1 week
+                        const stats = getFileStats(filePath);
+                        issues.push({
+                            type: "file",
+                            path: `reports/${file}`,
+                            reason: "Old cleanup report (>7 days)",
+                            severity: "info",
+                            sizeKB: stats?.sizeKB,
+                            lastModified: stats?.lastModified,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error("Error scanning reports directory:", error);
+    }
+    // Check for duplicate config files
+    try {
+        const configFiles = rootFiles.filter((f) => f.startsWith(".eslintrc"));
+        if (configFiles.length > 1) {
+            issues.push({
+                type: "file",
+                path: configFiles.join(", "),
+                reason: "Multiple ESLint config files detected - should use only one",
+                severity: "warning",
+            });
+        }
+    }
+    catch (error) {
+        console.error("Error checking config files:", error);
+    }
+    return issues;
+}
+function scanDirectoryRecursively(dirPath, relativePath, issues, depth = 0) {
+    // Limit recursion depth to prevent infinite loops
+    if (depth > 5)
+        return;
+    try {
+        const items = fs_1.default.readdirSync(dirPath);
+        for (const item of items) {
+            const itemPath = path_1.default.join(dirPath, item);
+            const relativeItemPath = path_1.default.join(relativePath, item);
+            const stats = fs_1.default.statSync(itemPath);
+            if (stats.isDirectory()) {
+                // Check if directory should be cleaned up
+                if (shouldCleanupDirectory(item, itemPath)) {
+                    issues.push({
+                        type: "directory",
+                        path: relativeItemPath,
+                        reason: "Build artifact directory",
+                        severity: "warning",
+                    });
+                }
+                else {
+                    // Recursively scan subdirectory
+                    scanDirectoryRecursively(itemPath, relativeItemPath, issues, depth + 1);
+                }
+            }
+            else if (stats.isFile()) {
+                // Check if file should be cleaned up
+                const sizeKB = Math.round(stats.size / 1024);
+                const lastModified = stats.mtime;
+                if (shouldCleanupFile(item, itemPath, sizeKB)) {
+                    issues.push({
+                        type: "file",
+                        path: relativeItemPath,
+                        reason: getFileCleanupReason(item, sizeKB),
+                        severity: "warning",
+                        sizeKB,
+                        lastModified,
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error(`Error scanning directory ${dirPath}:`, error);
+    }
+}
+function shouldCleanupDirectory(dirName, dirPath) {
+    // Cache directories
+    if (dirName === "cache" || dirName === ".cache")
+        return true;
+    // Build artifact directories
+    if (dirName === "trace" || dirName === "trace-build" || dirName === "turbopack")
+        return true;
+    // Test result directories (if old)
+    if (dirName === "artifacts" && isOlderThanDays(dirPath, 7))
+        return true;
+    // Coverage directories (if old)
+    if (dirName === "lcov-report" && isOlderThanDays(dirPath, 7))
+        return true;
+    return false;
+}
+function shouldCleanupFile(fileName, filePath, sizeKB) {
+    // Log files
+    if (fileName.endsWith(".log") && isOlderThanDays(filePath, 7))
+        return true;
+    // Debug files
+    if (fileName.includes("debug") && fileName.endsWith(".txt"))
+        return true;
+    // Temporary files
+    if (fileName.startsWith("temp-") || fileName.startsWith("tmp-"))
+        return true;
+    // Large files that might be artifacts (>100MB)
+    if (sizeKB > 100000)
+        return true;
+    // Build cache files
+    if (fileName.endsWith(".tsbuildinfo") && isOlderThanDays(filePath, 1))
+        return true;
+    // Package manager lock files (duplicates)
+    if ((fileName === "package-lock.json" || fileName === "yarn.lock") &&
+        fs_1.default.existsSync(path_1.default.join(path_1.default.dirname(filePath), "pnpm-lock.yaml")))
+        return true;
+    // IDE artifacts
+    if (fileName === ".DS_Store" || fileName === "Thumbs.db" || fileName === "desktop.ini")
+        return true;
+    // Backup files
+    if (fileName.endsWith(".backup") || fileName.endsWith(".bak") || fileName.endsWith(".old"))
+        return true;
+    // Profiling and debugging artifacts
+    if (fileName.endsWith(".heapsnapshot") || fileName.endsWith(".cpuprofile"))
+        return true;
+    // Test artifacts (old)
+    if ((fileName.includes("test-") || fileName.includes("spec-")) &&
+        fileName.endsWith(".json") &&
+        isOlderThanDays(filePath, 7))
+        return true;
+    // Coverage files (old)
+    if (fileName.includes("coverage") && isOlderThanDays(filePath, 7))
+        return true;
+    // Report files (old)
+    if (fileName.includes("report") &&
+        (fileName.endsWith(".html") || fileName.endsWith(".json")) &&
+        isOlderThanDays(filePath, 14))
+        return true;
+    return false;
+}
+function getFileCleanupReason(fileName, sizeKB) {
+    if (fileName.endsWith(".log"))
+        return "Old log file";
+    if (fileName.includes("debug"))
+        return "Debug file";
+    if (fileName.startsWith("temp-") || fileName.startsWith("tmp-"))
+        return "Temporary file";
+    if (sizeKB > 100000)
+        return `Large file (${sizeKB}KB) - possible artifact`;
+    if (fileName.endsWith(".tsbuildinfo"))
+        return "Old TypeScript build cache";
+    if (fileName === "package-lock.json" || fileName === "yarn.lock")
+        return "Duplicate package manager lock file";
+    if (fileName === ".DS_Store" || fileName === "Thumbs.db")
+        return "OS-generated file";
+    if (fileName.endsWith(".backup") || fileName.endsWith(".bak"))
+        return "Backup file";
+    if (fileName.endsWith(".heapsnapshot") || fileName.endsWith(".cpuprofile"))
+        return "Profiling artifact";
+    if (fileName.includes("test-") && fileName.endsWith(".json"))
+        return "Old test artifact";
+    if (fileName.includes("coverage"))
+        return "Old coverage file";
+    if (fileName.includes("report"))
+        return "Old report file";
+    return "Cleanup candidate";
+}
+function generateCleanupScript(issues) {
+    const safeToDelete = issues.filter((issue) => issue.severity === "warning" &&
+        (issue.type === "file" ? SAFE_TO_DELETE.includes(path_1.default.basename(issue.path)) : true));
+    if (safeToDelete.length === 0)
+        return "";
+    const script = [
+        "#!/bin/bash",
+        "# Auto-generated cleanup script",
+        "# Run with: bash cleanup-safe-files.sh",
+        "",
+        'echo "🧹 Cleaning up temporary files..."',
+        'echo "================================="',
+        "",
+        "# Set error handling",
+        "set -e",
+        "",
+        "# Track cleanup statistics",
+        "FILES_DELETED=0",
+        "DIRS_DELETED=0",
+        "SPACE_RECLAIMED=0",
+        "",
+        "# Function to safely delete file",
+        "delete_file() {",
+        '  local file="$1"',
+        '  local reason="$2"',
+        '  local size="$3"',
+        "  ",
+        '  if [ -f "$file" ]; then',
+        '    echo "${emoji.wrench}  Removing $file ($reason)"',
+        '    rm -f "$file"',
+        "    FILES_DELETED=$((FILES_DELETED + 1))",
+        '    if [ -n "$size" ]; then',
+        "      SPACE_RECLAIMED=$((SPACE_RECLAIMED + size))",
+        "    fi",
+        "  fi",
+        "}",
+        "",
+        "# Function to safely delete directory",
+        "delete_dir() {",
+        '  local dir="$1"',
+        '  local reason="$2"',
+        "  ",
+        '  if [ -d "$dir" ]; then',
+        '    echo "${emoji.folder} Removing directory $dir ($reason)"',
+        '    rm -rf "$dir"',
+        "    DIRS_DELETED=$((DIRS_DELETED + 1))",
+        "  fi",
+        "}",
+        "",
+        "# Clean up files and directories",
+    ];
+    for (const issue of safeToDelete) {
+        if (issue.type === "file") {
+            const sizeKB = issue.sizeKB || 0;
+            script.push(`delete_file "${issue.path}" "${issue.reason}" ${sizeKB}`);
+        }
+        else {
+            script.push(`delete_dir "${issue.path}" "${issue.reason}"`);
+        }
+    }
+    script.push("", "# Clean up additional patterns", "# Old log files", 'find . -name "*.log" -type f -mtime +7 -not -path "./node_modules/*" -not -path "./.git/*" -exec rm -f {} \\; 2>/dev/null || true', "", "# Old TypeScript build info files", 'find . -name "*.tsbuildinfo" -type f -mtime +1 -not -path "./node_modules/*" -exec rm -f {} \\; 2>/dev/null || true', "", "# Empty cache directories", "find .next/cache -type d -empty -delete 2>/dev/null || true", "find .swc/plugins -type d -empty -delete 2>/dev/null || true", "", "# Calculate space reclaimed in MB", "SPACE_MB=$((SPACE_RECLAIMED / 1024))", "", "# Summary", 'echo ""', 'echo "${emoji.chart} Cleanup Summary"', 'echo "=================="', 'echo "Files deleted: $FILES_DELETED"', 'echo "Directories deleted: $DIRS_DELETED"', 'echo "Space reclaimed: ${SPACE_MB}MB (${SPACE_RECLAIMED}KB)"', 'echo ""', 'echo "${emoji.success} Cleanup complete!"');
+    return script.join("\n");
+}
+function generatePowerShellCleanupScript(issues) {
+    const safeToDelete = issues.filter((issue) => issue.severity === "warning" &&
+        (issue.type === "file" ? SAFE_TO_DELETE.includes(path_1.default.basename(issue.path)) : true));
+    if (safeToDelete.length === 0)
+        return "";
+    const script = [
+        "# Auto-generated PowerShell cleanup script",
+        "# Run with: powershell -ExecutionPolicy Bypass -File cleanup-safe-files.ps1",
+        "",
+        'Write-Host "🧹 Cleaning up temporary files..." -ForegroundColor Cyan',
+        'Write-Host "=================================" -ForegroundColor Cyan',
+        "",
+        "# Set error handling",
+        '$ErrorActionPreference = "Continue"',
+        "",
+        "# Track cleanup statistics",
+        "$FilesDeleted = 0",
+        "$DirsDeleted = 0",
+        "$SpaceReclaimed = 0",
+        "",
+        "# Function to safely delete file",
+        "function Remove-SafeFile {",
+        "    param(",
+        "        [string]$FilePath,",
+        "        [string]$Reason,",
+        "        [int]$SizeKB = 0",
+        "    )",
+        "    ",
+        "    if (Test-Path $FilePath -PathType Leaf) {",
+        '        Write-Host "${emoji.wrench}  Removing $FilePath ($Reason)" -ForegroundColor Yellow',
+        "        Remove-Item $FilePath -Force -ErrorAction SilentlyContinue",
+        "        $script:FilesDeleted++",
+        "        $script:SpaceReclaimed += $SizeKB",
+        "    }",
+        "}",
+        "",
+        "# Function to safely delete directory",
+        "function Remove-SafeDirectory {",
+        "    param(",
+        "        [string]$DirPath,",
+        "        [string]$Reason",
+        "    )",
+        "    ",
+        "    if (Test-Path $DirPath -PathType Container) {",
+        '        Write-Host "${emoji.folder} Removing directory $DirPath ($Reason)" -ForegroundColor Yellow',
+        "        Remove-Item $DirPath -Recurse -Force -ErrorAction SilentlyContinue",
+        "        $script:DirsDeleted++",
+        "    }",
+        "}",
+        "",
+        "# Clean up files and directories",
+    ];
+    for (const issue of safeToDelete) {
+        if (issue.type === "file") {
+            const sizeKB = issue.sizeKB || 0;
+            script.push(`Remove-SafeFile "${issue.path}" "${issue.reason}" ${sizeKB}`);
+        }
+        else {
+            script.push(`Remove-SafeDirectory "${issue.path}" "${issue.reason}"`);
+        }
+    }
+    script.push("", "# Clean up additional patterns", "# Old log files", 'Get-ChildItem -Path . -Filter "*.log" -Recurse -File | Where-Object { $_.LastWriteTime -lt (Get-Date).AddDays(-7) -and $_.FullName -notmatch "node_modules|\.git" } | Remove-Item -Force -ErrorAction SilentlyContinue', "", "# Old TypeScript build info files", 'Get-ChildItem -Path . -Filter "*.tsbuildinfo" -Recurse -File | Where-Object { $_.LastWriteTime -lt (Get-Date).AddDays(-1) -and $_.FullName -notmatch "node_modules" } | Remove-Item -Force -ErrorAction SilentlyContinue', "", "# Empty cache directories", 'if (Test-Path ".next/cache") {', '    Get-ChildItem ".next/cache" -Directory | Where-Object { (Get-ChildItem $_.FullName).Count -eq 0 } | Remove-Item -Force -ErrorAction SilentlyContinue', "}", 'if (Test-Path ".swc/plugins") {', '    Get-ChildItem ".swc/plugins" -Directory | Where-Object { (Get-ChildItem $_.FullName).Count -eq 0 } | Remove-Item -Force -ErrorAction SilentlyContinue', "}", "", "# Calculate space reclaimed in MB", "$SpaceMB = [math]::Round($SpaceReclaimed / 1024, 2)", "", "# Summary", 'Write-Host ""', 'Write-Host "${emoji.chart} Cleanup Summary" -ForegroundColor Green', 'Write-Host "==================" -ForegroundColor Green', 'Write-Host "Files deleted: $FilesDeleted" -ForegroundColor Green', 'Write-Host "Directories deleted: $DirsDeleted" -ForegroundColor Green', 'Write-Host "Space reclaimed: ${SpaceMB}MB (${SpaceReclaimed}KB)" -ForegroundColor Green', 'Write-Host ""', 'Write-Host "${emoji.success} Cleanup complete!" -ForegroundColor Green');
+    return script.join("\n");
+}
+async function run() {
+    const reporter = (0, universal_progress_reporter_1.createUniversalProgressReporter)(exports.name);
+    console.log("🧹 File Cleanup Validation");
+    console.log("==========================\n");
+    const issues = scanForCleanupIssues();
+    if (issues.length === 0) {
+        console.log(`${console_chars_1.emoji.success} No cleanup issues found - repository is clean!`);
+        process.exit(0);
+    }
+    // Group issues by severity
+    const errors = issues.filter((i) => i.severity === "error");
+    const warnings = issues.filter((i) => i.severity === "warning");
+    const info = issues.filter((i) => i.severity === "info");
+    let totalSizeKB = 0;
+    if (errors.length > 0) {
+        console.log(`${console_chars_1.emoji.error} ERRORS (must be fixed):`);
+        for (const issue of errors) {
+            console.log(`   ${issue.path} - ${issue.reason}`);
+            if (issue.sizeKB) {
+                console.log(`     Size: ${issue.sizeKB}KB, Modified: ${issue.lastModified?.toLocaleDateString()}`);
+                totalSizeKB += issue.sizeKB;
+            }
+        }
+        console.log("");
+    }
+    if (warnings.length > 0) {
+        console.log(`${console_chars_1.emoji.warning}  WARNINGS (recommended cleanup):`);
+        for (const issue of warnings) {
+            console.log(`   ${issue.path} - ${issue.reason}`);
+            if (issue.sizeKB) {
+                console.log(`     Size: ${issue.sizeKB}KB, Modified: ${issue.lastModified?.toLocaleDateString()}`);
+                totalSizeKB += issue.sizeKB;
+            }
+        }
+        console.log("");
+    }
+    if (info.length > 0) {
+        console.log(`${console_chars_1.emoji.info}  INFO (optional cleanup):`);
+        for (const issue of info) {
+            console.log(`   ${issue.path} - ${issue.reason}`);
+            if (issue.sizeKB) {
+                console.log(`     Size: ${issue.sizeKB}KB, Modified: ${issue.lastModified?.toLocaleDateString()}`);
+                totalSizeKB += issue.sizeKB;
+            }
+        }
+        console.log("");
+    }
+    console.log(`${console_chars_1.emoji.chart} Summary: ${issues.length} cleanup opportunities found`);
+    if (totalSizeKB > 0) {
+        console.log(`💾 Total reclaimable space: ${Math.round(totalSizeKB / 1024)}MB`);
+    }
+    // Generate cleanup script for safe files
+    const cleanupScript = generateCleanupScript(issues);
+    if (cleanupScript) {
+        fs_1.default.writeFileSync(path_1.default.join(projectRoot, "cleanup-safe-files.sh"), cleanupScript);
+        console.log(`\n${console_chars_1.emoji.wrench} Generated cleanup-safe-files.sh for automatic cleanup`);
+        console.log("   Run: bash cleanup-safe-files.sh");
+    }
+    // Generate PowerShell cleanup script
+    const powershellScript = generatePowerShellCleanupScript(issues);
+    if (powershellScript) {
+        fs_1.default.writeFileSync(path_1.default.join(projectRoot, "cleanup-safe-files.ps1"), powershellScript);
+        console.log(`${console_chars_1.emoji.wrench} Generated cleanup-safe-files.ps1 for Windows cleanup`);
+        console.log("   Run: powershell -ExecutionPolicy Bypass -File cleanup-safe-files.ps1");
+    }
+    // Exit with error if there are blocking issues
+    if (errors.length > 0) {
+        console.log(`\n${console_chars_1.emoji.error} Build blocked due to cleanup issues`);
+        console.log("   Fix errors above or run cleanup script");
+        process.exit(1);
+    }
+    if (warnings.length > 5) {
+        console.log(`\n${console_chars_1.emoji.warning}  Many cleanup opportunities found`);
+        console.log("   Consider running cleanup script to reduce repository size");
+    }
+    process.exit(0);
+}
+// Allow direct execution
+if (require.main === module) {
+    run().catch((err) => {
+        console.error("Error:", err);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=file-cleanup-validation.js.map