@krmxd/onegpt 0.0.0-beta

package/src/config.js

@@ -0,0 +1,157 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { ogptNamesMap, tierRouting } = require("./catalog");
+
+const CONFIG_DIR = path.join(os.homedir(), ".config", "ogpt");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+
+const DEFAULTS = {
+  active_provider: "ollama",
+  active_model: "qwen2.5-coder:1.5b",
+  ollama: {
+    host: "http://127.0.0.1:11434",
+    timeout: 300,
+    keep_alive: "30m",
+    num_ctx: 8192,
+    warmup: true,
+  },
+  model_routing: tierRouting(),
+  ogpt_names: ogptNamesMap(),
+  aliases: {},
+  agent: {
+    max_rounds: 25,
+    max_tokens: 4096,
+    temperature: 0.7,
+    system_prompt:
+      "You are OGPT, the AI coding assistant built by KareemXD, running as {ogpt_model}. You are an expert programmer. You have tools to read/write files, run commands, search code, and use git - always use tools when needed. When the user asks you to create code or build something, write the files using your write_file tool and provide a clear explanation of what each file does. Be concise, direct, and helpful.",
+  },
+  ui: {
+    stream: true,
+    color: true,
+    preview: true,
+    timing: true,
+  },
+  session: {
+    auto_save: true,
+    restore_last: true,
+  },
+};
+
+function deepMerge(base, over) {
+  const r = { ...base };
+  for (const [k, v] of Object.entries(over)) {
+    if (r[k] && typeof r[k] === "object" && !Array.isArray(r[k]) && typeof v === "object" && !Array.isArray(v)) {
+      r[k] = deepMerge(r[k], v);
+    } else {
+      r[k] = v;
+    }
+  }
+  return r;
+}
+
+class Config {
+  constructor(filePath) {
+    this.path = filePath || CONFIG_FILE;
+    fs.mkdirSync(path.dirname(this.path), { recursive: true });
+    this._data = {};
+    this.load();
+  }
+
+  load() {
+    try {
+      if (fs.existsSync(this.path)) {
+        const saved = JSON.parse(fs.readFileSync(this.path, "utf-8"));
+        this._data = deepMerge(DEFAULTS, saved);
+      } else {
+        this._data = JSON.parse(JSON.stringify(DEFAULTS));
+      }
+    } catch {
+      this._data = JSON.parse(JSON.stringify(DEFAULTS));
+    }
+    this._envOverride();
+    return this._data;
+  }
+
+  save() {
+    fs.writeFileSync(this.path, JSON.stringify(this._data, null, 2));
+  }
+
+  get(key, defaultValue) {
+    const keys = key.split(".");
+    let val = this._data;
+    for (const k of keys) {
+      if (val && typeof val === "object") val = val[k];
+      else return defaultValue;
+      if (val === undefined || val === null) return defaultValue;
+    }
+    return val;
+  }
+
+  set(key, value) {
+    const keys = key.split(".");
+    let d = this._data;
+    for (let i = 0; i < keys.length - 1; i++) {
+      if (!d[keys[i]] || typeof d[keys[i]] !== "object") d[keys[i]] = {};
+      d = d[keys[i]];
+    }
+    d[keys[keys.length - 1]] = value;
+    this.save();
+  }
+
+  activeProvider() {
+    return this._data.active_provider || "ollama";
+  }
+
+  activeModel() {
+    return this._data.active_model || "qwen2.5-coder:1.5b";
+  }
+
+  displayName(model) {
+    const m = model || this.activeModel();
+    const { displayName: catDisplay, MODEL_CATALOG } = require("./catalog");
+    const custom = this._data.ogpt_names && this._data.ogpt_names[m];
+    if (custom && !MODEL_CATALOG[m]) return custom;
+    return catDisplay(m);
+  }
+
+  resolveModel(name) {
+    if (!name) return "";
+    const { resolveModel: catResolve } = require("./catalog");
+    const resolved = catResolve(name);
+    if (resolved) return resolved;
+    const aliases = this._data.aliases || {};
+    const target = aliases[name.toLowerCase()] || aliases[name];
+    if (target) {
+      // alias may be a full command ("/model oGPT-2a") or a raw model id
+      const parts = String(target).trim().split(/\s+/);
+      const last = parts[parts.length - 1];
+      return catResolve(last) || target;
+    }
+    for (const [mid, disp] of Object.entries(this._data.ogpt_names || {})) {
+      if (disp.toLowerCase() === name.toLowerCase()) return mid;
+    }
+    return name;
+  }
+
+  data() {
+    return this._data;
+  }
+
+  _envOverride() {
+    const ollamaHost = process.env.OLLAMA_HOST;
+    if (ollamaHost && this._data.ollama) {
+      this._data.ollama.host = ollamaHost;
+    }
+  }
+}
+
+let _cfg = null;
+function getConfig(filePath) {
+  if (!_cfg) _cfg = new Config(filePath);
+  return _cfg;
+}
+
+module.exports = { Config, getConfig, DEFAULTS, CONFIG_DIR };

package/src/glob.js

@@ -0,0 +1,58 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+function globSync(pattern, root) {
+  root = root || ".";
+  const results = [];
+  const parts = pattern.split("**");
+  if (parts.length === 2) {
+    const before = parts[0];
+    const after = parts[1].replace(/^\//, "");
+    const walk = (dir) => {
+      try {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+          const full = path.join(dir, entry.name);
+          if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+            walk(full);
+          } else if (entry.isFile()) {
+            const rel = path.relative(root, full);
+            if (matchGlob(after, entry.name)) {
+              results.push(rel);
+            }
+          }
+        }
+      } catch {}
+    };
+    walk(path.resolve(root));
+  } else {
+    const dir = path.dirname(pattern);
+    const filePattern = path.basename(pattern);
+    try {
+      const resolvedDir = path.resolve(root, dir === "." ? "" : dir);
+      for (const entry of fs.readdirSync(resolvedDir, { withFileTypes: true })) {
+        if (entry.isFile() && matchGlob(filePattern, entry.name)) {
+          results.push(path.join(dir, entry.name));
+        }
+      }
+    } catch {}
+  }
+  return results;
+}
+
+function matchGlob(pattern, name) {
+  if (pattern === "*") return true;
+  if (pattern.startsWith("*.")) {
+    return name.endsWith(pattern.slice(1));
+  }
+  if (pattern.includes("*")) {
+    const regex = new RegExp(
+      "^" + pattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$"
+    );
+    return regex.test(name);
+  }
+  return name === pattern;
+}
+
+module.exports = { globSync };

package/src/index.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const { CLI } = require("./cli");
+const { Agent } = require("./agent");
+const { ToolRegistry } = require("./tools");
+const { getConfig, Config } = require("./config");
+const { OllamaProvider, getSharedProvider } = require("./ollama");
+const catalog = require("./catalog");
+const Platform = require("./platform");
+
+module.exports = { CLI, Agent, ToolRegistry, getConfig, Config, OllamaProvider, getSharedProvider, catalog, Platform };

package/src/ollama.js

@@ -0,0 +1,427 @@
+"use strict";
+
+const http = require("http");
+const https = require("https");
+const { URL } = require("url");
+
+function normalizeHost(host) {
+  if (!host) return "http://127.0.0.1:11434";
+  return host.replace(/localhost/g, "127.0.0.1");
+}
+
+class OllamaProvider {
+  constructor(host, options = {}) {
+    this.host = normalizeHost(host || "http://127.0.0.1:11434");
+    this.timeout = (options.timeout || 600) * 1000;
+    this.maxRetries = options.maxRetries || 3;
+    this.retryDelay = options.retryDelay || 1000;
+    // Max silence between streamed bytes before giving up.
+    // Generous: cold model loads may send nothing for minutes.
+    this.idleTimeout = options.idleTimeout || 300 * 1000;
+    this.availabilityTtl = options.availabilityTtl || 5000;
+    this._modelCache = null;
+    this._modelCacheTs = 0;
+    this._availCache = null;
+    this._availTs = 0;
+    this._agent = new http.Agent({
+      keepAlive: true,
+      keepAliveMsecs: 120000,
+      maxSockets: 8,
+      maxFreeSockets: 4,
+    });
+  }
+
+  _cfg(key, fallback) {
+    try {
+      const { getConfig } = require("./config");
+      return getConfig().get(key, fallback);
+    } catch {
+      return fallback;
+    }
+  }
+
+  _keepAlive() {
+    return this._cfg("ollama.keep_alive", "30m");
+  }
+
+  _options(temperature = 0.7, maxTokens = 4096) {
+    const opts = {
+      temperature,
+      num_predict: maxTokens,
+      num_ctx: parseInt(this._cfg("ollama.num_ctx", 8192), 10) || 8192,
+    };
+    const threads = this._cfg("ollama.num_thread", 0);
+    if (threads) opts.num_thread = parseInt(threads, 10);
+    return opts;
+  }
+
+  async isAvailable() {
+    const now = Date.now();
+    if (this._availCache !== null && now - this._availTs < this.availabilityTtl) {
+      return this._availCache;
+    }
+    let ok = false;
+    try {
+      const r = await this._get("/api/tags", 3000);
+      ok = r.status === 200;
+    } catch {
+      ok = false;
+    }
+    this._availCache = ok;
+    this._availTs = Date.now();
+    return ok;
+  }
+
+  _markUnavailable() {
+    this._availCache = false;
+    this._availTs = Date.now();
+  }
+
+  // Preload a model into memory so the first real message is instant.
+  // Must pass the same options as chat() (num_ctx etc.), otherwise Ollama
+  // reloads the model on the next chat request, causing lag.
+  async warmup(model) {
+    try {
+      const r = await this._post("/api/generate", {
+        model,
+        keep_alive: this._keepAlive(),
+        options: this._options(0.7, 1),
+      });
+      return r.status === 200;
+    } catch {
+      return false;
+    }
+  }
+
+  // Models currently loaded in memory (/api/ps).
+  async runningModels() {
+    try {
+      const r = await this._get("/api/ps", 5000);
+      if (r.status !== 200) return [];
+      return JSON.parse(r.body).models || [];
+    } catch {
+      return [];
+    }
+  }
+
+  // Stream-pull a model, yielding progress objects.
+  async *pull(model) {
+    try {
+      const response = await this._postStream("/api/pull", { model, stream: true });
+      if (response.status !== 200) {
+        yield { error: `Engine HTTP ${response.status}` };
+        return;
+      }
+      let buffer = "";
+      for await (const chunk of response.body) {
+        buffer += chunk.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop();
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            yield JSON.parse(line);
+          } catch {}
+        }
+      }
+    } catch (e) {
+      yield { error: e.message };
+    }
+  }
+
+  async chat(messages, model, options = {}) {
+    const { tools, system, temperature = 0.7, maxTokens = 4096 } = options;
+    const msgs = this._fmt(messages, system);
+    const payload = {
+      model,
+      messages: msgs,
+      stream: false,
+      keep_alive: this._keepAlive(),
+      options: this._options(temperature, maxTokens),
+    };
+    if (tools && tools.length) {
+      payload.tools = tools.map((t) => this._toOllamaTool(t));
+    }
+    let lastErr;
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      try {
+        const r = await this._post("/api/chat", payload);
+        if (r.status !== 200) {
+          throw new Error(`Engine HTTP ${r.status}: ${r.body}`);
+        }
+        const data = JSON.parse(r.body);
+        const msg = data.message || {};
+        const toolCalls = (msg.tool_calls || []).map((tc) => ({
+          id: tc.id || `tc_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+          name: tc.function.name,
+          arguments: tc.function.arguments || {},
+        }));
+        return {
+          content: msg.content || "",
+          toolCalls,
+          usage: {
+            prompt: data.prompt_eval_count || 0,
+            completion: data.eval_count || 0,
+            total: (data.prompt_eval_count || 0) + (data.eval_count || 0),
+          },
+          model,
+        };
+      } catch (e) {
+        lastErr = e;
+        this._markUnavailable();
+        if (attempt < this.maxRetries - 1) {
+          await sleep(this.retryDelay * (attempt + 1));
+        }
+      }
+    }
+    throw lastErr || new Error("Local engine connection failed");
+  }
+
+  async *stream(messages, model, options = {}) {
+    const { tools, system, temperature = 0.7, maxTokens = 4096 } = options;
+    const msgs = this._fmt(messages, system);
+    const payload = {
+      model,
+      messages: msgs,
+      stream: true,
+      keep_alive: this._keepAlive(),
+      options: this._options(temperature, maxTokens),
+    };
+    if (tools && tools.length) {
+      payload.tools = tools.map((t) => this._toOllamaTool(t));
+    }
+    let lastErr;
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      try {
+        const response = await this._postStream("/api/chat", payload);
+        if (response.status !== 200) {
+          yield { type: "error", error: `Engine HTTP ${response.status}` };
+          return;
+        }
+        let buffer = "";
+        for await (const chunk of response.body) {
+          buffer += chunk.toString();
+          const lines = buffer.split("\n");
+          buffer = lines.pop();
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+              const data = JSON.parse(line);
+              if (data.message) {
+                const tok = data.message.content || "";
+                if (tok) yield { type: "text", text: tok };
+                for (const tc of data.message.tool_calls || []) {
+                  const fn = tc.function || {};
+                  let args = fn.arguments || {};
+                  if (typeof args === "string") {
+                    try { args = JSON.parse(args); } catch { args = {}; }
+                  }
+                  yield { type: "tool", id: tc.id || "", name: fn.name, arguments: args };
+                }
+              }
+              if (data.done) {
+                yield {
+                  type: "usage",
+                  usage: {
+                    prompt: data.prompt_eval_count || 0,
+                    completion: data.eval_count || 0,
+                    total: (data.prompt_eval_count || 0) + (data.eval_count || 0),
+                  },
+                };
+                return;
+              }
+            } catch {}
+          }
+        }
+        return;
+      } catch (e) {
+        lastErr = e;
+        this._markUnavailable();
+        if (attempt < this.maxRetries - 1) {
+          yield { type: "retry", attempt: attempt + 2, max: this.maxRetries };
+          await sleep(this.retryDelay * (attempt + 1));
+        }
+      }
+    }
+    yield { type: "error", error: lastErr?.message || "Local engine connection failed" };
+  }
+
+  async listModels(forceRefresh = false) {
+    const now = Date.now();
+    if (this._modelCache && !forceRefresh && now - this._modelCacheTs < 30000) {
+      return this._modelCache;
+    }
+    try {
+      const r = await this._get("/api/tags", 5000);
+      if (r.status !== 200) return this._modelCache || [];
+      const data = JSON.parse(r.body);
+      this._modelCache = (data.models || []).map((m) => ({
+        id: m.name,
+        name: m.name,
+        size: m.size || 0,
+      }));
+      this._modelCacheTs = now;
+      return this._modelCache;
+    } catch {
+      return this._modelCache || [];
+    }
+  }
+
+  async isModelAvailable(model) {
+    const models = await this.listModels();
+    return models.some((m) => m.id === model);
+  }
+
+  async bestAvailableModel(tier, configuredModel) {
+    if (configuredModel && (await this.isModelAvailable(configuredModel))) {
+      return configuredModel;
+    }
+    const { getConfig } = require("./config");
+    const routing = getConfig().get("model_routing", {});
+    const tierModel = routing[tier] || "";
+    if (tierModel && (await this.isModelAvailable(tierModel))) {
+      return tierModel;
+    }
+    const models = await this.listModels();
+    if (!models.length) return configuredModel || tierModel || "qwen2.5-coder:1.5b";
+    // Prefer the strongest catalog model that fits this machine's RAM
+    try {
+      const Platform = require("./platform");
+      const { recommendForRam } = require("./catalog");
+      const fit = recommendForRam(Platform.ramGB());
+      if (models.some((m) => m.id === fit)) return fit;
+    } catch {}
+    const qwen = models.find((m) => m.id.includes("qwen"));
+    return qwen ? qwen.id : models[0].id;
+  }
+
+  _fmt(messages, system) {
+    const msgs = [];
+    if (system) msgs.push({ role: "system", content: system });
+    for (const m of messages) {
+      const d = { role: m.role, content: m.content };
+      if (m.toolCalls && m.toolCalls.length) {
+        d.tool_calls = m.toolCalls.map((tc) => ({
+          function: { name: tc.name, arguments: tc.arguments },
+        }));
+      }
+      if (m.toolCallId) {
+        d.role = "tool";
+        d.tool_call_id = m.toolCallId;
+      }
+      msgs.push(d);
+    }
+    return msgs;
+  }
+
+  _toOllamaTool(toolDef) {
+    return {
+      type: "function",
+      function: {
+        name: toolDef.name,
+        description: toolDef.description,
+        parameters: toolDef.parameters,
+      },
+    };
+  }
+
+  _request(method, urlPath, body, timeout) {
+    return new Promise((resolve, reject) => {
+      const parsed = new URL(urlPath, this.host);
+      const isHttps = parsed.protocol === "https:";
+      const lib = isHttps ? https : http;
+      const req = lib.request(
+        {
+          hostname: parsed.hostname,
+          port: parsed.port,
+          path: parsed.pathname + parsed.search,
+          method,
+          agent: this._agent,
+          timeout: timeout || this.timeout,
+          headers: body ? { "Content-Type": "application/json" } : {},
+        },
+        (res) => {
+          const chunks = [];
+          res.on("data", (c) => chunks.push(c));
+          res.on("end", () => {
+            resolve({ status: res.statusCode, body: Buffer.concat(chunks).toString() });
+          });
+        }
+      );
+      req.on("error", reject);
+      req.on("timeout", () => { req.destroy(); reject(new Error("Timeout")); });
+      if (body) req.write(JSON.stringify(body));
+      req.end();
+    });
+  }
+
+  _get(urlPath, timeout) {
+    return this._request("GET", urlPath, null, timeout);
+  }
+
+  _post(urlPath, body) {
+    return this._request("POST", urlPath, body);
+  }
+
+  _postStream(urlPath, body) {
+    return new Promise((resolve, reject) => {
+      const parsed = new URL(urlPath, this.host);
+      const isHttps = parsed.protocol === "https:";
+      const lib = isHttps ? https : http;
+      let idleTimer = null;
+      const req = lib.request(
+        {
+          hostname: parsed.hostname,
+          port: parsed.port,
+          path: parsed.pathname + parsed.search,
+          method: "POST",
+          agent: this._agent,
+          // No fixed socket timeout: an inactivity watchdog below handles stalls,
+          // while cold model loads (minutes of silence) are tolerated.
+          timeout: 0,
+          headers: { "Content-Type": "application/json" },
+        },
+        (res) => {
+          // Reset the idle watchdog on every received chunk
+          res.on("data", () => resetIdle());
+          resolve({ status: res.statusCode, body: res });
+        }
+      );
+      const clearIdle = () => { if (idleTimer) { clearTimeout(idleTimer); idleTimer = null; } };
+      const resetIdle = () => {
+        clearIdle();
+        idleTimer = setTimeout(() => {
+          req.destroy(new Error(`No data from the local engine for ${Math.round(this.idleTimeout / 1000)}s`));
+        }, this.idleTimeout);
+      };
+      req.on("error", (e) => { clearIdle(); reject(e); });
+      req.on("close", clearIdle);
+      req.write(JSON.stringify(body));
+      req.end();
+      resetIdle(); // also covers slow cold starts before the first byte
+    });
+  }
+
+  close() {
+    this._agent.destroy();
+  }
+}
+
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// Shared connection pool
+let _shared = null;
+let _sharedHost = "";
+
+function getSharedProvider(host) {
+  const normalized = normalizeHost(host);
+  if (_shared && _sharedHost === normalized) return _shared;
+  if (_shared) _shared.close();
+  _shared = new OllamaProvider(normalized);
+  _sharedHost = normalized;
+  return _shared;
+}
+
+module.exports = { OllamaProvider, getSharedProvider };

package/src/platform.js

@@ -0,0 +1,37 @@
+"use strict";
+
+const os = require("os");
+
+class Platform {
+  static ramBytes() {
+    return os.totalmem();
+  }
+
+  static ramGB() {
+    return Math.round((os.totalmem() / (1024 ** 3)) * 10) / 10;
+  }
+
+  static cpuCount() {
+    return os.cpus().length || 4;
+  }
+
+  static safeThreads() {
+    return Math.max(1, Math.min(Math.floor(this.cpuCount() * 0.6), 8));
+  }
+
+  static recommendTier() {
+    const gb = this.ramGB();
+    if (gb >= 24) return "pro";
+    if (gb >= 8) return "balanced";
+    return "fast";
+  }
+
+  static recommendThreads() {
+    const cpus = this.cpuCount();
+    const gb = this.ramGB();
+    if (gb > 0 && gb < 6) return Math.max(1, Math.floor(cpus / 2));
+    return this.safeThreads();
+  }
+}
+
+module.exports = Platform;