code-foundry 1.46.5 → 1.46.6

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.46.6](https://github.com/0xPlayerOne/code-foundry/compare/v1.46.5...v1.46.6) (2026-10-08)
+
+
+### Bug Fixes
+
+* **pre-commit:** build before lint and type-check when the gate opts in ([#748](https://github.com/0xPlayerOne/code-foundry/issues/748)) ([f56454f](https://github.com/0xPlayerOne/code-foundry/commit/f56454f313a1a5b802b8a17b09d850902de1ba55)), closes [#691](https://github.com/0xPlayerOne/code-foundry/issues/691)
+
 ## [1.46.5](https://github.com/0xPlayerOne/code-foundry/compare/v1.46.4...v1.46.5) (2026-10-08)
 
 
@@ -133,16 +140,9 @@
 
 * **ci:** cancel only superseded pull-request runs in managed workflows ([#710](https://github.com/0xPlayerOne/code-foundry/issues/710)) ([f5fead6](https://github.com/0xPlayerOne/code-foundry/commit/f5fead677c032d253f2e1a2a256da4f207ddfa2a))
 
-## [1.44.1](https://github.com/0xPlayerOne/code-foundry/compare/v1.44.0...v1.44.1) (2026-10-03)
-
-
-### Bug Fixes
-
-* **release:** budget the package without the changelog and ship recent history only ([#708](https://github.com/0xPlayerOne/code-foundry/issues/708)) ([ab365e0](https://github.com/0xPlayerOne/code-foundry/commit/ab365e0910472c3596429adc86a1c8f3e19730f9))
-
 <!-- code-foundry: packaged changelog -->
 
 ---
 
-This packaged changelog lists the 20 most recent releases; 240 older releases are omitted to keep the package small.
+This packaged changelog lists the 20 most recent releases; 241 older releases are omitted to keep the package small.
 See the [full changelog](https://github.com/0xPlayerOne/code-foundry/blob/main/CHANGELOG.md) for the complete history.

package/docs/CONFIGURATION.md

@@ -131,7 +131,7 @@ See [Merge queue validation](merge-queues.md) before enabling it.
 | `coverage_minimum`                        | `0`–`100`                                            | Minimum percentage; defaults to `80`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `coverage_metrics`                        | `lines`, `functions`, `branches`, `statements`       | Metrics checked by the coverage gate.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `coverage_report`                         | comma-separated repository paths                     | Istanbul JSON summary or LCOV evidence files.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| `pre_commit_build`                        | `true`, `false`                                      | Run the project's build in the local pre-commit gate. Defaults to `false`; see [Pre-commit gate](#pre-commit-gate).                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `pre_commit_build`                        | `true`, `false`                                      | Run the project's build in the local pre-commit gate, before lint and type-check (mirroring CI's ordering). Defaults to `false`; see [Pre-commit gate](#pre-commit-gate).                                                                                                                                                                                                                                                                                                                                                                             |
 | `filter_<task>`                           | comma-separated repository path globs                | Skip a lane when no changed path matches; see [Lane path filters](#lane-path-filters).                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 | `rust_sccache`                            | `true`, `false`                                      | Install sccache and wrap rustc so compile artifacts survive manifest/lockfile churn.                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | `rust_nextest`                            | `true`, `false`                                      | Install cargo-nextest and prefer `cargo nextest run` over `cargo test` in Rust test lanes.                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
@@ -194,7 +194,11 @@ gate is change-aware and never runs work for code the commit cannot affect:
   Clippy.
 - The build does not run at commit time; CI and explicit commands own it. Set
   `pre_commit_build: true` to run the `build` script (or `cargo build`) when
-  code is staged.
+  code is staged. The build then runs before lint and type-check — mirroring
+  CI's ordering — because those tasks read built package output. With the
+  build disabled, a lint or type-check failure that a fresh clone's missing
+  build output could explain is printed with a one-line note saying so instead
+  of a bare error.
 
 Tools read working-tree contents, so a partially staged file is checked as it
 exists on disk. Task scripts that declare dependencies of their own, such as a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-foundry",
-  "version": "1.46.5",
+  "version": "1.46.6",
   "description": "A fast, language-aware repository factory for agent-ready workflows, testing, security, and release automation.",
   "homepage": "https://github.com/0xPlayerOne/code-foundry#readme",
   "bugs": {

package/src/lib/pre-commit.mjs

@@ -98,6 +98,25 @@ export function preCommitBuildEnabled(value) {
   return resolved === 'true'
 }
 
+/**
+ * The one-line explanation printed when lint or type-check fails while the
+ * commit-time build is disabled. CI builds before those tasks, so a fresh
+ * clone can fail the gate against an unmodified tree — a bare ENOENT trains
+ * `--no-verify` unless the gate names the actual problem.
+ *
+ * @param {{ build: boolean, buildScript: boolean, packageManager: string | null }} options
+ * @returns {string | undefined} The hint, or undefined when it cannot apply.
+ */
+export function freshCloneBuildHint({ build, buildScript, packageManager }) {
+  if (build || !buildScript) return undefined
+  const runner = packageManager ?? 'npm'
+  return (
+    `note: these checks may be reading missing build output on a fresh clone; ` +
+    `run "${runner} run build" once, or set pre_commit_build: true in ` +
+    `.github/code-foundry.yml to build before lint and type-check`
+  )
+}
+
 /**
  * Split a file list so one tool invocation never exceeds the platform's
  * argument-length limit on very large commits.

package/src/runtime-core.mjs

@@ -25,6 +25,7 @@ import {
   parseStagedFiles,
   planPreCommit,
   preCommitBuildEnabled,
+  freshCloneBuildHint,
 } from './lib/pre-commit.mjs'
 import { runNodePackagePerformance } from './lib/node-package-performance.mjs'
 import {
@@ -428,16 +429,20 @@ function commandExists(command) {
   return spawnSync(command, ['--version'], { stdio: 'ignore' }).status === 0
 }
 
-/** @param {string} command @param {string[]} [args] @param {Record<string, unknown>} [options] */
+/** @param {string} command @param {string[]} [args] @param {{ onFailure?: string }} [options] */
 function run(command, args = [], options = {}) {
+  const { onFailure, ...spawnOptions } = options
   const result = spawnSync(command, args, {
     cwd: root,
     stdio: 'inherit',
     env: process.env,
-    ...options,
+    ...spawnOptions,
   })
   if (result.error) throw result.error
-  if (result.status !== 0) process.exit(result.status ?? 1)
+  if (result.status !== 0) {
+    if (onFailure) console.error(onFailure)
+    process.exit(result.status ?? 1)
+  }
 }
 
 // pip-audit can report its clean result with a non-zero status when the
@@ -494,28 +499,28 @@ function packageCommand(args) {
   }
 }
 
-/** @param {string[]} names */
-function runScript(names) {
+/** @param {string[]} names @param {{ onFailure?: string }} [options] */
+function runScript(names, options = {}) {
   const name = names.find((candidate) => hasScript(candidate))
   if (!name) return false
   const [manager, args] = packageCommand(['run', name])
   if (!manager) return false
-  run(manager, args)
+  run(manager, args, options)
   return true
 }
 
-/** @param {string} tool @param {string[]} [args] */
-function runTool(tool, args = []) {
+/** @param {string} tool @param {string[]} [args] @param {{ onFailure?: string }} [options] */
+function runTool(tool, args = [], options = {}) {
   if (['ruff', 'pytest', 'pylint'].includes(tool)) {
     const venvTool = resolve(root, `.venv/bin/${tool}`)
-    if (existsSync(venvTool)) return run(venvTool, args)
+    if (existsSync(venvTool)) return run(venvTool, args, options)
   }
   const [manager] = packageCommand([])
-  if (manager === 'bun') return run('bunx', ['--no-install', tool, ...args])
-  if (manager === 'pnpm') return run('pnpm', ['exec', tool, ...args])
-  if (manager === 'yarn') return run('yarn', ['exec', tool, ...args])
-  if (manager === 'npm') return run('npx', ['--no-install', tool, ...args])
-  return run(tool, args)
+  if (manager === 'bun') return run('bunx', ['--no-install', tool, ...args], options)
+  if (manager === 'pnpm') return run('pnpm', ['exec', tool, ...args], options)
+  if (manager === 'yarn') return run('yarn', ['exec', tool, ...args], options)
+  if (manager === 'npm') return run('npx', ['--no-install', tool, ...args], options)
+  return run(tool, args, options)
 }
 
 function install() {
@@ -1193,9 +1198,11 @@ function runToolOnFiles(tool, args, files) {
  *
  * The gate is change-aware: it formats and lints only staged files, runs the
  * project's type-check command only when typed sources or compiler config are
- * staged, and never builds unless `pre_commit_build: true` opts back in. The
- * full suite still runs in CI. Tools see working-tree contents, so a partially
- * staged file is checked as it exists on disk.
+ * staged, and never builds unless `pre_commit_build: true` opts back in — in
+ * which case the build runs before lint and type-check, mirroring CI's
+ * ordering, because those tasks read built package output. The full suite
+ * still runs in CI. Tools see working-tree contents, so a partially staged
+ * file is checked as it exists on disk.
  */
 export function preCommit() {
   const staged = parseStagedFiles(
@@ -1225,9 +1232,22 @@ export function preCommit() {
       runScript(['format:check', 'format', 'fmt'])
     }
   }
+  // Mirror CI's prerequisite ordering: lint, boundary, and type-check tasks
+  // read built package output, so the opt-in build runs before them. Format
+  // stays first for the fastest feedback on the most common failure. Without
+  // the opt-in, a failure that CI (which builds first) cannot reproduce gets
+  // the one-line explanation instead of training `--no-verify`.
+  if (plan.build) ci('build')
+  const buildHint = freshCloneBuildHint({
+    build: plan.build,
+    buildScript: hasScript('build'),
+    packageManager: packageCommand([])[0],
+  })
+
   if (js && (plan.lintAll || plan.lintFiles.length)) {
     if (plan.lintAll) {
-      if (!runScript(['lint']) && hasOxlintSetup()) runTool('oxlint', ['--deny-warnings'])
+      if (!runScript(['lint'], { onFailure: buildHint }) && hasOxlintSetup())
+        runTool('oxlint', ['--deny-warnings'])
     } else if (hasOxlintSetup()) {
       runToolOnFiles(
         'oxlint',
@@ -1241,8 +1261,11 @@ export function preCommit() {
   if (js && plan.typeCheck) {
     // Use the project's own command so project references, workspaces, and
     // path aliases resolve exactly as they do in CI.
-    const scripted = runScript(['type-check', 'typecheck', 'type:check'])
-    if (!scripted && existsSync(resolve(root, 'tsconfig.json'))) runTool('tsc', ['--noEmit'])
+    const scripted = runScript(['type-check', 'typecheck', 'type:check'], {
+      onFailure: buildHint,
+    })
+    if (!scripted && existsSync(resolve(root, 'tsconfig.json')))
+      runTool('tsc', ['--noEmit'], { onFailure: buildHint })
   }
   if (plan.rust) {
     run('cargo', ['fmt', '--check'])
@@ -1255,7 +1278,6 @@ export function preCommit() {
     runToolOnFiles('ruff', ['format', '--check', '--force-exclude'], plan.pythonFiles)
     runToolOnFiles('ruff', ['check', '--force-exclude'], plan.pythonFiles)
   }
-  if (plan.build) ci('build')
 }
 
 // Only dispatch when this module is the process entry point. The CLI imports