redo-cli 0.1.2

Bookmarks for terminal workflows.

Redo

A CLI tool for saving repeated terminal workflows and running them again with one command.

Stop retyping commands. Save workflows once, run them anytime.

Quick Start · Demo · Features · Commands · Local Development

---

What is Redo?

Redo is a command-line tool that turns repeated terminal command chains into reusable workflows.

Instead of typing this every time:

git add .
git commit -m "fixed bug"
git push

Save it once:

redo new ship

Then run it anytime:

redo run ship

Think of Redo as bookmarks for terminal workflows.

---

Demo Flow

redo new ship
redo list
redo show ship
redo run ship --dry
redo run ship
redo stats

Add a real screenshot or GIF at assets/demo-run.png. Best shot: the live workflow status table while redo run ship is running.

---

Quick Start

Install from PyPI:

pip install redo-cli

Create a workflow:

redo new ship

Enter commands one by one:

Description: Commit and push code
Command: git add .
Command: git commit -m "{message}"
Command: git push
Command: :done

Run it later:

redo run ship

Preview before running:

redo run ship --dry

---

Why It Matters

Developers repeat command chains constantly:

Project setup	npm install, copy env files, start dev servers
Git workflows	git add, git commit, git push
Build flows	run tests, build apps, deploy projects
Cleanup flows	remove build folders, reinstall dependencies, reset local state

Redo removes the small friction that adds up over time.

---

Features

Feature	What it does
Named workflows	Save repeated command chains as reusable workflows
One-command replay	Run saved workflows with redo run <name>
Smart placeholders	Use values like {message} or {project_name}
Dry run mode	Preview commands before executing them
Safety checks	Detect risky commands before they surprise you
Focused errors	Stop on failure and show the command that broke
Usage stats	Track run counts and time-saved estimates
Import/export	Back up and move workflows between machines
Doctor/autofix	Check and repair workflow storage issues

---

Commands

Core

redo init
redo new <name>
redo list
redo show <name>
redo run <name>
redo run <name> --dry
redo delete <name>
redo stats

Developer QoL

redo search <query>
redo copy <source> <target>
redo rename <old-name> <new-name>
redo path
redo export workflows-backup.json
redo import workflows-backup.json
redo import workflows-backup.json --replace
redo doctor
redo autofix
redo guide
redo clearhistory

---

Example Workflow

redo new ship

Description: Commit and push code
Command: git add .
Command: git commit -m "{message}"
Command: git push
Command: :done

Saved data:

{
  "ship": {
    "description": "Commit and push code",
    "commands": [
      "git add .",
      "git commit -m \"{message}\"",
      "git push"
    ],
    "runs": 0
  }
}

Run it:

redo run ship

Redo asks for the placeholder value:

message: fixed clumsy ui

Then runs:

git add .
git commit -m "fixed clumsy ui"
git push

---

Screenshots

Suggested files to add:

assets/banner.png
assets/demo-run.png
assets/list-command.png
assets/dry-run.png
assets/error-panel.png

For a CLI project, a short terminal GIF is the strongest visual. Recommended GIF:

assets/demo.gif

Show this sequence:

redo new ship
redo list
redo run ship --dry
redo run ship

Then embed it near the top:

<p align="center">
  <img src="assets/demo.gif" alt="Redo terminal demo" width="85%" />
</p>

---

Placeholders

Use placeholders when part of a command changes each run.

git commit -m "{message}"
npm create vite@latest {project_name}
cd {project_name}

Redo asks once for each unique placeholder and replaces every occurrence across the workflow.

Valid placeholder names:

{message}
{project_name}
{ticket_123}

Invalid placeholder names:

{123ticket}
{project-name}
{}

Placeholder values are quoted before execution so user input is treated as one literal value instead of shell syntax.

---

Safety

Redo detects risky commands before running them.

Examples:

rm -rf
del /s
format
sudo
git reset --hard

If a risky command is found, Redo asks for confirmation before continuing.

Use dry-run mode whenever you want to inspect a workflow first:

redo run cleanup --dry

---

Storage

Redo stores workflow data in:

%APPDATA%/Redo/workflows.json

If APPDATA is unavailable, Redo falls back to:

~/.redo/workflows.json

Override the storage directory:

REDO_DATA_DIR=<path>

Print the exact storage path:

redo path

Repair common storage issues:

redo autofix

redo autofix can fix missing files, blank files, malformed JSON, and workflow entries with missing fields. If JSON is malformed, Redo saves a non-overwriting workflows.broken.json backup before resetting the main file.

---

Local Development

Requirements:

Python 3.11+

Clone the repository:

git clone https://github.com/VibeSlayer-code/Redo.git
cd Redo

Create and activate a virtual environment:

python -m venv .venv
.venv\Scripts\activate

Install dependencies:

pip install -r requirements.txt
pip install -e .

Run locally:

python main.py --help
redo --help
redo --info

Run tests:

pytest

---

How It Works

Redo is split into small modules instead of one large script.

storage.py       workflow JSON storage
placeholders.py  placeholder detection and replacement
runner.py        command execution and dry runs
ui.py            terminal output and tables
main.py          CLI commands

The workflow lifecycle:

load workflow
process placeholders
preview or run commands
stop on failure
update run count

This keeps the codebase simple while still supporting useful CLI features like dry runs, safety checks, repair tools, and stats.

---

Roadmap

• Project-local workflow files
• Shell completion
• Workflow tags
• Workflow templates
• Shared workflows for repositories
• More detailed time-saved analytics
• Better safety rules for destructive commands

---

License

Source-available, all rights reserved.

You may view the source code, but you may not copy, modify, distribute, or use it without permission.