codegpt-ai 1.0.0 → 1.2.0

package/README.md

@@ -0,0 +1,210 @@
+# CodeGPT
+
+**Your local AI assistant hub. One command. No cloud. No API keys.**
+
+```
+npm i -g codegpt-ai
+```
+
+Then type `ai`.
+
+```
+  ██████╗ ██████╗ ██████╗ ███████╗ ██████╗ ██████╗ ████████╗
+ ██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔════╝ ██╔══██╗╚══██╔══╝
+ ██║     ██║   ██║██║  ██║█████╗  ██║  ███╗██████╔╝   ██║
+ ██║     ██║   ██║██║  ██║██╔══╝  ██║   ██║██╔═══╝    ██║
+ ╚██████╗╚██████╔╝██████╔╝███████╗╚██████╔╝██║        ██║
+  ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚═════╝ ╚═╝        ╚═╝
+```
+
+## What is it?
+
+A fully-featured AI chat CLI that runs locally on your machine using [Ollama](https://ollama.com). No API keys needed. No cloud. No subscription.
+
+- **80+ slash commands** — chat, code, search, export, and more
+- **8 AI agents** — coder, debugger, reviewer, architect, pentester, explainer, optimizer, researcher
+- **29 AI tool integrations** — Claude, Codex, Gemini, Copilot, Cline, and more
+- **Multi-AI system** — swarm, vote, race, team chat with multiple AIs
+- **AI training** — train your own custom Ollama models from conversations
+- **Security** — PIN lock, audit log, sandboxed tools, shell blocklist
+- **Works anywhere** — Windows, macOS, Linux, Termux (Android)
+
+## Install
+
+### npm (recommended)
+```bash
+npm i -g codegpt-ai
+ai
+```
+
+Works with just Node.js. If Python is installed, you get the full 80+ command experience. Without Python, you get a lightweight Node.js chat client.
+
+### pip
+```bash
+pip install -e git+https://github.com/CCguvycu/codegpt.git#egg=codegpt
+ai
+```
+
+### PowerShell (Windows)
+```powershell
+irm https://raw.githubusercontent.com/CCguvycu/codegpt/main/install.ps1 | iex
+```
+
+### Termux (Android)
+```bash
+curl -sL https://raw.githubusercontent.com/CCguvycu/codegpt/main/install-termux.sh | bash
+```
+
+## Requirements
+
+- **Node.js 16+** (for npm install) OR **Python 3.10+** (for pip install)
+- **Ollama** — install from [ollama.com](https://ollama.com), then `ollama pull llama3.2`
+- Or connect to a remote Ollama server with `/connect IP`
+
+## Quick Start
+
+```bash
+# Install
+npm i -g codegpt-ai
+
+# Pull a model
+ollama pull llama3.2
+
+# Start chatting
+ai
+```
+
+Type `/help` inside for all commands.
+
+## Features
+
+### Chat
+| Command | Description |
+|---------|-------------|
+| `/new` | New conversation |
+| `/save` | Save conversation |
+| `/load` | Load saved conversation |
+| `/model` | Switch model |
+| `/persona` | Switch personality (hacker, teacher, roast, architect, minimal) |
+| `/think` | Toggle deep reasoning mode |
+| `/file path` | Read a file into context |
+| `/run` | Execute last code block |
+| `/compact` | Summarize conversation to save context |
+
+### AI Agents
+```
+/agent coder build a REST API
+/agent debugger why does this crash
+/agent reviewer check this code
+/agent architect design a microservices system
+```
+
+8 specialized agents: `coder` `debugger` `researcher` `reviewer` `architect` `pentester` `explainer` `optimizer`
+
+### Multi-AI
+```
+/all what's the best database?       # All 8 agents answer in parallel
+/vote Flask or FastAPI?              # Agents vote with consensus
+/swarm build a CLI password manager  # 6-agent pipeline
+/team claude codex                   # Group chat with 2 AIs + you
+/race explain recursion              # Race all models for speed
+```
+
+### AI Tools (29 integrations)
+```
+/tools                    # See all tools
+/claude                   # Launch Claude Code
+/codex                    # Launch Codex
+/gemini                   # Launch Gemini CLI
+/split claude codex       # Side-by-side split screen
+/grid claude codex gemini cline  # 2x2 grid
+```
+
+All tools auto-install on first use. Sandboxed for security.
+
+### AI Training
+```
+/rate good                # Rate a response
+/train collect            # Save chat as training data
+/train build mymodel      # Create custom Ollama model
+/model mymodel            # Use your trained model
+```
+
+### Remote Connect
+```
+/connect 192.168.1.100    # Connect to PC's Ollama
+/qr                       # Show QR code to connect from phone
+/server                   # Check connection status
+```
+
+### Security
+```
+/pin-set                  # Set login PIN
+/audit                    # View security log
+/security                 # Security dashboard
+```
+
+### Integrations
+```
+/github repos             # Your GitHub repos
+/spotify play             # Control Spotify
+/weather London           # Get weather
+/sysinfo                  # System info
+```
+
+## CLI Args (non-interactive)
+
+```bash
+ai --ask "explain kubernetes"
+ai --agent coder "build a flask app"
+ai --team claude codex "discuss auth"
+ai --tools
+ai --models
+ai --status
+ai doctor
+ai update
+echo "what is rust?" | ai
+```
+
+## Aliases
+
+Type faster with 30+ shortcuts:
+
+| Short | Full | Short | Full |
+|-------|------|-------|------|
+| `/q` | `/quit` | `/a` | `/all` |
+| `/n` | `/new` | `/sw` | `/swarm` |
+| `/s` | `/save` | `/t` | `/think` |
+| `/m` | `/model` | `/h` | `/help` |
+| `/f` | `/file` | `/con` | `/connect` |
+
+## Architecture
+
+```
+codegpt/
+  chat.py          6,200 lines   Main CLI (Python)
+  bin/chat.js       300 lines    Node.js fallback
+  bin/ai.js          50 lines    Entry point (routes to Python or Node)
+  ai_cli/                        Package (updater, doctor)
+  app.py                         TUI app (Textual)
+  bot.py                         Telegram bot
+  web.py                         Web app (Flask PWA)
+  server.py                      Backend API
+```
+
+## Data
+
+All data stored locally at `~/.codegpt/`:
+- `profiles/` — user profile
+- `memory/` — persistent AI memories
+- `security/` — PIN hash, audit log
+- `training/` — training data, custom models
+- `chats/` — saved conversations
+
+## License
+
+MIT
+
+## Author
+
+Built by [ArukuX](https://github.com/CCguvycu)

package/ai_cli/updater.py

@@ -148,18 +148,64 @@ def force_update():
         return
 
     asset = exe_assets[0]
+
+    # Find checksum file in release assets
+    sha_assets = [a for a in release.get("assets", []) if a["name"].endswith(".sha256")]
+    expected_hash = None
+    if sha_assets:
+        try:
+            sha_resp = requests.get(sha_assets[0]["browser_download_url"], timeout=10)
+            # Parse certutil output: second line is the hash
+            lines = sha_resp.text.strip().splitlines()
+            for line in lines:
+                line = line.strip().replace(" ", "")
+                if len(line) == 64 and all(c in "0123456789abcdef" for c in line.lower()):
+                    expected_hash = line.lower()
+                    break
+        except Exception:
+            pass
+
     console.print(f"  Downloading {asset['name']} ({latest_tag})...")
+    if expected_hash:
+        console.print(f"  Expected SHA256: {expected_hash[:16]}...")
+    else:
+        console.print("[yellow]  WARNING: No checksum file found. Cannot verify integrity.[/]")
 
     try:
         resp = requests.get(asset["browser_download_url"], stream=True, timeout=60)
         resp.raise_for_status()
 
-        # Download to temp file
+        # Download to temp file and compute hash
+        import hashlib as _hashlib
+        sha256 = _hashlib.sha256()
         tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".exe")
         for chunk in resp.iter_content(chunk_size=8192):
             tmp.write(chunk)
+            sha256.update(chunk)
         tmp.close()
 
+        actual_hash = sha256.hexdigest().lower()
+        console.print(f"  Actual SHA256:   {actual_hash[:16]}...")
+
+        # Verify checksum if available
+        if expected_hash and actual_hash != expected_hash:
+            console.print(Panel(
+                Text(
+                    "CHECKSUM MISMATCH — download may be tampered with.\n"
+                    f"Expected: {expected_hash}\n"
+                    f"Got:      {actual_hash}\n\n"
+                    "Update aborted for your safety.",
+                    style="bold red"
+                ),
+                title="[bold red]SECURITY ALERT[/]",
+                border_style="red",
+            ))
+            os.unlink(tmp.name)
+            return
+
+        if expected_hash:
+            console.print("[green]  Checksum verified.[/]")
+
         if _is_frozen():
             # Replace the running exe
             current_exe = sys.executable
@@ -172,7 +218,7 @@ def force_update():
             shutil.move(tmp.name, current_exe)
 
             console.print(Panel(
-                Text(f"Updated: v{current} -> {latest_tag}\nRestart to use the new version.", style="green"),
+                Text(f"Updated: v{current} -> {latest_tag}\nChecksum: {actual_hash[:16]}...\nRestart to use the new version.", style="green"),
                 border_style="green",
             ))
         else:

package/bin/ai.js

@@ -19,12 +19,8 @@ function findPython() {
 }
 
 const python = findPython();
-if (!python) {
-  console.error("Python not found. Install from https://python.org");
-  process.exit(1);
-}
 
-// Find chat.py — check npm package dir first, then common locations
+// Find chat.py
 const locations = [
   path.join(__dirname, "..", "chat.py"),
   path.join(process.env.HOME || process.env.USERPROFILE, "codegpt", "chat.py"),
@@ -39,17 +35,22 @@ for (const loc of locations) {
   }
 }
 
-if (!chatPy) {
-  console.error("CodeGPT not found. Run: codegpt-setup");
-  process.exit(1);
+// If Python + chat.py found, use full Python CLI
+if (python && chatPy) {
+  const args = [chatPy, ...process.argv.slice(2)];
+  const child = spawn(python, args, {
+    stdio: "inherit",
+    cwd: path.dirname(chatPy),
+    env: { ...process.env, PYTHONUTF8: "1" },
+  });
+  child.on("exit", (code) => process.exit(code || 0));
+} else {
+  // Fallback: Node.js chat client (no Python needed)
+  if (!python) {
+    console.log("  Python not found — using Node.js mode.");
+    console.log("  Install Python for the full 80+ command experience.\n");
+  } else {
+    console.log("  chat.py not found — using Node.js mode.\n");
+  }
+  require("./chat.js");
 }
-
-// Pass all args through to Python
-const args = [chatPy, ...process.argv.slice(2)];
-const child = spawn(python, args, {
-  stdio: "inherit",
-  cwd: path.dirname(chatPy),
-  env: { ...process.env, PYTHONUTF8: "1" },
-});
-
-child.on("exit", (code) => process.exit(code || 0));

package/bin/chat.js

@@ -0,0 +1,361 @@
+#!/usr/bin/env node
+/**
+ * CodeGPT — Node.js CLI (no Python required)
+ * Fallback when Python isn't installed. Connects to Ollama directly.
+ */
+
+const readline = require("readline");
+const http = require("http");
+const os = require("os");
+const fs = require("fs");
+const path = require("path");
+
+// --- Config ---
+const HOME = os.homedir();
+const CONFIG_DIR = path.join(HOME, ".codegpt");
+const PROFILE_FILE = path.join(CONFIG_DIR, "profiles", "cli_profile.json");
+const HISTORY_FILE = path.join(CONFIG_DIR, "node_history.json");
+const URL_FILE = path.join(CONFIG_DIR, "ollama_url");
+
+let OLLAMA_HOST = process.env.OLLAMA_URL || "http://localhost:11434";
+if (OLLAMA_HOST.includes("/api/chat")) OLLAMA_HOST = OLLAMA_HOST.replace("/api/chat", "");
+
+let MODEL = "llama3.2";
+let SYSTEM = "You are a helpful AI assistant. Be concise and technical.";
+let messages = [];
+let history = [];
+let totalTokens = 0;
+let startTime = Date.now();
+
+// --- Colors ---
+const c = {
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+  dim: (s) => `\x1b[2m${s}\x1b[0m`,
+  bold: (s) => `\x1b[1m${s}\x1b[0m`,
+  white: (s) => `\x1b[37m${s}\x1b[0m`,
+};
+
+// --- Helpers ---
+function ensureDir(p) {
+  if (!fs.existsSync(p)) fs.mkdirSync(p, { recursive: true });
+}
+
+function loadProfile() {
+  try {
+    if (fs.existsSync(PROFILE_FILE)) return JSON.parse(fs.readFileSync(PROFILE_FILE, "utf8"));
+  } catch {}
+  return { name: "", model: "llama3.2", persona: "default", total_sessions: 0 };
+}
+
+function saveProfile(profile) {
+  ensureDir(path.dirname(PROFILE_FILE));
+  fs.writeFileSync(PROFILE_FILE, JSON.stringify(profile, null, 2));
+}
+
+function loadSavedUrl() {
+  try {
+    if (fs.existsSync(URL_FILE)) {
+      const url = fs.readFileSync(URL_FILE, "utf8").trim();
+      if (url) return url.replace("/api/chat", "");
+    }
+  } catch {}
+  return null;
+}
+
+// --- Ollama API ---
+function ollamaRequest(endpoint, body) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(endpoint, OLLAMA_HOST);
+    const data = JSON.stringify(body);
+    const req = http.request(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      timeout: 120000,
+    }, (res) => {
+      let result = "";
+      res.on("data", (chunk) => result += chunk);
+      res.on("end", () => {
+        try { resolve(JSON.parse(result)); } catch { resolve(result); }
+      });
+    });
+    req.on("error", reject);
+    req.on("timeout", () => { req.destroy(); reject(new Error("timeout")); });
+    req.write(data);
+    req.end();
+  });
+}
+
+function ollamaGet(endpoint) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(endpoint, OLLAMA_HOST);
+    http.get(url, { timeout: 5000 }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => data += chunk);
+      res.on("end", () => {
+        try { resolve(JSON.parse(data)); } catch { resolve(null); }
+      });
+    }).on("error", reject).on("timeout", function() { this.destroy(); reject(new Error("timeout")); });
+  });
+}
+
+async function streamChat(msgs) {
+  return new Promise((resolve, reject) => {
+    const url = new URL("/api/chat", OLLAMA_HOST);
+    const body = JSON.stringify({
+      model: MODEL,
+      messages: [{ role: "system", content: SYSTEM }, ...msgs],
+      stream: true,
+    });
+
+    const req = http.request(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      timeout: 120000,
+    }, (res) => {
+      let full = "";
+      process.stdout.write(`\n  ${c.green("AI")} > `);
+
+      res.on("data", (chunk) => {
+        const lines = chunk.toString().split("\n").filter(Boolean);
+        for (const line of lines) {
+          try {
+            const obj = JSON.parse(line);
+            if (obj.message?.content) {
+              process.stdout.write(obj.message.content);
+              full += obj.message.content;
+            }
+            if (obj.eval_count) totalTokens += obj.eval_count;
+          } catch {}
+        }
+      });
+
+      res.on("end", () => {
+        process.stdout.write("\n\n");
+        resolve(full);
+      });
+    });
+
+    req.on("error", (e) => {
+      console.log(c.red(`\n  Error: ${e.message}`));
+      resolve("");
+    });
+    req.on("timeout", () => { req.destroy(); resolve(""); });
+    req.write(body);
+    req.end();
+  });
+}
+
+async function getModels() {
+  try {
+    const data = await ollamaGet("/api/tags");
+    return data?.models?.map((m) => m.name) || [];
+  } catch {
+    return [];
+  }
+}
+
+// --- UI ---
+const LOGO = `
+  ${c.cyan("██████╗ ██████╗ ██████╗ ███████╗")}${c.white(" ██████╗ ██████╗ ████████╗")}
+  ${c.cyan("██╔════╝██╔═══██╗██╔══██╗██╔════╝")}${c.white("██╔════╝ ██╔══██╗╚══██╔══╝")}
+  ${c.cyan("██║     ██║   ██║██║  ██║█████╗  ")}${c.white("██║  ███╗██████╔╝   ██║   ")}
+  ${c.cyan("██║     ██║   ██║██║  ██║██╔══╝  ")}${c.white("██║   ██║██╔═══╝    ██║   ")}
+  ${c.cyan("╚██████╗╚██████╔╝██████╔╝███████╗")}${c.white("╚██████╔╝██║        ██║   ")}
+  ${c.cyan(" ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝")}${c.white(" ╚═════╝ ╚═╝        ╚═╝   ")}
+  ${c.dim("        Your Local AI Assistant — Node.js Edition")}
+`;
+
+const COMMANDS = {
+  "/help": "Show commands",
+  "/model": "Switch model (/model name)",
+  "/models": "List available models",
+  "/new": "Start new conversation",
+  "/history": "Show conversation",
+  "/connect": "Connect to remote Ollama (/connect IP)",
+  "/server": "Show current server",
+  "/clear": "Clear screen",
+  "/quit": "Exit",
+};
+
+function printHeader() {
+  console.clear();
+  console.log(LOGO);
+  const elapsed = Math.floor((Date.now() - startTime) / 1000 / 60);
+  console.log(c.dim(`  ${MODEL} | ${messages.length} msgs | ${totalTokens} tok | ${elapsed}m | ${OLLAMA_HOST}`));
+  console.log();
+}
+
+function printHelp() {
+  console.log(c.bold("\n  Commands:"));
+  for (const [cmd, desc] of Object.entries(COMMANDS)) {
+    console.log(`  ${c.cyan(cmd.padEnd(14))} ${c.dim(desc)}`);
+  }
+  console.log();
+}
+
+// --- Main ---
+async function main() {
+  // Load saved URL
+  const savedUrl = loadSavedUrl();
+  if (savedUrl) OLLAMA_HOST = savedUrl;
+
+  // Load profile
+  const profile = loadProfile();
+  if (profile.model) MODEL = profile.model;
+
+  // Check Ollama
+  let models = await getModels();
+  if (!models.length) {
+    // Try common IPs
+    for (const ip of ["http://192.168.1.237:11434", "http://10.0.2.2:11434"]) {
+      OLLAMA_HOST = ip;
+      models = await getModels();
+      if (models.length) break;
+    }
+  }
+
+  printHeader();
+
+  if (!models.length) {
+    console.log(c.yellow("  No Ollama server found."));
+    console.log(c.dim("  Use /connect IP to connect to a remote server."));
+    console.log(c.dim("  Or install Ollama: https://ollama.com\n"));
+  } else {
+    const hour = new Date().getHours();
+    const greeting = hour < 12 ? "Good morning" : hour < 18 ? "Good afternoon" : "Good evening";
+    const name = profile.name || "there";
+    console.log(c.bold(`  ${greeting}, ${name}.\n`));
+  }
+
+  // Update session count
+  profile.total_sessions = (profile.total_sessions || 0) + 1;
+  saveProfile(profile);
+
+  // REPL
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: `  ${c.cyan(">")} `,
+    historySize: 100,
+  });
+
+  rl.prompt();
+
+  rl.on("line", async (line) => {
+    const input = line.trim();
+    if (!input) { rl.prompt(); return; }
+
+    if (input.startsWith("/")) {
+      const cmd = input.split(" ")[0].toLowerCase();
+      const args = input.slice(cmd.length).trim();
+
+      switch (cmd) {
+        case "/quit":
+        case "/q":
+        case "/exit":
+          const elapsed = Math.floor((Date.now() - startTime) / 1000);
+          console.log(c.dim(`\n  ${elapsed}s | ${messages.length} msgs | ${totalTokens} tok`));
+          process.exit(0);
+
+        case "/help":
+        case "/h":
+          printHelp();
+          break;
+
+        case "/model":
+        case "/m":
+          if (args) {
+            MODEL = args;
+            profile.model = MODEL;
+            saveProfile(profile);
+            console.log(c.green(`  Model: ${MODEL}`));
+          } else {
+            console.log(c.dim(`  Current: ${MODEL}`));
+          }
+          break;
+
+        case "/models":
+          const mods = await getModels();
+          if (mods.length) {
+            console.log(c.bold("\n  Models:"));
+            mods.forEach((m) => console.log(`  ${m === MODEL ? c.green("* " + m) : c.dim("  " + m)}`));
+            console.log();
+          } else {
+            console.log(c.red("  Ollama not reachable."));
+          }
+          break;
+
+        case "/new":
+        case "/n":
+          messages = [];
+          printHeader();
+          console.log(c.dim("  New conversation.\n"));
+          break;
+
+        case "/history":
+          if (!messages.length) { console.log(c.dim("  No messages.\n")); break; }
+          messages.forEach((m) => {
+            const tag = m.role === "user" ? c.cyan("You") : c.green("AI");
+            console.log(`  ${tag} > ${m.content.slice(0, 200)}\n`);
+          });
+          break;
+
+        case "/connect":
+        case "/con":
+          if (args) {
+            let url = args;
+            if (!url.startsWith("http")) url = "http://" + url;
+            if (!url.includes(":")) url += ":11434";
+            OLLAMA_HOST = url;
+            const test = await getModels();
+            if (test.length) {
+              models = test;
+              ensureDir(CONFIG_DIR);
+              fs.writeFileSync(URL_FILE, OLLAMA_HOST + "/api/chat");
+              console.log(c.green(`  Connected: ${OLLAMA_HOST} (${test.length} models)`));
+            } else {
+              console.log(c.red(`  Cannot reach ${OLLAMA_HOST}`));
+            }
+          } else {
+            console.log(c.dim("  Usage: /connect 192.168.1.237"));
+          }
+          break;
+
+        case "/server":
+        case "/srv":
+          const test2 = await getModels();
+          const status = test2.length ? c.green("connected") : c.red("offline");
+          console.log(`  ${c.dim("Server:")} ${OLLAMA_HOST} ${status}`);
+          break;
+
+        case "/clear":
+        case "/c":
+          printHeader();
+          break;
+
+        default:
+          console.log(c.dim(`  Unknown: ${cmd}. Type /help`));
+      }
+
+      rl.prompt();
+      return;
+    }
+
+    // Regular message
+    messages.push({ role: "user", content: input });
+    const response = await streamChat(messages);
+    if (response) {
+      messages.push({ role: "assistant", content: response });
+    } else {
+      messages.pop();
+    }
+    rl.prompt();
+  });
+
+  rl.on("close", () => process.exit(0));
+}
+
+main().catch(console.error);