fix: consolidate to code/ only, fix bugs, add missing UI options

- Removed duplicated sonicoder/ package (paths now only in code/)
- Removed duplicate static/index.html
- Added code/mcp/ and code/policy/ modules (previously missing)
- Added create_app() to code/server/__init__.py
- Added v2 REST endpoints to code/server/routes.py
- Fixed UnboundLocalError in code/model/loader.py switch_model
- Fixed JSONResponse default=str bug in routes.py
- Added UI: language/framework/skill/agent selectors, web search toggle, image upload
- Updated app.py to import from code.* only

app.py

@@ -1,18 +1,18 @@
 """SoniCoder v2 — Entry point.
 
-Uses FastAPI directly (not gradio.Server) so our custom index.html
-is always served at / without Gradio overriding the root route.
+gradio.Server (Gradio 6.x) serves index.html from project root
+with Gradio's queuing, concurrency, and API infrastructure.
 
-Model is loaded BLOCKING before server starts — no lazy loading.
+Blog: https://huggingface.co/blog/introducing-gradio-server
 """
 
 from __future__ import annotations
 
 import logging
-import os
 
-# Ensure workspace exists
-from sonicoder.config import WORKSPACE_ROOT, CONFIG_DIR
+# Ensure workspace + config dirs exist
+from code.config import WORKSPACE_ROOT, CONFIG_DIR
+
 WORKSPACE_ROOT.mkdir(parents=True, exist_ok=True)
 CONFIG_DIR.mkdir(parents=True, exist_ok=True)
 
@@ -27,39 +27,38 @@ logger = logging.getLogger(__name__)
 def main():
     logger.info("SoniCoder v2 starting...")
 
-    # ── BLOCKING model load — model must be ready BEFORE server starts ──
-    from sonicoder.model.loader import load_model
-    from sonicoder.config import load_settings
-    settings = load_settings()
-    model_key = settings.default_model
-    logger.info(f"Loading model {model_key} (blocking)...")
+    # Start loading default model in background
+    from code.model.loader import start_background_load
+
+    start_background_load()
+    logger.info("Background model loading started")
+
+    # Set up MCP servers from config (best-effort)
     try:
-        load_model(model_key)
-        logger.info("Model loaded successfully — ready to serve")
-    except Exception as e:
-        logger.error(f"Failed to load model: {e}")
-        logger.info("Server will start anyway — model can be loaded later via API")
-
-    # ── Set up MCP servers from config ─────────────────────────────────
-    from sonicoder.mcp import get_mcp_manager
-    if settings.mcp_servers:
-        mcp = get_mcp_manager()
-        mcp.configure(settings.mcp_servers)
-        results = mcp.connect_all()
-        for name, error in results.items():
-            if error:
-                logger.warning(f"MCP server '{name}' failed: {error}")
-            else:
-                logger.info(f"MCP server '{name}' connected")
-
-    # ── Create the FastAPI server ──────────────────────────────────────
-    from sonicoder.server import create_app
+        from code.config import load_settings
+        from code.mcp import get_mcp_manager
+
+        settings = load_settings()
+        if settings.mcp_servers:
+            mcp = get_mcp_manager()
+            mcp.configure(settings.mcp_servers)
+            results = mcp.connect_all()
+            for name, error in results.items():
+                if error:
+                    logger.warning("MCP server '%s' failed: %s", name, error)
+                else:
+                    logger.info("MCP server '%s' connected", name)
+    except Exception as exc:
+        logger.warning("MCP setup skipped: %s", exc)
+
+    # Create the server (gradio.Server — custom HTML + Gradio backend)
+    from code.server import create_app
+
     app = create_app()
 
-    logger.info("Launching on 0.0.0.0:7860...")
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860, log_level="info")
+    logger.info("Launching...")
+    app.launch(show_error=True, server_name="0.0.0.0", server_port=7860)
 
 
 if __name__ == "__main__":
-    main()
+    main()

code/config/__init__.py

@@ -1 +1,274 @@
-"""Configuration and constants."""
+"""Configuration system — hierarchical settings + constants.
+
+This module combines:
+- constants.py (app-wide constants, model registry, system prompt, languages)
+- settings (hierarchical Settings, MCP server config, policy rules, load_settings)
+
+Path layout:
+- WORKSPACE_ROOT: where the agent's sandboxed filesystem lives
+- CONFIG_DIR: where settings/agents/hooks/skills are stored (default: .sonicoder/)
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+# ── Re-export constants for backward compatibility ─────────────────────
+from code.config.constants import (
+    APP_TITLE,
+    DEFAULT_MAX_TOKENS,
+    DEFAULT_MODEL_KEY,
+    DEFAULT_TEMPERATURE,
+    EXAMPLE_PROMPTS,
+    LANGUAGE_MAP,
+    LANGUAGE_OPTIONS,
+    MODEL_CONFIGS,
+    MODEL_ID,
+    MODEL_URL,
+    SYSTEM_PROMPT,
+)
+
+# ── Path Constants ─────────────────────────────────────────────────────
+
+WORKSPACE_ROOT = Path(
+    os.environ.get(
+        "SONICODER_WORKSPACE",
+        os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "workspace")),
+    )
+)
+
+CONFIG_DIR = Path(
+    os.environ.get(
+        "SONICODER_CONFIG",
+        os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", ".sonicoder")),
+    )
+)
+
+
+# ── Runtime Defaults (override constants) ──────────────────────────────
+
+DEFAULT_MAX_ITERATIONS = 12
+AGENT_LOOP_TIMEOUT = 300  # seconds
+BASH_TIMEOUT = 120
+PYTHON_TIMEOUT = 30
+
+
+# ── Settings Dataclasses ───────────────────────────────────────────────
+
+
+@dataclass
+class ModelConfig:
+    """Configuration for a single model."""
+
+    name: str
+    model_id: str
+    model_type: str  # "text" | "vlm"
+    size_gb: float
+    description: str
+    dtype: str = "float16"
+    trust_remote_code: bool = True
+    device: str = "auto"
+
+
+@dataclass
+class MCPServerConfig:
+    """Configuration for an MCP server."""
+
+    name: str
+    transport: str  # "stdio" | "sse"
+    command: str | None = None
+    args: list[str] = field(default_factory=list)
+    env: dict[str, str] = field(default_factory=dict)
+    url: str | None = None
+    enabled: bool = True
+
+
+@dataclass
+class PolicyRule:
+    """A policy rule for tool approval."""
+
+    tool_name: str  # supports "*" wildcard
+    args_pattern: str | None = None
+    approval: str = "ask"  # "allow" | "ask" | "deny"
+    priority: int = 0
+    description: str = ""
+
+
+@dataclass
+class Settings:
+    """Hierarchical settings — cascades from global → project → local."""
+
+    # Model
+    default_model: str = DEFAULT_MODEL_KEY
+    temperature: float = DEFAULT_TEMPERATURE
+    max_tokens: int = DEFAULT_MAX_TOKENS
+
+    # Agent
+    max_iterations: int = DEFAULT_MAX_ITERATIONS
+    agent_timeout: int = AGENT_LOOP_TIMEOUT
+
+    # Tools
+    enabled_tools: list[str] = field(default_factory=lambda: ["*"])
+    disabled_tools: list[str] = field(default_factory=list)
+
+    # Safety
+    sandbox_enabled: bool = True
+    bash_timeout: int = BASH_TIMEOUT
+    python_timeout: int = PYTHON_TIMEOUT
+
+    # MCP
+    mcp_servers: list[MCPServerConfig] = field(default_factory=list)
+
+    # Policy
+    policy_rules: list[PolicyRule] = field(default_factory=list)
+
+    # Context
+    max_context_tokens: int = 32768
+    auto_compact: bool = True
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Settings:
+        """Create settings from a dictionary, ignoring unknown fields."""
+        known_fields = {f.name for f in cls.__dataclass_fields__.values()}
+        filtered = {k: v for k, v in data.items() if k in known_fields}
+        return cls(**filtered)
+
+    def merge(self, other: Settings) -> Settings:
+        """Merge another settings object (other takes precedence for non-default values)."""
+        result = Settings(
+            default_model=other.default_model or self.default_model,
+            temperature=(
+                other.temperature
+                if other.temperature != DEFAULT_TEMPERATURE
+                else self.temperature
+            ),
+            max_tokens=(
+                other.max_tokens
+                if other.max_tokens != DEFAULT_MAX_TOKENS
+                else self.max_tokens
+            ),
+            max_iterations=(
+                other.max_iterations
+                if other.max_iterations != DEFAULT_MAX_ITERATIONS
+                else self.max_iterations
+            ),
+            agent_timeout=(
+                other.agent_timeout
+                if other.agent_timeout != AGENT_LOOP_TIMEOUT
+                else self.agent_timeout
+            ),
+            sandbox_enabled=other.sandbox_enabled,
+            bash_timeout=other.bash_timeout,
+            python_timeout=other.python_timeout,
+            auto_compact=other.auto_compact,
+        )
+        # Merge lists
+        result.enabled_tools = (
+            other.enabled_tools if other.enabled_tools != ["*"] else self.enabled_tools
+        )
+        result.disabled_tools = list(set(self.disabled_tools + other.disabled_tools))
+        result.mcp_servers = self.mcp_servers + other.mcp_servers
+        result.policy_rules = other.policy_rules + self.policy_rules
+        return result
+
+
+# ── Public Helpers ─────────────────────────────────────────────────────
+
+
+def get_available_models() -> dict[str, dict[str, Any]]:
+    """Return all registered model configs (from constants.MODEL_CONFIGS)."""
+    return MODEL_CONFIGS.copy()
+
+
+def get_model_config(model_key: str) -> dict[str, Any] | None:
+    """Get a model config by key."""
+    return MODEL_CONFIGS.get(model_key)
+
+
+def load_settings(project_dir: Path | None = None) -> Settings:
+    """Load settings with hierarchical cascading.
+
+    Priority (highest → lowest):
+    1. Environment variables
+    2. .sonicoder/settings.local.json (local overrides, gitignored)
+    3. .sonicoder/settings.json (project settings)
+    4. Defaults
+    """
+    settings = Settings()
+
+    search_dirs = [Path.cwd()]
+    if project_dir:
+        search_dirs.insert(0, project_dir)
+
+    # Load project-level settings
+    for d in search_dirs:
+        local_path = d / CONFIG_DIR / "settings.local.json"
+        proj_path = d / CONFIG_DIR / "settings.json"
+
+        for path in [local_path, proj_path]:
+            if path.exists():
+                try:
+                    data = json.loads(path.read_text(encoding="utf-8"))
+                    # Parse MCP server configs
+                    if "mcp_servers" in data:
+                        data["mcp_servers"] = [
+                            MCPServerConfig(**s) for s in data["mcp_servers"]
+                        ]
+                    if "policy_rules" in data:
+                        data["policy_rules"] = [
+                            PolicyRule(**r) for r in data["policy_rules"]
+                        ]
+                    settings = settings.merge(Settings.from_dict(data))
+                except (json.JSONDecodeError, TypeError) as e:
+                    print(f"[config] Warning: Failed to parse {path}: {e}")
+
+    # Environment variable overrides
+    env_model = os.environ.get("SONICODER_MODEL")
+    if env_model and env_model in MODEL_CONFIGS:
+        settings.default_model = env_model
+
+    env_temp = os.environ.get("SONICODER_TEMPERATURE")
+    if env_temp:
+        try:
+            settings.temperature = float(env_temp)
+        except ValueError:
+            pass
+
+    return settings
+
+
+__all__ = [
+    # Constants
+    "APP_TITLE",
+    "DEFAULT_MAX_TOKENS",
+    "DEFAULT_MODEL_KEY",
+    "DEFAULT_TEMPERATURE",
+    "EXAMPLE_PROMPTS",
+    "LANGUAGE_MAP",
+    "LANGUAGE_OPTIONS",
+    "MODEL_CONFIGS",
+    "MODEL_ID",
+    "MODEL_URL",
+    "SYSTEM_PROMPT",
+    # Path constants
+    "WORKSPACE_ROOT",
+    "CONFIG_DIR",
+    # Runtime defaults
+    "DEFAULT_MAX_ITERATIONS",
+    "AGENT_LOOP_TIMEOUT",
+    "BASH_TIMEOUT",
+    "PYTHON_TIMEOUT",
+    # Dataclasses
+    "ModelConfig",
+    "MCPServerConfig",
+    "PolicyRule",
+    "Settings",
+    # Helpers
+    "get_available_models",
+    "get_model_config",
+    "load_settings",
+]

{sonicoder → code}/mcp/__init__.py

@@ -17,13 +17,14 @@ import logging
 import threading
 from typing import Any, Callable
 
-from ..config import MCPServerConfig
+from code.config import MCPServerConfig
 
 logger = logging.getLogger(__name__)
 
 
 # ── MCP Tool Bridge ────────────────────────────────────────────────────
 
+
 class MCPToolBridge:
     """Wraps an MCP tool as a ToolBuilder, making it indistinguishable from built-in tools.
 
@@ -31,7 +32,13 @@ class MCPToolBridge:
     interface so they get the same policy, confirmation, and scheduling treatment.
     """
 
-    def __init__(self, server_name: str, tool_name: str, tool_schema: dict, call_fn: Callable):
+    def __init__(
+        self,
+        server_name: str,
+        tool_name: str,
+        tool_schema: dict,
+        call_fn: Callable,
+    ):
         self.server_name = server_name
         self.tool_name = tool_name
         self._schema = tool_schema
@@ -47,7 +54,9 @@ class MCPToolBridge:
         return {
             "name": self.name,
             "description": self.description,
-            "parameters": self._schema.get("inputSchema", {"type": "object", "properties": {}}),
+            "parameters": self._schema.get(
+                "inputSchema", {"type": "object", "properties": {}}
+            ),
             "kind": self.kind,
             "mcp_server": self.server_name,
             "mcp_tool": self.tool_name,
@@ -60,6 +69,7 @@ class MCPToolBridge:
 
 # ── MCP Client Manager ─────────────────────────────────────────────────
 
+
 class MCPClientManager:
     """Manages multiple MCP server connections.
 
@@ -99,7 +109,7 @@ class MCPClientManager:
                     results[name] = error
                 except Exception as e:
                     results[name] = str(e)
-                    logger.error(f"MCP connect failed for {name}: {e}")
+                    logger.error("MCP connect failed for %s: %s", name, e)
         return results
 
     def disconnect_all(self) -> None:
@@ -115,7 +125,9 @@ class MCPClientManager:
         """Get a specific MCP tool by its full name (mcp_server_tool)."""
         return self._tools.get(name)
 
-    def call_tool(self, server_name: str, tool_name: str, arguments: dict[str, Any]) -> dict[str, Any]:
+    def call_tool(
+        self, server_name: str, tool_name: str, arguments: dict[str, Any]
+    ) -> dict[str, Any]:
         """Call an MCP tool on a specific server."""
         client = self._clients.get(server_name)
         if not client:
@@ -156,15 +168,17 @@ class MCPClientManager:
             if client and hasattr(client, "list_resources"):
                 try:
                     result = client.list_resources()
-                    for r in (result.resources if hasattr(result, "resources") else []):
-                        resources.append({
-                            "server": name,
-                            "uri": getattr(r, "uri", str(r)),
-                            "name": getattr(r, "name", ""),
-                            "description": getattr(r, "description", ""),
-                        })
+                    for r in result.resources if hasattr(result, "resources") else []:
+                        resources.append(
+                            {
+                                "server": name,
+                                "uri": getattr(r, "uri", str(r)),
+                                "name": getattr(r, "name", ""),
+                                "description": getattr(r, "description", ""),
+                            }
+                        )
                 except Exception as e:
-                    logger.warning(f"Failed to list resources from {name}: {e}")
+                    logger.warning("Failed to list resources from %s: %s", name, e)
         return resources
 
     def get_status(self) -> dict[str, Any]:
@@ -175,7 +189,9 @@ class MCPClientManager:
                 "enabled": config.enabled,
                 "connected": name in self._connected,
                 "transport": config.transport,
-                "tool_count": sum(1 for t in self._tools.values() if t.server_name == name),
+                "tool_count": sum(
+                    1 for t in self._tools.values() if t.server_name == name
+                ),
             }
         return status
 
@@ -189,8 +205,8 @@ class MCPClientManager:
         try:
             # Try to import MCP SDK
             try:
-                from mcp import ClientSession, StdioServerParameters
-                from mcp.client.stdio import stdio_client
+                from mcp import ClientSession, StdioServerParameters  # noqa: F401
+                from mcp.client.stdio import stdio_client  # noqa: F401
             except ImportError:
                 logger.info("MCP SDK not installed. Skipping MCP server %s", name)
                 return "mcp SDK not installed (pip install mcp)"
@@ -212,7 +228,11 @@ class MCPClientManager:
 
                 # Discover tools
                 self._discover_tools(name, client_session)
-                logger.info(f"MCP server '{name}' connected with {sum(1 for t in self._tools.values() if t.server_name == name)} tools")
+                logger.info(
+                    "MCP server '%s' connected with %d tools",
+                    name,
+                    sum(1 for t in self._tools.values() if t.server_name == name),
+                )
                 return None
 
             elif config.transport == "sse":
@@ -221,12 +241,12 @@ class MCPClientManager:
             return f"Unknown transport: {config.transport}"
 
         except Exception as e:
-            logger.error(f"MCP connect error for {name}: {e}")
+            logger.error("MCP connect error for %s: %s", name, e)
             return str(e)
 
     def _run_async_connect(self, name: str, server_params):
         """Run async MCP connection in a sync context."""
-        from mcp import ClientSession, StdioServerParameters
+        from mcp import ClientSession
         from mcp.client.stdio import stdio_client
 
         result = {"session": None, "error": None}
@@ -243,7 +263,9 @@ class MCPClientManager:
                 result["error"] = str(e)
 
         loop = asyncio.new_event_loop()
-        thread = threading.Thread(target=loop.run_until_complete, args=(_connect_async(),), daemon=True)
+        thread = threading.Thread(
+            target=loop.run_until_complete, args=(_connect_async(),), daemon=True
+        )
         thread.start()
         thread.join(timeout=10)
 
@@ -269,7 +291,9 @@ class MCPClientManager:
             for tool in tools:
                 schema = {
                     "description": getattr(tool, "description", ""),
-                    "inputSchema": getattr(tool, "inputSchema", {"type": "object", "properties": {}}),
+                    "inputSchema": getattr(
+                        tool, "inputSchema", {"type": "object", "properties": {}}
+                    ),
                     "annotations": getattr(tool, "annotations", {}),
                 }
                 tool_name = getattr(tool, "name", "unknown")
@@ -278,13 +302,14 @@ class MCPClientManager:
                     server_name=server_name,
                     tool_name=tool_name,
                     tool_schema=schema,
-                    call_fn=lambda sn=server_name, tn=tool_name, args=None: self.call_tool(sn, tn, args or {}),
+                    call_fn=lambda sn=server_name, tn=tool_name, args=None:
+                        self.call_tool(sn, tn, args or {}),
                 )
                 self._tools[bridge.name] = bridge
-                logger.debug(f"Discovered MCP tool: {bridge.name}")
+                logger.debug("Discovered MCP tool: %s", bridge.name)
 
         except Exception as e:
-            logger.warning(f"Failed to discover tools from {server_name}: {e}")
+            logger.warning("Failed to discover tools from %s: %s", server_name, e)
 
     def _disconnect(self, name: str) -> None:
         """Disconnect from an MCP server."""
@@ -306,12 +331,14 @@ class _AsyncSessionWrapper:
     def __getattr__(self, name):
         attr = getattr(self._session, name)
         if asyncio.iscoroutinefunction(attr):
+
             def sync_wrapper(*args, **kwargs):
                 try:
                     loop = asyncio.get_event_loop()
                     if loop.is_running():
                         # Can't await in running loop, return a placeholder
                         import concurrent.futures
+
                         with concurrent.futures.ThreadPoolExecutor() as pool:
                             future = pool.submit(asyncio.run, attr(*args, **kwargs))
                             return future.result(timeout=30)
@@ -319,6 +346,7 @@ class _AsyncSessionWrapper:
                         return loop.run_until_complete(attr(*args, **kwargs))
                 except RuntimeError:
                     return asyncio.run(attr(*args, **kwargs))
+
             return sync_wrapper
         return attr
 
@@ -333,4 +361,7 @@ def get_mcp_manager() -> MCPClientManager:
     global _global_manager
     if _global_manager is None:
         _global_manager = MCPClientManager()
-    return _global_manager
+    return _global_manager
+
+
+__all__ = ["MCPToolBridge", "MCPClientManager", "get_mcp_manager"]

code/model/loader.py

@@ -170,7 +170,7 @@ def start_background_load(model_key: str | None = None) -> threading.Thread:
 
 def switch_model(model_key: str) -> dict[str, Any]:
     """Switch to a different model. Returns status immediately, loads in background."""
-    global _current_model_key
+    global _current_model_key, _model_loaded
 
     if model_key not in MODEL_CONFIGS:
         return {"success": False, "message": f"Unknown model: {model_key}"}

{sonicoder → code}/policy/__init__.py

@@ -6,7 +6,6 @@ and pattern matching. Also incorporates Claude Code's allow/ask/deny model.
 
 from __future__ import annotations
 
-import fnmatch
 import re
 from dataclasses import dataclass
 from enum import Enum
@@ -22,6 +21,7 @@ class ApprovalDecision(Enum):
 @dataclass
 class PolicyCheckResult:
     """Result of a policy check."""
+
     decision: ApprovalDecision
     reason: str = ""
     matched_rule: str | None = None
@@ -79,6 +79,13 @@ class PolicyEngine:
             "priority": -100,
             "description": "Allow file edits in sandboxed workspace",
         },
+        {
+            "tool_name": "multi_edit",
+            "args_pattern": None,
+            "approval": "allow",
+            "priority": -100,
+            "description": "Allow multi-file edits in sandboxed workspace",
+        },
         {
             "tool_name": "read_file",
             "args_pattern": None,
@@ -122,11 +129,25 @@ class PolicyEngine:
             "description": "Allow web fetch",
         },
         {
-            "tool_name": "todo",
+            "tool_name": "todo_read",
+            "args_pattern": None,
+            "approval": "allow",
+            "priority": -200,
+            "description": "Allow todo reads",
+        },
+        {
+            "tool_name": "todo_write",
             "args_pattern": None,
             "approval": "allow",
             "priority": -200,
-            "description": "Allow todo management",
+            "description": "Allow todo writes",
+        },
+        {
+            "tool_name": "todo_update",
+            "args_pattern": None,
+            "approval": "allow",
+            "priority": -200,
+            "description": "Allow todo updates",
         },
         {
             "tool_name": "snapshot_workspace",
@@ -172,7 +193,9 @@ class PolicyEngine:
         for r in rules:
             self.add_rule(r)
 
-    def check(self, tool_name: str, args: dict[str, Any] | None = None) -> PolicyCheckResult:
+    def check(
+        self, tool_name: str, args: dict[str, Any] | None = None
+    ) -> PolicyCheckResult:
         """Check if a tool call is allowed.
 
         Returns the decision and reason from the highest-priority matching rule.
@@ -201,12 +224,17 @@ class PolicyEngine:
                     approval = "ask"
 
             # Auto-edit mode: auto-approve file writes/edits
-            if self._approval_mode == "auto_edit" and tool_name in ("write_file", "edit_file"):
+            if (
+                self._approval_mode == "auto_edit"
+                and tool_name in ("write_file", "edit_file", "multi_edit")
+            ):
                 approval = "allow"
 
             return PolicyCheckResult(
                 decision=ApprovalDecision(approval),
-                reason=rule.get("description", f"Rule matched: {rule['tool_name']}"),
+                reason=rule.get(
+                    "description", f"Rule matched: {rule['tool_name']}"
+                ),
                 matched_rule=rule.get("description"),
             )
 
@@ -242,4 +270,12 @@ def get_policy_engine() -> PolicyEngine:
     global _global_engine
     if _global_engine is None:
         _global_engine = PolicyEngine()
-    return _global_engine
+    return _global_engine
+
+
+__all__ = [
+    "ApprovalDecision",
+    "PolicyCheckResult",
+    "PolicyEngine",
+    "get_policy_engine",
+]

code/server/__init__.py

@@ -1 +1,31 @@
-"""FastAPI / Gradio server routes."""
+"""FastAPI / Gradio Server entry point.
+
+Provides `create_app()` which returns the configured `gradio.Server` instance
+with all HTTP routes and Gradio API endpoints registered.
+
+The actual routes are defined in `code/server/routes.py`.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def create_app() -> Any:
+    """Create and return the configured Gradio Server app instance.
+
+    This is a thin wrapper around `code.server.routes.get_app()` that
+    triggers all the route decorators when the routes module is first
+    imported.
+    """
+    from code.server.routes import get_app  # noqa: F401  (import has side effects)
+
+    return get_app()
+
+
+def get_app() -> Any:
+    """Backward-compatible alias for create_app()."""
+    return create_app()
+
+
+__all__ = ["create_app", "get_app"]

code/server/routes.py

@@ -33,11 +33,13 @@ import json
 import logging
 import os
 import tempfile
+import uuid
 from pathlib import Path
 from typing import Any, Optional
 
 import gradio as gr
-from fastapi.responses import HTMLResponse, FileResponse
+from fastapi import Request
+from fastapi.responses import HTMLResponse, FileResponse, JSONResponse, StreamingResponse
 try:
     from gradio import Server
 except ImportError:
@@ -717,6 +719,416 @@ def get_app() -> Server:
     return app
 
 
+# ─── V2 REST Endpoints (used by root index.html) ──────────────────────
+# These are plain FastAPI routes that the v2 frontend (index.html at project
+# root) calls with `fetch()`. They live alongside the @app.api Gradio
+# endpoints above; the two API styles don't conflict because they use
+# different URL patterns (/api/<name> for Gradio, /api/<name> for REST
+# with different methods / payloads).
+
+
+def _json_response(data: Any) -> JSONResponse:
+    """JSONResponse that handles non-serializable objects via str() fallback."""
+    return JSONResponse(content=json.loads(json.dumps(data, default=str)))
+
+
+# ─── Session state for v2 streaming chat ──────────────────────────────
+
+_v2_sessions: dict[str, dict[str, Any]] = {}
+
+
+def _v2_get_or_create_session(session_id: str = "") -> tuple[str, dict[str, Any]]:
+    """Get or create a per-session state dict (chat history + agent context)."""
+    if not session_id:
+        session_id = str(uuid.uuid4())[:12]
+    if session_id not in _v2_sessions:
+        _v2_sessions[session_id] = {
+            "history": [],
+            "active_agent": None,
+        }
+    return session_id, _v2_sessions[session_id]
+
+
+@app.get("/api/get_config")
+async def v2_get_config():
+    """Return runtime config: models, default model, workspace, version."""
+    models = []
+    for key, cfg in MODEL_CONFIGS.items():
+        models.append({
+            "key": key,
+            "name": cfg["name"],
+            "model_type": cfg["type"],
+            "size_gb": cfg.get("size_gb", 0),
+            "description": cfg.get("description", ""),
+        })
+
+    # Best-effort load of skills / commands / hooks / agents
+    skills_list: list[Any] = []
+    commands_list: list[Any] = []
+    hooks_list: list[Any] = []
+    agents_list: list[Any] = []
+    active_agent: Any = None
+
+    try:
+        from code.skills import list_skills
+        skills_list = list_skills()
+    except Exception as exc:
+        logger.debug("list_skills failed: %s", exc)
+
+    try:
+        from code.commands import list_commands
+        commands_list = list_commands()
+    except Exception as exc:
+        logger.debug("list_commands failed: %s", exc)
+
+    try:
+        from code.hooks import list_hooks
+        hooks_list = list_hooks()
+    except Exception as exc:
+        logger.debug("list_hooks failed: %s", exc)
+
+    try:
+        from code.agents import list_agents, get_active_agent
+        agents_list = list_agents()
+        active_agent = get_active_agent()
+    except Exception as exc:
+        logger.debug("list_agents failed: %s", exc)
+
+    return JSONResponse(content={
+        "app_title": APP_TITLE,
+        "models": models,
+        "model_configs": {
+            k: {
+                "name": v["name"],
+                "type": v["type"],
+                "description": v.get("description", ""),
+            }
+            for k, v in MODEL_CONFIGS.items()
+        },
+        "default_model": DEFAULT_MODEL_KEY,
+        "model_url": MODEL_URL,
+        "languages": LANGUAGE_OPTIONS,
+        "examples": [
+            {"label": label, "prompt": prompt, "language": lang, "framework": fw}
+            for label, prompt, lang, fw in EXAMPLE_PROMPTS
+        ],
+        "skills": skills_list,
+        "commands": commands_list,
+        "hooks": hooks_list,
+        "agents": agents_list,
+        "active_agent": active_agent,
+        "workspace": str(_get_workspace_root()),
+        "version": "2.0.0",
+    })
+
+
+def _get_workspace_root() -> Path:
+    """Return the workspace root path (created on demand)."""
+    try:
+        from code.tools.fs import get_workspace_root
+        return Path(get_workspace_root())
+    except Exception:
+        from code.config import WORKSPACE_ROOT
+        WORKSPACE_ROOT.mkdir(parents=True, exist_ok=True)
+        return WORKSPACE_ROOT
+
+
+@app.get("/api/model_status")
+async def v2_model_status():
+    """Return current model loading status (v2 underscore-style)."""
+    return JSONResponse(content=get_model_status())
+
+
+@app.get("/api/list_models")
+async def v2_list_models():
+    """List all available models with the `current` flag set."""
+    current = get_current_model_key()
+    result = []
+    for key, cfg in MODEL_CONFIGS.items():
+        result.append({
+            "key": key,
+            "name": cfg["name"],
+            "model_type": cfg["type"],
+            "size_gb": cfg.get("size_gb", 0),
+            "description": cfg.get("description", ""),
+            "current": key == current,
+        })
+    return JSONResponse(content=result)
+
+
+@app.post("/api/switch_model")
+async def v2_switch_model(request: Request):
+    """Switch to a different model. Accepts JSON: {model_key: str}."""
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+    model_key = body.get("model_key", "")
+    result = switch_model(model_key)
+    return JSONResponse(content={
+        "status": "switching" if result.get("success") else "error",
+        "model": model_key,
+        "message": result.get("message", ""),
+    })
+
+
+@app.get("/api/workspace_tree")
+async def v2_workspace_tree(max_depth: int = 4):
+    """Return the workspace file tree as a string."""
+    from code.tools.fs import list_workspace_tree
+    try:
+        result = list_workspace_tree(max_depth=max_depth)
+        return _json_response(result)
+    except Exception as exc:
+        logger.exception("workspace_tree failed")
+        return JSONResponse(content={"tree": f"(error: {exc})", "root": str(_get_workspace_root())})
+
+
+@app.post("/api/workspace_read")
+async def v2_workspace_read(request: Request):
+    """Read a file from the workspace."""
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+    path = body.get("path", "")
+    offset = int(body.get("offset", 1) or 1)
+    limit = int(body.get("limit", 500) or 500)
+    from code.tools.fs import read_file
+    result = read_file(path=path, offset=offset, limit=limit)
+    return _json_response(result)
+
+
+@app.post("/api/workspace_write")
+async def v2_workspace_write(request: Request):
+    """Write a file in the workspace."""
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+    path = body.get("path", "")
+    content = body.get("content", "")
+    from code.tools.fs import write_file
+    result = write_file(path=path, content=content)
+    return _json_response(result)
+
+
+@app.post("/api/workspace_bash")
+async def v2_workspace_bash(request: Request):
+    """Run a bash command in the workspace."""
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+    command = body.get("command", "")
+    timeout = int(body.get("timeout", 30) or 30)
+    from code.tools.bash import run_bash
+    result = run_bash(command=command, timeout=timeout)
+    return _json_response(result)
+
+
+@app.get("/api/mcp_status")
+async def v2_mcp_status():
+    """Return MCP server connection status."""
+    try:
+        from code.mcp import get_mcp_manager
+        return JSONResponse(content=get_mcp_manager().get_status())
+    except Exception as exc:
+        logger.debug("mcp_status failed: %s", exc)
+        return JSONResponse(content={})
+
+
+@app.get("/api/policy_status")
+async def v2_policy_status():
+    """Return policy engine mode and rules."""
+    try:
+        from code.policy import get_policy_engine
+        engine = get_policy_engine()
+        return JSONResponse(content={
+            "mode": engine.approval_mode,
+            "rules": engine.get_rules(),
+        })
+    except Exception as exc:
+        logger.debug("policy_status failed: %s", exc)
+        return JSONResponse(content={"mode": "default", "rules": []})
+
+
+@app.post("/api/reset_session")
+async def v2_reset_session(request: Request):
+    """Clear a chat session's history."""
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+    session_id = body.get("session_id", "")
+    if session_id in _v2_sessions:
+        _v2_sessions[session_id]["history"] = []
+        _v2_sessions[session_id]["active_agent"] = None
+    return JSONResponse(content={"success": True})
+
+
+@app.post("/api/list_skills")
+async def v2_list_skills():
+    """List all available skills."""
+    try:
+        from code.skills import list_skills
+        return JSONResponse(content={"success": True, "skills": list_skills()})
+    except Exception as exc:
+        return JSONResponse(content={"success": False, "skills": [], "error": str(exc)})
+
+
+@app.post("/api/list_commands")
+async def v2_list_commands():
+    """List all available slash commands."""
+    try:
+        from code.commands import list_commands
+        return JSONResponse(content={"success": True, "commands": list_commands()})
+    except Exception as exc:
+        return JSONResponse(content={"success": False, "commands": [], "error": str(exc)})
+
+
+@app.post("/api/list_hooks")
+async def v2_list_hooks():
+    """List all configured hooks."""
+    try:
+        from code.hooks import list_hooks
+        return JSONResponse(content={"success": True, "hooks": list_hooks()})
+    except Exception as exc:
+        return JSONResponse(content={"success": False, "hooks": [], "error": str(exc)})
+
+
+@app.post("/api/list_agents")
+async def v2_list_agents():
+    """List all available agents (builtins + user) and the active one."""
+    try:
+        from code.agents import list_agents, get_active_agent
+        return _json_response({
+            "success": True,
+            "agents": list_agents(),
+            "active_agent": get_active_agent(),
+        })
+    except Exception as exc:
+        return JSONResponse(content={"success": False, "agents": [], "error": str(exc)})
+
+
+@app.post("/api/set_active_agent")
+async def v2_set_active_agent(request: Request):
+    """Set or clear the active agent for subsequent prompts."""
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+    name = body.get("name", "")
+    try:
+        from code.agents import set_active_agent
+        result = set_active_agent(name or None)
+        return _json_response(result)
+    except Exception as exc:
+        return JSONResponse(content={"success": False, "error": str(exc)})
+
+
+@app.post("/api/todo_read")
+async def v2_todo_read(request: Request):
+    """Read the current todo list."""
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+    session_id = body.get("session_id", "default")
+    from code.tools.todos import todo_read
+    return _json_response(todo_read(session_id=session_id))
+
+
+@app.post("/api/todo_write")
+async def v2_todo_write(request: Request):
+    """Replace the todo list."""
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+    session_id = body.get("session_id", "default")
+    todos = body.get("todos", [])
+    from code.tools.todos import todo_write
+    return _json_response(todo_write(todos=todos, session_id=session_id))
+
+
+@app.post("/chat")
+async def v2_chat_stream(request: Request):
+    """Streaming chat — returns newline-delimited JSON via StreamingResponse.
+
+    Request body: {message, session_id, image_url?, target_language?, target_framework?, search_enabled?, agent_name?}
+
+    This wraps the `run_agent` generator and yields each event as a JSON line.
+    """
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+
+    message = (body.get("message") or "").strip()
+    session_id = body.get("session_id", "")
+    image_url = body.get("image_url", "") or ""
+    target_language = body.get("target_language", "") or ""
+    target_framework = body.get("target_framework", "") or ""
+    search_enabled = str(body.get("search_enabled", "false") or "false").lower() == "true"
+    agent_name = body.get("agent_name", "") or ""
+
+    if not message:
+        return StreamingResponse(
+            iter([json.dumps({"type": "error", "error": "Empty message"}) + "\n"]),
+            media_type="text/event-stream",
+            headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+        )
+
+    sid, session = _v2_get_or_create_session(session_id)
+    history = session.get("history", [])
+
+    # Run web search if enabled
+    search_context = ""
+    if search_enabled:
+        try:
+            results = web_search_google(message, num_results=6)
+            if results:
+                search_context = format_search_results(results)
+        except Exception as exc:
+            logger.warning("Web search failed: %s", exc)
+
+    from code.agent import run_agent
+
+    def event_generator():
+        try:
+            for event in run_agent(
+                user_input=message,
+                history=history,
+                target_language=target_language,
+                target_framework=target_framework,
+                search_context=search_context,
+                image_url=image_url.strip() or None,
+                agent_name=agent_name.strip() or None,
+            ):
+                # Persist final response into session history
+                if event.get("type") == "complete":
+                    content = event.get("content", "")
+                    session["history"] = history + [
+                        {"role": "user", "content": message},
+                        {"role": "assistant", "content": content},
+                    ]
+                yield json.dumps(event, ensure_ascii=False, default=str) + "\n"
+        except Exception as exc:
+            logger.error("Chat stream error: %s", exc, exc_info=True)
+            yield json.dumps({"type": "error", "error": str(exc)}) + "\n"
+
+    return StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "X-Accel-Buffering": "no",
+            "Connection": "keep-alive",
+        },
+    )
+
+
 # ─── Agent / Skills / Commands / Hooks / Workspace Endpoints ──────────
 
 

index.html

@@ -145,6 +145,26 @@ a:hover{text-decoration:underline;text-shadow:var(--glow-cyan)}
 .example-chip{background:rgba(30,42,58,.4);border:1px solid var(--border);border-radius:12px;padding:3px 10px;font-family:var(--font-mono);font-size:11px;color:var(--gray-mid);cursor:pointer;transition:all var(--transition);white-space:nowrap}
 .example-chip:hover{border-color:var(--purple);color:var(--purple);background:rgba(168,85,247,.05);text-shadow:var(--glow-purple)}
 
+/* ═══ OPTIONS ROW ═══ */
+#options-row{display:flex;align-items:center;gap:6px;margin-top:6px;flex-wrap:wrap}
+.opt-group{display:inline-flex;align-items:center;gap:4px;background:rgba(30,42,58,.3);border:1px solid var(--border);border-radius:var(--radius);padding:2px 4px 2px 6px;transition:border-color var(--transition)}
+.opt-group:hover{border-color:var(--border-focus)}
+.opt-group label{font-size:9px;color:var(--gray-dim);letter-spacing:1px;text-transform:uppercase;flex-shrink:0}
+.opt-group select{background:transparent;border:none;color:var(--cyan);font-family:var(--font-mono);font-size:11px;padding:3px 4px;outline:none;cursor:pointer;max-width:120px}
+.opt-group select option{background:var(--bg-deep);color:var(--gray-light)}
+.opt-toggle{display:inline-flex;align-items:center;gap:5px;background:rgba(30,42,58,.3);border:1px solid var(--border);border-radius:var(--radius);padding:3px 8px;font-size:10px;color:var(--gray-mid);cursor:pointer;transition:all var(--transition);user-select:none;letter-spacing:.5px}
+.opt-toggle:hover{border-color:var(--border-focus);color:var(--gray-light)}
+.opt-toggle input{display:none}
+.opt-toggle .toggle-dot{width:8px;height:8px;border-radius:50%;background:var(--gray-dim);transition:all var(--transition)}
+.opt-toggle.active{color:var(--amber);border-color:rgba(255,179,0,.4);background:rgba(255,179,0,.08);text-shadow:var(--glow-amber)}
+.opt-toggle.active .toggle-dot{background:var(--amber);box-shadow:0 0 6px var(--amber)}
+.opt-icon-btn{display:inline-flex;align-items:center;justify-content:center;width:24px;height:24px;background:rgba(30,42,58,.3);border:1px solid var(--border);border-radius:var(--radius);color:var(--gray-mid);cursor:pointer;transition:all var(--transition);font-size:13px;flex-shrink:0}
+.opt-icon-btn:hover{border-color:var(--cyan);color:var(--cyan);text-shadow:var(--glow-cyan)}
+.opt-icon-btn input{display:none}
+.img-preview{display:inline-flex;align-items:center;gap:4px;background:rgba(0,212,255,.08);border:1px solid rgba(0,212,255,.3);border-radius:var(--radius);padding:2px 6px;font-size:10px;color:var(--cyan);cursor:pointer}
+.img-preview img{width:18px;height:18px;border-radius:2px;object-fit:cover}
+.img-preview .remove{cursor:pointer;color:var(--red);margin-left:2px}
+
 /* ═══ OUTPUT PANEL ═══ */
 #output-panel{display:flex;flex-direction:column;width:45%;min-width:340px;max-width:55%;min-height:0;background:var(--bg-panel)}
 #output-tabs{display:flex;border-bottom:1px solid var(--border);background:rgba(13,17,23,.6);flex-shrink:0}
@@ -195,46 +215,17 @@ a:hover{text-decoration:underline;text-shadow:var(--glow-cyan)}
 #file-viewer pre{margin:0;font-size:11px;line-height:1.5;color:var(--code-text)}
 .file-line-num{color:var(--gray-dim);display:inline-block;width:50px;text-align:right;margin-right:12px;user-select:none;border-right:1px solid var(--border);padding-right:8px}
 
-/* ═══ MCP TAB — Rich Catalog UI ═══ */
-#pane-mcp{overflow-y:auto;flex:1}
-.mcp-tab-bar{display:flex;border-bottom:1px solid var(--border);background:rgba(13,17,23,.6);flex-shrink:0;padding:0 8px;gap:2px;overflow-x:auto}
-.mcp-cat-tab{background:transparent;border:none;border-bottom:2px solid transparent;color:var(--gray-dim);font-family:var(--font-mono);font-size:10px;padding:8px 10px;cursor:pointer;transition:all var(--transition);letter-spacing:.5px;text-transform:uppercase;white-space:nowrap}
-.mcp-cat-tab:hover{color:var(--gray-mid)}
-.mcp-cat-tab.active{color:var(--purple);border-bottom-color:var(--purple);text-shadow:var(--glow-purple)}
-.mcp-catalog{padding:10px;display:flex;flex-direction:column;gap:8px}
-.mcp-card{border:1px solid var(--border);border-radius:var(--radius);background:var(--bg-deep);overflow:hidden;transition:border-color var(--transition)}
-.mcp-card:hover{border-color:var(--border-focus)}
-.mcp-card-head{display:flex;align-items:center;gap:10px;padding:10px 12px;cursor:default}
-.mcp-card-icon{font-size:18px;flex-shrink:0;width:24px;text-align:center}
-.mcp-card-info{flex:1;min-width:0}
-.mcp-card-name{font-weight:600;color:var(--gray-light);font-size:12px;margin-bottom:2px}
-.mcp-card-desc{color:var(--gray-dim);font-size:11px;line-height:1.4;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
-.mcp-card-actions{display:flex;align-items:center;gap:6px;flex-shrink:0}
-.mcp-card-status{width:7px;height:7px;border-radius:50%;flex-shrink:0}
-.mcp-card-status.on{background:var(--success);box-shadow:0 0 6px var(--success)}
-.mcp-card-status.off{background:var(--gray-dim)}
-.mcp-toggle{position:relative;width:34px;height:18px;flex-shrink:0}
-.mcp-toggle input{opacity:0;width:0;height:0;position:absolute}
-.mcp-toggle-slider{position:absolute;inset:0;background:var(--border);border-radius:9px;cursor:pointer;transition:background var(--transition)}
-.mcp-toggle-slider::before{content:'';position:absolute;left:2px;top:2px;width:14px;height:14px;background:var(--gray-dim);border-radius:50%;transition:all var(--transition)}
-.mcp-toggle input:checked+.mcp-toggle-slider{background:rgba(57,255,20,.3);border:1px solid var(--green-dim)}
-.mcp-toggle input:checked+.mcp-toggle-slider::before{transform:translateX(16px);background:var(--green);box-shadow:0 0 6px var(--green)}
-.mcp-card-details{display:none;padding:0 12px 10px;border-top:1px solid var(--border);margin-top:0;padding-top:8px}
-.mcp-card.open .mcp-card-details{display:block}
-.mcp-detail-row{display:flex;align-items:flex-start;gap:8px;margin-bottom:4px;font-size:11px}
-.mcp-detail-label{color:var(--gray-dim);flex-shrink:0;min-width:60px}
-.mcp-detail-value{color:var(--gray-mid);word-break:break-all}
-.mcp-card-tools{display:flex;flex-wrap:wrap;gap:4px;margin-top:6px}
-.mcp-tool-chip{padding:2px 8px;background:rgba(0,212,255,.08);border:1px solid rgba(0,212,255,.2);border-radius:10px;font-size:10px;color:var(--cyan)}
-.mcp-card-error{color:var(--red);font-size:11px;margin-top:4px}
-.mcp-card-expand{background:transparent;border:none;color:var(--gray-dim);font-family:var(--font-mono);font-size:10px;cursor:pointer;padding:2px 6px;border-radius:3px;transition:color var(--transition)}
-.mcp-card-expand:hover{color:var(--cyan)}
-.mcp-connecting{color:var(--amber);font-size:10px;animation:pulse 1s ease infinite}
-.mcp-stats-bar{display:flex;align-items:center;gap:12px;padding:8px 12px;border-bottom:1px solid var(--border);background:rgba(30,42,58,.3);font-size:11px;flex-shrink:0}
-.mcp-stat{color:var(--gray-dim)}
-.mcp-stat strong{color:var(--gray-light);font-weight:600}
-.mcp-stat .green{color:var(--green)}
-.mcp-stat .red{color:var(--red)}
+/* MCP */
+#pane-mcp{padding:16px;gap:12px;overflow-y:auto}
+.mcp-server{border:1px solid var(--border);border-radius:var(--radius);overflow:hidden;margin-bottom:8px}
+.mcp-server-header{display:flex;align-items:center;gap:8px;padding:8px 12px;background:rgba(30,42,58,.5);border-bottom:1px solid var(--border);font-size:12px}
+.mcp-server-dot{width:8px;height:8px;border-radius:50%;flex-shrink:0}
+.mcp-server-dot.connected{background:var(--success);box-shadow:0 0 6px var(--success)}
+.mcp-server-dot.disconnected{background:var(--red);box-shadow:0 0 6px var(--red)}
+.mcp-server-name{font-weight:600;color:var(--gray-light);flex:1}
+.mcp-tools{padding:8px 12px;display:flex;flex-wrap:wrap;gap:4px}
+.mcp-tool-tag{padding:2px 8px;background:rgba(0,212,255,.08);border:1px solid rgba(0,212,255,.2);border-radius:10px;font-size:10px;color:var(--cyan)}
+.mcp-empty{color:var(--gray-dim);font-size:12px;text-align:center;padding:40px 20px}
 
 /* ═══ STATUS BAR ═══ */
 #status-bar{display:flex;align-items:center;gap:8px;padding:5px 16px;border-top:1px solid var(--border);background:var(--bg-panel);font-size:11px;flex-shrink:0}
@@ -290,7 +281,7 @@ a:hover{text-decoration:underline;text-shadow:var(--glow-cyan)}
         <span id="model-pill-text">Loading...</span>
       </div>
       <select id="model-select" title="Switch AI model"></select>
-      <div class="pill mcp-pill" id="mcp-pill" onclick="switchTab('mcp')" style="cursor:pointer" title="Open MCP panel">
+      <div class="pill mcp-pill" id="mcp-pill">
         <span class="dot disconnected" id="mcp-dot"></span>
         <span id="mcp-pill-text">MCP</span>
       </div>
@@ -299,7 +290,7 @@ a:hover{text-decoration:underline;text-shadow:var(--glow-cyan)}
   </header>
 
   <div id="banner">
-    Powered by <a id="banner-model-link" href="https://huggingface.co/Qwen/Qwen2.5-Coder-1.5B-Instruct" target="_blank" rel="noopener"><strong id="banner-model-name">Qwen2.5-Coder-1.5B</strong></a> running locally &mdash; no external APIs. Supports MCP tools, multiple 1B models, and agentic code generation with Gemini CLI patterns.
+    Powered by <a id="banner-model-link" href="https://huggingface.co/openbmb/MiniCPM5-1B" target="_blank" rel="noopener"><strong id="banner-model-name">MiniCPM5-1B</strong></a> running locally &mdash; no external APIs. Supports MCP tools, multiple 1B models, and agentic code generation with Gemini CLI patterns.
   </div>
 
   <div id="main">
@@ -313,6 +304,42 @@ a:hover{text-decoration:underline;text-shadow:var(--glow-cyan)}
           <button id="btn-send" onclick="handleSend()" title="Send message">&#10148;</button>
           <button id="btn-stop" onclick="stopGeneration()" title="Stop generation">&#9632; STOP</button>
         </div>
+        <div id="options-row">
+          <div class="opt-group">
+            <label>Lang</label>
+            <select id="opt-language" onchange="updateFrameworkOptions()" title="Target language">
+              <option value="">Auto</option>
+            </select>
+          </div>
+          <div class="opt-group">
+            <label>FW</label>
+            <select id="opt-framework" title="Target framework">
+              <option value="">Auto</option>
+            </select>
+          </div>
+          <div class="opt-group">
+            <label>Skill</label>
+            <select id="opt-skill" title="Apply a skill (use /skill command for multiple)">
+              <option value="">None</option>
+            </select>
+          </div>
+          <div class="opt-group">
+            <label>Agent</label>
+            <select id="opt-agent" title="Activate a custom agent persona" onchange="setActiveAgent(this.value)">
+              <option value="">Default</option>
+            </select>
+          </div>
+          <label class="opt-toggle" id="opt-search-toggle" title="Search the web before generating">
+            <input type="checkbox" id="opt-search">
+            <span class="toggle-dot"></span>
+            <span>Web</span>
+          </label>
+          <label class="opt-icon-btn" title="Attach image (for VLM models)">
+            <input type="file" id="opt-image-input" accept="image/*" onchange="handleImageSelect(event)">
+            <span>&#128247;</span>
+          </label>
+          <span id="image-preview-container"></span>
+        </div>
         <div id="examples-row"></div>
       </div>
     </div>
@@ -367,25 +394,7 @@ a:hover{text-decoration:underline;text-shadow:var(--glow-cyan)}
           <div id="file-viewer"><pre id="file-content"></pre></div>
         </div>
         <div class="tab-pane" id="pane-mcp">
-          <div class="mcp-stats-bar" id="mcp-stats-bar">
-            <span class="mcp-stat">Servers: <strong id="mcp-total-count">0</strong></span>
-            <span class="mcp-stat">Connected: <strong class="green" id="mcp-connected-count">0</strong></span>
-            <span class="mcp-stat">Tools: <strong id="mcp-tools-count">0</strong></span>
-          </div>
-          <div class="mcp-tab-bar" id="mcp-tab-bar">
-            <button class="mcp-cat-tab active" data-cat="all" onclick="filterMcpCat('all')">All</button>
-            <button class="mcp-cat-tab" data-cat="core" onclick="filterMcpCat('core')">Core</button>
-            <button class="mcp-cat-tab" data-cat="reasoning" onclick="filterMcpCat('reasoning')">Reasoning</button>
-            <button class="mcp-cat-tab" data-cat="dev-tools" onclick="filterMcpCat('dev-tools')">Dev Tools</button>
-            <button class="mcp-cat-tab" data-cat="database" onclick="filterMcpCat('database')">Database</button>
-            <button class="mcp-cat-tab" data-cat="search" onclick="filterMcpCat('search')">Search</button>
-            <button class="mcp-cat-tab" data-cat="browser" onclick="filterMcpCat('browser')">Browser</button>
-            <button class="mcp-cat-tab" data-cat="integrations" onclick="filterMcpCat('integrations')">Integrations</button>
-            <button class="mcp-cat-tab" data-cat="utilities" onclick="filterMcpCat('utilities')">Utilities</button>
-          </div>
-          <div class="mcp-catalog" id="mcp-catalog">
-            <div class="mcp-empty" style="color:var(--gray-dim);font-size:12px;text-align:center;padding:40px 20px">Loading MCP catalog...</div>
-          </div>
+          <div id="mcp-content"><div class="mcp-empty">Loading MCP status...</div></div>
         </div>
       </div>
     </div>
@@ -414,7 +423,6 @@ var state = {
   isGenerating: false,
   modelReady: false,
   activeTab: 'preview',
-  activeMcpCat: 'all',
   toolCalls: {},
   currentStreamDiv: null,
   lastCode: '',
@@ -422,7 +430,8 @@ var state = {
   consoleStdout: '',
   consoleStderr: '',
   generatedFiles: [],
-  mcpServers: [],
+  attachedImage: null,   // {dataUrl, file_url} or null
+  config: null,           // last loaded runtime config
 };
 
 // ═══ INIT ═══
@@ -430,13 +439,22 @@ document.addEventListener('DOMContentLoaded', function() {
   loadConfig();
   pollModelStatus();
   refreshWorkspace();
-  loadMcpCatalog();
+  loadMcpStatus();
 
   var input = document.getElementById('chat-input');
   input.addEventListener('input', autoResize);
   input.addEventListener('keydown', function(e) {
     if (e.key === 'Enter' && e.shiftKey) { e.preventDefault(); handleSend(); }
   });
+
+  // Wire up the Web search toggle
+  var searchToggle = document.getElementById('opt-search-toggle');
+  searchToggle.addEventListener('click', function(e) {
+    e.preventDefault();
+    var cb = document.getElementById('opt-search');
+    cb.checked = !cb.checked;
+    searchToggle.classList.toggle('active', cb.checked);
+  });
 });
 
 function autoResize() {
@@ -457,9 +475,9 @@ async function loadConfig() {
   try {
     var resp = await fetch('/api/get_config');
     var config = await resp.json();
+    state.config = config;
     var sel = document.getElementById('model-select');
     sel.innerHTML = '';
-
     (config.models || []).forEach(function(m) {
       var opt = document.createElement('option');
       opt.value = m.key;
@@ -467,12 +485,115 @@ async function loadConfig() {
       if (m.key === config.default_model) opt.selected = true;
       sel.appendChild(opt);
     });
-
     sel.addEventListener('change', function() { switchModel(sel.value); });
+
+    // Populate language selector
+    var langSel = document.getElementById('opt-language');
+    langSel.innerHTML = '<option value="">Auto</option>';
+    (config.languages || []).forEach(function(pair) {
+      var lang = Array.isArray(pair) ? pair[0] : (pair.language || pair.name || pair);
+      var opt = document.createElement('option');
+      opt.value = lang;
+      opt.textContent = lang;
+      langSel.appendChild(opt);
+    });
+    updateFrameworkOptions();
+
+    // Populate skills selector
+    var skillSel = document.getElementById('opt-skill');
+    skillSel.innerHTML = '<option value="">None</option>';
+    (config.skills || []).forEach(function(s) {
+      var name = typeof s === 'string' ? s : (s.name || s.id || '');
+      if (!name) return;
+      var opt = document.createElement('option');
+      opt.value = name;
+      opt.textContent = name;
+      skillSel.appendChild(opt);
+    });
+
+    // Populate agents selector
+    var agentSel = document.getElementById('opt-agent');
+    agentSel.innerHTML = '<option value="">Default</option>';
+    (config.agents || []).forEach(function(a) {
+      var name = typeof a === 'string' ? a : (a.name || a.id || '');
+      if (!name) return;
+      var opt = document.createElement('option');
+      opt.value = name;
+      opt.textContent = name + (a.active ? ' (active)' : '');
+      if (a.active) opt.selected = true;
+      agentSel.appendChild(opt);
+    });
+
     renderExamples(config);
   } catch(e) { console.error('Config load failed:', e); }
 }
 
+function updateFrameworkOptions() {
+  if (!state.config) return;
+  var langSel = document.getElementById('opt-language');
+  var fwSel = document.getElementById('opt-framework');
+  var lang = langSel.value;
+  fwSel.innerHTML = '<option value="">Auto</option>';
+  if (!lang) return;
+  var match = (state.config.languages || []).find(function(pair) {
+    var l = Array.isArray(pair) ? pair[0] : (pair.language || pair.name || pair);
+    return l === lang;
+  });
+  if (!match) return;
+  var fws = Array.isArray(match) ? match[1] : (match.frameworks || match.fws || []);
+  (fws || []).forEach(function(fw) {
+    var opt = document.createElement('option');
+    opt.value = fw;
+    opt.textContent = fw;
+    fwSel.appendChild(opt);
+  });
+}
+
+async function setActiveAgent(name) {
+  try {
+    await fetch('/api/set_active_agent', {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({name: name || ''}),
+    });
+  } catch(e) { console.error('Set agent failed:', e); }
+}
+
+function handleImageSelect(event) {
+  var file = event.target.files && event.target.files[0];
+  if (!file) return;
+  var reader = new FileReader();
+  reader.onload = function(ev) {
+    state.attachedImage = {dataUrl: ev.target.result, name: file.name};
+    renderImagePreview();
+  };
+  reader.readAsDataURL(file);
+}
+
+function renderImagePreview() {
+  var container = document.getElementById('image-preview-container');
+  container.innerHTML = '';
+  if (!state.attachedImage) return;
+  var div = document.createElement('span');
+  div.className = 'img-preview';
+  var img = document.createElement('img');
+  img.src = state.attachedImage.dataUrl;
+  div.appendChild(img);
+  var name = document.createElement('span');
+  name.textContent = state.attachedImage.name.substring(0, 16);
+  div.appendChild(name);
+  var rm = document.createElement('span');
+  rm.className = 'remove';
+  rm.textContent = '×';
+  rm.onclick = function() {
+    state.attachedImage = null;
+    document.getElementById('opt-image-input').value = '';
+    renderImagePreview();
+  };
+  div.appendChild(rm);
+  container.appendChild(div);
+}
+
 async function pollModelStatus() {
   try {
     var resp = await fetch('/api/model_status');
@@ -528,150 +649,68 @@ async function refreshWorkspace() {
   } catch(e) { console.error(e); }
 }
 
-// ═══ MCP CATALOG (Rich UI) ═══
-
-async function loadMcpCatalog() {
+async function loadMcpStatus() {
   try {
-    var resp = await fetch('/api/mcp_catalog');
+    var resp = await fetch('/api/mcp_status');
     var data = await resp.json();
-    state.mcpServers = data.servers || [];
-    renderMcpCatalog();
-    updateMcpPill();
-  } catch(e) {
-    document.getElementById('mcp-catalog').innerHTML = '<div class="mcp-empty">MCP catalog unavailable.</div>';
-  }
-}
-
-function updateMcpPill() {
-  var servers = state.mcpServers;
-  var connected = servers.filter(function(s) { return s.connected; });
-  var dot = document.getElementById('mcp-dot');
-  var text = document.getElementById('mcp-pill-text');
-  dot.className = connected.length > 0 ? 'dot connected' : 'dot disconnected';
-  text.textContent = 'MCP ' + (connected.length > 0 ? '(' + connected.length + ')' : '');
-}
-
-function filterMcpCat(cat) {
-  state.activeMcpCat = cat;
-  document.querySelectorAll('.mcp-cat-tab').forEach(function(t) {
-    t.classList.toggle('active', t.dataset.cat === cat);
-  });
-  renderMcpCatalog();
-}
-
-function renderMcpCatalog() {
-  var cat = state.activeMcpCat;
-  var servers = state.mcpServers.filter(function(s) {
-    return cat === 'all' || s.category === cat;
-  });
-
-  // Update stats
-  var totalServers = state.mcpServers.length;
-  var connectedServers = state.mcpServers.filter(function(s) { return s.connected; }).length;
-  var totalTools = state.mcpServers.reduce(function(sum, s) { return sum + (s.tool_count || 0); }, 0);
-  document.getElementById('mcp-total-count').textContent = totalServers;
-  document.getElementById('mcp-connected-count').textContent = connectedServers;
-  document.getElementById('mcp-tools-count').textContent = totalTools;
-
-  if (servers.length === 0) {
-    document.getElementById('mcp-catalog').innerHTML = '<div class="mcp-empty">No servers in this category.</div>';
-    return;
-  }
-
-  var html = '';
-  servers.forEach(function(s) {
-    var isOn = s.connected;
-    html += '<div class="mcp-card" id="mcp-card-' + escHtml(s.key) + '">';
-    html += '<div class="mcp-card-head">';
-    html += '<span class="mcp-card-icon">' + (s.icon || '') + '</span>';
-    html += '<div class="mcp-card-info">';
-    html += '<div class="mcp-card-name">' + escHtml(s.name) + '</div>';
-    html += '<div class="mcp-card-desc">' + escHtml(s.description) + '</div>';
-    html += '</div>';
-    html += '<div class="mcp-card-actions">';
-    html += '<span class="mcp-card-status ' + (isOn ? 'on' : 'off') + '" id="mcp-status-' + escHtml(s.key) + '"></span>';
-    html += '<label class="mcp-toggle" title="' + (isOn ? 'Disable' : 'Enable') + ' ' + escHtml(s.name) + '">';
-    html += '<input type="checkbox" ' + (isOn ? 'checked' : '') + ' onchange="toggleMcpServer(\'' + escHtml(s.key) + '\', this.checked)">';
-    html += '<span class="mcp-toggle-slider"></span>';
-    html += '</label>';
-    html += '<button class="mcp-card-expand" onclick="toggleMcpCard(\'' + escHtml(s.key) + '\')">&#9660; Info</button>';
-    html += '</div>';
-    html += '</div>';
-    html += '<div class="mcp-card-details" id="mcp-details-' + escHtml(s.key) + '">';
-    if (s.install_hint) {
-      html += '<div class="mcp-detail-row"><span class="mcp-detail-label">Install:</span><span class="mcp-detail-value" style="color:var(--cyan)">' + escHtml(s.install_hint) + '</span></div>';
-    }
-    html += '<div class="mcp-detail-row"><span class="mcp-detail-label">Transport:</span><span class="mcp-detail-value">' + escHtml(s.transport) + '</span></div>';
-    if (s.command) {
-      html += '<div class="mcp-detail-row"><span class="mcp-detail-label">Command:</span><span class="mcp-detail-value">' + escHtml(s.command + ' ' + (s.args || []).join(' ')) + '</span></div>';
-    }
-    if (s.repo_url) {
-      html += '<div class="mcp-detail-row"><span class="mcp-detail-label">Repo:</span><span class="mcp-detail-value"><a href="' + escHtml(s.repo_url) + '" target="_blank" rel="noopener">' + escHtml(s.repo_url) + '</a></span></div>';
-    }
-    if (s.tool_count > 0) {
-      html += '<div class="mcp-card-tools"><span class="mcp-tool-chip">' + s.tool_count + ' tools</span></div>';
+    var dot = document.getElementById('mcp-dot');
+    var text = document.getElementById('mcp-pill-text');
+    var content = document.getElementById('mcp-content');
+    var servers = data.servers || {};
+    var keys = Object.keys(servers);
+    if (keys.length === 0) {
+      dot.className = 'dot disconnected';
+      text.textContent = 'MCP';
+      content.innerHTML = '<div class="mcp-empty">No MCP servers configured.<br><br>Add MCP servers in your config to extend SoniCoder with external tools.</div>';
+      return;
     }
-    html += '<div id="mcp-error-' + escHtml(s.key) + '"></div>';
-    html += '</div>';
-    html += '</div>';
-  });
-
-  document.getElementById('mcp-catalog').innerHTML = html;
-}
-
-function toggleMcpCard(key) {
-  var card = document.getElementById('mcp-card-' + key);
-  if (card) card.classList.toggle('open');
-}
-
-async function toggleMcpServer(key, enabled) {
-  var errorEl = document.getElementById('mcp-error-' + key);
-  var statusEl = document.getElementById('mcp-status-' + key);
-  if (errorEl) errorEl.innerHTML = '<span class="mcp-connecting">' + (enabled ? 'Connecting...' : 'Disconnecting...') + '</span>';
-
-  try {
-    var resp = await fetch('/api/mcp_toggle', {
-      method: 'POST',
-      headers: {'Content-Type': 'application/json'},
-      body: JSON.stringify({ server_key: key, enabled: enabled }),
-    });
-    var data = await resp.json();
-    if (data.error) {
-      if (errorEl) errorEl.innerHTML = '<div class="mcp-card-error">' + escHtml(data.error) + '</div>';
-      // Revert toggle
-      var card = document.getElementById('mcp-card-' + key);
-      if (card) {
-        var cb = card.querySelector('input[type=checkbox]');
-        if (cb) cb.checked = !enabled;
+    var anyConnected = keys.some(function(k) { return servers[k].status === 'connected'; });
+    dot.className = anyConnected ? 'dot connected' : 'dot disconnected';
+    text.textContent = 'MCP (' + keys.length + ')';
+    var html = '';
+    keys.forEach(function(name) {
+      var s = servers[name];
+      var isConn = s.status === 'connected';
+      html += '<div class="mcp-server">';
+      html += '<div class="mcp-server-header">';
+      html += '<span class="mcp-server-dot ' + (isConn ? 'connected' : 'disconnected') + '"></span>';
+      html += '<span class="mcp-server-name">' + escHtml(name) + '</span>';
+      html += '<span class="tool-badge ' + (isConn ? 'success' : 'error') + '">' + s.status + '</span>';
+      html += '</div>';
+      if (s.tools && s.tools.length > 0) {
+        html += '<div class="mcp-tools">';
+        s.tools.forEach(function(t) { html += '<span class="mcp-tool-tag">' + escHtml(t) + '</span>'; });
+        html += '</div>';
       }
-      if (statusEl) statusEl.className = 'mcp-card-status off';
-    } else {
-      if (errorEl) errorEl.innerHTML = '';
-      if (statusEl) statusEl.className = 'mcp-card-status ' + (enabled ? 'on' : 'off');
-      // Refresh to get updated tool counts
-      setTimeout(loadMcpCatalog, 1500);
-    }
+      html += '</div>';
+    });
+    content.innerHTML = html;
   } catch(e) {
-    if (errorEl) errorEl.innerHTML = '<div class="mcp-card-error">Connection failed: ' + escHtml(e.message) + '</div>';
-    var card = document.getElementById('mcp-card-' + key);
-    if (card) {
-      var cb = card.querySelector('input[type=checkbox]');
-      if (cb) cb.checked = !enabled;
-    }
-    if (statusEl) statusEl.className = 'mcp-card-status off';
+    document.getElementById('mcp-dot').className = 'dot disconnected';
+    document.getElementById('mcp-content').innerHTML = '<div class="mcp-empty">MCP status unavailable.</div>';
   }
-  updateMcpPill();
 }
 
 function renderExamples(config) {
-  var examples = [
-    'Build a Flask REST API with user CRUD',
-    'Create a todo app with localStorage',
-    'Write a Python web scraper',
-    'Build a Markdown to HTML CLI tool',
-    'Create FastAPI with JWT auth',
-    'Make a React calculator component',
-  ];
+  // Use the examples from config; fall back to a curated list if missing.
+  var examples = [];
+  if (config && Array.isArray(config.examples) && config.examples.length) {
+    examples = config.examples.map(function(e) {
+      return typeof e === 'string' ? e : (e.label || e.prompt || '');
+    }).filter(Boolean);
+  }
+  if (!examples.length) {
+    examples = [
+      'Build a Flask REST API with user CRUD',
+      'Create a todo app with localStorage',
+      'Write a Python web scraper',
+      'Build a Markdown to HTML CLI tool',
+      'Create FastAPI with JWT auth',
+      'Make a React calculator component',
+    ];
+  }
+  // Show at most 6 examples so the row doesn't overflow on narrow screens.
+  examples = examples.slice(0, 6);
   var row = document.getElementById('examples-row');
   row.innerHTML = '<span class="examples-label">Try:</span>';
   examples.forEach(function(ex) {
@@ -680,6 +719,7 @@ function renderExamples(config) {
     chip.textContent = ex;
     chip.onclick = function() {
       document.getElementById('chat-input').value = ex;
+      document.getElementById('chat-input').dispatchEvent(new Event('input'));
       handleSend();
     };
     row.appendChild(chip);
@@ -696,7 +736,6 @@ function switchTab(tab) {
   document.querySelectorAll('.tab-pane').forEach(function(p) {
     p.classList.toggle('active', p.id === 'pane-' + tab);
   });
-  if (tab === 'mcp') loadMcpCatalog();
 }
 
 // ═══ FULLSCREEN ═══
@@ -732,7 +771,7 @@ function addMessage(role, content, extra) {
   var bodyClass = role === 'assistant' ? '<div class="msg-body">' : '';
   var bodyClose = role === 'assistant' ? '</div>' : '';
   var iterationHtml = extra.iteration ? '<div class="iteration-badge">Iteration ' + extra.iteration + '/' + extra.max_iterations + '</div>' : '';
-  div.innerHTML = iterationHtml + prefix + '<span class="msg-content">' + renderMd(content) + '</span>' + bodyClass + bodyClose;
+  div.innerHTML = iterationHtml + prefix + '<span class="msg-content">' + renderMd(content) + '</span>' + bodyClose + bodyClose;
   container.appendChild(div);
   container.scrollTop = container.scrollHeight;
   return div;
@@ -741,6 +780,7 @@ function addMessage(role, content, extra) {
 function renderMd(text) {
   if (!text) return '';
   text = escHtml(text);
+  // Code blocks
   text = text.replace(/```(\w*)\n([\s\S]*?)```/g, function(_, lang, code) {
     var id = 'cb_' + Date.now() + Math.random().toString(36).substr(2,4);
     return '<div class="code-block-wrap"><div class="code-block-header"><span class="code-lang">' + (lang||'code') + '</span><button class="btn-copy" onclick="copyBlock(\'' + id + '\')">&#128203; Copy</button></div><pre><code id="' + id + '">' + code.trim() + '</code></pre></div>';
@@ -784,7 +824,6 @@ function addToolCall(toolName, args) {
   var div = document.createElement('div');
   div.className = 'tool-block open';
   div.id = id;
-
   var argsStr = '';
   if (args) {
     Object.entries(args).forEach(function(e) {
@@ -792,7 +831,6 @@ function addToolCall(toolName, args) {
       argsStr += escHtml(e[0] + ': ' + v) + '\n';
     });
   }
-
   div.innerHTML =
     '<div class="tool-header">' +
       '<span class="tool-icon">&#9889;</span>' +
@@ -801,7 +839,6 @@ function addToolCall(toolName, args) {
     '</div>' +
     '<div class="tool-args">' + argsStr + '</div>' +
     '<div class="tool-result"></div>';
-
   container.appendChild(div);
   container.scrollTop = container.scrollHeight;
   state.toolCalls[id] = div;
@@ -813,7 +850,6 @@ function updateToolCall(id, success, output) {
   if (!div) return;
   var badge = div.querySelector('.tool-badge');
   var result = div.querySelector('.tool-result');
-
   if (success) {
     badge.className = 'tool-badge success';
     badge.textContent = 'DONE';
@@ -821,7 +857,6 @@ function updateToolCall(id, success, output) {
     badge.className = 'tool-badge error';
     badge.textContent = 'ERROR';
   }
-
   if (output) {
     result.textContent = output;
     result.className = success ? 'tool-result' : 'tool-result error-output';
@@ -868,25 +903,49 @@ async function handleSend() {
   startStreaming();
   setStatus('status-working', 'GENERATING...');
 
+  // Collect option values
+  var targetLanguage = (document.getElementById('opt-language') || {}).value || '';
+  var targetFramework = (document.getElementById('opt-framework') || {}).value || '';
+  var skill = (document.getElementById('opt-skill') || {}).value || '';
+  var agent = (document.getElementById('opt-agent') || {}).value || '';
+  var searchEnabled = (document.getElementById('opt-search') || {}).checked || false;
+
+  // Prepend /skill command if a skill is selected and not already in the message
+  var finalMessage = message;
+  if (skill && !message.startsWith('/skill')) {
+    finalMessage = '/skill ' + skill + '\n\n' + message;
+  }
+
+  // Attach image if present
+  var imageUrl = '';
+  if (state.attachedImage && state.attachedImage.dataUrl) {
+    imageUrl = state.attachedImage.dataUrl;
+  }
+
   try {
     var resp = await fetch('/chat', {
       method: 'POST',
       headers: {'Content-Type': 'application/json'},
-      body: JSON.stringify({ message: message, session_id: state.sessionId }),
+      body: JSON.stringify({
+        message: finalMessage,
+        session_id: state.sessionId,
+        target_language: targetLanguage,
+        target_framework: targetFramework,
+        search_enabled: searchEnabled ? 'true' : 'false',
+        agent_name: agent,
+        image_url: imageUrl,
+      }),
     });
     if (!resp.ok) throw new Error('HTTP ' + resp.status);
-
     var reader = resp.body.getReader();
     var decoder = new TextDecoder();
     var buffer = '';
-
     while (true) {
       var result = await reader.read();
       if (result.done) break;
       buffer += decoder.decode(result.value, {stream: true});
       var lines = buffer.split('\n');
       buffer = lines.pop() || '';
-
       for (var i = 0; i < lines.length; i++) {
         var line = lines[i];
         if (!line.trim()) continue;
@@ -909,6 +968,7 @@ async function handleSend() {
                   break;
                 }
               }
+              // Capture code for Code tab
               if (ev.result.output && (ev.result.output.includes('<!DOCTYPE') || ev.result.output.includes('<html'))) {
                 showPreview(ev.result.output);
               }
@@ -926,6 +986,12 @@ async function handleSend() {
               if (ev.iterations) setTimeout(refreshWorkspace, 500);
               setStatus('status-success', 'COMPLETE');
               setTimeout(function() { if (!state.isGenerating) setStatus('status-idle', 'IDLE'); }, 3000);
+              // Clear attached image after a successful send
+              if (state.attachedImage) {
+                state.attachedImage = null;
+                document.getElementById('opt-image-input').value = '';
+                renderImagePreview();
+              }
               break;
             case 'error':
               finalizeStream('Error: ' + ev.error);
@@ -941,7 +1007,6 @@ async function handleSend() {
       setStatus('status-error', 'CONNECTION ERROR');
     }
   }
-
   state.isGenerating = false;
   document.getElementById('btn-send').style.display = 'flex';
   document.getElementById('btn-stop').style.display = 'none';

requirements.txt

@@ -1,8 +1,6 @@
 # SoniCoder v2 — Optimized AI Code Agent
 # Architecture inspired by Gemini CLI and Claude Code
 
-fastapi>=0.115.0
-uvicorn[standard]>=0.30.0
 gradio==6.19.0
 transformers>=4.45.0
 torch>=2.1.0
@@ -12,8 +10,8 @@ requests>=2.31.0
 beautifulsoup4>=4.12.0
 Pillow>=10.0
 
-# MCP support (optional — servers work without it)
-# mcp>=1.0.0
+# MCP support
+mcp>=1.0.0
 
 # Optional: VLM support
 # torchvision>=0.16.0

sonicoder/__init__.py

@@ -1,12 +0,0 @@
-"""SoniCoder v2 — Optimized AI Code Writer Agent.
-
-Architecture inspired by Gemini CLI and Claude Code.
-- Event-driven agent protocol
-- ToolBuilder/ToolInvocation pattern
-- MCP (Model Context Protocol) support
-- Multiple smart 1B models
-- Policy/permission engine
-- Context window management with compression
-- Plugin system
-"""
-__version__ = "2.0.0"

sonicoder/agent/__init__.py

@@ -1,474 +0,0 @@
-"""Agent loop — the core agentic turn cycle.
-
-Implements the full agent loop inspired by both Gemini CLI and Claude Code:
-1. Build context (system prompt + tool schemas + history)
-2. Call model
-3. Parse tool calls from response
-4. Check policy
-5. Execute tools
-6. Feed results back to model
-7. Repeat until done or max iterations
-
-Tool call format: ```tool\nname\nkey: value\nkey: value\n```
-This is simpler than JSON function calling and works well with 1B models.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import re
-import time
-from typing import Any, Generator
-
-from ..config import Settings, get_model_config
-from ..model.inference import call_model_stream, TOOL_CALL_RE, THINKING_BLOCK_RE
-from ..tools import ToolRegistry, ToolResult, get_tool_registry
-from ..tools.fs import BUILTIN_TOOLS as FS_TOOLS
-from ..tools.bash import BUILTIN_TOOLS as BASH_TOOLS
-from ..tools.web import BUILTIN_TOOLS as WEB_TOOLS
-from ..tools.todos import BUILTIN_TOOLS as TODO_TOOLS
-from .protocol import AgentProtocol, AgentEvent, AgentEventType
-from ..policy import get_policy_engine, ApprovalDecision
-from ..mcp import get_mcp_manager
-
-logger = logging.getLogger(__name__)
-
-# ── System Prompt ──────────────────────────────────────────────────────
-
-SYSTEM_PROMPT = """You are SoniCoder v2, an expert AI coding agent. You write clean, well-structured code and help users build projects.
-
-## Capabilities
-- Read, write, and edit files in the workspace
-- Execute shell commands (bash)
-- Search the web for information
-- Manage task lists
-- Use MCP tools when available
-
-## Rules
-1. Always use tools to interact with the file system. Never guess file contents.
-2. When creating multi-file projects, write files one at a time with write_file.
-3. When editing existing files, use edit_file (search & replace) instead of rewriting.
-4. Run commands to verify your code works (e.g., python file.py, npm test).
-5. Think step-by-step. Plan before coding complex features.
-6. Use the todo tool to track multi-step tasks.
-7. If a tool fails, read the error and try to fix it.
-8. When done, summarize what you built.
-
-## File Output Format
-You can write code in two ways:
-1. Use the write_file tool for each file (preferred)
-2. Use fenced code blocks with language tags for display
-
-## Tool Call Format
-To use a tool, output a fenced code block with "tool" language:
-```tool
-tool_name
-key: value
-key2: value2
-```
-
-Example:
-```tool
-write_file
-path: hello.py
-content: print("Hello, World!")
-```
-
-## Multi-File Projects
-For projects with multiple files, write each file separately using write_file.
-Start with the main entry point, then supporting files.
-
-## Best Practices
-- Include error handling in your code
-- Add comments for complex logic
-- Use meaningful variable names
-- Follow the language's conventions and idioms
-- Test your code after writing it
-"""
-
-
-# ── Simple YAML Parser (no PyYAML dependency) ──────────────────────────
-
-def _parse_yaml_block(text: str) -> dict[str, Any]:
-    """Parse a simple YAML-like block into a dictionary.
-
-    Supports: key: value, key: | (block scalar), - item (lists)
-    """
-    result: dict[str, Any] = {}
-    current_key: str | None = None
-    current_lines: list[str] = []
-    in_block = False
-
-    for line in text.strip().splitlines():
-        # Check for list items
-        if line.strip().startswith("- "):
-            if in_block and current_key:
-                result[current_key] = "\n".join(current_lines).strip()
-                current_lines = []
-                in_block = False
-            item = line.strip()[2:].strip()
-            if current_key:
-                result.setdefault(current_key, [])
-                if isinstance(result[current_key], str):
-                    result[current_key] = [result[current_key]]
-                result[current_key].append(item)
-            continue
-
-        # Check for block scalar
-        if line.endswith("|"):
-            current_key = line[:-1].strip().rstrip(":")
-            in_block = True
-            current_lines = []
-            continue
-
-        # Check for key: value
-        match = re.match(r"^(\w[\w\s]*?)\s*:\s*(.*)", line)
-        if match and not in_block:
-            # Save previous block
-            if current_key and in_block and current_lines:
-                result[current_key] = "\n".join(current_lines).strip()
-
-            key = match.group(1).strip()
-            value = match.group(2).strip()
-            current_key = key
-
-            # Type coercion
-            if value.lower() in ("true", "yes"):
-                result[key] = True
-            elif value.lower() in ("false", "no"):
-                result[key] = False
-            elif value.isdigit():
-                result[key] = int(value)
-            else:
-                try:
-                    result[key] = float(value)
-                except ValueError:
-                    result[key] = value
-            in_block = False
-            current_lines = []
-            continue
-
-        if in_block and current_key:
-            current_lines.append(line)
-
-    # Save remaining block
-    if in_block and current_key and current_lines:
-        result[current_key] = "\n".join(current_lines).strip()
-
-    return result
-
-
-def _parse_tool_calls(text: str) -> list[dict[str, Any]]:
-    """Parse all tool calls from model output.
-
-    Format:
-    ```tool
-    tool_name
-    key: value
-    ```
-    """
-    calls = []
-    for match in TOOL_CALL_RE.finditer(text):
-        block = match.group(1).strip()
-        lines = block.split("\n", 1)
-
-        tool_name = lines[0].strip()
-        args_raw = lines[1] if len(lines) > 1 else ""
-        args = _parse_yaml_block(args_raw)
-
-        calls.append({
-            "tool_name": tool_name,
-            "args": args,
-            "raw": block,
-        })
-
-    return calls
-
-
-# ── Agent Session ──────────────────────────────────────────────────────
-
-class AgentSession(AgentProtocol):
-    """Full agent session with tool execution loop.
-
-    This is the main class that runs the agentic loop:
-    user message → model → tool calls → execute → feed back → model → ... → done
-    """
-
-    def __init__(
-        self,
-        settings: Settings | None = None,
-        tool_registry: ToolRegistry | None = None,
-    ):
-        super().__init__()
-        self._settings = settings or Settings()
-        self._registry = tool_registry or get_tool_registry()
-        self._policy = get_policy_engine()
-        self._mcp = get_mcp_manager()
-        self._history: list[dict[str, str]] = []
-        self._total_tokens = 0
-        self._tool_calls = 0
-        self._start_time = 0.0
-
-    def run(
-        self,
-        message: str,
-        session_id: str = "",
-        image_url: str | None = None,
-    ) -> Generator[dict, None, None]:
-        """Run the agent loop. Yields event dicts for streaming to the client."""
-        self._start_time = time.time()
-        self._tool_calls = 0
-
-        # Initialize
-        stream_id = self.send(message)
-        self._emit(AgentEventType.STATUS, {"status": "starting", "message": "Starting agent..."})
-
-        # Add user message to history
-        self._history.append({"role": "user", "content": message})
-
-        # Build tool schemas
-        tool_schemas = self._build_tool_schemas()
-
-        # Build full system prompt
-        system_prompt = self._build_system_prompt(tool_schemas)
-
-        # Agent loop
-        max_iterations = self._settings.max_iterations
-        model_config = get_model_config(self._settings.default_model)
-
-        for iteration in range(max_iterations):
-            if self.is_aborted:
-                self._emit(AgentEventType.COMPLETE, {"reason": "aborted"})
-                yield {"type": "complete", "reason": "aborted"}
-                return
-
-            self._emit(AgentEventType.STATUS, {
-                "status": "thinking",
-                "iteration": iteration + 1,
-                "max_iterations": max_iterations,
-                "message": f"Thinking (iteration {iteration + 1}/{max_iterations})...",
-            })
-
-            # Call model
-            try:
-                response_text = ""
-                for chunk in call_model_stream(
-                    messages=self._history,
-                    system_prompt=system_prompt,
-                    max_new_tokens=self._settings.max_tokens,
-                    temperature=self._settings.temperature,
-                    image_url=image_url,
-                ):
-                    response_text += chunk
-                    # Strip thinking blocks for display
-                    display = THINKING_BLOCK_RE.sub("", response_text)
-                    # Strip tool calls for display
-                    display_clean = TOOL_CALL_RE.sub("", display).strip()
-                    yield {"type": "streaming", "content": display_clean, "full_text": response_text}
-
-            except Exception as e:
-                self._emit(AgentEventType.ERROR, {"error": str(e)})
-                yield {"type": "error", "error": str(e)}
-                return
-
-            # Add assistant response to history
-            self._history.append({"role": "assistant", "content": response_text})
-
-            # Parse tool calls
-            tool_calls = _parse_tool_calls(response_text)
-
-            if not tool_calls:
-                # No tool calls — agent is done
-                display = THINKING_BLOCK_RE.sub("", response_text).strip()
-                self._emit(AgentEventType.MESSAGE, {"content": display})
-                self._emit(AgentEventType.COMPLETE, {"reason": "done"})
-                elapsed = time.time() - self._start_time
-                yield {
-                    "type": "complete",
-                    "reason": "done",
-                    "content": display,
-                    "iterations": iteration + 1,
-                    "tool_calls": self._tool_calls,
-                    "elapsed_seconds": round(elapsed, 1),
-                }
-                return
-
-            # Process tool calls
-            for tc in tool_calls:
-                if self.is_aborted:
-                    yield {"type": "complete", "reason": "aborted"}
-                    return
-
-                tool_name = tc["tool_name"]
-                args = tc["args"]
-
-                self._emit(AgentEventType.TOOL_REQUEST, {
-                    "tool": tool_name,
-                    "args": args,
-                })
-
-                yield {
-                    "type": "tool_call",
-                    "tool": tool_name,
-                    "args": args,
-                }
-
-                # Check policy
-                policy_result = self._policy.check(tool_name, args)
-                if policy_result.decision == ApprovalDecision.DENY:
-                    result = ToolResult(
-                        success=False,
-                        error=f"Blocked by policy: {policy_result.reason}",
-                    )
-                else:
-                    # Execute tool
-                    result = self._execute_tool(tool_name, args, session_id)
-
-                self._tool_calls += 1
-                self._emit(AgentEventType.TOOL_RESPONSE, {
-                    "tool": tool_name,
-                    "result": result.to_dict(),
-                })
-
-                yield {
-                    "type": "tool_result",
-                    "tool": tool_name,
-                    "result": result.to_dict(),
-                }
-
-                # Feed result back to model
-                result_content = result.to_json()
-                self._history.append({
-                    "role": "tool",
-                    "content": f"[{tool_name}] {result_content}",
-                })
-
-        # Max iterations reached
-        self._emit(AgentEventType.COMPLETE, {"reason": "max_iterations"})
-        yield {
-            "type": "complete",
-            "reason": "max_iterations",
-            "iterations": max_iterations,
-            "tool_calls": self._tool_calls,
-            "elapsed_seconds": round(time.time() - self._start_time, 1),
-        }
-
-    def _execute_tool(
-        self, tool_name: str, args: dict[str, Any], session_id: str
-    ) -> ToolResult:
-        """Execute a single tool call."""
-        # Check if it's an MCP tool
-        if tool_name.startswith("mcp_"):
-            return self._execute_mcp_tool(tool_name, args)
-
-        # Look up in registry
-        tool_builder = self._registry.get_tool(tool_name)
-        if not tool_builder:
-            return ToolResult(success=False, error=f"Unknown tool: {tool_name}")
-
-        # Validate
-        errors = tool_builder.validate(args)
-        if errors:
-            return ToolResult(success=False, error=f"Validation error: {'; '.join(errors)}")
-
-        # Create invocation
-        invocation = tool_builder.create_invocation(args)
-
-        # Inject session_id for todo tool
-        if tool_name == "todo":
-            invocation.session_id = session_id
-
-        # Execute
-        try:
-            return invocation.execute()
-        except Exception as e:
-            logger.error(f"Tool execution error ({tool_name}): {e}")
-            return ToolResult(success=False, error=f"Tool error: {e}")
-
-    def _execute_mcp_tool(self, tool_name: str, args: dict[str, Any]) -> ToolResult:
-        """Execute an MCP tool."""
-        bridge = self._mcp.get_tool(tool_name)
-        if not bridge:
-            return ToolResult(success=False, error=f"MCP tool not found: {tool_name}")
-
-        try:
-            result = self._mcp.call_tool(bridge.server_name, bridge.tool_name, args)
-            if "error" in result:
-                return ToolResult(success=False, error=result["error"])
-            return ToolResult(success=True, output=result.get("output", str(result)))
-        except Exception as e:
-            return ToolResult(success=False, error=f"MCP error: {e}")
-
-    def _build_tool_schemas(self) -> str:
-        """Build tool schema documentation for the system prompt."""
-        active = self._registry.get_active_tools()
-        mcp_tools = self._mcp.get_tools()
-
-        schema_parts = []
-        for name, tool in active.items():
-            schema_parts.append(f"### {name}\n{tool.description}")
-            if hasattr(tool, "get_schema"):
-                params = tool.get_schema()
-                props = params.get("properties", {})
-                required = params.get("required", [])
-                if props:
-                    schema_parts.append("Parameters:")
-                    for pname, pinfo in props.items():
-                        req = " (required)" if pname in required else ""
-                        ptype = pinfo.get("type", "any")
-                        desc = pinfo.get("description", "")
-                        schema_parts.append(f"  - {pname}: {ptype}{req} — {desc}")
-            schema_parts.append("")
-
-        # Add MCP tools
-        for name, bridge in mcp_tools.items():
-            schema_parts.append(f"### {name}\n{bridge.description}")
-            params = bridge._schema.get("inputSchema", {}).get("properties", {})
-            for pname, pinfo in params.items():
-                desc = pinfo.get("description", "")
-                schema_parts.append(f"  - {pname}: {desc}")
-            schema_parts.append("")
-
-        if not schema_parts:
-            return "No tools available."
-
-        return "## Available Tools\n\n" + "\n".join(schema_parts)
-
-    def _build_system_prompt(self, tool_schemas: str) -> str:
-        """Build the full system prompt."""
-        parts = [SYSTEM_PROMPT, "\n", tool_schemas]
-
-        # Add model-specific tips
-        model_key = self._settings.default_model
-        if "qwen" in model_key.lower():
-            parts.append(
-                "\n## Tips for Qwen Models\n"
-                "- Be explicit and structured in your responses\n"
-                "- Use complete file paths in tool calls\n"
-                "- Break complex tasks into clear steps"
-            )
-        elif "deepseek" in model_key.lower():
-            parts.append(
-                "\n## Tips for DeepSeek Models\n"
-                "- Think carefully before acting\n"
-                "- Use comments to explain complex code\n"
-                "- Verify code correctness with test commands"
-            )
-
-        return "\n".join(parts)
-
-    def clear_history(self) -> None:
-        """Clear conversation history."""
-        self._history.clear()
-        self._total_tokens = 0
-        self._tool_calls = 0
-
-
-# ── Register Built-in Tools ────────────────────────────────────────────
-
-def register_builtin_tools(registry: ToolRegistry) -> None:
-    """Register all built-in tools into the registry."""
-    for tools_module in [FS_TOOLS, BASH_TOOLS, WEB_TOOLS, TODO_TOOLS]:
-        for tool in tools_module:
-            registry.register(tool)

sonicoder/agent/protocol.py

@@ -1,106 +0,0 @@
-"""Agent protocol — event-driven architecture from Gemini CLI.
-
-The agent is purely event-driven. All communication flows through typed events.
-This is the core architectural pattern borrowed from Gemini CLI's AgentProtocol.
-"""
-
-from __future__ import annotations
-
-import time
-import uuid
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Any, Callable
-
-
-# ── Event Types ────────────────────────────────────────────────────────
-
-class AgentEventType(Enum):
-    """All possible agent events — discriminated union pattern from Gemini CLI."""
-    INITIALIZE = "initialize"
-    STATUS = "status"
-    MESSAGE = "message"            # Agent reasoning/text output
-    TOOL_REQUEST = "tool_request"  # Agent wants to call a tool
-    TOOL_RESPONSE = "tool_response"  # Tool result returned
-    STREAMING = "streaming"        # Incremental token
-    COMPLETE = "complete"          # Agent finished (success)
-    ERROR = "error"                # Agent finished (error)
-    USAGE = "usage"                # Token usage stats
-
-
-@dataclass
-class AgentEvent:
-    """A single event in the agent event stream."""
-    type: AgentEventType
-    data: dict[str, Any] = field(default_factory=dict)
-    timestamp: float = field(default_factory=time.time)
-    event_id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "type": self.type.value,
-            "data": self.data,
-            "timestamp": self.timestamp,
-            "event_id": self.event_id,
-        }
-
-
-# ── Agent Protocol Interface ───────────────────────────────────────────
-
-class AgentProtocol:
-    """Event-driven agent interface.
-
-    Inspired by Gemini CLI's AgentProtocol:
-    - send(): Submit a user message
-    - subscribe(): Listen for events
-    - abort(): Cancel current operation
-    """
-
-    def __init__(self):
-        self._subscribers: list[Callable[[AgentEvent], None]] = []
-        self._events: list[AgentEvent] = []
-        self._aborted = False
-        self._stream_id: str | None = None
-
-    def send(self, message: str, **kwargs) -> str:
-        """Submit a user message. Returns stream_id."""
-        self._aborted = False
-        self._stream_id = str(uuid.uuid4())[:12]
-        self._emit(AgentEventType.INITIALIZE, {
-            "stream_id": self._stream_id,
-            "message": message,
-        })
-        return self._stream_id
-
-    def subscribe(self, callback: Callable[[AgentEvent], None]) -> Callable:
-        """Subscribe to events. Returns unsubscribe function."""
-        self._subscribers.append(callback)
-        def unsubscribe():
-            self._subscribers.remove(callback)
-        return unsubscribe
-
-    def abort(self) -> None:
-        """Cancel the current operation."""
-        self._aborted = True
-
-    @property
-    def is_aborted(self) -> bool:
-        return self._aborted
-
-    def _emit(self, event_type: AgentEventType, data: dict[str, Any] | None = None) -> AgentEvent:
-        """Emit an event to all subscribers."""
-        event = AgentEvent(type=event_type, data=data or {})
-        self._events.append(event)
-        for sub in self._subscribers:
-            try:
-                sub(event)
-            except Exception:
-                pass
-        return event
-
-    @property
-    def events(self) -> list[AgentEvent]:
-        return list(self._events)
-
-    def clear_history(self) -> None:
-        self._events.clear()

sonicoder/config/__init__.py

@@ -1,455 +0,0 @@
-"""Configuration system — hierarchical settings like Claude Code."""
-
-from __future__ import annotations
-
-import json
-import os
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any
-
-# ── Defaults ──────────────────────────────────────────────────────────
-
-WORKSPACE_ROOT = Path(os.environ.get("SONICODER_WORKSPACE", "./workspace"))
-CONFIG_DIR = Path(os.environ.get("SONICODER_CONFIG", ".sonicoder"))
-
-DEFAULT_TEMPERATURE = 0.35
-DEFAULT_MAX_TOKENS = 4096
-DEFAULT_MAX_ITERATIONS = 12
-AGENT_LOOP_TIMEOUT = 300  # seconds
-BASH_TIMEOUT = 120
-PYTHON_TIMEOUT = 30
-
-
-@dataclass
-class ModelConfig:
-    """Configuration for a single model."""
-    name: str
-    model_id: str
-    model_type: str  # "text" | "vlm"
-    size_gb: float
-    description: str
-    dtype: str = "float16"
-    trust_remote_code: bool = True
-    device: str = "auto"
-
-
-@dataclass
-class MCPServerConfig:
-    """Configuration for an MCP server."""
-    name: str
-    transport: str  # "stdio" | "sse"
-    command: str | None = None
-    args: list[str] = field(default_factory=list)
-    env: dict[str, str] = field(default_factory=dict)
-    url: str | None = None
-    enabled: bool = True
-
-
-@dataclass
-class PolicyRule:
-    """A policy rule for tool approval."""
-    tool_name: str  # supports "*" wildcard
-    args_pattern: str | None = None
-    approval: str = "ask"  # "allow" | "ask" | "deny"
-    priority: int = 0
-    description: str = ""
-
-
-@dataclass
-class Settings:
-    """Hierarchical settings — cascades from global → project → local."""
-    # Model
-    default_model: str = "qwen25-coder-1.5b"
-    temperature: float = DEFAULT_TEMPERATURE
-    max_tokens: int = DEFAULT_MAX_TOKENS
-
-    # Agent
-    max_iterations: int = DEFAULT_MAX_ITERATIONS
-    agent_timeout: int = AGENT_LOOP_TIMEOUT
-
-    # Tools
-    enabled_tools: list[str] = field(default_factory=lambda: ["*"])
-    disabled_tools: list[str] = field(default_factory=list)
-
-    # Safety
-    sandbox_enabled: bool = True
-    bash_timeout: int = BASH_TIMEOUT
-    python_timeout: int = PYTHON_TIMEOUT
-
-    # MCP
-    mcp_servers: list[MCPServerConfig] = field(default_factory=list)
-
-    # Policy
-    policy_rules: list[PolicyRule] = field(default_factory=list)
-
-    # Context
-    max_context_tokens: int = 32768
-    auto_compact: bool = True
-
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> Settings:
-        """Create settings from a dictionary, ignoring unknown fields."""
-        known_fields = {f.name for f in cls.__dataclass_fields__.values()}
-        filtered = {k: v for k, v in data.items() if k in known_fields}
-        return cls(**filtered)
-
-    def merge(self, other: Settings) -> Settings:
-        """Merge another settings object (other takes precedence for non-default values)."""
-        result = Settings(
-            default_model=other.default_model or self.default_model,
-            temperature=other.temperature if other.temperature != DEFAULT_TEMPERATURE else self.temperature,
-            max_tokens=other.max_tokens if other.max_tokens != DEFAULT_MAX_TOKENS else self.max_tokens,
-            max_iterations=other.max_iterations if other.max_iterations != DEFAULT_MAX_ITERATIONS else self.max_iterations,
-            agent_timeout=other.agent_timeout if other.agent_timeout != AGENT_LOOP_TIMEOUT else self.agent_timeout,
-            sandbox_enabled=other.sandbox_enabled,
-            bash_timeout=other.bash_timeout,
-            python_timeout=other.python_timeout,
-            auto_compact=other.auto_compact,
-        )
-        # Merge lists
-        result.enabled_tools = other.enabled_tools if other.enabled_tools != ["*"] else self.enabled_tools
-        result.disabled_tools = list(set(self.disabled_tools + other.disabled_tools))
-        result.mcp_servers = self.mcp_servers + other.mcp_servers
-        result.policy_rules = other.policy_rules + self.policy_rules
-        return result
-
-
-# ── Model Registry ────────────────────────────────────────────────────
-
-MODEL_REGISTRY: dict[str, ModelConfig] = {
-    "qwen25-coder-1.5b": ModelConfig(
-        name="Qwen2.5-Coder-1.5B",
-        model_id="Qwen/Qwen2.5-Coder-1.5B-Instruct",
-        model_type="text",
-        size_gb=2.9,
-        description="Best-in-class 1.5B code model. Excellent at Python, JS, TypeScript, and multi-file generation.",
-    ),
-    "deepseek-coder-1.3b": ModelConfig(
-        name="DeepSeek-Coder-1.3B",
-        model_id="deepseek-ai/deepseek-coder-1.3b-instruct",
-        model_type="text",
-        size_gb=2.6,
-        description="Strong code understanding and generation. Good at multi-language coding tasks.",
-    ),
-    "qwen25-1.5b": ModelConfig(
-        name="Qwen2.5-1.5B-Instruct",
-        model_id="Qwen/Qwen2.5-1.5B-Instruct",
-        model_type="text",
-        size_gb=2.9,
-        description="General-purpose 1.5B model. Good for reasoning, analysis, and non-code tasks.",
-    ),
-    "smolvlm-2.2b": ModelConfig(
-        name="SmolVLM-2.2B",
-        model_id="HuggingFaceTB/SmolVLM2-2.2B-Instruct",
-        model_type="vlm",
-        size_gb=4.4,
-        description="Vision-language model. Can understand screenshots, diagrams, and generate code from images.",
-    ),
-    "minicpm5-1b": ModelConfig(
-        name="MiniCPM5-1B",
-        model_id="openbmb/MiniCPM5-1B",
-        model_type="text",
-        size_gb=2.17,
-        description="Compact text model. Fast inference, decent code generation.",
-    ),
-    "tinyllama-1.1b": ModelConfig(
-        name="TinyLlama-1.1B-Chat",
-        model_id="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
-        model_type="text",
-        size_gb=2.2,
-        description="Ultra-compact chat model. Good for simple tasks, fastest inference.",
-    ),
-}
-
-
-# ── MCP Server Catalog ─────────────────────────────────────────────────
-# Pre-configured MCP servers users can enable from the UI.
-
-MCP_CATALOG: list[dict[str, Any]] = [
-    {
-        "key": "filesystem",
-        "name": "Filesystem",
-        "description": "Read, write, and manage files on the server. Full file system access with safe path resolution.",
-        "category": "core",
-        "icon": "📁",
-        "transport": "stdio",
-        "command": "npx",
-        "args": ["-y", "@anthropic/mcp-filesystem", "."],
-        "install_hint": "npx -y @anthropic/mcp-filesystem",
-        "repo_url": "https://github.com/anthropics/mcp-filesystem",
-    },
-    {
-        "key": "fetch",
-        "name": "Fetch / HTTP",
-        "description": "Make HTTP requests to any URL. Fetch web pages, APIs, and resources for the agent to read.",
-        "category": "core",
-        "icon": "🌐",
-        "transport": "stdio",
-        "command": "npx",
-        "args": ["-y", "@anthropic/mcp-fetch"],
-        "install_hint": "npx -y @anthropic/mcp-fetch",
-        "repo_url": "https://github.com/anthropics/mcp-fetch",
-    },
-    {
-        "key": "memory",
-        "name": "Memory / Knowledge Graph",
-        "description": "Persistent knowledge graph memory. Store and retrieve facts, entities, and relationships across sessions.",
-        "category": "core",
-        "icon": "🧠",
-        "transport": "stdio",
-        "command": "npx",
-        "args": ["-y", "@anthropic/mcp-memory"],
-        "install_hint": "npx -y @anthropic/mcp-memory",
-        "repo_url": "https://github.com/anthropics/mcp-memory",
-    },
-    {
-        "key": "sequential-thinking",
-        "name": "Sequential Thinking",
-        "description": "Dynamic thinking and reflection. Break down complex problems into ordered reasoning steps.",
-        "category": "reasoning",
-        "icon": "💭",
-        "transport": "stdio",
-        "command": "npx",
-        "args": ["-y", "@anthropic/mcp-sequential-thinking"],
-        "install_hint": "npx -y @anthropic/mcp-sequential-thinking",
-        "repo_url": "https://github.com/anthropics/mcp-sequential-thinking",
-    },
-    {
-        "key": "github",
-        "name": "GitHub",
-        "description": "Search repos, manage issues/PRs, create branches, and interact with the GitHub API directly.",
-        "category": "dev-tools",
-        "icon": "🐙",
-        "transport": "stdio",
-        "command": "npx",
-        "args": ["-y", "@anthropic/mcp-github"],
-        "env": {"GITHUB_TOKEN": ""},
-        "install_hint": "Set GITHUB_TOKEN env var first, then: npx -y @anthropic/mcp-github",
-        "repo_url": "https://github.com/anthropics/mcp-github",
-    },
-    {
-        "key": "git",
-        "name": "Git",
-        "description": "Git operations: diff, log, status, branch management, and commit history analysis.",
-        "category": "dev-tools",
-        "icon": "🔀",
-        "transport": "stdio",
-        "command": "npx",
-        "args": ["-y", "@anthropic/mcp-git"],
-        "install_hint": "npx -y @anthropic/mcp-git",
-        "repo_url": "https://github.com/anthropics/mcp-git",
-    },
-    {
-        "key": "docker",
-        "name": "Docker",
-        "description": "Manage Docker containers, images, and compose stacks. Build, run, and inspect containers.",
-        "category": "dev-tools",
-        "icon": "🐳",
-        "transport": "stdio",
-        "command": "npx",
-        "args": ["-y", "@anthropic/mcp-docker"],
-        "install_hint": "npx -y @anthropic/mcp-docker (requires Docker daemon)",
-        "repo_url": "https://github.com/anthropics/mcp-docker",
-    },
-    {
-        "key": "postgres",
-        "name": "PostgreSQL",
-        "description": "Read/write PostgreSQL databases. Run queries, inspect schemas, and manage tables.",
-        "category": "database",
-        "icon": "🐘",
-        "transport": "stdio",
-        "command": "npx",
-        "args": ["-y", "@anthropic/mcp-postgres"],
-        "env": {"DATABASE_URL": "postgresql://localhost:5432/mydb"},
-        "install_hint": "Set DATABASE_URL, then: npx -y @anthropic/mcp-postgres",
-        "repo_url": "https://github.com/anthropics/mcp-postgres",
-    },
-    {
-        "key": "sqlite",
-        "name": "SQLite",
-        "description": "Read/write SQLite databases. Query tables, inspect schemas, run migrations.",
-        "category": "database",
-        "icon": "🗃️",
-        "transport": "stdio",
-        "command": "npx",
-        "args": ["-y", "@anthropic/mcp-sqlite", "--db-path", "./workspace/data.db"],
-        "install_hint": "npx -y @anthropic/mcp-sqlite --db-path ./data.db",
-        "repo_url": "https://github.com/anthropics/mcp-sqlite",
-    },
-    {
-        "key": "redis",
-        "name": "Redis",
-        "description": "Redis cache and data structure operations. Get/set keys, manage lists, sets, and hashes.",
-        "category": "database",
-        "icon": "🔴",
-        "transport": "stdio",
-        "command": "npx",
-        "args": ["-y", "@anthropic/mcp-redis"],
-        "env": {"REDIS_URL": "redis://localhost:6379"},
-        "install_hint": "Set REDIS_URL, then: npx -y @anthropic/mcp-redis",
-        "repo_url": "https://github.com/anthropics/mcp-redis",
-    },
-    {
-        "key": "brave-search",
-        "name": "Brave Search",
-        "description": "Web search powered by Brave. Search the web, get AI summaries, and fetch page contents.",
-        "category": "search",
-        "icon": "🔍",
-        "transport": "stdio",
-        "command": "npx",
-        "args": ["-y", "@anthropic/mcp-brave-search"],
-        "env": {"BRAVE_API_KEY": ""},
-        "install_hint": "Set BRAVE_API_KEY, then: npx -y @anthropic/mcp-brave-search",
-        "repo_url": "https://github.com/anthropics/mcp-brave-search",
-    },
-    {
-        "key": "puppeteer",
-        "name": "Puppeteer / Browser",
-        "description": "Headless browser automation. Navigate pages, take screenshots, extract content, and fill forms.",
-        "category": "browser",
-        "icon": "🎭",
-        "transport": "stdio",
-        "command": "npx",
-        "args": ["-y", "@anthropic/mcp-puppeteer"],
-        "install_hint": "npx -y @anthropic/mcp-puppeteer (requires Chromium)",
-        "repo_url": "https://github.com/anthropics/mcp-puppeteer",
-    },
-    {
-        "key": "slack",
-        "name": "Slack",
-        "description": "Send messages, read channels, and manage Slack workspaces via the Slack API.",
-        "category": "integrations",
-        "icon": "💬",
-        "transport": "stdio",
-        "command": "npx",
-        "args": ["-y", "@anthropic/mcp-slack"],
-        "env": {"SLACK_BOT_TOKEN": "", "SLACK_TEAM_ID": ""},
-        "install_hint": "Set SLACK_BOT_TOKEN + SLACK_TEAM_ID, then: npx -y @anthropic/mcp-slack",
-        "repo_url": "https://github.com/anthropics/mcp-slack",
-    },
-    {
-        "key": "context7",
-        "name": "Context7 / Docs",
-        "description": "Look up library documentation. Get up-to-date docs for npm packages, Python libs, and more.",
-        "category": "search",
-        "icon": "📚",
-        "transport": "stdio",
-        "command": "npx",
-        "args": ["-y", "@anthropic/mcp-context7"],
-        "install_hint": "npx -y @anthropic/mcp-context7",
-        "repo_url": "https://github.com/anthropics/mcp-context7",
-    },
-    {
-        "key": "everything",
-        "name": "Everything (Meta)",
-        "description": "Combines multiple MCP tools into one server: filesystem, fetch, memory, and more.",
-        "category": "core",
-        "icon": "⚡",
-        "transport": "stdio",
-        "command": "npx",
-        "args": ["-y", "@anthropic/mcp-everything"],
-        "install_hint": "npx -y @anthropic/mcp-everything",
-        "repo_url": "https://github.com/anthropics/mcp-everything",
-    },
-    {
-        "key": "sentry",
-        "name": "Sentry",
-        "description": "Query Sentry for error tracking. List issues, get stack traces, and manage projects.",
-        "category": "integrations",
-        "icon": "🛡️",
-        "transport": "stdio",
-        "command": "npx",
-        "args": ["-y", "@anthropic/mcp-sentry"],
-        "env": {"SENTRY_TOKEN": "", "SENTRY_ORG": "", "SENTRY_PROJECT": ""},
-        "install_hint": "Set SENTRY_TOKEN/ORG/PROJECT, then: npx -y @anthropic/mcp-sentry",
-        "repo_url": "https://github.com/anthropics/mcp-sentry",
-    },
-    {
-        "key": "google-maps",
-        "name": "Google Maps",
-        "description": "Search places, get directions, geocode addresses, and embed maps via Google Maps API.",
-        "category": "integrations",
-        "icon": "🗺️",
-        "transport": "stdio",
-        "command": "npx",
-        "args": ["-y", "@anthropic/mcp-google-maps"],
-        "env": {"GOOGLE_MAPS_API_KEY": ""},
-        "install_hint": "Set GOOGLE_MAPS_API_KEY, then: npx -y @anthropic/mcp-google-maps",
-        "repo_url": "https://github.com/anthropics/mcp-google-maps",
-    },
-    {
-        "key": "time",
-        "name": "Time / Timezone",
-        "description": "Get current time in any timezone. Convert between timezones and calculate time differences.",
-        "category": "utilities",
-        "icon": "⏰",
-        "transport": "stdio",
-        "command": "npx",
-        "args": ["-y", "@anthropic/mcp-time"],
-        "install_hint": "npx -y @anthropic/mcp-time",
-        "repo_url": "https://github.com/anthropics/mcp-time",
-    },
-]
-
-
-def get_available_models() -> dict[str, ModelConfig]:
-    """Return all registered models."""
-    return MODEL_REGISTRY.copy()
-
-
-def get_model_config(model_key: str) -> ModelConfig | None:
-    """Get a model config by key."""
-    return MODEL_REGISTRY.get(model_key)
-
-
-def load_settings(project_dir: Path | None = None) -> Settings:
-    """Load settings with hierarchical cascading.
-
-    Priority (highest → lowest):
-    1. Environment variables
-    2. .sonicoder/settings.local.json (local overrides, gitignored)
-    3. .sonicoder/settings.json (project settings)
-    4. Defaults
-    """
-    settings = Settings()
-
-    search_dirs = [Path.cwd()]
-    if project_dir:
-        search_dirs.insert(0, project_dir)
-
-    # Load project-level settings
-    for d in search_dirs:
-        local_path = d / CONFIG_DIR / "settings.local.json"
-        proj_path = d / CONFIG_DIR / "settings.json"
-
-        for path in [local_path, proj_path]:
-            if path.exists():
-                try:
-                    data = json.loads(path.read_text(encoding="utf-8"))
-                    # Parse MCP server configs
-                    if "mcp_servers" in data:
-                        data["mcp_servers"] = [
-                            MCPServerConfig(**s) for s in data["mcp_servers"]
-                        ]
-                    if "policy_rules" in data:
-                        data["policy_rules"] = [
-                            PolicyRule(**r) for r in data["policy_rules"]
-                        ]
-                    settings = settings.merge(Settings.from_dict(data))
-                except (json.JSONDecodeError, TypeError) as e:
-                    print(f"[config] Warning: Failed to parse {path}: {e}")
-
-    # Environment variable overrides
-    env_model = os.environ.get("SONICODER_MODEL")
-    if env_model and env_model in MODEL_REGISTRY:
-        settings.default_model = env_model
-
-    env_temp = os.environ.get("SONICODER_TEMPERATURE")
-    if env_temp:
-        try:
-            settings.temperature = float(env_temp)
-        except ValueError:
-            pass
-
-    return settings

sonicoder/context/__init__.py

@@ -1,154 +0,0 @@
-"""Context window manager — conversation history with compression.
-
-Inspired by Gemini CLI's graph-based context pipeline and Claude Code's auto-compaction.
-For 1B models, context window is small (~32K tokens), so compression is critical.
-"""
-
-from __future__ import annotations
-
-import logging
-from dataclasses import dataclass, field
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class ContextNode:
-    """A single node in the context graph."""
-    role: str  # "user" | "assistant" | "tool" | "system"
-    content: str
-    tokens: int = 0
-    compressed: bool = False
-    protected: bool = False  # Can't be GC'd
-    turn_index: int = 0
-
-
-class ContextManager:
-    """Manages conversation context within a token budget.
-
-    Strategies (inspired by both Gemini CLI and Claude Code):
-    1. Clear old tool outputs first (biggest token consumers)
-    2. Compress old conversation turns
-    3. Protect recent turns and system messages
-    4. Lazy tool schema loading (deferred definitions like Claude Code)
-    """
-
-    def __init__(self, max_tokens: int = 32768, auto_compact: bool = True):
-        self.max_tokens = max_tokens
-        self.auto_compact = auto_compact
-        self._nodes: list[ContextNode] = []
-        self._turn_count = 0
-
-    def add_message(self, role: str, content: str, protected: bool = False) -> None:
-        """Add a message to the context."""
-        tokens = self._estimate_tokens(content)
-        node = ContextNode(
-            role=role,
-            content=content,
-            tokens=tokens,
-            protected=protected,
-            turn_index=self._turn_count,
-        )
-        self._nodes.append(node)
-        if role == "user":
-            self._turn_count += 1
-
-    def get_messages(self) -> list[dict[str, str]]:
-        """Get all messages for the LLM, with auto-compaction if needed."""
-        if self.auto_compact:
-            self._maybe_compact()
-
-        return [
-            {"role": n.role, "content": n.content}
-            for n in self._nodes
-            if n.content  # Skip empty nodes
-        ]
-
-    def total_tokens(self) -> int:
-        """Estimate total tokens in context."""
-        return sum(n.tokens for n in self._nodes)
-
-    def clear(self) -> None:
-        """Clear all context."""
-        self._nodes.clear()
-        self._turn_count = 0
-
-    def _maybe_compact(self) -> None:
-        """Auto-compact if over budget."""
-        total = self.total_tokens()
-        if total <= self.max_tokens:
-            return
-
-        logger.info(f"Context over budget ({total} > {self.max_tokens}). Compacting...")
-
-        # Phase 1: Remove old tool results (biggest savings)
-        budget_remaining = self.max_tokens * 0.8  # Target 80% utilization
-        for node in self._nodes:
-            if self.total_tokens() <= budget_remaining:
-                break
-            if node.role == "tool" and not node.protected:
-                # Compress tool output
-                if len(node.content) > 200:
-                    node.content = node.content[:200] + f"\n... [truncated, was {len(node.content)} chars]"
-                    node.tokens = self._estimate_tokens(node.content)
-                    node.compressed = True
-
-        # Phase 2: Summarize old conversation turns
-        if self.total_tokens() > self.max_tokens:
-            # Find oldest non-protected assistant/user pairs to compress
-            pairs = self._find_compactable_pairs()
-            for user_node, assistant_node in pairs:
-                if self.total_tokens() <= budget_remaining:
-                    break
-                # Replace with summary
-                summary = self._summarize_pair(user_node, assistant_node)
-                user_node.content = summary
-                user_node.tokens = self._estimate_tokens(summary)
-                user_node.compressed = True
-                # Remove assistant node
-                self._nodes.remove(assistant_node)
-
-        # Phase 3: If still over budget, remove oldest non-protected nodes
-        if self.total_tokens() > self.max_tokens:
-            to_remove = []
-            for node in self._nodes:
-                if not node.protected and not node.compressed:
-                    to_remove.append(node)
-                    if self.total_tokens() - sum(n.tokens for n in to_remove) <= budget_remaining:
-                        break
-            for node in to_remove:
-                self._nodes.remove(node)
-
-        logger.info(f"Compaction done. Context now ~{self.total_tokens()} tokens")
-
-    def _find_compactable_pairs(self) -> list[tuple[ContextNode, ContextNode]]:
-        """Find user+assistant pairs that can be compressed."""
-        pairs = []
-        i = 0
-        while i < len(self._nodes) - 1:
-            if (self._nodes[i].role == "user" and
-                self._nodes[i + 1].role == "assistant" and
-                not self._nodes[i].protected):
-                pairs.append((self._nodes[i], self._nodes[i + 1]))
-                i += 2
-            else:
-                i += 1
-        return pairs
-
-    def _summarize_pair(self, user: ContextNode, assistant: ContextNode) -> str:
-        """Create a brief summary of a conversation pair."""
-        u_preview = user.content[:100].replace("\n", " ")
-        a_preview = assistant.content[:150].replace("\n", " ")
-        return f"[Earlier: User asked about '{u_preview}...' and assistant responded with '{a_preview}...']"
-
-    @staticmethod
-    def _estimate_tokens(text: str) -> int:
-        """Rough token estimation (1 token ~ 4 chars for code, ~3.5 for English)."""
-        if not text:
-            return 0
-        # Detect if mostly code
-        code_chars = sum(1 for c in text if c in " \t{}[]();:=<>+-*/!&|\\")
-        ratio = code_chars / max(len(text), 1)
-        chars_per_token = 3.5 + ratio * 1.5  # 3.5 for English, 5 for code
-        return int(len(text) / chars_per_token)

sonicoder/model/inference.py

@@ -1,224 +0,0 @@
-"""Streaming inference engine — supports both text and VLM models.
-
-Optimized for 1B models with proper streaming via TextIteratorStreamer.
-"""
-
-from __future__ import annotations
-
-import logging
-import re
-import threading
-from typing import Any, Generator
-
-from transformers import TextIteratorStreamer
-
-from ..config import MODEL_REGISTRY
-from .loader import get_model_and_tokenizer, get_model_status
-
-logger = logging.getLogger(__name__)
-
-# ── Regex Patterns ─────────────────────────────────────────────────────
-
-THINKING_BLOCK_RE = re.compile(r"<think>(.*?)</think>", re.DOTALL)
-CODE_BLOCK_RE = re.compile(r"```(\w*)\n(.*?)```", re.DOTALL)
-FILE_BLOCK_RE = re.compile(r"@@FILE:(.+?)@@\n(.*?)@@END@@", re.DOTALL)
-TOOL_CALL_RE = re.compile(r"```tool\s*\n(.*?)```", re.DOTALL)
-
-
-def _build_text_prompt(messages: list[dict[str, str]], system_prompt: str) -> str:
-    """Build a chat-style prompt for text models.
-
-    Uses a simple but effective template that works well with Qwen and DeepSeek models.
-    """
-    parts = [f"System: {system_prompt}\n"]
-
-    for msg in messages:
-        role = msg.get("role", "user")
-        content = msg.get("content", "")
-        if role == "system":
-            parts.append(f"System: {content}\n")
-        elif role == "user":
-            parts.append(f"User: {content}\n")
-        elif role == "assistant":
-            parts.append(f"Assistant: {content}\n")
-        elif role == "tool":
-            parts.append(f"Tool Result: {content}\n")
-
-    parts.append("Assistant:")
-    return "\n".join(parts)
-
-
-def call_model_stream(
-    messages: list[dict[str, str]],
-    system_prompt: str = "",
-    max_new_tokens: int = 4096,
-    temperature: float = 0.35,
-    image_url: str | None = None,
-) -> Generator[str, None, None]:
-    """Stream tokens from the model.
-
-    Yields partial text strings as they're generated.
-    Falls back to non-streaming if TextIteratorStreamer isn't available.
-    """
-    status = get_model_status()
-    if status["status"] != "ready":
-        raise RuntimeError(f"Model not ready: {status}")
-
-    model_key = status["model_key"]
-    config = MODEL_REGISTRY[model_key]
-
-    if config.model_type == "vlm" and image_url:
-        yield from _call_vlm_stream(messages, system_prompt, max_new_tokens, temperature, image_url)
-    else:
-        yield from _call_text_stream(messages, system_prompt, max_new_tokens, temperature)
-
-
-def _call_text_stream(
-    messages: list[dict[str, str]],
-    system_prompt: str,
-    max_new_tokens: int,
-    temperature: float,
-) -> Generator[str, None, None]:
-    """Stream from a text-only model."""
-    model, tokenizer = get_model_and_tokenizer()
-
-    prompt = _build_text_prompt(messages, system_prompt)
-    inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=32768)
-    inputs = {k: v.to(model.device) for k, v in inputs.items()}
-
-    # Try streaming first
-    try:
-        streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
-
-        generation_kwargs = {
-            **inputs,
-            "max_new_tokens": max_new_tokens,
-            "temperature": temperature,
-            "do_sample": temperature > 0,
-            "top_p": 0.9,
-            "top_k": 50,
-            "repetition_penalty": 1.1,
-            "streamer": streamer,
-            "pad_token_id": tokenizer.eos_token_id,
-        }
-
-        thread = threading.Thread(
-            target=model.generate, kwargs=generation_kwargs, daemon=True
-        )
-        thread.start()
-
-        for token in streamer:
-            if token:
-                yield token
-
-        thread.join(timeout=60)
-
-    except Exception as e:
-        logger.warning(f"Streaming failed, falling back to non-streaming: {e}")
-        # Non-streaming fallback
-        with torch.no_grad():
-            outputs = model.generate(
-                **inputs,
-                max_new_tokens=max_new_tokens,
-                temperature=temperature,
-                do_sample=temperature > 0,
-                top_p=0.9,
-                top_k=50,
-                repetition_penalty=1.1,
-                pad_token_id=tokenizer.eos_token_id,
-            )
-        text = tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)
-        yield text
-
-
-def _call_vlm_stream(
-    messages: list[dict[str, str]],
-    system_prompt: str,
-    max_new_tokens: int,
-    temperature: float,
-    image_url: str,
-) -> Generator[str, None, None]:
-    """Stream from a vision-language model."""
-    import torch
-    from PIL import Image
-    import requests
-
-    model, processor = get_model_and_tokenizer()
-
-    # Build messages for VLM
-    vlm_messages = []
-    if system_prompt:
-        vlm_messages.append({"role": "system", "content": system_prompt})
-
-    for msg in messages:
-        if msg["role"] == "user" and msg is messages[-1]:
-            # Add image to last user message
-            vlm_messages.append({
-                "role": "user",
-                "content": [
-                    {"type": "image", "url": image_url},
-                    {"type": "text", "text": msg["content"]},
-                ],
-            })
-        else:
-            vlm_messages.append(msg)
-
-    # Apply chat template
-    try:
-        prompt = processor.apply_chat_template(
-            vlm_messages, tokenize=False, add_generation_prompt=True
-        )
-    except Exception:
-        prompt = _build_text_prompt(messages, system_prompt)
-
-    # Process inputs
-    image = None
-    if image_url:
-        try:
-            if image_url.startswith(("http://", "https://")):
-                resp = requests.get(image_url, timeout=10)
-                image = Image.open(__import__("io").BytesIO(resp.content)).convert("RGB")
-            else:
-                image = Image.open(image_url).convert("RGB")
-        except Exception as e:
-            logger.warning(f"Failed to load image: {e}")
-
-    inputs = processor(text=prompt, images=image, return_tensors="pt", truncation=True)
-    inputs = {k: v.to(model.device) for k, v in inputs.items()}
-
-    # Non-streaming for VLM (most 1B VLMs don't support TextIteratorStreamer well)
-    with torch.no_grad():
-        outputs = model.generate(
-            **inputs,
-            max_new_tokens=max_new_tokens,
-            temperature=temperature,
-            do_sample=temperature > 0,
-            pad_token_id=processor.tokenizer.eos_token_id if hasattr(processor, "tokenizer") else 2,
-        )
-
-    # Decode
-    if hasattr(processor, "tokenizer"):
-        text = processor.tokenizer.decode(
-            outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True
-        )
-    elif hasattr(processor, "decode"):
-        text = processor.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)
-    else:
-        text = str(outputs[0])
-
-    yield text
-
-
-def call_model_sync(
-    messages: list[dict[str, str]],
-    system_prompt: str = "",
-    max_new_tokens: int = 4096,
-    temperature: float = 0.35,
-    image_url: str | None = None,
-) -> str:
-    """Non-streaming call — collects all tokens and returns the full text."""
-    chunks = list(call_model_stream(messages, system_prompt, max_new_tokens, temperature, image_url))
-    return "".join(chunks)
-
-
-import torch

sonicoder/model/loader.py

@@ -1,181 +0,0 @@
-"""Model loader — multi-model management with hot swapping.
-
-Supports multiple smart 1B models. Only one model loaded at a time
-to conserve memory (important for HF Spaces free tier).
-"""
-
-from __future__ import annotations
-
-import gc
-import logging
-import threading
-from typing import Any, Callable
-
-import torch
-from transformers import AutoConfig
-
-from ..config import MODEL_REGISTRY, ModelConfig
-
-logger = logging.getLogger(__name__)
-
-# ── Module State ───────────────────────────────────────────────────────
-
-_model = None
-_processor = None
-_tokenizer = None
-_model_key: str | None = None
-_model_loaded = False
-_model_loading = False
-_load_error: str | None = None
-_lock = threading.Lock()
-_on_status_change: list[Callable] = []
-
-
-def _get_device() -> str:
-    """Auto-detect best device."""
-    if torch.cuda.is_available():
-        return "cuda"
-    if hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
-        return "mps"
-    return "cpu"
-
-
-def _get_dtype(device: str) -> torch.dtype:
-    """Select dtype based on device."""
-    return torch.float16 if device == "cuda" else torch.float32
-
-
-def _unload_model() -> None:
-    """Unload current model and free memory."""
-    global _model, _processor, _tokenizer, _model_loaded
-    if _model is not None:
-        del _model
-        _model = None
-    if _processor is not None:
-        del _processor
-        _processor = None
-    if _tokenizer is not None:
-        del _tokenizer
-        _tokenizer = None
-    _model_loaded = False
-    gc.collect()
-    if torch.cuda.is_available():
-        torch.cuda.empty_cache()
-
-
-def load_model(model_key: str) -> None:
-    """Load a model by key. Blocks until loaded."""
-    global _model, _processor, _tokenizer, _model_key, _model_loaded, _model_loading, _load_error
-
-    config_entry = MODEL_REGISTRY.get(model_key)
-    if not config_entry:
-        raise ValueError(f"Unknown model: {model_key}. Available: {list(MODEL_REGISTRY.keys())}")
-
-    with _lock:
-        if _model_key == model_key and _model_loaded:
-            return  # Already loaded
-
-        _model_loading = True
-        _load_error = None
-        _notify_status()
-
-        try:
-            _unload_model()
-
-            device = _get_device()
-            dtype = _get_dtype(device)
-            logger.info(f"Loading {config_entry.name} ({config_entry.model_id}) on {device} ({dtype})...")
-
-            model_kwargs = {
-                "trust_remote_code": config_entry.trust_remote_code,
-                "low_cpu_mem_usage": True,
-                "dtype": dtype,
-            }
-
-            if device == "cuda":
-                model_kwargs["device_map"] = "auto"
-            else:
-                model_kwargs["device_map"] = None
-
-            if config_entry.model_type == "vlm":
-                from transformers import AutoModelForImageTextToText, AutoProcessor
-                _model = AutoModelForImageTextToText.from_pretrained(
-                    config_entry.model_id, **model_kwargs
-                )
-                _processor = AutoProcessor.from_pretrained(
-                    config_entry.model_id, trust_remote_code=True
-                )
-                _tokenizer = None
-            else:
-                from transformers import AutoModelForCausalLM, AutoTokenizer
-                _model = AutoModelForCausalLM.from_pretrained(
-                    config_entry.model_id, **model_kwargs
-                )
-                _tokenizer = AutoTokenizer.from_pretrained(
-                    config_entry.model_id, trust_remote_code=True
-                )
-                _processor = None
-
-            if not device == "cuda" and hasattr(_model, "to"):
-                _model = _model.to(device)
-
-            _model.eval()
-            _model_key = model_key
-            _model_loaded = True
-            logger.info(f"Model loaded: {config_entry.name}")
-
-        except Exception as e:
-            _load_error = str(e)
-            logger.error(f"Failed to load model: {e}")
-            raise
-        finally:
-            _model_loading = False
-            _notify_status()
-
-
-def start_background_load(model_key: str | None = None) -> None:
-    """Start loading a model in a background thread."""
-    key = model_key or "qwen25-coder-1.5b"
-    t = threading.Thread(target=load_model, args=(key,), daemon=True)
-    t.start()
-
-
-def switch_model(model_key: str) -> None:
-    """Switch to a different model (loads in background)."""
-    start_background_load(model_key)
-
-
-def get_model_status() -> dict[str, Any]:
-    """Get current model status."""
-    config = MODEL_REGISTRY.get(_model_key) if _model_key else None
-    status = "error" if _load_error else ("ready" if _model_loaded else ("loading" if _model_loading else "unknown"))
-    return {
-        "status": status,
-        "model_key": _model_key,
-        "model_name": config.name if config else None,
-        "model_id": config.model_id if config else None,
-        "model_type": config.model_type if config else None,
-        "error": _load_error,
-    }
-
-
-def get_model_and_tokenizer() -> tuple:
-    """Get the current model and tokenizer/processor. Returns (model, tokenizer_or_processor)."""
-    if not _model_loaded or _model is None:
-        raise RuntimeError("Model not loaded")
-    return _model, _tokenizer or _processor
-
-
-def on_status_change(callback: Callable) -> None:
-    """Register a callback for model status changes."""
-    _on_status_change.append(callback)
-
-
-def _notify_status() -> None:
-    """Notify all status change listeners."""
-    status = get_model_status()
-    for cb in _on_status_change:
-        try:
-            cb(status)
-        except Exception:
-            pass

sonicoder/server/__init__.py

@@ -1,413 +0,0 @@
-"""Server routes — pure FastAPI with custom HTML frontend.
-
-Uses FastAPI directly (not gradio.Server) to guarantee our custom
-index.html is served at / without Gradio's default UI taking over.
-
-Frontend uses plain fetch() — no @gradio/client needed.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import uuid
-from pathlib import Path
-from typing import Any, Generator
-
-from fastapi import FastAPI, Request
-from fastapi.responses import HTMLResponse, StreamingResponse, JSONResponse
-
-from ..config import (
-    Settings, get_available_models, load_settings,
-    WORKSPACE_ROOT, CONFIG_DIR, MCP_CATALOG,
-)
-from ..model.loader import (
-    get_model_status, start_background_load, switch_model as switch_model_fn,
-)
-from ..tools import get_tool_registry, ToolRegistry
-from ..tools.fs import BUILTIN_TOOLS as FS_TOOLS
-from ..tools.bash import BUILTIN_TOOLS as BASH_TOOLS
-from ..tools.web import BUILTIN_TOOLS as WEB_TOOLS
-from ..tools.todos import BUILTIN_TOOLS as TODO_TOOLS
-from ..agent import AgentSession, register_builtin_tools
-from ..mcp import get_mcp_manager
-from ..policy import get_policy_engine
-
-logger = logging.getLogger(__name__)
-
-# ── Global State ───────────────────────────────────────────────────────
-
-_settings: Settings | None = None
-_registry: ToolRegistry | None = None
-_sessions: dict[str, AgentSession] = {}
-
-
-def _get_settings() -> Settings:
-    global _settings
-    if _settings is None:
-        _settings = load_settings()
-    return _settings
-
-
-def _get_registry() -> ToolRegistry:
-    global _registry
-    if _registry is None:
-        _registry = get_tool_registry()
-        register_builtin_tools(_registry)
-        settings = _get_settings()
-        _registry.set_filters(settings.enabled_tools, settings.disabled_tools)
-    return _registry
-
-
-def _get_or_create_session(session_id: str = "") -> tuple[str, AgentSession]:
-    if not session_id:
-        session_id = str(uuid.uuid4())[:12]
-    if session_id not in _sessions:
-        _sessions[session_id] = AgentSession(
-            settings=_get_settings(),
-            tool_registry=_get_registry(),
-        )
-    return session_id, _sessions[session_id]
-
-
-# ── JSON helpers ───────────────────────────────────────────────────────
-
-def _json(data) -> JSONResponse:
-    return JSONResponse(content=data if isinstance(data, dict | list) else json.loads(data))
-
-
-def _json_str(data) -> JSONResponse:
-    return JSONResponse(content=json.loads(data) if isinstance(data, str) else data)
-
-
-# ── Create App ────────────────────────────────────────────────────────
-
-def create_app():
-    """Create and return a FastAPI app with custom HTML frontend.
-
-    Uses FastAPI directly (not gradio.Server) so our custom index.html
-    is always served at / without being overridden by Gradio's routes.
-    """
-    app = FastAPI(title="SoniCoder v2", docs_url=None, redoc_url=None)
-
-    # ── Serve index.html from project root ─────────────────────────────
-
-    @app.get("/", response_class=HTMLResponse)
-    async def homepage():
-        html_path = Path(__file__).parent.parent.parent / "index.html"
-        if not html_path.exists():
-            return HTMLResponse(
-                "<h1>SoniCoder v2</h1><p>index.html not found at project root</p>",
-                status_code=500,
-            )
-        with open(html_path, "r", encoding="utf-8") as f:
-            return f.read()
-
-    # ── Config ─────────────────────────────────────────────────────────
-
-    @app.get("/api/get_config")
-    async def get_config():
-        models = get_available_models()
-        model_list = []
-        for key, config in models.items():
-            model_list.append({
-                "key": key,
-                "name": config.name,
-                "model_type": config.model_type,
-                "size_gb": config.size_gb,
-                "description": config.description,
-            })
-        return JSONResponse(content={
-            "models": model_list,
-            "default_model": _get_settings().default_model,
-            "workspace": str(WORKSPACE_ROOT),
-            "version": "2.0.0",
-        })
-
-    # ── Model status ───────────────────────────────────────────────────
-
-    @app.get("/api/model_status")
-    async def model_status():
-        return _json(get_model_status())
-
-    # ── Switch model ────────────��──────────────────────────────────────
-
-    @app.post("/api/switch_model")
-    async def switch_model(request: Request):
-        body = await request.json()
-        model_key = body.get("model_key", "")
-        switch_model_fn(model_key)
-        return JSONResponse(content={"status": "switching", "model": model_key})
-
-    # ── List models ────────────────────────────────────────────────────
-
-    @app.get("/api/list_models")
-    async def list_models():
-        models = get_available_models()
-        current = get_model_status().get("model_key", "")
-        result = []
-        for key, config in models.items():
-            result.append({
-                "key": key,
-                "name": config.name,
-                "model_type": config.model_type,
-                "size_gb": config.size_gb,
-                "description": config.description,
-                "current": key == current,
-            })
-        return JSONResponse(content=result)
-
-    # ── Workspace tree ─────────────────────────────────────────────────
-
-    @app.get("/api/workspace_tree")
-    async def workspace_tree(max_depth: int = 3):
-        tree = []
-
-        def walk(path: Path, prefix: str = "", depth: int = 0):
-            if depth >= max_depth:
-                return
-            try:
-                items = sorted(path.iterdir(), key=lambda p: (not p.is_dir(), p.name.lower()))
-            except PermissionError:
-                return
-            skip = {".git", "node_modules", "__pycache__", ".venv", "venv", "dist", "build", ".sonicoder"}
-            for i, item in enumerate(items):
-                if item.name.startswith(".") or item.name in skip:
-                    continue
-                is_last = i == len(items) - 1
-                connector = "\u2514\u2500\u2500 " if is_last else "\u251c\u2500\u2500 "
-                if item.is_dir():
-                    tree.append(f"{prefix}{connector}{item.name}/")
-                    extension = "    " if is_last else "\u2502   "
-                    walk(item, prefix + extension, depth + 1)
-                else:
-                    tree.append(f"{prefix}{connector}{item.name}")
-
-        if WORKSPACE_ROOT.exists():
-            walk(WORKSPACE_ROOT)
-
-        return JSONResponse(content={
-            "tree": "\n".join(tree) if tree else "(empty workspace)",
-            "root": str(WORKSPACE_ROOT),
-        })
-
-    # ── Workspace read ─────────────────────────────────────────────────
-
-    @app.post("/api/workspace_read")
-    async def workspace_read(request: Request):
-        body = await request.json()
-        path = body.get("path", "")
-        offset = body.get("offset", 1)
-        limit = body.get("limit", 500)
-        from ..tools.fs import _resolve_safe
-        try:
-            resolved = _resolve_safe(path)
-            if not resolved.exists():
-                return JSONResponse(content={"error": f"File not found: {path}"})
-            content = resolved.read_text(encoding="utf-8", errors="replace")
-            lines = content.splitlines()
-            total = len(lines)
-            start = max(0, offset - 1)
-            end = min(total, start + limit)
-            selected = lines[start:end]
-            numbered = [f"  {i + start + 1:>6}\t{line}" for i, line in enumerate(selected)]
-            return JSONResponse(content={
-                "content": "\n".join(numbered),
-                "total_lines": total,
-                "truncated": end < total,
-            })
-        except Exception as e:
-            return JSONResponse(content={"error": str(e)})
-
-    # ── Workspace write ────────────────────────────────────────────────
-
-    @app.post("/api/workspace_write")
-    async def workspace_write(request: Request):
-        body = await request.json()
-        path = body.get("path", "")
-        content = body.get("content", "")
-        from ..tools.fs import _resolve_safe
-        try:
-            resolved = _resolve_safe(path)
-            resolved.parent.mkdir(parents=True, exist_ok=True)
-            resolved.write_text(content, encoding="utf-8")
-            return JSONResponse(content={"success": True, "path": path})
-        except Exception as e:
-            return JSONResponse(content={"error": str(e)})
-
-    # ── Workspace bash ─────────────────────────────────────────────────
-
-    @app.post("/api/workspace_bash")
-    async def workspace_bash(request: Request):
-        body = await request.json()
-        command = body.get("command", "")
-        from ..tools.bash import BashBuilder
-        builder = BashBuilder()
-        errors = builder.validate({"command": command})
-        if errors:
-            return JSONResponse(content={"error": "; ".join(errors)})
-        invocation = builder.create_invocation({"command": command})
-        result = invocation.execute()
-        return JSONResponse(content=result.to_dict())
-
-    # ── Web search ─────────────────────────────────────────────────────
-
-    @app.post("/api/web_search")
-    async def web_search(request: Request):
-        body = await request.json()
-        query = body.get("query", "")
-        from ..tools.web import WebSearchBuilder
-        builder = WebSearchBuilder()
-        invocation = builder.create_invocation({"query": query})
-        result = invocation.execute()
-        return JSONResponse(content=result.to_dict())
-
-    # ── MCP status ─────────────────────────────────────────────────────
-
-    @app.get("/api/mcp_status")
-    async def mcp_status():
-        return _json(get_mcp_manager().get_status())
-
-    # ── MCP catalog (available servers to enable) ──────────────────────
-
-    @app.get("/api/mcp_catalog")
-    async def mcp_catalog():
-        """Return all available MCP servers from the catalog, with their current status."""
-        manager = get_mcp_manager()
-        status = manager.get_status()
-        catalog = []
-        for server in MCP_CATALOG:
-            key = server["key"]
-            s = status.get(key, {"connected": False, "tool_count": 0})
-            catalog.append({
-                "key": key,
-                "name": server["name"],
-                "description": server["description"],
-                "category": server["category"],
-                "icon": server.get("icon", ""),
-                "transport": server["transport"],
-                "command": server.get("command", ""),
-                "args": server.get("args", []),
-                "connected": s.get("connected", False),
-                "enabled": key in status,
-                "tool_count": s.get("tool_count", 0),
-                "install_hint": server.get("install_hint", ""),
-                "repo_url": server.get("repo_url", ""),
-            })
-        return JSONResponse(content={"servers": catalog})
-
-    # ── MCP toggle (enable/disable a server) ───────────────────────────
-
-    @app.post("/api/mcp_toggle")
-    async def mcp_toggle(request: Request):
-        body = await request.json()
-        server_key = body.get("server_key", "")
-        enabled = body.get("enabled", False)
-
-        # Find in catalog
-        server_cfg = None
-        for s in MCP_CATALOG:
-            if s["key"] == server_key:
-                server_cfg = s
-                break
-
-        if not server_cfg:
-            return JSONResponse(content={"error": f"Unknown MCP server: {server_key}"})
-
-        manager = get_mcp_manager()
-
-        if not enabled:
-            # Disable: remove from manager
-            manager.remove_server(server_key)
-            return JSONResponse(content={"status": "disabled", "server": server_key})
-        else:
-            # Enable: add and connect
-            from ..config import MCPServerConfig
-            config = MCPServerConfig(
-                name=server_key,
-                transport=server_cfg["transport"],
-                command=server_cfg.get("command"),
-                args=server_cfg.get("args", []),
-                env=server_cfg.get("env", {}),
-                enabled=True,
-            )
-            manager.add_server(config)
-            error = None
-            if config.transport == "stdio" and config.command:
-                try:
-                    error = manager.connect_all().get(server_key)
-                except Exception as e:
-                    error = str(e)
-            return JSONResponse(content={
-                "status": "enabled" if not error else "error",
-                "server": server_key,
-                "error": error,
-            })
-
-    # ── MCP connect all ────────────────────────────────────────────────
-
-    @app.post("/api/mcp_connect_all")
-    async def mcp_connect_all():
-        manager = get_mcp_manager()
-        results = manager.connect_all()
-        return JSONResponse(content={"results": results})
-
-    # ── Policy status ──────────────────────────────────────────────────
-
-    @app.get("/api/policy_status")
-    async def policy_status():
-        engine = get_policy_engine()
-        return JSONResponse(content={"mode": engine.approval_mode, "rules": engine.get_rules()})
-
-    # ── Reset session ──────────────────────────────────────────────────
-
-    @app.post("/api/reset_session")
-    async def reset_session(request: Request):
-        body = await request.json()
-        session_id = body.get("session_id", "")
-        if session_id in _sessions:
-            _sessions[session_id].clear_history()
-        return JSONResponse(content={"success": True})
-
-    # ── Streaming chat ─────────────────────────────────────────────────
-
-    @app.post("/chat")
-    async def chat_stream(request: Request):
-        """Streaming chat — returns newline-delimited JSON via StreamingResponse."""
-        try:
-            body = await request.json()
-        except Exception:
-            body = {}
-
-        message = body.get("message", "")
-        session_id = body.get("session_id", "")
-        image_url = body.get("image_url")
-
-        if not message or not message.strip():
-            return StreamingResponse(
-                iter([json.dumps({"type": "error", "error": "Empty message"}) + "\n"]),
-                media_type="text/event-stream",
-                headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
-            )
-
-        sid, session = _get_or_create_session(session_id)
-
-        def event_generator():
-            try:
-                for event in session.run(message, session_id=sid, image_url=image_url):
-                    yield json.dumps(event, ensure_ascii=False) + "\n"
-            except Exception as e:
-                logger.error(f"Chat stream error: {e}", exc_info=True)
-                yield json.dumps({"type": "error", "error": str(e)}) + "\n"
-
-        return StreamingResponse(
-            event_generator(),
-            media_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache",
-                "X-Accel-Buffering": "no",
-                "Connection": "keep-alive",
-            },
-        )
-
-    return app

sonicoder/tools/__init__.py

@@ -1,215 +0,0 @@
-"""Tool system — ToolBuilder/ToolInvocation pattern from Gemini CLI.
-
-Every tool follows:
-  1. Define a class extending ToolBuilder
-  2. Implement get_schema(), validate(), create_invocation()
-  3. The invocation's execute() does the actual work
-  4. Register in ToolRegistry
-"""
-
-from __future__ import annotations
-
-import json
-from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Any, Callable
-
-
-# ── Tool Kinds ────────────────────────────────────────────────────────
-
-class ToolKind(Enum):
-    READ = "read"
-    WRITE = "write"
-    EDIT = "edit"
-    SHELL = "shell"
-    OTHER = "other"
-
-
-# ── Result Types ──────────────────────────────────────────────────────
-
-@dataclass
-class ToolResult:
-    """Result of a tool execution."""
-    success: bool
-    output: str = ""
-    error: str | None = None
-    metadata: dict[str, Any] = field(default_factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        d: dict[str, Any] = {"success": self.success}
-        if self.output:
-            d["output"] = self.output
-        if self.error:
-            d["error"] = self.error
-        if self.metadata:
-            d["metadata"] = self.metadata
-        return d
-
-    def to_json(self) -> str:
-        return json.dumps(self.to_dict(), ensure_ascii=False)
-
-
-# ── Tool Builder (Schema + Validation + Invocation Factory) ───────────
-
-class ToolBuilder(ABC):
-    """Base class for all tools — Gemini CLI pattern.
-
-    Tools are defined by:
-    - name: LLM-visible identifier
-    - description: What the tool does
-    - kind: READ/WRITE/EDIT/SHELL/OTHER
-    - get_schema(): JSON Schema for parameters
-    - validate(): Parameter validation
-    - create_invocation(): Factory for ToolInvocation
-    """
-
-    name: str = ""
-    description: str = ""
-    kind: ToolKind = ToolKind.OTHER
-    is_read_only: bool = False
-
-    @abstractmethod
-    def get_schema(self) -> dict[str, Any]:
-        """Return JSON Schema for this tool's parameters."""
-        ...
-
-    def get_display_name(self) -> str:
-        return self.name.replace("_", " ").title()
-
-    def get_tool_definition(self) -> dict[str, Any]:
-        """Full tool definition for the LLM."""
-        return {
-            "name": self.name,
-            "description": self.description,
-            "parameters": self.get_schema(),
-            "kind": self.kind.value,
-        }
-
-    def validate(self, params: dict[str, Any]) -> list[str]:
-        """Validate params. Returns list of error messages (empty = valid)."""
-        return []
-
-    @abstractmethod
-    def create_invocation(self, params: dict[str, Any]) -> ToolInvocation:
-        """Create an invocation with validated params."""
-        ...
-
-
-# ── Tool Invocation (Ready-to-Execute) ────────────────────────────────
-
-class ToolInvocation(ABC):
-    """A validated, ready-to-execute tool call — Gemini CLI pattern."""
-
-    def __init__(self, params: dict[str, Any]):
-        self.params = params
-
-    def get_description(self) -> str:
-        """Human-readable description of this invocation."""
-        return f"Execute {self.__class__.__name__}"
-
-    def get_affected_paths(self) -> list[str]:
-        """Return file paths affected by this invocation."""
-        return []
-
-    @abstractmethod
-    def execute(self) -> ToolResult:
-        """Execute the tool and return a result."""
-        ...
-
-
-# ── Tool Registry ─────────────────────────────────────────────────────
-
-class ToolRegistry:
-    """Central registry for all tools — manages discovery, filtering, and lookup.
-
-    Inspired by Gemini CLI's ToolRegistry with enable/disable support.
-    """
-
-    def __init__(self):
-        self._tools: dict[str, ToolBuilder] = {}
-        self._mcp_tools: dict[str, ToolBuilder] = {}
-        self._enabled_patterns: list[str] = ["*"]
-        self._disabled_patterns: list[str] = []
-
-    def register(self, tool: ToolBuilder) -> None:
-        """Register a built-in tool."""
-        self._tools[tool.name] = tool
-
-    def register_mcp(self, tool: ToolBuilder) -> None:
-        """Register an MCP-discovered tool (prefixed with mcp_)."""
-        self._mcp_tools[tool.name] = tool
-
-    def unregister_mcp(self, server_name: str) -> None:
-        """Unregister all MCP tools from a specific server."""
-        prefix = f"mcp_{server_name}_"
-        to_remove = [k for k in self._mcp_tools if k.startswith(prefix)]
-        for k in to_remove:
-            del self._mcp_tools[k]
-
-    def get_tool(self, name: str) -> ToolBuilder | None:
-        """Look up a tool by name."""
-        if name in self._mcp_tools:
-            return self._mcp_tools[name]
-        return self._tools.get(name)
-
-    def get_all_tools(self) -> dict[str, ToolBuilder]:
-        """Get all registered tools (built-in + MCP)."""
-        return {**self._tools, **self._mcp_tools}
-
-    def get_active_tools(self) -> dict[str, ToolBuilder]:
-        """Get tools that pass the enable/disable filters."""
-        all_tools = self.get_all_tools()
-        active = {}
-        for name, tool in all_tools.items():
-            if self._is_tool_enabled(name):
-                active[name] = tool
-        return active
-
-    def get_tool_schemas(self) -> list[dict[str, Any]]:
-        """Get schemas for all active tools (for LLM context)."""
-        active = self.get_active_tools()
-        return [tool.get_tool_definition() for tool in active.values()]
-
-    def set_filters(self, enabled: list[str], disabled: list[str]) -> None:
-        """Set enable/disable patterns."""
-        self._enabled_patterns = enabled
-        self._disabled_patterns = disabled
-
-    def _is_tool_enabled(self, name: str) -> bool:
-        """Check if a tool passes the filters."""
-        # Check explicit disable first
-        for pattern in self._disabled_patterns:
-            if self._match_pattern(name, pattern):
-                return False
-        # Check enable patterns
-        if "*" in self._enabled_patterns:
-            return True
-        for pattern in self._enabled_patterns:
-            if self._match_pattern(name, pattern):
-                return True
-        return False
-
-    @staticmethod
-    def _match_pattern(name: str, pattern: str) -> bool:
-        """Simple wildcard matching: * at start/end."""
-        if pattern == "*":
-            return True
-        if pattern.endswith("*"):
-            return name.startswith(pattern[:-1])
-        if pattern.startswith("*"):
-            return name.endswith(pattern[1:])
-        return name == pattern
-
-
-# ── Global Registry ───────────────────────────────────────────────────
-
-_global_registry: ToolRegistry | None = None
-
-
-def get_tool_registry() -> ToolRegistry:
-    """Get or create the global tool registry."""
-    global _global_registry
-    if _global_registry is None:
-        _global_registry = ToolRegistry()
-    return _global_registry

sonicoder/tools/bash.py

@@ -1,143 +0,0 @@
-"""Bash/shell execution tool — sandboxed subprocess execution.
-
-Inspired by Claude Code's Bash tool and Gemini CLI's run_shell_command.
-"""
-
-from __future__ import annotations
-
-import os
-import subprocess
-import threading
-from typing import Any
-
-from . import ToolBuilder, ToolInvocation, ToolKind, ToolResult
-
-# ── Security ───────────────────────────────────────────────────────────
-
-_BLOCKED_PATTERNS = [
-    "rm -rf /", "rm -rf ~", "rm -rf /*", "mkfs", "dd if=/dev/zero",
-    "shutdown", "reboot", "halt", "poweroff", ":(){ :|:& };:",
-    "chmod -R 777 /", "chown -R", "> /dev/sd", "mkswap",
-    "fdisk", "parted", "wipefs",
-]
-
-_SENSITIVE_ENV_VARS = [
-    "HF_TOKEN", "OPENAI_API_KEY", "ANTHROPIC_API_KEY", "GOOGLE_API_KEY",
-    "GEMINI_API_KEY", "AWS_SECRET_ACCESS_KEY", "AWS_ACCESS_KEY_ID",
-    "AZURE_API_KEY", "DEEPSEEK_API_KEY",
-]
-
-
-def _is_blocked(command: str) -> str | None:
-    """Check if command matches a blocked pattern. Returns reason or None."""
-    cmd_lower = command.strip().lower()
-    for pattern in _BLOCKED_PATTERNS:
-        if pattern in cmd_lower:
-            return f"Blocked: dangerous command pattern '{pattern}'"
-    return None
-
-
-def _scrub_env() -> dict[str, str]:
-    """Return a clean environment with sensitive vars removed."""
-    env = os.environ.copy()
-    for var in _SENSITIVE_ENV_VARS:
-        env.pop(var, None)
-    return env
-
-
-# ── Bash Tool ──────────────────────────────────────────────────────────
-
-class BashBuilder(ToolBuilder):
-    name = "bash"
-    description = (
-        "Execute a shell command in the workspace. Supports any bash command. "
-        "Commands are sandboxed and sensitive environment variables are scrubbed. "
-        "Timeout: 120 seconds by default."
-    )
-    kind = ToolKind.SHELL
-
-    def get_schema(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "command": {"type": "string", "description": "Shell command to execute"},
-                "timeout": {"type": "integer", "description": "Timeout in seconds (max 300)", "default": 120},
-            },
-            "required": ["command"],
-        }
-
-    def validate(self, params: dict[str, Any]) -> list[str]:
-        errors = []
-        if not params.get("command"):
-            errors.append("command is required")
-        blocked = _is_blocked(params.get("command", ""))
-        if blocked:
-            errors.append(blocked)
-        return errors
-
-    def create_invocation(self, params: dict[str, Any]) -> ToolInvocation:
-        return BashInvocation(params)
-
-
-class BashInvocation(ToolInvocation):
-    MAX_OUTPUT = 50000
-
-    def get_description(self) -> str:
-        cmd = self.params["command"][:80]
-        return f"Bash: {cmd}"
-
-    def execute(self) -> ToolResult:
-        command = self.params["command"]
-        timeout = min(self.params.get("timeout", 120) or 120, 300)
-
-        # Security check
-        blocked = _is_blocked(command)
-        if blocked:
-            return ToolResult(success=False, error=blocked)
-
-        workspace = os.environ.get("SONICODER_WORKSPACE", "./workspace")
-        env = _scrub_env()
-        env["SONICODER_WORKSPACE"] = workspace
-
-        try:
-            proc = subprocess.run(
-                ["bash", "-c", command],
-                capture_output=True,
-                text=True,
-                timeout=timeout,
-                cwd=workspace,
-                env=env,
-            )
-
-            stdout = proc.stdout or ""
-            stderr = proc.stderr or ""
-            combined = stdout
-            if stderr:
-                combined += ("\n--- stderr ---\n" + stderr) if stdout else stderr
-
-            # Truncate large output
-            if len(combined) > self.MAX_OUTPUT:
-                combined = combined[:self.MAX_OUTPUT] + f"\n... [truncated, total {len(proc.stdout + proc.stderr)} chars]"
-
-            if proc.returncode == 0:
-                return ToolResult(
-                    success=True,
-                    output=combined or "(no output)",
-                    metadata={"exit_code": 0},
-                )
-            else:
-                return ToolResult(
-                    success=False,
-                    output=combined,
-                    error=f"Exit code: {proc.returncode}",
-                    metadata={"exit_code": proc.returncode},
-                )
-        except subprocess.TimeoutExpired:
-            return ToolResult(success=False, error=f"Command timed out after {timeout}s")
-        except Exception as e:
-            return ToolResult(success=False, error=f"Execution error: {e}")
-
-
-# ── Register ───────────────────────────────────────────────────────────
-
-BUILTIN_TOOLS = [BashBuilder()]

sonicoder/tools/fs.py

@@ -1,508 +0,0 @@
-"""File system tools — read, write, edit, glob, grep, list_dir.
-
-Inspired by Claude Code's FileRead/FileWrite/FileEdit and Gemini CLI's file tools.
-"""
-
-from __future__ import annotations
-
-import fnmatch
-import os
-import re
-from pathlib import Path
-from typing import Any
-
-from . import ToolBuilder, ToolInvocation, ToolKind, ToolResult
-
-WORKSPACE = Path(os.environ.get("SONICODER_WORKSPACE", "./workspace")).resolve()
-
-
-def _resolve_safe(path: str) -> Path:
-    """Resolve a path and ensure it stays within the workspace sandbox."""
-    if not path:
-        path = "."
-    p = Path(path)
-    if not p.is_absolute():
-        p = WORKSPACE / p
-    try:
-        p = p.resolve()
-    except (OSError, ValueError):
-        p = WORKSPACE / path
-    # Security: must be under workspace
-    try:
-        p.relative_to(WORKSPACE)
-    except ValueError:
-        raise ValueError(f"Path '{path}' escapes workspace")
-    return p
-
-
-# ── Read File ──────────────────────────────────────────────────────────
-
-class ReadFileBuilder(ToolBuilder):
-    name = "read_file"
-    description = (
-        "Read file contents with line numbers. Supports offset/limit for pagination. "
-        "Returns content, line count, and truncation info."
-    )
-    kind = ToolKind.READ
-    is_read_only = True
-
-    def get_schema(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "path": {"type": "string", "description": "File path relative to workspace root"},
-                "offset": {"type": "integer", "description": "Start line (1-indexed)", "default": 1},
-                "limit": {"type": "integer", "description": "Max lines to return", "default": 500},
-            },
-            "required": ["path"],
-        }
-
-    def validate(self, params: dict[str, Any]) -> list[str]:
-        errors = []
-        if not params.get("path"):
-            errors.append("path is required")
-        return errors
-
-    def create_invocation(self, params: dict[str, Any]) -> ToolInvocation:
-        return ReadFileInvocation(params)
-
-
-class ReadFileInvocation(ToolInvocation):
-    def get_description(self) -> str:
-        return f"Read file: {self.params['path']}"
-
-    def get_affected_paths(self) -> list[str]:
-        return [self.params.get("path", "")]
-
-    def execute(self) -> ToolResult:
-        try:
-            path = _resolve_safe(self.params["path"])
-            if not path.exists():
-                return ToolResult(success=False, error=f"File not found: {self.params['path']}")
-            if not path.is_file():
-                return ToolResult(success=False, error=f"Not a file: {self.params['path']}")
-
-            offset = self.params.get("offset", 1) or 1
-            limit = self.params.get("limit", 500) or 500
-
-            lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
-            total = len(lines)
-            start = max(0, offset - 1)
-            end = min(total, start + limit)
-            selected = lines[start:end]
-
-            # Add line numbers
-            numbered = [f"  {i + start + 1:>6}\t{line}" for i, line in enumerate(selected)]
-            content = "\n".join(numbered)
-            truncated = end < total
-
-            meta = {"total_lines": total, "returned_lines": len(selected), "truncated": truncated}
-            if truncated:
-                meta["next_offset"] = end + 1
-
-            return ToolResult(success=True, output=content, metadata=meta)
-        except ValueError as e:
-            return ToolResult(success=False, error=str(e))
-        except Exception as e:
-            return ToolResult(success=False, error=f"Read error: {e}")
-
-
-# ── Write File ─────────────────────────────────────────────────────────
-
-class WriteFileBuilder(ToolBuilder):
-    name = "write_file"
-    description = (
-        "Write content to a file. Creates parent directories automatically. "
-        "Overwrites existing file content entirely."
-    )
-    kind = ToolKind.WRITE
-
-    def get_schema(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "path": {"type": "string", "description": "File path relative to workspace root"},
-                "content": {"type": "string", "description": "Full file content to write"},
-            },
-            "required": ["path", "content"],
-        }
-
-    def validate(self, params: dict[str, Any]) -> list[str]:
-        errors = []
-        if not params.get("path"):
-            errors.append("path is required")
-        if "content" not in params:
-            errors.append("content is required")
-        return errors
-
-    def create_invocation(self, params: dict[str, Any]) -> ToolInvocation:
-        return WriteFileInvocation(params)
-
-
-class WriteFileInvocation(ToolInvocation):
-    def get_description(self) -> str:
-        return f"Write file: {self.params['path']}"
-
-    def get_affected_paths(self) -> list[str]:
-        return [self.params.get("path", "")]
-
-    def execute(self) -> ToolResult:
-        try:
-            path = _resolve_safe(self.params["path"])
-            path.parent.mkdir(parents=True, exist_ok=True)
-            path.write_text(self.params["content"], encoding="utf-8")
-            line_count = self.params["content"].count("\n") + 1
-            return ToolResult(
-                success=True,
-                output=f"Written {line_count} lines to {self.params['path']}",
-                metadata={"path": str(path), "lines": line_count},
-            )
-        except ValueError as e:
-            return ToolResult(success=False, error=str(e))
-        except Exception as e:
-            return ToolResult(success=False, error=f"Write error: {e}")
-
-
-# ── Edit File (Search & Replace) ──────────────────────────────────────
-
-class EditFileBuilder(ToolBuilder):
-    name = "edit_file"
-    description = (
-        "Edit a file by finding exact old_string and replacing with new_string. "
-        "Claude Code pattern: exact match, not line-based diffs. "
-        "Set replace_all=true to replace every occurrence."
-    )
-    kind = ToolKind.EDIT
-
-    def get_schema(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "path": {"type": "string", "description": "File path relative to workspace root"},
-                "old_string": {"type": "string", "description": "Exact text to find"},
-                "new_string": {"type": "string", "description": "Replacement text"},
-                "replace_all": {"type": "boolean", "description": "Replace all occurrences", "default": False},
-            },
-            "required": ["path", "old_string", "new_string"],
-        }
-
-    def validate(self, params: dict[str, Any]) -> list[str]:
-        errors = []
-        if not params.get("path"):
-            errors.append("path is required")
-        if not params.get("old_string"):
-            errors.append("old_string is required")
-        if "new_string" not in params:
-            errors.append("new_string is required")
-        if params.get("old_string") == params.get("new_string"):
-            errors.append("old_string and new_string must differ")
-        return errors
-
-    def create_invocation(self, params: dict[str, Any]) -> ToolInvocation:
-        return EditFileInvocation(params)
-
-
-class EditFileInvocation(ToolInvocation):
-    def get_description(self) -> str:
-        p = self.params["path"]
-        old = self.params["old_string"][:50].replace("\n", "\\n")
-        return f"Edit {p}: '{old}...'"
-
-    def get_affected_paths(self) -> list[str]:
-        return [self.params.get("path", "")]
-
-    def execute(self) -> ToolResult:
-        try:
-            path = _resolve_safe(self.params["path"])
-            if not path.exists():
-                return ToolResult(success=False, error=f"File not found: {self.params['path']}")
-
-            content = path.read_text(encoding="utf-8")
-            old = self.params["old_string"]
-            new = self.params["new_string"]
-            replace_all = self.params.get("replace_all", False)
-
-            if old not in content:
-                # Fuzzy hint
-                return ToolResult(
-                    success=False,
-                    error=f"old_string not found in {self.params['path']}. "
-                          f"Make sure the text matches the file exactly (including whitespace).",
-                )
-
-            count = content.count(old)
-            if replace_all:
-                new_content = content.replace(old, new)
-            else:
-                if count > 1:
-                    return ToolResult(
-                        success=False,
-                        error=f"Found {count} occurrences. Use replace_all=true to replace all, "
-                              f"or make old_string more specific.",
-                    )
-                new_content = content.replace(old, new, 1)
-
-            path.write_text(new_content, encoding="utf-8")
-            return ToolResult(
-                success=True,
-                output=f"Replaced {count if replace_all else 1} occurrence(s) in {self.params['path']}",
-                metadata={"path": str(path), "replacements": count if replace_all else 1},
-            )
-        except ValueError as e:
-            return ToolResult(success=False, error=str(e))
-        except Exception as e:
-            return ToolResult(success=False, error=f"Edit error: {e}")
-
-
-# ── Glob ───────────────────────────────────────────────────────────────
-
-class GlobBuilder(ToolBuilder):
-    name = "glob"
-    description = (
-        "Find files matching a glob pattern (e.g., '**/*.py', 'src/**/*.ts'). "
-        "Searches recursively within the workspace."
-    )
-    kind = ToolKind.READ
-    is_read_only = True
-
-    def get_schema(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "pattern": {"type": "string", "description": "Glob pattern (e.g., '**/*.py')"},
-                "path": {"type": "string", "description": "Subdirectory to search in", "default": "."},
-            },
-            "required": ["pattern"],
-        }
-
-    def create_invocation(self, params: dict[str, Any]) -> ToolInvocation:
-        return GlobInvocation(params)
-
-
-class GlobInvocation(ToolInvocation):
-    def get_description(self) -> str:
-        return f"Glob: {self.params['pattern']}"
-
-    def execute(self) -> ToolResult:
-        try:
-            base = _resolve_safe(self.params.get("path", "."))
-            pattern = self.params["pattern"]
-            if not base.exists():
-                return ToolResult(success=True, output="Directory not found", metadata={"matches": []})
-
-            matches = []
-            for root, dirs, files in os.walk(base):
-                # Skip hidden and common heavy dirs
-                dirs[:] = [d for d in dirs if not d.startswith(".") and d not in
-                           ("node_modules", "__pycache__", ".venv", "venv", "dist", "build", ".git")]
-                for f in files:
-                    full = os.path.join(root, f)
-                    rel = os.path.relpath(full, WORKSPACE)
-                    if fnmatch.fnmatch(rel, pattern) or fnmatch.fnmatch(f, pattern):
-                        matches.append(rel)
-
-            matches.sort()
-            output = "\n".join(matches) if matches else "No matches found."
-            return ToolResult(success=True, output=output, metadata={"matches": matches, "count": len(matches)})
-        except ValueError as e:
-            return ToolResult(success=False, error=str(e))
-        except Exception as e:
-            return ToolResult(success=False, error=f"Glob error: {e}")
-
-
-# ── Grep ───────────────────────────────────────────────────────────────
-
-class GrepBuilder(ToolBuilder):
-    name = "grep"
-    description = (
-        "Search file contents using regex. Returns matching lines with file paths and line numbers. "
-        "Like ripgrep but simpler."
-    )
-    kind = ToolKind.READ
-    is_read_only = True
-
-    def get_schema(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "pattern": {"type": "string", "description": "Regex pattern to search for"},
-                "path": {"type": "string", "description": "Subdirectory to search in", "default": "."},
-                "include": {"type": "string", "description": "File glob to include (e.g., '*.py')"},
-                "ignore_case": {"type": "boolean", "description": "Case insensitive", "default": False},
-                "max_results": {"type": "integer", "description": "Max matches to return", "default": 50},
-            },
-            "required": ["pattern"],
-        }
-
-    def create_invocation(self, params: dict[str, Any]) -> ToolInvocation:
-        return GrepInvocation(params)
-
-
-class GrepInvocation(ToolInvocation):
-    def get_description(self) -> str:
-        return f"Grep: {self.params['pattern']}"
-
-    def execute(self) -> ToolResult:
-        try:
-            base = _resolve_safe(self.params.get("path", "."))
-            pattern = self.params["pattern"]
-            include = self.params.get("include", "*")
-            ignore_case = self.params.get("ignore_case", False)
-            max_results = self.params.get("max_results", 50) or 50
-
-            flags = re.IGNORECASE if ignore_case else 0
-            regex = re.compile(pattern, flags)
-            results = []
-            count = 0
-
-            for root, dirs, files in os.walk(base):
-                dirs[:] = [d for d in dirs if not d.startswith(".") and d not in
-                           ("node_modules", "__pycache__", ".venv", "venv", "dist", "build", ".git")]
-                for f in files:
-                    if not fnmatch.fnmatch(f, include):
-                        continue
-                    try:
-                        filepath = os.path.join(root, f)
-                        rel = os.path.relpath(filepath, WORKSPACE)
-                        lines = filepath.read_text(encoding="utf-8", errors="replace").splitlines()
-                        for i, line in enumerate(lines, 1):
-                            if regex.search(line):
-                                results.append(f"{rel}:{i}: {line.strip()}")
-                                count += 1
-                                if count >= max_results:
-                                    output = "\n".join(results)
-                                    output += f"\n\n... truncated at {max_results} matches"
-                                    return ToolResult(
-                                        success=True, output=output,
-                                        metadata={"matches": results, "count": count, "truncated": True},
-                                    )
-                    except (OSError, UnicodeDecodeError):
-                        continue
-
-            output = "\n".join(results) if results else "No matches found."
-            return ToolResult(
-                success=True, output=output,
-                metadata={"matches": results, "count": count, "truncated": False},
-            )
-        except ValueError as e:
-            return ToolResult(success=False, error=str(e))
-        except re.error as e:
-            return ToolResult(success=False, error=f"Invalid regex: {e}")
-        except Exception as e:
-            return ToolResult(success=False, error=f"Grep error: {e}")
-
-
-# ── List Directory ─────────────────────────────────────────────────────
-
-class ListDirBuilder(ToolBuilder):
-    name = "list_dir"
-    description = "List files and directories. Returns sorted listing with type indicators."
-    kind = ToolKind.READ
-    is_read_only = True
-
-    def get_schema(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "path": {"type": "string", "description": "Directory path (default: workspace root)", "default": "."},
-            },
-        }
-
-    def create_invocation(self, params: dict[str, Any]) -> ToolInvocation:
-        return ListDirInvocation(params)
-
-
-class ListDirInvocation(ToolInvocation):
-    def get_description(self) -> str:
-        return f"List dir: {self.params.get('path', '.')}"
-
-    def execute(self) -> ToolResult:
-        try:
-            path = _resolve_safe(self.params.get("path", "."))
-            if not path.exists():
-                return ToolResult(success=False, error=f"Directory not found: {self.params.get('path', '.')}")
-            if not path.is_dir():
-                return ToolResult(success=False, error=f"Not a directory: {self.params.get('path', '.')}")
-
-            entries = []
-            for item in sorted(path.iterdir()):
-                if item.name.startswith("."):
-                    continue
-                if item.is_dir():
-                    entries.append(f"  [DIR]  {item.name}/")
-                else:
-                    size = item.stat().st_size
-                    if size > 1024 * 1024:
-                        size_str = f"{size / 1024 / 1024:.1f}MB"
-                    elif size > 1024:
-                        size_str = f"{size / 1024:.1f}KB"
-                    else:
-                        size_str = f"{size}B"
-                    entries.append(f"  [FILE] {item.name}  ({size_str})")
-
-            output = "\n".join(entries) if entries else "(empty directory)"
-            return ToolResult(success=True, output=output, metadata={"entries": len(entries)})
-        except ValueError as e:
-            return ToolResult(success=False, error=str(e))
-        except Exception as e:
-            return ToolResult(success=False, error=f"List error: {e}")
-
-
-# ── Workspace Snapshot ─────────────────────────────────────────────────
-
-class SnapshotBuilder(ToolBuilder):
-    name = "snapshot_workspace"
-    description = "Get a snapshot of all workspace files and their contents. Useful for getting full project state."
-    kind = ToolKind.READ
-    is_read_only = True
-
-    def get_schema(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {},
-        }
-
-    def create_invocation(self, params: dict[str, Any]) -> ToolInvocation:
-        return SnapshotInvocation(params)
-
-
-class SnapshotInvocation(ToolInvocation):
-    SKIP_DIRS = {".git", "node_modules", "__pycache__", ".venv", "venv", "dist", "build",
-                 ".sonicoder"}
-
-    def execute(self) -> ToolResult:
-        try:
-            files = {}
-            for root, dirs, filenames in os.walk(WORKSPACE):
-                dirs[:] = [d for d in dirs if d not in self.SKIP_DIRS and not d.startswith(".")]
-                for f in filenames:
-                    if f.startswith("."):
-                        continue
-                    fp = os.path.join(root, f)
-                    rel = os.path.relpath(fp, WORKSPACE)
-                    try:
-                        files[rel] = fp if os.path.getsize(fp) > 500000 else \
-                            Path(fp).read_text(encoding="utf-8", errors="replace")
-                    except (OSError, UnicodeDecodeError):
-                        files[rel] = f"[binary file, {os.path.getsize(fp)} bytes]"
-
-            output = "\n".join(f"  {k}" for k in sorted(files.keys()))
-            return ToolResult(
-                success=True, output=output,
-                metadata={"files": files, "count": len(files)},
-            )
-        except Exception as e:
-            return ToolResult(success=False, error=f"Snapshot error: {e}")
-
-
-# ── Register All ───────────────────────────────────────────────────────
-
-BUILTIN_TOOLS = [
-    ReadFileBuilder(),
-    WriteFileBuilder(),
-    EditFileBuilder(),
-    GlobBuilder(),
-    GrepBuilder(),
-    ListDirBuilder(),
-    SnapshotBuilder(),
-]

sonicoder/tools/todos.py

@@ -1,109 +0,0 @@
-"""Todo management tool — per-session task tracking.
-
-Inspired by Claude Code's TodoWrite/TaskCreate.
-"""
-
-from __future__ import annotations
-
-import threading
-from typing import Any
-
-from . import ToolBuilder, ToolInvocation, ToolKind, ToolResult
-
-# ── In-Memory Store ────────────────────────────────────────────────────
-
-_store: dict[str, list[dict]] = {}
-_lock = threading.Lock()
-
-
-def _get_todos(session_id: str) -> list[dict]:
-    with _lock:
-        return _store.setdefault(session_id, [])
-
-
-# ── Todo Tool ──────────────────────────────────────────────────────────
-
-class TodoBuilder(ToolBuilder):
-    name = "todo"
-    description = (
-        "Manage a task todo list. Actions: 'read' (list all), 'write' (create), "
-        "'update' (change status/content), 'clear' (remove all). "
-        "Each todo has: id, content, status (pending/in_progress/completed)."
-    )
-    kind = ToolKind.OTHER
-
-    def get_schema(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "action": {
-                    "type": "string",
-                    "enum": ["read", "write", "update", "clear"],
-                    "description": "Action to perform",
-                },
-                "id": {"type": "string", "description": "Todo ID (for update)"},
-                "content": {"type": "string", "description": "Todo content (for write/update)"},
-                "status": {"type": "string", "description": "Status: pending/in_progress/completed"},
-            },
-            "required": ["action"],
-        }
-
-    def create_invocation(self, params: dict[str, Any]) -> ToolInvocation:
-        return TodoInvocation(params, session_id="")
-
-
-class TodoInvocation(ToolInvocation):
-    def __init__(self, params: dict[str, Any], session_id: str = ""):
-        super().__init__(params)
-        self.session_id = session_id
-
-    def get_description(self) -> str:
-        return f"Todo: {self.params['action']}"
-
-    def execute(self) -> ToolResult:
-        action = self.params["action"]
-        todos = _get_todos(self.session_id)
-
-        if action == "read":
-            if not todos:
-                return ToolResult(success=True, output="No todos.")
-            lines = []
-            for t in todos:
-                status_icon = {"pending": "[ ]", "in_progress": "[>]", "completed": "[x]"}.get(t["status"], "[ ]")
-                lines.append(f"  {status_icon} {t['id']}: {t['content']}")
-            return ToolResult(success=True, output="\n".join(lines), metadata={"todos": todos})
-
-        elif action == "write":
-            content = self.params.get("content", "")
-            if not content:
-                return ToolResult(success=False, error="content is required for write action")
-            new_id = str(len(todos) + 1)
-            todo = {"id": new_id, "content": content, "status": "pending"}
-            todos.append(todo)
-            return ToolResult(success=True, output=f"Added todo {new_id}: {content}", metadata={"todo": todo})
-
-        elif action == "update":
-            tid = self.params.get("id", "")
-            if not tid:
-                return ToolResult(success=False, error="id is required for update action")
-            for t in todos:
-                if t["id"] == tid:
-                    if "content" in self.params and self.params["content"]:
-                        t["content"] = self.params["content"]
-                    if "status" in self.params and self.params["status"]:
-                        if self.params["status"] not in ("pending", "in_progress", "completed"):
-                            return ToolResult(success=False, error="Invalid status")
-                        t["status"] = self.params["status"]
-                    return ToolResult(success=True, output=f"Updated todo {tid}", metadata={"todo": t})
-            return ToolResult(success=False, error=f"Todo {tid} not found")
-
-        elif action == "clear":
-            todos.clear()
-            return ToolResult(success=True, output="All todos cleared.")
-
-        return ToolResult(success=False, error=f"Unknown action: {action}")
-
-
-# ── Register ───────────────────────────────────────────────────────────
-
-BUILTIN_TOOLS = [TodoBuilder()]

sonicoder/tools/web.py

@@ -1,163 +0,0 @@
-"""Web tools — search and fetch.
-
-Inspired by Claude Code's WebSearch/WebFetch and Gemini CLI's google_web_search/web_fetch.
-No API keys needed — uses HTML scraping like original SoniCoder.
-"""
-
-from __future__ import annotations
-
-import re
-from typing import Any
-from urllib.parse import quote_plus, urljoin
-
-import requests
-from bs4 import BeautifulSoup
-
-from . import ToolBuilder, ToolInvocation, ToolKind, ToolResult
-
-HEADERS = {
-    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
-                  "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
-}
-
-
-# ── Web Search ─────────────────────────────────────────────────────────
-
-class WebSearchBuilder(ToolBuilder):
-    name = "web_search"
-    description = (
-        "Search the web using DuckDuckGo. No API key needed. "
-        "Returns numbered results with titles, URLs, and snippets."
-    )
-    kind = ToolKind.OTHER
-    is_read_only = True
-
-    def get_schema(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "query": {"type": "string", "description": "Search query"},
-                "max_results": {"type": "integer", "description": "Max results (default 8)", "default": 8},
-            },
-            "required": ["query"],
-        }
-
-    def create_invocation(self, params: dict[str, Any]) -> ToolInvocation:
-        return WebSearchInvocation(params)
-
-
-class WebSearchInvocation(ToolInvocation):
-    def get_description(self) -> str:
-        return f"Web search: {self.params['query'][:60]}"
-
-    def execute(self) -> ToolResult:
-        query = self.params["query"]
-        max_results = self.params.get("max_results", 8) or 8
-
-        try:
-            # DuckDuckGo HTML search
-            url = f"https://html.duckduckgo.com/html/?q={quote_plus(query)}"
-            resp = requests.get(url, headers=HEADERS, timeout=15)
-            resp.raise_for_status()
-
-            soup = BeautifulSoup(resp.text, "html.parser")
-            results = []
-
-            for result in soup.select(".result"):
-                title_el = result.select_one(".result__title a, .result__a")
-                snippet_el = result.select_one(".result__snippet")
-                if title_el:
-                    title = title_el.get_text(strip=True)
-                    href = title_el.get("href", "")
-                    # Clean DuckDuckGo redirect URL
-                    if "uddg=" in href:
-                        import urllib.parse
-                        parsed = urllib.parse.parse_qs(urllib.parse.urlparse(href).query)
-                        href = parsed.get("uddg", [href])[0]
-                    snippet = snippet_el.get_text(strip=True) if snippet_el else ""
-                    results.append(f"{len(results) + 1}. {title}\n   {href}\n   {snippet}")
-                    if len(results) >= max_results:
-                        break
-
-            if not results:
-                return ToolResult(success=True, output="No results found.", metadata={"results": []})
-
-            output = "\n\n".join(results)
-            return ToolResult(
-                success=True, output=output,
-                metadata={"results": results, "count": len(results)},
-            )
-        except requests.RequestException as e:
-            return ToolResult(success=False, error=f"Search failed: {e}")
-        except Exception as e:
-            return ToolResult(success=False, error=f"Search error: {e}")
-
-
-# ── Web Fetch ──────────────────────────────────────────────────────────
-
-class WebFetchBuilder(ToolBuilder):
-    name = "web_fetch"
-    description = (
-        "Fetch and extract text content from a URL. "
-        "Returns the main text content (strips HTML tags, scripts, styles)."
-    )
-    kind = ToolKind.OTHER
-    is_read_only = True
-
-    def get_schema(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "url": {"type": "string", "description": "URL to fetch"},
-            },
-            "required": ["url"],
-        }
-
-    def create_invocation(self, params: dict[str, Any]) -> ToolInvocation:
-        return WebFetchInvocation(params)
-
-
-class WebFetchInvocation(ToolInvocation):
-    MAX_CONTENT = 30000
-
-    def get_description(self) -> str:
-        return f"Fetch: {self.params['url'][:80]}"
-
-    def execute(self) -> ToolResult:
-        url = self.params["url"]
-        if not url.startswith(("http://", "https://")):
-            url = "https://" + url
-
-        try:
-            resp = requests.get(url, headers=HEADERS, timeout=20)
-            resp.raise_for_status()
-
-            soup = BeautifulSoup(resp.text, "html.parser")
-
-            # Remove scripts, styles, nav, footer
-            for tag in soup.select("script, style, nav, footer, header, aside, iframe"):
-                tag.decompose()
-
-            # Extract text
-            text = soup.get_text(separator="\n", strip=True)
-
-            # Clean up whitespace
-            lines = [line.strip() for line in text.splitlines() if line.strip()]
-            text = "\n".join(lines)
-
-            if len(text) > self.MAX_CONTENT:
-                text = text[:self.MAX_CONTENT] + f"\n... [truncated at {self.MAX_CONTENT} chars]"
-
-            return ToolResult(
-                success=True, output=text,
-                metadata={"url": url, "chars": len(text), "title": soup.title.string if soup.title else ""},
-            )
-        except requests.RequestException as e:
-            return ToolResult(success=False, error=f"Fetch failed: {e}")
-        except Exception as e:
-            return ToolResult(success=False, error=f"Fetch error: {e}")
-
-
-# ── Register ───────────────────────────────────────────────────────────
-
-BUILTIN_TOOLS = [WebSearchBuilder(), WebFetchBuilder()]

static/index.html

@@ -1,568 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>SoniCoder v2 — AI Code Agent</title>
-<style>
-  :root {
-    --bg-primary: #0f0f13;
-    --bg-secondary: #16161d;
-    --bg-tertiary: #1e1e2a;
-    --bg-hover: #252535;
-    --text-primary: #e4e4f0;
-    --text-secondary: #9393a8;
-    --text-muted: #6b6b80;
-    --accent: #7c6ef0;
-    --accent-hover: #6b5de0;
-    --accent-light: rgba(124,110,240,0.12);
-    --success: #4ade80;
-    --warning: #fbbf24;
-    --error: #f87171;
-    --info: #60a5fa;
-    --border: #2a2a3a;
-    --code-bg: #1a1a28;
-    --radius: 12px;
-    --radius-sm: 8px;
-    --shadow: 0 4px 24px rgba(0,0,0,0.4);
-  }
-  * { margin:0; padding:0; box-sizing:border-box; }
-  body { font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; background:var(--bg-primary); color:var(--text-primary); height:100vh; overflow:hidden; }
-  
-  /* Layout */
-  .app { display:flex; height:100vh; }
-  .sidebar { width:280px; background:var(--bg-secondary); border-right:1px solid var(--border); display:flex; flex-direction:column; flex-shrink:0; }
-  .main { flex:1; display:flex; flex-direction:column; min-width:0; }
-  .workspace-panel { width:300px; background:var(--bg-secondary); border-left:1px solid var(--border); display:flex; flex-direction:column; flex-shrink:0; transition:width 0.3s; overflow:hidden; }
-  .workspace-panel.collapsed { width:0; border-left:none; }
-
-  /* Sidebar */
-  .sidebar-header { padding:20px; border-bottom:1px solid var(--border); }
-  .logo { font-size:20px; font-weight:700; background:linear-gradient(135deg, #7c6ef0, #a78bfa, #60a5fa); -webkit-background-clip:text; -webkit-text-fill-color:transparent; }
-  .logo-sub { font-size:11px; color:var(--text-muted); margin-top:2px; letter-spacing:1px; text-transform:uppercase; }
-  .model-selector { padding:16px 20px; border-bottom:1px solid var(--border); }
-  .model-selector label { font-size:11px; color:var(--text-muted); text-transform:uppercase; letter-spacing:0.5px; display:block; margin-bottom:8px; }
-  .model-selector select { width:100%; padding:8px 12px; background:var(--bg-tertiary); color:var(--text-primary); border:1px solid var(--border); border-radius:var(--radius-sm); font-size:13px; cursor:pointer; outline:none; }
-  .model-selector select:focus { border-color:var(--accent); }
-  .model-status { padding:8px 20px; border-bottom:1px solid var(--border); }
-  .status-dot { display:inline-block; width:8px; height:8px; border-radius:50%; margin-right:6px; }
-  .status-dot.ready { background:var(--success); box-shadow:0 0 6px var(--success); }
-  .status-dot.loading { background:var(--warning); animation:pulse 1.5s infinite; }
-  .status-dot.error { background:var(--error); }
-  .status-dot.unknown { background:var(--text-muted); }
-  @keyframes pulse { 0%,100%{opacity:1} 50%{opacity:0.4} }
-  .status-text { font-size:12px; color:var(--text-secondary); }
-  
-  .sidebar-section { padding:16px 20px; }
-  .sidebar-section h3 { font-size:11px; color:var(--text-muted); text-transform:uppercase; letter-spacing:0.5px; margin-bottom:12px; }
-  .sidebar-info { font-size:12px; color:var(--text-secondary); line-height:1.6; }
-  .sidebar-info code { background:var(--bg-tertiary); padding:2px 6px; border-radius:4px; font-size:11px; color:var(--accent); }
-
-  .new-chat-btn { margin:16px 20px; padding:10px; background:var(--accent); color:white; border:none; border-radius:var(--radius-sm); font-size:13px; font-weight:600; cursor:pointer; transition:all 0.2s; }
-  .new-chat-btn:hover { background:var(--accent-hover); transform:translateY(-1px); }
-
-  /* Chat Area */
-  .chat-header { padding:16px 24px; border-bottom:1px solid var(--border); display:flex; align-items:center; justify-content:space-between; }
-  .chat-header h2 { font-size:15px; font-weight:600; }
-  .header-actions { display:flex; gap:8px; }
-  .header-btn { padding:6px 12px; background:var(--bg-tertiary); color:var(--text-secondary); border:1px solid var(--border); border-radius:var(--radius-sm); font-size:12px; cursor:pointer; transition:all 0.2s; }
-  .header-btn:hover { background:var(--bg-hover); color:var(--text-primary); }
-
-  .chat-messages { flex:1; overflow-y:auto; padding:24px; scroll-behavior:smooth; }
-  .chat-messages::-webkit-scrollbar { width:6px; }
-  .chat-messages::-webkit-scrollbar-track { background:transparent; }
-  .chat-messages::-webkit-scrollbar-thumb { background:var(--border); border-radius:3px; }
-
-  .message { margin-bottom:24px; animation:fadeIn 0.3s ease; }
-  @keyframes fadeIn { from{opacity:0;transform:translateY(8px)} to{opacity:1;transform:translateY(0)} }
-  .message-header { display:flex; align-items:center; gap:8px; margin-bottom:8px; }
-  .message-avatar { width:28px; height:28px; border-radius:8px; display:flex; align-items:center; justify-content:center; font-size:13px; font-weight:700; }
-  .message-avatar.user { background:var(--accent); color:white; }
-  .message-avatar.agent { background:var(--bg-tertiary); color:var(--accent); border:1px solid var(--border); }
-  .message-role { font-size:13px; font-weight:600; }
-  .message-time { font-size:11px; color:var(--text-muted); }
-
-  .message-body { padding-left:36px; line-height:1.7; font-size:14px; color:var(--text-primary); }
-  .message-body p { margin-bottom:8px; }
-  .message-body code { background:var(--code-bg); padding:2px 6px; border-radius:4px; font-size:13px; font-family:'JetBrains Mono','Fira Code',monospace; }
-  .message-body pre { background:var(--code-bg); padding:16px; border-radius:var(--radius-sm); overflow-x:auto; margin:12px 0; border:1px solid var(--border); }
-  .message-body pre code { background:none; padding:0; font-size:13px; line-height:1.5; }
-  .message-body ul, .message-body ol { padding-left:20px; margin:8px 0; }
-  .message-body li { margin:4px 0; }
-
-  /* Tool Calls */
-  .tool-call { background:var(--bg-tertiary); border:1px solid var(--border); border-radius:var(--radius-sm); margin:12px 0; padding:12px 16px; }
-  .tool-call-header { display:flex; align-items:center; gap:8px; margin-bottom:8px; }
-  .tool-icon { font-size:14px; }
-  .tool-name { font-size:13px; font-weight:600; color:var(--accent); }
-  .tool-status { font-size:11px; padding:2px 8px; border-radius:10px; font-weight:600; }
-  .tool-status.success { background:rgba(74,222,128,0.12); color:var(--success); }
-  .tool-status.error { background:rgba(248,113,113,0.12); color:var(--error); }
-  .tool-status.running { background:rgba(251,191,36,0.12); color:var(--warning); }
-  .tool-args { font-size:12px; color:var(--text-muted); margin-bottom:8px; }
-  .tool-result { font-size:12px; background:var(--bg-primary); border-radius:6px; padding:8px 12px; max-height:300px; overflow-y:auto; white-space:pre-wrap; word-break:break-all; font-family:'JetBrains Mono',monospace; line-height:1.5; color:var(--text-secondary); }
-  .tool-result::-webkit-scrollbar { width:4px; }
-  .tool-result::-webkit-scrollbar-thumb { background:var(--border); border-radius:2px; }
-
-  /* Iteration Badge */
-  .iteration-badge { display:inline-flex; align-items:center; gap:4px; font-size:11px; color:var(--text-muted); background:var(--bg-tertiary); padding:2px 10px; border-radius:10px; margin-bottom:8px; }
-
-  /* Input Area */
-  .chat-input { padding:16px 24px 24px; border-top:1px solid var(--border); }
-  .input-wrapper { display:flex; align-items:flex-end; gap:12px; background:var(--bg-tertiary); border:1px solid var(--border); border-radius:var(--radius); padding:12px 16px; transition:border-color 0.2s; }
-  .input-wrapper:focus-within { border-color:var(--accent); }
-  .input-wrapper textarea { flex:1; background:none; border:none; outline:none; color:var(--text-primary); font-size:14px; font-family:inherit; resize:none; max-height:200px; line-height:1.5; }
-  .input-wrapper textarea::placeholder { color:var(--text-muted); }
-  .send-btn { padding:8px 20px; background:var(--accent); color:white; border:none; border-radius:var(--radius-sm); font-size:13px; font-weight:600; cursor:pointer; transition:all 0.2s; white-space:nowrap; }
-  .send-btn:hover { background:var(--accent-hover); }
-  .send-btn:disabled { opacity:0.5; cursor:not-allowed; }
-  .stop-btn { padding:8px 20px; background:var(--error); color:white; border:none; border-radius:var(--radius-sm); font-size:13px; font-weight:600; cursor:pointer; }
-  .input-hint { font-size:11px; color:var(--text-muted); margin-top:8px; text-align:center; }
-
-  /* Workspace Panel */
-  .ws-header { padding:16px; border-bottom:1px solid var(--border); display:flex; align-items:center; justify-content:space-between; }
-  .ws-header h3 { font-size:13px; font-weight:600; }
-  .ws-tree { flex:1; overflow-y:auto; padding:12px 16px; font-family:'JetBrains Mono',monospace; font-size:12px; line-height:1.8; color:var(--text-secondary); white-space:pre; }
-  .ws-tree::-webkit-scrollbar { width:4px; }
-  .ws-tree::-webkit-scrollbar-thumb { background:var(--border); border-radius:2px; }
-
-  /* Typing indicator */
-  .typing-indicator { display:flex; gap:4px; padding:8px 0; }
-  .typing-dot { width:6px; height:6px; border-radius:50%; background:var(--accent); animation:typingBounce 1.4s infinite; }
-  .typing-dot:nth-child(2) { animation-delay:0.2s; }
-  .typing-dot:nth-child(3) { animation-delay:0.4s; }
-  @keyframes typingBounce { 0%,60%,100%{transform:translateY(0)} 30%{transform:translateY(-6px)} }
-
-  /* Example prompts */
-  .examples { padding:16px 20px; }
-  .example-btn { display:block; width:100%; text-align:left; padding:10px 12px; background:var(--bg-tertiary); color:var(--text-secondary); border:1px solid var(--border); border-radius:var(--radius-sm); font-size:12px; margin-bottom:8px; cursor:pointer; transition:all 0.2s; line-height:1.4; }
-  .example-btn:hover { background:var(--bg-hover); color:var(--text-primary); border-color:var(--accent); }
-
-  /* Responsive */
-  @media (max-width:900px) {
-    .sidebar { display:none; }
-    .workspace-panel { display:none; }
-  }
-</style>
-</head>
-<body>
-<div class="app">
-  <!-- Sidebar -->
-  <aside class="sidebar">
-    <div class="sidebar-header">
-      <div class="logo">SoniCoder v2</div>
-      <div class="logo-sub">AI Code Agent</div>
-    </div>
-
-    <div class="model-selector">
-      <label>Model</label>
-      <select id="modelSelect"></select>
-    </div>
-
-    <div class="model-status">
-      <span class="status-dot unknown" id="statusDot"></span>
-      <span class="status-text" id="statusText">Initializing...</span>
-    </div>
-
-    <button class="new-chat-btn" onclick="newChat()">+ New Chat</button>
-
-    <div class="sidebar-section">
-      <h3>Quick Start</h3>
-      <div class="sidebar-info">
-        Ask me to build anything — a web app, API, script, or full-stack project. I'll create the files and verify they work.
-      </div>
-    </div>
-
-    <div class="examples" id="examplesPanel">
-      <div class="example-btn" onclick="useExample(this)">Build a Flask REST API with user CRUD endpoints</div>
-      <div class="example-btn" onclick="useExample(this)">Create a React todo app with localStorage persistence</div>
-      <div class="example-btn" onclick="useExample(this)">Write a Python web scraper with error handling</div>
-      <div class="example-btn" onclick="useExample(this)">Build a CLI tool that converts Markdown to HTML</div>
-      <div class="example-btn" onclick="useExample(this)">Create a FastAPI backend with JWT authentication</div>
-    </div>
-  </aside>
-
-  <!-- Main Chat -->
-  <div class="main">
-    <div class="chat-header">
-      <h2>Chat</h2>
-      <div class="header-actions">
-        <button class="header-btn" onclick="toggleWorkspace()">Workspace</button>
-        <button class="header-btn" onclick="refreshWorkspace()">Refresh</button>
-      </div>
-    </div>
-
-    <div class="chat-messages" id="chatMessages">
-      <div class="message" style="text-align:center; padding:60px 20px;">
-        <div style="font-size:28px; margin-bottom:12px; opacity:0.6;">SoniCoder v2</div>
-        <div style="color:var(--text-secondary); font-size:14px; max-width:500px; margin:0 auto; line-height:1.7;">
-          AI-powered code agent that writes, runs, and debugs code. Built with patterns from Gemini CLI and Claude Code. Supports MCP tools and multiple 1B models.
-        </div>
-      </div>
-    </div>
-
-    <div class="chat-input">
-      <div class="input-wrapper">
-        <textarea id="chatInput" placeholder="Describe what you want to build..." rows="1" onkeydown="handleKeyDown(event)" oninput="autoResize(this)"></textarea>
-        <button class="send-btn" id="sendBtn" onclick="sendMessage()">Send</button>
-      </div>
-      <div class="input-hint">Press Enter to send, Shift+Enter for new line</div>
-    </div>
-  </div>
-
-  <!-- Workspace Panel -->
-  <div class="workspace-panel" id="workspacePanel">
-    <div class="ws-header">
-      <h3>Workspace</h3>
-    </div>
-    <div class="ws-tree" id="wsTree">Loading...</div>
-  </div>
-</div>
-
-<script>
-const __CONFIG__ = __RUNTIME_CONFIG__ || {};
-
-// ── State ──
-let sessionId = '';
-let isStreaming = false;
-let abortController = null;
-let currentToolCalls = {};
-
-// ── Init ──
-document.addEventListener('DOMContentLoaded', () => {
-  loadConfig();
-  pollModelStatus();
-  refreshWorkspace();
-});
-
-async function loadConfig() {
-  try {
-    const resp = await fetch('/api/get_config');
-    const config = await resp.json();
-    const parsed = typeof config === 'string' ? JSON.parse(config) : config;
-
-    const select = document.getElementById('modelSelect');
-    select.innerHTML = '';
-    (parsed.models || []).forEach(m => {
-      const opt = document.createElement('option');
-      opt.value = m.key;
-      opt.textContent = `${m.name} (${m.size_gb}GB)`;
-      if (m.key === parsed.default_model) opt.selected = true;
-      select.appendChild(opt);
-    });
-
-    select.addEventListener('change', () => switchModel(select.value));
-  } catch(e) { console.error('Config load failed:', e); }
-}
-
-async function pollModelStatus() {
-  try {
-    const resp = await fetch('/api/model_status');
-    const status = JSON.parse(await resp.json());
-    const dot = document.getElementById('statusDot');
-    const text = document.getElementById('statusText');
-
-    dot.className = 'status-dot ' + (status.status || 'unknown');
-    const names = { ready:'Ready', loading:'Loading...', error:'Error', unknown:'Unknown' };
-    text.textContent = (status.model_name || names[status.status] || 'Unknown');
-
-    if (status.status === 'loading') {
-      setTimeout(pollModelStatus, 3000);
-    }
-  } catch(e) { setTimeout(pollModelStatus, 5000); }
-}
-
-async function switchModel(key) {
-  try {
-    await fetch('/api/switch_model', { method:'POST', body: new URLSearchParams({data: JSON.stringify([key])}), headers:{'Content-Type':'application/x-www-form-urlencoded'} });
-    document.getElementById('statusDot').className = 'status-dot loading';
-    document.getElementById('statusText').textContent = 'Switching...';
-    setTimeout(pollModelStatus, 2000);
-  } catch(e) { console.error(e); }
-}
-
-async function refreshWorkspace() {
-  try {
-    const resp = await fetch('/api/workspace_tree', { method:'POST', body: new URLSearchParams({data: JSON.stringify([3])}), headers:{'Content-Type':'application/x-www-form-urlencoded'} });
-    const data = JSON.parse(await resp.json());
-    document.getElementById('wsTree').textContent = data.tree || '(empty)';
-  } catch(e) { console.error(e); }
-}
-
-function toggleWorkspace() {
-  document.getElementById('workspacePanel').classList.toggle('collapsed');
-}
-
-function newChat() {
-  if (sessionId) {
-    fetch('/api/reset_session', { method:'POST', body: new URLSearchParams({data: JSON.stringify([sessionId])}), headers:{'Content-Type':'application/x-www-form-urlencoded'} });
-  }
-  sessionId = '';
-  document.getElementById('chatMessages').innerHTML = `
-    <div class="message" style="text-align:center; padding:60px 20px;">
-      <div style="font-size:28px; margin-bottom:12px; opacity:0.6;">SoniCoder v2</div>
-      <div style="color:var(--text-secondary); font-size:14px;">New session started. What would you like to build?</div>
-    </div>`;
-}
-
-function useExample(btn) {
-  document.getElementById('chatInput').value = btn.textContent.trim();
-  sendMessage();
-}
-
-function handleKeyDown(e) {
-  if (e.key === 'Enter' && !e.shiftKey) {
-    e.preventDefault();
-    sendMessage();
-  }
-}
-
-function autoResize(el) {
-  el.style.height = 'auto';
-  el.style.height = Math.min(el.scrollHeight, 200) + 'px';
-}
-
-// ── Message Rendering ──
-function appendMessage(role, content, extra={}) {
-  const container = document.getElementById('chatMessages');
-  const div = document.createElement('div');
-  div.className = 'message';
-  div.id = extra.msgId || '';
-
-  const time = new Date().toLocaleTimeString([], {hour:'2-digit', minute:'2-digit'});
-  const avatarClass = role === 'user' ? 'user' : 'agent';
-  const avatarText = role === 'user' ? 'Y' : 'SC';
-
-  div.innerHTML = `
-    <div class="message-header">
-      <div class="message-avatar ${avatarClass}">${avatarText}</div>
-      <span class="message-role">${role === 'user' ? 'You' : 'SoniCoder'}</span>
-      <span class="message-time">${time}</span>
-      ${extra.iteration ? `<span class="iteration-badge">Iteration ${extra.iteration}</span>` : ''}
-    </div>
-    <div class="message-body">${formatContent(content)}</div>`;
-
-  container.appendChild(div);
-  container.scrollTop = container.scrollHeight;
-  return div;
-}
-
-function formatContent(text) {
-  if (!text) return '';
-  // Code blocks
-  text = text.replace(/```(\w*)\n([\s\S]*?)```/g, (_, lang, code) => {
-    return `<pre><code class="language-${lang}">${escapeHtml(code.trim())}</code></pre>`;
-  });
-  // Inline code
-  text = text.replace(/`([^`]+)`/g, '<code>$1</code>');
-  // Bold
-  text = text.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>');
-  // Lists
-  text = text.replace(/^[-•] (.+)$/gm, '<li>$1</li>');
-  text = text.replace(/(<li>.*<\/li>)/s, '<ul>$1</ul>');
-  // Line breaks
-  text = text.replace(/\n/g, '<br>');
-  return text;
-}
-
-function escapeHtml(text) {
-  const d = document.createElement('div');
-  d.textContent = text;
-  return d.innerHTML;
-}
-
-function addToolCall(toolName, args) {
-  const container = document.getElementById('chatMessages');
-  const id = 'tc_' + Date.now();
-  const div = document.createElement('div');
-  div.className = 'tool-call';
-  div.id = id;
-  div.innerHTML = `
-    <div class="tool-call-header">
-      <span class="tool-icon">⚡</span>
-      <span class="tool-name">${escapeHtml(toolName)}</span>
-      <span class="tool-status running">Running</span>
-    </div>
-    <div class="tool-args">${formatToolArgs(args)}</div>
-    <div class="tool-result" style="display:none;"></div>`;
-  container.appendChild(div);
-  container.scrollTop = container.scrollHeight;
-  currentToolCalls[id] = div;
-  return id;
-}
-
-function updateToolCall(id, success, output) {
-  const div = currentToolCalls[id];
-  if (!div) return;
-  const status = div.querySelector('.tool-status');
-  const result = div.querySelector('.tool-result');
-  status.className = 'tool-status ' + (success ? 'success' : 'error');
-  status.textContent = success ? 'Done' : 'Error';
-  if (output) {
-    result.textContent = output;
-    result.style.display = 'block';
-  }
-  document.getElementById('chatMessages').scrollTop = document.getElementById('chatMessages').scrollHeight;
-}
-
-function formatToolArgs(args) {
-  if (!args) return '';
-  const lines = Object.entries(args).map(([k, v]) => {
-    const val = typeof v === 'string' ? (v.length > 60 ? v.slice(0, 60) + '...' : v) : JSON.stringify(v);
-    return `${k}: ${val}`;
-  });
-  return escapeHtml(lines.join('\n'));
-}
-
-// ── Streaming ──
-let currentStreamDiv = null;
-let currentStreamContent = '';
-
-function startStreaming() {
-  currentStreamContent = '';
-  const container = document.getElementById('chatMessages');
-  // Remove welcome message if present
-  const welcome = container.querySelector('.message[style*="text-align:center"]');
-  if (welcome) welcome.remove();
-
-  currentStreamDiv = appendMessage('agent', '', {});
-  const body = currentStreamDiv.querySelector('.message-body');
-  body.innerHTML = '<div class="typing-indicator"><div class="typing-dot"></div><div class="typing-dot"></div><div class="typing-dot"></div></div>';
-}
-
-function updateStreaming(text) {
-  if (!currentStreamDiv) return;
-  const body = currentStreamDiv.querySelector('.message-body');
-  body.innerHTML = formatContent(text) || '<div class="typing-indicator"><div class="typing-dot"></div><div class="typing-dot"></div><div class="typing-dot"></div></div>';
-  document.getElementById('chatMessages').scrollTop = document.getElementById('chatMessages').scrollHeight;
-}
-
-function finalizeStream(text) {
-  if (!currentStreamDiv) return;
-  const body = currentStreamDiv.querySelector('.message-body');
-  body.innerHTML = formatContent(text);
-  currentStreamDiv = null;
-}
-
-// ── Send Message ──
-async function sendMessage() {
-  const input = document.getElementById('chatInput');
-  const message = input.value.trim();
-  if (!message || isStreaming) return;
-
-  input.value = '';
-  input.style.height = 'auto';
-  isStreaming = true;
-
-  const sendBtn = document.getElementById('sendBtn');
-  sendBtn.textContent = 'Stop';
-  sendBtn.className = 'stop-btn';
-  sendBtn.onclick = stopStreaming;
-
-  appendMessage('user', message);
-  startStreaming();
-
-  try {
-    const resp = await fetch('/api/chat', {
-      method: 'POST',
-      body: new URLSearchParams({
-        data: JSON.stringify([message, sessionId, '']),
-      }),
-      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-    });
-
-    const reader = resp.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split('\n');
-      buffer = lines.pop() || '';
-
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          const event = JSON.parse(line);
-
-          switch (event.type) {
-            case 'streaming':
-              const display = (event.content || '').replace(/```tool[\s\S]*?```/g, '').trim();
-              updateStreaming(display);
-              break;
-
-            case 'tool_call':
-              addToolCall(event.tool, event.args);
-              break;
-
-            case 'tool_result':
-              // Find the latest tool call for this tool name
-              const tcIds = Object.keys(currentToolCalls).reverse();
-              for (const tcId of tcIds) {
-                const tcDiv = currentToolCalls[tcId];
-                if (tcDiv && tcDiv.querySelector('.tool-status.running')) {
-                  updateToolCall(tcId, event.result.success, event.result.output || event.result.error);
-                  break;
-                }
-              }
-              break;
-
-            case 'status':
-              if (event.iteration) {
-                const header = currentStreamDiv?.querySelector('.message-header');
-                if (header) {
-                  let badge = header.querySelector('.iteration-badge');
-                  if (!badge) {
-                    badge = document.createElement('span');
-                    badge.className = 'iteration-badge';
-                    header.appendChild(badge);
-                  }
-                  badge.textContent = `Iteration ${event.iteration}/${event.max_iterations}`;
-                }
-              }
-              break;
-
-            case 'complete':
-              const finalText = event.content || currentStreamContent;
-              finalizeStream(finalText || 'Done.');
-              if (event.iterations) {
-                setTimeout(refreshWorkspace, 500);
-              }
-              break;
-
-            case 'error':
-              finalizeStream(`Error: ${event.error}`);
-              break;
-          }
-        } catch (e) { /* skip malformed lines */ }
-      }
-    }
-  } catch (e) {
-    if (e.name !== 'AbortError') {
-      finalizeStream(`Connection error: ${e.message}`);
-    }
-  }
-
-  isStreaming = false;
-  sendBtn.textContent = 'Send';
-  sendBtn.className = 'send-btn';
-  sendBtn.onclick = sendMessage;
-}
-
-function stopStreaming() {
-  // The streaming will naturally end when we close
-  isStreaming = false;
-  const sendBtn = document.getElementById('sendBtn');
-  sendBtn.textContent = 'Send';
-  sendBtn.className = 'send-btn';
-  sendBtn.onclick = sendMessage;
-  if (currentStreamDiv) {
-    finalizeStream(currentStreamContent || '(stopped)');
-  }
-}
-</script>
-</body>
-</html>