codegpt-ai 1.0.0

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "codegpt-ai",
+  "version": "1.0.0",
+  "description": "Local AI Assistant Hub — 80+ commands, 29 tools, 8 agents, training, security",
+  "author": "ArukuX",
+  "license": "MIT",
+  "bin": {
+    "ai": "./bin/ai.js",
+    "codegpt": "./bin/ai.js"
+  },
+  "scripts": {
+    "postinstall": "node bin/setup.js"
+  },
+  "keywords": [
+    "ai",
+    "cli",
+    "ollama",
+    "llm",
+    "chatgpt",
+    "terminal",
+    "assistant",
+    "agents"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CCguvycu/codegpt.git"
+  },
+  "homepage": "https://github.com/CCguvycu/codegpt",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "dependencies": {
+    "settings": "^0.1.1"
+  }
+}

package/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "codegpt"
+version = "1.0.0"
+description = "Local AI Assistant Hub — CLI, agents, training, 15+ tool integrations"
+readme = "CLAUDE.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+authors = [{name = "ArukuX"}]
+
+dependencies = [
+    "requests>=2.31.0",
+    "rich>=13.0.0",
+    "prompt-toolkit>=3.0.0",
+]
+
+[project.optional-dependencies]
+full = [
+    "textual>=0.40.0",
+    "python-telegram-bot>=20.0",
+    "flask>=3.0.0",
+    "groq>=0.4.0",
+    "SpeechRecognition>=3.10.0",
+]
+
+[project.scripts]
+ai = "ai_cli.__main__:main"
+
+[tool.setuptools.packages.find]
+include = ["ai_cli*"]

package/requirements.txt

@@ -0,0 +1,12 @@
+requests>=2.31.0
+rich>=13.0.0
+prompt_toolkit>=3.0.0
+textual>=1.0.0
+python-telegram-bot>=21.0
+SpeechRecognition>=3.10.0
+# PyAudio - install separately for voice input:
+#   pipwin install pyaudio  OR
+#   pip install pipwin && pipwin install pyaudio
+flask>=3.0.0
+groq>=0.4.0
+flet>=0.20.0

package/run.py

@@ -0,0 +1,157 @@
+"""CodeGPT Launcher
+
+Usage:
+    python run.py              Start CLI chat (default)
+    python run.py chat         Start CLI chat
+    python run.py tui          Start TUI with sidebar
+    python run.py bot          Start Telegram bot
+    python run.py server       Start backend server
+    python run.py mobile       Start mobile app (desktop preview)
+    python run.py apk          Build Android APK
+"""
+
+import os
+import sys
+import json
+import subprocess
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".codegpt"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+def load_config():
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    if CONFIG_FILE.exists():
+        try:
+            return json.loads(CONFIG_FILE.read_text())
+        except Exception:
+            pass
+    return {}
+
+
+def save_config(config):
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(config, indent=2))
+
+
+def run_script(name):
+    script = Path(__file__).parent / name
+    subprocess.run([sys.executable, str(script)])
+
+
+def run_bot(token=None):
+    config = load_config()
+    bot_token = token or os.environ.get("CODEGPT_BOT_TOKEN") or config.get("bot_token")
+
+    if not bot_token:
+        print("  No token. Get one from @BotFather on Telegram.")
+        try:
+            bot_token = input("  Paste token > ").strip()
+        except (KeyboardInterrupt, EOFError):
+            return
+        if not bot_token:
+            return
+        try:
+            if input("  Save for later? (y/n) > ").strip().lower() == "y":
+                config["bot_token"] = bot_token
+                save_config(config)
+                print("  Saved.\n")
+        except (KeyboardInterrupt, EOFError):
+            pass
+
+    os.environ["CODEGPT_BOT_TOKEN"] = bot_token
+    run_script("bot.py")
+
+
+def run_server():
+    config = load_config()
+    groq_key = os.environ.get("GROQ_API_KEY") or config.get("groq_api_key")
+
+    if not groq_key:
+        print("  No Groq API key found.")
+        print("  Get a free one at: https://console.groq.com/keys\n")
+        print("  Without it, the server will use local Ollama.\n")
+        try:
+            groq_key = input("  Paste Groq key (or Enter to skip) > ").strip()
+        except (KeyboardInterrupt, EOFError):
+            groq_key = ""
+
+        if groq_key:
+            try:
+                if input("  Save for later? (y/n) > ").strip().lower() == "y":
+                    config["groq_api_key"] = groq_key
+                    save_config(config)
+                    print("  Saved.\n")
+            except (KeyboardInterrupt, EOFError):
+                pass
+
+    if groq_key:
+        os.environ["GROQ_API_KEY"] = groq_key
+
+    run_script("server.py")
+
+
+def build_apk():
+    project = Path(__file__).parent
+    print("  Building APK with Flet...\n")
+    result = subprocess.run(
+        ["flet", "build", "apk", "--project", str(project), "--module-name", "mobile"],
+        cwd=str(project),
+    )
+    if result.returncode == 0:
+        # Copy APK to desktop
+        apk_path = project / "build" / "apk" / "app-release.apk"
+        desktop = Path.home() / "Desktop"
+        if not desktop.exists():
+            desktop = Path.home() / "OneDrive" / "Desktop"
+        if apk_path.exists():
+            import shutil
+            dest = desktop / "CodeGPT.apk"
+            shutil.copy2(str(apk_path), str(dest))
+            print(f"\n  APK copied to: {dest}")
+        else:
+            print(f"\n  APK built. Check: {project / 'build'}")
+    else:
+        print("\n  Build failed. Make sure Flet is installed: pip install flet")
+
+
+def main():
+    args = sys.argv[1:]
+
+    if not args or args[0].lower() in ("chat", "cli"):
+        run_script("chat.py")
+    elif args[0].lower() in ("tui", "ui", "app"):
+        run_script("app.py")
+    elif args[0].lower() in ("bot", "telegram"):
+        token = None
+        if "--token" in args:
+            idx = args.index("--token")
+            if idx + 1 < len(args):
+                token = args[idx + 1]
+        if "--save-token" in args:
+            idx = args.index("--save-token")
+            if idx + 1 < len(args):
+                token = args[idx + 1]
+                config = load_config()
+                config["bot_token"] = token
+                save_config(config)
+                print("  Token saved.")
+        run_bot(token)
+    elif args[0].lower() in ("server", "backend", "api"):
+        run_server()
+    elif args[0].lower() in ("mobile", "phone"):
+        run_script("mobile.py")
+    elif args[0].lower() in ("web",):
+        run_script("web.py")
+    elif args[0].lower() in ("apk", "build"):
+        build_apk()
+    elif args[0].lower() in ("help", "--help", "-h"):
+        print(__doc__)
+    else:
+        print(f"  Unknown: {args[0]}")
+        print("  Use: chat, tui, bot, server, mobile, or apk")
+
+
+if __name__ == "__main__":
+    main()

package/server.py

@@ -0,0 +1,335 @@
+"""CodeGPT Backend — Flask API server. Supports Groq (cloud) and Ollama (local).
+
+Deploy to Render/Railway/PythonAnywhere for 24/7 access without your laptop.
+
+Usage:
+    python server.py                         # Starts on port 5050
+    python server.py --port 8080             # Custom port
+    GROQ_API_KEY=gsk_... python server.py    # Use Groq cloud backend
+
+Endpoints:
+    POST /chat          — Send messages, get AI response (streaming)
+    POST /chat/quick    — Non-streaming single response
+    GET  /models        — List available models
+    GET  /health        — Health check
+    GET  /config        — Get server config (model, provider)
+"""
+
+import json
+import os
+import sys
+import time
+from datetime import datetime
+
+from flask import Flask, request, jsonify, Response, stream_with_context
+
+# Optional: Groq for cloud inference
+try:
+    from groq import Groq
+    HAS_GROQ = True
+except ImportError:
+    HAS_GROQ = False
+
+# Optional: requests for Ollama
+import requests as http_requests
+
+app = Flask(__name__)
+
+# --- Config ---
+
+GROQ_API_KEY = os.environ.get("GROQ_API_KEY", "")
+OLLAMA_URL = os.environ.get("OLLAMA_URL", "http://localhost:11434")
+DEFAULT_MODEL = os.environ.get("CODEGPT_MODEL", "llama-3.2-3b-preview")  # Groq model
+OLLAMA_MODEL = os.environ.get("OLLAMA_MODEL", "llama3.2")
+PORT = int(os.environ.get("PORT", 5050))
+
+# Auto-detect provider
+if GROQ_API_KEY and HAS_GROQ:
+    PROVIDER = "groq"
+else:
+    PROVIDER = "ollama"
+
+SYSTEM_PROMPT = """You are an AI modeled after a highly technical, system-focused developer mindset.
+Be direct, concise, and dense with information. No fluff, no filler, no emojis.
+Give conclusions first, then minimal necessary explanation.
+Focus on: AI, coding, automation, cybersecurity, system design.
+Blunt but intelligent. Slightly dark tone is acceptable.
+Keep responses concise for mobile reading."""
+
+PERSONAS = {
+    "Default": SYSTEM_PROMPT,
+    "Hacker": "You are a cybersecurity expert. Technical jargon, CVEs, attack vectors. Defensive security only. Concise.",
+    "Teacher": "You are a patient programming teacher. Step by step, analogies, examples. Concise.",
+    "Roast": "You are a brutally sarcastic code reviewer. Roast then fix. Dark humor. Concise.",
+    "Minimal": "Shortest possible answer. One line if possible. Code only.",
+}
+
+# Stats
+server_stats = {"requests": 0, "start": time.time()}
+
+
+# --- Groq Backend ---
+
+def query_groq(messages, model, system, stream=False):
+    """Query Groq cloud API."""
+    client = Groq(api_key=GROQ_API_KEY)
+
+    full_messages = [{"role": "system", "content": system}]
+    full_messages.extend(messages)
+
+    if stream:
+        completion = client.chat.completions.create(
+            model=model or DEFAULT_MODEL,
+            messages=full_messages,
+            stream=True,
+            max_tokens=4096,
+        )
+
+        def generate():
+            full = []
+            for chunk in completion:
+                delta = chunk.choices[0].delta
+                if delta and delta.content:
+                    full.append(delta.content)
+                    yield json.dumps({
+                        "content": delta.content,
+                        "done": False,
+                    }) + "\n"
+
+            yield json.dumps({
+                "content": "",
+                "done": True,
+                "full_response": "".join(full),
+                "model": model or DEFAULT_MODEL,
+                "provider": "groq",
+            }) + "\n"
+
+        return generate()
+    else:
+        completion = client.chat.completions.create(
+            model=model or DEFAULT_MODEL,
+            messages=full_messages,
+            max_tokens=4096,
+        )
+        content = completion.choices[0].message.content
+        usage = completion.usage
+        return {
+            "content": content,
+            "model": model or DEFAULT_MODEL,
+            "provider": "groq",
+            "tokens": {
+                "input": usage.prompt_tokens if usage else 0,
+                "output": usage.completion_tokens if usage else 0,
+            },
+        }
+
+
+# --- Ollama Backend ---
+
+def query_ollama(messages, model, system, stream=False):
+    """Query local Ollama."""
+    ollama_messages = [{"role": "system", "content": system}]
+    ollama_messages.extend(messages)
+
+    if stream:
+        try:
+            response = http_requests.post(
+                f"{OLLAMA_URL}/api/chat",
+                json={"model": model or OLLAMA_MODEL, "messages": ollama_messages, "stream": True},
+                stream=True,
+                timeout=120,
+            )
+            response.raise_for_status()
+        except Exception as e:
+            def error_gen():
+                yield json.dumps({"content": f"Error: {e}", "done": True}) + "\n"
+            return error_gen()
+
+        def generate():
+            for line in response.iter_lines():
+                if not line:
+                    continue
+                try:
+                    chunk = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+
+                content = chunk.get("message", {}).get("content", "")
+                done = chunk.get("done", False)
+
+                out = {"content": content, "done": done}
+
+                if done:
+                    ec = chunk.get("eval_count", 0)
+                    td = chunk.get("total_duration", 0)
+                    ds = td / 1e9 if td else 0
+                    tps = ec / ds if ds > 0 else 0
+                    out["model"] = model or OLLAMA_MODEL
+                    out["provider"] = "ollama"
+                    out["tokens"] = {"output": ec}
+                    out["stats"] = f"{ec} tok | {ds:.1f}s | {tps:.0f} tok/s"
+
+                yield json.dumps(out) + "\n"
+
+        return generate()
+    else:
+        response = http_requests.post(
+            f"{OLLAMA_URL}/api/chat",
+            json={"model": model or OLLAMA_MODEL, "messages": ollama_messages, "stream": False},
+            timeout=120,
+        )
+        response.raise_for_status()
+        data = response.json()
+        content = data.get("message", {}).get("content", "")
+        ec = data.get("eval_count", 0)
+        td = data.get("total_duration", 0)
+        ds = td / 1e9 if td else 0
+        return {
+            "content": content,
+            "model": model or OLLAMA_MODEL,
+            "provider": "ollama",
+            "tokens": {"output": ec},
+            "stats": f"{ec} tok | {ds:.1f}s",
+        }
+
+
+# --- Routes ---
+
+@app.route("/health", methods=["GET"])
+def health():
+    uptime = int(time.time() - server_stats["start"])
+    return jsonify({
+        "status": "ok",
+        "provider": PROVIDER,
+        "model": DEFAULT_MODEL if PROVIDER == "groq" else OLLAMA_MODEL,
+        "uptime": uptime,
+        "requests": server_stats["requests"],
+    })
+
+
+@app.route("/config", methods=["GET"])
+def get_config():
+    return jsonify({
+        "provider": PROVIDER,
+        "model": DEFAULT_MODEL if PROVIDER == "groq" else OLLAMA_MODEL,
+        "personas": list(PERSONAS.keys()),
+    })
+
+
+@app.route("/models", methods=["GET"])
+def list_models():
+    if PROVIDER == "groq":
+        # Groq available models
+        models = [
+            "llama-3.2-3b-preview",
+            "llama-3.2-1b-preview",
+            "llama-3.3-70b-versatile",
+            "llama-3.1-8b-instant",
+            "gemma2-9b-it",
+            "mixtral-8x7b-32768",
+        ]
+    else:
+        try:
+            resp = http_requests.get(f"{OLLAMA_URL}/api/tags", timeout=5)
+            models = [m["name"] for m in resp.json().get("models", [])]
+        except Exception:
+            models = []
+
+    return jsonify({"models": models, "provider": PROVIDER})
+
+
+@app.route("/chat", methods=["POST"])
+def chat_stream():
+    """Streaming chat endpoint."""
+    server_stats["requests"] += 1
+
+    data = request.get_json()
+    if not data:
+        return jsonify({"error": "Invalid JSON"}), 400
+    messages = data.get("messages", [])
+    model = data.get("model", "")
+    persona = data.get("persona", "Default")
+    system = PERSONAS.get(persona, SYSTEM_PROMPT)
+
+    if not messages:
+        return jsonify({"error": "No messages"}), 400
+
+    # Input validation: cap message count and content length
+    if len(messages) > 100:
+        messages = messages[-100:]
+    for msg in messages:
+        if not isinstance(msg, dict) or "role" not in msg or "content" not in msg:
+            return jsonify({"error": "Invalid message format"}), 400
+        if len(msg["content"]) > 50000:
+            msg["content"] = msg["content"][:50000]
+
+    try:
+        if PROVIDER == "groq":
+            gen = query_groq(messages, model, system, stream=True)
+        else:
+            gen = query_ollama(messages, model, system, stream=True)
+
+        return Response(
+            stream_with_context(gen),
+            content_type="application/x-ndjson",
+        )
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route("/chat/quick", methods=["POST"])
+def chat_quick():
+    """Non-streaming chat endpoint."""
+    server_stats["requests"] += 1
+
+    data = request.get_json()
+    if not data:
+        return jsonify({"error": "Invalid JSON"}), 400
+    messages = data.get("messages", [])
+    model = data.get("model", "")
+    persona = data.get("persona", "Default")
+    system = PERSONAS.get(persona, SYSTEM_PROMPT)
+
+    if not messages:
+        return jsonify({"error": "No messages"}), 400
+
+    # Input validation
+    if len(messages) > 100:
+        messages = messages[-100:]
+    for msg in messages:
+        if not isinstance(msg, dict) or "role" not in msg or "content" not in msg:
+            return jsonify({"error": "Invalid message format"}), 400
+        if len(msg["content"]) > 50000:
+            msg["content"] = msg["content"][:50000]
+
+    try:
+        if PROVIDER == "groq":
+            result = query_groq(messages, model, system, stream=False)
+        else:
+            result = query_ollama(messages, model, system, stream=False)
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# --- Main ---
+
+if __name__ == "__main__":
+    print("=" * 50)
+    print("  CodeGPT Backend Server")
+    print("=" * 50)
+    print(f"  Provider: {PROVIDER}")
+    if PROVIDER == "groq":
+        print(f"  Model:    {DEFAULT_MODEL}")
+        print(f"  API Key:  ****{GROQ_API_KEY[-4:]}")
+    else:
+        print(f"  Model:    {OLLAMA_MODEL}")
+        print(f"  Ollama:   {OLLAMA_URL}")
+    print(f"  Port:     {PORT}")
+    print(f"  Personas: {', '.join(PERSONAS.keys())}")
+    print("=" * 50)
+    print(f"  http://localhost:{PORT}")
+    print(f"  http://0.0.0.0:{PORT}")
+    print("  Ctrl+C to stop.\n")
+
+    app.run(host="0.0.0.0", port=PORT, debug=False)

package/uninstall.ps1

@@ -0,0 +1,30 @@
+# CodeGPT Uninstaller
+$installDir = "$env:LOCALAPPDATA\codegpt"
+
+Write-Host "Uninstalling CodeGPT..." -ForegroundColor Yellow
+
+# Remove binary
+if (Test-Path $installDir) {
+    Remove-Item -Recurse -Force $installDir
+    Write-Host "  Removed $installDir" -ForegroundColor Green
+}
+
+# Remove from PATH
+$userPath = [Environment]::GetEnvironmentVariable("Path", "User")
+if ($userPath -like "*$installDir*") {
+    $newPath = ($userPath.Split(";") | Where-Object { $_ -ne $installDir }) -join ";"
+    [Environment]::SetEnvironmentVariable("Path", $newPath, "User")
+    Write-Host "  Removed from PATH" -ForegroundColor Green
+}
+
+# Ask about data
+$answer = Read-Host "  Delete user data (~/.codegpt)? (y/n)"
+if ($answer -eq "y") {
+    $dataDir = "$HOME\.codegpt"
+    if (Test-Path $dataDir) {
+        Remove-Item -Recurse -Force $dataDir
+        Write-Host "  Removed $dataDir" -ForegroundColor Green
+    }
+}
+
+Write-Host "Uninstalled." -ForegroundColor Green