@codefast/cli 0.3.13-canary.3 → 0.3.13

package/dist/lib/arrange/presentation/report.presenter.js

@@ -1,37 +0,0 @@
-import path from "node:path";
-import { LONG_STRING_TOKEN_THRESHOLD, MAX_REPORT_LINES, } from "#lib/arrange/domain/constants.domain";
-export function printAnalyzeReport(analyzeRootDirectoryPath, analyzeReport, logger) {
-    const { out } = logger;
-    out(`Path: ${path.resolve(analyzeRootDirectoryPath)}`);
-    out(`.ts/.tsx files: ${analyzeReport.files}`);
-    out(`cn(...) call sites: ${analyzeReport.cnCallExpressions}`);
-    out(`tv(...) call sites: ${analyzeReport.tvCallExpressions}`);
-    out(`\nLong cn(...) string literals (≥${LONG_STRING_TOKEN_THRESHOLD} tokens — consider splitting arguments): ${analyzeReport.longCnStringLiterals.length}`);
-    for (const findingEntry of analyzeReport.longCnStringLiterals.slice(0, MAX_REPORT_LINES)) {
-        out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
-    }
-    if (analyzeReport.longCnStringLiterals.length > MAX_REPORT_LINES) {
-        out(`  … and ${analyzeReport.longCnStringLiterals.length - MAX_REPORT_LINES} more`);
-    }
-    out(`\nLong tv({...}) string literals in base/variants/… (≥${LONG_STRING_TOKEN_THRESHOLD} tokens): ${analyzeReport.longTvStringLiterals.length}`);
-    for (const findingEntry of analyzeReport.longTvStringLiterals.slice(0, MAX_REPORT_LINES)) {
-        out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
-    }
-    if (analyzeReport.longTvStringLiterals.length > MAX_REPORT_LINES) {
-        out(`  … and ${analyzeReport.longTvStringLiterals.length - MAX_REPORT_LINES} more`);
-    }
-    out(`\nJSX className="..." or className={'...'} (static strings, ≥${LONG_STRING_TOKEN_THRESHOLD} tokens): ${analyzeReport.longJsxClassNameLiterals.length}`);
-    for (const findingEntry of analyzeReport.longJsxClassNameLiterals.slice(0, MAX_REPORT_LINES)) {
-        out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
-    }
-    if (analyzeReport.longJsxClassNameLiterals.length > MAX_REPORT_LINES) {
-        out(`  … and ${analyzeReport.longJsxClassNameLiterals.length - MAX_REPORT_LINES} more`);
-    }
-    out(`\ncn(...) nested inside tv({...}) (prefer a string or array — preview/apply can rewrite): ${analyzeReport.cnInsideTvCalls.length}`);
-    for (const findingEntry of analyzeReport.cnInsideTvCalls.slice(0, MAX_REPORT_LINES)) {
-        out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.argCount} args)  ${findingEntry.preview}`);
-    }
-    if (analyzeReport.cnInsideTvCalls.length > MAX_REPORT_LINES) {
-        out(`  … and ${analyzeReport.cnInsideTvCalls.length - MAX_REPORT_LINES} more`);
-    }
-}

package/dist/lib/arrange/presentation/resolve-arrange-cli-target.presenter.d.ts

@@ -1,2 +0,0 @@
-export declare function resolveArrangeCliTargetPath(currentWorkingDirectory: string, target: string | undefined): string;
-//# sourceMappingURL=resolve-arrange-cli-target.presenter.d.ts.map

package/dist/lib/arrange/presentation/resolve-arrange-cli-target.presenter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-arrange-cli-target.presenter.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/presentation/resolve-arrange-cli-target.presenter.ts"],"names":[],"mappings":"AAGA,wBAAgB,2BAA2B,CACzC,uBAAuB,EAAE,MAAM,EAC/B,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,MAAM,CAIR"}

package/dist/lib/arrange/presentation/resolve-arrange-cli-target.presenter.js

@@ -1,7 +0,0 @@
-import path from "node:path";
-import { DEFAULT_ARRANGE_TARGET } from "#lib/arrange/domain/constants.domain";
-export function resolveArrangeCliTargetPath(currentWorkingDirectory, target) {
-    return target
-        ? path.resolve(target)
-        : path.resolve(currentWorkingDirectory, DEFAULT_ARRANGE_TARGET);
-}

package/dist/lib/config/domain/schema.domain.d.ts

@@ -1,50 +0,0 @@
-import { z } from "zod";
-export type CodefastAfterWriteHook = (ctx: {
-    files: string[];
-}) => void | Promise<void>;
-export declare const hookSchema: z.ZodCustom<CodefastAfterWriteHook, CodefastAfterWriteHook>;
-export declare const mirrorConfigSchema: z.ZodObject<{
-    skipPackages: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    pathTransformations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        removePrefix: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-    customExports: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>>;
-    cssExports: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
-        enabled: z.ZodOptional<z.ZodBoolean>;
-        customExports: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        forceExportFiles: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>]>>>;
-}, z.core.$strict>;
-export declare const codefastTagConfigSchema: z.ZodObject<{
-    skipPackages: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    onAfterWrite: z.ZodOptional<z.ZodCustom<CodefastAfterWriteHook, CodefastAfterWriteHook>>;
-}, z.core.$strict>;
-export declare const codefastArrangeConfigSchema: z.ZodObject<{
-    onAfterWrite: z.ZodOptional<z.ZodCustom<CodefastAfterWriteHook, CodefastAfterWriteHook>>;
-}, z.core.$strict>;
-export declare const codefastConfigSchema: z.ZodObject<{
-    mirror: z.ZodOptional<z.ZodObject<{
-        skipPackages: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        pathTransformations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            removePrefix: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>>;
-        customExports: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>>;
-        cssExports: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
-            enabled: z.ZodOptional<z.ZodBoolean>;
-            customExports: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-            forceExportFiles: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strict>]>>>;
-    }, z.core.$strict>>;
-    tag: z.ZodOptional<z.ZodObject<{
-        skipPackages: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        onAfterWrite: z.ZodOptional<z.ZodCustom<CodefastAfterWriteHook, CodefastAfterWriteHook>>;
-    }, z.core.$strict>>;
-    arrange: z.ZodOptional<z.ZodObject<{
-        onAfterWrite: z.ZodOptional<z.ZodCustom<CodefastAfterWriteHook, CodefastAfterWriteHook>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type MirrorConfig = z.infer<typeof mirrorConfigSchema>;
-export type CodefastTagConfig = z.infer<typeof codefastTagConfigSchema>;
-export type CodefastArrangeConfig = z.infer<typeof codefastArrangeConfigSchema>;
-export type CodefastConfig = z.infer<typeof codefastConfigSchema>;
-//# sourceMappingURL=schema.domain.d.ts.map

package/dist/lib/config/domain/schema.domain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.domain.d.ts","sourceRoot":"","sources":["../../../../src/lib/config/domain/schema.domain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,sBAAsB,GAAG,CAAC,GAAG,EAAE;IAAE,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAExF,eAAO,MAAM,UAAU,6DAErB,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;kBAuBpB,CAAC;AAEZ,eAAO,MAAM,uBAAuB;;;kBAKzB,CAAC;AAEZ,eAAO,MAAM,2BAA2B;;kBAI7B,CAAC;AAEZ,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;kBAMtB,CAAC;AAEZ,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/lib/config/domain/schema.domain.js

@@ -1,43 +0,0 @@
-import { z } from "zod";
-export const hookSchema = z.custom((value) => typeof value === "function", {
-    message: "Expected a function",
-});
-export const mirrorConfigSchema = z
-    .object({
-    skipPackages: z.array(z.string()).optional(),
-    pathTransformations: z
-        .record(z.string(), z.object({ removePrefix: z.string().optional() }).strict())
-        .optional(),
-    customExports: z.record(z.string(), z.record(z.string(), z.string())).optional(),
-    cssExports: z
-        .record(z.string(), z.union([
-        z.boolean(),
-        z
-            .object({
-            enabled: z.boolean().optional(),
-            customExports: z.record(z.string(), z.string()).optional(),
-            forceExportFiles: z.boolean().optional(),
-        })
-            .strict(),
-    ]))
-        .optional(),
-})
-    .strict();
-export const codefastTagConfigSchema = z
-    .object({
-    skipPackages: z.array(z.string()).optional(),
-    onAfterWrite: hookSchema.optional(),
-})
-    .strict();
-export const codefastArrangeConfigSchema = z
-    .object({
-    onAfterWrite: hookSchema.optional(),
-})
-    .strict();
-export const codefastConfigSchema = z
-    .object({
-    mirror: mirrorConfigSchema.optional(),
-    tag: codefastTagConfigSchema.optional(),
-    arrange: codefastArrangeConfigSchema.optional(),
-})
-    .strict();

package/dist/lib/config/index.d.ts

@@ -1,4 +0,0 @@
-export { loadConfig, resetConfigLoaderCacheForTests } from "#lib/config/infra/loader.adapter";
-export { codefastArrangeConfigSchema, codefastConfigSchema, codefastTagConfigSchema, hookSchema, mirrorConfigSchema, } from "#lib/config/domain/schema.domain";
-export type { CodefastAfterWriteHook, CodefastArrangeConfig, CodefastConfig, CodefastTagConfig, MirrorConfig, } from "#lib/config/domain/schema.domain";
-//# sourceMappingURL=index.d.ts.map

package/dist/lib/config/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,8BAA8B,EAAE,MAAM,kCAAkC,CAAC;AAC9F,OAAO,EACL,2BAA2B,EAC3B,oBAAoB,EACpB,uBAAuB,EACvB,UAAU,EACV,kBAAkB,GACnB,MAAM,kCAAkC,CAAC;AAC1C,YAAY,EACV,sBAAsB,EACtB,qBAAqB,EACrB,cAAc,EACd,iBAAiB,EACjB,YAAY,GACb,MAAM,kCAAkC,CAAC"}

package/dist/lib/config/index.js

@@ -1,2 +0,0 @@
-export { loadConfig, resetConfigLoaderCacheForTests } from "#lib/config/infra/loader.adapter";
-export { codefastArrangeConfigSchema, codefastConfigSchema, codefastTagConfigSchema, hookSchema, mirrorConfigSchema, } from "#lib/config/domain/schema.domain";

package/dist/lib/config/infra/loader.adapter.d.ts

@@ -1,11 +0,0 @@
-import type { CliFs } from "#lib/infra/fs-contract.port";
-import type { CodefastConfig } from "#lib/config/domain/schema.domain";
-type LoadConfigResult = {
-    config: CodefastConfig;
-    warnings: string[];
-    configPath?: string;
-};
-export declare function loadConfig(fs: CliFs, startDir?: string): Promise<LoadConfigResult>;
-export declare function resetConfigLoaderCacheForTests(): void;
-export {};
-//# sourceMappingURL=loader.adapter.d.ts.map

package/dist/lib/config/infra/loader.adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"loader.adapter.d.ts","sourceRoot":"","sources":["../../../../src/lib/config/infra/loader.adapter.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAEzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AASvE,KAAK,gBAAgB,GAAG;IACtB,MAAM,EAAE,cAAc,CAAC;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAkFF,wBAAsB,UAAU,CAAC,EAAE,EAAE,KAAK,EAAE,QAAQ,SAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAM/F;AAED,wBAAgB,8BAA8B,IAAI,IAAI,CAErD"}

package/dist/lib/config/infra/loader.adapter.js

@@ -1,90 +0,0 @@
-import path from "node:path";
-import process from "node:process";
-import jiti from "jiti";
-import { ZodError } from "zod";
-import { codefastConfigSchema } from "#lib/config/domain/schema.domain";
-const CONFIG_JS_PRIORITY = [
-    "codefast.config.mjs",
-    "codefast.config.js",
-    "codefast.config.cjs",
-];
-const CONFIG_JSON = "codefast.config.json";
-const cachedLoads = new Map();
-function formatZodError(error, filePath) {
-    const formatted = error.issues
-        .map((issue) => {
-        const pathLabel = issue.path.length > 0 ? issue.path.join(".") : "<root>";
-        return `  - ${pathLabel}: ${issue.message}`;
-    })
-        .join("\n");
-    return `Invalid config schema in ${path.basename(filePath)}:\n${formatted}`;
-}
-function parseLoadedConfig(raw, filePath) {
-    try {
-        return codefastConfigSchema.parse(raw);
-    }
-    catch (caughtError) {
-        if (caughtError instanceof ZodError) {
-            throw new Error(formatZodError(caughtError, filePath));
-        }
-        throw caughtError;
-    }
-}
-function listConfigCandidates(startDir, fs) {
-    const candidates = [];
-    let current = path.resolve(startDir);
-    while (true) {
-        for (const name of CONFIG_JS_PRIORITY) {
-            const candidate = path.join(current, name);
-            if (fs.existsSync(candidate)) {
-                candidates.push(candidate);
-            }
-        }
-        const jsonCandidate = path.join(current, CONFIG_JSON);
-        if (fs.existsSync(jsonCandidate)) {
-            candidates.push(jsonCandidate);
-        }
-        const parent = path.dirname(current);
-        if (parent === current) {
-            break;
-        }
-        current = parent;
-    }
-    return candidates;
-}
-async function readConfigFromPath(filePath, fs) {
-    const ext = path.extname(filePath);
-    if (ext === ".json") {
-        const content = await fs.readFile(filePath, "utf8");
-        return parseLoadedConfig(JSON.parse(content), filePath);
-    }
-    const loadWithJiti = jiti(process.cwd(), {
-        interopDefault: true,
-        moduleCache: false,
-    });
-    const moduleConfig = loadWithJiti(filePath);
-    const unwrappedConfig = typeof moduleConfig === "object" && moduleConfig !== null && "default" in moduleConfig
-        ? moduleConfig.default
-        : moduleConfig;
-    return parseLoadedConfig(unwrappedConfig, filePath);
-}
-async function loadOnce(fs, startDir) {
-    const warnings = [];
-    const configPaths = listConfigCandidates(startDir, fs);
-    if (configPaths.length === 0) {
-        return { config: {}, warnings };
-    }
-    const configPath = configPaths[0];
-    const config = await readConfigFromPath(configPath, fs);
-    return { config, warnings, configPath };
-}
-export async function loadConfig(fs, startDir = process.cwd()) {
-    const cacheKey = path.resolve(startDir);
-    if (!cachedLoads.has(cacheKey)) {
-        cachedLoads.set(cacheKey, loadOnce(fs, cacheKey));
-    }
-    return cachedLoads.get(cacheKey);
-}
-export function resetConfigLoaderCacheForTests() {
-    cachedLoads.clear();
-}

package/dist/lib/core/application/architecture-boundaries.policy.d.ts

@@ -1,19 +0,0 @@
-export type LibSourceLocation = {
-    readonly context: string;
-    readonly layer: string;
-};
-/**
- * Extract `#lib/...` and relative import specifiers from TypeScript source (static `from` / `import("...")` only).
- */
-export declare function extractImportSpecifiers(sourceText: string): string[];
-export declare function parseLibSourceLocation(absoluteFilePath: string): LibSourceLocation | null;
-export declare function isArchitectureExcludedSourceFile(absoluteFilePath: string): boolean;
-/**
- * Returns human-readable violations for a single file's imports (for unit tests and tooling).
- */
-export declare function violationsForFileContent(absoluteFilePath: string, loc: LibSourceLocation, sourceText: string): string[];
-/**
- * Scans `packages/cli/src/lib` for explicit-architecture boundary violations (non-test sources only).
- */
-export declare function scanCliPackageArchitectureViolations(cliPackageRoot: string): string[];
-//# sourceMappingURL=architecture-boundaries.policy.d.ts.map

package/dist/lib/core/application/architecture-boundaries.policy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"architecture-boundaries.policy.d.ts","sourceRoot":"","sources":["../../../../src/lib/core/application/architecture-boundaries.policy.ts"],"names":[],"mappings":"AAoBA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAkBpE;AAYD,wBAAgB,sBAAsB,CAAC,gBAAgB,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CA8BzF;AAED,wBAAgB,gCAAgC,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAMlF;AA2QD;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,gBAAgB,EAAE,MAAM,EACxB,GAAG,EAAE,iBAAiB,EACtB,UAAU,EAAE,MAAM,GACjB,MAAM,EAAE,CA6BV;AAuBD;;GAEG;AACH,wBAAgB,oCAAoC,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,EAAE,CAYrF"}

package/dist/lib/core/application/architecture-boundaries.policy.js

@@ -1,370 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-/** Product bounded contexts: no direct cross-imports between these (domain + application rules). */
-const PRODUCT_BOUNDED_CONTEXTS = new Set(["arrange", "mirror", "tag"]);
-const SHARED_SOURCE_CODE_CONTEXT = "shared-source-code";
-const LAYERS = new Set(["domain", "application", "infra", "presentation"]);
-/** Import roots that any product slice may depend on without going "through" another slice. */
-const NEUTRAL_LIB_IMPORT_ROOTS = new Set(["core", "config", "infra", "shared"]);
-function sharedSourceCodeLayerFromSpecifier(segments) {
-    if (segments.length < 3 || segments[0] !== "shared" || segments[1] !== "source-code") {
-        return null;
-    }
-    return segments[2];
-}
-/**
- * Extract `#lib/...` and relative import specifiers from TypeScript source (static `from` / `import("...")` only).
- */
-export function extractImportSpecifiers(sourceText) {
-    const specifiers = [];
-    const fromPattern = /\bfrom\s+["']([^"']+)["']/g;
-    let fromMatch;
-    while ((fromMatch = fromPattern.exec(sourceText)) !== null) {
-        specifiers.push(fromMatch[1]);
-    }
-    const importOnlyPattern = /^\s*import\s+["']([^"']+)["']\s*;/gm;
-    let importOnlyMatch;
-    while ((importOnlyMatch = importOnlyPattern.exec(sourceText)) !== null) {
-        specifiers.push(importOnlyMatch[1]);
-    }
-    const importCallPattern = /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g;
-    let importCallMatch;
-    while ((importCallMatch = importCallPattern.exec(sourceText)) !== null) {
-        specifiers.push(importCallMatch[1]);
-    }
-    return specifiers;
-}
-function pathUnderCliSrcLib(absolutePath) {
-    const normalized = path.normalize(absolutePath);
-    const marker = `${path.sep}src${path.sep}lib${path.sep}`;
-    const index = normalized.lastIndexOf(marker);
-    if (index === -1) {
-        return null;
-    }
-    return normalized.slice(index + marker.length);
-}
-export function parseLibSourceLocation(absoluteFilePath) {
-    const tail = pathUnderCliSrcLib(absoluteFilePath);
-    if (tail === null) {
-        return null;
-    }
-    const parts = tail.split(path.sep).filter(Boolean);
-    if (parts.length < 2) {
-        return null;
-    }
-    if (parts[0] === "shared" && parts[1] === "source-code" && parts.length >= 3) {
-        const layer = parts[2];
-        if (!LAYERS.has(layer)) {
-            return null;
-        }
-        const rest = parts.slice(3);
-        if (layer === "domain" && rest[0] === "__tests__") {
-            return { context: SHARED_SOURCE_CODE_CONTEXT, layer: "domain" };
-        }
-        return { context: SHARED_SOURCE_CODE_CONTEXT, layer };
-    }
-    const [context, layer, ...rest] = parts;
-    if (!LAYERS.has(layer)) {
-        return null;
-    }
-    if (layer === "domain" && rest[0] === "__tests__") {
-        return { context, layer };
-    }
-    return { context, layer };
-}
-export function isArchitectureExcludedSourceFile(absoluteFilePath) {
-    const base = path.basename(absoluteFilePath);
-    if (base.endsWith(".test.ts") || base.endsWith(".integration.test.ts")) {
-        return true;
-    }
-    return absoluteFilePath.split(path.sep).includes("__tests__");
-}
-function resolveRelativeSpecifier(fromAbsoluteFile, specifier) {
-    if (!specifier.startsWith(".")) {
-        return null;
-    }
-    const dir = path.dirname(fromAbsoluteFile);
-    const resolved = path.normalize(path.join(dir, specifier));
-    return resolved;
-}
-function libTailAfterResolution(absoluteResolved) {
-    const tail = pathUnderCliSrcLib(absoluteResolved);
-    if (tail === null) {
-        return null;
-    }
-    return tail.split(path.sep).filter(Boolean);
-}
-function lastSegmentOfLibSpecifier(specifier) {
-    if (!specifier.startsWith("#lib/")) {
-        return null;
-    }
-    const segments = specifier.slice("#lib/".length).split("/").filter(Boolean);
-    return segments.length > 0 ? segments[segments.length - 1] : null;
-}
-function importedModuleStem(specifier, fromAbsoluteFile) {
-    if (specifier.startsWith("#lib/")) {
-        return lastSegmentOfLibSpecifier(specifier);
-    }
-    const resolved = resolveRelativeSpecifier(fromAbsoluteFile, specifier);
-    if (resolved === null) {
-        return null;
-    }
-    const withTsExtension = resolved.endsWith(".ts") ? resolved : `${resolved}.ts`;
-    const baseName = path.basename(withTsExtension);
-    return baseName.endsWith(".ts") ? baseName.slice(0, -".ts".length) : baseName;
-}
-function isPureDomainOrModelFileName(fileBaseName) {
-    return /\.(domain|model)\.ts$/.test(fileBaseName);
-}
-function isRuleAForbiddenImportedStem(moduleStem) {
-    return (moduleStem.includes(".use-case") ||
-        moduleStem.includes(".adapter") ||
-        moduleStem.includes(".presenter"));
-}
-function isRuleBForbiddenImportedStem(moduleStem) {
-    return moduleStem.includes(".adapter") || moduleStem.includes(".presenter");
-}
-function violationRuleAPureDomainModel(absoluteFilePath, fileBaseName, specifier) {
-    if (!isPureDomainOrModelFileName(fileBaseName)) {
-        return null;
-    }
-    const stem = importedModuleStem(specifier, absoluteFilePath);
-    if (stem === null || !isRuleAForbiddenImportedStem(stem)) {
-        return null;
-    }
-    return `${absoluteFilePath}: Rule A (pure domain/model) must not import orchestration or IO modules — blocked ${specifier} (stem "${stem}")`;
-}
-function violationRuleBApplicationIsolation(loc, absoluteFilePath, specifier) {
-    if (loc.layer !== "application") {
-        return null;
-    }
-    const stem = importedModuleStem(specifier, absoluteFilePath);
-    if (stem === null || !isRuleBForbiddenImportedStem(stem)) {
-        return null;
-    }
-    return `${absoluteFilePath}: Rule B (application isolation) must not import adapters or presenters — blocked ${specifier} (stem "${stem}")`;
-}
-function violationRuleCAntiCrossSlice(loc, specifier, fromAbsoluteFile) {
-    if (!PRODUCT_BOUNDED_CONTEXTS.has(loc.context)) {
-        return null;
-    }
-    if (specifier.startsWith("#lib/")) {
-        const segments = specifier.slice("#lib/".length).split("/").filter(Boolean);
-        if (segments.length === 0) {
-            return null;
-        }
-        const importedRoot = segments[0];
-        if (NEUTRAL_LIB_IMPORT_ROOTS.has(importedRoot)) {
-            return null;
-        }
-        if (importedRoot === loc.context) {
-            return null;
-        }
-        if (PRODUCT_BOUNDED_CONTEXTS.has(importedRoot)) {
-            return `${fromAbsoluteFile}: Rule C (slice isolation) context "${loc.context}" must not import "${specifier}" — use #lib/shared/... or neutral roots (core, config, infra) instead`;
-        }
-        return null;
-    }
-    const resolved = resolveRelativeSpecifier(fromAbsoluteFile, specifier);
-    if (resolved === null) {
-        return null;
-    }
-    const resolvedPath = resolved.endsWith(".ts") ? resolved : `${resolved}.ts`;
-    const parts = libTailAfterResolution(resolvedPath);
-    if (parts === null || parts.length === 0) {
-        return null;
-    }
-    const importedContext = parts[0];
-    if (NEUTRAL_LIB_IMPORT_ROOTS.has(importedContext)) {
-        return null;
-    }
-    if (importedContext === loc.context) {
-        return null;
-    }
-    if (PRODUCT_BOUNDED_CONTEXTS.has(importedContext)) {
-        return `${fromAbsoluteFile}: Rule C (slice isolation) context "${loc.context}" must not resolve into sibling slice via ${specifier}`;
-    }
-    return null;
-}
-function violationDomainLayer(loc, specifier, fromAbsoluteFile) {
-    if (specifier.startsWith("#lib/")) {
-        const segments = specifier.slice("#lib/".length).split("/").filter(Boolean);
-        if (segments.length === 0) {
-            return null;
-        }
-        if (segments[0] === "infra") {
-            return `${fromAbsoluteFile}: domain must not import ${specifier}`;
-        }
-        const sharedLayerImported = sharedSourceCodeLayerFromSpecifier(segments);
-        if (sharedLayerImported !== null && sharedLayerImported !== "domain") {
-            return `${fromAbsoluteFile}: domain must not import ${specifier}`;
-        }
-        if (segments[0] === loc.context && segments.length >= 2) {
-            const importLayer = segments[1];
-            if (importLayer === "application" ||
-                importLayer === "infra" ||
-                importLayer === "presentation") {
-                return `${fromAbsoluteFile}: domain must not import ${specifier}`;
-            }
-        }
-        if (segments.length >= 2 &&
-            segments[1] === "domain" &&
-            PRODUCT_BOUNDED_CONTEXTS.has(segments[0]) &&
-            segments[0] !== loc.context) {
-            return `${fromAbsoluteFile}: domain (${loc.context}) must not import other bounded context domain ${specifier}`;
-        }
-        if (loc.context === "core" &&
-            segments.length >= 2 &&
-            segments[1] === "domain" &&
-            PRODUCT_BOUNDED_CONTEXTS.has(segments[0])) {
-            return `${fromAbsoluteFile}: core/domain must not import bounded context domain ${specifier}`;
-        }
-        if (loc.context === "config" &&
-            segments.length >= 2 &&
-            segments[1] === "domain" &&
-            PRODUCT_BOUNDED_CONTEXTS.has(segments[0])) {
-            return `${fromAbsoluteFile}: config/domain must not import bounded context domain ${specifier}`;
-        }
-        if (loc.context === SHARED_SOURCE_CODE_CONTEXT && PRODUCT_BOUNDED_CONTEXTS.has(segments[0])) {
-            return `${fromAbsoluteFile}: shared source-code domain must not import product context ${specifier}`;
-        }
-        return null;
-    }
-    const resolved = resolveRelativeSpecifier(fromAbsoluteFile, specifier);
-    if (resolved === null) {
-        return null;
-    }
-    const parts = libTailAfterResolution(resolved);
-    if (parts === null || parts.length < 2) {
-        return null;
-    }
-    const [relCtx, relLayer] = parts;
-    if (relCtx === "infra") {
-        return `${fromAbsoluteFile}: domain must not resolve into infra via ${specifier}`;
-    }
-    if (relCtx === loc.context) {
-        if (relLayer === "application" || relLayer === "infra" || relLayer === "presentation") {
-            return `${fromAbsoluteFile}: domain must not resolve into ${relLayer} via ${specifier}`;
-        }
-    }
-    if (relLayer === "domain" && PRODUCT_BOUNDED_CONTEXTS.has(relCtx) && relCtx !== loc.context) {
-        return `${fromAbsoluteFile}: domain must not resolve into other bounded context domain via ${specifier}`;
-    }
-    if (loc.context === "core" && relLayer === "domain" && PRODUCT_BOUNDED_CONTEXTS.has(relCtx)) {
-        return `${fromAbsoluteFile}: core/domain must not resolve into bounded context domain via ${specifier}`;
-    }
-    return null;
-}
-function violationApplicationLayer(loc, specifier, fromAbsoluteFile) {
-    if (specifier.startsWith("#lib/")) {
-        const segments = specifier.slice("#lib/".length).split("/").filter(Boolean);
-        if (segments.length === 0) {
-            return null;
-        }
-        if (segments[0] === "infra") {
-            return `${fromAbsoluteFile}: application must not import ${specifier}`;
-        }
-        const sharedLayerImported = sharedSourceCodeLayerFromSpecifier(segments);
-        if (sharedLayerImported === "infra" ||
-            sharedLayerImported === "presentation" ||
-            sharedLayerImported === "application") {
-            return `${fromAbsoluteFile}: application must not import ${specifier}`;
-        }
-        if (segments.length >= 2 && (segments[1] === "infra" || segments[1] === "presentation")) {
-            return `${fromAbsoluteFile}: application must not import ${specifier}`;
-        }
-        if (PRODUCT_BOUNDED_CONTEXTS.has(loc.context) &&
-            PRODUCT_BOUNDED_CONTEXTS.has(segments[0]) &&
-            segments[0] !== loc.context) {
-            return `${fromAbsoluteFile}: application (${loc.context}) must not import ${specifier}`;
-        }
-        return null;
-    }
-    const resolved = resolveRelativeSpecifier(fromAbsoluteFile, specifier);
-    if (resolved === null) {
-        return null;
-    }
-    const parts = libTailAfterResolution(resolved);
-    if (parts === null || parts.length < 2) {
-        return null;
-    }
-    const [relCtx, relLayer] = parts;
-    if (relCtx === "infra") {
-        return `${fromAbsoluteFile}: application must not resolve into infra via ${specifier}`;
-    }
-    if (relLayer === "infra" || relLayer === "presentation") {
-        return `${fromAbsoluteFile}: application must not resolve into ${relLayer} via ${specifier}`;
-    }
-    return null;
-}
-/**
- * Returns human-readable violations for a single file's imports (for unit tests and tooling).
- */
-export function violationsForFileContent(absoluteFilePath, loc, sourceText) {
-    const violations = [];
-    const fileBaseName = path.basename(absoluteFilePath);
-    for (const specifier of extractImportSpecifiers(sourceText)) {
-        const ruleA = violationRuleAPureDomainModel(absoluteFilePath, fileBaseName, specifier);
-        if (ruleA !== null) {
-            violations.push(ruleA);
-        }
-        const ruleB = violationRuleBApplicationIsolation(loc, absoluteFilePath, specifier);
-        if (ruleB !== null) {
-            violations.push(ruleB);
-        }
-        const ruleC = violationRuleCAntiCrossSlice(loc, specifier, absoluteFilePath);
-        if (ruleC !== null) {
-            violations.push(ruleC);
-        }
-        if (loc.layer === "domain") {
-            const domainViolation = violationDomainLayer(loc, specifier, absoluteFilePath);
-            if (domainViolation !== null) {
-                violations.push(domainViolation);
-            }
-        }
-        else if (loc.layer === "application") {
-            const appViolation = violationApplicationLayer(loc, specifier, absoluteFilePath);
-            if (appViolation !== null) {
-                violations.push(appViolation);
-            }
-        }
-    }
-    return [...new Set(violations)];
-}
-function walkNonTestTsFiles(rootDir) {
-    const results = [];
-    const scan = (dir) => {
-        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-            const full = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                if (entry.name === "node_modules" || entry.name === "dist") {
-                    continue;
-                }
-                scan(full);
-            }
-            else if (entry.isFile() && entry.name.endsWith(".ts")) {
-                if (!isArchitectureExcludedSourceFile(full)) {
-                    results.push(full);
-                }
-            }
-        }
-    };
-    scan(rootDir);
-    return results;
-}
-/**
- * Scans `packages/cli/src/lib` for explicit-architecture boundary violations (non-test sources only).
- */
-export function scanCliPackageArchitectureViolations(cliPackageRoot) {
-    const libRoot = path.join(cliPackageRoot, "src", "lib");
-    const violations = [];
-    for (const absoluteFilePath of walkNonTestTsFiles(libRoot)) {
-        const loc = parseLibSourceLocation(absoluteFilePath);
-        if (loc === null) {
-            continue;
-        }
-        const sourceText = fs.readFileSync(absoluteFilePath, "utf8");
-        violations.push(...violationsForFileContent(absoluteFilePath, loc, sourceText));
-    }
-    return violations;
-}