codegpt-ai 1.0.0

package/.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(wc:*)"
+    ]
+  }
+}

package/.github/workflows/release.yml

@@ -0,0 +1,40 @@
+name: Build & Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install dependencies
+        run: |
+          pip install requests rich prompt-toolkit pyinstaller
+
+      - name: Build exe
+        run: |
+          pyinstaller ai.spec
+
+      - name: Verify exe
+        run: |
+          dist\ai.exe --version
+
+      - name: Create Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: dist/ai.exe
+          generate_release_notes: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/CLAUDE.md

@@ -0,0 +1,58 @@
+# CodeGPT — Project Context
+
+## What This Is
+CodeGPT is a full-featured local AI assistant hub. CLI chat, TUI, Telegram bot, web app, and 15+ AI tool integrations — all powered by Ollama running locally.
+
+## Stack
+- **Language**: Python 3.13
+- **AI Backend**: Ollama (localhost:11434), default model: llama3.2
+- **CLI**: Rich + prompt_toolkit (chat.py)
+- **TUI**: Textual (app.py)
+- **Web**: Flask + HTTPS (web.py)
+- **Bot**: python-telegram-bot (bot.py)
+- **Server**: Flask API, Groq/Ollama (server.py)
+- **Launcher**: run.py (all modes)
+
+## Files
+- `chat.py` — Main CLI with 60+ slash commands, AI agents, AI lab, training, security, tool integrations
+- `app.py` — TUI sidebar app (Textual)
+- `bot.py` — Telegram bot (live streaming, profiles, 10 features)
+- `web.py` — PWA web app (Flask + HTTPS)
+- `server.py` — Backend API (Groq cloud + Ollama local)
+- `run.py` — Launcher (cli/tui/web/bot/server/mobile)
+- `mobile.py` — Flet mobile app (incomplete, disk space issue)
+
+## Key Architecture (chat.py)
+- `COMMANDS` dict — all slash commands
+- `AI_TOOLS` dict — all external tool configs (bin, install, default_args)
+- `AI_AGENTS` dict — 8 specialized agents (coder, debugger, researcher, etc.)
+- `PERSONAS` dict — 6 personalities (default, hacker, teacher, roast, architect, minimal)
+- `PROMPT_TEMPLATES` dict — 15 reusable prompt prefixes
+- `stream_response()` — streaming Ollama chat with live rendering
+- `SlashCompleter` — autocomplete for / commands
+- Profile system — persistent user data at ~/.codegpt/profiles/
+- Memory system — persistent AI memory at ~/.codegpt/memory/
+- Security — PIN lock, audit log, shell blocklist, code exec limits
+- Training — collect conversations, build custom Ollama models
+
+## Data Locations
+- `~/.codegpt/profiles/cli_profile.json` — user profile
+- `~/.codegpt/memory/memories.json` — AI memories
+- `~/.codegpt/security/` — PIN hash, audit log
+- `~/.codegpt/training/` — training data, custom modelfiles
+- `~/.codegpt/sandbox/` — sandboxed tool working dirs
+- `~/.codegpt/context.json` — shared context (updated every tool launch)
+- `~/.codegpt/chats/` — saved conversations
+- `~/.codegpt/exports/` — exported chats
+- `~/.codegpt/ratings.json` — response ratings
+
+## Owner
+ArukuX (Ark), student dev, Southampton UK. Prefers direct/technical tone.
+
+## Rules
+- All external AI tools are sandboxed (except coding tools that need file access)
+- API keys are stripped from sandboxed tool environments
+- All tool launches are audit logged
+- Security PIN uses SHA-256 hashing
+- Code execution limited to 20/session
+- Shell commands checked against blocklist

package/ai.spec

@@ -0,0 +1,81 @@
+# -*- mode: python ; coding: utf-8 -*-
+# PyInstaller spec file for CodeGPT -> ai.exe
+
+import sys
+from pathlib import Path
+
+block_cipher = None
+
+a = Analysis(
+    ['ai_cli/__main__.py'],
+    pathex=['.'],
+    binaries=[],
+    datas=[
+        ('chat.py', '.'),
+        ('CLAUDE.md', '.'),
+    ],
+    hiddenimports=[
+        'requests',
+        'rich',
+        'rich.console',
+        'rich.markdown',
+        'rich.panel',
+        'rich.table',
+        'rich.text',
+        'rich.live',
+        'rich.rule',
+        'rich.align',
+        'prompt_toolkit',
+        'prompt_toolkit.history',
+        'prompt_toolkit.completion',
+        'prompt_toolkit.styles',
+        'ai_cli',
+        'ai_cli.__main__',
+        'ai_cli.updater',
+        'ai_cli.doctor',
+    ],
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[
+        'textual',
+        'telegram',
+        'flask',
+        'groq',
+        'flet',
+        'tkinter',
+        'unittest',
+        'xmlrpc',
+        'pydoc',
+        'doctest',
+    ],
+    win_no_prefer_redirects=False,
+    win_private_assemblies=False,
+    cipher=block_cipher,
+    noarchive=False,
+)
+
+pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    a.binaries,
+    a.zipfiles,
+    a.datas,
+    [],
+    name='ai',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    runtime_tmpdir=None,
+    console=True,
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+    icon=None,
+)

package/ai_cli/__init__.py

@@ -0,0 +1,2 @@
+"""CodeGPT — Local AI Assistant Hub."""
+__version__ = "1.0.0"

package/ai_cli/__main__.py

@@ -0,0 +1,46 @@
+"""Entry point for `python -m ai_cli` and `ai` command."""
+import sys
+import os
+
+# Fix Unicode on Windows
+os.environ["PYTHONUTF8"] = "1"
+if sys.platform == "win32":
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+
+
+def main():
+    """Main entry point — wraps chat.py with auto-update check."""
+    from ai_cli import __version__
+    from ai_cli.updater import check_for_update
+
+    # Handle meta-commands before loading the full CLI
+    if len(sys.argv) > 1:
+        cmd = sys.argv[1].lower()
+        if cmd == "--version" or cmd == "-v":
+            print(f"CodeGPT v{__version__}")
+            return
+        elif cmd == "update":
+            from ai_cli.updater import force_update
+            force_update()
+            return
+        elif cmd == "doctor":
+            from ai_cli.doctor import run_doctor
+            run_doctor()
+            return
+
+    # Silent update check (non-blocking)
+    check_for_update()
+
+    # Add parent dir to path so chat.py imports work
+    project_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    if project_dir not in sys.path:
+        sys.path.insert(0, project_dir)
+
+    # Launch the CLI
+    from chat import main as chat_main
+    chat_main()
+
+
+if __name__ == "__main__":
+    main()

package/ai_cli/doctor.py

@@ -0,0 +1,89 @@
+"""System diagnostics — `ai doctor`."""
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+def run_doctor():
+    """Check system dependencies and configuration."""
+    from rich.console import Console
+    from rich.table import Table
+
+    console = Console()
+    table = Table(title="CodeGPT Doctor", border_style="bright_cyan",
+                  title_style="bold cyan", show_header=True, header_style="bold")
+    table.add_column("Check", style="white", width=24)
+    table.add_column("Status", width=8)
+    table.add_column("Details", style="dim")
+
+    checks = []
+
+    # Python
+    py_ver = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+    checks.append(("Python", True, py_ver))
+
+    # Ollama
+    ollama_ok = shutil.which("ollama") is not None
+    if ollama_ok:
+        try:
+            r = subprocess.run(["ollama", "list"], capture_output=True, text=True, timeout=5)
+            model_count = len(r.stdout.strip().splitlines()) - 1
+            checks.append(("Ollama", True, f"{model_count} models"))
+        except Exception:
+            checks.append(("Ollama", True, "installed, not running"))
+    else:
+        checks.append(("Ollama", False, "not installed — ollama.com"))
+
+    # Ollama connectivity
+    try:
+        import requests
+        r = requests.get("http://localhost:11434/api/tags", timeout=2)
+        models = [m["name"] for m in r.json().get("models", [])]
+        checks.append(("Ollama API", True, f"{len(models)} models loaded"))
+    except Exception:
+        checks.append(("Ollama API", False, "not reachable — run: ollama serve"))
+
+    # Data dir
+    data_dir = Path.home() / ".codegpt"
+    checks.append(("Data directory", data_dir.exists(), str(data_dir)))
+
+    # Profile
+    profile = data_dir / "profiles" / "cli_profile.json"
+    checks.append(("Profile", profile.exists(), "configured" if profile.exists() else "run ai to setup"))
+
+    # Memory
+    mem = data_dir / "memory" / "memories.json"
+    if mem.exists():
+        import json
+        try:
+            count = len(json.loads(mem.read_text()))
+            checks.append(("Memory", True, f"{count} entries"))
+        except Exception:
+            checks.append(("Memory", True, "exists"))
+    else:
+        checks.append(("Memory", True, "empty (normal)"))
+
+    # Security
+    pin = data_dir / "security" / "pin.hash"
+    checks.append(("PIN lock", pin.exists(), "enabled" if pin.exists() else "disabled"))
+
+    # External tools
+    for name, bin_name in [("Claude Code", "claude"), ("GitHub CLI", "gh"),
+                            ("Node.js", "node"), ("npm", "npm")]:
+        ok = shutil.which(bin_name) is not None
+        checks.append((name, ok, "found" if ok else "not found"))
+
+    # Render
+    for name, ok, detail in checks:
+        status = "[green]OK[/]" if ok else "[red]FAIL[/]"
+        table.add_row(name, status, detail)
+
+    console.print(table)
+    console.print()
+
+    fails = sum(1 for _, ok, _ in checks if not ok)
+    if fails == 0:
+        console.print("[bold green]All checks passed.[/]")
+    else:
+        console.print(f"[yellow]{fails} issue(s) found.[/]")

package/ai_cli/updater.py

@@ -0,0 +1,191 @@
+"""Self-updating system — checks GitHub Releases for new versions."""
+import os
+import sys
+import json
+import shutil
+import tempfile
+import threading
+from pathlib import Path
+
+# Configure these for your repo
+GITHUB_OWNER = "ArukuX"
+GITHUB_REPO = "codegpt"
+RELEASES_URL = f"https://api.github.com/repos/{GITHUB_OWNER}/{GITHUB_REPO}/releases/latest"
+UPDATE_CHECK_FILE = Path.home() / ".codegpt" / "last_update_check"
+
+
+def _get_current_version():
+    from ai_cli import __version__
+    return __version__
+
+
+def _parse_version(v):
+    """Parse 'v1.2.3' or '1.2.3' into tuple."""
+    v = v.lstrip("v").strip()
+    parts = v.split(".")
+    return tuple(int(p) for p in parts if p.isdigit())
+
+
+def _should_check():
+    """Only check once per hour."""
+    import time
+    try:
+        if UPDATE_CHECK_FILE.exists():
+            last = float(UPDATE_CHECK_FILE.read_text().strip())
+            if time.time() - last < 3600:  # 1 hour
+                return False
+    except Exception:
+        pass
+    return True
+
+
+def _save_check_time():
+    import time
+    try:
+        UPDATE_CHECK_FILE.parent.mkdir(parents=True, exist_ok=True)
+        UPDATE_CHECK_FILE.write_text(str(time.time()))
+    except Exception:
+        pass
+
+
+def _fetch_latest():
+    """Fetch latest release info from GitHub."""
+    import requests
+    try:
+        resp = requests.get(RELEASES_URL, timeout=5, headers={"Accept": "application/vnd.github.v3+json"})
+        if resp.status_code == 200:
+            return resp.json()
+    except Exception:
+        pass
+    return None
+
+
+def _is_frozen():
+    """Check if running as PyInstaller exe."""
+    return getattr(sys, 'frozen', False)
+
+
+def check_for_update():
+    """Non-blocking update check on startup."""
+    if not _should_check():
+        return
+
+    def _check():
+        _save_check_time()
+        release = _fetch_latest()
+        if not release:
+            return
+
+        latest_tag = release.get("tag_name", "")
+        current = _parse_version(_get_current_version())
+        latest = _parse_version(latest_tag)
+
+        if latest > current:
+            # Store update info for next prompt
+            update_file = Path.home() / ".codegpt" / "update_available.json"
+            update_file.write_text(json.dumps({
+                "version": latest_tag,
+                "current": _get_current_version(),
+                "url": release.get("html_url", ""),
+                "assets": [
+                    {"name": a["name"], "url": a["browser_download_url"]}
+                    for a in release.get("assets", [])
+                    if a["name"].endswith(".exe")
+                ],
+            }, indent=2))
+
+    # Run in background thread — never block startup
+    t = threading.Thread(target=_check, daemon=True)
+    t.start()
+
+
+def get_pending_update():
+    """Check if there's a pending update notification."""
+    update_file = Path.home() / ".codegpt" / "update_available.json"
+    if update_file.exists():
+        try:
+            data = json.loads(update_file.read_text())
+            latest = _parse_version(data["version"])
+            current = _parse_version(_get_current_version())
+            if latest > current:
+                return data
+        except Exception:
+            pass
+    return None
+
+
+def force_update():
+    """Force download and install the latest version."""
+    import requests
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.text import Text
+
+    console = Console()
+
+    console.print(Panel(
+        Text("Checking for updates...", style="bold"),
+        border_style="bright_cyan",
+    ))
+
+    release = _fetch_latest()
+    if not release:
+        console.print("[red]Cannot reach GitHub. Check your internet.[/]")
+        return
+
+    latest_tag = release.get("tag_name", "")
+    current = _get_current_version()
+
+    if _parse_version(latest_tag) <= _parse_version(current):
+        console.print(f"[green]Already up to date (v{current})[/]")
+        return
+
+    # Find the exe asset
+    exe_assets = [a for a in release.get("assets", []) if a["name"].endswith(".exe")]
+    if not exe_assets:
+        console.print("[yellow]No exe found in release. Update manually.[/]")
+        console.print(f"  {release.get('html_url', '')}")
+        return
+
+    asset = exe_assets[0]
+    console.print(f"  Downloading {asset['name']} ({latest_tag})...")
+
+    try:
+        resp = requests.get(asset["browser_download_url"], stream=True, timeout=60)
+        resp.raise_for_status()
+
+        # Download to temp file
+        tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".exe")
+        for chunk in resp.iter_content(chunk_size=8192):
+            tmp.write(chunk)
+        tmp.close()
+
+        if _is_frozen():
+            # Replace the running exe
+            current_exe = sys.executable
+            backup = current_exe + ".bak"
+
+            # Rename current to .bak, move new to current
+            if os.path.exists(backup):
+                os.remove(backup)
+            os.rename(current_exe, backup)
+            shutil.move(tmp.name, current_exe)
+
+            console.print(Panel(
+                Text(f"Updated: v{current} -> {latest_tag}\nRestart to use the new version.", style="green"),
+                border_style="green",
+            ))
+        else:
+            # Running from source — just notify
+            console.print(Panel(
+                Text(f"New version available: {latest_tag}\nDownloaded to: {tmp.name}", style="yellow"),
+                border_style="yellow",
+            ))
+
+        # Clear update notification
+        update_file = Path.home() / ".codegpt" / "update_available.json"
+        if update_file.exists():
+            update_file.unlink()
+
+    except Exception as e:
+        console.print(f"[red]Update failed: {e}[/]")