tinybird 0.0.1.dev245__py3-none-any.whl → 0.0.1.dev247__py3-none-any.whl

tinybird/ch_utils/constants.py

@@ -255,4 +255,6 @@ VALID_QUERY_FORMATS = (
     "JSONStrings",
     "Prometheus",
     "Native",
+    "RowBinaryWithNamesAndTypes",
+    "TabSeparated",
 )

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.dev245'
-__revision__ = 'f0c439a'
+__version__ = '0.0.1.dev247'
+__revision__ = '379a827'

tinybird/tb/modules/agent/agent.py

@@ -1,7 +1,8 @@
+import subprocess
 import sys
-import uuid
 from datetime import datetime
 from functools import partial
+from pathlib import Path
 from typing import Any
 
 import click
@@ -28,29 +29,40 @@ from tinybird.tb.client import TinyB
 from tinybird.tb.modules.agent.animations import ThinkingAnimation
 from tinybird.tb.modules.agent.banner import display_banner
 from tinybird.tb.modules.agent.memory import clear_history, load_history
-from tinybird.tb.modules.agent.models import create_model
+from tinybird.tb.modules.agent.models import create_model, model_costs
 from tinybird.tb.modules.agent.prompts import (
     datafile_instructions,
     plan_instructions,
     resources_prompt,
     sql_instructions,
 )
+from tinybird.tb.modules.agent.tools.append import append
+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.explore import explore_data
+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.utils import TinybirdAgentContext
 from tinybird.tb.modules.build_common import process as build_process
-from tinybird.tb.modules.exceptions import CLIBuildException
+from tinybird.tb.modules.common import _analyze, _get_tb_client
+from tinybird.tb.modules.config import CLIConfig
+from tinybird.tb.modules.deployment_common import create_deployment
+from tinybird.tb.modules.exceptions import CLIBuildException, CLIMockException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 from tinybird.tb.modules.local_common import get_tinybird_local_client
+from tinybird.tb.modules.mock_common import append_mock_data, create_mock_data
 from tinybird.tb.modules.project import Project
 
 
 class TinybirdAgent:
-    def __init__(self, token: str, host: str, project: Project):
+    def __init__(self, token: str, host: str, project: Project, dangerously_skip_permissions: bool):
         self.token = token
         self.host = host
+        self.dangerously_skip_permissions = dangerously_skip_permissions
         self.project = project
         self.messages: list[ModelMessage] = []
         self.agent = Agent(
@@ -86,7 +98,12 @@ You have access to the following tools:
 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.
-
+5. `build` - Build the project.
+6. `deploy` - Deploy the project to Tinybird Cloud.
+7. `deploy_check` - Check if the project can be deployed to Tinybird Cloud before deploying it.
+8. `mock` - Create mock data for a landing datasource.
+9. `read_fixture_data` - Read a fixture data file present in the project folder.
+10. `append` - Append existing fixture to a datasource.
 
 # When creating or updating datafiles:
 1. Use `plan` tool to plan the creation or update of resources.
@@ -140,6 +157,12 @@ Today is {datetime.now().strftime("%Y-%m-%d")}
                 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=True),
+                Tool(build, docstring_format="google", require_parameter_descriptions=True, takes_ctx=True),
+                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),
             ],
         )
 
@@ -147,44 +170,65 @@ Today is {datetime.now().strftime("%Y-%m-%d")}
         """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, project: Project) -> None:
-        user_prompt = f"{user_prompt}\n\n# Existing resources in the project:\n{resources_prompt(project)}"
+    def run(self, user_prompt: str, config: dict[str, Any], project: Project) -> None:
+        user_prompt = f"{user_prompt}\n\n{resources_prompt(project)}"
         client = TinyB(token=self.token, host=self.host)
         folder = self.project.folder
+
         thinking_animation = ThinkingAnimation(message="Chirping", delay=0.15)
         thinking_animation.start()
-
         result = self.agent.run_sync(
             user_prompt,
             deps=TinybirdAgentContext(
                 # context does not support the whole client, so we need to pass only the functions we need
                 explore_data=client.explore_data,
-                build_project=partial(build_project, folder=folder),
+                build_project=partial(build_project, project=project, config=config),
+                deploy_project=partial(deploy_project, project=project, config=config),
+                deploy_check_project=partial(deploy_check_project, project=project, config=config),
+                mock_data=partial(mock_data, project=project, config=config),
+                append_data=partial(append_data, config=config),
+                analyze_fixture=partial(analyze_fixture, config=config),
                 get_project_files=project.get_project_files,
                 folder=folder,
                 thinking_animation=thinking_animation,
+                workspace_name=self.project.workspace_name,
+                dangerously_skip_permissions=self.dangerously_skip_permissions,
             ),
             message_history=self.messages,
         )
         new_messages = result.new_messages()
         self.messages.extend(new_messages)
         thinking_animation.stop()
-
+        usage = result.usage()
+        request_tokens = usage.request_tokens or 0
+        response_tokens = usage.response_tokens or 0
+        total_tokens = usage.total_tokens or 0
+        cost = (
+            request_tokens * model_costs["input_cost_per_token"]
+            + response_tokens * model_costs["output_cost_per_token"]
+        )
+        click.echo()
         click.echo(result.output)
         click.echo("\n")
+        click.echo(f"Input tokens: {request_tokens}")
+        click.echo(f"Output tokens: {response_tokens}")
+        click.echo(f"Total tokens: {total_tokens}")
+        click.echo(f"Cost: ${cost:.6f}")
 
 
-def run_agent(config: dict[str, Any], project: Project):
+def run_agent(config: dict[str, Any], project: Project, dangerously_skip_permissions: bool):
     display_banner()
 
     try:
         token = config["token"]
         host = config["host"]
-        agent = TinybirdAgent(token, host, project)
+        agent = TinybirdAgent(token, host, project, dangerously_skip_permissions)
         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"))
+        if config.get("token"):
+            click.echo(FeedbackManager.info(message="Describe what you want to create and I'll help you build it"))
+            click.echo(FeedbackManager.info(message="Run /help for more commands"))
+        else:
+            click.echo(FeedbackManager.info(message="Run /login to authenticate"))
         click.echo()
 
     except Exception as e:
@@ -207,25 +251,29 @@ def run_agent(config: dict[str, Any], project: Project):
                     ),
                 )
 
-                if user_input.lower() in ["exit", "quit"]:
+                if user_input.lower() in ["/exit", "/quit"]:
                     click.echo(FeedbackManager.info(message="Goodbye!"))
                     break
-                elif user_input.lower() == "clear":
+                elif user_input.lower() == "/clear":
                     clear_history()
                     continue
-                elif user_input.lower() == "help":
+                elif user_input.lower() == "/login":
+                    click.echo()
+                    subprocess.run(["tb", "login"], check=True)
+                    click.echo()
+                    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("• Connect to external services: '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, project)
+                    agent.run(user_input, config, project)
 
             except KeyboardInterrupt:
                 click.echo(FeedbackManager.info(message="Goodbye!"))
@@ -239,10 +287,71 @@ def run_agent(config: dict[str, Any], project: Project):
         sys.exit(1)
 
 
-def build_project(folder: str) -> None:
-    workspace_name = f"tmp_workspace_{uuid.uuid4()}"
-    project = Project(folder, workspace_name=workspace_name)
-    local_client = get_tinybird_local_client({"path": folder, "name": workspace_name}, test=True, silent=True)
-    build_error = build_process(project=project, tb_client=local_client, watch=False, silent=True, exit_on_error=False)
+def build_project(config: dict[str, Any], project: Project, silent: bool = True, test: bool = True) -> None:
+    local_client = get_tinybird_local_client(config, test=test, silent=silent)
+    build_error = build_process(
+        project=project, tb_client=local_client, watch=False, silent=silent, exit_on_error=False
+    )
     if build_error:
         raise CLIBuildException(build_error)
+
+
+def deploy_project(config: dict[str, Any], project: Project) -> None:
+    client = _get_tb_client(config["token"], config["host"])
+    create_deployment(
+        project=project,
+        client=client,
+        config=config,
+        wait=True,
+        auto=True,
+        allow_destructive_operations=False,
+    )
+
+
+def deploy_check_project(config: dict[str, Any], project: Project) -> None:
+    client = _get_tb_client(config["token"], config["host"])
+    create_deployment(
+        project=project,
+        client=client,
+        config=config,
+        check=True,
+        wait=True,
+        auto=True,
+    )
+
+
+def append_data(config: dict[str, Any], datasource_name: str, path: str) -> None:
+    client = get_tinybird_local_client(config, test=False, silent=False)
+    append_mock_data(client, datasource_name, path)
+
+
+def mock_data(
+    config: dict[str, Any], project: Project, datasource_name: str, data_format: str, rows: int
+) -> list[dict[str, Any]]:
+    client = get_tinybird_local_client(config, test=False, silent=False)
+    cli_config = CLIConfig.get_project_config()
+    datasource_path = project.get_resource_path(datasource_name, "datasource")
+
+    if not datasource_path:
+        raise CLIMockException(f"Datasource {datasource_name} not found")
+
+    datasource_content = Path(datasource_path).read_text()
+    prompt = ""
+    return create_mock_data(
+        datasource_name,
+        datasource_content,
+        rows,
+        prompt,
+        cli_config,
+        config,
+        cli_config.get_user_token() or "",
+        client,
+        data_format,
+        project.folder,
+    )
+
+
+def analyze_fixture(config: dict[str, Any], fixture_path: str) -> 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("."))
+    return meta

tinybird/tb/modules/agent/models.py

@@ -18,3 +18,9 @@ def create_model(
         model_name=model,
         provider=AnthropicProvider(anthropic_client=client),
     )
+
+
+model_costs = {
+    "input_cost_per_token": 3e-06,
+    "output_cost_per_token": 1.5e-05,
+}

tinybird/tb/modules/agent/prompts.py

@@ -5,23 +5,29 @@ from tinybird.tb.modules.project import Project
 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
-
+Plan description: [One sentence describing what will be built]
+
+Steps:
+1. Connection: [name] - [description]
+2. Datasource: [name] - [description] - Depends on: [connection_name (optional)]
+3. Endpoint: [name] - [description] - Depends on: [resources]
+4. Materialized pipe: [name] - [description] - Depends on: [resources]
+5. Materialized datasource: [name] - [description] - Depends on: [resources]
+6. Sink: [name] - [description] - Depends on: [resources]
+7. Copy: [name] - [description] - Depends on: [resources]
+8. Build project
+9. Generate mock data: [datasource_name]
+10. Append existing fixture: [fixture_pathname] - Target: [datasource_name]
+
+<dev_notes>
 You can skip steps where resources will not be created or updated.
+Always add 'Build project' step after generating resources.
+Always add 'Generate mock data' step after building project if a landing datasource was created.
+Always add 'Append existing fixture' step after building project if a fixture file was provided at the beginning of the plan.
+</dev_notes>
 
-ESTIMATED_RESOURCES: [total number of steps]
-
-RESOURCE_DEPENDENCIES:
-[resource_name]: [resource_name]
+Resource dependencies:
+[resource_name]: [resources]
 """
 
 
@@ -89,31 +95,53 @@ datafile_instructions = """
 
 def resources_prompt(project: Project) -> str:
     files = project.get_project_files()
-
-    if not files:
-        return "No resources found"
-
-    paths = [Path(file_path) for file_path in files]
-
-    def get_resource_type(path: Path) -> str:
-        if path.suffix.lower() == ".pipe":
-            return Project.get_pipe_type(str(path))
-        elif path.suffix.lower() == ".datasource":
-            return "datasource"
-        elif path.suffix.lower() == ".connection":
-            return "connection"
-        return "unknown"
-
-    return "\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
-        ]
-    )
+    fixture_files = project.get_fixture_files()
+
+    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
+            ]
+        )
+    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
+            ]
+        )
+    else:
+        fixture_content += "No fixture files found"
+
+    return resources_content + "\n" + fixture_content
+
+
+def get_resource_type(path: Path) -> str:
+    if path.suffix.lower() == ".pipe":
+        return Project.get_pipe_type(str(path))
+    elif path.suffix.lower() == ".datasource":
+        return "datasource"
+    elif path.suffix.lower() == ".connection":
+        return "connection"
+    return "unknown"

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

@@ -0,0 +1,55 @@
+import click
+from pydantic_ai import RunContext
+
+from tinybird.tb.modules.agent.utils import TinybirdAgentContext, show_options
+from tinybird.tb.modules.feedback_manager import FeedbackManager
+
+
+def get_append_confirmation(datasource_name: str) -> bool:
+    """Get user confirmation for appending existing fixture"""
+    while True:
+        result = show_options(
+            options=["Yes, append existing fixture", "No, and tell Tinybird Code what to do"],
+            title=f"Do you want to append existing fixture for datasource {datasource_name}?",
+        )
+
+        if result is None:  # Cancelled
+            return False
+
+        if result.startswith("Yes"):
+            return True
+        elif result.startswith("No"):
+            return False
+
+        return False
+
+
+def append(ctx: RunContext[TinybirdAgentContext], datasource_name: str, fixture_pathname: str) -> str:
+    """Append existing fixture to a datasource
+
+    Args:
+        datasource_name: Name of the datasource to append fixture to
+        fixture_pathname: Path to the fixture file to append
+
+    Returns:
+        str: Message indicating the success or failure of the appending
+    """
+    try:
+        ctx.deps.thinking_animation.stop()
+        confirmation = ctx.deps.dangerously_skip_permissions or get_append_confirmation(datasource_name)
+        ctx.deps.thinking_animation.start()
+
+        if not confirmation:
+            return "User rejected appending existing fixture. Skipping..."
+
+        ctx.deps.thinking_animation.stop()
+        click.echo(FeedbackManager.highlight(message=f"\n» Appending {fixture_pathname} to {datasource_name}..."))
+        ctx.deps.append_data(datasource_name=datasource_name, path=fixture_pathname)
+        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:
+        ctx.deps.thinking_animation.stop()
+        click.echo(FeedbackManager.error(message=e))
+        ctx.deps.thinking_animation.start()
+        return f"Error appending fixture {fixture_pathname} to {datasource_name}: {e}"

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

@@ -0,0 +1,20 @@
+import click
+from pydantic_ai import RunContext
+
+from tinybird.tb.modules.agent.utils import TinybirdAgentContext
+from tinybird.tb.modules.feedback_manager import FeedbackManager
+
+
+def build(ctx: RunContext[TinybirdAgentContext]) -> str:
+    """Build the project"""
+    try:
+        ctx.deps.thinking_animation.stop()
+        click.echo(FeedbackManager.highlight(message="\n» Building project..."))
+        ctx.deps.build_project(test=False, silent=False)
+        ctx.deps.thinking_animation.start()
+        return "Project built successfully"
+    except Exception as e:
+        ctx.deps.thinking_animation.stop()
+        click.echo(FeedbackManager.error(message=e))
+        ctx.deps.thinking_animation.start()
+        return f"Error building project: {e}"

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

@@ -1,5 +1,18 @@
+import difflib
 from pathlib import Path
 
+try:
+    from colorama import Back, Fore, Style, init
+
+    init()
+except ImportError:  # fallback so that the imported classes always exist
+
+    class ColorFallback:
+        def __getattr__(self, name):
+            return ""
+
+    Fore = Back = Style = ColorFallback()
+
 import click
 from pydantic_ai import RunContext
 
@@ -8,6 +21,67 @@ from tinybird.tb.modules.exceptions import CLIBuildException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 
 
+def create_line_numbered_diff(original_content: str, new_content: str, filename: str) -> str:
+    """Create a diff with line numbers similar to the example format"""
+    original_lines = original_content.splitlines()
+    new_lines = new_content.splitlines()
+
+    # Create a SequenceMatcher to find the differences
+    matcher = difflib.SequenceMatcher(None, original_lines, new_lines)
+
+    result = []
+    result.append(f"╭{'─' * 88}╮")
+    result.append(f"│ {filename:<86} │")
+    result.append(f"│{' ' * 88}│")
+
+    # Process the opcodes to build the diff
+    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag == "equal":
+            # Show context lines
+            for i, line in enumerate(original_lines[i1:i2]):
+                line_num = i1 + i + 1
+                result.append(f"│ {line_num:4}        {line:<74} │")
+        elif tag == "replace":
+            # Show removed lines
+            for i, line in enumerate(original_lines[i1:i2]):
+                line_num = i1 + i + 1
+                result.append(f"│ {Back.RED}{line_num:4} -      {line:<74}{Back.RESET} │")
+            # Show added lines
+            for i, line in enumerate(new_lines[j1:j2]):
+                line_num = i1 + i + 1
+                result.append(f"│ {Back.GREEN}{line_num:4} +      {line:<74}{Back.RESET} │")
+        elif tag == "delete":
+            # Show removed lines
+            for i, line in enumerate(original_lines[i1:i2]):
+                line_num = i1 + i + 1
+                result.append(f"│ {Back.RED}{line_num:4} -      {line:<74}{Back.RESET} │")
+        elif tag == "insert":
+            # Show added lines
+            for i, line in enumerate(new_lines[j1:j2]):
+                # Use the line number from the original position
+                line_num = i1 + i + 1
+                result.append(f"│ {Back.GREEN}{line_num:4} +      {line:<74}{Back.RESET} │")
+
+    result.append(f"╰{'─' * 88}╯")
+    return "\n".join(result)
+
+
+def create_line_numbered_content(content: str, filename: str) -> str:
+    """Create a formatted display of file content with line numbers"""
+    lines = content.splitlines()
+
+    result = []
+    result.append(f"╭{'─' * 88}╮")
+    result.append(f"│ {filename:<86} │")
+    result.append(f"│{' ' * 88}│")
+
+    for i, line in enumerate(lines, 1):
+        result.append(f"│ {i:4}        {line:<74} │")
+
+    result.append(f"╰{'─' * 88}╯")
+    return "\n".join(result)
+
+
 def get_resource_confirmation(resource: Datafile, exists: bool) -> bool:
     """Get user confirmation for creating a resource"""
     while True:
@@ -39,22 +113,27 @@ def create_datafile(ctx: RunContext[TinybirdAgentContext], resource: Datafile) -
     """
     try:
         ctx.deps.thinking_animation.stop()
-        click.echo(resource.content)
         resource.pathname = resource.pathname.removeprefix("/")
         path = Path(ctx.deps.folder) / resource.pathname
+        content = resource.content
         exists = str(path) in ctx.deps.get_project_files()
-        confirmation = get_resource_confirmation(resource, exists)
-        ctx.deps.thinking_animation.start()
+        if exists:
+            content = create_line_numbered_diff(path.read_text(), resource.content, resource.pathname)
+        else:
+            content = create_line_numbered_content(resource.content, resource.pathname)
+        click.echo(content)
+        confirmation = ctx.deps.dangerously_skip_permissions or get_resource_confirmation(resource, exists)
 
         if not confirmation:
+            ctx.deps.thinking_animation.start()
             return f"Resource {resource.pathname} was not created. User cancelled creation."
 
         folder_path = path.parent
         folder_path.mkdir(parents=True, exist_ok=True)
         path.touch(exist_ok=True)
-
         path.write_text(resource.content)
-        ctx.deps.build_project()
+        ctx.deps.build_project(test=True, silent=True)
+        ctx.deps.thinking_animation.start()
         return f"Created {resource.pathname}"
 
     except CLIBuildException as e:

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

@@ -0,0 +1,45 @@
+import click
+from pydantic_ai import RunContext
+
+from tinybird.tb.modules.agent.utils import TinybirdAgentContext, show_options
+from tinybird.tb.modules.feedback_manager import FeedbackManager
+
+
+def get_deploy_confirmation() -> bool:
+    """Get user confirmation for deploying the project"""
+    while True:
+        result = show_options(
+            options=["Yes, deploy the project", "No, and tell Tinybird Code what to do"],
+            title="Do you want to deploy the project?",
+        )
+
+        if result is None:  # Cancelled
+            return False
+
+        if result.startswith("Yes"):
+            return True
+        elif result.startswith("No"):
+            return False
+
+        return False
+
+
+def deploy(ctx: RunContext[TinybirdAgentContext]) -> str:
+    """Deploy the project"""
+    try:
+        ctx.deps.thinking_animation.stop()
+        confirmation = ctx.deps.dangerously_skip_permissions or get_deploy_confirmation()
+        ctx.deps.thinking_animation.start()
+
+        if not confirmation:
+            return "User cancelled deployment."
+
+        ctx.deps.thinking_animation.stop()
+        ctx.deps.deploy_project()
+        ctx.deps.thinking_animation.start()
+        return "Project deployed successfully"
+    except Exception as e:
+        ctx.deps.thinking_animation.stop()
+        click.echo(FeedbackManager.error(message=e))
+        ctx.deps.thinking_animation.start()
+        return f"Error depoying project: {e}"