tinybird 0.0.1.dev253__py3-none-any.whl → 0.0.1.dev255__py3-none-any.whl

tinybird/prompts.py

@@ -689,7 +689,6 @@ materialized_pipe_instructions = """
 - TYPE MATERIALIZED is the type of the pipe and it is mandatory for materialized pipes.
 - The content of the .pipe file must follow the materialized_pipe_content format.
 - Use State modifier for the aggregated columns in the pipe.
-- Keep the SQL query simple and avoid using complex queries with joins, subqueries, etc.
 </materialized_pipe_instructions>
 <materialized_pipe_content>
 NODE daily_sales
@@ -812,11 +811,11 @@ TYPE endpoint
 """
 
 pipe_instructions = """
+Follow these instructions when creating or updating any type of .pipe file:
 <pipe_file_instructions>
     - The pipe names must be unique.
     - Nodes do NOT use the same name as the Pipe they belong to. So if the pipe name is "my_pipe", the nodes must be named different like "my_pipe_node_1", "my_pipe_node_2", etc.
     - Node names MUST be different from the resource names in the project.
-    - Avoid more than one node per pipe unless it is really necessary or requested by the user.
     - No indentation is allowed for property names: DESCRIPTION, NODE, SQL, TYPE, etc.
     - Allowed TYPE values are: endpoint, copy, materialized, sink.
     - Add always the output node in the TYPE section or in the last node of the pipe.

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.dev253'
-__revision__ = '3bc2143'
+__version__ = '0.0.1.dev255'
+__revision__ = '208306e'

tinybird/tb/modules/agent/agent.py

@@ -30,22 +30,25 @@ from tinybird.tb.modules.agent.memory import clear_history
 from tinybird.tb.modules.agent.models import create_model, model_costs
 from tinybird.tb.modules.agent.prompts import (
     datafile_instructions,
+    endpoint_optimization_instructions,
     plan_instructions,
     resources_prompt,
+    sql_agent_instructions,
     sql_instructions,
 )
-from tinybird.tb.modules.agent.tools.append import append
+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
 from tinybird.tb.modules.agent.tools.create_datafile import create_datafile
 from tinybird.tb.modules.agent.tools.deploy import deploy
 from tinybird.tb.modules.agent.tools.deploy_check import deploy_check
+from tinybird.tb.modules.agent.tools.diff_resource import diff_resource
 from tinybird.tb.modules.agent.tools.execute_query import execute_query
 from tinybird.tb.modules.agent.tools.get_endpoint_stats import get_endpoint_stats
 from tinybird.tb.modules.agent.tools.get_openapi_definition import get_openapi_definition
 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.read_fixture_data import read_fixture_data
 from tinybird.tb.modules.agent.tools.request_endpoint import request_endpoint
 from tinybird.tb.modules.agent.utils import TinybirdAgentContext, show_input
 from tinybird.tb.modules.build_common import process as build_process
@@ -112,12 +115,15 @@ You have access to the following tools:
 5. `deploy` - Deploy the project to Tinybird Cloud.
 6. `deploy_check` - Check if the project can be deployed to Tinybird Cloud before deploying it.
 7. `mock` - Create mock data for a landing datasource.
-8. `read_fixture_data` - Read a fixture data file present in the project folder.
-9. `append` - Append existing fixture to a datasource.
-10. `get_endpoint_stats` - Get metrics of the requests to an endpoint.
-11. `get_openapi_definition` - Get the OpenAPI definition for all endpoints that are built/deployed to Tinybird Cloud or Local.
-12. `execute_query` - Execute a query against Tinybird Cloud or Local.
+8. `analyze_file` - Analyze the content of a fixture file present in the project folder.
+9. `analyze_url` - Analyze the content of an external url.
+9. `append_file` - Append a file present in the project to a datasource.
+10. `append_url` - Append an external url to a datasource.
+11. `get_endpoint_stats` - Get metrics of the requests to an endpoint.
+12. `get_openapi_definition` - Get the OpenAPI definition for all endpoints that are built/deployed to Tinybird Cloud or Local.
+13. `execute_query` - Execute a query against Tinybird Cloud or Local.
 13. `request_endpoint` - Request an endpoint against Tinybird Cloud or Local.
+14. `diff_resource` - Diff the content of a resource in Tinybird Cloud vs Tinybird Local vs Project local file.
 
 # When creating or updating datafiles:
 1. Use `plan` tool to plan the creation or update of resources.
@@ -133,21 +139,11 @@ You have access to the following tools:
 - If the user does not specify anything about the desired schema, create a schema like this:
 SCHEMA >
     `data` String `json:$`
+
 - Use always json paths with .ndjson files.
 
 # When user wants to optimize an endpoint:
-First check if the query is optimized. E.g is filtering by a column present in the sorting key.
-Avoid when possible to update the landing datasource.
-Check endpoint stats to analyze how the endpoint is performing. Use `get_endpoint_stats` tool to get the stats.
-You can use `request_endpoint` tool to check if the endpoint is working as expected.
-You can use `execute_query` tool to execute a query against Tinybird Cloud or Local, to test different queries.
-When your data is in Tinybird, you can create intermediate data sources to preprocess data and make the endpoints faster. This can be done by using materialized views or copy pipes.
-- Copy pipes capture the result of a pipe at a specific point in time and write it to a target data source. They can run on a schedule or run on demand, making them ideal for event-sourced snapshots, data experimentation, and deduplication with snapshots.
-- Materialized views continuously re-evaluate a query as new events are inserted, maintaining an always up-to-date derived dataset. Unlike copy pipes which create point-in-time snapshots, materialized views provide real-time transformations of your data.
-Each approach has its own strengths and use cases:
-- Use copy pipes when you need scheduled or on-demand snapshots of your data.
-- Use materialized views when you need continuous, real-time transformations.
-Finally, update the existing endpoint itself, do not add a new one.
+{endpoint_optimization_instructions}
 
 IMPORTANT: If the user cancels some of the steps or there is an error in file creation, DO NOT continue with the plan. Stop the process and wait for the user before using any other tool.
 IMPORTANT: Every time you finish a plan and start a new resource creation or update process, create a new plan before starting with the changes.
@@ -179,6 +175,7 @@ IMPORTANT: Every time you finish a plan and start a new resource creation or upd
 {copy_pipe_instructions}
 
 # Working with SQL queries:
+{sql_agent_instructions}
 {sql_instructions}
 
 # Working with connections files:
@@ -189,6 +186,13 @@ Kafka: {kafka_connection_example}
 S3: {s3_connection_example}
 GCS: {gcs_connection_example}
 
+# When executing a query or requesting an endpoint:
+- You need to be sure that the selected resource is updated to the last version in the environment you are working on.
+- Use `diff_resource` tool to compare the content of the resource to compare the differences between environments.
+- Project local file is the source of truth.
+- If the resource is not present or updated to the last version in Tinybird Local, it means you need to build the project. 
+- If the resource is not present or updated to the last version in Tinybird Cloud, it means you need to deploy the project.
+
 # Info
 Today is {datetime.now().strftime("%Y-%m-%d")}
 """,
@@ -200,8 +204,10 @@ Today is {datetime.now().strftime("%Y-%m-%d")}
                 Tool(deploy, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
                 Tool(deploy_check, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
                 Tool(mock, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
-                Tool(read_fixture_data, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
-                Tool(append, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
+                Tool(analyze_file, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
+                Tool(analyze_url, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
+                Tool(append_file, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
+                Tool(append_url, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
                 Tool(
                     get_endpoint_stats, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True
                 ),
@@ -213,6 +219,7 @@ Today is {datetime.now().strftime("%Y-%m-%d")}
                 ),
                 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),
             ],
         )
 
@@ -238,10 +245,16 @@ Today is {datetime.now().strftime("%Y-%m-%d")}
                 mock_data=partial(mock_data, project=project, config=config),
                 append_data=partial(append_data, config=config),
                 analyze_fixture=partial(analyze_fixture, config=config),
-                execute_cloud_query=partial(execute_cloud_query, config=config),
-                execute_local_query=partial(execute_local_query, config=config),
+                execute_query_cloud=partial(execute_query_cloud, config=config),
+                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),
+                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),
+                get_pipe_datafile_local=partial(get_pipe_datafile_local, config=config),
+                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,
                 folder=folder,
                 thinking_animation=thinking_animation,
@@ -281,8 +294,8 @@ def run_agent(
     token = config.get("token", None)
     host = config.get("host", None)
     user_token = config.get("user_token", None)
-    workspace_id = config.get("id", None)
-    workspace_name = config.get("name", None)
+    workspace_id = config.get("id", "")
+    workspace_name = config.get("name", "")
     try:
         if not token or not host or not workspace_id or not user_token:
             yes = click.confirm(
@@ -443,18 +456,18 @@ def mock_data(
     )
 
 
-def analyze_fixture(config: dict[str, Any], fixture_path: str) -> dict[str, Any]:
+def analyze_fixture(config: dict[str, Any], fixture_path: str, format: str = "json") -> dict[str, Any]:
     local_client = get_tinybird_local_client(config, test=False, silent=True)
-    meta, _data = _analyze(fixture_path, local_client, Path(fixture_path).suffix.lstrip("."))
+    meta, _data = _analyze(fixture_path, local_client, format)
     return meta
 
 
-def execute_cloud_query(config: dict[str, Any], query: str, pipe_name: Optional[str] = None) -> dict[str, Any]:
+def execute_query_cloud(config: dict[str, Any], query: str, pipe_name: Optional[str] = None) -> dict[str, Any]:
     client = _get_tb_client(config["token"], config["host"])
     return client.query(sql=query, pipeline=pipe_name)
 
 
-def execute_local_query(config: dict[str, Any], query: str, pipe_name: Optional[str] = None) -> dict[str, Any]:
+def execute_query_local(config: dict[str, Any], query: str, pipe_name: Optional[str] = None) -> dict[str, Any]:
     local_client = get_tinybird_local_client(config, test=False, silent=True)
     return local_client.query(sql=query, pipeline=pipe_name)
 
@@ -471,3 +484,51 @@ def request_endpoint_local(
 ) -> dict[str, Any]:
     local_client = get_tinybird_local_client(config, test=False, silent=True)
     return local_client.pipe_data(endpoint_name, format="json", params=params)
+
+
+def get_datasource_datafile_cloud(config: dict[str, Any], datasource_name: str) -> str:
+    try:
+        client = _get_tb_client(config["token"], config["host"])
+        return client.datasource_file(datasource_name)
+    except Exception:
+        return "Datasource not found"
+
+
+def get_datasource_datafile_local(config: dict[str, Any], datasource_name: str) -> str:
+    try:
+        local_client = get_tinybird_local_client(config, test=False, silent=True)
+        return local_client.datasource_file(datasource_name)
+    except Exception:
+        return "Datasource not found"
+
+
+def get_pipe_datafile_cloud(config: dict[str, Any], pipe_name: str) -> str:
+    try:
+        client = _get_tb_client(config["token"], config["host"])
+        return client.pipe_file(pipe_name)
+    except Exception:
+        return "Pipe not found"
+
+
+def get_pipe_datafile_local(config: dict[str, Any], pipe_name: str) -> str:
+    try:
+        local_client = get_tinybird_local_client(config, test=False, silent=True)
+        return local_client.pipe_file(pipe_name)
+    except Exception:
+        return "Pipe not found"
+
+
+def get_connection_datafile_cloud(config: dict[str, Any], connection_name: str) -> str:
+    try:
+        client = _get_tb_client(config["token"], config["host"])
+        return client.connection_file(connection_name)
+    except Exception:
+        return "Connection not found"
+
+
+def get_connection_datafile_local(config: dict[str, Any], connection_name: str) -> str:
+    try:
+        local_client = get_tinybird_local_client(config, test=False, silent=True)
+        return local_client.connection_file(connection_name)
+    except Exception:
+        return "Connection not found"

tinybird/tb/modules/agent/prompts.py

@@ -1,4 +1,7 @@
 from pathlib import Path
+from typing import Any
+
+from pydantic_ai import format_as_xml
 
 from tinybird.tb.modules.project import Project
 
@@ -73,9 +76,10 @@ sql_instructions = """
     - 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.
+    - Do NOT use CREATE TABLE, INSERT INTO, CREATE DATABASE, SHOW TABLES, etc.
     - Use ONLY SELECT statements in the SQL section.
     - INSERT INTO is not supported in SQL section.
+    - Do NOT query system.<table_name> tables.
     - 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')}})
@@ -101,38 +105,32 @@ def resources_prompt(project: Project) -> str:
 
     resources_content = "# Existing resources in the project:\n"
     if files:
-        paths = [Path(file_path) for file_path in files]
-
-        resources_content += "\n".join(
-            [
-                f"""
-    <resource>
-        <path>{file_path.relative_to(project.folder)}</path>
-        <type>{get_resource_type(file_path)}</type>
-        <name>{file_path.stem}</name>
-        <content>{file_path.read_text()}</content>
-    </resource>
-    """
-                for file_path in paths
-            ]
-        )
+        resources: list[dict[str, Any]] = []
+        for filename in files:
+            file_path = Path(filename)
+            resource = {
+                "path": str(file_path.relative_to(project.folder)),
+                "type": get_resource_type(file_path),
+                "name": file_path.stem,
+                "content": file_path.read_text(),
+            }
+            resources.append(resource)
+        resources_content = format_as_xml(resources, root_tag="resources", item_tag="resource")
     else:
         resources_content += "No resources found"
 
     fixture_content = "# Fixture files in the project:\n"
     if fixture_files:
-        paths = [Path(file_path) for file_path in fixture_files]
-        fixture_content += "\n".join(
-            [
-                f"""
-    <fixture>
-        <path>{file_path.relative_to(project.folder)}</path>
-        <name>{file_path.stem}</name>
-    </fixture>
-    """
-                for file_path in paths
-            ]
-        )
+        fixtures: list[dict[str, Any]] = []
+        for filename in fixture_files:
+            file_path = Path(filename)
+            fixture = {
+                "path": str(file_path.relative_to(project.folder)),
+                "name": file_path.stem,
+            }
+            fixtures.append(fixture)
+        fixture_content = format_as_xml(fixtures, root_tag="fixtures", item_tag="fixture")
+
     else:
         fixture_content += "No fixture files found"
 
@@ -147,3 +145,352 @@ def get_resource_type(path: Path) -> str:
     elif path.suffix.lower() == ".connection":
         return "connection"
     return "unknown"
+
+
+endpoint_optimization_instructions = """
+<endpoint_optimization_instructions>
+## Endpoint Optimization Instructions
+### Step 1: Identify Performance Issues
+1. Analyze the endpoint's query performance metrics
+2. Look for endpoints with high latency or excessive data scanning
+3. Check read_bytes/write_bytes ratios to detect inefficient operations
+
+### Step 2: Apply the 5-Question Diagnostic Framework
+
+#### Question 1: Are you aggregating or transforming data at query time?
+**Detection:**
+- Look for `count()`, `sum()`, `avg()`, or data type casting in published API endpoints
+- Check if the same calculations are performed on every request
+
+**Fix:**
+- Create Materialized Views to pre-aggregate data at ingestion time
+- Move transformations from query time to ingestion time
+- Example transformation:
+  ```sql
+  -- Before (in endpoint)
+  SELECT date, count(*) as daily_count 
+  FROM events 
+  GROUP BY date
+  
+  -- After (in Materialized View)
+  ENGINE "AggregatingMergeTree"
+  ENGINE_PARTITION_KEY "toYYYYMM(date)"
+  ENGINE_SORTING_KEY "date"
+  AS SELECT 
+    date,
+    count(*) as daily_count
+  FROM events
+  GROUP BY date
+  ```
+
+#### Question 2: Are you filtering by fields in the sorting key?
+**Detection:**
+- Examine WHERE clauses in queries
+- Check if filtered columns are part of the sorting key
+- Look for filters on partition keys instead of sorting keys
+
+**Fix:**
+- Ensure sorting key includes frequently filtered columns
+- Order sorting key columns by selectivity (most selective first)
+- Guidelines:
+  - Use 3-5 columns in sorting key
+  - Place `customer_id` or tenant identifiers first for multi-tenant apps
+  - Avoid `timestamp` as the first sorting key element
+  - Never use partition key for filtering
+
+**Example Fix:**
+```sql
+-- Before
+ENGINE_SORTING_KEY "timestamp, customer_id"
+
+-- After (better for multi-tenant filtering)
+ENGINE_SORTING_KEY "customer_id, timestamp"
+```
+
+#### Question 3: Are you using the best data types?
+**Detection:**
+- Scan for overly large data types:
+  - String where UUID would work
+  - Int64 where UInt32 would suffice
+  - DateTime with unnecessary precision
+  - Nullable columns that could have defaults
+
+**Fix:**
+- Downsize data types:
+  ```sql
+  -- Before
+  id String,
+  count Int64,
+  created_at DateTime64(3),
+  status Nullable(String)
+  
+  -- After
+  id UUID,
+  count UInt32,
+  created_at DateTime,
+  status LowCardinality(String) DEFAULT 'pending'
+  ```
+- Use `LowCardinality()` for strings with <100k unique values
+- Replace Nullable with default values using `coalesce()`
+
+#### Question 4: Are you doing complex operations early in the pipeline?
+**Detection:**
+- Look for JOINs or aggregations before filters
+- Check operation order in multi-node pipes
+
+**Fix:**
+- Reorder operations: Filter → Simple transforms → Complex operations
+- Example:
+  ```sql
+  -- Before
+  SELECT * FROM (
+    SELECT a.*, b.name 
+    FROM events a 
+    JOIN users b ON a.user_id = b.id
+  ) WHERE date >= today() - 7
+  
+  -- After
+  SELECT a.*, b.name 
+  FROM (
+    SELECT * FROM events 
+    WHERE date >= today() - 7
+  ) a
+  JOIN users b ON a.user_id = b.id
+  ```
+
+#### Question 5: Are you joining two or more data sources?
+**Detection:**
+- Identify JOINs in queries
+- Check read_bytes/write_bytes ratio in Materialized Views
+- Look for full table scans on joined tables
+
+**Fix Options:**
+1. Replace JOIN with subquery:
+   ```sql
+   -- Before
+   SELECT e.*, u.name 
+   FROM events e 
+   JOIN users u ON e.user_id = u.id
+   
+   -- After
+   SELECT e.*, 
+     (SELECT name FROM users WHERE id = e.user_id) as name
+   FROM events e
+   WHERE user_id IN (SELECT id FROM users)
+   ```
+
+2. Optimize Materialized View JOINs:
+   ```sql
+   -- Before (inefficient)
+   SELECT a.id, a.value, b.value 
+   FROM a 
+   LEFT JOIN b USING id
+   
+   -- After (optimized)
+   SELECT a.id, a.value, b.value 
+   FROM a 
+   LEFT JOIN (
+     SELECT id, value 
+     FROM b 
+     WHERE b.id IN (SELECT id FROM a)
+   ) b USING id
+   ```
+
+### Step 3: Implementation Actions
+
+#### For Schema Changes:
+1. Update the datasource schema
+2. Update the sorting keys and data types
+3. Update dependent pipes and endpoints
+
+#### For Query Optimizations:
+1. Create Materialized Views for repeated aggregations
+2. Rewrite queries following best practices
+3. Test performance improvements
+
+#### For JOIN Optimizations:
+1. Evaluate if JOIN is necessary
+2. Consider denormalization strategies
+3. Use Copy Pipes for historical data recalculation
+4. Implement filtered JOINs in Materialized Views
+
+#### In general:
+1. If you need to iterate an existing resource, do not create a new iteration, just update it with the needed changes.
+
+## Monitoring and Validation
+
+### Monitoring:
+1. Set up alerts for endpoints exceeding latency thresholds
+2. Review of tinybird.pipe_stats_rt (realtime stats of last 24h) and tinybird.pipe_stats (historical stats aggregated by day)
+3. Track processed data patterns over time
+4. Monitor for query pattern changes
+
+### Success Metrics:
+- Reduced query latency
+- Lower data scanning (read_bytes)
+- Improved read_bytes/write_bytes ratio
+- Consistent sub-second API response times
+
+## Code Templates
+
+### Materialized View Template:
+```sql
+NODE materialized_view_name
+SQL >
+  SELECT 
+    -- Pre-aggregated fields
+    toDate(timestamp) as date,
+    customer_id,
+    count(*) as event_count,
+    sum(amount) as total_amount
+  FROM source_table
+  GROUP BY date, customer_id
+
+TYPE materialized
+DATASOURCE mv_datasource_name
+ENGINE "AggregatingMergeTree"
+ENGINE_PARTITION_KEY "toYYYYMM(date)"
+ENGINE_SORTING_KEY "customer_id, date"
+```
+
+### Optimized Query Template:
+```sql
+NODE endpoint_query
+SQL >
+  -- Step 1: Filter early
+  WITH filtered_data AS (
+    SELECT * FROM events
+    WHERE customer_id = {{ String(customer_id) }}
+      AND date >= {{ Date(start_date) }}
+      AND date <= {{ Date(end_date) }}
+  )
+  -- Step 2: Simple operations
+  SELECT 
+    date,
+    sum(amount) as daily_total
+  FROM filtered_data
+  GROUP BY date
+  ORDER BY date DESC
+```
+
+## Best Practices Summary
+
+1. **Think ingestion-time, not query-time** - Move computations upstream
+2. **Index smartly** - Sorting keys should match filter patterns
+3. **Size appropriately** - Use the smallest viable data types
+4. **Filter first** - Reduce data before complex operations
+5. **JOIN carefully** - Consider alternatives and optimize when necessary
+</endpoint_optimization_instructions>
+"""
+
+
+sql_agent_instructions = """
+# SQL Best Practices Rules
+
+## Core Principles
+1. **The best data is the data you don't write** - Don't save unnecessary data
+2. **The second best data is the one you don't read** - Filter as early as possible
+3. **Sequential reads are much faster** - Use proper indexes and sorting keys
+4. **The less data you process after read, the better** - Select only needed columns
+5. **Perform complex operations later in the processing pipeline** - Filter before joins/aggregations
+
+## SQL Query Rules
+
+### 1. Filter Placement Rules
+- **ALWAYS** apply WHERE filters before ORDER BY clauses
+- **ALWAYS** apply WHERE filters before GROUP BY operations
+- **ALWAYS** filter data at the earliest possible point in the query
+- **NEVER** sort data before filtering it
+
+### 2. Column Selection Rules
+- **NEVER** use SELECT * in production queries
+- **ALWAYS** specify only the columns you need
+- **ALWAYS** minimize the number of columns retrieved to reduce memory usage
+
+### 3. Sorting and Index Rules
+- **ALWAYS** filter by ENGINE_SORTING_KEY columns first (typically date/time columns)
+- **ALWAYS** order filtering conditions from most to least selective
+- **ALWAYS** use columns in ENGINE_SORTING_KEY for WHERE clauses when possible
+- **NEVER** use functions on indexed columns in WHERE clauses (e.g., avoid DATE_FORMAT, EXTRACT)
+
+### 4. Join Optimization Rules
+- **ALWAYS** pre-filter data before JOIN operations
+- **NEVER** join tables with more than 1 million rows without filtering
+- **ALWAYS** filter the right-side table in joins using subqueries
+- **PREFERRED** pattern for large joins:
+  ```sql
+  -- Good: Pre-filter right table
+  FROM left_table AS left
+  INNER JOIN (
+    SELECT id, column FROM right_table 
+    WHERE id IN (SELECT id FROM left_table)
+  ) AS right ON left.id = right.id
+  ```
+
+### 5. Aggregation Rules
+- **NEVER** use nested aggregate functions (e.g., MAX(AVG(column)))
+- **ALWAYS** use subqueries instead of nested aggregates
+- **ALWAYS** filter data before GROUP BY operations
+- **ALWAYS** perform aggregations as late as possible in the query
+
+### 6. Complex Operations Order
+- **ALWAYS** follow this operation order:
+  1. Filter (WHERE)
+  2. Select only needed columns
+  3. Join (if necessary)
+  4. Group/Aggregate (if necessary)
+  5. Sort (ORDER BY)
+  6. Limit
+
+### 7. Aggregate Function Rules
+- **ALWAYS** use -Merge combinators (countMerge, avgMerge, etc.) when querying AggregateFunction columns
+- **ALWAYS** apply -Merge functions as late as possible in the pipeline
+- **NEVER** select AggregateFunction columns without the appropriate -Merge combinator
+
+### 8. Performance Rules
+- **AVOID** full table scans - always include WHERE clauses
+- **AVOID** reading more than 1GB of data in a single query
+- **AVOID** operations that load large datasets into memory
+- **MINIMIZE** the number of rows processed at each step
+
+### 9. Memory Optimization Rules
+- **REDUCE** column count when hitting memory limits
+- **AVOID** cross JOINs that generate excessive rows
+- **FILTER** before massive GROUP BY operations
+- **CHUNK** large populate operations (they run in 1M row chunks)
+
+### 10. Query Pattern Examples
+
+**BAD Pattern - Filtering after sorting:**
+```sql
+SELECT * FROM table ORDER BY date WHERE condition = true
+```
+
+**GOOD Pattern - Filtering before sorting:**
+```sql
+SELECT column1, column2 FROM table WHERE condition = true ORDER BY date
+```
+
+**BAD Pattern - Nested aggregates:**
+```sql
+SELECT MAX(AVG(amount)) FROM table
+```
+
+**GOOD Pattern - Using subquery:**
+```sql
+SELECT MAX(avg_amount) FROM (SELECT AVG(amount) as avg_amount FROM table)
+```
+
+**BAD Pattern - Unfiltered join:**
+```sql
+SELECT * FROM small_table JOIN huge_table ON small_table.id = huge_table.id
+```
+
+**GOOD Pattern - Pre-filtered join:**
+```sql
+SELECT needed_columns 
+FROM small_table 
+JOIN (SELECT id, col FROM huge_table WHERE id IN (SELECT id FROM small_table)) filtered 
+ON small_table.id = filtered.id
+```
+"""

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

@@ -0,0 +1,79 @@
+import json
+from pathlib import Path
+from urllib.parse import urlparse
+
+import click
+from pydantic_ai import RunContext
+
+from tinybird.tb.modules.agent.utils import TinybirdAgentContext
+from tinybird.tb.modules.feedback_manager import FeedbackManager
+
+
+def analyze_file(ctx: RunContext[TinybirdAgentContext], fixture_pathname: str):
+    """Analyze a fixture data file present in the project folder
+
+    Args:
+        fixture_pathname (str): a path or an external url to a fixture file. Required.
+
+    Returns:
+        str: The content of the fixture data file.
+    """
+    try:
+        ctx.deps.thinking_animation.stop()
+        click.echo(FeedbackManager.highlight(message=f"» Analyzing {fixture_pathname}..."))
+        fixture_path = Path(ctx.deps.folder) / fixture_pathname.lstrip("/")
+
+        if not fixture_path.exists():
+            click.echo(FeedbackManager.error(message=f"No fixture data found for {fixture_pathname}."))
+            ctx.deps.thinking_animation.start()
+            return f"No fixture data found for {fixture_pathname}. Please check the path of the fixture and try again."
+
+        fixture_extension = fixture_path.suffix.lstrip(".")
+        response = ctx.deps.analyze_fixture(fixture_path=str(fixture_path), format=fixture_extension)
+        click.echo(FeedbackManager.success(message="✓ Done!\n"))
+        ctx.deps.thinking_animation.start()
+        # limit content to first 10 rows
+        data = response["preview"]["data"][:10]
+        columns = response["analysis"]["columns"]
+
+        return f"#Result of analysis of {fixture_pathname}:\n##Columns:\n{json.dumps(columns)}\n##Data sample:\n{json.dumps(data)}"
+    except Exception as e:
+        ctx.deps.thinking_animation.stop()
+        click.echo(FeedbackManager.error(message=f"Error analyzing {fixture_pathname}: {e}"))
+        ctx.deps.thinking_animation.start()
+        return f"Error analyzing {fixture_pathname}: {e}"
+
+
+def analyze_url(ctx: RunContext[TinybirdAgentContext], fixture_url: str):
+    """Analyze a fixture file present in an external url
+
+    Args:
+        fixture_url (str): an external url to a fixture file. Required.
+
+    Returns:
+        str: The analysis with the columns and the first 10 rows of the fixture data file.
+    """
+    try:
+        ctx.deps.thinking_animation.stop()
+        is_url = urlparse(fixture_url).scheme in ("http", "https")
+        click.echo(FeedbackManager.highlight(message=f"» Analyzing {fixture_url}..."))
+        if not is_url:
+            click.echo(FeedbackManager.error(message=f"{fixture_url} is not a valid url."))
+            ctx.deps.thinking_animation.start()
+            return f"{fixture_url} is not a valid url. Please check the url and try again."
+
+        fixture_extension = fixture_url.split(".")[-1]
+
+        response = ctx.deps.analyze_fixture(fixture_path=fixture_url, format=fixture_extension)
+        click.echo(FeedbackManager.success(message="✓ Done!\n"))
+        ctx.deps.thinking_animation.start()
+        # limit content to first 10 rows
+        data = response["preview"]["data"][:10]
+        columns = response["analysis"]["columns"]
+
+        return f"#Result of analysis of URL {fixture_url}:\n##Columns:\n{json.dumps(columns)}\n##Data sample:\n{json.dumps(data)}"
+    except Exception as e:
+        ctx.deps.thinking_animation.stop()
+        click.echo(FeedbackManager.error(message=f"Error analyzing {fixture_url}: {e}"))
+        ctx.deps.thinking_animation.start()
+        return f"Error analyzing {fixture_url}: {e}"

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

@@ -5,7 +5,7 @@ from tinybird.tb.modules.agent.utils import TinybirdAgentContext, show_confirmat
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
 
-def append(ctx: RunContext[TinybirdAgentContext], datasource_name: str, fixture_pathname: str) -> str:
+def append_file(ctx: RunContext[TinybirdAgentContext], datasource_name: str, fixture_pathname: str) -> str:
     """Append existing fixture to a datasource
 
     Args:
@@ -18,7 +18,7 @@ def append(ctx: RunContext[TinybirdAgentContext], datasource_name: str, fixture_
     try:
         ctx.deps.thinking_animation.stop()
         confirmation = show_confirmation(
-            title=f"Append existing fixture for datasource {datasource_name}?",
+            title=f"Append fixture {fixture_pathname} to datasource {datasource_name}?",
             skip_confirmation=ctx.deps.dangerously_skip_permissions,
         )
 
@@ -41,7 +41,70 @@ def append(ctx: RunContext[TinybirdAgentContext], datasource_name: str, fixture_
         ctx.deps.thinking_animation.start()
         return f"Data appended to {datasource_name}"
     except Exception as e:
+        error_message = str(e)
         ctx.deps.thinking_animation.stop()
-        click.echo(FeedbackManager.error(message=e))
+        click.echo(FeedbackManager.error(message=error_message))
+        error_message = handle_quarantine_error(ctx, error_message, datasource_name)
         ctx.deps.thinking_animation.start()
-        return f"Error appending fixture {fixture_pathname} to {datasource_name}: {e}"
+        return f"Error appending fixture {fixture_pathname} to {datasource_name}: {error_message}"
+
+
+def append_url(ctx: RunContext[TinybirdAgentContext], datasource_name: str, fixture_url: str) -> str:
+    """Append existing fixture to a datasource
+
+    Args:
+        datasource_name: Name of the datasource to append fixture to
+        fixture_url: external url to the fixture file to append
+
+    Returns:
+        str: Message indicating the success or failure of the appending
+    """
+    try:
+        ctx.deps.thinking_animation.stop()
+        confirmation = show_confirmation(
+            title=f"Append URL {fixture_url} to datasource {datasource_name}?",
+            skip_confirmation=ctx.deps.dangerously_skip_permissions,
+        )
+
+        if confirmation == "review":
+            click.echo()
+            feedback = show_input(ctx.deps.workspace_name)
+            ctx.deps.thinking_animation.start()
+            return f"User did not confirm appending URL {fixture_url} and gave the following feedback: {feedback}"
+
+        if confirmation == "cancel":
+            ctx.deps.thinking_animation.start()
+            return f"User rejected appending URL {fixture_url}. Skip this step"
+
+        ctx.deps.thinking_animation.stop()
+        click.echo(FeedbackManager.highlight(message=f"\n» Appending {fixture_url} to {datasource_name}..."))
+        ctx.deps.append_data(datasource_name=datasource_name, path=fixture_url)
+        click.echo(FeedbackManager.success(message=f"✓ Data appended to {datasource_name}"))
+        ctx.deps.thinking_animation.start()
+        return f"Data appended to {datasource_name}"
+    except Exception as e:
+        error_message = str(e)
+        ctx.deps.thinking_animation.stop()
+        click.echo(FeedbackManager.error(message=error_message))
+        error_message = handle_quarantine_error(ctx, error_message, datasource_name)
+        ctx.deps.thinking_animation.start()
+        return f"Error appending URL {fixture_url} to {datasource_name}: {error_message}"
+
+
+def handle_quarantine_error(ctx: RunContext[TinybirdAgentContext], error_message: str, datasource_name: str) -> str:
+    try:
+        if "in quarantine" in error_message:
+            click.echo(FeedbackManager.highlight(message=f"\n» Looking for errors in {datasource_name}_quarantine..."))
+            query = (
+                f"select * from {datasource_name}_quarantine order by insertion_date desc limit 5 FORMAT CSVWithNames"
+            )
+            quarantine_data = ctx.deps.execute_query_local(query=query)
+            error_message = (
+                error_message
+                + f"\nThese are the first 5 rows of the quarantine table for datasource '{datasource_name}':\n{quarantine_data}. Use again `mock` tool but add this issue to the context."
+            )
+
+    except Exception as quarantine_error:
+        error_message = error_message + f"\nError accessing to {datasource_name}_quarantine: {quarantine_error}"
+
+    return error_message

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

@@ -0,0 +1,51 @@
+from pathlib import Path
+
+import click
+from pydantic_ai import RunContext
+
+from tinybird.tb.modules.agent.utils import Datafile, TinybirdAgentContext
+from tinybird.tb.modules.feedback_manager import FeedbackManager
+
+
+def diff_resource(ctx: RunContext[TinybirdAgentContext], resource: Datafile) -> str:
+    """Diff the content of a resource in Tinybird Cloud vs Tinybird Local vs Project local file
+
+    Args:
+        resource (Datafile): The resource to diff. Required.
+
+    Returns:
+        Datafile: The diff of the resource.
+    """
+    try:
+        ctx.deps.thinking_animation.stop()
+        click.echo(
+            FeedbackManager.highlight(message=f"\n» Comparing content of {resource.pathname} with Tinybird Cloud")
+        )
+        resource.pathname = resource.pathname.removeprefix("/")
+        project_file_path = Path(ctx.deps.folder) / resource.pathname
+        if not project_file_path.exists():
+            raise Exception(f"Resource {resource.pathname} not found in project")
+
+        project_file_content = project_file_path.read_text()
+        if resource.type == "datasource":
+            cloud_content = ctx.deps.get_datasource_datafile_cloud(datasource_name=resource.name)
+            local_content = ctx.deps.get_datasource_datafile_local(datasource_name=resource.name)
+        elif resource.type == "connection":
+            cloud_content = ctx.deps.get_connection_datafile_cloud(connection_name=resource.name)
+            local_content = ctx.deps.get_connection_datafile_local(connection_name=resource.name)
+        elif resource.type in ["endpoint", "materialized", "sink", "copy"]:
+            cloud_content = ctx.deps.get_pipe_datafile_cloud(pipe_name=resource.name)
+            local_content = ctx.deps.get_pipe_datafile_local(pipe_name=resource.name)
+        else:
+            raise Exception(f"{resource.type} is not a valid extension")
+
+        needs_to_build = project_file_content != local_content
+        needs_to_deploy = project_file_content != cloud_content
+        ctx.deps.thinking_animation.start()
+        diff = f"# Diff of resource {resource.name}:\n"
+        diff += f"## Tinybird Cloud: {'Deploy needed. Resource does not exist or needs to be updated. Run `deploy` tool to deploy the resource.' if needs_to_deploy else 'Nothing to deploy.'}\n"
+        diff += f"## Tinybird Local: {'Build needed. Resource does not exist or needs to be updated. Run `build` tool to build the resource.' if needs_to_build else 'Nothing to build.'}\n"
+        return diff
+    except Exception as e:
+        ctx.deps.thinking_animation.start()
+        return f"Could not diff resource {resource.pathname}: {e}"

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

@@ -3,7 +3,7 @@ import humanfriendly
 from pydantic_ai import RunContext
 
 from tinybird.tb.modules.agent.utils import TinybirdAgentContext
-from tinybird.tb.modules.common import echo_safe_humanfriendly_tables_format_smart_table
+from tinybird.tb.modules.common import echo_safe_humanfriendly_tables_format_pretty_table
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
 
@@ -32,7 +32,7 @@ def execute_query(ctx: RunContext[TinybirdAgentContext], query: str, task: str,
         else:
             query = f"SELECT * FROM ({query}) {query_format}"
 
-        execute_query = ctx.deps.execute_cloud_query if cloud else ctx.deps.execute_local_query
+        execute_query = ctx.deps.execute_query_cloud if cloud else ctx.deps.execute_query_local
         result = execute_query(query=query)
         stats = result["statistics"]
         seconds = stats["elapsed"]
@@ -44,9 +44,10 @@ def execute_query(ctx: RunContext[TinybirdAgentContext], query: str, task: str,
         if not result["data"]:
             click.echo(FeedbackManager.info_no_rows())
         else:
-            echo_safe_humanfriendly_tables_format_smart_table(
-                data=[d.values() for d in result["data"]], column_names=result["data"][0].keys()
+            echo_safe_humanfriendly_tables_format_pretty_table(
+                data=[d.values() for d in result["data"][:10]], column_names=result["data"][0].keys()
             )
+            click.echo("Showing first 10 results\n")
         ctx.deps.thinking_animation.start()
         result["data"] = result["data"][:10]
         return f"Result for task '{task}' in {cloud_or_local} environment: {result}. The user is being shown the full result in the console but this message only contains the first 10 rows."

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

@@ -42,7 +42,7 @@ def get_endpoint_stats(
     FORMAT JSON
     """
 
-    execute_query = ctx.deps.execute_cloud_query if cloud else ctx.deps.execute_local_query
+    execute_query = ctx.deps.execute_query_cloud if cloud else ctx.deps.execute_query_local
 
     result = execute_query(query=query)
     click.echo(FeedbackManager.success(message="✓ Done!"))

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

@@ -60,7 +60,7 @@ def mock(
                     FeedbackManager.highlight(message=f"\n» Looking for errors in {datasource_name}_quarantine...")
                 )
                 query = f"select * from {datasource_name}_quarantine order by insertion_date desc limit 5 FORMAT CSVWithNames"
-                quarantine_data = ctx.deps.execute_local_query(query=query)
+                quarantine_data = ctx.deps.execute_query_local(query=query)
                 error_message = (
                     error_message
                     + f"\nThese are the first 5 rows of the quarantine table for datasource '{datasource_name}':\n{quarantine_data}. Use again `mock` tool but add this issue to the context."

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

@@ -16,7 +16,7 @@ def preview_datafile(name: str, type: str, description: str, content: str, pathn
     """
 
     return Datafile(
-        type=type,
+        type=type.lower(),
         name=name,
         content=content,
         description=description,

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

@@ -5,7 +5,7 @@ import humanfriendly
 from pydantic_ai import RunContext
 
 from tinybird.tb.modules.agent.utils import TinybirdAgentContext
-from tinybird.tb.modules.common import echo_safe_humanfriendly_tables_format_smart_table
+from tinybird.tb.modules.common import echo_safe_humanfriendly_tables_format_pretty_table
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
 
@@ -48,10 +48,10 @@ def request_endpoint(
         if not result["data"]:
             click.echo(FeedbackManager.info_no_rows())
         else:
-            echo_safe_humanfriendly_tables_format_smart_table(
-                data=[d.values() for d in result["data"][:5]], column_names=result["data"][0].keys()
+            echo_safe_humanfriendly_tables_format_pretty_table(
+                data=[d.values() for d in result["data"][:10]], column_names=result["data"][0].keys()
             )
-            click.echo("Showing first 5 results\n")
+            click.echo("Showing first 10 results\n")
         ctx.deps.thinking_animation.start()
         return f"Result for endpoint {endpoint_name} with params {params} in {cloud_or_local} environment: {result}. Do not show result is already shown in the console."
     except Exception as e:

tinybird/tb/modules/agent/utils.py

@@ -41,10 +41,16 @@ class TinybirdAgentContext(BaseModel):
     mock_data: Callable[..., list[dict[str, Any]]]
     append_data: Callable[..., None]
     analyze_fixture: Callable[..., dict[str, Any]]
-    execute_cloud_query: Callable[..., dict[str, Any]]
-    execute_local_query: Callable[..., dict[str, Any]]
+    execute_query_cloud: Callable[..., dict[str, Any]]
+    execute_query_local: Callable[..., dict[str, Any]]
     request_endpoint_cloud: Callable[..., dict[str, Any]]
     request_endpoint_local: Callable[..., dict[str, Any]]
+    get_datasource_datafile_cloud: Callable[..., str]
+    get_datasource_datafile_local: Callable[..., str]
+    get_pipe_datafile_cloud: Callable[..., str]
+    get_pipe_datafile_local: Callable[..., str]
+    get_connection_datafile_cloud: Callable[..., str]
+    get_connection_datafile_local: Callable[..., str]
     dangerously_skip_permissions: bool
     token: str
     user_token: str

tinybird/tb/modules/common.py

@@ -124,6 +124,23 @@ def echo_safe_humanfriendly_tables_format_smart_table(data: Iterable[Any], colum
             raise exc
 
 
+def echo_safe_humanfriendly_tables_format_pretty_table(data: Iterable[Any], column_names: List[str]) -> None:
+    """
+    There is a bug in the humanfriendly library: it breaks to render the small table for small terminals
+    (`format_robust_table`) if we call format_smart_table with an empty dataset. This catches the error and prints
+    what we would call an empty "robust_table".
+    """
+    try:
+        click.echo(humanfriendly.tables.format_pretty_table(data, column_names=column_names))
+    except ValueError as exc:
+        if str(exc) == "max() arg is an empty sequence":
+            click.echo("------------")
+            click.echo("Empty")
+            click.echo("------------")
+        else:
+            raise exc
+
+
 def echo_safe_format_table(data: Iterable[Any], columns) -> None:
     """
     There is a bug in the humanfriendly library: it breaks to render the small table for small terminals

{tinybird-0.0.1.dev253.dist-info → tinybird-0.0.1.dev255.dist-info}/METADATA

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

{tinybird-0.0.1.dev253.dist-info → tinybird-0.0.1.dev255.dist-info}/RECORD

@@ -3,7 +3,7 @@ tinybird/context.py,sha256=FfqYfrGX_I7PKGTQo93utaKPDNVYWelg4Hsp3evX5wM,1291
 tinybird/datatypes.py,sha256=r4WCvspmrXTJHiPjjyOTiZyZl31FO3Ynkwq4LQsYm6E,11059
 tinybird/feedback_manager.py,sha256=1INQFfRfuMCb9lfB8KNf4r6qC2khW568hoHjtk-wshI,69305
 tinybird/git_settings.py,sha256=Sw_8rGmribEFJ4Z_6idrVytxpFYk7ez8ei0qHULzs3E,3934
-tinybird/prompts.py,sha256=4VmdaMX7oUFoqjseXe8QuF9wTtIabbDkdwVGmd34S7s,45502
+tinybird/prompts.py,sha256=9zXOYI8TzFAyp_bolqtxhtaqg0c1u4AJolFM0o3aYiY,45393
 tinybird/sql.py,sha256=BufnOgclQokDyihtuXesOwHBsebN6wRXIxO5wKRkOwE,48299
 tinybird/sql_template.py,sha256=AezE1o6_BzbHFi0J9OIqTrXQ5WvoX5eNVq4QCbFjGcs,100338
 tinybird/sql_template_fmt.py,sha256=KUHdj5rYCYm_rKKdXYSJAE9vIyXUQLB0YSZnUXHeBlY,10196
@@ -17,7 +17,7 @@ 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=eK7q5QxuCP76bNpCpZzIiZeTSJL3JvT8Z0H4Zs8hUOY,247
+tinybird/tb/__cli__.py,sha256=51Rg-OvKFWGEJgEjFVuc2XEUi5XT3bb5o8ZEUJ1bdhA,247
 tinybird/tb/check_pypi.py,sha256=Gp0HkHHDFMSDL6nxKlOY51z7z1Uv-2LRexNTZSHHGmM,552
 tinybird/tb/cli.py,sha256=FdDFEIayjmsZEVsVSSvRiVYn_FHOVg_zWQzchnzfWho,1008
 tinybird/tb/client.py,sha256=pJbdkWMXGAqKseNAvdsRRnl_c7I-DCMB0dWCQnG82nU,54146
@@ -26,7 +26,7 @@ tinybird/tb/modules/build.py,sha256=efD-vamK1NPaDo9R86Hn8be2DYoW0Hh5bZiH7knK5dk,
 tinybird/tb/modules/build_common.py,sha256=rWhemU8bk0ZE2eiwZDaTmV9cPabDGGlyc2WnRxfhT0M,12859
 tinybird/tb/modules/cicd.py,sha256=0KLKccha9IP749QvlXBmzdWv1On3mFwMY4DUcJlBxiE,7326
 tinybird/tb/modules/cli.py,sha256=1kErLFhxgMWldbE7P4-bkPUcug8ymRyXDHRG9-vGb_4,16755
-tinybird/tb/modules/common.py,sha256=jTTaDDHrZREt--032XhP6GkbfFwC79YJ5aH1Sl7bmbo,81925
+tinybird/tb/modules/common.py,sha256=tj6DR2yOqMMQ0PILwFGXmMogxdrbQCgj36HdSM611rs,82657
 tinybird/tb/modules/config.py,sha256=gK7rgaWTDd4ZKCrNEg_Uemr26EQjqWt6TjyQKujxOws,11462
 tinybird/tb/modules/connection.py,sha256=-MY56NUAai6EMC4-wpi7bT0_nz_SA8QzTmHkV7HB1IQ,17810
 tinybird/tb/modules/copy.py,sha256=dPZkcIDvxjJrlQUIvToO0vsEEEs4EYumbNV77-BzNoU,4404
@@ -68,28 +68,29 @@ tinybird/tb/modules/watch.py,sha256=No0bK1M1_3CYuMaIgylxf7vYFJ72lTJe3brz6xQ-mJo,
 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=wZSHbWShmnq3VmS6Hf6TyU80_rOiZ4AwdltDu9Dnl3Q,23124
+tinybird/tb/modules/agent/agent.py,sha256=HtXB75QJ71YH21BdbWhx2Pb1c2KUFu1_3TfdVulCoh4,25349
 tinybird/tb/modules/agent/animations.py,sha256=4WOC5_2BracttmMCrV0H91tXfWcUzQHBUaIJc5FA7tE,3490
 tinybird/tb/modules/agent/banner.py,sha256=KX_e467uiy1gWOZ4ofTZt0GCFGQqHQ_8Ob27XLQqda0,3053
 tinybird/tb/modules/agent/memory.py,sha256=H6SJK--2L5C87B7AJd_jMqsq3sCvFvZwZXmajuT0GBE,1171
 tinybird/tb/modules/agent/models.py,sha256=LW1D27gjcd_jwFmghEzteCgToDfodX2B6B5S8BYbysw,735
-tinybird/tb/modules/agent/prompts.py,sha256=wbe6vUnm-fskceWgP13R5VW1v_YF7_wLDe-wBN6rlWw,6998
-tinybird/tb/modules/agent/utils.py,sha256=me5-kflBxV4N4psBSxI3vAfmFvAtsSnboc7ND3M9omw,26249
+tinybird/tb/modules/agent/prompts.py,sha256=qyAv3H1x9qctlYQSel0DHxLlRJM2_8HTg7M-foSoR0k,17567
+tinybird/tb/modules/agent/utils.py,sha256=5mUnc4LZATHLzQZThotNErzZdHQDwK3eur6W4NZULWA,26561
 tinybird/tb/modules/agent/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tinybird/tb/modules/agent/tools/append.py,sha256=cBdKBhUW0kooIbywtZNd_bhxbbMyf5NUKHwanAl5BmA,2042
+tinybird/tb/modules/agent/tools/analyze.py,sha256=7oxJ3waCS24Qja_k5GUB59_XiHTG9pCewZogOXhH0cA,3495
+tinybird/tb/modules/agent/tools/append.py,sha256=ekG7OxOzPjjjAjYUONAfp_PWlzyLT1GDfQhECgO-DYY,5065
 tinybird/tb/modules/agent/tools/build.py,sha256=LhzJMx6tbxC7gogIrxhfKJc-SDgoSR-FC6IunfaCdn8,758
 tinybird/tb/modules/agent/tools/create_datafile.py,sha256=wcPcChACTIFKw0lKFTlhm0sWJKhQkMLPLnGNpKyeETA,2962
 tinybird/tb/modules/agent/tools/deploy.py,sha256=WrsSlaufKGOBx0S13uoMQQH2DnKue5LQ231Rx4RXh2I,1443
 tinybird/tb/modules/agent/tools/deploy_check.py,sha256=LBE8aENYvCEaxbVTVKMSI2NGGiHeh-y60_MPlfrcvFk,1331
-tinybird/tb/modules/agent/tools/execute_query.py,sha256=s6QCIe8iD44_XZWgN-zYvWtXPEgJb2kGx6zgXCJbhKc,2642
+tinybird/tb/modules/agent/tools/diff_resource.py,sha256=euKo_mD9FZHC1X6yESv3D_CXMzBMB8EWHLeZjIRqjJg,2637
+tinybird/tb/modules/agent/tools/execute_query.py,sha256=hMRahWZkyP9qa-nMGzY0Z7MjDa9sb5O9V1evmA_V_w8,2702
 tinybird/tb/modules/agent/tools/explore.py,sha256=ihALc_kBcsjrKT3hZyicqyIowB0g_K3AtNNi-5uz9-8,412
-tinybird/tb/modules/agent/tools/get_endpoint_stats.py,sha256=_3wAvDykJitIOb5BRnP7wCy6y06y1qlULHLWB-MvS2M,1705
+tinybird/tb/modules/agent/tools/get_endpoint_stats.py,sha256=E9yPi9LwnpsTyjFd8EaiSNvDGVPkFSNqp_tZxg_pWqs,1705
 tinybird/tb/modules/agent/tools/get_openapi_definition.py,sha256=9cQ-SUeB1NVhPJN1s8aQh9KQxqI9-DEEW1Ot5r2JbOk,1575
-tinybird/tb/modules/agent/tools/mock.py,sha256=Omog_gdEdm8YuBXNrJdHwxHqjL_ji9UIr75mALF4ozI,3408
+tinybird/tb/modules/agent/tools/mock.py,sha256=4gEAPZCdTPo1w-fbryWiEx3hPXOK2ZfW0MpXY7smpcI,3408
 tinybird/tb/modules/agent/tools/plan.py,sha256=pr6LnItz6vlOeCG8GE459ExsrBEG0KLx-g02SZGNjXU,1217
-tinybird/tb/modules/agent/tools/preview_datafile.py,sha256=e9q5fR0afApcrntzFrnuHmd10ex7MG_GM6T0Pwc9bRI,850
-tinybird/tb/modules/agent/tools/read_fixture_data.py,sha256=rvTdVlZsu3rQTSWqXzpFt4LEwnBcMLIT8hlI5C7MVN4,1430
-tinybird/tb/modules/agent/tools/request_endpoint.py,sha256=iwzjYLtX_4YS7b9KzRwPGtVkx2UNujMAXv8m7mm8Fac,2683
+tinybird/tb/modules/agent/tools/preview_datafile.py,sha256=Gbao_FxhXstnUnngVQxztpizjugyfx1rOXTkw7Yabls,858
+tinybird/tb/modules/agent/tools/request_endpoint.py,sha256=Jl64ln0Jspu_rmp3ycZabj-2IXkmWFSZxoCdcavRpQo,2687
 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
@@ -110,8 +111,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.dev253.dist-info/METADATA,sha256=Ej8SV3sx05hZNJilrr1lV6-89EarblPY7rwcLtp486M,1733
-tinybird-0.0.1.dev253.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-tinybird-0.0.1.dev253.dist-info/entry_points.txt,sha256=LwdHU6TfKx4Qs7BqqtaczEZbImgU7Abe9Lp920zb_fo,43
-tinybird-0.0.1.dev253.dist-info/top_level.txt,sha256=VqqqEmkAy7UNaD8-V51FCoMMWXjLUlR0IstvK7tJYVY,54
-tinybird-0.0.1.dev253.dist-info/RECORD,,
+tinybird-0.0.1.dev255.dist-info/METADATA,sha256=oudst3Nwc1lfUUD-RID7T4ncAgcIuWnv5_VNlSjK08c,1733
+tinybird-0.0.1.dev255.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+tinybird-0.0.1.dev255.dist-info/entry_points.txt,sha256=LwdHU6TfKx4Qs7BqqtaczEZbImgU7Abe9Lp920zb_fo,43
+tinybird-0.0.1.dev255.dist-info/top_level.txt,sha256=VqqqEmkAy7UNaD8-V51FCoMMWXjLUlR0IstvK7tJYVY,54
+tinybird-0.0.1.dev255.dist-info/RECORD,,

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

@@ -1,36 +0,0 @@
-import json
-from pathlib import Path
-
-import click
-from pydantic_ai import RunContext
-
-from tinybird.tb.modules.agent.utils import TinybirdAgentContext
-from tinybird.tb.modules.feedback_manager import FeedbackManager
-
-
-def read_fixture_data(ctx: RunContext[TinybirdAgentContext], fixture_pathname: str):
-    """Read fixture data in the project folder
-
-    Args:
-        fixture_pathname (str): a path to a fixture file. Required.
-
-    Returns:
-        str: The content of the fixture data file.
-    """
-    ctx.deps.thinking_animation.stop()
-    click.echo(FeedbackManager.highlight(message=f"» Analyzing {fixture_pathname}..."))
-    fixture_path = Path(ctx.deps.folder) / fixture_pathname.lstrip("/")
-
-    if not fixture_path.exists():
-        click.echo(FeedbackManager.error(message=f"No fixture data found for {fixture_pathname}."))
-        ctx.deps.thinking_animation.start()
-        return f"No fixture data found for {fixture_pathname}. Please check the name of the fixture and try again."
-
-    response = ctx.deps.analyze_fixture(fixture_path=str(fixture_path))
-    click.echo(FeedbackManager.success(message="✓ Done!\n"))
-    ctx.deps.thinking_animation.start()
-    # limit content to first 10 rows
-    data = response["preview"]["data"][:10]
-    columns = response["analysis"]["columns"]
-
-    return f"#Result of analysis of {fixture_pathname}:\n##Columns:\n{json.dumps(columns)}\n##Data sample:\n{json.dumps(data)}"