boomtick-cli 0.2.1__py3-none-any.whl

dev_tools/services/jules.py

@@ -0,0 +1,181 @@
+# pylint: disable=invalid-name,line-too-long,missing-docstring,missing-timeout,raise-missing-from
+import os
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Dict, List, Optional, Union
+
+import requests
+from dev_tools.utils import log_debug, log_info, log_warn
+
+
+class JulesClient:
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = api_key or os.environ.get("JULES_API_KEY")
+        if not self.api_key:
+            raise ValueError("JULES_API_KEY is not set or empty")
+
+        self.base_url = "https://jules.googleapis.com/v1alpha"
+        self.legacy_url = "https://api.jules.ai/v1/sessions"
+        self.headers = {"Content-Type": "application/json", "x-goog-api-key": self.api_key}
+
+    def _get_clean_id(self, res_id: str, prefix: str) -> str:
+        return res_id.replace(f"{prefix}/", "")
+
+    def list_sources(self) -> List[Dict[str, Any]]:
+        url = f"{self.base_url}/sources"
+        response = requests.get(url, headers=self.headers, timeout=10)
+        response.raise_for_status()
+        return response.json().get("sources", [])
+
+    def list_sessions(self, pageSize: int = 100) -> List[Dict[str, Any]]:
+        url = f"{self.base_url}/sessions"
+        params = {"pageSize": pageSize}
+        response = requests.get(url, headers=self.headers, params=params, timeout=10)
+        response.raise_for_status()
+        return response.json().get("sessions", [])
+
+    def get_session(self, session_id: str) -> Optional[Dict[str, Any]]:
+        clean_id = self._get_clean_id(session_id, "sessions")
+        url = f"{self.base_url}/sessions/{clean_id}"
+        response = requests.get(url, headers=self.headers, timeout=10)
+        response.raise_for_status()
+        return response.json()
+
+    def discover_source_id(self, repo_full_name: str) -> Optional[str]:
+        sources = self.list_sources()
+        for s in sources:
+            ctx = s.get("githubRepo", {})
+            owner, repo = ctx.get("owner"), ctx.get("repo")
+            if owner and repo and f"{owner}/{repo}" == repo_full_name:
+                return self._get_clean_id(s.get("name") or "", "sources")
+            if repo_full_name in s.get("displayName", ""):
+                return self._get_clean_id(s.get("name") or "", "sources")
+        return None
+
+    def create_session_from_source(self, source_id: str, branch: str, prompt: str) -> Optional[Dict[str, Any]]:
+        url = f"{self.base_url}/sessions"
+        clean_source_id = self._get_clean_id(source_id, "sources")
+        payload = {
+            "prompt": prompt,
+            "sourceContext": {
+                "source": f"sources/{clean_source_id}",
+                "githubRepoContext": {"startingBranch": branch},
+            },
+            "automationMode": "AUTO_CREATE_PR",
+        }
+
+        log_debug(f"Creating Jules session at {url}")
+        log_debug(f"Payload: {payload}")
+
+        response = requests.post(url, headers=self.headers, json=payload, timeout=15)
+        response.raise_for_status()
+        return response.json()
+
+    def create_session(self, prompt: str, branch: str, title: str, owner: str, repo_name: str) -> str:
+        """Creates a new Jules session via the legacy API."""
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+        payload = {
+            "prompt": prompt,
+            "branch": branch,
+            "title": title,
+            "owner": owner,
+            "repo_name": repo_name,
+        }
+        try:
+            response = requests.post(self.legacy_url, headers=headers, json=payload)
+            response.raise_for_status()
+            session_id = response.json().get("id")
+            if not session_id:
+                raise RuntimeError("Could not find session ID in API response.")
+            return session_id
+        except requests.exceptions.RequestException as e:
+            error_msg = f"Error creating Jules session: {e}"
+            if e.response is not None:
+                error_msg += f"\nResponse: {e.response.text}"
+            raise RuntimeError(error_msg)
+
+    def _extract_activity_content(self, act: Dict[str, Any]) -> str:
+        if act.get("userMessaged"):
+            um = act["userMessaged"]
+            if isinstance(um, str):
+                return um
+            if isinstance(um, dict):
+                user_msg = um.get("userMessage", "")
+                return user_msg.get("body", "") if isinstance(user_msg, dict) else user_msg
+        elif act.get("progressUpdated") and isinstance(act["progressUpdated"], dict):
+            return act["progressUpdated"].get("description", "")
+        elif act.get("planGenerated") and isinstance(act["planGenerated"], dict):
+            plan = act["planGenerated"].get("plan") or {}
+            steps = plan.get("steps", []) if isinstance(plan, dict) else []
+            return "Generated plan:\n" + "\n".join(
+                f"- {s.get('description', '')}" for s in steps if isinstance(s, dict)
+            )
+        elif act.get("sessionCompleted"):
+            return "Session completed successfully."
+        return ""
+
+    def get_messages(self, session_id: str, timeout: int = 10) -> List[Dict[str, Any]]:
+        clean_id = self._get_clean_id(session_id, "sessions")
+        url = f"{self.base_url}/sessions/{clean_id}/activities"
+        response = requests.get(url, headers=self.headers, timeout=timeout)
+        response.raise_for_status()
+        activities = response.json().get("activities", [])
+        messages = []
+        for act in activities:
+            content = self._extract_activity_content(act)
+            if content:
+                messages.append(
+                    {
+                        "role": "user" if act.get("originator") == "user" else "jules",
+                        "content": content,
+                        "time": act.get("createTime"),
+                    }
+                )
+        return messages
+
+    def send_message(self, session_id: Union[str, List[str]], message: str) -> Dict[str, Any]:
+        session_ids = [session_id] if isinstance(session_id, str) else session_id
+
+        if len(session_ids) == 1:
+            return self._send_single_message(session_ids[0], message)
+
+        # The Pydantic model now enforces the BATCH_CAP, but we keep this as a secondary safety
+        BATCH_CAP = 50
+        if len(session_ids) > BATCH_CAP:
+            log_warn(f"Batch size {len(session_ids)} exceeds cap of {BATCH_CAP}. Truncating.")
+            session_ids = session_ids[:BATCH_CAP]
+
+        log_info(f"Batch sending message to {len(session_ids)} sessions...")
+
+        results = []
+        with ThreadPoolExecutor(max_workers=min(len(session_ids), 10)) as executor:
+            # Submit all tasks and keep track of futures in order
+            futures = [executor.submit(self._send_single_message, sid, message) for sid in session_ids]
+
+            # Reconstruct results in the original input order by iterating over the futures list
+            for sid, future in zip(session_ids, futures):
+                try:
+                    future.result()
+                    results.append({"sessionId": sid, "status": "success"})
+                except Exception as exc:
+                    log_warn(f"Failed to send message to {sid}: {exc}")
+                    results.append({"sessionId": sid, "status": "error", "message": str(exc)})
+
+        return {
+            "status": "success" if any(r["status"] == "success" for r in results) else "error",
+            "message": f"Batch send completed. {sum(1 for r in results if r['status'] == 'success')}/{len(session_ids)} successful.",
+            "results": results,
+        }
+
+    def _send_single_message(self, session_id: str, message: str) -> Dict[str, Any]:
+        clean_id = self._get_clean_id(session_id, "sessions")
+        url = f"{self.base_url}/sessions/{clean_id}:sendMessage"
+        response = requests.post(url, headers=self.headers, json={"prompt": message}, timeout=10)
+        response.raise_for_status()
+        return {"status": "success", "message": "Message sent successfully"}
+
+    def cancel_session(self, session_id: str) -> Dict[str, Any]:
+        clean_id = self._get_clean_id(session_id, "sessions")
+        url = f"{self.base_url}/sessions/{clean_id}"
+        response = requests.delete(url, headers=self.headers, timeout=10)
+        response.raise_for_status()
+        return {"status": "success", "message": "Session cancelled successfully"}

dev_tools/services/repair_service.py

@@ -0,0 +1,199 @@
+# pylint: disable=f-string-without-interpolation,line-too-long,missing-docstring,too-few-public-methods,unused-variable
+import json
+import os
+import re
+import sys
+from typing import Any, Dict, Optional
+
+from dev_tools.utils import log_warn
+
+
+def resolve_file_path(path: str) -> Optional[str]:
+    """Resolves path relative to current working directory or via filename lookup."""
+    if not path:
+        return None
+
+    # 1. Direct check (if absolute and exists, we take it, but we prefer relative)
+    if os.path.isabs(path) and os.path.exists(path):
+        # If it's absolute but under current directory, make it relative
+        try:
+            rel = os.path.relpath(path)
+            if not rel.startswith(".."):
+                return rel
+        except ValueError:
+            pass
+
+    # 2. Try stripping leading common absolute paths (like /app/ or /workspace/)
+    # We look for the first part that actually exists in the current directory relative to CWD
+    parts = [p for p in path.split(os.sep) if p]
+    for i in range(len(parts)):
+        subpath = os.path.join(*parts[i:])
+        if subpath and os.path.exists(subpath):
+            return subpath
+
+    # 3. Fallback to basename lookup in current directory (recursive)
+    filename = os.path.basename(path)
+    for root, dirs, files in os.walk("."):
+        if filename in files:
+            found_path = os.path.join(root, filename)
+            if found_path.startswith("./"):
+                return found_path[2:]
+            return found_path
+
+    return None
+
+
+def strip_ansi(text: str) -> str:
+    """Strips ANSI color codes from string."""
+    ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+    return ansi_escape.sub("", text)
+
+
+class SignatureExtractor:
+    """Extracts file, line, and error signature from logs."""
+
+    # ESLint stylish: /app/src/App.tsx:10:5: 'unused' is defined but never used. [eslint/no-unused-vars]
+    # ESLint compact: /app/src/App.tsx: line 10, col 5, Error - 'unused' is defined but never used. [eslint/no-unused-vars]
+    ESLINT_PATTERN = re.compile(r"^(.*?):(\d+):(\d+): (.*) \[(.*)\]$")
+    ESLINT_COMPACT_PATTERN = re.compile(r"^(.*?): line (\d+), col (\d+), (?:Error|Warning) - (.*) \[(.*)\]$")
+
+    # TS example: src/App.tsx:10:5 - error TS2322: Type 'string' is not assignable to type 'number'.
+    TS_PATTERN = re.compile(r"^(.*?):(\d+):(\d+) - error (TS\d+): (.*)$")
+
+    # TS alternate: src/App.tsx(10,5): error TS2322: ...
+    TS_ALT_PATTERN = re.compile(r"^(.*?)\((\d+),(\d+)\): error (TS\d+): (.*)$")
+
+    @staticmethod
+    def _parse_ts(match) -> Dict[str, Any]:
+        return {
+            "file": match.group(1),
+            "line": int(match.group(2)),
+            "col": int(match.group(3)),
+            "message": match.group(5),
+            "signature": f"ts/{match.group(4)[2:]}",  # Normalize TS2322 to ts/2322
+        }
+
+    @classmethod
+    def extract(cls, log_line: str) -> Optional[Dict[str, Any]]:
+        log_line = strip_ansi(log_line.strip())
+
+        # Try ESLint
+        match = cls.ESLINT_PATTERN.match(log_line) or cls.ESLINT_COMPACT_PATTERN.match(log_line)
+        if match:
+            sig = match.group(5)
+            if not sig.startswith("eslint/") and "/" not in sig:
+                sig = f"eslint/{sig}"
+            return {
+                "file": match.group(1),
+                "line": int(match.group(2)),
+                "col": int(match.group(3)),
+                "message": match.group(4),
+                "signature": sig,
+            }
+
+        # Try TS
+        match = cls.TS_PATTERN.match(log_line)
+        if match:
+            return cls._parse_ts(match)
+
+        # Try TS Alt
+        match = cls.TS_ALT_PATTERN.match(log_line)
+        if match:
+            return cls._parse_ts(match)
+
+        return None
+
+
+class ASTContextualizer:
+    """Extracts surrounding code block for a given line."""
+
+    @staticmethod
+    def extract_context(filepath: str, line_number: int, window: int = 15) -> Optional[str]:
+        """
+        Extracts a deterministic window of code around line_number.
+        Uses a fixed window to avoid brittle indentation heuristics.
+        """
+        if not os.path.exists(filepath):
+            return None
+
+        try:
+            with open(filepath, "r", encoding="utf-8") as f:
+                lines = f.readlines()
+        except Exception as e:
+            log_warn(f"Failed to read file {filepath} for context extraction: {e}")
+            return None
+        if not lines:
+            return None
+
+        # Adjust to 0-indexed
+        idx = line_number - 1
+        if idx < 0 or idx >= len(lines):
+            return None
+
+        # Use a deterministic window
+        start_idx = max(0, idx - window)
+        end_idx = min(len(lines) - 1, idx + window)
+
+        context_lines = lines[start_idx : end_idx + 1]
+        return "".join(context_lines)
+
+
+class RepairService:
+    """Coordinates extraction, lookup, and prompt construction."""
+
+    def __init__(self, knowledge_base_path: Optional[str] = None):
+        if knowledge_base_path is None:
+            if os.path.exists(".agents/knowledge/errors.json"):
+                knowledge_base_path = ".agents/knowledge/errors.json"
+            else:
+                knowledge_base_path = ".jules/knowledge/errors.json"
+        self.knowledge_base_path = knowledge_base_path
+        self.knowledge_base = self._load_kb()
+
+    def _load_kb(self) -> Dict[str, Any]:
+        if not os.path.exists(self.knowledge_base_path):
+            return {}
+        try:
+            with open(self.knowledge_base_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except json.JSONDecodeError as e:
+            print(f"⚠️ Warning: Knowledge base JSON is invalid: {e}", file=sys.stderr)
+            return {}
+        except Exception as e:
+            print(f"⚠️ Warning: Failed to load knowledge base: {e}", file=sys.stderr)
+            return {}
+
+    def generate_prompt(self, log_line: str) -> Optional[str]:
+        extracted = SignatureExtractor.extract(log_line)
+        if not extracted:
+            return None
+
+        sig = extracted["signature"]
+        strategy_data = self.knowledge_base.get(sig, {})
+        strategy = strategy_data.get("strategy", "Investigate the error and apply a fix based on common practices.")
+        examples = strategy_data.get("examples", [])
+
+        # Adjust file path for context extraction
+        filepath = resolve_file_path(extracted["file"])
+        context = ASTContextualizer.extract_context(filepath, extracted["line"]) if filepath else None
+
+        prompt = f"### Error Report\n"
+        prompt += f"- **File**: `{extracted['file']}`\n"
+        prompt += f"- **Line**: {extracted['line']}\n"
+        prompt += f"- **Error**: `{extracted['signature']}`: {extracted['message']}\n\n"
+
+        prompt += f"### Fix Strategy\n"
+        prompt += f"{strategy}\n\n"
+
+        if examples:
+            prompt += "### Few-Shot Examples\n"
+            for ex in examples:
+                prompt += f"**Before:**\n```\n{ex['before']}\n```\n"
+                prompt += f"**After:**\n```\n{ex['after']}\n```\n"
+            prompt += "\n"
+
+        if context:
+            prompt += "### Code Context\n"
+            prompt += f"```tsx\n{context}\n```\n"
+
+        return prompt

dev_tools/services/vector_store.py

@@ -0,0 +1,82 @@
+# pylint: disable=missing-docstring
+from typing import Any, Dict, List
+
+import chromadb
+from chromadb.utils import embedding_functions
+
+
+class VectorStore:
+    def __init__(self, persist_directory: str = "artifacts/chroma_db", collection_name: str = "codebase"):
+        self.persist_directory = persist_directory
+        self.collection_name = collection_name
+        self._client = None
+        self._collection = None
+        self._embedding_fn = None
+
+    @property
+    def client(self):
+        if self._client is None and self.is_available():
+            self._client = chromadb.PersistentClient(path=self.persist_directory)
+        return self._client
+
+    @property
+    def embedding_fn(self):
+        if self._embedding_fn is None and self.is_available():
+            self._embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(model_name="all-MiniLM-L6-v2")
+        return self._embedding_fn
+
+    @property
+    def collection(self):
+        if self._collection is None:
+            client = self.client
+            embedding_fn = self.embedding_fn
+            if client and embedding_fn:
+                self._collection = client.get_or_create_collection(
+                    name=self.collection_name, embedding_function=embedding_fn
+                )
+        return self._collection
+
+    def is_available(self) -> bool:
+        """Checks if ChromaDB and dependencies are available."""
+        return True
+
+    def add_documents(self, documents: List[str], metadatas: List[Dict[str, Any]], ids: List[str]):
+        """Adds documents to the collection."""
+        collection = self.collection
+        if collection:
+            collection.add(documents=documents, metadatas=metadatas, ids=ids)
+
+    def query(self, query_text: str, n_results: int = 5) -> List[Dict[str, Any]]:
+        """Queries the collection for similar documents."""
+        collection = self.collection
+        if not collection:
+            return []
+
+        results = collection.query(query_texts=[query_text], n_results=n_results)
+
+        # Format results for easier consumption
+        formatted_results = []
+        if results["documents"]:
+            for i in range(len(results["documents"][0])):
+                formatted_results.append(
+                    {
+                        "document": results["documents"][0][i],
+                        "metadata": results["metadatas"][0][i],
+                        "id": results["ids"][0][i],
+                        "distance": results["distances"][0][i] if "distances" in results else None,
+                    }
+                )
+        return formatted_results
+
+    def reset(self):
+        """Resets the collection."""
+        client = self.client
+        embedding_fn = self.embedding_fn
+        if not client or not embedding_fn:
+            return
+
+        try:
+            client.delete_collection(self.collection_name)
+        except Exception:
+            pass
+        self._collection = client.create_collection(name=self.collection_name, embedding_function=embedding_fn)

dev_tools/services/vision_service.py

@@ -0,0 +1,91 @@
+# pylint: disable=import-outside-toplevel,line-too-long,missing-docstring,no-name-in-module
+import base64
+import json
+import os
+from typing import Dict, List, Optional
+
+from dev_tools.config import load_project_config
+from dev_tools.utils import get_github_token, log_error
+
+PROJECT_CONFIG = load_project_config()
+
+
+class VisionService:
+    """Vision-based regression audit service via AI API."""
+
+    def __init__(self, model: Optional[str] = None):
+        self.model = model or os.environ.get("VISION_MODEL", PROJECT_CONFIG.ai_vision_model)
+        self.token = get_github_token()
+
+    def call_ai(self, prompt: str, image_paths: List[str]) -> Optional[str]:
+        """Calls the AI model with text prompt and images."""
+        images = []
+        for p in image_paths:
+            if os.path.exists(p):
+                with open(p, "rb") as f:
+                    images.append(base64.b64encode(f.read()).decode("utf-8"))
+
+        if not images:
+            return None
+
+        if not self.token:
+            return "No GITHUB_TOKEN found."
+
+        from dev_tools.utils import _request
+
+        message_content = [{"type": "text", "text": prompt}]
+        for img in images:
+            message_content.append({"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img}"}})
+
+        url_target = "https://models.inference.ai.azure.com/chat/completions"
+        headers = {"Authorization": f"Bearer {self.token}", "Content-Type": "application/json"}
+        payload = {
+            "model": self.model,
+            "messages": [{"role": "user", "content": message_content}],
+            "temperature": 0.7,
+            "max_tokens": 2048,
+        }
+
+        try:
+            response = _request(
+                "POST",
+                url_target,
+                headers=headers,
+                json=payload,
+                retry_status_codes=[429, 500, 502, 503, 504],
+            )
+            if not response:
+                return None
+            return response.json()["choices"][0]["message"]["content"]
+        except Exception as e:
+            return f"❌ Vision call failed: {e}"
+
+    def analyze_visual_changes(self, summary_path: str, project_root: str) -> Dict[str, str]:
+        """Analyzes visual changes based on a summary JSON file."""
+        if not os.path.exists(summary_path):
+            return {}
+
+        try:
+            with open(summary_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+        except FileNotFoundError:
+            log_error(f"Visual summary file not found: {summary_path}")
+            return {}
+        except json.JSONDecodeError as e:
+            log_error(f"Malformed visual summary JSON: {e}")
+            return {}
+
+        routes = data.get("routes", [])
+        results = {}
+
+        for s in routes:
+            before, after = s.get("beforeCroppedPath"), s.get("afterCroppedPath")
+            if not (before and after):
+                continue
+
+            prompt = f"Analyze visual changes for {s['route']}. Describe what changed between BEFORE and AFTER. Identify bugs vs improvements. Be concise."
+            res = self.call_ai(prompt, [os.path.join(project_root, before), os.path.join(project_root, after)])
+            if res:
+                results[s["route"]] = res
+
+        return results

dev_tools/td_cli.py

@@ -0,0 +1,28 @@
+# pylint: disable=import-outside-toplevel,missing-docstring
+#!/usr/bin/env python3
+"""
+td_cli.py - Project Developer CLI Shim
+
+This script is a thin wrapper around the unified dev_tools CLI.
+It maintains backward compatibility for existing scripts and CI workflows.
+"""
+
+import sys
+
+
+def main():
+    """Entry point for the td-cli shim."""
+    try:
+        from dev_tools.cli import main as cli_main
+
+        cli_main()
+    except ImportError as e:
+        # Handle missing dependencies gracefully (e.g. click, pydantic)
+        print(f"❌ Error: {e}", file=sys.stderr)
+        print("   The environment might not be fully bootstrapped.", file=sys.stderr)
+        print("   Run `pip install -e boomtick-pkg/cli/` to install dependencies.", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()