@echojs-ecosystem/architect 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,791 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from 'citty';
+import { relative, join, dirname, resolve, sep, basename } from 'path';
+import * as process2 from 'process';
+import process2__default from 'process';
+import { fromError } from 'zod-validation-error';
+import { ZodError, z } from 'zod';
+import { loadConfig, watchConfig as watchConfig$1 } from 'c12';
+import { map, switchMap, catchError, from, Observable, debounceTime, filter } from 'rxjs';
+import { open, rm, mkdir, rename } from 'fs/promises';
+import ts from 'typescript';
+import { minimatch } from 'minimatch';
+import * as fs from 'fs';
+import precinct from 'precinct';
+import { parse } from 'tsconfck';
+import { produce } from 'immer';
+import chokidar from 'chokidar';
+import { isGitIgnored } from 'globby';
+import chalk from 'chalk';
+import figures from 'figures';
+import terminalLink from 'terminal-link';
+import prexit from 'prexit';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/cli/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  default: () => init_default
+});
+var init_default;
+var init_init = __esm({
+  "src/cli/commands/init.ts"() {
+    init_default = defineCommand({
+      meta: {
+        name: "init",
+        description: "Initialize a fresh project"
+      }
+    });
+  }
+});
+var ConfigurationNotFoundError, ConfigurationInvalidError;
+var init_errors = __esm({
+  "src/config/errors.ts"() {
+    ConfigurationNotFoundError = class extends Error {
+      constructor() {
+        super(`Configuration not found in ${process2.cwd()}`);
+      }
+    };
+    ConfigurationInvalidError = class extends Error {
+      constructor(error, filepath) {
+        super(
+          fromError(error, {
+            prefix: `Invalid configuration in ${relative(process2.cwd(), filepath)}`
+          }).toString()
+        );
+        this.error = error;
+      }
+      error;
+    };
+  }
+});
+var RuleSchema, AbstractionSchema, EvolutionConfigSchema;
+var init_schema = __esm({
+  "src/config/schema.ts"() {
+    RuleSchema = z.object({
+      name: z.string(),
+      check: z.custom(),
+      severity: z.enum(["off", "warn", "error"]),
+      descriptionUrl: z.string().optional()
+    });
+    AbstractionSchema = z.object({
+      name: z.string(),
+      children: z.record(z.lazy(() => AbstractionSchema)),
+      rules: z.array(RuleSchema),
+      fractal: z.string().optional(),
+      fileTemplate: z.custom()
+    });
+    EvolutionConfigSchema = z.object({
+      root: AbstractionSchema,
+      baseUrl: z.string().optional(),
+      files: z.array(z.string()).optional(),
+      ignores: z.array(z.string()).optional()
+    });
+  }
+});
+var CONFIG_NAME, parseConfigResult, watchConfig;
+var init_load = __esm({
+  "src/config/load.ts"() {
+    init_errors();
+    init_schema();
+    CONFIG_NAME = "architect";
+    parseConfigResult = (filepath, data) => {
+      const parseResult = EvolutionConfigSchema.safeParse(data);
+      if (!parseResult.success) {
+        throw new ConfigurationInvalidError(parseResult.error, filepath);
+      }
+      return {
+        config: parseResult.data,
+        configPath: filepath
+      };
+    };
+    watchConfig = ({
+      cwd: cwd2,
+      onlyOne
+    }) => {
+      const config$ = from(
+        loadConfig({
+          cwd: cwd2,
+          name: CONFIG_NAME
+        })
+      ).pipe(
+        map(({ configFile, config }) => {
+          if (!configFile) {
+            throw new ConfigurationNotFoundError();
+          }
+          return parseConfigResult(configFile, config);
+        })
+      );
+      if (onlyOne) {
+        return config$;
+      }
+      return config$.pipe(
+        switchMap(
+          ({ configPath, config }) => new Observable((subscriber) => {
+            subscriber.next({ configPath, config });
+            let unwatchCallback = () => {
+            };
+            watchConfig$1({
+              cwd: cwd2,
+              name: CONFIG_NAME,
+              onUpdate: (config2) => {
+                subscriber.next(
+                  parseConfigResult(configPath, config2.newConfig.config)
+                );
+              }
+            }).then(({ unwatch }) => {
+              unwatchCallback = unwatch;
+            });
+            return () => unwatchCallback();
+          })
+        )
+      );
+    };
+  }
+});
+var applyAutofixes, tryToApplyFixes;
+var init_auto_fix = __esm({
+  "src/linter/auto-fix.ts"() {
+    applyAutofixes = async (diagnostics) => {
+      const stillRelevantDiagnostics = [];
+      const fixableDiagnostics = [];
+      for (const diagnostic of diagnostics) {
+        const fixes = diagnostic.fixes;
+        if (!fixes) {
+          stillRelevantDiagnostics.push(diagnostic);
+          continue;
+        }
+        fixableDiagnostics.push(diagnostic);
+      }
+      try {
+        await Promise.all(fixableDiagnostics.map(tryToApplyFixes));
+      } catch (error) {
+        stillRelevantDiagnostics.push(...fixableDiagnostics);
+        console.error(error);
+      }
+      return stillRelevantDiagnostics;
+    };
+    tryToApplyFixes = async (diagnostic) => {
+      const fixes = diagnostic.fixes ?? [];
+      return Promise.all(
+        fixes.map((fix) => {
+          switch (fix.type) {
+            case "rename":
+              return rename(fix.path, join(dirname(fix.path), fix.newName));
+            case "create-file":
+              return open(fix.path, "w").then((file) => {
+                file.write(fix.content);
+                return file.close();
+              });
+            case "create-folder":
+              return mkdir(fix.path, { recursive: true });
+            case "delete":
+              return rm(fix.path, { recursive: true });
+            case "modify-file":
+              return open(fix.path, "w").then(async (file) => {
+                await file.write(fix.content);
+                return file.close();
+              });
+            default:
+              return void 0;
+          }
+        })
+      );
+    };
+  }
+});
+
+// src/shared/memoize.ts
+var memoize;
+var init_memoize = __esm({
+  "src/shared/memoize.ts"() {
+    memoize = (fn) => {
+      const cache = /* @__PURE__ */ new WeakMap();
+      return function(arg) {
+        if (cache.has(arg)) {
+          return cache.get(arg);
+        }
+        const result = fn.call(this, arg);
+        cache.set(arg, result);
+        return result;
+      };
+    };
+  }
+});
+var resolveImport, imperfectKeys, normalizeCompilerOptions;
+var init_resolve_import = __esm({
+  "src/shared/resolve-import.ts"() {
+    resolveImport = (importedPath, importerPath, tsCompilerOptions, fileExists, directoryExists) => {
+      return ts.resolveModuleName(
+        importedPath,
+        importerPath,
+        normalizeCompilerOptions(tsCompilerOptions),
+        {
+          ...ts.sys,
+          fileExists,
+          directoryExists
+        }
+      ).resolvedModule?.resolvedFileName?.replaceAll("/", sep) ?? null;
+    };
+    imperfectKeys = {
+      module: ts.ModuleKind,
+      moduleResolution: {
+        ...ts.ModuleResolutionKind,
+        node: ts.ModuleResolutionKind.Node10
+      },
+      moduleDetection: ts.ModuleDetectionKind,
+      newLine: ts.NewLineKind,
+      target: ts.ScriptTarget
+    };
+    normalizeCompilerOptions = (compilerOptions) => {
+      return Object.fromEntries(
+        Object.entries(compilerOptions).map(([key, value]) => {
+          if (Object.keys(imperfectKeys).includes(key) && typeof value === "string") {
+            for (const [enumKey, enumValue] of Object.entries(
+              imperfectKeys[key]
+            )) {
+              if (enumKey.toLowerCase() === value.toLowerCase()) {
+                return [key, enumValue];
+              }
+            }
+          }
+          return [key, value];
+        })
+      );
+    };
+  }
+});
+
+// src/shared/index.ts
+var init_shared = __esm({
+  "src/shared/index.ts"() {
+    init_memoize();
+    init_resolve_import();
+  }
+});
+var parseAbstractionInstance;
+var init_parse = __esm({
+  "src/abstraction/instance/parse.ts"() {
+    init_shared();
+    parseAbstractionInstance = memoize(
+      (abstraction) => memoize((node) => {
+        if (node.type === "file") {
+          return {
+            abstraction,
+            path: node.path,
+            children: [],
+            childNodes: []
+          };
+        }
+        const children = {};
+        for (const [pattern, childAbstraction] of Object.entries(
+          abstraction.children
+        )) {
+          const nodeAbstractionInstance = parseAbstractionInstance(childAbstraction);
+          const nodesStack = [node];
+          while (nodesStack.length) {
+            const currentNode = nodesStack.pop();
+            if (minimatch(relative(node.path, currentNode.path), pattern)) {
+              children[currentNode.path] = nodeAbstractionInstance(currentNode);
+              continue;
+            }
+            if (children[currentNode.path]) {
+              continue;
+            }
+            if (currentNode.type === "folder") {
+              nodesStack.push(...currentNode.children);
+            }
+          }
+        }
+        const childNodes = [];
+        const childrenNodesStack = [node];
+        while (childrenNodesStack.length) {
+          const currentNode = childrenNodesStack.pop();
+          if (children[currentNode.path]) {
+            continue;
+          }
+          if (currentNode.path !== node.path) {
+            childNodes.push(currentNode.path);
+          }
+          if (currentNode.type === "folder") {
+            childrenNodesStack.push(...currentNode.children);
+          }
+        }
+        return {
+          abstraction,
+          path: node.path,
+          childNodes: Object.values(childNodes),
+          children: Object.values(children)
+        };
+      })
+    );
+  }
+});
+
+// src/vfs/get-flatten-files.ts
+var getFlattenFiles;
+var init_get_flatten_files = __esm({
+  "src/vfs/get-flatten-files.ts"() {
+    init_shared();
+    getFlattenFiles = memoize((node) => {
+      if (node.type === "file") {
+        return [node];
+      }
+      return node.children.reduce((acc, child) => {
+        if (child.type === "file") {
+          return [...acc, child];
+        }
+        return [...acc, ...getFlattenFiles(child)];
+      }, []);
+    });
+  }
+});
+var paperwork, parseDependenciesMap;
+var init_parse2 = __esm({
+  "src/dependencies/parse.ts"() {
+    init_shared();
+    init_get_flatten_files();
+    ({ paperwork } = precinct);
+    parseDependenciesMap = async (vfs) => {
+      const dependenciesMap = {
+        dependencies: {},
+        dependencyFor: {}
+      };
+      const basePath = vfs.path;
+      const { tsconfig } = await parse(basePath);
+      const files = getFlattenFiles(vfs);
+      for (const file of files) {
+        const dependencies = paperwork(file.path, {
+          includeCore: false,
+          fileSystem: fs
+        });
+        const resolvedDependencies = dependencies.map(
+          (dependency) => resolveImport(
+            dependency,
+            file.path,
+            tsconfig?.compilerOptions ?? {},
+            fs.existsSync,
+            fs.existsSync
+          )
+        ).filter((dependency) => dependency !== null);
+        dependenciesMap.dependencies[file.path] = new Set(resolvedDependencies);
+        for (const dependency of resolvedDependencies) {
+          if (!dependenciesMap.dependencyFor[dependency]) {
+            dependenciesMap.dependencyFor[dependency] = /* @__PURE__ */ new Set();
+          }
+          dependenciesMap.dependencyFor[dependency].add(file.path);
+        }
+      }
+      return dependenciesMap;
+    };
+  }
+});
+var addDirectory;
+var init_add_directory = __esm({
+  "src/vfs/add-directory.ts"() {
+    addDirectory = (tree, newDirectoryPath) => {
+      const rootPath = tree.path;
+      return produce(tree, (draft) => {
+        const pathSegments = relative(rootPath, newDirectoryPath).split(sep);
+        let currentFolder = draft;
+        for (const pathSegment of pathSegments.slice(0, -1)) {
+          const existingChild = currentFolder.children.find(
+            (child) => child.type === "folder" && basename(child.path) === pathSegment
+          );
+          if (existingChild === void 0) {
+            currentFolder.children.push({
+              type: "folder",
+              path: join(currentFolder.path, pathSegment),
+              children: []
+            });
+            currentFolder = currentFolder.children[currentFolder.children.length - 1];
+          } else {
+            currentFolder = existingChild;
+          }
+        }
+        currentFolder.children.push({
+          type: "folder",
+          path: newDirectoryPath,
+          children: []
+        });
+      });
+    };
+  }
+});
+var addFile;
+var init_add_file = __esm({
+  "src/vfs/add-file.ts"() {
+    addFile = (tree, newFilePath) => {
+      const rootPath = tree.path;
+      return produce(tree, (draft) => {
+        const pathSegments = relative(rootPath, newFilePath).split(sep);
+        let currentFolder = draft;
+        for (const pathSegment of pathSegments.slice(0, -1)) {
+          const existingChild = currentFolder.children.find(
+            (child) => child.type === "folder" && basename(child.path) === pathSegment
+          );
+          if (existingChild === void 0) {
+            currentFolder.children.push({
+              type: "folder",
+              path: join(currentFolder.path, pathSegment),
+              children: []
+            });
+            currentFolder = currentFolder.children[currentFolder.children.length - 1];
+          } else {
+            currentFolder = existingChild;
+          }
+        }
+        currentFolder.children.push({ type: "file", path: newFilePath });
+      });
+    };
+  }
+});
+
+// src/vfs/create-root.ts
+var createVfsRoot;
+var init_create_root = __esm({
+  "src/vfs/create-root.ts"() {
+    createVfsRoot = (path) => ({
+      type: "folder",
+      path,
+      children: []
+    });
+  }
+});
+var removeNode;
+var init_remove_node = __esm({
+  "src/vfs/remove-node.ts"() {
+    removeNode = (tree, removedNodePath) => {
+      const rootPath = tree.path;
+      return produce(tree, (draft) => {
+        const pathSegments = relative(rootPath, removedNodePath).split(sep);
+        let currentFolder = draft;
+        for (const pathSegment of pathSegments.slice(0, -1)) {
+          const existingChild = currentFolder.children.find(
+            (child) => child.type === "folder" && basename(child.path) === pathSegment
+          );
+          if (existingChild === void 0) {
+            return tree;
+          } else {
+            currentFolder = existingChild;
+          }
+        }
+        const removedNodeIndex = currentFolder.children.findIndex(
+          (child) => child.path === removedNodePath
+        );
+        if (removedNodeIndex === -1) {
+          return tree;
+        }
+        currentFolder.children.splice(removedNodeIndex, 1);
+      });
+    };
+  }
+});
+var watchFs, createWatcherObservable;
+var init_watch_fs = __esm({
+  "src/vfs/watch-fs.ts"() {
+    init_add_directory();
+    init_add_file();
+    init_create_root();
+    init_remove_node();
+    watchFs = (path, { onlyReady } = {}) => {
+      const isIgnored$ = from(isGitIgnored({ cwd: path }));
+      let vfs$ = isIgnored$.pipe(
+        switchMap((isIgnored) => createWatcherObservable({ path, isIgnored }))
+      );
+      if (onlyReady) {
+        vfs$ = vfs$.pipe(filter((e) => e.type === "ready"));
+      }
+      return vfs$;
+    };
+    createWatcherObservable = ({
+      path,
+      isIgnored
+    }) => {
+      return new Observable((observer) => {
+        let vfs = createVfsRoot(path);
+        const watcher = chokidar.watch(path, {
+          ignored: (path2) => path2.split(sep).includes("node_modules") || isIgnored(path2),
+          ignoreInitial: false,
+          alwaysStat: true,
+          awaitWriteFinish: true,
+          disableGlobbing: true,
+          cwd: path
+        });
+        watcher.on("add", async (relativePath) => {
+          vfs = addFile(vfs, join(path, relativePath));
+          observer.next({ type: "add", vfs });
+        });
+        watcher.on("addDir", async (relativePath) => {
+          vfs = addDirectory(vfs, join(path, relativePath));
+          observer.next({ type: "addDir", vfs });
+        });
+        watcher.on("change", async () => {
+          observer.next({ type: "change", vfs });
+        });
+        watcher.on("unlink", async (relativePath) => {
+          vfs = removeNode(vfs, join(path, relativePath));
+          observer.next({ type: "unlink", vfs });
+        });
+        watcher.on("unlinkDir", async (relativePath) => {
+          vfs = removeNode(vfs, join(path, relativePath));
+          observer.next({ type: "unlinkDir", vfs });
+        });
+        watcher.on("ready", () => {
+          observer.next({ type: "ready", vfs });
+        });
+        return () => {
+          watcher.close();
+        };
+      });
+    };
+  }
+});
+
+// src/linter/run-rules.ts
+var runRules;
+var init_run_rules = __esm({
+  "src/linter/run-rules.ts"() {
+    runRules = async ({
+      root,
+      instance,
+      dependenciesMap
+    }) => {
+      const ruleDiagnostics = (currentInstance) => async (rule) => {
+        if (rule.severity === "off") {
+          return [];
+        }
+        const { diagnostics } = await rule.check({
+          root,
+          instance: currentInstance,
+          dependenciesMap
+        });
+        return diagnostics.map((d) => ({ ...d, rule }));
+      };
+      const runAbstractionRules = (currentInstance) => {
+        return currentInstance.abstraction.rules.map(ruleDiagnostics(currentInstance)).concat(...currentInstance.children.flatMap(runAbstractionRules));
+      };
+      return await Promise.all(runAbstractionRules(instance)).then((r) => r.flat());
+    };
+  }
+});
+var lint;
+var init_lint = __esm({
+  "src/linter/lint.ts"() {
+    init_parse();
+    init_parse2();
+    init_watch_fs();
+    init_run_rules();
+    lint = ({
+      watch,
+      config,
+      configPath
+    }) => {
+      const rootPath = resolve(dirname(configPath), config.baseUrl ?? "./");
+      const parseNode = parseAbstractionInstance(config.root);
+      return watchFs(rootPath, { onlyReady: !watch }).pipe(
+        debounceTime(500),
+        switchMap(async ({ vfs }) => ({
+          root: vfs,
+          instance: parseNode(vfs),
+          dependenciesMap: await parseDependenciesMap(vfs)
+        })),
+        switchMap(runRules)
+      );
+    };
+  }
+});
+var formatLocation, formatSingleDiagnostic;
+var init_format_single_diagnostic = __esm({
+  "src/linter/reporter/format-single-diagnostic.ts"() {
+    formatLocation = (location, cwd2) => {
+      let path = relative(cwd2, location.path);
+      if (location.line !== void 0) {
+        path += `:${location.line}`;
+        if (location.column !== void 0) {
+          path += `:${location.column}`;
+        }
+      }
+      return path;
+    };
+    formatSingleDiagnostic = (d, cwd2) => {
+      const x = d.rule.severity === "error" ? chalk.red(figures.cross) : chalk.yellow(figures.warning);
+      const s2 = chalk.reset(figures.lineDownRight);
+      const bar = chalk.reset(figures.lineVertical);
+      const e = chalk.reset(figures.lineUpRight);
+      const message = chalk.reset(d.message);
+      const autofixable = d.fixes !== void 0 && d.fixes.length > 0 ? chalk.green(`${figures.tick} Auto-fixable`) : null;
+      const location = chalk.gray(formatLocation(d.location, cwd2));
+      const ruleName = d.rule.descriptionUrl ? chalk.blue(terminalLink(d.rule.name, d.rule.descriptionUrl)) : d.rule.name;
+      return `
+${s2} ${location}
+${x} ${message}
+${autofixable ? `${autofixable}
+${bar}` : bar}
+${e} ${ruleName}
+`.trim();
+    };
+  }
+});
+
+// src/linter/reporter/pluralization.ts
+var s;
+var init_pluralization = __esm({
+  "src/linter/reporter/pluralization.ts"() {
+    s = (amount) => amount === 1 ? "" : "s";
+  }
+});
+var formatPretty, reportPretty;
+var init_reporter = __esm({
+  "src/linter/reporter/index.ts"() {
+    init_format_single_diagnostic();
+    init_pluralization();
+    formatPretty = (diagnostics, cwd2) => {
+      if (diagnostics.length === 0) {
+        return chalk.green(`${figures.tick} No problems found!`);
+      }
+      const errors = diagnostics.filter((d) => d.rule.severity === "error");
+      const warnings = diagnostics.filter((d) => d.rule.severity === "warn");
+      let footer = `Found ${[
+        errors.length > 0 && chalk.red.bold(`${errors.length} error${s(errors.length)}`),
+        warnings.length > 0 && chalk.yellow.bold(`${warnings.length} warning${s(warnings.length)}`)
+      ].filter(Boolean).join(" and ")}`;
+      const autofixable = diagnostics.filter((d) => (d.fixes?.length ?? 0) > 0);
+      if (autofixable.length === diagnostics.length) {
+        footer += ` (all can be fixed automatically with ${chalk.green.bold("--fix")})`;
+      } else if (autofixable.length > 0) {
+        footer += ` (${autofixable.length} can be fixed automatically with ${chalk.green.bold("--fix")})`;
+      } else {
+        footer += " (none can be fixed automatically)";
+      }
+      return `
+${diagnostics.map((d) => formatSingleDiagnostic(d, cwd2)).join("\n\n")}
+
+${chalk.gray(figures.line.repeat(footer.length))}
+ ${footer}
+`;
+    };
+    reportPretty = (diagnostics, cwd2) => {
+      console.error(formatPretty(diagnostics, cwd2));
+    };
+  }
+});
+
+// src/linter/index.ts
+var init_linter = __esm({
+  "src/linter/index.ts"() {
+    init_auto_fix();
+    init_lint();
+    init_reporter();
+  }
+});
+
+// src/cli/commands/lint.ts
+var lint_exports = {};
+__export(lint_exports, {
+  default: () => lint_default
+});
+var lint_default;
+var init_lint2 = __esm({
+  "src/cli/commands/lint.ts"() {
+    init_load();
+    init_linter();
+    lint_default = defineCommand({
+      meta: {
+        name: "lint",
+        description: "Lint the project"
+      },
+      args: {
+        watch: {
+          type: "boolean",
+          description: "Watch for changes",
+          default: false
+        },
+        fix: {
+          type: "boolean",
+          description: "Apply autofixes",
+          default: false
+        },
+        "fail-on-warning": {
+          type: "boolean",
+          description: "Fail on warnings",
+          default: false
+        }
+      },
+      async run(ctx) {
+        const { watch, fix, "fail-on-warning": failOnWarning } = ctx.args;
+        const subscription = watchConfig({
+          cwd: process2__default.cwd(),
+          onlyOne: !watch
+        }).pipe(
+          map(({ configPath, config }) => ({ configPath, config, watch })),
+          switchMap(lint),
+          catchError((e) => {
+            if (e instanceof ZodError) {
+              console.error(fromError(e).toString());
+            } else if (e instanceof Error) {
+              console.error(e.message);
+            }
+            process2__default.exit(1);
+          })
+        ).subscribe(async (diagnostics) => {
+          if (watch) {
+            console.clear();
+            reportPretty(diagnostics, process2__default.cwd());
+            if (fix) {
+              await applyAutofixes(diagnostics);
+            }
+          } else {
+            let stillRelevantDiagnostics = diagnostics;
+            reportPretty(diagnostics, process2__default.cwd());
+            if (fix) {
+              stillRelevantDiagnostics = await applyAutofixes(diagnostics);
+            }
+            if (stillRelevantDiagnostics.length > 0) {
+              const onlyWarnings = stillRelevantDiagnostics.every(
+                (d) => d.rule.severity === "warn"
+              );
+              if (failOnWarning || !onlyWarnings) {
+                process2__default.exit(1);
+              }
+            }
+            process2__default.exit(0);
+          }
+        });
+        prexit(() => subscription.unsubscribe());
+      }
+    });
+  }
+});
+
+// src/cli/version.ts
+var version = "0.1.0";
+
+// src/cli/commands/index.ts
+var _rDefault = (r) => r.default || r;
+var commands = {
+  init: () => Promise.resolve().then(() => (init_init(), init_exports)).then(_rDefault),
+  lint: () => Promise.resolve().then(() => (init_lint2(), lint_exports)).then(_rDefault)
+};
+
+// src/cli/index.ts
+var main = defineCommand({
+  meta: {
+    name: "echo-architect",
+    version,
+    description: "EchoJS architecture linter CLI"
+  },
+  subCommands: commands
+});
+runMain(main);
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map