@hominis/fireforge 0.30.0 → 0.30.1

package/CHANGELOG.md

@@ -2,7 +2,7 @@
 
 ## 0.30.0
 
-- Added safe repo-local per-patch lint result caching for `lint --per-patch`, plus `--no-cache` and `lint cache clear` escape hatches while preserving release-gate severity accounting and queue-wide checks.
+- Added safe repo-local per-patch lint result caching for `lint --per-patch`, plus `--no-cache` and `lint cache clear` escape hatches while preserving release-gate severity accounting and queue-wide checks. Warm cache hits now skip per-patch diff generation as well as lint rule execution, guarded by patch, config, engine content, queue ownership, and engine HEAD inputs.
 
 ## 0.29.0
 

package/README.md

@@ -66,11 +66,6 @@ npx fireforge test browser/base/content/test/browser/
 
 Use `fireforge --help` for the full set of commands.
 
-`lint --per-patch` reuses safe repo-local results for unchanged patches from
-`.fireforge/lint-cache/`, while still running queue-wide checks every time. Use
-`npx fireforge lint --per-patch --no-cache` to force a fresh run, or
-`npx fireforge lint cache clear` to drop cached per-patch lint results.
-
 For large generated asset batches, `re-export --scan --scan-files <manifest>` assigns files to
 their owner patches without broad directory scanning. The manifest is JSON:
 

package/dist/src/commands/lint-per-patch.js

@@ -2,7 +2,7 @@
 import { join } from 'node:path';
 import { loadConfig } from '../core/config.js';
 import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
-import { buildPerPatchLintCacheKey, getCachedPerPatchLintIssues, loadPerPatchLintCache, savePerPatchLintCache, setCachedPerPatchLintIssues, } from '../core/lint-cache.js';
+import { buildPerPatchLintCacheKey, getCachedPerPatchLintIssues, getPerPatchLintCacheHeadSha, loadPerPatchLintCache, savePerPatchLintCache, setCachedPerPatchLintIssues, } from '../core/lint-cache.js';
 import { buildPatchQueueContext, lintExportedPatch, lintPatchQueue, resolvePatchSizeTier, } from '../core/patch-lint.js';
 import { loadPatchesManifest } from '../core/patch-manifest.js';
 import { evaluatePatchPolicy } from '../core/patch-policy.js';
@@ -13,6 +13,14 @@ function buildPerPatchMaxWarningsMessage(count, maxWarnings, linted) {
     return (`Patch lint found ${count} warning(s) across ${linted} patch(es), exceeding --max-warnings ${maxWarnings}.` +
         ' If this is a release gate, run with --per-patch to identify the owning patch. For intentional staged imports, use patch staged-dependency; for ownership repairs, preview patch move-files, patch reorder --dry-run, or re-export --files --dry-run; add scoped lintIgnore only after review.');
 }
+function emitTierNotice(filename, files, tier) {
+    const decision = resolvePatchSizeTier(files, tier);
+    if (decision.tier !== 'branding')
+        return;
+    info(decision.source === 'explicit'
+        ? `${filename}: branding threshold tier applied via patches.json \`tier: "branding"\` opt-in.`
+        : `${filename}: branding threshold tier applied (all files under browser/branding/ plus registration siblings).`);
+}
 /**
  * Lints each patch in the queue as its own isolated diff, honouring
  * per-patch `lintIgnore` entries. Cross-patch rules still run once over
@@ -28,6 +36,7 @@ export async function lintPerPatch(projectRoot, paths, options = {}) {
     const config = await loadConfig(projectRoot);
     const ctx = await buildPatchQueueContext(paths.patches);
     const cache = options.noCache === true ? undefined : await loadPerPatchLintCache(projectRoot);
+    const engineHeadSha = cache ? await getPerPatchLintCacheHeadSha(paths.engine) : undefined;
     let cacheDirty = false;
     let reusedCacheEntries = 0;
     const issues = [];
@@ -51,21 +60,11 @@ export async function lintPerPatch(projectRoot, paths, options = {}) {
             skipped++;
             continue;
         }
-        const diff = await getDiffForFilesAgainstHead(paths.engine, existing);
-        if (!diff.trim()) {
-            skipped++;
-            continue;
-        }
         const ignore = patch.lintIgnore?.length ? new Set(patch.lintIgnore) : undefined;
-        const decision = resolvePatchSizeTier(existing, patch.tier);
-        if (decision.tier === 'branding') {
-            info(decision.source === 'explicit'
-                ? `${patch.filename}: branding threshold tier applied via patches.json \`tier: "branding"\` opt-in.`
-                : `${patch.filename}: branding threshold tier applied (all files under browser/branding/ plus registration siblings).`);
-        }
         let patchIssues;
+        let cacheKey;
         if (cache) {
-            const cacheKey = await buildPerPatchLintCacheKey({
+            cacheKey = await buildPerPatchLintCacheKey({
                 projectRoot,
                 engineDir: paths.engine,
                 patchesDir: paths.patches,
@@ -73,16 +72,29 @@ export async function lintPerPatch(projectRoot, paths, options = {}) {
                 existingFiles: existing,
                 config,
                 queueContext: ctx,
+                ...(engineHeadSha === undefined ? {} : { engineHeadSha }),
             });
             patchIssues = getCachedPerPatchLintIssues(cache, patch.filename, cacheKey);
             if (patchIssues) {
                 reusedCacheEntries++;
+                emitTierNotice(patch.filename, existing, patch.tier);
+                for (const issue of patchIssues) {
+                    issues.push({ ...issue, file: `${patch.filename} :: ${issue.file}` });
+                }
+                linted++;
+                continue;
             }
-            else {
-                patchIssues = await lintExportedPatch(paths.engine, existing, diff, config, ctx, ignore, patch.tier);
-                setCachedPerPatchLintIssues(cache, patch.filename, cacheKey, patchIssues);
-                cacheDirty = true;
-            }
+        }
+        const diff = await getDiffForFilesAgainstHead(paths.engine, existing);
+        if (!diff.trim()) {
+            skipped++;
+            continue;
+        }
+        emitTierNotice(patch.filename, existing, patch.tier);
+        if (cache && cacheKey) {
+            patchIssues = await lintExportedPatch(paths.engine, existing, diff, config, ctx, ignore, patch.tier);
+            setCachedPerPatchLintIssues(cache, patch.filename, cacheKey, patchIssues);
+            cacheDirty = true;
         }
         else {
             patchIssues = await lintExportedPatch(paths.engine, existing, diff, config, ctx, ignore, patch.tier);

package/dist/src/core/lint-cache.d.ts

@@ -21,6 +21,7 @@ export interface PerPatchLintCacheKeyInput {
     existingFiles: string[];
     config: FireForgeConfig;
     queueContext: PatchQueueContext;
+    engineHeadSha?: string;
     packageVersion?: string;
 }
 type JsonValue = string | number | boolean | null | JsonValue[] | {
@@ -32,6 +33,8 @@ export declare function sha256Hex(content: string | Buffer): string;
 export declare function stableHash(value: JsonValue): string;
 /** Returns the repo-local per-patch lint cache file path. */
 export declare function getPerPatchLintCachePath(projectRoot: string): string;
+/** Returns the engine git HEAD identity used to guard diff-derived cache hits. */
+export declare function getPerPatchLintCacheHeadSha(engineDir: string): Promise<string>;
 /**
  * Builds the complete per-patch lint cache key for one lintable patch.
  * The key includes source, metadata, config, engine state, and ownership inputs.

package/dist/src/core/lint-cache.js

@@ -5,6 +5,7 @@ import { join, resolve } from 'node:path';
 import { pathExists, readJson, writeJson } from '../utils/fs.js';
 import { getPackageVersion } from '../utils/package-root.js';
 import { getFurnacePaths } from './furnace-config.js';
+import { git } from './git-base.js';
 import { collectNewFileCreatorsByPath } from './patch-lint.js';
 export const LINT_CACHE_SCHEMA_VERSION = 1;
 export const LINT_IMPLEMENTATION_VERSION = 1;
@@ -36,6 +37,10 @@ export function stableHash(value) {
 export function getPerPatchLintCachePath(projectRoot) {
     return join(projectRoot, '.fireforge', LINT_CACHE_DIRNAME, PER_PATCH_CACHE_FILENAME);
 }
+/** Returns the engine git HEAD identity used to guard diff-derived cache hits. */
+export async function getPerPatchLintCacheHeadSha(engineDir) {
+    return (await git(['rev-parse', 'HEAD'], engineDir)).trim();
+}
 async function fileHash(path) {
     if (!(await pathExists(path))) {
         return { exists: false };
@@ -90,6 +95,7 @@ export async function buildPerPatchLintCacheKey(input) {
         };
     return stableHash({
         cacheSchemaVersion: LINT_CACHE_SCHEMA_VERSION,
+        engineHeadSha: input.engineHeadSha ?? null,
         lintImplementationVersion: LINT_IMPLEMENTATION_VERSION,
         packageVersion: input.packageVersion ?? getPackageVersion(),
         patchFile: await fileHash(join(input.patchesDir, input.patch.filename)),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hominis/fireforge",
-  "version": "0.30.0",
+  "version": "0.30.1",
   "description": "FireForge — a build tool for customizing Firefox",
   "type": "module",
   "main": "./dist/src/index.js",