a4e 0.1.5__py3-none-any.whl

a4e/cli_commands/dev.py

@@ -0,0 +1,162 @@
+# a4e/cli_commands/dev.py
+
+import typer
+from pathlib import Path
+from typing import Optional
+import pyperclip
+import os
+
+
+from ..utils.dev_manager import DevManager  # Correct relative import
+
+
+# Create a 'Typer' app specifically for the 'dev' command group
+app = typer.Typer(
+    no_args_is_help=True,
+    help="Commands for running the development server and ngrok tunnels.",
+)
+
+
+def get_ngrok_authtoken():
+    """
+    Attempts to retrieve the ngrok authtoken from the system.
+    """
+    # Try to get the ngrok token from an environment variable
+    token = os.environ.get("NGROK_AUTHTOKEN")
+    if token:
+        return token
+
+    # If not an environment variable try to look for it in the system
+    try:
+        home = Path.home()
+        config_paths = [
+            home / "AppData" / "Local" / "ngrok" / "ngrok.yml",  # Windows
+            home / ".ngrok2" / "ngrok.yml",  # Linux
+            home / ".config" / "ngrok" / "ngrok.yml",  # Linux
+            home / "Library" / "Application Support" / "ngrok" / "ngrok.yml",  # macOS
+        ]
+        for config_path in config_paths:
+            if config_path.exists():
+                with open(config_path, "r") as f:
+                    for line in f:
+                        if line.strip().startswith("authtoken:"):
+                            return line.strip().split(":", 1)[1].strip().strip("'\"")
+    except Exception:
+        pass
+
+    return None
+
+
+@app.command()
+def start(
+    directory: str = typer.Option(None, help="The directory to run the server on."),
+    port: int = typer.Option(5000, help="The local port to run the server on."),
+    auth_token: Optional[str] = typer.Option(
+        None,
+        help="Your ngrok authtoken. If not provided, it will be sourced from your environment or ngrok config.",
+    ),
+) -> None:
+    """
+    Starts the development server with an ngrok tunnel.
+    This command must be run from within the 'agent-store' directory.
+    """
+    if not auth_token:
+        auth_token = get_ngrok_authtoken()
+
+    if not auth_token:
+        print("Error: Could not find ngrok authtoken.")
+        print(
+            "Please provide it with the --auth-token option, or run 'ngrok config add-authtoken <YOUR_TOKEN>'"
+        )
+        raise typer.Exit(code=1)
+
+    current_dir = Path.cwd()
+    if directory:
+        current_dir = Path(directory)
+    project_dir = None
+
+    # Check if we're inside an agent directory (has agent.py and metadata.json)
+    if (current_dir / "agent.py").exists() and (current_dir / "metadata.json").exists():
+        # We're inside an agent directory - use it directly
+        project_dir = current_dir
+        print(f"Detected agent directory: {project_dir.name}")
+    elif current_dir.name == "agent-store":
+        # We're in agent-store - list available agents and prompt for selection
+        agent_store_path = current_dir
+        available_agents = []
+        if agent_store_path.is_dir():
+            available_agents = [d for d in agent_store_path.iterdir() if d.is_dir()]
+
+        while not project_dir:
+            print("\nSelect an agent to start:")
+            if available_agents:
+                for i, agent in enumerate(available_agents):
+                    print(f"  [{i + 1}] {agent.name}")
+                prompt_text = "\nPlease choose an agent"
+            else:
+                print("No agents found in the current 'agent-store' directory.")
+                raise typer.Exit(code=1)
+
+            try:
+                # Check if user entered a number
+                response = typer.prompt(prompt_text, type=str)
+                choice_index = int(response) - 1
+                if 0 <= choice_index < len(available_agents):
+                    project_dir = available_agents[choice_index]
+                else:
+                    print("Invalid number. Please try again.")
+            except ValueError:
+                # User entered a path string
+                print("Please enter a valid number.")
+    else:
+        print("Error: Run this command from an agent directory or the 'agent-store' directory.")
+        print(f"Current directory: {current_dir}")
+        print("\nTip: cd into your agent folder, or use --directory to specify the path.")
+        raise typer.Exit(code=1)
+
+    # Final validation of the selected directory
+    if not project_dir or not project_dir.is_dir():
+        print("Error: No valid agent directory selected.")
+        raise typer.Exit(code=1)
+
+    print(f"\nUsing agent folder: {project_dir}")
+    print("Starting development server...")
+
+    result = DevManager.start_dev_server(
+        project_dir=project_dir, port=port, auth_token=auth_token
+    )
+
+    if result.get("success"):
+        print("Dev mode started successfully:")
+        print(f"  Public URL: {result.get('public_url')}")
+        print(f"  Hub URL: {result.get('hub_url')}")
+
+        try:
+            pyperclip.copy(str(result.get("hub_url")))
+            print("  (Hub URL copied to clipboard!)")
+        except pyperclip.PyperclipException:
+            print(
+                "  (Could not copy Hub URL to clipboard. Please install xclip/xsel or enable Wayland clipboard for Linux.)"
+            )
+
+        print("\nInstructions:")
+        for instruction in result.get("instructions", []):
+            print(f"  {instruction}")
+
+        # Keep the CLI running to maintain the server process
+        print("\n[Server running - Press Ctrl+C to stop]")
+        try:
+            import time
+            while True:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            print("\nStopping dev server...")
+            DevManager.stop_dev_server(port)
+            print("Dev server stopped.")
+    else:
+        print(f"Error starting server: {result.get('error')}")
+        if result.get("details"):
+            print(f"Details: {result.get('details')}")
+        if result.get("fix"):
+            print(f"Fix: {result.get('fix')}")
+        raise typer.Exit(code=1)

a4e/cli_commands/info.py

@@ -0,0 +1,206 @@
+# a4e/cli_commands/info.py
+"""
+Command for displaying agent information.
+"""
+
+import typer
+import json
+from pathlib import Path
+from typing import Optional
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+console = Console()
+
+# Create a 'Typer' app for the 'info' command
+app = typer.Typer(
+    no_args_is_help=False,
+    help="Display information about your agent.",
+)
+
+
+def find_agent_dir(agent_name: Optional[str] = None) -> Optional[Path]:
+    """Find the agent directory from name or current working directory."""
+    cwd = Path.cwd()
+
+    if agent_name:
+        if Path(agent_name).is_absolute() and Path(agent_name).exists():
+            return Path(agent_name)
+        if (cwd / agent_name).exists():
+            return cwd / agent_name
+        agent_store = cwd / "file-store" / "agent-store" / agent_name
+        if agent_store.exists():
+            return agent_store
+        return None
+
+    if (cwd / "agent.py").exists() and (cwd / "metadata.json").exists():
+        return cwd
+
+    return None
+
+
+@app.callback(invoke_without_command=True)
+def info(
+    ctx: typer.Context,
+    agent_name: Optional[str] = typer.Option(
+        None, "--agent", "-a", help="Agent name/path (defaults to current directory)"
+    ),
+    json_output: bool = typer.Option(
+        False, "--json", "-j", help="Output as JSON"
+    ),
+) -> None:
+    """
+    Display information about the agent.
+
+    Shows metadata, structure, and statistics about the agent.
+
+    Example:
+        a4e info
+        a4e info --agent my-agent --json
+    """
+    # If a subcommand is being invoked, skip the callback logic
+    if ctx.invoked_subcommand is not None:
+        return
+
+    agent_dir = find_agent_dir(agent_name)
+    if not agent_dir:
+        console.print("[red]Error: Not in an agent directory. Use --agent to specify the agent.[/red]")
+        raise typer.Exit(code=1)
+
+    try:
+        from ..tools.project.get_agent_info import get_agent_info as mcp_get_agent_info
+
+        result = mcp_get_agent_info(agent_name=str(agent_dir))
+
+        # Handle response (get_agent_info returns {"agent_id", "metadata", "path"} or {"error"})
+        if "error" not in result:
+            if json_output:
+                console.print(json.dumps(result, indent=2))
+                return
+
+            # Display panel with basic info
+            metadata = result.get("metadata", {})
+
+            console.print(Panel.fit(
+                f"[bold cyan]{metadata.get('display_name', agent_dir.name)}[/bold cyan]\n"
+                f"[dim]{metadata.get('description', 'No description')}[/dim]\n\n"
+                f"[bold]ID:[/bold] {metadata.get('id', agent_dir.name)}\n"
+                f"[bold]Category:[/bold] {metadata.get('category', 'Unknown')}\n"
+                f"[bold]Path:[/bold] {agent_dir}",
+                title="Agent Info",
+                border_style="blue"
+            ))
+
+            # Structure summary
+            structure = result.get("structure", {})
+
+            table = Table(title="Structure Summary")
+            table.add_column("Component", style="cyan")
+            table.add_column("Count", justify="right")
+
+            table.add_row("Tools", str(structure.get("tools_count", 0)))
+            table.add_row("Views", str(structure.get("views_count", 0)))
+            table.add_row("Skills", str(structure.get("skills_count", 0)))
+            table.add_row("Prompts", str(structure.get("prompts_count", 0)))
+
+            console.print("")
+            console.print(table)
+
+            # List items if present
+            if structure.get("tools"):
+                console.print("\n[bold]Tools:[/bold]")
+                for tool in structure.get("tools", []):
+                    console.print(f"  • {tool}")
+
+            if structure.get("views"):
+                console.print("\n[bold]Views:[/bold]")
+                for view in structure.get("views", []):
+                    console.print(f"  • {view}")
+
+            if structure.get("skills"):
+                console.print("\n[bold]Skills:[/bold]")
+                for skill in structure.get("skills", []):
+                    console.print(f"  • {skill}")
+
+        else:
+            console.print(f"[red]Error: {result.get('error')}[/red]")
+            raise typer.Exit(code=1)
+
+    except ImportError as e:
+        console.print(f"[red]Error importing tools: {e}[/red]")
+        raise typer.Exit(code=1)
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(code=1)
+
+
+@app.command("instructions")
+def instructions(
+    json_output: bool = typer.Option(
+        False, "--json", "-j", help="Output as JSON"
+    ),
+) -> None:
+    """
+    Show instructions for AI agents on how to use A4E tools.
+
+    This displays the comprehensive documentation that AI assistants
+    (like Claude, Cursor, etc.) use to understand how to create A4E agents.
+
+    Example:
+        a4e info instructions
+        a4e info instructions --json
+    """
+    try:
+        from ..tools.project.get_instructions import get_instructions as mcp_get_instructions
+
+        result = mcp_get_instructions()
+
+        if result.get("success"):
+            if json_output:
+                console.print(json.dumps(result, indent=2))
+                return
+
+            # Display the instructions with nice formatting
+            console.print(Panel.fit(
+                "[bold cyan]A4E Agent Creator - AI Instructions[/bold cyan]\n\n"
+                "These instructions are provided to AI assistants when they use\n"
+                "the A4E MCP tools to create agents.",
+                border_style="blue"
+            ))
+
+            # Display quick reference
+            quick_ref = result.get("quick_reference", {})
+
+            table = Table(title="Quick Reference")
+            table.add_column("Item", style="cyan")
+            table.add_column("Value")
+
+            table.add_row("Workflow", " → ".join(quick_ref.get("workflow", [])))
+            table.add_row("Parameter Types", ", ".join(quick_ref.get("parameter_types", [])))
+            table.add_row("Templates", ", ".join(quick_ref.get("templates", [])))
+
+            naming = quick_ref.get("naming", {})
+            table.add_row("agent_name", naming.get("agent_name", ""))
+            table.add_row("tool_name", naming.get("tool_name", ""))
+            table.add_row("view_id", naming.get("view_id", ""))
+            table.add_row("skill_id", naming.get("skill_id", ""))
+
+            console.print("")
+            console.print(table)
+
+            # Print the full instructions
+            console.print("\n[bold]Full Instructions:[/bold]\n")
+            console.print(result.get("instructions", ""))
+
+        else:
+            console.print(f"[red]Error: {result.get('error')}[/red]")
+            raise typer.Exit(code=1)
+
+    except ImportError as e:
+        console.print(f"[red]Error importing tools: {e}[/red]")
+        raise typer.Exit(code=1)
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(code=1)

a4e/cli_commands/init.py

@@ -0,0 +1,211 @@
+# a4e/cli_commands/init.py
+"""
+Interactive project initialization command.
+"""
+
+import typer
+from pathlib import Path
+from typing import Optional
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt, Confirm
+
+console = Console()
+
+# Create a 'Typer' app for the 'init' command
+app = typer.Typer(
+    no_args_is_help=False,
+    help="Initialize a new A4E agent project with an interactive wizard.",
+)
+
+CATEGORIES = [
+    "Concierge",
+    "E-commerce",
+    "Fitness & Health",
+    "Education",
+    "Entertainment",
+    "Productivity",
+    "Finance",
+    "Customer Support",
+    "General",
+]
+
+TEMPLATES = {
+    "basic": "Minimal files only (agent.py, metadata.json, welcome view)",
+    "with-tools": "Basic + example tool",
+    "with-views": "Basic + example view",
+    "full": "Basic + example tool + example view",
+}
+
+
+def validate_agent_name(name: str) -> bool:
+    """Validate agent name format (lowercase, hyphens/underscores only)."""
+    return name.replace("-", "").replace("_", "").isalnum() and name.islower()
+
+
+@app.callback(invoke_without_command=True)
+def init(
+    ctx: typer.Context,
+    name: Optional[str] = typer.Option(
+        None, "--name", "-n", help="Agent ID (lowercase, hyphens, e.g., 'nutrition-coach')"
+    ),
+    display_name: Optional[str] = typer.Option(
+        None, "--display-name", "-d", help="Human-readable name"
+    ),
+    description: Optional[str] = typer.Option(
+        None, "--description", help="Short description of the agent"
+    ),
+    category: Optional[str] = typer.Option(
+        None, "--category", "-c", help="Agent category for marketplace"
+    ),
+    template: Optional[str] = typer.Option(
+        None, "--template", "-t", help="Project template (basic, with-tools, with-views, full)"
+    ),
+    directory: Optional[str] = typer.Option(
+        None, "--directory", help="Directory to create agent in (defaults to current directory)"
+    ),
+    non_interactive: bool = typer.Option(
+        False, "--yes", "-y", help="Skip interactive prompts (requires all options)"
+    ),
+) -> None:
+    """
+    Initialize a new A4E agent project.
+
+    Run without arguments for an interactive wizard, or pass all options for non-interactive mode.
+    """
+    console.print(Panel.fit(
+        "[bold blue]A4E Agent Creator[/bold blue]\n"
+        "Create a new conversational AI agent",
+        border_style="blue"
+    ))
+
+    # Interactive mode - prompt for missing values
+    if not non_interactive:
+        # Agent name
+        if not name:
+            while True:
+                name = Prompt.ask(
+                    "\n[bold]Agent name[/bold] (lowercase, hyphens allowed)",
+                    default="my-agent"
+                )
+                if validate_agent_name(name):
+                    break
+                console.print("[red]Invalid name. Use lowercase letters, numbers, and hyphens only.[/red]")
+
+        # Display name
+        if not display_name:
+            default_display = name.replace("-", " ").replace("_", " ").title()
+            display_name = Prompt.ask(
+                "[bold]Display name[/bold]",
+                default=default_display
+            )
+
+        # Description
+        if not description:
+            description = Prompt.ask(
+                "[bold]Description[/bold]",
+                default=f"A helpful {display_name} agent"
+            )
+
+        # Category selection
+        if not category:
+            console.print("\n[bold]Select a category:[/bold]")
+            for i, cat in enumerate(CATEGORIES, 1):
+                console.print(f"  [{i}] {cat}")
+
+            while True:
+                choice = Prompt.ask("Enter number", default="9")
+                try:
+                    idx = int(choice) - 1
+                    if 0 <= idx < len(CATEGORIES):
+                        category = CATEGORIES[idx]
+                        break
+                except ValueError:
+                    pass
+                console.print("[red]Invalid selection. Please enter a number.[/red]")
+
+        # Template selection
+        if not template:
+            console.print("\n[bold]Select a template:[/bold]")
+            for i, (key, desc) in enumerate(TEMPLATES.items(), 1):
+                console.print(f"  [{i}] {key}: {desc}")
+
+            while True:
+                choice = Prompt.ask("Enter number", default="1")
+                try:
+                    idx = int(choice) - 1
+                    if 0 <= idx < len(TEMPLATES):
+                        template = list(TEMPLATES.keys())[idx]
+                        break
+                except ValueError:
+                    pass
+                console.print("[red]Invalid selection. Please enter a number.[/red]")
+
+    # Validate all required fields
+    if not all([name, display_name, description, category, template]):
+        console.print("[red]Error: All fields are required. Use --yes for non-interactive mode only with all options.[/red]")
+        raise typer.Exit(code=1)
+
+    if not validate_agent_name(name):
+        console.print("[red]Error: Agent name must be lowercase with hyphens/underscores only.[/red]")
+        raise typer.Exit(code=1)
+
+    if category not in CATEGORIES:
+        console.print(f"[red]Error: Invalid category. Choose from: {', '.join(CATEGORIES)}[/red]")
+        raise typer.Exit(code=1)
+
+    if template not in TEMPLATES:
+        console.print(f"[red]Error: Invalid template. Choose from: {', '.join(TEMPLATES.keys())}[/red]")
+        raise typer.Exit(code=1)
+
+    # Confirmation
+    if not non_interactive:
+        console.print("\n[bold]Creating agent with:[/bold]")
+        console.print(f"  Name: {name}")
+        console.print(f"  Display Name: {display_name}")
+        console.print(f"  Description: {description}")
+        console.print(f"  Category: {category}")
+        console.print(f"  Template: {template}")
+
+        if not Confirm.ask("\nProceed?", default=True):
+            console.print("[yellow]Cancelled.[/yellow]")
+            raise typer.Exit(code=0)
+
+    # Import and call the MCP tool function directly
+    try:
+        from ..tools.project.initialize_project import initialize_project
+
+        # Set environment variable for directory if specified
+        import os
+        if directory:
+            os.environ["A4E_WORKSPACE"] = str(Path(directory).resolve())
+
+        result = initialize_project(
+            name=name,
+            display_name=display_name,
+            description=description,
+            category=category,
+            template=template,
+        )
+
+        if result.get("success"):
+            console.print(f"\n[green]✓ Agent '{name}' created successfully![/green]")
+            console.print(f"  Path: {result.get('path')}")
+
+            console.print("\n[bold]Next steps:[/bold]")
+            for step in result.get("next_steps", []):
+                console.print(f"  • {step}")
+
+            console.print(f"\n  cd {name}")
+            console.print("  a4e dev start")
+        else:
+            console.print(f"\n[red]Error: {result.get('error')}[/red]")
+            raise typer.Exit(code=1)
+
+    except ImportError as e:
+        console.print(f"[red]Error importing tools: {e}[/red]")
+        raise typer.Exit(code=1)
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(code=1)