@ryuenn3123/agentic-senior-core 3.0.50 → 4.0.0

package/lib/cli/detector/design-evidence/structured-attribute-evidence.mjs

@@ -0,0 +1,117 @@
+/**
+ * Structured attribute-aware inspection: counts class attributes, bound class
+ * expressions, JSX/Vue inline styles, and Tailwind utility families seen in the
+ * source. These metrics complement the raw regex pass with a structurally
+ * aware view that better matches modern frontend authorship patterns.
+ */
+
+import {
+  COLOR_PATTERN,
+  CSS_VARIABLE_REFERENCE_PATTERN,
+  EXPRESSION_CLASS_ATTRIBUTE_PATTERN,
+  JSX_INLINE_STYLE_PATTERN,
+  RAW_RADIUS_PATTERN,
+  RAW_SHADOW_PATTERN,
+  RAW_SPACING_PATTERN,
+  STRING_CLASS_ATTRIBUTE_PATTERN,
+  VUE_INLINE_STYLE_PATTERN,
+} from './constants.mjs';
+import {
+  countPatternMatches,
+  getFirstDefinedCapture,
+  incrementCountMap,
+  inferUtilityFamily,
+  normalizeEvidenceSample,
+  pushSampleValue,
+} from './utility-helpers.mjs';
+
+function collectTailwindUtilityFamilies(classValue, utilityFamilyCounts, utilityFamilySamples, utilityFamilySampleSet) {
+  for (const utilityToken of String(classValue || '').split(/\s+/g)) {
+    const utilityFamily = inferUtilityFamily(utilityToken);
+    if (!utilityFamily) {
+      continue;
+    }
+
+    incrementCountMap(utilityFamilyCounts, utilityFamily);
+    pushSampleValue(utilityFamilySamples, utilityFamily, utilityFamilySampleSet);
+  }
+}
+
+function applyInlineStyleInspection(styleSourceText, summary, styleSampleSet) {
+  const normalizedStyleSource = normalizeEvidenceSample(styleSourceText);
+  pushSampleValue(summary.structuredInspection.inlineStyleSamples, normalizedStyleSource, styleSampleSet);
+
+  const hardcodedColorCount = countPatternMatches(styleSourceText, COLOR_PATTERN);
+  const rawSpacingCount = countPatternMatches(styleSourceText, RAW_SPACING_PATTERN);
+  const rawRadiusCount = countPatternMatches(styleSourceText, RAW_RADIUS_PATTERN);
+  const rawShadowCount = countPatternMatches(styleSourceText, RAW_SHADOW_PATTERN);
+  const cssVariableReferenceCount = countPatternMatches(styleSourceText, CSS_VARIABLE_REFERENCE_PATTERN);
+
+  summary.structuredInspection.inlineTokenBypassSignals.hardcodedColorCount += hardcodedColorCount;
+  summary.structuredInspection.inlineTokenBypassSignals.rawSpacingCount += rawSpacingCount;
+  summary.structuredInspection.inlineTokenBypassSignals.rawRadiusCount += rawRadiusCount;
+  summary.structuredInspection.inlineTokenBypassSignals.rawShadowCount += rawShadowCount;
+  summary.structuredInspection.inlineTokenBypassSignals.cssVariableReferenceCount += cssVariableReferenceCount;
+}
+
+export function collectStructuredAttributeEvidence(
+  sourceText,
+  summary,
+  classSampleSet,
+  styleSampleSet,
+  utilityFamilySampleSet,
+) {
+  for (const classAttributeMatch of sourceText.matchAll(STRING_CLASS_ATTRIBUTE_PATTERN)) {
+    const classValue = getFirstDefinedCapture(classAttributeMatch.slice(1));
+    if (!classValue) {
+      continue;
+    }
+
+    summary.structuredInspection.classAttributeCount += 1;
+    pushSampleValue(
+      summary.structuredInspection.classAttributeSamples,
+      normalizeEvidenceSample(classValue),
+      classSampleSet,
+    );
+    collectTailwindUtilityFamilies(
+      classValue,
+      summary.structuredInspection.utilityFamilyCounts,
+      summary.structuredInspection.utilityFamilySamples,
+      utilityFamilySampleSet,
+    );
+  }
+
+  for (const expressionClassAttributeMatch of sourceText.matchAll(EXPRESSION_CLASS_ATTRIBUTE_PATTERN)) {
+    const expressionValue = getFirstDefinedCapture(expressionClassAttributeMatch.slice(1));
+    if (!expressionValue) {
+      continue;
+    }
+
+    summary.structuredInspection.boundClassExpressionCount += 1;
+    pushSampleValue(
+      summary.structuredInspection.classAttributeSamples,
+      normalizeEvidenceSample(expressionValue),
+      classSampleSet,
+    );
+  }
+
+  for (const inlineStyleMatch of sourceText.matchAll(JSX_INLINE_STYLE_PATTERN)) {
+    const inlineStyleSource = getFirstDefinedCapture(inlineStyleMatch.slice(1));
+    if (!inlineStyleSource) {
+      continue;
+    }
+
+    summary.structuredInspection.inlineStyleObjectCount += 1;
+    applyInlineStyleInspection(inlineStyleSource, summary, styleSampleSet);
+  }
+
+  for (const vueInlineStyleMatch of sourceText.matchAll(VUE_INLINE_STYLE_PATTERN)) {
+    const inlineStyleSource = getFirstDefinedCapture(vueInlineStyleMatch.slice(1));
+    if (!inlineStyleSource) {
+      continue;
+    }
+
+    summary.structuredInspection.inlineStyleBindingCount += 1;
+    applyInlineStyleInspection(inlineStyleSource, summary, styleSampleSet);
+  }
+}

package/lib/cli/detector/design-evidence/summary.mjs

@@ -0,0 +1,109 @@
+/**
+ * Default-shaped design evidence summary. Constructed once per scan and then
+ * mutated in place by the collector and inspection passes. Keeping the default
+ * shape in one place makes downstream consumers diff-stable when adding new
+ * counters: add the field here once, and every scan starts with it.
+ */
+
+export function createDesignEvidenceSummary(scanRootRelativePaths) {
+  return {
+    summaryVersion: 'v1',
+    source: 'lightweight-static-scan',
+    scanRootRelativePaths,
+    scannedFileCount: 0,
+    cssVariables: {
+      definitionCount: 0,
+      referenceCount: 0,
+      sampleNames: [],
+      categoryCounts: {
+        color: 0,
+        spacing: 0,
+        radius: 0,
+        shadow: 0,
+        typography: 0,
+        motion: 0,
+        other: 0,
+      },
+    },
+    colors: {
+      hardcodedCount: 0,
+      kindCounts: {
+        hex: 0,
+        rgb: 0,
+        hsl: 0,
+        oklch: 0,
+        other: 0,
+      },
+      sampleValues: [],
+    },
+    spacing: {
+      rawValueCount: 0,
+      sampleValues: [],
+    },
+    radius: {
+      rawValueCount: 0,
+      sampleValues: [],
+    },
+    shadow: {
+      rawValueCount: 0,
+      sampleValues: [],
+    },
+    typography: {
+      fontFamilyCount: 0,
+      fontSizeCount: 0,
+      lineHeightCount: 0,
+      letterSpacingCount: 0,
+      fontFamilySamples: [],
+      fontSizeSamples: [],
+      lineHeightSamples: [],
+      letterSpacingSamples: [],
+    },
+    motion: {
+      transitionCount: 0,
+      animationCount: 0,
+      durationCount: 0,
+      durationSamples: [],
+    },
+    tailwind: {
+      breakpointUsageCount: 0,
+      arbitraryBreakpointCount: 0,
+      utilityFamilyCounts: {},
+      utilityFamilySamples: [],
+    },
+    componentInventory: {
+      componentFileCount: 0,
+      pageFileCount: 0,
+      layoutFileCount: 0,
+      surfaceFileSamples: [],
+    },
+    structuredInspection: {
+      mode: 'attribute-aware-static-scan',
+      classAttributeCount: 0,
+      boundClassExpressionCount: 0,
+      inlineStyleObjectCount: 0,
+      inlineStyleBindingCount: 0,
+      classAttributeSamples: [],
+      inlineStyleSamples: [],
+      utilityFamilyCounts: {},
+      utilityFamilySamples: [],
+      inlineTokenBypassSignals: {
+        hardcodedColorCount: 0,
+        rawSpacingCount: 0,
+        rawRadiusCount: 0,
+        rawShadowCount: 0,
+        cssVariableReferenceCount: 0,
+      },
+    },
+    tokenBypassSignals: {
+      hardcodedColorCount: 0,
+      rawSpacingCount: 0,
+      rawRadiusCount: 0,
+      rawShadowCount: 0,
+      inlineHardcodedColorCount: 0,
+      inlineRawSpacingCount: 0,
+      inlineRawRadiusCount: 0,
+      inlineRawShadowCount: 0,
+      inlineCssVariableReferenceCount: 0,
+    },
+  };
+}

package/lib/cli/detector/design-evidence/utility-helpers.mjs

@@ -0,0 +1,122 @@
+/**
+ * Small pure helpers shared across the static design evidence scan modules.
+ * Kept side-effect free so each can be tested in isolation.
+ */
+
+import { DESIGN_EVIDENCE_SAMPLE_LIMIT } from './constants.mjs';
+
+export function countPatternMatches(sourceText, pattern) {
+  return Array.from(sourceText.matchAll(pattern)).length;
+}
+
+export function pushSampleValue(targetSamples, value, targetSet) {
+  const normalizedValue = String(value || '').trim();
+  if (!normalizedValue || targetSet.has(normalizedValue)) {
+    return;
+  }
+
+  targetSet.add(normalizedValue);
+  if (targetSamples.length < DESIGN_EVIDENCE_SAMPLE_LIMIT) {
+    targetSamples.push(normalizedValue);
+  }
+}
+
+export function incrementCountMap(countMap, key) {
+  countMap[key] = (countMap[key] || 0) + 1;
+}
+
+export function getFirstDefinedCapture(matchGroups) {
+  for (const capturedValue of matchGroups) {
+    if (typeof capturedValue === 'string' && capturedValue.trim().length > 0) {
+      return capturedValue;
+    }
+  }
+
+  return '';
+}
+
+export function normalizeEvidenceSample(rawValue) {
+  return String(rawValue || '').replace(/\s+/g, ' ').trim();
+}
+
+export function categorizeCssVariable(variableName) {
+  const normalizedVariableName = String(variableName || '').trim().toLowerCase();
+
+  if (/(color|surface|accent|bg|text|border|fill|stroke|ink|tone)/.test(normalizedVariableName)) {
+    return 'color';
+  }
+
+  if (/(space|gap|padding|margin|size|width|height|inset)/.test(normalizedVariableName)) {
+    return 'spacing';
+  }
+
+  if (/(radius|rounded|corner)/.test(normalizedVariableName)) {
+    return 'radius';
+  }
+
+  if (/(shadow|elevation)/.test(normalizedVariableName)) {
+    return 'shadow';
+  }
+
+  if (/(font|type|line|letter|tracking|leading)/.test(normalizedVariableName)) {
+    return 'typography';
+  }
+
+  if (/(motion|duration|easing|ease|animation|transition)/.test(normalizedVariableName)) {
+    return 'motion';
+  }
+
+  return 'other';
+}
+
+export function inferColorKind(colorValue) {
+  if (/^#/i.test(colorValue)) {
+    return 'hex';
+  }
+
+  if (/^rgba?\(/i.test(colorValue)) {
+    return 'rgb';
+  }
+
+  if (/^hsla?\(/i.test(colorValue)) {
+    return 'hsl';
+  }
+
+  if (/^oklch\(/i.test(colorValue)) {
+    return 'oklch';
+  }
+
+  return 'other';
+}
+
+export function inferUtilityFamily(rawUtilityToken) {
+  const normalizedUtilityToken = String(rawUtilityToken || '')
+    .trim()
+    .split(':')
+    .pop()
+    ?.replace(/^!/, '')
+    ?.replace(/\/.+$/, '')
+    ?.trim();
+
+  if (!normalizedUtilityToken) {
+    return '';
+  }
+
+  if (/^grid(?:-|$)/.test(normalizedUtilityToken)) {
+    return 'grid';
+  }
+
+  if (/^flex(?:-|$)/.test(normalizedUtilityToken)) {
+    return 'flex';
+  }
+
+  if (/^(?:block|inline|hidden|contents)$/.test(normalizedUtilityToken)) {
+    return normalizedUtilityToken;
+  }
+
+  if (/^(?:min|max)-\[/.test(normalizedUtilityToken)) {
+    return 'arbitrary-breakpoint';
+  }
+
+  return normalizedUtilityToken.split('-')[0];
+}