vds-test-empty 1.0.0

package/vds-core/scan.mjs

@@ -0,0 +1,916 @@
+#!/usr/bin/env node
+/**
+ * VDS Core — Ghost scan. Run from project root: node vds-core/scan.mjs
+ * Paths are relative to the host project root (parent of vds-core).
+ * Set VDS_LOCALE=en|tr for CLI message language (default: en).
+ */
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+import { execSync } from "child_process";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = path.join(__dirname, "..");
+const projectRequire = createRequire(path.join(PROJECT_ROOT, "package.json"));
+
+const CLI_LOCALES = {
+  en: {
+    componentsNotFound: "src/components not found. VDS scan skipped.",
+    scanComplete: "VDS: {n} components → vds-output.json & public/vds-output.json",
+  },
+  tr: {
+    componentsNotFound: "src/components bulunamadı. VDS taraması atlandı.",
+    scanComplete: "VDS: {n} bileşen → vds-output.json ve public/vds-output.json",
+  },
+};
+const CLI_LOCALE = (process.env.VDS_LOCALE === "tr" ? "tr" : "en");
+const cliT = (key, n) => CLI_LOCALES[CLI_LOCALE][key].replace("{n}", String(n));
+const SRC_DIR = path.join(PROJECT_ROOT, "src");
+const COMPONENTS_DIR = path.join(PROJECT_ROOT, "src", "components");
+const PAGES_DIR = path.join(PROJECT_ROOT, "src", "pages");
+const OUTPUT_FILE = path.join(PROJECT_ROOT, "vds-output.json");
+const PUBLIC_MANIFEST = path.join(PROJECT_ROOT, "public", "vds-output.json");
+const HISTORY_FILE = path.join(PROJECT_ROOT, "vds-history.json");
+
+const DEFAULT_VITE_PORT = 5173;
+
+function getVitePort() {
+  for (const name of ["vite.config.ts", "vite.config.js"]) {
+    const p = path.join(PROJECT_ROOT, name);
+    if (!fs.existsSync(p)) continue;
+    try {
+      const raw = fs.readFileSync(p, "utf-8");
+      const m = raw.match(/port\s*:\s*(\d+)/);
+      if (m) return parseInt(m[1], 10);
+    } catch (_) {}
+  }
+  return DEFAULT_VITE_PORT;
+}
+
+function vdsDashboardUrl() {
+  const port = getVitePort();
+  return `http://localhost:${port}/vds`;
+}
+
+function formatClickableLink(url) {
+  return `\u001b]8;;${url}\u0007${url}\u001b]8;;\u0007`;
+}
+
+function getGitBranch() {
+  try {
+    return execSync("git branch --show-current", { cwd: PROJECT_ROOT, encoding: "utf-8" }).trim() || null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function getGitEngineer() {
+  try {
+    return execSync("git config user.name", { cwd: PROJECT_ROOT, encoding: "utf-8" }).trim() || null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function incPatch(version) {
+  const parts = String(version || "1.0.0").split(".");
+  const major = parseInt(parts[0], 10) || 1;
+  const minor = parseInt(parts[1], 10) || 0;
+  const patch = (parseInt(parts[2], 10) || 0) + 1;
+  return `${major}.${minor}.${patch}`;
+}
+
+function readPreviousOutput() {
+  try {
+    if (fs.existsSync(OUTPUT_FILE)) {
+      const raw = fs.readFileSync(OUTPUT_FILE, "utf-8");
+      const data = JSON.parse(raw);
+      return data.components || [];
+    }
+  } catch (_) {}
+  return null;
+}
+
+function readLastVersion() {
+  try {
+    if (fs.existsSync(HISTORY_FILE)) {
+      const raw = fs.readFileSync(HISTORY_FILE, "utf-8");
+      const data = JSON.parse(raw);
+      const entries = Array.isArray(data) ? data : data.entries || [];
+      const last = entries[entries.length - 1];
+      return last ? last.version : "1.0.0";
+    }
+  } catch (_) {}
+  return "1.0.0";
+}
+
+function readHistoryEntries() {
+  try {
+    if (fs.existsSync(HISTORY_FILE)) {
+      const raw = fs.readFileSync(HISTORY_FILE, "utf-8");
+      const data = JSON.parse(raw);
+      return Array.isArray(data) ? data : data.entries || [];
+    }
+  } catch (_) {}
+  return [];
+}
+
+function compareComponents(prevList, newResults) {
+  const prevByFile = new Map((prevList || []).map((c) => [c.file, c]));
+  const newByFile = new Map(newResults.map((c) => [c.file, c]));
+  const added = [];
+  const removed = [];
+  const modified = [];
+  for (const [file, c] of newByFile) {
+    const p = prevByFile.get(file);
+    if (!p) added.push({ type: "added", name: c.name, group: c.group, category: c.category });
+    else if (p.name !== c.name || p.group !== c.group || p.category !== c.category) {
+      modified.push({ type: "modified", name: c.name, group: c.group, category: c.category });
+    }
+  }
+  for (const [file, c] of prevByFile) {
+    if (!newByFile.has(file)) removed.push({ type: "removed", name: c.name, group: c.group, category: c.category });
+  }
+  return { added, removed, modified };
+}
+
+const CLASSIFICATION_RULES = [
+  { keywords: ["analysisdashboard", "componentlibrary"], group: "Sections", category: "Dashboard" },
+  {
+    keywords: [
+      "enterprisepushpanel",
+      "figmalibrarygenerator",
+      "integrationguide",
+      "projectdropzone",
+      "repoconnect",
+      "tokensstudioguide",
+    ],
+    group: "Sections",
+    category: "Features",
+  },
+  { keywords: ["hover-card"], group: "Feedback", category: "Feedback" },
+  {
+    keywords: [
+      "card",
+      "table",
+      "list",
+      "badge",
+      "avatar",
+      "chart",
+      "accordion",
+      "tabs",
+      "collapsible",
+      "toggle-group",
+      "carousel",
+      "scroll-area",
+    ],
+    group: "Data Display",
+    category: "Data Display",
+  },
+  { keywords: ["toggle"], group: "Actions", category: "Toggle" },
+  { keywords: ["button", "cta"], group: "Actions", category: "Button" },
+  { keywords: ["drawer", "sheet"], group: "Feedback", category: "Overlay" },
+  {
+    keywords: [
+      "modal",
+      "dialog",
+      "alert",
+      "toast",
+      "toaster",
+      "sonner",
+      "tooltip",
+      "popover",
+      "hover-card",
+      "progress",
+      "skeleton",
+    ],
+    group: "Feedback",
+    category: "Feedback",
+  },
+  {
+    keywords: [
+      "input",
+      "form",
+      "select",
+      "checkbox",
+      "textarea",
+      "label",
+      "switch",
+      "radio",
+      "slider",
+      "calendar",
+      "input-otp",
+      "command",
+    ],
+    group: "Forms",
+    category: "Forms",
+  },
+  {
+    keywords: [
+      "nav",
+      "header",
+      "sidebar",
+      "menu",
+      "menubar",
+      "dropdown-menu",
+      "navigation-menu",
+      "context-menu",
+      "navlink",
+      "breadcrumb",
+      "pagination",
+    ],
+    group: "Navigation",
+    category: "Navigation",
+  },
+  { keywords: ["separator", "aspect-ratio", "resizable"], group: "Layout", category: "Layout" },
+  {
+    keywords: ["hero", "banner", "section", "pricing", "feature", "featuresgrid", "interactivedemo", "modernhero"],
+    group: "Sections",
+    category: "Sections",
+  },
+];
+
+function getAllComponentFiles(dir, baseDir = dir) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...getAllComponentFiles(fullPath, baseDir));
+    } else if (entry.isFile() && /\.(tsx|jsx)$/i.test(entry.name)) {
+      files.push(path.relative(baseDir, fullPath).replace(/\\/g, "/"));
+    }
+  }
+  return files;
+}
+
+function getAllTsxJsxInDir(dir) {
+  if (!fs.existsSync(dir)) return [];
+  return getAllComponentFiles(dir, dir);
+}
+
+const BRAND_KEYWORDS = /logo|brand|icon|favicon|emblem|mark/i;
+const BRAND_EXTENSIONS = /\.(svg|png|ico)$/i;
+
+function getFilesByExtension(dir, extRe, baseDir = dir) {
+  if (!fs.existsSync(dir)) return [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...getFilesByExtension(fullPath, extRe, baseDir));
+    } else if (entry.isFile() && extRe.test(entry.name)) {
+      files.push(path.relative(baseDir, fullPath).replace(/\\/g, "/"));
+    }
+  }
+  return files;
+}
+
+/** Scan public/, src/assets/, src/images/ for .svg, .png, .ico; filter by brand keywords. */
+function extractBrandAssets() {
+  const assets = [];
+  const dirs = [
+    path.join(PROJECT_ROOT, "public"),
+    path.join(PROJECT_ROOT, "src", "assets"),
+    path.join(PROJECT_ROOT, "src", "images"),
+  ];
+  for (const dir of dirs) {
+    const relDir = path.relative(PROJECT_ROOT, dir).replace(/\\/g, "/");
+    const files = getFilesByExtension(dir, BRAND_EXTENSIONS, PROJECT_ROOT);
+    for (const filePath of files) {
+      const baseName = path.basename(filePath);
+      if (!BRAND_KEYWORDS.test(baseName)) continue;
+      const type = /favicon|\.ico$/i.test(baseName) ? "favicon" : /logo|brand|emblem|mark/i.test(baseName) ? "logo" : "icon";
+      assets.push({ path: filePath, name: baseName, type });
+    }
+  }
+  // Fallback: if no branded assets found by keyword, include all image files from src/assets
+  if (assets.length === 0 || assets.every((r) => r.type === "asset")) {
+    const assetsDir = path.join(SRC_DIR, "assets");
+    if (fs.existsSync(assetsDir)) {
+      const imgExtRe = /\.(png|jpg|jpeg|svg|gif|webp|ico)$/i;
+      const allImages = fs.readdirSync(assetsDir).filter((f) => imgExtRe.test(f));
+      for (const img of allImages) {
+        if (!assets.some((r) => r.path === "src/assets/" + img)) {
+          assets.push({ type: "asset", path: "src/assets/" + img, name: img });
+        }
+      }
+    }
+  }
+  return assets;
+}
+
+/** Extract icon names from `import { A, B, C } from "lucide-react"` (or 'lucide-react'). Returns unique list. */
+function extractLucideIconsUsed(srcDir) {
+  const files = getAllTsxJsxInDir(srcDir);
+  const names = new Set();
+  const importRe = /import\s*\{([^}]+)\}\s*from\s*["']lucide-react["']/g;
+  for (const rel of files) {
+    const fullPath = path.join(srcDir, rel);
+    try {
+      const content = fs.readFileSync(fullPath, "utf-8");
+      let m;
+      while ((m = importRe.exec(content)) !== null) {
+        const block = m[1];
+        block.split(",").forEach((part) => {
+          const trimmed = part.trim();
+          const asMatch = trimmed.match(/^(\w+)\s+as\s+/);
+          const name = asMatch ? asMatch[1] : trimmed.split(/\s+/)[0];
+          if (name && /^[A-Z][a-zA-Z0-9]*$/.test(name)) names.add(name);
+        });
+      }
+    } catch (_) {}
+    importRe.lastIndex = 0;
+  }
+  return [...names].sort();
+}
+
+function extractVdsTags(content) {
+  const tags = {};
+  const tagNames = ["vds-group", "vds-category", "vds-name", "vds-description"];
+  for (const tag of tagNames) {
+    const re = new RegExp(`@${tag}\\s+([^\n*]+)`, "g");
+    const m = re.exec(content);
+    if (m) tags[tag.replace("vds-", "")] = m[1].trim();
+  }
+  return Object.keys(tags).length ? tags : null;
+}
+
+function classifyByFileName(filePath) {
+  const baseName = path.basename(filePath, path.extname(filePath)).toLowerCase();
+  for (const rule of CLASSIFICATION_RULES) {
+    const found = rule.keywords.some((kw) => baseName.includes(kw));
+    if (found) return { group: rule.group, category: rule.category };
+  }
+  return { group: "Uncategorized", category: "Uncategorized" };
+}
+
+function humanizeName(filePath) {
+  const base = path.basename(filePath, path.extname(filePath));
+  return base.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase()).trim();
+}
+
+const COMPONENT_SUGGESTION_KEYWORDS = [
+  { re: /\bcard\b/i, name: "Card" },
+  { re: /\bsection\b/i, name: "Section" },
+  { re: /\bitem\b/i, name: "Item" },
+  { re: /\bbadge\b/i, name: "Badge" },
+  { re: /\brow\b/i, name: "Row" },
+  { re: /\bgrid\b/i, name: "Grid" },
+  { re: /\bhero\b/i, name: "Hero" },
+  { re: /\bcta\b/i, name: "Cta" },
+  { re: /\bstat\b/i, name: "Stat" },
+  { re: /\bprice\b/i, name: "Pricing" },
+  { re: /\bfeature\b/i, name: "Feature" },
+  { re: /\bbutton\b/i, name: "Button" },
+  { re: /\btag\b/i, name: "Tag" },
+  { re: /\bchip\b/i, name: "Chip" },
+  { re: /\btile\b/i, name: "Tile" },
+  { re: /\bbanner\b/i, name: "Banner" },
+  { re: /\bmodal\b/i, name: "Modal" },
+];
+
+function suggestNameFromPattern(pattern, index) {
+  const parts = [];
+  for (const { re, name } of COMPONENT_SUGGESTION_KEYWORDS) {
+    if (re.test(pattern)) parts.push(name);
+  }
+  if (parts.length > 0) return parts.join("");
+  return "Block" + (index + 1);
+}
+
+/** Scan src/pages/*.tsx for repeated className clusters; return component suggestions. */
+function extractComponentSuggestions() {
+  if (!fs.existsSync(PAGES_DIR)) return [];
+  const pageFiles = getAllComponentFiles(PAGES_DIR);
+  const byPattern = new Map();
+  const re = /className\s*=\s*["']([^"']+)["']|className\s*=\s*\{\s*["']([^"']+)["']/g;
+
+  for (const rel of pageFiles) {
+    const fullPath = path.join(PAGES_DIR, rel);
+    const content = fs.readFileSync(fullPath, "utf-8");
+    const srcRel = "src/pages/" + rel.replace(/\\/g, "/");
+    let m;
+    re.lastIndex = 0;
+    while ((m = re.exec(content)) !== null) {
+      const raw = (m[1] ?? m[2] ?? "").trim().replace(/\s+/g, " ").trim();
+      if (!raw) continue;
+      const classCount = raw.split(/\s+/).filter(Boolean).length;
+      if (classCount < 3) continue;
+      if (!byPattern.has(raw)) {
+        const before = content.substring(0, m.index);
+        const lastOpen = before.lastIndexOf("<");
+        const tagMatch = lastOpen >= 0 ? content.slice(lastOpen).match(/<(\w+)/) : null;
+        const tagName = tagMatch ? tagMatch[1] : "div";
+        byPattern.set(raw, {
+          count: 0,
+          files: new Set(),
+          snippet: `<${tagName} className="${raw}">...</${tagName}>`,
+        });
+      }
+      const entry = byPattern.get(raw);
+      entry.count += 1;
+      entry.files.add(srcRel);
+    }
+  }
+
+  const suggestions = [];
+  let blockIndex = 0;
+  for (const [pattern, { count, files, snippet }] of byPattern.entries()) {
+    if (count < 2) continue;
+    const suggestedName = suggestNameFromPattern(pattern, blockIndex);
+    if (suggestedName.startsWith("Block")) blockIndex += 1;
+    suggestions.push({
+      suggestedName,
+      occurrences: count,
+      foundIn: [...files].sort(),
+      pattern,
+      snippet,
+      reason: `Same className cluster appears ${count} times`,
+    });
+  }
+  return suggestions;
+}
+
+function extractTailwindTokens(content) {
+  const tokens = new Set();
+  const patterns = [
+    /className\s*=\s*["'`]([^"'`]+)["'`]/g,
+    /className\s*=\s*\{\s*["'`]([^"'`]+)["'`]/g,
+    /cn\s*\(\s*["'`]([^"'`]+)["'`]/g,
+    /cva\s*\(\s*["'`]([^"'`]+)["'`]/g,
+    /["'`]([a-zA-Z0-9_\-\/\s\[\]&:%.]+(?:hover|focus|active|disabled|sm|md|lg|xl|2xl|dark:)[a-zA-Z0-9_\-\/\s\[\]&:%.]*)["'`]/g,
+  ];
+  for (const re of patterns) {
+    let m;
+    while ((m = re.exec(content)) !== null) {
+      const part = m[1];
+      part
+        .replace(/\$\{[^}]*\}/g, " ")
+        .split(/\s+/)
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0 && /^[a-zA-Z0-9_\-\[\]\/:&%.]+$/.test(s))
+        .forEach((s) => tokens.add(s));
+    }
+  }
+  return [...tokens].sort();
+}
+
+/** Parse HSL string "0 0% 0%" or "hsl(0 0% 0%)" and return hex. */
+function hslToHex(hslStr) {
+  const match = hslStr.match(/hsl\s*\(\s*([\d.]+)\s*[, ]\s*([\d.]+)%\s*[, ]\s*([\d.]+)%\s*\)/) ||
+    hslStr.match(/^([\d.]+)\s+([\d.]+)%\s+([\d.]+)%$/);
+  if (!match) return null;
+  const h = Number(match[1]) / 360;
+  const s = Number(match[2]) / 100;
+  const l = Number(match[3]) / 100;
+  let r, g, b;
+  if (s === 0) {
+    r = g = b = l;
+  } else {
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    r = hue2rgb(p, q, h + 1 / 3);
+    g = hue2rgb(p, q, h);
+    b = hue2rgb(p, q, h - 1 / 3);
+  }
+  const toHex = (x) => {
+    const n = Math.round(Math.max(0, Math.min(255, x * 255)));
+    return n.toString(16).padStart(2, "0");
+  };
+  return "#" + toHex(r) + toHex(g) + toHex(b);
+}
+function hue2rgb(p, q, t) {
+  if (t < 0) t += 1;
+  if (t > 1) t -= 1;
+  if (t < 1 / 6) return p + (q - p) * 6 * t;
+  if (t < 1 / 2) return q;
+  if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+  return p;
+}
+
+function parseCssVarBlock(block) {
+  const out = {};
+  const varRe = /--([a-zA-Z0-9-]+)\s*:\s*([^;]+);/g;
+  let m;
+  while ((m = varRe.exec(block)) !== null) {
+    const name = m[1];
+    const raw = m[2].trim();
+    out[name] = raw;
+  }
+  return out;
+}
+
+/** Resolve Tailwind theme for boxShadow, spacing, screens, zIndex, motion. Uses resolveConfig when available. */
+function getTailwindTheme() {
+  const empty = { shadows: {}, spacing: {}, breakpoints: {}, zIndex: {}, transitionDuration: {}, transitionTimingFunction: {}, animation: {} };
+  try {
+    const resolveConfig = projectRequire("tailwindcss/resolveConfig");
+    let config = { content: [{ raw: "", extension: "html" }], theme: {} };
+    const twPath = path.join(PROJECT_ROOT, "tailwind.config.js");
+    const twPathMjs = path.join(PROJECT_ROOT, "tailwind.config.mjs");
+    if (fs.existsSync(twPath)) {
+      config = projectRequire(twPath);
+      if (config && typeof config === "object" && config.default) config = config.default;
+    } else if (fs.existsSync(twPathMjs)) {
+      config = projectRequire(twPathMjs);
+      if (config && typeof config === "object" && config.default) config = config.default;
+    }
+    const resolved = resolveConfig(config);
+    const theme = resolved.theme || {};
+    const boxShadow = theme.boxShadow;
+    const spacing = theme.spacing;
+    const screens = theme.screens;
+    const zIndex = theme.zIndex;
+    const transitionDuration = theme.transitionDuration;
+    const transitionTimingFunction = theme.transitionTimingFunction;
+    const animation = theme.animation;
+    const toObj = (v) => (v && typeof v === "object" && !Array.isArray(v) ? v : {});
+    return {
+      shadows: toObj(boxShadow),
+      spacing: toObj(spacing),
+      breakpoints: toObj(screens),
+      zIndex: toObj(zIndex),
+      transitionDuration: toObj(transitionDuration),
+      transitionTimingFunction: toObj(transitionTimingFunction),
+      animation: toObj(animation),
+    };
+  } catch (_) {
+    return empty;
+  }
+}
+
+function extractFoundations() {
+  const colors = {};
+  const colorsDark = {};
+  const typography = {};
+  const cssRadiusVars = {};
+  const borderRadiusScale = {};
+  const cssPath = path.join(PROJECT_ROOT, "src", "index.css");
+  const globalsCss = path.join(PROJECT_ROOT, "src", "globals.css");
+  const appGlobals = path.join(PROJECT_ROOT, "app", "globals.css");
+  const cssToRead = fs.existsSync(cssPath) ? cssPath : fs.existsSync(globalsCss) ? globalsCss : appGlobals;
+
+  try {
+    if (fs.existsSync(cssToRead)) {
+      const css = fs.readFileSync(cssToRead, "utf-8");
+
+      const rootMatch = css.match(/:root\s*\{([\s\S]*?)\}/);
+      if (rootMatch) {
+        const rootVars = parseCssVarBlock(rootMatch[1]);
+        for (const [name, value] of Object.entries(rootVars)) {
+          if (/\d+\s+\d+%/.test(value) || /\d+%/.test(value)) {
+            const hsl = `hsl(${value})`;
+            colors[name] = { value: hsl, hex: hslToHex(hsl) || hsl };
+          } else if (/rem|px/.test(value)) {
+            cssRadiusVars[name] = value;
+          } else {
+            colors[name] = { value, hex: value };
+          }
+        }
+      }
+
+      const darkMatch = css.match(/\.dark\s*\{([\s\S]*?)\}/) ||
+        css.match(/\[data-theme\s*=\s*["']dark["']\]\s*\{([\s\S]*?)\}/);
+      if (darkMatch) {
+        const darkVars = parseCssVarBlock(darkMatch[1]);
+        for (const [name, value] of Object.entries(darkVars)) {
+          if (/\d+\s+\d+%/.test(value) || /\d+%/.test(value)) {
+            const hsl = `hsl(${value})`;
+            colorsDark[name] = { value: hsl, hex: hslToHex(hsl) || hsl };
+          }
+        }
+      }
+
+      const bodyMatch = css.match(/body\s*\{[^}]*font-family:\s*([^;]+);/);
+      if (bodyMatch) typography.body = bodyMatch[1].trim();
+      const monoMatch = css.match(/code,\s*pre,\s*\.font-mono\s*\{[^}]*font-family:\s*([^;]+);/);
+      if (monoMatch) typography.mono = monoMatch[1].trim();
+    }
+  } catch (_) {}
+
+  try {
+    const twPath = path.join(PROJECT_ROOT, "tailwind.config.ts");
+    const twPathJs = path.join(PROJECT_ROOT, "tailwind.config.js");
+    const twFile = fs.existsSync(twPath) ? twPath : twPathJs;
+    if (fs.existsSync(twFile)) {
+      const tw = fs.readFileSync(twFile, "utf-8");
+      const sansMatch = tw.match(/sans:\s*\[([^\]]+)\]/);
+      if (sansMatch) {
+        typography.tailwindSans = sansMatch[1]
+          .split(",")
+          .map((s) => s.trim().replace(/^['"`]|['"`]$/g, ""))
+          .filter(Boolean);
+      }
+      const monoMatch2 = tw.match(/mono:\s*\[([^\]]+)\]/);
+      if (monoMatch2) {
+        typography.tailwindMono = monoMatch2[1]
+          .split(",")
+          .map((s) => s.trim().replace(/^['"`]|['"`]$/g, ""))
+          .filter(Boolean);
+      }
+      const brMatch = tw.match(/borderRadius:\s*\{([\s\S]*?)\}/);
+      if (brMatch) {
+        const body = brMatch[1];
+        const brRe = /(\w+):\s*"([^"]+)"/g;
+        let m2;
+        while ((m2 = brRe.exec(body)) !== null) borderRadiusScale[m2[1]] = m2[2];
+      }
+    }
+  } catch (_) {}
+
+  // Fallback: if no CSS variable colors found, extract hardcoded colors from component files
+  if (Object.keys(colors).length === 0) {
+    const hardcodedColors = new Map();
+    const srcFiles = getAllTsxJsxInDir(SRC_DIR);
+    for (const f of srcFiles) {
+      try {
+        const fullPath = path.join(SRC_DIR, f);
+        const content = fs.readFileSync(fullPath, "utf-8");
+        const matches = content.matchAll(/(bg|text|border|from|to|via|ring|fill|stroke|shadow|outline|accent|divide|decoration|placeholder)-\[#([0-9a-fA-F]{3,8})\]/g);
+        for (const m of matches) {
+          const hex = "#" + m[2].toLowerCase();
+          if (!hardcodedColors.has(hex)) {
+            hardcodedColors.set(hex, { usages: new Set(), count: 0 });
+          }
+          hardcodedColors.get(hex).usages.add(m[1]);
+          hardcodedColors.get(hex).count++;
+        }
+      } catch (_) {}
+    }
+    const sorted = [...hardcodedColors.entries()].sort((a, b) => b[1].count - a[1].count);
+    for (const [hex, info] of sorted) {
+      const primaryUsage = [...info.usages][0];
+      const name = `color-${primaryUsage}-${hex.slice(1)}`;
+      colors[name] = { value: hex, hex };
+    }
+  }
+
+  const radius = {};
+  if (cssRadiusVars.radius) radius.base = cssRadiusVars.radius;
+  if (Object.keys(borderRadiusScale).length > 0) radius.borderRadius = borderRadiusScale;
+  const foundationsColors = { ...colors };
+  if (Object.keys(colorsDark).length > 0) foundationsColors._dark = colorsDark;
+
+  // Fallback: if no typography tokens from config, extract from Google Fonts @import
+  if (Object.keys(typography).length === 0 || (!typography.body && !typography.bodyFontFamily)) {
+    for (const cssFile of ["src/index.css", "src/App.css", "src/globals.css", "src/styles/globals.css"]) {
+      const cssPath = path.join(PROJECT_ROOT, cssFile);
+      if (!fs.existsSync(cssPath)) continue;
+      try {
+        const cssContent = fs.readFileSync(cssPath, "utf-8");
+        const fontImports = cssContent.matchAll(/@import\s+url\(['"]?https:\/\/fonts\.googleapis\.com\/css2\?family=([^&'"]+)/g);
+        const families = [];
+        for (const m of fontImports) {
+          const family = decodeURIComponent(m[1]).replace(/\+/g, " ").split(":")[0];
+          families.push(family);
+        }
+        if (families.length > 0) {
+          typography.body = families[0] + ", sans-serif";
+          typography.fontFamilies = families;
+          if (families.length > 1) typography.headingFont = families.find((f) => f !== families[0]) || families[1];
+          break;
+        }
+      } catch (_) {}
+    }
+  }
+
+  const twTheme = getTailwindTheme();
+  const normalizeThemeObj = (obj) => {
+    if (!obj || typeof obj !== "object") return {};
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+      if (v !== undefined && v !== null) out[k] = typeof v === "string" ? v : String(v);
+    }
+    return out;
+  };
+  return {
+    colors: foundationsColors,
+    typography,
+    radius,
+    shadows: normalizeThemeObj(twTheme.shadows),
+    spacing: normalizeThemeObj(twTheme.spacing),
+    breakpoints: normalizeThemeObj(twTheme.breakpoints),
+    zIndex: normalizeThemeObj(twTheme.zIndex),
+    motion: {
+      transitionDuration: normalizeThemeObj(twTheme.transitionDuration),
+      transitionTimingFunction: normalizeThemeObj(twTheme.transitionTimingFunction),
+      animation: normalizeThemeObj(twTheme.animation),
+    },
+  };
+}
+
+function scan() {
+  if (!fs.existsSync(COMPONENTS_DIR)) {
+    console.error(CLI_LOCALES[CLI_LOCALE].componentsNotFound);
+    process.exit(1);
+  }
+  const relativeFiles = getAllComponentFiles(COMPONENTS_DIR);
+  const results = [];
+  for (const rel of relativeFiles) {
+    const fullPath = path.join(COMPONENTS_DIR, rel);
+    const content = fs.readFileSync(fullPath, "utf-8");
+    const vdsTags = extractVdsTags(content);
+    let group, category, name, description;
+    if (vdsTags) {
+      group = vdsTags.group ?? "Uncategorized";
+      category = vdsTags.category ?? "Uncategorized";
+      name = vdsTags.name ?? humanizeName(rel);
+      description = vdsTags.description ?? "";
+    } else {
+      const classified = classifyByFileName(rel);
+      group = classified.group;
+      category = classified.category;
+      name = humanizeName(rel);
+      description = "";
+    }
+    const tokens = extractTailwindTokens(content);
+    results.push({ file: rel, name, group, category, description, tokens });
+  }
+  if (fs.existsSync(PAGES_DIR)) {
+    const pageFiles = getAllComponentFiles(PAGES_DIR);
+    for (const rel of pageFiles) {
+      const fullPath = path.join(PAGES_DIR, rel);
+      const content = fs.readFileSync(fullPath, "utf-8");
+      const name = humanizeName(rel);
+      const tokens = extractTailwindTokens(content);
+      results.push({
+        file: "pages/" + rel,
+        name,
+        group: "Sections",
+        category: "Pages",
+        description: "",
+        tokens,
+      });
+    }
+  }
+  const foundations = extractFoundations();
+  foundations.icons = extractLucideIconsUsed(SRC_DIR);
+  foundations.brand = { assets: extractBrandAssets() };
+  const componentSuggestions = extractComponentSuggestions();
+  const output = {
+    branch: getGitBranch(),
+    engineer: getGitEngineer(),
+    scannedAt: new Date().toISOString(),
+    totalComponents: results.length,
+    components: results,
+    foundations,
+    componentSuggestions,
+  };
+
+  const prevComponents = readPreviousOutput();
+  const { added, removed, modified } = compareComponents(prevComponents, results);
+  const hasChanges = added.length > 0 || removed.length > 0 || modified.length > 0;
+
+  fs.writeFileSync(OUTPUT_FILE, JSON.stringify(output, null, 2), "utf-8");
+  const publicDir = path.join(PROJECT_ROOT, "public");
+  if (!fs.existsSync(publicDir)) fs.mkdirSync(publicDir, { recursive: true });
+  fs.writeFileSync(PUBLIC_MANIFEST, JSON.stringify(output, null, 2), "utf-8");
+
+  if (hasChanges) {
+    const lastVersion = readLastVersion();
+    const nextVersion = incPatch(lastVersion);
+    const changes = [...added, ...removed, ...modified];
+    const historyEntry = {
+      version: nextVersion,
+      timestamp: new Date().toISOString(),
+      branch: getGitBranch(),
+      engineer: getGitEngineer(),
+      changes,
+    };
+    const entries = readHistoryEntries();
+    entries.push(historyEntry);
+    fs.writeFileSync(HISTORY_FILE, JSON.stringify(entries, null, 2), "utf-8");
+    console.log(
+      `[VDS] v${nextVersion}: ${added.length} added, ${removed.length} removed, ${modified.length} modified`
+    );
+    console.log(cliT("scanComplete", results.length));
+  }
+}
+
+function loadVdsOutputFromBranch(branch) {
+  try {
+    const raw = execSync(`git show ${branch}:vds-output.json`, { cwd: PROJECT_ROOT, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
+    return JSON.parse(raw);
+  } catch (_) {
+    return null;
+  }
+}
+
+function componentSignature(c) {
+  return JSON.stringify({ name: c.name, group: c.group, category: c.category, tokens: (c.tokens || []).slice().sort() });
+}
+
+function runCompare() {
+  const argv = process.argv.slice(2);
+  const idx = argv.indexOf("--compare");
+  const branch1 = idx >= 0 ? argv[idx + 1] : null;
+  const branch2 = idx >= 0 ? argv[idx + 2] : null;
+  if (!branch1 || !branch2) {
+    console.error("Kullanım: node vds-core/scan.mjs --compare <branch1> <branch2>");
+    process.exit(1);
+  }
+  const data1 = loadVdsOutputFromBranch(branch1);
+  const data2 = loadVdsOutputFromBranch(branch2);
+  if (!data1 || !data1.components) {
+    console.error(`vds-output.json bulunamadı veya geçersiz: ${branch1}. Önce o branch'te 'npm run vds' çalıştırın.`);
+    process.exit(1);
+  }
+  if (!data2 || !data2.components) {
+    console.error(`vds-output.json bulunamadı veya geçersiz: ${branch2}. Önce o branch'te 'npm run vds' çalıştırın.`);
+    process.exit(1);
+  }
+  const byFile1 = new Map(data1.components.map((c) => [c.file, c]));
+  const byFile2 = new Map(data2.components.map((c) => [c.file, c]));
+  const files1 = new Set(byFile1.keys());
+  const files2 = new Set(byFile2.keys());
+  const commonFiles = [...files1].filter((f) => files2.has(f));
+  const only1 = [...files1].filter((f) => !files2.has(f));
+  const only2 = [...files2].filter((f) => !files1.has(f));
+  const different = commonFiles.filter((f) => componentSignature(byFile1.get(f)) !== componentSignature(byFile2.get(f)));
+  const commonCount = commonFiles.length - different.length;
+
+  const label1 = branch1.length > 20 ? branch1.slice(0, 17) + "…" : branch1;
+  const label2 = branch2.length > 20 ? branch2.slice(0, 17) + "…" : branch2;
+  console.log(`\n📊 Branch karşılaştırma: ${label1} vs ${label2}\n`);
+  console.log(`✅ Ortak: ${commonCount} component`);
+  if (different.length > 0) {
+    different.forEach((file) => {
+      const c = byFile1.get(file);
+      console.log(`🟡 Farklılaşan: ${c.name} (token veya meta farkı)`);
+    });
+  }
+  if (only1.length > 0) {
+    only1.forEach((file) => {
+      const c = byFile1.get(file);
+      const shortBranch = branch1.length > 15 ? branch1.replace(/^[^/]+\//, "").slice(0, 12) : branch1;
+      console.log(`🔴 Sadece ${shortBranch}'ta: ${c.name}`);
+    });
+  }
+  if (only2.length > 0) {
+    only2.forEach((file) => {
+      const c = byFile2.get(file);
+      const shortBranch = branch2.length > 15 ? branch2.replace(/^[^/]+\//, "").slice(0, 12) : branch2;
+      console.log(`🔴 Sadece ${shortBranch}'ta: ${c.name}`);
+    });
+  }
+  console.log("");
+}
+
+const isWatch = process.argv.includes("--watch");
+const isCompare = process.argv.includes("--compare");
+
+if (isCompare) {
+  runCompare();
+} else if (isWatch) {
+  if (!fs.existsSync(COMPONENTS_DIR)) {
+    console.error(CLI_LOCALES[CLI_LOCALE].componentsNotFound);
+    process.exit(1);
+  }
+  let debounceTimer = null;
+  let lastChangedFiles = new Set();
+
+  function runScan() {
+    const files = [...lastChangedFiles];
+    lastChangedFiles.clear();
+    if (files.length) {
+      const rel = path.relative(PROJECT_ROOT, files[0]);
+      if (files.length === 1) {
+        console.log(`[VDS] ${rel}`);
+      } else {
+        console.log(`[VDS] ${files.length} files changed`);
+      }
+    }
+    scan();
+    console.log("[VDS] Watch: src/components (.tsx, .jsx). Scan complete.");
+    const url = vdsDashboardUrl();
+    console.log("[VDS] Dashboard: " + formatClickableLink(url) + "\n");
+  }
+
+  function scheduleScan(filename) {
+    if (!filename || !/\.(tsx|jsx)$/i.test(filename)) return;
+    lastChangedFiles.add(path.join(COMPONENTS_DIR, filename));
+    clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(runScan, 300);
+  }
+
+  console.log("[VDS] Watching src/components for .tsx / .jsx changes…\n");
+  runScan();
+
+  try {
+    const watcher = fs.watch(COMPONENTS_DIR, { recursive: true }, (eventType, filename) => {
+      if (filename) scheduleScan(filename);
+    });
+    process.on("SIGINT", () => {
+      watcher.close();
+      process.exit(0);
+    });
+  } catch (err) {
+    console.error("[VDS] Watch failed:", err.message);
+    process.exit(1);
+  }
+} else {
+  scan();
+}