tsugite-cli 0.3.3__py3-none-any.whl

tsugite/cli/agents.py

@@ -0,0 +1,148 @@
+"""Agent management CLI commands."""
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+console = Console()
+
+agents_app = typer.Typer(help="Manage agents and agent inheritance")
+
+
+@agents_app.command("list")
+def agents_list(
+    global_only: bool = typer.Option(False, "--global", help="List only global agents"),
+    local_only: bool = typer.Option(False, "--local", help="List only local agents"),
+):
+    """List available agents."""
+    from tsugite.agent_inheritance import get_global_agents_paths
+    from tsugite.agent_utils import list_local_agents
+
+    # Show global agents
+    if global_only or not local_only:
+        console.print("[cyan]Global Agents:[/cyan]\n")
+
+        found_any = False
+        for global_path in get_global_agents_paths():
+            if not global_path.exists():
+                continue
+
+            agent_files = sorted(global_path.glob("*.md"))
+            if agent_files:
+                found_any = True
+                console.print(f"[dim]{global_path}[/dim]")
+                for agent_file in agent_files:
+                    console.print(f"  • {agent_file.stem}")
+                console.print()
+
+        if not found_any:
+            console.print("[yellow]No global agents found[/yellow]")
+            console.print("\nGlobal agent locations:")
+            for path in get_global_agents_paths():
+                console.print(f"  {path}")
+            console.print()
+
+    # Show local agents
+    if local_only or not global_only:
+        console.print("[cyan]Local Agents:[/cyan]\n")
+
+        local_agents = list_local_agents()
+
+        if not local_agents:
+            console.print("[yellow]No local agents found[/yellow]")
+            console.print("\nLocal agent locations:")
+            console.print("  • Current directory (*.md)")
+            console.print("  • .tsugite/")
+            console.print("  • ./agents/")
+        else:
+            for location, agent_files in local_agents.items():
+                console.print(f"[dim]{location}[/dim]")
+                for agent_file in agent_files:
+                    console.print(f"  • {agent_file.stem}")
+                console.print()
+
+
+@agents_app.command("show")
+def agents_show(
+    agent_path: str = typer.Argument(help="Agent name or path to agent file"),
+    show_inheritance: bool = typer.Option(False, "--inheritance", help="Show inheritance chain"),
+):
+    """Show agent information.
+
+    Can be either a file path (e.g., 'examples/my_agent.md') or
+    an agent name to search globally (e.g., 'default', 'builtin-default').
+    """
+    from tsugite.agent_inheritance import find_agent_file
+    from tsugite.md_agents import parse_agent_file
+
+    try:
+        agent_file = Path(agent_path)
+
+        # If path doesn't exist, try to find it as an agent name
+        if not agent_file.exists():
+            found_path = find_agent_file(agent_path, Path.cwd())
+            if found_path:
+                agent_file = found_path
+                console.print(f"[dim]Found: {agent_file}[/dim]\n")
+            else:
+                console.print(f"[red]Agent not found: {agent_path}[/red]")
+                console.print("\nSearched in:")
+                console.print("  • Package agents")
+                console.print("  • Current directory")
+                console.print("  • .tsugite/")
+                console.print("  • ./agents/")
+                console.print("  • Global locations (use 'agents list --global' to see)")
+                raise typer.Exit(1)
+
+        agent = parse_agent_file(agent_file)
+        config = agent.config
+
+        console.print(f"[cyan]Agent:[/cyan] [bold]{config.name}[/bold]\n")
+
+        if config.description:
+            console.print(f"[bold]Description:[/bold] {config.description}\n")
+
+        if config.model:
+            console.print(f"[bold]Model:[/bold] {config.model}")
+        else:
+            console.print("[bold]Model:[/bold] [dim](uses default)[/dim]")
+
+        console.print(f"[bold]Max Steps:[/bold] {config.max_turns}")
+
+        if config.tools:
+            console.print(f"\n[bold]Tools ({len(config.tools)}):[/bold]")
+            for tool in config.tools:
+                console.print(f"  • {tool}")
+
+        if config.extends:
+            console.print(f"\n[bold]Extends:[/bold] {config.extends}")
+
+        if show_inheritance:
+            from tsugite.agent_utils import build_inheritance_chain
+
+            try:
+                chain = build_inheritance_chain(agent_file)
+                console.print("\n[bold cyan]Inheritance Chain:[/bold cyan]")
+
+                if len(chain) == 1:
+                    console.print("  [dim](no inheritance)[/dim]")
+                else:
+                    for i, (agent_name, agent_path) in enumerate(chain):
+                        is_current = i == len(chain) - 1
+                        prefix = "  └─" if is_current else "  ├─"
+
+                        if is_current:
+                            console.print(f"{prefix} [bold]{agent_name}[/bold] [dim](current)[/dim]")
+                        else:
+                            console.print(f"{prefix} {agent_name} [dim]({agent_path.name})[/dim]")
+                            if i < len(chain) - 1:
+                                console.print("  │")
+            except Exception as e:
+                console.print(f"\n[yellow]Could not build inheritance chain: {e}[/yellow]")
+
+        console.print()
+
+    except Exception as e:
+        console.print(f"[red]Failed to load agent: {e}[/red]")
+        raise typer.Exit(1)

tsugite/cli/attachments.py

@@ -0,0 +1,193 @@
+"""Attachment management CLI commands."""
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+console = Console()
+
+attachments_app = typer.Typer(help="Manage reusable text attachments")
+
+
+@attachments_app.command("add")
+def attachments_add(
+    alias: str = typer.Argument(help="Unique name for the attachment"),
+    source: str = typer.Argument(help="File path, URL, or '-' for stdin"),
+):
+    """Add or update an attachment.
+
+    For stdin input ('-'), content is stored inline in attachments.json.
+    For files and URLs, only the reference is stored (content fetched on demand).
+    """
+    from tsugite.attachments import add_attachment
+
+    try:
+        if source == "-":
+            # Read from stdin - store inline
+            import sys
+
+            content = sys.stdin.read()
+            add_attachment(alias, source="inline", content=content)
+
+            console.print(f"[green]✓ Inline attachment '{alias}' saved[/green]")
+            console.print("  Type: Inline text")
+            console.print(f"  Size: {len(content)} characters")
+        else:
+            # File or URL reference - validate but don't fetch
+            if source.startswith("http://") or source.startswith("https://"):
+                # URL reference
+                add_attachment(alias, source=source)
+                console.print(f"[green]✓ URL attachment '{alias}' saved[/green]")
+                console.print(f"  Source: {source}")
+                console.print("  Type: URL (fetched on demand)")
+            else:
+                # File reference - validate it exists
+                file_path = Path(source).expanduser()
+                if not file_path.exists():
+                    console.print(f"[red]File not found: {source}[/red]")
+                    raise typer.Exit(1)
+
+                # Store absolute path for reliability
+                absolute_path = str(file_path.resolve())
+                add_attachment(alias, source=absolute_path)
+
+                console.print(f"[green]✓ File attachment '{alias}' saved[/green]")
+                console.print(f"  Source: {absolute_path}")
+                console.print("  Type: File (read on demand)")
+
+    except Exception as e:
+        console.print(f"[red]Failed to add attachment: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@attachments_app.command("list")
+def attachments_list():
+    """List all attachments."""
+    from rich.table import Table
+
+    from tsugite.attachments import list_attachments
+
+    attachments = list_attachments()
+
+    if not attachments:
+        console.print("[yellow]No attachments found[/yellow]")
+        console.print("\nAdd an attachment with: [cyan]tsugite attachments add NAME SOURCE[/cyan]")
+        return
+
+    table = Table(title=f"Attachments ({len(attachments)} total)")
+    table.add_column("Alias", style="cyan")
+    table.add_column("Source", style="dim")
+    table.add_column("Size", justify="right")
+    table.add_column("Updated", style="dim")
+
+    for alias, data in sorted(attachments.items()):
+        size = len(data.get("content", ""))
+        updated = data.get("updated", "unknown")[:10]  # Just date part
+        table.add_row(alias, data.get("source", "unknown"), f"{size:,}", updated)
+
+    console.print(table)
+
+
+@attachments_app.command("show")
+def attachments_show(
+    alias: str = typer.Argument(help="Attachment alias to show"),
+    content: bool = typer.Option(False, "--content", help="Show full content"),
+):
+    """Show details of an attachment."""
+    from rich.panel import Panel
+
+    from tsugite.attachments import get_attachment
+    from tsugite.cache import get_cache_key, list_cache
+
+    result = get_attachment(alias)
+
+    if result is None:
+        console.print(f"[red]Attachment '{alias}' not found[/red]")
+        raise typer.Exit(1)
+
+    source, stored_content = result
+
+    # Determine attachment type
+    is_inline = source.lower() in ("inline", "text")
+
+    # Build panel content
+    panel_content = f"[cyan]Alias:[/cyan] {alias}\n"
+    panel_content += f"[cyan]Type:[/cyan] {'Inline' if is_inline else 'Reference'}\n"
+    panel_content += f"[cyan]Source:[/cyan] {source}\n"
+
+    # Check cache status for references
+    if not is_inline:
+        cache_entries = list_cache()
+        cache_key = get_cache_key(source)
+        if cache_key in cache_entries:
+            cache_info = cache_entries[cache_key]
+            panel_content += f"[cyan]Cached:[/cyan] Yes (size: {cache_info['size']:,} bytes)\n"
+            panel_content += f"[cyan]Cached at:[/cyan] {cache_info['cached_at']}\n"
+        else:
+            panel_content += "[cyan]Cached:[/cyan] No\n"
+
+    # Show content or preview
+    if is_inline and stored_content:
+        panel_content += f"[cyan]Size:[/cyan] {len(stored_content):,} characters\n"
+        if content:
+            panel_content += f"\n[cyan]Content:[/cyan]\n{stored_content}"
+        else:
+            preview = stored_content[:200]
+            if len(stored_content) > 200:
+                preview += "..."
+            panel_content += f"\n[cyan]Preview:[/cyan]\n{preview}"
+            panel_content += "\n\n[dim]Use --content to show full content[/dim]"
+    elif not is_inline and content:
+        # For references, fetch and show content if requested
+        from tsugite.utils import resolve_attachments
+
+        resolved = resolve_attachments([alias])
+        if resolved:
+            _, resolved_content = resolved[0]
+            panel_content += f"[cyan]Size:[/cyan] {len(resolved_content):,} characters\n"
+            panel_content += f"\n[cyan]Content:[/cyan]\n{resolved_content}"
+    elif not is_inline:
+        panel_content += "\n[dim]Use --content to fetch and show full content[/dim]"
+
+    console.print(Panel(panel_content, title=f"Attachment: {alias}", border_style="blue"))
+
+
+@attachments_app.command("remove")
+def attachments_remove(
+    alias: str = typer.Argument(help="Attachment alias to remove"),
+):
+    """Remove an attachment."""
+    from tsugite.attachments import remove_attachment
+
+    if remove_attachment(alias):
+        console.print(f"[green]✓ Attachment '{alias}' removed[/green]")
+    else:
+        console.print(f"[yellow]Attachment '{alias}' not found[/yellow]")
+
+
+@attachments_app.command("search")
+def attachments_search(
+    query: str = typer.Argument(help="Search term"),
+):
+    """Search attachments by alias or source."""
+    from rich.table import Table
+
+    from tsugite.attachments import search_attachments
+
+    results = search_attachments(query)
+
+    if not results:
+        console.print(f"[yellow]No attachments found matching '{query}'[/yellow]")
+        return
+
+    table = Table(title=f"Search Results for '{query}' ({len(results)} found)")
+    table.add_column("Alias", style="cyan")
+    table.add_column("Source", style="dim")
+    table.add_column("Size", justify="right")
+
+    for alias, data in sorted(results.items()):
+        size = len(data.get("content", ""))
+        table.add_row(alias, data.get("source", "unknown"), f"{size:,}")
+
+    console.print(table)