@altimateai/altimate-code 0.5.1 → 0.5.3

package/CHANGELOG.md

@@ -5,6 +5,41 @@ 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.5.3] - 2026-03-19
+
+### Fixed
+
+- Bundle skills, dbt-tools, and altimate-setup in shipped npm binary — skills now work in all distribution channels (npm, Homebrew, AUR, Docker) without relying on `postinstall` filesystem copies (#316)
+- Exclude 220MB of unused `.node` binaries from dbt-tools bundle (#320)
+- Documentation about warehouse connections updated (#318)
+
+### Changed
+
+- Added `altimate_change` markers to upstream-shared files and marker removal detection to CI — prevents markers from being silently stripped (#322)
+
+## [0.5.2] - 2026-03-19
+
+### Added
+
+- Trace history dialog (`/trace` command) — browse, search, and open past session traces from the TUI (#297)
+- Docs showcase examples with screenshots (#292)
+
+### Fixed
+
+- TUI trace dialog now respects custom `tracing.dir` config — previously always used default directory (#307)
+- WebFetch `clearTimeout` leak — DNS failures no longer leak timer handles (#307)
+- WebFetch User-Agent strategy inverted to honest-bot-first — reduces 403 blocks from TLS fingerprint mismatch (#303)
+- Snowflake SDK stdout log noise suppressed in TUI via `additionalLogToConsole: false` (#305, #301)
+- `cleanTitle` fallback in trace dialog no longer returns empty string (#307)
+- Error logging added to `openTraceInBrowser` for debuggability (#307)
+- `altimate_change` markers added to `webfetch.ts` for upstream merge compatibility (#307)
+
+### Changed
+
+- Snowflake SDK minimum version bumped to `^2.0.3` for log suppression support (#305)
+- Removed brew from docs and README (#299)
+- Fixed README typo (`altimate` → `altimate-code`) (#293)
+
 ## [0.5.1] - 2026-03-19
 
 ### Added

package/bin/altimate

@@ -33,6 +33,12 @@ function run(target) {
   // Search from BOTH the binary's location AND the wrapper script's location
   // to cover npm flat installs, pnpm isolated stores, and hoisted monorepos.
   const env = { ...process.env }
+
+  // Export bin directory so the compiled binary can add it to PATH when
+  // spawning bash commands. This makes bundled tools (e.g. altimate-dbt)
+  // available to agents without manual PATH configuration.
+  env.ALTIMATE_BIN_DIR = scriptDir
+
   try {
     const resolvedTarget = fs.realpathSync(target)
     const targetDir = path.dirname(path.dirname(resolvedTarget))

package/bin/altimate-code

@@ -33,6 +33,12 @@ function run(target) {
   // Search from BOTH the binary's location AND the wrapper script's location
   // to cover npm flat installs, pnpm isolated stores, and hoisted monorepos.
   const env = { ...process.env }
+
+  // Export bin directory so the compiled binary can add it to PATH when
+  // spawning bash commands. This makes bundled tools (e.g. altimate-dbt)
+  // available to agents without manual PATH configuration.
+  env.ALTIMATE_BIN_DIR = scriptDir
+
   try {
     const resolvedTarget = fs.realpathSync(target)
     const targetDir = path.dirname(path.dirname(resolvedTarget))

package/dbt-tools/bin/altimate-dbt

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import("../dist/index.js")

package/dbt-tools/dist/altimate_python_packages/altimate_packages/altimate/fetch_schema.py

@@ -0,0 +1,35 @@
+import sqlglot
+from sqlglot.optimizer.qualify import qualify
+from altimate.utils import map_adapter_to_dialect
+
+
+def fetch_schema(sql: str, dialect: str):
+    parsed_query = sqlglot.parse_one(sql=sql, dialect=map_adapter_to_dialect(dialect))
+    columns = []
+    for c in parsed_query.selects:
+        if c.key == "column":
+            if c.args["this"].key == "star":
+                raise Exception(
+                    f"unable fetched schema due to star: {c.sql(pretty=True)}"
+                )
+            columns.append(c.alias_or_name)
+        elif c.key == "alias":
+            columns.append(c.alias_or_name)
+        else:
+            raise Exception(f"unknown key '{c.key}' detected for {c.sql(pretty=True)}")
+    return columns
+
+
+def validate_whether_sql_has_columns(sql: str, dialect: str):
+    try:
+        parsed_query = sqlglot.parse_one(sql=sql, dialect=map_adapter_to_dialect(dialect))
+        qualify(
+            parsed_query,
+            schema={},
+            dialect=dialect,
+            quote_identifiers=False,
+            validate_qualify_columns=True,
+        )
+        return True
+    except Exception as e:
+        return False

package/dbt-tools/dist/altimate_python_packages/altimate_packages/altimate/utils.py

@@ -0,0 +1,353 @@
+import re
+
+import sqlglot
+from sqlglot.executor import execute
+from sqlglot.expressions import Table
+from sqlglot.optimizer import traverse_scope
+from sqlglot.optimizer.qualify import qualify
+
+ADAPTER_MAPPING = {
+    "bigquery": "bigquery",
+    "clickhouse": "clickhouse",
+    "databricks": "databricks",
+    "duckdb": "duckdb",
+    "hive": "hive",
+    "mysql": "mysql",
+    "oracle": "oracle",
+    "postgres": "postgres",
+    "redshift": "redshift",
+    "snowflake": "snowflake",
+    "spark": "spark",
+    "starrocks": "starrocks",
+    "teradata": "teradata",
+    "trino": "trino",
+    "synapse": "tsql",
+    "sqlserver": "tsql",
+    "doris": "doris",
+    "athena": "presto",
+}
+
+MULTIPLE_OCCURENCES_STR = "Unable to highlight the exact location in the SQL code due to multiple occurrences."
+MAPPING_FAILED_STR = "Unable to highlight the exact location in the SQL code."
+
+
+def extract_column_name(text):
+    # List of regex patterns
+    regex_patterns = [
+        r"Column '\"(\w+)\"' could not be resolved",
+        r"Unknown column: (\w+)",
+        r"Column '(\w+)' could not be resolved",
+        r"Unknown output column: (\w+)",
+        r"Cannot automatically join: (\w+)",
+    ]
+
+    # Iterate over each regex pattern
+    for regex in regex_patterns:
+        matches = re.findall(regex, text)
+        if matches:
+            return matches[0]
+
+    return None
+
+
+def find_single_occurrence_indices(main_string, substring):
+    # Convert both strings to lowercase for case-insensitive comparison
+    main_string = main_string.lower()
+    substring = substring.lower() if substring else ""
+
+    if not substring:
+        # return consistent tuple when substring is empty
+        return None, None, 0
+
+    num_occurrences = main_string.count(substring)
+    # Check if the substring occurs only once in the main string
+    if num_occurrences == 1:
+        start_index = main_string.find(substring)
+        return start_index, start_index + len(substring), num_occurrences
+
+    # Return None if the substring doesn't occur exactly once
+    return None, None, num_occurrences
+
+
+def map_adapter_to_dialect(adapter: str):
+    return ADAPTER_MAPPING.get(adapter, adapter)
+
+
+def get_str_position(str, row, col):
+    """
+    Get the position of a grid position in a string
+    """
+    lines = str.split("\n")
+    position = 0
+    for i in range(row - 1):
+        position += len(lines[i]) + 1
+    position += col
+    return position
+
+
+def get_line_and_column_from_position(text, start_index):
+    """
+    Finds the grid position (row and column) in a multiline string given a Python start index.
+    Rows and columns are 1-indexed.
+
+    :param text: Multiline string.
+    :param start_index: Python start index (0-indexed).
+    :return: Tuple of (row, column).
+    """
+    row = 0
+    current_length = 0
+
+    # Split the text into lines
+    lines = text.split("\n")
+
+    for line in lines:
+        # Check if the start_index is in the current line
+        if current_length + len(line) >= start_index:
+            # Column is the difference between start_index and the length of processed characters
+            column = start_index - current_length + 1
+            return row, column
+
+        # Update the row and current length for the next iteration
+        row += 1
+        current_length += len(line) + 1  # +1 for the newline character
+
+    return None, None
+
+
+def _build_message(sql: str, error: dict):
+    len_highlight = len(error.get("highlight", ""))
+    len_prefix = len(error.get("start_context", ""))
+    if error.get("line") and error.get("col"):
+        end_position = get_str_position(sql, error["line"], error["col"])
+        start_position = end_position - len_highlight - len_prefix
+        row, col = get_line_and_column_from_position(sql, start_position)
+        return {
+            "description": "Failed to parse the sql query",
+            "start_position": [row, col],
+            "end_position": [error["line"], error["col"]],
+        }
+    return {"description": "Failed to parse the sql query"}
+
+
+def sql_parse_errors(sql: str, dialect: str):
+    errors = []
+    try:
+        sqlglot.transpile(sql, read=dialect)
+        ast = sqlglot.parse_one(sql, read=dialect)
+        if isinstance(ast, sqlglot.exp.Alias):
+            return [
+                {
+                    "description": "Failed to parse the sql query.",
+                }
+            ]
+    except sqlglot.errors.ParseError as e:
+        for error in e.errors:
+            errors.append(_build_message(sql, error))
+    return errors
+
+
+def get_start_and_end_position(sql: str, invalid_string: str):
+    start, end, num_occurences = find_single_occurrence_indices(sql, invalid_string)
+    if start and end:
+        return (
+            list(get_line_and_column_from_position(sql, start)),
+            list(get_line_and_column_from_position(sql, end)),
+            num_occurences,
+        )
+    return None, None, num_occurences
+
+
+def form_error(
+    error: str, invalid_entity: str, start_position, end_position, num_occurences
+):
+    if num_occurences > 1:
+        error = (
+            f"{error}\n {MULTIPLE_OCCURENCES_STR.format(invalid_entity=invalid_entity)}"
+        )
+        return {
+            "description": error,
+        }
+
+    if not start_position or not end_position:
+        error = (
+            f"{error}\n {MAPPING_FAILED_STR.format(invalid_entity=invalid_entity)}"
+            if invalid_entity
+            else error
+        )
+        return {
+            "description": error,
+        }
+
+    return {
+        "description": error,
+        "start_position": start_position,
+        "end_position": end_position,
+    }
+
+
+def validate_tables_and_columns(
+    sql: str,
+    dialect: str,
+    schemas: dict,
+):
+    try:
+        parsed_sql = sqlglot.parse_one(sql, read=dialect)
+        qualify(parsed_sql, dialect=dialect, schema=schemas)
+    except sqlglot.errors.OptimizeError as e:
+        error = str(e)
+        if "sqlglot" in error:
+            error = "Failed to validate the query."
+        invalid_entity = extract_column_name(error)
+        if not invalid_entity:
+            return [
+                {
+                    "description": error,
+                }
+            ]
+        start_position, end_position, num_occurences = get_start_and_end_position(
+            sql, invalid_entity
+        )
+        error = error if error[-1] == "." else error + "."
+        return [
+            form_error(
+                error, invalid_entity, start_position, end_position, num_occurences
+            )
+        ]
+
+    return None
+
+
+def sql_execute_errors(
+    sql: str,
+    dialect: str,
+    schemas: dict,
+):
+    tables = {}
+    for db in schemas:
+        if db not in tables:
+            tables[db] = {}
+        for schema in schemas[db]:
+            if schema not in tables[db]:
+                tables[db][schema] = {}
+            for table in schemas[db][schema]:
+                tables[db][schema][table] = []
+
+    try:
+        execute(
+            sql=sql,
+            read=dialect,
+            schema=schemas,
+            tables=tables,
+        )
+    except sqlglot.errors.ExecuteError as e:
+        return [
+            {
+                "description": str(e),
+            }
+        ]
+    return None
+
+
+def qualify_columns(expression):
+    """
+    Qualify the columns in the given SQL expression.
+    """
+    try:
+        return qualify(
+            expression,
+            qualify_columns=True,
+            isolate_tables=True,
+            validate_qualify_columns=False,
+        )
+    except sqlglot.errors.OptimizeError as error:
+        return expression
+
+
+def parse_sql_query(sql_query, dialect):
+    """
+    Parses the SQL query and returns an AST.
+    """
+    return sqlglot.parse_one(sql_query, read=dialect)
+
+
+def extract_physical_columns(ast):
+    """
+    Extracts physical columns from the given AST.
+    """
+    physical_columns = {}
+    for scope in traverse_scope(ast):
+        for column in scope.columns:
+            table = scope.sources.get(column.table)
+            if isinstance(table, Table):
+                db, schema, table_name = table.catalog, table.db, table.name
+                if db is None or schema is None:
+                    continue
+                path = f"{db}.{schema}.{table_name}".lower()
+                physical_columns.setdefault(path, set()).add(column.name)
+    return physical_columns
+
+
+def get_columns_used(sql_query, dialect):
+    """
+    Process the SQL query to extract physical columns.
+    """
+    ast = parse_sql_query(sql_query, dialect)
+    qualified_ast = qualify_columns(ast)
+    return extract_physical_columns(qualified_ast)
+
+
+def validate_columns_present_in_schema(sql_query, dialect, schemas, model_mapping):
+    """
+    Validate that the columns in the SQL query are present in the schema.
+    """
+    errors = []
+    new_schemas = {}
+    for db in schemas:
+        for schema in schemas[db]:
+            for table in schemas[db][schema]:
+                path = f"{db}.{schema}.{table}".lower()
+                new_schemas.setdefault(path, set()).update(
+                    [column.lower() for column in schemas[db][schema][table].keys()]
+                )
+    schemas = new_schemas
+    try:
+        columns_used = get_columns_used(sql_query, dialect)
+
+        for table, columns_set in columns_used.items():
+            if table not in schemas:
+                (
+                    start_position,
+                    end_position,
+                    num_occurences,
+                ) = get_start_and_end_position(sql_query, table)
+                error = f"Error: Table '{table}' not found. This issue often occurs when a table is used directly\n in dbt instead of being referenced through the appropriate syntax.\n To resolve this, ensure that '{table}' is propaerly defined in your project and use the 'ref()' function to reference it in your models."
+
+                errors.append(
+                    form_error(
+                        error, table, start_position, end_position, num_occurences
+                    )
+                )
+                continue
+
+            columns = schemas[table]
+            for column in columns_set:
+                if column.lower() not in columns:
+                    (
+                        start_position,
+                        end_position,
+                        num_occurences,
+                    ) = get_start_and_end_position(sql_query, column)
+                    table = model_mapping.get(table, table)
+                    error = f"Error: Column '{column}' not found in '{table}'. \nPossible causes: 1) Typo in column name. 2) Column not materialized. 3) Column not selected in parent cte."
+                    errors.append(
+                        form_error(
+                            error,
+                            column,
+                            start_position,
+                            end_position,
+                            num_occurences,
+                        )
+                    )
+    except Exception as e:
+        pass
+    return errors

package/dbt-tools/dist/altimate_python_packages/altimate_packages/altimate/validate_sql.py

@@ -0,0 +1,114 @@
+from typing import Dict, List
+
+from altimate.utils import (
+    map_adapter_to_dialect,
+    sql_execute_errors,
+    sql_parse_errors,
+    validate_columns_present_in_schema,
+    validate_tables_and_columns,
+)
+
+
+def _get_key(
+    key: str,
+    dialect: str,
+):
+    if dialect == "bigquery":
+        return key.lower()
+
+    if dialect == "snowflake":
+        return key.upper()
+    return key
+
+
+def _build_schemas(
+    models: List[Dict],
+    dialect: str,
+):
+    """
+    TODO: Duplicated in multiple places with slight variations. Fix this.
+    """
+    schemas = {}
+    for model in models:
+        schema = {}
+        for column in model["columns"]:
+            schema[_get_key(model["columns"][column]["name"], dialect)] = model[
+                "columns"
+            ][column].get("data_type", "string")
+
+        db = _get_key(model["database"], dialect)
+        schema_name = _get_key(model["schema"], dialect)
+        table = _get_key(model["alias"], dialect)
+        if db not in schemas:
+            schemas[db] = {}
+
+        if schema_name not in schemas[db]:
+            schemas[db][schema_name] = {}
+
+        schemas[db][schema_name][table] = schema
+
+    return schemas
+
+
+def _build_model_mapping(
+    models: List[Dict],
+):
+    model_map = {}
+    for model in models:
+        db = model["database"]
+        schema = model["schema"]
+        table = model["alias"]
+        model_map[f"{db}.{schema}.{table}".lower()] = model["name"]
+    return model_map
+
+
+def validate_sql_from_models(
+    sql: str,
+    dialect: str,
+    models: List[Dict],
+):
+    """
+    Validate SQL from models
+    """
+    try:
+        dialect = map_adapter_to_dialect(dialect)
+        schemas = _build_schemas(models, dialect)
+        model_mapping = _build_model_mapping(models)
+        errors = sql_parse_errors(sql, dialect)
+
+        if len(errors) > 0:
+            return {
+                "error_type": "sql_parse_error",
+                "errors": errors,
+            }
+
+        errors = validate_columns_present_in_schema(
+            sql, dialect, schemas, model_mapping
+        )
+        if len(errors) > 0:
+            return {
+                "error_type": "sql_invalid_error",
+                "errors": errors,
+            }
+
+        errors = validate_tables_and_columns(sql, dialect, schemas)
+
+        if errors:
+            return {
+                "error_type": "sql_invalid_error",
+                "errors": errors,
+            }
+
+        # errors = sql_execute_errors(sql, dialect, schemas)
+
+        # if errors:
+        #     return {"error_type": "sql_execute_error", "errors": errors}
+
+    except Exception as e:
+        return {
+            "error_type": "sql_unknown_error",
+            "errors": [
+                {"description": f"Unknown error. Cannot validate SQL. {str(e)}"}
+            ],
+        }
+    return {}