andromity 0.1.0__py3-none-any.whl

andromity/__init__.py

@@ -0,0 +1,2 @@
+"""Andromity - The coding agent that never clocks out."""
+__version__ = "0.1.0"

andromity/cli.py

@@ -0,0 +1,73 @@
+import asyncio
+import click
+
+
+@click.group(invoke_without_command=True)
+@click.pass_context
+def main(ctx):
+    """Andromity — The coding agent that never clocks out.
+
+    Run without arguments to launch the interactive TUI.
+    """
+    if ctx.invoked_subcommand is None:
+        # No subcommand given — launch TUI directly
+        _launch_tui()
+
+
+def _launch_tui():
+    from andromity.telemetry import maybe_ping
+    maybe_ping()
+
+    from rich.console import Console
+    console = Console()
+    with console.status("[bold cyan]✦ Starting Andromity...[/bold cyan]", spinner="dots12"):
+        from andromity.tui.app import AndromityApp
+        app = AndromityApp()
+    app.run()
+
+
+@main.command()
+@click.argument("prompt")
+@click.option("--yes", is_flag=True, help="Auto-approve all actions")
+@click.option("--dry-run", is_flag=True, help="Preview actions without executing")
+@click.option("--profile", type=str, default="builder", help="Agent profile to use")
+def run(prompt, yes, dry_run, profile):
+    """Headless single-task mode."""
+    asyncio.run(_run_async(prompt, yes, dry_run, profile))
+
+
+@main.command()
+def tui():
+    """Launch the interactive TUI (same as running `andromity` with no args)."""
+    _launch_tui()
+
+
+
+async def _run_async(prompt, yes, dry_run, profile):
+    from andromity.config import config
+    from andromity.core.session import Session
+    from andromity.core.agent import Agent
+    from andromity.core.events import TextDelta, ToolCallStart, ToolCallEnd, Done
+    from andromity.core.models import get_context_limit_for_model, get_ollama_num_ctx
+    session = Session(name="headless-session")
+    provider = config.get("default", "provider", "")
+    model = config.get("default", "model", "")
+    if provider == "ollama":
+        ctx_limit = get_ollama_num_ctx(model)
+    else:
+        ctx_limit = get_context_limit_for_model(provider, model) if (provider and model) else 0
+    agent = Agent(session, profile=profile, dry_run=dry_run, auto_approve=yes, ctx_limit=ctx_limit)
+    print(f"\nUser: {prompt}\n")
+    print("Andromity:", end=" ", flush=True)
+    async for event in agent.run(prompt):
+        if isinstance(event, TextDelta):
+            print(event.text, end="", flush=True)
+        elif isinstance(event, ToolCallStart):
+            print(f"\n[Tool: {event.tool_name}]", end=" ", flush=True)
+        elif isinstance(event, ToolCallEnd):
+            print("[Done]", end=" ", flush=True)
+    print(f"\n\nTokens: {session.token_total} | Cost: ${session.cost_usd:.4f}")
+
+
+if __name__ == "__main__":
+    main()

andromity/config.py

@@ -0,0 +1,316 @@
+import hashlib
+import os
+import platform
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+import tomli_w
+
+
+def get_config_dir() -> Path:
+    if platform.system() == "Windows":
+        return Path(os.environ.get("APPDATA", "~")).expanduser() / "andromity"
+    return Path.home() / ".andromity"
+
+
+def get_shell() -> str:
+    if platform.system() == "Windows":
+        return "powershell"
+    return os.environ.get("SHELL", "/bin/bash")
+
+
+class ConfigManager:
+    def __init__(self, config_dir: Optional[Path] = None):
+        self.config_dir = config_dir or get_config_dir()
+        self.config_path = self.config_dir / "config.toml"
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        self._config_cache: Dict[str, Any] = {}
+        self._load()
+
+    def _load(self):
+        if not self.config_path.exists():
+            self._create_default_config()
+        with open(self.config_path, "rb") as f:
+            try:
+                self._config_cache = tomllib.load(f)
+            except Exception as e:
+                print(f"Warning: Failed to parse {self.config_path}: {e}")
+                self._config_cache = {}
+
+    def _create_default_config(self):
+        default_config = {
+            "default": {
+                "provider": "anthropic",
+                "model": "claude-sonnet-4-6",
+                "profile": "builder",
+                "permission_mode": "safe",
+                "allowed_commands": ["npm run", "npm test", "npm list", "npm run dev", "pytest", "python -m pytest", "git status", "git diff", "git log", "ls", "dir", "cat", "echo"]
+            },
+            "providers": [
+                {"name": "anthropic", "type": "anthropic"},
+                {"name": "ollama", "type": "ollama", "base_url": "http://localhost:11434"},
+            ],
+        }
+        self.save(default_config)
+
+    def save(self, config_data: Optional[Dict[str, Any]] = None):
+        data_to_save = config_data if config_data is not None else self._config_cache
+        with open(self.config_path, "wb") as f:
+            tomli_w.dump(data_to_save, f)
+        if config_data is not None:
+            self._config_cache = config_data
+
+    def get(self, section: str, key: str, default: Any = None) -> Any:
+        return self._config_cache.get(section, {}).get(key, default)
+
+    def set(self, section: str, key: str, value: Any):
+        if section not in self._config_cache:
+            self._config_cache[section] = {}
+        self._config_cache[section][key] = value
+        self.save()
+
+    def get_provider_config(self, provider_name: str) -> Optional[Dict[str, Any]]:
+        providers = self._config_cache.get("providers", [])
+        for p in providers:
+            if p.get("name") == provider_name:
+                return p
+        return None
+
+    def get_api_key(self, provider_name: str) -> Optional[str]:
+        provider_cfg = self.get_provider_config(provider_name)
+        if provider_cfg:
+            key = provider_cfg.get("api_key")
+            if key:
+                if key.startswith("$"):
+                    return os.environ.get(key[1:])
+                return key
+        
+        # Fallback to standard env vars
+        env_map = {
+            "anthropic": "ANTHROPIC_API_KEY",
+            "openai": "OPENAI_API_KEY",
+            "google": "GEMINI_API_KEY",
+            "deepseek": "DEEPSEEK_API_KEY",
+            "groq": "GROQ_API_KEY",
+            "openrouter": "OPENROUTER_API_KEY",
+            "nvidia": "NVIDIA_API_KEY",
+        }
+        if provider_name == "google":
+            return os.environ.get("GEMINI_API_KEY") or os.environ.get("GOOGLE_API_KEY")
+        if provider_name == "nvidia":
+            return os.environ.get("NVIDIA_API_KEY") or os.environ.get("NVIDIA_NIM_API_KEY")
+        env_var = env_map.get(provider_name)
+        if env_var:
+            return os.environ.get(env_var)
+        return None
+
+    def set_api_key(self, provider_name: str, api_key: str):
+        """Set or update the API key for a given provider in config.toml and environment."""
+        providers = self._config_cache.get("providers", [])
+        found = False
+        for p in providers:
+            if p.get("name") == provider_name:
+                p["api_key"] = api_key
+                found = True
+                break
+        if not found:
+            providers.append({"name": provider_name, "type": provider_name, "api_key": api_key})
+            self._config_cache["providers"] = providers
+        self.save()
+
+        # Also set in os.environ for immediate use by litellm
+        env_map = {
+            "anthropic": "ANTHROPIC_API_KEY",
+            "openai": "OPENAI_API_KEY",
+            "google": "GEMINI_API_KEY",
+            "deepseek": "DEEPSEEK_API_KEY",
+            "groq": "GROQ_API_KEY",
+            "openrouter": "OPENROUTER_API_KEY",
+        }
+        env_var = env_map.get(provider_name)
+        if env_var:
+            os.environ[env_var] = api_key
+
+    def list_providers(self) -> list:
+        return self._config_cache.get("providers", [])
+
+    # ─── User Management ─────────────────────────────────────────────────
+    def get_user(self) -> Dict[str, str]:
+        return self._config_cache.get("user", {})
+
+    def set_user(self, name: str, email: str):
+        if "user" not in self._config_cache:
+            self._config_cache["user"] = {}
+        if name is not None:
+            self._config_cache["user"]["name"] = name
+        if email is not None:
+            self._config_cache["user"]["email"] = email
+        self.save()
+
+    # ─── MCP Config ──────────────────────────────────────────────────────
+    def get_mcp_config_path(self, project_path: str = "") -> Path:
+        """Find the most specific mcp.json file available."""
+        candidates = []
+        if project_path:
+            candidates.extend([
+                Path(project_path) / ".andromity" / "mcp.json",
+                Path(project_path) / ".vscode" / "mcp.json",
+            ])
+        candidates.append(Path.home() / ".andromity" / "mcp.json")
+        for p in candidates:
+            if p.is_file():
+                return p
+        # Default to home if none exist
+        default_path = Path.home() / ".andromity" / "mcp.json"
+        default_path.parent.mkdir(parents=True, exist_ok=True)
+        if not default_path.exists():
+            import json
+            default_path.write_text(json.dumps({"mcpServers": {}}, indent=2), encoding="utf-8")
+        return default_path
+
+    def set_mcp_server_disabled(self, project_path: str, server_name: str, disabled: bool):
+        """Toggle the 'disabled' flag for a specific MCP server in the config."""
+        path = self.get_mcp_config_path(project_path)
+        if not path.exists():
+            return
+        try:
+            import json
+            data = json.loads(path.read_text(encoding="utf-8"))
+            servers = data.get("mcpServers") or data.get("servers") or {}
+            if server_name in servers and isinstance(servers[server_name], dict):
+                servers[server_name]["disabled"] = disabled
+                path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+        except Exception:
+            pass
+
+    def _find_mcp_file_for_server(self, project_path: str, server_name: str):
+        """
+        Return (path, data, key) for the mcp.json file that contains server_name,
+        searching project then global Gemini config.
+        Returns (None, None, None) if not found.
+        """
+        import json
+
+        # Candidate files in priority order
+        candidates = []
+        if project_path:
+            candidates.extend([
+                Path(project_path) / ".andromity" / "mcp.json",
+                Path(project_path) / ".vscode" / "mcp.json",
+            ])
+        candidates.extend([
+            Path.home() / ".andromity" / "mcp.json",
+            Path.home() / ".gemini" / "config" / "mcp_config.json",
+        ])
+
+        for p in candidates:
+            if not p.is_file():
+                continue
+            try:
+                data = json.loads(p.read_text(encoding="utf-8"))
+            except Exception:
+                continue
+            for key in ("mcpServers", "servers"):
+                if server_name in data.get(key, {}):
+                    return p, data, key
+        return None, None, None
+
+    def set_mcp_server_env(self, project_path: str, server_name: str, key: str, value: str):
+        """Set a single env-var key for an MCP server in the config file."""
+        path, data, srv_key = self._find_mcp_file_for_server(project_path, server_name)
+        if path is None:
+            return
+        try:
+            import json
+            servers = data.get(srv_key, {})
+            if "env" not in servers[server_name]:
+                servers[server_name]["env"] = {}
+            servers[server_name]["env"][key] = value
+            path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+        except Exception:
+            pass
+
+    def remove_mcp_server(self, project_path: str, server_name: str) -> bool:
+        """Remove an MCP server entry from the config file. Returns True on success."""
+        path, data, srv_key = self._find_mcp_file_for_server(project_path, server_name)
+        if path is None:
+            return False
+        try:
+            import json
+            del data[srv_key][server_name]
+            path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+            return True
+        except Exception:
+            return False
+
+    def convert_remote_to_mcp_remote(
+        self, project_path: str, server_name: str, token: str
+    ) -> bool:
+        """
+        Convert a remote HTTP server (serverUrl only) to use npx mcp-remote
+        with an Authorization: Bearer header, so it can be launched as stdio.
+        Searches project and global Gemini config. Returns True on success.
+        """
+        path, data, srv_key = self._find_mcp_file_for_server(project_path, server_name)
+        if path is None:
+            return False
+        try:
+            import json
+            conf = data[srv_key][server_name]
+            remote_url = conf.get("serverUrl") or conf.get("url") or ""
+            if not remote_url:
+                return False
+            # Preserve safe metadata fields only
+            meta = {k: v for k, v in conf.items()
+                    if k not in ("command", "args", "env", "serverUrl", "url",
+                                 "type", "$typeName")}
+            data[srv_key][server_name] = {
+                "command": "npx",
+                "args": [
+                    "-y", "mcp-remote", remote_url,
+                    "--header", f"Authorization:Bearer {token}",
+                ],
+                "env": {},
+                **meta,
+            }
+            path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+            return True
+        except Exception:
+            return False
+
+    # ─── Trust Management ────────────────────────────────────────────────
+    def _trust_key(self, path: str) -> str:
+        resolved = str(Path(path).resolve())
+        return "p" + hashlib.sha256(resolved.encode()).hexdigest()[:15]
+
+    def is_trusted(self, path: str) -> bool:
+        key = self._trust_key(path)
+        return key in self._config_cache.get("trusted_projects", {})
+
+    def set_trusted(self, path: str):
+        resolved = str(Path(path).resolve())
+        key = self._trust_key(path)
+        if "trusted_projects" not in self._config_cache:
+            self._config_cache["trusted_projects"] = {}
+        self._config_cache["trusted_projects"][key] = {
+            "path": resolved,
+            "trusted_at": datetime.now(timezone.utc).isoformat(),
+        }
+        self.save()
+
+    def revoke_trust(self, path: str):
+        key = self._trust_key(path)
+        trusted = self._config_cache.get("trusted_projects", {})
+        if key in trusted:
+            del trusted[key]
+            self.save()
+
+
+config = ConfigManager()

andromity/core/__init__.py

@@ -0,0 +1 @@
+"""Core modules."""

andromity/core/agent.py

@@ -0,0 +1,211 @@
+import json
+from typing import AsyncGenerator, Dict, Any, Optional, Callable
+
+from andromity.core.provider import stream_completion
+from andromity.core.session import Session
+from andromity.core.profiles import get_system_prompt, filter_tools_for_profile
+from andromity.core.tools import CORE_TOOLS, ToolRegistry, execute_tool, register_session
+from andromity.core.events import (
+    StreamEvent, TextDelta, ToolCallStart, ToolCallDelta, ToolCallEnd, Done, ToolResult, PlanApprovalRequired
+)
+from andromity.config import config
+
+
+class Agent:
+    def __init__(self, session: Session, profile: str = None, dry_run: bool = False,
+                 auto_approve: bool = False, on_tool_approval: Optional[Callable] = None,
+                 ctx_limit: int = 0):
+        self.session = session
+        self.profile = profile or config.get("default", "profile", "builder")
+        self.dry_run = dry_run
+        self.auto_approve = auto_approve
+        self.on_tool_approval = on_tool_approval
+        self.ctx_limit = ctx_limit
+        self.allowed_tools = filter_tools_for_profile(CORE_TOOLS, self.profile)
+        self._empty_retried = False
+        # Register session so plan tools can store plan in it
+        register_session(session)
+        sys_prompt = get_system_prompt(self.profile)
+        deferred_catalog = ToolRegistry.get_instance().get_deferred_prompt_catalog()
+        if deferred_catalog:
+            sys_prompt += "\n\n" + deferred_catalog
+
+        if not self.session.messages:
+            self.session.add_message("system", sys_prompt)
+        elif self.session.messages[0]["role"] == "system":
+            self.session.messages[0]["content"] = sys_prompt
+            self.session.save()
+
+    async def _compact_context(self) -> AsyncGenerator[StreamEvent, None]:
+        limit = self.ctx_limit
+        if limit <= 0:
+            from andromity.core.models import get_context_limit_for_model
+            provider = config.get("default", "provider", "")
+            model = config.get("default", "model", "")
+            limit = get_context_limit_for_model(provider, model)
+        if limit <= 0:
+            limit = 131072  # 128K default for unknown models
+
+        # Use real API-reported token count as primary source.
+        # Fall back to a crude character estimate only if we haven't had any API reply yet.
+        if self.session.token_total > 0:
+            current_tokens = self.session.token_total
+        else:
+            current_tokens = sum(len(str(m.get("content", ""))) // 4 for m in self.session.messages)
+        threshold = int(limit * 0.8)
+
+        # Also compact if history has grown beyond 30 user/assistant turns
+        # regardless of token count — keeps the window fresh for long sessions.
+        non_system = [m for m in self.session.messages if m.get("role") != "system"]
+        turn_limit_hit = len(non_system) > 60  # 30 user + 30 assistant = 60 messages
+
+        if (current_tokens > threshold or turn_limit_hit) and len(self.session.messages) > 6:
+            reason = "turn limit (30 turns)" if turn_limit_hit else "token limit"
+            yield TextDelta(text=f"\n*Context window near {reason}. Compacting memory...*\n\n")
+            
+            keep_last_n = 10
+            msgs_to_summarize = self.session.messages[1:-keep_last_n]
+            
+            summary_prompt = (
+                "Summarize the following conversation history. Focus on decisions made, "
+                "files created, the overarching goal and important details. Combine this with the previous "
+                "summary if one exists:\n\n"
+            )
+            for m in msgs_to_summarize:
+                role = m.get("role", "unknown")
+                content = str(m.get("content", ""))
+                if len(content) > 500:
+                    content = content[:500] + " ...[truncated]"
+                summary_prompt += f"{role.upper()}: {content}\n\n"
+                
+            summary_msgs = [{"role": "user", "content": summary_prompt}]
+            
+            new_summary = ""
+            async for event in stream_completion(summary_msgs, tools=[]):
+                if isinstance(event, TextDelta):
+                    new_summary += event.text
+            
+            removed = self.session.compact_messages(new_summary, keep_last_n=keep_last_n)
+            yield TextDelta(text=f"*Compacted {removed} messages into memory.*\n\n")
+
+    async def run(self, user_input: str) -> AsyncGenerator[StreamEvent, None]:
+        self.session.add_message("user", content=user_input)
+        
+        async for event in self._compact_context():
+            yield event
+
+        while True:
+            current_tool_id = None
+            current_tool_name = None
+            current_tool_args_str = ""
+            tool_calls_to_execute = []
+            assistant_content = ""
+            last_usage = None
+
+            async for event in stream_completion(self.session.messages, tools=self.allowed_tools):
+                yield event
+                if isinstance(event, TextDelta):
+                    assistant_content += event.text
+                elif isinstance(event, ToolCallStart):
+                    current_tool_id = event.tool_id
+                    current_tool_name = event.tool_name
+                    current_tool_args_str = ""
+                elif isinstance(event, ToolCallDelta):
+                    if event.tool_id == current_tool_id:
+                        current_tool_args_str += event.args_json_chunk
+                elif isinstance(event, ToolCallEnd):
+                    if current_tool_id == event.tool_id:
+                        tool_calls_to_execute.append({
+                            "id": current_tool_id, "type": "function",
+                            "function": {"name": current_tool_name, "arguments": current_tool_args_str},
+                        })
+                        current_tool_id = None
+                elif isinstance(event, Done):
+                    last_usage = event.usage
+
+            if last_usage:
+                from andromity.config import config
+                m = f"{config.get('default', 'provider', 'ollama')}/{config.get('default', 'model', '')}"
+                self.session.update_usage(last_usage, model=m)
+            else:
+                prompt_tokens = sum(len(str(m.get("content", ""))) // 4 for m in self.session.messages)
+                completion_tokens = len(assistant_content) // 4
+                self.session.update_usage({
+                    "prompt_tokens": prompt_tokens,
+                    "completion_tokens": completion_tokens,
+                    "total_tokens": prompt_tokens + completion_tokens
+                })
+
+            self.session.add_message(
+                "assistant",
+                content=assistant_content if assistant_content else None,
+                tool_calls=tool_calls_to_execute if tool_calls_to_execute else None,
+            )
+
+            if not assistant_content and not tool_calls_to_execute:
+                # Model returned nothing — retry once before giving up
+                if not getattr(self, '_empty_retried', False):
+                    self._empty_retried = True
+                    yield TextDelta(text="\n*Model returned empty, retrying...*\n\n")
+                    continue
+                self._empty_retried = False
+                from andromity.core.models import get_context_limit_for_model
+                provider = config.get("default", "provider", "")
+                model = config.get("default", "model", "")
+                limit = self.ctx_limit or get_context_limit_for_model(provider, model)
+                current_tokens = sum(len(str(m.get("content", ""))) // 4 for m in self.session.messages)
+                if limit > 0 and current_tokens > limit * 0.9:
+                    warning = (
+                        f"\n**[No response from model]** Context full ({current_tokens:,}/{limit:,} tokens). "
+                        "Try `/new` for a fresh session, or switch model with **Ctrl+L**.\n"
+                    )
+                else:
+                    warning = (
+                        "\n**[No response from model]** The model returned an empty response. "
+                        "Try rephrasing your message or switch model with **Ctrl+L**.\n"
+                    )
+                yield TextDelta(text=warning)
+                break
+
+            self._empty_retried = False
+
+            if not tool_calls_to_execute:
+                break
+
+            for tool_call in tool_calls_to_execute:
+                tool_name = tool_call["function"]["name"]
+                try:
+                    args = json.loads(tool_call["function"]["arguments"])
+                except json.JSONDecodeError:
+                    args = {}
+
+                if not self.auto_approve and self.on_tool_approval:
+                    import asyncio
+                    is_approved = await self.on_tool_approval(tool_name, args) if asyncio.iscoroutinefunction(self.on_tool_approval) else self.on_tool_approval(tool_name, args)
+                    if not is_approved:
+                        result = (
+                            f"TOOL REJECTED BY USER: '{tool_name}' was explicitly declined.\n"
+                            f"Do NOT retry this tool call.\n"
+                            f"Acknowledge the rejection, then ask the user how they would like to proceed."
+                        )
+                        self.session.add_message("tool", content=result, name=tool_name, tool_call_id=tool_call["id"])
+                        yield ToolResult(tool_id=tool_call["id"], result="[Rejected by User]")
+                        continue
+
+                if self.dry_run:
+                    result = f"[DRY RUN] Would execute {tool_name}({json.dumps(args, indent=2)})"
+                else:
+                    try:
+                        from andromity.core.tools import execute_tool_async
+                        result = await execute_tool_async(tool_name, args)
+                    except Exception as e:
+                        result = f"Error executing {tool_name}: {e}"
+
+                self.session.add_message("tool", content=str(result), name=tool_name, tool_call_id=tool_call["id"])
+                yield ToolResult(tool_id=tool_call["id"], result=str(result))
+
+                if tool_name == "write_plan":
+                    plan = self.session.load_plan_obj()
+                    if plan and plan.status == "pending":
+                        yield PlanApprovalRequired(plan=plan)
+

andromity/core/audio.py

@@ -0,0 +1,32 @@
+import os
+import sys
+import subprocess
+from pathlib import Path
+import threading
+
+def play_sound(sound_name: str = "done.wav"):
+    """
+    Play a sound file cross-platform without blocking.
+    Assumes sound file is in the project root.
+    """
+    # Find sound file inside the package assets folder
+    sound_path = Path(__file__).resolve().parent.parent / "assets" / "sounds" / sound_name
+    
+    if not sound_path.exists():
+        return
+        
+    path_str = str(sound_path)
+    
+    def _play():
+        try:
+            if sys.platform == "win32":
+                import winsound
+                winsound.PlaySound(path_str, winsound.SND_FILENAME)
+            elif sys.platform == "darwin":
+                subprocess.run(["afplay", path_str], check=False)
+            else:
+                subprocess.run(["aplay", "-q", path_str], check=False, stderr=subprocess.DEVNULL)
+        except Exception:
+            pass
+            
+    threading.Thread(target=_play, daemon=True).start()