From fe0d03fc3ce95872471530656c9c9312ec1b526c Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Fri, 13 Nov 2026 16:44:57 +0530 Subject: [PATCH 01/56] feat: hold dbt run, build and show over the BigQuery scan limit until allowed Co-Authored-By: Claude Opus 5.5 --- .../hooks/features/cost.test.tsx | 194 +++++++++++++++ plugins/altimate-code/hooks/features/cost.tsx | 231 +++++++++++++++++- plugins/altimate-code/types/index.d.ts | 11 +- 3 files changed, 425 insertions(+), 11 deletions(-) create mode 100644 plugins/altimate-code/hooks/features/cost.test.tsx diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx new file mode 100644 index 00000000..e0b519d1 --- /dev/null +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -0,0 +1,194 @@ +import { expect, mock, test } from 'claude-code/testing' + +import { formatBytes, inlineSql } from './cost' + +const ROOT = '/repo' +const GIB = 1024 ** 3 + +type Options = { + /** What dbt_cost_estimate answers for a model or SQL, by model name or the SQL text. */ + answers?: Record | 'unknown-tool'> + /** The adapter's answer for everything else. */ + fallback?: Record +} + +/** The session beneath the plugin, a CLI whose dbt_cost_estimate is scripted, and a Bash tool that records what ran. */ +async function start($: any, on: any, options: Options = {}) { + const clock = mock.clock(on) + const estimates: string[] = [] + const ran: string[] = [] + const statuses: (string | undefined)[] = [] + on('command.register', (_: unknown, e: { name: string }) => ({ value: { command: e.name } })) + on('turn.start', (_: unknown, e: { turnId: string }) => ({ turnId: e.turnId })) + on('session.end', () => ({ sessionId: 'test' })) + on('turn.complete', (_: unknown, e: { answer: string }) => ({ text: e.answer })) + on('session.start', (_: unknown, e: { cwd: string }) => ({ cwd: e.cwd })) + on('session.root', () => ({ value: ROOT })) + on('ui.log', () => ({ value: undefined })) + on('ui.status', (_: unknown, e: { text?: string }) => { + statuses.push(e.text) + return { value: undefined } + }) + on('ui.render', ($$: any, e: any) => { + const { Box } = $$.ui.resolve(e) + return + }) + on('fs.exists', () => ({ value: false })) + on('process.run', (_: unknown, e: { argv: readonly string[] }) => { + const [, command, , tool] = e.argv + if (command !== 'tool') return { value: { exitCode: 1, stdout: '', stderr: 'not this test' } } + expect(tool).toBe('dbt_cost_estimate') + // The adapter starts the project's dbt: the call must carry write permission. + expect(e.argv).toContain('--allow-write') + const args = JSON.parse(String(e.argv[e.argv.indexOf('--args') + 1] ?? '{}')) + const key = String(args.model ?? args.sql) + estimates.push(key) + const answer = options.answers?.[key] ?? options.fallback + if (answer === 'unknown-tool') { + return { value: { exitCode: 1, stdout: JSON.stringify({ status: 'error', output: `Unknown tool: ${tool}. Run \`altimate-code tool list\` to see the available tools.`, metadata: {} }), stderr: '' } } + } + return { value: { exitCode: 0, stdout: JSON.stringify({ status: 'ok', output: '', metadata: answer ?? { success: false, error: 'no answer scripted' } }), stderr: '' } } + }) + // The Bash tool itself, beneath the plugin. + on('tool.call', (_: unknown, e: { tool: string; command?: string }) => { + if (e.tool === 'Bash') ran.push(String(e.command)) + return { result: { text: 'ok', isError: false } } + }) + await $.session.start({ cwd: ROOT, surface: 'terminal', isInteractive: true }) + await clock.settle() + return { clock, estimates, ran, statuses } +} + +const bq = (bytes: number, display: string) => ({ success: true, supported: true, adapter: 'bigquery', bytes, display }) +const OVER = bq(20 * GIB, '20.0 GiB') +const UNDER = bq(2 * GIB, '2.0 GiB') + +const bash = (command: string) => ({ tool: 'Bash' as const, command }) + +test('a model over the limit is refused with its estimate, and the command never runs', async ($, on) => { + const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } }) + const result: any = await $.tool.call(bash('dbt run --select orders')) + await clock.settle() + + expect(estimates).toEqual(['orders']) + expect(ran).toEqual([]) + expect(result.deny).toBe('≈ 20.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan.') +}) + +test('a model under the limit runs, with the estimate in a line under the row', async ($, on) => { + const { clock, ran } = await start($, on, { answers: { orders: UNDER } }) + const result: any = await $.tool.call(bash('dbt build -s orders')) + await clock.settle() + + expect(ran).toEqual(['dbt build -s orders']) + expect(result.context).toEqual(['cost · orders would scan 2.0 GiB']) +}) + +test('dbt show --inline is estimated from its SQL', async ($, on) => { + const { clock, estimates } = await start($, on, { answers: { 'select * from big': OVER } }) + const result: any = await $.tool.call(bash(`dbt show --inline "select * from big"`)) + await clock.settle() + + expect(estimates).toEqual(['select * from big']) + expect(result.deny).toContain('20.0 GiB') +}) + +test('/allow-scan lets the next held command through once, then the one after is held again', async ($, on) => { + const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } }) + expect((await $.tool.call(bash('dbt run -s orders')) as any).deny).toBeDefined() + + const allowed = await $.command.run({ command: 'allow-scan', args: '' } as any) + expect(allowed.text).toContain('runs once') + const through: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(through.deny).toBeUndefined() + expect(through.context).toEqual(['cost · orders would scan 20.0 GiB, over the 10.0 GiB limit: allowed once']) + expect(ran).toEqual(['dbt run -s orders']) + + expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined() + expect(estimates).toHaveLength(3) +}) + +test('a selection that is not one plain model passes, saying there is no estimate, and asks nothing', async ($, on) => { + const { clock, estimates, ran } = await start($, on) + for (const [command, why] of [ + ['dbt run', 'no model named'], + ['dbt build -s +orders', 'graph, tag, path or package selector'], + ['dbt run -s tag:nightly', 'graph, tag, path or package selector'], + ['dbt run -s a b', 'several selectors'], + ] as const) { + const result: any = await $.tool.call(bash(command)) + expect(result.deny).toBeUndefined() + expect(result.context[0]).toContain('cost · no estimate for this selection') + expect(result.context[0]).toContain(why) + } + await clock.settle() + expect(estimates).toEqual([]) + expect(ran).toHaveLength(4) +}) + +test('commands that scan nothing are not looked at', async ($, on) => { + const { clock, estimates, ran } = await start($, on) + for (const command of ['dbt test -s orders', 'dbt compile -s orders', 'ls', 'git status']) await $.tool.call(bash(command)) + await clock.settle() + expect(estimates).toEqual([]) + expect(ran).toHaveLength(4) +}) + +test('another warehouse is told once, never held, and not asked again', async ($, on) => { + const { clock, estimates, ran } = await start($, on, { fallback: { success: true, supported: false, adapter: 'snowflake' } }) + const first: any = await $.tool.call(bash('dbt run -s orders')) + const second: any = await $.tool.call(bash('dbt run -s customers')) + await clock.settle() + + expect(first.deny).toBeUndefined() + expect(first.context).toEqual(['cost · no estimate on snowflake: only BigQuery has a dry run']) + expect(second.deny).toBeUndefined() + expect(estimates).toEqual(['orders']) + expect(ran).toEqual(['dbt run -s orders', 'dbt run -s customers']) +}) + +test('an altimate-code without the tool shows one line saying what is needed, and the command runs', async ($, on) => { + const { clock, ran } = await start($, on, { answers: { orders: 'unknown-tool' } }) + const result: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + + expect(ran).toEqual(['dbt run -s orders']) + expect(result.context).toHaveLength(1) + expect(result.context[0]).toContain('needs a newer altimate-code') +}) + +test('a dry run that failed passes the command with the reason', async ($, on) => { + const { clock, ran } = await start($, on, { answers: { orders: { success: false, error: 'Access Denied: BigQuery job' } } }) + const result: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + + expect(ran).toEqual(['dbt run -s orders']) + expect(result.context).toEqual(['cost · no estimate for orders: Access Denied: BigQuery job']) +}) + +test('/scan-cost estimates a model on demand and says how it stands against the limit', async ($, on) => { + const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER, customers: UNDER } }) + expect((await $.command.run({ command: 'scan-cost', args: 'orders' } as any)).text).toBe( + 'orders would scan 20.0 GiB, over the 10.0 GiB limit: a dbt run of it is held until /allow-scan.', + ) + expect((await $.command.run({ command: 'scan-cost', args: 'customers' } as any)).text).toBe('customers would scan 2.0 GiB, within the 10.0 GiB limit.') + expect((await $.command.run({ command: 'scan-cost', args: '' } as any)).text).toContain('Last estimate: customers') + await clock.settle() + expect(estimates).toEqual(['orders', 'customers']) + expect(ran).toEqual([]) +}) + +test('inlineSql reads the query as the shell would', () => { + expect(inlineSql(`dbt show --inline "select 'a' as x"`)).toBe(`select 'a' as x`) + expect(inlineSql(`dbt show --inline='select 1'`)).toBe('select 1') + expect(inlineSql(`dbt show --inline select\\ 1 --limit 5`)).toBe('select 1') + expect(inlineSql('dbt show -s orders')).toBeNull() +}) + +test('formatBytes writes the units the dry run does', () => { + expect(formatBytes(512)).toBe('512.0 Bytes') + expect(formatBytes(1536)).toBe('1.5 KiB') + expect(formatBytes(10 * GIB)).toBe('10.0 GiB') + expect(formatBytes(1024 ** 5)).toBe('1.0 PiB') +}) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 4a4d0708..8201a552 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -1,20 +1,75 @@ // Cost check: BigQuery scans over the limit are held until allowed. // -// The plugin calls each function below at its moment, in the order features/index.ts fixes; one with -// nothing to do stays a no-op. This feature's own hooks (its commands and panes, each under a matcher -// no other part uses) go in `register`. The events the whole plugin shares (session start and end, -// turns, Bash and file tool calls, the band) come through the other functions, since a plugin hooks -// each of those once. The status-line part is set with `setStatusPart($, 'cost', text)`. +// Before a `dbt run`, `dbt build` or `dbt show` Claude runs, the gate asks altimate-code's +// dbt_cost_estimate (a BigQuery dry run) what the query would scan. Over `maxScanBytes` the command is +// refused with the estimate, and Other +// warehouses have no dry run: the first answer says so, and nothing is estimated or held after that. +// Only what names its query is estimated: `dbt show --inline ` and a single plain model name +// (`-s orders`); any other selection runs as it is, with one line saying so under the Bash row. +import { atom, read, update } from 'claude-code' import type { Args, EngineInterface, EventResult, On, RenderElement, ToolCallResult } from 'claude-code' +import { runTool } from '../altimate-cli' +import { parseDbtCommand, type DbtInvocation } from '../dbt-command' +import { setStatusPart } from '../status-line' import type { BashCall, ContextLines, EditedFile, FileCall } from '../tool-chain' +import type { CostState } from '../../types' import type { BandUi, FeatureContext } from './index' +/** Used when `maxScanBytes` is missing from the plugin's options: 10 GiB, as plugin.json's default. */ +const DEFAULT_MAX_SCAN_BYTES = 10 * 1024 ** 3 +/** The adapter may have to start (dbt deps, a parse) for the first estimate. */ +const ESTIMATE_BUDGET_MS = 120_000 +/** The dbt subcommands that run SQL a person pays for. */ +const SCANNING = new Set(['run', 'build', 'show']) +/** A selector that is one plain model name: no graph operator, tag, path, package or wildcard. */ +const PLAIN_MODEL = /^[A-Za-z_][A-Za-z0-9_]*$/ +/** What the CLI answers for a tool it doesn't have (altimate-code's tool-cli runner). */ +const UNKNOWN_TOOL = /Unknown tool/i +/** The altimate-code that has dbt_cost_estimate; changing it is the one edit a release needs. */ +const NEEDED_VERSION = 'a newer altimate-code (the release with dbt_cost_estimate)' + +const costAtom = atom({ plugin: 'altimate-code', key: 'cost' } as const, null as CostState | null) + +const FRESH: CostState = { unsupportedAdapter: null, lastEstimate: null, held: null, allowOnce: false } + +/** The limit in force; set by `register` from the plugin's options. 0 never holds. */ +let limitBytes = DEFAULT_MAX_SCAN_BYTES +/** The lines to show under each estimated command's Bash row, by command. Taken by bashAfter. */ +const notes = new Map() + /** Adds this feature's own hooks. */ -export function register(on: On, context: FeatureContext) {} +export function register(on: On, context: FeatureContext) { + const configured = Number((context.options as Record | undefined)?.maxScanBytes) + limitBytes = Number.isFinite(configured) && configured >= 0 ? configured : DEFAULT_MAX_SCAN_BYTES + + on('command.run', { command: 'allow-scan' }, async $ => { + await update($, costAtom, prev => ({ ...(prev ?? FRESH), allowOnce: true })) + return { text: 'The next dbt command held for its scan size runs once; the one after is held again.' } + }) + + on('command.run', { command: 'scan-cost' }, async ($, e) => { + const target = e.args.trim() + if (!target) { + const last = (await read($, costAtom))?.lastEstimate + return { text: last ? `Last estimate: ${last.target} would scan ${last.display}. Run /scan-cost for another.` : 'Run /scan-cost to estimate the scan of a model.' } + } + const answer = await estimate($, { model: target }) + if (answer.kind === 'bytes') { + const state = await rememberEstimate($, target, answer.bytes, answer.display) + return { text: `${target} would scan ${answer.display}${verdict(answer.bytes, state)}` } + } + return { text: answer.kind === 'unsupported' ? `No estimate: ${answer.adapter} has no dry run (only BigQuery has).` : `No estimate: ${answer.reason}` } + }) +} /** After the session started: the place to register commands. */ -export async function sessionStart($: EngineInterface, e: Args<'session.start'>) {} +export async function sessionStart($: EngineInterface, e: Args<'session.start'>) { + await update($, costAtom, () => ({ ...FRESH })) + await setStatusPart($, 'cost', null) + await $.command.register({ name: 'allow-scan', description: 'Let the next dbt command held for its BigQuery scan size run, once' }) + await $.command.register({ name: 'scan-cost', description: 'Estimate the BigQuery scan of a dbt model before running it', argumentHint: '' }) +} export async function turnStart($: EngineInterface, e: Args<'turn.start'>) {} @@ -23,9 +78,11 @@ export async function turnComplete($: EngineInterface, e: Args<'turn.complete'>, export async function sessionEnd($: EngineInterface, e: Args<'session.end'>) {} -/** This feature's line in the band, under the lineage line; null when there is nothing to say. */ +/** This feature's line in the band: the command held, until it is allowed or something else runs. */ export async function bandLine($: EngineInterface, ui: BandUi): Promise { - return null + const held = (await read($, costAtom))?.held + if (!held) return null + return {`⛔ held: ${held.target} would scan ${held.display} (limit ${formatBytes(limitBytes)}) · /allow-scan`} } /** The command to run in place of `e.command`; null keeps it. */ @@ -35,10 +92,63 @@ export async function bashRewrite($: EngineInterface, e: BashCall): Promise { + notes.delete(e.command) + if (limitBytes <= 0) return null + const invocations = parseDbtCommand(e.command).filter(i => i.subcommand !== null && SCANNING.has(i.subcommand)) + if (invocations.length === 0) return null + const state = (await read($, costAtom)) ?? FRESH + // A warehouse with no dry run was found out already: the command is never held, and nothing is asked again. + if (state.unsupportedAdapter) return null + + const lines: string[] = [] + let allowed = state.allowOnce + for (const invocation of invocations) { + const target = targetOf(e.command, invocation) + if (!target.model && target.sql === undefined) { + lines.push(`cost · no estimate for this selection (${target.why})`) + continue + } + const label = target.model ?? 'the inline query' + const answer = await estimate($, target.model ? { model: target.model } : { sql: target.sql }) + if (answer.kind === 'unsupported') { + await update($, costAtom, prev => ({ ...(prev ?? FRESH), unsupportedAdapter: answer.adapter })) + lines.push(`cost · no estimate on ${answer.adapter}: only BigQuery has a dry run`) + break + } + if (answer.kind === 'none') { + lines.push(`cost · no estimate for ${label}: ${answer.reason}`) + continue + } + await update($, costAtom, prev => ({ ...(prev ?? FRESH), lastEstimate: { target: label, bytes: answer.bytes, display: answer.display } })) + await setStatusPart($, 'cost', `scan ≈ ${answer.display}`) + if (answer.bytes <= limitBytes) { + lines.push(`cost · ${label} would scan ${answer.display}`) + continue + } + if (allowed) { + allowed = false + await update($, costAtom, prev => ({ ...(prev ?? FRESH), allowOnce: false, held: null })) + lines.push(`cost · ${label} would scan ${answer.display}, over the ${formatBytes(limitBytes)} limit: allowed once`) + continue + } + await update($, costAtom, prev => ({ ...(prev ?? FRESH), held: { command: e.command, target: label, bytes: answer.bytes, display: answer.display } })) + await setStatusPart($, 'cost', `scan held ≈ ${answer.display}`) + return { + deny: `≈ ${answer.display} would be scanned, over the ${formatBytes(limitBytes)} limit. Narrow the query, or ask the user to run /allow-scan.`, + } + } + // Nothing held: an earlier hold is over, as the person has moved on or allowed it. + await update($, costAtom, prev => (prev?.held ? { ...prev, held: null } : prev)) + if (lines.length > 0) notes.set(e.command, lines) return null } -export async function bashAfter($: EngineInterface, e: BashCall, result: ToolCallResult): Promise {} +/** What the gate said about the command, under its Bash row. */ +export async function bashAfter($: EngineInterface, e: BashCall, result: ToolCallResult): Promise { + const lines = notes.get(e.command) + notes.delete(e.command) + return lines +} /** `file.before` holds the text from before the edit only when `editReadsBefore` is true. */ export async function editAfter($: EngineInterface, e: FileCall, result: ToolCallResult, file: EditedFile): Promise {} @@ -47,3 +157,104 @@ export async function readOrEditAfter($: EngineInterface, e: FileCall, result: T /** Whether `editAfter` needs the file's text from before the edit (one extra read per edit). */ export const editReadsBefore = false + +type Target = { model?: string; sql?: string; why: string } + +/** What a scanning invocation names to estimate: its inline SQL, or one plain model; else why not. */ +function targetOf(command: string, invocation: DbtInvocation): Target { + if (invocation.subcommand === 'show') { + const inline = inlineSql(command.slice(invocation.start, invocation.end)) + if (inline !== null) return inline.trim() ? { sql: inline, why: '' } : { why: 'empty inline query' } + } + const [only, ...rest] = invocation.select + if (only === undefined) return { why: 'no model named; selection resolves with dbt ls' } + if (rest.length > 0) return { why: 'several selectors' } + if (!PLAIN_MODEL.test(only)) return { why: `${only} is a graph, tag, path or package selector` } + return { model: only, why: '' } +} + +/** The SQL of `--inline` in a dbt command's text, unquoted as the shell would; null when there is none. */ +export function inlineSql(text: string): string | null { + const words = shellWords(text) + for (let i = 0; i < words.length; i++) { + const word = words[i]! + if (word === '--inline') return words[i + 1] ?? null + if (word.startsWith('--inline=')) return word.slice('--inline='.length) + } + return null +} + +/** The words of a command's text with their quotes and backslashes resolved. */ +function shellWords(text: string): string[] { + const words: string[] = [] + let word = '' + let inWord = false + let quote: '"' | "'" | null = null + for (let i = 0; i < text.length; i++) { + const c = text[i]! + if (quote) { + if (c === quote) quote = null + else if (c === '\\' && quote === '"' && i + 1 < text.length && '"\\$`'.includes(text[i + 1]!)) word += text[++i] + else word += c + } else if (c === '"' || c === "'") { + quote = c + inWord = true + } else if (c === '\\' && i + 1 < text.length) { + word += text[++i] + inWord = true + } else if (/\s/.test(c)) { + if (inWord) words.push(word) + word = '' + inWord = false + } else { + word += c + inWord = true + } + } + if (inWord) words.push(word) + return words +} + +type Answer = { kind: 'bytes'; bytes: number; display: string } | { kind: 'unsupported'; adapter: string } | { kind: 'none'; reason: string } + +/** Asks altimate-code for the scan of a model or SQL; never throws: a failure is `none` with why. */ +async function estimate($: EngineInterface, args: { model?: string; sql?: string }): Promise { + try { + const until = (await $.clock.now()) + ESTIMATE_BUDGET_MS + const run = await runTool($, 'dbt_cost_estimate', args, { write: true, until }) + if (!run.ok && UNKNOWN_TOOL.test(run.text)) return { kind: 'none', reason: `this altimate-code has no cost estimate: it needs ${NEEDED_VERSION}` } + const data = run.metadata as { supported?: unknown; adapter?: unknown; bytes?: unknown; display?: unknown; error?: unknown } | null + if (data?.supported === false) return { kind: 'unsupported', adapter: typeof data.adapter === 'string' ? data.adapter : 'this warehouse' } + if (data?.supported === true && typeof data.bytes === 'number' && Number.isFinite(data.bytes)) { + return { kind: 'bytes', bytes: data.bytes, display: typeof data.display === 'string' ? data.display : formatBytes(data.bytes) } + } + const why = typeof data?.error === 'string' ? data.error : run.text.trim().split('\n')[0] || 'altimate-code gave no estimate' + return { kind: 'none', reason: why } + } catch (error) { + return { kind: 'none', reason: error instanceof Error ? error.message : String(error) } + } +} + +async function rememberEstimate($: EngineInterface, target: string, bytes: number, display: string): Promise { + await update($, costAtom, prev => ({ ...(prev ?? FRESH), lastEstimate: { target, bytes, display } })) + await setStatusPart($, 'cost', `scan ≈ ${display}`) + return (await read($, costAtom)) ?? FRESH +} + +/** What an estimate means against the limit, as a sentence tail for /cost. */ +function verdict(bytes: number, state: CostState): string { + if (limitBytes <= 0) return '.' + return bytes > limitBytes ? `, over the ${formatBytes(limitBytes)} limit: a dbt run of it is held until /allow-scan.` : `, within the ${formatBytes(limitBytes)} limit.` +} + +/** Bytes in the units BigQuery's dry run writes them in: "4.2 TiB". */ +export function formatBytes(bytes: number): string { + const units = ['Bytes', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB'] + let n = bytes + let i = 0 + while (Math.abs(n) >= 1024 && i < units.length - 1) { + n /= 1024 + i++ + } + return `${n.toFixed(1)} ${units[i]}` +} diff --git a/plugins/altimate-code/types/index.d.ts b/plugins/altimate-code/types/index.d.ts index 93c272e6..9e4d806f 100644 --- a/plugins/altimate-code/types/index.d.ts +++ b/plugins/altimate-code/types/index.d.ts @@ -204,7 +204,16 @@ export interface CommentsState {} // Cost check: the last scan estimate and any scan allowed once. // Filled in by that feature alone (hooks/features/); the other features never read or write it. // --------------------------------------------------------------------------------------------------- -export interface CostState {} +export interface CostState { + /** The warehouse that has no dry run (any but BigQuery), once the tool said so: nothing is estimated after that. */ + unsupportedAdapter: string | null + /** The newest estimate: what was estimated, in bytes, as the dry run wrote it. */ + lastEstimate: { target: string; bytes: number; display: string } | null + /** The command held for being over the limit, until it is allowed or a later command is not held. */ + held: { command: string; target: string; bytes: number; display: string } | null + /** /allow-scan was given: the next command that would be held runs. */ + allowOnce: boolean +} // --------------------------------------------------------------------------------------------------- // Project health: the health check issues on the changed models. From 70da5a8e2653feba1fee9cc238939dd052fc65a4 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Fri, 13 Nov 2026 16:45:05 +0530 Subject: [PATCH 02/56] fix: name the on-demand estimate command in its comment Co-Authored-By: Claude Opus 5.5 --- plugins/altimate-code/hooks/features/cost.tsx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 8201a552..918a2948 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -241,7 +241,7 @@ async function rememberEstimate($: EngineInterface, target: string, bytes: numbe return (await read($, costAtom)) ?? FRESH } -/** What an estimate means against the limit, as a sentence tail for /cost. */ +/** What an estimate means against the limit, as a sentence tail for /scan-cost. */ function verdict(bytes: number, state: CostState): string { if (limitBytes <= 0) return '.' return bytes > limitBytes ? `, over the ${formatBytes(limitBytes)} limit: a dbt run of it is held until /allow-scan.` : `, within the ${formatBytes(limitBytes)} limit.` From dc4b8c38ad61d20b37aea129495737df2d99b283 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Fri, 13 Nov 2026 17:00:44 +0530 Subject: [PATCH 03/56] test: the Bash pass-through test allows the cost note now that cost is built Co-Authored-By: Claude Sonnet 5.5 --- plugins/altimate-code/hooks/tool-chain.test.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/plugins/altimate-code/hooks/tool-chain.test.ts b/plugins/altimate-code/hooks/tool-chain.test.ts index 0f509d36..b1595785 100644 --- a/plugins/altimate-code/hooks/tool-chain.test.ts +++ b/plugins/altimate-code/hooks/tool-chain.test.ts @@ -72,7 +72,7 @@ test('without context lines the result is passed on as it came; the features run expect(FEATURE_IDS).toEqual(['runs', 'defer', 'toModel', 'comments', 'cost', 'health', 'sqlGraph', 'docs', 'cteProfile']) }) -test('through the plugin, a Bash call passes unchanged while every feature is a stub', async ($, on) => { +test('through the plugin, a Bash call passes unchanged, and only the features that are built add to its context', async ($, on) => { const calls: any[] = [] on('tool.call', (_: unknown, e: any) => { calls.push(e) @@ -80,5 +80,5 @@ test('through the plugin, a Bash call passes unchanged while every feature is a }) const bash: any = await $.tool.call({ tool: 'Bash', command: 'dbt run -s orders' }) expect(calls.map(one => one.command ?? one.tool)).toEqual(['dbt run -s orders']) - expect(bash.context ?? []).toEqual([]) + expect((bash.context ?? []).filter((line: string) => !line.startsWith('cost · '))).toEqual([]) }) From 90dc2993544d1e15549a79da282fc5feb5e91cef Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Fri, 13 Nov 2026 17:15:08 +0530 Subject: [PATCH 04/56] fix: hold a command whole, tie /allow-scan to the held command, skip commands that set their own target Co-Authored-By: Claude Sonnet 5.5 --- .../hooks/features/cost.test.tsx | 88 ++++++++++++- plugins/altimate-code/hooks/features/cost.tsx | 120 ++++++++++++------ 2 files changed, 168 insertions(+), 40 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index e0b519d1..a187754a 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -59,7 +59,7 @@ async function start($: any, on: any, options: Options = {}) { return { clock, estimates, ran, statuses } } -const bq = (bytes: number, display: string) => ({ success: true, supported: true, adapter: 'bigquery', bytes, display }) +const bq = (bytes: number, display: string, maxBytes = bytes) => ({ success: true, supported: true, adapter: 'bigquery', bytes, maxBytes, display }) const OVER = bq(20 * GIB, '20.0 GiB') const UNDER = bq(2 * GIB, '2.0 GiB') @@ -179,10 +179,96 @@ test('/scan-cost estimates a model on demand and says how it stands against the expect(ran).toEqual([]) }) +test('a command naming two models over the limit is held whole, and one /allow-scan lets all of it through once', async ($, on) => { + const { clock, ran } = await start($, on, { answers: { orders: OVER, customers: bq(30 * GIB, '30.0 GiB') } }) + const command = 'dbt run -s orders && dbt run -s customers' + expect(((await $.tool.call(bash(command))) as any).deny).toContain('30.0 GiB') + await $.command.run({ command: 'allow-scan', args: '' } as any) + const through: any = await $.tool.call(bash(command)) + await clock.settle() + + expect(through.deny).toBeUndefined() + expect(through.context).toEqual([ + 'cost · orders would scan 20.0 GiB, over the 10.0 GiB limit: allowed once', + 'cost · customers would scan 30.0 GiB, over the 10.0 GiB limit: allowed once', + ]) + expect(ran).toEqual([command]) + expect(((await $.tool.call(bash(command))) as any).deny).toBeDefined() +}) + +test('/allow-scan with nothing held allows nothing', async ($, on) => { + const { clock } = await start($, on, { answers: { orders: OVER } }) + expect((await $.command.run({ command: 'allow-scan', args: '' } as any)).text).toContain('Nothing is held') + expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined() + await clock.settle() +}) + +test('the allowance is for the command that was held: another over-limit command is held, and the allowance is gone', async ($, on) => { + const { clock, ran } = await start($, on, { answers: { orders: OVER, customers: OVER } }) + expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined() + await $.command.run({ command: 'allow-scan', args: '' } as any) + + expect(((await $.tool.call(bash('dbt run -s customers'))) as any).deny).toBeDefined() + expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined() + await clock.settle() + expect(ran).toEqual([]) +}) + +test('an estimate whose rounded size is within the limit but whose upper bound is over it is held', async ($, on) => { + const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, '10.0 GiB', 10 * GIB + 52 * 1024 ** 2) } }) + expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toContain('10.0 GiB') + await clock.settle() +}) + +test('a command that sets its own target, defer state, vars or project is not estimated', async ($, on) => { + const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } }) + const commands = [ + 'dbt run -s orders --target prod', + 'dbt run -s orders --defer --state prod-run', + `dbt run -s orders --vars '{a: 1}'`, + 'dbt run -s orders --project-dir other', + 'DBT_PROFILES_DIR=ci dbt run -s orders', + 'cd other && dbt run -s orders', + ] + for (const command of commands) { + const result: any = await $.tool.call(bash(command)) + expect(result.deny).toBeUndefined() + expect(result.context[0]).toContain('it sets its own target, defer state, vars or project') + } + await clock.settle() + expect(estimates).toEqual([]) + expect(ran).toEqual(commands) +}) + +test('dbt show --inline with its SQL on the next line after a backslash is estimated', async ($, on) => { + const { clock, estimates } = await start($, on, { answers: { 'select * from big': OVER } }) + const result: any = await $.tool.call(bash(`dbt show --inline \\\n 'select * from big'`)) + await clock.settle() + expect(estimates).toEqual(['select * from big']) + expect(result.deny).toContain('20.0 GiB') +}) + +test('letting a later command through clears the hold from the status line', async ($, on) => { + const { clock, statuses } = await start($, on, { answers: { orders: OVER } }) + await $.tool.call(bash('dbt run -s orders')) + await $.tool.call(bash('dbt run -s +orders')) + await clock.settle() + expect(statuses.filter(Boolean).at(-1)).not.toContain('held') +}) + +test('two calls of the same command each get their own lines under the row', async ($, on) => { + const { clock } = await start($, on, { answers: { orders: UNDER } }) + const [first, second]: any[] = await Promise.all([$.tool.call(bash('dbt run -s orders')), $.tool.call(bash('dbt run -s orders'))]) + await clock.settle() + expect(first.context).toEqual(['cost · orders would scan 2.0 GiB']) + expect(second.context).toEqual(['cost · orders would scan 2.0 GiB']) +}) + test('inlineSql reads the query as the shell would', () => { expect(inlineSql(`dbt show --inline "select 'a' as x"`)).toBe(`select 'a' as x`) expect(inlineSql(`dbt show --inline='select 1'`)).toBe('select 1') expect(inlineSql(`dbt show --inline select\\ 1 --limit 5`)).toBe('select 1') + expect(inlineSql(`dbt show --inline \\\n 'select 1'`)).toBe('select 1') expect(inlineSql('dbt show -s orders')).toBeNull() }) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index dd428713..b3184634 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -2,10 +2,11 @@ // // Before a `dbt run`, `dbt build` or `dbt show` Claude runs, the gate asks altimate-code's // dbt_cost_estimate (a BigQuery dry run) what the query would scan. Over `maxScanBytes` the command is -// refused with the estimate, and Other -// warehouses have no dry run: the first answer says so, and nothing is estimated or held after that. +// refused with the estimate until the user runs /allow-scan, which lets that same command through once. +// Other warehouses have no dry run: the first answer says so, and nothing is estimated or held after that. // Only what names its query is estimated: `dbt show --inline ` and a single plain model name -// (`-s orders`); any other selection runs as it is, with one line saying so under the Bash row. +// (`-s orders`); any other selection, and any command that sets its own target, defer state, vars or +// project, runs as it is, with one line saying so under the Bash row. import { atom, read, update } from 'claude-code' import type { Args, EngineInterface, EventResult, On, RenderElement, ToolCallResult } from 'claude-code' @@ -35,8 +36,8 @@ const FRESH: CostState = { unsupportedAdapter: null, lastEstimate: null, held: n /** The limit in force; set by `register` from the plugin's options. 0 never holds. */ let limitBytes = DEFAULT_MAX_SCAN_BYTES -/** The lines to show under each estimated command's Bash row, by command. Taken by bashAfter. */ -const notes = new Map() +/** The lines to show under each estimated command's Bash row, per command, oldest first. Taken by bashAfter. */ +const notes = new Map() /** Adds this feature's own hooks. */ export function register(on: On, context: FeatureContext) { @@ -44,8 +45,10 @@ export function register(on: On, context: FeatureContext) { limitBytes = Number.isFinite(configured) && configured >= 0 ? configured : DEFAULT_MAX_SCAN_BYTES on('command.run', { command: 'allow-scan' }, async $ => { + const held = (await read($, costAtom))?.held + if (!held) return { text: 'Nothing is held: no dbt command is waiting on its scan size.' } await update($, costAtom, prev => ({ ...(prev ?? FRESH), allowOnce: true })) - return { text: 'The next dbt command held for its scan size runs once; the one after is held again.' } + return { text: `The held command (${held.target}, ≈ ${held.display}) runs once when Claude runs it again; after that it is held again.` } }) on('command.run', { command: 'scan-cost' }, async ($, e) => { @@ -54,10 +57,10 @@ export function register(on: On, context: FeatureContext) { const last = (await read($, costAtom))?.lastEstimate return { text: last ? `Last estimate: ${last.target} would scan ${last.display}. Run /scan-cost for another.` : 'Run /scan-cost to estimate the scan of a model.' } } - const answer = await estimate($, { model: target }) + const answer = await estimate($, { model: target }, (await $.clock.now()) + ESTIMATE_BUDGET_MS) if (answer.kind === 'bytes') { - const state = await rememberEstimate($, target, answer.bytes, answer.display) - return { text: `${target} would scan ${answer.display}${verdict(answer.bytes, state)}` } + await rememberEstimate($, target, answer.bytes, answer.display) + return { text: `${target} would scan ${answer.display}${verdict(answer.maxBytes)}` } } return { text: answer.kind === 'unsupported' ? `No estimate: ${answer.adapter} has no dry run (only BigQuery has).` : `No estimate: ${answer.reason}` } }) @@ -96,7 +99,6 @@ export async function bashRewrite($: EngineInterface, e: BashCall): Promise { - notes.delete(e.command) if (limitBytes <= 0) return null const invocations = parseDbtCommand(e.command).filter(i => i.subcommand !== null && SCANNING.has(i.subcommand)) if (invocations.length === 0) return null @@ -105,7 +107,9 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: if (state.unsupportedAdapter) return null const lines: string[] = [] - let allowed = state.allowOnce + const over: { label: string; bytes: number; display: string }[] = [] + // One budget for the whole command, however many queries it names. + const until = (await $.clock.now()) + ESTIMATE_BUDGET_MS for (const invocation of invocations) { const target = targetOf(e.command, invocation) if (!target.model && target.sql === undefined) { @@ -113,7 +117,7 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: continue } const label = target.model ?? 'the inline query' - const answer = await estimate($, target.model ? { model: target.model } : { sql: target.sql }) + const answer = await estimate($, target.model ? { model: target.model } : { sql: target.sql }, until) if (answer.kind === 'unsupported') { await update($, costAtom, prev => ({ ...(prev ?? FRESH), unsupportedAdapter: answer.adapter })) lines.push(`cost · no estimate on ${answer.adapter}: only BigQuery has a dry run`) @@ -125,32 +129,51 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: } await update($, costAtom, prev => ({ ...(prev ?? FRESH), lastEstimate: { target: label, bytes: answer.bytes, display: answer.display } })) await setStatusPart($, 'cost', `scan ≈ ${answer.display}`) - if (answer.bytes <= limitBytes) { - lines.push(`cost · ${label} would scan ${answer.display}`) - continue - } - if (allowed) { - allowed = false - await update($, costAtom, prev => ({ ...(prev ?? FRESH), allowOnce: false, held: null })) - lines.push(`cost · ${label} would scan ${answer.display}, over the ${formatBytes(limitBytes)} limit: allowed once`) - continue + if (answer.maxBytes <= limitBytes) lines.push(`cost · ${label} would scan ${answer.display}`) + else over.push({ label, bytes: answer.maxBytes, display: answer.display }) + } + + if (over.length > 0) { + const worst = over.reduce((a, b) => (b.bytes > a.bytes ? b : a)) + // The allowance is spent in one step, and only by the command that was held for it. + let granted = false + await update($, costAtom, prev => { + const current = prev ?? FRESH + granted = current.allowOnce && current.held?.command === e.command + return granted + ? { ...current, allowOnce: false, held: null } + : { ...current, allowOnce: false, held: { command: e.command, target: worst.label, bytes: worst.bytes, display: worst.display } } + }) + if (granted) { + for (const one of over) lines.push(`cost · ${one.label} would scan ${one.display}, over the ${formatBytes(limitBytes)} limit: allowed once`) + keepNotes(e.command, lines) + return null } - await update($, costAtom, prev => ({ ...(prev ?? FRESH), held: { command: e.command, target: label, bytes: answer.bytes, display: answer.display } })) - await setStatusPart($, 'cost', `scan held ≈ ${answer.display}`) + await setStatusPart($, 'cost', `scan held ≈ ${worst.display}`) return { - deny: `≈ ${answer.display} would be scanned, over the ${formatBytes(limitBytes)} limit. Narrow the query, or ask the user to run /allow-scan.`, + deny: `≈ ${worst.display} would be scanned, over the ${formatBytes(limitBytes)} limit. Narrow the query, or ask the user to run /allow-scan.`, } } - // Nothing held: an earlier hold is over, as the person has moved on or allowed it. - await update($, costAtom, prev => (prev?.held ? { ...prev, held: null } : prev)) - if (lines.length > 0) notes.set(e.command, lines) + // Nothing held: an earlier hold is over, as the person has moved on, and so is its allowance. + if (state.held || state.allowOnce) { + await update($, costAtom, prev => ({ ...(prev ?? FRESH), held: null, allowOnce: false })) + const last = (await read($, costAtom))?.lastEstimate + await setStatusPart($, 'cost', last ? `scan ≈ ${last.display}` : null) + } + keepNotes(e.command, lines) return null } +function keepNotes(command: string, lines: string[]) { + if (lines.length === 0) return + notes.set(command, [...(notes.get(command) ?? []), lines]) +} + /** What the gate said about the command, under its Bash row. */ export async function bashAfter($: EngineInterface, e: BashCall, result: ToolCallResult): Promise { - const lines = notes.get(e.command) - notes.delete(e.command) + const queue = notes.get(e.command) + const lines = queue?.shift() + if (queue?.length === 0) notes.delete(e.command) return lines } @@ -166,8 +189,22 @@ type Target = { model?: string; sql?: string; why: string } /** What a scanning invocation names to estimate: its inline SQL, or one plain model; else why not. */ function targetOf(command: string, invocation: DbtInvocation): Target { + // The estimate runs in the session's project against its default target: a command that points + // elsewhere would be estimated as something it isn't. + const text = command.slice(invocation.start, invocation.end) + if ( + invocation.target || + invocation.targetPath || + invocation.hasDefer || + invocation.hasState || + /(^|\s)--(vars?|project-dir|profiles-dir|profile)\b/.test(text) || + /\bDBT_(PROJECT_DIR|PROFILES_DIR|PROFILE|VARS)=/.test(text) || + /(^|[;&|(]\s*)cd\s/.test(command.slice(0, invocation.start)) + ) { + return { why: 'it sets its own target, defer state, vars or project' } + } if (invocation.subcommand === 'show') { - const inline = inlineSql(command.slice(invocation.start, invocation.end)) + const inline = inlineSql(text) if (inline !== null) return inline.trim() ? { sql: inline, why: '' } : { why: 'empty inline query' } } const [only, ...rest] = invocation.select @@ -196,6 +233,11 @@ function shellWords(text: string): string[] { let quote: '"' | "'" | null = null for (let i = 0; i < text.length; i++) { const c = text[i]! + // A backslash before a line break joins the lines, in a word or in double quotes. + if (c === '\\' && quote !== "'" && (text[i + 1] === '\n' || (text[i + 1] === '\r' && text[i + 2] === '\n'))) { + i += text[i + 1] === '\n' ? 1 : 2 + continue + } if (quote) { if (c === quote) quote = null else if (c === '\\' && quote === '"' && i + 1 < text.length && '"\\$`'.includes(text[i + 1]!)) word += text[++i] @@ -219,18 +261,19 @@ function shellWords(text: string): string[] { return words } -type Answer = { kind: 'bytes'; bytes: number; display: string } | { kind: 'unsupported'; adapter: string } | { kind: 'none'; reason: string } +type Answer = { kind: 'bytes'; bytes: number; maxBytes: number; display: string } | { kind: 'unsupported'; adapter: string } | { kind: 'none'; reason: string } /** Asks altimate-code for the scan of a model or SQL; never throws: a failure is `none` with why. */ -async function estimate($: EngineInterface, args: { model?: string; sql?: string }): Promise { +async function estimate($: EngineInterface, args: { model?: string; sql?: string }, until: number): Promise { try { - const until = (await $.clock.now()) + ESTIMATE_BUDGET_MS const run = await runTool($, 'dbt_cost_estimate', args, { write: true, until }) if (!run.ok && UNKNOWN_TOOL.test(run.text)) return { kind: 'none', reason: `this altimate-code has no cost estimate: it needs ${NEEDED_VERSION}` } - const data = run.metadata as { supported?: unknown; adapter?: unknown; bytes?: unknown; display?: unknown; error?: unknown } | null + const data = run.metadata as { supported?: unknown; adapter?: unknown; bytes?: unknown; maxBytes?: unknown; display?: unknown; error?: unknown } | null if (data?.supported === false) return { kind: 'unsupported', adapter: typeof data.adapter === 'string' ? data.adapter : 'this warehouse' } if (data?.supported === true && typeof data.bytes === 'number' && Number.isFinite(data.bytes)) { - return { kind: 'bytes', bytes: data.bytes, display: typeof data.display === 'string' ? data.display : formatBytes(data.bytes) } + // The tool's upper bound when it gives one: the display is rounded, and the limit is a hard one. + const maxBytes = typeof data.maxBytes === 'number' && Number.isFinite(data.maxBytes) && data.maxBytes >= data.bytes ? data.maxBytes : data.bytes + return { kind: 'bytes', bytes: data.bytes, maxBytes, display: typeof data.display === 'string' ? data.display : formatBytes(data.bytes) } } const why = typeof data?.error === 'string' ? data.error : run.text.trim().split('\n')[0] || 'altimate-code gave no estimate' return { kind: 'none', reason: why } @@ -239,16 +282,15 @@ async function estimate($: EngineInterface, args: { model?: string; sql?: string } } -async function rememberEstimate($: EngineInterface, target: string, bytes: number, display: string): Promise { +async function rememberEstimate($: EngineInterface, target: string, bytes: number, display: string) { await update($, costAtom, prev => ({ ...(prev ?? FRESH), lastEstimate: { target, bytes, display } })) await setStatusPart($, 'cost', `scan ≈ ${display}`) - return (await read($, costAtom)) ?? FRESH } /** What an estimate means against the limit, as a sentence tail for /scan-cost. */ -function verdict(bytes: number, state: CostState): string { +function verdict(maxBytes: number): string { if (limitBytes <= 0) return '.' - return bytes > limitBytes ? `, over the ${formatBytes(limitBytes)} limit: a dbt run of it is held until /allow-scan.` : `, within the ${formatBytes(limitBytes)} limit.` + return maxBytes > limitBytes ? `, over the ${formatBytes(limitBytes)} limit: a dbt run of it is held until /allow-scan.` : `, within the ${formatBytes(limitBytes)} limit.` } /** Bytes in the units BigQuery's dry run writes them in: "4.2 TiB". */ From 1009d38e6e25556dc69c29d78e22c9b20db53eb2 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Fri, 13 Nov 2026 17:25:19 +0530 Subject: [PATCH 05/56] fix: allow only the hold that was read, keep the latest note per command, skip more commands that change context Co-Authored-By: Claude Sonnet 5.5 --- .../hooks/features/cost.test.tsx | 43 ++++++++++++++--- plugins/altimate-code/hooks/features/cost.tsx | 46 ++++++++++++------- plugins/altimate-code/types/index.d.ts | 4 +- 3 files changed, 67 insertions(+), 26 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index a187754a..355004c8 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -72,7 +72,7 @@ test('a model over the limit is refused with its estimate, and the command never expect(estimates).toEqual(['orders']) expect(ran).toEqual([]) - expect(result.deny).toBe('≈ 20.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan.') + expect(result.deny).toBe('≈ 20.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.') }) test('a model under the limit runs, with the estimate in a line under the row', async ($, on) => { @@ -229,11 +229,16 @@ test('a command that sets its own target, defer state, vars or project is not es 'dbt run -s orders --project-dir other', 'DBT_PROFILES_DIR=ci dbt run -s orders', 'cd other && dbt run -s orders', + ' cd other && dbt run -s orders', + 'export DBT_TARGET=prod; dbt run -s orders', + 'uv run --directory other dbt run -s orders', + "dbt run -s orders --'vars' x", + 'dbt run -s orders --full-refresh', ] for (const command of commands) { const result: any = await $.tool.call(bash(command)) expect(result.deny).toBeUndefined() - expect(result.context[0]).toContain('it sets its own target, defer state, vars or project') + expect(result.context[0]).toContain('it sets its own target, defer state, vars, project or refresh mode') } await clock.settle() expect(estimates).toEqual([]) @@ -256,12 +261,36 @@ test('letting a later command through clears the hold from the status line', asy expect(statuses.filter(Boolean).at(-1)).not.toContain('held') }) -test('two calls of the same command each get their own lines under the row', async ($, on) => { - const { clock } = await start($, on, { answers: { orders: UNDER } }) - const [first, second]: any[] = await Promise.all([$.tool.call(bash('dbt run -s orders')), $.tool.call(bash('dbt run -s orders'))]) +test('the lines under a command are the latest estimate of it, never an earlier one', async ($, on) => { + const answers: Record = { orders: UNDER } + const { clock } = await start($, on, { answers }) + expect(((await $.tool.call(bash('dbt run -s orders'))) as any).context).toEqual(['cost · orders would scan 2.0 GiB']) + answers.orders = bq(3 * GIB, '3.0 GiB') + expect(((await $.tool.call(bash('dbt run -s orders'))) as any).context).toEqual(['cost · orders would scan 3.0 GiB']) await clock.settle() - expect(first.context).toEqual(['cost · orders would scan 2.0 GiB']) - expect(second.context).toEqual(['cost · orders would scan 2.0 GiB']) +}) + +test('/allow-scan allows only the hold it read: a hold replaced meanwhile is not allowed', async ($, on) => { + const { clock, ran } = await start($, on, { answers: { orders: OVER, customers: OVER } }) + expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined() + const allowing = $.command.run({ command: 'allow-scan', args: '' } as any) + expect(((await $.tool.call(bash('dbt run -s customers'))) as any).deny).toBeDefined() + await allowing + await clock.settle() + // Whichever order the two steps took, customers (the later hold) is not allowed by a read of orders. + expect(((await $.tool.call(bash('dbt run -s customers'))) as any).deny).toBeDefined() + expect(ran).toEqual([]) +}) + +test('a non-dbt command in between neither clears the hold nor spends the allowance', async ($, on) => { + const { clock, ran } = await start($, on, { answers: { orders: OVER } }) + await $.tool.call(bash('dbt run -s orders')) + await $.command.run({ command: 'allow-scan', args: '' } as any) + await $.tool.call(bash('ls')) + const through: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(through.deny).toBeUndefined() + expect(ran).toEqual(['ls', 'dbt run -s orders']) }) test('inlineSql reads the query as the shell would', () => { diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index b3184634..7479c101 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -36,8 +36,8 @@ const FRESH: CostState = { unsupportedAdapter: null, lastEstimate: null, held: n /** The limit in force; set by `register` from the plugin's options. 0 never holds. */ let limitBytes = DEFAULT_MAX_SCAN_BYTES -/** The lines to show under each estimated command's Bash row, per command, oldest first. Taken by bashAfter. */ -const notes = new Map() +/** The lines to show under an estimated command's Bash row, by command; each gate pass replaces the last. Taken by bashAfter. */ +const notes = new Map() /** Adds this feature's own hooks. */ export function register(on: On, context: FeatureContext) { @@ -45,10 +45,17 @@ export function register(on: On, context: FeatureContext) { limitBytes = Number.isFinite(configured) && configured >= 0 ? configured : DEFAULT_MAX_SCAN_BYTES on('command.run', { command: 'allow-scan' }, async $ => { + // The allowance is set against the hold it was read from, in the same step: a hold replaced meanwhile is not allowed. const held = (await read($, costAtom))?.held + let allowed = false + await update($, costAtom, prev => { + const current = prev ?? FRESH + allowed = !!held && current.held?.command === held.command + return allowed ? { ...current, allowOnce: true } : current + }) if (!held) return { text: 'Nothing is held: no dbt command is waiting on its scan size.' } - await update($, costAtom, prev => ({ ...(prev ?? FRESH), allowOnce: true })) - return { text: `The held command (${held.target}, ≈ ${held.display}) runs once when Claude runs it again; after that it is held again.` } + if (!allowed) return { text: 'The held command changed meanwhile: run /allow-scan again to allow the one now held.' } + return { text: `Allowed: ${held.target} (≈ ${held.display}) runs once when Claude runs the same command again; after that it is held again.` } }) on('command.run', { command: 'scan-cost' }, async ($, e) => { @@ -68,9 +75,10 @@ export function register(on: On, context: FeatureContext) { /** After the session started: the place to register commands. */ export async function sessionStart($: EngineInterface, e: Args<'session.start'>) { + notes.clear() await update($, costAtom, () => ({ ...FRESH })) await setStatusPart($, 'cost', null) - await $.command.register({ name: 'allow-scan', description: 'Let the next dbt command held for its BigQuery scan size run, once' }) + await $.command.register({ name: 'allow-scan', description: 'Let the dbt command held for its BigQuery scan size run once, when run again unchanged' }) await $.command.register({ name: 'scan-cost', description: 'Estimate the BigQuery scan of a dbt model before running it', argumentHint: '' }) } @@ -82,7 +90,7 @@ export async function turnComplete($: EngineInterface, e: Args<'turn.complete'>, export async function sessionEnd($: EngineInterface, e: Args<'session.end'>) {} -/** This feature's line in the band: the command held, until it is allowed or something else runs. */ +/** This feature's line in the band: the command held, until it is allowed or a later dbt command is not held. */ export async function bandLine($: EngineInterface, ui: BandUi): Promise { const held = (await read($, costAtom))?.held if (!held) return null @@ -149,14 +157,15 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: keepNotes(e.command, lines) return null } + notes.delete(e.command) await setStatusPart($, 'cost', `scan held ≈ ${worst.display}`) return { - deny: `≈ ${worst.display} would be scanned, over the ${formatBytes(limitBytes)} limit. Narrow the query, or ask the user to run /allow-scan.`, + deny: `≈ ${worst.display} would be scanned, over the ${formatBytes(limitBytes)} limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.`, } } // Nothing held: an earlier hold is over, as the person has moved on, and so is its allowance. if (state.held || state.allowOnce) { - await update($, costAtom, prev => ({ ...(prev ?? FRESH), held: null, allowOnce: false })) + await update($, costAtom, prev => (prev?.held || prev?.allowOnce ? { ...prev, held: null, allowOnce: false } : prev)) const last = (await read($, costAtom))?.lastEstimate await setStatusPart($, 'cost', last ? `scan ≈ ${last.display}` : null) } @@ -165,15 +174,14 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: } function keepNotes(command: string, lines: string[]) { - if (lines.length === 0) return - notes.set(command, [...(notes.get(command) ?? []), lines]) + if (lines.length > 0) notes.set(command, lines) + else notes.delete(command) } /** What the gate said about the command, under its Bash row. */ export async function bashAfter($: EngineInterface, e: BashCall, result: ToolCallResult): Promise { - const queue = notes.get(e.command) - const lines = queue?.shift() - if (queue?.length === 0) notes.delete(e.command) + const lines = notes.get(e.command) + notes.delete(e.command) return lines } @@ -192,16 +200,20 @@ function targetOf(command: string, invocation: DbtInvocation): Target { // The estimate runs in the session's project against its default target: a command that points // elsewhere would be estimated as something it isn't. const text = command.slice(invocation.start, invocation.end) + // The flags as the shell reads them: quotes and backslashes inside a flag name don't change it. + const flags = text.replace(/['"\\]/g, '') if ( invocation.target || invocation.targetPath || invocation.hasDefer || invocation.hasState || - /(^|\s)--(vars?|project-dir|profiles-dir|profile)\b/.test(text) || - /\bDBT_(PROJECT_DIR|PROFILES_DIR|PROFILE|VARS)=/.test(text) || - /(^|[;&|(]\s*)cd\s/.test(command.slice(0, invocation.start)) + /(^|\s)--(vars?|project-dir|profiles-dir|profile|full-refresh|directory|project|env-file)\b/.test(flags) || + /(^|\s)(-f|-C)(\s|$)/.test(flags) || + /\bDBT_[A-Z_]*=/.test(flags) || + // What runs before it in the line may move to another project or set the environment. + /(^|[\n;&|({])\s*(cd|pushd|popd|export|env|source|\.|set|unset)\s/.test(command.slice(0, invocation.start)) ) { - return { why: 'it sets its own target, defer state, vars or project' } + return { why: 'it sets its own target, defer state, vars, project or refresh mode' } } if (invocation.subcommand === 'show') { const inline = inlineSql(text) diff --git a/plugins/altimate-code/types/index.d.ts b/plugins/altimate-code/types/index.d.ts index 9e4d806f..c25ed71c 100644 --- a/plugins/altimate-code/types/index.d.ts +++ b/plugins/altimate-code/types/index.d.ts @@ -209,9 +209,9 @@ export interface CostState { unsupportedAdapter: string | null /** The newest estimate: what was estimated, in bytes, as the dry run wrote it. */ lastEstimate: { target: string; bytes: number; display: string } | null - /** The command held for being over the limit, until it is allowed or a later command is not held. */ + /** The command held for being over the limit, until it is allowed or a later dbt command is not held; `bytes` is its scan's upper bound. */ held: { command: string; target: string; bytes: number; display: string } | null - /** /allow-scan was given: the next command that would be held runs. */ + /** /allow-scan was given for the held command: that same command runs once. */ allowOnce: boolean } From f7c547922d9fa428b6d5b685babe2249a68540e4 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Fri, 13 Nov 2026 17:32:46 +0530 Subject: [PATCH 06/56] fix: estimate only a plain dbt call: known-safe flags and nothing but dbt calls before it Co-Authored-By: Claude Sonnet 5.5 --- .../hooks/features/cost.test.tsx | 21 ++++++ plugins/altimate-code/hooks/features/cost.tsx | 70 ++++++++++++++----- 2 files changed, 72 insertions(+), 19 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 355004c8..a420b6cd 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -234,6 +234,10 @@ test('a command that sets its own target, defer state, vars or project is not es 'uv run --directory other dbt run -s orders', "dbt run -s orders --'vars' x", 'dbt run -s orders --full-refresh', + 'dbt run -s orders --full-\\\nrefresh', + 'if true; then cd other; fi; dbt run -s orders', + 'dbt --profiles-dir ci run -s orders', + 'FOO=1 dbt run -s orders', ] for (const command of commands) { const result: any = await $.tool.call(bash(command)) @@ -307,3 +311,20 @@ test('formatBytes writes the units the dry run does', () => { expect(formatBytes(10 * GIB)).toBe('10.0 GiB') expect(formatBytes(1024 ** 5)).toBe('1.0 PiB') }) + +test('what leaves the query alone is still estimated: other dbt calls before it, thread and limit flags, a launcher', async ($, on) => { + const { clock, estimates } = await start($, on, { answers: { orders: UNDER, 'select 1': UNDER } }) + for (const command of ['dbt deps && dbt run -s orders --threads 4', 'uv run dbt build --select orders --fail-fast', `dbt show --inline "select 1" --limit 5`]) { + expect(((await $.tool.call(bash(command))) as any).context[0]).toContain('would scan 2.0 GiB') + } + await clock.settle() + expect(estimates).toEqual(['orders', 'orders', 'select 1']) +}) + +test('a very long run of blank lines before the command costs no noticeable time', async ($, on) => { + const { clock } = await start($, on, { answers: { orders: UNDER } }) + const began = Date.now() + await $.tool.call(bash(`${'\n'.repeat(64000)}dbt run -s orders`)) + await clock.settle() + expect(Date.now() - began).toBeLessThan(3000) +}) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 7479c101..5828b22b 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -108,7 +108,8 @@ export async function bashRewrite($: EngineInterface, e: BashCall): Promise { if (limitBytes <= 0) return null - const invocations = parseDbtCommand(e.command).filter(i => i.subcommand !== null && SCANNING.has(i.subcommand)) + const all = parseDbtCommand(e.command) + const invocations = all.filter(i => i.subcommand !== null && SCANNING.has(i.subcommand)) if (invocations.length === 0) return null const state = (await read($, costAtom)) ?? FRESH // A warehouse with no dry run was found out already: the command is never held, and nothing is asked again. @@ -119,7 +120,7 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: // One budget for the whole command, however many queries it names. const until = (await $.clock.now()) + ESTIMATE_BUDGET_MS for (const invocation of invocations) { - const target = targetOf(e.command, invocation) + const target = targetOf(e.command, invocation, all) if (!target.model && target.sql === undefined) { lines.push(`cost · no estimate for this selection (${target.why})`) continue @@ -195,25 +196,56 @@ export const editReadsBefore = false type Target = { model?: string; sql?: string; why: string } +/** The dbt launchers whose project is the session's: nothing else on the line can move it. */ +const PLAIN_LAUNCHER = /^((uv|poetry) run )?(\S*\/)?dbt$/ +/** Flags with one value that leave the project, target and compiled SQL as they are. */ +const VALUE_FLAGS = new Set(['--inline', '--limit', '--threads']) +/** Flags that name the models; any number of values follow. */ +const SELECT_FLAGS = new Set(['-s', '--select', '-m', '--models', '--model']) +/** Flags without a value that leave the project, target and compiled SQL as they are. */ +const PLAIN_FLAGS = new Set(['--fail-fast', '-x', '--quiet', '-q']) + +/** + * Whether the estimate would be of what the invocation runs. It asks about the session's project at its + * default target, so it is only so when the line moves neither: the dbt launcher is plain, nothing + * precedes the invocation but other dbt invocations, and every flag is one known to leave the query + * alone. Anything else (another target, defer state, vars, project, a full refresh) is not estimated. + */ +function isPlainInvocation(command: string, invocation: DbtInvocation, all: DbtInvocation[]): boolean { + if (!PLAIN_LAUNCHER.test(invocation.binary)) return false + let before = command.slice(0, invocation.start) + for (const earlier of all.filter(one => one.end <= invocation.start).reverse()) { + before = before.slice(0, earlier.start) + ' ' + before.slice(earlier.end) + } + if (!/^[\s;&]*$/.test(before)) return false + const words = shellWords(command.slice(invocation.start, invocation.end)) + const launcher = shellWords(invocation.binary) + if (launcher.some((word, i) => words[i] !== word) || words[launcher.length] !== invocation.subcommand) return false + let selecting = false + let pending = false + for (const word of words.slice(launcher.length + 1)) { + if (pending) { + pending = false + continue + } + const flag = word.startsWith('-') ? word.split('=')[0]! : null + if (flag === null) { + if (selecting) continue + return false + } + selecting = SELECT_FLAGS.has(flag) + if (selecting || PLAIN_FLAGS.has(flag)) continue + if (VALUE_FLAGS.has(flag)) pending = !word.includes('=') + else return false + } + return true +} + /** What a scanning invocation names to estimate: its inline SQL, or one plain model; else why not. */ -function targetOf(command: string, invocation: DbtInvocation): Target { - // The estimate runs in the session's project against its default target: a command that points - // elsewhere would be estimated as something it isn't. +function targetOf(command: string, invocation: DbtInvocation, all: DbtInvocation[]): Target { const text = command.slice(invocation.start, invocation.end) - // The flags as the shell reads them: quotes and backslashes inside a flag name don't change it. - const flags = text.replace(/['"\\]/g, '') - if ( - invocation.target || - invocation.targetPath || - invocation.hasDefer || - invocation.hasState || - /(^|\s)--(vars?|project-dir|profiles-dir|profile|full-refresh|directory|project|env-file)\b/.test(flags) || - /(^|\s)(-f|-C)(\s|$)/.test(flags) || - /\bDBT_[A-Z_]*=/.test(flags) || - // What runs before it in the line may move to another project or set the environment. - /(^|[\n;&|({])\s*(cd|pushd|popd|export|env|source|\.|set|unset)\s/.test(command.slice(0, invocation.start)) - ) { - return { why: 'it sets its own target, defer state, vars, project or refresh mode' } + if (!isPlainInvocation(command, invocation, all)) { + return { why: 'it sets its own target, defer state, vars, project or refresh mode, or runs after something that might' } } if (invocation.subcommand === 'show') { const inline = inlineSql(text) From d43225ca59be16e18e7ccd4adf5185457405ed30 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Fri, 13 Nov 2026 17:37:33 +0530 Subject: [PATCH 07/56] fix: no estimate for a line with expansions or very many dbt calls Co-Authored-By: Claude Sonnet 5.5 --- plugins/altimate-code/hooks/features/cost.test.tsx | 14 ++++++++++++++ plugins/altimate-code/hooks/features/cost.tsx | 8 +++++++- 2 files changed, 21 insertions(+), 1 deletion(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index a420b6cd..b2264676 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -238,6 +238,10 @@ test('a command that sets its own target, defer state, vars or project is not es 'if true; then cd other; fi; dbt run -s orders', 'dbt --profiles-dir ci run -s orders', 'FOO=1 dbt run -s orders', + "dbt run -s orders --threads $(printf '4 --target prod')", + 'dbt run -s orders --threads `echo 4 --vars x`', + 'dbt run -s orders 2>&${DBT_TARGET:=1}', + 'dbt --log-path "${DBT_TARGET:=prod}" deps; dbt run -s orders', ] for (const command of commands) { const result: any = await $.tool.call(bash(command)) @@ -328,3 +332,13 @@ test('a very long run of blank lines before the command costs no noticeable time await clock.settle() expect(Date.now() - began).toBeLessThan(3000) }) + +test('a line with a great many dbt calls is not read call by call', async ($, on) => { + const { clock, estimates } = await start($, on, { answers: { orders: UNDER } }) + const began = Date.now() + const result: any = await $.tool.call(bash('dbt run -s orders;'.repeat(4000))) + await clock.settle() + expect(estimates).toEqual([]) + expect(result.context.every((line: string) => line.startsWith('cost · no estimate'))).toBe(true) + expect(Date.now() - began).toBeLessThan(3000) +}) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 5828b22b..a87c7341 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -196,6 +196,8 @@ export const editReadsBefore = false type Target = { model?: string; sql?: string; why: string } +/** More dbt calls than this on one line are not estimated. */ +const MAX_INVOCATIONS = 20 /** The dbt launchers whose project is the session's: nothing else on the line can move it. */ const PLAIN_LAUNCHER = /^((uv|poetry) run )?(\S*\/)?dbt$/ /** Flags with one value that leave the project, target and compiled SQL as they are. */ @@ -209,9 +211,13 @@ const PLAIN_FLAGS = new Set(['--fail-fast', '-x', '--quiet', '-q']) * Whether the estimate would be of what the invocation runs. It asks about the session's project at its * default target, so it is only so when the line moves neither: the dbt launcher is plain, nothing * precedes the invocation but other dbt invocations, and every flag is one known to leave the query - * alone. Anything else (another target, defer state, vars, project, a full refresh) is not estimated. + * alone, with no expansion on the line. Anything else (another target, defer state, vars, project, a + * full refresh) is not estimated. */ function isPlainInvocation(command: string, invocation: DbtInvocation, all: DbtInvocation[]): boolean { + // The shell expands `$` and backticks anywhere on the line (arguments, redirections, an earlier call) into + // flags or environment this check can't see; a line with many calls is not worth reading call by call. + if (/[$`]/.test(command) || all.length > MAX_INVOCATIONS) return false if (!PLAIN_LAUNCHER.test(invocation.binary)) return false let before = command.slice(0, invocation.start) for (const earlier of all.filter(one => one.end <= invocation.start).reverse()) { From 61355cbea3d4507dcdc87e1d3b91fd5ada51ac40 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Fri, 13 Nov 2026 21:27:49 +0530 Subject: [PATCH 08/56] fix: read the directory of a command with a long run of blank lines in linear time Co-Authored-By: Claude Sonnet 5.5 --- plugins/altimate-code/hooks/lineage.tsx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/plugins/altimate-code/hooks/lineage.tsx b/plugins/altimate-code/hooks/lineage.tsx index 0193b050..0b724c07 100644 --- a/plugins/altimate-code/hooks/lineage.tsx +++ b/plugins/altimate-code/hooks/lineage.tsx @@ -274,7 +274,7 @@ function sqlFilesIn(command: string, cwd: string): string[] { } // Where a shell command reads from: the session folder, moved by each `cd` in the command. -const CD = /(?:^|[;&|(\n]\s*)cd\s+("[^"]+"|'[^']+'|[^\s;&|)]+)/gm +const CD = /(?:^|[;&|(\n][ \t]*)cd\s+("[^"]+"|'[^']+'|[^\s;&|)]+)/gm function commandDir(command: string, cwd: string): string { let dir = cwd for (const match of command.matchAll(CD)) { From 27133835647220d6f37874147adb5a764eb3be85 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Sat, 14 Nov 2026 08:04:14 +0530 Subject: [PATCH 09/56] fix: keep a hold when the next command is not estimated, read the last --inline, say what the scan limit covers Co-Authored-By: Claude Sonnet 5.5 --- .../altimate-code/.claude-plugin/plugin.json | 2 +- .../hooks/features/cost.test.tsx | 24 +++++++++++++++++-- plugins/altimate-code/hooks/features/cost.tsx | 15 ++++++++---- 3 files changed, 33 insertions(+), 8 deletions(-) diff --git a/plugins/altimate-code/.claude-plugin/plugin.json b/plugins/altimate-code/.claude-plugin/plugin.json index c3ca6e67..e3ac101d 100644 --- a/plugins/altimate-code/.claude-plugin/plugin.json +++ b/plugins/altimate-code/.claude-plugin/plugin.json @@ -25,7 +25,7 @@ "maxScanBytes": { "type": "number", "title": "Largest BigQuery scan without asking", - "description": "A dbt run, build or show that BigQuery estimates would scan more bytes than this is held until you allow it with /allow-scan. 0 never holds one. Other warehouses are never held.", + "description": "A dbt run or build of one named model, or a show of one model or with --inline, that BigQuery estimates would scan more bytes than this is held until you allow it with /allow-scan. A whole-project run, a graph selection or a command with extra options is not estimated, so it is never held. 0 never holds one. Other warehouses are never held.", "default": 10737418240 }, "healthBlocksPush": { diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index b2264676..c118cb19 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -262,13 +262,32 @@ test('dbt show --inline with its SQL on the next line after a backslash is estim }) test('letting a later command through clears the hold from the status line', async ($, on) => { - const { clock, statuses } = await start($, on, { answers: { orders: OVER } }) + const { clock, statuses } = await start($, on, { answers: { orders: OVER, customers: UNDER } }) await $.tool.call(bash('dbt run -s orders')) - await $.tool.call(bash('dbt run -s +orders')) + await $.tool.call(bash('dbt run -s customers')) await clock.settle() expect(statuses.filter(Boolean).at(-1)).not.toContain('held') }) +test('a variant of the held command that is not estimated leaves the hold in place', async ($, on) => { + const { clock, ran } = await start($, on, { answers: { orders: OVER } }) + expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined() + await $.tool.call(bash('dbt run -s +orders')) + await $.tool.call(bash('dbt run -s orders --full-refresh')) + await clock.settle() + await $.command.run({ command: 'allow-scan', args: '' } as any) + expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeUndefined() + expect(ran.at(-1)).toBe('dbt run -s orders') +}) + +test('a repeated --inline is estimated from the last one, as dbt reads it', async ($, on) => { + const { clock, estimates } = await start($, on, { answers: { 'select * from big': OVER } }) + const result: any = await $.tool.call(bash(`dbt show --inline 'select 1' --inline 'select * from big'`)) + await clock.settle() + expect(estimates).toEqual(['select * from big']) + expect(result.deny).toContain('20.0 GiB') +}) + test('the lines under a command are the latest estimate of it, never an earlier one', async ($, on) => { const answers: Record = { orders: UNDER } const { clock } = await start($, on, { answers }) @@ -307,6 +326,7 @@ test('inlineSql reads the query as the shell would', () => { expect(inlineSql(`dbt show --inline select\\ 1 --limit 5`)).toBe('select 1') expect(inlineSql(`dbt show --inline \\\n 'select 1'`)).toBe('select 1') expect(inlineSql('dbt show -s orders')).toBeNull() + expect(inlineSql(`dbt show --inline 'select 1' --inline='select 2'`)).toBe('select 2') }) test('formatBytes writes the units the dry run does', () => { diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index a87c7341..01aa71cd 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -116,6 +116,7 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: if (state.unsupportedAdapter) return null const lines: string[] = [] + let estimated = false const over: { label: string; bytes: number; display: string }[] = [] // One budget for the whole command, however many queries it names. const until = (await $.clock.now()) + ESTIMATE_BUDGET_MS @@ -136,6 +137,7 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: lines.push(`cost · no estimate for ${label}: ${answer.reason}`) continue } + estimated = true await update($, costAtom, prev => ({ ...(prev ?? FRESH), lastEstimate: { target: label, bytes: answer.bytes, display: answer.display } })) await setStatusPart($, 'cost', `scan ≈ ${answer.display}`) if (answer.maxBytes <= limitBytes) lines.push(`cost · ${label} would scan ${answer.display}`) @@ -164,8 +166,9 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: deny: `≈ ${worst.display} would be scanned, over the ${formatBytes(limitBytes)} limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.`, } } - // Nothing held: an earlier hold is over, as the person has moved on, and so is its allowance. - if (state.held || state.allowOnce) { + // A command that was estimated and is under the limit ends an earlier hold, and its allowance. One that + // was not estimated says nothing, so the hold stays. + if (estimated && (state.held || state.allowOnce)) { await update($, costAtom, prev => (prev?.held || prev?.allowOnce ? { ...prev, held: null, allowOnce: false } : prev)) const last = (await read($, costAtom))?.lastEstimate await setStatusPart($, 'cost', last ? `scan ≈ ${last.display}` : null) @@ -267,12 +270,14 @@ function targetOf(command: string, invocation: DbtInvocation, all: DbtInvocation /** The SQL of `--inline` in a dbt command's text, unquoted as the shell would; null when there is none. */ export function inlineSql(text: string): string | null { const words = shellWords(text) + // dbt keeps the last of a repeated option. + let found: string | null = null for (let i = 0; i < words.length; i++) { const word = words[i]! - if (word === '--inline') return words[i + 1] ?? null - if (word.startsWith('--inline=')) return word.slice('--inline='.length) + if (word === '--inline') found = words[i + 1] ?? null + else if (word.startsWith('--inline=')) found = word.slice('--inline='.length) } - return null + return found } /** The words of a command's text with their quotes and backslashes resolved. */ From bf86dceca8fbaeaf6e5303937ae8125fef3c4d58 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Sat, 14 Nov 2026 08:08:16 +0530 Subject: [PATCH 10/56] fix: say that only an estimated command ends a hold, and what the scan limit covers Co-Authored-By: Claude Sonnet 5.5 --- plugins/altimate-code/.claude-plugin/plugin.json | 2 +- plugins/altimate-code/hooks/features/cost.tsx | 2 +- plugins/altimate-code/types/index.d.ts | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/plugins/altimate-code/.claude-plugin/plugin.json b/plugins/altimate-code/.claude-plugin/plugin.json index e3ac101d..912f5cce 100644 --- a/plugins/altimate-code/.claude-plugin/plugin.json +++ b/plugins/altimate-code/.claude-plugin/plugin.json @@ -25,7 +25,7 @@ "maxScanBytes": { "type": "number", "title": "Largest BigQuery scan without asking", - "description": "A dbt run or build of one named model, or a show of one model or with --inline, that BigQuery estimates would scan more bytes than this is held until you allow it with /allow-scan. A whole-project run, a graph selection or a command with extra options is not estimated, so it is never held. 0 never holds one. Other warehouses are never held.", + "description": "A dbt run or build of one named model, or a show of one model or with --inline, that BigQuery estimates would scan more bytes than this is held until you allow it with /allow-scan. A whole-project run, a graph selection or a command with options that change the target, state, vars, project or refresh mode, or one run after another command, is not estimated, so it is never held. 0 never holds one. Other warehouses are never held.", "default": 10737418240 }, "healthBlocksPush": { diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 01aa71cd..d366339d 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -90,7 +90,7 @@ export async function turnComplete($: EngineInterface, e: Args<'turn.complete'>, export async function sessionEnd($: EngineInterface, e: Args<'session.end'>) {} -/** This feature's line in the band: the command held, until it is allowed or a later dbt command is not held. */ +/** This feature's line in the band: the command held, until it is allowed or a later dbt command is estimated under the limit. */ export async function bandLine($: EngineInterface, ui: BandUi): Promise { const held = (await read($, costAtom))?.held if (!held) return null diff --git a/plugins/altimate-code/types/index.d.ts b/plugins/altimate-code/types/index.d.ts index c25ed71c..f0d124b4 100644 --- a/plugins/altimate-code/types/index.d.ts +++ b/plugins/altimate-code/types/index.d.ts @@ -209,7 +209,7 @@ export interface CostState { unsupportedAdapter: string | null /** The newest estimate: what was estimated, in bytes, as the dry run wrote it. */ lastEstimate: { target: string; bytes: number; display: string } | null - /** The command held for being over the limit, until it is allowed or a later dbt command is not held; `bytes` is its scan's upper bound. */ + /** The command held for being over the limit, until it is allowed or a later dbt command is estimated under the limit; `bytes` is its scan's upper bound. */ held: { command: string; target: string; bytes: number; display: string } | null /** /allow-scan was given for the held command: that same command runs once. */ allowOnce: boolean From 185f9035236f4ba8408096176cf66baa3f6e3818 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Sat, 14 Nov 2026 09:09:57 +0530 Subject: [PATCH 11/56] fix: take the value of --inline as the query, not as another option Co-Authored-By: Claude Sonnet 5.5 --- plugins/altimate-code/hooks/features/cost.test.tsx | 2 ++ plugins/altimate-code/hooks/features/cost.tsx | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index c118cb19..1ae763cb 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -327,6 +327,8 @@ test('inlineSql reads the query as the shell would', () => { expect(inlineSql(`dbt show --inline \\\n 'select 1'`)).toBe('select 1') expect(inlineSql('dbt show -s orders')).toBeNull() expect(inlineSql(`dbt show --inline 'select 1' --inline='select 2'`)).toBe('select 2') + // The value of --inline is the query, even when it looks like an option. + expect(inlineSql(`dbt show --inline '--inline=comment select 1'`)).toBe('--inline=comment select 1') }) test('formatBytes writes the units the dry run does', () => { diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index d366339d..55b1301b 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -274,7 +274,7 @@ export function inlineSql(text: string): string | null { let found: string | null = null for (let i = 0; i < words.length; i++) { const word = words[i]! - if (word === '--inline') found = words[i + 1] ?? null + if (word === '--inline') found = words[++i] ?? null else if (word.startsWith('--inline=')) found = word.slice('--inline='.length) } return found From 582f9f8b39e96f8284652b7d7a4f15933f0c6ec7 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Sun, 15 Nov 2026 22:16:53 +0530 Subject: [PATCH 12/56] fix: clear a hold when the warehouse has no dry run, cap the notes per command, and word a just-over scan as over Co-Authored-By: Claude Sonnet 5.5 --- .../altimate-code/.claude-plugin/plugin.json | 2 +- .../hooks/features/cost.test.tsx | 22 ++++++++++++++++++- plugins/altimate-code/hooks/features/cost.tsx | 17 +++++++++----- 3 files changed, 34 insertions(+), 7 deletions(-) diff --git a/plugins/altimate-code/.claude-plugin/plugin.json b/plugins/altimate-code/.claude-plugin/plugin.json index 912f5cce..a656d07f 100644 --- a/plugins/altimate-code/.claude-plugin/plugin.json +++ b/plugins/altimate-code/.claude-plugin/plugin.json @@ -25,7 +25,7 @@ "maxScanBytes": { "type": "number", "title": "Largest BigQuery scan without asking", - "description": "A dbt run or build of one named model, or a show of one model or with --inline, that BigQuery estimates would scan more bytes than this is held until you allow it with /allow-scan. A whole-project run, a graph selection or a command with options that change the target, state, vars, project or refresh mode, or one run after another command, is not estimated, so it is never held. 0 never holds one. Other warehouses are never held.", + "description": "A dbt run or build of one named model, or a show of one model or with --inline, that BigQuery estimates would scan more bytes than this is held until you allow it with /allow-scan. A whole-project run, a graph selection or a command with options that change the target, state, vars, project or refresh mode, or one run after a non-dbt command, is not estimated, so it is never held. 0 never holds one. Other warehouses are never held.", "default": 10737418240 }, "healthBlocksPush": { diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 1ae763cb..77770ebb 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -220,6 +220,24 @@ test('an estimate whose rounded size is within the limit but whose upper bound i await clock.settle() }) +test('a warehouse found to have no dry run ends a hold from before, and its allowance', async ($, on) => { + const answers: Record = { orders: OVER } + const { clock, ran } = await start($, on, { answers }) + expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined() + await $.command.run({ command: 'allow-scan', args: '' } as any) + answers.orders = { success: true, supported: false, adapter: 'snowflake' } + await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(ran).toEqual(['dbt run -s orders']) + expect((await $.command.run({ command: 'allow-scan', args: '' } as any)).text).toContain('Nothing is held') +}) + +test('a scan just over the limit reads as over it, not as equal to it', async ($, on) => { + const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, '10.0 GiB', 10 * GIB + 52 * 1024 ** 2) } }) + expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBe('just over 10.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.') + await clock.settle() +}) + test('a command that sets its own target, defer state, vars or project is not estimated', async ($, on) => { const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } }) const commands = [ @@ -361,6 +379,8 @@ test('a line with a great many dbt calls is not read call by call', async ($, on const result: any = await $.tool.call(bash('dbt run -s orders;'.repeat(4000))) await clock.settle() expect(estimates).toEqual([]) - expect(result.context.every((line: string) => line.startsWith('cost · no estimate'))).toBe(true) + expect(result.context.length).toBe(6) + expect(result.context[0]).toContain('cost · no estimate') + expect(result.context[5]).toBe('cost · 3995 more notes not shown') expect(Date.now() - began).toBeLessThan(3000) }) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 55b1301b..16bd5941 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -129,8 +129,10 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: const label = target.model ?? 'the inline query' const answer = await estimate($, target.model ? { model: target.model } : { sql: target.sql }, until) if (answer.kind === 'unsupported') { - await update($, costAtom, prev => ({ ...(prev ?? FRESH), unsupportedAdapter: answer.adapter })) + // Nothing can be held on this warehouse, so a hold from before the verdict goes with it. + await update($, costAtom, prev => ({ ...(prev ?? FRESH), unsupportedAdapter: answer.adapter, held: null, allowOnce: false })) lines.push(`cost · no estimate on ${answer.adapter}: only BigQuery has a dry run`) + over.length = 0 break } if (answer.kind === 'none') { @@ -138,8 +140,7 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: continue } estimated = true - await update($, costAtom, prev => ({ ...(prev ?? FRESH), lastEstimate: { target: label, bytes: answer.bytes, display: answer.display } })) - await setStatusPart($, 'cost', `scan ≈ ${answer.display}`) + await rememberEstimate($, label, answer.bytes, answer.display) if (answer.maxBytes <= limitBytes) lines.push(`cost · ${label} would scan ${answer.display}`) else over.push({ label, bytes: answer.maxBytes, display: answer.display }) } @@ -162,8 +163,10 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: } notes.delete(e.command) await setStatusPart($, 'cost', `scan held ≈ ${worst.display}`) + // The display is rounded: a scan just past the limit would read as equal to it. + const scanned = worst.display === formatBytes(limitBytes) ? `just over ${worst.display}` : `≈ ${worst.display}` return { - deny: `≈ ${worst.display} would be scanned, over the ${formatBytes(limitBytes)} limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.`, + deny: `${scanned} would be scanned, over the ${formatBytes(limitBytes)} limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.`, } } // A command that was estimated and is under the limit ends an earlier hold, and its allowance. One that @@ -177,8 +180,12 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: return null } +/** Notes kept per command: a line of many dbt calls would otherwise put one note each into Claude's context. */ +const MAX_NOTES = 5 + function keepNotes(command: string, lines: string[]) { - if (lines.length > 0) notes.set(command, lines) + if (lines.length > MAX_NOTES) notes.set(command, [...lines.slice(0, MAX_NOTES), `cost · ${lines.length - MAX_NOTES} more notes not shown`]) + else if (lines.length > 0) notes.set(command, lines) else notes.delete(command) } From 7cc430aaae298ccd481543b789883475c1106d0a Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Sun, 15 Nov 2026 22:24:24 +0530 Subject: [PATCH 13/56] fix: reset the status line when a hold ends, and show the upper bound of a scan whose estimate is under the limit Co-Authored-By: Claude Sonnet 5.5 --- .../altimate-code/hooks/features/cost.test.tsx | 7 ++++--- plugins/altimate-code/hooks/features/cost.tsx | 15 +++++++++++---- 2 files changed, 15 insertions(+), 7 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 77770ebb..38588f39 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -216,24 +216,25 @@ test('the allowance is for the command that was held: another over-limit command test('an estimate whose rounded size is within the limit but whose upper bound is over it is held', async ($, on) => { const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, '10.0 GiB', 10 * GIB + 52 * 1024 ** 2) } }) - expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toContain('10.0 GiB') + expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBe('up to 10.1 GiB (≈ 10.0 GiB estimated) would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.') await clock.settle() }) test('a warehouse found to have no dry run ends a hold from before, and its allowance', async ($, on) => { const answers: Record = { orders: OVER } - const { clock, ran } = await start($, on, { answers }) + const { clock, ran, statuses } = await start($, on, { answers }) expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined() await $.command.run({ command: 'allow-scan', args: '' } as any) answers.orders = { success: true, supported: false, adapter: 'snowflake' } await $.tool.call(bash('dbt run -s orders')) await clock.settle() expect(ran).toEqual(['dbt run -s orders']) + expect(statuses.at(-1) ?? '').not.toContain('held') expect((await $.command.run({ command: 'allow-scan', args: '' } as any)).text).toContain('Nothing is held') }) test('a scan just over the limit reads as over it, not as equal to it', async ($, on) => { - const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, '10.0 GiB', 10 * GIB + 52 * 1024 ** 2) } }) + const { clock } = await start($, on, { answers: { orders: bq(10 * GIB + 1024 ** 2, '10.0 GiB') } }) expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBe('just over 10.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.') await clock.settle() }) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 16bd5941..e9b873df 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -117,7 +117,7 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: const lines: string[] = [] let estimated = false - const over: { label: string; bytes: number; display: string }[] = [] + const over: { label: string; bytes: number; point: number; display: string }[] = [] // One budget for the whole command, however many queries it names. const until = (await $.clock.now()) + ESTIMATE_BUDGET_MS for (const invocation of invocations) { @@ -131,6 +131,7 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: if (answer.kind === 'unsupported') { // Nothing can be held on this warehouse, so a hold from before the verdict goes with it. await update($, costAtom, prev => ({ ...(prev ?? FRESH), unsupportedAdapter: answer.adapter, held: null, allowOnce: false })) + await setStatusPart($, 'cost', null) lines.push(`cost · no estimate on ${answer.adapter}: only BigQuery has a dry run`) over.length = 0 break @@ -142,7 +143,7 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: estimated = true await rememberEstimate($, label, answer.bytes, answer.display) if (answer.maxBytes <= limitBytes) lines.push(`cost · ${label} would scan ${answer.display}`) - else over.push({ label, bytes: answer.maxBytes, display: answer.display }) + else over.push({ label, bytes: answer.maxBytes, point: answer.bytes, display: answer.display }) } if (over.length > 0) { @@ -163,8 +164,14 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: } notes.delete(e.command) await setStatusPart($, 'cost', `scan held ≈ ${worst.display}`) - // The display is rounded: a scan just past the limit would read as equal to it. - const scanned = worst.display === formatBytes(limitBytes) ? `just over ${worst.display}` : `≈ ${worst.display}` + // The hold is decided on the upper bound, and the display is the rounded point estimate: either can read + // as not over the limit when the scan is just past it. + const scanned = + worst.point <= limitBytes + ? `up to ${formatBytes(worst.bytes)} (≈ ${worst.display} estimated)` + : worst.display === formatBytes(limitBytes) + ? `just over ${worst.display}` + : `≈ ${worst.display}` return { deny: `${scanned} would be scanned, over the ${formatBytes(limitBytes)} limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.`, } From 499c0710d6e237e4c1492a8c504748abcf5c37d4 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Tue, 17 Nov 2026 06:22:29 +0530 Subject: [PATCH 14/56] fix: an upper bound that formats like the limit reads as just over it --- plugins/altimate-code/hooks/features/cost.test.tsx | 6 ++++++ plugins/altimate-code/hooks/features/cost.tsx | 6 +++--- 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 38588f39..a7cdfe7c 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -220,6 +220,12 @@ test('an estimate whose rounded size is within the limit but whose upper bound i await clock.settle() }) +test('an upper bound that formats the same as the limit is not reported as equal to it', async ($, on) => { + const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, '10.0 GiB', 10 * GIB + 30 * 1024 ** 2) } }) + expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBe('just over 10.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.') + await clock.settle() +}) + test('a warehouse found to have no dry run ends a hold from before, and its allowance', async ($, on) => { const answers: Record = { orders: OVER } const { clock, ran, statuses } = await start($, on, { answers }) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index e9b873df..edb7c0ec 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -167,10 +167,10 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: // The hold is decided on the upper bound, and the display is the rounded point estimate: either can read // as not over the limit when the scan is just past it. const scanned = - worst.point <= limitBytes + worst.point <= limitBytes && formatBytes(worst.bytes) !== formatBytes(limitBytes) ? `up to ${formatBytes(worst.bytes)} (≈ ${worst.display} estimated)` - : worst.display === formatBytes(limitBytes) - ? `just over ${worst.display}` + : worst.display === formatBytes(limitBytes) || worst.point <= limitBytes + ? `just over ${formatBytes(limitBytes)}` : `≈ ${worst.display}` return { deny: `${scanned} would be scanned, over the ${formatBytes(limitBytes)} limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.`, From 1be22642df91b737cb29f7b3c339aba10cc3dc62 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Tue, 17 Nov 2026 07:43:36 +0530 Subject: [PATCH 15/56] test: the all-features phase test gives the built cost feature a session to run in Co-Authored-By: Claude Sonnet 5.5 --- .../altimate-code/hooks/features/index.test.ts | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/plugins/altimate-code/hooks/features/index.test.ts b/plugins/altimate-code/hooks/features/index.test.ts index 7c1e206d..0d93e472 100644 --- a/plugins/altimate-code/hooks/features/index.test.ts +++ b/plugins/altimate-code/hooks/features/index.test.ts @@ -1,4 +1,4 @@ -import { expect, test } from 'claude-code/testing' +import { expect, mock, test } from 'claude-code/testing' import { attempt, @@ -33,8 +33,19 @@ test('attempt logs a feature function that throws at once, one that rejects, and expect(logs).toEqual(['runs · sessionStart failed: Error: at once', 'defer · bandLine failed: Error: later']) }) -test('with every feature a stub, each phase runs through the features and logs nothing', async () => { - const { $, logs } = engine() +test('each phase runs through the features and logs nothing', async ($, on) => { + // The cost feature is built: it keeps state, registers commands and may ask the CLI, so it gets a session beneath it. + const logs: string[] = [] + mock.clock(on) + on('ui.log', (_: unknown, e: { text: string }) => { + logs.push(e.text) + return { value: undefined } + }) + on('command.register', (_: unknown, e: { name: string }) => ({ value: { command: e.name } })) + on('ui.status', () => ({ value: undefined })) + on('session.root', () => ({ value: '/repo' })) + on('fs.exists', () => ({ value: false })) + on('process.run', () => ({ value: { exitCode: 1, stdout: '', stderr: 'no CLI here' } })) const bash = { tool: 'Bash', command: 'dbt run -s a' } as any const file = { tool: 'Edit', file_path: '/repo/models/a.sql' } as any await featuresSessionStart($, {} as any) From 5a7baf654002ef520a923da3d2fdaf0f135d5c99 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Tue, 17 Nov 2026 08:02:20 +0530 Subject: [PATCH 16/56] fix: the cost gate waits inside the phase deadline and keeps a hold when it cannot re-estimate A gate that outlasts the tool chain's 5 s phase lets the command run unchecked. The gate now waits 4 s, refuses the command while an estimate is still running (the estimate carries on and the next try uses it), and a command held earlier stays held when its estimate cannot be made again. Co-Authored-By: Claude Sonnet 5.5 --- .../hooks/features/cost.test.tsx | 105 +++++++++++++++++- plugins/altimate-code/hooks/features/cost.tsx | 61 +++++++++- 2 files changed, 161 insertions(+), 5 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index a7cdfe7c..9f451598 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -10,6 +10,10 @@ type Options = { answers?: Record | 'unknown-tool'> /** The adapter's answer for everything else. */ fallback?: Record + /** The CLI answers only once this resolves. */ + hold?: Promise + /** With `hold`: only the estimate of this model or SQL waits. */ + holdFor?: string } /** The session beneath the plugin, a CLI whose dbt_cost_estimate is scripted, and a Bash tool that records what ran. */ @@ -34,7 +38,7 @@ async function start($: any, on: any, options: Options = {}) { return }) on('fs.exists', () => ({ value: false })) - on('process.run', (_: unknown, e: { argv: readonly string[] }) => { + on('process.run', async (_: unknown, e: { argv: readonly string[] }) => { const [, command, , tool] = e.argv if (command !== 'tool') return { value: { exitCode: 1, stdout: '', stderr: 'not this test' } } expect(tool).toBe('dbt_cost_estimate') @@ -42,6 +46,7 @@ async function start($: any, on: any, options: Options = {}) { expect(e.argv).toContain('--allow-write') const args = JSON.parse(String(e.argv[e.argv.indexOf('--args') + 1] ?? '{}')) const key = String(args.model ?? args.sql) + if (options.hold && (options.holdFor === undefined || options.holdFor === key)) await options.hold estimates.push(key) const answer = options.answers?.[key] ?? options.fallback if (answer === 'unknown-tool') { @@ -391,3 +396,101 @@ test('a line with a great many dbt calls is not read call by call', async ($, on expect(result.context[5]).toBe('cost · 3995 more notes not shown') expect(Date.now() - began).toBeLessThan(3000) }) + +test('an estimate not done within the gate wait refuses the command, and the finished answer is used on the next try', async ($, on) => { + let release!: () => void + const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER }, hold: new Promise(resolve => (release = resolve)) }) + const first = $.tool.call(bash('dbt run -s orders')) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + expect(ran).toEqual([]) + + release() + await clock.settle() + const second: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(second.deny).toContain('20.0 GiB') + // One estimate served both passes. + expect(estimates).toEqual(['orders']) + expect(ran).toEqual([]) +}) + +test('a held command stays held when its estimate cannot be made again, until /allow-scan', async ($, on) => { + const answers: Record = { orders: OVER } + const { clock, ran } = await start($, on, { answers }) + expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toContain('20.0 GiB') + + answers.orders = { success: false, error: 'Access Denied' } + const again: any = await $.tool.call(bash('dbt run -s orders')) + expect(again.deny).toContain('20.0 GiB') + expect(ran).toEqual([]) + + await $.command.run({ command: 'allow-scan', args: '' } as any) + const through: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(through.deny).toBeUndefined() + expect(ran).toEqual(['dbt run -s orders']) +}) + +test('an estimate still running spends no allowance: the held command stays held until every estimate is in', async ($, on) => { + const options: Options = { answers: { a: OVER, b: OVER } } + const { clock, ran } = await start($, on, options) + const both = 'dbt run -s a && dbt run -s b' + expect(((await $.tool.call(bash(both))) as any).deny).toContain('20.0 GiB') + await $.command.run({ command: 'allow-scan', args: '' } as any) + + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + options.holdFor = 'b' + const slow = $.tool.call(bash(both)) + await clock.advance(4_001) + expect(((await slow) as any).deny).toContain('still being estimated') + expect(ran).toEqual([]) + + // The allowance was not spent by the refusal: once b's estimate is in, the command goes through once. + release() + await clock.settle() + const through: any = await $.tool.call(bash(both)) + await clock.settle() + expect(through.deny).toBeUndefined() + expect(ran).toEqual([both]) +}) + +test('an answer nobody took is not used a minute later: the model may have changed', async ($, on) => { + const options: Options = { answers: { orders: OVER } } + const { clock, estimates, ran } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + const first = $.tool.call(bash('dbt run -s orders')) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + release() + await clock.settle() + + await clock.advance(61_000) + options.answers = { orders: UNDER } + const later: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(later.deny).toBeUndefined() + expect(estimates).toEqual(['orders', 'orders']) + expect(ran).toEqual(['dbt run -s orders']) +}) + +test('the same model named twice on a line is estimated once, so a slow estimate does not refuse the retry forever', async ($, on) => { + const options: Options = { answers: { orders: UNDER } } + const { clock, estimates, ran } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + const line = 'dbt run -s orders && dbt show -s orders' + const first = $.tool.call(bash(line)) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + release() + await clock.settle() + options.hold = undefined + const retry: any = await $.tool.call(bash(line)) + await clock.settle() + expect(retry.deny).toBeUndefined() + expect(estimates).toEqual(['orders']) + expect(ran).toEqual([line]) +}) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index edb7c0ec..2b6d8d4d 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -10,7 +10,7 @@ import { atom, read, update } from 'claude-code' import type { Args, EngineInterface, EventResult, On, RenderElement, ToolCallResult } from 'claude-code' -import { runTool } from '../altimate-cli' +import { runTool, within } from '../altimate-cli' import { parseDbtCommand, type DbtInvocation } from '../dbt-command' import { setStatusPart } from '../status-line' import type { BashCall, ContextLines, EditedFile, FileCall } from '../tool-chain' @@ -21,6 +21,11 @@ import type { BandUi, FeatureContext } from './index' const DEFAULT_MAX_SCAN_BYTES = 10 * 1024 ** 3 /** The adapter may have to start (dbt deps, a parse) for the first estimate. */ const ESTIMATE_BUDGET_MS = 120_000 +/** + * How long the gate waits for estimates, in all: inside the tool chain's 5 s phase deadline, past which the call + * runs unchecked. An estimate that is not done by then goes on, and the command is refused until it is. + */ +const GATE_WAIT_MS = 4_000 /** The dbt subcommands that run SQL a person pays for. */ const SCANNING = new Set(['run', 'build', 'show']) /** A selector that is one plain model name: no graph operator, tag, path, package or wildcard. */ @@ -38,6 +43,10 @@ const FRESH: CostState = { unsupportedAdapter: null, lastEstimate: null, held: n let limitBytes = DEFAULT_MAX_SCAN_BYTES /** The lines to show under an estimated command's Bash row, by command; each gate pass replaces the last. Taken by bashAfter. */ const notes = new Map() +/** Estimates still running past the gate's wait, by what they ask about; the next gate pass for the same target takes the answer. */ +const inflight = new Map; doneAt: number | null }>() +/** An answer nobody took within this long is dropped: the model may have changed since. */ +const ANSWER_KEEP_MS = 60_000 /** Adds this feature's own hooks. */ export function register(on: On, context: FeatureContext) { @@ -76,6 +85,7 @@ export function register(on: On, context: FeatureContext) { /** After the session started: the place to register commands. */ export async function sessionStart($: EngineInterface, e: Args<'session.start'>) { notes.clear() + inflight.clear() await update($, costAtom, () => ({ ...FRESH })) await setStatusPart($, 'cost', null) await $.command.register({ name: 'allow-scan', description: 'Let the dbt command held for its BigQuery scan size run once, when run again unchanged' }) @@ -118,8 +128,12 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: const lines: string[] = [] let estimated = false const over: { label: string; bytes: number; point: number; display: string }[] = [] - // One budget for the whole command, however many queries it names. - const until = (await $.clock.now()) + ESTIMATE_BUDGET_MS + // One wait for the whole command, however many queries it names. + const waitUntil = (await $.clock.now()) + GATE_WAIT_MS + const pending: string[] = [] + // What this pass already has, so the same query named twice on the line is asked for once. + const taken = new Map() + let failed = false for (const invocation of invocations) { const target = targetOf(e.command, invocation, all) if (!target.model && target.sql === undefined) { @@ -127,16 +141,22 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: continue } const label = target.model ?? 'the inline query' - const answer = await estimate($, target.model ? { model: target.model } : { sql: target.sql }, until) + const answer = await estimateWithin($, target.model ? { model: target.model } : { sql: target.sql }, waitUntil, taken) + if (answer === 'pending') { + pending.push(label) + continue + } if (answer.kind === 'unsupported') { // Nothing can be held on this warehouse, so a hold from before the verdict goes with it. await update($, costAtom, prev => ({ ...(prev ?? FRESH), unsupportedAdapter: answer.adapter, held: null, allowOnce: false })) await setStatusPart($, 'cost', null) lines.push(`cost · no estimate on ${answer.adapter}: only BigQuery has a dry run`) over.length = 0 + pending.length = 0 break } if (answer.kind === 'none') { + failed = true lines.push(`cost · no estimate for ${label}: ${answer.reason}`) continue } @@ -146,6 +166,17 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: else over.push({ label, bytes: answer.maxBytes, point: answer.bytes, display: answer.display }) } + // An estimate still running decides nothing yet, and spends no allowance: the command is refused until it is in. + if (pending.length > 0) { + notes.delete(e.command) + return { deny: `The scan of ${pending.join(', ')} is still being estimated (the dbt adapter may be starting). Run the same command again in a moment.` } + } + + // A command held earlier stays held while its estimate cannot be made again: only /allow-scan or an estimate under the limit frees it. + if (over.length === 0 && failed && state.held?.command === e.command && state.held.bytes > limitBytes) { + over.push({ label: state.held.target, bytes: state.held.bytes, point: state.held.bytes, display: state.held.display }) + } + if (over.length > 0) { const worst = over.reduce((a, b) => (b.bytes > a.bytes ? b : a)) // The allowance is spent in one step, and only by the command that was held for it. @@ -351,6 +382,28 @@ async function estimate($: EngineInterface, args: { model?: string; sql?: string } } +/** The estimate, started on the long budget if none is running for these arguments; `pending` when it is not done by `waitUntil`. */ +async function estimateWithin($: EngineInterface, args: { model?: string; sql?: string }, waitUntil: number, taken: Map): Promise { + const key = JSON.stringify(args) + const had = taken.get(key) + if (had) return had + let running = inflight.get(key) + if (running?.doneAt != null && (await $.clock.now()) - running.doneAt > ANSWER_KEEP_MS) running = undefined + if (!running) { + const entry: { answer: Promise; doneAt: number | null } = { answer: estimate($, args, (await $.clock.now()) + ESTIMATE_BUDGET_MS), doneAt: null } + void entry.answer.then(async () => void (entry.doneAt = await $.clock.now())) + inflight.set(key, entry) + running = entry + } + const left = waitUntil - (await $.clock.now()) + const done = left > 0 ? await within($, left, running.answer.then(answer => ({ answer }))) : null + if (!done) return 'pending' + // Taken: a later pass asks again. + if (inflight.get(key) === running) inflight.delete(key) + taken.set(key, done.answer) + return done.answer +} + async function rememberEstimate($: EngineInterface, target: string, bytes: number, display: string) { await update($, costAtom, prev => ({ ...(prev ?? FRESH), lastEstimate: { target, bytes, display } })) await setStatusPart($, 'cost', `scan ≈ ${display}`) From 0bf68ad6b94a70499a524cfd30c11f5e9ea26290 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Tue, 17 Nov 2026 11:51:07 +0530 Subject: [PATCH 17/56] fix: keep known over-limit scans and finished answers across retries; drop estimates on edit Co-Authored-By: Claude Sonnet 5.5 --- .../hooks/features/cost.test.tsx | 41 +++++++++++++++++++ plugins/altimate-code/hooks/features/cost.tsx | 16 ++++++-- 2 files changed, 54 insertions(+), 3 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 9f451598..29aa403b 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -494,3 +494,44 @@ test('the same model named twice on a line is estimated once, so a slow estimate expect(estimates).toEqual(['orders']) expect(ran).toEqual([line]) }) + +test('a compound command gets every answer over its retries, however long each estimate takes', async ($, on) => { + const options: Options = { answers: { a: UNDER, b: UNDER, c: UNDER } } + const { clock, estimates, ran } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + options.holdFor = 'c' + const all = 'dbt run -s a && dbt run -s b && dbt run -s c' + const first = $.tool.call(bash(all)) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + release() + await clock.settle() + const through: any = await $.tool.call(bash(all)) + await clock.settle() + expect(through.deny).toBeUndefined() + // a and b were asked for once: the retry used their answers. + expect(estimates.filter(key => key === 'a')).toEqual(['a']) + expect(ran).toEqual([all]) +}) + +test('an edit drops the estimates made before it', async ($, on) => { + const options: Options = { answers: { orders: UNDER } } + const { clock, estimates, ran } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + const first = $.tool.call(bash('dbt run -s orders')) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + release() + await clock.settle() + + options.answers = { orders: OVER } + await $.tool.call({ tool: 'Edit', file_path: '/repo/models/orders.sql', old_string: '1', new_string: '2' } as any) + await clock.settle() + const later: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(later.deny).toContain('20.0 GiB') + expect(estimates).toEqual(['orders', 'orders']) + expect(ran).toEqual([]) +}) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 2b6d8d4d..11f31402 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -166,8 +166,16 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: else over.push({ label, bytes: answer.maxBytes, point: answer.bytes, display: answer.display }) } + // A finished command's answers are taken: a later one asks again. A pending one keeps them for its retry. + if (pending.length === 0) for (const key of taken.keys()) inflight.delete(key) + // An estimate still running decides nothing yet, and spends no allowance: the command is refused until it is in. if (pending.length > 0) { + // What is already known to be over the limit stays held, so a failed estimate on the retry cannot free it. + if (over.length > 0) { + const worst = over.reduce((a, b) => (b.bytes > a.bytes ? b : a)) + await update($, costAtom, prev => ({ ...(prev ?? FRESH), held: { command: e.command, target: worst.label, bytes: worst.bytes, display: worst.display } })) + } notes.delete(e.command) return { deny: `The scan of ${pending.join(', ')} is still being estimated (the dbt adapter may be starting). Run the same command again in a moment.` } } @@ -235,7 +243,10 @@ export async function bashAfter($: EngineInterface, e: BashCall, result: ToolCal } /** `file.before` holds the text from before the edit only when `editReadsBefore` is true. */ -export async function editAfter($: EngineInterface, e: FileCall, result: ToolCallResult, file: EditedFile): Promise {} +export async function editAfter($: EngineInterface, e: FileCall, result: ToolCallResult, file: EditedFile): Promise { + // An edit can change what a model scans: no estimate made before it is reused. + inflight.clear() +} export async function readOrEditAfter($: EngineInterface, e: FileCall, result: ToolCallResult, file: { path: string }): Promise {} @@ -398,8 +409,7 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: const left = waitUntil - (await $.clock.now()) const done = left > 0 ? await within($, left, running.answer.then(answer => ({ answer }))) : null if (!done) return 'pending' - // Taken: a later pass asks again. - if (inflight.get(key) === running) inflight.delete(key) + // Not dropped here: while another query of the command is pending, the retry still needs this answer. taken.set(key, done.answer) return done.answer } From e3be0f54c3b62fc4e58399dbf4e40bf7c284562f Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Tue, 17 Nov 2026 11:57:53 +0530 Subject: [PATCH 18/56] fix: a pending hold keeps an allowance only for the command it was given for Co-Authored-By: Claude Sonnet 5.5 --- .../hooks/features/cost.test.tsx | 20 +++++++++++++++++++ plugins/altimate-code/hooks/features/cost.tsx | 7 ++++++- 2 files changed, 26 insertions(+), 1 deletion(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 29aa403b..a318d05b 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -535,3 +535,23 @@ test('an edit drops the estimates made before it', async ($, on) => { expect(estimates).toEqual(['orders', 'orders']) expect(ran).toEqual([]) }) + +test('a pending estimate on another command does not carry /allow-scan over to it', async ($, on) => { + const options: Options = { answers: { a: OVER, b: OVER, c: UNDER } } + const { clock, ran } = await start($, on, options) + expect(((await $.tool.call(bash('dbt run -s a'))) as any).deny).toContain('20.0 GiB') + await $.command.run({ command: 'allow-scan', args: '' } as any) + + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + options.holdFor = 'c' + const other = 'dbt run -s b && dbt run -s c' + const slow = $.tool.call(bash(other)) + await clock.advance(4_001) + expect(((await slow) as any).deny).toContain('still being estimated') + release() + await clock.settle() + const retry: any = await $.tool.call(bash(other)) + expect(retry.deny).toContain('20.0 GiB') + expect(ran).toEqual([]) +}) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 11f31402..a44f5715 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -174,7 +174,12 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: // What is already known to be over the limit stays held, so a failed estimate on the retry cannot free it. if (over.length > 0) { const worst = over.reduce((a, b) => (b.bytes > a.bytes ? b : a)) - await update($, costAtom, prev => ({ ...(prev ?? FRESH), held: { command: e.command, target: worst.label, bytes: worst.bytes, display: worst.display } })) + await update($, costAtom, prev => { + const current = prev ?? FRESH + // An allowance belongs to the command it was given for: another command's hold does not inherit it. + const same = current.held?.command === e.command + return { ...current, allowOnce: same && current.allowOnce, held: { command: e.command, target: worst.label, bytes: worst.bytes, display: worst.display } } + }) } notes.delete(e.command) return { deny: `The scan of ${pending.join(', ')} is still being estimated (the dbt adapter may be starting). Run the same command again in a moment.` } From d056a3551d3dc2dfa8cdb5eb19e7c7322837ea0c Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Tue, 17 Nov 2026 13:47:57 +0530 Subject: [PATCH 19/56] fix: start no further cost estimate once the gate wait is spent; list a pending model once; catch the done-time write --- plugins/altimate-code/hooks/altimate-cli.ts | 5 ++-- .../hooks/features/cost.test.tsx | 27 +++++++++++++++++++ plugins/altimate-code/hooks/features/cost.tsx | 6 +++-- 3 files changed, 34 insertions(+), 4 deletions(-) diff --git a/plugins/altimate-code/hooks/altimate-cli.ts b/plugins/altimate-code/hooks/altimate-cli.ts index 6fb0d6b4..c8b41eee 100644 --- a/plugins/altimate-code/hooks/altimate-cli.ts +++ b/plugins/altimate-code/hooks/altimate-cli.ts @@ -120,8 +120,9 @@ export type RunToolOptions = { /** * The tool needs write permission (it starts the dbt adapter, or changes something): the call goes * through the CLI with `--allow-write`, since the plugin's MCP server runs read-only. runTool asks - * nobody: a caller sets it only once the user has said yes to this write (README, "How it works", - * item 4), as the skill does before it adds `--allow-write`. + * nobody. A caller sets it either once the user has said yes to this write (README, "How it works", + * item 4), as the skill does before it adds `--allow-write`, or for a tool that only reads and needs + * the adapter started, as the cost gate's estimate does. */ write?: boolean } diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index a318d05b..06d827ee 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -495,6 +495,33 @@ test('the same model named twice on a line is estimated once, so a slow estimate expect(ran).toEqual([line]) }) +test('once the wait is spent no further estimate starts, so two adapters never start in one project at once', async ($, on) => { + const options: Options = { answers: { a: UNDER, b: UNDER } } + const { clock, estimates } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + const first = $.tool.call(bash('dbt run -s a && dbt run -s b')) + await clock.advance(4_001) + const denied: any = await first + expect(denied.deny).toContain('The scan of a, b is still being estimated') + release() + await clock.settle() + // b was never started: only one adapter start runs at a time. + expect(estimates).toEqual(['a']) +}) + +test('a model named twice on a line is listed once as still being estimated', async ($, on) => { + const options: Options = { answers: { orders: UNDER } } + const { clock } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + const first = $.tool.call(bash('dbt run -s orders && dbt show -s orders')) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('The scan of orders is still being estimated') + release() + await clock.settle() +}) + test('a compound command gets every answer over its retries, however long each estimate takes', async ($, on) => { const options: Options = { answers: { a: UNDER, b: UNDER, c: UNDER } } const { clock, estimates, ran } = await start($, on, options) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index a44f5715..017d49c0 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -143,7 +143,7 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: const label = target.model ?? 'the inline query' const answer = await estimateWithin($, target.model ? { model: target.model } : { sql: target.sql }, waitUntil, taken) if (answer === 'pending') { - pending.push(label) + if (!pending.includes(label)) pending.push(label) continue } if (answer.kind === 'unsupported') { @@ -406,8 +406,10 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: let running = inflight.get(key) if (running?.doneAt != null && (await $.clock.now()) - running.doneAt > ANSWER_KEEP_MS) running = undefined if (!running) { + // The wait is spent: nothing new starts. Each estimate may start the adapter (dbt deps), and two at once in one project collide. + if (waitUntil - (await $.clock.now()) <= 0) return 'pending' const entry: { answer: Promise; doneAt: number | null } = { answer: estimate($, args, (await $.clock.now()) + ESTIMATE_BUDGET_MS), doneAt: null } - void entry.answer.then(async () => void (entry.doneAt = await $.clock.now())) + void entry.answer.then(async () => void (entry.doneAt = await $.clock.now())).catch(() => {}) inflight.set(key, entry) running = entry } From 6780b313759e098e0990f120fc98cb98a906d29e Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Tue, 17 Nov 2026 14:07:37 +0530 Subject: [PATCH 20/56] fix: an edit or a shell change voids the estimates made before it; a no-dry-run warehouse is asked about again; document the merge limit and the one setting in use --- .../altimate-code/.claude-plugin/plugin.json | 2 +- plugins/altimate-code/README.md | 4 +- .../hooks/features/cost.test.tsx | 93 +++++++++++++++++++ plugins/altimate-code/hooks/features/cost.tsx | 60 ++++++++++-- 4 files changed, 149 insertions(+), 10 deletions(-) diff --git a/plugins/altimate-code/.claude-plugin/plugin.json b/plugins/altimate-code/.claude-plugin/plugin.json index 36146926..99b7cc4c 100644 --- a/plugins/altimate-code/.claude-plugin/plugin.json +++ b/plugins/altimate-code/.claude-plugin/plugin.json @@ -25,7 +25,7 @@ "maxScanBytes": { "type": "number", "title": "Largest BigQuery scan without asking", - "description": "A dbt run or build of one named model, or a show of one model or with --inline, that BigQuery estimates would scan more bytes than this is held until you allow it with /allow-scan. A whole-project run, a graph selection or a command with options that change the target, state, vars, project or refresh mode, or one run after a non-dbt command, is not estimated, so it is never held. 0 never holds one. Other warehouses are never held.", + "description": "A dbt run or build of one named model, or a show of one model or with --inline, that BigQuery estimates would scan more bytes than this is held until you allow it with /allow-scan. A whole-project run, a graph selection or a command with options that change the target, state, vars, project or refresh mode, or one run after a non-dbt command, is not estimated, so it is never held. 0 never holds one. Other warehouses are never held. The size is that of the model's query: an incremental merge's extra scan of its existing table is not counted.", "default": 10737418240, "min": 0 }, diff --git a/plugins/altimate-code/README.md b/plugins/altimate-code/README.md index e2594739..6cbc752e 100644 --- a/plugins/altimate-code/README.md +++ b/plugins/altimate-code/README.md @@ -136,11 +136,11 @@ Rule drafting uses altimate-code's own model (sign in to the Altimate LLM Gatewa ## Settings -The plugin has five settings, shown when you enable it (`userConfig` in `.claude-plugin/plugin.json`). None is used yet: the features that read them are not in this version, so changing one changes nothing. The table says what each will control. +The plugin has five settings, shown when you enable it (`userConfig` in `.claude-plugin/plugin.json`). Only `maxScanBytes` is used in this version; changing any other changes nothing yet. The table says what each controls. | Setting | Default | What it controls | | --- | --- | --- | -| `maxScanBytes` | 10 GiB | The largest BigQuery scan a dbt run, build or show may make before it waits for your approval (0 never waits; at least 0). Other warehouses are never held. | +| `maxScanBytes` | 10 GiB | The largest BigQuery scan a dbt run, build or show may make before it waits for your approval (0 never waits; at least 0). Other warehouses are never held. The size is that of the model's query: the extra scan of an incremental merge on a large existing table is not counted. | | `healthBlocksPush` | off | When on, `git push` is refused while the project health check finds new issues in the models you changed. Off, the issues are only shown. | | `healthConfigPath` | empty | The DataPilot health check config file, relative to the dbt project. Empty uses the default checks. | | `commentsPollSeconds` | 900 | How often the team's comments on shared docs are fetched again (at least 30). | diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 06d827ee..df89bf45 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -542,6 +542,99 @@ test('a compound command gets every answer over its retries, however long each e expect(ran).toEqual([all]) }) +const EDIT = { tool: 'Edit', file_path: '/repo/models/orders.sql', old_string: '1', new_string: '2' } as any +const NO_DRY_RUN = { success: true, supported: false, adapter: 'duckdb' } + +test('an edit made while an estimate is running makes its answer void: the command is asked about again', async ($, on) => { + const options: Options = { answers: { orders: UNDER } } + const { clock, estimates, ran } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + const first = $.tool.call(bash('dbt run -s orders')) + await clock.advance(1_000) + await $.tool.call(EDIT) + options.answers = { orders: OVER } + release() + await clock.settle() + expect(((await first) as any).deny).toContain('still being estimated') + expect(ran).toEqual([]) + + options.hold = undefined + const retry: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(retry.deny).toContain('20.0 GiB') + expect(estimates).toEqual(['orders', 'orders']) +}) + +test('a shell command that can rewrite the model drops the estimates made before it', async ($, on) => { + const options: Options = { answers: { orders: UNDER } } + const { clock, estimates, ran } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + const first = $.tool.call(bash('dbt run -s orders')) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + release() + await clock.settle() + + await $.tool.call(bash('git restore models/orders.sql')) + options.hold = undefined + options.answers = { orders: OVER } + const retry: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(retry.deny).toContain('20.0 GiB') + expect(ran).toEqual(['git restore models/orders.sql']) + expect(estimates).toEqual(['orders', 'orders']) +}) + +test('a read-only shell command keeps the answer waiting for the retry', async ($, on) => { + const options: Options = { answers: { orders: UNDER } } + const { clock, estimates } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + const first = $.tool.call(bash('dbt run -s orders')) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + release() + await clock.settle() + await $.tool.call(bash('ls models')) + options.hold = undefined + const retry: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(retry.deny).toBeUndefined() + expect(estimates).toEqual(['orders']) +}) + +test('a warehouse found to have no dry run is asked about again after an edit, a profile change or ten minutes', async ($, on) => { + const options: Options = { answers: { orders: NO_DRY_RUN } } + const { clock, ran } = await start($, on, options) + const run = () => $.tool.call(bash('dbt run -s orders')) as Promise + expect((await run()).deny).toBeUndefined() + + // The default target is now BigQuery: the next command is estimated and held. + options.answers = { orders: OVER } + expect((await run()).deny).toBeUndefined() + await $.tool.call(EDIT) + expect((await run()).deny).toContain('20.0 GiB') + + // The same by a shell command that names the profile. + options.answers = { orders: NO_DRY_RUN } + await $.command.run({ command: 'allow-scan', args: '' } as any) + expect((await run()).deny).toBeUndefined() + options.answers = { orders: OVER } + await $.tool.call(bash('sed -i s/duckdb/bigquery/ profiles.yml')) + expect((await run()).deny).toContain('20.0 GiB') + + // And by time alone. + options.answers = { orders: NO_DRY_RUN } + await $.command.run({ command: 'allow-scan', args: '' } as any) + expect((await run()).deny).toBeUndefined() + options.answers = { orders: OVER } + await clock.advance(10 * 60_000 + 1) + expect((await run()).deny).toContain('20.0 GiB') + expect(ran.length).toBeGreaterThan(0) +}) + test('an edit drops the estimates made before it', async ($, on) => { const options: Options = { answers: { orders: UNDER } } const { clock, estimates, ran } = await start($, on, options) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 017d49c0..78f99045 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -44,7 +44,16 @@ let limitBytes = DEFAULT_MAX_SCAN_BYTES /** The lines to show under an estimated command's Bash row, by command; each gate pass replaces the last. Taken by bashAfter. */ const notes = new Map() /** Estimates still running past the gate's wait, by what they ask about; the next gate pass for the same target takes the answer. */ -const inflight = new Map; doneAt: number | null }>() +const inflight = new Map; doneAt: number | null; generation: number }>() +/** Moves on whenever the project may have changed: an estimate started before it is never taken as an answer. */ +let generation = 0 +/** When the session found a warehouse with no dry run; null once forgotten. That finding is kept only so long, since the target can change. */ +let unsupportedSince: number | null = null +const UNSUPPORTED_KEEP_MS = 10 * 60_000 +/** Commands that can rewrite a model, the project or its profile from the shell: an estimate made before one is not reused. */ +const MAY_CHANGE_PROJECT = /(^|[\s;&|(])(git|sed|awk|perl|python3?|node|bun|patch|mv|cp|rm|tee|touch|dbt|make|sh|bash|dd|ed|ex)(\s|$)|>/ +/** Files and variables that decide which warehouse a dbt command runs on. */ +const MOVES_TARGET = /profiles\.yml|dbt_project\.yml|dbt\.json|DBT_|--target|-t\s|\.env/ /** An answer nobody took within this long is dropped: the model may have changed since. */ const ANSWER_KEEP_MS = 60_000 @@ -75,6 +84,7 @@ export function register(on: On, context: FeatureContext) { } const answer = await estimate($, { model: target }, (await $.clock.now()) + ESTIMATE_BUDGET_MS) if (answer.kind === 'bytes') { + await forgetUnsupported($) await rememberEstimate($, target, answer.bytes, answer.display) return { text: `${target} would scan ${answer.display}${verdict(answer.maxBytes)}` } } @@ -86,6 +96,8 @@ export function register(on: On, context: FeatureContext) { export async function sessionStart($: EngineInterface, e: Args<'session.start'>) { notes.clear() inflight.clear() + generation++ + unsupportedSince = null await update($, costAtom, () => ({ ...FRESH })) await setStatusPart($, 'cost', null) await $.command.register({ name: 'allow-scan', description: 'Let the dbt command held for its BigQuery scan size run once, when run again unchanged' }) @@ -122,8 +134,13 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: const invocations = all.filter(i => i.subcommand !== null && SCANNING.has(i.subcommand)) if (invocations.length === 0) return null const state = (await read($, costAtom)) ?? FRESH - // A warehouse with no dry run was found out already: the command is never held, and nothing is asked again. - if (state.unsupportedAdapter) return null + // A warehouse with no dry run was found out already: the command is never held, and nothing is asked again, + // until an edit or a command that can move the target, or time, says it may have changed. + if (state.unsupportedAdapter) { + if (unsupportedSince != null && (await $.clock.now()) - unsupportedSince < UNSUPPORTED_KEEP_MS) return null + await forgetUnsupported($) + state.unsupportedAdapter = null + } const lines: string[] = [] let estimated = false @@ -148,6 +165,7 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: } if (answer.kind === 'unsupported') { // Nothing can be held on this warehouse, so a hold from before the verdict goes with it. + unsupportedSince = await $.clock.now() await update($, costAtom, prev => ({ ...(prev ?? FRESH), unsupportedAdapter: answer.adapter, held: null, allowOnce: false })) await setStatusPart($, 'cost', null) lines.push(`cost · no estimate on ${answer.adapter}: only BigQuery has a dry run`) @@ -244,15 +262,32 @@ function keepNotes(command: string, lines: string[]) { export async function bashAfter($: EngineInterface, e: BashCall, result: ToolCallResult): Promise { const lines = notes.get(e.command) notes.delete(e.command) + // A shell command can rewrite a model or the profile (a git restore, a sed): no earlier estimate is reused after one. + if (MAY_CHANGE_PROJECT.test(e.command) && !parseDbtCommand(e.command).some(i => i.subcommand !== null && SCANNING.has(i.subcommand))) { + invalidate() + if (MOVES_TARGET.test(e.command)) await forgetUnsupported($) + } return lines } /** `file.before` holds the text from before the edit only when `editReadsBefore` is true. */ export async function editAfter($: EngineInterface, e: FileCall, result: ToolCallResult, file: EditedFile): Promise { - // An edit can change what a model scans: no estimate made before it is reused. + // An edit can change what a model scans, or the target it runs on: no estimate made before it is reused. + invalidate() + await forgetUnsupported($) +} + +function invalidate() { + generation++ inflight.clear() } +/** Forgets a warehouse found to have no dry run, so the next dbt command is asked about again. */ +async function forgetUnsupported($: EngineInterface) { + unsupportedSince = null + await update($, costAtom, prev => (prev?.unsupportedAdapter ? { ...prev, unsupportedAdapter: null } : prev)) +} + export async function readOrEditAfter($: EngineInterface, e: FileCall, result: ToolCallResult, file: { path: string }): Promise {} /** Whether `editAfter` needs the file's text from before the edit (one extra read per edit). */ @@ -403,12 +438,18 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: const key = JSON.stringify(args) const had = taken.get(key) if (had) return had + // The look-up and the insert below are one step: nothing is awaited between them, or two passes would each start one. + const now = await $.clock.now() let running = inflight.get(key) - if (running?.doneAt != null && (await $.clock.now()) - running.doneAt > ANSWER_KEEP_MS) running = undefined + if (running?.doneAt != null && now - running.doneAt > ANSWER_KEEP_MS) running = undefined if (!running) { // The wait is spent: nothing new starts. Each estimate may start the adapter (dbt deps), and two at once in one project collide. - if (waitUntil - (await $.clock.now()) <= 0) return 'pending' - const entry: { answer: Promise; doneAt: number | null } = { answer: estimate($, args, (await $.clock.now()) + ESTIMATE_BUDGET_MS), doneAt: null } + if (waitUntil - now <= 0) return 'pending' + const entry: { answer: Promise; doneAt: number | null; generation: number } = { + answer: estimate($, args, now + ESTIMATE_BUDGET_MS), + doneAt: null, + generation, + } void entry.answer.then(async () => void (entry.doneAt = await $.clock.now())).catch(() => {}) inflight.set(key, entry) running = entry @@ -416,6 +457,11 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: const left = waitUntil - (await $.clock.now()) const done = left > 0 ? await within($, left, running.answer.then(answer => ({ answer }))) : null if (!done) return 'pending' + // The project may have changed while it ran: that answer is of the old one, and the next pass asks again. + if (running.generation !== generation) { + if (inflight.get(key) === running) inflight.delete(key) + return 'pending' + } // Not dropped here: while another query of the command is pending, the retry still needs this answer. taken.set(key, done.answer) return done.answer From b4d09a521184b239777c6a261996f0d1c21b12e3 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Tue, 17 Nov 2026 14:19:50 +0530 Subject: [PATCH 21/56] fix: a shell line that rewrites the project voids earlier estimates, before it runs and after, even when it also runs dbt; a change while the answers arrive refuses the command --- plugins/altimate-code/README.md | 2 +- .../hooks/features/cost.test.tsx | 55 ++++++++++++++++++- plugins/altimate-code/hooks/features/cost.tsx | 29 +++++++++- 3 files changed, 81 insertions(+), 5 deletions(-) diff --git a/plugins/altimate-code/README.md b/plugins/altimate-code/README.md index 6cbc752e..f3f435e4 100644 --- a/plugins/altimate-code/README.md +++ b/plugins/altimate-code/README.md @@ -140,7 +140,7 @@ The plugin has five settings, shown when you enable it (`userConfig` in `.claude | Setting | Default | What it controls | | --- | --- | --- | -| `maxScanBytes` | 10 GiB | The largest BigQuery scan a dbt run, build or show may make before it waits for your approval (0 never waits; at least 0). Other warehouses are never held. The size is that of the model's query: the extra scan of an incremental merge on a large existing table is not counted. | +| `maxScanBytes` | 10 GiB | The largest BigQuery scan a dbt run, build or show may make before it waits for your approval (0 never waits; at least 0). Other warehouses are never held. The size is that of the model's query: the extra scan of an incremental merge on a large existing table is not counted. A line that rewrites a model and runs it in one command is estimated on the model as it was before the line. | | `healthBlocksPush` | off | When on, `git push` is refused while the project health check finds new issues in the models you changed. Off, the issues are only shown. | | `healthConfigPath` | empty | The DataPilot health check config file, relative to the dbt project. Empty uses the default checks. | | `commentsPollSeconds` | 900 | How often the team's comments on shared docs are fetched again (at least 30). | diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index df89bf45..cfa9446f 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -14,6 +14,8 @@ type Options = { hold?: Promise /** With `hold`: only the estimate of this model or SQL waits. */ holdFor?: string + /** The Bash tool runs this command only once this resolves. */ + holdBash?: { command: string; until: Promise } } /** The session beneath the plugin, a CLI whose dbt_cost_estimate is scripted, and a Bash tool that records what ran. */ @@ -55,7 +57,8 @@ async function start($: any, on: any, options: Options = {}) { return { value: { exitCode: 0, stdout: JSON.stringify({ status: 'ok', output: '', metadata: answer ?? { success: false, error: 'no answer scripted' } }), stderr: '' } } }) // The Bash tool itself, beneath the plugin. - on('tool.call', (_: unknown, e: { tool: string; command?: string }) => { + on('tool.call', async (_: unknown, e: { tool: string; command?: string }) => { + if (e.tool === 'Bash' && options.holdBash?.command === e.command) await options.holdBash.until if (e.tool === 'Bash') ran.push(String(e.command)) return { result: { text: 'ok', isError: false } } }) @@ -556,7 +559,7 @@ test('an edit made while an estimate is running makes its answer void: the comma options.answers = { orders: OVER } release() await clock.settle() - expect(((await first) as any).deny).toContain('still being estimated') + expect(((await first) as any).deny).toContain('The project changed while the scan was being estimated') expect(ran).toEqual([]) options.hold = undefined @@ -635,6 +638,54 @@ test('a warehouse found to have no dry run is asked about again after an edit, a expect(ran.length).toBeGreaterThan(0) }) +test('a shell line that rewrites the model and also runs dbt voids the estimates made before it', async ($, on) => { + const options: Options = { answers: { orders: UNDER, cheap: UNDER } } + const { clock, estimates } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + options.holdFor = 'orders' + const first = $.tool.call(bash('dbt run -s orders')) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + release() + await clock.settle() + + await $.tool.call(bash('git restore models/orders.sql && dbt run -s cheap')) + await clock.settle() + options.hold = undefined + options.answers = { orders: OVER, cheap: UNDER } + const retry: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(retry.deny).toContain('20.0 GiB') + expect(estimates.filter(key => key === 'orders')).toEqual(['orders', 'orders']) +}) + +test('a command that is rewriting the model voids the estimates before it ends, not only after', async ($, on) => { + const options: Options = { answers: { orders: UNDER } } + const { clock, estimates } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + const first = $.tool.call(bash('dbt run -s orders')) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + release() + await clock.settle() + + // The rewrite is still running (its after-hook has not come) when the retry asks. + let finish!: () => void + options.holdBash = { command: 'sed -i s/a/b/ models/orders.sql; sleep 10', until: new Promise(resolve => (finish = resolve)) } + const rewrite = $.tool.call(bash('sed -i s/a/b/ models/orders.sql; sleep 10')) + await clock.advance(1_000) + options.hold = undefined + options.answers = { orders: OVER } + const retry: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(retry.deny).toContain('20.0 GiB') + expect(estimates).toEqual(['orders', 'orders']) + finish() + await rewrite +}) + test('an edit drops the estimates made before it', async ($, on) => { const options: Options = { answers: { orders: UNDER } } const { clock, estimates, ran } = await start($, on, options) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 78f99045..1b3b4133 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -51,7 +51,19 @@ let generation = 0 let unsupportedSince: number | null = null const UNSUPPORTED_KEEP_MS = 10 * 60_000 /** Commands that can rewrite a model, the project or its profile from the shell: an estimate made before one is not reused. */ -const MAY_CHANGE_PROJECT = /(^|[\s;&|(])(git|sed|awk|perl|python3?|node|bun|patch|mv|cp|rm|tee|touch|dbt|make|sh|bash|dd|ed|ex)(\s|$)|>/ +const MAY_CHANGE_PROJECT = /(^|[\s;&|(])(git|sed|awk|perl|python3?|node|bun|patch|mv|cp|rm|tee|touch|make|sh|bash|dd|ed|ex)(\s|$)|>/ +/** The dbt subcommands that change nothing in the project. */ +const READS_ONLY = new Set(['run', 'build', 'show', 'compile', 'ls', 'list', 'debug', 'parse']) + +/** Whether the command can rewrite a model or the profile: any part of the line, with the dbt calls that only read set aside. */ +function mutates(command: string): boolean { + const all = parseDbtCommand(command) + if (all.some(i => i.subcommand !== null && !READS_ONLY.has(i.subcommand))) return true + let rest = command + for (const i of [...all].sort((a, b) => b.start - a.start)) rest = rest.slice(0, i.start) + ' ' + rest.slice(i.end) + return MAY_CHANGE_PROJECT.test(rest) +} + /** Files and variables that decide which warehouse a dbt command runs on. */ const MOVES_TARGET = /profiles\.yml|dbt_project\.yml|dbt\.json|DBT_|--target|-t\s|\.env/ /** An answer nobody took within this long is dropped: the model may have changed since. */ @@ -130,9 +142,16 @@ export async function bashRewrite($: EngineInterface, e: BashCall): Promise { if (limitBytes <= 0) return null + // Before it runs, not only after: another call can ask while a long command is rewriting the project. + if (mutates(e.command)) { + invalidate() + if (MOVES_TARGET.test(e.command)) await forgetUnsupported($) + } const all = parseDbtCommand(e.command) const invocations = all.filter(i => i.subcommand !== null && SCANNING.has(i.subcommand)) if (invocations.length === 0) return null + // An edit or a command that changed the project while the answers were coming in makes them void. + const startedAt = generation const state = (await read($, costAtom)) ?? FRESH // A warehouse with no dry run was found out already: the command is never held, and nothing is asked again, // until an edit or a command that can move the target, or time, says it may have changed. @@ -184,6 +203,12 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: else over.push({ label, bytes: answer.maxBytes, point: answer.bytes, display: answer.display }) } + if (generation !== startedAt) { + inflight.clear() + notes.delete(e.command) + return { deny: 'The project changed while the scan was being estimated. Run the same command again.' } + } + // A finished command's answers are taken: a later one asks again. A pending one keeps them for its retry. if (pending.length === 0) for (const key of taken.keys()) inflight.delete(key) @@ -263,7 +288,7 @@ export async function bashAfter($: EngineInterface, e: BashCall, result: ToolCal const lines = notes.get(e.command) notes.delete(e.command) // A shell command can rewrite a model or the profile (a git restore, a sed): no earlier estimate is reused after one. - if (MAY_CHANGE_PROJECT.test(e.command) && !parseDbtCommand(e.command).some(i => i.subcommand !== null && SCANNING.has(i.subcommand))) { + if (mutates(e.command)) { invalidate() if (MOVES_TARGET.test(e.command)) await forgetUnsupported($) } From 6b04f3dda62f063f9341d689c37f9551a3008058 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Tue, 17 Nov 2026 14:28:17 +0530 Subject: [PATCH 22/56] fix: a refused command's retry keeps its estimate; a void answer is never published; the status line cannot decide the gate --- .../hooks/features/cost.test.tsx | 48 +++++++++++++++++++ plugins/altimate-code/hooks/features/cost.tsx | 31 +++++++++--- 2 files changed, 73 insertions(+), 6 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index cfa9446f..9825e51d 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -14,6 +14,8 @@ type Options = { hold?: Promise /** With `hold`: only the estimate of this model or SQL waits. */ holdFor?: string + /** Drawing the status line throws. */ + statusFails?: boolean /** The Bash tool runs this command only once this resolves. */ holdBash?: { command: string; until: Promise } } @@ -32,6 +34,7 @@ async function start($: any, on: any, options: Options = {}) { on('session.root', () => ({ value: ROOT })) on('ui.log', () => ({ value: undefined })) on('ui.status', (_: unknown, e: { text?: string }) => { + if (options.statusFails) throw new Error('no status line') statuses.push(e.text) return { value: undefined } }) @@ -686,6 +689,51 @@ test('a command that is rewriting the model voids the estimates before it ends, await rewrite }) +test('a slow estimate for a line that also redirects its output is used on the retry, not asked for again', async ($, on) => { + const options: Options = { answers: { orders: UNDER } } + const { clock, estimates, ran } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + const line = 'dbt run -s orders > run.log' + const first = $.tool.call(bash(line)) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + release() + await clock.settle() + options.hold = undefined + const retry: any = await $.tool.call(bash(line)) + await clock.settle() + expect(retry.deny).toBeUndefined() + expect(estimates).toEqual(['orders']) + expect(ran).toEqual([line]) +}) + +test('a no-dry-run answer that an edit made void is not kept as the warehouse', async ($, on) => { + const options: Options = { answers: { orders: NO_DRY_RUN } } + const { clock } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + const first = $.tool.call(bash('dbt run -s orders')) + await clock.advance(1_000) + await $.tool.call(EDIT) + release() + await clock.settle() + expect(((await first) as any).deny).toContain('The project changed') + options.hold = undefined + options.answers = { orders: OVER } + const retry: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(retry.deny).toContain('20.0 GiB') +}) + +test('a status line that cannot be drawn does not let a scan over the limit through', async ($, on) => { + const { clock, ran } = await start($, on, { answers: { orders: OVER }, statusFails: true }) + const result: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(result.deny).toContain('20.0 GiB') + expect(ran).toEqual([]) +}) + test('an edit drops the estimates made before it', async ($, on) => { const options: Options = { answers: { orders: UNDER } } const { clock, estimates, ran } = await start($, on, options) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 1b3b4133..b5ff4727 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -45,6 +45,8 @@ let limitBytes = DEFAULT_MAX_SCAN_BYTES const notes = new Map() /** Estimates still running past the gate's wait, by what they ask about; the next gate pass for the same target takes the answer. */ const inflight = new Map; doneAt: number | null; generation: number }>() +/** Commands the gate refused while their estimate was running: they have not run, so a retry changes nothing. */ +const refused = new Set() /** Moves on whenever the project may have changed: an estimate started before it is never taken as an answer. */ let generation = 0 /** When the session found a warehouse with no dry run; null once forgotten. That finding is kept only so long, since the target can change. */ @@ -108,6 +110,7 @@ export function register(on: On, context: FeatureContext) { export async function sessionStart($: EngineInterface, e: Args<'session.start'>) { notes.clear() inflight.clear() + refused.clear() generation++ unsupportedSince = null await update($, costAtom, () => ({ ...FRESH })) @@ -143,7 +146,8 @@ export async function bashRewrite($: EngineInterface, e: BashCall): Promise { if (limitBytes <= 0) return null // Before it runs, not only after: another call can ask while a long command is rewriting the project. - if (mutates(e.command)) { + // A command refused for its estimate has not run: its retry is not a change, and keeps the answers it waited for. + if (mutates(e.command) && !refused.has(e.command)) { invalidate() if (MOVES_TARGET.test(e.command)) await forgetUnsupported($) } @@ -178,6 +182,8 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: } const label = target.model ?? 'the inline query' const answer = await estimateWithin($, target.model ? { model: target.model } : { sql: target.sql }, waitUntil, taken) + // The project changed while this was being asked: nothing it says is published, and the command is refused below. + if (generation !== startedAt) break if (answer === 'pending') { if (!pending.includes(label)) pending.push(label) continue @@ -185,8 +191,9 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: if (answer.kind === 'unsupported') { // Nothing can be held on this warehouse, so a hold from before the verdict goes with it. unsupportedSince = await $.clock.now() + if (generation !== startedAt) break await update($, costAtom, prev => ({ ...(prev ?? FRESH), unsupportedAdapter: answer.adapter, held: null, allowOnce: false })) - await setStatusPart($, 'cost', null) + await showStatus($, null) lines.push(`cost · no estimate on ${answer.adapter}: only BigQuery has a dry run`) over.length = 0 pending.length = 0 @@ -225,6 +232,7 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: }) } notes.delete(e.command) + refused.add(e.command) return { deny: `The scan of ${pending.join(', ')} is still being estimated (the dbt adapter may be starting). Run the same command again in a moment.` } } @@ -250,7 +258,7 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: return null } notes.delete(e.command) - await setStatusPart($, 'cost', `scan held ≈ ${worst.display}`) + await showStatus($, `scan held ≈ ${worst.display}`) // The hold is decided on the upper bound, and the display is the rounded point estimate: either can read // as not over the limit when the scan is just past it. const scanned = @@ -268,7 +276,7 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: if (estimated && (state.held || state.allowOnce)) { await update($, costAtom, prev => (prev?.held || prev?.allowOnce ? { ...prev, held: null, allowOnce: false } : prev)) const last = (await read($, costAtom))?.lastEstimate - await setStatusPart($, 'cost', last ? `scan ≈ ${last.display}` : null) + await showStatus($, last ? `scan ≈ ${last.display}` : null) } keepNotes(e.command, lines) return null @@ -287,6 +295,7 @@ function keepNotes(command: string, lines: string[]) { export async function bashAfter($: EngineInterface, e: BashCall, result: ToolCallResult): Promise { const lines = notes.get(e.command) notes.delete(e.command) + refused.delete(e.command) // A shell command can rewrite a model or the profile (a git restore, a sed): no earlier estimate is reused after one. if (mutates(e.command)) { invalidate() @@ -493,8 +502,18 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: } async function rememberEstimate($: EngineInterface, target: string, bytes: number, display: string) { - await update($, costAtom, prev => ({ ...(prev ?? FRESH), lastEstimate: { target, bytes, display } })) - await setStatusPart($, 'cost', `scan ≈ ${display}`) + // What is shown never decides the gate: a failure here must not let a scan the gate knows is over the limit through. + try { + await update($, costAtom, prev => ({ ...(prev ?? FRESH), lastEstimate: { target, bytes, display } })) + await setStatusPart($, 'cost', `scan ≈ ${display}`) + } catch {} +} + +/** The status line's cost part; a failure to draw it is dropped. */ +async function showStatus($: EngineInterface, text: string | null) { + try { + await setStatusPart($, 'cost', text) + } catch {} } /** What an estimate means against the limit, as a sentence tail for /scan-cost. */ From 3037a5c1e5c66d61534929059371264bdaad9982 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Tue, 17 Nov 2026 16:20:08 +0530 Subject: [PATCH 23/56] fix: only writing git commands and real redirects void the estimates; any rewrite forgets a no-dry-run verdict Co-Authored-By: Claude Sonnet 5.5 --- .../hooks/features/cost.test.tsx | 31 +++++++++++++++++++ plugins/altimate-code/hooks/features/cost.tsx | 12 ++++--- 2 files changed, 38 insertions(+), 5 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 9825e51d..7d5be3e3 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -641,6 +641,37 @@ test('a warehouse found to have no dry run is asked about again after an edit, a expect(ran.length).toBeGreaterThan(0) }) +test('a git read or a redirect to another stream does not drop the estimate the retry is waiting for', async ($, on) => { + const options: Options = { answers: { orders: UNDER } } + const { clock, estimates } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + const first = $.tool.call(bash('dbt run -s orders')) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + release() + await clock.settle() + await $.tool.call(bash('git status')) + await $.tool.call(bash('git diff --stat 2>&1')) + await $.tool.call(bash('ls models 2>/dev/null')) + options.hold = undefined + const retry: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(retry.deny).toBeUndefined() + expect(estimates).toEqual(['orders']) +}) + +test('a git restore that does not name the profile still makes the no-dry-run verdict forgotten', async ($, on) => { + const options: Options = { answers: { orders: NO_DRY_RUN } } + const { clock } = await start($, on, options) + const run = () => $.tool.call(bash('dbt run -s orders')) as Promise + expect((await run()).deny).toBeUndefined() + options.answers = { orders: OVER } + await $.tool.call(bash('git checkout .')) + await clock.settle() + expect((await run()).deny).toContain('20.0 GiB') +}) + test('a shell line that rewrites the model and also runs dbt voids the estimates made before it', async ($, on) => { const options: Options = { answers: { orders: UNDER, cheap: UNDER } } const { clock, estimates } = await start($, on, options) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index b5ff4727..2739fe62 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -53,7 +53,7 @@ let generation = 0 let unsupportedSince: number | null = null const UNSUPPORTED_KEEP_MS = 10 * 60_000 /** Commands that can rewrite a model, the project or its profile from the shell: an estimate made before one is not reused. */ -const MAY_CHANGE_PROJECT = /(^|[\s;&|(])(git|sed|awk|perl|python3?|node|bun|patch|mv|cp|rm|tee|touch|make|sh|bash|dd|ed|ex)(\s|$)|>/ +const MAY_CHANGE_PROJECT = /(^|[\s;&|(])(git\s+(-\S+\s+)*(checkout|restore|reset|stash|apply|clean|switch|merge|rebase|pull|cherry-pick|revert|am|rm|mv|worktree)|sed|awk|perl|python3?|node|bun|patch|mv|cp|rm|tee|touch|make|sh|bash|dd|ed|ex)(\s|$)|>/ /** The dbt subcommands that change nothing in the project. */ const READS_ONLY = new Set(['run', 'build', 'show', 'compile', 'ls', 'list', 'debug', 'parse']) @@ -63,11 +63,11 @@ function mutates(command: string): boolean { if (all.some(i => i.subcommand !== null && !READS_ONLY.has(i.subcommand))) return true let rest = command for (const i of [...all].sort((a, b) => b.start - a.start)) rest = rest.slice(0, i.start) + ' ' + rest.slice(i.end) + // A redirect to another stream or to /dev/null writes nothing in the project. + rest = rest.replace(/\d*>&\d+|\d*>>?\s*\/dev\/null/g, ' ') return MAY_CHANGE_PROJECT.test(rest) } -/** Files and variables that decide which warehouse a dbt command runs on. */ -const MOVES_TARGET = /profiles\.yml|dbt_project\.yml|dbt\.json|DBT_|--target|-t\s|\.env/ /** An answer nobody took within this long is dropped: the model may have changed since. */ const ANSWER_KEEP_MS = 60_000 @@ -149,7 +149,8 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: // A command refused for its estimate has not run: its retry is not a change, and keeps the answers it waited for. if (mutates(e.command) && !refused.has(e.command)) { invalidate() - if (MOVES_TARGET.test(e.command)) await forgetUnsupported($) + // Any rewrite can bring back another target (a git restore does not name the profile). + await forgetUnsupported($) } const all = parseDbtCommand(e.command) const invocations = all.filter(i => i.subcommand !== null && SCANNING.has(i.subcommand)) @@ -299,7 +300,8 @@ export async function bashAfter($: EngineInterface, e: BashCall, result: ToolCal // A shell command can rewrite a model or the profile (a git restore, a sed): no earlier estimate is reused after one. if (mutates(e.command)) { invalidate() - if (MOVES_TARGET.test(e.command)) await forgetUnsupported($) + // Any rewrite can bring back another target (a git restore does not name the profile). + await forgetUnsupported($) } return lines } From ee95359e660ed3b5780218b5d2d303afb42f62e1 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Tue, 17 Nov 2026 16:26:26 +0530 Subject: [PATCH 24/56] fix: backticks and dollar signs inside single quotes do not stop an inline query being estimated; a cd forgets the no-dry-run verdict Co-Authored-By: Claude Sonnet 5.5 --- .../hooks/features/cost.test.tsx | 25 +++++++++++++++++++ plugins/altimate-code/hooks/features/cost.tsx | 21 ++++++++++++++-- 2 files changed, 44 insertions(+), 2 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 7d5be3e3..cd687c66 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -104,6 +104,31 @@ test('dbt show --inline is estimated from its SQL', async ($, on) => { expect(result.deny).toContain('20.0 GiB') }) +test('a BigQuery table name in backticks inside single quotes is estimated; a backtick outside them is not', async ($, on) => { + const q = 'select * from `p.d.t`' + const { clock, estimates } = await start($, on, { answers: { [q]: OVER } }) + const result: any = await $.tool.call(bash(`dbt show --inline '${q}'`)) + await clock.settle() + expect(estimates).toEqual([q]) + expect(result.deny).toContain('20.0 GiB') + const before = estimates.length + await $.tool.call(bash('dbt show --inline "select 1" --target `echo prod`')) + await $.tool.call(bash('dbt show --inline "select `echo 1`"')) + await clock.settle() + expect(estimates.length).toBe(before) +}) + +test('a cd to another directory makes the no-dry-run verdict forgotten', async ($, on) => { + const options: Options = { answers: { orders: NO_DRY_RUN } } + const { clock } = await start($, on, options) + const run = () => $.tool.call(bash('dbt run -s orders')) as Promise + expect((await run()).deny).toBeUndefined() + options.answers = { orders: OVER } + await $.tool.call(bash('cd ../bigquery-project')) + await clock.settle() + expect((await run()).deny).toContain('20.0 GiB') +}) + test('/allow-scan lets the next held command through once, then the one after is held again', async ($, on) => { const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } }) expect((await $.tool.call(bash('dbt run -s orders')) as any).deny).toBeDefined() diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 2739fe62..9d87e6f4 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -53,7 +53,7 @@ let generation = 0 let unsupportedSince: number | null = null const UNSUPPORTED_KEEP_MS = 10 * 60_000 /** Commands that can rewrite a model, the project or its profile from the shell: an estimate made before one is not reused. */ -const MAY_CHANGE_PROJECT = /(^|[\s;&|(])(git\s+(-\S+\s+)*(checkout|restore|reset|stash|apply|clean|switch|merge|rebase|pull|cherry-pick|revert|am|rm|mv|worktree)|sed|awk|perl|python3?|node|bun|patch|mv|cp|rm|tee|touch|make|sh|bash|dd|ed|ex)(\s|$)|>/ +const MAY_CHANGE_PROJECT = /(^|[\s;&|(])(git\s+(-\S+\s+)*(checkout|restore|reset|stash|apply|clean|switch|merge|rebase|pull|cherry-pick|revert|am|rm|mv|worktree)|cd|pushd|popd|sed|awk|perl|python3?|node|bun|patch|mv|cp|rm|tee|touch|make|sh|bash|dd|ed|ex)(\s|$)|>/ /** The dbt subcommands that change nothing in the project. */ const READS_ONLY = new Set(['run', 'build', 'show', 'compile', 'ls', 'list', 'debug', 'parse']) @@ -342,6 +342,23 @@ const SELECT_FLAGS = new Set(['-s', '--select', '-m', '--models', '--model']) /** Flags without a value that leave the project, target and compiled SQL as they are. */ const PLAIN_FLAGS = new Set(['--fail-fast', '-x', '--quiet', '-q']) +/** Whether the shell would expand a `$` or a backtick on the line: inside single quotes (a BigQuery table name, say) they are literal. */ +function expands(command: string): boolean { + let quote: string | null = null + for (let i = 0; i < command.length; i++) { + const c = command[i]! + if (quote === "'") { + if (c === "'") quote = null + } else if (c === '\\') i++ + else if (quote === '"') { + if (c === '"') quote = null + else if (c === '$' || c === '`') return true + } else if (c === "'" || c === '"') quote = c + else if (c === '$' || c === '`') return true + } + return false +} + /** * Whether the estimate would be of what the invocation runs. It asks about the session's project at its * default target, so it is only so when the line moves neither: the dbt launcher is plain, nothing @@ -352,7 +369,7 @@ const PLAIN_FLAGS = new Set(['--fail-fast', '-x', '--quiet', '-q']) function isPlainInvocation(command: string, invocation: DbtInvocation, all: DbtInvocation[]): boolean { // The shell expands `$` and backticks anywhere on the line (arguments, redirections, an earlier call) into // flags or environment this check can't see; a line with many calls is not worth reading call by call. - if (/[$`]/.test(command) || all.length > MAX_INVOCATIONS) return false + if (expands(command) || all.length > MAX_INVOCATIONS) return false if (!PLAIN_LAUNCHER.test(invocation.binary)) return false let before = command.slice(0, invocation.start) for (const earlier of all.filter(one => one.end <= invocation.start).reverse()) { From 0627c081d79ce882bd23b9478c125f2ac9deefea Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Tue, 17 Nov 2026 16:33:18 +0530 Subject: [PATCH 25/56] fix: a command that keeps being retried keeps its finished estimates, so a slow later estimate cannot expire an earlier one forever Co-Authored-By: Claude Sonnet 5.5 --- .../hooks/features/cost.test.tsx | 28 +++++++++++++++++++ plugins/altimate-code/hooks/features/cost.tsx | 14 ++++++---- 2 files changed, 36 insertions(+), 6 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index cd687c66..a9e3a72d 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -487,6 +487,34 @@ test('an estimate still running spends no allowance: the held command stays held expect(ran).toEqual([both]) }) +test('a command being retried keeps its finished answers however long the later estimate took', async ($, on) => { + const options: Options = { answers: { a: UNDER, b: UNDER } } + const { clock, estimates } = await start($, on, options) + const both = 'dbt run -s a && dbt run -s b' + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + options.holdFor = 'b' + const first = $.tool.call(bash(both)) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + // b takes longer than the answer for a is kept for a command nobody retries. + const waiting = [] as any[] + for (let i = 0; i < 7; i++) { + await clock.advance(10_000) + const again = $.tool.call(bash(both)) + await clock.advance(4_001) + waiting.push((await again) as any) + } + expect(waiting.every(w => w.deny.includes('still being estimated'))).toBe(true) + release() + await clock.settle() + options.hold = undefined + const retry: any = await $.tool.call(bash(both)) + await clock.settle() + expect(retry.deny).toBeUndefined() + expect(estimates).toEqual(['a', 'b']) +}) + test('an answer nobody took is not used a minute later: the model may have changed', async ($, on) => { const options: Options = { answers: { orders: OVER } } const { clock, estimates, ran } = await start($, on, options) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 9d87e6f4..da5ba859 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -45,8 +45,8 @@ let limitBytes = DEFAULT_MAX_SCAN_BYTES const notes = new Map() /** Estimates still running past the gate's wait, by what they ask about; the next gate pass for the same target takes the answer. */ const inflight = new Map; doneAt: number | null; generation: number }>() -/** Commands the gate refused while their estimate was running: they have not run, so a retry changes nothing. */ -const refused = new Set() +/** Commands the gate refused while their estimate was running, and when it last did: they have not run, so a retry changes nothing. */ +const refused = new Map() /** Moves on whenever the project may have changed: an estimate started before it is never taken as an answer. */ let generation = 0 /** When the session found a warehouse with no dry run; null once forgotten. That finding is kept only so long, since the target can change. */ @@ -182,7 +182,7 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: continue } const label = target.model ?? 'the inline query' - const answer = await estimateWithin($, target.model ? { model: target.model } : { sql: target.sql }, waitUntil, taken) + const answer = await estimateWithin($, target.model ? { model: target.model } : { sql: target.sql }, waitUntil, taken, refused.get(e.command)) // The project changed while this was being asked: nothing it says is published, and the command is refused below. if (generation !== startedAt) break if (answer === 'pending') { @@ -233,7 +233,7 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: }) } notes.delete(e.command) - refused.add(e.command) + refused.set(e.command, await $.clock.now()) return { deny: `The scan of ${pending.join(', ')} is still being estimated (the dbt adapter may be starting). Run the same command again in a moment.` } } @@ -487,14 +487,16 @@ async function estimate($: EngineInterface, args: { model?: string; sql?: string } /** The estimate, started on the long budget if none is running for these arguments; `pending` when it is not done by `waitUntil`. */ -async function estimateWithin($: EngineInterface, args: { model?: string; sql?: string }, waitUntil: number, taken: Map): Promise { +async function estimateWithin($: EngineInterface, args: { model?: string; sql?: string }, waitUntil: number, taken: Map, refusedAt: number | undefined): Promise { const key = JSON.stringify(args) const had = taken.get(key) if (had) return had // The look-up and the insert below are one step: nothing is awaited between them, or two passes would each start one. const now = await $.clock.now() let running = inflight.get(key) - if (running?.doneAt != null && now - running.doneAt > ANSWER_KEEP_MS) running = undefined + // A command whose retries keep coming keeps what it waited for however long the others took: a later answer expiring an earlier one would never let it finish. + const retrying = refusedAt != null && now - refusedAt <= ANSWER_KEEP_MS + if (running?.doneAt != null && !retrying && now - running.doneAt > ANSWER_KEEP_MS) running = undefined if (!running) { // The wait is spent: nothing new starts. Each estimate may start the adapter (dbt deps), and two at once in one project collide. if (waitUntil - now <= 0) return 'pending' From 0d115b4cd18b1aa1b369ceb9696b684f0acb9b42 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Tue, 17 Nov 2026 21:04:34 +0530 Subject: [PATCH 26/56] Keep main's tsconfig.json Co-Authored-By: Claude Sonnet 5.5 --- plugins/altimate-code/tsconfig.json | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 plugins/altimate-code/tsconfig.json diff --git a/plugins/altimate-code/tsconfig.json b/plugins/altimate-code/tsconfig.json new file mode 100644 index 00000000..8681ec01 --- /dev/null +++ b/plugins/altimate-code/tsconfig.json @@ -0,0 +1,3 @@ +{ + "extends": "./.claude-plugin/types/tsconfig.json" +} From 2172c44c60840e558d6a9832ff6f7a22d1089a29 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 07:05:18 +0530 Subject: [PATCH 27/56] fix(cost): git global options with a separate value, a cd keeps estimates, cheap rejection first Co-Authored-By: Claude Opus 5.5 --- .../hooks/features/cost.test.tsx | 37 +- plugins/altimate-code/hooks/features/cost.tsx | 43 +- .../node_modules/.vite/vitest/CACHEDIR.TAG | 3 + .../results.json | 1 + .../01827a3d74da33920570f783b18edea8eb8d7b82 | 472 ++++++++++++++++++ .../node_modules/.vitest-cache/CACHEDIR.TAG | 3 + .../node_modules/.vitest-cache/_metadata.json | 3 + 7 files changed, 545 insertions(+), 17 deletions(-) create mode 100644 plugins/altimate-code/node_modules/.vite/vitest/CACHEDIR.TAG create mode 100644 plugins/altimate-code/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json create mode 100644 plugins/altimate-code/node_modules/.vitest-cache/01827a3d74da33920570f783b18edea8eb8d7b82 create mode 100644 plugins/altimate-code/node_modules/.vitest-cache/CACHEDIR.TAG create mode 100644 plugins/altimate-code/node_modules/.vitest-cache/_metadata.json diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index a9e3a72d..68592d88 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -112,7 +112,7 @@ test('a BigQuery table name in backticks inside single quotes is estimated; a ba expect(estimates).toEqual([q]) expect(result.deny).toContain('20.0 GiB') const before = estimates.length - await $.tool.call(bash('dbt show --inline "select 1" --target `echo prod`')) + await $.tool.call(bash('dbt show --inline "select 1" --threads `echo 4`')) await $.tool.call(bash('dbt show --inline "select `echo 1`"')) await clock.settle() expect(estimates.length).toBe(before) @@ -664,6 +664,41 @@ test('a read-only shell command keeps the answer waiting for the retry', async ( expect(estimates).toEqual(['orders']) }) +test('a cd keeps the answer waiting for the retry', async ($, on) => { + const options: Options = { answers: { orders: UNDER } } + const { clock, estimates } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + const first = $.tool.call(bash('dbt run -s orders')) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + release() + await clock.settle() + await $.tool.call(bash('cd models')) + options.hold = undefined + const retry: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(retry.deny).toBeUndefined() + expect(estimates).toEqual(['orders']) +}) + +for (const restore of [ + 'git -C /repo checkout .', + 'git -c core.fsmonitor=false restore .', + 'git --git-dir /x --work-tree /y reset --hard', +]) { +test(`${restore} makes the no-dry-run verdict forgotten`, async ($, on) => { + const options: Options = { answers: { orders: NO_DRY_RUN } } + const { clock } = await start($, on, options) + const run = () => $.tool.call(bash('dbt run -s orders')) as Promise + expect((await run()).deny).toBeUndefined() + options.answers = { orders: OVER } + await $.tool.call(bash(restore)) + await clock.settle() + expect((await run()).deny).toContain('20.0 GiB') +}) +} + test('a warehouse found to have no dry run is asked about again after an edit, a profile change or ten minutes', async ($, on) => { const options: Options = { answers: { orders: NO_DRY_RUN } } const { clock, ran } = await start($, on, options) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index da5ba859..5f70a2f6 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -53,21 +53,40 @@ let generation = 0 let unsupportedSince: number | null = null const UNSUPPORTED_KEEP_MS = 10 * 60_000 /** Commands that can rewrite a model, the project or its profile from the shell: an estimate made before one is not reused. */ -const MAY_CHANGE_PROJECT = /(^|[\s;&|(])(git\s+(-\S+\s+)*(checkout|restore|reset|stash|apply|clean|switch|merge|rebase|pull|cherry-pick|revert|am|rm|mv|worktree)|cd|pushd|popd|sed|awk|perl|python3?|node|bun|patch|mv|cp|rm|tee|touch|make|sh|bash|dd|ed|ex)(\s|$)|>/ +const MAY_CHANGE_PROJECT = /(^|[\s;&|(])(git\s+((-[Cc]|--git-dir|--namespace|--work-tree)\s+\S+\s+|-\S+\s+)*(checkout|restore|reset|stash|apply|clean|switch|merge|rebase|pull|cherry-pick|revert|am|worktree)|sed|awk|perl|python3?|node|bun|patch|mv|cp|rm|tee|touch|make|sh|bash|dd|ed|ex)(\s|$)|>/ +/** Commands that can move the session to another project or target without rewriting a file. */ +const MOVES_DIRECTORY = /(^|[\s;&|(])(cd|pushd|popd)(\s|$)/ /** The dbt subcommands that change nothing in the project. */ const READS_ONLY = new Set(['run', 'build', 'show', 'compile', 'ls', 'list', 'debug', 'parse']) -/** Whether the command can rewrite a model or the profile: any part of the line, with the dbt calls that only read set aside. */ -function mutates(command: string): boolean { +/** The command with the dbt calls that only read, and the redirects that write nothing, set aside. */ +function withoutReads(command: string): { all: DbtInvocation[]; rest: string } { const all = parseDbtCommand(command) - if (all.some(i => i.subcommand !== null && !READS_ONLY.has(i.subcommand))) return true let rest = command for (const i of [...all].sort((a, b) => b.start - a.start)) rest = rest.slice(0, i.start) + ' ' + rest.slice(i.end) // A redirect to another stream or to /dev/null writes nothing in the project. - rest = rest.replace(/\d*>&\d+|\d*>>?\s*\/dev\/null/g, ' ') + return { all, rest: rest.replace(/\d*>&\d+|\d*>>?\s*\/dev\/null/g, ' ') } +} + +/** Whether the command can rewrite a model or the profile: any part of the line, with the dbt calls that only read set aside. */ +function mutates(all: DbtInvocation[], rest: string): boolean { + if (all.some(i => i.subcommand !== null && !READS_ONLY.has(i.subcommand))) return true return MAY_CHANGE_PROJECT.test(rest) } +/** What a shell command did to the project: a rewrite voids the estimates and the verdict; a directory change only the verdict. */ +async function afterShellChange($: EngineInterface, command: string) { + const { all, rest } = withoutReads(command) + if (mutates(all, rest)) { + invalidate() + // Any rewrite can bring back another target (a git restore does not name the profile). + await forgetUnsupported($) + } else if (MOVES_DIRECTORY.test(rest)) { + // A cd cannot rewrite a model, so an estimate that is still coming in stays good; only the target may differ. + await forgetUnsupported($) + } +} + /** An answer nobody took within this long is dropped: the model may have changed since. */ const ANSWER_KEEP_MS = 60_000 @@ -147,11 +166,7 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: if (limitBytes <= 0) return null // Before it runs, not only after: another call can ask while a long command is rewriting the project. // A command refused for its estimate has not run: its retry is not a change, and keeps the answers it waited for. - if (mutates(e.command) && !refused.has(e.command)) { - invalidate() - // Any rewrite can bring back another target (a git restore does not name the profile). - await forgetUnsupported($) - } + if (!refused.has(e.command)) await afterShellChange($, e.command) const all = parseDbtCommand(e.command) const invocations = all.filter(i => i.subcommand !== null && SCANNING.has(i.subcommand)) if (invocations.length === 0) return null @@ -298,11 +313,7 @@ export async function bashAfter($: EngineInterface, e: BashCall, result: ToolCal notes.delete(e.command) refused.delete(e.command) // A shell command can rewrite a model or the profile (a git restore, a sed): no earlier estimate is reused after one. - if (mutates(e.command)) { - invalidate() - // Any rewrite can bring back another target (a git restore does not name the profile). - await forgetUnsupported($) - } + await afterShellChange($, e.command) return lines } @@ -369,7 +380,7 @@ function expands(command: string): boolean { function isPlainInvocation(command: string, invocation: DbtInvocation, all: DbtInvocation[]): boolean { // The shell expands `$` and backticks anywhere on the line (arguments, redirections, an earlier call) into // flags or environment this check can't see; a line with many calls is not worth reading call by call. - if (expands(command) || all.length > MAX_INVOCATIONS) return false + if (all.length > MAX_INVOCATIONS || expands(command)) return false if (!PLAIN_LAUNCHER.test(invocation.binary)) return false let before = command.slice(0, invocation.start) for (const earlier of all.filter(one => one.end <= invocation.start).reverse()) { diff --git a/plugins/altimate-code/node_modules/.vite/vitest/CACHEDIR.TAG b/plugins/altimate-code/node_modules/.vite/vitest/CACHEDIR.TAG new file mode 100644 index 00000000..8c1ef4ce --- /dev/null +++ b/plugins/altimate-code/node_modules/.vite/vitest/CACHEDIR.TAG @@ -0,0 +1,3 @@ +Signature: 8a477f597d28d172789f06886806bc55 +# This file is a cache directory tag created by Vitest. +# For information about cache directory tags see https://bford.info/cachedir/ diff --git a/plugins/altimate-code/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json b/plugins/altimate-code/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json new file mode 100644 index 00000000..93c7e71e --- /dev/null +++ b/plugins/altimate-code/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json @@ -0,0 +1 @@ +{"version":1,"projects":{"":{"files":{"hooks/features/cost.test.tsx":{"failed":true,"duration":0,"lastRun":1794805775627}}}}} \ No newline at end of file diff --git a/plugins/altimate-code/node_modules/.vitest-cache/01827a3d74da33920570f783b18edea8eb8d7b82 b/plugins/altimate-code/node_modules/.vitest-cache/01827a3d74da33920570f783b18edea8eb8d7b82 new file mode 100644 index 00000000..cdb1f273 --- /dev/null +++ b/plugins/altimate-code/node_modules/.vitest-cache/01827a3d74da33920570f783b18edea8eb8d7b82 @@ -0,0 +1,472 @@ +const __vite_ssr_import_0__ = await __vite_ssr_import__("claude-code/testing", {"importedNames":["expect","mock","test"]}); +const __vite_ssr_import_1__ = await __vite_ssr_import__("/hooks/features/cost.tsx", {"importedNames":["formatBytes","inlineSql"]}); +const __vite_ssr_import_2__ = await __vite_ssr_import__("react/jsx-dev-runtime", {"importedNames":["jsxDEV"]}); + + +var _jsxFileName = "/Users/harish/.quikim/workspaces/altimate-claude-plugin/feat/dbt-cost-estimate-tool/plugins/altimate-code/hooks/features/cost.test.tsx"; + +const ROOT = "/repo"; +const GIB = 1024 ** 3; +/** The session beneath the plugin, a CLI whose dbt_cost_estimate is scripted, and a Bash tool that records what ran. */ +async function start($, on, options = {}) { + const clock = __vite_ssr_import_0__.mock.clock(on); + const estimates = []; + const ran = []; + const statuses = []; + on("command.register", (_, e) => ({ value: { command: e.name } })); + on("turn.start", (_, e) => ({ turnId: e.turnId })); + on("session.end", () => ({ sessionId: "test" })); + on("turn.complete", (_, e) => ({ text: e.answer })); + on("session.start", (_, e) => ({ cwd: e.cwd })); + on("session.root", () => ({ value: ROOT })); + on("ui.log", () => ({ value: undefined })); + on("ui.status", (_, e) => { + statuses.push(e.text); + return { value: undefined }; + }); + on("ui.render", ($$, e) => { + const { Box } = $$.ui.resolve(e); + return /* @__PURE__ */ (0,__vite_ssr_import_2__.jsxDEV)(Box, {}, "engine", false, { + fileName: _jsxFileName, + lineNumber: 34, + columnNumber: 12 + }, this); + }); + on("fs.exists", () => ({ value: false })); + on("process.run", (_, e) => { + const [, command, , tool] = e.argv; + if (command !== "tool") return { value: { + exitCode: 1, + stdout: "", + stderr: "not this test" + } }; + (0,__vite_ssr_import_0__.expect)(tool).toBe("dbt_cost_estimate"); + // The adapter starts the project's dbt: the call must carry write permission. + (0,__vite_ssr_import_0__.expect)(e.argv).toContain("--allow-write"); + const args = JSON.parse(String(e.argv[e.argv.indexOf("--args") + 1] ?? "{}")); + const key = String(args.model ?? args.sql); + estimates.push(key); + const answer = options.answers?.[key] ?? options.fallback; + if (answer === "unknown-tool") { + return { value: { + exitCode: 1, + stdout: JSON.stringify({ + status: "error", + output: `Unknown tool: ${tool}. Run \`altimate-code tool list\` to see the available tools.`, + metadata: {} + }), + stderr: "" + } }; + }; + return { value: { + exitCode: 0, + stdout: JSON.stringify({ + status: "ok", + output: "", + metadata: answer ?? { + success: false, + error: "no answer scripted" + } + }), + stderr: "" + } }; + }); + // The Bash tool itself, beneath the plugin. + on("tool.call", (_, e) => { + if (e.tool === "Bash") ran.push(String(e.command)); + return { result: { + text: "ok", + isError: false + } }; + }); + await $.session.start({ + cwd: ROOT, + surface: "terminal", + isInteractive: true + }); + await clock.settle(); + return { + clock, + estimates, + ran, + statuses + }; +} +const bq = (bytes, display, maxBytes = bytes) => ({ + success: true, + supported: true, + adapter: "bigquery", + bytes, + maxBytes, + display +}); +const OVER = bq(20 * GIB, "20.0 GiB"); +const UNDER = bq(2 * GIB, "2.0 GiB"); +const bash = (command) => ({ + tool: "Bash", + command +}); +(0,__vite_ssr_import_0__.test)("a model over the limit is refused with its estimate, and the command never runs", async ($, on) => { + const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } }); + const result = await $.tool.call(bash("dbt run --select orders")); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["orders"]); + (0,__vite_ssr_import_0__.expect)(ran).toEqual([]); + (0,__vite_ssr_import_0__.expect)(result.deny).toBe("≈ 20.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again."); +}); +(0,__vite_ssr_import_0__.test)("a model under the limit runs, with the estimate in a line under the row", async ($, on) => { + const { clock, ran } = await start($, on, { answers: { orders: UNDER } }); + const result = await $.tool.call(bash("dbt build -s orders")); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt build -s orders"]); + (0,__vite_ssr_import_0__.expect)(result.context).toEqual(["cost · orders would scan 2.0 GiB"]); +}); +(0,__vite_ssr_import_0__.test)("dbt show --inline is estimated from its SQL", async ($, on) => { + const { clock, estimates } = await start($, on, { answers: { "select * from big": OVER } }); + const result = await $.tool.call(bash(`dbt show --inline "select * from big"`)); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["select * from big"]); + (0,__vite_ssr_import_0__.expect)(result.deny).toContain("20.0 GiB"); +}); +(0,__vite_ssr_import_0__.test)("/allow-scan lets the next held command through once, then the one after is held again", async ($, on) => { + const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); + const allowed = await $.command.run({ + command: "allow-scan", + args: "" + }); + (0,__vite_ssr_import_0__.expect)(allowed.text).toContain("runs once"); + const through = await $.tool.call(bash("dbt run -s orders")); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(through.deny).toBeUndefined(); + (0,__vite_ssr_import_0__.expect)(through.context).toEqual(["cost · orders would scan 20.0 GiB, over the 10.0 GiB limit: allowed once"]); + (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders"]); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); + (0,__vite_ssr_import_0__.expect)(estimates).toHaveLength(3); +}); +(0,__vite_ssr_import_0__.test)("a selection that is not one plain model passes, saying there is no estimate, and asks nothing", async ($, on) => { + const { clock, estimates, ran } = await start($, on); + for (const [command, why] of [ + ["dbt run", "no model named"], + ["dbt build -s +orders", "graph, tag, path or package selector"], + ["dbt run -s tag:nightly", "graph, tag, path or package selector"], + ["dbt run -s a b", "several selectors"] + ]) { + const result = await $.tool.call(bash(command)); + (0,__vite_ssr_import_0__.expect)(result.deny).toBeUndefined(); + (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain("cost · no estimate for this selection"); + (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain(why); + }; + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual([]); + (0,__vite_ssr_import_0__.expect)(ran).toHaveLength(4); +}); +(0,__vite_ssr_import_0__.test)("commands that scan nothing are not looked at", async ($, on) => { + const { clock, estimates, ran } = await start($, on); + for (const command of [ + "dbt test -s orders", + "dbt compile -s orders", + "ls", + "git status" + ]) await $.tool.call(bash(command)); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual([]); + (0,__vite_ssr_import_0__.expect)(ran).toHaveLength(4); +}); +(0,__vite_ssr_import_0__.test)("another warehouse is told once, never held, and not asked again", async ($, on) => { + const { clock, estimates, ran } = await start($, on, { fallback: { + success: true, + supported: false, + adapter: "snowflake" + } }); + const first = await $.tool.call(bash("dbt run -s orders")); + const second = await $.tool.call(bash("dbt run -s customers")); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(first.deny).toBeUndefined(); + (0,__vite_ssr_import_0__.expect)(first.context).toEqual(["cost · no estimate on snowflake: only BigQuery has a dry run"]); + (0,__vite_ssr_import_0__.expect)(second.deny).toBeUndefined(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["orders"]); + (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders", "dbt run -s customers"]); +}); +(0,__vite_ssr_import_0__.test)("an altimate-code without the tool shows one line saying what is needed, and the command runs", async ($, on) => { + const { clock, ran } = await start($, on, { answers: { orders: "unknown-tool" } }); + const result = await $.tool.call(bash("dbt run -s orders")); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders"]); + (0,__vite_ssr_import_0__.expect)(result.context).toHaveLength(1); + (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain("needs a newer altimate-code"); +}); +(0,__vite_ssr_import_0__.test)("a dry run that failed passes the command with the reason", async ($, on) => { + const { clock, ran } = await start($, on, { answers: { orders: { + success: false, + error: "Access Denied: BigQuery job" + } } }); + const result = await $.tool.call(bash("dbt run -s orders")); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders"]); + (0,__vite_ssr_import_0__.expect)(result.context).toEqual(["cost · no estimate for orders: Access Denied: BigQuery job"]); +}); +(0,__vite_ssr_import_0__.test)("/scan-cost estimates a model on demand and says how it stands against the limit", async ($, on) => { + const { clock, estimates, ran } = await start($, on, { answers: { + orders: OVER, + customers: UNDER + } }); + (0,__vite_ssr_import_0__.expect)((await $.command.run({ + command: "scan-cost", + args: "orders" + })).text).toBe("orders would scan 20.0 GiB, over the 10.0 GiB limit: a dbt run of it is held until /allow-scan."); + (0,__vite_ssr_import_0__.expect)((await $.command.run({ + command: "scan-cost", + args: "customers" + })).text).toBe("customers would scan 2.0 GiB, within the 10.0 GiB limit."); + (0,__vite_ssr_import_0__.expect)((await $.command.run({ + command: "scan-cost", + args: "" + })).text).toContain("Last estimate: customers"); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["orders", "customers"]); + (0,__vite_ssr_import_0__.expect)(ran).toEqual([]); +}); +(0,__vite_ssr_import_0__.test)("a command naming two models over the limit is held whole, and one /allow-scan lets all of it through once", async ($, on) => { + const { clock, ran } = await start($, on, { answers: { + orders: OVER, + customers: bq(30 * GIB, "30.0 GiB") + } }); + const command = "dbt run -s orders && dbt run -s customers"; + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash(command))).deny).toContain("30.0 GiB"); + await $.command.run({ + command: "allow-scan", + args: "" + }); + const through = await $.tool.call(bash(command)); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(through.deny).toBeUndefined(); + (0,__vite_ssr_import_0__.expect)(through.context).toEqual(["cost · orders would scan 20.0 GiB, over the 10.0 GiB limit: allowed once", "cost · customers would scan 30.0 GiB, over the 10.0 GiB limit: allowed once"]); + (0,__vite_ssr_import_0__.expect)(ran).toEqual([command]); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash(command))).deny).toBeDefined(); +}); +(0,__vite_ssr_import_0__.test)("/allow-scan with nothing held allows nothing", async ($, on) => { + const { clock } = await start($, on, { answers: { orders: OVER } }); + (0,__vite_ssr_import_0__.expect)((await $.command.run({ + command: "allow-scan", + args: "" + })).text).toContain("Nothing is held"); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); + await clock.settle(); +}); +(0,__vite_ssr_import_0__.test)("the allowance is for the command that was held: another over-limit command is held, and the allowance is gone", async ($, on) => { + const { clock, ran } = await start($, on, { answers: { + orders: OVER, + customers: OVER + } }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); + await $.command.run({ + command: "allow-scan", + args: "" + }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s customers"))).deny).toBeDefined(); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(ran).toEqual([]); +}); +(0,__vite_ssr_import_0__.test)("an estimate whose rounded size is within the limit but whose upper bound is over it is held", async ($, on) => { + const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, "10.0 GiB", 10 * GIB + 52 * 1024 ** 2) } }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBe("up to 10.1 GiB (≈ 10.0 GiB estimated) would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again."); + await clock.settle(); +}); +(0,__vite_ssr_import_0__.test)("an upper bound that formats the same as the limit is not reported as equal to it", async ($, on) => { + const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, "10.0 GiB", 10 * GIB + 30 * 1024 ** 2) } }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBe("just over 10.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again."); + await clock.settle(); +}); +(0,__vite_ssr_import_0__.test)("a warehouse found to have no dry run ends a hold from before, and its allowance", async ($, on) => { + const answers = { orders: OVER }; + const { clock, ran, statuses } = await start($, on, { answers }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); + await $.command.run({ + command: "allow-scan", + args: "" + }); + answers.orders = { + success: true, + supported: false, + adapter: "snowflake" + }; + await $.tool.call(bash("dbt run -s orders")); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders"]); + (0,__vite_ssr_import_0__.expect)(statuses.at(-1) ?? "").not.toContain("held"); + (0,__vite_ssr_import_0__.expect)((await $.command.run({ + command: "allow-scan", + args: "" + })).text).toContain("Nothing is held"); +}); +(0,__vite_ssr_import_0__.test)("a scan just over the limit reads as over it, not as equal to it", async ($, on) => { + const { clock } = await start($, on, { answers: { orders: bq(10 * GIB + 1024 ** 2, "10.0 GiB") } }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBe("just over 10.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again."); + await clock.settle(); +}); +(0,__vite_ssr_import_0__.test)("a command that sets its own target, defer state, vars or project is not estimated", async ($, on) => { + const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } }); + const commands = [ + "dbt run -s orders --target prod", + "dbt run -s orders --defer --state prod-run", + `dbt run -s orders --vars '{a: 1}'`, + "dbt run -s orders --project-dir other", + "DBT_PROFILES_DIR=ci dbt run -s orders", + "cd other && dbt run -s orders", + " cd other && dbt run -s orders", + "export DBT_TARGET=prod; dbt run -s orders", + "uv run --directory other dbt run -s orders", + "dbt run -s orders --'vars' x", + "dbt run -s orders --full-refresh", + "dbt run -s orders --full-\\\nrefresh", + "if true; then cd other; fi; dbt run -s orders", + "dbt --profiles-dir ci run -s orders", + "FOO=1 dbt run -s orders", + "dbt run -s orders --threads $(printf '4 --target prod')", + "dbt run -s orders --threads `echo 4 --vars x`", + "dbt run -s orders 2>&${DBT_TARGET:=1}", + "dbt --log-path \"${DBT_TARGET:=prod}\" deps; dbt run -s orders" + ]; + for (const command of commands) { + const result = await $.tool.call(bash(command)); + (0,__vite_ssr_import_0__.expect)(result.deny).toBeUndefined(); + (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain("it sets its own target, defer state, vars, project or refresh mode"); + }; + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual([]); + (0,__vite_ssr_import_0__.expect)(ran).toEqual(commands); +}); +(0,__vite_ssr_import_0__.test)("dbt show --inline with its SQL on the next line after a backslash is estimated", async ($, on) => { + const { clock, estimates } = await start($, on, { answers: { "select * from big": OVER } }); + const result = await $.tool.call(bash(`dbt show --inline \\\n 'select * from big'`)); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["select * from big"]); + (0,__vite_ssr_import_0__.expect)(result.deny).toContain("20.0 GiB"); +}); +(0,__vite_ssr_import_0__.test)("letting a later command through clears the hold from the status line", async ($, on) => { + const { clock, statuses } = await start($, on, { answers: { + orders: OVER, + customers: UNDER + } }); + await $.tool.call(bash("dbt run -s orders")); + await $.tool.call(bash("dbt run -s customers")); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(statuses.filter(Boolean).at(-1)).not.toContain("held"); +}); +(0,__vite_ssr_import_0__.test)("a variant of the held command that is not estimated leaves the hold in place", async ($, on) => { + const { clock, ran } = await start($, on, { answers: { orders: OVER } }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); + await $.tool.call(bash("dbt run -s +orders")); + await $.tool.call(bash("dbt run -s orders --full-refresh")); + await clock.settle(); + await $.command.run({ + command: "allow-scan", + args: "" + }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeUndefined(); + (0,__vite_ssr_import_0__.expect)(ran.at(-1)).toBe("dbt run -s orders"); +}); +(0,__vite_ssr_import_0__.test)("a repeated --inline is estimated from the last one, as dbt reads it", async ($, on) => { + const { clock, estimates } = await start($, on, { answers: { "select * from big": OVER } }); + const result = await $.tool.call(bash(`dbt show --inline 'select 1' --inline 'select * from big'`)); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["select * from big"]); + (0,__vite_ssr_import_0__.expect)(result.deny).toContain("20.0 GiB"); +}); +(0,__vite_ssr_import_0__.test)("the lines under a command are the latest estimate of it, never an earlier one", async ($, on) => { + const answers = { orders: UNDER }; + const { clock } = await start($, on, { answers }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).context).toEqual(["cost · orders would scan 2.0 GiB"]); + answers.orders = bq(3 * GIB, "3.0 GiB"); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).context).toEqual(["cost · orders would scan 3.0 GiB"]); + await clock.settle(); +}); +(0,__vite_ssr_import_0__.test)("/allow-scan allows only the hold it read: a hold replaced meanwhile is not allowed", async ($, on) => { + const { clock, ran } = await start($, on, { answers: { + orders: OVER, + customers: OVER + } }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); + const allowing = $.command.run({ + command: "allow-scan", + args: "" + }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s customers"))).deny).toBeDefined(); + await allowing; + await clock.settle(); + // Whichever order the two steps took, customers (the later hold) is not allowed by a read of orders. + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s customers"))).deny).toBeDefined(); + (0,__vite_ssr_import_0__.expect)(ran).toEqual([]); +}); +(0,__vite_ssr_import_0__.test)("a non-dbt command in between neither clears the hold nor spends the allowance", async ($, on) => { + const { clock, ran } = await start($, on, { answers: { orders: OVER } }); + await $.tool.call(bash("dbt run -s orders")); + await $.command.run({ + command: "allow-scan", + args: "" + }); + await $.tool.call(bash("ls")); + const through = await $.tool.call(bash("dbt run -s orders")); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(through.deny).toBeUndefined(); + (0,__vite_ssr_import_0__.expect)(ran).toEqual(["ls", "dbt run -s orders"]); +}); +(0,__vite_ssr_import_0__.test)("inlineSql reads the query as the shell would", () => { + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline "select 'a' as x"`)).toBe(`select 'a' as x`); + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline='select 1'`)).toBe("select 1"); + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline select\\ 1 --limit 5`)).toBe("select 1"); + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline \\\n 'select 1'`)).toBe("select 1"); + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)("dbt show -s orders")).toBeNull(); + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline 'select 1' --inline='select 2'`)).toBe("select 2"); + // The value of --inline is the query, even when it looks like an option. + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline '--inline=comment select 1'`)).toBe("--inline=comment select 1"); +}); +(0,__vite_ssr_import_0__.test)("formatBytes writes the units the dry run does", () => { + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.formatBytes)(512)).toBe("512.0 Bytes"); + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.formatBytes)(1536)).toBe("1.5 KiB"); + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.formatBytes)(10 * GIB)).toBe("10.0 GiB"); + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.formatBytes)(1024 ** 5)).toBe("1.0 PiB"); +}); +(0,__vite_ssr_import_0__.test)("what leaves the query alone is still estimated: other dbt calls before it, thread and limit flags, a launcher", async ($, on) => { + const { clock, estimates } = await start($, on, { answers: { + orders: UNDER, + "select 1": UNDER + } }); + for (const command of [ + "dbt deps && dbt run -s orders --threads 4", + "uv run dbt build --select orders --fail-fast", + `dbt show --inline "select 1" --limit 5` + ]) { + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash(command))).context[0]).toContain("would scan 2.0 GiB"); + }; + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual([ + "orders", + "orders", + "select 1" + ]); +}); +(0,__vite_ssr_import_0__.test)("a very long run of blank lines before the command costs no noticeable time", async ($, on) => { + const { clock } = await start($, on, { answers: { orders: UNDER } }); + const began = Date.now(); + await $.tool.call(bash(`${"\n".repeat(64e3)}dbt run -s orders`)); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(Date.now() - began).toBeLessThan(3e3); +}); +(0,__vite_ssr_import_0__.test)("a line with a great many dbt calls is not read call by call", async ($, on) => { + const { clock, estimates } = await start($, on, { answers: { orders: UNDER } }); + const began = Date.now(); + const result = await $.tool.call(bash("dbt run -s orders;".repeat(4e3))); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual([]); + (0,__vite_ssr_import_0__.expect)(result.context.length).toBe(6); + (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain("cost · no estimate"); + (0,__vite_ssr_import_0__.expect)(result.context[5]).toBe("cost · 3995 more notes not shown"); + (0,__vite_ssr_import_0__.expect)(Date.now() - began).toBeLessThan(3e3); +}); +//# sourceMappingSource=vite-generated +//# sourceMappingURL=data:application/json;base64,{"version":3,"mappings":"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","names":[],"ignoreList":[],"sources":["cost.test.tsx"],"sourcesContent":["import { expect, mock, test } from 'claude-code/testing'\n\nimport { formatBytes, inlineSql } from './cost'\n\nconst ROOT = '/repo'\nconst GIB = 1024 ** 3\n\ntype Options = {\n  /** What dbt_cost_estimate answers for a model or SQL, by model name or the SQL text. */\n  answers?: Record<string, Record<string, unknown> | 'unknown-tool'>\n  /** The adapter's answer for everything else. */\n  fallback?: Record<string, unknown>\n}\n\n/** The session beneath the plugin, a CLI whose dbt_cost_estimate is scripted, and a Bash tool that records what ran. */\nasync function start($: any, on: any, options: Options = {}) {\n  const clock = mock.clock(on)\n  const estimates: string[] = []\n  const ran: string[] = []\n  const statuses: (string | undefined)[] = []\n  on('command.register', (_: unknown, e: { name: string }) => ({ value: { command: e.name } }))\n  on('turn.start', (_: unknown, e: { turnId: string }) => ({ turnId: e.turnId }))\n  on('session.end', () => ({ sessionId: 'test' }))\n  on('turn.complete', (_: unknown, e: { answer: string }) => ({ text: e.answer }))\n  on('session.start', (_: unknown, e: { cwd: string }) => ({ cwd: e.cwd }))\n  on('session.root', () => ({ value: ROOT }))\n  on('ui.log', () => ({ value: undefined }))\n  on('ui.status', (_: unknown, e: { text?: string }) => {\n    statuses.push(e.text)\n    return { value: undefined }\n  })\n  on('ui.render', ($$: any, e: any) => {\n    const { Box } = $$.ui.resolve(e)\n    return <Box key=\"engine\" />\n  })\n  on('fs.exists', () => ({ value: false }))\n  on('process.run', (_: unknown, e: { argv: readonly string[] }) => {\n    const [, command, , tool] = e.argv\n    if (command !== 'tool') return { value: { exitCode: 1, stdout: '', stderr: 'not this test' } }\n    expect(tool).toBe('dbt_cost_estimate')\n    // The adapter starts the project's dbt: the call must carry write permission.\n    expect(e.argv).toContain('--allow-write')\n    const args = JSON.parse(String(e.argv[e.argv.indexOf('--args') + 1] ?? '{}'))\n    const key = String(args.model ?? args.sql)\n    estimates.push(key)\n    const answer = options.answers?.[key] ?? options.fallback\n    if (answer === 'unknown-tool') {\n      return { value: { exitCode: 1, stdout: JSON.stringify({ status: 'error', output: `Unknown tool: ${tool}. Run \\`altimate-code tool list\\` to see the available tools.`, metadata: {} }), stderr: '' } }\n    }\n    return { value: { exitCode: 0, stdout: JSON.stringify({ status: 'ok', output: '', metadata: answer ?? { success: false, error: 'no answer scripted' } }), stderr: '' } }\n  })\n  // The Bash tool itself, beneath the plugin.\n  on('tool.call', (_: unknown, e: { tool: string; command?: string }) => {\n    if (e.tool === 'Bash') ran.push(String(e.command))\n    return { result: { text: 'ok', isError: false } }\n  })\n  await $.session.start({ cwd: ROOT, surface: 'terminal', isInteractive: true })\n  await clock.settle()\n  return { clock, estimates, ran, statuses }\n}\n\nconst bq = (bytes: number, display: string, maxBytes = bytes) => ({ success: true, supported: true, adapter: 'bigquery', bytes, maxBytes, display })\nconst OVER = bq(20 * GIB, '20.0 GiB')\nconst UNDER = bq(2 * GIB, '2.0 GiB')\n\nconst bash = (command: string) => ({ tool: 'Bash' as const, command })\n\ntest('a model over the limit is refused with its estimate, and the command never runs', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } })\n  const result: any = await $.tool.call(bash('dbt run --select orders'))\n  await clock.settle()\n\n  expect(estimates).toEqual(['orders'])\n  expect(ran).toEqual([])\n  expect(result.deny).toBe('≈ 20.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.')\n})\n\ntest('a model under the limit runs, with the estimate in a line under the row', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: UNDER } })\n  const result: any = await $.tool.call(bash('dbt build -s orders'))\n  await clock.settle()\n\n  expect(ran).toEqual(['dbt build -s orders'])\n  expect(result.context).toEqual(['cost · orders would scan 2.0 GiB'])\n})\n\ntest('dbt show --inline is estimated from its SQL', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { 'select * from big': OVER } })\n  const result: any = await $.tool.call(bash(`dbt show --inline \"select * from big\"`))\n  await clock.settle()\n\n  expect(estimates).toEqual(['select * from big'])\n  expect(result.deny).toContain('20.0 GiB')\n})\n\ntest('/allow-scan lets the next held command through once, then the one after is held again', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } })\n  expect((await $.tool.call(bash('dbt run -s orders')) as any).deny).toBeDefined()\n\n  const allowed = await $.command.run({ command: 'allow-scan', args: '' } as any)\n  expect(allowed.text).toContain('runs once')\n  const through: any = await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n  expect(through.deny).toBeUndefined()\n  expect(through.context).toEqual(['cost · orders would scan 20.0 GiB, over the 10.0 GiB limit: allowed once'])\n  expect(ran).toEqual(['dbt run -s orders'])\n\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  expect(estimates).toHaveLength(3)\n})\n\ntest('a selection that is not one plain model passes, saying there is no estimate, and asks nothing', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on)\n  for (const [command, why] of [\n    ['dbt run', 'no model named'],\n    ['dbt build -s +orders', 'graph, tag, path or package selector'],\n    ['dbt run -s tag:nightly', 'graph, tag, path or package selector'],\n    ['dbt run -s a b', 'several selectors'],\n  ] as const) {\n    const result: any = await $.tool.call(bash(command))\n    expect(result.deny).toBeUndefined()\n    expect(result.context[0]).toContain('cost · no estimate for this selection')\n    expect(result.context[0]).toContain(why)\n  }\n  await clock.settle()\n  expect(estimates).toEqual([])\n  expect(ran).toHaveLength(4)\n})\n\ntest('commands that scan nothing are not looked at', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on)\n  for (const command of ['dbt test -s orders', 'dbt compile -s orders', 'ls', 'git status']) await $.tool.call(bash(command))\n  await clock.settle()\n  expect(estimates).toEqual([])\n  expect(ran).toHaveLength(4)\n})\n\ntest('another warehouse is told once, never held, and not asked again', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { fallback: { success: true, supported: false, adapter: 'snowflake' } })\n  const first: any = await $.tool.call(bash('dbt run -s orders'))\n  const second: any = await $.tool.call(bash('dbt run -s customers'))\n  await clock.settle()\n\n  expect(first.deny).toBeUndefined()\n  expect(first.context).toEqual(['cost · no estimate on snowflake: only BigQuery has a dry run'])\n  expect(second.deny).toBeUndefined()\n  expect(estimates).toEqual(['orders'])\n  expect(ran).toEqual(['dbt run -s orders', 'dbt run -s customers'])\n})\n\ntest('an altimate-code without the tool shows one line saying what is needed, and the command runs', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: 'unknown-tool' } })\n  const result: any = await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n\n  expect(ran).toEqual(['dbt run -s orders'])\n  expect(result.context).toHaveLength(1)\n  expect(result.context[0]).toContain('needs a newer altimate-code')\n})\n\ntest('a dry run that failed passes the command with the reason', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: { success: false, error: 'Access Denied: BigQuery job' } } })\n  const result: any = await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n\n  expect(ran).toEqual(['dbt run -s orders'])\n  expect(result.context).toEqual(['cost · no estimate for orders: Access Denied: BigQuery job'])\n})\n\ntest('/scan-cost estimates a model on demand and says how it stands against the limit', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER, customers: UNDER } })\n  expect((await $.command.run({ command: 'scan-cost', args: 'orders' } as any)).text).toBe(\n    'orders would scan 20.0 GiB, over the 10.0 GiB limit: a dbt run of it is held until /allow-scan.',\n  )\n  expect((await $.command.run({ command: 'scan-cost', args: 'customers' } as any)).text).toBe('customers would scan 2.0 GiB, within the 10.0 GiB limit.')\n  expect((await $.command.run({ command: 'scan-cost', args: '' } as any)).text).toContain('Last estimate: customers')\n  await clock.settle()\n  expect(estimates).toEqual(['orders', 'customers'])\n  expect(ran).toEqual([])\n})\n\ntest('a command naming two models over the limit is held whole, and one /allow-scan lets all of it through once', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER, customers: bq(30 * GIB, '30.0 GiB') } })\n  const command = 'dbt run -s orders && dbt run -s customers'\n  expect(((await $.tool.call(bash(command))) as any).deny).toContain('30.0 GiB')\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n  const through: any = await $.tool.call(bash(command))\n  await clock.settle()\n\n  expect(through.deny).toBeUndefined()\n  expect(through.context).toEqual([\n    'cost · orders would scan 20.0 GiB, over the 10.0 GiB limit: allowed once',\n    'cost · customers would scan 30.0 GiB, over the 10.0 GiB limit: allowed once',\n  ])\n  expect(ran).toEqual([command])\n  expect(((await $.tool.call(bash(command))) as any).deny).toBeDefined()\n})\n\ntest('/allow-scan with nothing held allows nothing', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: OVER } })\n  expect((await $.command.run({ command: 'allow-scan', args: '' } as any)).text).toContain('Nothing is held')\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await clock.settle()\n})\n\ntest('the allowance is for the command that was held: another over-limit command is held, and the allowance is gone', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER, customers: OVER } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n\n  expect(((await $.tool.call(bash('dbt run -s customers'))) as any).deny).toBeDefined()\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await clock.settle()\n  expect(ran).toEqual([])\n})\n\ntest('an estimate whose rounded size is within the limit but whose upper bound is over it is held', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, '10.0 GiB', 10 * GIB + 52 * 1024 ** 2) } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBe('up to 10.1 GiB (≈ 10.0 GiB estimated) would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.')\n  await clock.settle()\n})\n\ntest('an upper bound that formats the same as the limit is not reported as equal to it', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, '10.0 GiB', 10 * GIB + 30 * 1024 ** 2) } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBe('just over 10.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.')\n  await clock.settle()\n})\n\ntest('a warehouse found to have no dry run ends a hold from before, and its allowance', async ($, on) => {\n  const answers: Record<string, any> = { orders: OVER }\n  const { clock, ran, statuses } = await start($, on, { answers })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n  answers.orders = { success: true, supported: false, adapter: 'snowflake' }\n  await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n  expect(ran).toEqual(['dbt run -s orders'])\n  expect(statuses.at(-1) ?? '').not.toContain('held')\n  expect((await $.command.run({ command: 'allow-scan', args: '' } as any)).text).toContain('Nothing is held')\n})\n\ntest('a scan just over the limit reads as over it, not as equal to it', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: bq(10 * GIB + 1024 ** 2, '10.0 GiB') } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBe('just over 10.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.')\n  await clock.settle()\n})\n\ntest('a command that sets its own target, defer state, vars or project is not estimated', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } })\n  const commands = [\n    'dbt run -s orders --target prod',\n    'dbt run -s orders --defer --state prod-run',\n    `dbt run -s orders --vars '{a: 1}'`,\n    'dbt run -s orders --project-dir other',\n    'DBT_PROFILES_DIR=ci dbt run -s orders',\n    'cd other && dbt run -s orders',\n    ' cd other && dbt run -s orders',\n    'export DBT_TARGET=prod; dbt run -s orders',\n    'uv run --directory other dbt run -s orders',\n    \"dbt run -s orders --'vars' x\",\n    'dbt run -s orders --full-refresh',\n    'dbt run -s orders --full-\\\\\\nrefresh',\n    'if true; then cd other; fi; dbt run -s orders',\n    'dbt --profiles-dir ci run -s orders',\n    'FOO=1 dbt run -s orders',\n    \"dbt run -s orders --threads $(printf '4 --target prod')\",\n    'dbt run -s orders --threads `echo 4 --vars x`',\n    'dbt run -s orders 2>&${DBT_TARGET:=1}',\n    'dbt --log-path \"${DBT_TARGET:=prod}\" deps; dbt run -s orders',\n  ]\n  for (const command of commands) {\n    const result: any = await $.tool.call(bash(command))\n    expect(result.deny).toBeUndefined()\n    expect(result.context[0]).toContain('it sets its own target, defer state, vars, project or refresh mode')\n  }\n  await clock.settle()\n  expect(estimates).toEqual([])\n  expect(ran).toEqual(commands)\n})\n\ntest('dbt show --inline with its SQL on the next line after a backslash is estimated', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { 'select * from big': OVER } })\n  const result: any = await $.tool.call(bash(`dbt show --inline \\\\\\n  'select * from big'`))\n  await clock.settle()\n  expect(estimates).toEqual(['select * from big'])\n  expect(result.deny).toContain('20.0 GiB')\n})\n\ntest('letting a later command through clears the hold from the status line', async ($, on) => {\n  const { clock, statuses } = await start($, on, { answers: { orders: OVER, customers: UNDER } })\n  await $.tool.call(bash('dbt run -s orders'))\n  await $.tool.call(bash('dbt run -s customers'))\n  await clock.settle()\n  expect(statuses.filter(Boolean).at(-1)).not.toContain('held')\n})\n\ntest('a variant of the held command that is not estimated leaves the hold in place', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await $.tool.call(bash('dbt run -s +orders'))\n  await $.tool.call(bash('dbt run -s orders --full-refresh'))\n  await clock.settle()\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeUndefined()\n  expect(ran.at(-1)).toBe('dbt run -s orders')\n})\n\ntest('a repeated --inline is estimated from the last one, as dbt reads it', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { 'select * from big': OVER } })\n  const result: any = await $.tool.call(bash(`dbt show --inline 'select 1' --inline 'select * from big'`))\n  await clock.settle()\n  expect(estimates).toEqual(['select * from big'])\n  expect(result.deny).toContain('20.0 GiB')\n})\n\ntest('the lines under a command are the latest estimate of it, never an earlier one', async ($, on) => {\n  const answers: Record<string, any> = { orders: UNDER }\n  const { clock } = await start($, on, { answers })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).context).toEqual(['cost · orders would scan 2.0 GiB'])\n  answers.orders = bq(3 * GIB, '3.0 GiB')\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).context).toEqual(['cost · orders would scan 3.0 GiB'])\n  await clock.settle()\n})\n\ntest('/allow-scan allows only the hold it read: a hold replaced meanwhile is not allowed', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER, customers: OVER } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  const allowing = $.command.run({ command: 'allow-scan', args: '' } as any)\n  expect(((await $.tool.call(bash('dbt run -s customers'))) as any).deny).toBeDefined()\n  await allowing\n  await clock.settle()\n  // Whichever order the two steps took, customers (the later hold) is not allowed by a read of orders.\n  expect(((await $.tool.call(bash('dbt run -s customers'))) as any).deny).toBeDefined()\n  expect(ran).toEqual([])\n})\n\ntest('a non-dbt command in between neither clears the hold nor spends the allowance', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER } })\n  await $.tool.call(bash('dbt run -s orders'))\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n  await $.tool.call(bash('ls'))\n  const through: any = await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n  expect(through.deny).toBeUndefined()\n  expect(ran).toEqual(['ls', 'dbt run -s orders'])\n})\n\ntest('inlineSql reads the query as the shell would', () => {\n  expect(inlineSql(`dbt show --inline \"select 'a' as x\"`)).toBe(`select 'a' as x`)\n  expect(inlineSql(`dbt show --inline='select 1'`)).toBe('select 1')\n  expect(inlineSql(`dbt show --inline select\\\\ 1 --limit 5`)).toBe('select 1')\n  expect(inlineSql(`dbt show --inline \\\\\\n 'select 1'`)).toBe('select 1')\n  expect(inlineSql('dbt show -s orders')).toBeNull()\n  expect(inlineSql(`dbt show --inline 'select 1' --inline='select 2'`)).toBe('select 2')\n  // The value of --inline is the query, even when it looks like an option.\n  expect(inlineSql(`dbt show --inline '--inline=comment select 1'`)).toBe('--inline=comment select 1')\n})\n\ntest('formatBytes writes the units the dry run does', () => {\n  expect(formatBytes(512)).toBe('512.0 Bytes')\n  expect(formatBytes(1536)).toBe('1.5 KiB')\n  expect(formatBytes(10 * GIB)).toBe('10.0 GiB')\n  expect(formatBytes(1024 ** 5)).toBe('1.0 PiB')\n})\n\ntest('what leaves the query alone is still estimated: other dbt calls before it, thread and limit flags, a launcher', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { orders: UNDER, 'select 1': UNDER } })\n  for (const command of ['dbt deps && dbt run -s orders --threads 4', 'uv run dbt build --select orders --fail-fast', `dbt show --inline \"select 1\" --limit 5`]) {\n    expect(((await $.tool.call(bash(command))) as any).context[0]).toContain('would scan 2.0 GiB')\n  }\n  await clock.settle()\n  expect(estimates).toEqual(['orders', 'orders', 'select 1'])\n})\n\ntest('a very long run of blank lines before the command costs no noticeable time', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: UNDER } })\n  const began = Date.now()\n  await $.tool.call(bash(`${'\\n'.repeat(64000)}dbt run -s orders`))\n  await clock.settle()\n  expect(Date.now() - began).toBeLessThan(3000)\n})\n\ntest('a line with a great many dbt calls is not read call by call', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { orders: UNDER } })\n  const began = Date.now()\n  const result: any = await $.tool.call(bash('dbt run -s orders;'.repeat(4000)))\n  await clock.settle()\n  expect(estimates).toEqual([])\n  expect(result.context.length).toBe(6)\n  expect(result.context[0]).toContain('cost · no estimate')\n  expect(result.context[5]).toBe('cost · 3995 more notes not shown')\n  expect(Date.now() - began).toBeLessThan(3000)\n})\n"],"file":"/hooks/features/cost.test.tsx"} + +//# vitestCache=W3siZmlsZSI6IjEiLCJpZCI6IjEiLCJpbXBvcnRzIjoiMiIsIm1hcHBpbmdzIjpmYWxzZSwiZGVwcyI6IjMiLCJkeW5hbWljRGVwcyI6IjQiLCJzdGF0aWNNb2NrcyI6bnVsbCwiaGFzQ292ZXJhZ2VEYXRhIjpmYWxzZX0sIi9Vc2Vycy9oYXJpc2gvLnF1aWtpbS93b3Jrc3BhY2VzL2FsdGltYXRlLWNsYXVkZS1wbHVnaW4vZmVhdC9kYnQtY29zdC1lc3RpbWF0ZS10b29sL3BsdWdpbnMvYWx0aW1hdGUtY29kZS9ob29rcy9mZWF0dXJlcy9jb3N0LnRlc3QudHN4Iix7InVybHMiOiI1IiwiaWRzIjoiNiJ9LFsiNyIsIjgiLCI5Il0sW10sWyI3IiwiOCIsIjkiXSx7fSwiY2xhdWRlLWNvZGUvdGVzdGluZyIsIi9ob29rcy9mZWF0dXJlcy9jb3N0LnRzeCIsInJlYWN0L2pzeC1kZXYtcnVudGltZSJd \ No newline at end of file diff --git a/plugins/altimate-code/node_modules/.vitest-cache/CACHEDIR.TAG b/plugins/altimate-code/node_modules/.vitest-cache/CACHEDIR.TAG new file mode 100644 index 00000000..8c1ef4ce --- /dev/null +++ b/plugins/altimate-code/node_modules/.vitest-cache/CACHEDIR.TAG @@ -0,0 +1,3 @@ +Signature: 8a477f597d28d172789f06886806bc55 +# This file is a cache directory tag created by Vitest. +# For information about cache directory tags see https://bford.info/cachedir/ diff --git a/plugins/altimate-code/node_modules/.vitest-cache/_metadata.json b/plugins/altimate-code/node_modules/.vitest-cache/_metadata.json new file mode 100644 index 00000000..9ee9061a --- /dev/null +++ b/plugins/altimate-code/node_modules/.vitest-cache/_metadata.json @@ -0,0 +1,3 @@ +{ + "lockfileHash": "e3b0c442" +} \ No newline at end of file From 28ccf30d4ae7795b1341889a0e02fd584dfcd720 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 07:13:21 +0530 Subject: [PATCH 28/56] fix(cost): a cd voids estimates again; a lower-bound-only estimate is inconclusive Co-Authored-By: Claude Opus 5.5 --- .../altimate-code/hooks/features/cost.test.tsx | 18 ++++++++++++++---- plugins/altimate-code/hooks/features/cost.tsx | 9 ++++++--- 2 files changed, 20 insertions(+), 7 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 68592d88..00fbb087 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -664,7 +664,7 @@ test('a read-only shell command keeps the answer waiting for the retry', async ( expect(estimates).toEqual(['orders']) }) -test('a cd keeps the answer waiting for the retry', async ($, on) => { +test('a cd drops the answer waiting for the retry: it may have selected another project', async ($, on) => { const options: Options = { answers: { orders: UNDER } } const { clock, estimates } = await start($, on, options) let release!: () => void @@ -674,12 +674,22 @@ test('a cd keeps the answer waiting for the retry', async ($, on) => { expect(((await first) as any).deny).toContain('still being estimated') release() await clock.settle() - await $.tool.call(bash('cd models')) + await $.tool.call(bash('cd ../project-b')) options.hold = undefined + options.answers = { orders: OVER } const retry: any = await $.tool.call(bash('dbt run -s orders')) await clock.settle() - expect(retry.deny).toBeUndefined() - expect(estimates).toEqual(['orders']) + expect(retry.deny).toContain('20.0 GiB') + expect(estimates).toEqual(['orders', 'orders']) +}) + +test('a lower-bound-only estimate holds nothing and keeps an existing hold', async ($, on) => { + const { clock } = await start($, on, { answers: { orders: OVER, cheap: { success: true, supported: true, adapter: 'bigquery', bytes: 0, lowerBound: true, display: '0 Bytes' } } }) + expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toContain('20.0 GiB') + const result: any = await $.tool.call(bash('dbt run -s cheap')) + await clock.settle() + expect(result.context?.join(' ')).toContain('no estimate') + expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toContain('20.0 GiB') }) for (const restore of [ diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 5f70a2f6..c78e8190 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -74,7 +74,7 @@ function mutates(all: DbtInvocation[], rest: string): boolean { return MAY_CHANGE_PROJECT.test(rest) } -/** What a shell command did to the project: a rewrite voids the estimates and the verdict; a directory change only the verdict. */ +/** What a shell command did to the project: a rewrite voids the estimates and the verdict; a directory change the same, since it can select another project. */ async function afterShellChange($: EngineInterface, command: string) { const { all, rest } = withoutReads(command) if (mutates(all, rest)) { @@ -82,7 +82,8 @@ async function afterShellChange($: EngineInterface, command: string) { // Any rewrite can bring back another target (a git restore does not name the profile). await forgetUnsupported($) } else if (MOVES_DIRECTORY.test(rest)) { - // A cd cannot rewrite a model, so an estimate that is still coming in stays good; only the target may differ. + // A cd can select another project, which the estimate (keyed by model or SQL) does not name: nothing made before it is reused. + invalidate() await forgetUnsupported($) } } @@ -483,8 +484,10 @@ async function estimate($: EngineInterface, args: { model?: string; sql?: string try { const run = await runTool($, 'dbt_cost_estimate', args, { write: true, until }) if (!run.ok && UNKNOWN_TOOL.test(run.text)) return { kind: 'none', reason: `this altimate-code has no cost estimate: it needs ${NEEDED_VERSION}` } - const data = run.metadata as { supported?: unknown; adapter?: unknown; bytes?: unknown; maxBytes?: unknown; display?: unknown; error?: unknown } | null + const data = run.metadata as { supported?: unknown; adapter?: unknown; bytes?: unknown; maxBytes?: unknown; lowerBound?: unknown; display?: unknown; error?: unknown } | null if (data?.supported === false) return { kind: 'unsupported', adapter: typeof data.adapter === 'string' ? data.adapter : 'this warehouse' } + // A dry run that can undercount (a zero, a script) gives no upper bound to hold a command on. + if (data?.supported === true && data.lowerBound === true) return { kind: 'none', reason: 'the dry run gave only a lower bound, not a cap' } if (data?.supported === true && typeof data.bytes === 'number' && Number.isFinite(data.bytes)) { // The tool's upper bound when it gives one: the display is rounded, and the limit is a hard one. const maxBytes = typeof data.maxBytes === 'number' && Number.isFinite(data.maxBytes) && data.maxBytes >= data.bytes ? data.maxBytes : data.bytes From c4961ece72e7b6560bde3a4c6ba7dcbf49cf2d2e Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 07:21:16 +0530 Subject: [PATCH 29/56] fix(cost): a finished dbt run drops earlier estimates; spending the allowance clears the held status Co-Authored-By: Claude Opus 5.5 --- .../hooks/features/cost.test.tsx | 24 ++++++++++++++++++- plugins/altimate-code/hooks/features/cost.tsx | 12 ++++++++-- 2 files changed, 33 insertions(+), 3 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 00fbb087..0c65b6fd 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -130,8 +130,9 @@ test('a cd to another directory makes the no-dry-run verdict forgotten', async ( }) test('/allow-scan lets the next held command through once, then the one after is held again', async ($, on) => { - const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } }) + const { clock, estimates, ran, statuses } = await start($, on, { answers: { orders: OVER } }) expect((await $.tool.call(bash('dbt run -s orders')) as any).deny).toBeDefined() + expect(statuses.filter(Boolean).at(-1)).toContain('held') const allowed = await $.command.run({ command: 'allow-scan', args: '' } as any) expect(allowed.text).toContain('runs once') @@ -139,6 +140,7 @@ test('/allow-scan lets the next held command through once, then the one after is await clock.settle() expect(through.deny).toBeUndefined() expect(through.context).toEqual(['cost · orders would scan 20.0 GiB, over the 10.0 GiB limit: allowed once']) + expect(statuses.filter(Boolean).at(-1)).not.toContain('held') expect(ran).toEqual(['dbt run -s orders']) expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined() @@ -683,6 +685,26 @@ test('a cd drops the answer waiting for the retry: it may have selected another expect(estimates).toEqual(['orders', 'orders']) }) +test('a dbt run that has finished drops the estimates made before it', async ($, on) => { + const options: Options = { answers: { orders: UNDER, customers: UNDER } } + const { clock, estimates } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + const first = $.tool.call(bash('dbt run -s orders')) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + release() + await clock.settle() + options.hold = undefined + await $.tool.call(bash('dbt run -s customers')) + await clock.settle() + options.answers = { orders: OVER } + const retry: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(retry.deny).toContain('20.0 GiB') + expect(estimates.filter(e => e === 'orders').length).toBe(2) +}) + test('a lower-bound-only estimate holds nothing and keeps an existing hold', async ($, on) => { const { clock } = await start($, on, { answers: { orders: OVER, cheap: { success: true, supported: true, adapter: 'bigquery', bytes: 0, lowerBound: true, display: '0 Bytes' } } }) expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toContain('20.0 GiB') diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index c78e8190..7864986c 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -56,6 +56,8 @@ const UNSUPPORTED_KEEP_MS = 10 * 60_000 const MAY_CHANGE_PROJECT = /(^|[\s;&|(])(git\s+((-[Cc]|--git-dir|--namespace|--work-tree)\s+\S+\s+|-\S+\s+)*(checkout|restore|reset|stash|apply|clean|switch|merge|rebase|pull|cherry-pick|revert|am|worktree)|sed|awk|perl|python3?|node|bun|patch|mv|cp|rm|tee|touch|make|sh|bash|dd|ed|ex)(\s|$)|>/ /** Commands that can move the session to another project or target without rewriting a file. */ const MOVES_DIRECTORY = /(^|[\s;&|(])(cd|pushd|popd)(\s|$)/ +/** The dbt subcommands that rebuild warehouse relations. */ +const REBUILDS = new Set(['run', 'build']) /** The dbt subcommands that change nothing in the project. */ const READS_ONLY = new Set(['run', 'build', 'show', 'compile', 'ls', 'list', 'debug', 'parse']) @@ -75,8 +77,11 @@ function mutates(all: DbtInvocation[], rest: string): boolean { } /** What a shell command did to the project: a rewrite voids the estimates and the verdict; a directory change the same, since it can select another project. */ -async function afterShellChange($: EngineInterface, command: string) { +async function afterShellChange($: EngineInterface, command: string, ran = false) { const { all, rest } = withoutReads(command) + // A dbt run that has finished may have rebuilt what another model reads: an estimate made before it is stale. + // Not before the command runs: the gate's own estimates, kept for the retry, would be dropped by every pass. + if (ran && all.some(i => i.subcommand !== null && REBUILDS.has(i.subcommand))) invalidate() if (mutates(all, rest)) { invalidate() // Any rewrite can bring back another target (a git restore does not name the profile). @@ -272,6 +277,9 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: if (granted) { for (const one of over) lines.push(`cost · ${one.label} would scan ${one.display}, over the ${formatBytes(limitBytes)} limit: allowed once`) keepNotes(e.command, lines) + // The hold is spent: the status line stops showing it. + const last = (await read($, costAtom))?.lastEstimate + await showStatus($, last ? `scan ≈ ${last.display}` : null) return null } notes.delete(e.command) @@ -314,7 +322,7 @@ export async function bashAfter($: EngineInterface, e: BashCall, result: ToolCal notes.delete(e.command) refused.delete(e.command) // A shell command can rewrite a model or the profile (a git restore, a sed): no earlier estimate is reused after one. - await afterShellChange($, e.command) + await afterShellChange($, e.command, true) return lines } From 568ec553a9692b186f7ce06f0c4b7bc6fc3db8c9 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 07:28:19 +0530 Subject: [PATCH 30/56] fix(cost): a call with a glob or redirect in its arguments is not estimated Co-Authored-By: Claude Opus 5.5 --- plugins/altimate-code/hooks/features/cost.test.tsx | 1 + plugins/altimate-code/hooks/features/cost.tsx | 6 ++++-- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 0c65b6fd..97f9e256 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -297,6 +297,7 @@ test('a command that sets its own target, defer state, vars or project is not es 'uv run --directory other dbt run -s orders', "dbt run -s orders --'vars' x", 'dbt run -s orders --full-refresh', + 'dbt run -s orders stg_*', 'dbt run -s orders --full-\\\nrefresh', 'if true; then cd other; fi; dbt run -s orders', 'dbt --profiles-dir ci run -s orders', diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 7864986c..1868fd8a 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -384,13 +384,15 @@ function expands(command: string): boolean { * default target, so it is only so when the line moves neither: the dbt launcher is plain, nothing * precedes the invocation but other dbt invocations, and every flag is one known to leave the query * alone, with no expansion on the line. Anything else (another target, defer state, vars, project, a - * full refresh) is not estimated. + * full refresh) is not estimated. Every estimate is of the project as it is when the command starts: what an + * earlier step on the same line rebuilds is not known to it, which is the limit of any preflight. */ function isPlainInvocation(command: string, invocation: DbtInvocation, all: DbtInvocation[]): boolean { // The shell expands `$` and backticks anywhere on the line (arguments, redirections, an earlier call) into // flags or environment this check can't see; a line with many calls is not worth reading call by call. if (all.length > MAX_INVOCATIONS || expands(command)) return false - if (!PLAIN_LAUNCHER.test(invocation.binary)) return false + // A glob or redirect in the arguments leaves the parsed selection incomplete. + if (invocation.dynamic || !PLAIN_LAUNCHER.test(invocation.binary)) return false let before = command.slice(0, invocation.start) for (const earlier of all.filter(one => one.end <= invocation.start).reverse()) { before = before.slice(0, earlier.start) + ' ' + before.slice(earlier.end) From b8604814a7d9840808649281759ddb14255bf1b6 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 07:34:39 +0530 Subject: [PATCH 31/56] fix(cost): a lower bound over the limit holds; a /cd forgets the no-dry-run verdict Co-Authored-By: Claude Opus 5.5 --- .../hooks/features/cost.test.tsx | 21 +++++++++++++++++++ plugins/altimate-code/hooks/features/cost.tsx | 13 ++++++++++-- 2 files changed, 32 insertions(+), 2 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 97f9e256..5fc0a963 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -14,6 +14,8 @@ type Options = { hold?: Promise /** With `hold`: only the estimate of this model or SQL waits. */ holdFor?: string + /** The session's directory; changed mid-test to stand for a /cd. */ + cwd?: string /** Drawing the status line throws. */ statusFails?: boolean /** The Bash tool runs this command only once this resolves. */ @@ -32,6 +34,7 @@ async function start($: any, on: any, options: Options = {}) { on('turn.complete', (_: unknown, e: { answer: string }) => ({ text: e.answer })) on('session.start', (_: unknown, e: { cwd: string }) => ({ cwd: e.cwd })) on('session.root', () => ({ value: ROOT })) + on('session.cwd', () => ({ value: options.cwd ?? ROOT })) on('ui.log', () => ({ value: undefined })) on('ui.status', (_: unknown, e: { text?: string }) => { if (options.statusFails) throw new Error('no status line') @@ -706,6 +709,24 @@ test('a dbt run that has finished drops the estimates made before it', async ($, expect(estimates.filter(e => e === 'orders').length).toBe(2) }) +test('a /cd to another project makes the no-dry-run verdict forgotten', async ($, on) => { + const options: Options = { answers: { orders: NO_DRY_RUN } } + const { clock } = await start($, on, options) + const run = () => $.tool.call(bash('dbt run -s orders')) as Promise + expect((await run()).deny).toBeUndefined() + options.answers = { orders: OVER } + options.cwd = '/elsewhere/bigquery-project' + await clock.settle() + expect((await run()).deny).toContain('20.0 GiB') +}) + +test('a lower bound already over the limit holds the command', async ($, on) => { + const { clock } = await start($, on, { answers: { orders: { success: true, supported: true, adapter: 'bigquery', bytes: 20 * GIB, lowerBound: true, display: '20.0 GiB' } } }) + const result: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(result.deny).toContain('20.0 GiB') +}) + test('a lower-bound-only estimate holds nothing and keeps an existing hold', async ($, on) => { const { clock } = await start($, on, { answers: { orders: OVER, cheap: { success: true, supported: true, adapter: 'bigquery', bytes: 0, lowerBound: true, display: '0 Bytes' } } }) expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toContain('20.0 GiB') diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 1868fd8a..a809332d 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -51,6 +51,8 @@ const refused = new Map() let generation = 0 /** When the session found a warehouse with no dry run; null once forgotten. That finding is kept only so long, since the target can change. */ let unsupportedSince: number | null = null +/** The directory the session was in when it found that; a session now elsewhere (a /cd) asks again. */ +let unsupportedDir: string | null = null const UNSUPPORTED_KEEP_MS = 10 * 60_000 /** Commands that can rewrite a model, the project or its profile from the shell: an estimate made before one is not reused. */ const MAY_CHANGE_PROJECT = /(^|[\s;&|(])(git\s+((-[Cc]|--git-dir|--namespace|--work-tree)\s+\S+\s+|-\S+\s+)*(checkout|restore|reset|stash|apply|clean|switch|merge|rebase|pull|cherry-pick|revert|am|worktree)|sed|awk|perl|python3?|node|bun|patch|mv|cp|rm|tee|touch|make|sh|bash|dd|ed|ex)(\s|$)|>/ @@ -182,7 +184,7 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: // A warehouse with no dry run was found out already: the command is never held, and nothing is asked again, // until an edit or a command that can move the target, or time, says it may have changed. if (state.unsupportedAdapter) { - if (unsupportedSince != null && (await $.clock.now()) - unsupportedSince < UNSUPPORTED_KEEP_MS) return null + if (unsupportedSince != null && (await $.clock.now()) - unsupportedSince < UNSUPPORTED_KEEP_MS && unsupportedDir === (await $.session.cwd())) return null await forgetUnsupported($) state.unsupportedAdapter = null } @@ -213,6 +215,7 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: if (answer.kind === 'unsupported') { // Nothing can be held on this warehouse, so a hold from before the verdict goes with it. unsupportedSince = await $.clock.now() + unsupportedDir = await $.session.cwd() if (generation !== startedAt) break await update($, costAtom, prev => ({ ...(prev ?? FRESH), unsupportedAdapter: answer.adapter, held: null, allowOnce: false })) await showStatus($, null) @@ -497,7 +500,13 @@ async function estimate($: EngineInterface, args: { model?: string; sql?: string const data = run.metadata as { supported?: unknown; adapter?: unknown; bytes?: unknown; maxBytes?: unknown; lowerBound?: unknown; display?: unknown; error?: unknown } | null if (data?.supported === false) return { kind: 'unsupported', adapter: typeof data.adapter === 'string' ? data.adapter : 'this warehouse' } // A dry run that can undercount (a zero, a script) gives no upper bound to hold a command on. - if (data?.supported === true && data.lowerBound === true) return { kind: 'none', reason: 'the dry run gave only a lower bound, not a cap' } + if (data?.supported === true && data.lowerBound === true) { + // A floor already over the limit is enough to hold; a floor under it says nothing about the cap. + if (typeof data.bytes === 'number' && Number.isFinite(data.bytes) && limitBytes > 0 && data.bytes > limitBytes) { + return { kind: 'bytes', bytes: data.bytes, maxBytes: data.bytes, display: typeof data.display === 'string' ? data.display : formatBytes(data.bytes) } + } + return { kind: 'none', reason: 'the dry run gave only a lower bound, not a cap' } + } if (data?.supported === true && typeof data.bytes === 'number' && Number.isFinite(data.bytes)) { // The tool's upper bound when it gives one: the display is rounded, and the limit is a hard one. const maxBytes = typeof data.maxBytes === 'number' && Number.isFinite(data.maxBytes) && data.maxBytes >= data.bytes ? data.maxBytes : data.bytes From 2af28cf43a8ca91bb2a2b22ad2b2953b29f035b8 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 07:38:47 +0530 Subject: [PATCH 32/56] fix(cost): everything the gate learned belongs to the project it was in; a /cd drops it Co-Authored-By: Claude Opus 5.5 --- .../hooks/features/cost.test.tsx | 24 +++++++++++++++++++ plugins/altimate-code/hooks/features/cost.tsx | 16 +++++++++---- 2 files changed, 36 insertions(+), 4 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 5fc0a963..9b7a12c1 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -720,6 +720,30 @@ test('a /cd to another project makes the no-dry-run verdict forgotten', async ($ expect((await run()).deny).toContain('20.0 GiB') }) +test('a /cd to another project drops the finished answer and the allowance', async ($, on) => { + const options: Options = { answers: { orders: UNDER } } + const { clock, estimates } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + const first = $.tool.call(bash('dbt run -s orders')) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + release() + await clock.settle() + options.hold = undefined + options.cwd = '/elsewhere/project-b' + options.answers = { orders: OVER } + const retry: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(retry.deny).toContain('20.0 GiB') + expect(estimates).toEqual(['orders', 'orders']) + await $.command.run({ command: 'allow-scan', args: '' } as any) + options.cwd = '/elsewhere/project-c' + const again: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(again.deny).toContain('20.0 GiB') +}) + test('a lower bound already over the limit holds the command', async ($, on) => { const { clock } = await start($, on, { answers: { orders: { success: true, supported: true, adapter: 'bigquery', bytes: 20 * GIB, lowerBound: true, display: '20.0 GiB' } } }) const result: any = await $.tool.call(bash('dbt run -s orders')) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index a809332d..50d6debf 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -51,8 +51,8 @@ const refused = new Map() let generation = 0 /** When the session found a warehouse with no dry run; null once forgotten. That finding is kept only so long, since the target can change. */ let unsupportedSince: number | null = null -/** The directory the session was in when it found that; a session now elsewhere (a /cd) asks again. */ -let unsupportedDir: string | null = null +/** The directory the session was in at the last gate pass: estimates, a hold and an allowance belong to that project. */ +let seenDir: string | null = null const UNSUPPORTED_KEEP_MS = 10 * 60_000 /** Commands that can rewrite a model, the project or its profile from the shell: an estimate made before one is not reused. */ const MAY_CHANGE_PROJECT = /(^|[\s;&|(])(git\s+((-[Cc]|--git-dir|--namespace|--work-tree)\s+\S+\s+|-\S+\s+)*(checkout|restore|reset|stash|apply|clean|switch|merge|rebase|pull|cherry-pick|revert|am|worktree)|sed|awk|perl|python3?|node|bun|patch|mv|cp|rm|tee|touch|make|sh|bash|dd|ed|ex)(\s|$)|>/ @@ -140,6 +140,7 @@ export async function sessionStart($: EngineInterface, e: Args<'session.start'>) refused.clear() generation++ unsupportedSince = null + seenDir = null await update($, costAtom, () => ({ ...FRESH })) await setStatusPart($, 'cost', null) await $.command.register({ name: 'allow-scan', description: 'Let the dbt command held for its BigQuery scan size run once, when run again unchanged' }) @@ -175,6 +176,14 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: // Before it runs, not only after: another call can ask while a long command is rewriting the project. // A command refused for its estimate has not run: its retry is not a change, and keeps the answers it waited for. if (!refused.has(e.command)) await afterShellChange($, e.command) + // A session moved to another project (a /cd) keeps nothing the gate learned in the last one. + const dir = await $.session.cwd() + if (seenDir !== null && dir !== seenDir) { + invalidate() + await forgetUnsupported($) + await update($, costAtom, prev => (prev?.held || prev?.allowOnce ? { ...prev, held: null, allowOnce: false } : prev)) + } + seenDir = dir const all = parseDbtCommand(e.command) const invocations = all.filter(i => i.subcommand !== null && SCANNING.has(i.subcommand)) if (invocations.length === 0) return null @@ -184,7 +193,7 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: // A warehouse with no dry run was found out already: the command is never held, and nothing is asked again, // until an edit or a command that can move the target, or time, says it may have changed. if (state.unsupportedAdapter) { - if (unsupportedSince != null && (await $.clock.now()) - unsupportedSince < UNSUPPORTED_KEEP_MS && unsupportedDir === (await $.session.cwd())) return null + if (unsupportedSince != null && (await $.clock.now()) - unsupportedSince < UNSUPPORTED_KEEP_MS) return null await forgetUnsupported($) state.unsupportedAdapter = null } @@ -215,7 +224,6 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: if (answer.kind === 'unsupported') { // Nothing can be held on this warehouse, so a hold from before the verdict goes with it. unsupportedSince = await $.clock.now() - unsupportedDir = await $.session.cwd() if (generation !== startedAt) break await update($, costAtom, prev => ({ ...(prev ?? FRESH), unsupportedAdapter: answer.adapter, held: null, allowOnce: false })) await showStatus($, null) From 0538365fa55d0c9d8e0681863171c7867b412a61 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 08:12:46 +0530 Subject: [PATCH 33/56] test(cost): the fake CLI answers another feature's tool with nothing to report Co-Authored-By: Claude Opus 5.5 --- plugins/altimate-code/hooks/features/cost.test.tsx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 9b7a12c1..580b18cf 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -49,7 +49,8 @@ async function start($: any, on: any, options: Options = {}) { on('process.run', async (_: unknown, e: { argv: readonly string[] }) => { const [, command, , tool] = e.argv if (command !== 'tool') return { value: { exitCode: 1, stdout: '', stderr: 'not this test' } } - expect(tool).toBe('dbt_cost_estimate') + // Another feature's tool (runs asks dbt_run_results) has nothing to report here, and is not an estimate. + if (tool !== 'dbt_cost_estimate') return { value: { exitCode: 0, stdout: JSON.stringify({ status: 'ok', output: '', metadata: { found: false } }), stderr: '' } } // The adapter starts the project's dbt: the call must carry write permission. expect(e.argv).toContain('--allow-write') const args = JSON.parse(String(e.argv[e.argv.indexOf('--args') + 1] ?? '{}')) From 9dbbd31e902dceb11367bdbc4f00e6ce510238fc Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 08:16:30 +0530 Subject: [PATCH 34/56] test(cost): the many-calls bound covers the whole hook chain Co-Authored-By: Claude Opus 5.5 --- plugins/altimate-code/hooks/features/cost.test.tsx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 580b18cf..e0fcacb0 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -432,7 +432,8 @@ test('a line with a great many dbt calls is not read call by call', async ($, on expect(result.context.length).toBe(6) expect(result.context[0]).toContain('cost · no estimate') expect(result.context[5]).toBe('cost · 3995 more notes not shown') - expect(Date.now() - began).toBeLessThan(3000) + // Other features' hooks (runs reads the same line) share this call, so the bound is for the whole chain. + expect(Date.now() - began).toBeLessThan(10_000) }) test('an estimate not done within the gate wait refuses the command, and the finished answer is used on the next try', async ($, on) => { From 053e0ccda3d5ec573eef5b405a75f92853db7a3b Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 08:25:24 +0530 Subject: [PATCH 35/56] fix(cost): one estimate runs per project at a time; a dbt run let through drops kept estimates Co-Authored-By: Claude Opus 5.5 --- .../hooks/features/cost.test.tsx | 40 +++++++++++++++++++ plugins/altimate-code/hooks/features/cost.tsx | 9 +++++ 2 files changed, 49 insertions(+) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index e0fcacb0..6c573ce4 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -746,6 +746,46 @@ test('a /cd to another project drops the finished answer and the allowance', asy expect(again.deny).toContain('20.0 GiB') }) +test('a dbt run that is let through drops the estimates kept from before it', async ($, on) => { + const options: Options = { answers: { orders: UNDER, customers: UNDER } } + const { clock, estimates } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + options.holdFor = 'orders' + const first = $.tool.call(bash('dbt run -s orders')) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + release() + await clock.settle() + options.hold = undefined + // Another command's run is let through, and is still running (not yet after-phase) when orders is retried. + options.holdBash = { command: 'dbt run -s customers', until: new Promise(() => {}) } + void $.tool.call(bash('dbt run -s customers')) + await clock.settle() + options.answers = { orders: OVER } + const retry: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(retry.deny).toContain('20.0 GiB') + expect(estimates.filter(e => e === 'orders').length).toBe(2) +}) + +test('a second model is not estimated while another estimate is still running in the project', async ($, on) => { + const options: Options = { answers: { a: UNDER, b: UNDER } } + const { clock, estimates } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + const first = $.tool.call(bash('dbt run -s a')) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + const second: any = await $.tool.call(bash('dbt run -s b')) + expect(second.deny).toContain('still being estimated') + expect(estimates).toEqual([]) + release() + await clock.settle() + options.hold = undefined + expect(estimates).toEqual(['a']) +}) + test('a lower bound already over the limit holds the command', async ($, on) => { const { clock } = await start($, on, { answers: { orders: { success: true, supported: true, adapter: 'bigquery', bytes: 20 * GIB, lowerBound: true, display: '20.0 GiB' } } }) const result: any = await $.tool.call(bash('dbt run -s orders')) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 50d6debf..0f317ab6 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -172,6 +172,13 @@ export async function bashRewrite($: EngineInterface, e: BashCall): Promise { + const verdict = await gate($, e) + // A dbt run or build that is let through rebuilds relations while it runs: an estimate kept from before it is stale from here. + if (verdict === null && limitBytes > 0 && parseDbtCommand(e.command).some(i => i.subcommand !== null && REBUILDS.has(i.subcommand))) invalidate() + return verdict +} + +async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | null> { if (limitBytes <= 0) return null // Before it runs, not only after: another call can ask while a long command is rewriting the project. // A command refused for its estimate has not run: its retry is not a change, and keeps the answers it waited for. @@ -541,6 +548,8 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: if (!running) { // The wait is spent: nothing new starts. Each estimate may start the adapter (dbt deps), and two at once in one project collide. if (waitUntil - now <= 0) return 'pending' + // Nor while another is still running in this project, whichever command asked for it. + for (const other of inflight.values()) if (other.doneAt == null && other.generation === generation) return 'pending' const entry: { answer: Promise; doneAt: number | null; generation: number } = { answer: estimate($, args, now + ESTIMATE_BUDGET_MS), doneAt: null, From 648b4b45a3ed8c241d8860d505ff5a4f75429bee Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 08:33:08 +0530 Subject: [PATCH 36/56] fix(cost): estimates wait for the one running in the project, including one an edit voided Co-Authored-By: Claude Opus 5.5 --- .../hooks/features/cost.test.tsx | 33 ++++++++++++++++--- plugins/altimate-code/hooks/features/cost.tsx | 18 ++++++++-- 2 files changed, 45 insertions(+), 6 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 6c573ce4..b634f36d 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -769,23 +769,48 @@ test('a dbt run that is let through drops the estimates kept from before it', as expect(estimates.filter(e => e === 'orders').length).toBe(2) }) -test('a second model is not estimated while another estimate is still running in the project', async ($, on) => { +test('a second model waits for the estimate running in the project, and starts none while it runs', async ($, on) => { const options: Options = { answers: { a: UNDER, b: UNDER } } const { clock, estimates } = await start($, on, options) let release!: () => void options.hold = new Promise(resolve => (release = resolve)) + options.holdFor = 'a' const first = $.tool.call(bash('dbt run -s a')) await clock.advance(4_001) expect(((await first) as any).deny).toContain('still being estimated') - const second: any = await $.tool.call(bash('dbt run -s b')) - expect(second.deny).toContain('still being estimated') + const second = $.tool.call(bash('dbt run -s b')) + await clock.advance(4_001) + expect(((await second) as any).deny).toContain('still being estimated') expect(estimates).toEqual([]) release() await clock.settle() - options.hold = undefined expect(estimates).toEqual(['a']) }) +test('an edit that voids a running estimate does not let another start beside it', async ($, on) => { + const options: Options = { answers: { a: UNDER, b: UNDER } } + const { clock, estimates } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + options.holdFor = 'a' + const first = $.tool.call(bash('dbt run -s a')) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + await $.tool.call(bash('git restore models/a.sql')) + const second = $.tool.call(bash('dbt run -s b')) + await clock.advance(4_001) + expect(((await second) as any).deny).toContain('still being estimated') + expect(estimates).toEqual([]) + release() + await clock.settle() + options.hold = undefined + const third: any = await $.tool.call(bash('dbt run -s b')) + await clock.settle() + expect(third.deny).toBeUndefined() + expect(estimates).toEqual(['a', 'b']) +}) + + test('a lower bound already over the limit holds the command', async ($, on) => { const { clock } = await start($, on, { answers: { orders: { success: true, supported: true, adapter: 'bigquery', bytes: 20 * GIB, lowerBound: true, display: '20.0 GiB' } } }) const result: any = await $.tool.call(bash('dbt run -s orders')) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 0f317ab6..aadd3758 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -45,6 +45,8 @@ let limitBytes = DEFAULT_MAX_SCAN_BYTES const notes = new Map() /** Estimates still running past the gate's wait, by what they ask about; the next gate pass for the same target takes the answer. */ const inflight = new Map; doneAt: number | null; generation: number }>() +/** Estimates whose process is still running, whether or not an edit has voided their answer: one runs per project at a time. */ +const active = new Set>() /** Commands the gate refused while their estimate was running, and when it last did: they have not run, so a retry changes nothing. */ const refused = new Map() /** Moves on whenever the project may have changed: an estimate started before it is never taken as an answer. */ @@ -548,13 +550,25 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: if (!running) { // The wait is spent: nothing new starts. Each estimate may start the adapter (dbt deps), and two at once in one project collide. if (waitUntil - now <= 0) return 'pending' - // Nor while another is still running in this project, whichever command asked for it. - for (const other of inflight.values()) if (other.doneAt == null && other.generation === generation) return 'pending' + // Nor while another is still running in this project, whichever command asked for it, even one whose answer an edit voided: + // this one waits its turn, within the same bound. + while (active.size > 0) { + const left = waitUntil - (await $.clock.now()) + if (left <= 0 || !(await within($, left, Promise.all([...active]).then(() => true)))) return 'pending' + } + // Another pass may have started this same estimate while this waited. + const started = inflight.get(key) + if (started && started.doneAt == null) running = started + } + if (!running) { const entry: { answer: Promise; doneAt: number | null; generation: number } = { answer: estimate($, args, now + ESTIMATE_BUDGET_MS), doneAt: null, generation, } + const track = entry.answer.then(() => undefined, () => undefined) + active.add(track) + void track.then(() => active.delete(track)) void entry.answer.then(async () => void (entry.doneAt = await $.clock.now())).catch(() => {}) inflight.set(key, entry) running = entry From 6f3a75d875742fa1786752a5385850708ccdd40e Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 08:42:24 +0530 Subject: [PATCH 37/56] fix(cost): only an estimate that outlasted the gate wait holds the next one back Co-Authored-By: Claude Opus 5.5 --- plugins/altimate-code/hooks/features/cost.tsx | 30 +++++++++---------- 1 file changed, 14 insertions(+), 16 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index aadd3758..3aaf8f67 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -44,9 +44,9 @@ let limitBytes = DEFAULT_MAX_SCAN_BYTES /** The lines to show under an estimated command's Bash row, by command; each gate pass replaces the last. Taken by bashAfter. */ const notes = new Map() /** Estimates still running past the gate's wait, by what they ask about; the next gate pass for the same target takes the answer. */ -const inflight = new Map; doneAt: number | null; generation: number }>() -/** Estimates whose process is still running, whether or not an edit has voided their answer: one runs per project at a time. */ -const active = new Set>() +const inflight = new Map; settled: Promise; doneAt: number | null; generation: number }>() +/** Estimates that outlasted the gate's wait and are still running, whether or not an edit has voided their answer: nothing else starts beside one. */ +const late = new Set>() /** Commands the gate refused while their estimate was running, and when it last did: they have not run, so a retry changes nothing. */ const refused = new Map() /** Moves on whenever the project may have changed: an estimate started before it is never taken as an answer. */ @@ -550,32 +550,30 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: if (!running) { // The wait is spent: nothing new starts. Each estimate may start the adapter (dbt deps), and two at once in one project collide. if (waitUntil - now <= 0) return 'pending' - // Nor while another is still running in this project, whichever command asked for it, even one whose answer an edit voided: - // this one waits its turn, within the same bound. - while (active.size > 0) { + // Nor beside one that already outlasted its wait (its command was refused), whichever command asks, even when an edit voided + // its answer: this one waits its turn, within the same bound. + while (late.size > 0) { const left = waitUntil - (await $.clock.now()) - if (left <= 0 || !(await within($, left, Promise.all([...active]).then(() => true)))) return 'pending' + if (left <= 0 || !(await within($, left, Promise.all([...late]).then(() => true)))) return 'pending' } // Another pass may have started this same estimate while this waited. const started = inflight.get(key) if (started && started.doneAt == null) running = started } if (!running) { - const entry: { answer: Promise; doneAt: number | null; generation: number } = { - answer: estimate($, args, now + ESTIMATE_BUDGET_MS), - doneAt: null, - generation, - } - const track = entry.answer.then(() => undefined, () => undefined) - active.add(track) - void track.then(() => active.delete(track)) + const answer = estimate($, args, now + ESTIMATE_BUDGET_MS) + const entry = { answer, settled: answer.then(() => undefined, () => undefined), doneAt: null as number | null, generation } void entry.answer.then(async () => void (entry.doneAt = await $.clock.now())).catch(() => {}) inflight.set(key, entry) running = entry } const left = waitUntil - (await $.clock.now()) const done = left > 0 ? await within($, left, running.answer.then(answer => ({ answer }))) : null - if (!done) return 'pending' + if (!done) { + late.add(running.settled) + void running.settled.then(() => late.delete(running!.settled)) + return 'pending' + } // The project may have changed while it ran: that answer is of the old one, and the next pass asks again. if (running.generation !== generation) { if (inflight.get(key) === running) inflight.delete(key) From 811cf188f356ed693b67465558c0f69275b2903f Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 08:47:32 +0530 Subject: [PATCH 38/56] fix(cost): a dbt run let through drops only the finished answers, not an estimate a parallel call waits on Co-Authored-By: Claude Opus 5.5 --- plugins/altimate-code/hooks/features/cost.tsx | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 3aaf8f67..b2d09352 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -176,7 +176,7 @@ export async function bashRewrite($: EngineInterface, e: BashCall): Promise { const verdict = await gate($, e) // A dbt run or build that is let through rebuilds relations while it runs: an estimate kept from before it is stale from here. - if (verdict === null && limitBytes > 0 && parseDbtCommand(e.command).some(i => i.subcommand !== null && REBUILDS.has(i.subcommand))) invalidate() + if (verdict === null && limitBytes > 0 && parseDbtCommand(e.command).some(i => i.subcommand !== null && REBUILDS.has(i.subcommand))) dropFinished() return verdict } @@ -353,6 +353,11 @@ export async function editAfter($: EngineInterface, e: FileCall, result: ToolCal await forgetUnsupported($) } +/** Drops the answers already in; an estimate still running, which a parallel call may be waiting on, is left to finish. */ +function dropFinished() { + for (const [key, entry] of inflight) if (entry.doneAt != null) inflight.delete(key) +} + function invalidate() { generation++ inflight.clear() From 0723ec3ffaf8aca478773b4902ab617c1a721ea7 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 08:56:07 +0530 Subject: [PATCH 39/56] fix(cost): untrack the test caches; a /cd clears status and last estimate; voided estimates still hold the next back; quoted git option values Co-Authored-By: Claude Opus 5.5 --- .../hooks/features/cost.test.tsx | 46 ++ plugins/altimate-code/hooks/features/cost.tsx | 54 +- .../node_modules/.vite/vitest/CACHEDIR.TAG | 3 - .../results.json | 1 - .../01827a3d74da33920570f783b18edea8eb8d7b82 | 472 ------------------ .../node_modules/.vitest-cache/CACHEDIR.TAG | 3 - .../node_modules/.vitest-cache/_metadata.json | 3 - 7 files changed, 82 insertions(+), 500 deletions(-) delete mode 100644 plugins/altimate-code/node_modules/.vite/vitest/CACHEDIR.TAG delete mode 100644 plugins/altimate-code/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json delete mode 100644 plugins/altimate-code/node_modules/.vitest-cache/01827a3d74da33920570f783b18edea8eb8d7b82 delete mode 100644 plugins/altimate-code/node_modules/.vitest-cache/CACHEDIR.TAG delete mode 100644 plugins/altimate-code/node_modules/.vitest-cache/_metadata.json diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index b634f36d..968db3bc 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -811,6 +811,52 @@ test('an edit that voids a running estimate does not let another start beside it }) +test('a run let through while an estimate is still running: the retry does not take that estimate\'s pre-run answer', async ($, on) => { + const options: Options = { answers: { orders: UNDER } } + const { clock, estimates } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + const first = $.tool.call(bash('dbt run -s orders')) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + // Not estimated (its own target), so it is let through at once and starts rebuilding. + expect(((await $.tool.call(bash('dbt run -s customers --target prod'))) as any).deny).toBeUndefined() + release() + await clock.settle() + options.hold = undefined + options.answers = { orders: OVER } + const retry: any = await $.tool.call(bash('dbt run -s orders')) + await clock.settle() + expect(retry.deny).toContain('20.0 GiB') + expect(estimates).toEqual(['orders', 'orders']) +}) + +test('a /cd takes the old project\'s hold off the status line and forgets its last estimate', async ($, on) => { + const options: Options = { answers: { orders: OVER } } + const { clock, statuses } = await start($, on, options) + expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined() + expect(statuses.filter(Boolean).at(-1)).toContain('held') + options.cwd = '/elsewhere/project-b' + await $.tool.call(bash('ls')) + await clock.settle() + expect(statuses.at(-1)).toBeUndefined() + const allowed = await $.command.run({ command: 'allow-scan', args: '' } as any) + expect(allowed.text).toContain('Nothing is held') + const last = await $.command.run({ command: 'scan-cost', args: '' } as any) + expect(last.text).toContain('Run /scan-cost ') +}) + +test('a quoted git option value is read: git -C "my repo" checkout . forgets the verdict', async ($, on) => { + const options: Options = { answers: { orders: NO_DRY_RUN } } + const { clock } = await start($, on, options) + const run = () => $.tool.call(bash('dbt run -s orders')) as Promise + expect((await run()).deny).toBeUndefined() + options.answers = { orders: OVER } + await $.tool.call(bash('git -C "my repo" checkout .')) + await clock.settle() + expect((await run()).deny).toContain('20.0 GiB') +}) + test('a lower bound already over the limit holds the command', async ($, on) => { const { clock } = await start($, on, { answers: { orders: { success: true, supported: true, adapter: 'bigquery', bytes: 20 * GIB, lowerBound: true, display: '20.0 GiB' } } }) const result: any = await $.tool.call(bash('dbt run -s orders')) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index b2d09352..95994780 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -44,7 +44,7 @@ let limitBytes = DEFAULT_MAX_SCAN_BYTES /** The lines to show under an estimated command's Bash row, by command; each gate pass replaces the last. Taken by bashAfter. */ const notes = new Map() /** Estimates still running past the gate's wait, by what they ask about; the next gate pass for the same target takes the answer. */ -const inflight = new Map; settled: Promise; doneAt: number | null; generation: number }>() +const inflight = new Map; settled: Promise; doneAt: number | null; generation: number; voided?: boolean }>() /** Estimates that outlasted the gate's wait and are still running, whether or not an edit has voided their answer: nothing else starts beside one. */ const late = new Set>() /** Commands the gate refused while their estimate was running, and when it last did: they have not run, so a retry changes nothing. */ @@ -57,7 +57,7 @@ let unsupportedSince: number | null = null let seenDir: string | null = null const UNSUPPORTED_KEEP_MS = 10 * 60_000 /** Commands that can rewrite a model, the project or its profile from the shell: an estimate made before one is not reused. */ -const MAY_CHANGE_PROJECT = /(^|[\s;&|(])(git\s+((-[Cc]|--git-dir|--namespace|--work-tree)\s+\S+\s+|-\S+\s+)*(checkout|restore|reset|stash|apply|clean|switch|merge|rebase|pull|cherry-pick|revert|am|worktree)|sed|awk|perl|python3?|node|bun|patch|mv|cp|rm|tee|touch|make|sh|bash|dd|ed|ex)(\s|$)|>/ +const MAY_CHANGE_PROJECT = /(^|[\s;&|(])(git\s+((-[Cc]|--git-dir|--namespace|--work-tree)\s+(\S+|"[^"]*"|'[^']*')\s+|-\S+\s+)*(checkout|restore|reset|stash|apply|clean|switch|merge|rebase|pull|cherry-pick|revert|am|worktree)|sed|awk|perl|python3?|node|bun|patch|mv|cp|rm|tee|touch|make|sh|bash|dd|ed|ex)(\s|$)|>/ /** Commands that can move the session to another project or target without rewriting a file. */ const MOVES_DIRECTORY = /(^|[\s;&|(])(cd|pushd|popd)(\s|$)/ /** The dbt subcommands that rebuild warehouse relations. */ @@ -86,12 +86,9 @@ async function afterShellChange($: EngineInterface, command: string, ran = false // A dbt run that has finished may have rebuilt what another model reads: an estimate made before it is stale. // Not before the command runs: the gate's own estimates, kept for the retry, would be dropped by every pass. if (ran && all.some(i => i.subcommand !== null && REBUILDS.has(i.subcommand))) invalidate() - if (mutates(all, rest)) { - invalidate() - // Any rewrite can bring back another target (a git restore does not name the profile). - await forgetUnsupported($) - } else if (MOVES_DIRECTORY.test(rest)) { - // A cd can select another project, which the estimate (keyed by model or SQL) does not name: nothing made before it is reused. + // A rewrite can bring back another target (a git restore does not name the profile), and a cd can select another project, + // which the estimates (keyed by model or SQL) do not name: nothing made before either is reused. + if (mutates(all, rest) || MOVES_DIRECTORY.test(rest)) { invalidate() await forgetUnsupported($) } @@ -143,6 +140,7 @@ export async function sessionStart($: EngineInterface, e: Args<'session.start'>) generation++ unsupportedSince = null seenDir = null + late.clear() await update($, costAtom, () => ({ ...FRESH })) await setStatusPart($, 'cost', null) await $.command.register({ name: 'allow-scan', description: 'Let the dbt command held for its BigQuery scan size run once, when run again unchanged' }) @@ -186,13 +184,16 @@ async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | // A command refused for its estimate has not run: its retry is not a change, and keeps the answers it waited for. if (!refused.has(e.command)) await afterShellChange($, e.command) // A session moved to another project (a /cd) keeps nothing the gate learned in the last one. - const dir = await $.session.cwd() + const dir = await $.session.cwd().catch(() => seenDir) if (seenDir !== null && dir !== seenDir) { - invalidate() + // What is still running belongs to the project left behind: it holds nothing back here. + invalidate(false) + late.clear() await forgetUnsupported($) - await update($, costAtom, prev => (prev?.held || prev?.allowOnce ? { ...prev, held: null, allowOnce: false } : prev)) + await update($, costAtom, prev => (prev ? { ...prev, held: null, allowOnce: false, lastEstimate: null } : prev)) + await showStatus($, null) } - seenDir = dir + seenDir = dir ?? null const all = parseDbtCommand(e.command) const invocations = all.filter(i => i.subcommand !== null && SCANNING.has(i.subcommand)) if (invocations.length === 0) return null @@ -298,8 +299,7 @@ async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | for (const one of over) lines.push(`cost · ${one.label} would scan ${one.display}, over the ${formatBytes(limitBytes)} limit: allowed once`) keepNotes(e.command, lines) // The hold is spent: the status line stops showing it. - const last = (await read($, costAtom))?.lastEstimate - await showStatus($, last ? `scan ≈ ${last.display}` : null) + await showLastEstimate($) return null } notes.delete(e.command) @@ -320,8 +320,7 @@ async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | // was not estimated says nothing, so the hold stays. if (estimated && (state.held || state.allowOnce)) { await update($, costAtom, prev => (prev?.held || prev?.allowOnce ? { ...prev, held: null, allowOnce: false } : prev)) - const last = (await read($, costAtom))?.lastEstimate - await showStatus($, last ? `scan ≈ ${last.display}` : null) + await showLastEstimate($) } keepNotes(e.command, lines) return null @@ -355,11 +354,23 @@ export async function editAfter($: EngineInterface, e: FileCall, result: ToolCal /** Drops the answers already in; an estimate still running, which a parallel call may be waiting on, is left to finish. */ function dropFinished() { - for (const [key, entry] of inflight) if (entry.doneAt != null) inflight.delete(key) + for (const [key, entry] of inflight) { + if (entry.doneAt != null) inflight.delete(key) + // A pass already waiting on it takes its answer; a later pass does not, since a run began after it started. + else entry.voided = true + } } -function invalidate() { +/** An estimate voided while it runs still has its process: nothing starts beside it (unless `track` is false, for a project left). */ +function invalidate(track = true) { generation++ + if (track) { + for (const entry of inflight.values()) { + if (entry.doneAt != null) continue + late.add(entry.settled) + void entry.settled.then(() => late.delete(entry.settled)) + } + } inflight.clear() } @@ -549,6 +560,7 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: // The look-up and the insert below are one step: nothing is awaited between them, or two passes would each start one. const now = await $.clock.now() let running = inflight.get(key) + if (running?.voided) running = undefined // A command whose retries keep coming keeps what it waited for however long the others took: a later answer expiring an earlier one would never let it finish. const retrying = refusedAt != null && now - refusedAt <= ANSWER_KEEP_MS if (running?.doneAt != null && !retrying && now - running.doneAt > ANSWER_KEEP_MS) running = undefined @@ -598,6 +610,12 @@ async function rememberEstimate($: EngineInterface, target: string, bytes: numbe } /** The status line's cost part; a failure to draw it is dropped. */ +/** The status line's cost part back to the last estimate, once no hold is left. */ +async function showLastEstimate($: EngineInterface) { + const last = (await read($, costAtom))?.lastEstimate + await showStatus($, last ? `scan ≈ ${last.display}` : null) +} + async function showStatus($: EngineInterface, text: string | null) { try { await setStatusPart($, 'cost', text) diff --git a/plugins/altimate-code/node_modules/.vite/vitest/CACHEDIR.TAG b/plugins/altimate-code/node_modules/.vite/vitest/CACHEDIR.TAG deleted file mode 100644 index 8c1ef4ce..00000000 --- a/plugins/altimate-code/node_modules/.vite/vitest/CACHEDIR.TAG +++ /dev/null @@ -1,3 +0,0 @@ -Signature: 8a477f597d28d172789f06886806bc55 -# This file is a cache directory tag created by Vitest. -# For information about cache directory tags see https://bford.info/cachedir/ diff --git a/plugins/altimate-code/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json b/plugins/altimate-code/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json deleted file mode 100644 index 93c7e71e..00000000 --- a/plugins/altimate-code/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json +++ /dev/null @@ -1 +0,0 @@ -{"version":1,"projects":{"":{"files":{"hooks/features/cost.test.tsx":{"failed":true,"duration":0,"lastRun":1794805775627}}}}} \ No newline at end of file diff --git a/plugins/altimate-code/node_modules/.vitest-cache/01827a3d74da33920570f783b18edea8eb8d7b82 b/plugins/altimate-code/node_modules/.vitest-cache/01827a3d74da33920570f783b18edea8eb8d7b82 deleted file mode 100644 index cdb1f273..00000000 --- a/plugins/altimate-code/node_modules/.vitest-cache/01827a3d74da33920570f783b18edea8eb8d7b82 +++ /dev/null @@ -1,472 +0,0 @@ -const __vite_ssr_import_0__ = await __vite_ssr_import__("claude-code/testing", {"importedNames":["expect","mock","test"]}); -const __vite_ssr_import_1__ = await __vite_ssr_import__("/hooks/features/cost.tsx", {"importedNames":["formatBytes","inlineSql"]}); -const __vite_ssr_import_2__ = await __vite_ssr_import__("react/jsx-dev-runtime", {"importedNames":["jsxDEV"]}); - - -var _jsxFileName = "/Users/harish/.quikim/workspaces/altimate-claude-plugin/feat/dbt-cost-estimate-tool/plugins/altimate-code/hooks/features/cost.test.tsx"; - -const ROOT = "/repo"; -const GIB = 1024 ** 3; -/** The session beneath the plugin, a CLI whose dbt_cost_estimate is scripted, and a Bash tool that records what ran. */ -async function start($, on, options = {}) { - const clock = __vite_ssr_import_0__.mock.clock(on); - const estimates = []; - const ran = []; - const statuses = []; - on("command.register", (_, e) => ({ value: { command: e.name } })); - on("turn.start", (_, e) => ({ turnId: e.turnId })); - on("session.end", () => ({ sessionId: "test" })); - on("turn.complete", (_, e) => ({ text: e.answer })); - on("session.start", (_, e) => ({ cwd: e.cwd })); - on("session.root", () => ({ value: ROOT })); - on("ui.log", () => ({ value: undefined })); - on("ui.status", (_, e) => { - statuses.push(e.text); - return { value: undefined }; - }); - on("ui.render", ($$, e) => { - const { Box } = $$.ui.resolve(e); - return /* @__PURE__ */ (0,__vite_ssr_import_2__.jsxDEV)(Box, {}, "engine", false, { - fileName: _jsxFileName, - lineNumber: 34, - columnNumber: 12 - }, this); - }); - on("fs.exists", () => ({ value: false })); - on("process.run", (_, e) => { - const [, command, , tool] = e.argv; - if (command !== "tool") return { value: { - exitCode: 1, - stdout: "", - stderr: "not this test" - } }; - (0,__vite_ssr_import_0__.expect)(tool).toBe("dbt_cost_estimate"); - // The adapter starts the project's dbt: the call must carry write permission. - (0,__vite_ssr_import_0__.expect)(e.argv).toContain("--allow-write"); - const args = JSON.parse(String(e.argv[e.argv.indexOf("--args") + 1] ?? "{}")); - const key = String(args.model ?? args.sql); - estimates.push(key); - const answer = options.answers?.[key] ?? options.fallback; - if (answer === "unknown-tool") { - return { value: { - exitCode: 1, - stdout: JSON.stringify({ - status: "error", - output: `Unknown tool: ${tool}. Run \`altimate-code tool list\` to see the available tools.`, - metadata: {} - }), - stderr: "" - } }; - }; - return { value: { - exitCode: 0, - stdout: JSON.stringify({ - status: "ok", - output: "", - metadata: answer ?? { - success: false, - error: "no answer scripted" - } - }), - stderr: "" - } }; - }); - // The Bash tool itself, beneath the plugin. - on("tool.call", (_, e) => { - if (e.tool === "Bash") ran.push(String(e.command)); - return { result: { - text: "ok", - isError: false - } }; - }); - await $.session.start({ - cwd: ROOT, - surface: "terminal", - isInteractive: true - }); - await clock.settle(); - return { - clock, - estimates, - ran, - statuses - }; -} -const bq = (bytes, display, maxBytes = bytes) => ({ - success: true, - supported: true, - adapter: "bigquery", - bytes, - maxBytes, - display -}); -const OVER = bq(20 * GIB, "20.0 GiB"); -const UNDER = bq(2 * GIB, "2.0 GiB"); -const bash = (command) => ({ - tool: "Bash", - command -}); -(0,__vite_ssr_import_0__.test)("a model over the limit is refused with its estimate, and the command never runs", async ($, on) => { - const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } }); - const result = await $.tool.call(bash("dbt run --select orders")); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["orders"]); - (0,__vite_ssr_import_0__.expect)(ran).toEqual([]); - (0,__vite_ssr_import_0__.expect)(result.deny).toBe("≈ 20.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again."); -}); -(0,__vite_ssr_import_0__.test)("a model under the limit runs, with the estimate in a line under the row", async ($, on) => { - const { clock, ran } = await start($, on, { answers: { orders: UNDER } }); - const result = await $.tool.call(bash("dbt build -s orders")); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt build -s orders"]); - (0,__vite_ssr_import_0__.expect)(result.context).toEqual(["cost · orders would scan 2.0 GiB"]); -}); -(0,__vite_ssr_import_0__.test)("dbt show --inline is estimated from its SQL", async ($, on) => { - const { clock, estimates } = await start($, on, { answers: { "select * from big": OVER } }); - const result = await $.tool.call(bash(`dbt show --inline "select * from big"`)); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["select * from big"]); - (0,__vite_ssr_import_0__.expect)(result.deny).toContain("20.0 GiB"); -}); -(0,__vite_ssr_import_0__.test)("/allow-scan lets the next held command through once, then the one after is held again", async ($, on) => { - const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); - const allowed = await $.command.run({ - command: "allow-scan", - args: "" - }); - (0,__vite_ssr_import_0__.expect)(allowed.text).toContain("runs once"); - const through = await $.tool.call(bash("dbt run -s orders")); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(through.deny).toBeUndefined(); - (0,__vite_ssr_import_0__.expect)(through.context).toEqual(["cost · orders would scan 20.0 GiB, over the 10.0 GiB limit: allowed once"]); - (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders"]); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); - (0,__vite_ssr_import_0__.expect)(estimates).toHaveLength(3); -}); -(0,__vite_ssr_import_0__.test)("a selection that is not one plain model passes, saying there is no estimate, and asks nothing", async ($, on) => { - const { clock, estimates, ran } = await start($, on); - for (const [command, why] of [ - ["dbt run", "no model named"], - ["dbt build -s +orders", "graph, tag, path or package selector"], - ["dbt run -s tag:nightly", "graph, tag, path or package selector"], - ["dbt run -s a b", "several selectors"] - ]) { - const result = await $.tool.call(bash(command)); - (0,__vite_ssr_import_0__.expect)(result.deny).toBeUndefined(); - (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain("cost · no estimate for this selection"); - (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain(why); - }; - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual([]); - (0,__vite_ssr_import_0__.expect)(ran).toHaveLength(4); -}); -(0,__vite_ssr_import_0__.test)("commands that scan nothing are not looked at", async ($, on) => { - const { clock, estimates, ran } = await start($, on); - for (const command of [ - "dbt test -s orders", - "dbt compile -s orders", - "ls", - "git status" - ]) await $.tool.call(bash(command)); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual([]); - (0,__vite_ssr_import_0__.expect)(ran).toHaveLength(4); -}); -(0,__vite_ssr_import_0__.test)("another warehouse is told once, never held, and not asked again", async ($, on) => { - const { clock, estimates, ran } = await start($, on, { fallback: { - success: true, - supported: false, - adapter: "snowflake" - } }); - const first = await $.tool.call(bash("dbt run -s orders")); - const second = await $.tool.call(bash("dbt run -s customers")); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(first.deny).toBeUndefined(); - (0,__vite_ssr_import_0__.expect)(first.context).toEqual(["cost · no estimate on snowflake: only BigQuery has a dry run"]); - (0,__vite_ssr_import_0__.expect)(second.deny).toBeUndefined(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["orders"]); - (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders", "dbt run -s customers"]); -}); -(0,__vite_ssr_import_0__.test)("an altimate-code without the tool shows one line saying what is needed, and the command runs", async ($, on) => { - const { clock, ran } = await start($, on, { answers: { orders: "unknown-tool" } }); - const result = await $.tool.call(bash("dbt run -s orders")); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders"]); - (0,__vite_ssr_import_0__.expect)(result.context).toHaveLength(1); - (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain("needs a newer altimate-code"); -}); -(0,__vite_ssr_import_0__.test)("a dry run that failed passes the command with the reason", async ($, on) => { - const { clock, ran } = await start($, on, { answers: { orders: { - success: false, - error: "Access Denied: BigQuery job" - } } }); - const result = await $.tool.call(bash("dbt run -s orders")); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders"]); - (0,__vite_ssr_import_0__.expect)(result.context).toEqual(["cost · no estimate for orders: Access Denied: BigQuery job"]); -}); -(0,__vite_ssr_import_0__.test)("/scan-cost estimates a model on demand and says how it stands against the limit", async ($, on) => { - const { clock, estimates, ran } = await start($, on, { answers: { - orders: OVER, - customers: UNDER - } }); - (0,__vite_ssr_import_0__.expect)((await $.command.run({ - command: "scan-cost", - args: "orders" - })).text).toBe("orders would scan 20.0 GiB, over the 10.0 GiB limit: a dbt run of it is held until /allow-scan."); - (0,__vite_ssr_import_0__.expect)((await $.command.run({ - command: "scan-cost", - args: "customers" - })).text).toBe("customers would scan 2.0 GiB, within the 10.0 GiB limit."); - (0,__vite_ssr_import_0__.expect)((await $.command.run({ - command: "scan-cost", - args: "" - })).text).toContain("Last estimate: customers"); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["orders", "customers"]); - (0,__vite_ssr_import_0__.expect)(ran).toEqual([]); -}); -(0,__vite_ssr_import_0__.test)("a command naming two models over the limit is held whole, and one /allow-scan lets all of it through once", async ($, on) => { - const { clock, ran } = await start($, on, { answers: { - orders: OVER, - customers: bq(30 * GIB, "30.0 GiB") - } }); - const command = "dbt run -s orders && dbt run -s customers"; - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash(command))).deny).toContain("30.0 GiB"); - await $.command.run({ - command: "allow-scan", - args: "" - }); - const through = await $.tool.call(bash(command)); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(through.deny).toBeUndefined(); - (0,__vite_ssr_import_0__.expect)(through.context).toEqual(["cost · orders would scan 20.0 GiB, over the 10.0 GiB limit: allowed once", "cost · customers would scan 30.0 GiB, over the 10.0 GiB limit: allowed once"]); - (0,__vite_ssr_import_0__.expect)(ran).toEqual([command]); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash(command))).deny).toBeDefined(); -}); -(0,__vite_ssr_import_0__.test)("/allow-scan with nothing held allows nothing", async ($, on) => { - const { clock } = await start($, on, { answers: { orders: OVER } }); - (0,__vite_ssr_import_0__.expect)((await $.command.run({ - command: "allow-scan", - args: "" - })).text).toContain("Nothing is held"); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); - await clock.settle(); -}); -(0,__vite_ssr_import_0__.test)("the allowance is for the command that was held: another over-limit command is held, and the allowance is gone", async ($, on) => { - const { clock, ran } = await start($, on, { answers: { - orders: OVER, - customers: OVER - } }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); - await $.command.run({ - command: "allow-scan", - args: "" - }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s customers"))).deny).toBeDefined(); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(ran).toEqual([]); -}); -(0,__vite_ssr_import_0__.test)("an estimate whose rounded size is within the limit but whose upper bound is over it is held", async ($, on) => { - const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, "10.0 GiB", 10 * GIB + 52 * 1024 ** 2) } }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBe("up to 10.1 GiB (≈ 10.0 GiB estimated) would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again."); - await clock.settle(); -}); -(0,__vite_ssr_import_0__.test)("an upper bound that formats the same as the limit is not reported as equal to it", async ($, on) => { - const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, "10.0 GiB", 10 * GIB + 30 * 1024 ** 2) } }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBe("just over 10.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again."); - await clock.settle(); -}); -(0,__vite_ssr_import_0__.test)("a warehouse found to have no dry run ends a hold from before, and its allowance", async ($, on) => { - const answers = { orders: OVER }; - const { clock, ran, statuses } = await start($, on, { answers }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); - await $.command.run({ - command: "allow-scan", - args: "" - }); - answers.orders = { - success: true, - supported: false, - adapter: "snowflake" - }; - await $.tool.call(bash("dbt run -s orders")); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders"]); - (0,__vite_ssr_import_0__.expect)(statuses.at(-1) ?? "").not.toContain("held"); - (0,__vite_ssr_import_0__.expect)((await $.command.run({ - command: "allow-scan", - args: "" - })).text).toContain("Nothing is held"); -}); -(0,__vite_ssr_import_0__.test)("a scan just over the limit reads as over it, not as equal to it", async ($, on) => { - const { clock } = await start($, on, { answers: { orders: bq(10 * GIB + 1024 ** 2, "10.0 GiB") } }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBe("just over 10.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again."); - await clock.settle(); -}); -(0,__vite_ssr_import_0__.test)("a command that sets its own target, defer state, vars or project is not estimated", async ($, on) => { - const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } }); - const commands = [ - "dbt run -s orders --target prod", - "dbt run -s orders --defer --state prod-run", - `dbt run -s orders --vars '{a: 1}'`, - "dbt run -s orders --project-dir other", - "DBT_PROFILES_DIR=ci dbt run -s orders", - "cd other && dbt run -s orders", - " cd other && dbt run -s orders", - "export DBT_TARGET=prod; dbt run -s orders", - "uv run --directory other dbt run -s orders", - "dbt run -s orders --'vars' x", - "dbt run -s orders --full-refresh", - "dbt run -s orders --full-\\\nrefresh", - "if true; then cd other; fi; dbt run -s orders", - "dbt --profiles-dir ci run -s orders", - "FOO=1 dbt run -s orders", - "dbt run -s orders --threads $(printf '4 --target prod')", - "dbt run -s orders --threads `echo 4 --vars x`", - "dbt run -s orders 2>&${DBT_TARGET:=1}", - "dbt --log-path \"${DBT_TARGET:=prod}\" deps; dbt run -s orders" - ]; - for (const command of commands) { - const result = await $.tool.call(bash(command)); - (0,__vite_ssr_import_0__.expect)(result.deny).toBeUndefined(); - (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain("it sets its own target, defer state, vars, project or refresh mode"); - }; - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual([]); - (0,__vite_ssr_import_0__.expect)(ran).toEqual(commands); -}); -(0,__vite_ssr_import_0__.test)("dbt show --inline with its SQL on the next line after a backslash is estimated", async ($, on) => { - const { clock, estimates } = await start($, on, { answers: { "select * from big": OVER } }); - const result = await $.tool.call(bash(`dbt show --inline \\\n 'select * from big'`)); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["select * from big"]); - (0,__vite_ssr_import_0__.expect)(result.deny).toContain("20.0 GiB"); -}); -(0,__vite_ssr_import_0__.test)("letting a later command through clears the hold from the status line", async ($, on) => { - const { clock, statuses } = await start($, on, { answers: { - orders: OVER, - customers: UNDER - } }); - await $.tool.call(bash("dbt run -s orders")); - await $.tool.call(bash("dbt run -s customers")); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(statuses.filter(Boolean).at(-1)).not.toContain("held"); -}); -(0,__vite_ssr_import_0__.test)("a variant of the held command that is not estimated leaves the hold in place", async ($, on) => { - const { clock, ran } = await start($, on, { answers: { orders: OVER } }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); - await $.tool.call(bash("dbt run -s +orders")); - await $.tool.call(bash("dbt run -s orders --full-refresh")); - await clock.settle(); - await $.command.run({ - command: "allow-scan", - args: "" - }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeUndefined(); - (0,__vite_ssr_import_0__.expect)(ran.at(-1)).toBe("dbt run -s orders"); -}); -(0,__vite_ssr_import_0__.test)("a repeated --inline is estimated from the last one, as dbt reads it", async ($, on) => { - const { clock, estimates } = await start($, on, { answers: { "select * from big": OVER } }); - const result = await $.tool.call(bash(`dbt show --inline 'select 1' --inline 'select * from big'`)); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["select * from big"]); - (0,__vite_ssr_import_0__.expect)(result.deny).toContain("20.0 GiB"); -}); -(0,__vite_ssr_import_0__.test)("the lines under a command are the latest estimate of it, never an earlier one", async ($, on) => { - const answers = { orders: UNDER }; - const { clock } = await start($, on, { answers }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).context).toEqual(["cost · orders would scan 2.0 GiB"]); - answers.orders = bq(3 * GIB, "3.0 GiB"); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).context).toEqual(["cost · orders would scan 3.0 GiB"]); - await clock.settle(); -}); -(0,__vite_ssr_import_0__.test)("/allow-scan allows only the hold it read: a hold replaced meanwhile is not allowed", async ($, on) => { - const { clock, ran } = await start($, on, { answers: { - orders: OVER, - customers: OVER - } }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); - const allowing = $.command.run({ - command: "allow-scan", - args: "" - }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s customers"))).deny).toBeDefined(); - await allowing; - await clock.settle(); - // Whichever order the two steps took, customers (the later hold) is not allowed by a read of orders. - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s customers"))).deny).toBeDefined(); - (0,__vite_ssr_import_0__.expect)(ran).toEqual([]); -}); -(0,__vite_ssr_import_0__.test)("a non-dbt command in between neither clears the hold nor spends the allowance", async ($, on) => { - const { clock, ran } = await start($, on, { answers: { orders: OVER } }); - await $.tool.call(bash("dbt run -s orders")); - await $.command.run({ - command: "allow-scan", - args: "" - }); - await $.tool.call(bash("ls")); - const through = await $.tool.call(bash("dbt run -s orders")); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(through.deny).toBeUndefined(); - (0,__vite_ssr_import_0__.expect)(ran).toEqual(["ls", "dbt run -s orders"]); -}); -(0,__vite_ssr_import_0__.test)("inlineSql reads the query as the shell would", () => { - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline "select 'a' as x"`)).toBe(`select 'a' as x`); - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline='select 1'`)).toBe("select 1"); - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline select\\ 1 --limit 5`)).toBe("select 1"); - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline \\\n 'select 1'`)).toBe("select 1"); - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)("dbt show -s orders")).toBeNull(); - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline 'select 1' --inline='select 2'`)).toBe("select 2"); - // The value of --inline is the query, even when it looks like an option. - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline '--inline=comment select 1'`)).toBe("--inline=comment select 1"); -}); -(0,__vite_ssr_import_0__.test)("formatBytes writes the units the dry run does", () => { - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.formatBytes)(512)).toBe("512.0 Bytes"); - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.formatBytes)(1536)).toBe("1.5 KiB"); - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.formatBytes)(10 * GIB)).toBe("10.0 GiB"); - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.formatBytes)(1024 ** 5)).toBe("1.0 PiB"); -}); -(0,__vite_ssr_import_0__.test)("what leaves the query alone is still estimated: other dbt calls before it, thread and limit flags, a launcher", async ($, on) => { - const { clock, estimates } = await start($, on, { answers: { - orders: UNDER, - "select 1": UNDER - } }); - for (const command of [ - "dbt deps && dbt run -s orders --threads 4", - "uv run dbt build --select orders --fail-fast", - `dbt show --inline "select 1" --limit 5` - ]) { - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash(command))).context[0]).toContain("would scan 2.0 GiB"); - }; - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual([ - "orders", - "orders", - "select 1" - ]); -}); -(0,__vite_ssr_import_0__.test)("a very long run of blank lines before the command costs no noticeable time", async ($, on) => { - const { clock } = await start($, on, { answers: { orders: UNDER } }); - const began = Date.now(); - await $.tool.call(bash(`${"\n".repeat(64e3)}dbt run -s orders`)); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(Date.now() - began).toBeLessThan(3e3); -}); -(0,__vite_ssr_import_0__.test)("a line with a great many dbt calls is not read call by call", async ($, on) => { - const { clock, estimates } = await start($, on, { answers: { orders: UNDER } }); - const began = Date.now(); - const result = await $.tool.call(bash("dbt run -s orders;".repeat(4e3))); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual([]); - (0,__vite_ssr_import_0__.expect)(result.context.length).toBe(6); - (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain("cost · no estimate"); - (0,__vite_ssr_import_0__.expect)(result.context[5]).toBe("cost · 3995 more notes not shown"); - (0,__vite_ssr_import_0__.expect)(Date.now() - began).toBeLessThan(3e3); -}); -//# sourceMappingSource=vite-generated -//# sourceMappingURL=data:application/json;base64,{"version":3,"mappings":"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","names":[],"ignoreList":[],"sources":["cost.test.tsx"],"sourcesContent":["import { expect, mock, test } from 'claude-code/testing'\n\nimport { formatBytes, inlineSql } from './cost'\n\nconst ROOT = '/repo'\nconst GIB = 1024 ** 3\n\ntype Options = {\n  /** What dbt_cost_estimate answers for a model or SQL, by model name or the SQL text. */\n  answers?: Record<string, Record<string, unknown> | 'unknown-tool'>\n  /** The adapter's answer for everything else. */\n  fallback?: Record<string, unknown>\n}\n\n/** The session beneath the plugin, a CLI whose dbt_cost_estimate is scripted, and a Bash tool that records what ran. */\nasync function start($: any, on: any, options: Options = {}) {\n  const clock = mock.clock(on)\n  const estimates: string[] = []\n  const ran: string[] = []\n  const statuses: (string | undefined)[] = []\n  on('command.register', (_: unknown, e: { name: string }) => ({ value: { command: e.name } }))\n  on('turn.start', (_: unknown, e: { turnId: string }) => ({ turnId: e.turnId }))\n  on('session.end', () => ({ sessionId: 'test' }))\n  on('turn.complete', (_: unknown, e: { answer: string }) => ({ text: e.answer }))\n  on('session.start', (_: unknown, e: { cwd: string }) => ({ cwd: e.cwd }))\n  on('session.root', () => ({ value: ROOT }))\n  on('ui.log', () => ({ value: undefined }))\n  on('ui.status', (_: unknown, e: { text?: string }) => {\n    statuses.push(e.text)\n    return { value: undefined }\n  })\n  on('ui.render', ($$: any, e: any) => {\n    const { Box } = $$.ui.resolve(e)\n    return <Box key=\"engine\" />\n  })\n  on('fs.exists', () => ({ value: false }))\n  on('process.run', (_: unknown, e: { argv: readonly string[] }) => {\n    const [, command, , tool] = e.argv\n    if (command !== 'tool') return { value: { exitCode: 1, stdout: '', stderr: 'not this test' } }\n    expect(tool).toBe('dbt_cost_estimate')\n    // The adapter starts the project's dbt: the call must carry write permission.\n    expect(e.argv).toContain('--allow-write')\n    const args = JSON.parse(String(e.argv[e.argv.indexOf('--args') + 1] ?? '{}'))\n    const key = String(args.model ?? args.sql)\n    estimates.push(key)\n    const answer = options.answers?.[key] ?? options.fallback\n    if (answer === 'unknown-tool') {\n      return { value: { exitCode: 1, stdout: JSON.stringify({ status: 'error', output: `Unknown tool: ${tool}. Run \\`altimate-code tool list\\` to see the available tools.`, metadata: {} }), stderr: '' } }\n    }\n    return { value: { exitCode: 0, stdout: JSON.stringify({ status: 'ok', output: '', metadata: answer ?? { success: false, error: 'no answer scripted' } }), stderr: '' } }\n  })\n  // The Bash tool itself, beneath the plugin.\n  on('tool.call', (_: unknown, e: { tool: string; command?: string }) => {\n    if (e.tool === 'Bash') ran.push(String(e.command))\n    return { result: { text: 'ok', isError: false } }\n  })\n  await $.session.start({ cwd: ROOT, surface: 'terminal', isInteractive: true })\n  await clock.settle()\n  return { clock, estimates, ran, statuses }\n}\n\nconst bq = (bytes: number, display: string, maxBytes = bytes) => ({ success: true, supported: true, adapter: 'bigquery', bytes, maxBytes, display })\nconst OVER = bq(20 * GIB, '20.0 GiB')\nconst UNDER = bq(2 * GIB, '2.0 GiB')\n\nconst bash = (command: string) => ({ tool: 'Bash' as const, command })\n\ntest('a model over the limit is refused with its estimate, and the command never runs', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } })\n  const result: any = await $.tool.call(bash('dbt run --select orders'))\n  await clock.settle()\n\n  expect(estimates).toEqual(['orders'])\n  expect(ran).toEqual([])\n  expect(result.deny).toBe('≈ 20.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.')\n})\n\ntest('a model under the limit runs, with the estimate in a line under the row', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: UNDER } })\n  const result: any = await $.tool.call(bash('dbt build -s orders'))\n  await clock.settle()\n\n  expect(ran).toEqual(['dbt build -s orders'])\n  expect(result.context).toEqual(['cost · orders would scan 2.0 GiB'])\n})\n\ntest('dbt show --inline is estimated from its SQL', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { 'select * from big': OVER } })\n  const result: any = await $.tool.call(bash(`dbt show --inline \"select * from big\"`))\n  await clock.settle()\n\n  expect(estimates).toEqual(['select * from big'])\n  expect(result.deny).toContain('20.0 GiB')\n})\n\ntest('/allow-scan lets the next held command through once, then the one after is held again', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } })\n  expect((await $.tool.call(bash('dbt run -s orders')) as any).deny).toBeDefined()\n\n  const allowed = await $.command.run({ command: 'allow-scan', args: '' } as any)\n  expect(allowed.text).toContain('runs once')\n  const through: any = await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n  expect(through.deny).toBeUndefined()\n  expect(through.context).toEqual(['cost · orders would scan 20.0 GiB, over the 10.0 GiB limit: allowed once'])\n  expect(ran).toEqual(['dbt run -s orders'])\n\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  expect(estimates).toHaveLength(3)\n})\n\ntest('a selection that is not one plain model passes, saying there is no estimate, and asks nothing', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on)\n  for (const [command, why] of [\n    ['dbt run', 'no model named'],\n    ['dbt build -s +orders', 'graph, tag, path or package selector'],\n    ['dbt run -s tag:nightly', 'graph, tag, path or package selector'],\n    ['dbt run -s a b', 'several selectors'],\n  ] as const) {\n    const result: any = await $.tool.call(bash(command))\n    expect(result.deny).toBeUndefined()\n    expect(result.context[0]).toContain('cost · no estimate for this selection')\n    expect(result.context[0]).toContain(why)\n  }\n  await clock.settle()\n  expect(estimates).toEqual([])\n  expect(ran).toHaveLength(4)\n})\n\ntest('commands that scan nothing are not looked at', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on)\n  for (const command of ['dbt test -s orders', 'dbt compile -s orders', 'ls', 'git status']) await $.tool.call(bash(command))\n  await clock.settle()\n  expect(estimates).toEqual([])\n  expect(ran).toHaveLength(4)\n})\n\ntest('another warehouse is told once, never held, and not asked again', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { fallback: { success: true, supported: false, adapter: 'snowflake' } })\n  const first: any = await $.tool.call(bash('dbt run -s orders'))\n  const second: any = await $.tool.call(bash('dbt run -s customers'))\n  await clock.settle()\n\n  expect(first.deny).toBeUndefined()\n  expect(first.context).toEqual(['cost · no estimate on snowflake: only BigQuery has a dry run'])\n  expect(second.deny).toBeUndefined()\n  expect(estimates).toEqual(['orders'])\n  expect(ran).toEqual(['dbt run -s orders', 'dbt run -s customers'])\n})\n\ntest('an altimate-code without the tool shows one line saying what is needed, and the command runs', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: 'unknown-tool' } })\n  const result: any = await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n\n  expect(ran).toEqual(['dbt run -s orders'])\n  expect(result.context).toHaveLength(1)\n  expect(result.context[0]).toContain('needs a newer altimate-code')\n})\n\ntest('a dry run that failed passes the command with the reason', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: { success: false, error: 'Access Denied: BigQuery job' } } })\n  const result: any = await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n\n  expect(ran).toEqual(['dbt run -s orders'])\n  expect(result.context).toEqual(['cost · no estimate for orders: Access Denied: BigQuery job'])\n})\n\ntest('/scan-cost estimates a model on demand and says how it stands against the limit', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER, customers: UNDER } })\n  expect((await $.command.run({ command: 'scan-cost', args: 'orders' } as any)).text).toBe(\n    'orders would scan 20.0 GiB, over the 10.0 GiB limit: a dbt run of it is held until /allow-scan.',\n  )\n  expect((await $.command.run({ command: 'scan-cost', args: 'customers' } as any)).text).toBe('customers would scan 2.0 GiB, within the 10.0 GiB limit.')\n  expect((await $.command.run({ command: 'scan-cost', args: '' } as any)).text).toContain('Last estimate: customers')\n  await clock.settle()\n  expect(estimates).toEqual(['orders', 'customers'])\n  expect(ran).toEqual([])\n})\n\ntest('a command naming two models over the limit is held whole, and one /allow-scan lets all of it through once', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER, customers: bq(30 * GIB, '30.0 GiB') } })\n  const command = 'dbt run -s orders && dbt run -s customers'\n  expect(((await $.tool.call(bash(command))) as any).deny).toContain('30.0 GiB')\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n  const through: any = await $.tool.call(bash(command))\n  await clock.settle()\n\n  expect(through.deny).toBeUndefined()\n  expect(through.context).toEqual([\n    'cost · orders would scan 20.0 GiB, over the 10.0 GiB limit: allowed once',\n    'cost · customers would scan 30.0 GiB, over the 10.0 GiB limit: allowed once',\n  ])\n  expect(ran).toEqual([command])\n  expect(((await $.tool.call(bash(command))) as any).deny).toBeDefined()\n})\n\ntest('/allow-scan with nothing held allows nothing', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: OVER } })\n  expect((await $.command.run({ command: 'allow-scan', args: '' } as any)).text).toContain('Nothing is held')\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await clock.settle()\n})\n\ntest('the allowance is for the command that was held: another over-limit command is held, and the allowance is gone', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER, customers: OVER } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n\n  expect(((await $.tool.call(bash('dbt run -s customers'))) as any).deny).toBeDefined()\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await clock.settle()\n  expect(ran).toEqual([])\n})\n\ntest('an estimate whose rounded size is within the limit but whose upper bound is over it is held', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, '10.0 GiB', 10 * GIB + 52 * 1024 ** 2) } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBe('up to 10.1 GiB (≈ 10.0 GiB estimated) would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.')\n  await clock.settle()\n})\n\ntest('an upper bound that formats the same as the limit is not reported as equal to it', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, '10.0 GiB', 10 * GIB + 30 * 1024 ** 2) } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBe('just over 10.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.')\n  await clock.settle()\n})\n\ntest('a warehouse found to have no dry run ends a hold from before, and its allowance', async ($, on) => {\n  const answers: Record<string, any> = { orders: OVER }\n  const { clock, ran, statuses } = await start($, on, { answers })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n  answers.orders = { success: true, supported: false, adapter: 'snowflake' }\n  await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n  expect(ran).toEqual(['dbt run -s orders'])\n  expect(statuses.at(-1) ?? '').not.toContain('held')\n  expect((await $.command.run({ command: 'allow-scan', args: '' } as any)).text).toContain('Nothing is held')\n})\n\ntest('a scan just over the limit reads as over it, not as equal to it', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: bq(10 * GIB + 1024 ** 2, '10.0 GiB') } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBe('just over 10.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.')\n  await clock.settle()\n})\n\ntest('a command that sets its own target, defer state, vars or project is not estimated', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } })\n  const commands = [\n    'dbt run -s orders --target prod',\n    'dbt run -s orders --defer --state prod-run',\n    `dbt run -s orders --vars '{a: 1}'`,\n    'dbt run -s orders --project-dir other',\n    'DBT_PROFILES_DIR=ci dbt run -s orders',\n    'cd other && dbt run -s orders',\n    ' cd other && dbt run -s orders',\n    'export DBT_TARGET=prod; dbt run -s orders',\n    'uv run --directory other dbt run -s orders',\n    \"dbt run -s orders --'vars' x\",\n    'dbt run -s orders --full-refresh',\n    'dbt run -s orders --full-\\\\\\nrefresh',\n    'if true; then cd other; fi; dbt run -s orders',\n    'dbt --profiles-dir ci run -s orders',\n    'FOO=1 dbt run -s orders',\n    \"dbt run -s orders --threads $(printf '4 --target prod')\",\n    'dbt run -s orders --threads `echo 4 --vars x`',\n    'dbt run -s orders 2>&${DBT_TARGET:=1}',\n    'dbt --log-path \"${DBT_TARGET:=prod}\" deps; dbt run -s orders',\n  ]\n  for (const command of commands) {\n    const result: any = await $.tool.call(bash(command))\n    expect(result.deny).toBeUndefined()\n    expect(result.context[0]).toContain('it sets its own target, defer state, vars, project or refresh mode')\n  }\n  await clock.settle()\n  expect(estimates).toEqual([])\n  expect(ran).toEqual(commands)\n})\n\ntest('dbt show --inline with its SQL on the next line after a backslash is estimated', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { 'select * from big': OVER } })\n  const result: any = await $.tool.call(bash(`dbt show --inline \\\\\\n  'select * from big'`))\n  await clock.settle()\n  expect(estimates).toEqual(['select * from big'])\n  expect(result.deny).toContain('20.0 GiB')\n})\n\ntest('letting a later command through clears the hold from the status line', async ($, on) => {\n  const { clock, statuses } = await start($, on, { answers: { orders: OVER, customers: UNDER } })\n  await $.tool.call(bash('dbt run -s orders'))\n  await $.tool.call(bash('dbt run -s customers'))\n  await clock.settle()\n  expect(statuses.filter(Boolean).at(-1)).not.toContain('held')\n})\n\ntest('a variant of the held command that is not estimated leaves the hold in place', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await $.tool.call(bash('dbt run -s +orders'))\n  await $.tool.call(bash('dbt run -s orders --full-refresh'))\n  await clock.settle()\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeUndefined()\n  expect(ran.at(-1)).toBe('dbt run -s orders')\n})\n\ntest('a repeated --inline is estimated from the last one, as dbt reads it', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { 'select * from big': OVER } })\n  const result: any = await $.tool.call(bash(`dbt show --inline 'select 1' --inline 'select * from big'`))\n  await clock.settle()\n  expect(estimates).toEqual(['select * from big'])\n  expect(result.deny).toContain('20.0 GiB')\n})\n\ntest('the lines under a command are the latest estimate of it, never an earlier one', async ($, on) => {\n  const answers: Record<string, any> = { orders: UNDER }\n  const { clock } = await start($, on, { answers })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).context).toEqual(['cost · orders would scan 2.0 GiB'])\n  answers.orders = bq(3 * GIB, '3.0 GiB')\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).context).toEqual(['cost · orders would scan 3.0 GiB'])\n  await clock.settle()\n})\n\ntest('/allow-scan allows only the hold it read: a hold replaced meanwhile is not allowed', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER, customers: OVER } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  const allowing = $.command.run({ command: 'allow-scan', args: '' } as any)\n  expect(((await $.tool.call(bash('dbt run -s customers'))) as any).deny).toBeDefined()\n  await allowing\n  await clock.settle()\n  // Whichever order the two steps took, customers (the later hold) is not allowed by a read of orders.\n  expect(((await $.tool.call(bash('dbt run -s customers'))) as any).deny).toBeDefined()\n  expect(ran).toEqual([])\n})\n\ntest('a non-dbt command in between neither clears the hold nor spends the allowance', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER } })\n  await $.tool.call(bash('dbt run -s orders'))\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n  await $.tool.call(bash('ls'))\n  const through: any = await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n  expect(through.deny).toBeUndefined()\n  expect(ran).toEqual(['ls', 'dbt run -s orders'])\n})\n\ntest('inlineSql reads the query as the shell would', () => {\n  expect(inlineSql(`dbt show --inline \"select 'a' as x\"`)).toBe(`select 'a' as x`)\n  expect(inlineSql(`dbt show --inline='select 1'`)).toBe('select 1')\n  expect(inlineSql(`dbt show --inline select\\\\ 1 --limit 5`)).toBe('select 1')\n  expect(inlineSql(`dbt show --inline \\\\\\n 'select 1'`)).toBe('select 1')\n  expect(inlineSql('dbt show -s orders')).toBeNull()\n  expect(inlineSql(`dbt show --inline 'select 1' --inline='select 2'`)).toBe('select 2')\n  // The value of --inline is the query, even when it looks like an option.\n  expect(inlineSql(`dbt show --inline '--inline=comment select 1'`)).toBe('--inline=comment select 1')\n})\n\ntest('formatBytes writes the units the dry run does', () => {\n  expect(formatBytes(512)).toBe('512.0 Bytes')\n  expect(formatBytes(1536)).toBe('1.5 KiB')\n  expect(formatBytes(10 * GIB)).toBe('10.0 GiB')\n  expect(formatBytes(1024 ** 5)).toBe('1.0 PiB')\n})\n\ntest('what leaves the query alone is still estimated: other dbt calls before it, thread and limit flags, a launcher', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { orders: UNDER, 'select 1': UNDER } })\n  for (const command of ['dbt deps && dbt run -s orders --threads 4', 'uv run dbt build --select orders --fail-fast', `dbt show --inline \"select 1\" --limit 5`]) {\n    expect(((await $.tool.call(bash(command))) as any).context[0]).toContain('would scan 2.0 GiB')\n  }\n  await clock.settle()\n  expect(estimates).toEqual(['orders', 'orders', 'select 1'])\n})\n\ntest('a very long run of blank lines before the command costs no noticeable time', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: UNDER } })\n  const began = Date.now()\n  await $.tool.call(bash(`${'\\n'.repeat(64000)}dbt run -s orders`))\n  await clock.settle()\n  expect(Date.now() - began).toBeLessThan(3000)\n})\n\ntest('a line with a great many dbt calls is not read call by call', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { orders: UNDER } })\n  const began = Date.now()\n  const result: any = await $.tool.call(bash('dbt run -s orders;'.repeat(4000)))\n  await clock.settle()\n  expect(estimates).toEqual([])\n  expect(result.context.length).toBe(6)\n  expect(result.context[0]).toContain('cost · no estimate')\n  expect(result.context[5]).toBe('cost · 3995 more notes not shown')\n  expect(Date.now() - began).toBeLessThan(3000)\n})\n"],"file":"/hooks/features/cost.test.tsx"} - -//# vitestCache=W3siZmlsZSI6IjEiLCJpZCI6IjEiLCJpbXBvcnRzIjoiMiIsIm1hcHBpbmdzIjpmYWxzZSwiZGVwcyI6IjMiLCJkeW5hbWljRGVwcyI6IjQiLCJzdGF0aWNNb2NrcyI6bnVsbCwiaGFzQ292ZXJhZ2VEYXRhIjpmYWxzZX0sIi9Vc2Vycy9oYXJpc2gvLnF1aWtpbS93b3Jrc3BhY2VzL2FsdGltYXRlLWNsYXVkZS1wbHVnaW4vZmVhdC9kYnQtY29zdC1lc3RpbWF0ZS10b29sL3BsdWdpbnMvYWx0aW1hdGUtY29kZS9ob29rcy9mZWF0dXJlcy9jb3N0LnRlc3QudHN4Iix7InVybHMiOiI1IiwiaWRzIjoiNiJ9LFsiNyIsIjgiLCI5Il0sW10sWyI3IiwiOCIsIjkiXSx7fSwiY2xhdWRlLWNvZGUvdGVzdGluZyIsIi9ob29rcy9mZWF0dXJlcy9jb3N0LnRzeCIsInJlYWN0L2pzeC1kZXYtcnVudGltZSJd \ No newline at end of file diff --git a/plugins/altimate-code/node_modules/.vitest-cache/CACHEDIR.TAG b/plugins/altimate-code/node_modules/.vitest-cache/CACHEDIR.TAG deleted file mode 100644 index 8c1ef4ce..00000000 --- a/plugins/altimate-code/node_modules/.vitest-cache/CACHEDIR.TAG +++ /dev/null @@ -1,3 +0,0 @@ -Signature: 8a477f597d28d172789f06886806bc55 -# This file is a cache directory tag created by Vitest. -# For information about cache directory tags see https://bford.info/cachedir/ diff --git a/plugins/altimate-code/node_modules/.vitest-cache/_metadata.json b/plugins/altimate-code/node_modules/.vitest-cache/_metadata.json deleted file mode 100644 index 9ee9061a..00000000 --- a/plugins/altimate-code/node_modules/.vitest-cache/_metadata.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "lockfileHash": "e3b0c442" -} \ No newline at end of file From 01641beb6f2671bfc242f0f2ac89eff7854937c5 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 09:03:05 +0530 Subject: [PATCH 40/56] fix(cost): a voided running estimate is not reused and holds the next one back Co-Authored-By: Claude Opus 5.5 --- .../altimate-code/hooks/features/cost.test.tsx | 18 ++++++++++++++++++ plugins/altimate-code/hooks/features/cost.tsx | 8 ++++++-- 2 files changed, 24 insertions(+), 2 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 968db3bc..378e2c82 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -831,6 +831,24 @@ test('a run let through while an estimate is still running: the retry does not t expect(estimates).toEqual(['orders', 'orders']) }) +test('a voided running estimate is not reused and holds the next one back until it settles', async ($, on) => { + const options: Options = { answers: { orders: UNDER } } + const { clock, estimates } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + const first = $.tool.call(bash('dbt run -s orders')) + await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') + expect(((await $.tool.call(bash('dbt run -s customers --target prod'))) as any).deny).toBeUndefined() + const again = $.tool.call(bash('dbt run -s orders')) + await clock.advance(4_001) + expect(((await again) as any).deny).toContain('still being estimated') + expect(estimates).toEqual([]) + release() + await clock.settle() + expect(estimates).toEqual(['orders']) +}) + test('a /cd takes the old project\'s hold off the status line and forgets its last estimate', async ($, on) => { const options: Options = { answers: { orders: OVER } } const { clock, statuses } = await start($, on, options) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 95994780..06dcaf5d 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -357,7 +357,11 @@ function dropFinished() { for (const [key, entry] of inflight) { if (entry.doneAt != null) inflight.delete(key) // A pass already waiting on it takes its answer; a later pass does not, since a run began after it started. - else entry.voided = true + else { + entry.voided = true + late.add(entry.settled) + void entry.settled.then(() => late.delete(entry.settled)) + } } } @@ -575,7 +579,7 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: } // Another pass may have started this same estimate while this waited. const started = inflight.get(key) - if (started && started.doneAt == null) running = started + if (started && started.doneAt == null && !started.voided) running = started } if (!running) { const answer = estimate($, args, now + ESTIMATE_BUDGET_MS) From 47a093b643f8a58ee5cebe0e704db0e7323a8232 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 09:13:27 +0530 Subject: [PATCH 41/56] refactor(cost): one hold-back helper; the voided-estimate test pins the hold-back Co-Authored-By: Claude Opus 5.5 --- .../hooks/features/cost.test.tsx | 23 ++++++++++++++----- plugins/altimate-code/hooks/features/cost.tsx | 17 ++++++++------ 2 files changed, 27 insertions(+), 13 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 378e2c82..53d35525 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -26,6 +26,8 @@ type Options = { async function start($: any, on: any, options: Options = {}) { const clock = mock.clock(on) const estimates: string[] = [] + /** Estimates asked for, before any hold: one that has started and not yet answered is in here. */ + const started: string[] = [] const ran: string[] = [] const statuses: (string | undefined)[] = [] on('command.register', (_: unknown, e: { name: string }) => ({ value: { command: e.name } })) @@ -55,6 +57,7 @@ async function start($: any, on: any, options: Options = {}) { expect(e.argv).toContain('--allow-write') const args = JSON.parse(String(e.argv[e.argv.indexOf('--args') + 1] ?? '{}')) const key = String(args.model ?? args.sql) + started.push(key) if (options.hold && (options.holdFor === undefined || options.holdFor === key)) await options.hold estimates.push(key) const answer = options.answers?.[key] ?? options.fallback @@ -71,7 +74,7 @@ async function start($: any, on: any, options: Options = {}) { }) await $.session.start({ cwd: ROOT, surface: 'terminal', isInteractive: true }) await clock.settle() - return { clock, estimates, ran, statuses } + return { clock, estimates, ran, statuses, started } } const bq = (bytes: number, display: string, maxBytes = bytes) => ({ success: true, supported: true, adapter: 'bigquery', bytes, maxBytes, display }) @@ -833,17 +836,25 @@ test('a run let through while an estimate is still running: the retry does not t test('a voided running estimate is not reused and holds the next one back until it settles', async ($, on) => { const options: Options = { answers: { orders: UNDER } } - const { clock, estimates } = await start($, on, options) + const { clock, estimates, started } = await start($, on, options) let release!: () => void options.hold = new Promise(resolve => (release = resolve)) + let finish!: () => void + options.holdBash = { command: 'dbt run -s customers --target prod', until: new Promise(resolve => (finish = resolve)) } + // Still inside the gate's wait when the run is let through (and still running): nothing has timed it out yet. const first = $.tool.call(bash('dbt run -s orders')) - await clock.advance(4_001) - expect(((await first) as any).deny).toContain('still being estimated') - expect(((await $.tool.call(bash('dbt run -s customers --target prod'))) as any).deny).toBeUndefined() + await clock.advance(1_000) + const rebuild = $.tool.call(bash('dbt run -s customers --target prod')) + await clock.advance(10) const again = $.tool.call(bash('dbt run -s orders')) + await clock.advance(500) + expect(started).toEqual(['orders']) await clock.advance(4_001) + expect(((await first) as any).deny).toContain('still being estimated') expect(((await again) as any).deny).toContain('still being estimated') - expect(estimates).toEqual([]) + expect(started).toEqual(['orders']) + finish() + await rebuild release() await clock.settle() expect(estimates).toEqual(['orders']) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 06dcaf5d..5111d5a9 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -352,6 +352,12 @@ export async function editAfter($: EngineInterface, e: FileCall, result: ToolCal await forgetUnsupported($) } +/** Nothing starts beside this estimate until its process has settled. */ +function holdBack(entry: { settled: Promise }) { + late.add(entry.settled) + void entry.settled.then(() => late.delete(entry.settled)) +} + /** Drops the answers already in; an estimate still running, which a parallel call may be waiting on, is left to finish. */ function dropFinished() { for (const [key, entry] of inflight) { @@ -359,8 +365,7 @@ function dropFinished() { // A pass already waiting on it takes its answer; a later pass does not, since a run began after it started. else { entry.voided = true - late.add(entry.settled) - void entry.settled.then(() => late.delete(entry.settled)) + holdBack(entry) } } } @@ -371,8 +376,7 @@ function invalidate(track = true) { if (track) { for (const entry of inflight.values()) { if (entry.doneAt != null) continue - late.add(entry.settled) - void entry.settled.then(() => late.delete(entry.settled)) + holdBack(entry) } } inflight.clear() @@ -591,8 +595,7 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: const left = waitUntil - (await $.clock.now()) const done = left > 0 ? await within($, left, running.answer.then(answer => ({ answer }))) : null if (!done) { - late.add(running.settled) - void running.settled.then(() => late.delete(running!.settled)) + holdBack(running) return 'pending' } // The project may have changed while it ran: that answer is of the old one, and the next pass asks again. @@ -613,13 +616,13 @@ async function rememberEstimate($: EngineInterface, target: string, bytes: numbe } catch {} } -/** The status line's cost part; a failure to draw it is dropped. */ /** The status line's cost part back to the last estimate, once no hold is left. */ async function showLastEstimate($: EngineInterface) { const last = (await read($, costAtom))?.lastEstimate await showStatus($, last ? `scan ≈ ${last.display}` : null) } +/** The status line's cost part; a failure to draw it is dropped. */ async function showStatus($: EngineInterface, text: string | null) { try { await setStatusPart($, 'cost', text) From 2fa62d2fbb7c40ecf0970fa851a30e160f7fc214 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 09:22:19 +0530 Subject: [PATCH 42/56] fix(cost): a gate that finds the project changed drops only the estimates older than the change Co-Authored-By: Claude Opus 5.5 --- plugins/altimate-code/hooks/features/cost.tsx | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 5111d5a9..362f75fd 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -254,7 +254,8 @@ async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | } if (generation !== startedAt) { - inflight.clear() + // Only what this pass could have started: a newer pass's estimates are its own. + for (const [key, entry] of inflight) if (entry.generation < generation) inflight.delete(key) notes.delete(e.command) return { deny: 'The project changed while the scan was being estimated. Run the same command again.' } } From 81020c3c763dd0ee004fa1625cdfa4f6fcdc4b52 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 09:28:45 +0530 Subject: [PATCH 43/56] fix(cost): leave a newer pass's estimates alone when the project changed Co-Authored-By: Claude Opus 5.5 --- plugins/altimate-code/hooks/features/cost.tsx | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 362f75fd..1d180691 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -254,8 +254,7 @@ async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | } if (generation !== startedAt) { - // Only what this pass could have started: a newer pass's estimates are its own. - for (const [key, entry] of inflight) if (entry.generation < generation) inflight.delete(key) + // Nothing is cleared here: the change already cleared what was older, and a newer pass's estimates are its own. notes.delete(e.command) return { deny: 'The project changed while the scan was being estimated. Run the same command again.' } } From efdf8ca1a35db7a2becd3e2c878f6a9fc9a089a2 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 09:45:10 +0530 Subject: [PATCH 44/56] test: narrow holdBash in the cost harness and give the long-line test a timeout matching its bound Co-Authored-By: Claude Sonnet 5.5 --- plugins/altimate-code/hooks/features/cost.test.tsx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 53d35525..f70bdac0 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -68,7 +68,7 @@ async function start($: any, on: any, options: Options = {}) { }) // The Bash tool itself, beneath the plugin. on('tool.call', async (_: unknown, e: { tool: string; command?: string }) => { - if (e.tool === 'Bash' && options.holdBash?.command === e.command) await options.holdBash.until + if (e.tool === 'Bash' && options.holdBash && options.holdBash.command === e.command) await options.holdBash.until if (e.tool === 'Bash') ran.push(String(e.command)) return { result: { text: 'ok', isError: false } } }) @@ -426,7 +426,7 @@ test('a very long run of blank lines before the command costs no noticeable time expect(Date.now() - began).toBeLessThan(3000) }) -test('a line with a great many dbt calls is not read call by call', async ($, on) => { +test('a line with a great many dbt calls is not read call by call', { timeoutMs: 20_000 }, async ($, on) => { const { clock, estimates } = await start($, on, { answers: { orders: UNDER } }) const began = Date.now() const result: any = await $.tool.call(bash('dbt run -s orders;'.repeat(4000))) From a8100d03bd2180e1f8b09338bd816d3f7df76768 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 10:00:59 +0530 Subject: [PATCH 45/56] fix(cost): one estimate runs per project at a time, a /scan-cost included Co-Authored-By: Claude Opus 5.5 --- .../hooks/features/cost.test.tsx | 53 ++++++++++ plugins/altimate-code/hooks/features/cost.tsx | 99 +++++++++++-------- 2 files changed, 111 insertions(+), 41 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index f70bdac0..280a565d 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -860,6 +860,59 @@ test('a voided running estimate is not reused and holds the next one back until expect(estimates).toEqual(['orders']) }) +test('parallel dbt calls estimate one at a time: the second starts when the first is in', async ($, on) => { + const options: Options = { answers: { a: UNDER, b: UNDER } } + const { clock, started } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + options.holdFor = 'a' + const both = Promise.all([$.tool.call(bash('dbt run -s a')), $.tool.call(bash('dbt run -s b'))]) + await clock.advance(1_000) + expect(started).toEqual(['a']) + release() + const results: any[] = await both + await clock.settle() + expect(started).toEqual(['a', 'b']) + // The first run finished while the second was being estimated, which moved the project on: the second asks again. + expect(results[0].deny).toBeUndefined() + expect(results[1].deny).toContain('Run the same command again') +}) + +test('/scan-cost does not start beside a running gate estimate', async ($, on) => { + const options: Options = { answers: { a: UNDER, orders: UNDER } } + const { clock, started } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + options.holdFor = 'a' + const gate = $.tool.call(bash('dbt run -s a')) + await clock.advance(500) + const scan = $.command.run({ command: 'scan-cost', args: 'orders' } as any) + await clock.advance(1_000) + expect(started).toEqual(['a']) + release() + await gate + expect(((await scan) as any).text).toContain('orders would scan 2.0 GiB') + expect(started).toEqual(['a', 'orders']) +}) + +test('a gate estimate does not start beside a running /scan-cost', async ($, on) => { + const options: Options = { answers: { a: UNDER, orders: UNDER } } + const { clock, started } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + options.holdFor = 'orders' + const scan = $.command.run({ command: 'scan-cost', args: 'orders' } as any) + await clock.advance(500) + const gate = $.tool.call(bash('dbt run -s a')) + await clock.advance(1_000) + expect(started).toEqual(['orders']) + release() + await scan + expect(((await gate) as any).deny).toBeUndefined() + await clock.settle() + expect(started).toEqual(['orders', 'a']) +}) + test('a /cd takes the old project\'s hold off the status line and forgets its last estimate', async ($, on) => { const options: Options = { answers: { orders: OVER } } const { clock, statuses } = await start($, on, options) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 1d180691..cb048f4a 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -45,8 +45,8 @@ let limitBytes = DEFAULT_MAX_SCAN_BYTES const notes = new Map() /** Estimates still running past the gate's wait, by what they ask about; the next gate pass for the same target takes the answer. */ const inflight = new Map; settled: Promise; doneAt: number | null; generation: number; voided?: boolean }>() -/** Estimates that outlasted the gate's wait and are still running, whether or not an edit has voided their answer: nothing else starts beside one. */ -const late = new Set>() +/** Every estimate whose process is still running (gate or /scan-cost), whether or not an edit has voided its answer: one runs per project at a time. */ +const active = new Set>() /** Commands the gate refused while their estimate was running, and when it last did: they have not run, so a retry changes nothing. */ const refused = new Map() /** Moves on whenever the project may have changed: an estimate started before it is never taken as an answer. */ @@ -122,7 +122,10 @@ export function register(on: On, context: FeatureContext) { const last = (await read($, costAtom))?.lastEstimate return { text: last ? `Last estimate: ${last.target} would scan ${last.display}. Run /scan-cost for another.` : 'Run /scan-cost to estimate the scan of a model.' } } - const answer = await estimate($, { model: target }, (await $.clock.now()) + ESTIMATE_BUDGET_MS) + const began = await $.clock.now() + const started = await startWhenIdle($, { model: target }, began + ESTIMATE_BUDGET_MS, began + ESTIMATE_BUDGET_MS, () => undefined, one => one) + if (!started) return { text: 'No estimate: another estimate is still running in this project. Try again in a moment.' } + const answer = await started.answer if (answer.kind === 'bytes') { await forgetUnsupported($) await rememberEstimate($, target, answer.bytes, answer.display) @@ -140,7 +143,7 @@ export async function sessionStart($: EngineInterface, e: Args<'session.start'>) generation++ unsupportedSince = null seenDir = null - late.clear() + active.clear() await update($, costAtom, () => ({ ...FRESH })) await setStatusPart($, 'cost', null) await $.command.register({ name: 'allow-scan', description: 'Let the dbt command held for its BigQuery scan size run once, when run again unchanged' }) @@ -187,8 +190,8 @@ async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | const dir = await $.session.cwd().catch(() => seenDir) if (seenDir !== null && dir !== seenDir) { // What is still running belongs to the project left behind: it holds nothing back here. - invalidate(false) - late.clear() + invalidate() + active.clear() await forgetUnsupported($) await update($, costAtom, prev => (prev ? { ...prev, held: null, allowOnce: false, lastEstimate: null } : prev)) await showStatus($, null) @@ -352,10 +355,33 @@ export async function editAfter($: EngineInterface, e: FileCall, result: ToolCal await forgetUnsupported($) } -/** Nothing starts beside this estimate until its process has settled. */ -function holdBack(entry: { settled: Promise }) { - late.add(entry.settled) - void entry.settled.then(() => late.delete(entry.settled)) +/** Runs the estimate and counts it as running until it settles. */ +function startEstimate($: EngineInterface, args: { model?: string; sql?: string }, until: number) { + const answer = estimate($, args, until) + const settled = answer.then(() => undefined, () => undefined) + active.add(settled) + void settled.then(() => active.delete(settled)) + return { answer, settled } +} + +/** + * Starts the estimate once no other is running, in the same step as that check: two waiters woken together never both + * start. `reuse` is asked at that step too, for an estimate of the same thing another pass started meanwhile. Null when + * `waitUntil` comes first. + */ +async function startWhenIdle( + $: EngineInterface, + args: { model?: string; sql?: string }, + waitUntil: number, + budgetUntil: number, + reuse: () => T | undefined, + begin: (started: { answer: Promise; settled: Promise }) => T, +): Promise { + while (active.size > 0) { + const left = waitUntil - (await $.clock.now()) + if (left <= 0 || !(await within($, left, Promise.all([...active]).then(() => true)))) return null + } + return reuse() ?? begin(startEstimate($, args, budgetUntil)) } /** Drops the answers already in; an estimate still running, which a parallel call may be waiting on, is left to finish. */ @@ -363,22 +389,12 @@ function dropFinished() { for (const [key, entry] of inflight) { if (entry.doneAt != null) inflight.delete(key) // A pass already waiting on it takes its answer; a later pass does not, since a run began after it started. - else { - entry.voided = true - holdBack(entry) - } + else entry.voided = true } } -/** An estimate voided while it runs still has its process: nothing starts beside it (unless `track` is false, for a project left). */ -function invalidate(track = true) { +function invalidate() { generation++ - if (track) { - for (const entry of inflight.values()) { - if (entry.doneAt != null) continue - holdBack(entry) - } - } inflight.clear() } @@ -575,29 +591,30 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: if (!running) { // The wait is spent: nothing new starts. Each estimate may start the adapter (dbt deps), and two at once in one project collide. if (waitUntil - now <= 0) return 'pending' - // Nor beside one that already outlasted its wait (its command was refused), whichever command asks, even when an edit voided - // its answer: this one waits its turn, within the same bound. - while (late.size > 0) { - const left = waitUntil - (await $.clock.now()) - if (left <= 0 || !(await within($, left, Promise.all([...late]).then(() => true)))) return 'pending' - } - // Another pass may have started this same estimate while this waited. - const started = inflight.get(key) - if (started && started.doneAt == null && !started.voided) running = started - } - if (!running) { - const answer = estimate($, args, now + ESTIMATE_BUDGET_MS) - const entry = { answer, settled: answer.then(() => undefined, () => undefined), doneAt: null as number | null, generation } - void entry.answer.then(async () => void (entry.doneAt = await $.clock.now())).catch(() => {}) - inflight.set(key, entry) + // Nor beside any running one, whichever command asks (a /scan-cost too), even when an edit voided its answer: + // this one waits its turn, within the same bound. + const entry = await startWhenIdle( + $, + args, + waitUntil, + now + ESTIMATE_BUDGET_MS, + () => { + const other = inflight.get(key) + return other && other.doneAt == null && !other.voided ? other : undefined + }, + started => { + const made = { answer: started.answer, settled: started.settled, doneAt: null as number | null, generation, voided: false } + void made.answer.then(async () => void (made.doneAt = await $.clock.now())).catch(() => {}) + inflight.set(key, made) + return made + }, + ) + if (!entry) return 'pending' running = entry } const left = waitUntil - (await $.clock.now()) const done = left > 0 ? await within($, left, running.answer.then(answer => ({ answer }))) : null - if (!done) { - holdBack(running) - return 'pending' - } + if (!done) return 'pending' // The project may have changed while it ran: that answer is of the old one, and the next pass asks again. if (running.generation !== generation) { if (inflight.get(key) === running) inflight.delete(key) From bf58888cfbe8ecffaf167134447ae329cb09ae5c Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 10:05:42 +0530 Subject: [PATCH 46/56] test(cost): the parallel-call test does not depend on when the first run finishes Co-Authored-By: Claude Opus 5.5 --- plugins/altimate-code/hooks/features/cost.test.tsx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 280a565d..147f87d8 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -873,9 +873,9 @@ test('parallel dbt calls estimate one at a time: the second starts when the firs const results: any[] = await both await clock.settle() expect(started).toEqual(['a', 'b']) - // The first run finished while the second was being estimated, which moved the project on: the second asks again. + // The first run may finish while the second is being estimated, which moves the project on: then the second asks again. expect(results[0].deny).toBeUndefined() - expect(results[1].deny).toContain('Run the same command again') + expect(results[1].deny ?? 'Run the same command again').toContain('Run the same command again') }) test('/scan-cost does not start beside a running gate estimate', async ($, on) => { From 1c8c9d82029fa0fdba9d4ae128421be59b002765 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 10:13:28 +0530 Subject: [PATCH 47/56] fix(cost): /scan-cost waits a short while for a running estimate; the estimate's budget starts after the wait Co-Authored-By: Claude Opus 5.5 --- plugins/altimate-code/hooks/features/cost.test.tsx | 2 +- plugins/altimate-code/hooks/features/cost.tsx | 7 +++---- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 147f87d8..675f7952 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -875,7 +875,7 @@ test('parallel dbt calls estimate one at a time: the second starts when the firs expect(started).toEqual(['a', 'b']) // The first run may finish while the second is being estimated, which moves the project on: then the second asks again. expect(results[0].deny).toBeUndefined() - expect(results[1].deny ?? 'Run the same command again').toContain('Run the same command again') + expect(results[1].deny === undefined || results[1].deny.includes('Run the same command again')).toBe(true) }) test('/scan-cost does not start beside a running gate estimate', async ($, on) => { diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index cb048f4a..6558d8b9 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -123,7 +123,8 @@ export function register(on: On, context: FeatureContext) { return { text: last ? `Last estimate: ${last.target} would scan ${last.display}. Run /scan-cost for another.` : 'Run /scan-cost to estimate the scan of a model.' } } const began = await $.clock.now() - const started = await startWhenIdle($, { model: target }, began + ESTIMATE_BUDGET_MS, began + ESTIMATE_BUDGET_MS, () => undefined, one => one) + // The wait is short (the user is looking at the screen); the estimate's own budget starts when the wait ends, at the latest. + const started = await startWhenIdle($, { model: target }, began + GATE_WAIT_MS, () => undefined, one => one) if (!started) return { text: 'No estimate: another estimate is still running in this project. Try again in a moment.' } const answer = await started.answer if (answer.kind === 'bytes') { @@ -373,7 +374,6 @@ async function startWhenIdle( $: EngineInterface, args: { model?: string; sql?: string }, waitUntil: number, - budgetUntil: number, reuse: () => T | undefined, begin: (started: { answer: Promise; settled: Promise }) => T, ): Promise { @@ -381,7 +381,7 @@ async function startWhenIdle( const left = waitUntil - (await $.clock.now()) if (left <= 0 || !(await within($, left, Promise.all([...active]).then(() => true)))) return null } - return reuse() ?? begin(startEstimate($, args, budgetUntil)) + return reuse() ?? begin(startEstimate($, args, waitUntil + ESTIMATE_BUDGET_MS)) } /** Drops the answers already in; an estimate still running, which a parallel call may be waiting on, is left to finish. */ @@ -597,7 +597,6 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: $, args, waitUntil, - now + ESTIMATE_BUDGET_MS, () => { const other = inflight.get(key) return other && other.doneAt == null && !other.voided ? other : undefined From 9029264ac98fa65a4a72a84c2ca14fea3f82d683 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 10:44:37 +0530 Subject: [PATCH 48/56] fix(cost): a /cd keeps the estimates still running in the project left, so coming back does not start a second one Co-Authored-By: Claude Sonnet 5.5 --- .../hooks/features/cost.test.tsx | 23 +++++++++++++++++++ plugins/altimate-code/hooks/features/cost.tsx | 17 +++++++------- .../hooks/features/index.test.ts | 10 ++++---- 3 files changed, 38 insertions(+), 12 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 675f7952..e7d14222 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -1166,3 +1166,26 @@ test('a pending estimate on another command does not carry /allow-scan over to i expect(retry.deny).toContain('20.0 GiB') expect(ran).toEqual([]) }) + +test('a /cd away and back does not forget the estimate still running in the project', async ($, on) => { + const options: Options = { answers: { orders: UNDER, b: UNDER, c: UNDER } } + const { clock, started } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + options.holdFor = 'orders' + const first = $.command.run({ command: 'scan-cost', args: 'orders' } as any) + await clock.advance(500) + // Another project is not held back by it. + options.cwd = '/elsewhere/project-b' + const other = $.command.run({ command: 'scan-cost', args: 'b' } as any) + await clock.advance(500) + expect(((await other) as any).text).toContain('b would scan 2.0 GiB') + // Back in the first project, a second estimate waits its turn and gives up after the short wait. + options.cwd = undefined + const again = $.command.run({ command: 'scan-cost', args: 'c' } as any) + await clock.advance(4_001) + expect(((await again) as any).text).toContain('another estimate is still running in this project') + expect(started).toEqual(['orders', 'b']) + release() + await first +}) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 6558d8b9..3cae8558 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -46,7 +46,7 @@ const notes = new Map() /** Estimates still running past the gate's wait, by what they ask about; the next gate pass for the same target takes the answer. */ const inflight = new Map; settled: Promise; doneAt: number | null; generation: number; voided?: boolean }>() /** Every estimate whose process is still running (gate or /scan-cost), whether or not an edit has voided its answer: one runs per project at a time. */ -const active = new Set>() +const active = new Map, string | null>() /** Commands the gate refused while their estimate was running, and when it last did: they have not run, so a retry changes nothing. */ const refused = new Map() /** Moves on whenever the project may have changed: an estimate started before it is never taken as an answer. */ @@ -190,9 +190,8 @@ async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | // A session moved to another project (a /cd) keeps nothing the gate learned in the last one. const dir = await $.session.cwd().catch(() => seenDir) if (seenDir !== null && dir !== seenDir) { - // What is still running belongs to the project left behind: it holds nothing back here. + // What is still running belongs to the project left behind: it holds nothing back here, and still holds that project back on return. invalidate() - active.clear() await forgetUnsupported($) await update($, costAtom, prev => (prev ? { ...prev, held: null, allowOnce: false, lastEstimate: null } : prev)) await showStatus($, null) @@ -357,10 +356,10 @@ export async function editAfter($: EngineInterface, e: FileCall, result: ToolCal } /** Runs the estimate and counts it as running until it settles. */ -function startEstimate($: EngineInterface, args: { model?: string; sql?: string }, until: number) { +function startEstimate($: EngineInterface, args: { model?: string; sql?: string }, until: number, dir: string | null) { const answer = estimate($, args, until) const settled = answer.then(() => undefined, () => undefined) - active.add(settled) + active.set(settled, dir) void settled.then(() => active.delete(settled)) return { answer, settled } } @@ -377,11 +376,13 @@ async function startWhenIdle( reuse: () => T | undefined, begin: (started: { answer: Promise; settled: Promise }) => T, ): Promise { - while (active.size > 0) { + const dir = (await $.session.cwd().catch(() => seenDir)) ?? null + const running = () => [...active].filter(([, d]) => d === dir).map(([p]) => p) + while (running().length > 0) { const left = waitUntil - (await $.clock.now()) - if (left <= 0 || !(await within($, left, Promise.all([...active]).then(() => true)))) return null + if (left <= 0 || !(await within($, left, Promise.all(running()).then(() => true)))) return null } - return reuse() ?? begin(startEstimate($, args, waitUntil + ESTIMATE_BUDGET_MS)) + return reuse() ?? begin(startEstimate($, args, waitUntil + ESTIMATE_BUDGET_MS, dir)) } /** Drops the answers already in; an estimate still running, which a parallel call may be waiting on, is left to finish. */ diff --git a/plugins/altimate-code/hooks/features/index.test.ts b/plugins/altimate-code/hooks/features/index.test.ts index 00a494a3..b0e8ca26 100644 --- a/plugins/altimate-code/hooks/features/index.test.ts +++ b/plugins/altimate-code/hooks/features/index.test.ts @@ -18,9 +18,11 @@ const engine = () => { const logs: string[] = [] // Enough of the engine for a feature that keeps state, reads files and registers commands; a stub needs none of it. const $ = { - ui: { log: (text: string) => void logs.push(text) }, + ui: { log: (text: string) => void logs.push(text), status: () => {} }, + session: { cwd: async () => '/repo' }, + clock: { now: async () => 0 }, fs: { exists: async () => false, read: async () => '' }, - state: { get: async () => ({ value: null }), set: async () => ({ isSet: true }), update: async () => ({ isSet: true }) }, + state: { get: async () => ({ value: {} }), set: async () => ({ isSet: true }), update: async () => ({ isSet: true }) }, command: { register: async () => {} }, } return { logs, $: $ as any } @@ -42,14 +44,14 @@ test('attempt logs a feature function that throws at once, one that rejects, and test('with every feature a stub, each phase runs through the features and logs nothing', async () => { const { $, logs } = engine() - const bash = { tool: 'Bash', command: 'dbt run -s a' } as any + const bash = { tool: 'Bash', command: 'dbt compile -s a' } as any const file = { tool: 'Edit', file_path: '/repo/models/a.sql' } as any await featuresSessionStart($, {} as any) await featuresTurnStart($, {} as any) await featuresTurnComplete($, {} as any, {} as any) await featuresSessionEnd($, {} as any) expect(await featureBandLines($, {} as any)).toEqual([]) - expect(await featuresBashRewrite($, bash)).toBe('dbt run -s a') + expect(await featuresBashRewrite($, bash)).toBe('dbt compile -s a') expect(await featuresBashGate($, bash)).toBeNull() expect(await featuresBashAfter($, bash, {} as any)).toEqual([]) expect(await featuresEditAfter($, file, {} as any, { path: '/repo/models/a.sql', before: null })).toEqual([]) From 9cfa4e366f20e07be396ceb6f424b772d545d0c7 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 10:52:14 +0530 Subject: [PATCH 49/56] fix(cost): a queued estimate takes the project now in use after its wait, so it never starts beside that project's running one Co-Authored-By: Claude Sonnet 5.5 --- .../hooks/features/cost.test.tsx | 28 +++++++++++++++++++ plugins/altimate-code/hooks/features/cost.tsx | 13 ++++++--- 2 files changed, 37 insertions(+), 4 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index e7d14222..1dfe5fd2 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -14,6 +14,8 @@ type Options = { hold?: Promise /** With `hold`: only the estimate of this model or SQL waits. */ holdFor?: string + /** Per model: that model's estimate answers only once its promise resolves. */ + holds?: Record> /** The session's directory; changed mid-test to stand for a /cd. */ cwd?: string /** Drawing the status line throws. */ @@ -58,6 +60,7 @@ async function start($: any, on: any, options: Options = {}) { const args = JSON.parse(String(e.argv[e.argv.indexOf('--args') + 1] ?? '{}')) const key = String(args.model ?? args.sql) started.push(key) + if (options.holds?.[key]) await options.holds[key] if (options.hold && (options.holdFor === undefined || options.holdFor === key)) await options.hold estimates.push(key) const answer = options.answers?.[key] ?? options.fallback @@ -1189,3 +1192,28 @@ test('a /cd away and back does not forget the estimate still running in the proj release() await first }) + +test('a queued /scan-cost that wakes after a /cd runs under the project now in use, behind its running estimate', async ($, on) => { + const options: Options = { answers: { orders: UNDER, b: UNDER, c: UNDER } } + const { clock, started } = await start($, on, options) + let releaseFirst!: () => void + let release!: () => void + options.holds = { orders: new Promise(resolve => (releaseFirst = resolve)), b: new Promise(resolve => (release = resolve)) } + const first = $.command.run({ command: 'scan-cost', args: 'orders' } as any) + await clock.advance(100) + const queued = $.command.run({ command: 'scan-cost', args: 'c' } as any) + await clock.advance(100) + options.cwd = '/elsewhere/project-b' + const inB = $.command.run({ command: 'scan-cost', args: 'b' } as any) + await clock.advance(100) + expect(started).toEqual(['orders', 'b']) + // The first project's estimate ends: the queued one must not start beside project b's running estimate. + releaseFirst() + await first + await clock.advance(1_000) + expect(started).toEqual(['orders', 'b']) + release() + await inB + await queued + await first +}) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 3cae8558..58490140 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -376,11 +376,16 @@ async function startWhenIdle( reuse: () => T | undefined, begin: (started: { answer: Promise; settled: Promise }) => T, ): Promise { - const dir = (await $.session.cwd().catch(() => seenDir)) ?? null - const running = () => [...active].filter(([, d]) => d === dir).map(([p]) => p) - while (running().length > 0) { + // The project is read again after each wait: a /cd meanwhile moves the check to the project now in use. + let dir: string | null = null + let running: Promise[] = [] + for (;;) { + dir = (await $.session.cwd().catch(() => seenDir)) ?? null + const here = dir + running = [...active].filter(([, d]) => d === here).map(([p]) => p) + if (running.length === 0) break const left = waitUntil - (await $.clock.now()) - if (left <= 0 || !(await within($, left, Promise.all(running()).then(() => true)))) return null + if (left <= 0 || !(await within($, left, Promise.all(running).then(() => true)))) return null } return reuse() ?? begin(startEstimate($, args, waitUntil + ESTIMATE_BUDGET_MS, dir)) } From b1d39f96c58f7bc36847b93d32946c4c2c7c3a1f Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 11:38:59 +0530 Subject: [PATCH 50/56] fix(cost): an estimate made in another project is never taken, and a /cd while the gate waits refuses the command Co-Authored-By: Claude Sonnet 5.5 --- .../altimate-code/hooks/features/cost.test.tsx | 15 +++++++++++++++ plugins/altimate-code/hooks/features/cost.tsx | 16 ++++++++++------ 2 files changed, 25 insertions(+), 6 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 1dfe5fd2..e48ba052 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -1217,3 +1217,18 @@ test('a queued /scan-cost that wakes after a /cd runs under the project now in u await queued await first }) + +test('a /cd while the gate waits for an estimate: its answer is of the project left, so the command is refused', async ($, on) => { + const options: Options = { answers: { orders: UNDER } } + const { clock, started } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + options.holdFor = 'orders' + const call = $.tool.call(bash('dbt run -s orders')) + await clock.advance(500) + expect(started).toEqual(['orders']) + options.cwd = '/elsewhere/project-b' + release() + const result: any = await call + expect(result.deny).toContain('The project changed while the scan was being estimated') +}) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 58490140..a54ad57d 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -44,7 +44,7 @@ let limitBytes = DEFAULT_MAX_SCAN_BYTES /** The lines to show under an estimated command's Bash row, by command; each gate pass replaces the last. Taken by bashAfter. */ const notes = new Map() /** Estimates still running past the gate's wait, by what they ask about; the next gate pass for the same target takes the answer. */ -const inflight = new Map; settled: Promise; doneAt: number | null; generation: number; voided?: boolean }>() +const inflight = new Map; settled: Promise; doneAt: number | null; generation: number; dir: string | null; voided?: boolean }>() /** Every estimate whose process is still running (gate or /scan-cost), whether or not an edit has voided its answer: one runs per project at a time. */ const active = new Map, string | null>() /** Commands the gate refused while their estimate was running, and when it last did: they have not run, so a retry changes nothing. */ @@ -228,6 +228,8 @@ async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | } const label = target.model ?? 'the inline query' const answer = await estimateWithin($, target.model ? { model: target.model } : { sql: target.sql }, waitUntil, taken, refused.get(e.command)) + // A /cd while it was being asked: the answer is of the project left, and nothing here is allowed on it. + if (((await $.session.cwd().catch(() => dir)) ?? null) !== (dir ?? null)) invalidate() // The project changed while this was being asked: nothing it says is published, and the command is refused below. if (generation !== startedAt) break if (answer === 'pending') { @@ -361,7 +363,7 @@ function startEstimate($: EngineInterface, args: { model?: string; sql?: string const settled = answer.then(() => undefined, () => undefined) active.set(settled, dir) void settled.then(() => active.delete(settled)) - return { answer, settled } + return { answer, settled, dir } } /** @@ -374,7 +376,7 @@ async function startWhenIdle( args: { model?: string; sql?: string }, waitUntil: number, reuse: () => T | undefined, - begin: (started: { answer: Promise; settled: Promise }) => T, + begin: (started: { answer: Promise; settled: Promise; dir: string | null }) => T, ): Promise { // The project is read again after each wait: a /cd meanwhile moves the check to the project now in use. let dir: string | null = null @@ -589,8 +591,10 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: if (had) return had // The look-up and the insert below are one step: nothing is awaited between them, or two passes would each start one. const now = await $.clock.now() + const here = (await $.session.cwd().catch(() => seenDir)) ?? null let running = inflight.get(key) - if (running?.voided) running = undefined + // An answer made in another project is of that project's models, not this one's. + if (running?.voided || (running && running.dir !== here)) running = undefined // A command whose retries keep coming keeps what it waited for however long the others took: a later answer expiring an earlier one would never let it finish. const retrying = refusedAt != null && now - refusedAt <= ANSWER_KEEP_MS if (running?.doneAt != null && !retrying && now - running.doneAt > ANSWER_KEEP_MS) running = undefined @@ -608,7 +612,7 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: return other && other.doneAt == null && !other.voided ? other : undefined }, started => { - const made = { answer: started.answer, settled: started.settled, doneAt: null as number | null, generation, voided: false } + const made = { answer: started.answer, settled: started.settled, doneAt: null as number | null, generation, dir: started.dir, voided: false } void made.answer.then(async () => void (made.doneAt = await $.clock.now())).catch(() => {}) inflight.set(key, made) return made @@ -621,7 +625,7 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: const done = left > 0 ? await within($, left, running.answer.then(answer => ({ answer }))) : null if (!done) return 'pending' // The project may have changed while it ran: that answer is of the old one, and the next pass asks again. - if (running.generation !== generation) { + if (running.generation !== generation || running.dir !== ((await $.session.cwd().catch(() => seenDir)) ?? null)) { if (inflight.get(key) === running) inflight.delete(key) return 'pending' } From 5e4731edaa2ce663c739a01ae1b20bb069766add Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 13:56:19 +0530 Subject: [PATCH 51/56] fix(cost): a /cd during a gate pass forgets the old project's hold like the other /cd path; tests pin the queue and the unfinished-call leak Co-Authored-By: Claude Sonnet 5.5 --- .../hooks/features/cost.test.tsx | 36 ++++++++++++++++--- plugins/altimate-code/hooks/features/cost.tsx | 23 +++++++----- 2 files changed, 47 insertions(+), 12 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index e48ba052..170268da 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -765,14 +765,17 @@ test('a dbt run that is let through drops the estimates kept from before it', as await clock.settle() options.hold = undefined // Another command's run is let through, and is still running (not yet after-phase) when orders is retried. - options.holdBash = { command: 'dbt run -s customers', until: new Promise(() => {}) } - void $.tool.call(bash('dbt run -s customers')) + let finish!: () => void + options.holdBash = { command: 'dbt run -s customers', until: new Promise(resolve => (finish = resolve)) } + const customers = $.tool.call(bash('dbt run -s customers')) await clock.settle() options.answers = { orders: OVER } const retry: any = await $.tool.call(bash('dbt run -s orders')) await clock.settle() expect(retry.deny).toContain('20.0 GiB') expect(estimates.filter(e => e === 'orders').length).toBe(2) + finish() + await customers }) test('a second model waits for the estimate running in the project, and starts none while it runs', async ($, on) => { @@ -1172,7 +1175,7 @@ test('a pending estimate on another command does not carry /allow-scan over to i test('a /cd away and back does not forget the estimate still running in the project', async ($, on) => { const options: Options = { answers: { orders: UNDER, b: UNDER, c: UNDER } } - const { clock, started } = await start($, on, options) + const { clock, started, ran } = await start($, on, options) let release!: () => void options.hold = new Promise(resolve => (release = resolve)) options.holdFor = 'orders' @@ -1189,6 +1192,14 @@ test('a /cd away and back does not forget the estimate still running in the proj await clock.advance(4_001) expect(((await again) as any).text).toContain('another estimate is still running in this project') expect(started).toEqual(['orders', 'b']) + // A Bash pass in the other project must not forget the first project's running estimate either. + await $.tool.call(bash('ls')) + expect(ran).toEqual(['ls']) + options.cwd = undefined + const third = $.command.run({ command: 'scan-cost', args: 'd' } as any) + await clock.advance(4_001) + expect(((await third) as any).text).toContain('another estimate is still running in this project') + expect(started).toEqual(['orders', 'b']) release() await first }) @@ -1214,10 +1225,27 @@ test('a queued /scan-cost that wakes after a /cd runs under the project now in u expect(started).toEqual(['orders', 'b']) release() await inB - await queued + expect(((await queued) as any).text).toContain('c would scan 2.0 GiB') + expect(started).toEqual(['orders', 'b', 'c']) await first }) +test('a /cd while the gate waits for an estimate also drops the hold of the project left', async ($, on) => { + const options: Options = { answers: { a: OVER, b: UNDER } } + const { clock } = await start($, on, options) + expect(((await $.tool.call(bash('dbt run -s a'))) as any).deny).toContain('20.0 GiB') + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + options.holdFor = 'b' + const call = $.tool.call(bash('dbt run -s b')) + await clock.advance(500) + options.cwd = '/elsewhere/project-b' + release() + expect(((await call) as any).deny).toContain('The project changed while the scan was being estimated') + await clock.settle() + expect(((await $.command.run({ command: 'allow-scan', args: '' } as any)) as any).text).toContain('Nothing is held') +}) + test('a /cd while the gate waits for an estimate: its answer is of the project left, so the command is refused', async ($, on) => { const options: Options = { answers: { orders: UNDER } } const { clock, started } = await start($, on, options) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index a54ad57d..3947e7f3 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -182,6 +182,14 @@ export async function bashGate($: EngineInterface, e: BashCall): Promise<{ deny: return verdict } +/** Everything the gate learned in the project just left: its answers, hold, allowance, estimate and band line. */ +async function leaveProject($: EngineInterface) { + invalidate() + await forgetUnsupported($) + await update($, costAtom, prev => (prev ? { ...prev, held: null, allowOnce: false, lastEstimate: null } : prev)) + await showStatus($, null) +} + async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | null> { if (limitBytes <= 0) return null // Before it runs, not only after: another call can ask while a long command is rewriting the project. @@ -191,10 +199,7 @@ async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | const dir = await $.session.cwd().catch(() => seenDir) if (seenDir !== null && dir !== seenDir) { // What is still running belongs to the project left behind: it holds nothing back here, and still holds that project back on return. - invalidate() - await forgetUnsupported($) - await update($, costAtom, prev => (prev ? { ...prev, held: null, allowOnce: false, lastEstimate: null } : prev)) - await showStatus($, null) + await leaveProject($) } seenDir = dir ?? null const all = parseDbtCommand(e.command) @@ -229,7 +234,11 @@ async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | const label = target.model ?? 'the inline query' const answer = await estimateWithin($, target.model ? { model: target.model } : { sql: target.sql }, waitUntil, taken, refused.get(e.command)) // A /cd while it was being asked: the answer is of the project left, and nothing here is allowed on it. - if (((await $.session.cwd().catch(() => dir)) ?? null) !== (dir ?? null)) invalidate() + const now = (await $.session.cwd().catch(() => dir)) ?? null + if (now !== (dir ?? null)) { + await leaveProject($) + seenDir = now + } // The project changed while this was being asked: nothing it says is published, and the command is refused below. if (generation !== startedAt) break if (answer === 'pending') { @@ -380,11 +389,9 @@ async function startWhenIdle( ): Promise { // The project is read again after each wait: a /cd meanwhile moves the check to the project now in use. let dir: string | null = null - let running: Promise[] = [] for (;;) { dir = (await $.session.cwd().catch(() => seenDir)) ?? null - const here = dir - running = [...active].filter(([, d]) => d === here).map(([p]) => p) + const running = [...active].filter(([, d]) => d === dir).map(([p]) => p) if (running.length === 0) break const left = waitUntil - (await $.clock.now()) if (left <= 0 || !(await within($, left, Promise.all(running).then(() => true)))) return null From 805787c1137135b838fed9c0df4ff2ee8a0a7d85 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 14:03:38 +0530 Subject: [PATCH 52/56] fix(cost): a dbt run let through while the gate waits voids the answer it waits on Co-Authored-By: Claude Sonnet 5.5 --- .../hooks/features/cost.test.tsx | 19 +++++++++++++++++++ plugins/altimate-code/hooks/features/cost.tsx | 4 ++-- 2 files changed, 21 insertions(+), 2 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 170268da..ee282f84 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -1260,3 +1260,22 @@ test('a /cd while the gate waits for an estimate: its answer is of the project l const result: any = await call expect(result.deny).toContain('The project changed while the scan was being estimated') }) + +test('a dbt run let through while the gate waits on its estimate voids that answer: the waiting command is not allowed on it', async ($, on) => { + const options: Options = { answers: { orders: UNDER } } + const { clock, ran } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + let finish!: () => void + options.holdBash = { command: 'dbt run -s customers --target prod', until: new Promise(resolve => (finish = resolve)) } + const first = $.tool.call(bash('dbt run -s orders')) + await clock.advance(1_000) + const rebuild = $.tool.call(bash('dbt run -s customers --target prod')) + await clock.advance(10) + release() + await clock.advance(10) + expect(((await first) as any).deny).toContain('still being estimated') + finish() + await rebuild + expect(ran).toEqual(['dbt run -s customers --target prod']) +}) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 3947e7f3..973b19d7 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -631,8 +631,8 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: const left = waitUntil - (await $.clock.now()) const done = left > 0 ? await within($, left, running.answer.then(answer => ({ answer }))) : null if (!done) return 'pending' - // The project may have changed while it ran: that answer is of the old one, and the next pass asks again. - if (running.generation !== generation || running.dir !== ((await $.session.cwd().catch(() => seenDir)) ?? null)) { + // The project may have changed while it ran (an edit, a /cd, or a dbt run let through meanwhile): that answer is of the old one, and the next pass asks again. + if (running.voided || running.generation !== generation || running.dir !== ((await $.session.cwd().catch(() => seenDir)) ?? null)) { if (inflight.get(key) === running) inflight.delete(key) return 'pending' } From 893781c2eeb30c9f1e4d0e31dd40db4fff66803c Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 14:09:20 +0530 Subject: [PATCH 53/56] fix(cost): a dbt run let through refuses the gate passes already holding an answer, so none acts on a pre-run estimate Co-Authored-By: Claude Sonnet 5.5 --- plugins/altimate-code/hooks/features/cost.test.tsx | 4 ++-- plugins/altimate-code/hooks/features/cost.tsx | 2 ++ 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index ee282f84..6eda9771 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -856,7 +856,7 @@ test('a voided running estimate is not reused and holds the next one back until await clock.advance(500) expect(started).toEqual(['orders']) await clock.advance(4_001) - expect(((await first) as any).deny).toContain('still being estimated') + expect(((await first) as any).deny).toContain('The project changed while the scan was being estimated') expect(((await again) as any).deny).toContain('still being estimated') expect(started).toEqual(['orders']) finish() @@ -1274,7 +1274,7 @@ test('a dbt run let through while the gate waits on its estimate voids that answ await clock.advance(10) release() await clock.advance(10) - expect(((await first) as any).deny).toContain('still being estimated') + expect(((await first) as any).deny).toContain('The project changed while the scan was being estimated') finish() await rebuild expect(ran).toEqual(['dbt run -s customers --target prod']) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 973b19d7..4a437794 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -401,6 +401,8 @@ async function startWhenIdle( /** Drops the answers already in; an estimate still running, which a parallel call may be waiting on, is left to finish. */ function dropFinished() { + // A pass that already took an answer (or is about to) must not act on it once a run has begun: it is refused and asks again. + generation++ for (const [key, entry] of inflight) { if (entry.doneAt != null) inflight.delete(key) // A pass already waiting on it takes its answer; a later pass does not, since a run began after it started. From 033826ba91a9f2e7b5cf4f04c55599f6044b9808 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 14:21:45 +0530 Subject: [PATCH 54/56] fix(cost): fail closed when a hold cannot be recorded, recheck the project after the awaits, and one rule for a voided answer Co-Authored-By: Claude Sonnet 5.5 --- .../hooks/features/cost.test.tsx | 9 +- plugins/altimate-code/hooks/features/cost.tsx | 54 +- .../node_modules/.vite/vitest/CACHEDIR.TAG | 3 + .../results.json | 1 + .../01827a3d74da33920570f783b18edea8eb8d7b82 | 472 ++++++++++++++++++ .../node_modules/.vitest-cache/CACHEDIR.TAG | 3 + .../node_modules/.vitest-cache/_metadata.json | 3 + 7 files changed, 521 insertions(+), 24 deletions(-) create mode 100644 plugins/altimate-code/node_modules/.vite/vitest/CACHEDIR.TAG create mode 100644 plugins/altimate-code/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json create mode 100644 plugins/altimate-code/node_modules/.vitest-cache/01827a3d74da33920570f783b18edea8eb8d7b82 create mode 100644 plugins/altimate-code/node_modules/.vitest-cache/CACHEDIR.TAG create mode 100644 plugins/altimate-code/node_modules/.vitest-cache/_metadata.json diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 6eda9771..d0b9e161 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -1175,7 +1175,7 @@ test('a pending estimate on another command does not carry /allow-scan over to i test('a /cd away and back does not forget the estimate still running in the project', async ($, on) => { const options: Options = { answers: { orders: UNDER, b: UNDER, c: UNDER } } - const { clock, started, ran } = await start($, on, options) + const { clock, started } = await start($, on, options) let release!: () => void options.hold = new Promise(resolve => (release = resolve)) options.holdFor = 'orders' @@ -1192,10 +1192,13 @@ test('a /cd away and back does not forget the estimate still running in the proj await clock.advance(4_001) expect(((await again) as any).text).toContain('another estimate is still running in this project') expect(started).toEqual(['orders', 'b']) - // A Bash pass in the other project must not forget the first project's running estimate either. + // The gate learns each project it passes through: a Bash pass in A, one in B (the /cd), then back in A. + options.cwd = undefined + await $.tool.call(bash('ls')) + options.cwd = '/elsewhere/project-b' await $.tool.call(bash('ls')) - expect(ran).toEqual(['ls']) options.cwd = undefined + await $.tool.call(bash('ls')) const third = $.command.run({ command: 'scan-cost', args: 'd' } as any) await clock.advance(4_001) expect(((await third) as any).text).toContain('another estimate is still running in this project') diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 4a437794..360eac86 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -44,7 +44,7 @@ let limitBytes = DEFAULT_MAX_SCAN_BYTES /** The lines to show under an estimated command's Bash row, by command; each gate pass replaces the last. Taken by bashAfter. */ const notes = new Map() /** Estimates still running past the gate's wait, by what they ask about; the next gate pass for the same target takes the answer. */ -const inflight = new Map; settled: Promise; doneAt: number | null; generation: number; dir: string | null; voided?: boolean }>() +const inflight = new Map; settled: Promise; doneAt: number | null; generation: number; dir: string | null }>() /** Every estimate whose process is still running (gate or /scan-cost), whether or not an edit has voided its answer: one runs per project at a time. */ const active = new Map, string | null>() /** Commands the gate refused while their estimate was running, and when it last did: they have not run, so a retry changes nothing. */ @@ -269,8 +269,7 @@ async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | if (generation !== startedAt) { // Nothing is cleared here: the change already cleared what was older, and a newer pass's estimates are its own. - notes.delete(e.command) - return { deny: 'The project changed while the scan was being estimated. Run the same command again.' } + return changedDeny(e.command) } // A finished command's answers are taken: a later one asks again. A pending one keeps them for its retry. @@ -302,18 +301,25 @@ async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | const worst = over.reduce((a, b) => (b.bytes > a.bytes ? b : a)) // The allowance is spent in one step, and only by the command that was held for it. let granted = false - await update($, costAtom, prev => { - const current = prev ?? FRESH - granted = current.allowOnce && current.held?.command === e.command - return granted - ? { ...current, allowOnce: false, held: null } - : { ...current, allowOnce: false, held: { command: e.command, target: worst.label, bytes: worst.bytes, display: worst.display } } - }) + try { + await update($, costAtom, prev => { + const current = prev ?? FRESH + granted = current.allowOnce && current.held?.command === e.command + return granted + ? { ...current, allowOnce: false, held: null } + : { ...current, allowOnce: false, held: { command: e.command, target: worst.label, bytes: worst.bytes, display: worst.display } } + }) + } catch { + // A hold that cannot be recorded must not become a pass: a gate that throws lets the call run. + notes.delete(e.command) + return { deny: `${worst.display} would be scanned, over the ${formatBytes(limitBytes)} limit, and the hold could not be recorded. Run the same command again.` } + } if (granted) { for (const one of over) lines.push(`cost · ${one.label} would scan ${one.display}, over the ${formatBytes(limitBytes)} limit: allowed once`) keepNotes(e.command, lines) // The hold is spent: the status line stops showing it. await showLastEstimate($) + if (generation !== startedAt) return changedDeny(e.command) return null } notes.delete(e.command) @@ -336,10 +342,17 @@ async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | await update($, costAtom, prev => (prev?.held || prev?.allowOnce ? { ...prev, held: null, allowOnce: false } : prev)) await showLastEstimate($) } + // An edit during the awaits above makes the estimate void: nothing is allowed on it. + if (generation !== startedAt) return changedDeny(e.command) keepNotes(e.command, lines) return null } +function changedDeny(command: string) { + notes.delete(command) + return { deny: 'The project changed while the scan was being estimated. Run the same command again.' } +} + /** Notes kept per command: a line of many dbt calls would otherwise put one note each into Claude's context. */ const MAX_NOTES = 5 @@ -399,15 +412,14 @@ async function startWhenIdle( return reuse() ?? begin(startEstimate($, args, waitUntil + ESTIMATE_BUDGET_MS, dir)) } -/** Drops the answers already in; an estimate still running, which a parallel call may be waiting on, is left to finish. */ +/** + * A run or build about to start voids every answer: the finished ones are dropped, and the generation moves, so a pass that + * already took an answer (or waits on a running estimate) is refused rather than served, and asks again. An estimate still + * running is left to finish: its process counts toward the one-per-project queue. + */ function dropFinished() { - // A pass that already took an answer (or is about to) must not act on it once a run has begun: it is refused and asks again. generation++ - for (const [key, entry] of inflight) { - if (entry.doneAt != null) inflight.delete(key) - // A pass already waiting on it takes its answer; a later pass does not, since a run began after it started. - else entry.voided = true - } + for (const [key, entry] of inflight) if (entry.doneAt != null) inflight.delete(key) } function invalidate() { @@ -603,7 +615,7 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: const here = (await $.session.cwd().catch(() => seenDir)) ?? null let running = inflight.get(key) // An answer made in another project is of that project's models, not this one's. - if (running?.voided || (running && running.dir !== here)) running = undefined + if (running && (running.generation !== generation || running.dir !== here)) running = undefined // A command whose retries keep coming keeps what it waited for however long the others took: a later answer expiring an earlier one would never let it finish. const retrying = refusedAt != null && now - refusedAt <= ANSWER_KEEP_MS if (running?.doneAt != null && !retrying && now - running.doneAt > ANSWER_KEEP_MS) running = undefined @@ -618,10 +630,10 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: waitUntil, () => { const other = inflight.get(key) - return other && other.doneAt == null && !other.voided ? other : undefined + return other && other.doneAt == null && other.generation === generation ? other : undefined }, started => { - const made = { answer: started.answer, settled: started.settled, doneAt: null as number | null, generation, dir: started.dir, voided: false } + const made = { answer: started.answer, settled: started.settled, doneAt: null as number | null, generation, dir: started.dir } void made.answer.then(async () => void (made.doneAt = await $.clock.now())).catch(() => {}) inflight.set(key, made) return made @@ -634,7 +646,7 @@ async function estimateWithin($: EngineInterface, args: { model?: string; sql?: const done = left > 0 ? await within($, left, running.answer.then(answer => ({ answer }))) : null if (!done) return 'pending' // The project may have changed while it ran (an edit, a /cd, or a dbt run let through meanwhile): that answer is of the old one, and the next pass asks again. - if (running.voided || running.generation !== generation || running.dir !== ((await $.session.cwd().catch(() => seenDir)) ?? null)) { + if (running.generation !== generation || running.dir !== ((await $.session.cwd().catch(() => seenDir)) ?? null)) { if (inflight.get(key) === running) inflight.delete(key) return 'pending' } diff --git a/plugins/altimate-code/node_modules/.vite/vitest/CACHEDIR.TAG b/plugins/altimate-code/node_modules/.vite/vitest/CACHEDIR.TAG new file mode 100644 index 00000000..8c1ef4ce --- /dev/null +++ b/plugins/altimate-code/node_modules/.vite/vitest/CACHEDIR.TAG @@ -0,0 +1,3 @@ +Signature: 8a477f597d28d172789f06886806bc55 +# This file is a cache directory tag created by Vitest. +# For information about cache directory tags see https://bford.info/cachedir/ diff --git a/plugins/altimate-code/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json b/plugins/altimate-code/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json new file mode 100644 index 00000000..93c7e71e --- /dev/null +++ b/plugins/altimate-code/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json @@ -0,0 +1 @@ +{"version":1,"projects":{"":{"files":{"hooks/features/cost.test.tsx":{"failed":true,"duration":0,"lastRun":1794805775627}}}}} \ No newline at end of file diff --git a/plugins/altimate-code/node_modules/.vitest-cache/01827a3d74da33920570f783b18edea8eb8d7b82 b/plugins/altimate-code/node_modules/.vitest-cache/01827a3d74da33920570f783b18edea8eb8d7b82 new file mode 100644 index 00000000..cdb1f273 --- /dev/null +++ b/plugins/altimate-code/node_modules/.vitest-cache/01827a3d74da33920570f783b18edea8eb8d7b82 @@ -0,0 +1,472 @@ +const __vite_ssr_import_0__ = await __vite_ssr_import__("claude-code/testing", {"importedNames":["expect","mock","test"]}); +const __vite_ssr_import_1__ = await __vite_ssr_import__("/hooks/features/cost.tsx", {"importedNames":["formatBytes","inlineSql"]}); +const __vite_ssr_import_2__ = await __vite_ssr_import__("react/jsx-dev-runtime", {"importedNames":["jsxDEV"]}); + + +var _jsxFileName = "/Users/harish/.quikim/workspaces/altimate-claude-plugin/feat/dbt-cost-estimate-tool/plugins/altimate-code/hooks/features/cost.test.tsx"; + +const ROOT = "/repo"; +const GIB = 1024 ** 3; +/** The session beneath the plugin, a CLI whose dbt_cost_estimate is scripted, and a Bash tool that records what ran. */ +async function start($, on, options = {}) { + const clock = __vite_ssr_import_0__.mock.clock(on); + const estimates = []; + const ran = []; + const statuses = []; + on("command.register", (_, e) => ({ value: { command: e.name } })); + on("turn.start", (_, e) => ({ turnId: e.turnId })); + on("session.end", () => ({ sessionId: "test" })); + on("turn.complete", (_, e) => ({ text: e.answer })); + on("session.start", (_, e) => ({ cwd: e.cwd })); + on("session.root", () => ({ value: ROOT })); + on("ui.log", () => ({ value: undefined })); + on("ui.status", (_, e) => { + statuses.push(e.text); + return { value: undefined }; + }); + on("ui.render", ($$, e) => { + const { Box } = $$.ui.resolve(e); + return /* @__PURE__ */ (0,__vite_ssr_import_2__.jsxDEV)(Box, {}, "engine", false, { + fileName: _jsxFileName, + lineNumber: 34, + columnNumber: 12 + }, this); + }); + on("fs.exists", () => ({ value: false })); + on("process.run", (_, e) => { + const [, command, , tool] = e.argv; + if (command !== "tool") return { value: { + exitCode: 1, + stdout: "", + stderr: "not this test" + } }; + (0,__vite_ssr_import_0__.expect)(tool).toBe("dbt_cost_estimate"); + // The adapter starts the project's dbt: the call must carry write permission. + (0,__vite_ssr_import_0__.expect)(e.argv).toContain("--allow-write"); + const args = JSON.parse(String(e.argv[e.argv.indexOf("--args") + 1] ?? "{}")); + const key = String(args.model ?? args.sql); + estimates.push(key); + const answer = options.answers?.[key] ?? options.fallback; + if (answer === "unknown-tool") { + return { value: { + exitCode: 1, + stdout: JSON.stringify({ + status: "error", + output: `Unknown tool: ${tool}. Run \`altimate-code tool list\` to see the available tools.`, + metadata: {} + }), + stderr: "" + } }; + }; + return { value: { + exitCode: 0, + stdout: JSON.stringify({ + status: "ok", + output: "", + metadata: answer ?? { + success: false, + error: "no answer scripted" + } + }), + stderr: "" + } }; + }); + // The Bash tool itself, beneath the plugin. + on("tool.call", (_, e) => { + if (e.tool === "Bash") ran.push(String(e.command)); + return { result: { + text: "ok", + isError: false + } }; + }); + await $.session.start({ + cwd: ROOT, + surface: "terminal", + isInteractive: true + }); + await clock.settle(); + return { + clock, + estimates, + ran, + statuses + }; +} +const bq = (bytes, display, maxBytes = bytes) => ({ + success: true, + supported: true, + adapter: "bigquery", + bytes, + maxBytes, + display +}); +const OVER = bq(20 * GIB, "20.0 GiB"); +const UNDER = bq(2 * GIB, "2.0 GiB"); +const bash = (command) => ({ + tool: "Bash", + command +}); +(0,__vite_ssr_import_0__.test)("a model over the limit is refused with its estimate, and the command never runs", async ($, on) => { + const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } }); + const result = await $.tool.call(bash("dbt run --select orders")); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["orders"]); + (0,__vite_ssr_import_0__.expect)(ran).toEqual([]); + (0,__vite_ssr_import_0__.expect)(result.deny).toBe("≈ 20.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again."); +}); +(0,__vite_ssr_import_0__.test)("a model under the limit runs, with the estimate in a line under the row", async ($, on) => { + const { clock, ran } = await start($, on, { answers: { orders: UNDER } }); + const result = await $.tool.call(bash("dbt build -s orders")); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt build -s orders"]); + (0,__vite_ssr_import_0__.expect)(result.context).toEqual(["cost · orders would scan 2.0 GiB"]); +}); +(0,__vite_ssr_import_0__.test)("dbt show --inline is estimated from its SQL", async ($, on) => { + const { clock, estimates } = await start($, on, { answers: { "select * from big": OVER } }); + const result = await $.tool.call(bash(`dbt show --inline "select * from big"`)); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["select * from big"]); + (0,__vite_ssr_import_0__.expect)(result.deny).toContain("20.0 GiB"); +}); +(0,__vite_ssr_import_0__.test)("/allow-scan lets the next held command through once, then the one after is held again", async ($, on) => { + const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); + const allowed = await $.command.run({ + command: "allow-scan", + args: "" + }); + (0,__vite_ssr_import_0__.expect)(allowed.text).toContain("runs once"); + const through = await $.tool.call(bash("dbt run -s orders")); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(through.deny).toBeUndefined(); + (0,__vite_ssr_import_0__.expect)(through.context).toEqual(["cost · orders would scan 20.0 GiB, over the 10.0 GiB limit: allowed once"]); + (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders"]); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); + (0,__vite_ssr_import_0__.expect)(estimates).toHaveLength(3); +}); +(0,__vite_ssr_import_0__.test)("a selection that is not one plain model passes, saying there is no estimate, and asks nothing", async ($, on) => { + const { clock, estimates, ran } = await start($, on); + for (const [command, why] of [ + ["dbt run", "no model named"], + ["dbt build -s +orders", "graph, tag, path or package selector"], + ["dbt run -s tag:nightly", "graph, tag, path or package selector"], + ["dbt run -s a b", "several selectors"] + ]) { + const result = await $.tool.call(bash(command)); + (0,__vite_ssr_import_0__.expect)(result.deny).toBeUndefined(); + (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain("cost · no estimate for this selection"); + (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain(why); + }; + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual([]); + (0,__vite_ssr_import_0__.expect)(ran).toHaveLength(4); +}); +(0,__vite_ssr_import_0__.test)("commands that scan nothing are not looked at", async ($, on) => { + const { clock, estimates, ran } = await start($, on); + for (const command of [ + "dbt test -s orders", + "dbt compile -s orders", + "ls", + "git status" + ]) await $.tool.call(bash(command)); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual([]); + (0,__vite_ssr_import_0__.expect)(ran).toHaveLength(4); +}); +(0,__vite_ssr_import_0__.test)("another warehouse is told once, never held, and not asked again", async ($, on) => { + const { clock, estimates, ran } = await start($, on, { fallback: { + success: true, + supported: false, + adapter: "snowflake" + } }); + const first = await $.tool.call(bash("dbt run -s orders")); + const second = await $.tool.call(bash("dbt run -s customers")); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(first.deny).toBeUndefined(); + (0,__vite_ssr_import_0__.expect)(first.context).toEqual(["cost · no estimate on snowflake: only BigQuery has a dry run"]); + (0,__vite_ssr_import_0__.expect)(second.deny).toBeUndefined(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["orders"]); + (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders", "dbt run -s customers"]); +}); +(0,__vite_ssr_import_0__.test)("an altimate-code without the tool shows one line saying what is needed, and the command runs", async ($, on) => { + const { clock, ran } = await start($, on, { answers: { orders: "unknown-tool" } }); + const result = await $.tool.call(bash("dbt run -s orders")); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders"]); + (0,__vite_ssr_import_0__.expect)(result.context).toHaveLength(1); + (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain("needs a newer altimate-code"); +}); +(0,__vite_ssr_import_0__.test)("a dry run that failed passes the command with the reason", async ($, on) => { + const { clock, ran } = await start($, on, { answers: { orders: { + success: false, + error: "Access Denied: BigQuery job" + } } }); + const result = await $.tool.call(bash("dbt run -s orders")); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders"]); + (0,__vite_ssr_import_0__.expect)(result.context).toEqual(["cost · no estimate for orders: Access Denied: BigQuery job"]); +}); +(0,__vite_ssr_import_0__.test)("/scan-cost estimates a model on demand and says how it stands against the limit", async ($, on) => { + const { clock, estimates, ran } = await start($, on, { answers: { + orders: OVER, + customers: UNDER + } }); + (0,__vite_ssr_import_0__.expect)((await $.command.run({ + command: "scan-cost", + args: "orders" + })).text).toBe("orders would scan 20.0 GiB, over the 10.0 GiB limit: a dbt run of it is held until /allow-scan."); + (0,__vite_ssr_import_0__.expect)((await $.command.run({ + command: "scan-cost", + args: "customers" + })).text).toBe("customers would scan 2.0 GiB, within the 10.0 GiB limit."); + (0,__vite_ssr_import_0__.expect)((await $.command.run({ + command: "scan-cost", + args: "" + })).text).toContain("Last estimate: customers"); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["orders", "customers"]); + (0,__vite_ssr_import_0__.expect)(ran).toEqual([]); +}); +(0,__vite_ssr_import_0__.test)("a command naming two models over the limit is held whole, and one /allow-scan lets all of it through once", async ($, on) => { + const { clock, ran } = await start($, on, { answers: { + orders: OVER, + customers: bq(30 * GIB, "30.0 GiB") + } }); + const command = "dbt run -s orders && dbt run -s customers"; + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash(command))).deny).toContain("30.0 GiB"); + await $.command.run({ + command: "allow-scan", + args: "" + }); + const through = await $.tool.call(bash(command)); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(through.deny).toBeUndefined(); + (0,__vite_ssr_import_0__.expect)(through.context).toEqual(["cost · orders would scan 20.0 GiB, over the 10.0 GiB limit: allowed once", "cost · customers would scan 30.0 GiB, over the 10.0 GiB limit: allowed once"]); + (0,__vite_ssr_import_0__.expect)(ran).toEqual([command]); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash(command))).deny).toBeDefined(); +}); +(0,__vite_ssr_import_0__.test)("/allow-scan with nothing held allows nothing", async ($, on) => { + const { clock } = await start($, on, { answers: { orders: OVER } }); + (0,__vite_ssr_import_0__.expect)((await $.command.run({ + command: "allow-scan", + args: "" + })).text).toContain("Nothing is held"); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); + await clock.settle(); +}); +(0,__vite_ssr_import_0__.test)("the allowance is for the command that was held: another over-limit command is held, and the allowance is gone", async ($, on) => { + const { clock, ran } = await start($, on, { answers: { + orders: OVER, + customers: OVER + } }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); + await $.command.run({ + command: "allow-scan", + args: "" + }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s customers"))).deny).toBeDefined(); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(ran).toEqual([]); +}); +(0,__vite_ssr_import_0__.test)("an estimate whose rounded size is within the limit but whose upper bound is over it is held", async ($, on) => { + const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, "10.0 GiB", 10 * GIB + 52 * 1024 ** 2) } }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBe("up to 10.1 GiB (≈ 10.0 GiB estimated) would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again."); + await clock.settle(); +}); +(0,__vite_ssr_import_0__.test)("an upper bound that formats the same as the limit is not reported as equal to it", async ($, on) => { + const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, "10.0 GiB", 10 * GIB + 30 * 1024 ** 2) } }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBe("just over 10.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again."); + await clock.settle(); +}); +(0,__vite_ssr_import_0__.test)("a warehouse found to have no dry run ends a hold from before, and its allowance", async ($, on) => { + const answers = { orders: OVER }; + const { clock, ran, statuses } = await start($, on, { answers }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); + await $.command.run({ + command: "allow-scan", + args: "" + }); + answers.orders = { + success: true, + supported: false, + adapter: "snowflake" + }; + await $.tool.call(bash("dbt run -s orders")); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders"]); + (0,__vite_ssr_import_0__.expect)(statuses.at(-1) ?? "").not.toContain("held"); + (0,__vite_ssr_import_0__.expect)((await $.command.run({ + command: "allow-scan", + args: "" + })).text).toContain("Nothing is held"); +}); +(0,__vite_ssr_import_0__.test)("a scan just over the limit reads as over it, not as equal to it", async ($, on) => { + const { clock } = await start($, on, { answers: { orders: bq(10 * GIB + 1024 ** 2, "10.0 GiB") } }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBe("just over 10.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again."); + await clock.settle(); +}); +(0,__vite_ssr_import_0__.test)("a command that sets its own target, defer state, vars or project is not estimated", async ($, on) => { + const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } }); + const commands = [ + "dbt run -s orders --target prod", + "dbt run -s orders --defer --state prod-run", + `dbt run -s orders --vars '{a: 1}'`, + "dbt run -s orders --project-dir other", + "DBT_PROFILES_DIR=ci dbt run -s orders", + "cd other && dbt run -s orders", + " cd other && dbt run -s orders", + "export DBT_TARGET=prod; dbt run -s orders", + "uv run --directory other dbt run -s orders", + "dbt run -s orders --'vars' x", + "dbt run -s orders --full-refresh", + "dbt run -s orders --full-\\\nrefresh", + "if true; then cd other; fi; dbt run -s orders", + "dbt --profiles-dir ci run -s orders", + "FOO=1 dbt run -s orders", + "dbt run -s orders --threads $(printf '4 --target prod')", + "dbt run -s orders --threads `echo 4 --vars x`", + "dbt run -s orders 2>&${DBT_TARGET:=1}", + "dbt --log-path \"${DBT_TARGET:=prod}\" deps; dbt run -s orders" + ]; + for (const command of commands) { + const result = await $.tool.call(bash(command)); + (0,__vite_ssr_import_0__.expect)(result.deny).toBeUndefined(); + (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain("it sets its own target, defer state, vars, project or refresh mode"); + }; + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual([]); + (0,__vite_ssr_import_0__.expect)(ran).toEqual(commands); +}); +(0,__vite_ssr_import_0__.test)("dbt show --inline with its SQL on the next line after a backslash is estimated", async ($, on) => { + const { clock, estimates } = await start($, on, { answers: { "select * from big": OVER } }); + const result = await $.tool.call(bash(`dbt show --inline \\\n 'select * from big'`)); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["select * from big"]); + (0,__vite_ssr_import_0__.expect)(result.deny).toContain("20.0 GiB"); +}); +(0,__vite_ssr_import_0__.test)("letting a later command through clears the hold from the status line", async ($, on) => { + const { clock, statuses } = await start($, on, { answers: { + orders: OVER, + customers: UNDER + } }); + await $.tool.call(bash("dbt run -s orders")); + await $.tool.call(bash("dbt run -s customers")); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(statuses.filter(Boolean).at(-1)).not.toContain("held"); +}); +(0,__vite_ssr_import_0__.test)("a variant of the held command that is not estimated leaves the hold in place", async ($, on) => { + const { clock, ran } = await start($, on, { answers: { orders: OVER } }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); + await $.tool.call(bash("dbt run -s +orders")); + await $.tool.call(bash("dbt run -s orders --full-refresh")); + await clock.settle(); + await $.command.run({ + command: "allow-scan", + args: "" + }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeUndefined(); + (0,__vite_ssr_import_0__.expect)(ran.at(-1)).toBe("dbt run -s orders"); +}); +(0,__vite_ssr_import_0__.test)("a repeated --inline is estimated from the last one, as dbt reads it", async ($, on) => { + const { clock, estimates } = await start($, on, { answers: { "select * from big": OVER } }); + const result = await $.tool.call(bash(`dbt show --inline 'select 1' --inline 'select * from big'`)); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["select * from big"]); + (0,__vite_ssr_import_0__.expect)(result.deny).toContain("20.0 GiB"); +}); +(0,__vite_ssr_import_0__.test)("the lines under a command are the latest estimate of it, never an earlier one", async ($, on) => { + const answers = { orders: UNDER }; + const { clock } = await start($, on, { answers }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).context).toEqual(["cost · orders would scan 2.0 GiB"]); + answers.orders = bq(3 * GIB, "3.0 GiB"); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).context).toEqual(["cost · orders would scan 3.0 GiB"]); + await clock.settle(); +}); +(0,__vite_ssr_import_0__.test)("/allow-scan allows only the hold it read: a hold replaced meanwhile is not allowed", async ($, on) => { + const { clock, ran } = await start($, on, { answers: { + orders: OVER, + customers: OVER + } }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); + const allowing = $.command.run({ + command: "allow-scan", + args: "" + }); + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s customers"))).deny).toBeDefined(); + await allowing; + await clock.settle(); + // Whichever order the two steps took, customers (the later hold) is not allowed by a read of orders. + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s customers"))).deny).toBeDefined(); + (0,__vite_ssr_import_0__.expect)(ran).toEqual([]); +}); +(0,__vite_ssr_import_0__.test)("a non-dbt command in between neither clears the hold nor spends the allowance", async ($, on) => { + const { clock, ran } = await start($, on, { answers: { orders: OVER } }); + await $.tool.call(bash("dbt run -s orders")); + await $.command.run({ + command: "allow-scan", + args: "" + }); + await $.tool.call(bash("ls")); + const through = await $.tool.call(bash("dbt run -s orders")); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(through.deny).toBeUndefined(); + (0,__vite_ssr_import_0__.expect)(ran).toEqual(["ls", "dbt run -s orders"]); +}); +(0,__vite_ssr_import_0__.test)("inlineSql reads the query as the shell would", () => { + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline "select 'a' as x"`)).toBe(`select 'a' as x`); + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline='select 1'`)).toBe("select 1"); + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline select\\ 1 --limit 5`)).toBe("select 1"); + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline \\\n 'select 1'`)).toBe("select 1"); + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)("dbt show -s orders")).toBeNull(); + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline 'select 1' --inline='select 2'`)).toBe("select 2"); + // The value of --inline is the query, even when it looks like an option. + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline '--inline=comment select 1'`)).toBe("--inline=comment select 1"); +}); +(0,__vite_ssr_import_0__.test)("formatBytes writes the units the dry run does", () => { + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.formatBytes)(512)).toBe("512.0 Bytes"); + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.formatBytes)(1536)).toBe("1.5 KiB"); + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.formatBytes)(10 * GIB)).toBe("10.0 GiB"); + (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.formatBytes)(1024 ** 5)).toBe("1.0 PiB"); +}); +(0,__vite_ssr_import_0__.test)("what leaves the query alone is still estimated: other dbt calls before it, thread and limit flags, a launcher", async ($, on) => { + const { clock, estimates } = await start($, on, { answers: { + orders: UNDER, + "select 1": UNDER + } }); + for (const command of [ + "dbt deps && dbt run -s orders --threads 4", + "uv run dbt build --select orders --fail-fast", + `dbt show --inline "select 1" --limit 5` + ]) { + (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash(command))).context[0]).toContain("would scan 2.0 GiB"); + }; + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual([ + "orders", + "orders", + "select 1" + ]); +}); +(0,__vite_ssr_import_0__.test)("a very long run of blank lines before the command costs no noticeable time", async ($, on) => { + const { clock } = await start($, on, { answers: { orders: UNDER } }); + const began = Date.now(); + await $.tool.call(bash(`${"\n".repeat(64e3)}dbt run -s orders`)); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(Date.now() - began).toBeLessThan(3e3); +}); +(0,__vite_ssr_import_0__.test)("a line with a great many dbt calls is not read call by call", async ($, on) => { + const { clock, estimates } = await start($, on, { answers: { orders: UNDER } }); + const began = Date.now(); + const result = await $.tool.call(bash("dbt run -s orders;".repeat(4e3))); + await clock.settle(); + (0,__vite_ssr_import_0__.expect)(estimates).toEqual([]); + (0,__vite_ssr_import_0__.expect)(result.context.length).toBe(6); + (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain("cost · no estimate"); + (0,__vite_ssr_import_0__.expect)(result.context[5]).toBe("cost · 3995 more notes not shown"); + (0,__vite_ssr_import_0__.expect)(Date.now() - began).toBeLessThan(3e3); +}); +//# sourceMappingSource=vite-generated +//# sourceMappingURL=data:application/json;base64,{"version":3,"mappings":"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","names":[],"ignoreList":[],"sources":["cost.test.tsx"],"sourcesContent":["import { expect, mock, test } from 'claude-code/testing'\n\nimport { formatBytes, inlineSql } from './cost'\n\nconst ROOT = '/repo'\nconst GIB = 1024 ** 3\n\ntype Options = {\n  /** What dbt_cost_estimate answers for a model or SQL, by model name or the SQL text. */\n  answers?: Record<string, Record<string, unknown> | 'unknown-tool'>\n  /** The adapter's answer for everything else. */\n  fallback?: Record<string, unknown>\n}\n\n/** The session beneath the plugin, a CLI whose dbt_cost_estimate is scripted, and a Bash tool that records what ran. */\nasync function start($: any, on: any, options: Options = {}) {\n  const clock = mock.clock(on)\n  const estimates: string[] = []\n  const ran: string[] = []\n  const statuses: (string | undefined)[] = []\n  on('command.register', (_: unknown, e: { name: string }) => ({ value: { command: e.name } }))\n  on('turn.start', (_: unknown, e: { turnId: string }) => ({ turnId: e.turnId }))\n  on('session.end', () => ({ sessionId: 'test' }))\n  on('turn.complete', (_: unknown, e: { answer: string }) => ({ text: e.answer }))\n  on('session.start', (_: unknown, e: { cwd: string }) => ({ cwd: e.cwd }))\n  on('session.root', () => ({ value: ROOT }))\n  on('ui.log', () => ({ value: undefined }))\n  on('ui.status', (_: unknown, e: { text?: string }) => {\n    statuses.push(e.text)\n    return { value: undefined }\n  })\n  on('ui.render', ($$: any, e: any) => {\n    const { Box } = $$.ui.resolve(e)\n    return <Box key=\"engine\" />\n  })\n  on('fs.exists', () => ({ value: false }))\n  on('process.run', (_: unknown, e: { argv: readonly string[] }) => {\n    const [, command, , tool] = e.argv\n    if (command !== 'tool') return { value: { exitCode: 1, stdout: '', stderr: 'not this test' } }\n    expect(tool).toBe('dbt_cost_estimate')\n    // The adapter starts the project's dbt: the call must carry write permission.\n    expect(e.argv).toContain('--allow-write')\n    const args = JSON.parse(String(e.argv[e.argv.indexOf('--args') + 1] ?? '{}'))\n    const key = String(args.model ?? args.sql)\n    estimates.push(key)\n    const answer = options.answers?.[key] ?? options.fallback\n    if (answer === 'unknown-tool') {\n      return { value: { exitCode: 1, stdout: JSON.stringify({ status: 'error', output: `Unknown tool: ${tool}. Run \\`altimate-code tool list\\` to see the available tools.`, metadata: {} }), stderr: '' } }\n    }\n    return { value: { exitCode: 0, stdout: JSON.stringify({ status: 'ok', output: '', metadata: answer ?? { success: false, error: 'no answer scripted' } }), stderr: '' } }\n  })\n  // The Bash tool itself, beneath the plugin.\n  on('tool.call', (_: unknown, e: { tool: string; command?: string }) => {\n    if (e.tool === 'Bash') ran.push(String(e.command))\n    return { result: { text: 'ok', isError: false } }\n  })\n  await $.session.start({ cwd: ROOT, surface: 'terminal', isInteractive: true })\n  await clock.settle()\n  return { clock, estimates, ran, statuses }\n}\n\nconst bq = (bytes: number, display: string, maxBytes = bytes) => ({ success: true, supported: true, adapter: 'bigquery', bytes, maxBytes, display })\nconst OVER = bq(20 * GIB, '20.0 GiB')\nconst UNDER = bq(2 * GIB, '2.0 GiB')\n\nconst bash = (command: string) => ({ tool: 'Bash' as const, command })\n\ntest('a model over the limit is refused with its estimate, and the command never runs', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } })\n  const result: any = await $.tool.call(bash('dbt run --select orders'))\n  await clock.settle()\n\n  expect(estimates).toEqual(['orders'])\n  expect(ran).toEqual([])\n  expect(result.deny).toBe('≈ 20.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.')\n})\n\ntest('a model under the limit runs, with the estimate in a line under the row', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: UNDER } })\n  const result: any = await $.tool.call(bash('dbt build -s orders'))\n  await clock.settle()\n\n  expect(ran).toEqual(['dbt build -s orders'])\n  expect(result.context).toEqual(['cost · orders would scan 2.0 GiB'])\n})\n\ntest('dbt show --inline is estimated from its SQL', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { 'select * from big': OVER } })\n  const result: any = await $.tool.call(bash(`dbt show --inline \"select * from big\"`))\n  await clock.settle()\n\n  expect(estimates).toEqual(['select * from big'])\n  expect(result.deny).toContain('20.0 GiB')\n})\n\ntest('/allow-scan lets the next held command through once, then the one after is held again', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } })\n  expect((await $.tool.call(bash('dbt run -s orders')) as any).deny).toBeDefined()\n\n  const allowed = await $.command.run({ command: 'allow-scan', args: '' } as any)\n  expect(allowed.text).toContain('runs once')\n  const through: any = await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n  expect(through.deny).toBeUndefined()\n  expect(through.context).toEqual(['cost · orders would scan 20.0 GiB, over the 10.0 GiB limit: allowed once'])\n  expect(ran).toEqual(['dbt run -s orders'])\n\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  expect(estimates).toHaveLength(3)\n})\n\ntest('a selection that is not one plain model passes, saying there is no estimate, and asks nothing', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on)\n  for (const [command, why] of [\n    ['dbt run', 'no model named'],\n    ['dbt build -s +orders', 'graph, tag, path or package selector'],\n    ['dbt run -s tag:nightly', 'graph, tag, path or package selector'],\n    ['dbt run -s a b', 'several selectors'],\n  ] as const) {\n    const result: any = await $.tool.call(bash(command))\n    expect(result.deny).toBeUndefined()\n    expect(result.context[0]).toContain('cost · no estimate for this selection')\n    expect(result.context[0]).toContain(why)\n  }\n  await clock.settle()\n  expect(estimates).toEqual([])\n  expect(ran).toHaveLength(4)\n})\n\ntest('commands that scan nothing are not looked at', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on)\n  for (const command of ['dbt test -s orders', 'dbt compile -s orders', 'ls', 'git status']) await $.tool.call(bash(command))\n  await clock.settle()\n  expect(estimates).toEqual([])\n  expect(ran).toHaveLength(4)\n})\n\ntest('another warehouse is told once, never held, and not asked again', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { fallback: { success: true, supported: false, adapter: 'snowflake' } })\n  const first: any = await $.tool.call(bash('dbt run -s orders'))\n  const second: any = await $.tool.call(bash('dbt run -s customers'))\n  await clock.settle()\n\n  expect(first.deny).toBeUndefined()\n  expect(first.context).toEqual(['cost · no estimate on snowflake: only BigQuery has a dry run'])\n  expect(second.deny).toBeUndefined()\n  expect(estimates).toEqual(['orders'])\n  expect(ran).toEqual(['dbt run -s orders', 'dbt run -s customers'])\n})\n\ntest('an altimate-code without the tool shows one line saying what is needed, and the command runs', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: 'unknown-tool' } })\n  const result: any = await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n\n  expect(ran).toEqual(['dbt run -s orders'])\n  expect(result.context).toHaveLength(1)\n  expect(result.context[0]).toContain('needs a newer altimate-code')\n})\n\ntest('a dry run that failed passes the command with the reason', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: { success: false, error: 'Access Denied: BigQuery job' } } })\n  const result: any = await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n\n  expect(ran).toEqual(['dbt run -s orders'])\n  expect(result.context).toEqual(['cost · no estimate for orders: Access Denied: BigQuery job'])\n})\n\ntest('/scan-cost estimates a model on demand and says how it stands against the limit', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER, customers: UNDER } })\n  expect((await $.command.run({ command: 'scan-cost', args: 'orders' } as any)).text).toBe(\n    'orders would scan 20.0 GiB, over the 10.0 GiB limit: a dbt run of it is held until /allow-scan.',\n  )\n  expect((await $.command.run({ command: 'scan-cost', args: 'customers' } as any)).text).toBe('customers would scan 2.0 GiB, within the 10.0 GiB limit.')\n  expect((await $.command.run({ command: 'scan-cost', args: '' } as any)).text).toContain('Last estimate: customers')\n  await clock.settle()\n  expect(estimates).toEqual(['orders', 'customers'])\n  expect(ran).toEqual([])\n})\n\ntest('a command naming two models over the limit is held whole, and one /allow-scan lets all of it through once', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER, customers: bq(30 * GIB, '30.0 GiB') } })\n  const command = 'dbt run -s orders && dbt run -s customers'\n  expect(((await $.tool.call(bash(command))) as any).deny).toContain('30.0 GiB')\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n  const through: any = await $.tool.call(bash(command))\n  await clock.settle()\n\n  expect(through.deny).toBeUndefined()\n  expect(through.context).toEqual([\n    'cost · orders would scan 20.0 GiB, over the 10.0 GiB limit: allowed once',\n    'cost · customers would scan 30.0 GiB, over the 10.0 GiB limit: allowed once',\n  ])\n  expect(ran).toEqual([command])\n  expect(((await $.tool.call(bash(command))) as any).deny).toBeDefined()\n})\n\ntest('/allow-scan with nothing held allows nothing', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: OVER } })\n  expect((await $.command.run({ command: 'allow-scan', args: '' } as any)).text).toContain('Nothing is held')\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await clock.settle()\n})\n\ntest('the allowance is for the command that was held: another over-limit command is held, and the allowance is gone', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER, customers: OVER } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n\n  expect(((await $.tool.call(bash('dbt run -s customers'))) as any).deny).toBeDefined()\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await clock.settle()\n  expect(ran).toEqual([])\n})\n\ntest('an estimate whose rounded size is within the limit but whose upper bound is over it is held', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, '10.0 GiB', 10 * GIB + 52 * 1024 ** 2) } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBe('up to 10.1 GiB (≈ 10.0 GiB estimated) would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.')\n  await clock.settle()\n})\n\ntest('an upper bound that formats the same as the limit is not reported as equal to it', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, '10.0 GiB', 10 * GIB + 30 * 1024 ** 2) } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBe('just over 10.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.')\n  await clock.settle()\n})\n\ntest('a warehouse found to have no dry run ends a hold from before, and its allowance', async ($, on) => {\n  const answers: Record<string, any> = { orders: OVER }\n  const { clock, ran, statuses } = await start($, on, { answers })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n  answers.orders = { success: true, supported: false, adapter: 'snowflake' }\n  await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n  expect(ran).toEqual(['dbt run -s orders'])\n  expect(statuses.at(-1) ?? '').not.toContain('held')\n  expect((await $.command.run({ command: 'allow-scan', args: '' } as any)).text).toContain('Nothing is held')\n})\n\ntest('a scan just over the limit reads as over it, not as equal to it', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: bq(10 * GIB + 1024 ** 2, '10.0 GiB') } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBe('just over 10.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.')\n  await clock.settle()\n})\n\ntest('a command that sets its own target, defer state, vars or project is not estimated', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } })\n  const commands = [\n    'dbt run -s orders --target prod',\n    'dbt run -s orders --defer --state prod-run',\n    `dbt run -s orders --vars '{a: 1}'`,\n    'dbt run -s orders --project-dir other',\n    'DBT_PROFILES_DIR=ci dbt run -s orders',\n    'cd other && dbt run -s orders',\n    ' cd other && dbt run -s orders',\n    'export DBT_TARGET=prod; dbt run -s orders',\n    'uv run --directory other dbt run -s orders',\n    \"dbt run -s orders --'vars' x\",\n    'dbt run -s orders --full-refresh',\n    'dbt run -s orders --full-\\\\\\nrefresh',\n    'if true; then cd other; fi; dbt run -s orders',\n    'dbt --profiles-dir ci run -s orders',\n    'FOO=1 dbt run -s orders',\n    \"dbt run -s orders --threads $(printf '4 --target prod')\",\n    'dbt run -s orders --threads `echo 4 --vars x`',\n    'dbt run -s orders 2>&${DBT_TARGET:=1}',\n    'dbt --log-path \"${DBT_TARGET:=prod}\" deps; dbt run -s orders',\n  ]\n  for (const command of commands) {\n    const result: any = await $.tool.call(bash(command))\n    expect(result.deny).toBeUndefined()\n    expect(result.context[0]).toContain('it sets its own target, defer state, vars, project or refresh mode')\n  }\n  await clock.settle()\n  expect(estimates).toEqual([])\n  expect(ran).toEqual(commands)\n})\n\ntest('dbt show --inline with its SQL on the next line after a backslash is estimated', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { 'select * from big': OVER } })\n  const result: any = await $.tool.call(bash(`dbt show --inline \\\\\\n  'select * from big'`))\n  await clock.settle()\n  expect(estimates).toEqual(['select * from big'])\n  expect(result.deny).toContain('20.0 GiB')\n})\n\ntest('letting a later command through clears the hold from the status line', async ($, on) => {\n  const { clock, statuses } = await start($, on, { answers: { orders: OVER, customers: UNDER } })\n  await $.tool.call(bash('dbt run -s orders'))\n  await $.tool.call(bash('dbt run -s customers'))\n  await clock.settle()\n  expect(statuses.filter(Boolean).at(-1)).not.toContain('held')\n})\n\ntest('a variant of the held command that is not estimated leaves the hold in place', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await $.tool.call(bash('dbt run -s +orders'))\n  await $.tool.call(bash('dbt run -s orders --full-refresh'))\n  await clock.settle()\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeUndefined()\n  expect(ran.at(-1)).toBe('dbt run -s orders')\n})\n\ntest('a repeated --inline is estimated from the last one, as dbt reads it', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { 'select * from big': OVER } })\n  const result: any = await $.tool.call(bash(`dbt show --inline 'select 1' --inline 'select * from big'`))\n  await clock.settle()\n  expect(estimates).toEqual(['select * from big'])\n  expect(result.deny).toContain('20.0 GiB')\n})\n\ntest('the lines under a command are the latest estimate of it, never an earlier one', async ($, on) => {\n  const answers: Record<string, any> = { orders: UNDER }\n  const { clock } = await start($, on, { answers })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).context).toEqual(['cost · orders would scan 2.0 GiB'])\n  answers.orders = bq(3 * GIB, '3.0 GiB')\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).context).toEqual(['cost · orders would scan 3.0 GiB'])\n  await clock.settle()\n})\n\ntest('/allow-scan allows only the hold it read: a hold replaced meanwhile is not allowed', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER, customers: OVER } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  const allowing = $.command.run({ command: 'allow-scan', args: '' } as any)\n  expect(((await $.tool.call(bash('dbt run -s customers'))) as any).deny).toBeDefined()\n  await allowing\n  await clock.settle()\n  // Whichever order the two steps took, customers (the later hold) is not allowed by a read of orders.\n  expect(((await $.tool.call(bash('dbt run -s customers'))) as any).deny).toBeDefined()\n  expect(ran).toEqual([])\n})\n\ntest('a non-dbt command in between neither clears the hold nor spends the allowance', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER } })\n  await $.tool.call(bash('dbt run -s orders'))\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n  await $.tool.call(bash('ls'))\n  const through: any = await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n  expect(through.deny).toBeUndefined()\n  expect(ran).toEqual(['ls', 'dbt run -s orders'])\n})\n\ntest('inlineSql reads the query as the shell would', () => {\n  expect(inlineSql(`dbt show --inline \"select 'a' as x\"`)).toBe(`select 'a' as x`)\n  expect(inlineSql(`dbt show --inline='select 1'`)).toBe('select 1')\n  expect(inlineSql(`dbt show --inline select\\\\ 1 --limit 5`)).toBe('select 1')\n  expect(inlineSql(`dbt show --inline \\\\\\n 'select 1'`)).toBe('select 1')\n  expect(inlineSql('dbt show -s orders')).toBeNull()\n  expect(inlineSql(`dbt show --inline 'select 1' --inline='select 2'`)).toBe('select 2')\n  // The value of --inline is the query, even when it looks like an option.\n  expect(inlineSql(`dbt show --inline '--inline=comment select 1'`)).toBe('--inline=comment select 1')\n})\n\ntest('formatBytes writes the units the dry run does', () => {\n  expect(formatBytes(512)).toBe('512.0 Bytes')\n  expect(formatBytes(1536)).toBe('1.5 KiB')\n  expect(formatBytes(10 * GIB)).toBe('10.0 GiB')\n  expect(formatBytes(1024 ** 5)).toBe('1.0 PiB')\n})\n\ntest('what leaves the query alone is still estimated: other dbt calls before it, thread and limit flags, a launcher', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { orders: UNDER, 'select 1': UNDER } })\n  for (const command of ['dbt deps && dbt run -s orders --threads 4', 'uv run dbt build --select orders --fail-fast', `dbt show --inline \"select 1\" --limit 5`]) {\n    expect(((await $.tool.call(bash(command))) as any).context[0]).toContain('would scan 2.0 GiB')\n  }\n  await clock.settle()\n  expect(estimates).toEqual(['orders', 'orders', 'select 1'])\n})\n\ntest('a very long run of blank lines before the command costs no noticeable time', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: UNDER } })\n  const began = Date.now()\n  await $.tool.call(bash(`${'\\n'.repeat(64000)}dbt run -s orders`))\n  await clock.settle()\n  expect(Date.now() - began).toBeLessThan(3000)\n})\n\ntest('a line with a great many dbt calls is not read call by call', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { orders: UNDER } })\n  const began = Date.now()\n  const result: any = await $.tool.call(bash('dbt run -s orders;'.repeat(4000)))\n  await clock.settle()\n  expect(estimates).toEqual([])\n  expect(result.context.length).toBe(6)\n  expect(result.context[0]).toContain('cost · no estimate')\n  expect(result.context[5]).toBe('cost · 3995 more notes not shown')\n  expect(Date.now() - began).toBeLessThan(3000)\n})\n"],"file":"/hooks/features/cost.test.tsx"} + +//# vitestCache=W3siZmlsZSI6IjEiLCJpZCI6IjEiLCJpbXBvcnRzIjoiMiIsIm1hcHBpbmdzIjpmYWxzZSwiZGVwcyI6IjMiLCJkeW5hbWljRGVwcyI6IjQiLCJzdGF0aWNNb2NrcyI6bnVsbCwiaGFzQ292ZXJhZ2VEYXRhIjpmYWxzZX0sIi9Vc2Vycy9oYXJpc2gvLnF1aWtpbS93b3Jrc3BhY2VzL2FsdGltYXRlLWNsYXVkZS1wbHVnaW4vZmVhdC9kYnQtY29zdC1lc3RpbWF0ZS10b29sL3BsdWdpbnMvYWx0aW1hdGUtY29kZS9ob29rcy9mZWF0dXJlcy9jb3N0LnRlc3QudHN4Iix7InVybHMiOiI1IiwiaWRzIjoiNiJ9LFsiNyIsIjgiLCI5Il0sW10sWyI3IiwiOCIsIjkiXSx7fSwiY2xhdWRlLWNvZGUvdGVzdGluZyIsIi9ob29rcy9mZWF0dXJlcy9jb3N0LnRzeCIsInJlYWN0L2pzeC1kZXYtcnVudGltZSJd \ No newline at end of file diff --git a/plugins/altimate-code/node_modules/.vitest-cache/CACHEDIR.TAG b/plugins/altimate-code/node_modules/.vitest-cache/CACHEDIR.TAG new file mode 100644 index 00000000..8c1ef4ce --- /dev/null +++ b/plugins/altimate-code/node_modules/.vitest-cache/CACHEDIR.TAG @@ -0,0 +1,3 @@ +Signature: 8a477f597d28d172789f06886806bc55 +# This file is a cache directory tag created by Vitest. +# For information about cache directory tags see https://bford.info/cachedir/ diff --git a/plugins/altimate-code/node_modules/.vitest-cache/_metadata.json b/plugins/altimate-code/node_modules/.vitest-cache/_metadata.json new file mode 100644 index 00000000..9ee9061a --- /dev/null +++ b/plugins/altimate-code/node_modules/.vitest-cache/_metadata.json @@ -0,0 +1,3 @@ +{ + "lockfileHash": "e3b0c442" +} \ No newline at end of file From 68dd49a779a31c75116d1ce831706a4a59bf90d8 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 14:43:43 +0530 Subject: [PATCH 55/56] fix(cost): a failed estimate on a parallel call is held by the over-limit answer another call has in hand Co-Authored-By: Claude Sonnet 5.5 --- .../hooks/features/cost.test.tsx | 20 ++++++++++++++++++- plugins/altimate-code/hooks/features/cost.tsx | 15 +++++++++++--- 2 files changed, 31 insertions(+), 4 deletions(-) diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index d0b9e161..1f086105 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -10,6 +10,8 @@ type Options = { answers?: Record | 'unknown-tool'> /** The adapter's answer for everything else. */ fallback?: Record + /** Answers given in turn for a model, before `answers` applies again. */ + sequence?: Record[]> /** The CLI answers only once this resolves. */ hold?: Promise /** With `hold`: only the estimate of this model or SQL waits. */ @@ -63,7 +65,7 @@ async function start($: any, on: any, options: Options = {}) { if (options.holds?.[key]) await options.holds[key] if (options.hold && (options.holdFor === undefined || options.holdFor === key)) await options.hold estimates.push(key) - const answer = options.answers?.[key] ?? options.fallback + const answer = options.sequence?.[key]?.shift() ?? options.answers?.[key] ?? options.fallback if (answer === 'unknown-tool') { return { value: { exitCode: 1, stdout: JSON.stringify({ status: 'error', output: `Unknown tool: ${tool}. Run \`altimate-code tool list\` to see the available tools.`, metadata: {} }), stderr: '' } } } @@ -1282,3 +1284,19 @@ test('a dbt run let through while the gate waits on its estimate voids that answ await rebuild expect(ran).toEqual(['dbt run -s customers --target prod']) }) + +test('a parallel call whose estimate fails is held by the hold another call recorded meanwhile', async ($, on) => { + const options: Options = { sequence: { orders: [OVER, { success: false, error: 'Access Denied' }] } } + const { clock, ran } = await start($, on, options) + let release!: () => void + options.hold = new Promise(resolve => (release = resolve)) + const first = $.tool.call(bash('dbt run -s orders')) + const second = $.tool.call(bash('dbt run -s orders')) + await clock.advance(500) + release() + await clock.advance(100) + const results: any[] = [await first, await second] + await clock.settle() + expect(results.every(r => typeof r?.deny === 'string')).toBe(true) + expect(ran).toEqual([]) +}) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 360eac86..26f6fae2 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -176,7 +176,7 @@ export async function bashRewrite($: EngineInterface, e: BashCall): Promise { - const verdict = await gate($, e) + const verdict = await gate($, e).finally(() => overNow.delete(e.command)) // A dbt run or build that is let through rebuilds relations while it runs: an estimate kept from before it is stale from here. if (verdict === null && limitBytes > 0 && parseDbtCommand(e.command).some(i => i.subcommand !== null && REBUILDS.has(i.subcommand))) dropFinished() return verdict @@ -190,6 +190,9 @@ async function leaveProject($: EngineInterface) { await showStatus($, null) } +/** Per command: the over-limit answer a pass has in hand but has not yet recorded as the hold. */ +const overNow = new Map() + async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | null> { if (limitBytes <= 0) return null // Before it runs, not only after: another call can ask while a long command is rewriting the project. @@ -262,6 +265,8 @@ async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | continue } estimated = true + // Noted before any await: a parallel pass for this command whose own estimate fails must still see it. + if (answer.maxBytes > limitBytes) overNow.set(e.command, { label, bytes: answer.maxBytes, display: answer.display }) await rememberEstimate($, label, answer.bytes, answer.display) if (answer.maxBytes <= limitBytes) lines.push(`cost · ${label} would scan ${answer.display}`) else over.push({ label, bytes: answer.maxBytes, point: answer.bytes, display: answer.display }) @@ -293,8 +298,12 @@ async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | } // A command held earlier stays held while its estimate cannot be made again: only /allow-scan or an estimate under the limit frees it. - if (over.length === 0 && failed && state.held?.command === e.command && state.held.bytes > limitBytes) { - over.push({ label: state.held.target, bytes: state.held.bytes, point: state.held.bytes, display: state.held.display }) + // The hold is read now, not from the state taken before the estimates: a parallel call may have recorded it meanwhile. + // Or from an over-limit answer a parallel pass for the same command has in hand and has not recorded yet. + const stored = over.length === 0 && failed ? (await read($, costAtom))?.held : null + const heldNow = stored && stored.command === e.command ? { label: stored.target, bytes: stored.bytes, display: stored.display } : overNow.get(e.command) + if (over.length === 0 && failed && heldNow && heldNow.bytes > limitBytes) { + over.push({ label: heldNow.label, bytes: heldNow.bytes, point: heldNow.bytes, display: heldNow.display }) } if (over.length > 0) { From 7aa9ffdb86f67ddb82702c3815904fb3d44d44e8 Mon Sep 17 00:00:00 2001 From: Harish Kumar Date: Wed, 18 Nov 2026 14:51:33 +0530 Subject: [PATCH 56/56] chore(cost): untrack the test caches and ignore node_modules; a pass drops only its own over-limit note Co-Authored-By: Claude Sonnet 5.5 --- .gitignore | 1 + .../hooks/features/cost.test.tsx | 7 +- plugins/altimate-code/hooks/features/cost.tsx | 13 +- .../node_modules/.vite/vitest/CACHEDIR.TAG | 3 - .../results.json | 1 - .../01827a3d74da33920570f783b18edea8eb8d7b82 | 472 ------------------ .../node_modules/.vitest-cache/CACHEDIR.TAG | 3 - .../node_modules/.vitest-cache/_metadata.json | 3 - 8 files changed, 15 insertions(+), 488 deletions(-) delete mode 100644 plugins/altimate-code/node_modules/.vite/vitest/CACHEDIR.TAG delete mode 100644 plugins/altimate-code/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json delete mode 100644 plugins/altimate-code/node_modules/.vitest-cache/01827a3d74da33920570f783b18edea8eb8d7b82 delete mode 100644 plugins/altimate-code/node_modules/.vitest-cache/CACHEDIR.TAG delete mode 100644 plugins/altimate-code/node_modules/.vitest-cache/_metadata.json diff --git a/.gitignore b/.gitignore index 89b72ee7..5db4b3bb 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,3 @@ __pycache__/ .context/ +node_modules/ diff --git a/plugins/altimate-code/hooks/features/cost.test.tsx b/plugins/altimate-code/hooks/features/cost.test.tsx index 1f086105..38f7d808 100644 --- a/plugins/altimate-code/hooks/features/cost.test.tsx +++ b/plugins/altimate-code/hooks/features/cost.test.tsx @@ -1194,8 +1194,7 @@ test('a /cd away and back does not forget the estimate still running in the proj await clock.advance(4_001) expect(((await again) as any).text).toContain('another estimate is still running in this project') expect(started).toEqual(['orders', 'b']) - // The gate learns each project it passes through: a Bash pass in A, one in B (the /cd), then back in A. - options.cwd = undefined + // The gate learns each project it passes through: a Bash pass in A, one in B (the /cd, while orders still runs), then back in A. await $.tool.call(bash('ls')) options.cwd = '/elsewhere/project-b' await $.tool.call(bash('ls')) @@ -1287,7 +1286,7 @@ test('a dbt run let through while the gate waits on its estimate voids that answ test('a parallel call whose estimate fails is held by the hold another call recorded meanwhile', async ($, on) => { const options: Options = { sequence: { orders: [OVER, { success: false, error: 'Access Denied' }] } } - const { clock, ran } = await start($, on, options) + const { clock, ran, started } = await start($, on, options) let release!: () => void options.hold = new Promise(resolve => (release = resolve)) const first = $.tool.call(bash('dbt run -s orders')) @@ -1297,6 +1296,8 @@ test('a parallel call whose estimate fails is held by the hold another call reco await clock.advance(100) const results: any[] = [await first, await second] await clock.settle() + // Both calls asked: the second got its own failing estimate, not the first one's answer. + expect(started).toEqual(['orders', 'orders']) expect(results.every(r => typeof r?.deny === 'string')).toBe(true) expect(ran).toEqual([]) }) diff --git a/plugins/altimate-code/hooks/features/cost.tsx b/plugins/altimate-code/hooks/features/cost.tsx index 26f6fae2..f968d4a3 100644 --- a/plugins/altimate-code/hooks/features/cost.tsx +++ b/plugins/altimate-code/hooks/features/cost.tsx @@ -176,7 +176,11 @@ export async function bashRewrite($: EngineInterface, e: BashCall): Promise { - const verdict = await gate($, e).finally(() => overNow.delete(e.command)) + const mine: { note?: object } = {} + const verdict = await gate($, e, mine).finally(() => { + // Only this pass's own note: a sibling pass for the same command may still be between noting and recording its answer. + if (overNow.get(e.command) === mine.note) overNow.delete(e.command) + }) // A dbt run or build that is let through rebuilds relations while it runs: an estimate kept from before it is stale from here. if (verdict === null && limitBytes > 0 && parseDbtCommand(e.command).some(i => i.subcommand !== null && REBUILDS.has(i.subcommand))) dropFinished() return verdict @@ -193,7 +197,7 @@ async function leaveProject($: EngineInterface) { /** Per command: the over-limit answer a pass has in hand but has not yet recorded as the hold. */ const overNow = new Map() -async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | null> { +async function gate($: EngineInterface, e: BashCall, mine: { note?: object }): Promise<{ deny: string } | null> { if (limitBytes <= 0) return null // Before it runs, not only after: another call can ask while a long command is rewriting the project. // A command refused for its estimate has not run: its retry is not a change, and keeps the answers it waited for. @@ -266,7 +270,10 @@ async function gate($: EngineInterface, e: BashCall): Promise<{ deny: string } | } estimated = true // Noted before any await: a parallel pass for this command whose own estimate fails must still see it. - if (answer.maxBytes > limitBytes) overNow.set(e.command, { label, bytes: answer.maxBytes, display: answer.display }) + if (answer.maxBytes > limitBytes) { + mine.note = { label, bytes: answer.maxBytes, display: answer.display } + overNow.set(e.command, mine.note as { label: string; bytes: number; display: string }) + } await rememberEstimate($, label, answer.bytes, answer.display) if (answer.maxBytes <= limitBytes) lines.push(`cost · ${label} would scan ${answer.display}`) else over.push({ label, bytes: answer.maxBytes, point: answer.bytes, display: answer.display }) diff --git a/plugins/altimate-code/node_modules/.vite/vitest/CACHEDIR.TAG b/plugins/altimate-code/node_modules/.vite/vitest/CACHEDIR.TAG deleted file mode 100644 index 8c1ef4ce..00000000 --- a/plugins/altimate-code/node_modules/.vite/vitest/CACHEDIR.TAG +++ /dev/null @@ -1,3 +0,0 @@ -Signature: 8a477f597d28d172789f06886806bc55 -# This file is a cache directory tag created by Vitest. -# For information about cache directory tags see https://bford.info/cachedir/ diff --git a/plugins/altimate-code/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json b/plugins/altimate-code/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json deleted file mode 100644 index 93c7e71e..00000000 --- a/plugins/altimate-code/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json +++ /dev/null @@ -1 +0,0 @@ -{"version":1,"projects":{"":{"files":{"hooks/features/cost.test.tsx":{"failed":true,"duration":0,"lastRun":1794805775627}}}}} \ No newline at end of file diff --git a/plugins/altimate-code/node_modules/.vitest-cache/01827a3d74da33920570f783b18edea8eb8d7b82 b/plugins/altimate-code/node_modules/.vitest-cache/01827a3d74da33920570f783b18edea8eb8d7b82 deleted file mode 100644 index cdb1f273..00000000 --- a/plugins/altimate-code/node_modules/.vitest-cache/01827a3d74da33920570f783b18edea8eb8d7b82 +++ /dev/null @@ -1,472 +0,0 @@ -const __vite_ssr_import_0__ = await __vite_ssr_import__("claude-code/testing", {"importedNames":["expect","mock","test"]}); -const __vite_ssr_import_1__ = await __vite_ssr_import__("/hooks/features/cost.tsx", {"importedNames":["formatBytes","inlineSql"]}); -const __vite_ssr_import_2__ = await __vite_ssr_import__("react/jsx-dev-runtime", {"importedNames":["jsxDEV"]}); - - -var _jsxFileName = "/Users/harish/.quikim/workspaces/altimate-claude-plugin/feat/dbt-cost-estimate-tool/plugins/altimate-code/hooks/features/cost.test.tsx"; - -const ROOT = "/repo"; -const GIB = 1024 ** 3; -/** The session beneath the plugin, a CLI whose dbt_cost_estimate is scripted, and a Bash tool that records what ran. */ -async function start($, on, options = {}) { - const clock = __vite_ssr_import_0__.mock.clock(on); - const estimates = []; - const ran = []; - const statuses = []; - on("command.register", (_, e) => ({ value: { command: e.name } })); - on("turn.start", (_, e) => ({ turnId: e.turnId })); - on("session.end", () => ({ sessionId: "test" })); - on("turn.complete", (_, e) => ({ text: e.answer })); - on("session.start", (_, e) => ({ cwd: e.cwd })); - on("session.root", () => ({ value: ROOT })); - on("ui.log", () => ({ value: undefined })); - on("ui.status", (_, e) => { - statuses.push(e.text); - return { value: undefined }; - }); - on("ui.render", ($$, e) => { - const { Box } = $$.ui.resolve(e); - return /* @__PURE__ */ (0,__vite_ssr_import_2__.jsxDEV)(Box, {}, "engine", false, { - fileName: _jsxFileName, - lineNumber: 34, - columnNumber: 12 - }, this); - }); - on("fs.exists", () => ({ value: false })); - on("process.run", (_, e) => { - const [, command, , tool] = e.argv; - if (command !== "tool") return { value: { - exitCode: 1, - stdout: "", - stderr: "not this test" - } }; - (0,__vite_ssr_import_0__.expect)(tool).toBe("dbt_cost_estimate"); - // The adapter starts the project's dbt: the call must carry write permission. - (0,__vite_ssr_import_0__.expect)(e.argv).toContain("--allow-write"); - const args = JSON.parse(String(e.argv[e.argv.indexOf("--args") + 1] ?? "{}")); - const key = String(args.model ?? args.sql); - estimates.push(key); - const answer = options.answers?.[key] ?? options.fallback; - if (answer === "unknown-tool") { - return { value: { - exitCode: 1, - stdout: JSON.stringify({ - status: "error", - output: `Unknown tool: ${tool}. Run \`altimate-code tool list\` to see the available tools.`, - metadata: {} - }), - stderr: "" - } }; - }; - return { value: { - exitCode: 0, - stdout: JSON.stringify({ - status: "ok", - output: "", - metadata: answer ?? { - success: false, - error: "no answer scripted" - } - }), - stderr: "" - } }; - }); - // The Bash tool itself, beneath the plugin. - on("tool.call", (_, e) => { - if (e.tool === "Bash") ran.push(String(e.command)); - return { result: { - text: "ok", - isError: false - } }; - }); - await $.session.start({ - cwd: ROOT, - surface: "terminal", - isInteractive: true - }); - await clock.settle(); - return { - clock, - estimates, - ran, - statuses - }; -} -const bq = (bytes, display, maxBytes = bytes) => ({ - success: true, - supported: true, - adapter: "bigquery", - bytes, - maxBytes, - display -}); -const OVER = bq(20 * GIB, "20.0 GiB"); -const UNDER = bq(2 * GIB, "2.0 GiB"); -const bash = (command) => ({ - tool: "Bash", - command -}); -(0,__vite_ssr_import_0__.test)("a model over the limit is refused with its estimate, and the command never runs", async ($, on) => { - const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } }); - const result = await $.tool.call(bash("dbt run --select orders")); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["orders"]); - (0,__vite_ssr_import_0__.expect)(ran).toEqual([]); - (0,__vite_ssr_import_0__.expect)(result.deny).toBe("≈ 20.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again."); -}); -(0,__vite_ssr_import_0__.test)("a model under the limit runs, with the estimate in a line under the row", async ($, on) => { - const { clock, ran } = await start($, on, { answers: { orders: UNDER } }); - const result = await $.tool.call(bash("dbt build -s orders")); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt build -s orders"]); - (0,__vite_ssr_import_0__.expect)(result.context).toEqual(["cost · orders would scan 2.0 GiB"]); -}); -(0,__vite_ssr_import_0__.test)("dbt show --inline is estimated from its SQL", async ($, on) => { - const { clock, estimates } = await start($, on, { answers: { "select * from big": OVER } }); - const result = await $.tool.call(bash(`dbt show --inline "select * from big"`)); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["select * from big"]); - (0,__vite_ssr_import_0__.expect)(result.deny).toContain("20.0 GiB"); -}); -(0,__vite_ssr_import_0__.test)("/allow-scan lets the next held command through once, then the one after is held again", async ($, on) => { - const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); - const allowed = await $.command.run({ - command: "allow-scan", - args: "" - }); - (0,__vite_ssr_import_0__.expect)(allowed.text).toContain("runs once"); - const through = await $.tool.call(bash("dbt run -s orders")); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(through.deny).toBeUndefined(); - (0,__vite_ssr_import_0__.expect)(through.context).toEqual(["cost · orders would scan 20.0 GiB, over the 10.0 GiB limit: allowed once"]); - (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders"]); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); - (0,__vite_ssr_import_0__.expect)(estimates).toHaveLength(3); -}); -(0,__vite_ssr_import_0__.test)("a selection that is not one plain model passes, saying there is no estimate, and asks nothing", async ($, on) => { - const { clock, estimates, ran } = await start($, on); - for (const [command, why] of [ - ["dbt run", "no model named"], - ["dbt build -s +orders", "graph, tag, path or package selector"], - ["dbt run -s tag:nightly", "graph, tag, path or package selector"], - ["dbt run -s a b", "several selectors"] - ]) { - const result = await $.tool.call(bash(command)); - (0,__vite_ssr_import_0__.expect)(result.deny).toBeUndefined(); - (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain("cost · no estimate for this selection"); - (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain(why); - }; - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual([]); - (0,__vite_ssr_import_0__.expect)(ran).toHaveLength(4); -}); -(0,__vite_ssr_import_0__.test)("commands that scan nothing are not looked at", async ($, on) => { - const { clock, estimates, ran } = await start($, on); - for (const command of [ - "dbt test -s orders", - "dbt compile -s orders", - "ls", - "git status" - ]) await $.tool.call(bash(command)); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual([]); - (0,__vite_ssr_import_0__.expect)(ran).toHaveLength(4); -}); -(0,__vite_ssr_import_0__.test)("another warehouse is told once, never held, and not asked again", async ($, on) => { - const { clock, estimates, ran } = await start($, on, { fallback: { - success: true, - supported: false, - adapter: "snowflake" - } }); - const first = await $.tool.call(bash("dbt run -s orders")); - const second = await $.tool.call(bash("dbt run -s customers")); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(first.deny).toBeUndefined(); - (0,__vite_ssr_import_0__.expect)(first.context).toEqual(["cost · no estimate on snowflake: only BigQuery has a dry run"]); - (0,__vite_ssr_import_0__.expect)(second.deny).toBeUndefined(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["orders"]); - (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders", "dbt run -s customers"]); -}); -(0,__vite_ssr_import_0__.test)("an altimate-code without the tool shows one line saying what is needed, and the command runs", async ($, on) => { - const { clock, ran } = await start($, on, { answers: { orders: "unknown-tool" } }); - const result = await $.tool.call(bash("dbt run -s orders")); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders"]); - (0,__vite_ssr_import_0__.expect)(result.context).toHaveLength(1); - (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain("needs a newer altimate-code"); -}); -(0,__vite_ssr_import_0__.test)("a dry run that failed passes the command with the reason", async ($, on) => { - const { clock, ran } = await start($, on, { answers: { orders: { - success: false, - error: "Access Denied: BigQuery job" - } } }); - const result = await $.tool.call(bash("dbt run -s orders")); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders"]); - (0,__vite_ssr_import_0__.expect)(result.context).toEqual(["cost · no estimate for orders: Access Denied: BigQuery job"]); -}); -(0,__vite_ssr_import_0__.test)("/scan-cost estimates a model on demand and says how it stands against the limit", async ($, on) => { - const { clock, estimates, ran } = await start($, on, { answers: { - orders: OVER, - customers: UNDER - } }); - (0,__vite_ssr_import_0__.expect)((await $.command.run({ - command: "scan-cost", - args: "orders" - })).text).toBe("orders would scan 20.0 GiB, over the 10.0 GiB limit: a dbt run of it is held until /allow-scan."); - (0,__vite_ssr_import_0__.expect)((await $.command.run({ - command: "scan-cost", - args: "customers" - })).text).toBe("customers would scan 2.0 GiB, within the 10.0 GiB limit."); - (0,__vite_ssr_import_0__.expect)((await $.command.run({ - command: "scan-cost", - args: "" - })).text).toContain("Last estimate: customers"); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["orders", "customers"]); - (0,__vite_ssr_import_0__.expect)(ran).toEqual([]); -}); -(0,__vite_ssr_import_0__.test)("a command naming two models over the limit is held whole, and one /allow-scan lets all of it through once", async ($, on) => { - const { clock, ran } = await start($, on, { answers: { - orders: OVER, - customers: bq(30 * GIB, "30.0 GiB") - } }); - const command = "dbt run -s orders && dbt run -s customers"; - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash(command))).deny).toContain("30.0 GiB"); - await $.command.run({ - command: "allow-scan", - args: "" - }); - const through = await $.tool.call(bash(command)); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(through.deny).toBeUndefined(); - (0,__vite_ssr_import_0__.expect)(through.context).toEqual(["cost · orders would scan 20.0 GiB, over the 10.0 GiB limit: allowed once", "cost · customers would scan 30.0 GiB, over the 10.0 GiB limit: allowed once"]); - (0,__vite_ssr_import_0__.expect)(ran).toEqual([command]); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash(command))).deny).toBeDefined(); -}); -(0,__vite_ssr_import_0__.test)("/allow-scan with nothing held allows nothing", async ($, on) => { - const { clock } = await start($, on, { answers: { orders: OVER } }); - (0,__vite_ssr_import_0__.expect)((await $.command.run({ - command: "allow-scan", - args: "" - })).text).toContain("Nothing is held"); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); - await clock.settle(); -}); -(0,__vite_ssr_import_0__.test)("the allowance is for the command that was held: another over-limit command is held, and the allowance is gone", async ($, on) => { - const { clock, ran } = await start($, on, { answers: { - orders: OVER, - customers: OVER - } }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); - await $.command.run({ - command: "allow-scan", - args: "" - }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s customers"))).deny).toBeDefined(); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(ran).toEqual([]); -}); -(0,__vite_ssr_import_0__.test)("an estimate whose rounded size is within the limit but whose upper bound is over it is held", async ($, on) => { - const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, "10.0 GiB", 10 * GIB + 52 * 1024 ** 2) } }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBe("up to 10.1 GiB (≈ 10.0 GiB estimated) would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again."); - await clock.settle(); -}); -(0,__vite_ssr_import_0__.test)("an upper bound that formats the same as the limit is not reported as equal to it", async ($, on) => { - const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, "10.0 GiB", 10 * GIB + 30 * 1024 ** 2) } }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBe("just over 10.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again."); - await clock.settle(); -}); -(0,__vite_ssr_import_0__.test)("a warehouse found to have no dry run ends a hold from before, and its allowance", async ($, on) => { - const answers = { orders: OVER }; - const { clock, ran, statuses } = await start($, on, { answers }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); - await $.command.run({ - command: "allow-scan", - args: "" - }); - answers.orders = { - success: true, - supported: false, - adapter: "snowflake" - }; - await $.tool.call(bash("dbt run -s orders")); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(ran).toEqual(["dbt run -s orders"]); - (0,__vite_ssr_import_0__.expect)(statuses.at(-1) ?? "").not.toContain("held"); - (0,__vite_ssr_import_0__.expect)((await $.command.run({ - command: "allow-scan", - args: "" - })).text).toContain("Nothing is held"); -}); -(0,__vite_ssr_import_0__.test)("a scan just over the limit reads as over it, not as equal to it", async ($, on) => { - const { clock } = await start($, on, { answers: { orders: bq(10 * GIB + 1024 ** 2, "10.0 GiB") } }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBe("just over 10.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again."); - await clock.settle(); -}); -(0,__vite_ssr_import_0__.test)("a command that sets its own target, defer state, vars or project is not estimated", async ($, on) => { - const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } }); - const commands = [ - "dbt run -s orders --target prod", - "dbt run -s orders --defer --state prod-run", - `dbt run -s orders --vars '{a: 1}'`, - "dbt run -s orders --project-dir other", - "DBT_PROFILES_DIR=ci dbt run -s orders", - "cd other && dbt run -s orders", - " cd other && dbt run -s orders", - "export DBT_TARGET=prod; dbt run -s orders", - "uv run --directory other dbt run -s orders", - "dbt run -s orders --'vars' x", - "dbt run -s orders --full-refresh", - "dbt run -s orders --full-\\\nrefresh", - "if true; then cd other; fi; dbt run -s orders", - "dbt --profiles-dir ci run -s orders", - "FOO=1 dbt run -s orders", - "dbt run -s orders --threads $(printf '4 --target prod')", - "dbt run -s orders --threads `echo 4 --vars x`", - "dbt run -s orders 2>&${DBT_TARGET:=1}", - "dbt --log-path \"${DBT_TARGET:=prod}\" deps; dbt run -s orders" - ]; - for (const command of commands) { - const result = await $.tool.call(bash(command)); - (0,__vite_ssr_import_0__.expect)(result.deny).toBeUndefined(); - (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain("it sets its own target, defer state, vars, project or refresh mode"); - }; - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual([]); - (0,__vite_ssr_import_0__.expect)(ran).toEqual(commands); -}); -(0,__vite_ssr_import_0__.test)("dbt show --inline with its SQL on the next line after a backslash is estimated", async ($, on) => { - const { clock, estimates } = await start($, on, { answers: { "select * from big": OVER } }); - const result = await $.tool.call(bash(`dbt show --inline \\\n 'select * from big'`)); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["select * from big"]); - (0,__vite_ssr_import_0__.expect)(result.deny).toContain("20.0 GiB"); -}); -(0,__vite_ssr_import_0__.test)("letting a later command through clears the hold from the status line", async ($, on) => { - const { clock, statuses } = await start($, on, { answers: { - orders: OVER, - customers: UNDER - } }); - await $.tool.call(bash("dbt run -s orders")); - await $.tool.call(bash("dbt run -s customers")); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(statuses.filter(Boolean).at(-1)).not.toContain("held"); -}); -(0,__vite_ssr_import_0__.test)("a variant of the held command that is not estimated leaves the hold in place", async ($, on) => { - const { clock, ran } = await start($, on, { answers: { orders: OVER } }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); - await $.tool.call(bash("dbt run -s +orders")); - await $.tool.call(bash("dbt run -s orders --full-refresh")); - await clock.settle(); - await $.command.run({ - command: "allow-scan", - args: "" - }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeUndefined(); - (0,__vite_ssr_import_0__.expect)(ran.at(-1)).toBe("dbt run -s orders"); -}); -(0,__vite_ssr_import_0__.test)("a repeated --inline is estimated from the last one, as dbt reads it", async ($, on) => { - const { clock, estimates } = await start($, on, { answers: { "select * from big": OVER } }); - const result = await $.tool.call(bash(`dbt show --inline 'select 1' --inline 'select * from big'`)); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual(["select * from big"]); - (0,__vite_ssr_import_0__.expect)(result.deny).toContain("20.0 GiB"); -}); -(0,__vite_ssr_import_0__.test)("the lines under a command are the latest estimate of it, never an earlier one", async ($, on) => { - const answers = { orders: UNDER }; - const { clock } = await start($, on, { answers }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).context).toEqual(["cost · orders would scan 2.0 GiB"]); - answers.orders = bq(3 * GIB, "3.0 GiB"); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).context).toEqual(["cost · orders would scan 3.0 GiB"]); - await clock.settle(); -}); -(0,__vite_ssr_import_0__.test)("/allow-scan allows only the hold it read: a hold replaced meanwhile is not allowed", async ($, on) => { - const { clock, ran } = await start($, on, { answers: { - orders: OVER, - customers: OVER - } }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s orders"))).deny).toBeDefined(); - const allowing = $.command.run({ - command: "allow-scan", - args: "" - }); - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s customers"))).deny).toBeDefined(); - await allowing; - await clock.settle(); - // Whichever order the two steps took, customers (the later hold) is not allowed by a read of orders. - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash("dbt run -s customers"))).deny).toBeDefined(); - (0,__vite_ssr_import_0__.expect)(ran).toEqual([]); -}); -(0,__vite_ssr_import_0__.test)("a non-dbt command in between neither clears the hold nor spends the allowance", async ($, on) => { - const { clock, ran } = await start($, on, { answers: { orders: OVER } }); - await $.tool.call(bash("dbt run -s orders")); - await $.command.run({ - command: "allow-scan", - args: "" - }); - await $.tool.call(bash("ls")); - const through = await $.tool.call(bash("dbt run -s orders")); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(through.deny).toBeUndefined(); - (0,__vite_ssr_import_0__.expect)(ran).toEqual(["ls", "dbt run -s orders"]); -}); -(0,__vite_ssr_import_0__.test)("inlineSql reads the query as the shell would", () => { - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline "select 'a' as x"`)).toBe(`select 'a' as x`); - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline='select 1'`)).toBe("select 1"); - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline select\\ 1 --limit 5`)).toBe("select 1"); - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline \\\n 'select 1'`)).toBe("select 1"); - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)("dbt show -s orders")).toBeNull(); - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline 'select 1' --inline='select 2'`)).toBe("select 2"); - // The value of --inline is the query, even when it looks like an option. - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.inlineSql)(`dbt show --inline '--inline=comment select 1'`)).toBe("--inline=comment select 1"); -}); -(0,__vite_ssr_import_0__.test)("formatBytes writes the units the dry run does", () => { - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.formatBytes)(512)).toBe("512.0 Bytes"); - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.formatBytes)(1536)).toBe("1.5 KiB"); - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.formatBytes)(10 * GIB)).toBe("10.0 GiB"); - (0,__vite_ssr_import_0__.expect)((0,__vite_ssr_import_1__.formatBytes)(1024 ** 5)).toBe("1.0 PiB"); -}); -(0,__vite_ssr_import_0__.test)("what leaves the query alone is still estimated: other dbt calls before it, thread and limit flags, a launcher", async ($, on) => { - const { clock, estimates } = await start($, on, { answers: { - orders: UNDER, - "select 1": UNDER - } }); - for (const command of [ - "dbt deps && dbt run -s orders --threads 4", - "uv run dbt build --select orders --fail-fast", - `dbt show --inline "select 1" --limit 5` - ]) { - (0,__vite_ssr_import_0__.expect)((await $.tool.call(bash(command))).context[0]).toContain("would scan 2.0 GiB"); - }; - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual([ - "orders", - "orders", - "select 1" - ]); -}); -(0,__vite_ssr_import_0__.test)("a very long run of blank lines before the command costs no noticeable time", async ($, on) => { - const { clock } = await start($, on, { answers: { orders: UNDER } }); - const began = Date.now(); - await $.tool.call(bash(`${"\n".repeat(64e3)}dbt run -s orders`)); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(Date.now() - began).toBeLessThan(3e3); -}); -(0,__vite_ssr_import_0__.test)("a line with a great many dbt calls is not read call by call", async ($, on) => { - const { clock, estimates } = await start($, on, { answers: { orders: UNDER } }); - const began = Date.now(); - const result = await $.tool.call(bash("dbt run -s orders;".repeat(4e3))); - await clock.settle(); - (0,__vite_ssr_import_0__.expect)(estimates).toEqual([]); - (0,__vite_ssr_import_0__.expect)(result.context.length).toBe(6); - (0,__vite_ssr_import_0__.expect)(result.context[0]).toContain("cost · no estimate"); - (0,__vite_ssr_import_0__.expect)(result.context[5]).toBe("cost · 3995 more notes not shown"); - (0,__vite_ssr_import_0__.expect)(Date.now() - began).toBeLessThan(3e3); -}); -//# sourceMappingSource=vite-generated -//# sourceMappingURL=data:application/json;base64,{"version":3,"mappings":"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","names":[],"ignoreList":[],"sources":["cost.test.tsx"],"sourcesContent":["import { expect, mock, test } from 'claude-code/testing'\n\nimport { formatBytes, inlineSql } from './cost'\n\nconst ROOT = '/repo'\nconst GIB = 1024 ** 3\n\ntype Options = {\n  /** What dbt_cost_estimate answers for a model or SQL, by model name or the SQL text. */\n  answers?: Record<string, Record<string, unknown> | 'unknown-tool'>\n  /** The adapter's answer for everything else. */\n  fallback?: Record<string, unknown>\n}\n\n/** The session beneath the plugin, a CLI whose dbt_cost_estimate is scripted, and a Bash tool that records what ran. */\nasync function start($: any, on: any, options: Options = {}) {\n  const clock = mock.clock(on)\n  const estimates: string[] = []\n  const ran: string[] = []\n  const statuses: (string | undefined)[] = []\n  on('command.register', (_: unknown, e: { name: string }) => ({ value: { command: e.name } }))\n  on('turn.start', (_: unknown, e: { turnId: string }) => ({ turnId: e.turnId }))\n  on('session.end', () => ({ sessionId: 'test' }))\n  on('turn.complete', (_: unknown, e: { answer: string }) => ({ text: e.answer }))\n  on('session.start', (_: unknown, e: { cwd: string }) => ({ cwd: e.cwd }))\n  on('session.root', () => ({ value: ROOT }))\n  on('ui.log', () => ({ value: undefined }))\n  on('ui.status', (_: unknown, e: { text?: string }) => {\n    statuses.push(e.text)\n    return { value: undefined }\n  })\n  on('ui.render', ($$: any, e: any) => {\n    const { Box } = $$.ui.resolve(e)\n    return <Box key=\"engine\" />\n  })\n  on('fs.exists', () => ({ value: false }))\n  on('process.run', (_: unknown, e: { argv: readonly string[] }) => {\n    const [, command, , tool] = e.argv\n    if (command !== 'tool') return { value: { exitCode: 1, stdout: '', stderr: 'not this test' } }\n    expect(tool).toBe('dbt_cost_estimate')\n    // The adapter starts the project's dbt: the call must carry write permission.\n    expect(e.argv).toContain('--allow-write')\n    const args = JSON.parse(String(e.argv[e.argv.indexOf('--args') + 1] ?? '{}'))\n    const key = String(args.model ?? args.sql)\n    estimates.push(key)\n    const answer = options.answers?.[key] ?? options.fallback\n    if (answer === 'unknown-tool') {\n      return { value: { exitCode: 1, stdout: JSON.stringify({ status: 'error', output: `Unknown tool: ${tool}. Run \\`altimate-code tool list\\` to see the available tools.`, metadata: {} }), stderr: '' } }\n    }\n    return { value: { exitCode: 0, stdout: JSON.stringify({ status: 'ok', output: '', metadata: answer ?? { success: false, error: 'no answer scripted' } }), stderr: '' } }\n  })\n  // The Bash tool itself, beneath the plugin.\n  on('tool.call', (_: unknown, e: { tool: string; command?: string }) => {\n    if (e.tool === 'Bash') ran.push(String(e.command))\n    return { result: { text: 'ok', isError: false } }\n  })\n  await $.session.start({ cwd: ROOT, surface: 'terminal', isInteractive: true })\n  await clock.settle()\n  return { clock, estimates, ran, statuses }\n}\n\nconst bq = (bytes: number, display: string, maxBytes = bytes) => ({ success: true, supported: true, adapter: 'bigquery', bytes, maxBytes, display })\nconst OVER = bq(20 * GIB, '20.0 GiB')\nconst UNDER = bq(2 * GIB, '2.0 GiB')\n\nconst bash = (command: string) => ({ tool: 'Bash' as const, command })\n\ntest('a model over the limit is refused with its estimate, and the command never runs', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } })\n  const result: any = await $.tool.call(bash('dbt run --select orders'))\n  await clock.settle()\n\n  expect(estimates).toEqual(['orders'])\n  expect(ran).toEqual([])\n  expect(result.deny).toBe('≈ 20.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.')\n})\n\ntest('a model under the limit runs, with the estimate in a line under the row', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: UNDER } })\n  const result: any = await $.tool.call(bash('dbt build -s orders'))\n  await clock.settle()\n\n  expect(ran).toEqual(['dbt build -s orders'])\n  expect(result.context).toEqual(['cost · orders would scan 2.0 GiB'])\n})\n\ntest('dbt show --inline is estimated from its SQL', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { 'select * from big': OVER } })\n  const result: any = await $.tool.call(bash(`dbt show --inline \"select * from big\"`))\n  await clock.settle()\n\n  expect(estimates).toEqual(['select * from big'])\n  expect(result.deny).toContain('20.0 GiB')\n})\n\ntest('/allow-scan lets the next held command through once, then the one after is held again', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } })\n  expect((await $.tool.call(bash('dbt run -s orders')) as any).deny).toBeDefined()\n\n  const allowed = await $.command.run({ command: 'allow-scan', args: '' } as any)\n  expect(allowed.text).toContain('runs once')\n  const through: any = await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n  expect(through.deny).toBeUndefined()\n  expect(through.context).toEqual(['cost · orders would scan 20.0 GiB, over the 10.0 GiB limit: allowed once'])\n  expect(ran).toEqual(['dbt run -s orders'])\n\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  expect(estimates).toHaveLength(3)\n})\n\ntest('a selection that is not one plain model passes, saying there is no estimate, and asks nothing', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on)\n  for (const [command, why] of [\n    ['dbt run', 'no model named'],\n    ['dbt build -s +orders', 'graph, tag, path or package selector'],\n    ['dbt run -s tag:nightly', 'graph, tag, path or package selector'],\n    ['dbt run -s a b', 'several selectors'],\n  ] as const) {\n    const result: any = await $.tool.call(bash(command))\n    expect(result.deny).toBeUndefined()\n    expect(result.context[0]).toContain('cost · no estimate for this selection')\n    expect(result.context[0]).toContain(why)\n  }\n  await clock.settle()\n  expect(estimates).toEqual([])\n  expect(ran).toHaveLength(4)\n})\n\ntest('commands that scan nothing are not looked at', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on)\n  for (const command of ['dbt test -s orders', 'dbt compile -s orders', 'ls', 'git status']) await $.tool.call(bash(command))\n  await clock.settle()\n  expect(estimates).toEqual([])\n  expect(ran).toHaveLength(4)\n})\n\ntest('another warehouse is told once, never held, and not asked again', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { fallback: { success: true, supported: false, adapter: 'snowflake' } })\n  const first: any = await $.tool.call(bash('dbt run -s orders'))\n  const second: any = await $.tool.call(bash('dbt run -s customers'))\n  await clock.settle()\n\n  expect(first.deny).toBeUndefined()\n  expect(first.context).toEqual(['cost · no estimate on snowflake: only BigQuery has a dry run'])\n  expect(second.deny).toBeUndefined()\n  expect(estimates).toEqual(['orders'])\n  expect(ran).toEqual(['dbt run -s orders', 'dbt run -s customers'])\n})\n\ntest('an altimate-code without the tool shows one line saying what is needed, and the command runs', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: 'unknown-tool' } })\n  const result: any = await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n\n  expect(ran).toEqual(['dbt run -s orders'])\n  expect(result.context).toHaveLength(1)\n  expect(result.context[0]).toContain('needs a newer altimate-code')\n})\n\ntest('a dry run that failed passes the command with the reason', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: { success: false, error: 'Access Denied: BigQuery job' } } })\n  const result: any = await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n\n  expect(ran).toEqual(['dbt run -s orders'])\n  expect(result.context).toEqual(['cost · no estimate for orders: Access Denied: BigQuery job'])\n})\n\ntest('/scan-cost estimates a model on demand and says how it stands against the limit', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER, customers: UNDER } })\n  expect((await $.command.run({ command: 'scan-cost', args: 'orders' } as any)).text).toBe(\n    'orders would scan 20.0 GiB, over the 10.0 GiB limit: a dbt run of it is held until /allow-scan.',\n  )\n  expect((await $.command.run({ command: 'scan-cost', args: 'customers' } as any)).text).toBe('customers would scan 2.0 GiB, within the 10.0 GiB limit.')\n  expect((await $.command.run({ command: 'scan-cost', args: '' } as any)).text).toContain('Last estimate: customers')\n  await clock.settle()\n  expect(estimates).toEqual(['orders', 'customers'])\n  expect(ran).toEqual([])\n})\n\ntest('a command naming two models over the limit is held whole, and one /allow-scan lets all of it through once', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER, customers: bq(30 * GIB, '30.0 GiB') } })\n  const command = 'dbt run -s orders && dbt run -s customers'\n  expect(((await $.tool.call(bash(command))) as any).deny).toContain('30.0 GiB')\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n  const through: any = await $.tool.call(bash(command))\n  await clock.settle()\n\n  expect(through.deny).toBeUndefined()\n  expect(through.context).toEqual([\n    'cost · orders would scan 20.0 GiB, over the 10.0 GiB limit: allowed once',\n    'cost · customers would scan 30.0 GiB, over the 10.0 GiB limit: allowed once',\n  ])\n  expect(ran).toEqual([command])\n  expect(((await $.tool.call(bash(command))) as any).deny).toBeDefined()\n})\n\ntest('/allow-scan with nothing held allows nothing', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: OVER } })\n  expect((await $.command.run({ command: 'allow-scan', args: '' } as any)).text).toContain('Nothing is held')\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await clock.settle()\n})\n\ntest('the allowance is for the command that was held: another over-limit command is held, and the allowance is gone', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER, customers: OVER } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n\n  expect(((await $.tool.call(bash('dbt run -s customers'))) as any).deny).toBeDefined()\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await clock.settle()\n  expect(ran).toEqual([])\n})\n\ntest('an estimate whose rounded size is within the limit but whose upper bound is over it is held', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, '10.0 GiB', 10 * GIB + 52 * 1024 ** 2) } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBe('up to 10.1 GiB (≈ 10.0 GiB estimated) would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.')\n  await clock.settle()\n})\n\ntest('an upper bound that formats the same as the limit is not reported as equal to it', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: bq(10 * GIB, '10.0 GiB', 10 * GIB + 30 * 1024 ** 2) } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBe('just over 10.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.')\n  await clock.settle()\n})\n\ntest('a warehouse found to have no dry run ends a hold from before, and its allowance', async ($, on) => {\n  const answers: Record<string, any> = { orders: OVER }\n  const { clock, ran, statuses } = await start($, on, { answers })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n  answers.orders = { success: true, supported: false, adapter: 'snowflake' }\n  await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n  expect(ran).toEqual(['dbt run -s orders'])\n  expect(statuses.at(-1) ?? '').not.toContain('held')\n  expect((await $.command.run({ command: 'allow-scan', args: '' } as any)).text).toContain('Nothing is held')\n})\n\ntest('a scan just over the limit reads as over it, not as equal to it', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: bq(10 * GIB + 1024 ** 2, '10.0 GiB') } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBe('just over 10.0 GiB would be scanned, over the 10.0 GiB limit. Narrow the query, or ask the user to run /allow-scan and then run the same command again.')\n  await clock.settle()\n})\n\ntest('a command that sets its own target, defer state, vars or project is not estimated', async ($, on) => {\n  const { clock, estimates, ran } = await start($, on, { answers: { orders: OVER } })\n  const commands = [\n    'dbt run -s orders --target prod',\n    'dbt run -s orders --defer --state prod-run',\n    `dbt run -s orders --vars '{a: 1}'`,\n    'dbt run -s orders --project-dir other',\n    'DBT_PROFILES_DIR=ci dbt run -s orders',\n    'cd other && dbt run -s orders',\n    ' cd other && dbt run -s orders',\n    'export DBT_TARGET=prod; dbt run -s orders',\n    'uv run --directory other dbt run -s orders',\n    \"dbt run -s orders --'vars' x\",\n    'dbt run -s orders --full-refresh',\n    'dbt run -s orders --full-\\\\\\nrefresh',\n    'if true; then cd other; fi; dbt run -s orders',\n    'dbt --profiles-dir ci run -s orders',\n    'FOO=1 dbt run -s orders',\n    \"dbt run -s orders --threads $(printf '4 --target prod')\",\n    'dbt run -s orders --threads `echo 4 --vars x`',\n    'dbt run -s orders 2>&${DBT_TARGET:=1}',\n    'dbt --log-path \"${DBT_TARGET:=prod}\" deps; dbt run -s orders',\n  ]\n  for (const command of commands) {\n    const result: any = await $.tool.call(bash(command))\n    expect(result.deny).toBeUndefined()\n    expect(result.context[0]).toContain('it sets its own target, defer state, vars, project or refresh mode')\n  }\n  await clock.settle()\n  expect(estimates).toEqual([])\n  expect(ran).toEqual(commands)\n})\n\ntest('dbt show --inline with its SQL on the next line after a backslash is estimated', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { 'select * from big': OVER } })\n  const result: any = await $.tool.call(bash(`dbt show --inline \\\\\\n  'select * from big'`))\n  await clock.settle()\n  expect(estimates).toEqual(['select * from big'])\n  expect(result.deny).toContain('20.0 GiB')\n})\n\ntest('letting a later command through clears the hold from the status line', async ($, on) => {\n  const { clock, statuses } = await start($, on, { answers: { orders: OVER, customers: UNDER } })\n  await $.tool.call(bash('dbt run -s orders'))\n  await $.tool.call(bash('dbt run -s customers'))\n  await clock.settle()\n  expect(statuses.filter(Boolean).at(-1)).not.toContain('held')\n})\n\ntest('a variant of the held command that is not estimated leaves the hold in place', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  await $.tool.call(bash('dbt run -s +orders'))\n  await $.tool.call(bash('dbt run -s orders --full-refresh'))\n  await clock.settle()\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeUndefined()\n  expect(ran.at(-1)).toBe('dbt run -s orders')\n})\n\ntest('a repeated --inline is estimated from the last one, as dbt reads it', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { 'select * from big': OVER } })\n  const result: any = await $.tool.call(bash(`dbt show --inline 'select 1' --inline 'select * from big'`))\n  await clock.settle()\n  expect(estimates).toEqual(['select * from big'])\n  expect(result.deny).toContain('20.0 GiB')\n})\n\ntest('the lines under a command are the latest estimate of it, never an earlier one', async ($, on) => {\n  const answers: Record<string, any> = { orders: UNDER }\n  const { clock } = await start($, on, { answers })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).context).toEqual(['cost · orders would scan 2.0 GiB'])\n  answers.orders = bq(3 * GIB, '3.0 GiB')\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).context).toEqual(['cost · orders would scan 3.0 GiB'])\n  await clock.settle()\n})\n\ntest('/allow-scan allows only the hold it read: a hold replaced meanwhile is not allowed', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER, customers: OVER } })\n  expect(((await $.tool.call(bash('dbt run -s orders'))) as any).deny).toBeDefined()\n  const allowing = $.command.run({ command: 'allow-scan', args: '' } as any)\n  expect(((await $.tool.call(bash('dbt run -s customers'))) as any).deny).toBeDefined()\n  await allowing\n  await clock.settle()\n  // Whichever order the two steps took, customers (the later hold) is not allowed by a read of orders.\n  expect(((await $.tool.call(bash('dbt run -s customers'))) as any).deny).toBeDefined()\n  expect(ran).toEqual([])\n})\n\ntest('a non-dbt command in between neither clears the hold nor spends the allowance', async ($, on) => {\n  const { clock, ran } = await start($, on, { answers: { orders: OVER } })\n  await $.tool.call(bash('dbt run -s orders'))\n  await $.command.run({ command: 'allow-scan', args: '' } as any)\n  await $.tool.call(bash('ls'))\n  const through: any = await $.tool.call(bash('dbt run -s orders'))\n  await clock.settle()\n  expect(through.deny).toBeUndefined()\n  expect(ran).toEqual(['ls', 'dbt run -s orders'])\n})\n\ntest('inlineSql reads the query as the shell would', () => {\n  expect(inlineSql(`dbt show --inline \"select 'a' as x\"`)).toBe(`select 'a' as x`)\n  expect(inlineSql(`dbt show --inline='select 1'`)).toBe('select 1')\n  expect(inlineSql(`dbt show --inline select\\\\ 1 --limit 5`)).toBe('select 1')\n  expect(inlineSql(`dbt show --inline \\\\\\n 'select 1'`)).toBe('select 1')\n  expect(inlineSql('dbt show -s orders')).toBeNull()\n  expect(inlineSql(`dbt show --inline 'select 1' --inline='select 2'`)).toBe('select 2')\n  // The value of --inline is the query, even when it looks like an option.\n  expect(inlineSql(`dbt show --inline '--inline=comment select 1'`)).toBe('--inline=comment select 1')\n})\n\ntest('formatBytes writes the units the dry run does', () => {\n  expect(formatBytes(512)).toBe('512.0 Bytes')\n  expect(formatBytes(1536)).toBe('1.5 KiB')\n  expect(formatBytes(10 * GIB)).toBe('10.0 GiB')\n  expect(formatBytes(1024 ** 5)).toBe('1.0 PiB')\n})\n\ntest('what leaves the query alone is still estimated: other dbt calls before it, thread and limit flags, a launcher', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { orders: UNDER, 'select 1': UNDER } })\n  for (const command of ['dbt deps && dbt run -s orders --threads 4', 'uv run dbt build --select orders --fail-fast', `dbt show --inline \"select 1\" --limit 5`]) {\n    expect(((await $.tool.call(bash(command))) as any).context[0]).toContain('would scan 2.0 GiB')\n  }\n  await clock.settle()\n  expect(estimates).toEqual(['orders', 'orders', 'select 1'])\n})\n\ntest('a very long run of blank lines before the command costs no noticeable time', async ($, on) => {\n  const { clock } = await start($, on, { answers: { orders: UNDER } })\n  const began = Date.now()\n  await $.tool.call(bash(`${'\\n'.repeat(64000)}dbt run -s orders`))\n  await clock.settle()\n  expect(Date.now() - began).toBeLessThan(3000)\n})\n\ntest('a line with a great many dbt calls is not read call by call', async ($, on) => {\n  const { clock, estimates } = await start($, on, { answers: { orders: UNDER } })\n  const began = Date.now()\n  const result: any = await $.tool.call(bash('dbt run -s orders;'.repeat(4000)))\n  await clock.settle()\n  expect(estimates).toEqual([])\n  expect(result.context.length).toBe(6)\n  expect(result.context[0]).toContain('cost · no estimate')\n  expect(result.context[5]).toBe('cost · 3995 more notes not shown')\n  expect(Date.now() - began).toBeLessThan(3000)\n})\n"],"file":"/hooks/features/cost.test.tsx"} - -//# vitestCache=W3siZmlsZSI6IjEiLCJpZCI6IjEiLCJpbXBvcnRzIjoiMiIsIm1hcHBpbmdzIjpmYWxzZSwiZGVwcyI6IjMiLCJkeW5hbWljRGVwcyI6IjQiLCJzdGF0aWNNb2NrcyI6bnVsbCwiaGFzQ292ZXJhZ2VEYXRhIjpmYWxzZX0sIi9Vc2Vycy9oYXJpc2gvLnF1aWtpbS93b3Jrc3BhY2VzL2FsdGltYXRlLWNsYXVkZS1wbHVnaW4vZmVhdC9kYnQtY29zdC1lc3RpbWF0ZS10b29sL3BsdWdpbnMvYWx0aW1hdGUtY29kZS9ob29rcy9mZWF0dXJlcy9jb3N0LnRlc3QudHN4Iix7InVybHMiOiI1IiwiaWRzIjoiNiJ9LFsiNyIsIjgiLCI5Il0sW10sWyI3IiwiOCIsIjkiXSx7fSwiY2xhdWRlLWNvZGUvdGVzdGluZyIsIi9ob29rcy9mZWF0dXJlcy9jb3N0LnRzeCIsInJlYWN0L2pzeC1kZXYtcnVudGltZSJd \ No newline at end of file diff --git a/plugins/altimate-code/node_modules/.vitest-cache/CACHEDIR.TAG b/plugins/altimate-code/node_modules/.vitest-cache/CACHEDIR.TAG deleted file mode 100644 index 8c1ef4ce..00000000 --- a/plugins/altimate-code/node_modules/.vitest-cache/CACHEDIR.TAG +++ /dev/null @@ -1,3 +0,0 @@ -Signature: 8a477f597d28d172789f06886806bc55 -# This file is a cache directory tag created by Vitest. -# For information about cache directory tags see https://bford.info/cachedir/ diff --git a/plugins/altimate-code/node_modules/.vitest-cache/_metadata.json b/plugins/altimate-code/node_modules/.vitest-cache/_metadata.json deleted file mode 100644 index 9ee9061a..00000000 --- a/plugins/altimate-code/node_modules/.vitest-cache/_metadata.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "lockfileHash": "e3b0c442" -} \ No newline at end of file