@codefast/cli 0.3.13-canary.0 → 0.3.13-canary.2

package/dist/lib/arrange/presentation/report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/presentation/report.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE/D,wBAAgB,kBAAkB,CAChC,wBAAwB,EAAE,MAAM,EAChC,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,SAAS,GAChB,IAAI,CAkDN"}

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

@@ -0,0 +1,37 @@
+import path from "node:path";
+import { LONG_STRING_TOKEN_THRESHOLD, MAX_REPORT_LINES } from "#lib/arrange/domain/constants";
+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/config/domain/schema.d.ts

@@ -0,0 +1,50 @@
+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.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/lib/config/domain/schema.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.js

@@ -0,0 +1,43 @@
+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

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

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

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

package/dist/lib/config/index.js

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

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

@@ -0,0 +1,11 @@
+import type { CliFs } from "#lib/infra/fs-contract";
+import type { CodefastConfig } from "#lib/config/domain/schema";
+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.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../../src/lib/config/infra/loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAEpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAShE,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.js

@@ -0,0 +1,90 @@
+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";
+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.d.ts

@@ -0,0 +1,19 @@
+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.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"architecture-boundaries.d.ts","sourceRoot":"","sources":["../../../../src/lib/core/application/architecture-boundaries.ts"],"names":[],"mappings":"AAiBA,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;AAyJD;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,gBAAgB,EAAE,MAAM,EACxB,GAAG,EAAE,iBAAiB,EACtB,UAAU,EAAE,MAAM,GACjB,MAAM,EAAE,CAgBV;AAuBD;;GAEG;AACH,wBAAgB,oCAAoC,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,EAAE,CAYrF"}

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

@@ -0,0 +1,263 @@
+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"]);
+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 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 = [];
+    for (const specifier of extractImportSpecifiers(sourceText)) {
+        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 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 || (loc.layer !== "domain" && loc.layer !== "application")) {
+            continue;
+        }
+        const sourceText = fs.readFileSync(absoluteFilePath, "utf8");
+        violations.push(...violationsForFileContent(absoluteFilePath, loc, sourceText));
+    }
+    return violations;
+}

package/dist/lib/core/application/ports/cli-io.port.d.ts

@@ -0,0 +1,27 @@
+import type { Dirent } from "node:fs";
+/**
+ * Filesystem surface for CLI use cases — inject in tests. Implementations live in infra.
+ */
+export type CliFs = {
+    existsSync: (path: string) => boolean;
+    statSync: (path: string) => {
+        isDirectory: () => boolean;
+        isFile: () => boolean;
+    };
+    readFileSync: (path: string, encoding: BufferEncoding) => string;
+    writeFileSync: (path: string, data: string, encoding: BufferEncoding) => void;
+    readdirSync: (path: string) => string[];
+    readFile: (path: string, encoding: BufferEncoding) => Promise<string>;
+    writeFile: (path: string, data: string, encoding: BufferEncoding) => Promise<void>;
+    readdir: (path: string, options?: {
+        recursive?: boolean;
+        withFileTypes?: boolean;
+    }) => Promise<string[] | Dirent[]>;
+    rename: (oldPath: string, newPath: string) => Promise<void>;
+    unlink: (path: string) => Promise<void>;
+};
+export type CliLogger = {
+    out: (line: string) => void;
+    err: (line: string) => void;
+};
+//# sourceMappingURL=cli-io.port.d.ts.map

package/dist/lib/core/application/ports/cli-io.port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-io.port.d.ts","sourceRoot":"","sources":["../../../../../src/lib/core/application/ports/cli-io.port.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEtC;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG;IAClB,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IACtC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK;QAAE,WAAW,EAAE,MAAM,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,OAAO,CAAA;KAAE,CAAC;IAClF,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,KAAK,MAAM,CAAC;IACjE,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,KAAK,IAAI,CAAC;IAC9E,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC;IACxC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACtE,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACnF,OAAO,EAAE,CACP,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,aAAa,CAAC,EAAE,OAAO,CAAA;KAAE,KACvD,OAAO,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;IAClC,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7B,CAAC"}

package/dist/lib/core/application/schema-parse.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import { type AppError } from "#lib/core/domain/errors";
+import { type Result } from "#lib/core/domain/result";
+/**
+ * Validates `input` with `schema`, returning {@link AppError} with code `VALIDATION_ERROR` on failure.
+ */
+export declare function parseWithSchema<T>(schema: z.ZodType<T>, input: unknown): Result<T, AppError>;
+//# sourceMappingURL=schema-parse.d.ts.map

package/dist/lib/core/application/schema-parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-parse.d.ts","sourceRoot":"","sources":["../../../../src/lib/core/application/schema-parse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAW/D;;GAEG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,CAAC,EAAE,QAAQ,CAAC,CAM5F"}

package/dist/lib/core/application/schema-parse.js

@@ -0,0 +1,20 @@
+import { appError } from "#lib/core/domain/errors";
+import { err, ok } from "#lib/core/domain/result";
+function formatZodIssues(issues) {
+    return issues
+        .map((issue) => {
+        const path = issue.path.length > 0 ? `${issue.path.join(".")}: ` : "";
+        return `${path}${issue.message}`;
+    })
+        .join("; ");
+}
+/**
+ * Validates `input` with `schema`, returning {@link AppError} with code `VALIDATION_ERROR` on failure.
+ */
+export function parseWithSchema(schema, input) {
+    const parsed = schema.safeParse(input);
+    if (!parsed.success) {
+        return err(appError("VALIDATION_ERROR", formatZodIssues(parsed.error.issues)));
+    }
+    return ok(parsed.data);
+}

package/dist/lib/core/application/utils/caught-unknown-message.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Stable, user-facing text for values caught as `unknown`.
+ * Avoids `String(unknown)` / `[object Object]` and satisfies strict `no-base-to-string`.
+ */
+export declare function messageFromCaughtUnknown(value: unknown): string;
+//# sourceMappingURL=caught-unknown-message.d.ts.map

package/dist/lib/core/application/utils/caught-unknown-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"caught-unknown-message.d.ts","sourceRoot":"","sources":["../../../../../src/lib/core/application/utils/caught-unknown-message.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CA4B/D"}