design-system-enforcer 1.0.1 → 1.0.4

package/dist/cli.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs8 from "fs";
+import path8 from "path";
 import { Command } from "commander";
-import pc2 from "picocolors";
+import pc3 from "picocolors";
 
 // src/config/loader.ts
-import fs from "fs";
-import path from "path";
+import fs3 from "fs";
+import path3 from "path";
 import { pathToFileURL } from "url";
 
 // src/config/presets/berserk.ts
@@ -97,6 +97,9 @@ var berserkPreset = {
     disallowRawHtml: {
       button: { replaceWith: "Button", importFrom: "@/components/ui/button", checkRawElement: true },
       select: { replaceWith: "Dropdown", importFrom: "@/components/ui/dropdown", checkRawElement: true },
+      textarea: { replaceWith: "Textarea", importFrom: "@/components/ui/textarea", checkRawElement: true },
+      progress: { replaceWith: "ProgressBar", importFrom: "@/components/ui/progress", checkRawElement: true },
+      dialog: { replaceWith: "Modal or Dialog", importFrom: "@/components/ui/modal", checkRawElement: true },
       table: { replaceWith: "Table", importFrom: "@/components/ui/table", checkRawElement: true },
       thead: { replaceWith: "TableHeader", importFrom: "@/components/ui/table", checkRawElement: true },
       tbody: { replaceWith: "TableBody", importFrom: "@/components/ui/table", checkRawElement: true },
@@ -148,7 +151,8 @@ var berserkPreset = {
     "table-no-horizontal-stacking": "error",
     "table-windowed-pagination": "error",
     "tabs-component-required": "error",
-    "component-inventory-active": "error"
+    "component-inventory-active": "error",
+    "no-wrapping-compact-elements": "error"
   }
 };
 
@@ -185,7 +189,10 @@ var defaultPreset = {
   components: {
     disallowRawHtml: {
       button: { replaceWith: "Button", importFrom: "@/components/ui/button", checkRawElement: true },
-      select: { replaceWith: "Dropdown", importFrom: "@/components/ui/dropdown", checkRawElement: true }
+      select: { replaceWith: "Dropdown", importFrom: "@/components/ui/dropdown", checkRawElement: true },
+      textarea: { replaceWith: "Textarea", importFrom: "@/components/ui/textarea", checkRawElement: true },
+      progress: { replaceWith: "ProgressBar", importFrom: "@/components/ui/progress", checkRawElement: true },
+      dialog: { replaceWith: "Modal or Dialog", importFrom: "@/components/ui/modal", checkRawElement: true }
     },
     disallowPseudoChips: true
   },
@@ -196,7 +203,8 @@ var defaultPreset = {
     "no-pseudo-chips": "warn",
     "no-chip-colored-buttons": "error",
     "no-text-arrows": "error",
-    "no-backdrop-blur": "warn"
+    "no-backdrop-blur": "warn",
+    "no-wrapping-compact-elements": "warn"
   }
 };
 
@@ -260,6 +268,221 @@ var pythonPreset = {
   }
 };
 
+// src/detector/index.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/detector/ignores.ts
+import fs from "fs";
+import path from "path";
+var DEFAULT_IGNORES = [
+  "**/node_modules/**",
+  "**/.next/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/out/**",
+  "**/.turbo/**",
+  "**/.git/**",
+  "**/coverage/**",
+  "**/.venv/**",
+  "**/venv/**",
+  "**/env/**",
+  "**/__pycache__/**",
+  "**/.pytest_cache/**",
+  "**/*.pyc",
+  // Non-UI code
+  "**/api/**",
+  "**/*.test.*",
+  "**/*.spec.*",
+  "**/__tests__/**",
+  "**/*.stories.*",
+  "**/generated/**"
+];
+function getSmartIgnores(cwd) {
+  const result = new Set(DEFAULT_IGNORES);
+  const gitignorePath = path.resolve(cwd, ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
+    try {
+      const content = fs.readFileSync(gitignorePath, "utf-8");
+      const lines = content.split(/\r?\n/);
+      for (let line of lines) {
+        line = line.trim();
+        if (!line || line.startsWith("#")) continue;
+        if (line.startsWith("/")) {
+          line = line.substring(1);
+        }
+        if (line.endsWith("/")) {
+          line = line.slice(0, -1);
+        }
+        if (line) {
+          result.add(`**/${line}/**`);
+          result.add(`**/${line}`);
+        }
+      }
+    } catch {
+    }
+  }
+  return Array.from(result);
+}
+
+// src/detector/index.ts
+function safeReadJson(filePath) {
+  try {
+    if (fs2.existsSync(filePath)) {
+      const raw = fs2.readFileSync(filePath, "utf-8");
+      return JSON.parse(raw);
+    }
+  } catch {
+  }
+  return null;
+}
+function detectProject(cwd = process.cwd()) {
+  const pkg = safeReadJson(path2.resolve(cwd, "package.json"));
+  const deps = { ...pkg?.dependencies || {}, ...pkg?.devDependencies || {} };
+  const hasRequirements = fs2.existsSync(path2.resolve(cwd, "requirements.txt"));
+  const hasPyproject = fs2.existsSync(path2.resolve(cwd, "pyproject.toml"));
+  const hasPython = hasRequirements || hasPyproject || fs2.existsSync(path2.resolve(cwd, "setup.py"));
+  let isStreamlit = false;
+  if (hasPython) {
+    if (hasRequirements) {
+      try {
+        const reqContent = fs2.readFileSync(path2.resolve(cwd, "requirements.txt"), "utf-8");
+        if (reqContent.toLowerCase().includes("streamlit")) {
+          isStreamlit = true;
+        }
+      } catch {
+      }
+    }
+  }
+  const isPnpmMonorepo = fs2.existsSync(path2.resolve(cwd, "pnpm-workspace.yaml"));
+  const isTurbo = fs2.existsSync(path2.resolve(cwd, "turbo.json"));
+  let monorepoWorkspaces = [];
+  if (Array.isArray(pkg?.workspaces)) {
+    monorepoWorkspaces = pkg.workspaces;
+  } else if (pkg?.workspaces?.packages) {
+    monorepoWorkspaces = pkg.workspaces.packages;
+  }
+  const isMonorepo = isPnpmMonorepo || isTurbo || monorepoWorkspaces.length > 0;
+  let framework = "unknown";
+  if (deps["next"]) {
+    framework = "nextjs";
+  } else if (deps["vite"]) {
+    framework = "vite";
+  } else if (deps["@remix-run/react"]) {
+    framework = "remix";
+  } else if (deps["astro"]) {
+    framework = "astro";
+  } else if (deps["react-scripts"]) {
+    framework = "react-cra";
+  } else if (isStreamlit) {
+    framework = "streamlit";
+  } else if (hasPython) {
+    framework = "python-general";
+  }
+  const libraries = [];
+  const hasShadcnConfig = fs2.existsSync(path2.resolve(cwd, "components.json"));
+  if (hasShadcnConfig || deps["@radix-ui/react-slot"]) {
+    libraries.push("shadcn");
+  }
+  if (Object.keys(deps).some((d) => d.startsWith("@radix-ui/"))) {
+    if (!libraries.includes("shadcn")) libraries.push("radix");
+  }
+  if (deps["tailwindcss"]) {
+    libraries.push("tailwind");
+  }
+  if (deps["lucide-react"] || deps["lucide"]) {
+    libraries.push("lucide");
+  }
+  if (deps["@mui/material"] || deps["@material-ui/core"]) {
+    libraries.push("mui");
+  }
+  if (deps["@chakra-ui/react"]) {
+    libraries.push("chakra");
+  }
+  const hasTailwind = Boolean(deps["tailwindcss"] || fs2.existsSync(path2.resolve(cwd, "tailwind.config.js")) || fs2.existsSync(path2.resolve(cwd, "tailwind.config.ts")));
+  let tailwindVersion;
+  if (hasTailwind) {
+    const rawVersion = deps["tailwindcss"] || "";
+    if (rawVersion.includes("^4") || rawVersion.includes("~4") || rawVersion.startsWith("4")) {
+      tailwindVersion = "v4";
+    } else {
+      tailwindVersion = "v3";
+    }
+  }
+  const hasTypeScript = Boolean(deps["typescript"] || fs2.existsSync(path2.resolve(cwd, "tsconfig.json")));
+  const suggestedIncludes = [];
+  const extGroup = hasTypeScript ? "{tsx,jsx,ts,js}" : "{jsx,js}";
+  const candidateDirs = [
+    "frontend/src",
+    "frontend",
+    "apps/web/src",
+    "apps/web",
+    "client/src",
+    "client",
+    "src",
+    "app",
+    "pages",
+    "components"
+  ];
+  let foundUiDir = false;
+  for (const dir of candidateDirs) {
+    if (fs2.existsSync(path2.resolve(cwd, dir))) {
+      if (dir === "frontend" && fs2.existsSync(path2.resolve(cwd, "frontend/src"))) continue;
+      if (dir === "client" && fs2.existsSync(path2.resolve(cwd, "client/src"))) continue;
+      if (dir === "apps/web" && fs2.existsSync(path2.resolve(cwd, "apps/web/src"))) continue;
+      suggestedIncludes.push(`${dir}/**/*.${extGroup}`);
+      foundUiDir = true;
+      break;
+    }
+  }
+  if (hasPython) {
+    suggestedIncludes.push("**/*.py");
+  } else if (!foundUiDir) {
+    suggestedIncludes.push(`**/*.${extGroup}`);
+  }
+  const suggestedIgnores = getSmartIgnores(cwd);
+  if (hasShadcnConfig || libraries.includes("shadcn")) {
+    suggestedIgnores.push("**/components/ui/**");
+  }
+  const tokenCandidates = [
+    "frontend/src/lib/tokens.ts",
+    "frontend/src/tokens.ts",
+    "src/lib/tokens.ts",
+    "src/tokens.ts",
+    "src/design/tokens.ts",
+    "styles/tokens.css",
+    "src/app/globals.css",
+    "frontend/src/index.css",
+    "src/index.css"
+  ];
+  let tokensFile;
+  for (const candidate of tokenCandidates) {
+    if (fs2.existsSync(path2.resolve(cwd, candidate))) {
+      tokensFile = candidate;
+      break;
+    }
+  }
+  let preset = "berserk";
+  if (framework === "streamlit" || framework === "python-general") {
+    preset = "python";
+  }
+  return {
+    root: cwd,
+    isMonorepo,
+    monorepoWorkspaces,
+    framework,
+    libraries,
+    hasTailwind,
+    tailwindVersion,
+    hasTypeScript,
+    hasPython,
+    suggestedIncludes,
+    suggestedIgnores,
+    tokensFile,
+    preset
+  };
+}
+
 // src/config/loader.ts
 var CONFIG_FILES = [
   "dse.config.js",
@@ -271,17 +494,18 @@ var CONFIG_FILES = [
   ".dserc"
 ];
 async function loadConfig(cwd = process.cwd(), customPath) {
+  const detected = detectProject(cwd);
   let userConfig = {};
   let foundConfigPath = null;
   if (customPath) {
-    const resolved = path.resolve(cwd, customPath);
-    if (fs.existsSync(resolved)) {
+    const resolved = path3.resolve(cwd, customPath);
+    if (fs3.existsSync(resolved)) {
       foundConfigPath = resolved;
     }
   } else {
     for (const filename of CONFIG_FILES) {
-      const candidate = path.resolve(cwd, filename);
-      if (fs.existsSync(candidate)) {
+      const candidate = path3.resolve(cwd, filename);
+      if (fs3.existsSync(candidate)) {
         foundConfigPath = candidate;
         break;
       }
@@ -289,7 +513,7 @@ async function loadConfig(cwd = process.cwd(), customPath) {
   }
   if (foundConfigPath) {
     if (foundConfigPath.endsWith(".json") || foundConfigPath.endsWith(".dserc")) {
-      const content = fs.readFileSync(foundConfigPath, "utf-8");
+      const content = fs3.readFileSync(foundConfigPath, "utf-8");
       try {
         userConfig = JSON.parse(content);
       } catch (err) {
@@ -302,7 +526,7 @@ async function loadConfig(cwd = process.cwd(), customPath) {
         userConfig = mod.default || mod;
       } catch {
         try {
-          const content = fs.readFileSync(foundConfigPath, "utf-8");
+          const content = fs3.readFileSync(foundConfigPath, "utf-8");
           const cjsReq = createCjsEvaluator(foundConfigPath, content);
           userConfig = cjsReq;
         } catch (innerErr) {
@@ -311,18 +535,19 @@ async function loadConfig(cwd = process.cwd(), customPath) {
       }
     }
   }
-  let presetName = userConfig.preset;
-  if (!presetName) {
-    const isPython = fs.existsSync(path.resolve(cwd, "requirements.txt")) || fs.existsSync(path.resolve(cwd, "pyproject.toml")) || fs.existsSync(path.resolve(cwd, ".streamlit")) || fs.existsSync(path.resolve(cwd, "manage.py"));
-    presetName = isPython ? "python" : "berserk";
-  }
+  let presetName = userConfig.preset || detected.preset;
   let basePreset = berserkPreset;
   if (presetName === "python") {
     basePreset = pythonPreset;
   } else if (presetName === "recommended") {
     basePreset = defaultPreset;
   }
-  return mergeConfigs(basePreset, userConfig);
+  const autonomousDefaults = {
+    include: detected.suggestedIncludes,
+    exclude: detected.suggestedIgnores
+  };
+  const withAutonomous = mergeConfigs(basePreset, autonomousDefaults);
+  return mergeConfigs(withAutonomous, userConfig);
 }
 function createCjsEvaluator(filePath, content) {
   if (content.includes("export default")) {
@@ -372,8 +597,8 @@ function mergeConfigs(base, overrides) {
 }
 
 // src/rules/runner.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import fg from "fast-glob";
 
 // src/parser/ast.ts
@@ -786,16 +1011,52 @@ function checkRawHtmlElements(tagName, attributes, pos, filePath, addViolation,
         pos.line,
         pos.col,
         "no-raw-html-elements",
-        `Raw browser default '<input type="checkbox">' detected. Use standard design system '<Checkbox>' or '<Toggle>'.`,
+        `Raw browser default '<input type="checkbox">' detected. Never use unstyled browser checkboxes. Use standard design system '<Checkbox>' or '<Toggle>'.`,
         lineSnippet
       );
-    } else if (["text", "email", "search"].includes(typeVal)) {
+    } else if (typeVal === "radio") {
       addViolation(
         filePath,
         pos.line,
         pos.col,
         "no-raw-html-elements",
-        `Raw '<input type="${typeVal}">' element detected. Use standard design system '<Input>' component.`,
+        `Raw browser default '<input type="radio">' detected. Never use unstyled browser radio buttons. Use standard design system '<RadioGroup>' or styled toggle.`,
+        lineSnippet
+      );
+    } else if (typeVal === "range") {
+      addViolation(
+        filePath,
+        pos.line,
+        pos.col,
+        "no-raw-html-elements",
+        `Raw browser default '<input type="range">' detected. Never use unstyled browser sliders. Use standard design system '<Slider>'.`,
+        lineSnippet
+      );
+    } else if (typeVal === "file") {
+      addViolation(
+        filePath,
+        pos.line,
+        pos.col,
+        "no-raw-html-elements",
+        `Raw browser default '<input type="file">' detected. Never display native unstyled file picker inputs. Use a custom styled dropzone or trigger.`,
+        lineSnippet
+      );
+    } else if (typeVal === "color") {
+      addViolation(
+        filePath,
+        pos.line,
+        pos.col,
+        "no-raw-html-elements",
+        `Raw browser default '<input type="color">' detected. Never use native browser color pickers. Use a custom color picker component.`,
+        lineSnippet
+      );
+    } else if (["text", "email", "search", "password", "number", "tel", "url"].includes(typeVal)) {
+      addViolation(
+        filePath,
+        pos.line,
+        pos.col,
+        "no-raw-html-elements",
+        `Raw browser default '<input type="${typeVal}">' element detected. Use standard design system '<Input>' component.`,
         lineSnippet
       );
     }
@@ -1053,6 +1314,9 @@ function checkPseudoChips(tagName, attributes, pos, filePath, addViolation, line
 function checkElementClasses(node, tagName, attributes, pos, filePath, addViolation, sourceFile, config) {
   if (!attributes.className) return;
   const isButton = ["Button", "IconButton", "ButtonyIcon", "FloatingActionButton"].includes(tagName);
+  const isChip = ["Chip", "Badge", "Tag", "StatusBadge"].includes(tagName);
+  const isTab = ["Tab", "TabTrigger", "TabsTrigger"].includes(tagName);
+  const isCompactElement = isButton || isChip || isTab;
   const isCheckbox = tagName === "Checkbox" || attributes.type?.initializer?.getText(sourceFile)?.includes("checkbox") || attributes.role?.initializer?.getText(sourceFile)?.includes("checkbox") || Boolean(attributes["aria-checked"]) || attributes.className && /\b(?:size-5|w-5\s+h-5)\b/.test(attributes.className.rawText);
   const lineSnippet = sourceFile.getFullText().split("\n")[pos.line - 1] || "";
   const classStrings = extractClassNames(attributes.className.initializer, sourceFile);
@@ -1092,8 +1356,33 @@ function checkElementClasses(node, tagName, attributes, pos, filePath, addViolat
           );
         }
       }
+      if (isCompactElement && config.rules?.["no-wrapping-compact-elements"] !== "off") {
+        if (dec.core === "flex-wrap" || dec.core === "whitespace-normal" || dec.core === "whitespace-pre-wrap") {
+          addViolation(
+            filePath,
+            nodePos.line,
+            nodePos.col,
+            "no-wrapping-compact-elements",
+            `Disallowed text wrapping class '${dec.core}' on <${tagName}>. Compact interactive elements (buttons, chips, badges, tabs) must never wrap text across multiple lines.`,
+            lineSnippet
+          );
+        }
+      }
     });
   });
+  if (tagName === "TableHead" && config.rules?.["no-wrapping-compact-elements"] !== "off") {
+    const rawClass = attributes.className?.rawText || "";
+    if (/\b(?:flex-wrap|whitespace-normal|whitespace-pre-wrap)\b/.test(rawClass)) {
+      addViolation(
+        filePath,
+        pos.line,
+        pos.col,
+        "no-wrapping-compact-elements",
+        `Disallowed text wrapping on <TableHead>. Column headers must remain single-line ('whitespace-nowrap') to preserve table column alignment.`,
+        lineSnippet
+      );
+    }
+  }
 }
 
 // src/rules/regex-rules.ts
@@ -1314,8 +1603,8 @@ function runPythonRules(content, filePath, addViolation, config) {
 
 // src/rules/runner.ts
 async function runDseScan(config, cwd = process.cwd()) {
-  let targetDir = path2.resolve(cwd, config.targetDir || "src");
-  if (!fs2.existsSync(targetDir)) {
+  let targetDir = path4.resolve(cwd, config.targetDir || "src");
+  if (!fs4.existsSync(targetDir)) {
     targetDir = cwd;
   }
   const includePatterns = config.include || ["**/*.{tsx,jsx,ts,js}"];
@@ -1347,7 +1636,7 @@ async function runDseScan(config, cwd = process.cwd()) {
   const violations = [];
   const seenViolationKeys = /* @__PURE__ */ new Set();
   const addViolation = (file, line, col, rule, message, snippet) => {
-    const normFile = path2.relative(cwd, file).replace(/\\/g, "/");
+    const normFile = path4.relative(cwd, file).replace(/\\/g, "/");
     const key = `${normFile}:${line}:${rule}`;
     if (seenViolationKeys.has(key)) return;
     seenViolationKeys.add(key);
@@ -1365,7 +1654,7 @@ async function runDseScan(config, cwd = process.cwd()) {
   };
   let scannedJsxFiles = false;
   for (const filePath of files) {
-    const content = fs2.readFileSync(filePath, "utf-8");
+    const content = fs4.readFileSync(filePath, "utf-8");
     const isJsx = filePath.endsWith(".tsx") || filePath.endsWith(".jsx") || filePath.endsWith(".ts") || filePath.endsWith(".js");
     const isPythonOrTemplate = filePath.endsWith(".py") || filePath.endsWith(".html") || filePath.endsWith(".jinja") || filePath.endsWith(".jinja2") || filePath.endsWith(".css");
     if (isJsx) {
@@ -1486,8 +1775,8 @@ function formatJson(result) {
 }
 
 // src/scaffold/index.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs5 from "fs";
+import path5 from "path";
 
 // src/scaffold/templates/tokens.ts
 var tokensTemplate = `/**
@@ -1630,7 +1919,8 @@ export const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
   ({ className = "", variant = "primary", size = "default", children, ...props }, ref) => {
     // Standard 36px height, 8px radius, font-medium, strictly neutral palette
     const baseClasses =
-      "inline-flex items-center justify-center font-medium text-sm rounded-md transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-neutral-400 disabled:pointer-events-none disabled:opacity-50 select-none";
+      "inline-flex items-center justify-center font-medium text-sm rounded-md whitespace-nowrap shrink-0 transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-neutral-400 disabled:pointer-events-none disabled:opacity-50 select-none cursor-pointer";
+
 
     const variantClasses = {
       primary: "bg-neutral-900 text-white hover:bg-neutral-800 shadow-2xs",
@@ -1671,7 +1961,8 @@ export const Chip: React.FC<ChipProps> = ({
 }) => {
   // Standard 36px height, 8px radius, 14px typography
   const baseClasses =
-    "inline-flex items-center h-[36px] min-h-[36px] px-3 rounded-md text-sm font-medium gap-1.5 select-none";
+    "inline-flex items-center h-[36px] min-h-[36px] px-3 rounded-md text-sm font-medium whitespace-nowrap shrink-0 gap-1.5 select-none";
+
 
   const variantClasses = {
     neutral: "bg-neutral-100 text-neutral-800 border border-neutral-200",
@@ -1841,12 +2132,12 @@ export const TableHead = React.forwardRef<HTMLTableCellElement, TableHeadProps>(
   ({ className = "", icon, resizable = true, children, ...props }, ref) => (
     <th
       ref={ref}
-      className={\`h-[36px] px-4 text-left font-medium text-sm text-neutral-900 select-none align-middle relative \${className}\`}
+      className={\`h-[36px] px-4 text-left font-medium text-sm text-neutral-900 select-none align-middle relative whitespace-nowrap \${className}\`}
       {...props}
     >
       <div className="flex items-center gap-2">
         {icon && <span className="text-neutral-500 shrink-0">{icon}</span>}
-        <span>{children}</span>
+        <span className="whitespace-nowrap">{children}</span>
       </div>
     </th>
   )
@@ -1892,7 +2183,7 @@ export const Tabs: React.FC<TabsProps> = ({ items, activeId, onChange, className
             type="button"
             disabled={tab.disabled}
             onClick={() => onChange(tab.id)}
-            className={\`inline-flex h-[28px] items-center justify-center gap-1.5 rounded-sm px-3 text-sm font-medium transition-all select-none \${
+            className={\`inline-flex h-[28px] items-center justify-center gap-1.5 rounded-sm px-3 text-sm font-medium whitespace-nowrap shrink-0 transition-all select-none \${
               isActive
                 ? "bg-white text-neutral-900 shadow-2xs"
                 : "text-neutral-600 hover:text-neutral-900 hover:bg-neutral-200/50"
@@ -1984,8 +2275,8 @@ var COMPONENT_TEMPLATES = {
 };
 function scaffoldConfig(cwd = process.cwd(), preset = "berserk") {
   if (preset === "python") {
-    const jsonPath = path3.resolve(cwd, "dse.config.json");
-    if (fs3.existsSync(jsonPath)) return jsonPath;
+    const jsonPath = path5.resolve(cwd, "dse.config.json");
+    if (fs5.existsSync(jsonPath)) return jsonPath;
     const content2 = JSON.stringify(
       {
         preset: "python",
@@ -2002,11 +2293,11 @@ function scaffoldConfig(cwd = process.cwd(), preset = "berserk") {
       null,
       2
     ) + "\n";
-    fs3.writeFileSync(jsonPath, content2, "utf-8");
+    fs5.writeFileSync(jsonPath, content2, "utf-8");
     return jsonPath;
   }
-  const configPath = path3.resolve(cwd, "dse.config.js");
-  if (fs3.existsSync(configPath)) {
+  const configPath = path5.resolve(cwd, "dse.config.js");
+  if (fs5.existsSync(configPath)) {
     return configPath;
   }
   const content = `import { defineConfig } from "design-system-enforcer";
@@ -2034,21 +2325,21 @@ export default defineConfig({
   ],
 });
 `;
-  fs3.writeFileSync(configPath, content, "utf-8");
+  fs5.writeFileSync(configPath, content, "utf-8");
   return configPath;
 }
 function scaffoldTokens(cwd = process.cwd()) {
-  const libDir = path3.resolve(cwd, "src/lib");
-  const appDir = path3.resolve(cwd, "src/app");
-  if (!fs3.existsSync(libDir)) fs3.mkdirSync(libDir, { recursive: true });
-  if (!fs3.existsSync(appDir)) fs3.mkdirSync(appDir, { recursive: true });
-  const tokensPath = path3.join(libDir, "tokens.ts");
-  if (!fs3.existsSync(tokensPath)) {
-    fs3.writeFileSync(tokensPath, tokensTemplate, "utf-8");
-  }
-  const cssPath = path3.join(appDir, "globals.css");
-  if (!fs3.existsSync(cssPath)) {
-    fs3.writeFileSync(cssPath, cssTemplate, "utf-8");
+  const libDir = path5.resolve(cwd, "src/lib");
+  const appDir = path5.resolve(cwd, "src/app");
+  if (!fs5.existsSync(libDir)) fs5.mkdirSync(libDir, { recursive: true });
+  if (!fs5.existsSync(appDir)) fs5.mkdirSync(appDir, { recursive: true });
+  const tokensPath = path5.join(libDir, "tokens.ts");
+  if (!fs5.existsSync(tokensPath)) {
+    fs5.writeFileSync(tokensPath, tokensTemplate, "utf-8");
+  }
+  const cssPath = path5.join(appDir, "globals.css");
+  if (!fs5.existsSync(cssPath)) {
+    fs5.writeFileSync(cssPath, cssTemplate, "utf-8");
   }
   return { tokensPath, cssPath };
 }
@@ -2058,13 +2349,13 @@ function scaffoldComponent(componentName, cwd = process.cwd()) {
   if (!template) {
     return null;
   }
-  const uiDir = path3.resolve(cwd, "src/components/ui");
-  if (!fs3.existsSync(uiDir)) {
-    fs3.mkdirSync(uiDir, { recursive: true });
+  const uiDir = path5.resolve(cwd, "src/components/ui");
+  if (!fs5.existsSync(uiDir)) {
+    fs5.mkdirSync(uiDir, { recursive: true });
   }
-  const targetPath = path3.join(uiDir, template.filename);
-  if (!fs3.existsSync(targetPath)) {
-    fs3.writeFileSync(targetPath, template.content, "utf-8");
+  const targetPath = path5.join(uiDir, template.filename);
+  if (!fs5.existsSync(targetPath)) {
+    fs5.writeFileSync(targetPath, template.content, "utf-8");
   }
   return targetPath;
 }
@@ -2129,12 +2420,283 @@ function generateMarkdownRules(config) {
 `;
 }
 
+// src/doctor/index.ts
+function computeDoctorScore(result) {
+  const categoryViolations = {
+    typography: 0,
+    geometry: 0,
+    components: 0,
+    colors: 0,
+    wrapping: 0,
+    tables: 0
+  };
+  const fileCountMap = {};
+  result.violations.forEach((v) => {
+    fileCountMap[v.file] = (fileCountMap[v.file] || 0) + 1;
+    if (v.rule.startsWith("font-") || v.rule.includes("text-size") || v.rule.includes("uppercase")) {
+      categoryViolations.typography++;
+    } else if (v.rule.includes("wrapping")) {
+      categoryViolations.wrapping++;
+    } else if (v.rule.startsWith("control-") || v.rule.startsWith("corner-radius")) {
+      categoryViolations.geometry++;
+    } else if (v.rule.includes("color") || v.rule.includes("gradient") || v.rule.includes("blur")) {
+      categoryViolations.colors++;
+    } else if (v.rule.startsWith("table-")) {
+      categoryViolations.tables++;
+    } else {
+      categoryViolations.components++;
+    }
+  });
+  const filesCount = Math.max(1, result.scannedFilesCount || 1);
+  function calcScore(violations) {
+    const penaltyPerViolation = 100 / (filesCount * 2);
+    return Math.max(0, Math.round(100 - violations * penaltyPerViolation));
+  }
+  const categories = [
+    { name: "Typography Scale", category: "typography", violations: categoryViolations.typography, score: calcScore(categoryViolations.typography) },
+    { name: "Geometry & Radii", category: "geometry", violations: categoryViolations.geometry, score: calcScore(categoryViolations.geometry) },
+    { name: "Wrap Integrity", category: "wrapping", violations: categoryViolations.wrapping, score: calcScore(categoryViolations.wrapping) },
+    { name: "Component Inventory", category: "components", violations: categoryViolations.components, score: calcScore(categoryViolations.components) },
+    { name: "Color Purity", category: "colors", violations: categoryViolations.colors, score: calcScore(categoryViolations.colors) },
+    { name: "Table Invariants", category: "tables", violations: categoryViolations.tables, score: calcScore(categoryViolations.tables) }
+  ];
+  const totalScore = Math.round(categories.reduce((acc, c) => acc + c.score, 0) / categories.length);
+  let grade = "F";
+  if (totalScore >= 98) grade = "A+";
+  else if (totalScore >= 90) grade = "A";
+  else if (totalScore >= 80) grade = "B";
+  else if (totalScore >= 70) grade = "C";
+  else if (totalScore >= 60) grade = "D";
+  const fileBreakdown = Object.entries(fileCountMap).map(([file, violations]) => ({ file, violations })).sort((a, b) => b.violations - a.violations).slice(0, 5);
+  return {
+    overallScore: totalScore,
+    grade,
+    scannedFiles: filesCount,
+    totalViolations: result.violations.length,
+    categories,
+    fileBreakdown
+  };
+}
+
+// src/doctor/formatter.ts
+import pc2 from "picocolors";
+function renderProgressBar(percentage, width = 20) {
+  const filledChars = Math.round(percentage / 100 * width);
+  const emptyChars = width - filledChars;
+  let colorFn = pc2.green;
+  if (percentage < 70) colorFn = pc2.red;
+  else if (percentage < 90) colorFn = pc2.yellow;
+  const bar = colorFn("\u2588".repeat(filledChars)) + pc2.dim("\u2591".repeat(emptyChars));
+  return `${bar} ${colorFn(percentage.toString().padStart(3) + "%")}`;
+}
+function formatDoctorOutput(report) {
+  const lines = [];
+  lines.push("");
+  lines.push(pc2.bold(pc2.cyan("========================================================")));
+  lines.push(pc2.bold(pc2.cyan("       DESIGN SYSTEM ENFORCER - HEALTH REPORT           ")));
+  lines.push(pc2.bold(pc2.cyan("========================================================")));
+  lines.push("");
+  let gradeColor = pc2.green;
+  if (report.grade === "B") gradeColor = pc2.cyan;
+  else if (report.grade === "C") gradeColor = pc2.yellow;
+  else if (report.grade === "D" || report.grade === "F") gradeColor = pc2.red;
+  lines.push(
+    `  ${pc2.bold("Overall Score:")}  ${gradeColor(pc2.bold(report.overallScore + "/100"))}  [${gradeColor(pc2.bold(report.grade))}]`
+  );
+  lines.push(`  ${pc2.bold("Scanned Files:")}  ${pc2.white(report.scannedFiles)}`);
+  lines.push(`  ${pc2.bold("Total Issues:")}   ${report.totalViolations === 0 ? pc2.green("0") : pc2.red(report.totalViolations)}`);
+  lines.push("");
+  lines.push(pc2.bold("  Category Compliance:"));
+  report.categories.forEach((cat) => {
+    const paddedName = cat.name.padEnd(22, " ");
+    const issueCount = cat.violations > 0 ? pc2.dim(`(${cat.violations} issues)`) : "";
+    lines.push(`    ${pc2.dim(paddedName)} ${renderProgressBar(cat.score)} ${issueCount}`);
+  });
+  lines.push("");
+  if (report.fileBreakdown.length > 0) {
+    lines.push(pc2.bold(pc2.yellow("  Top Offending Files:")));
+    report.fileBreakdown.forEach((item, idx) => {
+      lines.push(`    ${idx + 1}. ${pc2.cyan(item.file)}: ${pc2.red(item.violations + " violations")}`);
+    });
+    lines.push("");
+    lines.push(pc2.dim("  Run 'dse check' for detailed line-by-line violation reports."));
+    lines.push(pc2.dim("  Run 'dse fix' to automatically remediate common violations."));
+  } else {
+    lines.push(pc2.bold(pc2.green("  \u2714 All design tokens and component invariants are 100% compliant!")));
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/fixer/index.ts
+import fs6 from "fs";
+import path6 from "path";
+async function runDseFix(config, cwd = process.cwd()) {
+  const scanResult = await runDseScan(config, cwd);
+  const violationsByFile = {};
+  scanResult.violations.forEach((v) => {
+    if (!violationsByFile[v.file]) {
+      violationsByFile[v.file] = [];
+    }
+    violationsByFile[v.file].push(v);
+  });
+  const details = [];
+  let totalModifications = 0;
+  for (const [relPath, violations] of Object.entries(violationsByFile)) {
+    const fullPath = path6.resolve(cwd, relPath);
+    if (!fs6.existsSync(fullPath)) continue;
+    let content = fs6.readFileSync(fullPath, "utf-8");
+    const originalContent = content;
+    const fileFixes = [];
+    if (violations.some((v) => v.rule === "no-wrapping-compact-elements")) {
+      const before = content;
+      content = content.replace(/(<(?:Button|IconButton|Chip|Badge)\b[^>]*className=["'`][^"'`]*?)\b(?:whitespace-normal|whitespace-pre-wrap|flex-wrap)\b([^"'`]*?["'`])/g, (match, prefix, suffix) => {
+        return `${prefix}whitespace-nowrap shrink-0${suffix}`;
+      });
+      if (before !== content) {
+        fileFixes.push("Replaced wrapping classes with 'whitespace-nowrap shrink-0' on compact controls");
+      }
+    }
+    if (violations.some((v) => v.rule === "no-raw-html-elements" && v.message.includes("<button>"))) {
+      const before = content;
+      content = content.replace(/<button(\s|>)/g, "<Button$1");
+      content = content.replace(/<\/button>/g, "</Button>");
+      if (before !== content) {
+        if (!content.includes("import { Button }") && !content.includes("import Button") && !relPath.includes("components/ui/button")) {
+          content = `import { Button } from "@/components/ui/button";
+` + content;
+        }
+        fileFixes.push("Upgraded raw <button> to <Button>");
+      }
+    }
+    if (violations.some((v) => v.rule === "no-raw-html-elements" && v.message.includes("<select>"))) {
+      const before = content;
+      content = content.replace(/<select(\s|>)/g, "<Dropdown$1");
+      content = content.replace(/<\/select>/g, "</Dropdown>");
+      if (before !== content) {
+        if (!content.includes("import { Dropdown }") && !content.includes("import Dropdown") && !relPath.includes("components/ui/dropdown")) {
+          content = `import { Dropdown } from "@/components/ui/dropdown";
+` + content;
+        }
+        fileFixes.push("Upgraded raw <select> to <Dropdown>");
+      }
+    }
+    if (violations.some((v) => v.rule === "no-raw-html-elements" && v.message.includes("<textarea>"))) {
+      const before = content;
+      content = content.replace(/<textarea(\s|>)/g, "<Textarea$1");
+      content = content.replace(/<\/textarea>/g, "</Textarea>");
+      if (before !== content) {
+        if (!content.includes("import { Textarea }") && !content.includes("import Textarea") && !relPath.includes("components/ui/textarea")) {
+          content = `import { Textarea } from "@/components/ui/textarea";
+` + content;
+        }
+        fileFixes.push("Upgraded raw <textarea> to <Textarea>");
+      }
+    }
+    if (violations.some((v) => v.rule === "no-arbitrary-text-size")) {
+      const before = content;
+      content = content.replace(/\btext-\[(?:13|13\.5|14|14\.5|15|15\.5)px\]\b/g, "text-sm");
+      content = content.replace(/\btext-\[(?:11|11\.5|12|12\.5)px\]\b/g, "text-xs");
+      content = content.replace(/\btext-\[(?:16|17)px\]\b/g, "text-base");
+      if (before !== content) {
+        fileFixes.push("Standardized arbitrary font sizes to compliant token scales");
+      }
+    }
+    if (violations.some((v) => v.rule === "no-backdrop-blur")) {
+      const before = content;
+      content = content.replace(/\bbackdrop-blur(?:-(?:none|sm|md|lg|xl|2xl|3xl))?\b/g, "");
+      if (before !== content) {
+        fileFixes.push("Removed non-compliant backdrop-blur classes");
+      }
+    }
+    if (content !== originalContent) {
+      fs6.writeFileSync(fullPath, content, "utf-8");
+      totalModifications += fileFixes.length;
+      details.push({
+        file: relPath,
+        fixes: fileFixes
+      });
+    }
+  }
+  return {
+    filesFixed: details.length,
+    totalModifications,
+    details
+  };
+}
+
+// src/guardrails/index.ts
+import fs7 from "fs";
+import path7 from "path";
+function generateAgentInstructions(config) {
+  const allowedRadii = config.tokens?.geometry?.allowedRadii?.join(", ") || "0px, 8px, 12px, 16px, 9999px";
+  const maxControlHeight = config.tokens?.geometry?.maxControlHeight || 36;
+  const bannedColors = config.tokens?.colors?.bannedColorFamilies?.join(", ") || "slate, gray, zinc, stone, etc.";
+  return `<!-- BEGIN:DSE-AGENT-RULES -->
+# DESIGN SYSTEM ENFORCER (DSE) - MANDATORY RULES
+
+You MUST adhere to these design system invariants for all UI generation:
+
+1. COMPONENT INVARIANTS:
+   - NEVER use raw HTML: <button>, <select>, <textarea>, <table>, <input type="checkbox">, <input type="radio">.
+   - ALWAYS use standard primitives: <Button>, <Dropdown>, <Textarea>, <Table>, <Checkbox>, <Chip>.
+   - Never create pseudo-chips using raw <div> or <span> with background fills and borders. Use <Chip>.
+
+2. WRAP INTEGRITY (COMPACT ELEMENTS):
+   - Interactive compact elements (<Button>, <Chip>, <Badge>, <TableHead>, tabs) MUST NOT wrap text.
+   - ALWAYS include 'whitespace-nowrap shrink-0' on compact interactive components.
+
+3. GEOMETRY & RADII:
+   - Standard control height for buttons and inputs is strictly max ${maxControlHeight}px ('h-[36px]' or 'h-9').
+   - Allowed corner radii tokens: ${allowedRadii}. Never use random arbitrary radii.
+
+4. COLOR SCALE & PURITY:
+   - Strictly neutral palette for base surfaces and borders ('neutral-100' through 'neutral-900').
+   - Banned arbitrary color families: ${bannedColors}.
+   - Never use arbitrary inline hex colors ('#1a2b3c') in utility classes. Use design system CSS variables ('var(--primary)').
+
+5. BEFORE FINISHING UI EDITS:
+   - Run 'npx dse check' to verify zero design system violations.
+<!-- END:DSE-AGENT-RULES -->
+`;
+}
+function installPreCommitHook(cwd = process.cwd()) {
+  const gitDir = path7.resolve(cwd, ".git");
+  if (!fs7.existsSync(gitDir)) {
+    throw new Error("No .git repository found in this directory.");
+  }
+  const hooksDir = path7.resolve(gitDir, "hooks");
+  if (!fs7.existsSync(hooksDir)) {
+    fs7.mkdirSync(hooksDir, { recursive: true });
+  }
+  const hookPath = path7.resolve(hooksDir, "pre-commit");
+  const hookScript = `#!/usr/bin/env sh
+# Design System Enforcer (DSE) Pre-Commit Hook
+echo "
+\u{1F50D} Running Design System Enforcer pre-commit check..."
+
+if command -v npx >/dev/null 2>&1; then
+  npx dse check --strict
+  RESULT=$?
+  if [ $RESULT -ne 0 ]; then
+    echo "
+\u274C Commit rejected: Design System violations found."
+    echo "\u{1F4A1} Run 'npx dse fix' or 'npx dse check' to review issues.
+"
+    exit 1
+  fi
+fi
+`;
+  fs7.writeFileSync(hookPath, hookScript, { mode: 493 });
+  return true;
+}
+
 // src/cli.ts
 var program = new Command();
-program.name("dse").description("Design System Enforcer (DSE) - AST-based Linter and Scaffold Engine").version("1.0.0");
+program.name("dse").description("Design System Enforcer (DSE) - AST-based Linter and Scaffold Engine").version("1.0.4");
 program.command("check [targetDir]", { isDefault: true }).description("Scan codebase and enforce Design System rules").option("-c, --config <path>", "Path to custom dse.config.js / dse.config.json").option("-f, --format <format>", "Output format: 'stylish' | 'json'", "stylish").option("--strict", "Treat warnings as errors", false).action(async (targetDirArg, options) => {
   try {
-    const cwd = targetDirArg ? path4.resolve(process.cwd(), targetDirArg) : process.cwd();
+    const cwd = targetDirArg ? path8.resolve(process.cwd(), targetDirArg) : process.cwd();
     const config = await loadConfig(cwd, options.config);
     const result = await runDseScan(config, cwd);
     if (options.format === "json") {
@@ -2147,76 +2709,125 @@ program.command("check [targetDir]", { isDefault: true }).description("Scan code
       process.exit(1);
     }
   } catch (err) {
-    console.error(pc2.red("Error running DSE scan:"), err);
+    console.error(pc3.red(`
+\u2716 Error running scan: ${err.message}`));
     process.exit(1);
   }
 });
-program.command("init").description("Initialize DSE configuration and optionally scaffold base primitives").option("--preset <name>", "Preset to use: 'berserk' | 'recommended' | 'python'").option("--with-primitives", "Scaffold full base primitives and tokens suite", false).action((options) => {
+program.command("doctor [targetDir]").description("Perform a visual Design System health audit and compute compliance score").option("-c, --config <path>", "Path to custom dse.config.js / dse.config.json").action(async (targetDirArg, options) => {
+  try {
+    const cwd = targetDirArg ? path8.resolve(process.cwd(), targetDirArg) : process.cwd();
+    const config = await loadConfig(cwd, options.config);
+    const result = await runDseScan(config, cwd);
+    const report = computeDoctorScore(result);
+    console.log(formatDoctorOutput(report));
+  } catch (err) {
+    console.error(pc3.red(`
+\u2716 Error generating health report: ${err.message}`));
+    process.exit(1);
+  }
+});
+program.command("fix [targetDir]").description("Automatically remediate common Design System violations in place").option("-c, --config <path>", "Path to custom dse.config.js / dse.config.json").action(async (targetDirArg, options) => {
+  try {
+    const cwd = targetDirArg ? path8.resolve(process.cwd(), targetDirArg) : process.cwd();
+    const config = await loadConfig(cwd, options.config);
+    console.log(pc3.cyan("\n\u{1F527} Running Design System Enforcer Auto-Fixer...\n"));
+    const fixReport = await runDseFix(config, cwd);
+    if (fixReport.filesFixed === 0) {
+      console.log(pc3.green("\u2714 No auto-fixable violations found. Your codebase is clean!"));
+    } else {
+      console.log(pc3.bold(pc3.green(`\u2714 Successfully fixed ${fixReport.totalModifications} issues across ${fixReport.filesFixed} files:
+`)));
+      fixReport.details.forEach((item) => {
+        console.log(`  ${pc3.bold(pc3.cyan(item.file))}:`);
+        item.fixes.forEach((f) => console.log(`    - ${pc3.dim(f)}`));
+      });
+    }
+    console.log("");
+  } catch (err) {
+    console.error(pc3.red(`
+\u2716 Error during auto-fix: ${err.message}`));
+    process.exit(1);
+  }
+});
+program.command("detect [targetDir]").description("Inspect project architecture, framework, libraries, and design tokens autonomously").action((targetDirArg) => {
+  const cwd = targetDirArg ? path8.resolve(process.cwd(), targetDirArg) : process.cwd();
+  const info = detectProject(cwd);
+  console.log(pc3.bold(pc3.cyan("\n\u{1F50D} DSE Autonomous Project Diagnostics\n")));
+  console.log(`  ${pc3.bold("Target Directory:")}   ${info.root}`);
+  console.log(`  ${pc3.bold("Framework:")}          ${pc3.green(info.framework)}`);
+  console.log(`  ${pc3.bold("Monorepo:")}           ${info.isMonorepo ? pc3.yellow("Yes") : "No"}`);
+  if (info.isMonorepo && info.monorepoWorkspaces.length > 0) {
+    console.log(`  ${pc3.bold("Workspaces:")}         ${info.monorepoWorkspaces.join(", ")}`);
+  }
+  console.log(`  ${pc3.bold("Libraries:")}          ${info.libraries.length ? pc3.magenta(info.libraries.join(", ")) : "None"}`);
+  console.log(`  ${pc3.bold("Tailwind CSS:")}       ${info.hasTailwind ? pc3.green(info.tailwindVersion || "Yes") : "No"}`);
+  console.log(`  ${pc3.bold("TypeScript:")}         ${info.hasTypeScript ? "Yes" : "No"}`);
+  console.log(`  ${pc3.bold("Tokens File:")}        ${info.tokensFile ? pc3.cyan(info.tokensFile) : pc3.dim("None (using preset defaults)")}`);
+  console.log(`  ${pc3.bold("Default Preset:")}     ${pc3.yellow(info.preset)}`);
+  console.log(`  ${pc3.bold("Auto Includes:")}      ${info.suggestedIncludes.join(", ")}`);
+  console.log(`  ${pc3.bold("Auto Ignores:")}       ${info.suggestedIgnores.slice(0, 5).join(", ")} (+${Math.max(0, info.suggestedIgnores.length - 5)} more)`);
+  console.log("");
+});
+program.command("export-agent").description("Export ultra-compact prompt rules for Cursor, Claude, Antigravity, or Copilot").option("-w, --write <file>", "Target file to write/append into (e.g. .cursorrules, AGENTS.md)").action(async (options) => {
   const cwd = process.cwd();
-  console.log(pc2.bold(pc2.cyan("\nInitializing Design System Enforcer (DSE)...")));
-  const isPythonProject = fs4.existsSync(path4.resolve(cwd, "requirements.txt")) || fs4.existsSync(path4.resolve(cwd, "pyproject.toml")) || fs4.existsSync(path4.resolve(cwd, ".streamlit"));
-  const preset = options.preset || (isPythonProject ? "python" : "berserk");
-  const configPath = scaffoldConfig(cwd, preset);
-  console.log(pc2.green("\u2714 Created config:"), pc2.bold(path4.relative(cwd, configPath)), pc2.dim(`(preset: ${preset})`));
-  const pkgPath = path4.resolve(cwd, "package.json");
-  if (fs4.existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
-      pkg.scripts = pkg.scripts || {};
-      if (!pkg.scripts.dse) {
-        pkg.scripts.dse = "dse";
-        fs4.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
-        console.log(pc2.green("\u2714 Added script 'dse' to package.json"));
+  const config = await loadConfig(cwd);
+  const instructions = generateAgentInstructions(config);
+  if (options.write) {
+    const targetPath = path8.resolve(cwd, options.write);
+    if (fs8.existsSync(targetPath)) {
+      let existing = fs8.readFileSync(targetPath, "utf-8");
+      const startTag = "<!-- BEGIN:DSE-AGENT-RULES -->";
+      const endTag = "<!-- END:DSE-AGENT-RULES -->";
+      if (existing.includes(startTag) && existing.includes(endTag)) {
+        const regex = new RegExp(`${startTag}[\\s\\S]*?${endTag}`, "g");
+        existing = existing.replace(regex, instructions.trim());
+      } else {
+        existing = `${existing.trim()}
+
+${instructions.trim()}
+`;
       }
-    } catch (err) {
-      console.warn(pc2.yellow("\u26A0 Could not update package.json:"), err);
+      fs8.writeFileSync(targetPath, existing, "utf-8");
+      console.log(pc3.green(`\u2714 Updated AI guardrails in ${options.write}`));
+    } else {
+      fs8.writeFileSync(targetPath, instructions, "utf-8");
+      console.log(pc3.green(`\u2714 Created ${options.write} with AI guardrails`));
     }
-  }
-  if (options.withPrimitives) {
-    console.log(pc2.cyan("Scaffolding primitives and theme tokens..."));
-    const created = scaffoldAllPrimitives(cwd);
-    created.forEach((file) => {
-      console.log(pc2.green("\u2714 Created:"), pc2.dim(path4.relative(cwd, file)));
-    });
   } else {
-    console.log(
-      pc2.dim("\nTip: Run 'npx dse scaffold' to generate rule-compliant base primitives and tokens anytime.")
-    );
+    console.log(instructions);
   }
-  console.log(pc2.bold(pc2.green("\n\u2714 DSE setup complete! Run 'npm run dse' to verify your project.\n")));
 });
-program.command("add <components...>").description("Scaffold specific rule-compliant design system primitives (button, chip, input, table, tabs, card, checkbox, dropdown, skeleton)").action((components) => {
-  const cwd = process.cwd();
-  console.log(pc2.bold(pc2.cyan("\nScaffolding requested components...")));
-  for (const comp of components) {
-    const filePath = scaffoldComponent(comp, cwd);
-    if (filePath) {
-      console.log(pc2.green("\u2714 Created:"), pc2.bold(path4.relative(cwd, filePath)));
-    } else {
-      console.log(
-        pc2.yellow(`\u26A0 Unknown component '${comp}'. Available: ${Object.keys(COMPONENT_TEMPLATES).join(", ")}`)
-      );
+program.command("hook [action]").description("Install or manage git pre-commit hooks to block non-compliant commits").action((action) => {
+  if (action === "install" || !action) {
+    try {
+      installPreCommitHook(process.cwd());
+      console.log(pc3.bold(pc3.green("\n\u2714 Successfully installed pre-commit hook in .git/hooks/pre-commit!")));
+      console.log(pc3.dim("  Every git commit will now be checked with 'dse check --strict'.\n"));
+    } catch (err) {
+      console.error(pc3.red(`
+\u2716 Could not install hook: ${err.message}
+`));
     }
   }
-  console.log("");
 });
-program.command("scaffold").description("Scaffold all base primitives and HSL tokens into src/components/ui/ and src/lib/").action(() => {
-  const cwd = process.cwd();
-  console.log(pc2.bold(pc2.cyan("\nScaffolding full design system suite...")));
-  const created = scaffoldAllPrimitives(cwd);
-  created.forEach((file) => {
-    console.log(pc2.green("\u2714 Created:"), pc2.bold(path4.relative(cwd, file)));
-  });
-  console.log(pc2.bold(pc2.green("\n\u2714 All design system primitives scaffolded successfully!\n")));
+program.command("init").description("Initialize DSE configuration in current repository").option("-p, --preset <name>", "Preset: berserk | recommended | minimal | python", "berserk").action((options) => {
+  scaffoldConfig(process.cwd(), options.preset);
+});
+program.command("scaffold-tokens").description("Generate official design system tokens TypeScript/CSS file").action(() => {
+  scaffoldTokens(process.cwd());
+});
+program.command("scaffold-primitives").description("Scaffold all canonical zero-compromise design system UI primitives").action(() => {
+  scaffoldAllPrimitives(process.cwd());
 });
 program.command("export-rules").description("Export rules in Markdown format for AI coding assistants (AGENTS.md, .cursorrules, CLAUDE.md)").option("-w, --write <file>", "Write directly to target file (e.g. AGENTS.md)").action(async (options) => {
   const cwd = process.cwd();
   const config = await loadConfig(cwd);
   const rulesMd = generateMarkdownRules(config);
   if (options.write) {
-    const targetFile = path4.resolve(cwd, options.write);
-    if (fs4.existsSync(targetFile)) {
-      let existing = fs4.readFileSync(targetFile, "utf-8");
+    const targetFile = path8.resolve(cwd, options.write);
+    if (fs8.existsSync(targetFile)) {
+      let existing = fs8.readFileSync(targetFile, "utf-8");
       const startTag = "<!-- BEGIN:design-system-enforcer-rules -->";
       const endTag = "<!-- END:design-system-enforcer-rules -->";
       if (existing.includes(startTag) && existing.includes(endTag)) {
@@ -2228,11 +2839,11 @@ program.command("export-rules").description("Export rules in Markdown format for
 ${rulesMd.trim()}
 `;
       }
-      fs4.writeFileSync(targetFile, existing, "utf-8");
-      console.log(pc2.green(`\u2714 Updated rules in ${options.write}`));
+      fs8.writeFileSync(targetFile, existing, "utf-8");
+      console.log(pc3.green(`\u2714 Updated rules in ${options.write}`));
     } else {
-      fs4.writeFileSync(targetFile, rulesMd, "utf-8");
-      console.log(pc2.green(`\u2714 Created ${options.write} with design system rules`));
+      fs8.writeFileSync(targetFile, rulesMd, "utf-8");
+      console.log(pc3.green(`\u2714 Created ${options.write} with design system rules`));
     }
   } else {
     console.log(rulesMd);