tinybird 0.0.1.dev262__tar.gz → 0.0.1.dev263__tar.gz

{tinybird-0.0.1.dev262 → tinybird-0.0.1.dev263}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tinybird
-Version: 0.0.1.dev262
+Version: 0.0.1.dev263
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/forward/commands
 Author: Tinybird

{tinybird-0.0.1.dev262 → tinybird-0.0.1.dev263}/tinybird/datafile/common.py

@@ -461,6 +461,15 @@ class Datafile:
                     raise DatafileValidationError(
                         f"Invalid permission {token['permission']} for token {token['token_name']}. Only READ and APPEND are allowed for datasources"
                     )
+
+            # Validate sorting key if present
+            if "engine" in node and isinstance(node["engine"], dict) and "args" in node["engine"]:
+                for arg_name, arg_value in node["engine"]["args"]:
+                    if arg_name.lower() == "sorting_key":
+                        # Check for sorting key constraints
+                        self._validate_sorting_key(arg_value, node)
+                        break
+
             # Validate Kafka params
             if any(param in node for param in KAFKA_PARAMS) and (
                 missing := [param for param in REQUIRED_KAFKA_PARAMS if param not in node]
@@ -483,6 +492,148 @@ class Datafile:
             # We cannot validate a datafile whose kind is unknown
             pass
 
+    def _validate_sorting_key(self, sorting_key: str, node: Dict[str, Any]) -> None:
+        """
+        Validates that a sorting key doesn't reference:
+        - Nullable columns
+        - AggregateFunction types
+        - Engine version columns for ReplacingMergeTree
+        """
+        if sorting_key == "tuple()" or not sorting_key:
+            return  # Empty sorting key is valid
+
+        engine_ver_column = self._extract_engine_ver_column(node)
+        schema_columns = {col["name"]: col for col in node["columns"]}
+        sorting_key_columns = self._parse_sorting_key_columns(sorting_key, engine_ver_column)
+
+        self._validate_columns_against_schema(sorting_key_columns, schema_columns)
+
+    def _extract_engine_ver_column(self, node: Dict[str, Any]) -> Optional[str]:
+        engine_info = node.get("engine", {})
+
+        if not isinstance(engine_info, dict):
+            return None
+
+        engine_type = engine_info.get("type", "")
+        if engine_type != "ReplacingMergeTree":
+            return None
+
+        engine_args = engine_info.get("args", [])
+        for arg_name, arg_value in engine_args:
+            if arg_name == "ver":
+                return arg_value
+
+        return None
+
+    def _parse_sorting_key_columns(self, sorting_key: str, engine_ver_column: Optional[str]) -> List[str]:
+        """Parse sorting key to extract column names and validate constraints."""
+        # Validate ENGINE_VER column constraint early
+        if engine_ver_column and engine_ver_column in sorting_key:
+            raise DatafileValidationError(
+                f"ENGINE_VER column '{engine_ver_column}' cannot be included in the sorting key for ReplacingMergeTree. "
+                f"Including the version column in the sorting key prevents deduplication because rows with different "
+                f"versions will have different sorting keys and won't be considered duplicates. The sorting key should "
+                f"define the record identity (what makes it unique), while ENGINE_VER tracks which version to keep."
+            )
+
+        # Remove tuple() wrapper if present
+        column_str = sorting_key
+        if column_str.startswith("tuple(") and column_str.endswith(")"):
+            column_str = column_str[6:-1]
+
+        sorting_key_columns = []
+
+        for part in column_str.split(","):
+            part = part.strip()
+
+            if self._is_aggregate_function_expression(part):
+                raise DatafileValidationError(
+                    f"Sorting key contains aggregate function expression '{part}'. Aggregate function expressions cannot be used in sorting keys."
+                )
+
+            # Extract column names from the part
+            extracted_columns = self._extract_column_names_from_part(part)
+            sorting_key_columns.extend(extracted_columns)
+
+        return sorting_key_columns
+
+    def _is_aggregate_function_expression(self, part: str) -> bool:
+        """Check if a sorting key part is an aggregate function expression."""
+        if not ("(" in part and part.endswith(")")):
+            return False
+
+        func_start = part.find("(")
+        func_name = part[:func_start].strip().lower()
+
+        aggregate_function_names = {
+            "sum",
+            "count",
+            "avg",
+            "min",
+            "max",
+            "any",
+            "grouparray",
+            "groupuniqarray",
+            "uniq",
+            "summerge",
+            "countmerge",
+            "avgmerge",
+            "minmerge",
+            "maxmerge",
+            "anymerge",
+            "grouparraymerge",
+            "groupuniqarraymerge",
+            "uniqmerge",
+        }
+
+        return func_name in aggregate_function_names
+
+    def _extract_column_names_from_part(self, part: str) -> List[str]:
+        """Extract column names from a sorting key part."""
+        columns = []
+
+        if "(" in part and part.endswith(")"):
+            # Function expression - extract column names from inside parentheses
+            func_start = part.find("(")
+            inner_content = part[func_start + 1 : -1].strip()
+            for inner_part in inner_content.split(","):
+                inner_part = inner_part.strip().strip("`")
+                if inner_part and inner_part.isidentifier():
+                    columns.append(inner_part)
+        elif part:
+            # Simple column name
+            column_name = part.strip("`")
+            if column_name:
+                columns.append(column_name)
+
+        return columns
+
+    def _validate_columns_against_schema(
+        self, sorting_key_columns: List[str], schema_columns: Dict[str, Dict[str, Any]]
+    ) -> None:
+        """Validate each column in the sorting key against the schema."""
+        if not schema_columns:
+            return  # No schema information available, can't validate
+
+        for col_name in sorting_key_columns:
+            if col_name not in schema_columns:
+                continue
+
+            self._validate_single_column(col_name, schema_columns[col_name])
+
+    def _validate_single_column(self, col_name: str, column_info: Dict[str, Any]) -> None:
+        """Validate a single column for use in sorting keys."""
+        col_type = column_info.get("type", "").lower()
+        is_nullable = column_info.get("nullable", False)
+        if is_nullable:
+            raise DatafileValidationError(
+                f"Sorting key contains nullable column '{col_name}'. Nullable columns cannot be used in sorting keys."
+            )
+        if "aggregatefunction" in col_type:
+            raise DatafileValidationError(
+                f"Sorting key contains column '{col_name}' with AggregateFunction type. AggregateFunction columns cannot be used in sorting keys."
+            )
+
 
 def format_filename(filename: str, hide_folders: bool = False):
     return os.path.basename(filename) if hide_folders else filename

{tinybird-0.0.1.dev262 → tinybird-0.0.1.dev263}/tinybird/tb/__cli__.py

@@ -4,5 +4,5 @@ __description__ = 'Tinybird Command Line Tool'
 __url__ = 'https://www.tinybird.co/docs/forward/commands'
 __author__ = 'Tinybird'
 __author_email__ = 'support@tinybird.co'
-__version__ = '0.0.1.dev262'
-__revision__ = 'b28ec2c'
+__version__ = '0.0.1.dev263'
+__revision__ = '1d13423'

{tinybird-0.0.1.dev262 → tinybird-0.0.1.dev263}/tinybird/tb/modules/agent/agent.py

@@ -2,6 +2,7 @@ import asyncio
 import shlex
 import subprocess
 import sys
+import urllib.parse
 from functools import partial
 from pathlib import Path
 from typing import Any, Optional
@@ -11,13 +12,16 @@ import humanfriendly
 from pydantic_ai import Agent, RunContext, Tool
 from pydantic_ai.agent import AgentRunResult
 from pydantic_ai.messages import ModelMessage, ModelRequest, UserPromptPart
+from requests import Response
 
 from tinybird.tb.client import TinyB
 from tinybird.tb.modules.agent.animations import ThinkingAnimation
 from tinybird.tb.modules.agent.banner import display_banner
+from tinybird.tb.modules.agent.command_agent import CommandAgent
 from tinybird.tb.modules.agent.memory import clear_history, clear_messages, load_messages, save_messages
 from tinybird.tb.modules.agent.models import create_model, model_costs
 from tinybird.tb.modules.agent.prompts import agent_system_prompt, load_custom_project_rules, resources_prompt
+from tinybird.tb.modules.agent.testing_agent import TestingAgent
 from tinybird.tb.modules.agent.tools.analyze import analyze_file, analyze_url
 from tinybird.tb.modules.agent.tools.append import append_file, append_url
 from tinybird.tb.modules.agent.tools.build import build
@@ -32,9 +36,7 @@ from tinybird.tb.modules.agent.tools.mock import mock
 from tinybird.tb.modules.agent.tools.plan import plan
 from tinybird.tb.modules.agent.tools.preview_datafile import preview_datafile
 from tinybird.tb.modules.agent.tools.request_endpoint import request_endpoint
-from tinybird.tb.modules.agent.tools.test import create_tests as create_tests_tool
-from tinybird.tb.modules.agent.tools.test import run_tests as run_tests_tool
-from tinybird.tb.modules.agent.utils import AgentRunCancelled, TinybirdAgentContext, show_input
+from tinybird.tb.modules.agent.utils import AgentRunCancelled, TinybirdAgentContext, show_confirmation, show_input
 from tinybird.tb.modules.build_common import process as build_process
 from tinybird.tb.modules.common import _analyze, _get_tb_client, echo_safe_humanfriendly_tables_format_pretty_table
 from tinybird.tb.modules.config import CLIConfig
@@ -64,6 +66,7 @@ class TinybirdAgent:
         self.host = host
         self.dangerously_skip_permissions = dangerously_skip_permissions or prompt_mode
         self.project = project
+        self.thinking_animation = ThinkingAnimation()
         if prompt_mode:
             self.messages: list[ModelMessage] = load_messages()[-5:]
         else:
@@ -102,12 +105,61 @@ class TinybirdAgent:
                 Tool(execute_query, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
                 Tool(request_endpoint, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
                 Tool(diff_resource, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
-                Tool(create_tests_tool, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
-                Tool(run_tests_tool, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
             ],
             history_processors=[self._context_aware_processor],
         )
 
+        self.testing_agent = TestingAgent(
+            dangerously_skip_permissions=self.dangerously_skip_permissions,
+            prompt_mode=prompt_mode,
+            thinking_animation=self.thinking_animation,
+            token=self.token,
+            user_token=self.user_token,
+            host=self.host,
+            workspace_id=workspace_id,
+            project=self.project,
+        )
+        self.command_agent = CommandAgent(
+            dangerously_skip_permissions=self.dangerously_skip_permissions,
+            prompt_mode=prompt_mode,
+            thinking_animation=self.thinking_animation,
+            token=self.token,
+            user_token=self.user_token,
+            host=self.host,
+            workspace_id=workspace_id,
+            project=self.project,
+        )
+
+        @self.agent.tool
+        def manage_tests(ctx: RunContext[TinybirdAgentContext], task: str) -> str:
+            """Delegate test management to the test agent:
+
+            Args:
+                task (str): The detailed task to perform. Required.
+
+            Returns:
+                str: The result of the query.
+            """
+            result = self.testing_agent.run(task, deps=ctx.deps, usage=ctx.usage)
+
+            if not result:
+                return "Could not solve the task using the test agent"
+
+            return result.output
+
+        @self.agent.tool
+        def run_command(ctx: RunContext[TinybirdAgentContext], task: str) -> str:
+            """Solve a task using directly Tinybird CLI commands.
+
+            Args:
+                task (str): The task to solve. Required.
+
+            Returns:
+                str: The result of the command.
+            """
+            result = self.command_agent.run(task, deps=ctx.deps, usage=ctx.usage)
+            return result.output
+
         @self.agent.instructions
         def get_local_host(ctx: RunContext[TinybirdAgentContext]) -> str:
             return f"Tinybird Local host: {ctx.deps.local_host}"
@@ -128,8 +180,6 @@ class TinybirdAgent:
         def get_project_files(ctx: RunContext[TinybirdAgentContext]) -> str:
             return resources_prompt(self.project)
 
-        self.thinking_animation = ThinkingAnimation()
-
     def add_message(self, message: ModelMessage) -> None:
         self.messages.append(message)
 
@@ -155,6 +205,7 @@ class TinybirdAgent:
         project = self.project
         folder = self.project.folder
         local_client = get_tinybird_local_client(config, test=False, silent=False)
+        test_client = get_tinybird_local_client(config, test=True, silent=True)
         return TinybirdAgentContext(
             # context does not support the whole client, so we need to pass only the functions we need
             explore_data=client.explore_data,
@@ -169,6 +220,8 @@ class TinybirdAgent:
             execute_query_local=partial(execute_query_local, config=config),
             request_endpoint_cloud=partial(request_endpoint_cloud, config=config),
             request_endpoint_local=partial(request_endpoint_local, config=config),
+            build_project_test=partial(build_project_test, project=project, client=test_client),
+            get_pipe_data_test=partial(get_pipe_data_test, client=test_client),
             get_datasource_datafile_cloud=partial(get_datasource_datafile_cloud, config=config),
             get_datasource_datafile_local=partial(get_datasource_datafile_local, config=config),
             get_pipe_datafile_cloud=partial(get_pipe_datafile_cloud, config=config),
@@ -176,7 +229,7 @@ class TinybirdAgent:
             get_connection_datafile_cloud=partial(get_connection_datafile_cloud, config=config),
             get_connection_datafile_local=partial(get_connection_datafile_local, config=config),
             get_project_files=project.get_project_files,
-            run_tests=partial(run_tests, project=project, config=config),
+            run_tests=partial(run_tests, project=project, client=test_client),
             folder=folder,
             thinking_animation=self.thinking_animation,
             workspace_name=self.project.workspace_name,
@@ -277,15 +330,40 @@ def run_agent(
                     FeedbackManager.error(message="Tinybird Code requires authentication. Run 'tb login' first.")
                 )
                 return
+        build_user_input: Optional[str] = None
+        try:
+            build_project(config, project, test=False, silent=True)
+        except CLIBuildException as e:
+            if prompt:
+                raise e
+            click.echo(FeedbackManager.error(message=e))
+            try:
+                show_confirmation(
+                    title="Fix project errors?", skip_confirmation=dangerously_skip_permissions, show_review=False
+                )
+            except AgentRunCancelled:
+                click.echo(FeedbackManager.info(message="User cancelled the operation"))
+                return
 
-        build_project(config, project, test=False, silent=True)
+            build_user_input = f"Error building project. Fix the errors before continuing. {e}"
 
         # In prompt mode, always skip permissions to avoid interactive prompts
         prompt_mode = prompt is not None
-        agent = TinybirdAgent(token, user_token, host, workspace_id, project, dangerously_skip_permissions, prompt_mode)
+
+        agent = TinybirdAgent(
+            token,
+            user_token,
+            host,
+            workspace_id,
+            project,
+            dangerously_skip_permissions,
+            prompt_mode,
+        )
 
         # Print mode: run once with the provided prompt and exit
         if prompt:
+            if build_user_input:
+                prompt = f"User input: {prompt}\n\n{build_user_input}"
             agent.run(prompt, config)
             return
 
@@ -302,7 +380,8 @@ def run_agent(
     try:
         while True:
             try:
-                user_input = show_input(workspace_name)
+                user_input = build_user_input or show_input(workspace_name)
+                build_user_input = None
                 if user_input.startswith("tb "):
                     cmd_parts = shlex.split(user_input)
                     subprocess.run(cmd_parts)
@@ -373,12 +452,12 @@ def run_agent(
 
 
 def build_project(
-    config: dict[str, Any], project: Project, silent: bool = True, test: bool = True, load_fixtures: bool = False
+    config: dict[str, Any], project: Project, silent: bool = False, test: bool = True, load_fixtures: bool = False
 ) -> None:
-    local_client = get_tinybird_local_client(config, test=test, silent=silent)
+    client = get_tinybird_local_client(config, test=test, silent=silent)
     build_error = build_process(
         project=project,
-        tb_client=local_client,
+        tb_client=client,
         watch=False,
         silent=silent,
         exit_on_error=False,
@@ -388,6 +467,23 @@ def build_project(
         raise CLIBuildException(build_error)
 
 
+def build_project_test(
+    client: TinyB,
+    project: Project,
+    silent: bool = False,
+) -> None:
+    build_error = build_process(
+        project=project,
+        tb_client=client,
+        watch=False,
+        silent=silent,
+        exit_on_error=False,
+        load_fixtures=True,
+    )
+    if build_error:
+        raise CLIBuildException(build_error)
+
+
 def deploy_project(config: dict[str, Any], project: Project) -> None:
     client = _get_tb_client(config["token"], config["host"])
     try:
@@ -408,6 +504,8 @@ def deploy_check_project(config: dict[str, Any], project: Project) -> None:
     try:
         create_deployment(project=project, client=client, config=config, check=True, wait=True, auto=True)
     except SystemExit as e:
+        if hasattr(e, "code") and e.code == 0:
+            return
         raise CLIDeploymentException(e.args[0])
 
 
@@ -529,9 +627,24 @@ def get_connection_datafile_local(config: dict[str, Any], connection_name: str)
         return "Connection not found"
 
 
-def run_tests(config: dict[str, Any], project: Project, pipe_name: Optional[str] = None) -> None:
-    local_client = get_tinybird_local_client(config, test=True, silent=True)
+def run_tests(client: TinyB, project: Project, pipe_name: Optional[str] = None) -> None:
     try:
-        run_tests_common(name=(pipe_name,) if pipe_name else (), project=project, client=local_client)
+        run_tests_common(name=(pipe_name,) if pipe_name else (), project=project, client=client)
     except SystemExit as e:
         raise Exception(e.args[0])
+
+
+def get_pipe_data_test(client: TinyB, pipe_name: str, test_params: Optional[dict[str, str]] = None) -> Response:
+    pipe = client._req(f"/v0/pipes/{pipe_name}")
+    output_node = next(
+        (node for node in pipe["nodes"] if node["node_type"] != "default" and node["node_type"] != "standard"),
+        {"name": "not_found"},
+    )
+    if output_node["node_type"] == "endpoint":
+        return client._req_raw(f"/v0/pipes/{pipe_name}.ndjson?{test_params}")
+
+    params = {
+        "q": output_node["sql"],
+        "pipeline": pipe_name,
+    }
+    return client._req_raw(f"""/v0/sql?{urllib.parse.urlencode(params)}&{test_params}""")

tinybird-0.0.1.dev263/tinybird/tb/modules/agent/banner.py

@@ -0,0 +1,131 @@
+import os
+import sys
+
+import click
+
+
+def detect_terminal_capabilities():
+    """Detect terminal color and Unicode capabilities"""
+    # Check for true color support
+    colorterm = os.environ.get("COLORTERM", "").lower()
+    term = os.environ.get("TERM", "").lower()
+    term_program = os.environ.get("TERM_PROGRAM", "").lower()
+
+    # Known terminals with good true color support
+    modern_terminals = ["warp", "ghostty", "iterm2", "alacritty", "kitty", "hyper"]
+
+    # Check for true color support
+    has_truecolor = (
+        colorterm in ["truecolor", "24bit"]
+        or term_program in modern_terminals
+        or "truecolor" in term
+        or "24bit" in term
+    )
+
+    # Check if it's standard macOS Terminal
+    is_macos_terminal = term_program == "apple_terminal"
+
+    # Check for Unicode support (most modern terminals support this)
+    has_unicode = sys.stdout.encoding and "utf" in sys.stdout.encoding.lower()
+
+    return {
+        "truecolor": has_truecolor and not is_macos_terminal,
+        "unicode": has_unicode,
+        "is_macos_terminal": is_macos_terminal,
+    }
+
+
+def display_banner():
+    reset = "\033[0m"
+    capabilities = detect_terminal_capabilities()
+
+    click.echo("\n")
+
+    # Choose banner based on Unicode support
+    if capabilities["unicode"]:
+        # Unicode box-drawing characters banner
+        banner = [
+            "  ████████╗██╗███╗   ██╗██╗   ██╗██████╗ ██╗██████╗ ██████╗     ██████╗ ██████╗ ██████╗ ███████╗",
+            "  ╚══██╔══╝██║████╗  ██║╚██╗ ██╔╝██╔══██╗██║██╔══██╗██╔══██╗   ██╔════╝██╔═══██╗██╔══██╗██╔════╝",
+            "     ██║   ██║██╔██╗ ██║ ╚████╔╝ ██████╔╝██║██████╔╝██║  ██║   ██║     ██║   ██║██║  ██║█████╗  ",
+            "     ██║   ██║██║╚██╗██║  ╚██╔╝  ██╔══██╗██║██╔══██╗██║  ██║   ██║     ██║   ██║██║  ██║██╔══╝  ",
+            "     ██║   ██║██║ ╚████║   ██║   ██████╔╝██║██║  ██║██████╔╝   ╚██████╗╚██████╔╝██████╔╝███████╗",
+            "     ╚═╝   ╚═╝╚═╝  ╚═══╝   ╚═╝   ╚═════╝ ╚═╝╚═╝  ╚═╝╚═════╝     ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝",
+        ]
+    else:
+        # ASCII fallback banner
+        banner = [
+            "  ████████T██I███N   ██N██   ██Y██████B ██I██████B ██████B     ██████C ██████O ██████D ███████E",
+            "  ╚══██╔══╝██║████╗  ██║╚██╗ ██╔╝██╔══██╗██║██╔══██╗██╔══██╗   ██╔════╝██╔═══██╗██╔══██╗██╔════╝",
+            "     ██║   ██║██╔██╗ ██║ ╚████╔╝ ██████╔╝██║██████╔╝██║  ██║   ██║     ██║   ██║██║  ██║█████╗  ",
+            "     ██║   ██║██║╚██╗██║  ╚██╔╝  ██╔══██╗██║██╔══██╗██║  ██║   ██║     ██║   ██║██║  ██║██╔══╝  ",
+            "     ██║   ██║██║ ╚████║   ██║   ██████╔╝██║██║  ██║██████╔╝   ╚██████╗╚██████╔╝██████╔╝███████╗",
+            "     ╚═╝   ╚═╝╚═╝  ╚═══╝   ╚═╝   ╚═════╝ ╚═╝╚═╝  ╚═╝╚═════╝     ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝",
+        ]
+
+    def interpolate_color(start_rgb, end_rgb, factor):
+        """Interpolate between two RGB colors"""
+        return [int(start_rgb[i] + (end_rgb[i] - start_rgb[i]) * factor) for i in range(3)]
+
+    def rgb_to_ansi(r: int, g: int, b: int, use_truecolor: bool):
+        """Convert RGB values to ANSI escape code"""
+        if use_truecolor:
+            return f"\033[38;2;{r};{g};{b}m"
+        else:
+            # Convert to 8-bit color (256 color palette)
+            # Simple approximation: map RGB to 216-color cube + grayscale
+            if r == g == b:
+                # Grayscale
+                gray = int(r / 255 * 23) + 232
+                return f"\033[38;5;{gray}m"
+            else:
+                # Color cube (6x6x6)
+                r_idx = int(r / 255 * 5)
+                g_idx = int(g / 255 * 5)
+                b_idx = int(b / 255 * 5)
+                color_idx = 16 + (36 * r_idx) + (6 * g_idx) + b_idx
+                return f"\033[38;5;{color_idx}m"
+
+    # Define start and end colors for smooth gradient
+    start_color = [0, 128, 128]  # Deep teal
+    end_color = [100, 190, 190]  # Light turquoise (balanced green and blue)
+
+    # Print each line with gradient for modern terminals, solid color for limited terminals
+    for line in banner:
+        colored_line = ""
+
+        if capabilities["truecolor"]:
+            # Use gradient for modern terminals
+            non_space_chars = sum(1 for char in line if char != " ")
+            char_count = 0
+
+            for char in line:
+                if char == " ":
+                    colored_line += char
+                    continue
+
+                # Calculate smooth gradient position (0.0 to 1.0)
+                if non_space_chars > 1:
+                    gradient_position = char_count / (non_space_chars - 1)
+                else:
+                    gradient_position = 0
+
+                # Interpolate color
+                current_rgb = interpolate_color(start_color, end_color, gradient_position)
+                color_code = rgb_to_ansi(*current_rgb, use_truecolor=True)  # type: ignore
+
+                colored_line += f"{color_code}{char}"
+                char_count += 1
+        else:
+            # Use solid color for limited terminals (like macOS Terminal)
+            solid_color = start_color  # Use the deep teal consistently
+            color_code = rgb_to_ansi(*solid_color, use_truecolor=False)  # type: ignore
+
+            for char in line:
+                if char == " ":
+                    colored_line += char
+                else:
+                    colored_line += f"{color_code}{char}"
+
+        click.echo(colored_line + reset)
+    click.echo()

tinybird-0.0.1.dev263/tinybird/tb/modules/agent/command_agent.py

@@ -0,0 +1,59 @@
+from pydantic_ai import Agent, RunContext, Tool
+from pydantic_ai.messages import ModelMessage
+from pydantic_ai.usage import Usage
+
+from tinybird.tb.modules.agent.animations import ThinkingAnimation
+from tinybird.tb.modules.agent.models import create_model
+from tinybird.tb.modules.agent.prompts import tests_files_prompt
+from tinybird.tb.modules.agent.tools.run_command import run_command
+from tinybird.tb.modules.agent.utils import TinybirdAgentContext
+from tinybird.tb.modules.project import Project
+
+
+class CommandAgent:
+    def __init__(
+        self,
+        token: str,
+        user_token: str,
+        host: str,
+        workspace_id: str,
+        project: Project,
+        dangerously_skip_permissions: bool,
+        prompt_mode: bool,
+        thinking_animation: ThinkingAnimation,
+    ):
+        self.token = token
+        self.user_token = user_token
+        self.host = host
+        self.dangerously_skip_permissions = dangerously_skip_permissions or prompt_mode
+        self.project = project
+        self.thinking_animation = thinking_animation
+        self.messages: list[ModelMessage] = []
+        self.agent = Agent(
+            model=create_model(user_token, host, workspace_id),
+            deps_type=TinybirdAgentContext,
+            instructions=[
+                """
+You are part of Tinybird Code, an agentic CLI that can help users to work with Tinybird.                 
+You are a sub-agent of the main Tinybird Code agent. You are responsible for running commands on the user's machine.
+You will be given a task to perform and you will use `run_command` tool to complete it.
+If you do not find a command that can solve the task, just say that there is no command that can solve the task.
+You can run `-h` in every level of the command to get help. E.g. `tb -h`, `tb datasource -h`, `tb datasource ls -h`.
+When you need to access Tinybird Cloud, add the `--cloud` flag. E.g. `tb --cloud datasource ls`.
+Token and host are not required to add to the commands.
+Always run first help commands to be sure that the commands you are running is not interactive.
+""",
+            ],
+            tools=[
+                Tool(run_command, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
+            ],
+        )
+
+        @self.agent.instructions
+        def get_tests_files(ctx: RunContext[TinybirdAgentContext]) -> str:
+            return tests_files_prompt(self.project)
+
+    def run(self, task: str, deps: TinybirdAgentContext, usage: Usage):
+        result = self.agent.run_sync(task, deps=deps, usage=usage, message_history=self.messages)
+        self.messages.extend(result.new_messages())
+        return result