aact 1.0.0 → 2.0.0

package/README.md

@@ -0,0 +1,171 @@
+<img width="150" height="150" alt="aact logo" src="https://github.com/user-attachments/assets/abbcea49-51c9-4e57-8cbe-a1ed11d1fa48" />
+
+# Architecture As Code Tools (aact)
+
+[![test workflow](https://github.com/razonrus/ArchAsCode_Tests/actions/workflows/test.yaml/badge.svg?branch=main)](https://github.com/razonrus/ArchAsCode_Tests/actions/workflows/test.yaml)
+
+CLI и библиотека для валидации, анализа и генерации архитектуры микросервисных систем, описанной "as Code" (PlantUML C4, Structurizr).
+
+Инструменты для работы с архитектурой в формате "as Code":
+
+1. Код и примеры покрытия тестами микросервисной архитектуры, описанной в plantuml ([#](#покрытие-архитектуры-тестами))
+2. Автогенерация архитектуры ([#](#автогенерация-архитектуры-1))
+3. Тестирование архитектуры модульного монолита ([#](#тестирование-модульного-монолита))
+
+[Планы развития инструментов и репозитория](roadmap.md). PullRequest'ы и Issues'ы приветствуются.
+
+[Справочник](patterns.md) принципов и паттернов проектирования с примерами покрытия их тестами (пополняется...)
+
+<img src="https://github.com/Byndyusoft/aact/assets/1096954/a3c3b3b0-a09b-4da7-aca4-5538159b371c" width="15"/> Телеграм-канал: [Архитектура распределённых систем](https://t.me/rsa_enc)
+
+## Quick Start (CLI)
+
+```bash
+# Инициализация конфига
+npx aact init
+
+# Проверка правил архитектуры
+npx aact check
+
+# Анализ метрик
+npx aact analyze
+
+# Генерация артефактов
+npx aact generate --format plantuml
+npx aact generate --format kubernetes
+```
+
+### Конфигурация
+
+`aact init` создаст файл `aact.config.ts`:
+
+```ts
+import { defineConfig } from "aact";
+
+export default defineConfig({
+  source: {
+    type: "plantuml", // "plantuml" | "structurizr"
+    path: "./architecture.puml",
+  },
+  rules: {
+    acl: true,
+    acyclic: true,
+    crud: true,
+    dbPerService: true,
+    cohesion: true,
+  },
+});
+```
+
+## Использование как библиотеки
+
+```ts
+import {
+  loadPlantumlElements,
+  mapContainersFromPlantumlElements,
+  checkAcl,
+  checkAcyclic,
+  checkCrud,
+  analyzeArchitecture,
+} from "aact";
+
+const elements = await loadPlantumlElements("architecture.puml");
+const model = mapContainersFromPlantumlElements(elements);
+
+// Проверка правил
+const aclViolations = checkAcl(model.allContainers);
+const cyclicViolations = checkAcyclic(model.allContainers);
+
+// Анализ метрик
+const { report } = analyzeArchitecture(model);
+console.log(`Elements: ${report.elementsCount}`);
+```
+
+## Примеры
+
+- [Banking (PlantUML)](examples/banking-plantuml/) — проверка правил, CCR-анализ, генерация K8s-конфигов
+- [Microservices (Structurizr)](examples/microservices-structurizr/) — полный цикл: правила, анализ, генерация
+
+## Документация
+
+- [Справочник паттернов](patterns.md) — принципы и паттерны с примерами тестов
+- [ADR](ADRs/) — Architecture Decision Records
+- [Roadmap](roadmap.md) — планы развития
+
+## Публичные материалы
+
+### Раз архитектура — «as Code», почему бы её не покрыть тестами?!
+
+<a href="https://www.youtube.com/watch?v=POIbWZh68Cg"><img src="https://github.com/Byndyusoft/aact/assets/1096954/e011958e-12c8-4fb9-97f4-a61779408e4f" width="400"/></a>
+<a href="https://www.youtube.com/watch?v=tZ-FQeObSjY"><img src="https://github.com/Byndyusoft/aact/assets/1096954/daea29de-776b-49a0-b781-ad4eba9a2221" width="400"/></a>
+https://www.youtube.com/watch?v=POIbWZh68Cg $~~~~~~~~~~$ https://www.youtube.com/watch?v=tZ-FQeObSjY
+
+[Статья на Хабре](https://habr.com/ru/articles/800205/)
+
+### Автогенерация архитектуры
+
+<a href="https://www.youtube.com/watch?v=fb2UjqjHGUE"><img src="https://github.com/Byndyusoft/aact/assets/1096954/ecb54a6f-f6c1-4816-972b-c845069e9f4a" width="400"/></a><br/>
+https://www.youtube.com/watch?v=fb2UjqjHGUE
+
+# Покрытие архитектуры тестами
+
+## Что это, какую боль решает, и с чего начать?
+
+Раз архитектура — «as Code», почему бы её не покрыть тестами?!
+
+Тема идеи и данный открытый репозиторий вызвал неожиданную волну позитивных отзывов о попадании в яблочко болей и о применимости и полезности решения :)
+
+Подход помогает решить **проблемы неактуальности, декларативности и отсутствия контроля ИТ-архитектур и инфраструктуры** (ограничение и требование — архитектура и инфраструктура должны быть "as code").
+
+Тесты проверяют 2 больших блока:
+
+- актуальность архитектуры реальному работающему в продакшне решению
+- соответствие "нарисованной" архитектуры выбранным принципам и паттернам проектирования
+
+Подробнее о подходе, решаемых проблемах, схеме работы представленного в репозитории примера и проверяемых в тестах репозитория принципах — на [слайдах](https://docs.google.com/presentation/d/16_3h1BTIRyREXO_oSqnjEbRJAnN3Z4aX/edit?usp=sharing&ouid=106100367728328513490&rtpof=true&sd=true).
+
+### Схема работы
+
+<img src="https://github.com/Byndyusoft/aact/assets/1096954/9b0ad909-b789-4395-a580-9fb44397afa0" height="350">
+
+### Визуализация примера автоматически проверяемого принципа (отсутствие бизнес-логики в CRUD-сервисах)
+
+<img src="https://github.com/Byndyusoft/aact/assets/1096954/292b1bbd-0f18-40be-9560-65385a1d4df9" height="300">
+
+## Пример архитектуры, которую покроем тестами
+
+[![C4](resources/architecture/Demo%20Tests.svg)](resources/architecture/Demo%20Tests.svg)
+
+## Пример тестов
+
+1. [find diff in configs and uml containers](examples/banking-plantuml/architecture.test.ts) — проверяет актуальность списка микросервисов на архитектуре и в [конфигурации инфраструктуры](resources/kubernetes/microservices)
+2. [find diff in configs and uml dependencies](examples/banking-plantuml/architecture.test.ts) — проверяет актуальность зависимостей (связей) микросервисов на архитектуре и в [конфигурации инфраструктуры](resources/kubernetes/microservices)
+3. [check that urls and topics from relations exist in config](examples/banking-plantuml/architecture.test.ts) — проверяет соответствие между параметрами связей микросервисов (REST-урлы, топики kafka) на архитектуре и в [конфигурации инфраструктуры](resources/kubernetes/microservices)
+4. [only acl can depend on external systems](test/rules/acl.test.ts) — проверяет, что не нарушен выбранный принцип построения интеграций с внешними системами только через ACL (Anti Corruption Layer). Проверяет, что только acl-микросервисы имеют зависимости от внешних систем.
+5. [connect to external systems only by API Gateway or kafka](examples/banking-plantuml/architecture.test.ts) — проверяет, что все внешние интеграции идут через API Gateway или через kafka
+
+# Автогенерация архитектуры
+
+## Генерация архитектуры из описанной «as Code» инфраструктуры
+
+Сравнение ~~белковой~~ составленной вручную архитектуры и сгенерированной.
+
+### Ручная:
+
+[![C4](resources/architecture/Demo%20Tests.svg)](resources/architecture/Demo%20Tests.svg)
+
+### Сгенерированная:
+
+[![C4](resources/architecture/Demo%20Generated.svg)](resources/architecture/Demo%20Generated.svg)
+
+# Тестирование модульного монолита
+
+Тестами можно покрывать не только архитектуру микросервисов, но архитектуру монолитов, особенно, если они модульные.
+
+- [Тест архитектуры модульного монолита на C#](https://github.com/Byndyusoft/aact/tree/main/ModularMonolith)
+
+# Тестирование на основе информации из кода
+
+Информацию об архитектуре реализованной системы можно извлечь и из ее кода, особенно, если он написан качественно;)
+
+- [Извлечение информации об архитектуры системы из ее кода](https://github.com/Byndyusoft/byndyusoft-architecture-testing)

package/dist/cli/index.d.mts

@@ -0,0 +1,2 @@
+
+export { };

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+
+export { };

package/dist/cli/index.mjs

@@ -0,0 +1,506 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from 'citty';
+import consola from 'consola';
+import { A as AactConfigSchema, m as loadStructurizrElements, l as loadPlantumlElements, o as mapContainersFromPlantumlElements, a as analyzeArchitecture, c as checkAcl, b as checkAcyclic, d as checkApiGateway, f as checkCrud, g as checkDbPerService, e as checkCohesion, h as checkStableDependencies, j as generateKubernetes, k as generatePlantumlFromModel } from '../shared/aact.Dqryafrg.mjs';
+import { loadConfig } from 'c12';
+import * as v from 'valibot';
+import path from 'node:path';
+import fs, { readFile, writeFile } from 'node:fs/promises';
+import 'yaml';
+import 'plantuml-parser';
+
+const loadAndValidateConfig = async () => {
+  const { config } = await loadConfig({ name: "aact" });
+  if (!config) {
+    throw new Error("No source configured. Create an aact.config.ts file.");
+  }
+  return v.parse(AactConfigSchema, config);
+};
+
+const loadModel = async (config) => {
+  const resolvedPath = path.resolve(config.source.path);
+  switch (config.source.type) {
+    case "plantuml": {
+      const elements = await loadPlantumlElements(resolvedPath);
+      return mapContainersFromPlantumlElements(elements);
+    }
+    case "structurizr": {
+      return loadStructurizrElements(resolvedPath);
+    }
+    default: {
+      const sourceType = config.source.type;
+      throw new Error(`Unsupported source type: ${String(sourceType)}`);
+    }
+  }
+};
+
+const analyze = defineCommand({
+  meta: { description: "Analyze architecture metrics" },
+  args: {
+    format: {
+      type: "string",
+      description: "Output format: text, json"
+    }
+  },
+  async run({ args }) {
+    const config = await loadAndValidateConfig();
+    const model = await loadModel(config);
+    const { report } = analyzeArchitecture(model);
+    if (args.format === "json") {
+      console.log(JSON.stringify(report, void 0, 2));
+      return;
+    }
+    consola.info(`Elements: ${report.elementsCount}`);
+    consola.info(`Sync API calls: ${report.syncApiCalls}`);
+    consola.info(`Async API calls: ${report.asyncApiCalls}`);
+    consola.info(
+      `Databases: ${report.databases.count} (consumed by ${report.databases.consumes} relation(s))`
+    );
+    for (const b of report.boundaries) {
+      consola.info(
+        `Boundary "${b.label}": cohesion=${b.cohesion}, coupling=${b.coupling}`
+      );
+      if (b.couplingRelations.length > 0) {
+        for (const r of b.couplingRelations) {
+          consola.log(`  ${r.from} \u2192 ${r.to}`);
+        }
+      }
+    }
+  }
+});
+
+const plantumlSyntax = {
+  containerPattern: (name) => `Container(${name},`,
+  containerDecl: (name, label, tags) => {
+    const tagsPart = tags ? `, "", "", $tags="${tags}"` : "";
+    return `Container(${name}, "${label}"${tagsPart})`;
+  },
+  relationPattern: (from, to) => `Rel(${from}, ${to}`,
+  relationDecl: (from, to, tech, tags) => {
+    const tagsPart = tags ? `, $tags="${tags}"` : "";
+    return `Rel(${from}, ${to}, "${tech ?? ""}"${tagsPart})`;
+  }
+};
+
+const applyEdits = (source, edits) => {
+  let lines = source.split("\n");
+  for (const edit of edits) {
+    const idx = lines.findIndex((line) => line.includes(edit.search));
+    if (idx === -1) continue;
+    switch (edit.type) {
+      case "remove": {
+        lines.splice(idx, 1);
+        break;
+      }
+      case "replace": {
+        lines[idx] = edit.content ?? "";
+        break;
+      }
+      case "add": {
+        lines = [
+          ...lines.slice(0, idx + 1),
+          edit.content ?? "",
+          ...lines.slice(idx + 1)
+        ];
+        break;
+      }
+    }
+  }
+  return lines.join("\n");
+};
+
+const fixAcl = (model, violations, syntax, options) => {
+  const tag = options?.tag ?? "acl";
+  const externalType = options?.externalType ?? "System_Ext";
+  const results = [];
+  for (const violation of violations) {
+    const container = model.allContainers.find(
+      (c) => c.name === violation.container
+    );
+    if (!container) continue;
+    const externalRels = container.relations.filter(
+      (r) => r.to.type === externalType
+    );
+    if (externalRels.length === 0) continue;
+    const aclName = `${container.name}_acl`;
+    const fix = {
+      rule: "acl",
+      description: `Add ACL layer for ${container.name}`,
+      edits: []
+    };
+    fix.edits.push({
+      type: "add",
+      search: syntax.containerPattern(container.name),
+      content: syntax.containerDecl(aclName, `${container.label} ACL`, tag)
+    });
+    for (const rel of externalRels) {
+      const tech = rel.technology ?? "";
+      fix.edits.push(
+        {
+          type: "replace",
+          search: syntax.relationPattern(container.name, rel.to.name),
+          content: syntax.relationDecl(container.name, aclName, tech)
+        },
+        {
+          type: "add",
+          search: syntax.relationPattern(container.name, aclName),
+          content: syntax.relationDecl(aclName, rel.to.name, tech)
+        }
+      );
+    }
+    results.push(fix);
+  }
+  return results;
+};
+
+const fixDbPerService = (model, violations, syntax, options) => {
+  const dbType = options?.dbType ?? "ContainerDb";
+  const results = [];
+  for (const violation of violations) {
+    const db = model.allContainers.find(
+      (c) => c.name === violation.container && c.type === dbType
+    );
+    if (!db) continue;
+    const accessors = model.allContainers.filter(
+      (c) => c.relations.some((r) => r.to.name === db.name)
+    );
+    if (accessors.length <= 1) continue;
+    const owner = accessors[0];
+    const fix = {
+      rule: "dbPerService",
+      description: `Redirect access to ${db.name} through ${owner.name}`,
+      edits: []
+    };
+    for (const accessor of accessors.slice(1)) {
+      const rel = accessor.relations.find((r) => r.to.name === db.name);
+      if (!rel) continue;
+      const tags = rel.tags && rel.tags.length > 0 ? rel.tags.join("+") : void 0;
+      const oldRel = syntax.relationPattern(accessor.name, db.name);
+      const newRel = syntax.relationDecl(
+        accessor.name,
+        owner.name,
+        rel.technology ?? "",
+        tags
+      );
+      fix.edits.push({ type: "replace", search: oldRel, content: newRel });
+    }
+    results.push(fix);
+  }
+  return results;
+};
+
+const defineRule = (def) => def;
+const ruleRegistry = [
+  defineRule({
+    name: "acl",
+    check: (m, o) => checkAcl(m.allContainers, o),
+    fix: fixAcl
+  }),
+  defineRule({ name: "acyclic", check: (m) => checkAcyclic(m.allContainers) }),
+  defineRule({
+    name: "apiGateway",
+    check: (m, o) => checkApiGateway(m.allContainers, o)
+  }),
+  defineRule({
+    name: "crud",
+    check: (m, o) => checkCrud(m.allContainers, o)
+  }),
+  defineRule({
+    name: "dbPerService",
+    check: (m, o) => checkDbPerService(m.allContainers, o),
+    fix: fixDbPerService
+  }),
+  defineRule({
+    name: "cohesion",
+    check: (m, o) => checkCohesion(m, o)
+  }),
+  defineRule({
+    name: "stableDependencies",
+    check: (m, o) => checkStableDependencies(m.allContainers, o)
+  })
+];
+
+const runRules = (model, rules) => {
+  const results = [];
+  for (const rule of ruleRegistry) {
+    const configValue = rules?.[rule.name];
+    if (configValue === false) continue;
+    const options = typeof configValue === "object" ? configValue : void 0;
+    results.push({ name: rule.name, violations: rule.check(model, options) });
+  }
+  return results;
+};
+const getSyntax = (sourceType) => {
+  if (sourceType === "plantuml") {
+    return plantumlSyntax;
+  }
+  throw new Error(`Write-back not supported for ${sourceType}`);
+};
+const generateFixes = (model, results, rules, syntax) => {
+  const fixes = [];
+  for (const result of results) {
+    if (result.violations.length === 0) continue;
+    const ruleDef = ruleRegistry.find((r) => r.name === result.name);
+    if (!ruleDef?.fix) continue;
+    const configValue = rules?.[ruleDef.name];
+    const options = typeof configValue === "object" ? configValue : void 0;
+    fixes.push(...ruleDef.fix(model, result.violations, syntax, options));
+  }
+  return fixes;
+};
+const formatText = (results) => {
+  for (const result of results) {
+    if (result.violations.length === 0) {
+      consola.success(`${result.name} \u2014 passed`);
+    } else {
+      consola.error(
+        `${result.name} \u2014 ${result.violations.length} violation(s)`
+      );
+      for (const v of result.violations) {
+        consola.log(`  ${v.container}: ${v.message}`);
+      }
+    }
+  }
+};
+const formatJson = (results) => {
+  const output = {
+    results: results.map((r) => ({
+      rule: r.name,
+      passed: r.violations.length === 0,
+      violations: r.violations
+    }))
+  };
+  console.log(JSON.stringify(output, void 0, 2));
+};
+const formatGithub = (results) => {
+  for (const result of results) {
+    for (const v of result.violations) {
+      console.log(`::error title=${result.name}::${v.container}: ${v.message}`);
+    }
+  }
+};
+const formatFixes = (fixes) => {
+  for (const fix of fixes) {
+    consola.info(`[${fix.rule}] ${fix.description}`);
+    for (const edit of fix.edits) {
+      switch (edit.type) {
+        case "remove": {
+          consola.log(`  - ${edit.search}`);
+          break;
+        }
+        case "replace": {
+          consola.log(`  - ${edit.search}`);
+          consola.log(`  + ${edit.content}`);
+          break;
+        }
+        case "add": {
+          consola.log(`  (after "${edit.search}")`);
+          consola.log(`  + ${edit.content}`);
+          break;
+        }
+      }
+    }
+  }
+};
+const detectFormat = (format) => {
+  if (format) return format;
+  if (process.env.GITHUB_ACTIONS) return "github";
+  return "text";
+};
+const check = defineCommand({
+  meta: { description: "Check architecture rules" },
+  args: {
+    format: {
+      type: "string",
+      description: "Output format: text, json, github"
+    },
+    fix: {
+      type: "boolean",
+      description: "Apply auto-fixes to the source file"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Show fixes without applying them"
+    }
+  },
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  async run({ args }) {
+    const config = await loadAndValidateConfig();
+    const model = await loadModel(config);
+    const results = runRules(model, config.rules);
+    const format = detectFormat(args.format);
+    switch (format) {
+      case "json": {
+        formatJson(results);
+        break;
+      }
+      case "github": {
+        formatGithub(results);
+        break;
+      }
+      default: {
+        formatText(results);
+      }
+    }
+    const hasViolations = results.some((r) => r.violations.length > 0);
+    if (args.fix || args["dry-run"]) {
+      if (!hasViolations) {
+        consola.success("No violations to fix");
+        return;
+      }
+      const syntax = getSyntax(config.source.type);
+      const fixes = generateFixes(model, results, config.rules, syntax);
+      if (fixes.length === 0) {
+        consola.info("No auto-fixes available for these violations");
+        if (hasViolations) {
+          throw new Error("Architecture rule violations found");
+        }
+        return;
+      }
+      formatFixes(fixes);
+      if (args["dry-run"]) {
+        return;
+      }
+      const sourcePath = path.resolve(config.source.path);
+      let source = await readFile(sourcePath, "utf8");
+      for (const fix of fixes) {
+        source = applyEdits(source, fix.edits);
+      }
+      await writeFile(sourcePath, source, "utf8");
+      const reModel = await loadModel(config);
+      const reResults = runRules(reModel, config.rules);
+      const remaining = reResults.reduce((n, r) => n + r.violations.length, 0);
+      consola.success(
+        `Applied ${fixes.length} fix(es), wrote ${sourcePath}` + (remaining > 0 ? ` (${remaining} violation(s) remain)` : "")
+      );
+      return;
+    }
+    if (hasViolations) {
+      try {
+        const syntax = getSyntax(config.source.type);
+        const fixes = generateFixes(model, results, config.rules, syntax);
+        if (fixes.length > 0) {
+          consola.info("Suggested fixes (run with --fix to apply):");
+          formatFixes(fixes);
+        }
+      } catch {
+      }
+      throw new Error("Architecture rule violations found");
+    }
+  }
+});
+
+const runPlantuml = async (config, outputPath) => {
+  const model = await loadModel(config);
+  const puml = generatePlantumlFromModel(model, {
+    boundaryLabel: config.generate?.boundaryLabel
+  });
+  if (outputPath) {
+    await fs.writeFile(outputPath, puml);
+    consola.success(`Written to ${outputPath}`);
+  } else {
+    console.log(puml);
+  }
+};
+const runKubernetes = async (config, outputDir) => {
+  const model = await loadModel(config);
+  const outputs = generateKubernetes(model);
+  const targetDir = outputDir ?? config.generate?.kubernetes?.path ?? "resources/kubernetes/microservices";
+  await fs.mkdir(targetDir, { recursive: true });
+  for (const output of outputs) {
+    const filePath = path.join(targetDir, output.fileName);
+    await fs.writeFile(filePath, output.content);
+  }
+  consola.success(`Generated ${outputs.length} file(s) in ${targetDir}`);
+};
+const generate = defineCommand({
+  meta: { description: "Generate architecture artifacts" },
+  args: {
+    output: {
+      type: "string",
+      description: "Output path (file for plantuml, directory for kubernetes)"
+    },
+    format: {
+      type: "string",
+      description: "Output format: plantuml, kubernetes"
+    }
+  },
+  async run({ args }) {
+    const config = await loadAndValidateConfig();
+    const format = args.format ?? "plantuml";
+    switch (format) {
+      case "plantuml": {
+        await runPlantuml(config, args.output);
+        break;
+      }
+      case "kubernetes": {
+        await runKubernetes(config, args.output);
+        break;
+      }
+      default: {
+        throw new Error(`Unknown format: ${format}`);
+      }
+    }
+  }
+});
+
+const template = `import { defineConfig } from "aact";
+
+export default defineConfig({
+  // Source of architecture description
+  source: {
+    type: "structurizr", // "plantuml" | "structurizr"
+    path: "./workspace.json",
+  },
+
+  // Validation rules (true = enabled with defaults, false = disabled)
+  rules: {
+    acl: true, // Anti-Corruption Layer: only tagged containers depend on externals
+    // acl: { tag: "acl", externalType: "System_Ext" },
+
+    acyclic: true, // No circular dependencies
+
+    crud: true, // Only repo/relay containers access databases
+    // crud: { repoTags: ["repo", "relay"], dbType: "ContainerDb" },
+
+    dbPerService: true, // Each database accessed by single service
+    // dbPerService: { dbType: "ContainerDb" },
+
+    cohesion: true, // Boundary cohesion > coupling
+    // cohesion: { externalType: "System_Ext", internalType: "Container" },
+  },
+
+  // PlantUML generation from Kubernetes configs (aact generate)
+  // generate: {
+  //   kubernetes: {
+  //     path: "resources/kubernetes/microservices",
+  //   },
+  //   boundaryLabel: "Our system",
+  // },
+});
+`;
+const configFileName = "aact.config.ts";
+const init = defineCommand({
+  meta: { description: "Create aact.config.ts with default settings" },
+  async run() {
+    const configPath = path.resolve(process.cwd(), configFileName);
+    try {
+      await fs.access(configPath);
+      consola.warn(`${configFileName} already exists. Skipping.`);
+      return;
+    } catch {
+    }
+    await fs.writeFile(configPath, template);
+    consola.success(`Created ${configFileName}`);
+  }
+});
+
+const main = defineCommand({
+  meta: {
+    name: "aact",
+    version: "2.0.0",
+    description: "Architecture analysis and compliance tool"
+  },
+  subCommands: { init, check, analyze, generate }
+});
+void runMain(main);