@bossmissing/agent-meta 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 agent-meta contributors
+
+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,91 @@
+# Agent Meta CLI
+
+面向 AI 编程工作流的项目元数据管理工具。在项目内建立并维护一套统一、可校验、可扩展的 Agent 协作元数据：根/局部 `AGENTS.md`、领域文档、ADR、文档 frontmatter、OpenSpec 基础结构检查等。
+
+完整需求见 [docs/prd.md](./docs/prd.md)。
+
+## 安装
+
+```bash
+pnpm add -D @bossmissing/agent-meta
+pnpm exec meta init
+```
+
+本仓库内开发：
+
+```bash
+pnpm install
+pnpm dev -- init          # tsx 直接运行
+pnpm build                # 编译到 dist/
+pnpm test                 # Vitest
+```
+
+## 命令
+
+| 命令 | 用途 |
+| --- | --- |
+| `meta init` | 初始化 Agent Meta 基础结构（`--yes` 非交互，`--type`，`--dry-run`） |
+| `meta new-domain <name>` | 创建领域文档目录与局部 `AGENTS.md`（`--title` `--owner` `--with-state-machine` `--with-glossary` `--no-local-agents` `--force` `--dry-run`） |
+| `meta new-adr <slug>` | 自动编号创建 ADR（`--title` `--owner` `--status` `--path` `--dry-run`） |
+| `meta check` | 确定性元数据校验（`--strict` `--docs` `--adr` `--agents` `--openspec` `--json`） |
+| `meta audit` | 治理分析报告，不阻塞、不改文件（`--agents` `--docs` `--risk` `--json`） |
+| `meta sync` | 重建 `docs/domain` / `docs/adr` 索引，调用 `openspec update`（`--indexes` `--openspec` `--dry-run`） |
+| `meta config list / set` | 查看与修改 `agent-meta.config.yaml` |
+
+## 退出码
+
+| 退出码 | 含义 |
+| --- | --- |
+| 0 | 无 error（warning 不阻塞；`--strict` 除外） |
+| 1 | 存在校验 error |
+| 2 | 命令参数错误 |
+| 3 | 配置文件无法解析 |
+| 4 | 文件系统 IO 错误 |
+| 5 | 模板缺失或损坏 |
+
+## 典型流程
+
+```bash
+meta init --yes
+
+meta new-domain withdrawal \
+  --title "提现与打款" \
+  --owner payments \
+  --with-state-machine
+
+meta new-adr withdrawal-idempotency \
+  --title "提现打款采用业务幂等键" \
+  --owner payments
+
+meta check --strict
+```
+
+## 模板覆盖
+
+在项目内创建 `templates/agent-meta/<name>.tmpl` 可覆盖内置模板（仅支持 `{{variable}}` 替换）：
+
+```
+templates/agent-meta/adr.md.tmpl
+templates/agent-meta/domain-readme.md.tmpl
+templates/agent-meta/domain-rules.md.tmpl
+templates/agent-meta/domain-state-machine.md.tmpl
+templates/agent-meta/domain-agents.md.tmpl
+templates/agent-meta/agents.md.tmpl
+```
+
+可用变量：`{{project_name}}` `{{project_type}}` `{{date}}` `{{owner}}` `{{domain_name}}` `{{domain_title}}` `{{adr_number}}` `{{slug}}` `{{status}}`。
+
+## CI 集成
+
+```yaml
+- run: pnpm exec meta check --strict
+```
+
+Git Hook（lefthook）：
+
+```yaml
+pre-commit:
+  commands:
+    meta-check:
+      run: pnpm exec meta check
+```

package/dist/analyzers/duplicate-rule-analyzer.d.ts

@@ -0,0 +1,31 @@
+export interface RuleLine {
+    raw: string;
+    normalized: string;
+    line: number;
+}
+/**
+ * Normalize a markdown line for heuristic rule comparison: strip list
+ * markers, inline code/emphasis markers, punctuation, collapse whitespace,
+ * lowercase. Returns "" for lines that are not rule-like (headings, blanks,
+ * comments, table rows, fences).
+ */
+export declare function normalizeRuleLine(line: string): string;
+export declare function extractRuleLines(content: string): RuleLine[];
+export interface DuplicateRule {
+    rule: string;
+    rootLine: number;
+    localLine: number;
+}
+export interface ConflictRule {
+    rootRule: string;
+    localRule: string;
+    rootLine: number;
+    localLine: number;
+}
+export interface AgentsComparison {
+    duplicates: DuplicateRule[];
+    conflicts: ConflictRule[];
+}
+/** Compare a local AGENTS.md against the root AGENTS.md. */
+export declare function compareAgentsRules(rootContent: string, localContent: string): AgentsComparison;
+export declare function countLines(absPath: string): number;

package/dist/analyzers/duplicate-rule-analyzer.js

@@ -0,0 +1,80 @@
+import fs from "node:fs";
+/**
+ * Normalize a markdown line for heuristic rule comparison: strip list
+ * markers, inline code/emphasis markers, punctuation, collapse whitespace,
+ * lowercase. Returns "" for lines that are not rule-like (headings, blanks,
+ * comments, table rows, fences).
+ */
+export function normalizeRuleLine(line) {
+    const trimmed = line.trim();
+    if (trimmed === "" ||
+        trimmed.startsWith("#") ||
+        trimmed.startsWith("<!--") ||
+        trimmed.startsWith("|") ||
+        trimmed.startsWith("```") ||
+        trimmed.startsWith("~~~") ||
+        trimmed.startsWith("---")) {
+        return "";
+    }
+    const normalized = trimmed
+        .replace(/^[-*+]\s+/, "")
+        .replace(/^\d+\.\s+/, "")
+        .replace(/[`*_]/g, "")
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}\s]/gu, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    // Very short fragments produce false positives.
+    return normalized.length >= 12 ? normalized : "";
+}
+export function extractRuleLines(content) {
+    const out = [];
+    let inFence = false;
+    content.split(/\r?\n/).forEach((raw, idx) => {
+        if (/^\s*(```|~~~)/.test(raw)) {
+            inFence = !inFence;
+            return;
+        }
+        if (inFence)
+            return;
+        const normalized = normalizeRuleLine(raw);
+        if (normalized)
+            out.push({ raw: raw.trim(), normalized, line: idx + 1 });
+    });
+    return out;
+}
+/** Compare a local AGENTS.md against the root AGENTS.md. */
+export function compareAgentsRules(rootContent, localContent) {
+    const rootRules = extractRuleLines(rootContent);
+    const localRules = extractRuleLines(localContent);
+    const rootByNorm = new Map(rootRules.map((r) => [r.normalized, r]));
+    const duplicates = [];
+    const conflicts = [];
+    for (const local of localRules) {
+        const dup = rootByNorm.get(local.normalized);
+        if (dup) {
+            duplicates.push({ rule: local.raw, rootLine: dup.line, localLine: local.line });
+            continue;
+        }
+        // Potential conflict: local "must not X" vs root "must X" (and vice versa).
+        const localWithoutNot = local.normalized
+            .replace(/\bmust not\b/, "must")
+            .replace(/\bdo not\b/, "do")
+            .replace(/\bnever\b/, "always");
+        if (localWithoutNot !== local.normalized) {
+            const conflicting = rootByNorm.get(localWithoutNot);
+            if (conflicting) {
+                conflicts.push({
+                    rootRule: conflicting.raw,
+                    localRule: local.raw,
+                    rootLine: conflicting.line,
+                    localLine: local.line,
+                });
+            }
+        }
+    }
+    return { duplicates, conflicts };
+}
+export function countLines(absPath) {
+    return fs.readFileSync(absPath, "utf8").split(/\r?\n/).length;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { Command } from "commander";
+import { EXIT_CODES, MetaError } from "./core/errors.js";
+import { logger } from "./core/logger.js";
+import { runInit } from "./commands/init.js";
+import { runNewDomain } from "./commands/new-domain.js";
+import { runNewAdr } from "./commands/new-adr.js";
+import { runCheck, printCheckResult, checkExitCode, toJsonOutput } from "./commands/check.js";
+import { runAudit } from "./commands/audit.js";
+import { runSync } from "./commands/sync.js";
+import { runConfigList, runConfigSet } from "./commands/config.js";
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+const program = new Command();
+const cwd = process.cwd();
+function handleError(e) {
+    if (e instanceof MetaError) {
+        logger.error(e.message);
+        process.exit(e.exitCode);
+    }
+    if (e instanceof Error && e.name === "ExitPromptError") {
+        // User pressed Ctrl+C inside an inquirer prompt.
+        process.exit(EXIT_CODES.OK);
+    }
+    const err = e;
+    if (err?.code === "EACCES" || err?.code === "EPERM" || err?.code === "ENOSPC") {
+        logger.error(`File system error: ${err.message}`);
+        process.exit(EXIT_CODES.IO_ERROR);
+    }
+    logger.error(e?.message ?? String(e));
+    process.exit(EXIT_CODES.CHECK_FAILED);
+}
+program
+    .name("meta")
+    .description("Agent Meta CLI — manage AI agent collaboration metadata")
+    .version(pkg.version, "-v, --version", "output the version number")
+    .exitOverride((err) => {
+    if (err.code === "commander.helpDisplayed" || err.code === "commander.version") {
+        process.exit(EXIT_CODES.OK);
+    }
+    process.exit(EXIT_CODES.BAD_ARGS);
+});
+program
+    .command("init")
+    .description("Initialize agent metadata infrastructure in the current project")
+    .option("-y, --yes", "non-interactive mode, accept all defaults")
+    .option("--type <type>", "project type: node | monorepo | nextjs | cocos | backend | other")
+    .option("--dry-run", "show what would be created without writing files")
+    .action(async (opts) => {
+    try {
+        await runInit(cwd, opts);
+    }
+    catch (e) {
+        handleError(e);
+    }
+});
+program
+    .command("new-domain")
+    .description("Create a domain documentation directory (and optional local AGENTS.md)")
+    .argument("<name>", "domain name, e.g. withdrawal or 'Payment Callback'")
+    .option("--title <title>", "human-readable title (Chinese allowed)")
+    .option("--owner <owner>", "owner team or person")
+    .option("--path <path>", "custom target directory")
+    .option("--with-state-machine", "also create state-machine.md")
+    .option("--with-glossary", "also create glossary.md")
+    .option("--with-local-agents", "also create a local AGENTS.md")
+    .option("--no-local-agents", "do not create a local AGENTS.md")
+    .option("--force", "create missing files in an existing domain directory (never overwrites)")
+    .option("--dry-run", "show what would be created without writing files")
+    .action((name, opts) => {
+    try {
+        runNewDomain(cwd, name, opts);
+    }
+    catch (e) {
+        handleError(e);
+    }
+});
+program
+    .command("new-adr")
+    .description("Create a new ADR with an auto-incremented number")
+    .argument("<slug>", "ADR slug, e.g. payment-callback-idempotency")
+    .option("--title <title>", "ADR title (Chinese allowed)")
+    .option("--owner <owner>", "owner team or person")
+    .option("--status <status>", "proposed | accepted | deprecated | superseded | rejected")
+    .option("--path <path>", "custom ADR directory")
+    .option("--dry-run", "show what would be created without writing files")
+    .action((slug, opts) => {
+    try {
+        runNewAdr(cwd, slug, opts);
+    }
+    catch (e) {
+        handleError(e);
+    }
+});
+program
+    .command("check")
+    .description("Run deterministic metadata checks (for local dev, git hooks and CI)")
+    .option("--strict", "treat warnings as errors")
+    .option("--docs", "only check document frontmatter")
+    .option("--adr", "only check ADRs")
+    .option("--agents", "only check AGENTS.md files")
+    .option("--openspec", "only check OpenSpec structure")
+    .option("--json", "machine-readable JSON output")
+    .action((opts) => {
+    try {
+        const result = runCheck(cwd, opts);
+        if (opts.json) {
+            console.log(JSON.stringify(toJsonOutput(result), null, 2));
+        }
+        else {
+            printCheckResult(result, Boolean(opts.strict));
+        }
+        process.exit(checkExitCode(result, Boolean(opts.strict)));
+    }
+    catch (e) {
+        handleError(e);
+    }
+});
+program
+    .command("audit")
+    .description("Governance-oriented analysis report (never blocks, never edits files)")
+    .option("--json", "machine-readable JSON output")
+    .option("--agents", "only audit AGENTS.md files")
+    .option("--docs", "only audit documentation health")
+    .option("--risk", "only audit high-risk domain coverage")
+    .action((opts) => {
+    try {
+        runAudit(cwd, opts);
+    }
+    catch (e) {
+        handleError(e);
+    }
+});
+program
+    .command("sync")
+    .description("Regenerate documentation indexes and sync OpenSpec")
+    .option("--indexes", "only regenerate docs/domain and docs/adr indexes")
+    .option("--openspec", "only run openspec update")
+    .option("--templates", "sync team template packs (planned)")
+    .option("--dry-run", "show what would be updated without writing files")
+    .action((opts) => {
+    try {
+        runSync(cwd, opts);
+    }
+    catch (e) {
+        handleError(e);
+    }
+});
+const configCmd = program
+    .command("config")
+    .description("View and modify agent-meta.config.yaml");
+configCmd
+    .command("list")
+    .description("Print the effective configuration")
+    .action(() => {
+    try {
+        runConfigList(cwd);
+    }
+    catch (e) {
+        handleError(e);
+    }
+});
+configCmd
+    .command("set")
+    .description("Set a configuration value, e.g. meta config set defaults.agents_max_lines 220")
+    .argument("<key>", "dot-separated key, e.g. defaults.review_interval_days")
+    .argument("<value>", "value")
+    .action((key, value) => {
+    try {
+        runConfigSet(cwd, key, value);
+    }
+    catch (e) {
+        handleError(e);
+    }
+});
+program.parseAsync(process.argv).catch(handleError);

package/dist/commands/audit.d.ts

@@ -0,0 +1,7 @@
+export interface AuditOptions {
+    json?: boolean;
+    agents?: boolean;
+    docs?: boolean;
+    risk?: boolean;
+}
+export declare function runAudit(root: string, opts: AuditOptions): void;

package/dist/commands/audit.js

@@ -0,0 +1,187 @@
+import fs from "node:fs";
+import path from "node:path";
+import pc from "picocolors";
+import { loadConfig } from "../core/config.js";
+import { parseDocFile } from "../core/frontmatter.js";
+import { dateValueToString, daysSince } from "../core/paths.js";
+import { matchRiskKeywords } from "../core/risk.js";
+import { compareAgentsRules } from "../analyzers/duplicate-rule-analyzer.js";
+import { findLocalAgentsFiles } from "../validators/agents-validator.js";
+import { listDomainDirs } from "../validators/domain-validator.js";
+import { listAdrFiles } from "../generators/adr-generator.js";
+import fg from "fast-glob";
+export function runAudit(root, opts) {
+    const { config } = loadConfig(root);
+    const all = !opts.agents && !opts.docs && !opts.risk;
+    const report = {};
+    // --- Agents audit -------------------------------------------------------
+    let agentsAudit = null;
+    if (all || opts.agents) {
+        const rootAgentsAbs = path.join(root, config.paths.root_agents);
+        const rootContent = fs.existsSync(rootAgentsAbs)
+            ? fs.readFileSync(rootAgentsAbs, "utf8")
+            : null;
+        const localFiles = findLocalAgentsFiles(root, config.paths.root_agents);
+        let duplicateRules = 0;
+        let conflictingRules = 0;
+        if (rootContent) {
+            for (const rel of localFiles) {
+                const { duplicates, conflicts } = compareAgentsRules(rootContent, fs.readFileSync(path.join(root, rel), "utf8"));
+                duplicateRules += duplicates.length;
+                conflictingRules += conflicts.length;
+            }
+        }
+        agentsAudit = {
+            rootLines: rootContent ? rootContent.split(/\r?\n/).length : null,
+            rootMaxLines: config.defaults.agents_max_lines,
+            localFiles,
+            duplicateRules,
+            conflictingRules,
+        };
+        report.agents = agentsAudit;
+    }
+    // --- Docs health --------------------------------------------------------
+    let docsAudit = null;
+    if (all || opts.docs) {
+        const files = fg
+            .sync(config.validation.require_doc_frontmatter, { cwd: root, ignore: ["**/AGENTS.md"] })
+            .sort();
+        const byStatus = {};
+        let noOwner = 0;
+        let stale = 0;
+        for (const rel of files) {
+            const doc = parseDocFile(path.join(root, rel));
+            const status = typeof doc.data["status"] === "string" ? doc.data["status"] : "unknown";
+            byStatus[status] = (byStatus[status] ?? 0) + 1;
+            const owner = doc.data["owner"];
+            if (!owner || (Array.isArray(owner) && owner.length === 0))
+                noOwner++;
+            const reviewed = dateValueToString(doc.data["last_reviewed"]);
+            const staleDays = status === "active"
+                ? config.validation.stale_review_days.active
+                : status === "draft"
+                    ? config.validation.stale_review_days.draft
+                    : null;
+            if (reviewed && staleDays !== null && daysSince(reviewed) > staleDays)
+                stale++;
+        }
+        // Orphan ADRs: not referenced by any other markdown file in the repo.
+        const adrDir = path.join(root, config.paths.adr_docs);
+        const adrs = listAdrFiles(adrDir);
+        const allMd = fg.sync("**/*.md", {
+            cwd: root,
+            ignore: ["node_modules/**", ".git/**", "dist/**"],
+        });
+        const corpus = allMd
+            .filter((rel) => !rel.startsWith(config.paths.adr_docs))
+            .map((rel) => fs.readFileSync(path.join(root, rel), "utf8"))
+            .join("\n");
+        const orphanAdrs = adrs
+            .filter((a) => !corpus.includes(path.basename(a.file)))
+            .map((a) => path.basename(a.file));
+        const domainsWithoutReadme = listDomainDirs(root, config.paths.domain_docs).filter((d) => !fs.existsSync(path.join(root, config.paths.domain_docs, d, "README.md")));
+        docsAudit = {
+            totalDocs: files.length,
+            byStatus,
+            noOwner,
+            stale,
+            adrTotal: adrs.length,
+            orphanAdrs,
+            domainsWithoutReadme,
+        };
+        report.docs = docsAudit;
+    }
+    // --- Risk coverage ------------------------------------------------------
+    let riskAudit = null;
+    if (all || opts.risk) {
+        riskAudit = [];
+        for (const domain of listDomainDirs(root, config.paths.domain_docs)) {
+            const matched = matchRiskKeywords(domain, config.risk_keywords);
+            if (matched.length === 0)
+                continue;
+            const dir = path.join(root, config.paths.domain_docs, domain);
+            const coverage = {
+                "README.md": fs.existsSync(path.join(dir, "README.md")),
+                "rules.md": fs.existsSync(path.join(dir, "rules.md")),
+                "local AGENTS.md": fs.existsSync(path.join(dir, "AGENTS.md")),
+                "state-machine.md": fs.existsSync(path.join(dir, "state-machine.md")),
+            };
+            const recommendations = [];
+            if (!coverage["rules.md"])
+                recommendations.push("Add rules.md with invariants and boundaries.");
+            if (!coverage["local AGENTS.md"])
+                recommendations.push("Add a local AGENTS.md.");
+            if (!coverage["state-machine.md"])
+                recommendations.push("Add a state machine.");
+            recommendations.push(`Consider an ADR for ${domain} idempotency / retry / audit logging.`);
+            riskAudit.push({ domain, matched, coverage, recommendations });
+        }
+        report.risk = riskAudit;
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    // --- Text report --------------------------------------------------------
+    console.log(pc.bold("Agent Meta Audit"));
+    console.log();
+    if (agentsAudit) {
+        console.log(pc.bold("AGENTS.md Audit"));
+        console.log();
+        if (agentsAudit.rootLines === null) {
+            console.log("Root AGENTS.md: missing");
+        }
+        else {
+            console.log(`Root AGENTS.md: ${agentsAudit.rootLines} lines`);
+            if (agentsAudit.rootLines > agentsAudit.rootMaxLines) {
+                console.log("Recommendation: split into architecture, domain, and engineering documentation.");
+            }
+        }
+        console.log();
+        console.log(`Local AGENTS.md files: ${agentsAudit.localFiles.length}`);
+        for (const f of agentsAudit.localFiles)
+            console.log(`- ${f}`);
+        console.log();
+        console.log(`Potential duplicate rules: ${agentsAudit.duplicateRules}`);
+        console.log(`Potential conflicting rules: ${agentsAudit.conflictingRules}`);
+        console.log();
+    }
+    if (docsAudit) {
+        console.log(pc.bold("Docs Health"));
+        console.log();
+        console.log(`Total documents: ${docsAudit.totalDocs}`);
+        const statusLine = Object.entries(docsAudit.byStatus)
+            .map(([k, v]) => `${k}: ${v}`)
+            .join(", ");
+        console.log(`Status distribution: ${statusLine || "n/a"}`);
+        console.log(`Documents without owner: ${docsAudit.noOwner}`);
+        console.log(`Stale documents: ${docsAudit.stale}`);
+        console.log(`ADRs: ${docsAudit.adrTotal} (orphan: ${docsAudit.orphanAdrs.length})`);
+        for (const o of docsAudit.orphanAdrs)
+            console.log(`- orphan: ${o}`);
+        if (docsAudit.domainsWithoutReadme.length > 0) {
+            console.log(`Domains without README: ${docsAudit.domainsWithoutReadme.join(", ")}`);
+        }
+        console.log();
+    }
+    if (riskAudit) {
+        console.log(pc.bold("High-Risk Domains"));
+        console.log();
+        if (riskAudit.length === 0) {
+            console.log("No high-risk domains detected.");
+        }
+        for (const r of riskAudit) {
+            console.log(`High-risk domain detected: ${r.domain} (matched: ${r.matched.join(", ")})`);
+            console.log();
+            console.log("Current coverage:");
+            for (const [file, ok] of Object.entries(r.coverage)) {
+                console.log(`${ok ? pc.green("✓") : pc.red("✗")} ${file}`);
+            }
+            console.log();
+            console.log("Recommendation:");
+            for (const rec of r.recommendations)
+                console.log(`- ${rec}`);
+            console.log();
+        }
+    }
+}

package/dist/commands/check.d.ts

@@ -0,0 +1,35 @@
+import { type MetaCheckResult } from "../core/types.js";
+export interface CheckOptions {
+    strict?: boolean;
+    docs?: boolean;
+    adr?: boolean;
+    agents?: boolean;
+    openspec?: boolean;
+    json?: boolean;
+}
+export declare function runCheck(root: string, opts?: CheckOptions): MetaCheckResult;
+export declare function printCheckResult(result: MetaCheckResult, strict: boolean): void;
+export declare function checkExitCode(result: MetaCheckResult, strict: boolean): number;
+export declare function toJsonOutput(result: MetaCheckResult): {
+    status: import("../core/types.js").CheckStatus;
+    errors: {
+        code: string;
+        file: string | undefined;
+        line: number | undefined;
+        message: string;
+        suggestion: string | undefined;
+    }[];
+    warnings: {
+        code: string;
+        file: string | undefined;
+        line: number | undefined;
+        message: string;
+        suggestion: string | undefined;
+    }[];
+    summary: {
+        errors: number;
+        warnings: number;
+        infos: number;
+        checkedFiles: number;
+    };
+};