antimatter-ag2 1.0.0__tar.gz

antimatter_ag2-1.0.0/.gitignore

@@ -0,0 +1,31 @@
+node_modules/
+dist/
+build/
+site/
+.DS_Store
+*.log
+.env
+reports/
+.vscode/
+.agents/
+outputs/
+.astro/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+.venv/
+pip-log.txt
+pip-delete-this-directory.txt
+.pytest_cache/
+*.egg-info/
+.hatch/
+
+# VSIX / Extension Manifests
+*.vsix
+extension.vsixmanifest

antimatter_ag2-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Saif Mukhtar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

antimatter_ag2-1.0.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: antimatter-ag2
+Version: 1.0.0
+Summary: Antimatter AG2 Adapter — companion daemon for Google AntiGravity IDE
+Project-URL: Homepage, https://saifmukhtar.dev
+Project-URL: Repository, https://github.com/saifmukhtar/antimatter
+Project-URL: Issues, https://github.com/saifmukhtar/antimatter/issues
+Project-URL: Documentation, https://saifmukhtar.dev/docs/antimatter
+Project-URL: Changelog, https://github.com/saifmukhtar/antimatter/releases
+Author-email: Saif Mukhtar <saifmukhtar@saifmukhtar.dev>
+License: MIT License
+        
+        Copyright (c) 2026 Saif Mukhtar
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: ai,android,antigravity,bridge,ide,mobile,websocket
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Communications
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11
+Requires-Dist: google-antigravity==0.1.2
+Requires-Dist: websockets==15.0.1
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'test'
+Requires-Dist: pytest>=7.0.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Antimatter: Antigravity 2.0 Adapter (AG2)
+
+This directory contains the Antimatter IPC adapter for the Antigravity 2.0 SDK CLI.
+
+## Architecture
+
+This adapter follows the **Independent Adapter Model**. It does NOT contain any complex networking, Cloudflare tunnels, or cryptographic pairing logic. Instead, it acts purely as a "dumb" IPC client that connects to the central Antimatter Gateway.
+
+1. **Connection**: The daemon connects locally to the Gateway via WebSocket at `ws://127.0.0.1:8765`.
+2. **Registration**: Upon connection, it sends `{"type": "REGISTER_ADAPTER", "name": "ag2"}`.
+3. **Execution**: When you send a message from the Antimatter Android app targeting AG2, the Gateway securely routes that payload to this adapter. This adapter interfaces with the Antigravity 2.0 SDK by monitoring the `.system_generated/logs/transcript.jsonl` files and submitting local Python subprocess commands.
+
+## Building
+
+```bash
+uv build
+uv tool install .
+```
+
+For full system documentation, please see the `docs/` folder in the repository root.

antimatter_ag2-1.0.0/README.md

@@ -0,0 +1,20 @@
+# Antimatter: Antigravity 2.0 Adapter (AG2)
+
+This directory contains the Antimatter IPC adapter for the Antigravity 2.0 SDK CLI.
+
+## Architecture
+
+This adapter follows the **Independent Adapter Model**. It does NOT contain any complex networking, Cloudflare tunnels, or cryptographic pairing logic. Instead, it acts purely as a "dumb" IPC client that connects to the central Antimatter Gateway.
+
+1. **Connection**: The daemon connects locally to the Gateway via WebSocket at `ws://127.0.0.1:8765`.
+2. **Registration**: Upon connection, it sends `{"type": "REGISTER_ADAPTER", "name": "ag2"}`.
+3. **Execution**: When you send a message from the Antimatter Android app targeting AG2, the Gateway securely routes that payload to this adapter. This adapter interfaces with the Antigravity 2.0 SDK by monitoring the `.system_generated/logs/transcript.jsonl` files and submitting local Python subprocess commands.
+
+## Building
+
+```bash
+uv build
+uv tool install .
+```
+
+For full system documentation, please see the `docs/` folder in the repository root.

antimatter_ag2-1.0.0/antimatter_ag2/agent_bridge.py

@@ -0,0 +1,456 @@
+import asyncio
+import json
+import os
+import glob
+from pathlib import Path
+
+
+import asyncio
+
+class AgentBridge:
+    def __init__(self, websocket, app_data_dir: str, current_convo_id: str):
+        self.websocket = websocket
+        self.agent = None
+        self.app_data_dir = app_data_dir
+        self.conversation_id = current_convo_id
+        self.step_index = 0
+        # BUG-005: Initialize last_position here so poll_transcript never raises AttributeError
+        # even if send_transcript was not called first
+        self.last_position = 0
+        # BUG-006: Stop event for graceful shutdown of poll_transcript
+        self._stop_event = asyncio.Event()
+        self._watch_task = None
+
+    async def _send_step(self, case: str, value: str = None, tool: str = None):
+        step_payload = {"case": case}
+        if value is not None:
+            step_payload["value"] = value
+        if tool is not None:
+            step_payload["tool"] = tool
+
+        await self.websocket.send(json.dumps({
+            "type": "STEP",
+            "index": self.step_index,
+            "step": step_payload
+        }))
+        self.step_index += 1
+
+    async def _send_generating(self):
+        await self.websocket.send(json.dumps({
+            "type": "GENERATING",
+            "conversationId": self.conversation_id
+        }))
+
+    async def _send_response_complete(self):
+        await self.websocket.send(json.dumps({
+            "type": "RESPONSE_COMPLETE",
+            "conversationId": self.conversation_id
+        }))
+
+    async def send_history(self):
+        brain_dir = os.path.join(self.app_data_dir, "brain")
+        conversations = []
+        if os.path.exists(brain_dir):
+            import json, re
+            for d in os.listdir(brain_dir):
+                d_path = os.path.join(brain_dir, d)
+                logs_dir = os.path.join(d_path, ".system_generated", "logs")
+                if os.path.isdir(logs_dir):
+                    transcript_path = os.path.join(logs_dir, "transcript.jsonl")
+                    if os.path.exists(transcript_path):
+                        timestamp = int(os.path.getmtime(transcript_path) * 1000)
+                        title = "New Conversation"
+                        try:
+                            with open(transcript_path, 'r', encoding='utf-8') as f:
+                                for line in f:
+                                    try:
+                                        data = json.loads(line)
+                                        if data.get("type") == "USER_INPUT":
+                                            content = data.get("content", "")
+                                            match = re.search(r'<USER_REQUEST>\s*(.*?)\s*</USER_REQUEST>', content, re.DOTALL)
+                                            if match:
+                                                title = match.group(1).strip()
+                                            else:
+                                                title = re.sub(r'<[^>]+>', '', content).strip()
+                                            # Truncate title
+                                            if len(title) > 50:
+                                                title = title[:47] + "..."
+                                            break
+                                    except Exception:
+                                        pass
+                        except Exception:
+                            pass
+                        
+                        conversations.append({
+                            "id": d,
+                            "timestamp": timestamp,
+                            "title": title
+                        })
+        
+        # Sort descending by timestamp
+        conversations.sort(key=lambda x: x["timestamp"], reverse=True)
+        
+        if not conversations:
+            conversations = [{
+                "id": self.conversation_id,
+                "timestamp": 0,
+                "title": "Current Session"
+            }]
+
+        await self.websocket.send(json.dumps({
+            "type": "HISTORY_LIST",
+            "conversations": conversations
+        }))
+
+    def _is_boilerplate(self, text: str) -> bool:
+        t = text.lower()
+        if t.startswith("#") and ("tool" in t or "instruction" in t):
+            return True
+        keywords = [
+            "critical instruction", "tool specificity", "tool usage",
+            "tool ecosystem", "tool repertoire", "instruction to avoid cat",
+            "eliminating the use of ls", "default to grep_search",
+            "actively avoiding using ls", "avoiding cat within bash",
+            "before making tool calls", "list related tools",
+            "tool list: `", "i must prioritize using the most specific tool"
+        ]
+        return any(k in t for k in keywords)
+
+    def _parse_line(self, line: str):
+        import json
+        import re
+        try:
+            data = json.loads(line)
+            msg_type = data.get("type")
+            content = data.get("content", "")
+
+            steps_to_return = []
+            
+            def add_step(case_type, value):
+                steps_to_return.append({
+                    "index": self.step_index,
+                    "step": {"case": case_type, "value": value}
+                })
+                self.step_index += 1
+            
+            if msg_type == "USER_INPUT":
+                match = re.search(r'<USER_REQUEST>\s*(.*?)\s*</USER_REQUEST>', content, re.DOTALL)
+                if match:
+                    content = match.group(1).strip()
+                else:
+                    content = re.sub(r'<[^>]+>', '', content).strip()
+                add_step("userInput", content)
+            elif msg_type == "SYSTEM_MESSAGE":
+                match = re.search(r'content=(.*?)(?:\n</SYSTEM_MESSAGE>|$)', content, re.DOTALL)
+                if match:
+                    parsed_content = match.group(1).strip()
+                    if not parsed_content.startswith("Task id") and not parsed_content.startswith("Tool is running"):
+                        add_step("SYSTEM_MESSAGE", parsed_content)
+            elif msg_type == "PLANNER_RESPONSE":
+                thinking = data.get("thinking", "")
+                if thinking:
+                    clean_thinking = [
+                        paragraph for paragraph in thinking.split("\n\n") 
+                        if not self._is_boilerplate(paragraph)
+                    ]
+                    
+                    final_thinking = "\n\n".join(clean_thinking).strip()
+                    if final_thinking:
+                        stripped_of_punctuation = re.sub(r'[#\s*\-=_]+', '', final_thinking).strip()
+                        if stripped_of_punctuation:
+                            add_step("plannerResponse", final_thinking)
+                if content:
+                    add_step("text", content)
+            elif msg_type == "SYSTEM_ALERT":
+                add_step("ephemeralMessage", content)
+            elif msg_type == "MODEL_TEXT":
+                add_step("text", content)
+            elif msg_type in ["VIEW_FILE", "LIST_DIRECTORY", "CODE_ACTION", "GREP_SEARCH", "READ_URL_CONTENT", "SEARCH_WEB"]:
+                pass
+            elif msg_type == "ERROR_MESSAGE":
+                add_step("errorMessage", content)
+                
+            return steps_to_return
+        except Exception:
+            return []
+
+    async def send_transcript(self, convo_id: str):
+        transcript_path = os.path.join(self.app_data_dir, "brain", convo_id, ".system_generated", "logs", "transcript.jsonl")
+        steps = []
+        
+        self.step_index = 0
+        self.last_position = 0
+
+        if os.path.exists(transcript_path):
+            try:
+                with open(transcript_path, 'r', encoding='utf-8') as f:
+                    for line in f:
+                        parsed_steps = self._parse_line(line)
+                        if parsed_steps:
+                            steps.extend(parsed_steps)
+                    self.last_position = f.tell()
+
+            except Exception as e:
+                print(f"[Gateway] ERROR in reading transcript: {e}", flush=True)
+
+        await self.websocket.send(json.dumps({
+            "type": "SESSION_STATE",
+            "conversationId": convo_id,
+            "stepCount": len(steps)
+        }))
+
+        await self.websocket.send(json.dumps({
+            "type": "STEP_BATCH",
+            "conversationId": convo_id,
+            "steps": steps
+        }))
+
+    async def poll_transcript(self):
+        """Poll the transcript file for new lines, with graceful shutdown and debouncing."""
+        import asyncio
+        current_opened_convo_id = None
+        f = None
+
+        try:
+            while not self._stop_event.is_set():
+                if current_opened_convo_id != self.conversation_id:
+                    if f:
+                        f.close()
+                    transcript_path = os.path.join(
+                        self.app_data_dir, "brain", self.conversation_id,
+                        ".system_generated", "logs", "transcript.jsonl"
+                    )
+                    # Wait for file to exist
+                    while not os.path.exists(transcript_path):
+                        if self._stop_event.is_set() or current_opened_convo_id != self.conversation_id:
+                            break
+                        await asyncio.sleep(1)
+                        
+                    if self._stop_event.is_set():
+                        break
+                    
+                    if os.path.exists(transcript_path):
+                        f = open(transcript_path, 'r', encoding='utf-8')
+                        f.seek(self.last_position)
+                        current_opened_convo_id = self.conversation_id
+                
+                if f:
+                    line = f.readline()
+                    if not line:
+                        await asyncio.sleep(0.1)
+                        continue
+
+                    parsed_steps = self._parse_line(line)
+                    if parsed_steps:
+                        for s in parsed_steps:
+                            if s["step"]["case"] in ["userInput", "toolCall"]:
+                                await self._send_generating()
+                            elif s["step"]["case"] in ["text", "errorMessage", "ephemeralMessage"]:
+                                await self._send_response_complete()
+
+                        await self.websocket.send(json.dumps({
+                            "type": "STEP_BATCH",
+                            "conversationId": self.conversation_id,
+                            "steps": parsed_steps
+                        }))
+                else:
+                    await asyncio.sleep(0.5)
+        finally:
+            if f:
+                f.close()
+
+    async def watch_brain_dir(self):
+        brain_dir = os.path.join(self.app_data_dir, "brain")
+        while not self._stop_event.is_set():
+            try:
+                if os.path.exists(brain_dir):
+                    subdirs = [os.path.join(brain_dir, d) for d in os.listdir(brain_dir) if os.path.isdir(os.path.join(brain_dir, d))]
+                    if subdirs:
+                        newest_dir = max(subdirs, key=os.path.getmtime)
+                        newest_convo_id = os.path.basename(newest_dir)
+                        if newest_convo_id != "scratch":
+                            # Only broadcast history so the sidebar updates, don't force a UI switch
+                            await self.send_history()
+            except Exception:
+                pass
+            await asyncio.sleep(2)
+
+    async def send_artifacts(self, convo_id: str):
+        artifacts_dir = os.path.join(self.app_data_dir, "brain", convo_id)
+        artifacts = []
+        if os.path.exists(artifacts_dir):
+            for file in os.listdir(artifacts_dir):
+                if file.endswith(".md") and file not in ["task.md", "walkthrough.md", "implementation_plan.md"]:
+                    artifacts.append({
+                        "name": file,
+                        "path": os.path.join(artifacts_dir, file),
+                        "isDir": False
+                    })
+            # Add standard artifacts
+            for std in ["implementation_plan.md", "task.md", "walkthrough.md"]:
+                if os.path.exists(os.path.join(artifacts_dir, std)):
+                    artifacts.append({
+                        "name": std,
+                        "path": os.path.join(artifacts_dir, std),
+                        "isDir": False
+                    })
+                    
+        await self.websocket.send(json.dumps({
+            "type": "ARTIFACTS_LIST",
+            "artifacts": artifacts
+        }))
+
+    async def read_artifact(self, path: str):
+        import pathlib
+        p = pathlib.Path(path).resolve()
+        brain_dir = pathlib.Path(self.app_data_dir) / "brain"
+        try:
+            p.relative_to(brain_dir.resolve())
+        except ValueError:
+            return  # Path traversal rejected
+            
+        if p.exists():
+            try:
+                with open(p, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                await self.websocket.send(json.dumps({
+                    "type": "ARTIFACT_CONTENT",
+                    "path": str(p),
+                    "content": content
+                }))
+            except Exception:
+                pass
+
+    async def send_workspace(self, root_path=None):
+        if root_path is None:
+            root_path = os.getcwd()
+
+        IGNORED = {
+            'node_modules', '.git', 'dist', 'build', 'out', '.gradle',
+            '__pycache__', '.venv', 'venv', '.idea', '.DS_Store', '.kotlin',
+        }
+
+        # Performance: Build the file tree in a thread pool so the synchronous
+        # os.listdir/os.path.isdir calls don't block the asyncio event loop.
+        def build_tree(path: str, depth: int = 0) -> list:
+            if depth > 2:
+                return []
+            nodes = []
+            try:
+                for item in sorted(os.listdir(path)):
+                    if item.startswith('.') or item in IGNORED:
+                        continue
+                    full_path = os.path.join(path, item)
+                    is_dir = os.path.isdir(full_path)
+                    node = {
+                        "name": item,
+                        "path": full_path,
+                        "isDir": is_dir
+                    }
+                    if is_dir and depth < 2:
+                        node["children"] = build_tree(full_path, depth + 1)
+                    nodes.append(node)
+            except PermissionError:
+                pass
+            except Exception:
+                pass
+            # Directories first, then files, both alphabetical
+            return sorted(nodes, key=lambda x: (not x["isDir"], x["name"]))
+
+        # Run synchronous tree scan off the event loop
+        tree = await asyncio.to_thread(build_tree, root_path)
+        await self.websocket.send(json.dumps({
+            "type": "FILE_TREE",
+            "tree": tree
+        }))
+
+    async def read_file(self, path: str):
+        import pathlib
+        workspace = pathlib.Path(os.getcwd()).resolve()
+        p = pathlib.Path(path)
+        if not p.is_absolute():
+            p = workspace / p
+        p = p.resolve()
+        
+        try:
+            p.relative_to(workspace)
+        except ValueError:
+            await self.websocket.send(json.dumps({
+                "type": "ERROR",
+                "message": "Path traversal rejected"
+            }))
+            return
+
+        try:
+            with open(p, 'r', encoding='utf-8') as f:
+                content = f.read()
+            await self.websocket.send(json.dumps({
+                "type": "FILE_CONTENT",
+                "path": str(p),
+                "content": content,
+                "language": "markdown" if str(p).endswith(".md") else "text"
+            }))
+        except Exception as e:
+            await self.websocket.send(json.dumps({
+                "type": "ERROR",
+                "message": f"Failed to read file: {e}"
+            }))
+
+    async def process_message(self, text: str, images: list = None):
+        if images is None:
+            images = []
+            
+        # Process images
+        if images:
+            import base64
+            import time
+            scratch_dir = os.path.join(self.app_data_dir, "brain", self.conversation_id, "scratch")
+            os.makedirs(scratch_dir, exist_ok=True)
+            
+            for i, b64_str in enumerate(images):
+                try:
+                    if "," in b64_str:
+                        b64_str = b64_str.split(",")[1]
+                        
+                    img_data = base64.b64decode(b64_str)
+                    timestamp = int(time.time() * 1000)
+                    filename = f"upload_{timestamp}_{i}.jpg"
+                    filepath = os.path.join(scratch_dir, filename)
+                    
+                    with open(filepath, "wb") as f:
+                        f.write(img_data)
+                        
+                    text += f"\\n\\n![Image](file://{filepath})"
+                except Exception as e:
+                    print(f"Failed to decode image {i}: {e}")
+
+        # We DO NOT send userInput directly anymore because Agent.chat() or agentapi will append it to the file,
+        # and poll_transcript will pick it up and broadcast it properly, avoiding duplicates.
+        await self._send_generating()
+
+        try:
+            import asyncio
+            agentapi_path = os.path.expanduser("~/.gemini/antigravity/bin/agentapi")
+            
+            proc = await asyncio.create_subprocess_exec(
+                agentapi_path, "send-message", str(self.conversation_id), str(text),
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE
+            )
+            stdout, stderr = await proc.communicate()
+            
+            if proc.returncode != 0:
+                if b"ANTIGRAVITY_LS_ADDRESS is not set" in stderr:
+                    logger.error("FATAL: Adapter MUST be started from inside the Antigravity IDE integrated terminal!")
+                await self._send_step("errorMessage", f"Failed to inject message into IDE: {stderr.decode()}")
+            else:
+                await self._send_step("ephemeralMessage", "Message queued to IDE Agent.")
+        except Exception as e:
+            await self._send_step("errorMessage", f"Agent Error: {str(e)}")
+        finally:
+            await self._send_response_complete()
+
+
+    async def cleanup(self):
+        # BUG-006: Signal poll_transcript to stop gracefully
+        self._stop_event.set()

antimatter_ag2-1.0.0/antimatter_ag2/assets/plugin.json

@@ -0,0 +1,5 @@
+{
+  "name": "antimatter-ag2",
+  "version": "1.0.0",
+  "description": "Seamless integration with the Antimatter Android App."
+}

antimatter_ag2-1.0.0/antimatter_ag2/assets/skills/antimatter-ag2/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: antimatter-ag2
+description: "Starts the Antimatter AG2 adapter to connect the IDE to the Gateway. Use this skill when the user asks to start, manage, or connect their AG2 adapter."
+---
+# Antimatter AG2 Adapter Skill
+
+This skill teaches the agent how to launch and manage the Antimatter AG2 Adapter natively.
+
+## How to use this skill
+
+1. When the user asks to start the adapter, execute the following command (using the `run_command` tool):
+
+```bash
+# Start the Antigravity 2.0 adapter (it will automatically run in the background)
+antimatter-ag2 start
+```
+*(If developing locally, you can run `uv run antimatter-ag2 start` from its directory)*
+
+2. The daemon runs indefinitely and handles all IDE communication seamlessly via the Google Antigravity SDK. You do not need to intervene in the process once it has started.
+
+## Stopping or Restarting the Adapter
+
+If the user asks to "stop", "terminate", or "kill" the Antimatter Adapter, simply run:
+```bash
+antimatter-ag2 stop
+```
+
+If the user asks to "restart" the adapter, run `stop` followed by `start`.

antimatter_ag2-1.0.0/antimatter_ag2/cli.py

@@ -0,0 +1,131 @@
+import os
+import sys
+import shutil
+import argparse
+from pathlib import Path
+from antimatter_ag2 import server
+
+def init_plugin():
+    """Initializes the plugin by copying assets into the Antigravity IDE plugins directory."""
+    print("Initializing Antimatter AG2 plugin...")
+    
+    home_dir = Path.home()
+    plugin_dir = home_dir / ".gemini" / "config" / "plugins" / "antimatter-ag2"
+    
+    # Define source assets path
+    assets_dir = Path(__file__).parent / "assets"
+    
+    if not assets_dir.exists():
+        print(f"Error: Could not find assets directory at {assets_dir}", file=sys.stderr)
+        sys.exit(1)
+        
+    try:
+        # Create target directories
+        print(f"Creating directory: {plugin_dir}")
+        plugin_dir.mkdir(parents=True, exist_ok=True)
+        
+        # 1. Copy plugin.json
+        print("Copying plugin.json...")
+        shutil.copy2(assets_dir / "plugin.json", plugin_dir / "plugin.json")
+        
+        # 2. Create skills directory and copy SKILL.md
+        skill_dir = plugin_dir / "skills" / "antimatter-ag2"
+        print(f"Creating directory: {skill_dir}")
+        skill_dir.mkdir(parents=True, exist_ok=True)
+        
+        print("Copying SKILL.md...")
+        shutil.copy2(assets_dir / "skills" / "antimatter-ag2" / "SKILL.md", skill_dir / "SKILL.md")
+        
+        print("\n✅ Successfully initialized Antimatter AG2 Adapter!")
+        print("You can now open Antigravity 2.0 and say: 'Start my Antimatter adapter'")
+        
+    except Exception as e:
+        print(f"Failed to initialize plugin: {e}", file=sys.stderr)
+        sys.exit(1)
+
+def start_server():
+    """Starts the WebSocket bridge adapter client in the background."""
+    print("Starting Antimatter AG2 Adapter in background...")
+    
+    app_data = Path.home() / ".gemini" / "antigravity"
+    app_data.mkdir(parents=True, exist_ok=True)
+    pid_file = app_data / ".ag2.pid"
+    
+    if pid_file.exists():
+        try:
+            pid = int(pid_file.read_text())
+            os.kill(pid, 0)
+            print("Adapter is already running.")
+            return
+        except (ValueError, OSError):
+            pid_file.unlink(missing_ok=True)
+            
+    import subprocess
+    
+    process = subprocess.Popen(
+        [sys.executable, "-m", "antimatter_ag2.cli", "run_server"],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True
+    )
+    
+    pid_file.write_text(str(process.pid))
+    print(f"✅ Adapter started successfully (PID: {process.pid}).")
+
+def stop_server():
+    """Stops the background adapter."""
+    pid_file = Path.home() / ".gemini" / "antigravity" / ".ag2.pid"
+    if not pid_file.exists():
+        print("Adapter is not running.")
+        return
+        
+    try:
+        pid = int(pid_file.read_text())
+        import signal
+        os.kill(pid, signal.SIGTERM)
+        print("Adapter stopped successfully.")
+    except Exception as e:
+        print(f"Failed to stop adapter or it was not running: {e}")
+    finally:
+        pid_file.unlink(missing_ok=True)
+
+def run_server():
+    """Actually runs the server loop (internal use)."""
+    try:
+        import asyncio
+        asyncio.run(server.main())
+    except KeyboardInterrupt:
+        pass
+
+def main():
+    parser = argparse.ArgumentParser(description="Antimatter AG2 CLI")
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+    
+    # Init command
+    init_parser = subparsers.add_parser("init", help="Initialize the plugin in the Antigravity SDK directory")
+    
+    # Start command
+    start_parser = subparsers.add_parser("start", help="Start the WebSocket daemon in the background")
+    
+    # Stop command
+    stop_parser = subparsers.add_parser("stop", help="Stop the background daemon")
+    
+    # Run server command (internal)
+    run_parser = subparsers.add_parser("run_server", help=argparse.SUPPRESS)
+    
+    args = parser.parse_args()
+    
+    if args.command == "init":
+        init_plugin()
+    elif args.command == "start":
+        start_server()
+    elif args.command == "stop":
+        stop_server()
+    elif args.command == "run_server":
+        run_server()
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

antimatter_ag2-1.0.0/antimatter_ag2/server.py

@@ -0,0 +1,135 @@
+import asyncio
+import json
+import logging
+import websockets
+import os
+from pathlib import Path
+from .agent_bridge import AgentBridge
+
+logging.basicConfig(level=logging.WARNING)
+logger = logging.getLogger(__name__)
+
+APP_DATA_DIR = Path(os.environ.get("AGY_APP_DATA_DIR", os.path.expanduser("~/.gemini/antigravity")))
+
+def get_latest_conversation_id(app_data_dir: Path) -> str:
+    brain_dir = app_data_dir / "brain"
+    if not brain_dir.exists():
+        return "default"
+    
+    conv_dirs = [d.name for d in brain_dir.iterdir() if d.is_dir() and (brain_dir / d / ".system_generated").exists()]
+    if not conv_dirs:
+        return "default"
+        
+    conv_dirs.sort(key=lambda d: (brain_dir / d).stat().st_mtime, reverse=True)
+    return conv_dirs[0]
+
+def get_default_workspace() -> str:
+    if "AGY_WORKSPACE_DIR" in os.environ:
+        return os.environ["AGY_WORKSPACE_DIR"]
+    try:
+        current = Path(__file__).resolve().parent
+        while current != current.parent:
+            if (current / ".git").exists():
+                return str(current)
+            current = current.parent
+    except Exception:
+        pass
+    return os.getcwd()
+
+async def main():
+    uri = "ws://127.0.0.1:8765"
+    logger.info(f"[AG2 Adapter] Connecting to Gateway at {uri}...")
+    
+    while True:
+        try:
+            async with websockets.connect(uri) as websocket:
+                logger.info("[AG2 Adapter] Connected to Gateway IPC.")
+                
+                import uuid
+                import os
+                id_file = APP_DATA_DIR / ".agent_id"
+                if id_file.exists():
+                    agent_id = id_file.read_text().strip()
+                else:
+                    agent_id = str(uuid.uuid4())
+                    id_file.write_text(agent_id)
+
+                # Register
+                await websocket.send(json.dumps({
+                    "type": "REGISTER_ADAPTER",
+                    "id": agent_id,
+                    "name": "ag2",
+                    "workspaceRoot": get_default_workspace()
+                }))
+                
+                convo_id = os.environ.get("AGY_CONVERSATION_ID") or get_latest_conversation_id(APP_DATA_DIR)
+                bridge = AgentBridge(websocket, str(APP_DATA_DIR), convo_id)
+                bridge._watch_task = asyncio.create_task(bridge.watch_brain_dir())
+                bridge._poll_task = asyncio.create_task(bridge.poll_transcript())
+                
+                try:
+                    async for message in websocket:
+                        try:
+                            data = json.loads(message)
+                            msg_type = data.get("type")
+                            
+                            if msg_type == "SUBSCRIBE_CONVERSATION":
+                                cid = data.get("conversationId")
+                                if cid:
+                                    bridge.conversation_id = cid
+                                if bridge.conversation_id:
+                                    await bridge.send_transcript(bridge.conversation_id)
+                                    await bridge.send_artifacts(bridge.conversation_id)
+                                await bridge.send_workspace(get_default_workspace())
+
+                            elif msg_type == "NEW_CONVERSATION":
+                                # ag2 does not support new conversations, but we shouldn't throw an error
+                                # because the Android app calls this automatically when switching agents.
+                                # Instead, just send the current session state.
+                                if bridge.conversation_id:
+                                    await bridge.send_transcript(bridge.conversation_id)
+
+                            elif msg_type == "GET_HISTORY":
+                                await bridge.send_history()
+
+                            elif msg_type == "GET_ARTIFACTS":
+                                cid = data.get("conversationId", bridge.conversation_id)
+                                if cid:
+                                    await bridge.send_artifacts(cid)
+
+                            elif msg_type == "READ_ARTIFACT":
+                                path = data.get("path")
+                                if path:
+                                    await bridge.read_artifact(path)
+
+                            elif msg_type == "GET_FILES":
+                                await bridge.send_workspace(get_default_workspace())
+                                
+                            elif msg_type == "READ_FILE":
+                                path = data.get("path")
+                                if path:
+                                    await bridge.read_file(path)
+                                
+                            elif msg_type == "SEND_MESSAGE":
+                                logger.info(f"[AG2 Adapter] Received SEND_MESSAGE: {data.get('text', '')[:50]}...")
+                                text = data.get("text", "")
+                                images = data.get("images", [])
+                                asyncio.create_task(bridge.process_message(text, images))
+                                
+                            elif msg_type == "PING":
+                                await websocket.send(json.dumps({"type": "PONG"}))
+                                
+                        except json.JSONDecodeError:
+                            pass
+                finally:
+                    await bridge.cleanup()
+                    
+        except Exception as e:
+            logger.warning(f"[AG2 Adapter] Connection error: {e}. Reconnecting in 3s...")
+            await asyncio.sleep(3)
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("\nAdapter shut down gracefully.")

antimatter_ag2-1.0.0/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "antimatter-ag2"
+version = "1.0.0"
+description = "Antimatter AG2 Adapter — companion daemon for Google AntiGravity IDE"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [
+    { name = "Saif Mukhtar", email = "saifmukhtar@saifmukhtar.dev" }
+]
+requires-python = ">=3.11"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development",
+    "Topic :: Communications",
+    "Intended Audience :: Developers",
+    "Environment :: Console",
+]
+keywords = ["antigravity", "ai", "ide", "mobile", "bridge", "websocket", "android"]
+dependencies = [
+    "websockets==15.0.1",
+    "google-antigravity==0.1.2",
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.23.0",
+]
+
+[project.urls]
+Homepage = "https://saifmukhtar.dev"
+Repository = "https://github.com/saifmukhtar/antimatter"
+Issues = "https://github.com/saifmukhtar/antimatter/issues"
+Documentation = "https://saifmukhtar.dev/docs/antimatter"
+Changelog = "https://github.com/saifmukhtar/antimatter/releases"
+
+[project.scripts]
+antimatter-ag2 = "antimatter_ag2.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["antimatter_ag2"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "antimatter_ag2",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]