@altimateai/altimate-code 0.8.6 → 0.8.9

package/CHANGELOG.md

@@ -5,6 +5,69 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.8.9] - 2026-06-19
+
+### Fixed
+
+- **The non-interactive `run` guard no longer mis-handles a blank env var.** A blank/whitespace `ALTIMATE_NON_INTERACTIVE=` is now treated as unset, so it can't silently reintroduce the headless `run` hang that #937 fixed. (#937 follow-up)
+- **Session transcript boolean query flags accept the common falsey strings.** `thinking`, `toolDetails`, and `assistantMetadata` now treat `false`/`0`/`no`/`off` (case-insensitive) as false, not just the literal `"false"`. (#941 follow-up)
+- **Writing an MCP server entry refuses to clobber an unparseable config** (detected via `parse()` with an error sink, not the error-tolerant `parseTree()`), and `updatedAt` is preserved through config normalization so the datamate reconnect signal survives. (#893 follow-up)
+- **dbt error bubbling strips the full ANSI escape family** (cursor/erase sequences from progress spinners), not just SGR color codes. (#933 follow-up)
+
+### Changed
+
+- **The headless `serve` startup upgrade check is jittered** (base + random, ~1–6s) so a fleet restarting together doesn't stampede the unauthenticated GitHub releases API in the same instant. (#940 follow-up)
+
+### Internal
+
+- **Diverged upstream constants are wrapped in `altimate_change` markers** (`DEFAULT_CHUNK_TIMEOUT`, the question-tool `output` field) so they survive upstream merges. (#844, #937)
+- **Added a v0.8.9 adversarial test suite** covering the shipping code and the review fixes under hostile input (question-tool env matrix, MCP config parse-guard, startup-upgrade fail-safety + jitter).
+
+## [0.8.8] - 2026-06-19
+
+### Added
+
+- **Windows now has a one-line PowerShell installer.** `irm https://www.altimate.sh/install.ps1 | iex` downloads the standalone binary from GitHub releases (AVX2-aware, with a baseline fallback), adds it to your user `PATH`, and supports `-Version`, `-NoPathUpdate`, and `-ForceBaseline`. `altimate upgrade` uses the same path on Windows. (#930)
+- **IDE-aware datamate transport, MCP enabled-state persistence, and a `/mcps` command.** The active IDE's `mcp.json` datamate entry/URL is mirrored into `altimate-code.json` and reconnected when it changes; enabled/disabled state for MCP servers now persists to disk; `/mcps` lists and toggles servers; project `mcp.json` files are discovered recursively (project-scoped servers are discovered disabled, never auto-connected). (#893)
+- **Session transcript REST endpoint for the datamates extension.** `GET /session/:id/transcript` returns the full conversation as formatted Markdown, with `thinking`, `toolDetails`, and `assistantMetadata` query flags. (#941)
+
+### Changed
+
+- **Headless `serve` now checks for and applies updates on startup.** When `autoupdate` is unset (the default) and a supported install method is present, `serve` performs a one-shot, best-effort self-upgrade shortly after start. It never restarts the running process and can never crash `serve` (errors are swallowed). Opt out with `autoupdate: false` or `"notify"` in config, or `OPENCODE_DISABLE_AUTOUPDATE=1`. (#940)
+- **The per-chunk streaming watchdog timeout was raised from 2 minutes to 5 minutes** so slow warehouse/LLM streams are not aborted prematurely. (#844)
+
+### Fixed
+
+- **`dbt show`/`compile` failures now surface the real dbt error** instead of a generic "Could not parse", with inline SQL redacted from the message so secrets/PII don't leak into logs. (#933)
+- **The question tool no longer hangs in non-interactive contexts.** `altimate run` is detected as headless and returns "Unanswered" (letting the agent decide) rather than blocking forever; `ALTIMATE_AUTO_ANSWER=first|last|<label>` can pre-answer. (#937)
+- **Windows release archives are verified by checksum in both installers** before extraction, and latest-version resolution is more resilient to transient fetch failures. (#942, #946)
+
+### Internal
+
+- **`serve` logs the trace directory on startup** so operators can find session traces. (#929)
+- **Added a release-validation regression suite** covering the merged PRs. (#952)
+
+## [0.8.7] - 2026-06-10
+
+### Added
+
+- **Verified query optimization — `altimate_core_rewrite` now proves a rewrite is safe before suggesting it.** A new `verify_equivalence` mode composes the rewrite engine with the equivalence checker: a candidate rewrite is labeled **VERIFIED** only when the engine affirmatively returns `equivalent === true`; everything else (including the no-schema case) is still returned but labeled "review before applying." This is the gated core for one-click verified query optimization, so an optimization that silently changes results is never presented as safe. (#918)
+- **Per-turn tool retrieval trims the tool-definition context flood.** Three flag-gated, default-off agent-loop reliability features: a per-turn tool subset (always-on core tools + lexical top-k, never dropping a tool referenced mid-trajectory) that cuts the ~78-tool definition payload sent each turn; grammar/JSON-Schema constrained decoding for local models (vLLM/LM Studio/llama.cpp); and a pluggable pre-execution critic gate for side-effecting tools. All default off, so the existing agent path is unchanged unless explicitly enabled. (#858)
+
+### Changed
+
+- **Upgraded the SQL engine `@altimateai/altimate-core` `0.4.0` → `0.5.1` and wired its new equivalence capabilities into the dbt PR reviewer.** The reviewer now forwards the project's SQL **dialect** hint to the equivalence engine, so dialect-specific compiled warehouse SQL (e.g. Snowflake semi-structured `col:field`) parses and the comparison is decided instead of abstaining on a syntax error, and it honors the engine's new authoritative **`decidable`** flag — abstaining when the engine itself says it could not decide, rather than guessing. An empty/auto-detect dialect is coerced to "no hint" so the engine is never handed an unknown dialect. (#925, #928)
+
+### Fixed
+
+- **The dbt PR reviewer is more reliable and less noisy.** Demo-parity hardening: tighter PII-review precision, reduced safe-refactor review noise, schema YAML catalog rules now run in review, and added DuckDB data-diff end-to-end coverage. (#919)
+- **dbt review no longer misclassifies YAML files.** Schema/property YAML files are classified correctly so the right rules apply to them. (#920)
+- **The `release-v0.8.5` adversarial test gate is pinned to a constant version** so it stops breaking on every subsequent release. (#923)
+
+### Internal
+
+- **Centralized code-review dispatch on PR ready.** A gated loop dispatches a centralized OCR/Gemini review when a pull request is marked ready for review. (#914)
+
 ## [0.8.6] - 2026-06-08
 
 ### Added

package/dbt-tools/dist/index.js

@@ -321,16 +321,25 @@ function getDbt() {
   }
   return resolvedDbt;
 }
+function toExecFileError(e) {
+  if (e instanceof Error)
+    return e;
+  return new Error(String(e));
+}
 function run2(args) {
   const dbt2 = getDbt();
   const env = buildDbtEnv(dbt2);
   const cwd = globalOptions.projectRoot ?? process.cwd();
   return new Promise((resolve4, reject2) => {
     execFile(dbt2.path, args, { timeout: 120000, maxBuffer: 10 * 1024 * 1024, env, cwd }, (err, stdout, stderr) => {
-      if (err)
-        reject2(err);
-      else
+      if (err) {
+        const execErr = err;
+        execErr.stdout = stdout;
+        execErr.stderr = stderr;
+        reject2(execErr);
+      } else {
         resolve4({ stdout, stderr });
+      }
     });
   });
 }
@@ -392,7 +401,7 @@ function looksLikeRowData(val) {
   }
 }
 function stripAnsi(text) {
-  return text.replace(/\x1b\[[0-9;]*m/g, "");
+  return text.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
 }
 function parseAsciiTable(text) {
   const cleaned = stripAnsi(text);
@@ -439,41 +448,43 @@ async function execDbtShow(sql, limit) {
   const args = ["show", "--inline", sql, "--output", "json", "--log-format", "json"];
   if (limit !== undefined)
     args.push("--limit", String(limit));
-  let lines;
+  let primaryRunError;
+  let lines = [];
   try {
     const { stdout } = await run2(args);
     lines = parseJsonLines(stdout);
-  } catch {
-    lines = [];
-  }
-  const previewLine = lines.find((l) => l.data?.preview) ?? lines.find((l) => l.data?.rows) ?? lines.find((l) => l.result?.preview) ?? lines.find((l) => l.result?.rows);
-  const sqlLine = lines.find((l) => l.data?.sql) ?? lines.find((l) => l.data?.compiled_sql) ?? lines.find((l) => l.result?.sql);
-  if (previewLine) {
-    const preview = previewLine.data?.preview ?? previewLine.data?.rows ?? previewLine.result?.preview ?? previewLine.result?.rows;
-    let rows;
-    if (typeof preview === "string") {
-      const parsed = safeJsonParse(preview);
-      if (Array.isArray(parsed)) {
-        rows = parsed;
+  } catch (e) {
+    primaryRunError = toExecFileError(e);
+  }
+  if (!primaryRunError) {
+    const previewLine = lines.find((l) => l.data?.preview) ?? lines.find((l) => l.data?.rows) ?? lines.find((l) => l.result?.preview) ?? lines.find((l) => l.result?.rows);
+    const sqlLine = lines.find((l) => l.data?.sql) ?? lines.find((l) => l.data?.compiled_sql) ?? lines.find((l) => l.result?.sql);
+    if (previewLine) {
+      const preview = previewLine.data?.preview ?? previewLine.data?.rows ?? previewLine.result?.preview ?? previewLine.result?.rows;
+      let rows;
+      if (typeof preview === "string") {
+        const parsed = safeJsonParse(preview);
+        rows = Array.isArray(parsed) ? parsed : [];
+      } else if (Array.isArray(preview)) {
+        rows = preview;
       } else {
         rows = [];
       }
-    } else {
-      rows = preview;
-    }
-    const columnNames = rows.length > 0 && rows[0] ? Object.keys(rows[0]) : [];
-    const compiledSql = sqlLine?.data?.sql ?? sqlLine?.data?.compiled_sql ?? sqlLine?.result?.sql ?? sql;
-    return { columnNames, columnTypes: columnNames.map(() => "string"), data: rows, rawSql: sql, compiledSql };
-  }
-  for (const line of lines) {
-    const found = deepFind(line, (val) => looksLikeRowData(val));
-    if (found) {
-      const rows = typeof found === "string" ? JSON.parse(found) : found;
       const columnNames = rows.length > 0 && rows[0] ? Object.keys(rows[0]) : [];
-      const compiledSql = deepFind(line, (val) => looksLikeSql(val)) ?? sql;
+      const compiledSql = sqlLine?.data?.sql ?? sqlLine?.data?.compiled_sql ?? sqlLine?.result?.sql ?? sql;
       return { columnNames, columnTypes: columnNames.map(() => "string"), data: rows, rawSql: sql, compiledSql };
     }
+    for (const line of lines) {
+      const found = deepFind(line, (val) => looksLikeRowData(val));
+      if (found) {
+        const rows = typeof found === "string" ? JSON.parse(found) : found;
+        const columnNames = rows.length > 0 && rows[0] ? Object.keys(rows[0]) : [];
+        const compiledSql = deepFind(line, (val) => looksLikeSql(val)) ?? sql;
+        return { columnNames, columnTypes: columnNames.map(() => "string"), data: rows, rawSql: sql, compiledSql };
+      }
+    }
   }
+  let plainRunError;
   try {
     const plainArgs = ["show", "--inline", sql];
     if (limit !== undefined)
@@ -489,62 +500,135 @@ async function execDbtShow(sql, limit) {
         compiledSql: sql
       };
     }
-  } catch {}
+  } catch (e) {
+    plainRunError = toExecFileError(e);
+  }
+  if (primaryRunError) {
+    const errorLogLines = parseJsonLines(primaryRunError.stdout?.toString() ?? "");
+    const realError = extractDbtError(errorLogLines, primaryRunError, plainRunError);
+    if (realError) {
+      const hasDbtCategoryPrefix = /^(Compilation|Database|Runtime|Parsing|Validation|Dependency)\s+Error\b/.test(realError);
+      throw new Error(hasDbtCategoryPrefix ? realError : `dbt show failed: ${realError}`);
+    }
+  }
+  if (plainRunError) {
+    const fallback = extractDbtError([], undefined, plainRunError) ?? fallbackExitMessage(undefined, plainRunError) ?? "unknown error";
+    throw new Error(`Could not parse dbt show JSON output, and plain-text fallback failed: ${fallback}`);
+  }
   throw new Error("Could not parse dbt show output in any format (JSON, heuristic, or plain text). " + `Got ${lines.length} JSON lines.`);
 }
+function extractDbtError(lines, primary, plain) {
+  if (!primary && !plain)
+    return;
+  const errorMessages = lines.map((l) => {
+    const line = l;
+    const isError = line.info?.level === "error" || line.level === "error";
+    if (!isError)
+      return;
+    return line.info?.msg ?? line.msg;
+  }).filter((m) => typeof m === "string" && m.trim().length > 0);
+  const structuredMsg = errorMessages.at(-1);
+  const primaryStderr = primary?.stderr?.toString().trim();
+  const plainStderr = plain?.stderr?.toString().trim();
+  const chosen = (structuredMsg && structuredMsg.length > 0 ? structuredMsg : undefined) ?? (primaryStderr && primaryStderr.length > 0 ? primaryStderr : undefined) ?? (plainStderr && plainStderr.length > 0 ? plainStderr : undefined) ?? fallbackExitMessage(primary, plain);
+  return chosen ? stripAnsi(chosen) : undefined;
+}
+function fallbackExitMessage(primary, plain) {
+  const err = primary ?? plain;
+  if (!err)
+    return;
+  const looksLikeCommandFailed = typeof err.message === "string" && err.message.startsWith("Command failed:");
+  if (!looksLikeCommandFailed)
+    return err.message;
+  if (typeof err.code === "number")
+    return `dbt exited with status ${err.code}`;
+  if (err.signal)
+    return `dbt killed by signal ${err.signal}`;
+  if (typeof err.code === "string")
+    return `dbt failed: ${err.code}`;
+  return "dbt failed (no exit code reported)";
+}
+function bubbleDbtError(label, primary, plain) {
+  const errorLogLines = primary?.stdout ? parseJsonLines(primary.stdout.toString()) : [];
+  const real = extractDbtError(errorLogLines, primary, plain);
+  if (real) {
+    const hasDbtCategoryPrefix = /^(Compilation|Database|Runtime|Parsing|Validation|Dependency)\s+Error\b/.test(real);
+    return hasDbtCategoryPrefix ? real : `${label}: ${real}`;
+  }
+  return `${label}: ${fallbackExitMessage(primary, plain) ?? "unknown error"}`;
+}
 async function execDbtCompile(model) {
   const args = ["compile", "--select", model, "--output", "json", "--log-format", "json"];
-  let lines;
+  let lines = [];
+  let primaryRunError;
   try {
     const { stdout } = await run2(args);
     lines = parseJsonLines(stdout);
-  } catch {
-    lines = [];
+  } catch (e) {
+    primaryRunError = toExecFileError(e);
   }
-  const sql = findCompiledSql(lines);
-  if (sql)
-    return { sql };
-  for (const line of lines) {
-    const found = deepFind(line, (val) => looksLikeSql(val));
-    if (found)
-      return { sql: found };
+  if (!primaryRunError) {
+    const sql = findCompiledSql(lines);
+    if (sql)
+      return { sql };
+    for (const line of lines) {
+      const found = deepFind(line, (val) => looksLikeSql(val));
+      if (found)
+        return { sql: found };
+    }
   }
+  let manifestRunError;
   try {
     await run2(["compile", "--select", model]);
-  } catch {}
+  } catch (e) {
+    manifestRunError = toExecFileError(e);
+  }
   const fromManifest = readCompiledFromManifest(model);
   if (fromManifest)
     return { sql: fromManifest };
+  let plainRunError;
   try {
     const { stdout: plainOut } = await run2(["compile", "--select", model]);
     return { sql: plainOut.trim() };
   } catch (e) {
-    throw new Error(`Could not compile model '${model}' in any format (JSON, heuristic, or manifest). ` + `Last error: ${e instanceof Error ? e.message : String(e)}`);
+    plainRunError = toExecFileError(e);
+  }
+  if (primaryRunError || plainRunError || manifestRunError) {
+    throw new Error(bubbleDbtError("dbt compile failed", primaryRunError, plainRunError ?? manifestRunError));
   }
+  throw new Error(`Could not compile model '${model}' in any format (JSON, heuristic, or manifest).`);
 }
 async function execDbtCompileInline(sql, _model) {
   const args = ["compile", "--inline", sql, "--output", "json", "--log-format", "json"];
-  let lines;
+  let lines = [];
+  let primaryRunError;
   try {
     const { stdout } = await run2(args);
     lines = parseJsonLines(stdout);
-  } catch {
-    lines = [];
+  } catch (e) {
+    primaryRunError = toExecFileError(e);
   }
-  const compiled = findCompiledSql(lines);
-  if (compiled)
-    return { sql: compiled };
-  for (const line of lines) {
-    const found = deepFind(line, (val) => looksLikeSql(val));
-    if (found)
-      return { sql: found };
+  if (!primaryRunError) {
+    const compiled = findCompiledSql(lines);
+    if (compiled)
+      return { sql: compiled };
+    for (const line of lines) {
+      const found = deepFind(line, (val) => looksLikeSql(val));
+      if (found)
+        return { sql: found };
+    }
   }
+  let plainRunError;
   try {
     const { stdout: plainOut } = await run2(["compile", "--inline", sql]);
     return { sql: plainOut.trim() };
   } catch (e) {
-    throw new Error(`Could not compile inline SQL in any format (JSON, heuristic, or plain text). ` + `Last error: ${e instanceof Error ? e.message : String(e)}`);
+    plainRunError = toExecFileError(e);
+  }
+  if (primaryRunError || plainRunError) {
+    throw new Error(bubbleDbtError("dbt compile inline failed", primaryRunError, plainRunError));
   }
+  throw new Error("Could not compile inline SQL in any format (JSON, heuristic, or plain text).");
 }
 function findCompiledSql(lines) {
   const compiledLine = lines.find((l) => l.data?.compiled) ?? lines.find((l) => l.data?.compiled_code) ?? lines.find((l) => l.result?.node?.compiled_code) ?? lines.find((l) => l.result?.compiled_code) ?? lines.find((l) => l.data?.compiled_sql);

package/package.json

@@ -7,20 +7,20 @@
   "scripts": {
     "postinstall": "bun ./postinstall.mjs || node ./postinstall.mjs"
   },
-  "version": "0.8.6",
+  "version": "0.8.9",
   "license": "MIT",
   "dependencies": {
-    "@altimateai/altimate-core": "0.4.0"
+    "@altimateai/altimate-core": "0.5.1"
   },
   "optionalDependencies": {
-    "@altimateai/altimate-code-linux-arm64": "0.8.6",
-    "@altimateai/altimate-code-darwin-arm64": "0.8.6",
-    "@altimateai/altimate-code-linux-x64-baseline": "0.8.6",
-    "@altimateai/altimate-code-darwin-x64-baseline": "0.8.6",
-    "@altimateai/altimate-code-windows-x64-baseline": "0.8.6",
-    "@altimateai/altimate-code-darwin-x64": "0.8.6",
-    "@altimateai/altimate-code-windows-x64": "0.8.6",
-    "@altimateai/altimate-code-linux-x64": "0.8.6"
+    "@altimateai/altimate-code-linux-x64-baseline": "0.8.9",
+    "@altimateai/altimate-code-windows-x64": "0.8.9",
+    "@altimateai/altimate-code-linux-x64": "0.8.9",
+    "@altimateai/altimate-code-darwin-x64": "0.8.9",
+    "@altimateai/altimate-code-darwin-x64-baseline": "0.8.9",
+    "@altimateai/altimate-code-darwin-arm64": "0.8.9",
+    "@altimateai/altimate-code-windows-x64-baseline": "0.8.9",
+    "@altimateai/altimate-code-linux-arm64": "0.8.9"
   },
   "peerDependencies": {
     "pg": ">=8",

package/skills/query-optimize/SKILL.md

@@ -7,7 +7,7 @@ description: Analyze and optimize SQL queries for better performance
 
 ## Requirements
 **Agent:** any (read-only analysis)
-**Tools used:** sql_optimize, sql_analyze, sql_explain, altimate_core_equivalence, read, glob, schema_inspect, warehouse_list
+**Tools used:** altimate_core_rewrite (with `verify_equivalence: true`), sql_analyze, sql_explain, read, glob, schema_inspect, warehouse_list
 
 Analyze SQL queries for performance issues and suggest concrete optimizations including rewritten SQL.
 
@@ -20,9 +20,9 @@ Analyze SQL queries for performance issues and suggest concrete optimizations in
 
 2. **Determine the dialect** -- Default to `snowflake`. If the user specifies a dialect (postgres, bigquery, duckdb, etc.), use that instead. Check the project for warehouse connections using `warehouse_list` if unsure.
 
-3. **Run the optimizer**:
-   - Call `sql_optimize` with the SQL, dialect, and schema context if available
-   - If the user has a warehouse connection, first call `schema_inspect` on the relevant tables to build schema context for better optimization (e.g., SELECT * expansion)
+3. **Run the verified optimizer**:
+   - If the user has a warehouse connection, first call `schema_inspect` on the relevant tables to build schema context (needed both for better rewrites — e.g. SELECT * expansion — and to verify equivalence)
+   - Call `altimate_core_rewrite` with the SQL, schema context, and **`verify_equivalence: true`**. This proposes rewrites AND proves each one returns the same results as the original in a single step. The result is partitioned into **verified-equivalent** rewrites (safe to apply) and **unverified** rewrites (review before applying), so you never recommend a rewrite that silently changes semantics.
 
 4. **Run detailed analysis**:
    - Call `sql_analyze` with the same SQL and dialect to get the full anti-pattern breakdown with recommendations
@@ -32,10 +32,10 @@ Analyze SQL queries for performance issues and suggest concrete optimizations in
    - Look for: full table scans, sort operations on large datasets, inefficient join strategies, missing partition pruning
    - Include key findings in the report under "Execution Plan Insights"
 
-6. **Verify rewrites preserve correctness**:
-   - If `sql_optimize` produced a rewritten query, call `altimate_core_equivalence` to verify the original and optimized queries produce the same result set
-   - If not equivalent, flag the difference and present both versions for the user to decide
-   - This prevents "optimization" that silently changes query semantics
+6. **Equivalence verification is built into step 3** (`verify_equivalence: true`):
+   - Present the **verified-equivalent** rewrites as safe to apply.
+   - Present **unverified** rewrites separately with their reason ("review before applying") — do not recommend applying these without manual review.
+   - If no schema was available, all rewrites come back unverified; say so and recommend supplying a schema (or a warehouse connection) to enable verification.
 
 7. **Present findings** in a structured format:
 
@@ -83,4 +83,4 @@ The user invokes this skill with SQL or a file path:
 - `/query-optimize models/staging/stg_orders.sql` -- Optimize SQL from a file
 - `/query-optimize` -- Optimize the most recently discussed SQL in the conversation
 
-Use the tools: `sql_optimize`, `sql_analyze`, `sql_explain` (execution plans), `altimate_core_equivalence` (rewrite verification), `read` (for file-based SQL), `glob` (to find SQL files), `schema_inspect` (for schema context), `warehouse_list` (to check connections).
+Use the tools: `altimate_core_rewrite` with `verify_equivalence: true` (proposes rewrites AND proves they preserve results in one step), `sql_analyze`, `sql_explain` (execution plans), `read` (for file-based SQL), `glob` (to find SQL files), `schema_inspect` (for schema context), `warehouse_list` (to check connections).