@sebgroup/green-core 2.37.2 → 2.37.4

package/bin/context-cli/migrate/types.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Types for the Green Design System migration engine.
+ *
+ * Migration units are versioned, self-contained modules that detect and
+ * optionally fix breaking changes in consumer codebases. Each unit targets
+ * a specific major version upgrade and encapsulates:
+ * - Detection logic (regex-based, zero external dependencies)
+ * - Transformation logic (string replacement or manual-review flagging)
+ *
+ * ## Directory layout
+ *
+ * Units are organized by major version in the file system:
+ *
+ *     units/
+ *       3/
+ *         remove-dropdown-value-generic.ts
+ *         rename-datepicker-slot.ts
+ *       4/
+ *         some-future-migration.ts
+ *
+ * The major version is derived from the directory name — not from a field
+ * on the unit itself. Units that should not appear in listings or be run
+ * can set `enabled: false`.
+ *
+ * @module migrate/types
+ */
+/**
+ * A single match found by a migration unit's detect function.
+ */
+export interface MigrationMatch {
+    /** File path (made relative by the engine after detect returns) */
+    file: string;
+    /** 1-based line number where the match was found */
+    line: number;
+    /** The matched text snippet (the relevant line fragment) */
+    match: string;
+    /** Human-readable description of what needs to change */
+    message: string;
+    /**
+     * If true, this match cannot be auto-fixed and requires manual
+     * intervention. The engine will report it separately.
+     */
+    manualReview?: boolean;
+}
+/**
+ * Aggregated result from running a single migration unit across a project.
+ */
+export interface MigrationResult {
+    /** The migration unit ID */
+    unitId: string;
+    /** Short summary of the migration */
+    summary: string;
+    /** Number of files scanned */
+    filesScanned: number;
+    /** All matches found */
+    matches: MigrationMatch[];
+    /** Number of files that were modified (0 in detect-only mode) */
+    filesModified: number;
+    /** Matches that require manual review (subset of matches) */
+    manualReview: MigrationMatch[];
+}
+/**
+ * A migration unit describes a single automated migration step.
+ *
+ * ## Creating a new unit
+ *
+ * 1. Create a new file under `migrate/units/<major>/`
+ *    (e.g. `units/3/remove-dropdown-value-generic.ts`)
+ * 2. Export a `MigrationUnit` object named `unit`
+ * 3. The registry auto-discovers it from the directory structure
+ *
+ * See `migrate/units/0/example.ts` for a documented template.
+ */
+export interface MigrationUnit {
+    /**
+     * Unique identifier (kebab-case slug).
+     * Example: `remove-dropdown-value-generic`
+     */
+    id: string;
+    /**
+     * Whether this unit should be listed and available for execution.
+     * Set to `false` for drafts, examples, or temporarily disabled units.
+     */
+    enabled: boolean;
+    /** Short human-readable summary (one line) */
+    summary: string;
+    /**
+     * Code example showing the pattern **before** the migration is applied.
+     * Primarily serves as context for coding models applying changes manually.
+     */
+    exampleBefore: string;
+    /**
+     * Code example showing the expected result **after** migration.
+     * Primarily serves as context for coding models applying changes manually.
+     */
+    exampleAfter: string;
+    /**
+     * File extensions to scan, including the leading dot.
+     * Example: `['.ts', '.tsx', '.html']`
+     */
+    fileExtensions: string[];
+    /**
+     * Whether this migration is safe to auto-apply without manual review.
+     * When `true`, `apply()` is guaranteed to produce correct output for
+     * every match that `detect()` finds. When `false`, some matches may
+     * require manual intervention.
+     */
+    safe: boolean;
+    /**
+     * Detect occurrences of the deprecated pattern in a file.
+     *
+     * @param filePath - Absolute path to the file being scanned
+     * @param content  - The file's full text content (UTF-8)
+     * @returns Array of matches found in the file (may be empty)
+     */
+    detect(filePath: string, content: string): MigrationMatch[];
+    /**
+     * Apply the migration transformation to a file's content.
+     *
+     * @param filePath - Absolute path to the file being transformed
+     * @param content  - The file's full text content (UTF-8)
+     * @returns The transformed content, or `null` if no changes were made
+     */
+    apply(filePath: string, content: string): string | null;
+}
+/**
+ * A migration unit enriched with metadata derived from the directory
+ * structure during auto-discovery. Returned by the registry.
+ */
+export interface ResolvedMigrationUnit {
+    /** Major version, derived from the `units/<major>/` directory name */
+    major: number;
+    /** The migration unit definition */
+    unit: MigrationUnit;
+}

package/bin/context-cli/migrate/units/0/example.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Example migration unit — template for creating new units.
+ *
+ * This file is a documented reference for how to build a migration unit.
+ * It has `enabled: false`, so it will not appear in `green-core-context
+ * migrate list` or be executed during `migrate run`.
+ *
+ * ## How to create a new migration unit
+ *
+ * 1. Create a file under `units/<major>/` (e.g. `units/3/my-migration.ts`)
+ * 2. Export a `MigrationUnit` object as `export const unit`
+ * 3. The registry auto-discovers it from the directory structure — no
+ *    manual registration needed
+ *
+ * ## Multi-framework / multi-syntax coverage
+ *
+ * A single migration unit should cover ONE semantic change across ALL
+ * syntax variants. We cannot determine framework from file extension —
+ * an Angular template may live inside a `.ts` file, plain HTML may live
+ * in a `.html` file that is not Angular, and React JSX uses `.tsx`.
+ *
+ * Instead, define variant patterns for every known syntax form of the
+ * same attribute/property rename:
+ *
+ *   - HTML attribute:         `gds-theme="dark"`
+ *   - Angular property:       `[gdsTheme]="expr"`
+ *   - Angular attr binding:   `[attr.gds-theme]="expr"`
+ *   - React JSX prop:         `gdsTheme="dark"` or `gdsTheme={expr}`
+ *   - JS property assignment: `.gdsTheme = value`
+ *   - JS setAttribute call:   `setAttribute('gds-theme', value)`
+ *
+ * All patterns are applied to ALL files. This means the unit will find
+ * Angular bindings in a `.tsx` file too — that is intentional and harmless.
+ * False positives are better than missed migrations.
+ *
+ * ## Guidelines
+ *
+ * - Keep regex patterns simple and well-commented
+ * - Use non-capturing groups `(?:...)` unless capture is needed
+ * - Reset `lastIndex` before reusing a regex with the `g` flag
+ * - In `detect()`, always set `file` to `filePath` — the engine
+ *   normalises it to a relative path afterwards
+ * - In `apply()`, return `null` if nothing changed
+ * - Mark matches as `manualReview: true` when auto-fix isn't safe
+ * - Prefer line-by-line scanning for readable detect logic
+ * - Always provide `exampleBefore` / `exampleAfter` — they are used by
+ *   coding models as context when applying changes manually
+ *
+ * @module migrate/units/0/example
+ */
+import type { MigrationUnit } from '../../types.js';
+export declare const unit: MigrationUnit;

package/bin/context-cli/migrate/units/0/example.js

@@ -0,0 +1,147 @@
+import "../../../../../chunks/chunk.CAV4X6PU.js";
+const VARIANTS = [
+  // ----- HTML attribute (plain HTML, web component, Angular template) -----
+  {
+    label: "HTML attribute",
+    pattern: /\bgds-theme\s*=\s*["']([^"']*)["']/g,
+    replace: (_match, value) => `gds-mode="${value}"`,
+    message: (m) => `Replace gds-theme="${m[1]}" with gds-mode="${m[1]}"`,
+    safe: true
+  },
+  // ----- Angular property binding: [gdsTheme]="expr" -----
+  {
+    label: "Angular property binding",
+    pattern: /\[gdsTheme\]\s*=\s*"([^"]*)"/g,
+    replace: (_match, expr) => `[gdsMode]="${expr}"`,
+    message: (m) => `Replace [gdsTheme]="${m[1]}" with [gdsMode]="${m[1]}"`,
+    safe: true
+  },
+  // ----- Angular explicit attr binding: [attr.gds-theme]="expr" -----
+  {
+    label: "Angular attr binding",
+    pattern: /\[attr\.gds-theme\]\s*=\s*"([^"]*)"/g,
+    replace: (_match, expr) => `[attr.gds-mode]="${expr}"`,
+    message: (m) => `Replace [attr.gds-theme]="${m[1]}" with [attr.gds-mode]="${m[1]}"`,
+    safe: true
+  },
+  // ----- React JSX prop: gdsTheme="value" or gdsTheme={expr} -----
+  // Negative lookbehind (?<!\.) excludes JS property access like el.gdsTheme
+  {
+    label: "React JSX prop (string)",
+    pattern: /(?<!\.)\bgdsTheme\s*=\s*"([^"]*)"/g,
+    replace: (_match, value) => `gdsMode="${value}"`,
+    message: (m) => `Replace gdsTheme="${m[1]}" with gdsMode="${m[1]}"`,
+    safe: true
+  },
+  {
+    label: "React JSX prop (expression)",
+    pattern: /(?<!\.)\bgdsTheme\s*=\s*\{([^}]*)\}/g,
+    replace: (_match, expr) => `gdsMode={${expr}}`,
+    message: (m) => `Replace gdsTheme={${m[1]}} with gdsMode={${m[1]}}`,
+    safe: true
+  },
+  // ----- JS/TS property assignment: .gdsTheme = value -----
+  {
+    label: "JS property assignment",
+    pattern: /\.gdsTheme\s*=/g,
+    replace: ".gdsMode =",
+    message: () => `Replace .gdsTheme = with .gdsMode =`,
+    safe: true
+  },
+  // ----- JS/TS setAttribute call: setAttribute('gds-theme', ...) -----
+  {
+    label: "setAttribute call",
+    pattern: /setAttribute\(\s*['"]gds-theme['"]/g,
+    replace: `setAttribute('gds-mode'`,
+    message: () => `Replace setAttribute('gds-theme', ...) with setAttribute('gds-mode', ...)`,
+    safe: true
+  }
+];
+function detectVariants(filePath, content, variants) {
+  const matches = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const variant of variants) {
+      variant.pattern.lastIndex = 0;
+      let m;
+      while ((m = variant.pattern.exec(line)) !== null) {
+        matches.push({
+          file: filePath,
+          line: i + 1,
+          match: m[0],
+          message: variant.message(m),
+          manualReview: !variant.safe
+        });
+      }
+    }
+  }
+  return matches;
+}
+function applyVariants(content, variants) {
+  let result = content;
+  for (const variant of variants) {
+    if (!variant.safe)
+      continue;
+    variant.pattern.lastIndex = 0;
+    result = result.replace(variant.pattern, variant.replace);
+  }
+  return result !== content ? result : null;
+}
+const unit = {
+  id: "theme-to-mode",
+  enabled: false,
+  // Example only — not a real migration
+  summary: "[Example] Replace deprecated gds-theme / gdsTheme with gds-mode / gdsMode",
+  exampleBefore: [
+    "<!-- HTML attribute -->",
+    '<div gds-theme="dark"><gds-button>Click</gds-button></div>',
+    "",
+    "<!-- Angular property binding -->",
+    '<gds-card [gdsTheme]="theme"></gds-card>',
+    "",
+    "<!-- Angular explicit attr binding -->",
+    '<gds-card [attr.gds-theme]="theme"></gds-card>',
+    "",
+    "<!-- React JSX prop -->",
+    '<GdsCard gdsTheme="dark" />',
+    "<GdsCard gdsTheme={theme} />",
+    "",
+    "// JS property assignment",
+    'el.gdsTheme = "dark"',
+    "",
+    "// JS setAttribute",
+    "el.setAttribute('gds-theme', 'dark')"
+  ].join("\n"),
+  exampleAfter: [
+    "<!-- HTML attribute -->",
+    '<div gds-mode="dark"><gds-button>Click</gds-button></div>',
+    "",
+    "<!-- Angular property binding -->",
+    '<gds-card [gdsMode]="theme"></gds-card>',
+    "",
+    "<!-- Angular explicit attr binding -->",
+    '<gds-card [attr.gds-mode]="theme"></gds-card>',
+    "",
+    "<!-- React JSX prop -->",
+    '<GdsCard gdsMode="dark" />',
+    "<GdsCard gdsMode={theme} />",
+    "",
+    "// JS property assignment",
+    'el.gdsMode = "dark"',
+    "",
+    "// JS setAttribute",
+    "el.setAttribute('gds-mode', 'dark')"
+  ].join("\n"),
+  fileExtensions: [".html", ".ts", ".tsx"],
+  safe: true,
+  detect(filePath, content) {
+    return detectVariants(filePath, content, VARIANTS);
+  },
+  apply(_filePath, content) {
+    return applyVariants(content, VARIANTS);
+  }
+};
+export {
+  unit
+};

package/bin/context-cli/parse-args.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk.QU3DSPNU.js";
+import "../../chunks/chunk.CAV4X6PU.js";
 function parseArgs(argv) {
   const positional = [];
   const flags = {};

package/bin/mcp-server/constants.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk.QU3DSPNU.js";
+import "../../chunks/chunk.CAV4X6PU.js";
 const SERVER_CONFIG = {
   /** Server name used in MCP protocol */
   SERVER_NAME: "green-design-system",

package/bin/mcp-server/errors.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk.QU3DSPNU.js";
+import "../../chunks/chunk.CAV4X6PU.js";
 var McpErrorCode = /* @__PURE__ */ ((McpErrorCode2) => {
   McpErrorCode2["INVALID_INPUT"] = "INVALID_INPUT";
   McpErrorCode2["NOT_FOUND"] = "NOT_FOUND";

package/bin/mcp-server/handlers.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk.QU3DSPNU.js";
+import "../../chunks/chunk.CAV4X6PU.js";
 import { capitalize } from "../../utils/helpers/casing.js";
 import { DOC_TYPES, PATHS, SEARCH_CONFIG, URI_SCHEME } from "./constants.js";
 import { NotFoundError } from "./errors.js";

package/bin/mcp-server/resources.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk.QU3DSPNU.js";
+import "../../chunks/chunk.CAV4X6PU.js";
 import {
   ListResourcesRequestSchema,
   ReadResourceRequestSchema

package/bin/mcp-server/search.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk.QU3DSPNU.js";
+import "../../chunks/chunk.CAV4X6PU.js";
 import { SEARCH_CONFIG, SEARCH_TIERS } from "./constants.js";
 import { RegexError } from "./errors.js";
 function compileRegexPattern(pattern) {
@@ -132,7 +132,8 @@ function performSearch(components, icons, query, searchTerms, regexPattern, matc
     }
   }
   results.sort((a, b) => {
-    if (a.tier !== b.tier) return a.tier - b.tier;
+    if (a.tier !== b.tier)
+      return a.tier - b.tier;
     if (splitTerms && a.matchedTerms !== b.matchedTerms) {
       return b.matchedTerms - a.matchedTerms;
     }

package/bin/mcp-server/tools.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk.QU3DSPNU.js";
+import "../../chunks/chunk.CAV4X6PU.js";
 import {
   CallToolRequestSchema,
   ListToolsRequestSchema

package/bin/mcp-server/utils.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk.QU3DSPNU.js";
+import "../../chunks/chunk.CAV4X6PU.js";
 import { promises as fs } from "fs";
 import * as path from "node:path";
 import { fileURLToPath } from "url";
@@ -80,10 +80,12 @@ function normalizeComponentName(name) {
 function findComponent(name, components) {
   const normalized = normalizeComponentName(name);
   let found = components.find((c) => c.tagName === normalized);
-  if (found) return found;
+  if (found)
+    return found;
   const withoutPrefix = name.replace(/^gds-/, "");
   found = components.find((c) => c.tagName === `gds-${withoutPrefix}`);
-  if (found) return found;
+  if (found)
+    return found;
   const lowerName = name.toLowerCase();
   found = components.find(
     (c) => c.tagName.toLowerCase().includes(lowerName) || c.name.toLowerCase().includes(lowerName)
@@ -93,10 +95,12 @@ function findComponent(name, components) {
 function findIcon(name, icons) {
   const normalized = normalizeComponentName(name);
   let found = icons.find((i) => i.tagName === normalized);
-  if (found) return found;
+  if (found)
+    return found;
   const withoutPrefix = name.replace(/^gds-/, "").replace(/^icon-/, "");
   found = icons.find((i) => i.tagName === `gds-icon-${withoutPrefix}`);
-  if (found) return found;
+  if (found)
+    return found;
   const lowerName = name.toLowerCase();
   found = icons.find(
     (i) => i.tagName.toLowerCase().includes(lowerName) || i.name.toLowerCase().includes(lowerName)
@@ -131,7 +135,8 @@ function buildResourceUri(category, name, docType) {
 }
 function parseResourceUri(uri) {
   const match = uri.match(/^green:\/\/([^/]+)\/([^/]+)(?:\/([^/]+))?$/);
-  if (!match) return null;
+  if (!match)
+    return null;
   const [, category, name, docType] = match;
   return { category, name, docType };
 }

package/bin/mcp-server/validation.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk.QU3DSPNU.js";
+import "../../chunks/chunk.CAV4X6PU.js";
 import { CATEGORIES, FRAMEWORKS, GUIDE_CATEGORIES } from "./constants.js";
 import { ValidationError } from "./errors.js";
 function validateEnum(value, allowed, fieldName) {

package/chunks/chunk.CAV4X6PU.js

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+
+export {
+  __decorateClass,
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateMethod
+};