Supercharge Your Data Pipelines: Build Powerful CLIs in Minutes

Data is the lifeblood of modern business, but accessing and processing it often remains a bottleneck. Data science and analytics teams spend countless hours writing complex scripts to fetch, clean, and analyze information. The problem? These scripts often live in isolated notebooks or repositories, are difficult for others to run, and suffer from the classic "it works on my machine" syndrome.

What if you could transform any data analysis script or ETL pipeline into a robust, shareable, and standardized command-line tool in minutes? What if you could empower teammates—from fellow engineers to product managers—to run complex data workflows with a single, intuitive command?

Welcome to the agentic way of building CLIs with cli.do. It's time to stop wrestling with ad-hoc scripts and start building scalable, accessible data tools.

The Friction in Modern Data Workflows

If you're on a data team, this probably sounds familiar:

Dependency Hell: A script written by a colleague won't run because you have a different version of pandas or a missing database driver.
Knowledge Silos: Only the script's original author knows the exact sequence of steps and the right parameters to use. When they're on vacation, the workflow grinds to a halt.
The Accessibility Gap: A product manager needs a daily sales report. They have to ask a data analyst to run a script manually, creating a recurring interruption and a delay in getting critical information.
No Standardization: One script takes a CSV file path as an argument, another requires you to edit a date range directly in the code, and a third pulls from a hardcoded S3 bucket. It's chaotic and error-prone.

These challenges prevent data teams from scaling their impact. The solution isn't to write more documentation; it's to turn your business logic into accessible, distributable tools.

The Solution: CLIs as an API

cli.do reimagines the command-line interface. Instead of a tedious local utility you have to build, package, and distribute yourself, cli.do treats your CLI as an API.

You define your command's logic and its parameters as part of an Agentic Workflow. Our platform instantly handles the rest:

Automatic Argument Parsing: No more argparse boilerplate. Define your arguments, types, and defaults, and we handle the parsing and validation.
Cloud Hosting & Execution: Your script runs in a consistent, scalable cloud environment. No more dependency conflicts.
Instant Distribution: Once defined, your CLI is live and callable by anyone you grant access to, from any terminal with the do command.

You write the core logic; we build, host, and serve the production-ready tool.

Example: From Python Script to Powerful Data CLI

Let's say you have a Python script that analyzes user engagement for a specific date range and cohort.

The "Before" Script (analyze.py):

# analysis_script.py
import pandas as pd

# PROBLEM: Parameters are hardcoded and must be manually changed for each run.
START_DATE = "2023-11-01"
END_DATE = "2023-11-30"
COHORT = "new_users"
OUTPUT_PATH = f"/tmp/report_{COHORT}.csv"

def run_analysis():
    print(f"Fetching data from {START_DATE} to {END_DATE} for cohort: {COHORT}...")
    # Pretend we are fetching data from a database or data lake
    # df = fetch_data(START_DATE, END_DATE, COHORT)
    # results = process_data(df)
    print(f"Analysis complete. Report saved to {OUTPUT_PATH}")
    # results.to_csv(OUTPUT_PATH)

# To run this, a user must edit the file and then execute `python analysis_script.py`
run_analysis()

This is brittle and impossible for a non-technical user to operate. Now, let's turn this into a powerful CLI using cli.do.

The "After" CLI-as-an-API (with a hypothetical Python SDK):

# Using a Python SDK conceptually similar to the @do-sdk/agent
from do_sdk import Agent 
import pandas as pd

# Define your CLI as an Agent
# This command will be available under the 'data' namespace
cli = Agent('data.cli.do')

# Create a 'run-engagement' command
@cli.on('run-engagement', {
    'start_date': { 'type': 'string', 'required': True },
    'end_date': { 'type': 'string', 'required': True },
    'cohort': { 'type': 'string', 'default': 'all_users' },
    'format': { 'type': 'string', 'default': 'json' }
})
async def run_analysis(args):
    """
    Fetches and analyzes user engagement data for a given period and cohort.
    """
    print(f"Fetching data from {args.start_date} to {args.end_date} for cohort: {args.cohort}...")
    
    # Your actual data fetching and analysis logic goes here
    # df = await fetch_data(args.start_date, args.end_date, args.cohort)
    # results = process_data(df)

    message = f"Analysis for cohort '{args.cohort}' completed successfully."
    return { 'status': 'success', 'message': message, 'output_format': args.format }

# That's it! Your CLI is now live.

With that simple agent definition, you've created a globally accessible tool. Anyone on your team can now open their terminal and run:

> do data run-engagement --start-date 2023-11-01 --end-date 2023-11-30 --cohort new_users

They get instant help and argument information with --help. The execution is logged. And you can control access with the full power of the .do platform's authentication system.

Unlocking Agility for Your Data Team

By adopting the CLI-as-an-API model, data teams can:

Democratize Data: Allow the sales team to generate their own weekly reports (do reports run-sales --region EMEA) or let product managers track feature adoption (do analytics query-feature --id 123).
Streamline MLOps: Create simple commands to trigger complex machine learning workflows.
- do ml retrain-model --model-id churn_predictor
- do ml deploy-model --model-id churn_predictor --env production
Ensure Reproducibility: Every CLI run is parameterized and executed in the same environment, making your results consistent and your experiments reproducible.
Accelerate Productionization: Go from a script in a notebook to a robust, shared tool without writing any boilerplate server code, API wrappers, or deployment pipelines.

Stop passing scripts around. Start distributing power. cli.do bridges the gap between your complex business logic and the people who need to use it, turning your data analysis into a scalable, on-demand service.