agentops-cockpit 0.4.1__py3-none-any.whl → 0.9.5__py3-none-any.whl

agent_ops_cockpit/ops/secret_scanner.py

@@ -12,6 +12,9 @@ console = Console()
 SECRET_PATTERNS = {
     "Google API Key": r"AIza[0-9A-Za-z-_]{35}",
     "AWS Access Key": r"AKIA[0-9A-Z]{16}",
+    "OpenAI API Key": r"sk-[a-zA-Z0-9]{20,}",
+    "Anthropic API Key": r"sk-ant-[a-zA-Z0-9]{20,}",
+    "Azure OpenAI Key": r"[0-9a-f]{32}",
     "Generic Bearer Token": r"Bearer\s+[0-9a-zA-Z._-]{20,}",
     "Hardcoded API Variable": r"(?i)(api_key|app_secret|client_secret|access_token)\s*=\s*['\"][0-9a-zA-Z_-]{16,}['\"]",
     "GCP Service Account": r"\"type\":\s*\"service_account\"",
@@ -28,7 +31,7 @@ def scan(path: str = typer.Argument(".", help="Directory to scan for secrets")):
     
     for root, dirs, files in os.walk(path):
         # Skip virtual environments, git, and tests
-        if any(skip in root for skip in [".venv", ".git", "src/backend/tests"]):
+        if any(skip in root.lower() for skip in [".venv", ".git", "tests", "test_", "node_modules"]):
             continue
             
         for file in files:
@@ -47,7 +50,7 @@ def scan(path: str = typer.Argument(".", help="Directory to scan for secrets")):
                                         "type": secret_name,
                                         "content": line.strip()[:50] + "..."
                                     })
-                except Exception as e:
+                except Exception:
                     continue
 
     table = Table(title="🛡️ Security Findings: Hardcoded Secrets")
@@ -57,6 +60,7 @@ def scan(path: str = typer.Argument(".", help="Directory to scan for secrets")):
     table.add_column("Suggestion", style="green")
 
     if findings:
+        console.print("\n[bold]🛠️  DEVELOPER ACTIONS REQUIRED:[/bold]")
         for finding in findings:
             table.add_row(
                 finding["file"],
@@ -64,7 +68,10 @@ def scan(path: str = typer.Argument(".", help="Directory to scan for secrets")):
                 finding["type"],
                 "Move to Secret Manager"
             )
-        console.print(table)
+            # Orchestrator parsing
+            console.print(f"ACTION: {finding['file']}:{finding['line']} | Found {finding['type']} leak | Move this credential to Google Cloud Secret Manager or .env file.")
+            
+        console.print("\n", table)
         console.print(f"\n❌ [bold red]FAIL:[/bold red] Found {len(findings)} potential credential leaks.")
         console.print("💡 [bold green]Recommendation:[/bold green] Use Google Cloud Secret Manager or environment variables for all tokens.")
         raise typer.Exit(code=1)

agent_ops_cockpit/ops/ui_auditor.py

@@ -5,116 +5,111 @@ from rich.console import Console
 from rich.table import Table
 from rich.panel import Panel
 
-app = typer.Typer(help="UI/UX Auditor: Governance and optimization for the Agent Face.")
+app = typer.Typer(help="Face Auditor: Scan frontend code for A2UI alignment.")
 console = Console()
 
-class UIFinding:
-    def __init__(self, id: str, category: str, severity: str, message: str, file: str, suggestion: str):
-        self.id = id
-        self.category = category
-        self.severity = severity
-        self.message = message
-        self.file = file
-        self.suggestion = suggestion
+@app.command()
+def audit(path: str = "src"):
+    """
+    Step 4: Frontend / A2UI Auditing.
+    Ensures frontend components are properly mapping surfaceId and detecting triggers.
+    """
+    console.print(Panel.fit("🎭 [bold blue]FACE AUDITOR: A2UI COMPONENT SCAN[/bold blue]", border_style="blue"))
+    console.print(f"Scanning directory: [yellow]{path}[/yellow]")
 
-def audit_ui_best_practices(src_path: str):
-    findings = []
-    
-    for root, dirs, files in os.walk(src_path):
-        if "node_modules" in root or ".venv" in root: continue
-        
-        for file in files:
-            path = os.path.join(root, file)
-            rel_path = os.path.relpath(path, src_path)
+    files_scanned = 0
+    issues = []
+
+    # Heuristic Patterns
+    surface_id_pattern = re.compile(r"surfaceId|['\"]surface-id['\"]")
+    registry_pattern = re.compile(r"A2UIRegistry|registerComponent")
+    trigger_pattern = re.compile(r"onTrigger|handleTrigger|agentAction")
+    ux_feedback_pattern = re.compile(r"Skeleton|Loading|Spinner|Progress")
+    a11y_pattern = re.compile(r"aria-label|role=|tabIndex|alt=")
+    legal_pattern = re.compile(r"Copyright|PrivacyPolicy|Disclaimer|TermsOfService|©")
+    marketing_pattern = re.compile(r"og:image|meta\s+name=['\"]description['\"]|favicon|logo")
+
+    for root, dirs, files in os.walk(path):
+        if any(d in root for d in [".venv", "node_modules", ".git", "dist"]):
+            continue
             
-            if file.endswith((".tsx", ".jsx", ".ts", ".js")):
+        for file in files:
+            if file.endswith((".tsx", ".ts", ".js", ".jsx")):
+                files_scanned += 1
+                file_path = os.path.join(root, file)
+                rel_path = os.path.relpath(file_path, ".")
                 try:
-                    with open(path, "r", errors="ignore") as f:
-                        content = f.read()
+                    with open(file_path, 'r') as f:
+                        lines = f.readlines()
+                        content = "".join(lines)
                         
-                        # 1. A2UI Compliance: Missing surface IDs
-                        if "a2-surface" in content and "surfaceId" not in content:
-                            findings.append(UIFinding(
-                                "a2ui_surface_id", "A2UI Protocol", "HIGH",
-                                "Detected A2UI surface without unique surfaceId.",
-                                rel_path, "Add `surfaceId` for automated browser testing."
-                            ))
-                            
-                        # 2. Accessibility: Missing ARIA
-                        if "<button" in content.lower() and "aria-label" not in content.lower() and "children" not in content.lower():
-                            findings.append(UIFinding(
-                                "aria_label", "Accessibility", "MEDIUM",
-                                "Interactive button lacks description.",
-                                rel_path, "Add `aria-label` for screen readers."
-                            ))
+                    findings = []
+                    
+                    # Heuristic with Line Numbers
+                    if not surface_id_pattern.search(content):
+                        findings.append({"line": 1, "issue": "Missing 'surfaceId' mapping", "fix": "Add 'surfaceId' prop to the root component or exported interface."})
+                    
+                    if not registry_pattern.search(content) and "Registry" in file:
+                        findings.append({"line": 1, "issue": "Registry component without A2UIRegistry registration", "fix": "Wrap component in A2UIRegistry.registerComponent()."})
+                    
+                    if "Button" in file and not trigger_pattern.search(content):
+                        # Try to find the button line
+                        line_no = 1
+                        for i, line in enumerate(lines):
+                            if "<button" in line.lower() or "<Button" in line:
+                                line_no = i + 1
+                                break
+                        findings.append({"line": line_no, "issue": "Interactive component without Tool/Agent triggers", "fix": "Ensure the button calls an agent tool trigger (onTrigger)."})
 
-                        # 3. Optimization: Large Component Detection
-                        if len(content.splitlines()) > 300:
-                            findings.append(UIFinding(
-                                "large_component", "Refactor", "MEDIUM",
-                                f"Component file is very large ({len(content.splitlines())} lines).",
-                                rel_path, "Split into smaller sub-components for better performance."
-                            ))
+                    if not ux_feedback_pattern.search(content) and ("Page" in file or "View" in file):
+                         findings.append({"line": 1, "issue": "Missing 'Thinking' feedback (Skeleton/Spinner)", "fix": "Implement a Loading state or Skeleton component for agent latency."})
+                    
+                    if not a11y_pattern.search(content) and ("Button" in file or "Input" in file):
+                        line_no = 1
+                        for i, line in enumerate(lines):
+                            if "<button" in line.lower() or "<input" in line.lower():
+                                line_no = i + 1
+                                break
+                        findings.append({"line": line_no, "issue": "Missing i18n/Accessibility labels (aria-label)", "fix": "Add aria-label or alt tags for screen readers and i18n."})
 
-                        # 4. Streamlit: Hardcoded Secrets
-                        if "st.secrets" not in content and (".env" in content or "API_KEY" in content):
-                            findings.append(UIFinding(
-                                "st_secrets", "Streamlit Security", "HIGH",
-                                "Detected likely hardcoded keys instead of st.secrets.",
-                                rel_path, "Move tokens to .streamlit/secrets.toml."
-                            ))
+                    if not legal_pattern.search(content) and ("Page" in file or "Layout" in file or "Footer" in file):
+                        findings.append({"line": 1, "issue": "Missing Legal Disclaimer or Privacy Policy link", "fix": "Add a footer link to the mandatory Privacy Policy / TOS."})
+                    
+                    if not marketing_pattern.search(content) and ("index" in file.lower() or "head" in file.lower() or "App" in file):
+                        findings.append({"line": 1, "issue": "Missing Branding (Logo) or SEO Metadata (OG/Description)", "fix": "Add meta tags (og:image, description) and project logo."})
 
-                        # 5. Angular: Reactive Pattern
-                        if "@Component" in content and "signal" not in content.lower() and "Observable" not in content:
-                             findings.append(UIFinding(
-                                "angular_reactivity", "Angular Performance", "MEDIUM",
-                                "Component lacks reactive patterns (Signals/Observables).",
-                                rel_path, "Use Signals for low-latency Agent output sync."
-                            ))
+                    if findings:
+                        issues.append({"file": rel_path, "findings": findings})
 
-                except: continue
+                except Exception:
+                    pass
 
-            if file.endswith(".css"):
-                try:
-                    with open(path, "r", errors="ignore") as f:
-                        content = f.read()
-                        
-                        # 4. Responsive: Missing Media Queries
-                        if "@media" not in content:
-                            findings.append(UIFinding(
-                                "missing_media_queries", "UX / Responsive", "HIGH",
-                                "No media queries detected in CSS file.",
-                                rel_path, "Implement mobile-first responsive design."
-                            ))
-                except: continue
-                
-    return findings
+    console.print(f"📝 Scanned [bold]{files_scanned}[/bold] frontend files.")
 
-@app.command()
-def audit(path: str = typer.Argument("src", help="Path to the frontend source code")):
-    """
-    Runs a comprehensive UI/UX best practice audit on the codebase.
-    """
-    console.print(Panel.fit("🎨 [bold magenta]FACE AUDITOR: UI/UX GOVERNANCE[/bold magenta]", border_style="magenta"))
-    
-    findings = audit_ui_best_practices(path)
-    
-    table = Table(title="🎨 UI/UX Audit Results")
-    table.add_column("Category", style="cyan")
-    table.add_column("Severity", style="bold")
-    table.add_column("Message", style="white")
-    table.add_column("File", style="dim")
-    table.add_column("Suggestion", style="green")
+    table = Table(title="🔍 A2UI Audit Findings")
+    table.add_column("File:Line", style="cyan")
+    table.add_column("Issue", style="red")
+    table.add_column("Recommended Fix", style="green")
 
-    if findings:
-        for f in findings:
-            severity_style = "red" if f.severity == "HIGH" else "yellow"
-            table.add_row(f.category, f"[{severity_style}]{f.severity}[/{severity_style}]", f.message, f.file, f.suggestion)
-        
-        console.print(table)
-        console.print(f"\n⚠️ Found {len(findings)} UI/UX improvement opportunities.")
+    if not issues:
+        table.add_row("All Files", "[green]A2UI Ready[/green]", "No action needed.")
+    else:
+        # Structured output for Orchestrator parsing
+        console.print("\n[bold]🛠️  DEVELOPER ACTIONS REQUIRED:[/bold]")
+        for issue in issues:
+            for finding in issue["findings"]:
+                table.add_row(f"{issue['file']}:{finding['line']}", finding["issue"], finding["fix"])
+                # This line is for the orchestrator to parse easily
+                console.print(f"ACTION: {issue['file']}:{finding['line']} | {finding['issue']} | {finding['fix']}")
+
+    console.print("\n", table)
+
+    
+    if len(issues) > 5:
+        console.print("\n⚠️  [yellow]Recommendation:[/yellow] Your 'Face' layer has fragmented A2UI surface mappings.")
+        console.print("💡 Use the A2UI Registry to unify how your agent logic triggers visual surfaces.")
     else:
-        console.print("✅ [bold green]PASS:[/bold green] UI/UX architecture aligns with Agent Ops standards.")
+        console.print("\n✅ [bold green]Frontend is Well-Architected for GenUI interactions.[/bold green]")
 
 if __name__ == "__main__":
     app()

agent_ops_cockpit/ops/watcher.py

@@ -0,0 +1,138 @@
+import json
+import os
+import urllib.request
+import xml.etree.ElementTree as ET
+import re
+import sys
+from datetime import datetime
+from typing import Dict, Optional
+import importlib.metadata
+from packaging import version
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+console = Console()
+
+WATCHLIST_PATH = os.path.join(os.path.dirname(__file__), "watchlist.json")
+
+def get_local_version(package_name: str) -> str:
+    try:
+        return importlib.metadata.version(package_name)
+    except importlib.metadata.PackageNotFoundError:
+        return "Not Installed"
+
+def clean_version(v_str: str) -> str:
+    """Extracts a clean version number from strings like 'v1.2.3', 'package==1.2.3', '2026-01-28 (v0.1.0)'"""
+    # Look for patterns like X.Y.Z or X.Y
+    match = re.search(r'(\d+\.\d+(?:\.\d+)?(?:[a-zA-Z]+\d+)?)', v_str)
+    if match:
+        return match.group(1)
+    return v_str.strip().lstrip('v')
+
+def fetch_latest_from_atom(url: str) -> Optional[Dict[str, str]]:
+    try:
+        req = urllib.request.Request(url, headers={'User-Agent': 'Mozilla/5.0'})
+        with urllib.request.urlopen(req, timeout=10) as response:
+            tree = ET.parse(response)
+            root = tree.getroot()
+            ns = {'ns': 'http://www.w3.org/2005/Atom'}
+            
+            latest_entry = root.find('ns:entry', ns)
+            if latest_entry is not None:
+                title = latest_entry.find('ns:title', ns).text
+                updated = latest_entry.find('ns:updated', ns).text
+                raw_v = title.strip().split()[-1]
+                return {
+                    "version": clean_version(raw_v) if "==" not in raw_v else clean_version(raw_v.split("==")[-1]),
+                    "date": updated,
+                    "title": title
+                }
+    except Exception:
+        # console.print(f"[dim red]Error fetching {url}: {e}[/dim red]")
+        return None
+    return None
+
+def run_watch():
+    console.print(Panel.fit("🔍 [bold blue]AGENTOPS COCKPIT: ECOSYSTEM WATCHER[/bold blue]", border_style="blue"))
+    
+    if not os.path.exists(WATCHLIST_PATH):
+        console.print(f"❌ [red]Watchlist not found at {WATCHLIST_PATH}[/red]")
+        return
+
+    with open(WATCHLIST_PATH, 'r') as f:
+        watchlist = json.load(f)
+
+    table = Table(title=f"Ecosystem Pulse - {datetime.now().strftime('%Y-%m-%d')}", show_header=True, header_style="bold magenta")
+    table.add_column("Category", style="cyan")
+    table.add_column("Component", style="white")
+    table.add_column("Local", style="yellow")
+    table.add_column("Latest", style="green")
+    table.add_column("Status", justify="center")
+
+    updates_found = []
+
+    for category, items in watchlist.items():
+        for name, info in items.items():
+            package = info.get("package")
+            local_v_raw = get_local_version(package) if package else None
+            local_v = local_v_raw if local_v_raw else "N/A"
+            
+            with console.status(f"[dim]Checking {name}..."):
+                latest_info = fetch_latest_from_atom(info["feed"])
+            
+            if latest_info:
+                latest_v = latest_info["version"]
+                
+                is_outdated = False
+                if local_v_raw and local_v_raw != "Not Installed":
+                    try:
+                        is_outdated = version.parse(latest_v) > version.parse(local_v_raw)
+                    except Exception:
+                        is_outdated = latest_v > local_v_raw
+
+                status = "🚨 [bold red]UPDATE[/bold red]" if is_outdated else "✅ [green]OK[/green]"
+                if local_v == "Not Installed":
+                    status = "➕ [dim]NEW[/dim]"
+                if package is None:
+                    status = "🌐 [blue]SPEC[/blue]"
+
+                display_local = local_v if local_v != "Not Installed" else "[dim]Not Installed[/dim]"
+                table.add_row(
+                    category.upper(),
+                    name,
+                    display_local,
+                    latest_v,
+                    status
+                )
+
+                if is_outdated:
+                    updates_found.append({
+                        "name": name,
+                        "current": local_v,
+                        "latest": latest_v,
+                        "package": package,
+                        "desc": info["description"]
+                    })
+            else:
+                table.add_row(category.upper(), name, local_v, "[red]Fetch Failed[/red]", "❓")
+
+    console.print(table)
+
+    if updates_found:
+        console.print("\n[bold yellow]⚠️ Actionable Intelligence:[/bold yellow]")
+        for up in updates_found:
+            console.print(f"• [bold]{up['name']}[/bold]: {up['current']} ➔ [bold green]{up['latest']}[/bold green]")
+            console.print(f"  [dim]{up['desc']}[/dim]")
+        
+        pkgs = " ".join([u['package'] for u in updates_found if u['package']])
+        if pkgs:
+            console.print(f"\n[bold cyan]Pro-tip:[/bold cyan] Run `pip install --upgrade {pkgs}` to sync.")
+        
+        # Exit with special code to signal updates to CI/CD
+        sys.exit(2)
+    else:
+        console.print("\n[bold green]✨ All components are currently in sync with the latest stable releases.[/bold green]")
+
+if __name__ == "__main__":
+    run_watch()

agent_ops_cockpit/ops/watchlist.json

@@ -0,0 +1,88 @@
+{
+  "orchestration_frameworks": {
+    "google-adk": {
+      "feed": "https://github.com/google/adk-python/releases.atom",
+      "package": "google-adk",
+      "description": "Agent Development Kit - Core reasoning & tool orchestration",
+      "min_version_for_optimizations": "0.15.0"
+    },
+    "crewai": {
+      "feed": "https://github.com/crewAIInc/crewAI/releases.atom",
+      "package": "crewai",
+      "description": "CrewAI - Role-playing multi-agent systems",
+      "min_version_for_optimizations": "1.0.0"
+    },
+    "langgraph": {
+      "feed": "https://github.com/langchain-ai/langgraph/releases.atom",
+      "package": "langgraph",
+      "description": "LangGraph - Stateful multi-agent orchestration",
+      "min_version_for_optimizations": "0.1.0"
+    },
+    "autogen": {
+      "feed": "https://github.com/microsoft/autogen/releases.atom",
+      "package": "pyautogen",
+      "description": "Microsoft AutoGen - Conversational agent framework",
+      "min_version_for_optimizations": "0.4.0"
+    },
+    "openai-agents": {
+      "feed": "https://github.com/openai/openai-agents-python/releases.atom",
+      "package": "openai-agents",
+      "description": "OpenAI Agents SDK - Multi-agent workflows",
+      "min_version_for_optimizations": "0.5.0"
+    },
+    "copilotkit": {
+      "feed": "https://github.com/CopilotKit/CopilotKit/releases.atom",
+      "package": "@copilotkit/react-core",
+      "description": "In-app AI Copilots & UX components",
+      "min_version_for_optimizations": "1.20.0"
+    }
+  },
+  "platform_services": {
+    "agent-engine": {
+      "feed": "https://github.com/googleapis/python-aiplatform/releases.atom",
+      "package": "google-cloud-aiplatform",
+      "description": "Vertex AI Agent Engine - Managed agent execution",
+      "min_version_for_optimizations": "1.70.0"
+    }
+  },
+  "compatibility_rules": [
+    {
+      "component": "langgraph",
+      "works_well_with": [
+        "google-adk",
+        "openai-agents"
+      ],
+      "incompatible_with": [
+        "crewai"
+      ],
+      "reason": "CrewAI and LangGraph both attempt to manage the orchestration loop and state, leading to cyclic-dependency conflicts."
+    },
+    {
+      "component": "google-adk",
+      "works_well_with": [
+        "langgraph",
+        "mcp"
+      ],
+      "incompatible_with": [
+        "pyautogen"
+      ],
+      "reason": "AutoGen's conversational loop pattern conflicts with ADK's strictly typed tool orchestration."
+    },
+    {
+      "component": "mcp",
+      "works_well_with": [
+        "google-adk",
+        "langgraph",
+        "openai-agents"
+      ],
+      "incompatible_with": [],
+      "reason": "MCP is a universal standard and thrives in multi-framework environments."
+    }
+  ],
+  "research_sources": {
+    "well_architected": "https://cloud.google.com/architecture/framework",
+    "security_best_practices": "https://cloud.google.com/architecture/framework/security",
+    "cost_optimization": "https://cloud.google.com/architecture/framework/cost-optimization",
+    "operational_excellence": "https://cloud.google.com/architecture/framework/operational-excellence"
+  }
+}