fix: three simple bugs — locale duration, dispatcher reset, impact test count (#529)

1. Fix Locale.duration for >=24h (#368): days and hours were swapped.
   `Math.floor(input / 3600000)` gave total hours, not days.
   Now correctly: days = input/86400000, hours = remainder/3600000.

2. Fix dispatcher.reset() not clearing lazy registration hook (#468):
   reset() only cleared handlers but left _ensureRegistered alive.
   Next call() would re-register all handlers via the stale hook,
   causing flaky test failures when test files share module state.

3. Fix impact_analysis showing project-wide test_count (#371):
   Was using manifest.test_count (all tests in project).
   Now collects individual test nodes with their depends_on refs
   and counts only tests that reference the target model or its
   downstream dependents.

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: kulvirgit

packages/opencode/src/altimate/native/dbt/manifest.ts

@@ -10,6 +10,7 @@ import type {
   DbtManifestResult,
   DbtModelInfo,
   DbtSourceInfo,
+  DbtTestInfo,
   ModelColumn,
 } from "../types"
 
@@ -30,6 +31,7 @@ export async function parseManifest(params: DbtManifestParams): Promise<DbtManif
   const emptyResult: DbtManifestResult = {
     models: [],
     sources: [],
+    tests: [],
     source_count: 0,
     model_count: 0,
     test_count: 0,
@@ -67,6 +69,7 @@ export async function parseManifest(params: DbtManifestParams): Promise<DbtManif
   const sourcesDict = manifest.sources || {}
 
   const models: DbtModelInfo[] = []
+  const tests: DbtTestInfo[] = []
   let testCount = 0
   let snapshotCount = 0
   let seedCount = 0
@@ -88,6 +91,11 @@ export async function parseManifest(params: DbtManifestParams): Promise<DbtManif
       })
     } else if (resourceType === "test") {
       testCount++
+      tests.push({
+        unique_id: nodeId,
+        name: node.name || "",
+        depends_on: node.depends_on?.nodes || [],
+      })
     } else if (resourceType === "snapshot") {
       snapshotCount++
     } else if (resourceType === "seed") {
@@ -111,6 +119,7 @@ export async function parseManifest(params: DbtManifestParams): Promise<DbtManif
   return {
     models,
     sources,
+    tests,
     source_count: sources.length,
     model_count: models.length,
     test_count: testCount,

packages/opencode/src/altimate/native/dispatcher.ts

@@ -17,14 +17,15 @@ export function register(method: BridgeMethod, handler: NativeHandler): void {
   nativeHandlers.set(method, handler)
 }
 
-/** Clear all registered handlers (for test isolation). */
+/** Lazy registration hook — set by native/index.ts */
+let _ensureRegistered: (() => Promise<void>) | null = null
+
+/** Clear all registered handlers and lazy registration hook (for test isolation). */
 export function reset(): void {
   nativeHandlers.clear()
+  _ensureRegistered = null
 }
 
-/** Lazy registration hook — set by native/index.ts */
-let _ensureRegistered: (() => Promise<void>) | null = null
-
 /** Called by native/index.ts to set the lazy registration function. */
 export function setRegistrationHook(fn: () => Promise<void>): void {
   _ensureRegistered = fn

packages/opencode/src/altimate/native/types.ts

@@ -188,9 +188,16 @@ export interface DbtSourceInfo {
   columns: ModelColumn[]
 }
 
+export interface DbtTestInfo {
+  unique_id: string
+  name: string
+  depends_on: string[]
+}
+
 export interface DbtManifestResult {
   models: DbtModelInfo[]
   sources: DbtSourceInfo[]
+  tests: DbtTestInfo[]
   source_count: number
   model_count: number
   test_count: number

packages/opencode/src/altimate/tools/impact-analysis.ts

@@ -70,8 +70,15 @@ export const ImpactAnalysisTool = Tool.define("impact_analysis", {
       const direct = downstream.filter((d) => d.depth === 1)
       const transitive = downstream.filter((d) => d.depth > 1)
 
-      // Step 4: Report test count (manifest has test_count but not individual tests)
-      const affectedTestCount = manifest.test_count ?? 0
+      // Step 4: Count only tests that reference the target model or its downstream models
+      const affectedModelIds = new Set([
+        targetModel.unique_id,
+        ...downstream.map((d) => modelsByName.get(d.name)?.unique_id).filter(Boolean),
+      ])
+      const affectedTests = (manifest.tests ?? []).filter((t) =>
+        t.depends_on?.some((dep) => affectedModelIds.has(dep)),
+      )
+      const affectedTestCount = affectedTests.length
 
       // Step 5: If column specified, attempt column-level lineage
       let columnImpact: string[] = []
@@ -253,9 +260,13 @@ export function formatImpactReport(data: {
 
   // Affected tests
   if (data.affectedTestCount > 0) {
-    lines.push(`Tests in project: ${data.affectedTestCount}`)
+    lines.push(`Affected tests: ${data.affectedTestCount}`)
     lines.push("".padEnd(40, "-"))
-    lines.push(`  Run \`dbt test\` to verify all ${data.affectedTestCount} tests still pass after this change.`)
+    lines.push(
+      data.affectedTestCount === 1
+        ? "  Run `dbt test` to verify this test still passes after this change."
+        : `  Run \`dbt test\` to verify these ${data.affectedTestCount} tests still pass after this change.`,
+    )
     lines.push("")
   }
 

packages/opencode/src/util/locale.ts

@@ -54,8 +54,8 @@ export namespace Locale {
       const minutes = Math.floor((input % 3600000) / 60000)
       return `${hours}h ${minutes}m`
     }
-    const hours = Math.floor(input / 3600000)
-    const days = Math.floor((input % 3600000) / 86400000)
+    const days = Math.floor(input / 86400000)
+    const hours = Math.floor((input % 86400000) / 3600000)
     return `${days}d ${hours}h`
   }
 

packages/opencode/test/altimate/tools/impact-analysis.test.ts

@@ -151,7 +151,7 @@ describe("formatImpactReport", () => {
     })
     expect(report).toContain("WARNING: Rename requires updating all downstream references.")
     expect(report).toContain("Update all downstream SQL references to new name")
-    expect(report).toContain("Tests in project: 5")
+    expect(report).toContain("Affected tests: 5")
   })
 
   test("column-level impact shows affected columns", () => {

packages/opencode/test/util/locale.test.ts

@@ -43,13 +43,10 @@ describe("Locale.duration", () => {
     expect(Locale.duration(5400000)).toBe("1h 30m")
   })
 
-  // BUG: Locale.duration >=24h has swapped days/hours calculation.
-  // hours = Math.floor(input / 3600000) gives total hours (25), not remainder.
-  // days = Math.floor((input % 3600000) / 86400000) always yields 0.
-  // Correct: days = Math.floor(input / 86400000), hours = Math.floor((input % 86400000) / 3600000)
-  // 90000000ms = 25h = 1d 1h — should display "1d 1h"
+  // Fixed in this PR: days and hours were swapped for >=24h durations.
+  // 90000000ms = 25h = 1d 1h
   // See: https://github.com/AltimateAI/altimate-code/issues/368
-  test.skip("FIXME: days and hours for >=24h are calculated correctly", () => {
+  test("days and hours for >=24h are calculated correctly", () => {
     expect(Locale.duration(90000000)).toBe("1d 1h")
   })
 })