entelligence-cli 0.1.0__tar.gz

entelligence_cli-0.1.0/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: entelligence-cli
+Version: 0.1.0
+Summary: EntelligenceAI CLI - AI-powered code review from your terminal
+Author-email: EntelligenceAI <info@entelligence.ai>
+License: MIT
+Project-URL: Homepage, https://entelligenceai.com
+Project-URL: Documentation, https://github.com/entelligenceai/cli#readme
+Project-URL: Repository, https://github.com/entelligenceai/cli
+Keywords: code-review,ai,cli,git,entelligence
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: flake8>=5.0.0; extra == "dev"
+Requires-Dist: mypy>=0.990; extra == "dev"
+
+# EntelligenceAI CLI
+
+AI-powered code review from your terminal.
+
+## Quick Start
+
+```bash
+# Setup (this will install uv if not already there)
+make setup
+
+# Authenticate
+entelligence auth login
+
+# Run review
+entelligence review
+```
+
+## Installation
+
+```bash
+# Development (recommended)
+make setup
+# or
+uv sync --dev
+
+# Production
+uv pip install entelligence-cli
+```
+
+## Authentication
+
+Get your API key from [app.entelligence.ai/settings?tab=api](https://app.entelligence.ai/settings?tab=api)
+
+```bash
+entelligence auth login
+entelligence auth status
+entelligence auth logout
+```
+
+## Usage
+
+```bash
+# Review changes
+entelligence review
+
+# Options
+entelligence review --base-branch main --priority high --mode concise
+entelligence review --include-uncommitted  # Include uncommitted changes
+entelligence review --plain                # Plain text output
+entelligence review --debug               # Debug mode
+```
+
+## Configuration
+
+**Config file:** `~/.entelligence/config.json` (permissions: `0o600`)
+
+**Stored locally:**
+- `api_key` - Saved during `entelligence auth login`
+
+**Fetched from backend:**
+- `OrgUUID` - Fetched from `/getUserInfo/` endpoint at session start (required)
+- `GitHubToken` - Fetched from `/getUserInfo/` endpoint at session start (optional)
+
+**Environment variables:**
+- `ENTELLIGENCE_API_KEY` - API key (auto-saved to config file on login)
+- `ENTELLIGENCE_ENDPOINT` - API endpoint (default: `http://127.0.0.1:8000/generateReviewForPR/`)
+
+## Development
+
+```bash
+make setup          # Initial setup
+make test           # Run tests
+make format         # Format code
+make lint           # Lint code
+make type-check     # Type check
+make check          # Run all checks
+make clean          # Clean build artifacts
+make help           # Show all commands
+```
+
+## Publishing
+
+The package is automatically published to PyPI when a new GitHub release is created.
+
+**Before publishing:**
+1. Update version in `pyproject.toml`
+2. Commit and push changes
+3. Create a new GitHub release (tagged with version, e.g., `v0.1.0`)
+
+**Manual publishing:**
+```bash
+# Build package
+uv build
+
+# Publish to PyPI (requires PyPI credentials)
+uv publish
+```
+
+**Setup PyPI Trusted Publisher (one-time):**
+1. Go to PyPI project settings → "Publishing" → "Add a new trusted publisher"
+2. Select "GitHub" as publisher
+3. Specify repository: `Entelligence-AI/cli`
+4. Workflow file: `.github/workflows/publish.yml`
+5. Environment name: `(Any)` or `pypi`
+
+## Uninstall
+
+```bash
+# Uninstall the CLI tool
+uv pip uninstall entelligence-cli
+
+# Remove configuration files (API keys, tokens, etc.)
+rm -rf ~/.entelligence/
+```
+
+## Troubleshooting
+
+**401 Unauthorized:** Verify API key with `entelligence auth status`
+
+**Connection errors:** Ensure backend is running at the configured endpoint

entelligence_cli-0.1.0/README.md

@@ -0,0 +1,120 @@
+# EntelligenceAI CLI
+
+AI-powered code review from your terminal.
+
+## Quick Start
+
+```bash
+# Setup (this will install uv if not already there)
+make setup
+
+# Authenticate
+entelligence auth login
+
+# Run review
+entelligence review
+```
+
+## Installation
+
+```bash
+# Development (recommended)
+make setup
+# or
+uv sync --dev
+
+# Production
+uv pip install entelligence-cli
+```
+
+## Authentication
+
+Get your API key from [app.entelligence.ai/settings?tab=api](https://app.entelligence.ai/settings?tab=api)
+
+```bash
+entelligence auth login
+entelligence auth status
+entelligence auth logout
+```
+
+## Usage
+
+```bash
+# Review changes
+entelligence review
+
+# Options
+entelligence review --base-branch main --priority high --mode concise
+entelligence review --include-uncommitted  # Include uncommitted changes
+entelligence review --plain                # Plain text output
+entelligence review --debug               # Debug mode
+```
+
+## Configuration
+
+**Config file:** `~/.entelligence/config.json` (permissions: `0o600`)
+
+**Stored locally:**
+- `api_key` - Saved during `entelligence auth login`
+
+**Fetched from backend:**
+- `OrgUUID` - Fetched from `/getUserInfo/` endpoint at session start (required)
+- `GitHubToken` - Fetched from `/getUserInfo/` endpoint at session start (optional)
+
+**Environment variables:**
+- `ENTELLIGENCE_API_KEY` - API key (auto-saved to config file on login)
+- `ENTELLIGENCE_ENDPOINT` - API endpoint (default: `http://127.0.0.1:8000/generateReviewForPR/`)
+
+## Development
+
+```bash
+make setup          # Initial setup
+make test           # Run tests
+make format         # Format code
+make lint           # Lint code
+make type-check     # Type check
+make check          # Run all checks
+make clean          # Clean build artifacts
+make help           # Show all commands
+```
+
+## Publishing
+
+The package is automatically published to PyPI when a new GitHub release is created.
+
+**Before publishing:**
+1. Update version in `pyproject.toml`
+2. Commit and push changes
+3. Create a new GitHub release (tagged with version, e.g., `v0.1.0`)
+
+**Manual publishing:**
+```bash
+# Build package
+uv build
+
+# Publish to PyPI (requires PyPI credentials)
+uv publish
+```
+
+**Setup PyPI Trusted Publisher (one-time):**
+1. Go to PyPI project settings → "Publishing" → "Add a new trusted publisher"
+2. Select "GitHub" as publisher
+3. Specify repository: `Entelligence-AI/cli`
+4. Workflow file: `.github/workflows/publish.yml`
+5. Environment name: `(Any)` or `pypi`
+
+## Uninstall
+
+```bash
+# Uninstall the CLI tool
+uv pip uninstall entelligence-cli
+
+# Remove configuration files (API keys, tokens, etc.)
+rm -rf ~/.entelligence/
+```
+
+## Troubleshooting
+
+**401 Unauthorized:** Verify API key with `entelligence auth status`
+
+**Connection errors:** Ensure backend is running at the configured endpoint

entelligence_cli-0.1.0/entelligence_cli/__init__.py

@@ -0,0 +1,10 @@
+"""EntelligenceAI CLI - AI-powered code review from your terminal."""
+
+__version__ = "0.1.0"
+
+from .cli import cli
+from .git_operations import GitOperations
+from .api_client import APIClient, APIConfig
+from .config import ConfigManager
+
+__all__ = ["cli", "GitOperations", "APIClient", "APIConfig", "ConfigManager"]

entelligence_cli-0.1.0/entelligence_cli/api_client.py

@@ -0,0 +1,350 @@
+import requests
+import logging
+from typing import Any, Dict, Optional, List
+import json
+from typing import Dict, Optional
+from dataclasses import dataclass
+
+@dataclass
+class APIConfig:
+    endpoint: str
+    api_token: Optional[str] = None
+    timeout: int = 300  # Increase default timeout to 5 minutes for longer reviews
+
+class APIClient:
+    def __init__(self, config: APIConfig):
+        self.config = config
+        
+    def generate_review(self, payload: Dict) -> Dict:
+        """Send code changes to EntelligenceAI for review."""
+        def _mask(tok: Optional[str]) -> str:
+            if not tok:
+                return "(empty)"
+            if len(tok) <= 8:
+                return "*" * (len(tok) - 1) + tok[-1]
+            return f"{tok[:4]}...{tok[-4:]}"
+        # Normalize API token
+        api_token = (self.config.api_token or "").strip()
+        headers = {
+            "Content-Type": "application/json",
+        }
+        
+        if api_token:
+            headers["Authorization"] = f"Bearer {api_token}"
+            logging.info(f"Using API key (masked): {_mask(api_token)}")
+        else:
+            logging.info("No API key provided; sending request without Authorization header.")
+        # Log presence of GitHub token in payload
+        gh_tok = ""
+        try:
+            gh_tok = (payload.get("githubToken") or "").strip()
+        except Exception:
+            pass
+        if gh_tok:
+            logging.info(f"Including githubToken in payload (masked): {_mask(gh_tok)}")
+        else:
+            logging.info("githubToken not set in payload or empty.")
+        
+        try:
+            logging.info(f"Sending request to {self.config.endpoint} (timeout {self.config.timeout}s)")
+            response = requests.post(
+                self.config.endpoint,
+                json=payload,
+                headers=headers,
+                timeout=self.config.timeout
+            )
+            logging.info(f"HTTP {response.status_code}")
+            response.raise_for_status()
+            return response.json()
+        
+        except requests.exceptions.Timeout:
+            return {"error": "Request timed out - review is taking longer than expected"}
+        except requests.exceptions.HTTPError as e:
+            return {"error": f"API error: {e.response.status_code} - {e.response.text}"}
+        except requests.exceptions.RequestException as e:
+            return {"error": f"Request failed: {str(e)}"}
+    
+    def _coerce_to_dict(self, resp: Any) -> Dict[str, Any]:
+        """
+        Try very hard to coerce backend response into a dict.
+        Handles: dict, bytes, JSON string, double-encoded JSON string,
+        and string with leading text before the first '{'.
+        """
+        # Unwrap bytes
+        if isinstance(resp, (bytes, bytearray)):
+            try:
+                resp = resp.decode("utf-8", errors="ignore")
+            except Exception:
+                pass
+        # Attempt up to 3 JSON parses (double-encoded cases)
+        for _ in range(3):
+            if isinstance(resp, dict):
+                return resp
+            if isinstance(resp, str):
+                s = resp.strip()
+                # If string has leading text, try to extract the first JSON object
+                if not (s.startswith("{") or s.startswith("[")):
+                    start = s.find("{")
+                    end = s.rfind("}")
+                    if start != -1 and end != -1 and end > start:
+                        s = s[start : end + 1]
+                try:
+                    resp = json.loads(s)
+                    continue
+                except Exception:
+                    break
+            else:
+                break
+        # Final fallback
+        if isinstance(resp, dict):
+            return resp
+        return {"raw_response": resp, "error": "Non-JSON or unexpected backend response"}
+
+    def parse_review_response(self, response: Any) -> Dict:
+        """Parse EntelligenceAI response into display format."""
+        # Normalize to a dict (supports double-encoded string cases)
+        response = self._coerce_to_dict(response)
+        if not isinstance(response, dict):
+            return {"error": "Unexpected backend response type", "raw_response": response}
+        if "error" in response and response["error"]:
+            return response
+        
+        # Normalize multiple possible response shapes
+        comments: list[Dict] = []
+        meta: Dict = {}
+        # Capture helpful meta so we can show it even without comments
+        for key in ("releaseNote", "walkthrough_and_changes", "file_overview", "pr_diff"):
+            if key in response:
+                meta[key] = response[key]
+        
+        # v1 format: {"review": {"files": [ {path, comments:[...]}, ... ] }, "security_findings": [...]}
+        if isinstance(response, dict) and "review" in response:
+            review_data = response["review"]
+            
+            # Parse file-level comments
+            if "files" in review_data:
+                for file_review in review_data["files"]:
+                    file_path = file_review.get("path", "unknown")
+                    
+                    if "comments" in file_review:
+                        for comment in file_review["comments"]:
+                            comments.append({
+                                "severity": comment.get("severity", "info"),
+                                "file": file_path,
+                                "line": comment.get("line"),
+                                "message": comment.get("message", ""),
+                                "code_snippet": comment.get("snippet", ""),
+                                "language": self._detect_language(file_path)
+                            })
+            
+            # Parse security findings
+            if "security_findings" in review_data:
+                for finding in review_data["security_findings"]:
+                    comments.append({
+                        "severity": "error",
+                        "file": finding.get("file", "unknown"),
+                        "line": finding.get("line"),
+                        "message": f"Security: {finding.get('description', '')}",
+                        "code_snippet": finding.get("snippet", ""),
+                        "language": self._detect_language(finding.get("file", ""))
+                    })
+        
+        # v2 format A: {"gitdiff_chunks_review": [ { "file"|"file_path"|"path": str, "comments":[...] }, ... ]}
+        # v2 format B: {"gitdiff_chunks_review": [ { "file_name"/"path": str, "body"/"bug_description": str, ... }, ... ]}
+        if isinstance(response, dict) and isinstance(response.get("gitdiff_chunks_review"), list):
+            for item in response["gitdiff_chunks_review"]:
+                # Case A: per-file bucket with comments array
+                if isinstance(item, dict) and isinstance(item.get("comments"), list):
+                    file_path = item.get("file") or item.get("file_path") or item.get("path") or "unknown"
+                    for c in item["comments"]:
+                        comments.append({
+                            "severity": c.get("severity", "info"),
+                            "file": file_path,
+                            "line": c.get("line") or c.get("lineno"),
+                            "message": c.get("message") or c.get("text") or "",
+                            "code_snippet": c.get("code_snippet") or c.get("snippet") or "",
+                            "language": self._detect_language(file_path),
+                        })
+                    continue
+                # Case B: each element is a single review object
+                if isinstance(item, dict):
+                    file_path = item.get("path") or item.get("file_name") or item.get("file") or "unknown"
+                    message = item.get("body") or item.get("bug_description") or ""
+                    line = item.get("line") or item.get("start_line") or None
+                    # Choose best snippet field (committable suggestion)
+                    snippet = (
+                        item.get("commitable_suggestion")  # common variant from backend
+                        or item.get("committable_suggestion")
+                        or item.get("committable_code")
+                        or item.get("commitable_code")
+                        or item.get("code_snippet")
+                        or ""
+                    )
+                    # Strip triple-fence if present for display/application
+                    if isinstance(snippet, str) and "```" in snippet:
+                        snippet = "\n".join(
+                            ln for ln in snippet.splitlines() if not ln.strip().startswith("```")
+                        ).strip()
+                    suggested_code = item.get("suggested_code") or ""
+                    # If suggested_code is a ```diff fenced block, strip the fence and keep as suggested_patch
+                    suggested_patch = None
+                    if isinstance(suggested_code, str) and "```" in suggested_code:
+                        sc = suggested_code.strip()
+                        if sc.startswith("```"):
+                            sc = sc.strip("`")
+                            # After stripping backticks, it might still include 'diff\n'
+                        # Simpler: just remove surrounding triple backticks lines
+                        lines = [ln for ln in suggested_code.splitlines() if not ln.strip().startswith("```")]
+                        suggested_patch = "\n".join(lines).strip()
+                    # Determine severity from fields
+                    suggestion_type = item.get("suggestion_type") or ""
+                    impact = (item.get("impact") or "").lower()
+                    sev = "info"
+                    if suggestion_type.lower() in ("bug fix", "bug", "error") or impact == "high":
+                        sev = "error"
+                    elif impact in ("medium", "med"):
+                        sev = "warning"
+                    else:
+                        sev = "suggestion"
+                    # Parse range "line_numbers": "16-26"
+                    apply_start = item.get("start_line")
+                    apply_end = item.get("end_line") or item.get("line")
+                    ln_range = item.get("line_numbers")
+                    if (apply_start is None or apply_end is None) and isinstance(ln_range, str) and "-" in ln_range:
+                        try:
+                            a, b = ln_range.split("-", 1)
+                            apply_start = apply_start or int(a.strip())
+                            apply_end = apply_end or int(b.strip())
+                        except Exception:
+                            pass
+                    # Capture optional agent prompt to display/copy
+                    agent_prompt_obj = item.get("prompt_for_ai_agents_for_addressing_review")
+                    agent_prompt_str = None
+                    if agent_prompt_obj is not None:
+                        try:
+                            agent_prompt_str = json.dumps(agent_prompt_obj, indent=2)
+                        except Exception:
+                            agent_prompt_str = str(agent_prompt_obj)
+                    extra = {
+                        "suggestion_type": item.get("suggestion_type"),
+                        "impact": item.get("impact"),
+                        "score": item.get("score"),
+                        "reasoning": item.get("reasoning"),
+                        "line_numbers": item.get("line_numbers"),
+                        "agent_prompt": agent_prompt_str,
+                    }
+                    comments.append({
+                        "severity": sev,
+                        "file": file_path,
+                        "line": line,
+                        "message": message,
+                        "code_snippet": snippet,
+                        "language": self._detect_language(file_path),
+                        "suggested_patch": suggested_patch,
+                        "apply_snippet": snippet,
+                        "apply_start": apply_start,
+                        "apply_end": apply_end,
+                        "ai_prompt": agent_prompt_str,
+                        "extra": extra,
+                    })
+        
+        # Build summary
+        summary = {
+            "files_changed": response.get("files_changed", 0) or len(meta.get("file_overview", {}).get("files_selected", [])),
+            "errors": len([c for c in comments if c["severity"] == "error"]),
+            "warnings": len([c for c in comments if c["severity"] == "warning"]),
+            "suggestions": len([c for c in comments if c["severity"] in ["info", "suggestion"]])
+        }
+        
+        return {
+            "comments": comments,
+            "summary": summary,
+            "meta": meta,
+            "raw_response": response  # Keep raw response for debugging
+        }
+    
+    def get_user_info(self) -> Optional[Dict[str, Any]]:
+        """Fetch user information from backend including org UUID, GitHub token, etc."""
+        if not self.config.api_token:
+            logging.warning("No API token available to fetch user info")
+            return None
+
+        # Extract base URL from endpoint (remove /generateReviewForPR/)
+        base_url = self.config.endpoint.rsplit('/', 2)[0] if '/' in self.config.endpoint else self.config.endpoint
+        user_info_url = f"{base_url}/getUserInfo/"
+
+        headers = {
+            "Authorization": f"Bearer {self.config.api_token}",
+        }
+
+        try:
+            logging.info(f"Fetching user info from {user_info_url}")
+            response = requests.get(
+                user_info_url,
+                headers=headers,
+                timeout=10
+            )
+            response.raise_for_status()
+            data = response.json()
+
+            # Handle potential double-stringified JSON
+            if isinstance(data, str):
+                try:
+                    data = json.loads(data)
+                except Exception:
+                    pass
+
+            if isinstance(data, dict):
+                if data.get("Error") or data.get("error"):
+                    error_msg = data.get("Error") or data.get("error")
+                    logging.warning(f"Error fetching user info: {error_msg}")
+                    return None
+
+                # Return the user info dict with expected fields
+                return {
+                    "UserUUID": data.get("UserUUID"),
+                    "OrgUUID": data.get("OrgUUID"),
+                    "OrgName": data.get("OrgName"),
+                    "Email": data.get("Email"),
+                    "Name": data.get("Name"),
+                    "GitHubToken": data.get("GitHubToken"),
+                }
+
+            return None
+        except requests.exceptions.HTTPError as e:
+            # Silently handle 404 (endpoint doesn't exist yet on older backends)
+            if e.response.status_code == 404:
+                logging.debug(f"getUserInfo endpoint not available (404) - using fallback")
+                return None
+            logging.warning(f"Failed to fetch user info: {str(e)}")
+            return None
+        except requests.exceptions.RequestException as e:
+            logging.debug(f"Failed to fetch user info: {str(e)}")
+            return None
+    
+    def _detect_language(self, file_path: str) -> str:
+        """Detect programming language from file extension."""
+        ext_map = {
+            ".py": "python",
+            ".js": "javascript",
+            ".ts": "typescript",
+            ".jsx": "javascript",
+            ".tsx": "typescript",
+            ".java": "java",
+            ".go": "go",
+            ".rs": "rust",
+            ".cpp": "cpp",
+            ".c": "c",
+            ".rb": "ruby",
+            ".php": "php",
+            ".swift": "swift",
+            ".kt": "kotlin",
+        }
+        
+        for ext, lang in ext_map.items():
+            if file_path.endswith(ext):
+                return lang
+        
+        return "text"
+
+