superqode 0.1.8__tar.gz → 0.1.10__tar.gz

{superqode-0.1.8/src/superqode.egg-info → superqode-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 0.1.8
+Version: 0.1.10
 Summary: SuperQode: Super Quality Engineering for Agentic Coding Teams
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>

{superqode-0.1.8 → superqode-0.1.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superqode"
-version = "0.1.8"
+version = "0.1.10"
 description = "SuperQode: Super Quality Engineering for Agentic Coding Teams"
 readme = "README.md"
 requires-python = ">=3.12"

{superqode-0.1.8 → superqode-0.1.10}/src/superqode/__init__.py

@@ -30,4 +30,4 @@ __all__ = [
     "sidebar",
 ]
 
-__version__ = "0.1.8"
+__version__ = "0.1.10"

superqode-0.1.10/src/superqode/agents/data/ampcode.com.toml

@@ -0,0 +1,69 @@
+# Schema defined in agent_schema.py
+# https://ampcode.com
+
+identity = "ampcode.com"
+name = "Amp"
+short_name = "amp"
+url = "https://ampcode.com"
+protocol = "acp"
+author_name = "Ampcode"
+author_url = "https://ampcode.com"
+publisher_name = "Superagentic AI"
+publisher_url = "https://super-agentic.ai"
+type = "coding"
+description = "AI coding agent by Ampcode. Works in any codebase with full ACP support via acp-amp adapter."
+tags = ["ampcode", "amp", "coding", "acp"]
+run_command."*" = "acp-amp"
+
+help = '''
+# Amp
+
+AI coding agent by Ampcode. Works in any codebase with full ACP support.
+
+- Multi-turn conversations with thread continuity
+- Full tool execution with permission modes
+- MCP server integration
+- Image support
+
+## Installation
+
+Install Amp CLI and the ACP adapter:
+
+```bash
+# Install Amp CLI
+curl -fsSL https://ampcode.com/install.sh | bash
+amp login
+
+# Install ACP adapter (Python - recommended)
+uv tool install acp-amp
+
+# Alternative: Node.js
+npm install -g @superagenticai/acp-amp
+```
+
+**Requirements:**
+- Amp CLI authenticated (`amp login`)
+- Python 3.10+ with uv (for Python version)
+- Or Node.js 18+ (for Node.js version)
+
+---
+
+**For latest install instructions**: https://superagenticai.github.io/acp-amp/
+**ACP Adapter**: https://github.com/SuperagenticAI/acp-amp
+'''
+
+welcome = '''
+Welcome to Amp! 🚀
+
+I'm Amp, an AI coding agent by Ampcode. I can help you with:
+- Code analysis and refactoring
+- Bug fixing and debugging
+- Writing new features
+- Code review and optimization
+
+Just tell me what you'd like to work on!
+'''
+
+[actions."*".install]
+command = "uv tool install acp-amp"
+description = "Install Amp ACP adapter (see https://superagenticai.github.io/acp-amp/ for latest)"

{superqode-0.1.8 → superqode-0.1.10}/src/superqode/agents/registry.py

@@ -247,6 +247,19 @@ AGENTS: Dict[str, AgentDef] = {
         connection_type="stdio",
         command="llmling-agent --acp",
     ),
+    "amp": AgentDef(
+        id="amp",
+        name="Amp",
+        protocol=AgentProtocol.ACP,
+        status=AgentStatus.SUPPORTED,
+        description="AI coding agent by Ampcode with full ACP support",
+        auth_info="Managed via amp login",
+        setup_command="uv tool install acp-amp",
+        docs_url="https://ampcode.com",
+        capabilities=["File editing", "Shell commands", "MCP tools", "Multi-turn"],
+        connection_type="stdio",
+        command="acp-amp",
+    ),
 }
 
 

{superqode-0.1.8 → superqode-0.1.10}/src/superqode/app_main.py

@@ -4660,7 +4660,7 @@ team:
         else:
             # Handle all other ACP-compatible agents generically
             # This covers: junie, goose, kimi, stakpak, vtcode, auggie,
-            # code-assistant, cagent, fast-agent, llmling-agent
+            # code-assistant, cagent, fast-agent, llmling-agent, amp
             acp_agents = {
                 "junie",
                 "goose",
@@ -4672,6 +4672,7 @@ team:
                 "cagent",
                 "fast-agent",
                 "llmling-agent",
+                "amp",
             }
             if short_name in acp_agents:
                 model_name = self.current_model if self.current_model else "auto"
@@ -4722,7 +4723,7 @@ team:
             self._current_file_context = ""  # Clear after use
 
         # Route ACP-compatible agents to the JSON-RPC ACP client
-        # All 14 official ACP agents support the Agent Client Protocol
+        # All 15 official ACP agents support the Agent Client Protocol
         acp_agents = (
             "opencode",
             "claude",
@@ -4738,6 +4739,7 @@ team:
             "cagent",
             "fast-agent",
             "llmling-agent",
+            "amp",
         )
         if agent_type in acp_agents:
             self._run_acp_jsonrpc_client(
@@ -4979,7 +4981,7 @@ team:
             self._current_file_context = ""
 
         # Choose command and model display based on agent type
-        # All 14 official ACP agents are supported
+        # All 15 official ACP agents are supported
         if agent_type == "gemini":
             command = "gemini --experimental-acp"
             model_display = f"gemini/{model}" if model and model != "auto" else "gemini/auto"
@@ -5058,6 +5060,10 @@ team:
         elif agent_type == "llmling-agent":
             command = "llmling-agent --acp"
             model_display = f"llmling-agent/{model}" if model else "llmling-agent/auto"
+        elif agent_type == "amp":
+            command = "acp-amp"
+            model_display = f"amp/{model}" if model else "amp/auto"
+            # Amp handles its own authentication via `amp login`
         else:
             self.call_from_thread(self._stop_thinking)
             self.call_from_thread(log.add_error, f"Unsupported ACP agent type: {agent_type}")
@@ -14862,6 +14868,9 @@ team:
             "stakpak": "📦",  # Package
             "vtcode": "🎨",  # Paint palette
             "openhands": "🤲",  # Open hands
+            "amp": "⚡",  # Lightning (Amp)
+            "ampcode": "⚡",  # Lightning
+            "ampcode.com": "⚡",  # Lightning
         }
 
         priority_order = {

superqode-0.1.10/src/superqode/auth/__init__.py

@@ -0,0 +1,264 @@
+"""
+Local Auth Storage for SuperQode.
+
+Simple, minimal local storage for API keys. Inspired by opencode's approach.
+
+Security:
+- File permissions set to 0o600 (owner read/write only)
+- Stored in ~/.superqode/auth.json
+- Never logs or exposes key values
+
+This is OPTIONAL - SuperQode still supports BYOK (env vars) as primary.
+Local storage is for users who prefer file-based key management.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+logger = logging.getLogger(__name__)
+
+
+class AuthType(Enum):
+    """Type of authentication credential."""
+
+    API = "api"  # Simple API key
+    OAUTH = "oauth"  # OAuth with refresh token
+    WELLKNOWN = "wellknown"  # Well-known auth (key + token pair)
+
+
+@dataclass
+class ApiAuth:
+    """Simple API key authentication."""
+
+    type: str = "api"
+    key: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"type": self.type, "key": self.key}
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ApiAuth":
+        return cls(type=data.get("type", "api"), key=data.get("key", ""))
+
+
+@dataclass
+class OAuthAuth:
+    """OAuth authentication with refresh token."""
+
+    type: str = "oauth"
+    refresh: str = ""
+    access: str = ""
+    expires: int = 0
+    account_id: Optional[str] = None
+    enterprise_url: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        result = {
+            "type": self.type,
+            "refresh": self.refresh,
+            "access": self.access,
+            "expires": self.expires,
+        }
+        if self.account_id:
+            result["account_id"] = self.account_id
+        if self.enterprise_url:
+            result["enterprise_url"] = self.enterprise_url
+        return result
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "OAuthAuth":
+        return cls(
+            type=data.get("type", "oauth"),
+            refresh=data.get("refresh", ""),
+            access=data.get("access", ""),
+            expires=data.get("expires", 0),
+            account_id=data.get("account_id"),
+            enterprise_url=data.get("enterprise_url"),
+        )
+
+    def is_expired(self) -> bool:
+        """Check if access token is expired."""
+        return self.expires > 0 and self.expires < int(datetime.now().timestamp())
+
+
+@dataclass
+class WellKnownAuth:
+    """Well-known authentication (key + token pair)."""
+
+    type: str = "wellknown"
+    key: str = ""
+    token: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"type": self.type, "key": self.key, "token": self.token}
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "WellKnownAuth":
+        return cls(
+            type=data.get("type", "wellknown"),
+            key=data.get("key", ""),
+            token=data.get("token", ""),
+        )
+
+
+AuthInfo = Union[ApiAuth, OAuthAuth, WellKnownAuth]
+
+
+def parse_auth_info(data: Dict[str, Any]) -> Optional[AuthInfo]:
+    """Parse auth info from dict based on type."""
+    auth_type = data.get("type")
+    if auth_type == "api":
+        return ApiAuth.from_dict(data)
+    if auth_type == "oauth":
+        return OAuthAuth.from_dict(data)
+    if auth_type == "wellknown":
+        return WellKnownAuth.from_dict(data)
+    return None
+
+
+class LocalAuthStorage:
+    """
+    Local storage for API keys and OAuth tokens.
+
+    Stores credentials in ~/.superqode/auth.json with restricted permissions.
+
+    Usage:
+        auth = LocalAuthStorage()
+
+        # Set API key
+        auth.set("anthropic", ApiAuth(key="sk-..."))
+
+        # Get credentials
+        creds = auth.get("anthropic")
+
+        # Remove
+        auth.remove("anthropic")
+
+        # List all
+        all_creds = auth.all()
+    """
+
+    DEFAULT_PATH = Path.home() / ".superqode" / "auth.json"
+
+    def __init__(self, filepath: Optional[Path] = None):
+        self.filepath = filepath or self.DEFAULT_PATH
+        self._ensure_dir()
+
+    def _ensure_dir(self) -> None:
+        """Ensure parent directory exists with proper permissions."""
+        parent = self.filepath.parent
+        if not parent.exists():
+            parent.mkdir(parents=True, mode=0o700)
+
+    def _read_file(self) -> Dict[str, Any]:
+        """Read auth file, return empty dict if not exists or invalid."""
+        if not self.filepath.exists():
+            return {}
+        try:
+            with open(self.filepath) as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return {}
+
+    def _write_file(self, data: Dict[str, Any]) -> None:
+        """Write auth file with secure permissions."""
+        # Write to temp file first, then rename (atomic)
+        temp_path = self.filepath.with_suffix(".tmp")
+        with open(temp_path, "w") as f:
+            json.dump(data, f, indent=2)
+
+        # Set permissions before moving
+        os.chmod(temp_path, 0o600)
+
+        # Atomic rename
+        temp_path.rename(self.filepath)
+
+    def get(self, provider_id: str) -> Optional[AuthInfo]:
+        """Get credentials for a provider."""
+        data = self._read_file()
+        if provider_id not in data:
+            return None
+        return parse_auth_info(data[provider_id])
+
+    def all(self) -> Dict[str, AuthInfo]:
+        """Get all stored credentials."""
+        data = self._read_file()
+        result: Dict[str, AuthInfo] = {}
+        for key, value in data.items():
+            if isinstance(value, dict):
+                parsed = parse_auth_info(value)
+                if parsed:
+                    result[key] = parsed
+        return result
+
+    def set(self, provider_id: str, info: AuthInfo) -> None:
+        """Set credentials for a provider."""
+        data = self._read_file()
+        data[provider_id] = info.to_dict()
+        self._write_file(data)
+        logger.debug(f"Saved auth for {provider_id}")
+
+    def remove(self, provider_id: str) -> bool:
+        """Remove credentials for a provider. Returns True if removed."""
+        data = self._read_file()
+        if provider_id not in data:
+            return False
+        del data[provider_id]
+        self._write_file(data)
+        logger.debug(f"Removed auth for {provider_id}")
+        return True
+
+    def exists(self, provider_id: str) -> bool:
+        """Check if credentials exist for a provider."""
+        return provider_id in self._read_file()
+
+    def clear(self) -> None:
+        """Clear all stored credentials."""
+        self._write_file({})
+        logger.debug("Cleared all auth")
+
+
+# Singleton instance
+_storage: Optional[LocalAuthStorage] = None
+
+
+def get_storage() -> LocalAuthStorage:
+    """Get the singleton auth storage instance."""
+    global _storage
+    if _storage is None:
+        _storage = LocalAuthStorage()
+    return _storage
+
+
+# Convenience functions
+def get(provider_id: str) -> Optional[AuthInfo]:
+    """Get credentials for a provider."""
+    return get_storage().get(provider_id)
+
+
+def all() -> Dict[str, AuthInfo]:
+    """Get all stored credentials."""
+    return get_storage().all()
+
+
+def set(provider_id: str, info: AuthInfo) -> None:
+    """Set credentials for a provider."""
+    get_storage().set(provider_id, info)
+
+
+def remove(provider_id: str) -> bool:
+    """Remove credentials for a provider."""
+    return get_storage().remove(provider_id)
+
+
+def exists(provider_id: str) -> bool:
+    """Check if credentials exist for a provider."""
+    return get_storage().exists(provider_id)