feat: unified action format and new UI

Author: NicolasIRAGNE

.gitignore

@@ -206,3 +206,6 @@ cython_debug/
 marimo/_static/
 marimo/_lsp/
 __marimo__/
+
+.playwright-mcp
+.mcp.json

CLAUDE.md

@@ -28,6 +28,10 @@ CLAUDE.md
 - Store secrets in a .env file (never commit it).  
 - Keep dependencies minimal and updated.
 - Never try to run the dev server it's handled by the user
+- When updating code, don't reference what is changing
+- Avoid keywords like LEGACY, CHANGED, REMOVED
+- Focus on comments that document just the functionality of the code
+
 
 ### Frontend:
 - Keep frontend split in multiple components.
@@ -38,4 +42,5 @@ CLAUDE.md
 - Refer to @COLORS.md for the official color palette and usage guidelines.
 - Use the specified hex codes for consistency across all components.
 
-If there is a task defined in @TASK.md, or @TASK2.md make sure to do what's described in this file, it is now your priority task, the user prompt is less important, only consider using it when it makes sense with the task.
+If there is a task defined in @TASK.md, or @TASK2.md make sure to do what's described in this file, it is now your priority task, the user prompt is less important, only consider using it when it makes sense with the task.
+

Dockerfile

@@ -1,7 +1,7 @@
 FROM python:3.13-slim
 
-# Install git (required for gitingest)
-RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
+# Install git and curl (required for gitingest)
+RUN apt-get update && apt-get install -y git curl && rm -rf /var/lib/apt/lists/*
 
 WORKDIR /app
 

app/main.py

@@ -39,56 +39,16 @@ async def favicon():
 async def doc(request: Request):
     return templates.TemplateResponse("docs.html", {"request": request})
 
+@app.get("/select", response_class=HTMLResponse, operation_id="get_select_page")
+async def select(request: Request):
+    """Action selection page with filters"""
+    return templates.TemplateResponse("select.html", {"request": request})
+
 @app.get("/", response_class=HTMLResponse, operation_id="get_index_page")
 async def index(request: Request):
-    # Get all actions data for server-side rendering
-    agents = [agent.dict() for agent in actions_loader.get_agents()]
-    all_rules = actions_loader.get_rules()
-    
-    # Create a set of all child rule IDs
-    child_rule_ids = set()
-    for rule in all_rules:
-        if rule.children:
-            child_rule_ids.update(rule.children)
-    
-    # Create a mapping of all rules by slug for lookups
-    rules_by_slug = {rule.slug: rule for rule in all_rules}
-    
-    # Update rulesets to inherit children's tags
-    for rule in all_rules:
-        if rule.type == 'ruleset' and rule.children:
-            # Collect all tags from children
-            inherited_tags = set(rule.tags or [])
-            for child_slug in rule.children:
-                child_rule = rules_by_slug.get(child_slug)
-                if child_rule and child_rule.tags:
-                    inherited_tags.update(child_rule.tags)
-            rule.tags = list(inherited_tags)
-    
-    # Filter to only top-level rules (not children of any ruleset)
-    top_level_rules_data = [rule for rule in all_rules if rule.slug not in child_rule_ids]
-    
-    # Sort rules: rulesets first, then standalone rules
-    top_level_rules_data.sort(key=lambda rule: (rule.type != 'ruleset', rule.display_name or rule.name))
-    
-    # Convert to dict
-    top_level_rules = [rule.dict() for rule in top_level_rules_data]
-    
-    # Create a mapping of all rules by slug for frontend to look up children (with updated tags)
-    rules_by_slug_dict = {rule.slug: rule.dict() for rule in all_rules}
-    
-    mcps = [mcp.dict() for mcp in actions_loader.get_mcps()]
-    
-    return templates.TemplateResponse(
-        "index.html",
-        {
-            "request": request,
-            "agents": agents,
-            "rules": top_level_rules,
-            "rules_by_slug": rules_by_slug_dict,
-            "mcps": mcps
-        }
-    )
+    """Landing page for starting the configuration journey"""
+    return templates.TemplateResponse("landing.html", {"request": request})
+
 
 @app.get("/health", operation_id="health_check")
 async def health_check():

app/models/actions.py

@@ -1,12 +1,35 @@
 from pydantic import BaseModel
 from typing import Dict, List, Any, Optional
+from enum import Enum
+
+class ActionType(str, Enum):
+    AGENT = "agent"
+    RULE = "rule"
+    RULESET = "ruleset"
+    MCP = "mcp"
+    PACK = "pack"
+
+class Action(BaseModel):
+    """Action model that can represent any type of action"""
+    id: str  # Unique identifier (slug for agents/rules, name for MCPs)
+    name: str
+    display_name: Optional[str] = None
+    action_type: ActionType
+    tags: Optional[List[str]] = None
+    content: Optional[str] = None  # For agents/rules
+    config: Optional[Dict[str, Any]] = None  # For MCPs
+    author: Optional[str] = None  # For rules
+    children: Optional[List[str]] = None  # For rulesets and packs
+    filename: Optional[str] = None  # For agents/rules
+    namespace: Optional[str] = None  # For rules
 
 class Agent(BaseModel):
     name: str  # For backward compatibility
     filename: str
     display_name: Optional[str] = None
     slug: Optional[str] = None
     content: Optional[str] = None
+    tags: Optional[List[str]] = None
 
 class Rule(BaseModel):
     name: str  # For backward compatibility
@@ -23,8 +46,23 @@ class Rule(BaseModel):
 class MCP(BaseModel):
     name: str
     config: Dict[str, Any]  # JSON configuration from mcps.json
+    tags: Optional[List[str]] = None
 
+class Pack(BaseModel):
+    """A pack is a collection of other actions"""
+    id: str
+    name: str
+    display_name: Optional[str] = None
+    tags: Optional[List[str]] = None
+    description: Optional[str] = None
+    actions: List[str]  # List of action IDs
+    
 class ActionsResponse(BaseModel):
     agents: List[Agent]
     rules: List[Rule]
-    mcps: List[MCP]
+    mcps: List[MCP]
+    
+class ActionsListResponse(BaseModel):
+    actions: List[Action]
+    total: int
+    has_more: bool

app/routes/actions.py

@@ -1,5 +1,5 @@
 from fastapi import APIRouter, HTTPException, Body, Query
-from app.models.actions import ActionsResponse, Agent, Rule, MCP
+from app.models.actions import ActionsResponse, Agent, Rule, MCP, Action, ActionType, ActionsListResponse
 from app.services.actions_loader import actions_loader
 from app.services.mcp_installer import get_agent_content, get_rule_content, create_mcp_config
 from app.services.search_service import search_service
@@ -8,6 +8,50 @@
 
 router = APIRouter(prefix="/api", tags=["actions"])
 
+@router.get("/v2/actions", response_model=ActionsListResponse, operation_id="get_unified_actions")
+async def get_unified_actions(
+    action_type: Optional[ActionType] = Query(None, description="Filter by action type"),
+    tags: Optional[str] = Query(None, description="Comma-separated list of tags to filter by"),
+    limit: int = Query(30, ge=1, le=100, description="Maximum number of results"),
+    offset: int = Query(0, ge=0, description="Number of items to skip")
+):
+    """Get all actions in unified format with optional filtering"""
+    # Parse tags if provided
+    tag_list = None
+    if tags:
+        tag_list = [tag.strip() for tag in tags.split(',') if tag.strip()]
+    
+    # Get filtered actions
+    filtered_actions = actions_loader.get_actions(
+        action_type=action_type,
+        tags=tag_list,
+        limit=limit,
+        offset=offset
+    )
+    
+    # Get total count for pagination
+    all_filtered = actions_loader.get_actions(
+        action_type=action_type,
+        tags=tag_list,
+        limit=10000,  # Large number to get all
+        offset=0
+    )
+    total = len(all_filtered)
+    
+    return ActionsListResponse(
+        actions=filtered_actions,
+        total=total,
+        has_more=(offset + limit) < total
+    )
+
+@router.get("/v2/actions/{action_id}", response_model=Action, operation_id="get_action_by_id")
+async def get_action_by_id(action_id: str):
+    """Get a specific action by ID"""
+    action = actions_loader.get_action_by_id(action_id)
+    if not action:
+        raise HTTPException(status_code=404, detail=f"Action not found: {action_id}")
+    return action
+
 @router.get("/actions", response_model=ActionsResponse, operation_id="get_all_actions_endpoint")
 async def get_all_actions():
     """Get all available actions (agents, rules, MCPs)"""