stay-gold 1.0.4 → 1.1.0

package/dist/index.d.ts

@@ -1,4 +1,2 @@
-export * from "./bang.js";
-export * from "./css-named-colors.js";
-export * from "./css-vars.js";
-export * from "./todos.js";
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -1,4 +1,52 @@
-export * from "./bang.js";
-export * from "./css-named-colors.js";
-export * from "./css-vars.js";
-export * from "./todos.js";
+#!/usr/bin/env node
+// index.ts
+// Main script to run all stay-gold checks in sequence
+import { spawn } from "node:child_process";
+const checks = [
+    { name: "Bang Check", script: "./dist/bang.js" },
+    { name: "TODO Check", script: "./dist/todos.js" },
+    { name: "CSS Variables Check", script: "./dist/css-vars.js" },
+    { name: "CSS Named Colors Check", script: "./dist/css-named-colors.js" }
+];
+async function runCheck(script, name) {
+    return new Promise((resolve) => {
+        console.log(`\n--- Running ${name} ---`);
+        const child = spawn("node", [script], {
+            stdio: "inherit",
+            cwd: process.cwd()
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                console.log(`✅ ${name} passed`);
+                resolve(true);
+            }
+            else {
+                console.log(`❌ ${name} failed`);
+                resolve(false);
+            }
+        });
+    });
+}
+async function runAllChecks() {
+    console.log("🚀 Running all Stay Gold checks...\n");
+    let allPassed = true;
+    for (const check of checks) {
+        const passed = await runCheck(check.script, check.name);
+        if (!passed) {
+            allPassed = false;
+        }
+    }
+    console.log("\n" + "=".repeat(50));
+    if (allPassed) {
+        console.log("🎉 All checks passed! Your code stays gold! ✨");
+        process.exit(0);
+    }
+    else {
+        console.log("💥 Some checks failed. Please fix the issues above.");
+        process.exit(1);
+    }
+}
+runAllChecks().catch((error) => {
+    console.error("Error running checks:", error);
+    process.exit(1);
+});

package/dist/stay-gold.test.d.ts

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

package/dist/stay-gold.test.js

@@ -0,0 +1,305 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { execSync } from "node:child_process";
+import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+describe("stay-gold command", () => {
+    const testDir = join(process.cwd(), "test-project");
+    const srcDir = join(testDir, "src");
+    const publicDir = join(testDir, "public");
+    const stylesDir = join(srcDir, "styles");
+    beforeAll(() => {
+        // Create test project structure
+        if (existsSync(testDir)) {
+            rmSync(testDir, { recursive: true, force: true });
+        }
+        mkdirSync(srcDir, { recursive: true });
+        mkdirSync(publicDir, { recursive: true });
+        mkdirSync(stylesDir, { recursive: true });
+        // Create clean test files
+        writeFileSync(join(srcDir, "clean.ts"), "// This is a clean file\nconst x = 1;\n");
+        writeFileSync(join(stylesDir, "variables.css"), ":root {\n  --primary: #000;\n  --secondary: #fff;\n}\n");
+        writeFileSync(join(stylesDir, "styles.css"), ".test { color: var(--primary); }\n");
+        // Build the project to ensure dist exists
+        try {
+            execSync("npm run build", { cwd: process.cwd(), stdio: "pipe" });
+        }
+        catch (error) {
+            console.error("Build failed:", error);
+        }
+    });
+    afterAll(() => {
+        // Cleanup test directory
+        if (existsSync(testDir)) {
+            rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+    describe("1. Command runs successfully without errors", () => {
+        it("should execute without throwing errors on clean project", () => {
+            expect(() => {
+                execSync("npm run find", {
+                    cwd: testDir,
+                    stdio: "pipe",
+                    encoding: "utf-8",
+                });
+            }).not.toThrow();
+        });
+        it("should execute todos checker without errors", () => {
+            expect(() => {
+                execSync("npm run todos", {
+                    cwd: testDir,
+                    stdio: "pipe",
+                    encoding: "utf-8",
+                });
+            }).not.toThrow();
+        });
+        it("should execute variables checker without errors on valid CSS", () => {
+            expect(() => {
+                execSync("npm run variables", {
+                    cwd: testDir,
+                    stdio: "pipe",
+                    encoding: "utf-8",
+                });
+            }).not.toThrow();
+        });
+        it("should execute named-colors checker without errors", () => {
+            expect(() => {
+                execSync("npm run named-colors", {
+                    cwd: testDir,
+                    stdio: "pipe",
+                    encoding: "utf-8",
+                });
+            }).not.toThrow();
+        });
+        it("should run all checks via gold command on clean project", () => {
+            const result = execSync("npm run gold", {
+                cwd: testDir,
+                stdio: "pipe",
+                encoding: "utf-8",
+            });
+            expect(result).toBeDefined();
+        });
+    });
+    describe("2. Command correctly executes all sub-commands", () => {
+        it("should detect forbidden bang comments", () => {
+            var _a, _b;
+            writeFileSync(join(srcDir, "with-bang.ts"), "// ! This should be detected\n");
+            try {
+                execSync(`node ${join(process.cwd(), "dist/bang.js")}`, {
+                    cwd: testDir,
+                    stdio: "pipe",
+                    encoding: "utf-8",
+                });
+                expect.fail("Should have exited with error code 1");
+            }
+            catch (error) {
+                expect(error.status).toBe(1);
+                const stderr = ((_a = error.stderr) === null || _a === void 0 ? void 0 : _a.toString()) || "";
+                const stdout = ((_b = error.stdout) === null || _b === void 0 ? void 0 : _b.toString()) || "";
+                const output = stderr + stdout;
+                expect(output).toContain("Forbidden string found");
+            }
+            finally {
+                // Cleanup
+                rmSync(join(srcDir, "with-bang.ts"), { force: true });
+            }
+        });
+        it("should detect and count TODO comments", () => {
+            writeFileSync(join(srcDir, "with-todo.ts"), "// TODO: Fix this later\nconst x = 1;\n");
+            try {
+                execSync(`node ${join(process.cwd(), "dist/todos.js")}`, {
+                    cwd: testDir,
+                    stdio: "pipe",
+                    encoding: "utf-8",
+                });
+                expect.fail("Should have exited with error code 1");
+            }
+            catch (error) {
+                expect(error.status).toBe(1);
+                expect(error.stdout.toString()).toContain("TODO(s) in");
+                expect(error.stderr.toString()).toContain("Total TODOs found: 1");
+            }
+            finally {
+                // Cleanup
+                rmSync(join(srcDir, "with-todo.ts"), { force: true });
+            }
+        });
+        it("should detect undefined CSS variables", () => {
+            writeFileSync(join(stylesDir, "bad-vars.css"), ".test { color: var(--undefined-var); }\n");
+            try {
+                execSync(`node ${join(process.cwd(), "dist/css-vars.js")}`, {
+                    cwd: testDir,
+                    stdio: "pipe",
+                    encoding: "utf-8",
+                });
+                expect.fail("Should have exited with error code 1");
+            }
+            catch (error) {
+                expect(error.status).toBe(1);
+                expect(error.stderr.toString()).toContain("Undefined CSS variable");
+                expect(error.stderr.toString()).toContain("undefined-var");
+            }
+            finally {
+                // Cleanup
+                rmSync(join(stylesDir, "bad-vars.css"), { force: true });
+            }
+        });
+        it("should detect named CSS colors", () => {
+            writeFileSync(join(stylesDir, "named-colors.css"), ".test { color: red; background: blue; }\n");
+            try {
+                execSync(`node ${join(process.cwd(), "dist/css-named-colors.js")}`, {
+                    cwd: testDir,
+                    stdio: "pipe",
+                    encoding: "utf-8",
+                });
+                expect.fail("Should have exited with error code 1");
+            }
+            catch (error) {
+                expect(error.status).toBe(1);
+                expect(error.stdout.toString()).toContain("named color");
+                expect(error.stderr.toString()).toContain("Total named CSS colors");
+            }
+            finally {
+                // Cleanup
+                rmSync(join(stylesDir, "named-colors.css"), { force: true });
+            }
+        });
+        it("should pass all checks when project is clean", () => {
+            const output = execSync(`node ${join(process.cwd(), "dist/bang.js")}`, {
+                cwd: testDir,
+                stdio: "pipe",
+                encoding: "utf-8",
+            });
+            expect(output).toContain("No forbidden string found");
+        });
+    });
+    describe("3. Command handles various input arguments or flags", () => {
+        it("should handle execution from different working directories", () => {
+            const output = execSync(`node ${join(process.cwd(), "dist/bang.js")}`, {
+                cwd: testDir,
+                stdio: "pipe",
+                encoding: "utf-8",
+            });
+            expect(output).toBeDefined();
+        });
+        it("should work when called via npm bin script", () => {
+            const output = execSync(`node ${join(process.cwd(), "dist/bang.js")}`, {
+                cwd: testDir,
+                stdio: "pipe",
+                encoding: "utf-8",
+            });
+            expect(output).toContain("No forbidden string found");
+        });
+        it("should handle projects with no src directory gracefully", () => {
+            const emptyTestDir = join(process.cwd(), "test-empty");
+            mkdirSync(emptyTestDir, { recursive: true });
+            try {
+                execSync(`node ${join(process.cwd(), "dist/bang.js")}`, {
+                    cwd: emptyTestDir,
+                    stdio: "pipe",
+                    encoding: "utf-8",
+                });
+            }
+            catch (error) {
+                // Should handle missing directories
+                expect(error).toBeDefined();
+            }
+            finally {
+                rmSync(emptyTestDir, { recursive: true, force: true });
+            }
+        });
+        it("should process multiple file types correctly", () => {
+            // Create files with different extensions
+            writeFileSync(join(srcDir, "test.js"), "const x = 1;\n");
+            writeFileSync(join(srcDir, "test.ts"), "const x: number = 1;\n");
+            writeFileSync(join(srcDir, "test.tsx"), "const x = <div />;\n");
+            writeFileSync(join(srcDir, "test.astro"), "---\nconst x = 1;\n---\n");
+            const output = execSync(`node ${join(process.cwd(), "dist/bang.js")}`, {
+                cwd: testDir,
+                stdio: "pipe",
+                encoding: "utf-8",
+            });
+            expect(output).toContain("No forbidden string found");
+            // Cleanup
+            rmSync(join(srcDir, "test.js"), { force: true });
+            rmSync(join(srcDir, "test.ts"), { force: true });
+            rmSync(join(srcDir, "test.tsx"), { force: true });
+            rmSync(join(srcDir, "test.astro"), { force: true });
+        });
+        it("should handle all comment styles for bang detection", () => {
+            // Test JavaScript style
+            writeFileSync(join(srcDir, "js-bang.js"), "// ! Error\n");
+            try {
+                execSync(`node ${join(process.cwd(), "dist/bang.js")}`, {
+                    cwd: testDir,
+                    stdio: "pipe",
+                });
+                expect.fail("Should detect // ! style");
+            }
+            catch (error) {
+                expect(error.status).toBe(1);
+            }
+            finally {
+                rmSync(join(srcDir, "js-bang.js"), { force: true });
+            }
+            // Test HTML style
+            writeFileSync(join(srcDir, "html-bang.astro"), "<!-- ! Error -->\n");
+            try {
+                execSync(`node ${join(process.cwd(), "dist/bang.js")}`, {
+                    cwd: testDir,
+                    stdio: "pipe",
+                });
+                expect.fail("Should detect <!-- ! style");
+            }
+            catch (error) {
+                expect(error.status).toBe(1);
+            }
+            finally {
+                rmSync(join(srcDir, "html-bang.astro"), { force: true });
+            }
+            // Test JSX style
+            writeFileSync(join(srcDir, "jsx-bang.tsx"), "{/* ! Error */}\n");
+            try {
+                execSync(`node ${join(process.cwd(), "dist/bang.js")}`, {
+                    cwd: testDir,
+                    stdio: "pipe",
+                });
+                expect.fail("Should detect {/* ! style");
+            }
+            catch (error) {
+                expect(error.status).toBe(1);
+            }
+            finally {
+                rmSync(join(srcDir, "jsx-bang.tsx"), { force: true });
+            }
+        });
+        it("should exit with proper exit codes", () => {
+            // Test success exit code
+            try {
+                execSync(`node ${join(process.cwd(), "dist/bang.js")}`, {
+                    cwd: testDir,
+                    stdio: "pipe",
+                });
+                // If no error thrown, exit code was 0 (success)
+                expect(true).toBe(true);
+            }
+            catch (error) {
+                expect.fail("Should exit with code 0 on clean project");
+            }
+            // Test failure exit code
+            writeFileSync(join(srcDir, "fail.ts"), "// ! Error\n");
+            try {
+                execSync(`node ${join(process.cwd(), "dist/bang.js")}`, {
+                    cwd: testDir,
+                    stdio: "pipe",
+                });
+                expect.fail("Should exit with code 1 on violations");
+            }
+            catch (error) {
+                expect(error.status).toBe(1);
+            }
+            finally {
+                rmSync(join(srcDir, "fail.ts"), { force: true });
+            }
+        });
+    });
+});

package/dist/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/dist/vitest.config.js

@@ -0,0 +1,9 @@
+import { defineConfig } from "vitest/config";
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: "node",
+        testTimeout: 30000,
+        hookTimeout: 30000,
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stay-gold",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "type": "module",
   "description": "Checks and balances for code quality. Run as a dev dependency in any project.",
   "main": "dist/index.js",
@@ -14,10 +14,13 @@
     "stay-gold-find": "dist/bang.js",
     "stay-gold-todos": "dist/todos.js",
     "stay-gold-css-vars": "dist/css-vars.js",
-    "stay-gold-css-named-colors": "dist/css-named-colors.js"
+    "stay-gold-css-named-colors": "dist/css-named-colors.js",
+    "stay-gold": "dist/index.js"
   },
   "scripts": {
     "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "find": "node dist/bang.js",
     "todos": "node dist/todos.js",
     "variables": "node dist/css-vars.js",
@@ -37,7 +40,9 @@
   "license": "ISC",
   "devDependencies": {
     "@types/node": "^24.3.1",
+    "@vitest/ui": "^4.0.5",
+    "string-checker": "latest",
     "typescript": "^5.9.2",
-    "string-checker": "latest"
+    "vitest": "^4.0.5"
   }
 }