@agentxm/client-core 0.3.2 → 0.4.0

package/dist/src/unstable/lint/cli.js

@@ -222,83 +222,844 @@ export const detectPublishGateDrift = (config) => {
     visitCatalog(packRules);
     return weakened;
 };
-/**
- * Render a finding-first human text report.
- *
- * Output shape (one line per entry, grouped first by context type then by
- * severity within each group):
- *
- *     DRIFT: The registry will still block publish on these rules:
- *       - skill/manifest-schema-valid
- *
- *     WORKSPACE
- *       [error] workspace/lockfile-valid  axm-lock.yaml is missing.  ./axm-lock.yaml
- *       [warning] workspace/...  ...
- *
- *     SKILLS
- *       [error] ...
- *
- *     Summary: 2 errors, 1 warning.
- *     Applied 3 fixes; 1 warning surfaced from applyPlan.
- *
- * @experimental This API is unstable and may change without notice.
- */
-export const renderFindingsText = (args) => {
-    const lines = [];
-    const { summary, fixSummary } = args;
-    if (summary.driftBanner.length > 0) {
-        lines.push("DRIFT: The registry will still block publish on these rules:");
-        for (const id of summary.driftBanner) {
-            lines.push(`  - ${id}`);
+const defaultHumanReporter = "grouped";
+const compareRenderedFindings = (left, right) => {
+    const byPath = left.path.localeCompare(right.path);
+    if (byPath !== 0) {
+        return byPath;
+    }
+    const bySeverity = severityOrder(left.finding.severity) - severityOrder(right.finding.severity);
+    if (bySeverity !== 0) {
+        return bySeverity;
+    }
+    const byRuleId = left.finding.ruleId.localeCompare(right.finding.ruleId);
+    if (byRuleId !== 0) {
+        return byRuleId;
+    }
+    return left.finding.message.localeCompare(right.finding.message);
+};
+const pluralize = (n, singular, plural) => n === 1 ? singular : plural;
+const splitSentences = (message) => {
+    const out = [];
+    let remaining = message.trim();
+    while (remaining.length > 0) {
+        const match = /^(.+?\.(?=\s+[A-Z`]))\s+(.+)$/.exec(remaining);
+        if (match === null) {
+            out.push(remaining);
+            break;
         }
-        lines.push("");
-    }
-    const groups = [
-        { key: "workspace", label: "WORKSPACE" },
-        { key: "skill", label: "SKILLS" },
-        { key: "pack", label: "PACKS" },
-    ];
-    for (const group of groups) {
-        const inGroup = summary.findings.filter((f) => f.group === group.key);
-        if (inGroup.length === 0) {
+        const head = match[1];
+        const tail = match[2];
+        if (head === undefined || tail === undefined) {
+            out.push(remaining);
+            break;
+        }
+        out.push(head);
+        remaining = tail;
+    }
+    return out;
+};
+const splitDetailClause = (message) => {
+    const marker = " Detail: ";
+    const index = message.indexOf(marker);
+    if (index === -1) {
+        return {
+            lead: message,
+            detail: undefined,
+            trailing: [],
+        };
+    }
+    const lead = message.slice(0, index);
+    const rest = message.slice(index + marker.length);
+    const sentences = splitSentences(rest);
+    const detail = sentences[0];
+    return {
+        lead,
+        detail,
+        trailing: sentences.slice(1),
+    };
+};
+const parseFindingMessage = (message) => {
+    const detailSplit = splitDetailClause(message);
+    const leadSentences = splitSentences(detailSplit.lead);
+    const title = leadSentences[0] ?? message.trim();
+    const details = detailSplit.detail === undefined ? [] : [detailSplit.detail];
+    return {
+        title,
+        details,
+        helps: [...leadSentences.slice(1), ...detailSplit.trailing],
+    };
+};
+const dirnamePosix = (path) => {
+    if (path === "." || path === "..") {
+        return path;
+    }
+    const index = path.lastIndexOf("/");
+    if (index <= 0) {
+        return path;
+    }
+    return path.slice(0, index);
+};
+const groupDisplayPath = (entry) => {
+    switch (entry.finding.ruleId) {
+        case "workspace/skills-managed":
+            return dirnamePosix(entry.path);
+        default:
+            return entry.path;
+    }
+};
+const bucketForFinding = (entry, parsed) => {
+    switch (entry.finding.ruleId) {
+        case "workspace/lockfile-valid":
+            if (parsed.title.startsWith("Lockfile is missing required field `")) {
+                return "missing-required-field";
+            }
+            if (parsed.title.startsWith("The lockfile is not valid YAML.")) {
+                return "invalid-yaml";
+            }
+            return "validation";
+        case "workspace/skills-managed":
+            if (parsed.title.includes("but it is not managed by this workspace.")) {
+                return "unmanaged";
+            }
+            return "managed";
+        case "workspace/skills-artifacts-correct":
+            return "artifact-state";
+        case "workspace/skills-lockfile-aligned":
+            if (parsed.title.includes("missing from the lockfile.")) {
+                return "missing";
+            }
+            if (parsed.title.includes("listed in the lockfile but not in settings.skills.")) {
+                return "orphan";
+            }
+            if (parsed.title.includes("lockfile version does not match the declared version.")) {
+                return "version";
+            }
+            return "alignment";
+        case "workspace/skills-integrity-valid":
+            return "integrity";
+        default:
+            return entry.finding.ruleId;
+    }
+};
+const parseHumanFinding = (entry) => {
+    const parsed = parseFindingMessage(entry.finding.message);
+    return {
+        path: groupDisplayPath(entry),
+        bucket: bucketForFinding(entry, parsed),
+        severity: entry.finding.severity,
+        ruleId: entry.finding.ruleId,
+        title: parsed.title,
+        details: parsed.details,
+        helps: parsed.helps,
+        fixable: entry.finding.kind === "autofixable",
+    };
+};
+const matchSingleQuoted = (message) => {
+    const match = /'([^']+)'/.exec(message);
+    return match?.[1];
+};
+const uniqueStrings = (values) => {
+    const out = [];
+    const seen = new Set();
+    for (const value of values) {
+        if (seen.has(value)) {
             continue;
         }
-        const sorted = [...inGroup].sort((a, b) => severityOrder(a.finding.severity) - severityOrder(b.finding.severity));
-        lines.push(group.label);
-        for (const entry of sorted) {
-            lines.push(`  [${entry.finding.severity}] ${entry.finding.ruleId}  ${entry.finding.message}  ${entry.path}`);
+        seen.add(value);
+        out.push(value);
+    }
+    return out;
+};
+const sortStrings = (values) => [...values].sort();
+const uniquePaths = (findings) => uniqueStrings(findings.map((finding) => finding.path));
+const mergedRuleHelps = (findings, autofixHelp) => {
+    if (findings.every((finding) => finding.fixable)) {
+        return [autofixHelp];
+    }
+    const helps = uniqueStrings(findings.flatMap((finding) => finding.helps));
+    return helps.length > 0
+        ? helps
+        : findings.some((finding) => finding.fixable)
+            ? [autofixHelp]
+            : [];
+};
+const summarizeSkillByDetail = (finding) => {
+    const name = matchSingleQuoted(finding.title);
+    const detail = finding.details[0];
+    if (name === undefined) {
+        return detail ?? finding.title;
+    }
+    if (detail === undefined) {
+        return name;
+    }
+    return `${name}: ${detail}`;
+};
+const compressDetails = (details, limit = 10) => {
+    if (details.length <= limit) {
+        return details;
+    }
+    const remaining = details.length - limit;
+    return [...details.slice(0, limit), `... and ${remaining} more`];
+};
+const previewList = (values, limit = 3) => {
+    if (values.length === 0) {
+        return "";
+    }
+    if (values.length <= limit) {
+        return values.join(", ");
+    }
+    const remaining = values.length - limit;
+    return `${values.slice(0, limit).join(", ")}, ... and ${remaining} more`;
+};
+const groupFindingsByPath = (findings, extract) => {
+    const grouped = new Map();
+    for (const finding of findings) {
+        const current = grouped.get(finding.path);
+        const value = extract(finding);
+        if (current === undefined) {
+            grouped.set(finding.path, [value]);
+        }
+        else {
+            current.push(value);
+        }
+    }
+    return [...grouped.entries()].sort(([left], [right]) => left.localeCompare(right));
+};
+const coalesceFullDiagnostic = (findings) => {
+    const [first] = findings;
+    if (first === undefined) {
+        return {
+            severity: "info",
+            ruleId: "",
+            title: "",
+            details: [],
+            helps: [],
+            fixable: false,
+            paths: [],
+        };
+    }
+    if (findings.length === 1) {
+        return {
+            severity: first.severity,
+            ruleId: first.ruleId,
+            title: first.title,
+            details: first.details,
+            helps: first.helps,
+            fixable: first.fixable,
+            paths: [first.path],
+        };
+    }
+    const allHelps = uniqueStrings(findings.flatMap((finding) => finding.helps));
+    const paths = uniquePaths(findings);
+    switch (`${first.ruleId}:${first.bucket}`) {
+        case "workspace/lockfile-valid:missing-required-field": {
+            const fields = findings.flatMap((finding) => {
+                const match = /Lockfile is missing required field `([^`]+)`\./.exec(finding.title);
+                return match?.[1] === undefined ? [] : [match[1]];
+            });
+            return {
+                severity: first.severity,
+                ruleId: first.ruleId,
+                title: "Lockfile is missing required fields.",
+                details: compressDetails(fields),
+                helps: [
+                    "Regenerate `.axm/axm-lock.yaml` from `.axm/settings.json` by reinstalling the declared extensions.",
+                ],
+                fixable: false,
+                paths,
+            };
+        }
+        case "workspace/skills-managed:unmanaged": {
+            const names = findings.flatMap((finding) => {
+                const name = matchSingleQuoted(finding.title);
+                return name === undefined ? [] : [name];
+            });
+            return {
+                severity: first.severity,
+                ruleId: first.ruleId,
+                title: `${names.length} ${pluralize(names.length, "skill is", "skills are")} present here but not managed by this workspace.`,
+                details: compressDetails(names),
+                helps: [
+                    "To keep them: run `axm skills install <source>` for each skill you want axm to manage.",
+                    "To remove them: run `axm prune` or `axm skills prune <name>`.",
+                ],
+                fixable: false,
+                paths,
+            };
+        }
+        case "workspace/skills-artifacts-correct:enabled-missing":
+        case "workspace/skills-artifacts-correct:disabled-present":
+        case "workspace/skills-artifacts-correct:inconsistent":
+        case "workspace/skills-artifacts-correct:artifact-state":
+            return {
+                severity: first.severity,
+                ruleId: first.ruleId,
+                title: `${findings.length} ${pluralize(findings.length, "skill is", "skills are")} inconsistent across the declared agents.`,
+                details: compressDetails(findings.map(summarizeSkillByDetail)),
+                helps: mergedRuleHelps(findings, "Run `axm lint --fix` to reconcile the declared agent artifacts."),
+                fixable: findings.some((finding) => finding.fixable),
+                paths,
+            };
+        case "workspace/skills-lockfile-aligned:missing":
+        case "workspace/skills-lockfile-aligned:orphan":
+        case "workspace/skills-lockfile-aligned:version":
+        case "workspace/skills-lockfile-aligned:alignment":
+            return {
+                severity: first.severity,
+                ruleId: first.ruleId,
+                title: "Skill declarations and lockfile entries are out of sync.",
+                details: compressDetails(findings.map(summarizeSkillByDetail)),
+                helps: ["Run `axm lint --fix` to reconcile settings.skills with the lockfile."],
+                fixable: true,
+                paths,
+            };
+        case "workspace/skills-integrity-valid:integrity":
+            return {
+                severity: first.severity,
+                ruleId: first.ruleId,
+                title: "Installed skill sources do not match their lockfile entries.",
+                details: compressDetails(findings.map(summarizeSkillByDetail)),
+                helps: mergedRuleHelps(findings, "Run `axm lint --fix` to reinstall the affected skills."),
+                fixable: findings.some((finding) => finding.fixable),
+                paths,
+            };
+        default:
+            return {
+                severity: first.severity,
+                ruleId: first.ruleId,
+                title: `${findings.length} findings reported for this rule.`,
+                details: compressDetails(findings.map((finding) => finding.details.length === 0
+                    ? finding.title
+                    : `${finding.title}: ${finding.details.join("; ")}`)),
+                helps: allHelps,
+                fixable: findings.some((finding) => finding.fixable),
+                paths,
+            };
+    }
+};
+const coalesceGroupedDiagnostic = (findings) => {
+    const [first] = findings;
+    if (first === undefined) {
+        return {
+            severity: "info",
+            ruleId: "",
+            title: "",
+            details: [],
+            helps: [],
+            fixable: false,
+            paths: [],
+        };
+    }
+    if (findings.length === 1) {
+        return {
+            severity: first.severity,
+            ruleId: first.ruleId,
+            title: first.title,
+            details: first.details,
+            helps: first.helps,
+            fixable: first.fixable,
+            paths: [first.path],
+        };
+    }
+    const paths = uniquePaths(findings);
+    const allHelps = uniqueStrings(findings.flatMap((finding) => finding.helps));
+    switch (`${first.ruleId}:${first.bucket}`) {
+        case "workspace/lockfile-valid:missing-required-field": {
+            const fields = sortStrings(uniqueStrings(findings.flatMap((finding) => {
+                const match = /Lockfile is missing required field `([^`]+)`\./.exec(finding.title);
+                return match?.[1] === undefined ? [] : [match[1]];
+            })));
+            return {
+                severity: first.severity,
+                ruleId: first.ruleId,
+                title: "Lockfile is missing fields required by the current schema.",
+                details: [`Missing fields include: ${previewList(fields, 4)}`],
+                helps: [
+                    "Fix: Regenerate `.axm/axm-lock.yaml` from `.axm/settings.json` by reinstalling the declared extensions.",
+                ],
+                fixable: false,
+                paths,
+            };
+        }
+        case "workspace/skills-managed:unmanaged": {
+            const perPath = groupFindingsByPath(findings, (finding) => matchSingleQuoted(finding.title) ?? finding.title);
+            return {
+                severity: first.severity,
+                ruleId: first.ruleId,
+                title: `Unmanaged skills are present in ${paths.length} ${pluralize(paths.length, "skill directory", "skill directories")}.`,
+                details: compressDetails(perPath.map(([path, names]) => {
+                    const sorted = sortStrings(uniqueStrings(names));
+                    return `${path}: ${sorted.length} unmanaged ${pluralize(sorted.length, "skill", "skills")} (${previewList(sorted, 3)})`;
+                }), 8),
+                helps: [
+                    "To keep them: run `axm skills install <source>` for each skill you want axm to manage.",
+                    "To remove them: run `axm prune` or `axm skills prune <name>`.",
+                ],
+                fixable: false,
+                paths,
+            };
         }
-        lines.push("");
+        case "workspace/skills-artifacts-correct:enabled-missing":
+        case "workspace/skills-artifacts-correct:disabled-present":
+        case "workspace/skills-artifacts-correct:inconsistent":
+        case "workspace/skills-artifacts-correct:artifact-state":
+            return {
+                severity: first.severity,
+                ruleId: first.ruleId,
+                title: `${findings.length} ${pluralize(findings.length, "skill is", "skills are")} inconsistent across the declared agents.`,
+                details: compressDetails(findings.map(summarizeSkillByDetail)),
+                helps: mergedRuleHelps(findings, "Run `axm lint --fix` to reconcile the declared agent artifacts."),
+                fixable: findings.some((finding) => finding.fixable),
+                paths,
+            };
+        case "workspace/skills-lockfile-aligned:missing":
+        case "workspace/skills-lockfile-aligned:orphan":
+        case "workspace/skills-lockfile-aligned:version":
+        case "workspace/skills-lockfile-aligned:alignment":
+            return {
+                severity: first.severity,
+                ruleId: first.ruleId,
+                title: "`settings.skills` and the lockfile are out of sync.",
+                details: compressDetails(findings.map(summarizeSkillByDetail)),
+                helps: ["Run `axm lint --fix` to reconcile `settings.skills` with the lockfile."],
+                fixable: true,
+                paths,
+            };
+        case "workspace/skills-integrity-valid:integrity":
+            return {
+                severity: first.severity,
+                ruleId: first.ruleId,
+                title: "Installed skill sources do not match their lockfile entries.",
+                details: compressDetails(findings.map(summarizeSkillByDetail)),
+                helps: mergedRuleHelps(findings, "Run `axm lint --fix` to reinstall the affected skills."),
+                fixable: findings.some((finding) => finding.fixable),
+                paths,
+            };
+        default:
+            return {
+                severity: first.severity,
+                ruleId: first.ruleId,
+                title: findings.length === 1
+                    ? first.title
+                    : `${findings.length} related findings were reported.`,
+                details: compressDetails(findings.map((finding) => {
+                    const detail = finding.details.length === 0
+                        ? finding.title
+                        : `${finding.title}: ${finding.details.join("; ")}`;
+                    return paths.length === 1 ? detail : `${finding.path}: ${detail}`;
+                })),
+                helps: allHelps,
+                fixable: findings.some((finding) => finding.fixable),
+                paths,
+            };
+    }
+};
+const joinList = (values) => {
+    if (values.length === 0) {
+        return "";
+    }
+    if (values.length === 1) {
+        return values[0] ?? "";
     }
-    if (summary.findings.length === 0 && summary.driftBanner.length === 0) {
-        lines.push("No findings.");
+    if (values.length === 2) {
+        const first = values[0] ?? "";
+        const second = values[1] ?? "";
+        return `${first} and ${second}`;
+    }
+    const head = values.slice(0, -1).join(", ");
+    const tail = values[values.length - 1] ?? "";
+    return `${head}, and ${tail}`;
+};
+const formatFullOverviewSentence = (args) => {
+    const parts = [];
+    if (args.counts.errors > 0) {
+        parts.push(`${args.counts.errors} ${pluralize(args.counts.errors, "error", "errors")}`);
+    }
+    if (args.counts.warnings > 0) {
+        parts.push(`${args.counts.warnings} ${pluralize(args.counts.warnings, "warning", "warnings")}`);
+    }
+    if (args.counts.infos > 0) {
+        parts.push(`${args.counts.infos} ${pluralize(args.counts.infos, "info", "infos")}`);
+    }
+    const locations = `${args.locationCount} ${pluralize(args.locationCount, "location", "locations")}`;
+    const base = `Found ${joinList(parts)} in ${locations}.`;
+    if (args.fixableCount === 0) {
+        return base;
+    }
+    return `${base} ${args.fixableCount} ${pluralize(args.fixableCount, "finding can", "findings can")} be auto-fixed.`;
+};
+const formatGroupedOverviewSentence = (args) => {
+    const parts = [`${args.diagnosticCount} ${pluralize(args.diagnosticCount, "issue", "issues")}.`];
+    if (args.fixableCount > 0) {
+        parts.push(`${args.fixableCount} ${pluralize(args.fixableCount, "can", "can")} be fixed automatically.`);
+    }
+    const manualCount = args.diagnosticCount - args.fixableCount;
+    if (manualCount > 0) {
+        parts.push(`${manualCount} ${pluralize(manualCount, "needs", "need")} manual attention.`);
+    }
+    return parts.join(" ");
+};
+const buildFullDiagnostics = (parsed) => {
+    const pathOrder = [];
+    const byPath = new Map();
+    for (const entry of parsed) {
+        const current = byPath.get(entry.path);
+        if (current === undefined) {
+            byPath.set(entry.path, [entry]);
+            pathOrder.push(entry.path);
+        }
+        else {
+            current.push(entry);
+        }
+    }
+    const blocks = [];
+    pathOrder.forEach((path, index) => {
+        const pathEntries = byPath.get(path);
+        if (pathEntries === undefined) {
+            return;
+        }
+        const groups = new Map();
+        const groupOrder = [];
+        for (const entry of pathEntries) {
+            const key = `${severityOrder(entry.severity)}:${entry.ruleId}:${entry.bucket}`;
+            const current = groups.get(key);
+            if (current === undefined) {
+                groups.set(key, [entry]);
+                groupOrder.push(key);
+            }
+            else {
+                current.push(entry);
+            }
+        }
+        blocks.push({
+            kind: "pathGroup",
+            path,
+            diagnostics: groupOrder.flatMap((key) => {
+                const grouped = groups.get(key);
+                return grouped === undefined ? [] : [coalesceFullDiagnostic(grouped)];
+            }),
+        });
+        if (index < pathOrder.length - 1) {
+            blocks.push({ kind: "blank" });
+        }
+    });
+    return blocks;
+};
+const groupedBucketKey = (entry) => {
+    switch (entry.ruleId) {
+        case "workspace/skills-managed":
+            return `${entry.ruleId}:${entry.bucket}`;
+        default:
+            return `${entry.path}:${entry.ruleId}:${entry.bucket}`;
+    }
+};
+const buildGroupedDiagnostics = (parsed) => {
+    const groups = new Map();
+    const order = [];
+    for (const entry of parsed) {
+        const key = groupedBucketKey(entry);
+        const current = groups.get(key);
+        if (current === undefined) {
+            groups.set(key, [entry]);
+            order.push(key);
+        }
+        else {
+            current.push(entry);
+        }
+    }
+    return order.flatMap((key) => {
+        const grouped = groups.get(key);
+        return grouped === undefined ? [] : [coalesceGroupedDiagnostic(grouped)];
+    });
+};
+const appendDiagnosticSection = (blocks, title, diagnostics, note) => {
+    if (diagnostics.length === 0) {
+        return;
+    }
+    if (blocks.length > 0) {
+        blocks.push({ kind: "blank" });
+    }
+    blocks.push(note === undefined ? { kind: "section", title } : { kind: "section", title, note });
+    diagnostics.forEach((diagnostic, index) => {
+        blocks.push({ kind: "diagnostic", diagnostic });
+        if (index < diagnostics.length - 1) {
+            blocks.push({ kind: "blank" });
+        }
+    });
+};
+const stripFixHelps = (diagnostic) => {
+    const filtered = diagnostic.helps.filter((h) => !h.includes("axm lint --fix"));
+    return filtered.length === diagnostic.helps.length
+        ? diagnostic
+        : { ...diagnostic, helps: filtered };
+};
+const buildSectionedDiagnostics = (args) => {
+    const fixable = args.diagnostics.filter((diagnostic) => diagnostic.fixable);
+    const manual = args.diagnostics.filter((diagnostic) => diagnostic.severity === "error" && !diagnostic.fixable);
+    const warnings = args.diagnostics.filter((diagnostic) => diagnostic.severity === "warning");
+    const infos = args.diagnostics.filter((diagnostic) => diagnostic.severity === "info");
+    appendDiagnosticSection(args.blocks, "Auto-fixable", fixable.map(stripFixHelps), "run `axm lint --fix`");
+    appendDiagnosticSection(args.blocks, "Requires manual attention", manual);
+    appendDiagnosticSection(args.blocks, "Warnings", warnings);
+    appendDiagnosticSection(args.blocks, "Information", infos);
+};
+const makeSummaryDiagnostic = (diagnostic) => ({
+    ...diagnostic,
+    details: diagnostic.paths.length === 1
+        ? ["1 affected location"]
+        : [
+            `${diagnostic.paths.length} affected ${pluralize(diagnostic.paths.length, "location", "locations")}`,
+        ],
+    helps: [],
+});
+const toFullLintHumanBlocks = (args) => {
+    const blocks = [];
+    const { summary, fixSummary } = args;
+    if (summary.findings.length === 0) {
+        blocks.push(summary.driftBanner.length === 0
+            ? { kind: "empty", message: "No findings." }
+            : { kind: "empty", message: "No local findings." });
     }
     else {
-        lines.push(formatCountsSentence(summary.counts));
+        const parsed = [...summary.findings].sort(compareRenderedFindings).map(parseHumanFinding);
+        const locationCount = uniqueStrings(parsed.map((finding) => finding.path)).length;
+        const fixableCount = summary.findings.filter((finding) => finding.finding.kind === "autofixable").length;
+        blocks.push({
+            kind: "overview",
+            message: formatFullOverviewSentence({
+                counts: summary.counts,
+                locationCount,
+                fixableCount,
+            }),
+            counts: summary.counts,
+            notes: fixableCount > 0 && fixSummary === undefined
+                ? ["Next step: Run `axm lint --fix` for the auto-fixable findings."]
+                : [],
+        });
+        if (summary.driftBanner.length > 0) {
+            blocks.push({ kind: "blank" });
+            blocks.push({
+                kind: "driftBanner",
+                title: "The registry will still block publish on these rules:",
+                ruleIds: summary.driftBanner,
+            });
+        }
+        const diagnostics = buildFullDiagnostics(parsed);
+        if (diagnostics.length > 0) {
+            blocks.push({ kind: "blank" });
+            blocks.push(...diagnostics);
+        }
+    }
+    if (summary.findings.length === 0 && summary.driftBanner.length > 0) {
+        blocks.push({ kind: "blank" });
+        blocks.push({
+            kind: "driftBanner",
+            title: "The registry will still block publish on these rules:",
+            ruleIds: summary.driftBanner,
+        });
     }
     if (fixSummary !== undefined) {
-        lines.push(formatFixSummary(fixSummary));
-        for (const warning of fixSummary.warnings) {
-            lines.push(`  warning: ${warning}`);
+        blocks.push({ kind: "blank" });
+        blocks.push({
+            kind: "fixSummary",
+            message: formatFixSummary(fixSummary),
+            summary: fixSummary,
+        });
+    }
+    return blocks;
+};
+const toGroupedLintHumanBlocks = (args) => {
+    const blocks = [];
+    const { summary, fixSummary } = args;
+    if (summary.findings.length === 0) {
+        blocks.push(summary.driftBanner.length === 0
+            ? { kind: "empty", message: "No findings." }
+            : { kind: "empty", message: "No local findings." });
+    }
+    else {
+        const parsed = [...summary.findings].sort(compareRenderedFindings).map(parseHumanFinding);
+        const diagnostics = buildGroupedDiagnostics(parsed);
+        const fixableCount = diagnostics.filter((diagnostic) => diagnostic.fixable).length;
+        blocks.push({
+            kind: "overview",
+            message: formatGroupedOverviewSentence({
+                diagnosticCount: diagnostics.length,
+                fixableCount,
+            }),
+            counts: summary.counts,
+            notes: [],
+        });
+        if (summary.driftBanner.length > 0) {
+            blocks.push({ kind: "blank" });
+            blocks.push({
+                kind: "driftBanner",
+                title: "The registry will still block publish on these rules:",
+                ruleIds: summary.driftBanner,
+            });
         }
+        buildSectionedDiagnostics({ blocks, diagnostics });
     }
-    return lines;
+    if (summary.findings.length === 0 && summary.driftBanner.length > 0) {
+        blocks.push({ kind: "blank" });
+        blocks.push({
+            kind: "driftBanner",
+            title: "The registry will still block publish on these rules:",
+            ruleIds: summary.driftBanner,
+        });
+    }
+    if (fixSummary !== undefined) {
+        blocks.push({ kind: "blank" });
+        blocks.push({
+            kind: "fixSummary",
+            message: formatFixSummary(fixSummary),
+            summary: fixSummary,
+        });
+    }
+    if (summary.findings.length > 0) {
+        blocks.push({ kind: "blank" });
+        blocks.push({
+            kind: "footer",
+            message: "More output: `axm lint --details` | `axm lint --json`",
+        });
+    }
+    return blocks;
 };
-const formatCountsSentence = (counts) => {
-    const parts = [];
-    parts.push(`${counts.errors} ${pluralize(counts.errors, "error", "errors")}`);
-    parts.push(`${counts.warnings} ${pluralize(counts.warnings, "warning", "warnings")}`);
-    if (counts.infos > 0) {
-        parts.push(`${counts.infos} ${pluralize(counts.infos, "info", "infos")}`);
+const toSummaryLintHumanBlocks = (args) => {
+    const blocks = [];
+    const { summary, fixSummary } = args;
+    if (summary.findings.length === 0) {
+        blocks.push(summary.driftBanner.length === 0
+            ? { kind: "empty", message: "No findings." }
+            : { kind: "empty", message: "No local findings." });
+    }
+    else {
+        const parsed = [...summary.findings].sort(compareRenderedFindings).map(parseHumanFinding);
+        const diagnostics = buildGroupedDiagnostics(parsed).map(makeSummaryDiagnostic);
+        const fixableCount = diagnostics.filter((diagnostic) => diagnostic.fixable).length;
+        blocks.push({
+            kind: "overview",
+            message: formatGroupedOverviewSentence({
+                diagnosticCount: diagnostics.length,
+                fixableCount,
+            }),
+            counts: summary.counts,
+            notes: fixableCount > 0 && fixSummary === undefined
+                ? ["Run `axm lint --fix` to apply available fixes."]
+                : [],
+        });
+        if (summary.driftBanner.length > 0) {
+            blocks.push({ kind: "blank" });
+            blocks.push({
+                kind: "driftBanner",
+                title: "The registry will still block publish on these rules:",
+                ruleIds: summary.driftBanner,
+            });
+        }
+        buildSectionedDiagnostics({ blocks, diagnostics });
+    }
+    if (summary.findings.length === 0 && summary.driftBanner.length > 0) {
+        blocks.push({ kind: "blank" });
+        blocks.push({
+            kind: "driftBanner",
+            title: "The registry will still block publish on these rules:",
+            ruleIds: summary.driftBanner,
+        });
     }
-    return `Summary: ${parts.join(", ")}.`;
+    if (fixSummary !== undefined) {
+        blocks.push({ kind: "blank" });
+        blocks.push({
+            kind: "fixSummary",
+            message: formatFixSummary(fixSummary),
+            summary: fixSummary,
+        });
+    }
+    return blocks;
+};
+export const toLintHumanBlocks = (args) => {
+    switch (args.reporter ?? defaultHumanReporter) {
+        case "full":
+            return toFullLintHumanBlocks(args);
+        case "summary":
+            return toSummaryLintHumanBlocks(args);
+        case "grouped":
+            return toGroupedLintHumanBlocks(args);
+    }
+};
+export const renderFindingsText = (args) => {
+    const lines = [];
+    for (const block of toLintHumanBlocks(args)) {
+        switch (block.kind) {
+            case "overview":
+                lines.push(block.message);
+                for (const note of block.notes) {
+                    lines.push(note);
+                }
+                break;
+            case "driftBanner":
+                lines.push(`DRIFT: ${block.title}`);
+                for (const id of block.ruleIds) {
+                    lines.push(`  - ${id}`);
+                }
+                break;
+            case "section": {
+                const label = block.note !== undefined ? `${block.title} (${block.note})` : block.title;
+                lines.push(label);
+                break;
+            }
+            case "diagnostic": {
+                const location = block.diagnostic.paths.length === 1
+                    ? (block.diagnostic.paths[0] ?? "")
+                    : block.diagnostic.paths.length > 1
+                        ? `(${block.diagnostic.paths.length} locations)`
+                        : "(workspace)";
+                lines.push(`  [${block.diagnostic.severity}] ${location}`);
+                lines.push(`  rule: ${block.diagnostic.ruleId}${block.diagnostic.fixable ? " (auto-fixable)" : ""}`);
+                lines.push(`  ${block.diagnostic.title}`);
+                for (const detail of block.diagnostic.details) {
+                    lines.push(`  - ${detail}`);
+                }
+                for (const help of block.diagnostic.helps) {
+                    lines.push(`  ${help}`);
+                }
+                break;
+            }
+            case "pathGroup":
+                lines.push(block.path);
+                for (const diagnostic of block.diagnostics) {
+                    lines.push(`  [${diagnostic.severity}] ${diagnostic.ruleId}${diagnostic.fixable ? " (auto-fixable)" : ""}: ${diagnostic.title}`);
+                    for (const detail of diagnostic.details) {
+                        lines.push(`    - ${detail}`);
+                    }
+                    for (const help of diagnostic.helps) {
+                        lines.push(`    ${help}`);
+                    }
+                }
+                break;
+            case "blank":
+                lines.push("");
+                break;
+            case "empty":
+                lines.push(block.message);
+                break;
+            case "footer":
+                lines.push(block.message);
+                break;
+            case "fixSummary":
+                lines.push(block.message);
+                for (const warning of block.summary.warnings) {
+                    lines.push(`  warning: ${warning}`);
+                }
+                break;
+        }
+    }
+    return lines;
 };
 const formatFixSummary = (fix) => {
     const appliedLabel = pluralize(fix.applied, "fix", "fixes");
     const warningsLabel = pluralize(fix.warnings.length, "warning", "warnings");
     return `Applied ${fix.applied} ${appliedLabel}; ${fix.warnings.length} ${warningsLabel}, ${fix.failed} failed.`;
 };
-const pluralize = (n, singular, plural) => n === 1 ? singular : plural;
 const toJsonFinding = (entry) => {
     const base = {
         group: entry.group,
@@ -308,7 +1069,6 @@ const toJsonFinding = (entry) => {
         message: entry.finding.message,
         displayRoot: entry.displayRoot,
         path: entry.path,
-        suggestions: [...entry.finding.suggestions],
     };
     if (entry.finding.location === undefined) {
         return base;