project-tiny-context-harness 0.2.52 → 0.2.54

package/dist/lib/upgrade.js

@@ -1,11 +1,33 @@
 import { runDoctor } from "./doctor.js";
-import { formatUpgradePlan, runMigrations } from "./migrations.js";
+import { createUpgradePlan, formatUpgradePlan, runMigrations } from "./migrations.js";
 import { assertSupportedSchema } from "./schema-guard.js";
 import { runSync } from "./sync-engine.js";
+export class UpgradeBlockedError extends Error {
+    lines;
+    constructor(lines) {
+        super("upgrade completed with blockers");
+        this.lines = lines;
+    }
+}
 export async function runUpgrade(projectRoot) {
+    const report = await runUpgradeReport(projectRoot);
+    if (report.blocked) {
+        throw new UpgradeBlockedError(report.lines);
+    }
+    return report.lines;
+}
+export async function runUpgradeReport(projectRoot) {
     const lines = [];
     await assertSupportedSchema(projectRoot, "upgrade");
-    const migrationReport = await runMigrations(projectRoot);
+    const plan = await createUpgradePlan(projectRoot);
+    if (plan.blocked.length > 0) {
+        lines.push(...formatUpgradePlan(plan));
+        lines.push("upgrade blocked: resolve blocked migration items before applying safe migrations or sync.");
+        const doctor = await runDoctor(projectRoot);
+        lines.push(`doctor warnings=${doctor.warnings.length} errors=${doctor.errors.length}`);
+        return { lines, blocked: true };
+    }
+    const migrationReport = await runMigrations(projectRoot, plan);
     lines.push(`migrations changed=${migrationReport.changed.length} skipped=${migrationReport.skipped.length} manual_required=${migrationReport.manualRequired.length} blocked=${migrationReport.blocked.length}`);
     if (migrationReport.manualRequired.length > 0 || migrationReport.blocked.length > 0) {
         lines.push(...formatUpgradePlan({
@@ -21,11 +43,9 @@ export async function runUpgrade(projectRoot) {
     }
     const doctor = await runDoctor(projectRoot);
     lines.push(`doctor warnings=${doctor.warnings.length} errors=${doctor.errors.length}`);
-    if (migrationReport.manualRequired.length > 0 ||
+    const blocked = migrationReport.manualRequired.length > 0 ||
         migrationReport.blocked.length > 0 ||
         syncReport.blocked.length > 0 ||
-        doctor.errors.length > 0) {
-        throw new Error("upgrade completed with blockers");
-    }
-    return lines;
+        doctor.errors.length > 0;
+    return { lines, blocked };
 }

package/dist/lib/validators.js

@@ -2,10 +2,12 @@ import path from "node:path";
 import { readConfig } from "./config.js";
 import { harnessPath, harnessRoot } from "./harness-root.js";
 import { listFiles, pathExists, readText } from "./fs.js";
+import { runModularityCheck } from "./modularity.js";
 import { unsupportedSchemaMessage } from "./schema-guard.js";
 const VALIDATORS = {
     "validate-context": validateContext,
-    "validate-harness": validateContext
+    "validate-code-modularity": validateCodeModularity,
+    "validate-harness": validateHarness
 };
 const GLOBAL_REQUIRED_SECTIONS = [
     ...sectionSpecs([
@@ -71,12 +73,43 @@ export async function runValidator(projectRoot, gate) {
         return {
             info: [],
             errors: [
-                `unknown validator: ${gate}. Minimal Context Harness supports validate-context and validate-harness only.`
+                `unknown validator: ${gate}. Minimal Context Harness supports validate-context, validate-code-modularity and validate-harness only.`
             ]
         };
     }
     return validator(projectRoot);
 }
+async function validateHarness(projectRoot) {
+    const contextReport = await validateContext(projectRoot);
+    const modularityReport = await validateCodeModularity(projectRoot);
+    return {
+        info: [...contextReport.info, ...modularityReport.info],
+        errors: [...contextReport.errors, ...modularityReport.errors]
+    };
+}
+async function validateCodeModularity(projectRoot) {
+    const report = await runModularityCheck(projectRoot, { touched: true });
+    const info = [
+        `code modularity audited=${report.files.length} warning=${report.warnings.length} waived=${report.waivedWarnings.length} limit=${report.limit}`
+    ];
+    if (report.files.length === 0) {
+        info.push("No handwritten source files matched the selected scope.");
+    }
+    for (const file of report.files) {
+        const prefix = file.overLimit && file.waived ? "waived" : file.overLimit ? "over-limit" : "ok";
+        info.push(`${prefix}: ${file.relativePath} ${file.lines} lines`);
+    }
+    for (const waiver of report.waivedWarnings) {
+        info.push(`waived: ${waiver}`);
+    }
+    if (report.errors.length === 0 && report.warnings.length === 0) {
+        info.push("Code modularity validation passed");
+    }
+    return {
+        info,
+        errors: [...report.errors, ...report.warnings]
+    };
+}
 async function validateContext(projectRoot) {
     const info = [];
     const errors = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-tiny-context-harness",
-  "version": "0.2.52",
+  "version": "0.2.54",
   "description": "Minimal project memory and validation harness for AI coding agents.",
   "license": "MIT",
   "author": "Seven128",