@monte3l/groundwork 0.0.0

package/dist/survey/survey-shape.js

@@ -0,0 +1,182 @@
+/**
+ * Collects codebase-shape facts: package manager, monorepo tooling, module
+ * system, pinned versions, source/test layout, and the evidence (not the
+ * verdict) for what kind of project this is. `/customize`'s interview step
+ * does the inferring; this module only records what is literally on disk.
+ */
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { walkBounded } from "./fs-walk.js";
+const FRAMEWORK_DEP_NAMES = [
+    "react",
+    "vue",
+    "svelte",
+    "next",
+    "nuxt",
+    "@angular/core",
+    "express",
+    "fastify",
+    "koa",
+    "@nestjs/core",
+    "hono",
+];
+function readPackageJson(dir) {
+    const path = join(dir, "package.json");
+    if (!existsSync(path)) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function detectPackageManager(dir) {
+    if (existsSync(join(dir, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (existsSync(join(dir, "yarn.lock")))
+        return "yarn";
+    if (existsSync(join(dir, "bun.lockb")))
+        return "bun";
+    if (existsSync(join(dir, "package-lock.json")))
+        return "npm";
+    return "unknown";
+}
+function extractYamlStringListUnder(content, key) {
+    const lines = content.split("\n");
+    const keyIndex = lines.findIndex((line) => line.trim() === `${key}:`);
+    if (keyIndex === -1) {
+        return [];
+    }
+    const items = [];
+    for (const line of lines.slice(keyIndex + 1)) {
+        const match = /^\s*-\s*["']?([^"'#]+)["']?\s*$/.exec(line);
+        if (match?.[1] === undefined) {
+            break;
+        }
+        items.push(match[1].trim());
+    }
+    return items;
+}
+function detectMonorepo(dir, packageJson) {
+    const pnpmWorkspacePath = join(dir, "pnpm-workspace.yaml");
+    if (existsSync(pnpmWorkspacePath)) {
+        const content = readFileSync(pnpmWorkspacePath, "utf8");
+        return {
+            tool: "pnpm-workspaces",
+            globs: extractYamlStringListUnder(content, "packages"),
+        };
+    }
+    if (existsSync(join(dir, "turbo.json"))) {
+        return { tool: "turbo", globs: [] };
+    }
+    if (existsSync(join(dir, "nx.json"))) {
+        return { tool: "nx", globs: [] };
+    }
+    if (existsSync(join(dir, "lerna.json"))) {
+        return { tool: "lerna", globs: [] };
+    }
+    const workspaces = packageJson?.["workspaces"];
+    if (Array.isArray(workspaces)) {
+        return {
+            tool: "npm-workspaces",
+            globs: workspaces.filter((w) => typeof w === "string"),
+        };
+    }
+    return { tool: "none", globs: [] };
+}
+function detectModuleType(packageJson) {
+    const type = packageJson?.["type"];
+    if (type === "module")
+        return "module";
+    if (type === "commonjs")
+        return "commonjs";
+    return "unspecified";
+}
+function detectTypescriptVersion(packageJson) {
+    const deps = packageJson?.["dependencies"];
+    const devDeps = packageJson?.["devDependencies"];
+    const fromDeps = typeof deps === "object" && deps !== null
+        ? deps["typescript"]
+        : undefined;
+    const fromDevDeps = typeof devDeps === "object" && devDeps !== null
+        ? devDeps["typescript"]
+        : undefined;
+    const value = fromDevDeps ?? fromDeps;
+    return typeof value === "string" ? value : undefined;
+}
+function detectNodeVersionPin(dir, packageJson) {
+    for (const [source, filename] of [
+        [".node-version", ".node-version"],
+        [".nvmrc", ".nvmrc"],
+    ]) {
+        const path = join(dir, filename);
+        if (existsSync(path)) {
+            return { source, value: readFileSync(path, "utf8").trim() };
+        }
+    }
+    const engines = packageJson?.["engines"];
+    const nodeEngine = typeof engines === "object" && engines !== null
+        ? engines["node"]
+        : undefined;
+    if (typeof nodeEngine === "string") {
+        return { source: "package.json#engines.node", value: nodeEngine };
+    }
+    return undefined;
+}
+function detectSourceLayout(dir) {
+    if (existsSync(join(dir, "src")))
+        return "src";
+    if (existsSync(join(dir, "lib")))
+        return "lib";
+    const rootEntries = readdirSync(dir).filter((name) => /\.(ts|tsx|js|mjs)$/.test(name));
+    if (rootEntries.length > 0)
+        return "root";
+    return "unknown";
+}
+function hasColocatedTests(dir) {
+    return walkBounded(dir, 2).some((entry) => !entry.isDirectory && /\.(test|spec)\.[jt]sx?$/.test(entry.relPath));
+}
+function detectTestPlacement(dir) {
+    if (existsSync(join(dir, "tests")) || existsSync(join(dir, "test"))) {
+        return "tests-dir";
+    }
+    if (hasColocatedTests(dir)) {
+        return "colocated";
+    }
+    return "unknown";
+}
+function collectKindEvidence(packageJson) {
+    const deps = packageJson?.["dependencies"];
+    const devDeps = packageJson?.["devDependencies"];
+    const allDepNames = new Set([
+        ...(typeof deps === "object" && deps !== null ? Object.keys(deps) : []),
+        ...(typeof devDeps === "object" && devDeps !== null
+            ? Object.keys(devDeps)
+            : []),
+    ]);
+    return {
+        hasExportsMap: packageJson?.["exports"] !== undefined,
+        hasBinField: packageJson?.["bin"] !== undefined,
+        hasMainField: packageJson?.["main"] !== undefined,
+        frameworkDeps: FRAMEWORK_DEP_NAMES.filter((name) => allDepNames.has(name)),
+    };
+}
+/** Surveys codebase shape at `dir`. Offline, read-only, records evidence rather than verdicts. */
+export function surveyShape(dir) {
+    const packageJson = readPackageJson(dir);
+    const monorepo = detectMonorepo(dir, packageJson);
+    return {
+        packageManager: detectPackageManager(dir),
+        monorepoTool: monorepo.tool,
+        workspaceGlobs: monorepo.globs,
+        moduleType: detectModuleType(packageJson),
+        typescriptVersion: detectTypescriptVersion(packageJson),
+        nodeVersionPin: detectNodeVersionPin(dir, packageJson),
+        sourceLayout: detectSourceLayout(dir),
+        testPlacement: detectTestPlacement(dir),
+        kindEvidence: collectKindEvidence(packageJson),
+    };
+}
+//# sourceMappingURL=survey-shape.js.map

package/dist/survey/survey-toolchain.d.ts

@@ -0,0 +1,4 @@
+import type { ToolchainSurvey } from "./types.js";
+/** Surveys toolchain enforcement at `dir`. Appends anything it could not parse to `undetermined`. */
+export declare function surveyToolchain(dir: string, undetermined: string[]): ToolchainSurvey;
+//# sourceMappingURL=survey-toolchain.d.ts.map

package/dist/survey/survey-toolchain.js

@@ -0,0 +1,217 @@
+/**
+ * Collects toolchain-enforcement facts: the tsconfig `extends` chain and its
+ * effective strict-family flags, which eslint/test/formatter/git-hook tool
+ * is in play and its config file, workflow files, and the full `scripts`
+ * block. YAML-shaped config (git hooks, workflows) is indexed and excerpted
+ * here, never parsed -- see `needsReading` on each -- because this package
+ * carries no YAML dependency.
+ */
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { STRICT_FLAGS } from "../toolchain/rules.js";
+import { loadTsconfigChain } from "../toolchain/tsconfig-chain.js";
+/** Every flag the toolchain grader judges, so `effectiveFlags` and the grade cannot disagree. */
+const STRICT_FLAG_NAMES = [...STRICT_FLAGS, "allowUnreachableCode"];
+const ESLINT_PLUGIN_PATTERN = /["']((?:eslint-plugin-|@typescript-eslint\/)[a-z0-9-]+)["']/gi;
+function readPackageJson(dir) {
+    const path = join(dir, "package.json");
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function findTsconfigPath(dir) {
+    for (const name of ["tsconfig.json"]) {
+        const path = join(dir, name);
+        if (existsSync(path))
+            return path;
+    }
+    return undefined;
+}
+/**
+ * Follows a tsconfig's `extends` chain with the resolver the toolchain grader
+ * shares, so the survey and the grade cannot disagree about a project's
+ * effective flags. `files` are absolute and child-first. A file that fails to
+ * parse, or a relative `extends` that points at nothing, is a parse failure; a
+ * bare package specifier that is not installed is only a note -- the flags it
+ * would contribute are simply absent.
+ */
+function surveyTsconfig(dir, undetermined) {
+    const entryPath = findTsconfigPath(dir);
+    if (entryPath === undefined) {
+        return { files: [], effectiveFlags: {}, parsed: false };
+    }
+    const chain = loadTsconfigChain(dir, "tsconfig.json");
+    let parsed = chain.parsed;
+    for (const file of chain.files) {
+        if (file.error !== undefined) {
+            undetermined.push(`could not parse ${file.abs}: ${file.error}`);
+        }
+    }
+    for (const link of chain.links) {
+        if (link.resolved)
+            continue;
+        if (link.kind === "relative") {
+            parsed = false;
+            undetermined.push(`could not parse ${link.attempted}: ${link.attempted} does not exist`);
+        }
+        else {
+            undetermined.push(`tsconfig extends "${link.specifier}" from ${link.from} could not be resolved (is it installed?) -- the flags it sets are not in the effective set`);
+        }
+    }
+    const effectiveFlags = {};
+    for (const flag of STRICT_FLAG_NAMES) {
+        const value = chain.options[flag];
+        if (value !== undefined)
+            effectiveFlags[flag] = value;
+    }
+    return { files: chain.files.map((file) => file.abs), effectiveFlags, parsed };
+}
+function surveyEslint(dir) {
+    const flatCandidates = [
+        "eslint.config.js",
+        "eslint.config.mjs",
+        "eslint.config.ts",
+    ];
+    const legacyCandidates = [
+        ".eslintrc.js",
+        ".eslintrc.cjs",
+        ".eslintrc.json",
+        ".eslintrc",
+    ];
+    for (const name of flatCandidates) {
+        const path = join(dir, name);
+        if (existsSync(path)) {
+            const content = readFileSync(path, "utf8");
+            return {
+                configFile: name,
+                flat: true,
+                referencedPlugins: extractPluginNames(content),
+            };
+        }
+    }
+    for (const name of legacyCandidates) {
+        const path = join(dir, name);
+        if (existsSync(path)) {
+            const content = readFileSync(path, "utf8");
+            return {
+                configFile: name,
+                flat: false,
+                referencedPlugins: extractPluginNames(content),
+            };
+        }
+    }
+    return { configFile: undefined, flat: false, referencedPlugins: [] };
+}
+function extractPluginNames(content) {
+    const names = new Set();
+    for (const match of content.matchAll(ESLINT_PLUGIN_PATTERN)) {
+        const name = match[1];
+        if (name !== undefined)
+            names.add(name);
+    }
+    return [...names];
+}
+function surveyTestRunner(dir, scripts) {
+    const candidates = [
+        ["vitest.config.ts", "vitest"],
+        ["vitest.config.js", "vitest"],
+        ["jest.config.js", "jest"],
+        ["jest.config.cjs", "jest"],
+        ["jest.config.ts", "jest"],
+        ["jest.config.json", "jest"],
+        [".mocharc.json", "mocha"],
+        [".mocharc.js", "mocha"],
+    ];
+    for (const [name, tool] of candidates) {
+        if (existsSync(join(dir, name))) {
+            return { tool, configFile: name };
+        }
+    }
+    const testScript = scripts["test"] ?? "";
+    if (/node --test/.test(testScript)) {
+        return { tool: "node-test", configFile: undefined };
+    }
+    return { tool: "unknown", configFile: undefined };
+}
+function surveyFormatter(dir) {
+    const prettierCandidates = [
+        ".prettierrc.json",
+        ".prettierrc.js",
+        ".prettierrc",
+        ".prettierrc.yaml",
+        ".prettierrc.yml",
+    ];
+    for (const name of prettierCandidates) {
+        if (existsSync(join(dir, name))) {
+            return { tool: "prettier", configFile: name };
+        }
+    }
+    if (existsSync(join(dir, "biome.json"))) {
+        return { tool: "biome", configFile: "biome.json" };
+    }
+    return { tool: "unknown", configFile: undefined };
+}
+function surveyGitHooks(dir, undetermined) {
+    if (existsSync(join(dir, "lefthook.yml")) ||
+        existsSync(join(dir, "lefthook.yaml"))) {
+        const configFile = existsSync(join(dir, "lefthook.yml"))
+            ? "lefthook.yml"
+            : "lefthook.yaml";
+        undetermined.push(`${configFile} found -- its stage commands need reading, not parsing`);
+        return { manager: "lefthook", configFile, needsReading: true };
+    }
+    if (existsSync(join(dir, ".husky"))) {
+        undetermined.push(".husky/ found -- its hook scripts need reading, not parsing");
+        return { manager: "husky", configFile: ".husky", needsReading: true };
+    }
+    if (existsSync(join(dir, "simple-git-hooks.json"))) {
+        return {
+            manager: "simple-git-hooks",
+            configFile: "simple-git-hooks.json",
+            needsReading: true,
+        };
+    }
+    return { manager: "none", configFile: undefined, needsReading: false };
+}
+function surveyWorkflows(dir, undetermined) {
+    const workflowsDir = join(dir, ".github", "workflows");
+    if (!existsSync(workflowsDir)) {
+        return { files: [], needsReading: false };
+    }
+    const files = readdirSync(workflowsDir).filter((name) => /\.ya?ml$/.test(name));
+    if (files.length > 0) {
+        undetermined.push(`${files.length} workflow file(s) under .github/workflows -- their job steps need reading, not parsing`);
+    }
+    return { files, needsReading: files.length > 0 };
+}
+function surveyScripts(packageJson) {
+    const scripts = packageJson?.["scripts"];
+    if (typeof scripts !== "object" || scripts === null)
+        return {};
+    const result = {};
+    for (const [key, value] of Object.entries(scripts)) {
+        if (typeof value === "string")
+            result[key] = value;
+    }
+    return result;
+}
+/** Surveys toolchain enforcement at `dir`. Appends anything it could not parse to `undetermined`. */
+export function surveyToolchain(dir, undetermined) {
+    const packageJson = readPackageJson(dir);
+    const scripts = surveyScripts(packageJson);
+    return {
+        tsconfig: surveyTsconfig(dir, undetermined),
+        eslint: surveyEslint(dir),
+        testRunner: surveyTestRunner(dir, scripts),
+        formatter: surveyFormatter(dir),
+        gitHooks: surveyGitHooks(dir, undetermined),
+        workflows: surveyWorkflows(dir, undetermined),
+        scripts,
+    };
+}
+//# sourceMappingURL=survey-toolchain.js.map

package/dist/survey/survey.d.ts

@@ -0,0 +1,5 @@
+import type { ProjectSurvey } from "./types.js";
+export type { ProjectSurvey } from "./types.js";
+/** Surveys `dir` end to end: shape, toolchain, harness, and docs. Offline, read-only. */
+export declare function surveyProject(dir: string): ProjectSurvey;
+//# sourceMappingURL=survey.d.ts.map

package/dist/survey/survey.js

@@ -0,0 +1,21 @@
+/**
+ * The survey aggregate: runs all four collectors against a target directory
+ * and returns the combined `ProjectSurvey`. See `types.ts` for the shape
+ * and each `survey-*.ts` module's header for what it collects and why.
+ */
+import { surveyDocs } from "./survey-docs.js";
+import { surveyHarness } from "./survey-harness.js";
+import { surveyShape } from "./survey-shape.js";
+import { surveyToolchain } from "./survey-toolchain.js";
+/** Surveys `dir` end to end: shape, toolchain, harness, and docs. Offline, read-only. */
+export function surveyProject(dir) {
+    const undetermined = [];
+    return {
+        shape: surveyShape(dir),
+        toolchain: surveyToolchain(dir, undetermined),
+        harness: surveyHarness(dir),
+        docs: surveyDocs(dir),
+        undetermined,
+    };
+}
+//# sourceMappingURL=survey.js.map

package/dist/survey/types.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Shared type definitions for the four survey collectors and their
+ * aggregate. Kept in one file since every collector's output composes into
+ * `ProjectSurvey`, and `conflicts.ts`/`report.ts` need to name these shapes
+ * without importing a collector module just for its types.
+ */
+export type PackageManager = "npm" | "pnpm" | "yarn" | "bun" | "unknown";
+export type MonorepoTool = "pnpm-workspaces" | "turbo" | "nx" | "lerna" | "npm-workspaces" | "none";
+export type ModuleType = "module" | "commonjs" | "unspecified";
+export type SourceLayout = "src" | "lib" | "root" | "unknown";
+export type TestPlacement = "tests-dir" | "colocated" | "unknown";
+export interface NodeVersionPin {
+    source: string;
+    value: string;
+}
+export interface KindEvidence {
+    hasExportsMap: boolean;
+    hasBinField: boolean;
+    hasMainField: boolean;
+    frameworkDeps: string[];
+}
+export interface ShapeSurvey {
+    packageManager: PackageManager;
+    monorepoTool: MonorepoTool;
+    workspaceGlobs: string[];
+    moduleType: ModuleType;
+    typescriptVersion: string | undefined;
+    nodeVersionPin: NodeVersionPin | undefined;
+    sourceLayout: SourceLayout;
+    testPlacement: TestPlacement;
+    kindEvidence: KindEvidence;
+}
+export interface TsconfigSurvey {
+    /** The extends chain, entry file first (child before parent), as absolute paths. */
+    files: string[];
+    /** The effective value of each strict-family flag this baseline cares about, after following `extends`. */
+    effectiveFlags: Record<string, unknown>;
+    /** False if any file in the chain failed to parse -- see `undetermined` on the parent survey. */
+    parsed: boolean;
+}
+export interface EslintSurvey {
+    configFile: string | undefined;
+    flat: boolean;
+    referencedPlugins: string[];
+}
+type TestRunnerTool = "vitest" | "jest" | "mocha" | "node-test" | "unknown";
+export interface TestRunnerSurvey {
+    tool: TestRunnerTool;
+    configFile: string | undefined;
+}
+type FormatterTool = "prettier" | "biome" | "unknown";
+export interface FormatterSurvey {
+    tool: FormatterTool;
+    configFile: string | undefined;
+}
+type GitHookManager = "lefthook" | "husky" | "simple-git-hooks" | "none";
+export interface GitHooksSurvey {
+    manager: GitHookManager;
+    configFile: string | undefined;
+    /** True whenever the manager's config is YAML/shell-script shaped -- this module indexes it, never parses it. */
+    needsReading: boolean;
+}
+export interface WorkflowsSurvey {
+    files: string[];
+    needsReading: boolean;
+}
+export interface ToolchainSurvey {
+    tsconfig: TsconfigSurvey;
+    eslint: EslintSurvey;
+    testRunner: TestRunnerSurvey;
+    formatter: FormatterSurvey;
+    gitHooks: GitHooksSurvey;
+    workflows: WorkflowsSurvey;
+    scripts: Record<string, string>;
+}
+export interface HarnessAgent {
+    name: string;
+    model: string | undefined;
+}
+export interface HarnessSkill {
+    name: string;
+    description: string | undefined;
+}
+export interface HarnessRule {
+    name: string;
+    paths: string | undefined;
+}
+export interface HarnessSurvey {
+    present: boolean;
+    settingsFile: string | undefined;
+    agents: HarnessAgent[];
+    skills: HarnessSkill[];
+    hooks: string[];
+    rules: HarnessRule[];
+    commands: string[];
+    hasSettingsLocal: boolean;
+    hasClaudeMd: boolean;
+    claudeMdHeadings: string[];
+}
+export interface DocFile {
+    path: string;
+    sizeBytes: number;
+    headings: string[];
+}
+export interface DocsSurvey {
+    files: DocFile[];
+}
+export interface ProjectSurvey {
+    shape: ShapeSurvey;
+    toolchain: ToolchainSurvey;
+    harness: HarnessSurvey;
+    docs: DocsSurvey;
+    /** Things the survey attempted and could not parse or classify -- never silently dropped. */
+    undetermined: string[];
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/survey/types.js

@@ -0,0 +1,8 @@
+/**
+ * Shared type definitions for the four survey collectors and their
+ * aggregate. Kept in one file since every collector's output composes into
+ * `ProjectSurvey`, and `conflicts.ts`/`report.ts` need to name these shapes
+ * without importing a collector module just for its types.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/tokens.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Token substitution: a fixed string-replace table, not a template engine --
+ * the CLI has zero runtime dependencies it can avoid, and a `__TOKEN__`
+ * literal replace is all `templates/core` needs.
+ */
+export type TokenTable = Record<string, string>;
+/**
+ * Replaces every `__KEY__` occurrence in `content` with `tokens[KEY]`, for
+ * every key in `tokens`. Unmatched `__KEY__`-shaped text that isn't a known
+ * token is left untouched.
+ */
+export declare function applyTokens(content: string, tokens: TokenTable): string;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/tokens.js

@@ -0,0 +1,13 @@
+/**
+ * Replaces every `__KEY__` occurrence in `content` with `tokens[KEY]`, for
+ * every key in `tokens`. Unmatched `__KEY__`-shaped text that isn't a known
+ * token is left untouched.
+ */
+export function applyTokens(content, tokens) {
+    let result = content;
+    for (const [key, value] of Object.entries(tokens)) {
+        result = result.split(`__${key}__`).join(value);
+    }
+    return result;
+}
+//# sourceMappingURL=tokens.js.map

package/dist/toolchain/conformance.d.ts

@@ -0,0 +1,20 @@
+/**
+ * How far a project's toolchain files have drifted from `templates/core`'s --
+ * the second number the grader reports, kept separate from rubric quality
+ * because `/customize` deliberately rewrites the baseline. "Divergent" is
+ * therefore information, never a defect. Derived from the conflict plan
+ * `planConflicts` already computed, so no second diff is ever run.
+ */
+import type { FileConflict } from "../conflicts.js";
+export interface ToolchainConformance {
+    identical: number;
+    divergent: number;
+    absent: number;
+    /** Baseline toolchain files the project has edited. */
+    divergentFiles: string[];
+    /** Baseline toolchain files the project lacks. */
+    absentFiles: string[];
+}
+/** Counts the toolchain-scoped subset of a baseline conflict plan. */
+export declare function summarizeToolchainConformance(conflicts: FileConflict[]): ToolchainConformance;
+//# sourceMappingURL=conformance.d.ts.map

package/dist/toolchain/conformance.js

@@ -0,0 +1,30 @@
+const TOOLCHAIN_FILES = new Set([
+    "package.json",
+    ".node-version",
+    ".prettierrc.json",
+    "knip.json",
+    "lefthook.yml",
+    "vitest.config.ts",
+]);
+function isToolchainPath(relPath) {
+    return (TOOLCHAIN_FILES.has(relPath) ||
+        /^tsconfig(\..+)?\.json$/.test(relPath) ||
+        /^eslint\.config\./.test(relPath) ||
+        relPath.startsWith("bin/") ||
+        relPath.startsWith(".github/workflows/"));
+}
+/** Counts the toolchain-scoped subset of a baseline conflict plan. */
+export function summarizeToolchainConformance(conflicts) {
+    const scoped = conflicts.filter((conflict) => isToolchainPath(conflict.relPath));
+    const files = (status) => scoped
+        .filter((conflict) => conflict.status === status)
+        .map((conflict) => conflict.relPath);
+    return {
+        identical: files("identical").length,
+        divergent: files("divergent").length,
+        absent: files("absent").length,
+        divergentFiles: files("divergent"),
+        absentFiles: files("absent"),
+    };
+}
+//# sourceMappingURL=conformance.js.map

package/dist/toolchain/grade.d.ts

@@ -0,0 +1,4 @@
+import type { ToolchainGrade } from "./types.js";
+/** Runs every rule over the project rooted at `rootDir` and tallies the result. */
+export declare function gradeToolchain(rootDir: string): ToolchainGrade;
+//# sourceMappingURL=grade.d.ts.map