omga-cli 1.1.0__py3-none-any.whl

core/__init__.py

@@ -0,0 +1,7 @@
+"""
+omga-cli – AI-Powered Development Assistant
+"""
+
+__version__ = "1.0.0"
+__author__  = "Pouria Hosseini"
+__email__   = "PouriaHosseini@outlook.com"

core/ai.py

@@ -0,0 +1,399 @@
+import json
+import time
+import threading
+from typing import Iterator, List, Optional
+
+import requests
+
+from core.cache_db import get as cache_get, set_ as cache_set
+from core.config import get_api_key, get_config_value
+from core.logger import logger
+
+# ── API constants ──────────────────────────────────────────────────────────────
+_BASE_URL = "https://openrouter.ai/api/v1/chat/completions"
+_REFERER  = "https://github.com/omga-cli"
+_APP_NAME = "omga-cli"
+
+_SYSTEM_PROMPT_EN = (
+    "You are an expert AI coding assistant integrated into omga-cli, "
+    "developed by Pouria Hosseini (@isPoori — PouriaHosseini.ir). "
+    "You are precise and always produce complete, production-quality output.\n"
+    "RULES (non-negotiable):\n"
+    "- Never truncate your response. Write the complete answer every time.\n"
+    "- Never say 'continued below', 'see next', or '# ... rest unchanged'.\n"
+    "- When returning code use the appropriate markdown code fence.\n"
+    "- Think step by step before answering complex questions.\n"
+    "- State uncertainty clearly rather than guessing."
+)
+
+_SYSTEM_PROMPT_FA = (
+    "You are an expert AI coding assistant integrated into omga-cli, "
+    "developed by Pouria Hosseini (@isPoori — PouriaHosseini.ir). "
+    "You are precise and always produce complete, production-quality output.\n"
+    "RULES (non-negotiable):\n"
+    "- Never truncate your response. Write the complete answer every time.\n"
+    "- Never say 'continued below', 'see next', or '# ... rest unchanged'.\n"
+    "- When returning code use the appropriate markdown code fence.\n"
+    "- Think step by step before answering complex questions.\n"
+    "- State uncertainty clearly rather than guessing.\n\n"
+    "LANGUAGE RULE: The user is writing in Persian (Farsi — فارسی). "
+    "You MUST reply entirely in Persian. "
+    "Use proper Persian grammar, punctuation, and technical terminology. "
+    "Code identifiers remain in English; all prose must be in Persian."
+)
+
+_RETRYABLE = frozenset({429, 500, 502, 503, 504})
+
+
+# ── Persian detection ──────────────────────────────────────────────────────────
+
+def _has_persian(text: str) -> bool:
+    """Return True if *text* contains Persian/Arabic Unicode characters."""
+    for ch in text:
+        cp = ord(ch)
+        if 0x0600 <= cp <= 0x06FF or 0xFB50 <= cp <= 0xFDFF or 0xFE70 <= cp <= 0xFEFF:
+            return True
+    return False
+
+
+def _system_prompt(prompt: str) -> str:
+    return _SYSTEM_PROMPT_FA if _has_persian(prompt) else _SYSTEM_PROMPT_EN
+
+
+# ── HTTP helpers ───────────────────────────────────────────────────────────────
+
+def _headers() -> dict:
+    return {
+        "Content-Type":  "application/json",
+        "Authorization": f"Bearer {get_api_key()}",
+        "HTTP-Referer":  _REFERER,
+        "X-Title":       _APP_NAME,
+    }
+
+
+def _payload(prompt: str, *, stream: bool = False) -> dict:
+    return {
+        "model":       get_config_value("api.model", "arcee-ai/trinity-large-preview:free"),
+        "max_tokens":  get_config_value("api.max_tokens", 8192),
+        "temperature": get_config_value("api.temperature", 0.7),
+        "stream":      stream,
+        "messages": [
+            {"role": "system", "content": _system_prompt(prompt)},
+            {"role": "user",   "content": prompt},
+        ],
+    }
+
+
+def _parse_error(resp: requests.Response) -> str:
+    try:
+        return resp.json().get("error", {}).get("message", resp.text[:300])
+    except Exception:
+        return resp.text[:300]
+
+
+def _backoff(attempt: int) -> None:
+    time.sleep(min(2 ** attempt, 16))
+
+
+# ── Low-level streaming request ────────────────────────────────────────────────
+
+def _request_stream(prompt: str, retries: int = 3) -> Iterator[str]:
+    """
+    Open a streaming POST and yield SSE content chunks.
+    Retries on transient server errors (429, 5xx) with exponential back-off.
+    All other errors propagate immediately.
+    """
+    timeout = get_config_value("api.timeout", 60)
+
+    for attempt in range(1, retries + 1):
+        try:
+            resp = requests.post(
+                _BASE_URL,
+                json=_payload(prompt, stream=True),
+                headers=_headers(),
+                timeout=timeout,
+                stream=True,
+            )
+
+            if not resp.ok:
+                detail = _parse_error(resp)
+                logger.error("Stream API %s attempt %d: %s", resp.status_code, attempt, detail)
+                if not resp.status_code in _RETRYABLE:
+                    raise RuntimeError(f"API error {resp.status_code}: {detail}")
+            else:
+                for raw_line in resp.iter_lines(decode_unicode=True):
+                    if not raw_line or not raw_line.startswith("data: "):
+                        continue
+                    payload = raw_line[6:].strip()
+                    if payload == "[DONE]":
+                        return
+                    try:
+                        data  = json.loads(payload)
+                        delta = (data.get("choices") or [{}])[0].get("delta", {})
+                        chunk = delta.get("content", "")
+                        if chunk:
+                            yield chunk
+                    except (json.JSONDecodeError, IndexError):
+                        continue
+                return  # clean EOF
+
+        except RuntimeError:
+            raise
+        except (requests.ConnectionError, requests.Timeout) as exc:
+            logger.warning("Network error stream attempt %d/%d: %s", attempt, retries, exc)
+        except Exception:
+            raise
+
+        if attempt < retries:
+            _backoff(attempt)
+
+    raise RuntimeError("AI service unavailable after multiple retries.")
+
+
+# ── Public: ask_stream  (spinner → stream) ─────────────────────────────────────
+
+def ask_stream(prompt: str, context: Optional[str] = None) -> Iterator[str]:
+    """
+    Send *prompt* and yield response chunks with the full UX flow:
+
+        spinner (waiting for first token)  →  streaming panel (word-by-word)
+
+    Steps
+    ──────
+    1. Cache hit  → replay stored text in small chunks, no network call.
+    2. Cache miss →
+       a. Background thread opens the stream and waits for the first chunk.
+       b. Main thread shows the thinking spinner.
+       c. When the first chunk arrives the background thread sets an event.
+       d. Spinner stops; main thread yields all chunks to the caller.
+       e. Caller's Live panel renders them word-by-word.
+       f. Complete response is written to cache after the stream ends.
+    """
+    from core.ui import ui   # lazy — avoids circular import at module load
+
+    full_prompt = f"Context:\n{context}\n\n{prompt}" if context else prompt
+    persian     = _has_persian(full_prompt)
+
+    # ── 1. Cache check ─────────────────────────────────────────────────────────
+    if get_config_value("features.cache_responses", True):
+        cached = cache_get(full_prompt)
+        if cached:
+            logger.debug("Cache hit, replaying %d chars", len(cached))
+            for i in range(0, len(cached), 4):
+                yield cached[i:i + 4]
+            return
+
+    # ── 2. Prime the stream in a background thread ─────────────────────────────
+    # We buffer only the *first* chunk here; the rest are yielded directly
+    # after the spinner exits so no large buffer is ever held in memory.
+
+    ready_event:     threading.Event     = threading.Event()
+    first_buf:       List[str]           = []   # holds at most one chunk
+    prime_error:     List[Exception]     = []
+    gen_holder:      List[Iterator[str]] = []   # the live generator
+
+    def _prime() -> None:
+        try:
+            gen = _request_stream(full_prompt)
+            gen_holder.append(gen)
+            try:
+                chunk = next(gen)
+                if chunk:
+                    first_buf.append(chunk)
+            except StopIteration:
+                pass                    # empty stream — edge case
+        except Exception as exc:
+            prime_error.append(exc)
+        finally:
+            ready_event.set()           # always unblock the main thread
+
+    threading.Thread(target=_prime, daemon=True).start()
+
+    # ── 3. Show spinner until first token arrives ──────────────────────────────
+    with ui.thinking_spinner(persian=persian):
+        ready_event.wait()              # blocks here; spinner animates freely
+
+    # ── 4. Spinner is gone — propagate any error ───────────────────────────────
+    if prime_error:
+        raise prime_error[0]
+
+    # ── 5. Yield all chunks to the caller ─────────────────────────────────────
+    accumulated: List[str] = []
+
+    for chunk in first_buf:
+        accumulated.append(chunk)
+        yield chunk
+
+    if gen_holder:
+        try:
+            for chunk in gen_holder[0]:
+                accumulated.append(chunk)
+                yield chunk
+        except Exception as exc:
+            logger.error("Stream interrupted mid-response: %s", exc)
+            if not accumulated:
+                raise           # nothing delivered yet — surface the error
+            # Otherwise: partial response already shown; log and stop cleanly
+
+    # ── 6. Persist complete response to cache ─────────────────────────────────
+    full_text = "".join(accumulated)
+    if full_text and get_config_value("features.cache_responses", True):
+        cache_set(full_prompt, full_text)
+
+
+# ── Public: ask  (blocking, collects full stream) ─────────────────────────────
+
+def ask(prompt: str, context: Optional[str] = None, *, use_cache: bool = True) -> str:
+    """
+    Send *prompt* and return the complete response as a string.
+
+    Internally calls ask_stream() so the spinner → stream UX applies
+    even for callers that only want the final string.
+
+    use_cache=False forces a fresh network call (used by generate_project_code).
+    """
+    if not use_cache:
+        # Bypass cache by using a unique sentinel suffix that is never stored
+        _sentinel = "\x00nocache"
+        parts: List[str] = []
+        full = f"Context:\n{context}\n\n{prompt}" if context else prompt
+        # Call _request_stream directly to avoid cache logic in ask_stream
+        from core.ui import ui
+        persian = _has_persian(full)
+
+        ready_event  = threading.Event()
+        first_buf:   List[str]           = []
+        prime_error: List[Exception]     = []
+        gen_holder:  List[Iterator[str]] = []
+
+        def _prime_nocache() -> None:
+            try:
+                gen = _request_stream(full)
+                gen_holder.append(gen)
+                try:
+                    chunk = next(gen)
+                    if chunk:
+                        first_buf.append(chunk)
+                except StopIteration:
+                    pass
+            except Exception as exc:
+                prime_error.append(exc)
+            finally:
+                ready_event.set()
+
+        threading.Thread(target=_prime_nocache, daemon=True).start()
+        with ui.thinking_spinner(persian=persian):
+            ready_event.wait()
+        if prime_error:
+            raise prime_error[0]
+        parts.extend(first_buf)
+        if gen_holder:
+            parts.extend(gen_holder[0])
+        return "".join(parts)
+
+    parts = list(ask_stream(prompt, context))
+    return "".join(parts)
+
+
+# ── Specialised helpers ────────────────────────────────────────────────────────
+
+def explain_code(code: str, language: str = "python") -> str:
+    prompt = (
+        f"Explain the following {language} code in full detail. "
+        f"Do NOT truncate — write the complete explanation.\n\n"
+        f"```{language}\n{code}\n```\n\n"
+        f"Structure your response as:\n"
+        f"1. **Overview** – what the code does in one paragraph\n"
+        f"2. **Step-by-step breakdown** – every significant block explained\n"
+        f"3. **Key concepts** – patterns, algorithms, or techniques used\n"
+        f"4. **Potential issues** – bugs, edge-cases, security concerns\n"
+        f"5. **Improvement suggestions** – actionable ideas with code snippets\n"
+    )
+    return ask(prompt)
+
+
+def fix_code(code: str, language: str = "python", issues: Optional[str] = None) -> str:
+    issue_block = f"\nKnown issues to address:\n{issues}\n" if issues else ""
+    prompt = (
+        f"Fix ALL problems in the following {language} code.\n"
+        f"{issue_block}\n"
+        f"```{language}\n{code}\n```\n\n"
+        f"Requirements:\n"
+        f"- Fix every syntax error, logic bug, and style violation.\n"
+        f"- Improve error handling and input validation.\n"
+        f"- Add brief inline comments for non-obvious changes.\n"
+        f"- Return the COMPLETE corrected file in a single code fence.\n"
+        f"- Never omit any part. Never write '# ... rest unchanged'.\n"
+    )
+    return _strip_code_fence(ask(prompt))
+
+
+def suggest_improvements(code: str, language: str = "python") -> str:
+    prompt = (
+        f"Review this {language} code and provide thorough improvement suggestions.\n\n"
+        f"```{language}\n{code}\n```\n\n"
+        f"Cover ALL sections — do not skip any:\n"
+        f"1. **Performance** – bottlenecks and faster alternatives\n"
+        f"2. **Readability** – naming, structure, comments\n"
+        f"3. **Maintainability** – modularity, testability\n"
+        f"4. **Modern practices** – idiomatic {language} patterns\n"
+        f"5. **Security** – input validation, injection risks, secret handling\n"
+        f"6. **Error handling** – robustness improvements\n\n"
+        f"Include short code snippets demonstrating each suggestion.\n"
+    )
+    return ask(prompt)
+
+
+def generate_documentation(code: str, language: str = "python") -> str:
+    prompt = (
+        f"Generate complete, production-ready documentation for the following {language} code.\n\n"
+        f"```{language}\n{code}\n```\n\n"
+        f"Include ALL of the following — never truncate:\n"
+        f"1. Module / class / function docstrings (Google style)\n"
+        f"2. Parameter types and descriptions\n"
+        f"3. Return types and descriptions\n"
+        f"4. Raises sections where applicable\n"
+        f"5. Usage examples for every public function\n\n"
+        f"Return the COMPLETE documented source in a single code fence.\n"
+    )
+    return ask(prompt)
+
+
+def generate_project_code(description: str, template: str = "fastapi") -> dict[str, str]:
+    """
+    Generate a complete project scaffold.
+    Returns a dict mapping relative file paths to their content.
+    """
+    prompt = (
+        f"Generate a complete, production-ready {template} project based on:\n\n"
+        f'"{description}"\n\n'
+        f"Return a JSON object: keys = relative file paths, values = file contents.\n"
+        f"Example: {{\"main.py\": \"...\", \"requirements.txt\": \"...\"}}\n\n"
+        f"Include:\n"
+        f"- All application files — complete, not abbreviated\n"
+        f"- requirements.txt with pinned versions\n"
+        f"- Detailed README.md\n"
+        f"- Proper error handling and logging\n"
+        f"- Inline comments explaining the structure\n\n"
+        f"Return ONLY the raw JSON object — no markdown fences, no prose.\n"
+        f"CRITICAL: Write every file in full. Never truncate.\n"
+    )
+    raw = _strip_code_fence(ask(prompt, use_cache=False)).strip()
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError:
+        return {"main.py": raw}
+
+
+# ── Utility ────────────────────────────────────────────────────────────────────
+
+def _strip_code_fence(text: str) -> str:
+    """Remove leading/trailing markdown code fences."""
+    if not text:
+        return ""
+    lines = text.strip().splitlines()
+    if lines and lines[0].lstrip().startswith("```"):
+        lines = lines[1:]
+    if lines and lines[-1].lstrip().startswith("```"):
+        lines = lines[:-1]
+    return "\n".join(lines).strip()

core/cache_db.py

@@ -0,0 +1,159 @@
+"""
+SQLite-backed response cache with thread-safe access and automatic TTL expiry.
+
+Each entry stores a prompt hash → response text with a timestamp.
+Entries older than TTL_HOURS (default: 24 h) are pruned automatically:
+  • on every write  (set_)
+  • on every read   (get) — stale entries return None
+  • on explicit     (clear_expired)
+
+This keeps the database lightweight and prevents stale AI answers
+from being served indefinitely.
+"""
+
+import sqlite3
+import hashlib
+import datetime
+import threading
+from typing import Optional
+
+from core.config import CACHE_DB
+
+_lock    = threading.Lock()
+TTL_HOURS: int = 24   # cache entries expire after this many hours
+
+# ── Schema ─────────────────────────────────────────────────────────────────────
+_DDL = """
+CREATE TABLE IF NOT EXISTS cache (
+    key        TEXT PRIMARY KEY,
+    value      TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+)
+"""
+
+
+def _connect() -> sqlite3.Connection:
+    conn = sqlite3.connect(CACHE_DB, check_same_thread=False)
+    conn.execute(_DDL)
+    conn.commit()
+    return conn
+
+
+def _hash(text: str) -> str:
+    """Return a stable SHA-256 hex digest of *text* for use as cache key."""
+    return hashlib.sha256(text.encode("utf-8", errors="replace")).hexdigest()
+
+
+def _cutoff_iso() -> str:
+    """Return the ISO timestamp that is exactly TTL_HOURS ago."""
+    cutoff = datetime.datetime.now() - datetime.timedelta(hours=TTL_HOURS)
+    return cutoff.isoformat(sep=" ", timespec="seconds")
+
+
+# ── Public API ─────────────────────────────────────────────────────────────────
+
+def get(key: str) -> Optional[str]:
+    """
+    Return cached value for *key*, or None if absent or expired.
+
+    Expired entries are deleted on access (lazy eviction) so they
+    never accumulate silently.
+    """
+    with _lock:
+        conn = _connect()
+        try:
+            row = conn.execute(
+                "SELECT value, updated_at FROM cache WHERE key = ?",
+                (_hash(key),),
+            ).fetchone()
+
+            if row is None:
+                return None
+
+            value, updated_at_str = row
+
+            # Parse stored timestamp and check TTL
+            try:
+                updated_at = datetime.datetime.fromisoformat(updated_at_str)
+                age = datetime.datetime.now() - updated_at
+                if age.total_seconds() > TTL_HOURS * 3600:
+                    # Expired — delete and return None
+                    conn.execute("DELETE FROM cache WHERE key = ?", (_hash(key),))
+                    conn.commit()
+                    return None
+            except ValueError:
+                # Unparseable timestamp: treat as expired
+                conn.execute("DELETE FROM cache WHERE key = ?", (_hash(key),))
+                conn.commit()
+                return None
+
+            return value
+        finally:
+            conn.close()
+
+
+def set_(key: str, value: str) -> None:
+    """
+    Insert or replace a cache entry.
+
+    Also runs a background sweep to remove all entries older than TTL_HOURS,
+    keeping the database compact without ever blocking the caller for long.
+    """
+    with _lock:
+        conn = _connect()
+        try:
+            now = datetime.datetime.now().isoformat(sep=" ", timespec="seconds")
+            conn.execute(
+                "INSERT OR REPLACE INTO cache (key, value, updated_at) VALUES (?, ?, ?)",
+                (_hash(key), value, now),
+            )
+            # Sweep stale rows on every write — cheap because updated_at is indexed
+            conn.execute(
+                "DELETE FROM cache WHERE updated_at < ?",
+                (_cutoff_iso(),),
+            )
+            conn.commit()
+        finally:
+            conn.close()
+
+
+def count() -> int:
+    """Return total number of non-expired cached entries."""
+    with _lock:
+        conn = _connect()
+        try:
+            return conn.execute(
+                "SELECT COUNT(*) FROM cache WHERE updated_at >= ?",
+                (_cutoff_iso(),),
+            ).fetchone()[0]
+        finally:
+            conn.close()
+
+
+def clear() -> None:
+    """Remove ALL cache entries (expired and non-expired)."""
+    with _lock:
+        conn = _connect()
+        try:
+            conn.execute("DELETE FROM cache")
+            conn.commit()
+        finally:
+            conn.close()
+
+
+def clear_expired() -> int:
+    """
+    Remove only the entries that have exceeded TTL_HOURS.
+    Returns the number of rows deleted.
+    """
+    with _lock:
+        conn = _connect()
+        try:
+            cursor = conn.execute(
+                "DELETE FROM cache WHERE updated_at < ?",
+                (_cutoff_iso(),),
+            )
+            conn.commit()
+            return cursor.rowcount
+        finally:
+            conn.close()

core/checker.py

@@ -0,0 +1,101 @@
+"""
+Static analysis for source files.
+
+check_file()           – language-aware syntax + lint check
+quick_fix_suggestion() – ask AI for a summary of detected issues
+"""
+
+import ast
+import importlib.util
+import os
+from typing import Optional
+
+from core.utils import detect_language, find_file, read_file
+from core.logger import logger
+
+
+# ── Language dispatchers ───────────────────────────────────────────────────────
+
+def _check_python(path: str) -> tuple[bool, list[str]]:
+    """Parse Python source with ast; optionally run flake8 for style issues."""
+    try:
+        source = read_file(path)
+    except FileNotFoundError as exc:
+        return False, [str(exc)]
+
+    # AST syntax check
+    try:
+        ast.parse(source, filename=path)
+    except SyntaxError as exc:
+        return False, [f"SyntaxError at line {exc.lineno}: {exc.msg}"]
+
+    messages: list[str] = []
+
+    # Optional flake8 style check (installed separately)
+    if importlib.util.find_spec("flake8"):
+        try:
+            from flake8.api import legacy as flake8
+            guide  = flake8.get_style_guide(max_line_length=120, ignore=["E501", "W503"])
+            report = guide.check_files([path])
+            messages = report.get_statistics("E") + report.get_statistics("W")
+        except Exception as exc:
+            logger.warning("flake8 check failed: %s", exc)
+
+    return True, messages
+
+
+def _check_generic(path: str) -> tuple[bool, list[str]]:
+    """Fallback checker: just verifies the file is readable UTF-8 text."""
+    try:
+        read_file(path)
+        return True, []
+    except FileNotFoundError as exc:
+        return False, [str(exc)]
+    except UnicodeDecodeError:
+        return False, [f"File is not valid UTF-8: {path}"]
+
+
+# ── Public API ─────────────────────────────────────────────────────────────────
+
+_CHECKERS = {
+    "python": _check_python,
+}
+
+
+def check_file(path: str) -> tuple[bool, list[str]]:
+    """
+    Check *path* for syntax/style issues.
+
+    Returns (ok, messages) where *ok* is False only when the file
+    cannot be parsed at all.  Style warnings leave *ok* as True.
+    """
+    # Resolve the path if it is not absolute
+    if not os.path.isabs(path) and not os.path.exists(path):
+        resolved = find_file(os.path.basename(path))
+        if resolved:
+            path = resolved
+
+    lang = detect_language(path)
+    checker = _CHECKERS.get(lang, _check_generic)
+    return checker(path)
+
+
+def quick_fix_suggestion(path: str) -> str:
+    """
+    Run check_file() and ask the AI to summarise detected problems.
+    Returns a plain-text suggestion string.
+    """
+    # Import here to avoid circular dependency at module load time
+    from core.ai import ask
+
+    ok, messages = check_file(path)
+
+    if ok and not messages:
+        return "✅ No issues found – the file looks clean."
+
+    summary = "; ".join(messages[:20])  # cap at 20 to keep the prompt concise
+    prompt  = (
+        f"The following issues were detected in a source file:\n\n{summary}\n\n"
+        "Summarise these issues clearly and suggest precise fixes for each one."
+    )
+    return ask(prompt)