@titannio/webtoolkit-cli 1.3.0

package/dist/guards/rebuild-preflight.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { loadConfig } from '../config.js';
+import { isMainModule } from './guard-config.js';
+const defaultRepoRoot = process.cwd();
+const colors = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+};
+function colorize(message, color) {
+    return `${color}${message}${colors.reset}`;
+}
+function quoteShellArg(arg) {
+    if (/^[\w@%+=:,./\\-]+$/.test(arg)) {
+        return arg;
+    }
+    return `"${arg.replace(/"/g, '\\"')}"`;
+}
+export function getTargetDefinition(target, targetDefinitions) {
+    const definition = targetDefinitions[target];
+    if (!definition) {
+        throw new Error(`Unknown rebuild preflight target: ${target}. Expected one of ${Object.keys(targetDefinitions).join(', ')}`);
+    }
+    return definition;
+}
+export function parseTurboDryRun(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed) {
+        throw new Error('Turbo dry run produced no JSON output');
+    }
+    return JSON.parse(trimmed);
+}
+export function extractPackagesNeedingRebuild(report, relevantBuildPackages) {
+    const relevantPackages = new Set(relevantBuildPackages);
+    return report.tasks
+        .filter((task) => task.task === 'build')
+        .filter((task) => task.command !== '<NONEXISTENT>')
+        .filter((task) => relevantPackages.size === 0 || relevantPackages.has(task.package))
+        .filter((task) => task.cache?.status !== 'HIT')
+        .map((task) => task.package);
+}
+function runTurboBuildDryRun(options) {
+    const { repoRoot, turboFilters, packageManager } = options;
+    const args = ['turbo', 'run', 'build', '--dry=json'];
+    for (const filter of turboFilters) {
+        args.push(`--filter=${filter}`);
+    }
+    const result = process.platform === 'win32'
+        ? spawnSync(process.env.ComSpec ?? 'cmd.exe', ['/d', '/s', '/c', [packageManager, ...args].map(quoteShellArg).join(' ')], {
+            cwd: repoRoot,
+            encoding: 'utf8',
+            env: { ...process.env, FORCE_COLOR: '1' },
+        })
+        : spawnSync(packageManager, args, {
+            cwd: repoRoot,
+            encoding: 'utf8',
+            env: { ...process.env, FORCE_COLOR: '1' },
+        });
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        const details = result.stderr?.trim() || result.stdout?.trim() || `exit code ${result.status}`;
+        throw new Error(`Turbo dry run failed: ${details}`);
+    }
+    return parseTurboDryRun(result.stdout);
+}
+export async function getRebuildPreflightReport({ repoRoot = defaultRepoRoot, target, }) {
+    const { config } = await loadConfig(repoRoot);
+    const targetDefinitions = config.guards?.rebuildPreflight?.targets;
+    if (!targetDefinitions || Object.keys(targetDefinitions).length === 0) {
+        throw new Error('guards.rebuildPreflight.targets is not configured in .webtoolkit-cli/config.json.');
+    }
+    const definition = getTargetDefinition(target, targetDefinitions);
+    if (definition.relevantBuildPackages.length === 0) {
+        return {
+            target,
+            warningTitle: definition.warningTitle,
+            packagesNeedingRebuild: [],
+        };
+    }
+    const turboReport = runTurboBuildDryRun({
+        repoRoot,
+        turboFilters: definition.turboFilters,
+        packageManager: config.packageManager,
+    });
+    return {
+        target,
+        warningTitle: definition.warningTitle,
+        packagesNeedingRebuild: extractPackagesNeedingRebuild(turboReport, definition.relevantBuildPackages),
+    };
+}
+export function formatRebuildPreflightWarning(report) {
+    if (report.packagesNeedingRebuild.length === 0) {
+        return '';
+    }
+    const packageNames = report.packagesNeedingRebuild.join(', ');
+    return `${colorize(`[DEV PRECHECK] ${report.warningTitle}: ${packageNames}`, colors.red)}\n`;
+}
+export async function printRebuildPreflightWarning(options) {
+    const report = await getRebuildPreflightReport(options);
+    const warning = formatRebuildPreflightWarning(report);
+    if (warning) {
+        process.stderr.write(warning);
+    }
+    return report;
+}
+/* v8 ignore start -- executable adapter */
+function getTargetFromArgv(argv = process.argv) {
+    const targetArg = argv.find((arg) => arg.startsWith('--target='));
+    return targetArg ? targetArg.slice('--target='.length) : null;
+}
+async function main() {
+    const target = getTargetFromArgv();
+    if (!target) {
+        process.stderr.write(colorize('[DEV PRECHECK] Missing --target=<name>; skipping rebuild warning.\n', colors.yellow));
+        process.exit(0);
+    }
+    try {
+        await printRebuildPreflightWarning({ target });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(colorize(`[DEV PRECHECK] Warning check failed: ${message}\n`, colors.yellow));
+    }
+    process.exit(0);
+}
+/* v8 ignore stop */
+/* v8 ignore start -- executable adapter */
+if (isMainModule(import.meta.url)) {
+    main().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(colorize(`[DEV PRECHECK] Warning check failed: ${message}\n`, colors.yellow));
+    });
+}
+/* v8 ignore stop */

package/dist/guards/repository-hygiene-guard.d.ts

@@ -0,0 +1,12 @@
+import type { RepositoryHygieneGuardConfig } from '../config.js';
+export type RepositoryHygieneIssue = {
+    filePath: string;
+    pattern: string;
+};
+export declare function readTrackedFiles(rootDir: string): string[];
+export declare function inspectTrackedPaths(trackedFiles: string[], config: RepositoryHygieneGuardConfig): RepositoryHygieneIssue[];
+export declare function runRepositoryHygieneGuard(options?: {
+    rootDir?: string;
+    config?: RepositoryHygieneGuardConfig;
+    trackedFiles?: string[];
+}): Promise<number>;

package/dist/guards/repository-hygiene-guard.js

@@ -0,0 +1,70 @@
+import { spawnSync } from 'node:child_process';
+import { compilePatterns, isMainModule, loadGuardConfig } from './guard-config.js';
+function normalizeTrackedPath(filePath) {
+    return filePath.replaceAll('\\', '/');
+}
+export function readTrackedFiles(rootDir) {
+    const result = spawnSync('git', ['ls-files', '-z'], {
+        cwd: rootDir,
+        encoding: 'utf8',
+        shell: false,
+    });
+    if (result.error) {
+        throw new Error(`repository-hygiene: unable to list Git-tracked files: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        const detail = result.stderr.trim();
+        /* v8 ignore next -- Git reports command failures on stderr */
+        throw new Error(`repository-hygiene: git ls-files failed${detail ? `: ${detail}` : '.'}`);
+    }
+    const files = result.stdout
+        .split('\0')
+        .filter(Boolean)
+        .map(normalizeTrackedPath);
+    if (files.length === 0) {
+        throw new Error('repository-hygiene: git ls-files returned no tracked files.');
+    }
+    return files;
+}
+export function inspectTrackedPaths(trackedFiles, config) {
+    const forbidden = compilePatterns(config.forbiddenPathPatterns);
+    const allowed = compilePatterns(config.allowedPathPatterns);
+    const issues = [];
+    for (const filePath of trackedFiles.map(normalizeTrackedPath)) {
+        if (allowed.some((pattern) => pattern.test(filePath)))
+            continue;
+        const index = forbidden.findIndex((pattern) => pattern.test(filePath));
+        if (index >= 0) {
+            issues.push({ filePath, pattern: config.forbiddenPathPatterns[index] });
+        }
+    }
+    return issues.sort((left, right) => Buffer.compare(Buffer.from(left.filePath), Buffer.from(right.filePath)));
+}
+export async function runRepositoryHygieneGuard(options = {}) {
+    const rootDir = options.rootDir ?? process.cwd();
+    const config = options.config ?? await loadGuardConfig('repositoryHygiene', rootDir);
+    const trackedFiles = options.trackedFiles ?? readTrackedFiles(rootDir);
+    if (trackedFiles.length === 0) {
+        throw new Error('repository-hygiene: tracked-file inventory must not be empty.');
+    }
+    const issues = inspectTrackedPaths(trackedFiles, config);
+    if (issues.length === 0) {
+        console.info(`Repository hygiene is valid (${trackedFiles.length} tracked files).`);
+        return 0;
+    }
+    console.error('Repository hygiene guard failed:');
+    for (const issue of issues) {
+        console.error(`  - ${issue.filePath} [${issue.pattern}]`);
+    }
+    return 1;
+}
+/* v8 ignore start -- executable adapter */
+if (isMainModule(import.meta.url)) {
+    runRepositoryHygieneGuard().then((code) => {
+        process.exitCode = code;
+    }).catch((error) => {
+        console.error(error.message);
+        process.exitCode = 1;
+    });
+}
+/* v8 ignore stop */

package/dist/guards/schema-guard.d.ts

@@ -0,0 +1,10 @@
+import { Project } from 'ts-morph';
+import type { SchemaGuardConfig } from '../config.js';
+export declare function findSchemaDefinitions(filePath: string, project: Project, configuredBuilders: string[]): Array<{
+    line: number;
+    snippet: string;
+}>;
+export declare function runSchemaGuard(options?: {
+    rootDir?: string;
+    config?: SchemaGuardConfig;
+}): Promise<number>;

package/dist/guards/schema-guard.js

@@ -0,0 +1,160 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Node, Project, SyntaxKind, } from 'ts-morph';
+import { BASE_SOURCE_EXCLUDE_PATTERNS, BASE_SOURCE_EXTENSIONS, assertConfiguredScanScope, compilePatterns, hasExtension, isMainModule, loadGuardConfig, resolveProjectPath, } from './guard-config.js';
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    gray: '\x1b[90m',
+};
+function isWithinDirectory(filePath, directory) {
+    const relative = path.relative(directory, filePath);
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..');
+}
+function normalizedRelativePath(rootDir, filePath) {
+    return path.relative(rootDir, filePath).replaceAll('\\', '/');
+}
+function collectFiles(rootDir, config, centralDirectory, excludePatterns) {
+    const files = [];
+    function walk(directory) {
+        if (!fs.existsSync(directory) || !fs.statSync(directory).isDirectory())
+            return;
+        if (isWithinDirectory(directory, centralDirectory))
+            return;
+        for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+            const fullPath = path.join(directory, entry.name);
+            const relativePath = normalizedRelativePath(rootDir, fullPath);
+            if (entry.isDirectory()) {
+                if (!excludePatterns.some((pattern) => pattern.test(relativePath)))
+                    walk(fullPath);
+            }
+            else if (entry.isFile() &&
+                hasExtension(fullPath, BASE_SOURCE_EXTENSIONS) &&
+                !excludePatterns.some((pattern) => pattern.test(relativePath))) {
+                files.push(fullPath);
+            }
+        }
+    }
+    for (const includePath of config.includePaths) {
+        walk(resolveProjectPath(rootDir, includePath));
+    }
+    return files.sort();
+}
+function unwrapExpression(expression) {
+    if (Node.isParenthesizedExpression(expression) ||
+        Node.isAsExpression(expression) ||
+        Node.isTypeAssertion(expression) ||
+        Node.isSatisfiesExpression(expression) ||
+        Node.isNonNullExpression(expression)) {
+        return unwrapExpression(expression.getExpression());
+    }
+    return expression;
+}
+function findRootBuilder(expression, builders) {
+    const current = unwrapExpression(expression);
+    if (!Node.isCallExpression(current))
+        return null;
+    const callee = unwrapExpression(current.getExpression());
+    if (!Node.isPropertyAccessExpression(callee))
+        return null;
+    const target = unwrapExpression(callee.getExpression());
+    if (Node.isIdentifier(target) && target.getText() === 'z' && builders.has(callee.getName())) {
+        return callee.getName();
+    }
+    return findRootBuilder(target, builders);
+}
+function definitionCandidate(node) {
+    if (Node.isVariableDeclaration(node) || Node.isPropertyDeclaration(node) || Node.isPropertyAssignment(node)) {
+        const expression = node.getInitializer();
+        return expression ? { owner: node, expression } : null;
+    }
+    if (Node.isExportAssignment(node)) {
+        return { owner: node, expression: node.getExpression() };
+    }
+    if (Node.isBinaryExpression(node) && node.getOperatorToken().getKind() === SyntaxKind.EqualsToken) {
+        return { owner: node, expression: node.getRight() };
+    }
+    return null;
+}
+function isNestedInDefinition(candidate, outer) {
+    if (candidate.expression.getStart() <= outer.expression.getStart() ||
+        candidate.expression.getEnd() > outer.expression.getEnd()) {
+        return false;
+    }
+    for (const ancestor of candidate.expression.getAncestors()) {
+        if (ancestor === outer.expression)
+            return true;
+        if (ancestor !== candidate.owner && Node.isFunctionLikeDeclaration(ancestor))
+            return false;
+    }
+    /* v8 ignore next -- a contained ts-morph descendant always reaches the containing expression */
+    return false;
+}
+export function findSchemaDefinitions(filePath, project, configuredBuilders) {
+    const sourceFile = project.addSourceFileAtPath(filePath);
+    const builders = new Set(configuredBuilders);
+    const candidates = [];
+    sourceFile.forEachDescendant((node) => {
+        const candidate = definitionCandidate(node);
+        if (candidate && findRootBuilder(candidate.expression, builders))
+            candidates.push(candidate);
+    });
+    return candidates
+        .filter((candidate) => !candidates.some((outer) => (outer !== candidate && isNestedInDefinition(candidate, outer))))
+        .map((candidate) => ({
+        line: candidate.expression.getStartLineNumber(),
+        snippet: candidate.expression.getText().replace(/\s+/gu, ' ').slice(0, 120),
+    }));
+}
+export async function runSchemaGuard(options = {}) {
+    const rootDir = options.rootDir ?? process.cwd();
+    const config = options.config ?? await loadGuardConfig('schema', rootDir);
+    /* v8 ignore next -- every invalid operand and the valid fallthrough are asserted */
+    if (!config.centralDirectory || config.includePaths.length === 0 || config.builders.length === 0) {
+        throw new Error('guards.schema requires centralDirectory, non-empty includePaths, and non-empty builders.');
+    }
+    const excludePatterns = compilePatterns(config.excludePatterns, BASE_SOURCE_EXCLUDE_PATTERNS);
+    const centralDirectory = resolveProjectPath(rootDir, config.centralDirectory);
+    const files = collectFiles(rootDir, config, centralDirectory, excludePatterns);
+    assertConfiguredScanScope({
+        root: rootDir,
+        guardName: 'schema',
+        configPath: 'guards.schema.includePaths',
+        configuredPaths: config.includePaths,
+        eligibleFiles: files,
+    });
+    const project = new Project({ skipAddingFilesFromTsConfig: true });
+    const violations = [];
+    for (const filePath of files) {
+        for (const definition of findSchemaDefinitions(filePath, project, config.builders)) {
+            violations.push({
+                filePath: normalizedRelativePath(rootDir, filePath),
+                ...definition,
+            });
+        }
+    }
+    if (violations.length === 0) {
+        console.info(`${colors.green}${colors.bright}✅ [OK]${colors.reset} No configured schema builders found outside ${config.centralDirectory}.`);
+        return 0;
+    }
+    console.error(`${colors.bright}${colors.yellow}Configured schemas found outside ${config.centralDirectory}:${colors.reset}`);
+    for (const violation of violations) {
+        console.error(`${colors.gray}${violation.filePath}:${violation.line}${colors.reset} ${violation.snippet}`);
+    }
+    console.error(`${colors.red}Move these definitions to ${config.centralDirectory}.${colors.reset}`);
+    return 1;
+}
+/* v8 ignore start -- executable adapter */
+if (isMainModule(import.meta.url)) {
+    runSchemaGuard().then((code) => {
+        process.exitCode = code;
+    }).catch((error) => {
+        console.error(error.message);
+        process.exitCode = 1;
+    });
+}
+/* v8 ignore stop */

package/dist/guards/singleton-deps-guard.d.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env tsx
+export declare const MANIFEST_FIELDS: readonly ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
+export type ManifestDependencies = Partial<Record<(typeof MANIFEST_FIELDS)[number], Record<string, string>>>;
+export type ManifestIssue = {
+    filePath: string;
+    message: string;
+};
+export type ManifestEntry = {
+    filePath: string;
+    manifest: ManifestDependencies;
+};
+export type SingletonDependencyValidationInput = {
+    lockfileContent?: string | null;
+    manifests: ManifestEntry[];
+    overrides: Record<string, string>;
+};
+export declare function collectWorkspacePackageJsonFiles(rootDir?: string): string[];
+export declare function isValidSemverRange(value: string): boolean;
+export declare function collectLockfileVersions(lockfileContent: string, packageName: string): string[];
+export declare function validateSingletonDependencyPolicy(input: SingletonDependencyValidationInput, rootDir?: string): ManifestIssue[];
+export declare function runSingletonDepsGuard(rootDir?: string): number;

package/dist/guards/singleton-deps-guard.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env tsx
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { isMainModule } from './guard-config.js';
+import { readPnpmWorkspaceOverrides } from './pnpm-workspace-config.js';
+const require = createRequire(import.meta.url);
+const semver = require('semver');
+const WORKSPACE_ROOTS = ['apps', 'packages'];
+export const MANIFEST_FIELDS = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+};
+function readJsonFile(filePath) {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+export function collectWorkspacePackageJsonFiles(rootDir = process.cwd()) {
+    const manifests = [];
+    for (const root of WORKSPACE_ROOTS) {
+        const absoluteRoot = path.resolve(rootDir, root);
+        if (!fs.existsSync(absoluteRoot))
+            continue;
+        for (const entry of fs.readdirSync(absoluteRoot, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const manifestPath = path.join(absoluteRoot, entry.name, 'package.json');
+            if (fs.existsSync(manifestPath)) {
+                manifests.push(manifestPath);
+            }
+        }
+    }
+    return manifests.sort((left, right) => left.localeCompare(right));
+}
+function toRelativePath(filePath, rootDir) {
+    return path.isAbsolute(filePath) ? path.relative(rootDir, filePath) : filePath;
+}
+export function isValidSemverRange(value) {
+    return semver.validRange(value) !== null;
+}
+function acceptsResolvedVersion(versionRange, resolvedVersion) {
+    return semver.satisfies(resolvedVersion, versionRange, { includePrerelease: true });
+}
+function collectOverrideIssues(overrides) {
+    return Object.entries(overrides)
+        .sort((left, right) => left[0].localeCompare(right[0]))
+        .flatMap(([packageName, overrideRange]) => isValidSemverRange(overrideRange)
+        ? []
+        : [
+            {
+                filePath: 'pnpm-workspace.yaml',
+                message: `overrides["${packageName}"] deve ser um semver/range valido; encontrado "${overrideRange}"`,
+            },
+        ]);
+}
+function buildResolvedVersionsByPackage(lockfileContent, packageNames) {
+    const versionsByPackage = new Map();
+    for (const packageName of packageNames) {
+        versionsByPackage.set(packageName, lockfileContent ? collectLockfileVersions(lockfileContent, packageName) : []);
+    }
+    return versionsByPackage;
+}
+function collectManifestCompatibilityIssues(manifestEntry, overrides, resolvedVersionsByPackage, rootDir) {
+    const relativePath = toRelativePath(manifestEntry.filePath, rootDir);
+    const issues = [];
+    for (const [packageName, overrideRange] of Object.entries(overrides)) {
+        const resolvedVersions = resolvedVersionsByPackage.get(packageName);
+        if (resolvedVersions.length !== 1)
+            continue;
+        const resolvedVersion = resolvedVersions[0];
+        for (const field of MANIFEST_FIELDS) {
+            const declaredVersion = manifestEntry.manifest[field]?.[packageName];
+            if (!declaredVersion)
+                continue;
+            if (!isValidSemverRange(declaredVersion) || !acceptsResolvedVersion(declaredVersion, resolvedVersion)) {
+                issues.push({
+                    filePath: relativePath,
+                    message: `"${packageName}" em "${field}" deve aceitar a versao singleton resolvida "${resolvedVersion}" (override: "${overrideRange}"); encontrado "${declaredVersion}"`,
+                });
+            }
+        }
+    }
+    return issues;
+}
+export function collectLockfileVersions(lockfileContent, packageName) {
+    const pattern = new RegExp(`^\\s{2}${escapeRegExp(packageName)}@([^:\\n]+):$`, 'gm');
+    const versions = new Set();
+    for (const match of lockfileContent.matchAll(pattern)) {
+        const normalizedVersion = match[1].split('(')[0].trim();
+        if (normalizedVersion.length > 0) {
+            versions.add(normalizedVersion);
+        }
+    }
+    return Array.from(versions).sort((left, right) => left.localeCompare(right));
+}
+export function validateSingletonDependencyPolicy(input, rootDir = process.cwd()) {
+    const issues = [...collectOverrideIssues(input.overrides)];
+    const packageNames = Object.keys(input.overrides).sort((left, right) => left.localeCompare(right));
+    const resolvedVersionsByPackage = buildResolvedVersionsByPackage(input.lockfileContent, packageNames);
+    for (const packageName of packageNames) {
+        const overrideRange = input.overrides[packageName];
+        const resolvedVersions = resolvedVersionsByPackage.get(packageName);
+        if (resolvedVersions.length > 1) {
+            issues.push({
+                filePath: 'pnpm-lock.yaml',
+                message: `"${packageName}" aparece com multiplas versoes no lockfile: ${resolvedVersions.join(', ')}`,
+            });
+            continue;
+        }
+        if (resolvedVersions.length === 1 &&
+            isValidSemverRange(overrideRange) &&
+            !acceptsResolvedVersion(overrideRange, resolvedVersions[0])) {
+            issues.push({
+                filePath: 'pnpm-lock.yaml',
+                message: `"${packageName}" resolve para "${resolvedVersions[0]}" no lockfile, mas pnpm-workspace.yaml overrides exige compatibilidade com "${overrideRange}"`,
+            });
+        }
+    }
+    for (const manifestEntry of input.manifests) {
+        issues.push(...collectManifestCompatibilityIssues(manifestEntry, input.overrides, resolvedVersionsByPackage, rootDir));
+    }
+    return issues;
+}
+function printIssues(issues) {
+    for (const issue of issues) {
+        console.info(`${colors.gray}${issue.filePath}${colors.reset}`);
+        console.info(`  ${colors.red}→${colors.reset} ${issue.message}`);
+    }
+}
+export function runSingletonDepsGuard(rootDir = process.cwd()) {
+    console.info(`${colors.bright}${colors.blue}🔒 Checking singleton dependency compatibility...${colors.reset}`);
+    const rootPackageJsonPath = path.resolve(rootDir, 'package.json');
+    const lockfilePath = path.resolve(rootDir, 'pnpm-lock.yaml');
+    if (!fs.existsSync(rootPackageJsonPath)) {
+        console.error(`${colors.red}Root package.json not found.${colors.reset}`);
+        return 1;
+    }
+    const rootManifest = readJsonFile(rootPackageJsonPath);
+    const overrides = readPnpmWorkspaceOverrides(path.resolve(rootDir, 'pnpm-workspace.yaml'));
+    const overrideEntries = Object.entries(overrides).sort((left, right) => left[0].localeCompare(right[0]));
+    if (overrideEntries.length === 0) {
+        console.info(`${colors.yellow}No pnpm-workspace.yaml overrides configured. Singleton dependency guard skipped.${colors.reset}`);
+        return 0;
+    }
+    const manifests = [{ filePath: rootPackageJsonPath, manifest: rootManifest }];
+    for (const manifestPath of collectWorkspacePackageJsonFiles(rootDir)) {
+        const manifest = readJsonFile(manifestPath);
+        manifests.push({ filePath: manifestPath, manifest });
+    }
+    const issues = [];
+    if (!fs.existsSync(lockfilePath)) {
+        issues.push({
+            filePath: 'pnpm-lock.yaml',
+            message: 'pnpm-lock.yaml não encontrado',
+        });
+    }
+    else {
+        const lockfileContent = fs.readFileSync(lockfilePath, 'utf8');
+        issues.push(...validateSingletonDependencyPolicy({ lockfileContent, manifests, overrides }, rootDir));
+    }
+    if (issues.length > 0) {
+        console.info(`${colors.bright}${colors.red}⚠️  SINGLETON DEPENDENCY POLICY VIOLATION${colors.reset}\n`);
+        printIssues(issues);
+        console.info(`\n${colors.red}Ajuste os manifests/lockfile para manter dependências singleton alinhadas.${colors.reset}`);
+        return 1;
+    }
+    console.info(`${colors.green}${colors.bright}✅ [OK]${colors.reset} Singleton dependencies are compatible with pnpm-workspace.yaml overrides`);
+    return 0;
+}
+/* v8 ignore start -- executable adapter */
+if (isMainModule(import.meta.url)) {
+    process.exitCode = runSingletonDepsGuard();
+}
+/* v8 ignore stop */

package/dist/guards/tsconfig-guard.d.ts

@@ -0,0 +1,5 @@
+import type { TsconfigGuardConfig } from '../config.js';
+export declare function runTsconfigGuard(options?: {
+    rootDir?: string;
+    config?: TsconfigGuardConfig;
+}): Promise<number>;