@akanjs/devkit 3.0.0-alpha.71 → 3.0.0-alpha.73

package/workflow/executor.test.ts

@@ -0,0 +1,146 @@
+import { describe, expect, test } from "bun:test";
+import { WorkflowExecutor, workflowStepKey } from "./executor";
+import type {
+  PrimitiveChangedFile,
+  WorkflowDiagnostic,
+  WorkflowPlan,
+  WorkflowStep,
+  WorkflowStepRegistry,
+  WorkflowStepResult,
+} from "./types";
+
+/**
+ * `WorkflowExecutor` takes its registry by constructor injection and its plan as data, so `apply` runs with
+ * no filesystem and no workspace — the `workspace` argument is what gates every post-apply check. These
+ * cover the ordering rules that `cli/workflow/workflow.test.ts` can only reach through a real scaffold.
+ */
+const step = (id: string, tool = `tool:${id}`): WorkflowStep => ({
+  id,
+  tool,
+  title: id,
+  description: id,
+});
+
+// Every field spelled out rather than cast through `unknown`: `apply` reads `validation` before the first
+// step runs, so a partial literal fails at runtime instead of at the type level.
+const planOf = (steps: WorkflowStep[], diagnostics: WorkflowDiagnostic[] = []): WorkflowPlan => ({
+  schemaVersion: 1,
+  workflow: "add-field",
+  mode: "plan",
+  inputs: {},
+  optionalSurfaces: {},
+  steps,
+  predictedChanges: [],
+  validation: [],
+  diagnostics,
+  recommendations: [],
+  requiresApproval: true,
+});
+
+/**
+ * A registry that records **which key** each call resolved through, not just that a step ran — the
+ * resolution order is the thing under test, and every candidate key would otherwise record the same step id.
+ */
+const changed = (path: string): PrimitiveChangedFile => ({ path, action: "modify", reason: "test" });
+
+const recordingRegistry = (results: Record<string, WorkflowStepResult | undefined> = {}) => {
+  const calls: string[] = [];
+  const registry: WorkflowStepRegistry = {};
+  const on = (key: string) => {
+    registry[key] = async () => {
+      calls.push(key);
+      return results[key];
+    };
+  };
+  return { calls, registry, on };
+};
+
+describe("WorkflowExecutor.apply", () => {
+  test("runs no step when the plan already carries an error diagnostic", async () => {
+    const { calls, registry, on } = recordingRegistry();
+    on(workflowStepKey("add-field", "one"));
+    const plan = planOf([step("one")], [{ severity: "error", code: "plan-invalid", message: "bad inputs" }]);
+
+    const report = await new WorkflowExecutor(registry).apply(plan);
+
+    expect(calls).toEqual([]);
+    expect(report.diagnostics.map((diagnostic) => diagnostic.code)).toContain("plan-invalid");
+  });
+
+  test("a warning in the plan does not stop the steps", async () => {
+    const { calls, registry, on } = recordingRegistry();
+    on(workflowStepKey("add-field", "one"));
+    const plan = planOf([step("one")], [{ severity: "warning", code: "plan-note", message: "heads up" }]);
+
+    await new WorkflowExecutor(registry).apply(plan);
+
+    expect(calls).toEqual([workflowStepKey("add-field", "one")]);
+  });
+
+  test("resolves a runner by workflow-scoped key first, then tool, then bare step id", async () => {
+    const { calls, registry, on } = recordingRegistry();
+    // All three keys are registered for the same step, so only the winner records a call.
+    on(workflowStepKey("add-field", "scoped"));
+    on("tool:scoped");
+    on("scoped");
+    await new WorkflowExecutor(registry).apply(planOf([step("scoped")]));
+    expect(calls).toEqual([workflowStepKey("add-field", "scoped")]);
+
+    const byTool = recordingRegistry();
+    byTool.on("tool:viaTool");
+    byTool.on("viaTool");
+    await new WorkflowExecutor(byTool.registry).apply(planOf([step("viaTool")]));
+    expect(byTool.calls).toEqual(["tool:viaTool"]);
+
+    const byId = recordingRegistry();
+    byId.on("viaId");
+    await new WorkflowExecutor(byId.registry).apply(planOf([step("viaId")]));
+    expect(byId.calls).toEqual(["viaId"]);
+  });
+
+  test("an unsupported step is reported and abandons the rest of the plan", async () => {
+    const { calls, registry, on } = recordingRegistry();
+    on(workflowStepKey("add-field", "first"));
+    on(workflowStepKey("add-field", "third"));
+
+    const report = await new WorkflowExecutor(registry).apply(planOf([step("first"), step("second"), step("third")]));
+
+    expect(calls).toEqual([workflowStepKey("add-field", "first")]);
+    expect(report.diagnostics.map((diagnostic) => diagnostic.code)).toContain("workflow-step-unsupported");
+    expect(report.nextActions.map((action) => action.command)).toContain("akan workflow explain add-field");
+  });
+
+  test("accumulates changed files and diagnostics across steps, and stops at the first error", async () => {
+    const key = (id: string) => workflowStepKey("add-field", id);
+    const { calls, registry, on } = recordingRegistry({
+      [key("a")]: { changedFiles: [changed("apps/demo/lib/task/task.constant.ts")] },
+      [key("b")]: {
+        changedFiles: [changed("apps/demo/lib/task/task.dictionary.ts")],
+        diagnostics: [{ severity: "error", code: "step-failed", message: "no such module" }],
+      },
+      [key("c")]: { changedFiles: [changed("never-reached.ts")] },
+    });
+    on(key("a"));
+    on(key("b"));
+    on(key("c"));
+
+    const report = await new WorkflowExecutor(registry).apply(planOf([step("a"), step("b"), step("c")]));
+
+    expect(calls).toEqual([key("a"), key("b")]);
+    expect(report.changedFiles.map((file) => file.path)).toEqual([
+      "apps/demo/lib/task/task.constant.ts",
+      "apps/demo/lib/task/task.dictionary.ts",
+    ]);
+    expect(report.diagnostics.map((diagnostic) => diagnostic.code)).toContain("step-failed");
+  });
+
+  test("a runner that answers nothing is not an error", async () => {
+    const { calls, registry, on } = recordingRegistry();
+    on(workflowStepKey("add-field", "silent"));
+    const report = await new WorkflowExecutor(registry).apply(planOf([step("silent")]));
+
+    expect(calls).toEqual([workflowStepKey("add-field", "silent")]);
+    expect(report.diagnostics.filter((diagnostic) => diagnostic.severity === "error")).toEqual([]);
+    expect(report.changedFiles).toEqual([]);
+  });
+});

package/builder.ts

@@ -1,164 +0,0 @@
-import { existsSync } from "node:fs";
-import { mkdir } from "node:fs/promises";
-import path from "node:path";
-import type { Loader } from "bun";
-import type { Executor } from "./executors";
-import { FileSys } from "./fileSys";
-import type { PackageJson } from "./types";
-
-/** Relative paths under these directories are not used as Bun.build entrypoints (Bun does not expand `**` in entrypoint strings; we scan with {@link Bun.Glob}). */
-const SKIP_ENTRY_DIR_SET = new Set(["node_modules", "dist", "build", ".git", ".next"]);
-
-const assetExtensions = [".css", ".md", ".js", ".png", ".ico", ".svg", ".json", ".template"];
-const assetLoader = Object.fromEntries(assetExtensions.map((ext) => [ext, "file" as const])) satisfies Record<
-  string,
-  Loader
->;
-
-type BunBuildConfig = Parameters<typeof Bun.build>[0] & { bundle?: boolean };
-type ExportValue = string | string[] | { [condition: string]: ExportValue };
-
-interface BuildOptions {
-  bundle?: boolean;
-  additionalEntryPoints?: string[];
-}
-
-interface BuilderOptions {
-  executor: Executor;
-  distExecutor: Executor;
-  pkgJson: PackageJson;
-  rootPackageJson: PackageJson;
-}
-export class Builder {
-  #executor: Executor;
-  #distExecutor: Executor;
-  #pkgJson: PackageJson;
-
-  constructor({ executor, distExecutor, pkgJson }: BuilderOptions) {
-    this.#executor = executor;
-    this.#distExecutor = distExecutor;
-    this.#pkgJson = pkgJson;
-  }
-  #globEntrypoints(cwd: string, pattern: string): string[] {
-    const glob = new Bun.Glob(pattern);
-    return Array.from(glob.scanSync({ cwd, onlyFiles: true }))
-      .filter((relativePath) => {
-        const segments = relativePath.split(path.sep);
-        return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
-      })
-      .map((rel) => path.join(cwd, rel));
-  }
-  #globFiles(cwd: string, pattern = "**/*.*"): string[] {
-    const glob = new Bun.Glob(pattern);
-    return Array.from(glob.scanSync({ cwd, onlyFiles: true })).filter((relativePath) => {
-      const segments = relativePath.split(path.sep);
-      return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
-    });
-  }
-
-  #resolveAdditionalEntrypoints(cwd: string, additionalEntryPoints: string[]): string[] {
-    const out: string[] = [];
-    for (const p of additionalEntryPoints) {
-      if (p.includes("*")) {
-        const rel = p.startsWith(`${cwd}/`) || p.startsWith(`${cwd}${path.sep}`) ? p.slice(cwd.length + 1) : p;
-        out.push(...this.#globEntrypoints(cwd, rel));
-      } else out.push(path.isAbsolute(p) ? p : path.join(cwd, p));
-    }
-    return out;
-  }
-  #getBuildOptions({ bundle = false, additionalEntryPoints = [] }: BuildOptions = {}): BunBuildConfig {
-    const cwd = this.#executor.cwdPath;
-    const entrypoints = [
-      ...(bundle ? [path.join(cwd, "index.ts")] : this.#globEntrypoints(cwd, "**/*.{ts,tsx}")),
-      ...this.#resolveAdditionalEntrypoints(cwd, additionalEntryPoints),
-    ];
-    return {
-      root: cwd,
-      entrypoints,
-      bundle,
-      packages: "external",
-      splitting: false,
-      target: this.#pkgJson.bun?.platform,
-      format: "esm",
-      outdir: this.#distExecutor.cwdPath,
-      external: ["react", "react-dom"],
-      loader: assetLoader,
-    };
-  }
-  async #copySourceFiles() {
-    const cwd = this.#executor.cwdPath;
-    for (const relativePath of this.#globFiles(cwd)) {
-      if (relativePath === "package.json") continue;
-      const sourcePath = path.join(cwd, relativePath);
-      const targetPath = path.join(this.#distExecutor.cwdPath, relativePath);
-      await mkdir(path.dirname(targetPath), { recursive: true });
-      await Bun.write(targetPath, Bun.file(sourcePath));
-    }
-  }
-  #toPublishedPath(publishedPath: string, { useSource }: { useSource: boolean }) {
-    const hasDotSlash = publishedPath.startsWith("./");
-    const withoutFormatDir = publishedPath.replace(/^(?:\.\/)?(?:esm|cjs)\//, hasDotSlash ? "./" : "");
-    if (!useSource) return withoutFormatDir;
-    if (!hasDotSlash && withoutFormatDir === publishedPath) return publishedPath;
-    const parsed = path.posix.parse(withoutFormatDir);
-    if (![".js", ".mjs", ".cjs"].includes(parsed.ext)) return withoutFormatDir;
-    const withoutExt = path.posix.join(parsed.dir, parsed.name);
-    const sourcePath = withoutExt.startsWith("./") ? withoutExt.slice(2) : withoutExt;
-    const sourceCandidates = [`${sourcePath}.ts`, `${sourcePath}.tsx`];
-    const matchedSource = sourceCandidates.find((candidate) =>
-      existsSync(path.join(this.#executor.cwdPath, candidate)),
-    );
-    if (!matchedSource) return withoutFormatDir;
-    return hasDotSlash ? `./${matchedSource}` : matchedSource;
-  }
-  #normalizeExports(
-    exportsValue: ExportValue | undefined,
-    { useSource }: { useSource: boolean },
-  ): ExportValue | undefined {
-    if (!exportsValue) return exportsValue;
-    if (typeof exportsValue === "string") return this.#toPublishedPath(exportsValue, { useSource });
-    if (Array.isArray(exportsValue))
-      return exportsValue.map((value) => this.#normalizeExports(value, { useSource }) as string);
-    if (typeof exportsValue !== "object") return exportsValue;
-
-    return Object.fromEntries(
-      Object.entries(exportsValue)
-        .filter(([condition]) => condition !== "require")
-        .map(([condition, value]) => [condition, this.#normalizeExports(value, { useSource })])
-        .filter((entry): entry is [string, ExportValue] => entry[1] !== undefined),
-    );
-  }
-  #getPackageJson({ bundle = false }: BuildOptions = {}): PackageJson {
-    const rootEntry = bundle ? "./index.js" : "./index.ts";
-    const normalizedExports = this.#normalizeExports(this.#pkgJson.exports as ExportValue | undefined, {
-      useSource: !bundle,
-    });
-    return {
-      ...this.#pkgJson,
-      type: "module",
-      main: rootEntry,
-      bin: this.#normalizeExports(this.#pkgJson.bin as ExportValue | undefined, { useSource: !bundle }),
-      exports: {
-        ...((typeof normalizedExports === "object" && !Array.isArray(normalizedExports)
-          ? normalizedExports
-          : {}) as Record<string, ExportValue>),
-        ".": {
-          import: rootEntry,
-          types: bundle ? "./index.d.ts" : "./index.ts",
-        },
-      },
-    };
-  }
-  async build(options: BuildOptions = {}) {
-    if (await FileSys.dirExists(this.#distExecutor.cwdPath))
-      await this.#distExecutor.exec(`rm -rf ${this.#distExecutor.cwdPath}`);
-
-    if (options.bundle) {
-      const buildResult = await Bun.build({ ...this.#getBuildOptions(options) });
-      if (!buildResult.success) throw new AggregateError(buildResult.logs, "Bundle failed");
-    } else await this.#copySourceFiles();
-
-    const pkgPackageJson = this.#getPackageJson(options);
-    await this.#distExecutor.setPackageJson(pkgPackageJson);
-  }
-}

package/extractDeps.ts

@@ -1,86 +0,0 @@
-import type { PackageJson } from "./types";
-
-const NODE_NATIVE_MODULE_SET = new Set([
-  "assert",
-  "async_hooks",
-  "buffer",
-  "child_process",
-  "cluster",
-  "console",
-  "constants",
-  "crypto",
-  "dgram",
-  "dns",
-  "domain",
-  "events",
-  "fs",
-  "http",
-  "http2",
-  "https",
-  "inspector",
-  "module",
-  "net",
-  "os",
-  "path",
-  "perf_hooks",
-  "process",
-  "punycode",
-  "querystring",
-  "readline",
-  "repl",
-  "stream",
-  "string_decoder",
-  "timers",
-  "tls",
-  "trace_events",
-  "tty",
-  "url",
-  "util",
-  "v8",
-  "vm",
-  "wasi",
-  "worker_threads",
-  "zlib",
-]);
-
-export const extractDependencies = (
-  filepaths: { path: string; text: string }[],
-  pacakgeJson: PackageJson,
-  defaultDependencies: string[] = [],
-) => {
-  if (!pacakgeJson.dependencies) throw new Error("No dependencies found in package.json");
-  const dependencies = new Set<string>(defaultDependencies);
-
-  const existingDependencies = new Set<string>([
-    ...Object.keys(pacakgeJson.dependencies ?? {}),
-    ...Object.keys(pacakgeJson.devDependencies ?? {}),
-  ]);
-  const versionObj = {
-    ...(pacakgeJson.dependencies ?? {}),
-    ...(pacakgeJson.devDependencies ?? {}),
-  };
-
-  // Look for require statements: require('package-name') or import 'package-name'
-  const requireRegex = /(?:require\s*\(|import\s*(?:[\w\s{},*]*\s+from\s*)?|import\s*\()\s*['"`]([^'"`]+)['"`]/g;
-  for (const { text } of filepaths.filter(({ path }) => path.endsWith(".js") || path.endsWith(".ts"))) {
-    let requireMatch = requireRegex.exec(text);
-    while (requireMatch !== null) {
-      const moduleName = requireMatch[1];
-      if (!moduleName) throw new Error(`No module name found in ${text}`);
-      const moduleNameParts = moduleName.split("/");
-      const subModuleLength = moduleNameParts.length;
-      for (let i = 0; i < subModuleLength; i++) {
-        const libName = moduleNameParts.slice(0, i + 1).join("/");
-        if (!NODE_NATIVE_MODULE_SET.has(libName) && existingDependencies.has(libName)) dependencies.add(libName);
-      }
-      requireMatch = requireRegex.exec(text);
-    }
-  }
-  return Object.fromEntries(
-    [...dependencies].sort().map((dep) => {
-      const version = versionObj[dep];
-      if (!version) throw new Error(`No version found for ${dep}`);
-      return [dep, version];
-    }),
-  );
-};

package/frontendBuild/styleGuard.test.ts

@@ -1,180 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { StyleGuard, type StyleGuardRule } from "./styleGuard";
-
-const guard = new StyleGuard();
-const scan = (content: string, path = "Demo.tsx") => guard.run([{ path, content }]);
-const rules = (content: string): StyleGuardRule[] => scan(content).map((v) => v.rule);
-
-describe("StyleGuard raw-palette", () => {
-  test("flags raw Tailwind palette utilities", () => {
-    expect(rules('<div className="bg-blue-500 text-gray-700" />')).toEqual(["raw-palette", "raw-palette"]);
-  });
-
-  test("flags palette with variant prefix and opacity", () => {
-    expect(rules('<div className="hover:bg-red-500/50" />')).toContain("raw-palette");
-  });
-
-  test("flags numeric neutral but allows bare semantic neutral", () => {
-    expect(rules('<div className="bg-neutral-500" />')).toEqual(["raw-palette"]);
-    expect(scan('<div className="bg-neutral text-neutral-foreground" />')).toHaveLength(0);
-  });
-
-  test("does not flag semantic tokens or black/white", () => {
-    expect(scan('<div className="bg-primary text-muted-foreground border-border" />')).toHaveLength(0);
-    expect(scan('<div className="bg-black text-white bg-white/30 bg-black/50" />')).toHaveLength(0);
-  });
-
-  test("does not flag non-color numeric utilities", () => {
-    expect(scan('<div className="gap-4 mt-2 grid-cols-3 w-500" />')).toHaveLength(0);
-  });
-});
-
-describe("StyleGuard arbitrary-color", () => {
-  test("flags hex and color-function arbitrary values", () => {
-    expect(rules('<div className="bg-[#3b82f6]" />')).toEqual(["arbitrary-color"]);
-    expect(rules('<div className="text-[rgb(0,0,0)]" />')).toEqual(["arbitrary-color"]);
-  });
-
-  test("allows arbitrary CSS variable references", () => {
-    expect(scan('<div className="bg-[--brand] text-[var(--fg)]" />')).toHaveLength(0);
-  });
-});
-
-describe("StyleGuard inline-color", () => {
-  test("flags hardcoded color in style object", () => {
-    expect(rules("<div style={{ color: '#fff', background: 'rgb(0,0,0)' }} />")).toEqual([
-      "inline-color",
-      "inline-color",
-    ]);
-  });
-
-  test("flags color literal inside <style> tag", () => {
-    expect(rules("<style>{`.x { color: #abcdef; }`}</style>")).toEqual(["inline-color"]);
-  });
-
-  test("allows var() references in style object", () => {
-    expect(scan("<div style={{ color: 'var(--primary)', width: '100%' }} />")).toHaveLength(0);
-  });
-});
-
-describe("StyleGuard daisyui-legacy", () => {
-  test("flags high-signal daisyUI compound classes", () => {
-    expect(rules('<button className="btn-primary" />')).toEqual(["daisyui-legacy"]);
-    expect(rules('<span className="badge-success" />')).toEqual(["daisyui-legacy"]);
-    expect(rules('<div className="modal-box card-body" />')).toEqual(["daisyui-legacy", "daisyui-legacy"]);
-  });
-
-  test("does not flag bare ambiguous names that collide with Tailwind", () => {
-    expect(scan('<div className="card input badge btn" />')).toHaveLength(0);
-  });
-
-  test("flags daisyUI colour slots the vocabulary dropped", () => {
-    expect(rules('<div className="bg-base-100" />')).toEqual(["daisyui-legacy"]);
-    expect(rules('<div className="text-base-content/70" />')).toEqual(["daisyui-legacy"]);
-    expect(rules('<div className="border-t-base-300" />')).toEqual(["daisyui-legacy"]);
-    expect(rules('<div className="text-primary-content" />')).toEqual(["daisyui-legacy"]);
-    expect(rules('<div className="border-error/30 bg-error/5" />')).toEqual(["daisyui-legacy", "daisyui-legacy"]);
-  });
-
-  test("does not flag colour slots that survived into the semantic vocabulary", () => {
-    expect(scan('<div className="bg-primary text-primary-foreground" />')).toHaveLength(0);
-    expect(scan('<div className="bg-neutral text-info border-warning" />')).toHaveLength(0);
-    expect(scan('<div className="bg-destructive/10 text-destructive" />')).toHaveLength(0);
-    expect(scan('<div className="content-center justify-content" />')).toHaveLength(0);
-  });
-});
-
-// The fixtures below must contain a literal `${`. Writing it inside a plain string trips biome's
-// noTemplateCurlyInString, so the placeholder is assembled from `D` — that keeps the rule on for real code
-// instead of scattering suppressions through the fixtures.
-const D = "$";
-const INTERPOLATED = {
-  size: `<div className={\`min-h-[${D}{minHeight}px] flex\`} />`,
-  color: `<div className={\`bg-[${D}{color}] w-full\`} />`,
-  brokenBracket: `<div className={\`min-h-[ w-full${D}{minHeight}px] flex\`} />`,
-  outsideBrackets: `<div className={\`flex gap-2 ${D}{isOpen ? "opacity-50" : ""}\`} />`,
-  styleProp: `<div style={{ minHeight }} className={\`flex ${D}{extra}\`} />`,
-};
-
-describe("StyleGuard interpolated-arbitrary", () => {
-  test("flags an arbitrary value assembled from a runtime expression", () => {
-    expect(rules(INTERPOLATED.size)).toEqual(["interpolated-arbitrary"]);
-    expect(rules(INTERPOLATED.color)).toEqual(["interpolated-arbitrary"]);
-  });
-
-  test("flags the broken-bracket typo that swallows the next class", () => {
-    expect(rules(INTERPOLATED.brokenBracket)).toEqual(["interpolated-arbitrary"]);
-  });
-
-  test("allows a literal arbitrary value, and interpolation outside brackets", () => {
-    expect(scan('<div className="min-h-[300px] flex" />')).toHaveLength(0);
-    expect(scan(INTERPOLATED.outsideBrackets)).toHaveLength(0);
-    expect(scan(INTERPOLATED.styleProp)).toHaveLength(0);
-  });
-});
-
-describe("StyleGuard violation shape", () => {
-  test("reports 1-based line and trimmed snippet with a suggestion", () => {
-    const content = ['<div className="ok" />', '  <div className="bg-blue-500" />'].join("\n");
-    const [v] = scan(content);
-    expect(v.line).toBe(2);
-    expect(v.snippet).toBe('<div className="bg-blue-500" />');
-    expect(v.severity).toBe("error");
-    expect(v.suggestion.length).toBeGreaterThan(0);
-  });
-});
-
-describe("StyleGuard comment handling", () => {
-  test("does not flag class names inside line or block comments", () => {
-    expect(scan('// iconClassName="btn-primary bg-blue-500"')).toHaveLength(0);
-    expect(scan("/** legacy: toggle-accent / bg-red-500 */")).toHaveLength(0);
-    expect(scan("{/* <div className='bg-blue-500' /> */}")).toHaveLength(0);
-  });
-
-  test("still flags real code on a line that also contains a string with //", () => {
-    expect(rules('<a href="https://x.io" className="bg-blue-500" />')).toEqual(["raw-palette"]);
-  });
-});
-
-describe("StyleGuard escape hatch", () => {
-  test("styleguard-disable-next-line suppresses the following line only", () => {
-    const content = [
-      "// styleguard-disable-next-line raw-palette",
-      '<div className="bg-blue-500" />',
-      '<div className="bg-red-500" />',
-    ].join("\n");
-    const found = scan(content);
-    expect(found).toHaveLength(1);
-    expect(found[0].line).toBe(3);
-  });
-
-  test("file-level styleguard-disable suppresses the named rule everywhere", () => {
-    const content = ["// styleguard-disable raw-palette", '<div className="bg-blue-500 bg-[#fff]" />'].join("\n");
-    // raw-palette suppressed, arbitrary-color still reported.
-    expect(rules(content)).toEqual(["arbitrary-color"]);
-  });
-
-  test("bare styleguard-disable suppresses all rules in the file", () => {
-    const content = ["/* styleguard-disable */", '<div className="bg-blue-500 btn-primary bg-[#fff]" />'].join("\n");
-    expect(scan(content)).toHaveLength(0);
-  });
-});
-
-describe("StyleGuard.countNamedComponentClasses", () => {
-  test("counts named classes declared inside @layer components", () => {
-    const css = `
-      @layer components {
-        .foo { color: var(--primary); }
-        .bar-baz { padding: 1rem; }
-      }
-      .outside { color: red; }
-    `;
-    const metric = StyleGuard.countNamedComponentClasses(css);
-    expect(metric.count).toBe(2);
-    expect(metric.names).toEqual(["bar-baz", "foo"]);
-  });
-
-  test("returns zero when no component layer exists", () => {
-    expect(StyleGuard.countNamedComponentClasses(".a { color: red; }").count).toBe(0);
-  });
-});