archprint 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,4 @@
+# archprint
+
+Release notes are generated by [Changesets](https://github.com/changesets/changesets) on each release and
+appear here starting with the first published version.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Oluwatomiwa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,268 @@
+# Archprint
+
+**Mine the architecture rules your repo already enforces, with the evidence attached.**
+
+Archprint scans a TypeScript repository's real import graph, finds the architectural boundaries the code
+already respects, and turns the ones that pass a statistical confidence gate into deterministic, ready to
+install lint rules. Every rule ships with the evidence behind it: how many files conform, how many break it,
+and how confident the inference is.
+
+Your `CLAUDE.md` is guidance. Your lint rules are enforcement. Archprint closes the gap by generating the
+enforcement from patterns your codebase already demonstrates, so you adopt rules you can trust instead of
+authoring them by hand.
+
+**What auto-enforces vs. what you review.** Archprint is honest about which of its inferences it will stand
+behind unattended. An adversarial correctness audit (three rounds over four real repositories) found that the
+_mechanical_ families, ones grounded in unambiguous signals (no cycles, production must not import tests, no
+`console` in library code, no undeclared dependencies, deep-relative import style, public-API barrels, no
+reaching into a dependency's internals, and the DB/UI-in-server-entry rule), had zero false positives every
+round. So those auto-generate as enforcement. The _structural-inference_ families (layer and role boundaries,
+UI/data separation, entry purity, server/client, feature-slice and app isolation) infer a "layer" or "role"
+from paths, which can be wrong, so Archprint holds them for human review by default rather than silently
+enforcing them. Nothing whose inferred layer or role could be wrong is written as enforcement without you
+opting in.
+
+> Status: `0.1.0`, pre-stable (0.x may break between minor versions). Not yet published to npm. Production-ready
+> today: the insight commands (`scan`, `recommend`) and the auto-enforcement of the mechanical families above.
+> The structural families are review-only while they are hardened.
+
+## What makes it different
+
+Established TypeScript tools (dependency-cruiser, eslint-plugin-boundaries, Nx, Sheriff, ts-arch) all
+**enforce** architecture rules you write by hand. Archprint **infers** them from the actual import graph and
+**gates each one on statistical evidence** before proposing it. Across the TypeScript ecosystem, no other tool
+does either (see the comparison below). It then emits into those existing tools' formats, so it complements
+your stack rather than replacing it.
+
+## Install
+
+Not yet on npm. For now, build from source:
+
+```bash
+git clone https://github.com/Tommkruix/archprint
+cd archprint
+npm ci
+npm run build
+node dist/cli.js scan <path-to-your-app>
+```
+
+Once published, it will install as a normal dev dependency:
+
+```bash
+npm install --save-dev archprint
+npx archprint scan .
+```
+
+Requires Node >= 20. Point Archprint at an app directory that has a `tsconfig.json` (for a monorepo, a
+package such as `apps/web`; a monorepo root is fine too, Archprint discovers the app directories).
+
+## Quick start
+
+```bash
+# One-shot setup: detect the stack, enforce the rules your code already follows,
+# and record what to adopt next in archprint.json
+archprint init apps/web
+
+# See the rules your repo already follows, with the evidence
+archprint scan apps/web
+
+# Write the auto-trusted (mechanical) rules to disk (rule files + tool configs).
+# Structural-inference rules are held for review; add --include-structural to emit them too.
+archprint generate apps/web --out archprint-rules
+
+# Inspect the gate evidence behind one rule
+archprint explain AP-002 apps/web
+
+# Generate a single rule by id after reviewing it (including a SUGGEST rule)
+archprint generate apps/web --rule AP-001
+
+# Recommend a rule set from the evidence and the detected stack (fresh repos too)
+archprint recommend apps/web
+
+# Reference the generated rules from the enforcement tools your repo uses (managed, reversible)
+archprint wire
+
+# Remove archprint's files and any wired references (clean uninstall)
+archprint eject
+```
+
+Re-running `generate` (or `init`) refreshes the files in `archprint-rules/` and removes any rule the
+evidence no longer supports, so the output never drifts from the current codebase. `wire` detects the
+enforcement tools your repo already uses (a flat eslint config, a `.dependency-cruiser.json`) and inserts a
+single managed reference into each, one that survives those regenerations; `eject` removes archprint's files
+and every wired reference, restoring each config exactly. For a tool config it cannot safely edit (a JS
+dependency-cruiser config, say), it prints the exact snippet to paste. The flagship forbidden-import rules
+(AP-) ship as a generated local eslint plugin that the eslint reference activates, so wiring the eslint config
+enforces them too, no extra install.
+
+`recommend` sorts every rule family into three tiers: rules your code already
+follows (enforce now), rules with thin evidence (review and adopt), and rules that
+comparable repos commonly follow but yours does not yet (adopt from day one). Each
+recommendation carries the evidence behind it: the share of comparable repos (your
+detected stack, else overall) that already enforce that rule, mined from a census of
+tens of thousands of public TypeScript repositories. The "adopt from day one" tier is
+driven by that census rather than hand-picked defaults, so on a fresh repo, where
+there is little code to infer from, it still gives you a stack-aware baseline backed
+by what the ecosystem actually does.
+
+## Example
+
+A real scan of [inbox-zero](https://github.com/elie222/inbox-zero) (`apps/web`, 2,232 TypeScript files),
+trimmed:
+
+```
+Archprint v0.1.0
+Scanned 2,232 TypeScript files
+Workspace aliases: 18 resolved
+
+GENERATED RULES
+  AP-002  no-ui-layer-in-server-entry      confidence 97%
+          Evidence: 216/217 role files conform (99.5% observed)
+          Exceptions: 1
+
+LAYER BOUNDARIES (review before enforcing)
+  utils !-> app  layer boundary   confidence 99%
+          Evidence: 650/653 utils files conform (99.5%); 451 app file(s) depend on utils
+  hooks !-> app  layer boundary   confidence 94%
+          Evidence: 65/65 hooks files conform (100%); 121 app file(s) depend on hooks
+```
+
+`AP-002` is a mechanical family, so it auto-generates as enforcement. The layer boundaries are inferred, so
+they are shown for review, not written as enforcement unless you pass `--include-structural`.
+
+Every number is measured from the import graph, not estimated.
+
+## What Archprint detects
+
+Ships as: **Auto** = auto-generated as enforcement (mechanical families, 0 false positives across the
+correctness audit). **Review** = held for human review by default; emit with `--include-structural` (the
+inferred layer/role can be wrong, so it is not enforced silently). **Report** = surfaced only, never enforced.
+
+| Detector                         | Rule it can infer                                                                                                    | Ships as |
+| -------------------------------- | -------------------------------------------------------------------------------------------------------------------- | -------- |
+| Forbidden imports (marker based) | A role (route handler, server entry) must not import a target (the DB client, the UI layer)                          | Auto     |
+| Circular dependencies            | The module graph should stay acyclic (gated on how cycle free it already is)                                         | Auto     |
+| Test isolation                   | Production (non-test) code must not import test or spec files                                                        | Auto     |
+| Dependency hygiene               | Import third-party packages by their public entry, not a dependency's `src`/`internal` internals                     | Auto     |
+| Dependency declaration           | Every imported third-party package must be declared in `package.json` (no phantom/transitive deps)                   | Auto     |
+| Import style                     | Prefer workspace aliases over deep relative imports (`../../../`)                                                    | Auto     |
+| Console isolation                | Library (non-CLI) code must not call `console.*`                                                                     | Auto     |
+| Public API (barrel) boundaries   | Files outside a feature or package must import it through its `index` barrel, not deep import its internals          | Auto     |
+| Layer boundaries                 | Files in one layer must not import another, inferred from the dominant dependency direction                          | Review   |
+| Role layering                    | Semantic tiers keep their direction (a REPOSITORY must not import a SERVICE, a SERVICE must not import a CONTROLLER) | Review   |
+| Entry purity                     | Framework entries (pages, routes, layouts) must not be imported by other first-party code                            | Review   |
+| UI / data separation             | Reusable UI components must not import the DB/data layer directly                                                    | Review   |
+| Server / client boundary         | A Next.js `"use client"` module must not import a `server-only` module                                               | Review   |
+| Feature-slice isolation          | Sibling slices under a `features`/`modules`/`slices`/`domains` container must not import each other                  | Review   |
+| App isolation                    | Sibling apps under an `apps`/`services` container must not import each other directly                                | Review   |
+| Env access                       | Read `process.env` only in the config/env layer                                                                      | Review   |
+| Workspace package API            | Import a monorepo workspace package by its name, not a deep path into its source                                     | Review   |
+| Stories isolation                | Storybook `.stories` files must not be imported by other code                                                        | Review   |
+| Orphan modules                   | Files nothing imports and that are not framework entries (dead code candidates)                                      | Report   |
+| Transitive reachability          | A layer boundary that a plain import rule passes but that leaks through an intermediary layer                        | Report   |
+
+## The confidence gate
+
+Archprint never proposes a rule as enforceable on a thin sample. Each candidate is scored with a **Wilson
+score lower bound** on its true conformance rate, which fuses the observed ratio and the sample size into one
+number, so 5 of 5 clean files is not treated as evidence of a 90% rule but 40 of 40 is.
+
+- **AUTO** (enforceable): the 95% lower bound on conformance is at least 90%, with at most 3 exceptions and a
+  confidently classified role.
+- **SUGGEST** (provisional): the pattern looks like a rule (at least 80% observed) but the sample is too thin
+  to be confident. Surfaced for review, not auto generated.
+- **REJECT**: not enough signal.
+
+The statistical gate is necessary but not sufficient: a rule can be statistically clean yet semantically wrong
+if the inferred "layer" or "role" is not real. So a second, evidence-based gate sits on top of it: only the
+_mechanical_ families (see the "Ships as: Auto" rows above), which an adversarial correctness audit found had
+zero false positives across three rounds and four repositories, auto-generate as enforcement. The
+_structural-inference_ families are capped at review regardless of their statistical score until they earn the
+same clean record. The bias is deliberate and conservative: one wrong enforced rule hurts credibility more than
+zero rules.
+
+## Output formats
+
+`archprint generate` writes into the formats your existing tools already read:
+
+- **dependency-cruiser** `forbidden` rulesets: by default the mechanical boundaries (public-API deep-import,
+  test-isolation, dependency-internals); the structural ones (layer, role-layering, feature-slice,
+  app-isolation, entry-purity) are written only with `--include-structural`, after you review them
+- **eslint-plugin-boundaries** element-types config, and **ESLint core** rules (`no-restricted-imports`) for
+  import-style boundaries
+- **ESLint rule files** for marker based patterns: a rule card (`.md`), the rule (`.ts`), and a passing and a
+  failing fixture
+- **Mermaid** and **Graphviz DOT** of the layer dependency graph, so the inferred architecture is visible and
+  its violations are marked
+
+## How it compares
+
+Verified against each tool's documentation (TypeScript ecosystem). The two columns that matter are the ones no
+other TypeScript tool fills:
+
+| Tool                          | Enforces arch rules | Auto-infers from the import graph | Attaches statistical evidence |
+| ----------------------------- | :-----------------: | :-------------------------------: | :---------------------------: |
+| **Archprint**                 |         yes         |              **yes**              |            **yes**            |
+| dependency-cruiser            |         yes         |                no                 |              no               |
+| eslint-plugin-boundaries      |         yes         |                no                 |              no               |
+| @nx/enforce-module-boundaries |         yes         |                no                 |              no               |
+| Sheriff                       |         yes         |                no                 |              no               |
+| ts-arch                       |         yes         |                no                 |              no               |
+| madge / knip                  |    analysis only    |                no                 |              no               |
+
+Honest caveat: in other ecosystems, [Tach](https://github.com/gauge-sh/tach) (Python) and ArchLint (Java) do
+auto-infer module boundaries, so Archprint's specific niche is auto-inference **plus statistical evidence
+gating in the TypeScript ecosystem**. Archprint also overlaps in detection with dependency-cruiser (cycles,
+orphans, reachability) and knip (dead code); rather than compete, it emits into those tools' formats.
+
+## Commands
+
+| Command                         | What it does                                                                                                                                                                                                 |
+| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `archprint init [path]`         | Zero-config setup: detect the stack, enforce the rules the code already follows, and write an `archprint.json` with the adopt tiers. `--include-structural`, `--out <dir>`, `--fast`, `--force`.             |
+| `archprint scan [path]`         | Report the rules the repo already follows, with evidence. `--deep` resolves through barrels and aliases.                                                                                                     |
+| `archprint generate [path]`     | Write the auto-trusted mechanical rules + tool configs; structural rules held for review. `--rule <id>` emits one reviewed rule (including a SUGGEST rule). `--include-structural`, `--out <dir>`, `--fast`. |
+| `archprint explain <id> [path]` | Show the gate breakdown for one rule, with a codeframe per exception plus how-to-fix, when-not-to-use, and how-to-enforce.                                                                                   |
+| `archprint recommend [path]`    | Recommend a rule set from the repo's evidence and detected stack (works on a fresh repo too).                                                                                                                |
+| `archprint wire`                | Reference the generated rules from the enforcement tools your repo uses (flat eslint config, `.dependency-cruiser.json`) via a managed, reversible reference. `--out <dir>`, `--dry-run`.                    |
+| `archprint eject`               | Remove archprint's generated files, its manifests, and any wired references. `--out <dir>`, `--dry-run`.                                                                                                     |
+
+## Documentation
+
+Full docs live in [`docs/`](./docs/): [getting started](./docs/getting-started.md),
+[concepts](./docs/concepts.md) (the confidence gate, mechanical vs. structural, fast vs. deep, the
+generate/wire/eject lifecycle), and the [rule-family reference](./docs/rules.md) (what each rule detects, how it
+ships, and when not to use it).
+
+## Fast and deep modes
+
+`scan` defaults to a **fast** specifier level pass (no type checker). `generate` defaults to a
+**deep** pass that resolves through barrels and workspace aliases, since generation is the commitment point.
+Structural analysis (cycles, orphans, reachability, public-API) always uses the fast graph: it is faithful to
+deep resolution for those, and public-API detection in fact requires it (deep resolution would resolve through
+a barrel and erase the barrel-versus-deep signal).
+
+## Determinism
+
+Same repo plus same version produces the same output. Analysis is pure and sorted; there is no randomness.
+
+## Status and roadmap
+
+`0.1.0`, pre-stable. The engine (twenty detectors, five output formats, the confidence gate) is in place and
+tested, and an adversarial correctness audit (three rounds, four real repositories) drove the false-positive
+rate on auto-generated rules to zero for the mechanical families, which is why those auto-enforce while the
+structural-inference families are held for review.
+
+Production-ready today: `scan` and `recommend` (insight), and auto-enforcement of the mechanical families.
+Still ahead: hardening the structural families toward auto-enforcement (a real per-file role-confidence measure,
+layer-cohesion, role-classifier ordering), a self-consistency check at generate time, a pinned regression
+corpus, an `init` scaffolder for fresh repos, and broader framework role coverage.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). The project lints, type checks, and tests itself; every change keeps
+coverage above its thresholds and ships a changeset.
+
+## License
+
+[MIT](LICENSE)

package/dist/cli/codeframe.d.ts

@@ -0,0 +1,6 @@
+export interface CodeFrame {
+    line: number;
+    text: string;
+}
+export declare function locateImport(appDir: string, relativeFile: string, specifier: string): CodeFrame | null;
+//# sourceMappingURL=codeframe.d.ts.map

package/dist/cli/codeframe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeframe.d.ts","sourceRoot":"","sources":["../../src/cli/codeframe.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,GAChB,SAAS,GAAG,IAAI,CAiBlB"}

package/dist/cli/codeframe.js

@@ -0,0 +1,22 @@
+import { readFileSync } from 'node:fs';
+import * as path from 'node:path';
+export function locateImport(appDir, relativeFile, specifier) {
+    let source;
+    try {
+        source = readFileSync(path.join(appDir, relativeFile), 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const single = `'${specifier}'`;
+    const double = `"${specifier}"`;
+    const lines = source.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index++) {
+        const text = lines[index];
+        if (text.includes(single) || text.includes(double)) {
+            return { line: index + 1, text: text.trim() };
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=codeframe.js.map

package/dist/cli/codeframe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeframe.js","sourceRoot":"","sources":["../../src/cli/codeframe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAOlC,MAAM,UAAU,YAAY,CAC1B,MAAc,EACd,YAAoB,EACpB,SAAiB;IAEjB,IAAI,MAAc,CAAC;IACnB,IAAI,CAAC;QACH,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,CAAC,CAAC;IACjE,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,MAAM,GAAG,IAAI,SAAS,GAAG,CAAC;IAChC,MAAM,MAAM,GAAG,IAAI,SAAS,GAAG,CAAC;IAChC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACpC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QAClD,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAE,CAAC;QAC3B,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YACnD,OAAO,EAAE,IAAI,EAAE,KAAK,GAAG,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;QAChD,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/cli/generate.d.ts

@@ -0,0 +1,37 @@
+import type { GenerationStatus } from '../detector/confidence-gate.js';
+import type { ScannedPattern, ScanResult } from './scan.js';
+export declare function writeRules(scan: ScanResult, outDir: string, statuses?: readonly GenerationStatus[]): string[];
+export declare function emitOne(pattern: ScannedPattern, appDir: string, outDir: string): string;
+export declare function writeLayerConfig(scan: ScanResult, outDir: string, statuses?: readonly GenerationStatus[]): string[];
+export declare function writePublicApiConfig(scan: ScanResult, outDir: string, statuses?: readonly GenerationStatus[]): string[];
+export declare function writeFeatureSliceConfig(scan: ScanResult, outDir: string, statuses?: readonly GenerationStatus[]): string[];
+export declare function writeAppIsolationConfig(scan: ScanResult, outDir: string, statuses?: readonly GenerationStatus[]): string[];
+export declare function writeTestIsolationConfig(scan: ScanResult, outDir: string): string[];
+export declare function writeRoleLayeringConfig(scan: ScanResult, outDir: string, statuses?: readonly GenerationStatus[]): string[];
+export declare function writeDeepRelativeConfig(scan: ScanResult, outDir: string): string[];
+export declare function writeConsoleIsolationConfig(scan: ScanResult, outDir: string): string[];
+export declare function writeServerClientConfig(scan: ScanResult, outDir: string): string[];
+export declare function writeUiDataConfig(scan: ScanResult, outDir: string): string[];
+export declare function writeStoriesIsolationConfig(scan: ScanResult, outDir: string): string[];
+export declare function writeWorkspacePackageConfig(scan: ScanResult, outDir: string): string[];
+export declare function writeEnvAccessConfig(scan: ScanResult, outDir: string): string[];
+export declare function writePhantomDependencyConfig(scan: ScanResult, outDir: string): string[];
+export declare function writeEntryPurityConfig(scan: ScanResult, outDir: string): string[];
+export declare function writeDependencyInternalsConfig(scan: ScanResult, outDir: string): string[];
+export declare function writeEslintPlugin(scan: ScanResult, outDir: string): string[];
+export declare function writeGraph(scan: ScanResult, outDir: string): string[];
+export interface WrittenConfig {
+    files: string[];
+    label: string | null;
+}
+export declare function writeEnforcementConfigs(scan: ScanResult, outDir: string, options?: {
+    structural?: boolean;
+}): WrittenConfig[];
+export declare function regenerateConfigs(scan: ScanResult, outDir: string, options: {
+    structural?: boolean;
+    version: string;
+}): {
+    configs: WrittenConfig[];
+    removed: string[];
+};
+//# sourceMappingURL=generate.d.ts.map

package/dist/cli/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/cli/generate.ts"],"names":[],"mappings":"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"}

package/dist/cli/generate.js

@@ -0,0 +1,259 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import * as path from 'node:path';
+import { toDependencyCruiser, toEslintBoundaries } from '../generator/layer-emitters.js';
+import { toDependencyCruiserPublicApi } from '../generator/public-api-emitters.js';
+import { toDependencyCruiserFeatureSlice } from '../generator/feature-slice-emitters.js';
+import { toDependencyCruiserTestIsolation } from '../generator/test-isolation-emitters.js';
+import { toDependencyCruiserAppIsolation } from '../generator/app-isolation-emitters.js';
+import { toDependencyCruiserDependencyInternals } from '../generator/dependency-internals-emitters.js';
+import { toDependencyCruiserRoleLayering } from '../generator/role-layering-emitters.js';
+import { toDependencyCruiserEntryPurity } from '../generator/entry-purity-emitters.js';
+import { toDependencyCruiserPhantomDependencies } from '../generator/phantom-dependency-emitters.js';
+import { toEslintDeepRelative } from '../generator/deep-relative-emitters.js';
+import { toEslintConsoleIsolation } from '../generator/console-isolation-emitters.js';
+import { toEslintEnvAccess } from '../generator/env-access-emitters.js';
+import { toEslintWorkspacePackageApi } from '../generator/workspace-package-emitters.js';
+import { toDependencyCruiserStoriesIsolation } from '../generator/stories-isolation-emitters.js';
+import { toDependencyCruiserUiData } from '../generator/ui-data-isolation-emitters.js';
+import { toDependencyCruiserServerClient } from '../generator/server-client-emitters.js';
+import { toGraphviz, toMermaid } from '../generator/graph-emitters.js';
+import { emitRuleArtifacts } from '../generator/rule-generator.js';
+import { buildForbiddenImportSpecs, renderEslintPluginSource, } from '../generator/eslint-plugin-emitter.js';
+import { cleanPreviousOutputs, removeIfEmpty, writeOutputsManifest } from './outputs-manifest.js';
+import { hasDependencyCruiserBlocks, hasEslintOutputs, writeDependencyCruiserAggregate, writeEslintAggregator, } from './wiring.js';
+export function writeRules(scan, outDir, statuses = ['AUTO']) {
+    const written = [];
+    for (const pattern of scan.patterns) {
+        if (!statuses.includes(pattern.result.gate.status))
+            continue;
+        written.push(emitOne(pattern, scan.appDir, outDir));
+    }
+    return written;
+}
+export function emitOne(pattern, appDir, outDir) {
+    return emitRuleArtifacts(pattern.config, pattern.result, outDir, `archprint scan ${appDir}`);
+}
+export function writeLayerConfig(scan, outDir, statuses = ['AUTO']) {
+    const dependencyCruiser = toDependencyCruiser(scan.layerBoundaries, statuses);
+    if (dependencyCruiser.forbidden.length === 0)
+        return [];
+    mkdirSync(outDir, { recursive: true });
+    const write = (name, config) => {
+        const file = path.join(outDir, name);
+        writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+        return file;
+    };
+    return [
+        write('dependency-cruiser.archprint.json', dependencyCruiser),
+        write('eslint-boundaries.archprint.json', toEslintBoundaries(scan.layerBoundaries, statuses)),
+    ];
+}
+export function writePublicApiConfig(scan, outDir, statuses = ['AUTO']) {
+    const config = toDependencyCruiserPublicApi(scan.publicApi.groups, statuses);
+    if (config.forbidden.length === 0)
+        return [];
+    mkdirSync(outDir, { recursive: true });
+    const file = path.join(outDir, 'dependency-cruiser.public-api.archprint.json');
+    writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+    return [file];
+}
+export function writeFeatureSliceConfig(scan, outDir, statuses = ['AUTO']) {
+    const config = toDependencyCruiserFeatureSlice(scan.featureSlices.groups, statuses);
+    if (config.forbidden.length === 0)
+        return [];
+    mkdirSync(outDir, { recursive: true });
+    const file = path.join(outDir, 'dependency-cruiser.feature-slice.archprint.json');
+    writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+    return [file];
+}
+export function writeAppIsolationConfig(scan, outDir, statuses = ['AUTO']) {
+    const config = toDependencyCruiserAppIsolation(scan.appIsolation.groups, statuses);
+    if (config.forbidden.length === 0)
+        return [];
+    mkdirSync(outDir, { recursive: true });
+    const file = path.join(outDir, 'dependency-cruiser.app-isolation.archprint.json');
+    writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+    return [file];
+}
+export function writeTestIsolationConfig(scan, outDir) {
+    const config = toDependencyCruiserTestIsolation(scan.testIsolation);
+    if (config.forbidden.length === 0)
+        return [];
+    mkdirSync(outDir, { recursive: true });
+    const file = path.join(outDir, 'dependency-cruiser.test-isolation.archprint.json');
+    writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+    return [file];
+}
+export function writeRoleLayeringConfig(scan, outDir, statuses = ['AUTO']) {
+    const config = toDependencyCruiserRoleLayering(scan.roleLayering.boundaries, statuses);
+    if (config.forbidden.length === 0)
+        return [];
+    mkdirSync(outDir, { recursive: true });
+    const file = path.join(outDir, 'dependency-cruiser.role-layering.archprint.json');
+    writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+    return [file];
+}
+export function writeDeepRelativeConfig(scan, outDir) {
+    const config = toEslintDeepRelative(scan.deepRelative);
+    if (config === null)
+        return [];
+    mkdirSync(outDir, { recursive: true });
+    const file = path.join(outDir, 'eslint.deep-relative.archprint.json');
+    writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+    return [file];
+}
+export function writeConsoleIsolationConfig(scan, outDir) {
+    const config = toEslintConsoleIsolation(scan.consoleIsolation);
+    if (config === null)
+        return [];
+    mkdirSync(outDir, { recursive: true });
+    const file = path.join(outDir, 'eslint.console-isolation.archprint.json');
+    writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+    return [file];
+}
+export function writeServerClientConfig(scan, outDir) {
+    const config = toDependencyCruiserServerClient(scan.serverClient);
+    if (config.forbidden.length === 0)
+        return [];
+    mkdirSync(outDir, { recursive: true });
+    const file = path.join(outDir, 'dependency-cruiser.server-client.archprint.json');
+    writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+    return [file];
+}
+export function writeUiDataConfig(scan, outDir) {
+    const config = toDependencyCruiserUiData(scan.uiDataIsolation);
+    if (config.forbidden.length === 0)
+        return [];
+    mkdirSync(outDir, { recursive: true });
+    const file = path.join(outDir, 'dependency-cruiser.ui-data.archprint.json');
+    writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+    return [file];
+}
+export function writeStoriesIsolationConfig(scan, outDir) {
+    const config = toDependencyCruiserStoriesIsolation(scan.storiesIsolation);
+    if (config.forbidden.length === 0)
+        return [];
+    mkdirSync(outDir, { recursive: true });
+    const file = path.join(outDir, 'dependency-cruiser.stories-isolation.archprint.json');
+    writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+    return [file];
+}
+export function writeWorkspacePackageConfig(scan, outDir) {
+    const config = toEslintWorkspacePackageApi(scan.workspacePackageApi);
+    if (config === null)
+        return [];
+    mkdirSync(outDir, { recursive: true });
+    const file = path.join(outDir, 'eslint.workspace-package.archprint.json');
+    writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+    return [file];
+}
+export function writeEnvAccessConfig(scan, outDir) {
+    const config = toEslintEnvAccess(scan.envAccess);
+    if (config === null)
+        return [];
+    mkdirSync(outDir, { recursive: true });
+    const file = path.join(outDir, 'eslint.env-access.archprint.json');
+    writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+    return [file];
+}
+export function writePhantomDependencyConfig(scan, outDir) {
+    const config = toDependencyCruiserPhantomDependencies(scan.phantomDependencies);
+    if (config.forbidden.length === 0)
+        return [];
+    mkdirSync(outDir, { recursive: true });
+    const file = path.join(outDir, 'dependency-cruiser.phantom-deps.archprint.json');
+    writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+    return [file];
+}
+export function writeEntryPurityConfig(scan, outDir) {
+    const config = toDependencyCruiserEntryPurity(scan.entryPurity);
+    if (config.forbidden.length === 0)
+        return [];
+    mkdirSync(outDir, { recursive: true });
+    const file = path.join(outDir, 'dependency-cruiser.entry-purity.archprint.json');
+    writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+    return [file];
+}
+export function writeDependencyInternalsConfig(scan, outDir) {
+    const config = toDependencyCruiserDependencyInternals(scan.dependencyInternals);
+    if (config.forbidden.length === 0)
+        return [];
+    mkdirSync(outDir, { recursive: true });
+    const file = path.join(outDir, 'dependency-cruiser.dependency-internals.archprint.json');
+    writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+    return [file];
+}
+export function writeEslintPlugin(scan, outDir) {
+    const specs = buildForbiddenImportSpecs(scan.patterns);
+    if (specs.length === 0)
+        return [];
+    mkdirSync(outDir, { recursive: true });
+    const file = path.join(outDir, 'eslint-plugin.archprint.mjs');
+    writeFileSync(file, renderEslintPluginSource(specs));
+    return [file];
+}
+export function writeGraph(scan, outDir) {
+    if (scan.layerBoundaries.length === 0)
+        return [];
+    mkdirSync(outDir, { recursive: true });
+    const write = (name, content) => {
+        const file = path.join(outDir, name);
+        writeFileSync(file, `${content}\n`);
+        return file;
+    };
+    return [
+        write('layer-graph.archprint.mmd', toMermaid(scan.layerBoundaries)),
+        write('layer-graph.archprint.dot', toGraphviz(scan.layerBoundaries)),
+    ];
+}
+const countAuto = (items) => items.filter((item) => item.gate.status === 'AUTO').length;
+export function writeEnforcementConfigs(scan, outDir, options = {}) {
+    const structural = options.structural ?? false;
+    const configs = [];
+    const add = (files, label) => {
+        if (files.length > 0)
+            configs.push({ files, label });
+    };
+    add(writeRules(scan, outDir, ['AUTO']), null);
+    add(writeEslintPlugin(scan, outDir), 'forbidden-import rules as a loadable eslint plugin');
+    if (structural) {
+        add(writeLayerConfig(scan, outDir, ['AUTO']), `${countAuto(scan.layerBoundaries)} layer boundaries: dependency-cruiser and eslint-plugin-boundaries`);
+        add(writeRoleLayeringConfig(scan, outDir, ['AUTO']), `${countAuto(scan.roleLayering.boundaries)} role-layering boundaries: dependency-cruiser rules`);
+    }
+    add(writePublicApiConfig(scan, outDir, ['AUTO']), `${countAuto(scan.publicApi.groups)} public API boundaries: dependency-cruiser deep-import rules`);
+    if (structural) {
+        add(writeFeatureSliceConfig(scan, outDir, ['AUTO']), `${countAuto(scan.featureSlices.groups)} feature-slice boundaries: dependency-cruiser cross-slice rules`);
+        add(writeAppIsolationConfig(scan, outDir, ['AUTO']), `${countAuto(scan.appIsolation.groups)} app boundaries: dependency-cruiser cross-app rules`);
+    }
+    add(writeTestIsolationConfig(scan, outDir), 'test isolation: dependency-cruiser not-to-test rule');
+    add(writeDependencyInternalsConfig(scan, outDir), 'dependency hygiene: dependency-cruiser no-internals rule');
+    if (structural)
+        add(writeEntryPurityConfig(scan, outDir), 'entry purity: dependency-cruiser no-import-entry rule');
+    add(writePhantomDependencyConfig(scan, outDir), 'dependency declaration: dependency-cruiser no-phantom-deps rule');
+    add(writeDeepRelativeConfig(scan, outDir), 'import style: eslint no-restricted-imports rule');
+    add(writeConsoleIsolationConfig(scan, outDir), 'console isolation: eslint no-console rule');
+    if (structural) {
+        add(writeEnvAccessConfig(scan, outDir), 'env access: eslint no-restricted-properties rule');
+        add(writeWorkspacePackageConfig(scan, outDir), 'workspace package API: eslint no-restricted-imports rule');
+        add(writeStoriesIsolationConfig(scan, outDir), 'stories isolation: dependency-cruiser no-import-stories rule');
+        add(writeUiDataConfig(scan, outDir), 'UI / data separation: dependency-cruiser no-ui-to-data rule');
+        add(writeServerClientConfig(scan, outDir), 'server / client boundary: dependency-cruiser no-server-only-in-client rule');
+    }
+    add(writeGraph(scan, outDir), 'layer dependency graph: Mermaid and Graphviz DOT');
+    return configs;
+}
+export function regenerateConfigs(scan, outDir, options) {
+    const removed = cleanPreviousOutputs(outDir);
+    const configs = writeEnforcementConfigs(scan, outDir, { structural: options.structural });
+    const allPaths = configs.flatMap((config) => config.files);
+    if (hasEslintOutputs(allPaths))
+        allPaths.push(writeEslintAggregator(outDir));
+    if (hasDependencyCruiserBlocks(allPaths))
+        allPaths.push(writeDependencyCruiserAggregate(outDir));
+    if (allPaths.length > 0)
+        writeOutputsManifest(outDir, allPaths, options.version);
+    else
+        removeIfEmpty(outDir);
+    return { configs, removed };
+}
+//# sourceMappingURL=generate.js.map