@webpieces/nx-webpieces-rules 0.0.1

package/src/executors/validate-ts-in-src/executor.ts

@@ -0,0 +1,283 @@
+/**
+ * Validate TypeScript Files in src/ Executor
+ *
+ * Two-layer rule:
+ *   Layer 1: every .ts file inside an Nx project must live under src/
+ *            (jest.config.ts at project root is the only exception)
+ *   Layer 2: every .ts file anywhere in the workspace must belong to some
+ *            Nx project. Orphan files (at workspace root or in a non-project
+ *            directory) fail the rule unless explicitly allowlisted.
+ *
+ * Configurable via nx.json targetDefaults:
+ *   "validate-ts-in-src": {
+ *       "options": {
+ *           "mode": "ON",
+ *           "excludePaths": [...],
+ *           "allowedRootFiles": [...]
+ *       }
+ *   }
+ *
+ * Usage: nx run architecture:validate-ts-in-src
+ */
+
+import type { ExecutorContext } from '@nx/devkit';
+import { createProjectGraphAsync, readProjectsConfigurationFromProjectGraph } from '@nx/devkit';
+import { loadConfig } from '@webpieces/rules-config';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export type ValidateTsInSrcMode = 'ON' | 'OFF';
+
+export interface ValidateTsInSrcOptions {
+    mode?: ValidateTsInSrcMode;
+    excludePaths?: string[];
+    allowedRootFiles?: string[];
+}
+
+export interface ExecutorResult {
+    success: boolean;
+}
+
+const DEFAULT_EXCLUDE_PATHS: string[] = [
+    'node_modules', 'dist', '.nx', '.git',
+    'architecture', 'tmp', 'scripts',
+];
+
+const DEFAULT_ALLOWED_ROOT_FILES: string[] = ['jest.setup.ts'];
+
+class LayerOneViolation {
+    filePath: string;
+    projectName: string;
+
+    constructor(filePath: string, projectName: string) {
+        this.filePath = filePath;
+        this.projectName = projectName;
+    }
+}
+
+class LayerTwoViolation {
+    filePath: string;
+
+    constructor(filePath: string) {
+        this.filePath = filePath;
+    }
+}
+
+function isNodeModulesDir(name: string): boolean {
+    return name === 'node_modules' || name.startsWith('node_modules_');
+}
+
+function shouldSkipTopLevelDir(name: string, excludePaths: string[]): boolean {
+    if (isNodeModulesDir(name)) return true;
+    return excludePaths.includes(name);
+}
+
+async function getProjectRoots(workspaceRoot: string): Promise<string[]> {
+    const projectGraph = await createProjectGraphAsync();
+    const projectsConfig = readProjectsConfigurationFromProjectGraph(projectGraph);
+    const roots: string[] = [];
+    for (const cfg of Object.values(projectsConfig.projects)) {
+        if (cfg.root === '' || cfg.root === '.') continue;
+        if (cfg.root === 'architecture') continue;
+        roots.push(path.join(workspaceRoot, cfg.root));
+    }
+    return roots;
+}
+
+function findTsFilesOutsideSrc(projectDir: string): string[] {
+    const violations: string[] = [];
+    if (!fs.existsSync(projectDir)) return violations;
+    const entries = fs.readdirSync(projectDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+        if (entry.name === 'src') continue;
+        if (isNodeModulesDir(entry.name)) continue;
+        if (entry.name === 'dist') continue;
+
+        if (entry.isFile() && entry.name.endsWith('.ts')) {
+            if (entry.name === 'jest.config.ts') continue;
+            violations.push(path.join(projectDir, entry.name));
+        }
+
+        if (entry.isDirectory()) {
+            const tsFiles = findTsFilesRecursively(path.join(projectDir, entry.name));
+            violations.push(...tsFiles);
+        }
+    }
+
+    return violations;
+}
+
+function findTsFilesRecursively(dir: string): string[] {
+    const results: string[] = [];
+    if (!fs.existsSync(dir)) return results;
+
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (isNodeModulesDir(entry.name)) continue;
+        if (entry.name === 'dist') continue;
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isFile() && entry.name.endsWith('.ts')) {
+            results.push(fullPath);
+        } else if (entry.isDirectory()) {
+            results.push(...findTsFilesRecursively(fullPath));
+        }
+    }
+    return results;
+}
+
+function findOrphanTsFiles(
+    dir: string,
+    projectRootSet: Set<string>,
+    workspaceRoot: string,
+    results: string[],
+): void {
+    if (!fs.existsSync(dir)) return;
+
+    const relDir = path.relative(workspaceRoot, dir);
+    if (projectRootSet.has(relDir)) return;
+
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (isNodeModulesDir(entry.name)) continue;
+        if (entry.name === 'dist') continue;
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isFile() && entry.name.endsWith('.ts')) {
+            results.push(fullPath);
+        } else if (entry.isDirectory()) {
+            findOrphanTsFiles(fullPath, projectRootSet, workspaceRoot, results);
+        }
+    }
+}
+
+function checkLayerOne(projectRoots: string[], workspaceRoot: string): LayerOneViolation[] {
+    const violations: LayerOneViolation[] = [];
+    for (const projectDir of projectRoots) {
+        const projectName = path.relative(workspaceRoot, projectDir);
+        const tsFiles = findTsFilesOutsideSrc(projectDir);
+        for (const tsFile of tsFiles) {
+            const relativePath = path.relative(workspaceRoot, tsFile);
+            violations.push(new LayerOneViolation(relativePath, projectName));
+        }
+    }
+    return violations;
+}
+
+function checkLayerTwo(
+    workspaceRoot: string,
+    projectRoots: string[],
+    excludePaths: string[],
+    allowedRootFiles: string[],
+): LayerTwoViolation[] {
+    const violations: LayerTwoViolation[] = [];
+    const projectRootSet = new Set(
+        projectRoots.map((p) => path.relative(workspaceRoot, p)),
+    );
+
+    const entries = fs.readdirSync(workspaceRoot, { withFileTypes: true });
+
+    for (const entry of entries) {
+        if (entry.isFile()) {
+            if (!entry.name.endsWith('.ts')) continue;
+            if (allowedRootFiles.includes(entry.name)) continue;
+            violations.push(new LayerTwoViolation(entry.name));
+            continue;
+        }
+        if (!entry.isDirectory()) continue;
+        if (shouldSkipTopLevelDir(entry.name, excludePaths)) continue;
+
+        const orphans: string[] = [];
+        findOrphanTsFiles(
+            path.join(workspaceRoot, entry.name),
+            projectRootSet,
+            workspaceRoot,
+            orphans,
+        );
+        for (const orphan of orphans) {
+            violations.push(new LayerTwoViolation(path.relative(workspaceRoot, orphan)));
+        }
+    }
+
+    return violations;
+}
+
+function reportLayerOneFailure(violations: LayerOneViolation[]): void {
+    console.error('❌ TypeScript files found outside src/ directory!\n');
+    console.error('All .ts source files must be inside the project\'s src/ directory.');
+    console.error('This enforces the standard project structure:\n');
+    console.error('  packages/{category}/{name}/');
+    console.error('  ├── src/          ← ALL .ts files here');
+    console.error('  ├── package.json');
+    console.error('  ├── project.json');
+    console.error('  └── tsconfig.json\n');
+
+    for (const v of violations) {
+        console.error(`  ❌ ${v.filePath}`);
+    }
+
+    console.error('\nTo fix: Move the .ts file(s) into the src/ directory');
+    console.error('Only exception: jest.config.ts at project root\n');
+}
+
+function reportLayerTwoFailure(violations: LayerTwoViolation[]): void {
+    console.error('❌ TypeScript files found outside any Nx project!\n');
+    console.error('Every .ts file must belong to an Nx project so it is compiled,');
+    console.error('linted, and tested under a known project config. Orphan files are');
+    console.error('invisible to the build graph and will rot.\n');
+
+    for (const v of violations) {
+        console.error(`  ❌ ${v.filePath}`);
+    }
+
+    console.error('\nTo fix, pick one:');
+    console.error('  (a) Move the file into an existing project\'s src/ directory');
+    console.error('  (b) Create a new project (add project.json) that owns the directory');
+    console.error('  (c) Add the containing top-level directory to validate-ts-in-src.excludePaths');
+    console.error('      in nx.json targetDefaults, or add the filename to allowedRootFiles');
+    console.error('      if it is a legitimate workspace-root file (e.g., jest.setup.ts)\n');
+}
+
+export default async function runExecutor(
+    _nxOptions: ValidateTsInSrcOptions,
+    context: ExecutorContext,
+): Promise<ExecutorResult> {
+    // Config comes from webpieces.config.json — same source as ai-hooks
+    // and validate-code — via @webpieces/rules-config.
+    const shared = loadConfig(context.root);
+    const rule = shared.rules.get('validate-ts-in-src');
+
+    if (rule && rule.enabled === false) {
+        console.log('\n⏭️  Skipping validate-ts-in-src (enabled: false)\n');
+        return { success: true };
+    }
+
+    const workspaceRoot = context.root;
+    const excludePaths =
+        (rule?.options['excludePaths'] as string[] | undefined) ?? DEFAULT_EXCLUDE_PATHS;
+    const allowedRootFiles =
+        (rule?.options['allowedRootFiles'] as string[] | undefined) ?? DEFAULT_ALLOWED_ROOT_FILES;
+
+    console.log('\n📁 Validating TypeScript files are in src/ and owned by a project\n');
+
+    const projectRoots = await getProjectRoots(workspaceRoot);
+
+    const layerOneViolations = checkLayerOne(projectRoots, workspaceRoot);
+    const layerTwoViolations = checkLayerTwo(
+        workspaceRoot, projectRoots, excludePaths, allowedRootFiles,
+    );
+
+    if (layerOneViolations.length === 0 && layerTwoViolations.length === 0) {
+        console.log('✅ All .ts files are inside a project\'s src/ directory\n');
+        return { success: true };
+    }
+
+    if (layerOneViolations.length > 0) {
+        reportLayerOneFailure(layerOneViolations);
+    }
+    if (layerTwoViolations.length > 0) {
+        reportLayerTwoFailure(layerTwoViolations);
+    }
+
+    console.error('To disable: set rules["validate-ts-in-src"].enabled to false in webpieces.config.json\n');
+    return { success: false };
+}

package/src/executors/validate-ts-in-src/schema.json

@@ -0,0 +1,25 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "title": "Validate TypeScript Files in src/ Executor",
+    "description": "Validates (1) every .ts file inside an Nx project lives under src/, and (2) every .ts file in the workspace is owned by some Nx project.",
+    "type": "object",
+    "properties": {
+        "mode": {
+            "type": "string",
+            "enum": ["ON", "OFF"],
+            "default": "ON",
+            "description": "ON = enforce both layers, OFF = skip validation"
+        },
+        "excludePaths": {
+            "type": "array",
+            "items": { "type": "string" },
+            "description": "Top-level workspace directory names to skip entirely when looking for orphan .ts files. Defaults: node_modules, dist, .nx, .git, architecture, tmp, scripts. node_modules_* backup directories are always skipped regardless of this list. Override replaces the defaults — re-list any defaults you want to keep."
+        },
+        "allowedRootFiles": {
+            "type": "array",
+            "items": { "type": "string" },
+            "description": "Workspace-root .ts filenames that are exempt from the 'must be owned by a project' rule. Defaults: jest.setup.ts. Override replaces the defaults."
+        }
+    },
+    "required": []
+}

package/src/executors/validate-versions-locked/executor.ts

@@ -0,0 +1,376 @@
+/**
+ * Validate Versions Locked Executor
+ *
+ * Validates that package.json versions are:
+ * 1. LOCKED (exact versions, no semver ranges like ^, ~, *)
+ * 2. CONSISTENT across all package.json files (no version conflicts)
+ *
+ * Why locked versions matter:
+ * - Micro bugs ARE introduced via patch versions (1.4.5 → 1.4.6)
+ * - git bisect fails when software changes OUTSIDE of git
+ * - Library upgrades must be explicit via PR/commit, not implicit drift
+ *
+ * Usage:
+ * nx run architecture:validate-versions-locked
+ */
+
+import type { ExecutorContext } from '@nx/devkit';
+import * as fs from 'fs';
+import * as path from 'path';
+import { toError } from '../../toError';
+
+export interface ValidateVersionsLockedOptions {
+    // No options needed
+}
+
+export interface ExecutorResult {
+    success: boolean;
+}
+
+// webpieces-disable max-lines-new-methods -- Existing method from renamed validate-versions file
+// Find all package.json files except node_modules, dist, .nx, .angular
+function findPackageJsonFiles(dir: string, basePath = ''): string[] {
+    const files: string[] = [];
+    const items = fs.readdirSync(dir);
+
+    for (const item of items) {
+        const fullPath = path.join(dir, item);
+        const relativePath = path.join(basePath, item);
+
+        // Skip these directories
+        if (
+            ['node_modules', 'dist', '.nx', '.angular', 'tmp', '.git'].includes(
+                item,
+            )
+        ) {
+            continue;
+        }
+
+        // Skip platform-specific node_modules backups (node_modules_mac, node_modules_linux, etc.)
+        if (item.startsWith('node_modules_')) {
+            continue;
+        }
+
+        // Skip all hidden directories (starting with .)
+        if (item.startsWith('.')) {
+            continue;
+        }
+
+        const stat = fs.statSync(fullPath);
+        if (stat.isDirectory()) {
+            files.push(...findPackageJsonFiles(fullPath, relativePath));
+        } else if (item === 'package.json') {
+            files.push(fullPath);
+        }
+    }
+
+    return files;
+}
+
+// Check if a version string uses semver ranges
+function hasSemverRange(version: string): boolean {
+    // Allow workspace protocol
+    if (version.startsWith('workspace:')) {
+        return false;
+    }
+
+    // Allow file: protocol (for local packages)
+    if (version.startsWith('file:')) {
+        return false;
+    }
+
+    // Check for common semver range patterns
+    const semverPatterns = [
+        /^\^/, // ^1.2.3
+        /^~/, // ~1.2.3
+        /^\+/, // +1.2.3
+        /^\*/, // *
+        /^>/, // >1.2.3
+        /^</, // <1.2.3
+        /^>=/, // >=1.2.3
+        /^<=/, // <=1.2.3
+        /\|\|/, // 1.2.3 || 2.x
+        / - /, // 1.2.3 - 2.3.4
+        /^\d+\.x/, // 1.x, 1.2.x
+        /^latest$/, // latest
+        /^next$/, // next
+    ];
+
+    return semverPatterns.some((pattern) => pattern.test(version));
+}
+
+// webpieces-disable max-lines-new-methods -- Existing method from renamed validate-versions file
+// Validate a single package.json file for semver ranges
+function validatePackageJson(filePath: string): string[] {
+    // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const pkg = JSON.parse(content);
+        const errors: string[] = [];
+
+        // Check dependencies
+        if (pkg.dependencies) {
+            for (const [name, version] of Object.entries(pkg.dependencies)) {
+                // Skip internal workspace packages
+                if (name.startsWith('@webpieces/')) {
+                    continue;
+                }
+
+                if (hasSemverRange(version as string)) {
+                    errors.push(
+                        `dependencies.${name}: "${version}" uses semver range (must be locked to exact version)`,
+                    );
+                }
+            }
+        }
+
+        // Check devDependencies
+        if (pkg.devDependencies) {
+            for (const [name, version] of Object.entries(pkg.devDependencies)) {
+                // Skip internal workspace packages
+                if (name.startsWith('@webpieces/')) {
+                    continue;
+                }
+
+                if (hasSemverRange(version as string)) {
+                    errors.push(
+                        `devDependencies.${name}: "${version}" uses semver range (must be locked to exact version)`,
+                    );
+                }
+            }
+        }
+
+        // Check peerDependencies (these can have ranges for compatibility)
+        // We don't validate peerDependencies for semver ranges since they're meant to be flexible
+
+        return errors;
+    } catch (err: unknown) {
+        const error = toError(err);
+        return [`Failed to parse ${filePath}: ${error.message}`];
+    }
+}
+
+// Track all dependency versions across the monorepo
+interface DependencyUsage {
+    version: string;
+    file: string;
+    type: 'dependencies' | 'devDependencies';
+}
+
+// webpieces-disable max-lines-new-methods -- Collecting dependencies from all package.json files
+// Collect all dependency versions from all package.json files
+function collectAllDependencies(workspaceRoot: string): Map<string, DependencyUsage[]> {
+    const dependencyMap = new Map<string, DependencyUsage[]>();
+    const packageFiles = findPackageJsonFiles(workspaceRoot);
+
+    for (const filePath of packageFiles) {
+        // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const pkg = JSON.parse(content);
+            const relativePath = path.relative(workspaceRoot, filePath);
+
+            // Collect dependencies
+            if (pkg.dependencies) {
+                for (const [name, version] of Object.entries(pkg.dependencies)) {
+                    // Skip internal workspace packages
+                    if (name.startsWith('@webpieces/')) continue;
+
+                    const usage: DependencyUsage = {
+                        version: version as string,
+                        file: relativePath,
+                        type: 'dependencies'
+                    };
+
+                    if (!dependencyMap.has(name)) {
+                        dependencyMap.set(name, []);
+                    }
+                    dependencyMap.get(name)!.push(usage);
+                }
+            }
+
+            // Collect devDependencies
+            if (pkg.devDependencies) {
+                for (const [name, version] of Object.entries(pkg.devDependencies)) {
+                    // Skip internal workspace packages
+                    if (name.startsWith('@webpieces/')) continue;
+
+                    const usage: DependencyUsage = {
+                        version: version as string,
+                        file: relativePath,
+                        type: 'devDependencies'
+                    };
+
+                    if (!dependencyMap.has(name)) {
+                        dependencyMap.set(name, []);
+                    }
+                    dependencyMap.get(name)!.push(usage);
+                }
+            }
+        } catch (err: unknown) {
+            // const error = toError(err);
+            // Intentionally skip files that can't be parsed - this is expected for some package.json files
+        }
+    }
+
+    return dependencyMap;
+}
+
+// webpieces-disable max-lines-new-methods -- Simple iteration logic, splitting would reduce clarity
+// Check for version conflicts across package.json files
+function checkVersionConflicts(workspaceRoot: string): string[] {
+    console.log('\n🔍 Checking for version conflicts across package.json files:');
+
+    const dependencyMap = collectAllDependencies(workspaceRoot);
+    const conflicts: string[] = [];
+
+    for (const [packageName, usages] of dependencyMap.entries()) {
+        // Get unique versions (ignoring workspace: and file: protocols)
+        const versions = new Set(
+            usages
+                .map(u => u.version)
+                .filter(v => !v.startsWith('workspace:') && !v.startsWith('file:'))
+        );
+
+        if (versions.size > 1) {
+            const conflictDetails = usages
+                .filter(u => !u.version.startsWith('workspace:') && !u.version.startsWith('file:'))
+                .map(u => `      ${u.file} (${u.type}): ${u.version}`)
+                .join('\n');
+
+            conflicts.push(`   ❌ ${packageName} has ${versions.size} different versions:\n${conflictDetails}`);
+        }
+    }
+
+    if (conflicts.length === 0) {
+        console.log('   ✅ No version conflicts found');
+    } else {
+        for (const conflict of conflicts) {
+            console.log(conflict);
+        }
+    }
+
+    return conflicts;
+}
+
+/**
+ * Prints the educational message explaining why semver ranges are forbidden.
+ * This helps developers understand the rationale behind locked versions.
+ */
+// webpieces-disable max-lines-new-methods -- Educational message template, splitting reduces clarity
+function printSemverRangeEducationalMessage(semverErrors: number): void {
+    console.log(`
+❌ SEMVER RANGES DETECTED - BUILD FAILED
+
+Found ${semverErrors} package(s) using semver ranges (^, ~, *, etc.) instead of locked versions.
+
+WHY THIS IS A HARD FAILURE:
+═══════════════════════════════════════════════════════════════════════════════
+
+1. MICRO BUGS ARE REAL
+   Thinking that patch versions (1.4.5 → 1.4.6) don't introduce bugs is wrong.
+   They do. Sometimes what looks like an "easy fix" breaks things in subtle ways.
+
+2. GIT BISECT BECOMES USELESS
+   When you run "git bisect" to find when a bug was introduced, it fails if
+   software changed OUTSIDE of git. You checkout an old commit, but node_modules
+   has different versions than when that commit was made. The bug persists even
+   in "known good" commits because the library versions drifted.
+
+3. THE "MAGIC BUG" PROBLEM
+   You checkout code from 6 months ago to debug an issue. The bug is still there!
+   But it wasn't there 6 months ago... The culprit: a minor version upgrade that
+   happened silently without any PR or git commit. Impossible to track down.
+
+4. CHANGES OUTSIDE GIT = BAD
+   Every change to your software should be tracked in version control.
+   Implicit library upgrades via semver ranges violate this principle.
+
+THE SOLUTION:
+═══════════════════════════════════════════════════════════════════════════════
+
+Use LOCKED (exact) versions for all dependencies:
+  ❌ "lodash": "^4.17.21"    <- BAD: allows 4.17.22, 4.18.0, etc.
+  ❌ "lodash": "~4.17.21"    <- BAD: allows 4.17.22, 4.17.23, etc.
+  ✅ "lodash": "4.17.21"     <- GOOD: locked to this exact version
+
+To upgrade libraries, use an explicit process:
+  1. Run: npm update <package-name>
+  2. Test thoroughly
+  3. Commit the package.json AND package-lock.json changes
+  4. Create a PR so the upgrade is reviewed and tracked in git history
+
+This way, every library change is:
+  • Intentional (not accidental)
+  • Reviewed (via PR)
+  • Tracked (in git history)
+  • Bisectable (git bisect works correctly)
+
+`);
+}
+
+type SemverRangeResult = { errors: number };
+
+// Check semver ranges in all package.json files - FAILS if any found
+function checkSemverRanges(workspaceRoot: string): SemverRangeResult {
+    console.log('\n📋 Checking for unlocked versions (semver ranges):');
+    const packageFiles = findPackageJsonFiles(workspaceRoot);
+    let semverErrors = 0;
+
+    for (const filePath of packageFiles) {
+        const relativePath = path.relative(workspaceRoot, filePath);
+        const errors = validatePackageJson(filePath);
+
+        if (errors.length > 0) {
+            console.log(`   ❌ ${relativePath}:`);
+            for (const error of errors) {
+                console.log(`      ${error}`);
+            }
+            semverErrors += errors.length;
+        } else {
+            console.log(`   ✅ ${relativePath}`);
+        }
+    }
+
+    return { errors: semverErrors };
+}
+
+export default async function runExecutor(
+    _options: ValidateVersionsLockedOptions,
+    context: ExecutorContext
+): Promise<ExecutorResult> {
+    console.log('\n🔒 Validating Package Versions are LOCKED and CONSISTENT\n');
+
+    const workspaceRoot = context.root;
+
+    // Step 1: Check for semver ranges (FAILS if any found)
+    const semverResult = checkSemverRanges(workspaceRoot);
+    const semverErrors = semverResult.errors;
+    const packageFiles = findPackageJsonFiles(workspaceRoot);
+
+    // Step 2: Check for version conflicts across package.json files
+    const versionConflicts = checkVersionConflicts(workspaceRoot);
+
+    // Summary
+    console.log(`\n📊 Summary:`);
+    console.log(`   Files checked: ${packageFiles.length}`);
+    console.log(`   Unlocked versions (semver ranges): ${semverErrors}`);
+    console.log(`   Version conflicts: ${versionConflicts.length}`);
+
+    // Fail on semver ranges with educational message
+    if (semverErrors > 0) {
+        printSemverRangeEducationalMessage(semverErrors);
+        return { success: false };
+    }
+
+    // Fail on version conflicts
+    if (versionConflicts.length > 0) {
+        console.log('\n❌ VALIDATION FAILED!');
+        console.log('   Fix version conflicts - all package.json files must use the same version for each dependency.');
+        console.log('   This prevents "works on my machine" bugs where different projects use different library versions.\n');
+        return { success: false };
+    }
+
+    console.log('\n✅ VALIDATION PASSED! All versions are locked and consistent.');
+    return { success: true };
+}

package/src/executors/validate-versions-locked/schema.json

@@ -0,0 +1,8 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "title": "Validate Versions Locked Executor",
+    "description": "Validates package.json versions are locked (no semver ranges) and consistent across all projects",
+    "type": "object",
+    "properties": {},
+    "required": []
+}