@viberails/config 0.3.3 → 0.5.0

package/dist/index.js

@@ -1,13 +1,17 @@
+// src/generate-config.ts
+import * as path from "path";
+
 // src/defaults.ts
 var DEFAULT_RULES = {
   maxFileLines: 300,
   maxTestFileLines: 0,
-  maxFunctionLines: 50,
-  requireTests: true,
+  testCoverage: 80,
   enforceNaming: true,
-  enforceBoundaries: false
+  enforceBoundaries: false,
+  enforceMissingTests: true
 };
-var DEFAULT_IGNORE = [
+var DEFAULT_IGNORE = [];
+var BUILTIN_IGNORE = [
   "**/*.d.ts",
   "**/*.min.js",
   "**/*.min.cjs",
@@ -29,70 +33,68 @@ var DEFAULT_IGNORE = [
   "**/__generated__/**"
 ];
 
-// src/generate-config.ts
-import * as path from "path";
-
-// src/generate-overrides.ts
-function conventionsDiffer(pkgConventions, globalConventions) {
-  const overrides = {};
-  let hasDiff = false;
+// src/generate-packages.ts
+function buildPackageStack(pkg) {
+  const config = {
+    language: formatStackItem(pkg.stack.language),
+    packageManager: formatStackItem(pkg.stack.packageManager)
+  };
+  if (pkg.stack.framework) config.framework = formatStackItem(pkg.stack.framework);
+  if (pkg.stack.styling) config.styling = formatStackItem(pkg.stack.styling);
+  if (pkg.stack.backend) config.backend = formatStackItem(pkg.stack.backend);
+  if (pkg.stack.orm) config.orm = formatStackItem(pkg.stack.orm);
+  if (pkg.stack.linter) config.linter = formatStackItem(pkg.stack.linter);
+  if (pkg.stack.formatter) config.formatter = formatStackItem(pkg.stack.formatter);
+  if (pkg.stack.testRunner) config.testRunner = formatStackItem(pkg.stack.testRunner);
+  return config;
+}
+function buildPackageConventions(pkgConventions) {
+  const config = {};
   for (const key of CONVENTION_KEYS) {
     const detected = pkgConventions[key];
-    if (!detected) continue;
-    const mapped = mapConvention(detected);
-    if (mapped === void 0) continue;
-    const globalValue = globalConventions[key];
-    const globalStr = typeof globalValue === "string" ? globalValue : globalValue?.value;
-    if (detected.value !== globalStr) {
-      overrides[key] = mapped;
-      hasDiff = true;
+    if (detected && detected.confidence !== "low") {
+      config[key] = detected.value;
     }
   }
-  return hasDiff ? overrides : void 0;
+  return config;
 }
-function generatePackageOverrides(scanResult, globalConfig) {
+function generatePackages(scanResult) {
   if (!scanResult.packages || scanResult.packages.length <= 1) return void 0;
-  const overrides = [];
+  const packages = [];
   for (const pkg of scanResult.packages) {
-    const override = {
+    const pkgScanResult = {
+      root: pkg.root,
+      stack: pkg.stack,
+      structure: pkg.structure,
+      conventions: pkg.conventions,
+      statistics: pkg.statistics
+    };
+    const packageConfig = {
       name: pkg.name,
-      path: pkg.relativePath
+      path: pkg.relativePath,
+      stack: buildPackageStack(pkg),
+      structure: mapStructure(pkgScanResult),
+      conventions: buildPackageConventions(pkg.conventions)
     };
-    let hasDiff = false;
-    const stackOverride = {};
-    let hasStackDiff = false;
-    const optionalStackFields = [
-      "framework",
-      "styling",
-      "backend",
-      "orm",
-      "linter",
-      "formatter",
-      "testRunner"
-    ];
-    for (const field of optionalStackFields) {
-      const pkgItem = pkg.stack[field];
-      if (!pkgItem) continue;
-      const pkgValue = formatStackItem(pkgItem);
-      if (pkgValue !== globalConfig.stack[field]) {
-        stackOverride[field] = pkgValue;
-        hasStackDiff = true;
-      }
-    }
-    if (hasStackDiff) {
-      override.stack = stackOverride;
-      hasDiff = true;
-    }
-    const conventionOverrides = conventionsDiffer(pkg.conventions, globalConfig.conventions);
-    if (conventionOverrides) {
-      override.conventions = conventionOverrides;
-      hasDiff = true;
-    }
-    if (hasDiff) {
-      overrides.push(override);
+    if (pkg.typesOnly) {
+      packageConfig.rules = { testCoverage: 0 };
     }
+    packages.push(packageConfig);
+  }
+  return packages.length > 0 ? packages : void 0;
+}
+
+// src/infer-coverage-command.ts
+function inferCoverageCommand(testRunner) {
+  if (!testRunner) return void 0;
+  const runner = testRunner.split("@")[0];
+  if (runner === "vitest") {
+    return "npx vitest run --coverage --coverage.reporter=json-summary";
+  }
+  if (runner === "jest") {
+    return "npx jest --coverage --coverageReporters=json-summary";
   }
-  return overrides.length > 0 ? overrides : void 0;
+  return void 0;
 }
 
 // src/generate-config.ts
@@ -139,16 +141,6 @@ function mapStructure(scanResult) {
   }
   return config;
 }
-function mapConvention(convention) {
-  if (convention.confidence === "low") {
-    return void 0;
-  }
-  return {
-    value: convention.value,
-    _confidence: convention.confidence,
-    _consistency: convention.consistency
-  };
-}
 var CONVENTION_KEYS = [
   "fileNaming",
   "componentNaming",
@@ -156,67 +148,308 @@ var CONVENTION_KEYS = [
   "importAlias"
 ];
 function mapConventions(scanResult) {
-  const config = {};
+  const conventions = {};
+  const meta = {};
   for (const key of CONVENTION_KEYS) {
     const detected = scanResult.conventions[key];
-    if (detected) {
-      const value = mapConvention(detected);
-      if (value !== void 0) {
-        config[key] = value;
-      }
+    if (detected && detected.confidence !== "low") {
+      conventions[key] = detected.value;
+      meta[key] = {
+        value: detected.value,
+        confidence: detected.confidence,
+        consistency: detected.consistency
+      };
     }
   }
-  return config;
+  return { conventions, meta };
+}
+function buildConventionMeta(conventions) {
+  const meta = {};
+  for (const key of CONVENTION_KEYS) {
+    const detected = conventions[key];
+    if (detected && detected.confidence !== "low") {
+      meta[key] = {
+        value: detected.value,
+        confidence: detected.confidence,
+        consistency: detected.consistency
+      };
+    }
+  }
+  return meta;
 }
 function generateConfig(scanResult) {
+  const projectName = path.basename(scanResult.root);
+  const { conventions, meta } = mapConventions(scanResult);
+  const rootPackage = {
+    name: projectName,
+    path: ".",
+    stack: mapStack(scanResult),
+    structure: mapStructure(scanResult),
+    conventions
+  };
+  const _meta = {
+    lastSync: (/* @__PURE__ */ new Date()).toISOString(),
+    packages: {
+      ".": { conventions: Object.keys(meta).length > 0 ? meta : void 0 }
+    }
+  };
   const config = {
     $schema: "https://viberails.sh/schema/v1.json",
     version: 1,
-    name: path.basename(scanResult.root),
-    enforcement: "warn",
-    stack: mapStack(scanResult),
-    structure: mapStructure(scanResult),
-    conventions: mapConventions(scanResult),
+    name: projectName,
     rules: { ...DEFAULT_RULES },
-    ignore: [...DEFAULT_IGNORE]
+    ignore: [...DEFAULT_IGNORE],
+    packages: [rootPackage],
+    _meta
   };
+  const testRunner = scanResult.stack.testRunner;
+  const coverageCommand = inferCoverageCommand(
+    testRunner ? formatStackItem(testRunner) : void 0
+  );
+  if (coverageCommand) {
+    config.defaults = { coverage: { command: coverageCommand } };
+  }
   if (scanResult.workspace) {
-    config.workspace = {
-      packages: scanResult.workspace.packages.map((p) => p.relativePath),
-      isMonorepo: true
-    };
+    const packages = generatePackages(scanResult);
+    if (packages) {
+      config.packages = packages;
+      const pkgMeta = {};
+      for (const pkg of scanResult.packages) {
+        const convMeta = buildConventionMeta(pkg.conventions);
+        if (Object.keys(convMeta).length > 0) {
+          pkgMeta[pkg.relativePath] = { conventions: convMeta };
+        }
+      }
+      if (Object.keys(pkgMeta).length > 0) {
+        _meta.packages = pkgMeta;
+      }
+    }
     config.boundaries = { deny: {} };
   }
-  const packageOverrides = generatePackageOverrides(scanResult, config);
-  if (packageOverrides) {
-    config.packages = packageOverrides;
-  }
   return config;
 }
 
+// src/compact-config.ts
+var STACK_KEYS = [
+  "language",
+  "packageManager",
+  "framework",
+  "styling",
+  "backend",
+  "orm",
+  "linter",
+  "formatter",
+  "testRunner"
+];
+var STRUCTURE_KEYS = [
+  "srcDir",
+  "pages",
+  "components",
+  "hooks",
+  "utils",
+  "types",
+  "tests",
+  "testPattern"
+];
+function compactConfig(config) {
+  const pkgs = config.packages ?? [];
+  const defaults = {};
+  const packages = pkgs.map((p) => {
+    const copy = { ...p };
+    if (config.defaults?.coverage) {
+      copy.coverage = { ...config.defaults.coverage, ...copy.coverage ?? {} };
+    }
+    if (config.defaults?.stack) {
+      copy.stack = { ...config.defaults.stack, ...copy.stack ?? {} };
+    }
+    if (config.defaults?.structure) {
+      copy.structure = { ...config.defaults.structure, ...copy.structure ?? {} };
+    }
+    if (config.defaults?.conventions) {
+      copy.conventions = { ...config.defaults.conventions, ...copy.conventions ?? {} };
+    }
+    return copy;
+  });
+  if (packages.length <= 1) {
+    for (const pkg of packages) {
+      if (pkg.stack && Object.keys(pkg.stack).length === 0) delete pkg.stack;
+      if (pkg.structure && Object.keys(pkg.structure).length === 0) delete pkg.structure;
+      if (pkg.conventions && Object.keys(pkg.conventions).length === 0) delete pkg.conventions;
+      if (pkg.coverage && Object.keys(pkg.coverage).length === 0) delete pkg.coverage;
+    }
+    const { defaults: _d, ...rest } = config;
+    return { ...rest, packages };
+  }
+  const sharedStack = {};
+  for (const key of STACK_KEYS) {
+    const values = packages.map((p) => (p.stack ?? {})[key]);
+    if (values[0] !== void 0 && values.every((v) => v === values[0])) {
+      sharedStack[key] = values[0];
+    }
+  }
+  if (Object.keys(sharedStack).length > 0) {
+    defaults.stack = sharedStack;
+    for (const pkg of packages) {
+      const pkgStack = pkg.stack ?? {};
+      const sparse = {};
+      for (const key of STACK_KEYS) {
+        if (pkgStack[key] !== void 0 && pkgStack[key] !== sharedStack[key]) {
+          sparse[key] = pkgStack[key];
+        }
+      }
+      pkg.stack = sparse;
+    }
+  }
+  const sharedStructure = {};
+  for (const key of STRUCTURE_KEYS) {
+    const values = packages.map((p) => p.structure?.[key]);
+    const first = values[0];
+    if (first !== void 0 && values.every((v) => JSON.stringify(v) === JSON.stringify(first))) {
+      sharedStructure[key] = first;
+    }
+  }
+  if (Object.keys(sharedStructure).length > 0) {
+    defaults.structure = sharedStructure;
+    for (const pkg of packages) {
+      const pkgStructure = pkg.structure ?? {};
+      const sparse = {};
+      for (const key of STRUCTURE_KEYS) {
+        const val = pkgStructure[key];
+        if (val !== void 0 && JSON.stringify(val) !== JSON.stringify(sharedStructure[key])) {
+          sparse[key] = val;
+        }
+      }
+      pkg.structure = sparse;
+    }
+  }
+  const sharedConventions = {};
+  for (const key of CONVENTION_KEYS) {
+    const values = packages.map((p) => p.conventions?.[key]);
+    if (values[0] !== void 0 && values.every((v) => v === values[0])) {
+      sharedConventions[key] = values[0];
+    }
+  }
+  const sharedCoverage = {};
+  const coverageKeys = ["command", "summaryPath"];
+  for (const key of coverageKeys) {
+    const values = packages.map((p) => p.coverage?.[key]);
+    if (values[0] !== void 0 && values.every((v) => v === values[0])) {
+      sharedCoverage[key] = values[0];
+    }
+  }
+  if (Object.keys(sharedCoverage).length > 0) {
+    defaults.coverage = sharedCoverage;
+    for (const pkg of packages) {
+      const pkgCoverage = pkg.coverage ?? {};
+      const sparse = {};
+      for (const key of coverageKeys) {
+        if (pkgCoverage[key] !== void 0 && pkgCoverage[key] !== sharedCoverage[key]) {
+          sparse[key] = pkgCoverage[key];
+        }
+      }
+      pkg.coverage = sparse;
+    }
+  }
+  if (Object.keys(sharedConventions).length > 0) {
+    defaults.conventions = sharedConventions;
+    for (const pkg of packages) {
+      const pkgConventions = pkg.conventions ?? {};
+      const sparse = {};
+      for (const key of CONVENTION_KEYS) {
+        if (pkgConventions[key] !== void 0 && pkgConventions[key] !== sharedConventions[key]) {
+          sparse[key] = pkgConventions[key];
+        }
+      }
+      pkg.conventions = sparse;
+    }
+  }
+  for (const pkg of packages) {
+    if (pkg.stack && Object.keys(pkg.stack).length === 0) {
+      delete pkg.stack;
+    }
+    if (pkg.structure && Object.keys(pkg.structure).length === 0) {
+      delete pkg.structure;
+    }
+    if (pkg.conventions && Object.keys(pkg.conventions).length === 0) {
+      delete pkg.conventions;
+    }
+    if (pkg.coverage && Object.keys(pkg.coverage).length === 0) {
+      delete pkg.coverage;
+    }
+  }
+  const result = {
+    ...config.$schema ? { $schema: config.$schema } : {},
+    version: config.version,
+    name: config.name,
+    rules: config.rules,
+    ...config.ignore && config.ignore.length > 0 ? { ignore: config.ignore } : {},
+    ...config.boundaries ? { boundaries: config.boundaries } : {},
+    ...Object.keys(defaults).length > 0 ? { defaults } : {},
+    packages,
+    ...config._meta ? { _meta: config._meta } : {}
+  };
+  return result;
+}
+function expandDefaults(config) {
+  const defaults = config.defaults;
+  const packages = config.packages.map((pkg) => {
+    const expanded = { ...pkg };
+    expanded.stack = { ...defaults?.stack ?? {}, ...pkg.stack ?? {} };
+    expanded.structure = { ...defaults?.structure ?? {}, ...pkg.structure ?? {} };
+    expanded.conventions = { ...defaults?.conventions ?? {}, ...pkg.conventions ?? {} };
+    const mergedCoverage = { ...defaults?.coverage ?? {}, ...pkg.coverage ?? {} };
+    if (Object.keys(mergedCoverage).length > 0) {
+      expanded.coverage = mergedCoverage;
+    } else {
+      delete expanded.coverage;
+    }
+    return expanded;
+  });
+  const ignore = config.ignore ?? [];
+  const { defaults: _d, ...rest } = config;
+  return { ...rest, ignore, packages };
+}
+
 // src/load-config.ts
 import * as fs from "fs/promises";
 function validateConfig(parsed, configPath) {
   const errors = [];
-  const required = ["version", "name", "stack", "rules"];
+  const required = ["version", "name", "packages", "rules"];
   const missing = required.filter((field) => parsed[field] === void 0);
   if (missing.length > 0) {
     throw new Error(
       `Invalid viberails config at ${configPath}: missing required field(s): ${missing.join(", ")}`
     );
   }
-  if (typeof parsed.version !== "number") errors.push('"version" must be a number');
-  if (typeof parsed.name !== "string") errors.push('"name" must be a string');
-  if (parsed.enforcement !== void 0 && parsed.enforcement !== "warn" && parsed.enforcement !== "enforce") {
-    errors.push('"enforcement" must be "warn" or "enforce"');
+  if (typeof parsed.version !== "number") {
+    errors.push('"version" must be a number');
+  } else if (parsed.version !== 1) {
+    errors.push('"version" must be 1');
   }
-  if (typeof parsed.stack !== "object" || parsed.stack === null) {
-    errors.push('"stack" must be an object');
+  if (typeof parsed.name !== "string") errors.push('"name" must be a string');
+  if (!Array.isArray(parsed.packages)) {
+    errors.push('"packages" must be an array');
+  } else if (parsed.packages.length === 0) {
+    errors.push('"packages" must contain at least one package');
   } else {
-    const stack = parsed.stack;
-    if (typeof stack.language !== "string") errors.push('"stack.language" must be a string');
-    if (typeof stack.packageManager !== "string")
-      errors.push('"stack.packageManager" must be a string');
+    for (let i = 0; i < parsed.packages.length; i++) {
+      const pkg = parsed.packages[i];
+      if (typeof pkg.name !== "string") errors.push(`"packages[${i}].name" must be a string`);
+      if (typeof pkg.path !== "string") errors.push(`"packages[${i}].path" must be a string`);
+      if (pkg.coverage !== void 0) {
+        if (typeof pkg.coverage !== "object" || pkg.coverage === null) {
+          errors.push(`"packages[${i}].coverage" must be an object`);
+        } else {
+          const coverage = pkg.coverage;
+          if (coverage.command !== void 0 && typeof coverage.command !== "string") {
+            errors.push(`"packages[${i}].coverage.command" must be a string`);
+          }
+          if (coverage.summaryPath !== void 0 && typeof coverage.summaryPath !== "string") {
+            errors.push(`"packages[${i}].coverage.summaryPath" must be a string`);
+          }
+        }
+      }
+    }
   }
   if (typeof parsed.rules !== "object" || parsed.rules === null) {
     errors.push('"rules" must be an object');
@@ -224,10 +457,18 @@ function validateConfig(parsed, configPath) {
     const rules = parsed.rules;
     if (typeof rules.maxFileLines !== "number")
       errors.push('"rules.maxFileLines" must be a number');
-    if (typeof rules.maxFunctionLines !== "number")
-      errors.push('"rules.maxFunctionLines" must be a number');
-    if (typeof rules.requireTests !== "boolean")
-      errors.push('"rules.requireTests" must be a boolean');
+    else if (rules.maxFileLines < 0) errors.push('"rules.maxFileLines" must be >= 0');
+    if (rules.maxTestFileLines !== void 0) {
+      if (typeof rules.maxTestFileLines !== "number") {
+        errors.push('"rules.maxTestFileLines" must be a number');
+      } else if (rules.maxTestFileLines < 0) {
+        errors.push('"rules.maxTestFileLines" must be >= 0');
+      }
+    }
+    if (typeof rules.testCoverage !== "number")
+      errors.push('"rules.testCoverage" must be a number');
+    else if (rules.testCoverage < 0 || rules.testCoverage > 100)
+      errors.push('"rules.testCoverage" must be between 0 and 100');
     if (typeof rules.enforceNaming !== "boolean")
       errors.push('"rules.enforceNaming" must be a boolean');
     if (typeof rules.enforceBoundaries !== "boolean")
@@ -236,6 +477,26 @@ function validateConfig(parsed, configPath) {
   if (parsed.ignore !== void 0 && !Array.isArray(parsed.ignore)) {
     errors.push('"ignore" must be an array');
   }
+  if (parsed.defaults !== void 0) {
+    if (typeof parsed.defaults !== "object" || parsed.defaults === null) {
+      errors.push('"defaults" must be an object');
+    } else {
+      const defaults = parsed.defaults;
+      if (defaults.coverage !== void 0) {
+        if (typeof defaults.coverage !== "object" || defaults.coverage === null) {
+          errors.push('"defaults.coverage" must be an object');
+        } else {
+          const coverage = defaults.coverage;
+          if (coverage.command !== void 0 && typeof coverage.command !== "string") {
+            errors.push('"defaults.coverage.command" must be a string');
+          }
+          if (coverage.summaryPath !== void 0 && typeof coverage.summaryPath !== "string") {
+            errors.push('"defaults.coverage.summaryPath" must be a string');
+          }
+        }
+      }
+    }
+  }
   if (errors.length > 0) {
     throw new Error(`Invalid viberails config at ${configPath}: ${errors.join("; ")}`);
   }
@@ -262,7 +523,15 @@ async function loadConfig(configPath) {
   if (rules.maxTestFileLines === void 0) {
     rules.maxTestFileLines = 0;
   }
-  return parsed;
+  if (rules.enforceMissingTests === void 0) {
+    rules.enforceMissingTests = true;
+  }
+  if (parsed.ignore === void 0) {
+    parsed.ignore = [];
+  }
+  let config = parsed;
+  config = expandDefaults(config);
+  return config;
 }
 async function loadConfigSafe(configPath) {
   try {
@@ -298,43 +567,79 @@ function mergeStructure(existing, fresh) {
     testPattern: existing.testPattern ?? fresh.testPattern
   };
 }
-function hasConvention(conventions, key) {
-  return conventions[key] !== void 0;
-}
-function markAsDetected(value) {
-  if (typeof value === "string") {
-    return { value, _confidence: "high", _consistency: 100, _detected: true };
-  }
-  return { ...value, _detected: true };
-}
-function mergeConventions(existing, fresh) {
-  const merged = { ...existing };
+function mergeConventions(existing, fresh, existingMeta, freshMeta) {
+  const conventions = { ...existing };
+  const meta = { ...existingMeta ?? {} };
   for (const key of CONVENTION_KEYS) {
-    if (!hasConvention(existing, key) && fresh[key] !== void 0) {
-      const freshValue = fresh[key];
-      if (freshValue !== void 0) {
-        merged[key] = markAsDetected(freshValue);
+    if (existing[key] === void 0 && fresh[key] !== void 0) {
+      conventions[key] = fresh[key];
+      if (freshMeta?.[key]) {
+        meta[key] = { ...freshMeta[key], detected: true };
       }
+    } else if (existing[key] !== void 0 && freshMeta?.[key]) {
+      meta[key] = { ...freshMeta[key], value: freshMeta[key].value };
     }
   }
-  return merged;
+  return { conventions, meta };
+}
+function mergePackage(existing, fresh, existingMeta, freshMeta) {
+  const { conventions, meta } = mergeConventions(
+    existing.conventions ?? {},
+    fresh.conventions ?? {},
+    existingMeta,
+    freshMeta
+  );
+  return {
+    pkg: {
+      ...existing,
+      stack: mergeStack(existing.stack ?? {}, fresh.stack ?? {}),
+      structure: mergeStructure(existing.structure ?? {}, fresh.structure ?? {}),
+      conventions
+    },
+    meta
+  };
 }
 function mergeConfig(existing, scanResult) {
   const fresh = generateConfig(scanResult);
+  const existingByPath = new Map(existing.packages.map((p) => [p.path, p]));
+  const freshByPath = new Map(fresh.packages.map((p) => [p.path, p]));
+  const mergedPackages = [];
+  const mergedPkgMeta = {};
+  for (const existingPkg of existing.packages) {
+    const freshPkg = freshByPath.get(existingPkg.path);
+    if (freshPkg) {
+      const existingConvMeta = existing._meta?.packages?.[existingPkg.path]?.conventions;
+      const freshConvMeta = fresh._meta?.packages?.[existingPkg.path]?.conventions;
+      const { pkg, meta } = mergePackage(existingPkg, freshPkg, existingConvMeta, freshConvMeta);
+      mergedPackages.push(pkg);
+      if (Object.keys(meta).length > 0) {
+        mergedPkgMeta[pkg.path] = { conventions: meta };
+      }
+    } else {
+      mergedPackages.push(existingPkg);
+    }
+  }
+  for (const freshPkg of fresh.packages) {
+    if (!existingByPath.has(freshPkg.path)) {
+      mergedPackages.push(freshPkg);
+      const freshConvMeta = fresh._meta?.packages?.[freshPkg.path]?.conventions;
+      if (freshConvMeta && Object.keys(freshConvMeta).length > 0) {
+        mergedPkgMeta[freshPkg.path] = { conventions: freshConvMeta };
+      }
+    }
+  }
   const merged = {
     $schema: existing.$schema ?? fresh.$schema,
     version: existing.version,
     name: existing.name,
-    enforcement: existing.enforcement,
-    stack: mergeStack(existing.stack, fresh.stack),
-    structure: mergeStructure(existing.structure, fresh.structure),
-    conventions: mergeConventions(existing.conventions, fresh.conventions),
     rules: { ...existing.rules },
-    ignore: [...existing.ignore]
+    ignore: [...existing.ignore ?? []],
+    packages: mergedPackages,
+    _meta: {
+      lastSync: (/* @__PURE__ */ new Date()).toISOString(),
+      ...Object.keys(mergedPkgMeta).length > 0 ? { packages: mergedPkgMeta } : {}
+    }
   };
-  if (fresh.workspace) {
-    merged.workspace = fresh.workspace;
-  }
   if (existing.boundaries) {
     merged.boundaries = {
       deny: { ...existing.boundaries.deny },
@@ -346,57 +651,10 @@ function mergeConfig(existing, scanResult) {
       ...fresh.boundaries.ignore ? { ignore: [...fresh.boundaries.ignore] } : {}
     };
   }
-  if (existing.packages || fresh.packages) {
-    merged.packages = mergePackageOverrides(existing.packages, fresh.packages);
-  }
   return merged;
 }
-function mergePackageOverrides(existing, fresh) {
-  if (!fresh || fresh.length === 0) return existing;
-  if (!existing || existing.length === 0) return fresh;
-  const existingByPath = new Map(existing.map((p) => [p.path, p]));
-  const merged = [...existing];
-  for (const freshPkg of fresh) {
-    if (!existingByPath.has(freshPkg.path)) {
-      merged.push(freshPkg);
-    }
-  }
-  return merged.length > 0 ? merged : void 0;
-}
 
 // src/schema-parts.ts
-var conventionValueDef = {
-  description: "A convention value \u2014 either a plain string (user-confirmed) or an object with scanner metadata.",
-  oneOf: [
-    { type: "string" },
-    {
-      type: "object",
-      required: ["value", "_confidence", "_consistency"],
-      properties: {
-        value: {
-          type: "string",
-          description: "The convention value."
-        },
-        _confidence: {
-          type: "string",
-          enum: ["high", "medium", "low"],
-          description: "Scanner confidence level."
-        },
-        _consistency: {
-          type: "number",
-          minimum: 0,
-          maximum: 100,
-          description: "Scanner consistency percentage."
-        },
-        _detected: {
-          type: "boolean",
-          description: "Set by mergeConfig when a convention is newly detected during sync."
-        }
-      },
-      additionalProperties: false
-    }
-  ]
-};
 var boundarySchema = {
   type: "object",
   required: ["deny"],
@@ -417,44 +675,112 @@ var boundarySchema = {
   },
   additionalProperties: false
 };
+var stackSchema = {
+  type: "object",
+  properties: {
+    framework: { type: "string", description: 'Primary framework (e.g. "nextjs@15").' },
+    language: { type: "string", description: 'Primary language (e.g. "typescript").' },
+    styling: { type: "string", description: 'Styling solution (e.g. "tailwindcss@4").' },
+    backend: { type: "string", description: 'Backend framework (e.g. "express@5").' },
+    orm: { type: "string", description: 'ORM or database client (e.g. "prisma").' },
+    packageManager: { type: "string", description: 'Package manager (e.g. "pnpm").' },
+    linter: { type: "string", description: 'Linter (e.g. "eslint@9").' },
+    formatter: { type: "string", description: 'Formatter (e.g. "prettier").' },
+    testRunner: { type: "string", description: 'Test runner (e.g. "vitest").' }
+  },
+  additionalProperties: false
+};
+var structureSchema = {
+  type: "object",
+  properties: {
+    srcDir: { type: "string", description: 'Source directory (e.g. "src").' },
+    pages: { type: "string", description: "Pages or routes directory." },
+    components: { type: "string", description: "Components directory." },
+    hooks: { type: "string", description: "Hooks directory." },
+    utils: { type: "string", description: "Utilities directory." },
+    types: { type: "string", description: "Type definitions directory." },
+    tests: { type: "string", description: "Tests directory." },
+    testPattern: { type: "string", description: 'Test file naming pattern (e.g. "*.test.ts").' }
+  },
+  additionalProperties: false
+};
+var conventionsSchema = {
+  type: "object",
+  properties: {
+    fileNaming: { type: "string", description: 'File naming convention (e.g. "kebab-case").' },
+    componentNaming: { type: "string", description: "Component naming convention." },
+    hookNaming: { type: "string", description: "Hook naming convention." },
+    importAlias: { type: "string", description: 'Import alias pattern (e.g. "@/*").' }
+  },
+  additionalProperties: false
+};
+var coverageSchema = {
+  type: "object",
+  properties: {
+    command: {
+      type: "string",
+      description: "Command to generate coverage summary data for this package."
+    },
+    summaryPath: {
+      type: "string",
+      description: "Path to coverage summary JSON relative to package root."
+    }
+  },
+  additionalProperties: false
+};
 var packageItemSchema = {
   type: "object",
   required: ["name", "path"],
   properties: {
     name: { type: "string", description: "Package name from package.json." },
-    path: { type: "string", description: "Relative path to the package." },
-    stack: {
-      type: "object",
-      properties: {
-        framework: { type: "string" },
-        language: { type: "string" },
-        styling: { type: "string" },
-        backend: { type: "string" },
-        orm: { type: "string" },
-        packageManager: { type: "string" },
-        linter: { type: "string" },
-        formatter: { type: "string" },
-        testRunner: { type: "string" }
-      },
-      additionalProperties: false
+    path: { type: "string", description: 'Relative path to the package ("." for root).' },
+    stack: { ...stackSchema, description: "Technology stack for this package." },
+    structure: { ...structureSchema, description: "Directory structure for this package." },
+    conventions: { ...conventionsSchema, description: "Coding conventions for this package." },
+    coverage: {
+      ...coverageSchema,
+      description: "Coverage generation and summary settings for this package."
     },
-    conventions: { $ref: "#/properties/conventions" },
     rules: {
       type: "object",
       properties: {
         maxFileLines: { type: "number" },
         maxTestFileLines: { type: "number" },
-        maxFunctionLines: { type: "number" },
-        requireTests: { type: "boolean" },
+        testCoverage: { type: "number" },
         enforceNaming: { type: "boolean" },
         enforceBoundaries: { type: "boolean" }
       },
       additionalProperties: false
     },
-    ignore: { type: "array", items: { type: "string" } }
+    ignore: { type: "array", items: { type: "string" } },
+    boundaries: {
+      type: "object",
+      properties: {
+        deny: { type: "array", items: { type: "string" } },
+        ignore: { type: "array", items: { type: "string" } }
+      },
+      additionalProperties: false
+    }
   },
   additionalProperties: false
 };
+var defaultsSchema = {
+  type: "object",
+  properties: {
+    stack: { ...stackSchema, description: "Default stack inherited by all packages." },
+    structure: { ...structureSchema, description: "Default structure inherited by all packages." },
+    conventions: {
+      ...conventionsSchema,
+      description: "Default conventions inherited by all packages."
+    },
+    coverage: {
+      ...coverageSchema,
+      description: "Default coverage settings inherited by all packages."
+    }
+  },
+  additionalProperties: false,
+  description: "Shared defaults for all packages. Packages inherit and can override."
+};
 
 // src/schema.ts
 var configSchema = {
@@ -463,7 +789,7 @@ var configSchema = {
   title: "viberails configuration",
   description: "Configuration file for viberails \u2014 guardrails for vibe coding.",
   type: "object",
-  required: ["version", "name", "stack", "rules"],
+  required: ["version", "name", "packages", "rules"],
   properties: {
     $schema: {
       type: "string",
@@ -472,120 +798,20 @@ var configSchema = {
     version: {
       type: "number",
       const: 1,
-      description: "Config format version. Always 1 for V1.0."
+      description: "Config format version. Always 1."
     },
     name: {
       type: "string",
       description: "Project name, typically from package.json."
     },
-    enforcement: {
-      type: "string",
-      enum: ["warn", "enforce"],
-      default: "warn",
-      description: "Whether conventions are warned about or enforced as errors."
-    },
-    stack: {
-      type: "object",
-      required: ["language", "packageManager"],
-      properties: {
-        framework: {
-          type: "string",
-          description: 'Primary framework identifier (e.g. "nextjs@15", "remix@2").'
-        },
-        language: {
-          type: "string",
-          description: 'Primary language (e.g. "typescript", "javascript").'
-        },
-        styling: {
-          type: "string",
-          description: 'Styling solution (e.g. "tailwindcss@4", "css-modules").'
-        },
-        backend: {
-          type: "string",
-          description: 'Backend framework (e.g. "express@5", "fastify").'
-        },
-        orm: {
-          type: "string",
-          description: 'ORM or database client (e.g. "prisma", "drizzle", "typeorm").'
-        },
-        packageManager: {
-          type: "string",
-          description: 'Package manager (e.g. "pnpm", "npm", "yarn").'
-        },
-        linter: {
-          type: "string",
-          description: 'Linter (e.g. "eslint@9", "biome").'
-        },
-        formatter: {
-          type: "string",
-          description: 'Formatter (e.g. "prettier", "biome").'
-        },
-        testRunner: {
-          type: "string",
-          description: 'Test runner (e.g. "vitest", "jest").'
-        }
-      },
-      additionalProperties: false,
-      description: "Detected or configured technology stack."
-    },
-    structure: {
-      type: "object",
-      properties: {
-        srcDir: {
-          type: "string",
-          description: 'Source directory (e.g. "src"), or omit for flat structure.'
-        },
-        pages: {
-          type: "string",
-          description: 'Pages or routes directory (e.g. "src/app").'
-        },
-        components: {
-          type: "string",
-          description: 'Components directory (e.g. "src/components").'
-        },
-        hooks: {
-          type: "string",
-          description: 'Hooks directory (e.g. "src/hooks").'
-        },
-        utils: {
-          type: "string",
-          description: 'Utilities directory (e.g. "src/utils", "src/lib").'
-        },
-        types: {
-          type: "string",
-          description: 'Type definitions directory (e.g. "src/types").'
-        },
-        tests: {
-          type: "string",
-          description: 'Tests directory (e.g. "tests", "__tests__").'
-        },
-        testPattern: {
-          type: "string",
-          description: 'Test file naming pattern (e.g. "*.test.ts", "*.spec.ts").'
-        }
-      },
-      additionalProperties: false,
-      description: "Detected or configured directory structure."
-    },
-    conventions: {
-      type: "object",
-      properties: {
-        fileNaming: { $ref: "#/definitions/conventionValue" },
-        componentNaming: { $ref: "#/definitions/conventionValue" },
-        hookNaming: { $ref: "#/definitions/conventionValue" },
-        importAlias: { $ref: "#/definitions/conventionValue" }
-      },
-      additionalProperties: false,
-      description: "Detected or configured coding conventions."
-    },
     rules: {
       type: "object",
       required: [
         "maxFileLines",
-        "maxFunctionLines",
-        "requireTests",
+        "testCoverage",
         "enforceNaming",
-        "enforceBoundaries"
+        "enforceBoundaries",
+        "enforceMissingTests"
       ],
       properties: {
         maxFileLines: {
@@ -596,17 +822,12 @@ var configSchema = {
         maxTestFileLines: {
           type: "number",
           default: 0,
-          description: "Maximum number of lines allowed per test file. Set to 0 to exempt test files from size checks."
+          description: "Maximum number of lines allowed per test file. Set to 0 to exempt test files."
         },
-        maxFunctionLines: {
+        testCoverage: {
           type: "number",
-          default: 50,
-          description: "Maximum number of lines allowed per function."
-        },
-        requireTests: {
-          type: "boolean",
-          default: true,
-          description: "Whether to require test files for source modules."
+          default: 80,
+          description: "Minimum line coverage target percentage. 0 disables coverage threshold checks."
         },
         enforceNaming: {
           type: "boolean",
@@ -617,6 +838,11 @@ var configSchema = {
           type: "boolean",
           default: false,
           description: "Whether to enforce module boundary rules."
+        },
+        enforceMissingTests: {
+          type: "boolean",
+          default: true,
+          description: "Whether to enforce that every source file has a corresponding test file."
         }
       },
       additionalProperties: false,
@@ -625,49 +851,61 @@ var configSchema = {
     ignore: {
       type: "array",
       items: { type: "string" },
-      description: "Glob patterns for files and directories to ignore."
+      description: "Project-specific glob patterns to ignore (universal patterns are built-in)."
     },
     boundaries: {
       ...boundarySchema,
       description: "Module boundary rules for import enforcement."
     },
-    workspace: {
+    defaults: defaultsSchema,
+    packages: {
+      type: "array",
+      items: packageItemSchema,
+      description: 'Per-package configs. Single projects use path ".".'
+    },
+    _meta: {
       type: "object",
-      required: ["packages", "isMonorepo"],
       properties: {
+        lastSync: { type: "string", description: "ISO timestamp of last sync." },
         packages: {
-          type: "array",
-          items: { type: "string" },
-          description: "Relative paths to workspace packages."
-        },
-        isMonorepo: {
-          type: "boolean",
-          description: "Whether this project is a monorepo with multiple packages."
+          type: "object",
+          additionalProperties: {
+            type: "object",
+            properties: {
+              conventions: {
+                type: "object",
+                additionalProperties: {
+                  type: "object",
+                  properties: {
+                    value: { type: "string" },
+                    confidence: { type: "string", enum: ["high", "medium", "low"] },
+                    consistency: { type: "number" },
+                    detected: { type: "boolean" }
+                  }
+                }
+              }
+            }
+          }
         }
       },
-      additionalProperties: false,
-      description: "Workspace configuration for monorepo projects."
-    },
-    packages: {
-      type: "array",
-      items: packageItemSchema,
-      description: "Per-package overrides for monorepo projects."
+      description: "Scanner metadata. Regenerated on every sync \u2014 not user-editable."
     }
   },
-  additionalProperties: false,
-  definitions: {
-    conventionValue: conventionValueDef
-  }
+  additionalProperties: false
 };
 
 // src/index.ts
-var VERSION = "0.3.3";
+var VERSION = "0.5.0";
 export {
+  BUILTIN_IGNORE,
   DEFAULT_IGNORE,
   DEFAULT_RULES,
   VERSION,
+  compactConfig,
   configSchema,
+  expandDefaults,
   generateConfig,
+  inferCoverageCommand,
   loadConfig,
   loadConfigSafe,
   mergeConfig