@alhisan/gac 1.0.0 → 1.1.0

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,33 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Publish Package to npmjs
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npm test
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm publish --provenance --access public
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/README.md

@@ -1,10 +1,10 @@
-# GPT4All CLI (gac)
+# GAC CLI (gac)
 
-Terminal client for GPT4All running on localhost. Supports streaming responses, interactive chat, and configurable markdown rendering using `terminal-kit`.
+Terminal client for OpenAI-compatible APIs (including GPT4All) and Ollama. Supports streaming responses, interactive chat, and configurable markdown rendering using `terminal-kit`.
 
 ## Installation
 
-Requirements: Node.js 18+ and a running GPT4All OpenAI-compatible server.
+Requirements: Node.js 18+ and a running OpenAI-compatible server (like GPT4All) or Ollama.
 
 ```bash
 npm install -g @alhisan/gac
@@ -68,6 +68,7 @@ View and edit:
 
 ```bash
 gac config
+gac config tui
 gac config get baseUrl
 gac config set baseUrl http://localhost:4891
 gac config set model "Llama 3 8B Instruct"
@@ -77,7 +78,10 @@ gac config set detailedSuggest true
 
 ### Core settings
 
+- `provider` (string): `openai` (default) or `ollama`
 - `baseUrl` (string): GPT4All server base, e.g. `http://localhost:4891`
+- `ollamaBaseUrl` (string): Ollama base, e.g. `http://localhost:11434`
+- `apiKey` (string): API key for OpenAI-compatible services (empty for local servers)
 - `model` (string): model ID from `/v1/models`
 - `temperature` (number)
 - `maxTokens` (number)
@@ -136,9 +140,19 @@ Example:
 If you see connection errors, verify the server is reachable:
 
 ```bash
-curl http://localhost:4891/v1/models
+curl http://[SERVER_ADDRESS]:[SERVER_PORT]/v1/models
+```
+
+For Ollama:
+
+```bash
+curl http://localhost:11434/api/tags
 ```
 
 ## License
 
 GNU General Public License v3.0. See `LICENSE`.
+
+## Disclaimer
+
+This was mostly vibe coded and I'm treating it as a fun side project / tool that is likely to remain improved and updated by agentic models.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alhisan/gac",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Terminal client for GPT4All running on localhost",
   "license": "GPL-3.0-only",
   "type": "module",

package/src/cli.js

@@ -7,7 +7,7 @@ import process from "process";
 const { terminal: term } = terminalKit;
 
 function printHelp() {
-  term(`gac - GPT4All CLI\n\n`);
+  term(`gac - OpenAI-compatible & Ollama CLI\n\n`);
   term(`Options:\n`);
   term(`  -a                Single prompt mode (alias for ask)\n`);
   term(`  suggest           Suggestion mode\n`);
@@ -16,6 +16,7 @@ function printHelp() {
   term(`  chat              Interactive chat mode\n`);
   term(`  models            List models and set default\n`);
   term(`  config            View or edit configuration\n`);
+  term(`  config tui        Open interactive config editor\n`);
   term(`  --no-render      Disable markdown rendering\n`);
   term(`  --debug-render   Show both rendered and raw output\n`);
   term(
@@ -31,6 +32,7 @@ function printHelp() {
   term(`  gac chat\n`);
   term(`  gac models\n`);
   term(`  gac config\n`);
+  term(`  gac config tui\n`);
   term(`  gac config get <key>\n`);
   term(`  gac config set <key> <value>\n`);
   term(`  gac --no-render -a "Raw markdown output"\n`);
@@ -139,6 +141,225 @@ async function inputLine(label) {
   });
 }
 
+function formatConfigValue(value) {
+  if (typeof value === "string") {
+    if (!value) return "(empty)";
+    if (value.length > 48) return `${value.slice(0, 45)}...`;
+    return value;
+  }
+  return JSON.stringify(value);
+}
+
+function maskApiKey(apiKey) {
+  if (!apiKey) return "(empty)";
+  if (apiKey.length <= 6) return "***";
+  return `${apiKey.slice(0, 3)}...${apiKey.slice(-3)}`;
+}
+
+async function promptConfigValue(label, currentValue) {
+  term(`${label} [${formatConfigValue(currentValue)}]: `);
+  return new Promise((resolve) => {
+    term.inputField({ cancelable: true, default: String(currentValue ?? "") }, (error, input) => {
+      term("\n");
+      if (error || input === undefined || input === null) {
+        resolve(null);
+        return;
+      }
+      resolve(input.trim());
+    });
+  });
+}
+
+async function selectConfigProvider(config) {
+  const options = [
+    "OpenAI-compatible (includes GPT4All)",
+    "Ollama",
+  ];
+  const currentIndex = config.provider === "ollama" ? 1 : 0;
+  term("\nSelect provider:\n");
+  return new Promise((resolve) => {
+    term.singleColumnMenu(
+      options,
+      { cancelable: true, selectedIndex: currentIndex },
+      (error, response) => {
+        term("\n");
+        if (error || !response || response.canceled) {
+          resolve(null);
+          return;
+        }
+        resolve(response.selectedIndex === 1 ? "ollama" : "openai");
+      }
+    );
+  });
+}
+
+async function runConfigTui(config) {
+  term("Config editor (Esc to exit)\n\n");
+  let updatedConfig = { ...config };
+  term.grabInput({ mouse: "button" });
+  const cleanup = () => {
+    term.grabInput(false);
+    term.removeListener("key", onKey);
+    term.hideCursor(false);
+  };
+  const onKey = (name) => {
+    if (name === "CTRL_C") {
+      cleanup();
+      term("\nCanceled.\n");
+      term.processExit(0);
+    }
+  };
+  term.on("key", onKey);
+  const menuLoop = async () => {
+    const menuItems = [
+      `Provider: ${updatedConfig.provider === "ollama" ? "Ollama" : "OpenAI-compatible"}`,
+      `Base URL (OpenAI): ${formatConfigValue(updatedConfig.baseUrl)}`,
+      `Base URL (Ollama): ${formatConfigValue(updatedConfig.ollamaBaseUrl)}`,
+      `API Key: ${maskApiKey(updatedConfig.apiKey)}`,
+      `Model: ${formatConfigValue(updatedConfig.model)}`,
+      `Temperature: ${formatConfigValue(updatedConfig.temperature)}`,
+      `Max Tokens: ${formatConfigValue(updatedConfig.maxTokens)}`,
+      `Stream: ${formatConfigValue(updatedConfig.stream)}`,
+      `Render Markdown: ${formatConfigValue(updatedConfig.renderMarkdown)}`,
+      `Debug Render: ${formatConfigValue(updatedConfig.debugRender)}`,
+      `Detailed Suggest: ${formatConfigValue(updatedConfig.detailedSuggest)}`,
+      "Save and exit",
+    ];
+
+    return new Promise((resolve) => {
+      term.singleColumnMenu(menuItems, { cancelable: true }, (error, response) => {
+        term("\n");
+        if (error || !response || response.canceled) {
+          resolve(false);
+          return;
+        }
+        resolve(response.selectedIndex);
+      });
+    });
+  };
+
+  while (true) {
+    const selection = await menuLoop();
+    if (selection === false) {
+      cleanup();
+      term("Config editor closed.\n");
+      break;
+    }
+
+    if (selection === 0) {
+      const provider = await selectConfigProvider(updatedConfig);
+      if (provider) {
+        setConfigValue("provider", provider);
+        updatedConfig.provider = provider;
+      }
+      continue;
+    }
+
+    if (selection === 1) {
+      const value = await promptConfigValue("OpenAI base URL", updatedConfig.baseUrl);
+      if (value !== null) {
+        setConfigValue("baseUrl", value);
+        updatedConfig.baseUrl = value;
+      }
+      continue;
+    }
+
+    if (selection === 2) {
+      const value = await promptConfigValue("Ollama base URL", updatedConfig.ollamaBaseUrl);
+      if (value !== null) {
+        setConfigValue("ollamaBaseUrl", value);
+        updatedConfig.ollamaBaseUrl = value;
+      }
+      continue;
+    }
+
+    if (selection === 3) {
+      term("API Key (leave empty to clear)\n");
+      const value = await promptConfigValue("API key", updatedConfig.apiKey);
+      if (value !== null) {
+        setConfigValue("apiKey", value);
+        updatedConfig.apiKey = value;
+      }
+      continue;
+    }
+
+    if (selection === 4) {
+      const value = await promptConfigValue("Model", updatedConfig.model);
+      if (value !== null) {
+        setConfigValue("model", value);
+        updatedConfig.model = value;
+      }
+      continue;
+    }
+
+    if (selection === 5) {
+      const value = await promptConfigValue("Temperature", updatedConfig.temperature);
+      if (value !== null) {
+        setConfigValue("temperature", value);
+        updatedConfig.temperature = value;
+      }
+      continue;
+    }
+
+    if (selection === 6) {
+      const value = await promptConfigValue("Max Tokens", updatedConfig.maxTokens);
+      if (value !== null) {
+        setConfigValue("maxTokens", value);
+        updatedConfig.maxTokens = value;
+      }
+      continue;
+    }
+
+    if (selection === 7) {
+      const value = await promptConfigValue("Stream (true/false)", updatedConfig.stream);
+      if (value !== null) {
+        setConfigValue("stream", value);
+        updatedConfig.stream = value;
+      }
+      continue;
+    }
+
+    if (selection === 8) {
+      const value = await promptConfigValue(
+        "Render Markdown (true/false)",
+        updatedConfig.renderMarkdown
+      );
+      if (value !== null) {
+        setConfigValue("renderMarkdown", value);
+        updatedConfig.renderMarkdown = value;
+      }
+      continue;
+    }
+
+    if (selection === 9) {
+      const value = await promptConfigValue("Debug Render (true/false)", updatedConfig.debugRender);
+      if (value !== null) {
+        setConfigValue("debugRender", value);
+        updatedConfig.debugRender = value;
+      }
+      continue;
+    }
+
+    if (selection === 10) {
+      const value = await promptConfigValue(
+        "Detailed Suggest (true/false)",
+        updatedConfig.detailedSuggest
+      );
+      if (value !== null) {
+        setConfigValue("detailedSuggest", value);
+        updatedConfig.detailedSuggest = value;
+      }
+      continue;
+    }
+
+    if (selection === 11) {
+      cleanup();
+      term("Configuration saved.\n");
+      break;
+    }
+  }
+}
+
 async function runChat(config) {
   term('Interactive chat. Type "exit" to quit.\n\n');
   const messages = [];
@@ -187,20 +408,20 @@ async function runChat(config) {
 async function runModels(config) {
   let models;
   try {
-    models = await listModels(config.baseUrl);
+    models = await listModels(config);
   } catch (err) {
     term(`Error: ${err.message}\n`);
     term.processExit(1);
   }
 
   if (!models.length) {
-    term("No models found from GPT4All server.\n");
+    term("No models found from the configured provider.\n");
     term.processExit(0);
   }
 
   term("Available models:\n");
-  // Append 'Use default gpt4all model' option at the top
-  models.unshift("Use default gpt4all setting");
+  // Append option to keep current default at the top
+  models.unshift("Keep current default");
   models.forEach((model) => term(`- ${model}\n`));
   term("\nSelect a default model (use arrows + Enter, Esc to cancel):\n");
 
@@ -231,9 +452,10 @@ async function runModels(config) {
           term.processExit(0);
         }
         let selected = models[response.selectedIndex];
-        // if user selected the default model option, set to 'gpt4all'
-        if (selected === "Use default gpt4all setting") {
-          selected = "gpt4all";
+        if (selected === "Keep current default") {
+          cleanup();
+          term(`Default model unchanged ("${config.model}").\n`);
+          term.processExit(0);
         }
         setConfigValue("model", selected);
         config.model = selected;
@@ -277,6 +499,10 @@ export async function runCli(argv) {
   }
 
   if (args[0] === "config") {
+    if (args[1] === "tui") {
+      await runConfigTui(config);
+      return;
+    }
     if (args[1] === "get" && args[2]) {
       const key = args[2];
       term(`${config[key]}\n`);

package/src/config.js

@@ -3,7 +3,10 @@ import path from "path";
 import os from "os";
 
 const DEFAULT_CONFIG = {
+  provider: "openai",
   baseUrl: "http://localhost:4891",
+  ollamaBaseUrl: "http://localhost:11434",
+  apiKey: "",
   model: "gpt4all",
   temperature: 0.7,
   maxTokens: 512,

package/src/gpt4all.js

@@ -1,37 +1,66 @@
-import terminalKit from 'terminal-kit';
-import { createMarkdownRenderer } from './markdown.js';
+import terminalKit from "terminal-kit";
+import { createMarkdownRenderer } from "./markdown.js";
 
 const { terminal: term } = terminalKit;
 
 function getContentDelta(chunk) {
-  if (!chunk || !chunk.choices || !chunk.choices[0]) return '';
+  if (!chunk || !chunk.choices || !chunk.choices[0]) return "";
   const choice = chunk.choices[0];
   if (choice.delta && choice.delta.content) return choice.delta.content;
   if (choice.message && choice.message.content) return choice.message.content;
   if (choice.text) return choice.text;
-  return '';
+  return "";
+}
+
+function getOllamaContentDelta(chunk) {
+  if (!chunk) return "";
+  if (chunk.message && chunk.message.content) return chunk.message.content;
+  if (chunk.response) return chunk.response;
+  return "";
+}
+
+function normalizeOpenAiBaseUrl(baseUrl) {
+  const trimmed = baseUrl.replace(/\/$/, "");
+  if (trimmed.endsWith("/v1")) return trimmed;
+  return `${trimmed}/v1`;
+}
+
+function normalizeOllamaBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/$/, "");
+}
+
+function getProvider(config) {
+  return config.provider === "ollama" ? "ollama" : "openai";
+}
+
+function buildOpenAiHeaders(apiKey) {
+  const headers = { "Content-Type": "application/json" };
+  if (apiKey) {
+    headers.Authorization = `Bearer ${apiKey}`;
+  }
+  return headers;
 }
 
 async function parseStream(response, onToken, renderer) {
   const reader = response.body.getReader();
-  const decoder = new TextDecoder('utf-8');
-  let buffer = '';
-  let fullText = '';
-  let lineBuffer = '';
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  let fullText = "";
+  let lineBuffer = "";
 
   while (true) {
     const { value, done } = await reader.read();
     if (done) break;
     buffer += decoder.decode(value, { stream: true });
 
-    const lines = buffer.split('\n');
-    buffer = lines.pop() || '';
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
 
     for (const line of lines) {
       const trimmed = line.trim();
-      if (!trimmed || !trimmed.startsWith('data:')) continue;
-      const payload = trimmed.replace(/^data:\s*/, '');
-      if (payload === '[DONE]') {
+      if (!trimmed || !trimmed.startsWith("data:")) continue;
+      const payload = trimmed.replace(/^data:\s*/, "");
+      if (payload === "[DONE]") {
         return fullText;
       }
 
@@ -44,8 +73,8 @@ async function parseStream(response, onToken, renderer) {
             onToken(delta);
           } else {
             lineBuffer += delta;
-            const lines = lineBuffer.split('\n');
-            lineBuffer = lines.pop() || '';
+            const lines = lineBuffer.split("\n");
+            lineBuffer = lines.pop() || "";
             for (const line of lines) {
               onToken(`${renderer.renderLine(line)}\n`);
             }
@@ -64,76 +93,135 @@ async function parseStream(response, onToken, renderer) {
   return fullText;
 }
 
-function normalizeBaseUrl(baseUrl) {
-  const trimmed = baseUrl.replace(/\/$/, '');
-  if (trimmed.endsWith('/v1')) return trimmed;
-  return `${trimmed}/v1`;
+async function parseOllamaStream(response, onToken, renderer) {
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  let fullText = "";
+  let lineBuffer = "";
+
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const json = JSON.parse(trimmed);
+        if (json.done) {
+          return fullText;
+        }
+        const delta = getOllamaContentDelta(json);
+        if (delta) {
+          fullText += delta;
+          if (!renderer) {
+            onToken(delta);
+          } else {
+            lineBuffer += delta;
+            const lines = lineBuffer.split("\n");
+            lineBuffer = lines.pop() || "";
+            for (const line of lines) {
+              onToken(`${renderer.renderLine(line)}\n`);
+            }
+          }
+        }
+      } catch (err) {
+        // Ignore non-JSON payloads
+      }
+    }
+  }
+
+  if (renderer && lineBuffer) {
+    onToken(renderer.renderLine(lineBuffer));
+  }
+
+  return fullText;
 }
 
-async function fetchJson(url, payload) {
+async function fetchJson(url, payload, errorLabel) {
   try {
     const response = await fetch(url, payload);
     if (!response.ok) {
       const text = await response.text();
-      throw new Error(`GPT4All error ${response.status}: ${text}`);
+      throw new Error(`${errorLabel} error ${response.status}: ${text}`);
     }
     return await response.json();
   } catch (err) {
-    if (err.message && err.message.startsWith('GPT4All error')) {
+    if (err.message && err.message.startsWith(`${errorLabel} error`)) {
       throw err;
     }
-    throw new Error(`Failed to connect to ${url}. Is GPT4All running and reachable? (${err.message})`);
+    throw new Error(`Failed to connect to ${url}. (${err.message})`);
   }
 }
 
-export async function listModels(baseUrl) {
-  const url = `${normalizeBaseUrl(baseUrl)}/models`;
-  const json = await fetchJson(url, { method: 'GET' });
-  if (!json || !Array.isArray(json.data)) return [];
-  return json.data.map((model) => model.id).filter(Boolean);
-}
-
-async function fetchCompletion(url, payload) {
+async function fetchCompletion(url, payload, headers, errorLabel) {
   try {
     return await fetch(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(payload)
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
     });
   } catch (err) {
-    throw new Error(`Failed to connect to ${url}. Is GPT4All running and reachable? (${err.message})`);
+    throw new Error(`Failed to connect to ${url}. (${err.message})`);
   }
 }
 
-async function handleError(response) {
+async function handleError(response, errorLabel) {
   const text = await response.text();
-  throw new Error(`GPT4All error ${response.status}: ${text}`);
+  throw new Error(`${errorLabel} error ${response.status}: ${text}`);
+}
+
+export async function listModels(config) {
+  const provider = getProvider(config);
+  if (provider === "ollama") {
+    const baseUrl = normalizeOllamaBaseUrl(config.ollamaBaseUrl);
+    const url = `${baseUrl}/api/tags`;
+    const json = await fetchJson(url, { method: "GET" }, "Ollama");
+    if (!json || !Array.isArray(json.models)) return [];
+    return json.models.map((model) => model.name).filter(Boolean);
+  }
+
+  const url = `${normalizeOpenAiBaseUrl(config.baseUrl)}/models`;
+  const headers = buildOpenAiHeaders(config.apiKey);
+  const json = await fetchJson(url, { method: "GET", headers }, "OpenAI");
+  if (!json || !Array.isArray(json.data)) return [];
+  return json.data.map((model) => model.id).filter(Boolean);
 }
 
-export async function chatCompletion(
-  { baseUrl, model, temperature, maxTokens, stream, renderMarkdown, markdownStyles },
-  messages
-) {
-  const url = `${normalizeBaseUrl(baseUrl)}/chat/completions`;
+async function openAiChatCompletion(config, messages) {
+  const url = `${normalizeOpenAiBaseUrl(config.baseUrl)}/chat/completions`;
   const payload = {
-    model,
+    model: config.model,
     messages,
-    temperature,
-    max_tokens: maxTokens,
-    stream: Boolean(stream)
+    temperature: config.temperature,
+    max_tokens: config.maxTokens,
+    stream: Boolean(config.stream),
   };
 
-  let response = await fetchCompletion(url, payload);
+  const headers = buildOpenAiHeaders(config.apiKey);
+  let response = await fetchCompletion(url, payload, headers, "OpenAI");
 
-  const renderer = renderMarkdown ? createMarkdownRenderer(markdownStyles) : null;
+  const renderer = config.renderMarkdown
+    ? createMarkdownRenderer(config.markdownStyles)
+    : null;
 
   if (!response.ok) {
     const text = await response.text();
-    if (stream && response.status === 400 && text.includes('stream') && text.includes('not supported')) {
+    if (
+      config.stream &&
+      response.status === 400 &&
+      text.includes("stream") &&
+      text.includes("not supported")
+    ) {
       const retryPayload = { ...payload, stream: false };
-      response = await fetchCompletion(url, retryPayload);
+      response = await fetchCompletion(url, retryPayload, headers, "OpenAI");
       if (!response.ok) {
-        await handleError(response);
+        await handleError(response, "OpenAI");
       }
       const json = await response.json();
       const content = getContentDelta(json);
@@ -145,19 +233,62 @@ export async function chatCompletion(
       return content;
     }
 
-    throw new Error(`GPT4All error ${response.status}: ${text}`);
+    throw new Error(`OpenAI error ${response.status}: ${text}`);
   }
 
-  if (stream) {
-    const contentType = response.headers.get('content-type') || '';
-    if (contentType.includes('text/event-stream')) {
+  if (config.stream) {
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("text/event-stream")) {
       return parseStream(response, (chunk) => term(chunk), renderer);
     }
   }
 
   const json = await response.json();
   const content = getContentDelta(json);
-  if (stream) {
+  if (config.stream) {
+    if (renderer) {
+      term(renderer.renderText(content));
+    } else {
+      term(content);
+    }
+  }
+  return content;
+}
+
+async function ollamaChatCompletion(config, messages) {
+  const baseUrl = normalizeOllamaBaseUrl(config.ollamaBaseUrl);
+  const url = `${baseUrl}/api/chat`;
+  const payload = {
+    model: config.model,
+    messages,
+    stream: Boolean(config.stream),
+    options: {
+      temperature: config.temperature,
+      num_predict: config.maxTokens,
+    },
+  };
+
+  const renderer = config.renderMarkdown
+    ? createMarkdownRenderer(config.markdownStyles)
+    : null;
+  const response = await fetchCompletion(
+    url,
+    payload,
+    { "Content-Type": "application/json" },
+    "Ollama"
+  );
+
+  if (!response.ok) {
+    await handleError(response, "Ollama");
+  }
+
+  if (config.stream) {
+    return parseOllamaStream(response, (chunk) => term(chunk), renderer);
+  }
+
+  const json = await response.json();
+  const content = getOllamaContentDelta(json);
+  if (config.stream) {
     if (renderer) {
       term(renderer.renderText(content));
     } else {
@@ -166,3 +297,11 @@ export async function chatCompletion(
   }
   return content;
 }
+
+export async function chatCompletion(config, messages) {
+  const provider = getProvider(config);
+  if (provider === "ollama") {
+    return ollamaChatCompletion(config, messages);
+  }
+  return openAiChatCompletion(config, messages);
+}