redo-cli 0.1.0__py3-none-any.whl

modules/ui.py

@@ -0,0 +1,433 @@
+from rich import box
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+from rich.text import Text
+from rich.theme import Theme
+
+
+ASCII_BANNER = r"""
+ /$$$$$$$                  /$$
+| $$__  $$                | $$
+| $$  \ $$  /$$$$$$   /$$$$$$$  /$$$$$$
+| $$$$$$$/ /$$__  $$ /$$__  $$ /$$__  $$
+| $$__  $$| $$$$$$$$| $$  | $$| $$  \ $$
+| $$  \ $$| $$_____/| $$  | $$| $$  | $$
+| $$  | $$|  $$$$$$$|  $$$$$$$|  $$$$$$/
+|__/  |__/ \_______/ \_______/ \______/
+""".strip("\n")
+
+theme = Theme(
+    {
+        "brand": "bold steel_blue",
+        "muted": "grey58",
+        "success": "green4",
+        "warning": "dark_orange3",
+        "error": "red3",
+        "number": "grey82",
+        "command": "bright_white",
+    }
+)
+console = Console(theme=theme, highlight=False)
+
+BRAND = "bold steel_blue"
+MUTED = "grey58"
+SUCCESS = "green4"
+WARNING = "dark_orange3"
+ERROR = "red3"
+NUMBER = "grey82"
+PANEL_BORDER = "grey50"
+TABLE_BORDER = "grey46"
+BANNER_START = "#6f86a8"
+BANNER_END = "#b39ddb"
+
+
+def _hex_to_rgb(value):
+    value = value.lstrip("#")
+    return tuple(int(value[index : index + 2], 16) for index in (0, 2, 4))
+
+
+def _rgb_to_hex(rgb):
+    return "#{:02x}{:02x}{:02x}".format(*rgb)
+
+
+def _blend(start, end, ratio):
+    return tuple(round(start[index] + (end[index] - start[index]) * ratio) for index in range(3))
+
+
+def _gradient_text(text, start_color=BANNER_START, end_color=BANNER_END):
+    start = _hex_to_rgb(start_color)
+    end = _hex_to_rgb(end_color)
+    lines = text.splitlines()
+    total = max(len(lines) - 1, 1)
+    output = Text()
+
+    for index, line in enumerate(lines):
+        color = _rgb_to_hex(_blend(start, end, index / total))
+        output.append(line, style=f"bold {color}")
+        if index != len(lines) - 1:
+            output.append("\n")
+
+    return output
+
+
+def _status_line(label, message, style):
+    text = Text()
+    text.append(f"[{label}] ", style=style)
+    text.append(message)
+    console.print(text)
+
+
+def _plural(count, singular, plural=None):
+    if count == 1:
+        return f"{count} {singular}"
+    return f"{count} {plural or singular + 's'}"
+
+
+def _format_seconds(seconds):
+    seconds = int(seconds)
+    minutes, remaining_seconds = divmod(seconds, 60)
+    hours, remaining_minutes = divmod(minutes, 60)
+
+    parts = []
+    if hours:
+        parts.append(f"{hours}h")
+    if remaining_minutes:
+        parts.append(f"{remaining_minutes}m")
+    if remaining_seconds or not parts:
+        parts.append(f"{remaining_seconds}s")
+
+    return " ".join(parts)
+
+
+def _metadata_table(rows):
+    table = Table.grid(padding=(0, 2))
+    table.add_column(style=MUTED, no_wrap=True)
+    table.add_column()
+
+    for label, value in rows:
+        table.add_row(label, str(value))
+
+    return table
+
+
+def print_success(message):
+    _status_line("SUCCESS", message, SUCCESS)
+
+
+def print_error(message):
+    _status_line("ERROR", message, ERROR)
+
+
+def print_warning(message):
+    _status_line("WARNING", message, WARNING)
+
+
+def show_banner():
+    console.print(_gradient_text(ASCII_BANNER))
+    console.print(Text("Bookmarks for terminal workflows.", style=MUTED))
+    console.print(Text("Run redo --help for commands or redo --info for project details.", style=MUTED))
+
+
+def show_info(version, credit):
+    metadata = _metadata_table(
+        [
+            ("Version", version),
+            ("Credit", credit),
+            ("Storage", "redo path"),
+            ("Guide", "redo guide"),
+        ]
+    )
+
+    console.print(_gradient_text(ASCII_BANNER))
+    console.print(
+        Panel(
+            metadata,
+            title="Redo info",
+            border_style=PANEL_BORDER,
+            box=box.ROUNDED,
+        )
+    )
+
+
+def show_help_menu(version):
+    console.print(_gradient_text(ASCII_BANNER))
+    console.print(Text("Bookmarks for terminal workflows.", style=MUTED))
+
+    daily = Table(
+        title="Daily workflow",
+        box=box.ROUNDED,
+        border_style=TABLE_BORDER,
+        header_style=BRAND,
+    )
+    daily.add_column("Command", no_wrap=True)
+    daily.add_column("Purpose")
+    daily.add_row("redo new <name>", "Save a reusable workflow")
+    daily.add_row("redo run <name>", "Run a saved workflow")
+    daily.add_row("redo run <name> --dry", "Preview commands without executing")
+    daily.add_row("redo list", "See every saved workflow")
+    daily.add_row("redo show <name>", "Inspect commands and run count")
+
+    utilities = Table(
+        title="Utilities",
+        box=box.ROUNDED,
+        border_style=TABLE_BORDER,
+        header_style=BRAND,
+    )
+    utilities.add_column("Command", no_wrap=True)
+    utilities.add_column("Purpose")
+    utilities.add_row("redo guide", "Open the quick-start guide")
+    utilities.add_row("redo search <query>", "Find workflows by name, description, or command")
+    utilities.add_row("redo copy <source> <target>", "Duplicate a workflow")
+    utilities.add_row("redo rename <old> <new>", "Rename a workflow")
+    utilities.add_row("redo delete <name>", "Delete one workflow")
+    utilities.add_row("redo clearhistory", "Clear all saved workflows")
+
+    maintenance = Table(
+        title="Storage and maintenance",
+        box=box.ROUNDED,
+        border_style=TABLE_BORDER,
+        header_style=BRAND,
+    )
+    maintenance.add_column("Command", no_wrap=True)
+    maintenance.add_column("Purpose")
+    maintenance.add_row("redo path", "Show workflow storage location")
+    maintenance.add_row("redo doctor", "Check storage and risky saved commands")
+    maintenance.add_row("redo autofix", "Repair common storage problems")
+    maintenance.add_row("redo export <file>", "Back up workflows")
+    maintenance.add_row("redo import <file>", "Import workflows")
+    maintenance.add_row("redo --info", f"Show version {version} and credits")
+
+    console.print(
+        Panel(
+            Text("Redo command center", style=BRAND),
+            border_style=PANEL_BORDER,
+            box=box.ROUNDED,
+        )
+    )
+    console.print(daily)
+    console.print(utilities)
+    console.print(maintenance)
+    console.print(Text("Tip: placeholders look like {message} and are filled when you run a workflow.", style=MUTED))
+
+
+def show_guide():
+    intro = Text.assemble(
+        ("Redo guide\n", BRAND),
+        ("Save repeated terminal workflows once. Run them again with one command.", MUTED),
+    )
+
+    basics = Table.grid(padding=(0, 2))
+    basics.add_column(style=MUTED, no_wrap=True)
+    basics.add_column()
+    basics.add_row("Create", "redo new ship")
+    basics.add_row("Run", "redo run ship")
+    basics.add_row("Preview", "redo run ship --dry")
+    basics.add_row("Inspect", "redo list  |  redo show ship")
+
+    example = Syntax(
+        'Description: Commit and push code\n'
+        'Command: git add .\n'
+        'Command: git commit -m "{message}"\n'
+        'Command: git push\n'
+        'Command: :done',
+        "text",
+        theme="ansi_dark",
+        word_wrap=True,
+    )
+
+    placeholders = Table(
+        title="Placeholders",
+        box=box.ROUNDED,
+        border_style=TABLE_BORDER,
+        header_style=BRAND,
+    )
+    placeholders.add_column("Pattern", no_wrap=True)
+    placeholders.add_column("What happens")
+    placeholders.add_row("{message}", "Redo asks once, then inserts the value everywhere.")
+    placeholders.add_row("{project_name}", "Names must use letters, numbers, and underscores.")
+
+    warnings = Table(
+        title="Warnings",
+        box=box.ROUNDED,
+        border_style=TABLE_BORDER,
+        header_style=BRAND,
+    )
+    warnings.add_column("Tip", no_wrap=True)
+    warnings.add_column("Why it matters")
+    warnings.add_row("One command per prompt", "Do not separate commands with commas.")
+    warnings.add_row('Use git commit -m "{message}"', "Git needs -m for commit messages.")
+    warnings.add_row("Use --dry first", "Preview before running risky workflows.")
+
+    console.print(Panel(intro, border_style=PANEL_BORDER, box=box.ROUNDED))
+    console.print(Panel(basics, title="Core commands", border_style=PANEL_BORDER, box=box.ROUNDED))
+    console.print(Panel(example, title="Example workflow", border_style=PANEL_BORDER, box=box.ROUNDED))
+    console.print(placeholders)
+    console.print(warnings)
+
+
+def show_workflows_table(workflows):
+    if not workflows:
+        console.print(
+            Panel(
+                Text("No workflows saved yet.", style=MUTED),
+                title="Redo workflows",
+                border_style=PANEL_BORDER,
+                box=box.ROUNDED,
+            )
+        )
+        return
+
+    table = Table(
+        title="Redo workflows",
+        box=box.ROUNDED,
+        border_style=TABLE_BORDER,
+        header_style=BRAND,
+        show_lines=False,
+    )
+    table.add_column("Name", style="bold", no_wrap=True)
+    table.add_column("Description", overflow="fold")
+    table.add_column("Commands", justify="right", no_wrap=True)
+    table.add_column("Runs", justify="right", style=NUMBER, no_wrap=True)
+
+    for name, workflow in sorted(workflows.items()):
+        command_count = len(workflow.get("commands", []))
+        table.add_row(
+            name,
+            workflow.get("description", "") or "-",
+            _plural(command_count, "command"),
+            str(workflow.get("runs", 0)),
+        )
+
+    console.print(table)
+
+
+def show_workflow_details(name, workflow):
+    commands = workflow.get("commands", [])
+    metadata = _metadata_table(
+        [
+            ("Description", workflow.get("description", "") or "-"),
+            ("Commands", _plural(len(commands), "command")),
+            ("Runs", workflow.get("runs", 0)),
+        ]
+    )
+
+    console.print(
+        Panel(
+            metadata,
+            title=f"Workflow: {name}",
+            border_style=PANEL_BORDER,
+            box=box.ROUNDED,
+            expand=False,
+        )
+    )
+    show_commands(commands)
+
+
+def show_commands(commands):
+    if not commands:
+        console.print(
+            Panel(
+                Text("No commands in this workflow.", style=MUTED),
+                title="Commands",
+                border_style=PANEL_BORDER,
+                box=box.ROUNDED,
+            )
+        )
+        return
+
+    table = Table(
+        title="Commands",
+        box=box.SIMPLE_HEAVY,
+        header_style=BRAND,
+        show_edge=False,
+    )
+    table.add_column("#", justify="right", style=MUTED, no_wrap=True)
+    table.add_column("Command")
+
+    for index, command in enumerate(commands, start=1):
+        syntax = Syntax(command, "bash", theme="ansi_dark", word_wrap=True)
+        table.add_row(str(index), syntax)
+
+    console.print(table)
+
+
+def show_stats(workflows):
+    total_workflows = len(workflows)
+    total_runs = sum(int(workflow.get("runs", 0)) for workflow in workflows.values())
+    total_commands = sum(len(workflow.get("commands", [])) for workflow in workflows.values())
+    total_commands_run = sum(
+        len(workflow.get("commands", [])) * int(workflow.get("runs", 0))
+        for workflow in workflows.values()
+    )
+    estimated_seconds_saved = total_commands_run * 5
+    most_used = "-"
+
+    if workflows:
+        most_used_name, most_used_workflow = max(
+            workflows.items(),
+            key=lambda item: int(item[1].get("runs", 0)),
+        )
+        most_used = f"{most_used_name} ({_plural(int(most_used_workflow.get('runs', 0)), 'run')})"
+
+    summary = _metadata_table(
+        [
+            ("Total workflows", total_workflows),
+            ("Saved commands", total_commands),
+            ("Total runs", total_runs),
+            ("Most used workflow", most_used),
+            ("Estimated time saved", _format_seconds(estimated_seconds_saved)),
+        ]
+    )
+    console.print(
+        Panel(
+            summary,
+            title="Redo stats",
+            border_style=PANEL_BORDER,
+            box=box.ROUNDED,
+        )
+    )
+
+
+def show_doctor_report(report):
+    has_warnings = report["dangerous_count"] > 0 or not report["exists"]
+    health_text = "Needs attention" if has_warnings else "Ready"
+    health_style = WARNING if has_warnings else SUCCESS
+
+    headline = Text.assemble(
+        ("Status: ", MUTED),
+        (health_text, health_style),
+    )
+    checks = _metadata_table(
+        [
+            ("Workflow file", report["path"]),
+            ("File exists", "yes" if report["exists"] else "no"),
+            ("Total workflows", report["total_workflows"]),
+            ("Total commands", report["total_commands"]),
+            ("Placeholder fields", report["placeholder_count"]),
+            ("Dangerous commands", report["dangerous_count"]),
+        ]
+    )
+
+    console.print(
+        Panel(
+            Group(headline, "", checks),
+            title="Health check",
+            border_style=health_style,
+            box=box.ROUNDED,
+        )
+    )
+
+    if report["dangerous_commands"]:
+        table = Table(
+            title="Dangerous commands",
+            box=box.ROUNDED,
+            border_style=WARNING,
+            header_style=WARNING,
+        )
+        table.add_column("Workflow", style="bold", no_wrap=True)
+        table.add_column("Command")
+        for name, command in report["dangerous_commands"]:
+            table.add_row(name, command)
+        console.print(table)

redo_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,231 @@
+Metadata-Version: 2.4
+Name: redo-cli
+Version: 0.1.0
+Summary: Bookmarks for terminal workflows.
+Project-URL: Homepage, https://github.com/VibeSlayer-code/Redo
+Project-URL: Repository, https://github.com/VibeSlayer-code/Redo
+Project-URL: Issues, https://github.com/VibeSlayer-code/Redo/issues
+Keywords: cli,terminal,workflow,automation,developer-tools
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Topic :: System :: Shells
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12
+Requires-Dist: rich>=13
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+
+# Redo
+
+Redo is a CLI tool that saves repeated terminal workflows and runs them again with one command. It is built for developers who are tired of retyping the same setup, build, deploy, and cleanup commands.
+
+Think of it as bookmarks for terminal workflows.
+
+## Why Redo Exists
+
+Developers repeat the same command chains constantly: starting projects, running test suites, cleaning folders, pushing code, building apps, and following long README setup steps.
+
+Redo lets you define those workflows once, then replay them whenever you need them. It supports smart placeholders, previews, safety checks for dangerous commands, and simple usage stats.
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install redo-cli
+```
+
+For local development, clone the project, create a virtual environment, and install dependencies:
+
+```bash
+python -m venv .venv
+.venv\Scripts\activate
+pip install -r requirements.txt
+pip install -e .
+```
+
+You can run Redo locally with either form:
+
+```bash
+python main.py --help
+redo --help
+redo --info
+```
+
+Running `redo` with no command shows the Redo ASCII banner. Running `redo --info` shows the banner, version, storage path, and credit.
+
+Redo stores its workflow data in:
+
+```txt
+%APPDATA%/Redo/workflows.json on Windows, or ~/.redo/workflows.json when APPDATA is unavailable
+```
+
+Set `REDO_DATA_DIR` to override the storage directory. Run `redo path` to print the exact file Redo is using.
+
+Run `redo init` to create the folder and file explicitly, or let Redo create them the first time it needs storage.
+
+The first time you run `redo new`, Redo offers to show a quick guide. You can open that guide anytime with:
+
+```bash
+redo guide
+```
+
+## Usage
+
+Create a workflow:
+
+```bash
+redo new ship
+```
+
+Enter commands one by one:
+
+```txt
+Description: Commit and push code
+Command: git add .
+Command: git commit -m "{message}"
+Command: git push
+Command: :done
+```
+
+Run it later:
+
+```bash
+redo run ship
+```
+
+Redo shows a live status table while commands run. Successful command output stays quiet by default; if a command fails, Redo stops the workflow and shows a focused error panel with the captured output.
+
+Preview it without executing commands:
+
+```bash
+redo run ship --dry
+```
+
+## Commands
+
+```bash
+redo init
+redo new <name>
+redo list
+redo show <name>
+redo run <name>
+redo run <name> --dry
+redo delete <name>
+redo clearhistory
+redo stats
+```
+
+Developer QoL commands:
+
+```bash
+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 doctor` checks the workflow file, counts saved commands/placeholders, and flags risky commands before they surprise you later.
+
+`redo autofix` repairs common storage problems: 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 next to the main file before resetting it.
+
+`redo clearhistory` clears every saved workflow from the file shown by `redo path`. Use `redo clearhistory --yes` to skip the confirmation prompt.
+
+## Placeholders
+
+Use placeholders when part of a command changes each run:
+
+```bash
+git commit -m "{message}"
+npm create vite@latest {project_name}
+cd {project_name}
+```
+
+Redo asks once for each unique placeholder, then replaces every occurrence across the workflow.
+
+Valid placeholder names use letters, numbers, and underscores, and cannot start with a number:
+
+```txt
+{message}
+{project_name}
+{ticket_123}
+```
+
+Placeholder values are quoted before execution so prompt input is treated as one literal value instead of shell syntax. This prevents command separators, variable expansion, and globs from silently changing the command shape.
+
+Workflow names cannot be blank or reuse Redo command names such as `run`, `new`, `delete`, or `stats`.
+
+## Demo Workflow
+
+```bash
+redo new ship
+redo list
+redo show ship
+redo run ship --dry
+redo run ship
+redo stats
+```
+
+Example workflow data:
+
+```json
+{
+  "ship": {
+    "description": "Commit and push code",
+    "commands": [
+      "git add .",
+      "git commit -m \"{message}\"",
+      "git push"
+    ],
+    "runs": 0
+  }
+}
+```
+
+## Safety
+
+Redo detects risky commands before running them and asks for confirmation. Examples include:
+
+```bash
+rm -rf
+del /s
+format
+sudo
+git reset --hard
+```
+
+## Git Push Tip
+
+If Git says the current branch has no upstream branch, run the command Git suggests once:
+
+```bash
+git push --set-upstream origin master
+```
+
+After that, a workflow containing `git push` can push normally.
+
+## Roadmap
+
+- Project-local and global workflow stores
+- Tags and search
+- Shell completion
+- Workflow sharing through repository templates
+- More detailed time-saved analytics

redo_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+main.py,sha256=NVRu7YDsoqbRUGfNomRBSLdnjIrz7LH2nW4dp26iLss,9266
+modules/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+modules/placeholders.py,sha256=m0Yvo89cb5IKIxT1O1qPnAdyyo9ynuB5fsUKFed2nkQ,3606
+modules/runner.py,sha256=wihfKp4VMvJbn4t_B0J3bUvVO6Xu8gm3U_ZTiHP6Gag,7967
+modules/storage.py,sha256=bg7fGNVsgIehOXo1i-bEl5ZGwkpG5AXZIbumnl5m0Yk,15132
+modules/ui.py,sha256=tQi0JKDz8VD8BCpXw69zhtlW28I7LrVTSjFF9TwK9VQ,13221
+redo_cli-0.1.0.dist-info/METADATA,sha256=EBk_oFqtG6HbtRsMs-kASsJkowbCG_SSM0P908lpvAQ,6186
+redo_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+redo_cli-0.1.0.dist-info/entry_points.txt,sha256=g5fzs2F79fisWEEssiMcn6s-exrkvPme9CiYBPu7rqU,34
+redo_cli-0.1.0.dist-info/top_level.txt,sha256=AEStq8Ul9X2lAyef8AHIv8n5McZyoG48rZkemhotqrg,13
+redo_cli-0.1.0.dist-info/RECORD,,

redo_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

redo_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+redo = main:app

redo_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+main
+modules