@technicalshree/auto-fix 1.1.0

package/dist/subsystems/checks.js

@@ -0,0 +1,118 @@
+function nodeChecks(detection, selected) {
+    if (!detection.node.detected)
+        return [];
+    const scripts = detection.node.packageScripts;
+    const steps = [];
+    if (selected.includes("format") && scripts.includes("format")) {
+        steps.push({
+            id: "check-node-format",
+            title: "Run Node format check",
+            subsystem: "checks",
+            phase: "checks",
+            checkKind: "format",
+            rationale: "Configured formatting check for JS/TS project.",
+            commands: ["npm run format"],
+            destructive: false,
+            irreversible: false,
+            undoable: false,
+            status: "planned",
+        });
+    }
+    if (selected.includes("lint") && scripts.includes("lint")) {
+        steps.push({
+            id: "check-node-lint",
+            title: "Run Node lint check",
+            subsystem: "checks",
+            phase: "checks",
+            checkKind: "lint",
+            rationale: "Configured lint check for JS/TS project.",
+            commands: ["npm run lint"],
+            destructive: false,
+            irreversible: false,
+            undoable: false,
+            status: "planned",
+        });
+    }
+    if (selected.includes("test") && scripts.includes("test")) {
+        steps.push({
+            id: "check-node-test",
+            title: "Run Node tests",
+            subsystem: "checks",
+            phase: "checks",
+            checkKind: "test",
+            rationale: "Configured test script for JS/TS project.",
+            commands: ["npm test"],
+            destructive: false,
+            irreversible: false,
+            undoable: false,
+            status: "planned",
+        });
+    }
+    return steps;
+}
+function pythonChecks(detection, config, selected) {
+    if (!detection.python.detected)
+        return [];
+    const steps = [];
+    if (selected.includes("format")) {
+        for (const cmd of config.python.tools.format) {
+            steps.push({
+                id: `check-python-format-${cmd.replace(/[^a-z0-9]/gi, "-")}`,
+                title: `Run Python format: ${cmd}`,
+                subsystem: "checks",
+                phase: "checks",
+                checkKind: "format",
+                rationale: "Configured Python formatting check.",
+                commands: [cmd],
+                destructive: false,
+                irreversible: false,
+                undoable: false,
+                status: "planned",
+            });
+        }
+    }
+    if (selected.includes("lint")) {
+        for (const cmd of config.python.tools.lint) {
+            steps.push({
+                id: `check-python-lint-${cmd.replace(/[^a-z0-9]/gi, "-")}`,
+                title: `Run Python lint: ${cmd}`,
+                subsystem: "checks",
+                phase: "checks",
+                checkKind: "lint",
+                rationale: "Configured Python lint check.",
+                commands: [cmd],
+                destructive: false,
+                irreversible: false,
+                undoable: false,
+                status: "planned",
+            });
+        }
+    }
+    if (selected.includes("test")) {
+        for (const cmd of config.python.tools.test) {
+            steps.push({
+                id: `check-python-test-${cmd.replace(/[^a-z0-9]/gi, "-")}`,
+                title: `Run Python tests: ${cmd}`,
+                subsystem: "checks",
+                phase: "checks",
+                checkKind: "test",
+                rationale: "Configured Python test check.",
+                commands: [cmd],
+                destructive: false,
+                irreversible: false,
+                undoable: false,
+                status: "planned",
+            });
+        }
+    }
+    return steps;
+}
+export function buildCheckSteps(detection, config, flags, focusSubsystem) {
+    const selected = flags.checks ?? config.checks.default;
+    const steps = [];
+    if (!focusSubsystem || focusSubsystem === "node")
+        steps.push(...nodeChecks(detection, selected));
+    if (!focusSubsystem || focusSubsystem === "python")
+        steps.push(...pythonChecks(detection, config, selected));
+    return steps;
+}

package/dist/subsystems/docker.js

@@ -0,0 +1,56 @@
+function composePrefix(detection) {
+    if (!detection.docker.composeFile)
+        return "docker compose";
+    return `docker compose -f ${detection.docker.composeFile}`;
+}
+export function buildDockerSteps(detection, config, flags) {
+    if (!detection.docker.detected)
+        return [];
+    const steps = [];
+    const prefix = composePrefix(detection);
+    if (config.docker.safe_down) {
+        steps.push({
+            id: "docker-compose-down",
+            title: "Run docker compose down",
+            subsystem: "docker",
+            phase: "docker",
+            rationale: "Reset stale compose state safely.",
+            commands: [`${prefix} down`],
+            destructive: false,
+            irreversible: false,
+            undoable: false,
+            status: "planned",
+        });
+    }
+    if (config.docker.rebuild) {
+        steps.push({
+            id: "docker-compose-rebuild",
+            title: "Rebuild docker compose services",
+            subsystem: "docker",
+            phase: "docker",
+            rationale: "Rebuild services to resolve dirty container/image state.",
+            commands: [`${prefix} up -d --build`],
+            destructive: false,
+            irreversible: false,
+            undoable: false,
+            status: "planned",
+        });
+    }
+    if (flags.deep || flags.approve || config.docker.prune) {
+        steps.push({
+            id: "docker-prune",
+            title: "IRREVERSIBLE: Prune docker system",
+            subsystem: "docker",
+            phase: "docker",
+            rationale: "Deep cleanup requested for stale docker artifacts.",
+            commands: ["docker system prune -f"],
+            destructive: true,
+            irreversible: true,
+            irreversibleReason: "cannot be snapshotted",
+            undoable: false,
+            undoHints: [{ action: "Rebuild services", command: `${prefix} up -d --build` }],
+            status: "planned",
+        });
+    }
+    return steps;
+}

package/dist/subsystems/node.js

@@ -0,0 +1,124 @@
+function choosePm(detected, configured) {
+    if (configured !== "auto")
+        return configured;
+    if (detected === "unknown")
+        return "npm";
+    return detected;
+}
+function frozenInstall(pm) {
+    if (pm === "pnpm")
+        return "pnpm install --frozen-lockfile";
+    if (pm === "yarn")
+        return "yarn install --frozen-lockfile";
+    return "npm ci";
+}
+export function buildNodeSteps(detection, config, flags) {
+    if (!detection.node.detected)
+        return [];
+    const pm = choosePm(detection.node.packageManager, config.node.package_manager);
+    const steps = [];
+    if (detection.node.lockfileCorrupted) {
+        steps.push({
+            id: "node-lockfile-corruption-detected",
+            title: "Lockfile corruption detected",
+            subsystem: "node",
+            phase: "node",
+            rationale: "Lockfile parse failure detected; frozen install strategy will likely fail.",
+            commands: [],
+            destructive: false,
+            irreversible: false,
+            undoable: false,
+            status: "proposed",
+            proposedReason: "Recommend fresh regeneration with --force-fresh and --deep/--approve",
+        });
+        if (flags.forceFresh && (flags.deep || flags.approve)) {
+            steps.push({
+                id: "node-remove-lockfiles-force-fresh",
+                title: "IRREVERSIBLE: Remove corrupted lockfiles and regenerate",
+                subsystem: "node",
+                phase: "node",
+                rationale: "Forced fresh recovery for corrupted lockfile.",
+                commands: ["rm -f package-lock.json pnpm-lock.yaml yarn.lock", `${pm} install`],
+                destructive: true,
+                irreversible: true,
+                irreversibleReason: "cannot be snapshotted reliably if unreadable/corrupt",
+                undoable: false,
+                undoHints: [{ action: "Regenerate lockfile", command: `${pm} install` }],
+                status: "planned",
+            });
+        }
+    }
+    if (!detection.node.hasNodeModules) {
+        steps.push({
+            id: "node-install-deps",
+            title: "Install Node dependencies",
+            subsystem: "node",
+            phase: "node",
+            rationale: "package.json found and node_modules appears missing.",
+            commands: [detection.node.lockfileCorrupted ? `${pm} install` : frozenInstall(pm)],
+            destructive: false,
+            irreversible: false,
+            undoable: false,
+            status: "planned",
+        });
+    }
+    if (detection.node.hasNext && config.node.caches.next) {
+        steps.push({
+            id: "node-clean-next-cache",
+            title: "Clean Next.js cache",
+            subsystem: "node",
+            phase: "node",
+            rationale: "Next.js cache can cause stale build/runtime state.",
+            commands: ["rm -rf .next"],
+            destructive: false,
+            irreversible: false,
+            undoable: false,
+            status: "planned",
+        });
+    }
+    if (detection.node.hasVite && config.node.caches.vite) {
+        steps.push({
+            id: "node-clean-vite-cache",
+            title: "Clean Vite cache",
+            subsystem: "node",
+            phase: "node",
+            rationale: "Vite cache corruption is a common local issue.",
+            commands: ["rm -rf node_modules/.vite"],
+            destructive: false,
+            irreversible: false,
+            undoable: false,
+            status: "planned",
+        });
+    }
+    for (const cacheDir of config.node.caches.directories) {
+        steps.push({
+            id: `node-clean-cache-${cacheDir.replace(/[^a-z0-9]/gi, "-")}`,
+            title: `Clean cache directory ${cacheDir}`,
+            subsystem: "node",
+            phase: "node",
+            rationale: "Configured cache directory cleanup.",
+            commands: [`rm -rf ${cacheDir}`],
+            destructive: false,
+            irreversible: false,
+            undoable: false,
+            status: "planned",
+        });
+    }
+    if (flags.deep && config.node.deep_cleanup.remove_node_modules) {
+        steps.push({
+            id: "node-remove-node-modules",
+            title: "IRREVERSIBLE: Remove node_modules for clean reinstall",
+            subsystem: "node",
+            phase: "node",
+            rationale: "Deep cleanup requested to resolve dependency drift.",
+            commands: ["rm -rf node_modules", `${pm} install`],
+            destructive: true,
+            irreversible: true,
+            irreversibleReason: "large folder not snapshotted in MVP",
+            undoable: false,
+            undoHints: [{ action: "Reinstall dependencies", command: `${pm} install` }],
+            status: "planned",
+        });
+    }
+    return steps;
+}

package/dist/subsystems/python.js

@@ -0,0 +1,64 @@
+function installCommand(prefer) {
+    switch (prefer) {
+        case "uv":
+            return "uv pip install -r requirements.txt";
+        case "poetry":
+            return "poetry install";
+        case "pipenv":
+            return "pipenv install";
+        case "pip":
+            return "pip install -r requirements.txt";
+        default:
+            return "pip install -r requirements.txt";
+    }
+}
+export function buildPythonSteps(detection, config, flags) {
+    if (!detection.python.detected)
+        return [];
+    const steps = [];
+    if (!detection.python.venvExists) {
+        steps.push({
+            id: "python-create-venv",
+            title: "Create Python virtual environment",
+            subsystem: "python",
+            phase: "python",
+            rationale: "Python project detected without configured virtual environment.",
+            commands: [`python3 -m venv ${config.python.venv_path}`],
+            destructive: false,
+            irreversible: false,
+            undoable: false,
+            status: "planned",
+        });
+    }
+    if (detection.python.hasRequirements || detection.python.hasPyproject) {
+        steps.push({
+            id: "python-install-deps",
+            title: "Install Python dependencies",
+            subsystem: "python",
+            phase: "python",
+            rationale: "Dependency refresh to resolve environment drift.",
+            commands: [installCommand(config.python.install.prefer)],
+            destructive: false,
+            irreversible: false,
+            undoable: false,
+            status: "planned",
+        });
+    }
+    if (flags.deep) {
+        steps.push({
+            id: "python-reset-venv",
+            title: "IRREVERSIBLE: Reset Python virtual environment",
+            subsystem: "python",
+            phase: "python",
+            rationale: "Deep cleanup for persistent Python environment drift.",
+            commands: [`rm -rf ${config.python.venv_path}`, `python3 -m venv ${config.python.venv_path}`],
+            destructive: true,
+            irreversible: true,
+            irreversibleReason: "cannot restore environment state fully",
+            undoable: false,
+            undoHints: [{ action: "Reinstall dependencies", command: installCommand(config.python.install.prefer) }],
+            status: "planned",
+        });
+    }
+    return steps;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/renderer.js

@@ -0,0 +1,161 @@
+import * as p from "@clack/prompts";
+const S = {
+    ok: "\u2714",
+    fail: "\u2717",
+    skip: "\u23ED",
+    warn: "\u25B2",
+    irr: "\u26A0",
+    dot: "\u25CF",
+    diamond: "\u25C6",
+};
+export function createRenderer(flags, interactive) {
+    const rich = interactive && !flags.quiet && !flags.json;
+    const spin = rich ? p.spinner() : null;
+    let spinRunning = false;
+    return {
+        isRich: rich,
+        intro(command) {
+            if (!rich)
+                return;
+            const tags = [];
+            if (flags.deep)
+                tags.push("deep");
+            if (flags.approve)
+                tags.push("approve");
+            if (flags.forceFresh)
+                tags.push("force-fresh");
+            if (flags.focus !== "all")
+                tags.push(`focus:${flags.focus}`);
+            if (flags.killPorts)
+                tags.push("kill-ports");
+            const extra = tags.length ? ` [${tags.join(", ")}]` : "";
+            p.intro(`auto-fix \u00B7 ${command}${extra}`);
+        },
+        showDetection(detection) {
+            if (!rich)
+                return;
+            const parts = [];
+            if (detection.node.detected)
+                parts.push(`Node (${detection.node.packageManager})`);
+            if (detection.python.detected)
+                parts.push("Python");
+            if (detection.docker.detected)
+                parts.push("Docker Compose");
+            p.log.info(`Detected: ${parts.join(", ") || "No supported project detected"}`);
+            for (const issue of detection.issues) {
+                p.log.warn(issue);
+            }
+        },
+        showPlan(steps, label) {
+            if (!rich)
+                return;
+            if (steps.length === 0) {
+                p.log.info("No actions to take.");
+                return;
+            }
+            const lines = steps.map((s) => {
+                const prefix = s.irreversible ? S.irr : s.destructive ? S.diamond : S.dot;
+                const irr = s.irreversible ? " [IRREVERSIBLE]" : "";
+                const reason = s.proposedReason ? ` \u2014 ${s.proposedReason}` : "";
+                return `  ${prefix}  ${s.title}${irr}${reason}`;
+            });
+            p.note(lines.join("\n"), label ?? `Plan \u2014 ${steps.length} step(s)`);
+        },
+        createStepHooks() {
+            return {
+                onStepStart: (step) => {
+                    if (!rich || !spin)
+                        return;
+                    spin.start(step.title);
+                    spinRunning = true;
+                },
+                onStepEnd: (step) => {
+                    if (!rich)
+                        return;
+                    if (spinRunning && spin) {
+                        const msg = step.status === "success"
+                            ? `${S.ok}  ${step.title}`
+                            : step.status === "failed"
+                                ? `${S.fail}  ${step.title}${step.error ? ` \u2014 ${step.error}` : ""}`
+                                : `${S.skip}  ${step.title}${step.proposedReason ? ` (${step.proposedReason})` : ""}`;
+                        spin.stop(msg);
+                        spinRunning = false;
+                    }
+                    else {
+                        const symbol = step.status === "proposed" ? S.skip : S.dot;
+                        const reason = step.proposedReason ? ` (${step.proposedReason})` : "";
+                        p.log.warn(`${symbol}  ${step.title}${reason}`);
+                    }
+                },
+                onConfirm: async (question) => {
+                    if (!rich)
+                        return false;
+                    if (spinRunning && spin) {
+                        spin.stop();
+                        spinRunning = false;
+                    }
+                    const result = await p.confirm({ message: question });
+                    if (p.isCancel(result)) {
+                        p.cancel("Operation cancelled.");
+                        process.exit(0);
+                    }
+                    return result;
+                },
+            };
+        },
+        showResults(summary) {
+            if (!rich)
+                return;
+            const parts = [];
+            if (summary.succeeded > 0)
+                parts.push(`${S.ok} ${summary.succeeded} succeeded`);
+            if (summary.failed > 0)
+                parts.push(`${S.fail} ${summary.failed} failed`);
+            if (summary.skipped > 0)
+                parts.push(`${S.skip} ${summary.skipped} skipped/proposed`);
+            p.log.success(parts.join("  "));
+            if (summary.irreversibleStepIds.length > 0) {
+                p.log.warn(`Undo coverage: partial \u2014 ${summary.irreversibleStepIds.join(", ")} not undoable`);
+            }
+            for (const w of summary.warnings) {
+                p.log.warn(w);
+            }
+        },
+        showUndoResults(restored, skipped, missing, failed) {
+            if (!rich)
+                return;
+            const parts = [];
+            if (restored > 0)
+                parts.push(`${S.ok} ${restored} restored`);
+            if (skipped > 0)
+                parts.push(`${S.skip} ${skipped} skipped`);
+            if (missing > 0)
+                parts.push(`${S.warn} ${missing} missing snapshot`);
+            if (failed > 0)
+                parts.push(`${S.fail} ${failed} failed`);
+            p.log.success(parts.join("  "));
+        },
+        showReportInfo(msg) {
+            if (!rich)
+                return;
+            p.log.info(msg);
+        },
+        startTask(msg) {
+            if (!rich || !spin)
+                return;
+            spin.start(msg);
+            spinRunning = true;
+        },
+        stopTask(msg) {
+            if (!rich || !spin || !spinRunning)
+                return;
+            spin.stop(msg);
+            spinRunning = false;
+        },
+        outro(message) {
+            if (!rich)
+                return;
+            p.outro(`Next \u2192 ${message}`);
+        },
+    };
+}

package/dist/utils/colors.js

@@ -0,0 +1,20 @@
+const reset = "\u001b[0m";
+const bold = "\u001b[1m";
+const dim = "\u001b[2m";
+const green = "\u001b[32m";
+const red = "\u001b[31m";
+const yellow = "\u001b[33m";
+const cyan = "\u001b[36m";
+function wrap(enabled, code, value) {
+    return enabled ? `${code}${value}${reset}` : value;
+}
+export function style(enabled) {
+    return {
+        title: (v) => wrap(enabled, `${bold}${cyan}`, v),
+        ok: (v) => wrap(enabled, green, v),
+        warn: (v) => wrap(enabled, yellow, v),
+        err: (v) => wrap(enabled, red, v),
+        strong: (v) => wrap(enabled, bold, v),
+        dim: (v) => wrap(enabled, dim, v),
+    };
+}

package/dist/utils/fs.js

@@ -0,0 +1,60 @@
+import { access, cp, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { constants } from "node:fs";
+export async function fileExists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function ensureDir(dir) {
+    await mkdir(dir, { recursive: true });
+}
+export async function ensureWritableDir(dir) {
+    try {
+        await ensureDir(dir);
+        await access(dir, constants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function readJsonFile(target) {
+    if (!(await fileExists(target)))
+        return null;
+    const content = await readFile(target, "utf8");
+    return JSON.parse(content);
+}
+export async function writeJsonFile(target, data) {
+    await ensureDir(path.dirname(target));
+    await writeFile(target, JSON.stringify(data, null, 2), "utf8");
+}
+export async function copyPath(src, dest) {
+    await ensureDir(path.dirname(dest));
+    await cp(src, dest, { recursive: true, force: true });
+}
+export async function ensureAutofixInGitignore(cwd) {
+    let current = cwd;
+    while (true) {
+        const gitDir = path.join(current, ".git");
+        if (await fileExists(gitDir)) {
+            const gitignore = path.join(current, ".gitignore");
+            const exists = await fileExists(gitignore);
+            const body = exists ? await readFile(gitignore, "utf8") : "";
+            if (!body.split(/\r?\n/).includes(".autofix/")) {
+                const next = `${body}${body.endsWith("\n") || body.length === 0 ? "" : "\n"}.autofix/\n`;
+                await writeFile(gitignore, next, "utf8");
+                return true;
+            }
+            return false;
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            return false;
+        current = parent;
+    }
+}

package/dist/utils/process.js

@@ -0,0 +1,17 @@
+import { exec } from "node:child_process";
+export function runShellCommand(command, cwd) {
+    return new Promise((resolve) => {
+        exec(command, { cwd, maxBuffer: 1024 * 1024 * 4 }, (error, stdout, stderr) => {
+            if (error) {
+                resolve({
+                    success: false,
+                    code: typeof error.code === "number" ? error.code : 1,
+                    stdout: stdout ?? "",
+                    stderr: stderr ?? error.message,
+                });
+                return;
+            }
+            resolve({ success: true, code: 0, stdout: stdout ?? "", stderr: stderr ?? "" });
+        });
+    });
+}

package/dist/utils/tty.js

@@ -0,0 +1,3 @@
+export function isInteractive() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY && !process.env.CI);
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@technicalshree/auto-fix",
+  "version": "1.1.0",
+  "description": "Detect, diagnose, and safely fix common local dev environment issues",
+  "main": "dist/cli.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TechnicalShree/ts-cli-tool.git"
+  },
+  "homepage": "https://github.com/TechnicalShree/ts-cli-tool#readme",
+  "bugs": {
+    "url": "https://github.com/TechnicalShree/ts-cli-tool/issues"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "bin": {
+    "auto-fix": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/cli.ts",
+    "start": "node dist/cli.js",
+    "test": "npm run build --silent && node --test",
+    "lint": "tsc --noEmit",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run lint && npm test"
+  },
+  "keywords": [
+    "cli",
+    "autofix",
+    "developer-tools"
+  ],
+  "author": "Krushna Raut",
+  "license": "ISC",
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.0.1",
+    "yaml": "^2.8.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "tsx": "^4.20.4",
+    "typescript": "^5.9.2"
+  }
+}