tinybird 0.0.1.dev238__py3-none-any.whl → 0.0.1.dev240__py3-none-any.whl

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.dev238'
-__revision__ = 'e7b8c5b'
+__version__ = '0.0.1.dev240'
+__revision__ = '268407c'

tinybird/tb/client.py

@@ -1396,5 +1396,5 @@ class TinyB:
         self._req(f"/v0/tags/{name}", method="DELETE")
 
     def explore_data(self, prompt: str) -> str:
-        params = urlencode({"prompt": prompt, "host": self.host})
+        params = urlencode({"prompt": prompt, "host": self.host, "origin": "cli"})
         return self._req(f"/v1/agents/explore?{params}")

tinybird/tb/modules/agent/__init__.py

@@ -0,0 +1,3 @@
+from .agent import run_agent
+
+__all__ = ["run_agent"]

tinybird/tb/modules/agent/agent.py

@@ -0,0 +1,212 @@
+import sys
+from datetime import datetime
+
+import click
+from prompt_toolkit import prompt
+from prompt_toolkit.cursor_shapes import CursorShape
+from prompt_toolkit.styles import Style
+from pydantic_ai import Agent, Tool
+from pydantic_ai.messages import ModelMessage
+
+from tinybird.prompts import (
+    connection_instructions,
+    copy_pipe_instructions,
+    datasource_example,
+    datasource_instructions,
+    gcs_connection_example,
+    kafka_connection_example,
+    materialized_pipe_instructions,
+    pipe_example,
+    pipe_instructions,
+    s3_connection_example,
+    sink_pipe_instructions,
+)
+from tinybird.tb.modules.agent.banner import display_banner
+from tinybird.tb.modules.agent.client import TinybirdClient
+from tinybird.tb.modules.agent.memory import clear_history, load_history
+from tinybird.tb.modules.agent.models import create_model
+from tinybird.tb.modules.agent.prompts import datafile_instructions, plan_instructions, sql_instructions
+from tinybird.tb.modules.agent.tools.create_datafile import create_datafile
+from tinybird.tb.modules.agent.tools.explore import explore_data
+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.utils import TinybirdAgentContext
+from tinybird.tb.modules.feedback_manager import FeedbackManager
+
+
+class TinybirdAgent:
+    def __init__(self, token: str, host: str, folder: str):
+        self.token = token
+        self.host = host
+        self.folder = folder
+        self.messages: list[ModelMessage] = []
+        self.agent = Agent(
+            model=create_model(token, host),
+            deps_type=TinybirdAgentContext,
+            system_prompt=f"""
+You are a Tinybird Code, an agentic CLI that can help users to work with Tinybird.
+
+You are an interactive CLI tool that helps users with data engineering tasks. Use the instructions below and the tools available to you to assist the user.
+
+# Tone and style
+You should be concise, direct, and to the point. 
+Remember that your output will be displayed on a command line interface. Your responses can use Github-flavored markdown for formatting.
+Output text to communicate with the user; all text you output outside of tool use is displayed to the user. Only use tools to complete tasks. Never use tools like Bash or code comments as means to communicate with the user during the session.
+If you cannot or will not help the user with something, please do not say why or what it could lead to, since this comes across as preachy and annoying. Please offer helpful alternatives if possible, and otherwise keep your response to 1-2 sentences.
+IMPORTANT: You should minimize output tokens as much as possible while maintaining helpfulness, quality, and accuracy. Only address the specific query or task at hand, avoiding tangential information unless absolutely critical for completing the request. If you can answer in 1-3 sentences or a short paragraph, please do.
+IMPORTANT: You should NOT answer with unnecessary preamble or postamble (such as explaining your code or summarizing your action), unless the user asks you to.
+IMPORTANT: Keep your responses short, since they will be displayed on a command line interface. You MUST answer concisely with fewer than 4 lines (not including tool use or code generation), unless user asks for detail. Answer the user's question directly, without elaboration, explanation, or details. One word answers are best. Avoid introductions, conclusions, and explanations. You MUST avoid text before/after your response, such as "The answer is <answer>.", "Here is the content of the file..." or "Based on the information provided, the answer is..." or "Here is what I will do next...". Here are some examples to demonstrate appropriate verbosity:
+
+# Proactiveness
+You are allowed to be proactive, but only when the user asks you to do something. You should strive to strike a balance between:
+Doing the right thing when asked, including taking actions and follow-up actions
+Not surprising the user with actions you take without asking
+For example, if the user asks you how to approach something, you should do your best to answer their question first, and not immediately jump into taking actions.
+Do not add additional code explanation summary unless requested by the user. After working on a file, just stop, rather than providing an explanation of what you did.
+
+# Code style
+IMPORTANT: DO NOT ADD ANY COMMENTS unless asked by the user.
+
+# Tools
+You have access to the following tools:
+1. `explore_data` - Explore data in the current workspace
+2. `preview_datafile` - Preview the content of a datafile (datasource, endpoint, materialized, sink, copy, connection).
+3. `create_datafile` - Create a file in the project folder. Confirmation will be asked by the tool before creating the file.
+4. `plan` - Plan the creation or update of resources.
+
+
+# When creating or updating datafiles:
+1. Use `plan` tool to plan the creation or update of resources.
+2. If the user confirms the plan, go from 3 to 7 steps until all the resources are created, updated or skipped.
+3. Use `preview_datafile` tool to preview the content of a datafile.
+4. Without asking, use the `create_datafile` tool to create the datafile, because it will ask for confirmation before creating the file.
+5. Check the result of the `create_datafile` tool to see if the datafile was created successfully.
+6. If the datafile was created successfully, report the result to the user.
+7. If the datafile was not created successfully, finish the process and just wait for a new user prompt.
+
+IMPORTANT: If the user cancels some of the steps or there is an error, DO NOT continue with the plan. Stop the process and wait for the user before using any other tool.
+
+# When planning the creation or update of resources:
+{plan_instructions}
+{datafile_instructions}
+
+# Working with datasource files:
+{datasource_instructions}
+{datasource_example}
+
+# Working with any type of pipe file:
+{pipe_instructions}
+{pipe_example}
+
+# Working with materialized pipe files:
+{materialized_pipe_instructions}
+
+# Working with sink pipe files:
+{sink_pipe_instructions}
+
+# Working with copy pipe files:
+{copy_pipe_instructions}
+
+# Working with SQL queries:
+{sql_instructions}
+
+# Working with connections files:
+{connection_instructions}
+
+# Connection examples:
+Kafka: {kafka_connection_example}
+S3: {s3_connection_example}
+GCS: {gcs_connection_example}
+
+# Info
+Today is {datetime.now().strftime("%Y-%m-%d")}
+""",
+            tools=[
+                Tool(explore_data, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
+                Tool(preview_datafile, docstring_format="google", require_parameter_descriptions=True, takes_ctx=False),
+                Tool(create_datafile, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
+                Tool(plan, docstring_format="google", require_parameter_descriptions=True, takes_ctx=False),
+            ],
+        )
+
+    def _keep_recent_messages(self) -> list[ModelMessage]:
+        """Keep only the last 5 messages to manage token usage."""
+        return self.messages[-5:] if len(self.messages) > 5 else self.messages
+
+    def run(self, user_prompt: str) -> None:
+        result = self.agent.run_sync(
+            user_prompt,
+            deps=TinybirdAgentContext(
+                client=TinybirdClient(token=self.token, host=self.host),
+                folder=self.folder,
+            ),
+            message_history=self.messages,
+        )
+        new_messages = result.new_messages()
+        self.messages.extend(new_messages)
+        click.echo("\n")
+        click.echo(result.output)
+        click.echo("\n")
+
+
+def run_agent(token: str, host: str, folder: str):
+    display_banner()
+
+    try:
+        agent = TinybirdAgent(token, host, folder)
+        click.echo()
+        click.echo(FeedbackManager.success(message="Welcome to Tinybird Code"))
+        click.echo(FeedbackManager.info(message="Describe what you want to create and I'll help you build it"))
+        click.echo(FeedbackManager.info(message="Commands: 'exit', 'quit', 'help', or Ctrl+C to exit"))
+        click.echo()
+
+    except Exception as e:
+        click.echo(FeedbackManager.error(message=f"Failed to initialize agent: {e}"))
+        return
+
+    # Interactive loop
+    try:
+        while True:
+            try:
+                user_input = prompt(
+                    [("class:prompt", "tb » ")],
+                    history=load_history(),
+                    cursor=CursorShape.BLOCK,
+                    style=Style.from_dict(
+                        {
+                            "prompt": "#40a8a8 bold",
+                            "": "",  # Normal color for user input
+                        }
+                    ),
+                )
+
+                if user_input.lower() in ["exit", "quit"]:
+                    click.echo(FeedbackManager.info(message="Goodbye!"))
+                    break
+                elif user_input.lower() == "clear":
+                    clear_history()
+                    continue
+                elif user_input.lower() == "help":
+                    click.echo()
+                    click.echo(FeedbackManager.info(message="Tinybird Code Help:"))
+                    click.echo("• Describe what you want to create: 'Create a user analytics system'")
+                    click.echo("• Ask for specific resources: 'Create a pipe to aggregate daily clicks'")
+                    click.echo("• Request data sources: 'Set up a Kafka connection for events'")
+                    click.echo("• Type 'exit' or 'quit' to leave")
+                    click.echo()
+                    continue
+                elif user_input.strip() == "":
+                    continue
+                else:
+                    agent.run(user_input)
+
+            except KeyboardInterrupt:
+                click.echo(FeedbackManager.info(message="Goodbye!"))
+                break
+            except EOFError:
+                click.echo(FeedbackManager.info(message="Goodbye!"))
+                break
+
+    except Exception as e:
+        click.echo(FeedbackManager.error(message=f"Error: {e}"))
+        sys.exit(1)

tinybird/tb/modules/agent/banner.py

@@ -0,0 +1,55 @@
+import click
+
+
+def display_banner():
+    reset = "\033[0m"
+
+    click.echo("\n")
+    # The Tinybird Code ASCII art banner
+    banner = [
+        "  ████████╗██╗███╗   ██╗██╗   ██╗██████╗ ██╗██████╗ ██████╗     ██████╗ ██████╗ ██████╗ ███████╗",
+        "  ╚══██╔══╝██║████╗  ██║╚██╗ ██╔╝██╔══██╗██║██╔══██╗██╔══██╗   ██╔════╝██╔═══██╗██╔══██╗██╔════╝",
+        "     ██║   ██║██╔██╗ ██║ ╚████╔╝ ██████╔╝██║██████╔╝██║  ██║   ██║     ██║   ██║██║  ██║█████╗  ",
+        "     ██║   ██║██║╚██╗██║  ╚██╔╝  ██╔══██╗██║██╔══██╗██║  ██║   ██║     ██║   ██║██║  ██║██╔══╝  ",
+        "     ██║   ██║██║ ╚████║   ██║   ██████╔╝██║██║  ██║██████╔╝   ╚██████╗╚██████╔╝██████╔╝███████╗",
+        "     ╚═╝   ╚═╝╚═╝  ╚═══╝   ╚═╝   ╚═════╝ ╚═╝╚═╝  ╚═╝╚═════╝     ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝",
+    ]
+
+    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, g, b):
+        """Convert RGB values to ANSI escape code"""
+        return f"\033[38;2;{r};{g};{b}m"
+
+    # Define start and end colors for smooth gradient
+    start_color = [0, 128, 128]  # Deep teal
+    end_color = [100, 200, 180]  # Light turquoise
+
+    # Print each line with a very smooth horizontal gradient
+    for line in banner:
+        colored_line = ""
+        # Count non-space characters for gradient calculation
+        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)
+
+            colored_line += f"{color_code}{char}"
+            char_count += 1
+
+        click.echo(colored_line + reset)

tinybird/tb/modules/agent/client.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+import httpx
+
+
+@dataclass
+class TinybirdClient:
+    def __init__(self, host: str, token: str):
+        self.host = host
+        self.token = token
+        self.client = httpx.Client(
+            timeout=30.0,
+            headers={"Accept": "application/json", "User-Agent": "Python/APIClient"},
+        )
+        self.insights: list[str] = []
+
+    def __aenter__(self):
+        return self
+
+    def __aexit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def close(self):
+        """Close the underlying HTTP client."""
+        self.client.close()
+
+    def _get(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> str:
+        if params is None:
+            params = {}
+        params["token"] = self.token
+        url = f"{self.host}{endpoint}"
+        response = self.client.get(url, params=params)
+        try:
+            response.raise_for_status()
+        except Exception as e:
+            raise Exception(response.json().get("error", str(e))) from e
+        return response.text
+
+    def explore_data(self, prompt: str) -> str:
+        params = {"prompt": prompt, "host": self.host, "origin": "cli"}
+        return self._get("/v1/agents/explore", params)

tinybird/tb/modules/agent/memory.py

@@ -0,0 +1,41 @@
+from pathlib import Path
+from typing import Optional
+
+from prompt_toolkit.history import FileHistory
+
+
+def get_history_file_path():
+    """Get the history file path based on current working directory"""
+    # Get current working directory
+    cwd = Path.cwd()
+
+    # Get user's home directory
+    home = Path.home()
+
+    # Calculate relative path from home to current directory
+    try:
+        relative_path = cwd.relative_to(home)
+    except ValueError:
+        # If current directory is not under home, use absolute path components
+        relative_path = Path(*cwd.parts[1:]) if cwd.is_absolute() else cwd
+
+    # Create history directory structure
+    history_dir = home / ".tinybird" / "projects" / relative_path
+    history_dir.mkdir(parents=True, exist_ok=True)
+
+    # Return history file path
+    return history_dir / "history.txt"
+
+
+def load_history() -> Optional[FileHistory]:
+    try:
+        history_file = get_history_file_path()
+        return FileHistory(str(history_file))
+    except Exception:
+        return None
+
+
+def clear_history():
+    """Clear the history file"""
+    history_file = get_history_file_path()
+    history_file.unlink(missing_ok=True)

tinybird/tb/modules/agent/models.py

@@ -0,0 +1,20 @@
+from anthropic import AsyncAnthropic
+from httpx import AsyncClient
+from pydantic_ai.models.anthropic import AnthropicModel, AnthropicModelName
+from pydantic_ai.providers.anthropic import AnthropicProvider
+
+
+def create_model(
+    token: str,
+    base_url: str = "https://api.wadus3.aws.tinybird.co",
+    model: AnthropicModelName = "claude-4-sonnet-20250514",
+):
+    client = AsyncAnthropic(
+        base_url=base_url,
+        http_client=AsyncClient(params={"token": token}),
+        auth_token=token,
+    )
+    return AnthropicModel(
+        model_name=model,
+        provider=AnthropicProvider(anthropic_client=client),
+    )

tinybird/tb/modules/agent/prompts.py

@@ -0,0 +1,83 @@
+plan_instructions = """
+When asked to create a plan, you MUST respond with this EXACT format and NOTHING ELSE:
+
+PLAN_DESCRIPTION: [One sentence describing what will be built]
+
+STEPS:
+1. CREATE_DATASOURCE: [name] - [description] - DEPENDS_ON: none
+2. CREATE_ENDPOINT: [name] - [description] - DEPENDS_ON: [resource_name]
+3. CREATE_MATERIALIZED_PIPE: [name] - [description] - DEPENDS_ON: [resource_name]
+4. CREATE_MATERIALIZED_DATASOURCE: [name] - [description] - DEPENDS_ON: [resource_name]
+5. CREATE_SINK: [name] - [description] - DEPENDS_ON: [resource_name]
+6. CREATE_COPY: [name] - [description] - DEPENDS_ON: [resource_name]
+7. CREATE_CONNECTION: [name] - [description] - DEPENDS_ON: none
+
+You can skip steps where resources will not be created or updated.
+
+ESTIMATED_RESOURCES: [total number of steps]
+
+RESOURCE_DEPENDENCIES:
+[resource_name]: [resource_name]
+"""
+
+
+sql_instructions = """
+<sql_instructions>
+    - The SQL query must be a valid ClickHouse SQL query that mixes ClickHouse syntax and Tinybird templating syntax (Tornado templating language under the hood).
+    - SQL queries with parameters must start with "%" character and a newline on top of every query to be able to use the parameters. Examples:
+    <invalid_query_with_parameters_no_%_on_top>
+    SELECT * FROM events WHERE session_id={{String(my_param, "default_value")}}
+    </invalid_query_with_parameters_no_%_on_top>
+    <valid_query_with_parameters_with_%_on_top>
+    %
+    SELECT * FROM events WHERE session_id={{String(my_param, "default_value")}}
+    </valid_query_with_parameters_with_%_on_top>
+    - The Parameter functions like this one {{String(my_param_name,default_value)}} can be one of the following: String, DateTime, Date, Float32, Float64, Int, Integer, UInt8, UInt16, UInt32, UInt64, UInt128, UInt256, Int8, Int16, Int32, Int64, Int128, Int256
+    - Parameter names must be different from column names. Pass always the param name and a default value to the function.
+    - Use ALWAYS hardcoded values for default values for parameters.
+    - Code inside the template {{template_expression}} follows the rules of Tornado templating language so no module is allowed to be imported. So for example you can't use now() as default value for a DateTime parameter. You need an if else block like this:
+    <invalid_condition_with_now>
+    AND timestamp BETWEEN {{DateTime(start_date, now() - interval 30 day)}} AND {{DateTime(end_date, now())}}
+    </invalid_condition_with_now>
+    <valid_condition_without_now>
+    {{%if not defined(start_date)%}}
+    timestamp BETWEEN now() - interval 30 day
+    {{%else%}}
+    timestamp BETWEEN {{DateTime(start_date)}}
+    {{%end%}}
+    {{%if not defined(end_date)%}}
+    AND now()
+    {{%else%}}
+    AND {{DateTime(end_date)}}
+    {{%end%}}
+    </valid_condition_without_now>
+    - Parameters must not be quoted.
+    - When you use defined function with a paremeter inside, do NOT add quotes around the parameter:
+    <invalid_defined_function_with_parameter>{{% if defined('my_param') %}}</invalid_defined_function_with_parameter>
+    <valid_defined_function_without_parameter>{{% if defined(my_param) %}}</valid_defined_function_without_parameter>
+    - Use datasource names as table names when doing SELECT statements.
+    - Do not use pipe names as table names.
+    - The available datasource names to use in the SQL are the ones present in the existing_resources section or the ones you will create.
+    - Use node names as table names only when nodes are present in the same file.
+    - Do not reference the current node name in the SQL.
+    - SQL queries only accept SELECT statements with conditions, aggregations, joins, etc.
+    - Do NOT use CREATE TABLE, INSERT INTO, CREATE DATABASE, etc.
+    - Use ONLY SELECT statements in the SQL section.
+    - INSERT INTO is not supported in SQL section.
+    - When using functions try always ClickHouse functions first, then SQL functions.
+    - Parameters are never quoted in any case.
+    - Use the following syntax in the SQL section for the iceberg table function: iceberg('s3://bucket/path/to/table', {{tb_secret('aws_access_key_id')}}, {{tb_secret('aws_secret_access_key')}})
+    - Use the following syntax in the SQL section for the postgres table function: postgresql('host:port', 'database', 'table', {{tb_secret('db_username')}}, {{tb_secret('db_password')}}), 'schema')
+</sql_instructions>
+"""
+
+datafile_instructions = """
+<datafile_instructions>
+- Endpoint files will be created under the `/endpoints` folder.
+- Materialized pipe files will be created under the `/materialized` folder.
+- Sink pipe files will be created under the `/sinks` folder.
+- Copy pipe files will be created under the `/copies` folder.
+- Connection files will be created under the `/connections` folder.
+- Datasource files will be created under the `/datasources` folder.
+</datafile_instructions>
+"""

tinybird/tb/modules/agent/tools/create_datafile.py

@@ -0,0 +1,62 @@
+from pathlib import Path
+
+import click
+from pydantic_ai import RunContext
+
+from tinybird.tb.modules.agent.utils import Datafile, TinybirdAgentContext, show_options
+
+
+def get_resource_confirmation(resource: Datafile) -> bool:
+    """Get user confirmation for creating a resource"""
+    while True:
+        result = show_options(
+            options=[f"Yes, create {resource.type} '{resource.name}'", "No, and tell Tinybird Code what to do"],
+            title=f"What would you like to do with {resource.type} '{resource.name}'?",
+        )
+
+        if result is None:  # Cancelled
+            return False
+
+        if result.startswith("Yes"):
+            return True
+        elif result.startswith("No"):
+            return False
+
+        return False
+
+
+def create_datafile(ctx: RunContext[TinybirdAgentContext], resource: Datafile) -> str:
+    """Given a resource representation, create a file in the project folder
+
+    Args:
+        resource (Datafile): The resource to create. Required.
+
+    Returns:
+        str: If the resource was created or not.
+    """
+    try:
+        click.echo()
+        click.echo(resource.content)
+        confirmation = get_resource_confirmation(resource)
+
+        if not confirmation:
+            return f"Resource {resource.pathname} was not created. User cancelled creation."
+
+        resource.pathname = resource.pathname.removeprefix("/")
+
+        path = Path(ctx.deps.folder) / resource.pathname
+
+        folder_path = path.parent
+
+        if not folder_path.exists():
+            folder_path.mkdir()
+
+        if not path.exists():
+            path.touch()
+
+        path.write_text(resource.content)
+
+        return f"Created {resource.pathname}"
+
+    except Exception as e:
+        return f"Error creating {resource.pathname}: {e}"

tinybird/tb/modules/agent/tools/explore.py

@@ -0,0 +1,15 @@
+from pydantic_ai import RunContext
+
+from tinybird.tb.modules.agent.utils import TinybirdAgentContext
+
+
+def explore_data(ctx: RunContext[TinybirdAgentContext], prompt: str):
+    """Explore production data in the current workspace
+
+    Args:
+        prompt (str): The prompt to explore data with. Required.
+
+    Returns:
+        str: The result of the exploration.
+    """
+    return ctx.deps.client.explore_data(prompt)

tinybird/tb/modules/agent/tools/plan.py

@@ -0,0 +1,45 @@
+import click
+
+from tinybird.tb.modules.agent.utils import show_options
+
+
+def get_plan_confirmation() -> bool:
+    """Get user confirmation for implementing a plan"""
+    while True:
+        result = show_options(
+            options=["Yes, implement the plan", "No, and tell Tinybird Code what to do"],
+            title="Do you want to implement the plan?",
+        )
+
+        if result is None:  # Cancelled
+            return False
+
+        if result.startswith("Yes"):
+            return True
+        elif result.startswith("No"):
+            return False
+
+        return False
+
+
+def plan(plan: str) -> str:
+    """Given a plan, ask the user for confirmation to implement it
+
+    Args:
+        plan (str): The plan to implement. Required.
+
+    Returns:
+        str: If the plan was implemented or not.
+    """
+    try:
+        click.echo()
+        click.echo(plan)
+        confirmation = get_plan_confirmation()
+
+        if not confirmation:
+            return "Plan was not implemented. User cancelled implementation."
+
+        return "User confirmed the plan. Implementing..."
+
+    except Exception as e:
+        return f"Error implementing the plan: {e}"

tinybird/tb/modules/agent/tools/preview_datafile.py

@@ -0,0 +1,24 @@
+from tinybird.tb.modules.agent.utils import Datafile
+
+
+def preview_datafile(name: str, type: str, description: str, content: str, pathname: str) -> Datafile:
+    """Preview the content of a datafile before creating it
+
+    Args:
+        name (str): The name of the datafile. Required.
+        type (str): The type of the datafile. Options: datasource, endpoint, materialized, sink, copy, connection. Required.
+        description (str): The description of the datafile. Required.
+        content (str): The content of the datafile. Required.
+        pathname (str): The pathname of the datafile where the file will be created. Required.
+
+    Returns:
+        Datafile: The datafile preview.
+    """
+
+    return Datafile(
+        type=type,
+        name=name,
+        content=content,
+        description=description,
+        pathname=pathname,
+    )

tinybird/tb/modules/agent/utils.py

@@ -0,0 +1,382 @@
+import os
+from contextlib import contextmanager
+from typing import Any, List, Optional
+
+import click
+from prompt_toolkit.application import Application, get_app
+from prompt_toolkit.filters import IsDone
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout import Layout
+from prompt_toolkit.layout.containers import ConditionalContainer, HSplit, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.layout.dimension import LayoutDimension as D
+from prompt_toolkit.mouse_events import MouseEventType
+from prompt_toolkit.patch_stdout import patch_stdout as pt_patch_stdout
+from prompt_toolkit.shortcuts import PromptSession
+from prompt_toolkit.styles import Style
+from pydantic import BaseModel, Field
+
+from tinybird.tb.modules.agent.client import TinybirdClient
+
+
+class TinybirdAgentContext(BaseModel):
+    client: TinybirdClient
+    folder: str
+
+
+default_style = Style.from_dict(
+    {
+        "separator": "#6C6C6C",
+        "questionmark": "#FF9D00 bold",
+        "selected": "#5F819D",
+        "pointer": "#FF9D00 bold",
+        "instruction": "",  # default
+        "answer": "#5F819D bold",
+        "question": "",
+    }
+)
+
+
+def if_mousedown(handler):
+    def handle_if_mouse_down(mouse_event):
+        if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
+            return handler(mouse_event)
+        else:
+            return NotImplemented
+
+    return handle_if_mouse_down
+
+
+class Separator:
+    line = "-" * 15
+
+    def __init__(self, line=None):
+        if line:
+            self.line = line
+
+    def __str__(self):
+        return self.line
+
+
+class PromptParameterException(ValueError):
+    def __init__(self, message, errors=None):
+        # Call the base class constructor with the parameters it needs
+        super().__init__("You must provide a `%s` value" % message, errors)
+
+
+class InquirerControl(FormattedTextControl):
+    def __init__(self, choices, default, **kwargs):
+        self.selected_option_index = 0
+        self.answered = False
+        self.choices = choices
+        self._init_choices(choices, default)
+        super().__init__(self._get_choice_tokens, **kwargs)
+
+    def _init_choices(self, choices, default):
+        # helper to convert from question format to internal format
+        self.choices = []  # list (name, value, disabled)
+        searching_first_choice = True
+        for i, c in enumerate(choices):
+            if isinstance(c, Separator):
+                self.choices.append((c, None, None))
+            else:
+                if isinstance(c, str):
+                    self.choices.append((c, c, None))
+                else:
+                    name = c.get("name")
+                    value = c.get("value", name)
+                    disabled = c.get("disabled", None)
+                    self.choices.append((name, value, disabled))
+                    if value == default:
+                        self.selected_option_index = i
+                        searching_first_choice = False
+                if searching_first_choice:
+                    self.selected_option_index = i  # found the first choice
+                    searching_first_choice = False
+                if default and (default in (i, c)):
+                    self.selected_option_index = i  # default choice exists
+                    searching_first_choice = False
+
+    @property
+    def choice_count(self):
+        return len(self.choices)
+
+    def _get_choice_tokens(self):
+        tokens: list[Any] = []
+
+        def append(index, choice):
+            selected = index == self.selected_option_index
+
+            @if_mousedown
+            def select_item(mouse_event):
+                # bind option with this index to mouse event
+                self.selected_option_index = index
+                self.answered = True
+                get_app().exit(result=self.get_selection()[0])
+
+            if isinstance(choice[0], Separator):
+                tokens.append(("class:separator", "  %s\n" % choice[0]))
+            else:
+                tokens.append(
+                    (
+                        "",
+                        " \u276f " if selected else "   ",
+                    )
+                )
+                if selected:
+                    tokens.append(("[SetCursorPosition]", ""))
+                if choice[2]:  # disabled
+                    tokens.append(
+                        (
+                            "",
+                            "- %s (%s)" % (choice[0], choice[2]),
+                        )
+                    )
+                else:
+                    try:
+                        tokens.append(
+                            (
+                                "",
+                                str(choice[0]),
+                                select_item,
+                            )
+                        )
+                    except Exception:
+                        tokens.append(
+                            (
+                                "",
+                                choice[0],
+                                select_item,
+                            )
+                        )
+                tokens.append(("", "\n"))
+
+        # prepare the select choices
+        for i, choice in enumerate(self.choices):
+            append(i, choice)
+        tokens.pop()  # Remove last newline.
+        return tokens
+
+    def get_selection(self):
+        return self.choices[self.selected_option_index]
+
+
+def prompt_question(message, **kwargs):
+    # TODO disabled, dict choices
+    if "choices" not in kwargs:
+        raise PromptParameterException("choices")
+
+    choices = kwargs.pop("choices", None)
+    default = kwargs.pop("default", None)
+    style = kwargs.pop("style", default_style)
+
+    ic = InquirerControl(choices, default=default)
+
+    def get_prompt_tokens():
+        tokens = []
+
+        tokens.append(("class:question", " %s " % message))
+        if ic.answered:
+            tokens.append(("class:answer", " " + ic.get_selection()[0]))
+        else:
+            tokens.append(("class:instruction", " (Use arrow keys)"))
+        return tokens
+
+    # assemble layout
+    layout = HSplit(
+        [
+            Window(height=D.exact(1), content=FormattedTextControl(get_prompt_tokens)),
+            ConditionalContainer(Window(ic), filter=~IsDone()),
+        ]
+    )
+
+    # key bindings
+    kb = KeyBindings()
+
+    @kb.add("c-q", eager=True)
+    @kb.add("c-c", eager=True)
+    def _(event):
+        raise KeyboardInterrupt()
+        # event.app.exit(result=None)
+
+    @kb.add("down", eager=True)
+    def move_cursor_down(event):
+        def _next():
+            ic.selected_option_index = (ic.selected_option_index + 1) % ic.choice_count
+
+        _next()
+        while isinstance(ic.choices[ic.selected_option_index][0], Separator) or ic.choices[ic.selected_option_index][2]:
+            _next()
+
+    @kb.add("up", eager=True)
+    def move_cursor_up(event):
+        def _prev():
+            ic.selected_option_index = (ic.selected_option_index - 1) % ic.choice_count
+
+        _prev()
+        while isinstance(ic.choices[ic.selected_option_index][0], Separator) or ic.choices[ic.selected_option_index][2]:
+            _prev()
+
+    @kb.add("enter", eager=True)
+    def set_answer(event):
+        ic.answered = True
+        event.app.exit(result=ic.get_selection()[1])
+
+    return Application(layout=Layout(layout), key_bindings=kb, mouse_support=True, style=style)
+
+
+def prompt(questions, answers=None, **kwargs):
+    if isinstance(questions, dict):
+        questions = [questions]
+    answers = answers or {}
+
+    patch_stdout = kwargs.pop("patch_stdout", False)
+    kbi_msg = kwargs.pop("keyboard_interrupt_msg", "Cancelled by user")
+    raise_kbi = kwargs.pop("raise_keyboard_interrupt", False)
+
+    for question in questions:
+        # import the question
+        if "type" not in question:
+            raise PromptParameterException("type")
+        if "name" not in question:
+            raise PromptParameterException("name")
+        if "message" not in question:
+            raise PromptParameterException("message")
+        try:
+            choices = question.get("choices")
+            if choices is not None and callable(choices):
+                question["choices"] = choices(answers)
+
+            _kwargs = {}
+            _kwargs.update(kwargs)
+            _kwargs.update(question)
+            type_ = _kwargs.pop("type")
+            name = _kwargs.pop("name")
+            message = _kwargs.pop("message")
+            when = _kwargs.pop("when", None)
+            filter = _kwargs.pop("filter", None)
+
+            if when:
+                # at least a little sanity check!
+                if callable(question["when"]):
+                    try:
+                        if not question["when"](answers):
+                            continue
+                    except Exception as e:
+                        raise ValueError("Problem in 'when' check of %s question: %s" % (name, e))
+                else:
+                    raise ValueError("'when' needs to be function that accepts a dict argument")
+            if filter and not callable(question["filter"]):
+                raise ValueError("'filter' needs to be function that accepts an argument")
+
+            if callable(question.get("default")):
+                _kwargs["default"] = question["default"](answers)
+
+            with pt_patch_stdout() if patch_stdout else _dummy_context_manager():
+                result = prompt_question(message, **_kwargs)
+
+                if isinstance(result, PromptSession):
+                    answer = result.prompt()
+                elif isinstance(result, Application):
+                    answer = result.run()
+                else:
+                    # assert isinstance(answer, str)
+                    answer = result
+
+                # answer = application.run(
+                #    return_asyncio_coroutine=return_asyncio_coroutine,
+                #    true_color=true_color,
+                #    refresh_interval=refresh_interval)
+
+            if answer is not None:
+                if filter:
+                    try:
+                        answer = question["filter"](answer)
+                    except Exception as e:
+                        raise ValueError("Problem processing 'filter' of %s question: %s" % (name, e))
+                answers[name] = answer
+        except AttributeError:
+            raise ValueError("No question type '%s'" % type_)
+        except KeyboardInterrupt as exc:
+            if raise_kbi:
+                raise exc from None
+            if kbi_msg:
+                click.echo(kbi_msg)
+            return {}
+    return answers
+
+
+@contextmanager
+def _dummy_context_manager():
+    yield
+
+
+def show_options(options: List[str], title: str = "Select an option") -> Optional[str]:
+    questions = [
+        {
+            "type": "list",
+            "name": "option",
+            "message": title,
+            "choices": options,
+        }
+    ]
+    result = prompt(questions)
+
+    if "option" not in result:
+        return None
+
+    return result["option"]
+
+
+def load_existing_resources(folder: str) -> str:
+    """Load existing Tinybird resources from the workspace"""
+    existing_resources = []
+
+    # Check for datasources
+    datasources_dir = os.path.join(folder, "datasources")
+    if os.path.exists(datasources_dir):
+        for file in os.listdir(datasources_dir):
+            if file.endswith(".datasource"):
+                file_path = os.path.join(datasources_dir, file)
+                try:
+                    with open(file_path, "r") as f:
+                        existing_resources.append(f"DATASOURCE {file}:\n{f.read()}\n")
+                except Exception as e:
+                    click.echo(f"Warning: Could not read {file_path}: {e}")
+
+    # Check for pipes
+    pipes_dir = os.path.join(folder, "pipes")
+    if os.path.exists(pipes_dir):
+        for file in os.listdir(pipes_dir):
+            if file.endswith(".pipe"):
+                file_path = os.path.join(pipes_dir, file)
+                try:
+                    with open(file_path, "r") as f:
+                        existing_resources.append(f"PIPE {file}:\n{f.read()}\n")
+                except Exception as e:
+                    click.echo(f"Warning: Could not read {file_path}: {e}")
+
+    # Check for connections
+    connections_dir = os.path.join(folder, "connections")
+    if os.path.exists(connections_dir):
+        for file in os.listdir(connections_dir):
+            if file.endswith(".connection"):
+                file_path = os.path.join(connections_dir, file)
+                try:
+                    with open(file_path, "r") as f:
+                        existing_resources.append(f"CONNECTION {file}:\n{f.read()}\n")
+                except Exception as e:
+                    click.echo(f"Warning: Could not read {file_path}: {e}")
+
+    return "\n".join(existing_resources)
+
+
+class Datafile(BaseModel):
+    """Represents a generated Tinybird datafile"""
+
+    type: str
+    name: str
+    content: str
+    description: str
+    pathname: str
+    dependencies: List[str] = Field(default_factory=list)

tinybird/tb/modules/cli.py

@@ -196,7 +196,7 @@ def cli(
     is_agent_mode = agent_mode_flag and ctx.invoked_subcommand is None
 
     if is_agent_mode:
-        run_agent(config)
+        run_agent(config.get("token", None), config["host"], str(project.path))
 
 
 @cli.command(hidden=True)

tinybird/tb/modules/local.py

@@ -1,4 +1,5 @@
 import subprocess
+from pathlib import Path
 
 import click
 import requests
@@ -148,6 +149,11 @@ def remove() -> None:
 )
 def start(use_aws_creds: bool, volumes_path: str) -> None:
     """Start Tinybird Local"""
+    if volumes_path is not None:
+        absolute_path = Path(volumes_path).absolute()
+        absolute_path.mkdir(parents=True, exist_ok=True)
+        volumes_path = str(absolute_path)
+
     click.echo(FeedbackManager.highlight(message="» Starting Tinybird Local..."))
     docker_client = get_docker_client()
     start_tinybird_local(docker_client, use_aws_creds, volumes_path)
@@ -168,6 +174,11 @@ def start(use_aws_creds: bool, volumes_path: str) -> None:
 )
 def restart(use_aws_creds: bool, volumes_path: str) -> None:
     """Restart Tinybird Local"""
+    if volumes_path is not None:
+        absolute_path = Path(volumes_path).absolute()
+        absolute_path.mkdir(parents=True, exist_ok=True)
+        volumes_path = str(absolute_path)
+
     click.echo(FeedbackManager.highlight(message="» Restarting Tinybird Local..."))
     docker_client = get_docker_client()
     remove_tinybird_local(docker_client, volumes_path is not None)

{tinybird-0.0.1.dev238.dist-info → tinybird-0.0.1.dev240.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tinybird
-Version: 0.0.1.dev238
+Version: 0.0.1.dev240
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/forward/commands
 Author: Tinybird
@@ -8,7 +8,7 @@ Author-email: support@tinybird.co
 Requires-Python: >=3.9, <3.14
 Description-Content-Type: text/x-rst
 Requires-Dist: aiofiles==24.1.0
-Requires-Dist: anthropic==0.42.0
+Requires-Dist: anthropic==0.55.0
 Requires-Dist: boto3
 Requires-Dist: click<8.2,>=8.1.6
 Requires-Dist: clickhouse-toolset==0.34.dev0
@@ -20,7 +20,8 @@ Requires-Dist: docker==7.1.0
 Requires-Dist: GitPython~=3.1.32
 Requires-Dist: humanfriendly~=8.2
 Requires-Dist: prompt_toolkit==3.0.48
-Requires-Dist: pydantic~=2.8.0
+Requires-Dist: pydantic~=2.11.7
+Requires-Dist: pydantic-ai-slim[anthropic]~=0.3.1
 Requires-Dist: pyperclip==1.8.2
 Requires-Dist: pyyaml<6.1,>=6.0
 Requires-Dist: requests<3,>=2.28.1

{tinybird-0.0.1.dev238.dist-info → tinybird-0.0.1.dev240.dist-info}/RECORD

@@ -17,15 +17,14 @@ tinybird/datafile/exceptions.py,sha256=8rw2umdZjtby85QbuRKFO5ETz_eRHwUY5l7eHsy1w
 tinybird/datafile/parse_connection.py,sha256=tRyn2Rpr1TeWet5BXmMoQgaotbGdYep1qiTak_OqC5E,1825
 tinybird/datafile/parse_datasource.py,sha256=ssW8QeFSgglVFi3sDZj_HgkJiTJ2069v2JgqnH3CkDE,1825
 tinybird/datafile/parse_pipe.py,sha256=xf4m0Tw44QWJzHzAm7Z7FwUoUUtr7noMYjU1NiWnX0k,3880
-tinybird/tb/__cli__.py,sha256=5Idbq2jxT7vdWTl7jfPYf2dt09IXEqHf7N0np87IKH4,247
+tinybird/tb/__cli__.py,sha256=OB0M6HqPur6rsd93Mf9BRpLf5zvrZ_aq4HvYd7nAacc,247
 tinybird/tb/check_pypi.py,sha256=Gp0HkHHDFMSDL6nxKlOY51z7z1Uv-2LRexNTZSHHGmM,552
 tinybird/tb/cli.py,sha256=FdDFEIayjmsZEVsVSSvRiVYn_FHOVg_zWQzchnzfWho,1008
-tinybird/tb/client.py,sha256=gdfZjLkobXZgqhnXAESj0AEGTSSMTnYK3fmCMJ4gjI4,54129
+tinybird/tb/client.py,sha256=pJbdkWMXGAqKseNAvdsRRnl_c7I-DCMB0dWCQnG82nU,54146
 tinybird/tb/config.py,sha256=mhMTGnMB5KcxGoh3dewIr2Jjsa6pHE183gCPAQWyp6o,3973
-tinybird/tb/modules/agent.py,sha256=RE_QlGSq6MByEaOBUbr1dSr3X2bi09-QvzoxpxQtyPs,3900
 tinybird/tb/modules/build.py,sha256=MxGQY-KII4lYut-yOWGBIHFpg-m_cfHgpE7lwOzZCeQ,19871
 tinybird/tb/modules/cicd.py,sha256=0KLKccha9IP749QvlXBmzdWv1On3mFwMY4DUcJlBxiE,7326
-tinybird/tb/modules/cli.py,sha256=SgXaNjyX1ba3Uvmjpc-ViG1NLbscw394mH1vBj-A2JI,16335
+tinybird/tb/modules/cli.py,sha256=_-kj4PSN_OPYk__WYgFfzLsDJfy4cQfveZg6tTOc220,16389
 tinybird/tb/modules/common.py,sha256=jTTaDDHrZREt--032XhP6GkbfFwC79YJ5aH1Sl7bmbo,81925
 tinybird/tb/modules/config.py,sha256=gK7rgaWTDd4ZKCrNEg_Uemr26EQjqWt6TjyQKujxOws,11462
 tinybird/tb/modules/connection.py,sha256=-MY56NUAai6EMC4-wpi7bT0_nz_SA8QzTmHkV7HB1IQ,17810
@@ -43,7 +42,7 @@ tinybird/tb/modules/infra.py,sha256=JE9oLIyF4bi_JBoe-BgZ5HhKp_lQgSihuSV1KIS02Qs,
 tinybird/tb/modules/job.py,sha256=wBsnu8UPTOha2rkLvucgmw4xYv73ubmui3eeSIF68ZM,3107
 tinybird/tb/modules/llm.py,sha256=QbHRcMLgFmLKEh4zVb2ctR_5tIGUGdFJrAiRCDtMxDw,1572
 tinybird/tb/modules/llm_utils.py,sha256=nS9r4FAElJw8yXtmdYrx-rtI2zXR8qXfi1QqUDCfxvg,3469
-tinybird/tb/modules/local.py,sha256=HTLUFb8xqR8_PEFkvZV1UB-uk2L66_DAh6eflce6_FE,6446
+tinybird/tb/modules/local.py,sha256=tpiw_F_qOIp42h3kTBwTm5GQDyuVLF0QNF1jmB0zR94,6845
 tinybird/tb/modules/local_common.py,sha256=_WODjW3oPshgsZ1jDFFx2nr0zrLi3Gxz5dlahWPobM8,17464
 tinybird/tb/modules/login.py,sha256=glqj5RWH26AseEoBl8XfrSDEjQTdko17i_pVWOIMoGc,12497
 tinybird/tb/modules/logout.py,sha256=sniI4JNxpTrVeRCp0oGJuQ3yRerG4hH5uz6oBmjv724,1009
@@ -63,6 +62,19 @@ tinybird/tb/modules/token.py,sha256=DkXW9FNCLGBisXewfk195jTJ6B1Iz7zq3cEEac48aAs,
 tinybird/tb/modules/watch.py,sha256=No0bK1M1_3CYuMaIgylxf7vYFJ72lTJe3brz6xQ-mJo,8819
 tinybird/tb/modules/workspace.py,sha256=Q_8HcxMsNg8QG9aBlwcWS2umrDP5IkTIHqqz3sfmGuc,11341
 tinybird/tb/modules/workspace_members.py,sha256=5JdkJgfuEwbq-t6vxkBhYwgsiTDxF790wsa6Xfif9nk,8608
+tinybird/tb/modules/agent/__init__.py,sha256=i3oe3vDIWWPaicdCM0zs7D7BJ1W0k7th93ooskHAV00,54
+tinybird/tb/modules/agent/agent.py,sha256=98X8rqUszArhOnrWWGAJRNwAK-me6Ql2UGNGFxcuc2E,10205
+tinybird/tb/modules/agent/banner.py,sha256=KX_e467uiy1gWOZ4ofTZt0GCFGQqHQ_8Ob27XLQqda0,3053
+tinybird/tb/modules/agent/client.py,sha256=ZNE_0xtbrfhXXRZ7nx3Ze0gHb1IK7zXRLTlGudAAuUg,1264
+tinybird/tb/modules/agent/memory.py,sha256=H6SJK--2L5C87B7AJd_jMqsq3sCvFvZwZXmajuT0GBE,1171
+tinybird/tb/modules/agent/models.py,sha256=jUEO7i_JwlQVZi6QEUeGyFJMFkPZ4ikyDZdei6s6f3M,628
+tinybird/tb/modules/agent/prompts.py,sha256=j7nkx1E2BnPP6Ra718FvSDGRWucyFgSX07V9QAiaiGg,4864
+tinybird/tb/modules/agent/utils.py,sha256=E785Sq_TLVBi1gaBR53YlHvyP_Kbh4TmRouYl3KHFpo,13080
+tinybird/tb/modules/agent/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tinybird/tb/modules/agent/tools/create_datafile.py,sha256=06HK33h86T1d54zvnJXJz_1su3zIS7UJDPyBqhgo81c,1771
+tinybird/tb/modules/agent/tools/explore.py,sha256=iEVsi85CRPCPhWcl-fC1J4hYK22TfunxyqNu5pDxdDU,419
+tinybird/tb/modules/agent/tools/plan.py,sha256=acMbyjqI6cN7IwmMAC8-MPNSg0PEZVKGEk2NOY4gMi8,1162
+tinybird/tb/modules/agent/tools/preview_datafile.py,sha256=e9q5fR0afApcrntzFrnuHmd10ex7MG_GM6T0Pwc9bRI,850
 tinybird/tb/modules/datafile/build.py,sha256=NFKBrusFLU0WJNCXePAFWiEDuTaXpwc0lHlOQWEJ43s,51117
 tinybird/tb/modules/datafile/build_common.py,sha256=2yNdxe49IMA9wNvl25NemY2Iaz8L66snjOdT64dm1is,4511
 tinybird/tb/modules/datafile/build_datasource.py,sha256=Ra8pVQBDafbFRUKlhpgohhTsRyp_ADKZJVG8Gd69idY,17227
@@ -83,8 +95,8 @@ tinybird/tb_cli_modules/config.py,sha256=IsgdtFRnUrkY8-Zo32lmk6O7u3bHie1QCxLwgp4
 tinybird/tb_cli_modules/exceptions.py,sha256=pmucP4kTF4irIt7dXiG-FcnI-o3mvDusPmch1L8RCWk,3367
 tinybird/tb_cli_modules/regions.py,sha256=QjsL5H6Kg-qr0aYVLrvb1STeJ5Sx_sjvbOYO0LrEGMk,166
 tinybird/tb_cli_modules/telemetry.py,sha256=Hh2Io8ZPROSunbOLuMvuIFU4TqwWPmQTqal4WS09K1A,10449
-tinybird-0.0.1.dev238.dist-info/METADATA,sha256=eA-peAy4Kbl3DbnrNQMTDLHb-bSi5duvZKMTiRwSPkc,1682
-tinybird-0.0.1.dev238.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-tinybird-0.0.1.dev238.dist-info/entry_points.txt,sha256=LwdHU6TfKx4Qs7BqqtaczEZbImgU7Abe9Lp920zb_fo,43
-tinybird-0.0.1.dev238.dist-info/top_level.txt,sha256=VqqqEmkAy7UNaD8-V51FCoMMWXjLUlR0IstvK7tJYVY,54
-tinybird-0.0.1.dev238.dist-info/RECORD,,
+tinybird-0.0.1.dev240.dist-info/METADATA,sha256=XT_HpNQ7KOTyQt5ICua7m_CWsFaKQGB0tMvg43YO4XM,1733
+tinybird-0.0.1.dev240.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+tinybird-0.0.1.dev240.dist-info/entry_points.txt,sha256=LwdHU6TfKx4Qs7BqqtaczEZbImgU7Abe9Lp920zb_fo,43
+tinybird-0.0.1.dev240.dist-info/top_level.txt,sha256=VqqqEmkAy7UNaD8-V51FCoMMWXjLUlR0IstvK7tJYVY,54
+tinybird-0.0.1.dev240.dist-info/RECORD,,

tinybird/tb/modules/agent.py

@@ -1,80 +0,0 @@
-import os
-import sys
-from typing import Any, Dict, Optional
-
-import click
-from prompt_toolkit import PromptSession
-from prompt_toolkit.history import FileHistory
-from prompt_toolkit.styles import Style
-
-from tinybird.tb.client import TinyB
-from tinybird.tb.modules.common import _get_tb_client
-from tinybird.tb.modules.feedback_manager import FeedbackManager
-
-
-def agent_banner():
-    # Define gradient colors (teal/turquoise range)
-    colors = [
-        "\033[38;2;0;128;128m",  # Teal
-        "\033[38;2;0;150;136m",  # Teal-ish
-        "\033[38;2;20;160;145m",  # Turquoise blend
-        "\033[38;2;40;170;155m",  # Light turquoise
-        "\033[38;2;60;180;165m",  # Lighter turquoise
-        "\033[38;2;80;190;175m",  # Very light turquoise
-    ]
-    reset = "\033[0m"
-
-    # The Tinybird Code ASCII art banner
-    banner = [
-        "  ████████╗██╗███╗   ██╗██╗   ██╗██████╗ ██╗██████╗ ██████╗     ██████╗ ██████╗ ██████╗ ███████╗",
-        "  ╚══██╔══╝██║████╗  ██║╚██╗ ██╔╝██╔══██╗██║██╔══██╗██╔══██╗   ██╔════╝██╔═══██╗██╔══██╗██╔════╝",
-        "     ██║   ██║██╔██╗ ██║ ╚████╔╝ ██████╔╝██║██████╔╝██║  ██║   ██║     ██║   ██║██║  ██║█████╗  ",
-        "     ██║   ██║██║╚██╗██║  ╚██╔╝  ██╔══██╗██║██╔══██╗██║  ██║   ██║     ██║   ██║██║  ██║██╔══╝  ",
-        "     ██║   ██║██║ ╚████║   ██║   ██████╔╝██║██║  ██║██████╔╝   ╚██████╗╚██████╔╝██████╔╝███████╗",
-        "     ╚═╝   ╚═╝╚═╝  ╚═══╝   ╚═╝   ╚═════╝ ╚═╝╚═╝  ╚═╝╚═════╝     ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝",
-    ]
-
-    # Print each line with a smooth horizontal gradient
-    for line in banner:
-        colored_line = ""
-        for j, char in enumerate(line):
-            # Skip coloring spaces
-            if char == " ":
-                colored_line += char
-                continue
-
-            # Calculate color index for a smooth gradient
-            color_index = min(int(j * len(colors) / len(line)), len(colors) - 1)
-            colored_line += f"{colors[color_index]}{char}"
-
-        click.echo(colored_line + reset)
-
-
-def explore_data(client: TinyB, prompt: str):
-    click.echo(FeedbackManager.highlight(message="\nExploring data...\n"))
-    result = client.explore_data(prompt)
-    click.echo(result)
-
-
-def run_agent_shell(config: Dict[str, Any]):
-    style = Style.from_dict({"prompt": "fg:#34D399 bold"})
-    history: Optional[FileHistory] = None
-    try:
-        history_file = os.path.expanduser("~/.tb_agent_history")
-        history = FileHistory(history_file)
-    except Exception:
-        pass
-    workspace_name = config.get("name", "No workspace found")
-    session: PromptSession = PromptSession(history=history)
-    user_input = session.prompt([("class:prompt", f"\ntb ({workspace_name}) » ")], style=style)
-    if user_input == "exit":
-        sys.exit(0)
-    else:
-        client = _get_tb_client(config.get("token", None), config["host"])
-        explore_data(client, user_input)
-        return run_agent_shell(config)
-
-
-def run_agent(config: Dict[str, Any]):
-    agent_banner()
-    run_agent_shell(config)