@devstroupe/devkit-cli 1.0.0

package/dist/templates/ui/spartan/hlm-core.template.js

@@ -0,0 +1,322 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devkitHlmCoreTemplate = devkitHlmCoreTemplate;
+function devkitHlmCoreTemplate() {
+    return {
+        ts: `import { isPlatformBrowser } from '@angular/common';
+import {
+  DestroyRef,
+  effect,
+  ElementRef,
+  HostAttributeToken,
+  inject,
+  Injector,
+  PLATFORM_ID,
+  runInInjectionContext,
+} from '@angular/core';
+import { type ClassValue, clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+export function hlm(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+
+// Global map to track class managers per element
+const elementClassManagers = new WeakMap<HTMLElement, ElementClassManager>();
+// Global mutation observer for all elements
+let globalObserver: MutationObserver | null = null;
+const observedElements = new Set<HTMLElement>();
+
+interface ElementClassManager {
+  element: HTMLElement;
+  sources: Map<number, { classes: Set<string>; order: number }>;
+  baseClasses: Set<string>;
+  isUpdating: boolean;
+  nextOrder: number;
+  hasInitialized: boolean;
+  restoreRafId: number | null;
+  /** Transitions are suppressed until the first effect writes correct classes */
+  transitionsSuppressed: boolean;
+  /** Original inline transition value to restore after suppression (empty string = none was set) */
+  previousTransition: string;
+  /** Original inline transition priority to preserve !important when restoring */
+  previousTransitionPriority: string;
+}
+
+let sourceCounter = 0;
+
+/**
+ * This function dynamically adds and removes classes for a given element without requiring
+ * the a class binding (e.g. \`[class]="..."\`) which may interfere with other class bindings.
+ *
+ * 1. This will merge the existing classes on the element with the new classes.
+ * 2. It will also remove any classes that were previously added by this function but are no longer present in the new classes.
+ * 3. Multiple calls to this function on the same element will be merged efficiently.
+ */
+export function classes(computed: () => ClassValue[] | string, options: ClassesOptions = {}) {
+  runInInjectionContext(options.injector ?? inject(Injector), () => {
+    const elementRef = options.elementRef ?? inject(ElementRef);
+    const platformId = inject(PLATFORM_ID);
+    const destroyRef = inject(DestroyRef);
+    const baseClasses = inject(new HostAttributeToken('class'), { optional: true });
+
+    const element = elementRef.nativeElement;
+
+    // Create unique identifier for this source
+    const sourceId = sourceCounter++;
+
+    // Get or create the class manager for this element
+    let manager = elementClassManagers.get(element);
+
+    if (!manager) {
+      // Initialize base classes from variation (host attribute 'class')
+      const initialBaseClasses = new Set<string>();
+
+      if (baseClasses) {
+        toClassList(baseClasses).forEach((cls) => initialBaseClasses.add(cls));
+      }
+
+      manager = {
+        element,
+        sources: new Map(),
+        baseClasses: initialBaseClasses,
+        isUpdating: false,
+        nextOrder: 0,
+        hasInitialized: false,
+        restoreRafId: null,
+        transitionsSuppressed: false,
+        previousTransition: '',
+        previousTransitionPriority: '',
+      };
+      elementClassManagers.set(element, manager);
+
+      // Setup global observer if needed and register this element
+      setupGlobalObserver(platformId);
+      observedElements.add(element);
+
+      // Suppress transitions until the first effect writes correct classes and
+      // the browser has painted them. This prevents CSS transition animations
+      // during hydration when classes change from SSR state to client state.
+      if (isPlatformBrowser(platformId)) {
+        manager.previousTransition = element.style.getPropertyValue('transition');
+        manager.previousTransitionPriority = element.style.getPropertyPriority('transition');
+        element.style.setProperty('transition', 'none', 'important');
+        manager.transitionsSuppressed = true;
+      }
+    }
+
+    // Assign order once at registration time
+    const sourceOrder = manager.nextOrder++;
+
+    function updateClasses(): void {
+      // Get the new classes from the computed function
+      const newClasses = toClassList(computed());
+
+      // Update this source's classes, keeping the original order
+      manager!.sources.set(sourceId, {
+        classes: new Set(newClasses),
+        order: sourceOrder,
+      });
+
+      // Update the element
+      updateElement(manager!);
+
+      // Re-enable transitions after the first effect writes correct classes.
+      // Deferred to next animation frame so the browser paints the class change
+      // with transitions disabled first, then re-enables them.
+      if (manager!.transitionsSuppressed) {
+        manager!.transitionsSuppressed = false;
+        manager!.restoreRafId = requestAnimationFrame(() => {
+          manager!.restoreRafId = null;
+          restoreTransitionSuppression(manager!);
+        });
+      }
+    }
+
+    // Register cleanup with DestroyRef
+    destroyRef.onDestroy(() => {
+      if (manager!.restoreRafId !== null) {
+        cancelAnimationFrame(manager!.restoreRafId);
+        manager!.restoreRafId = null;
+      }
+
+      if (manager!.transitionsSuppressed) {
+        manager!.transitionsSuppressed = false;
+        restoreTransitionSuppression(manager!);
+      }
+
+      // Remove this source from the manager
+      manager!.sources.delete(sourceId);
+
+      // If no more sources, clean up the manager
+      if (manager!.sources.size === 0) {
+        cleanupManager(element);
+      } else {
+        // Update element without this source's classes
+        updateElement(manager!);
+      }
+    });
+
+    /**
+     * We need this effect to track changes to the computed classes. Ideally, we would use
+     * afterRenderEffect here, but that doesn't run in SSR contexts, so we use a standard
+     * effect which works in both browser and SSR.
+     */
+    effect(updateClasses);
+  });
+}
+
+function restoreTransitionSuppression(manager: ElementClassManager): void {
+  const prev = manager.previousTransition;
+  if (prev) {
+    manager.element.style.setProperty(
+      'transition',
+      prev,
+      manager.previousTransitionPriority || undefined,
+    );
+  } else {
+    manager.element.style.removeProperty('transition');
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-wrapper-object-types
+function setupGlobalObserver(platformId: Object): void {
+  if (isPlatformBrowser(platformId) && !globalObserver) {
+    // Create single global observer that watches the entire document
+    globalObserver = new MutationObserver((mutations) => {
+      for (const mutation of mutations) {
+        if (mutation.type === 'attributes' && mutation.attributeName === 'class') {
+          const element = mutation.target as HTMLElement;
+          const manager = elementClassManagers.get(element);
+
+          // Only process elements we're managing
+          if (manager && observedElements.has(element)) {
+            if (manager.isUpdating) continue; // Ignore changes we're making
+
+            // Update base classes to include any externally added classes
+            const currentClasses = toClassList(element.className);
+            const allSourceClasses = new Set<string>();
+
+            // Collect all classes from all sources
+            for (const source of manager.sources.values()) {
+              for (const className of source.classes) {
+                allSourceClasses.add(className);
+              }
+            }
+
+            // Any classes not from sources become new base classes
+            manager.baseClasses.clear();
+
+            for (const className of currentClasses) {
+              if (!allSourceClasses.has(className)) {
+                manager.baseClasses.add(className);
+              }
+            }
+
+            updateElement(manager);
+          }
+        }
+      }
+    });
+
+    // Start observing the entire document for class attribute changes
+    globalObserver.observe(document, {
+      attributes: true,
+      attributeFilter: ['class'],
+      subtree: true, // Watch all descendants
+    });
+  }
+}
+
+function updateElement(manager: ElementClassManager): void {
+  if (manager.isUpdating) return; // Prevent recursive updates
+
+  manager.isUpdating = true;
+
+  // Handle initialization: capture base classes after first source registration
+  if (!manager.hasInitialized && manager.sources.size > 0) {
+    // Get current classes on element (may include SSR classes)
+    const currentClasses = toClassList(manager.element.className);
+
+    // Get all classes that will be applied by sources
+    const allSourceClasses = new Set<string>();
+    for (const source of manager.sources.values()) {
+      source.classes.forEach((className) => allSourceClasses.add(className));
+    }
+
+    // Only consider classes as "base" if they're not produced by any source
+    // This prevents SSR-rendered classes from being preserved as base classes
+    currentClasses.forEach((className) => {
+      if (!allSourceClasses.has(className)) {
+        manager.baseClasses.add(className);
+      }
+    });
+
+    manager.hasInitialized = true;
+  }
+
+  // Get classes from all sources, sorted by registration order (later takes precedence)
+  const sortedSources = Array.from(manager.sources.entries()).sort(
+    ([, a], [, b]) => a.order - b.order,
+  );
+
+  const allSourceClasses: string[] = [];
+  for (const [, source] of sortedSources) {
+    allSourceClasses.push(...source.classes);
+  }
+
+  // Combine base classes with all source classes, ensuring base classes take precedence
+  const classesToApply =
+    allSourceClasses.length > 0 || manager.baseClasses.size > 0
+      ? hlm([...allSourceClasses, ...manager.baseClasses])
+      : '';
+
+  // Apply the classes to the element
+  if (manager.element.className !== classesToApply) {
+    manager.element.className = classesToApply;
+  }
+
+  manager.isUpdating = false;
+}
+
+function cleanupManager(element: HTMLElement): void {
+  // Remove from global tracking
+  observedElements.delete(element);
+  elementClassManagers.delete(element);
+
+  // If no more elements being tracked, cleanup global observer
+  if (observedElements.size === 0 && globalObserver) {
+    globalObserver.disconnect();
+    globalObserver = null;
+  }
+}
+
+interface ClassesOptions {
+  elementRef?: ElementRef<HTMLElement>;
+  injector?: Injector;
+}
+
+// Cache for parsed class lists to avoid repeated string operations
+const classListCache = new Map<string, string[]>();
+
+function toClassList(className: string | ClassValue[]): string[] {
+  // For simple string inputs, use cache to avoid repeated parsing
+  if (typeof className === 'string' && classListCache.has(className)) {
+    return classListCache.get(className)!;
+  }
+
+  const result = clsx(className)
+    .split(' ')
+    .filter((c) => c.length > 0);
+
+  // Cache string results, but limit cache size to prevent memory growth
+  if (typeof className === 'string' && classListCache.size < 1000) {
+    classListCache.set(className, result);
+  }
+
+  return result;
+}
+`
+    };
+}
+// 16. Template da diretiva hlmBtn do Spartan local (hlm-button.ts oficial do Spartan v1.0.4)

package/dist/templates/ui/spartan/index.d.ts

@@ -0,0 +1,5 @@
+export * from './hlm-core.template';
+export * from './button-directive.template';
+export * from './button-token.template';
+export * from './input-directive.template';
+export * from './badge-directive.template';

package/dist/templates/ui/spartan/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hlm-core.template"), exports);
+__exportStar(require("./button-directive.template"), exports);
+__exportStar(require("./button-token.template"), exports);
+__exportStar(require("./input-directive.template"), exports);
+__exportStar(require("./badge-directive.template"), exports);

package/dist/templates/ui/spartan/input-directive.template.d.ts

@@ -0,0 +1,3 @@
+export declare function devkitHlmInputDirectiveTemplate(): {
+    ts: string;
+};

package/dist/templates/ui/spartan/input-directive.template.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devkitHlmInputDirectiveTemplate = devkitHlmInputDirectiveTemplate;
+function devkitHlmInputDirectiveTemplate() {
+    return {
+        ts: `import { Directive } from '@angular/core';
+import { BrnFieldControlDescribedBy } from '@spartan-ng/brain/field';
+import { BrnInput } from '@spartan-ng/brain/input';
+import { classes } from '@spartan-ng/helm/utils';
+
+@Directive({
+  selector: '[hlmInput]',
+  hostDirectives: [
+    { directive: BrnInput, inputs: ['id', 'forceInvalid'] },
+    BrnFieldControlDescribedBy,
+  ],
+  host: { 'data-slot': 'input' },
+  standalone: true,
+})
+export class HlmInput {
+  constructor() {
+    classes(
+      () =>
+        'dark:bg-input/30 border-input focus-visible:border-ring focus-visible:ring-ring/50 data-[matches-spartan-invalid=true]:ring-destructive/20 dark:data-[matches-spartan-invalid=true]:ring-destructive/40 data-[matches-spartan-invalid=true]:border-destructive dark:data-[matches-spartan-invalid=true]:border-destructive/50 disabled:bg-input/50 dark:disabled:bg-input/80 h-8 rounded-lg border bg-transparent px-2.5 py-1 text-base transition-colors file:h-6 file:text-sm file:font-medium focus-visible:ring-3 data-[matches-spartan-invalid=true]:ring-3 md:text-sm file:text-foreground placeholder:text-muted-foreground w-full min-w-0 outline-none file:inline-flex file:border-0 file:bg-transparent disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50',
+    );
+  }
+}
+`
+    };
+}
+// 18. Template da diretiva hlmBadge do Spartan local (hlm-badge.ts oficial)

package/dist/templates/ui/theme-css.template.d.ts

@@ -0,0 +1,7 @@
+export declare function devkitThemeCssTemplate(config: {
+    preset?: 'nova' | 'vega' | 'lyra' | 'maia' | 'mira' | 'luma' | 'custom';
+    theme?: 'violet' | 'zinc' | 'slate' | 'orange' | 'rose' | 'custom';
+    primaryColor?: string;
+    secondaryColor?: string;
+    fontFamily?: string;
+}): string;

package/dist/templates/ui/theme-css.template.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devkitThemeCssTemplate = devkitThemeCssTemplate;
+const colors_1 = require("./shared/colors");
+function devkitThemeCssTemplate(config) {
+    const theme = config.theme || 'custom';
+    const fontFamily = config.fontFamily || "'Inter', sans-serif";
+    // Mapeamento de cores dos temas padrão do Shadcn/Spartan
+    const themeColors = {
+        violet: {
+            light: {
+                primary: '262.1 83.3% 57.8%',
+                primaryForeground: '0 0% 98%',
+                secondary: '240 4.8% 95.9%',
+                secondaryForeground: '240 5.9% 10%',
+                ring: '262.1 83.3% 57.8%',
+                border: '240 5.9% 90%',
+                input: '240 5.9% 90%'
+            },
+            dark: {
+                primary: '263.4 70% 50.4%',
+                primaryForeground: '210 20% 98%',
+                secondary: '240 3.7% 15.9%',
+                secondaryForeground: '0 0% 98%',
+                ring: '263.4 70% 50.4%',
+                border: '240 3.7% 15.9%',
+                input: '240 3.7% 15.9%'
+            }
+        },
+        zinc: {
+            light: {
+                primary: '240 5.9% 10%',
+                primaryForeground: '0 0% 98%',
+                secondary: '240 4.8% 95.9%',
+                secondaryForeground: '240 5.9% 10%',
+                ring: '240 5.9% 10%',
+                border: '240 5.9% 90%',
+                input: '240 5.9% 90%'
+            },
+            dark: {
+                primary: '0 0% 98%',
+                primaryForeground: '240 5.9% 10%',
+                secondary: '240 3.7% 15.9%',
+                secondaryForeground: '0 0% 98%',
+                ring: '240 4.9% 83.9%',
+                border: '240 3.7% 15.9%',
+                input: '240 3.7% 15.9%'
+            }
+        },
+        slate: {
+            light: {
+                primary: '222.2 47.4% 11.2%',
+                primaryForeground: '210 40% 98%',
+                secondary: '210 40% 96.1%',
+                secondaryForeground: '222.2 47.4% 11.2%',
+                ring: '222.2 84% 4.9%',
+                border: '214.3 31.8% 91.4%',
+                input: '214.3 31.8% 91.4%'
+            },
+            dark: {
+                primary: '210 40% 98%',
+                primaryForeground: '222.2 47.4% 11.2%',
+                secondary: '217.2 32.6% 17.5%',
+                secondaryForeground: '210 40% 98%',
+                ring: '217.2 91.2% 59.8%',
+                border: '217.2 32.6% 17.5%',
+                input: '217.2 32.6% 17.5%'
+            }
+        },
+        orange: {
+            light: {
+                primary: '24.6 95% 53.1%',
+                primaryForeground: '0 0% 98%',
+                secondary: '240 4.8% 95.9%',
+                secondaryForeground: '240 5.9% 10%',
+                ring: '24.6 95% 53.1%',
+                border: '240 5.9% 90%',
+                input: '240 5.9% 90%'
+            },
+            dark: {
+                primary: '20.5 90.2% 48.2%',
+                primaryForeground: '60 9.1% 97.8%',
+                secondary: '240 3.7% 15.9%',
+                secondaryForeground: '0 0% 98%',
+                ring: '20.5 90.2% 48.2%',
+                border: '240 3.7% 15.9%',
+                input: '240 3.7% 15.9%'
+            }
+        },
+        rose: {
+            light: {
+                primary: '346.8 77.2% 49.8%',
+                primaryForeground: '355.7 100% 97.3%',
+                secondary: '240 4.8% 95.9%',
+                secondaryForeground: '240 5.9% 10%',
+                ring: '346.8 77.2% 49.8%',
+                border: '240 5.9% 90%',
+                input: '240 5.9% 90%'
+            },
+            dark: {
+                primary: '346.8 77.2% 49.8%',
+                primaryForeground: '355.7 100% 97.3%',
+                secondary: '240 3.7% 15.9%',
+                secondaryForeground: '0 0% 98%',
+                ring: '346.8 77.2% 49.8%',
+                border: '240 3.7% 15.9%',
+                input: '240 3.7% 15.9%'
+            }
+        }
+    };
+    // Cores personalizadas / fallback
+    const primaryHex = config.primaryColor || '#7136ff';
+    const secondaryHex = config.secondaryColor || '#ff6633';
+    const primaryHsl = (0, colors_1.hexToHsl)(primaryHex);
+    const secondaryHsl = (0, colors_1.hexToHsl)(secondaryHex);
+    const customColors = {
+        light: {
+            primary: primaryHsl,
+            primaryForeground: '0 0% 98%',
+            secondary: secondaryHsl,
+            secondaryForeground: '240 5.9% 10%',
+            ring: primaryHsl,
+            border: '240 5.9% 90%',
+            input: '240 5.9% 90%'
+        },
+        dark: {
+            primary: primaryHsl,
+            primaryForeground: '240 5.9% 10%',
+            secondary: '240 3.7% 15.9%',
+            secondaryForeground: '0 0% 98%',
+            ring: primaryHsl,
+            border: '240 3.7% 15.9%',
+            input: '240 3.7% 15.9%'
+        }
+    };
+    const selectedTheme = (theme !== 'custom' && themeColors[theme]) ? themeColors[theme] : customColors;
+    return `/* Tema do DevKit.
+   O style visual dos primitives vem do Helm gerado pelo Spartan CLI em libs/ui. */
+
+:root {
+  color-scheme: light;
+
+  --font-family: ${fontFamily};
+
+  /* Variáveis Spartan / Shadcn UI - Tema Light */
+  --background: hsl(0 0% 98%);
+  --foreground: hsl(240 10% 3.9%);
+  --card: hsl(0 0% 100%);
+  --card-foreground: hsl(240 10% 3.9%);
+  --popover: hsl(0 0% 100%);
+  --popover-foreground: hsl(240 10% 3.9%);
+  --primary: hsl(${selectedTheme.light.primary});
+  --primary-foreground: hsl(${selectedTheme.light.primaryForeground});
+  --secondary: hsl(${selectedTheme.light.secondary});
+  --secondary-foreground: hsl(${selectedTheme.light.secondaryForeground});
+  --muted: hsl(240 4.8% 95.9%);
+  --muted-foreground: hsl(240 3.8% 46.1%);
+  --accent: hsl(240 4.8% 95.9%);
+  --accent-foreground: hsl(240 5.9% 10%);
+  --destructive: hsl(0 84.2% 60.2%);
+  --destructive-foreground: hsl(0 0% 98%);
+  --border: hsl(${selectedTheme.light.border});
+  --input: hsl(${selectedTheme.light.input});
+  --ring: hsl(${selectedTheme.light.ring});
+}
+
+:root.dark,
+.dark {
+  color-scheme: dark;
+
+  /* Variáveis Spartan / Shadcn UI - Tema Dark */
+  --background: hsl(240 10% 3.9%);
+  --foreground: hsl(0 0% 98%);
+  --card: hsl(240 10% 3.9%);
+  --card-foreground: hsl(0 0% 98%);
+  --popover: hsl(240 10% 3.9%);
+  --popover-foreground: hsl(0 0% 98%);
+  --primary: hsl(${selectedTheme.dark.primary});
+  --primary-foreground: hsl(${selectedTheme.dark.primaryForeground});
+  --secondary: hsl(${selectedTheme.dark.secondary});
+  --secondary-foreground: hsl(${selectedTheme.dark.secondaryForeground});
+  --muted: hsl(240 3.7% 15.9%);
+  --muted-foreground: hsl(240 5% 64.9%);
+  --accent: hsl(240 3.7% 15.9%);
+  --accent-foreground: hsl(0 0% 98%);
+  --destructive: hsl(0 62.8% 30.6%);
+  --destructive-foreground: hsl(0 0% 98%);
+  --border: hsl(${selectedTheme.dark.border});
+  --input: hsl(${selectedTheme.dark.input});
+  --ring: hsl(${selectedTheme.dark.ring});
+}
+
+body {
+  font-family: var(--font-family);
+  background-color: var(--background);
+  color: var(--foreground);
+  margin: 0;
+}
+
+@layer base {
+  * {
+    @apply border-border outline-ring/50;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+}
+
+`;
+}

package/dist/templates/ui-templates.d.ts

@@ -0,0 +1 @@
+export * from './ui';

package/dist/templates/ui-templates.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ui"), exports);

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@devstroupe/devkit-cli",
+  "version": "1.0.0",
+  "description": "DevsTroupe Development Kit CLI — scaffold NestJS+Angular projects, inject Spartan UI, generate CRUDs and audit architectural governance",
+  "license": "MIT",
+  "keywords": [
+    "devstroupe",
+    "devkit",
+    "cli",
+    "nestjs",
+    "angular",
+    "spartan",
+    "crud",
+    "scaffolding",
+    "generator",
+    "code-generation",
+    "governance"
+  ],
+  "homepage": "https://github.com/devstroupe/devkit#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/devstroupe/devkit.git",
+    "directory": "packages/devkit-cli"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "main": "dist/index.js",
+  "bin": {
+    "devstroupe": "./dist/index.js"
+  },
+  "dependencies": {
+    "@devstroupe/devkit-core": "^1.0.0",
+    "commander": "^12.0.0",
+    "fs-extra": "^11.2.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.11.0",
+    "typescript": "^5.4.5"
+  },
+  "scripts": {
+    "build": "tsc && node postbuild.js && chmod +x dist/index.js",
+    "test": "tsc && node --test dist/rules/linter-rules.test.js dist/templates/relationship-templates.test.js"
+  }
+}