Wenn Sie Ihre CLI schon immer interaktiver und dynamischer gestalten wollten, könnte der Aufbau eines Echtzeit-Befehlsinteraktionssystems die Antwort sein. Durch die Nutzung der Introspektionsfähigkeiten von Python, Click zum Verwalten von Befehlen und Rich zum Formatieren der Ausgabe können Sie eine leistungsstarke, flexible CLI erstellen, die intelligent auf Benutzereingaben reagiert. Anstatt jeden Befehl manuell fest zu codieren, kann Ihre CLI Befehle automatisch erkennen und ausführen, wodurch das Benutzererlebnis reibungsloser und ansprechender wird.

Buntes Konsolen-Chaos: Hier treffen Klickbefehle auf satte Ausgabe – denn selbst das Terminal zeigt sich gern mit Stil!

Warum Click und Markdown verwenden?

Click vereinfacht die Verwaltung von Befehlen, das Parsen von Argumenten und die Generierung von Hilfe. Es ermöglicht außerdem eine einfache Befehlsstrukturierung und Optionshandhabung.

Mit Rich können Sie wunderschön formatiertes Markdown direkt im Terminal ausgeben, wodurch die Ergebnisse nicht nur funktional, sondern auch optisch ansprechend sind.

Durch die Kombination dieser beiden Bibliotheken mit Python-Introspektion können Sie eine interaktive Chat-Funktion erstellen, die Befehle dynamisch erkennt und ausführt und gleichzeitig die Ausgabe in einem reichhaltigen, lesbaren Format anzeigt. Sehen Sie sich als praktisches Beispiel an, wie StoryCraftr einen ähnlichen Ansatz verwendet, um KI-gesteuerte Schreibabläufe zu optimieren: https://storycraftr.app.

Aufbau des interaktiven Chat-Systems

1. Einrichten des grundlegenden Chat-Befehls

Der Chat-Befehl initialisiert die Sitzung und ermöglicht Benutzern die Interaktion mit der CLI. Hier erfassen wir Benutzereingaben, die dynamisch den entsprechenden Klickbefehlen zugeordnet werden.

import os
import click
import shlex
from rich.console import Console
from rich.markdown import Markdown

console = Console()

@click.command()
@click.option("--project-path", type=click.Path(), help="Path to the project directory")
def chat(project_path=None):
    """
    Start a chat session with the assistant for the given project.
    """
    if not project_path:
        project_path = os.getcwd()

    console.print(
        f"Starting chat for [bold]{project_path}[/bold]. Type [bold green]exit()[/bold green] to quit."
    )

    # Start the interactive session
    while True:
        user_input = console.input("[bold blue]You:[/bold blue] ")

        # Handle exit
        if user_input.lower() == "exit()":
            console.print("[bold red]Exiting chat...[/bold red]")
            break

        # Call the function to handle command execution
        execute_cli_command(user_input)

2. Selbstbeobachtung zum Entdecken und Ausführen von Befehlen

Mithilfe der Python-Introspektion entdecken wir dynamisch verfügbare Befehle und führen sie aus. Ein entscheidender Teil hierbei ist, dass Click-Befehle dekorierte Funktionen sind. Um die eigentliche Logik auszuführen, müssen wir die nicht dekorierte Funktion (d. h. den Rückruf) aufrufen.

So können Sie mithilfe der Introspektion Befehle dynamisch ausführen und mit den Dekoratoren von Click umgehen:

import inspect
import your_project_cmd  # Replace with your actual module containing commands

command_modules = {"project": your_project_cmd}  # List your command modules here

def execute_cli_command(user_input):
    """
    Function to execute CLI commands dynamically based on the available modules,
    calling the undecorated function directly.
    """
    try:
        # Use shlex.split to handle quotes and separate arguments correctly
        parts = shlex.split(user_input)
        module_name = parts[0]
        command_name = parts[1].replace("-", "_")  # Replace hyphens with underscores
        command_args = parts[2:]  # Keep the rest of the arguments as a list

        # Check if the module exists in command_modules
        if module_name in command_modules:
            module = command_modules[module_name]

            # Introspection: Get the function by name
            if hasattr(module, command_name):
                cmd_func = getattr(module, command_name)

                # Check if it's a Click command and strip the decorator
                if hasattr(cmd_func, "callback"):
                    # Call the underlying undecorated function
                    cmd_func = cmd_func.callback

                # Check if it's a callable (function)
                if callable(cmd_func):
                    console.print(
                        f"Executing command from module: [bold]{module_name}[/bold]"
                    )

                    # Directly call the function with the argument list
                    cmd_func(*command_args)
                else:
                    console.print(
                        f"[bold red]'{command_name}' is not a valid command[/bold red]"
                    )
            else:
                console.print(
                    f"[bold red]Command '{command_name}' not found in {module_name}[/bold red]"
                )
        else:
            console.print(f"[bold red]Module {module_name} not found[/bold red]")
    except Exception as e:
        console.print(f"[bold red]Error executing command: {str(e)}[/bold red]")

Wie funktioniert das?

• Eingabeparsing: Wir verwenden shlex.split, um Eingaben wie Befehlszeilenargumente zu verarbeiten. Dadurch wird sichergestellt, dass Zeichenfolgen und Sonderzeichen in Anführungszeichen korrekt verarbeitet werden.
• Modul- und Befehlssuche: Die Eingabe wird in Modulname und Befehlsname aufgeteilt. Der Befehlsname wird verarbeitet, um Bindestriche durch Unterstriche zu ersetzen, damit sie mit den Python-Funktionsnamen übereinstimmen.
• Introspektion: Wir verwenden getattr(), um die Befehlsfunktion dynamisch vom Modul abzurufen. Wenn es sich um einen Click-Befehl handelt (d. h. das Callback-Attribut hat), greifen wir auf die eigentliche Funktionslogik zu, indem wir den Click-Dekorator entfernen.
• Befehlsausführung: Sobald wir die nicht dekorierte Funktion abrufen, übergeben wir die Argumente und rufen sie auf, so als würden wir direkt eine Python-Funktion aufrufen.

3. Beispiel-CLI-Befehle

Betrachten wir einige Beispielbefehle innerhalb eines Projektmoduls, die Benutzer interaktiv über den Chat aufrufen können:

@click.group()
def project():
    """Project management CLI."""
    pass

@project.command()
def init():
    """Initialize a new project."""
    console.print("[bold green]Project initialized![/bold green]")

@project.command()
@click.argument("name")
def create(name):
    """Create a new component in the project."""
    console.print(f"[bold cyan]Component {name} created.[/bold cyan]")

@project.command()
def status():
    """Check the project status."""
    console.print("[bold yellow]All systems operational.[/bold yellow]")

Ausführen der Chat-Schnittstelle

So führen Sie das interaktive Chat-System aus:

1. Stellen Sie sicher, dass Ihre Module (wie das Projekt) in command_modules aufgeführt sind.
2. Führen Sie den Befehl aus:

python your_cli.py chat --project-path /path/to/project

Sobald die Sitzung beginnt, können Benutzer Befehle eingeben wie:

You: project init You: project create "Homepage"

Die Ausgabe wird mit Rich Markdown gut formatiert angezeigt:

[bold green]Project initialized![/bold green] [bold cyan]Component Homepage created.[/bold cyan]

Abschluss

Durch die Kombination von Click für die Befehlsverwaltung, Rich für Markdown-Formatierung und Python-Introspektion können wir ein leistungsstarkes und interaktives Chat-System für CLIs erstellen. Mit diesem Ansatz können Sie Befehle dynamisch erkennen und ausführen und gleichzeitig die Ausgabe in einem eleganten, lesbaren Format präsentieren.

Wichtige Highlights:

• Dynamische Befehlsausführung: Mit Introspection können Sie Befehle erkennen und ausführen, ohne sie fest zu codieren.
• Rich-Ausgabe: Durch die Verwendung von Rich Markdown wird sichergestellt, dass die Ausgabe leicht lesbar und optisch ansprechend ist.
• Flexibilität: Dieses Setup ermöglicht Flexibilität in der Befehlsstruktur und -ausführung.