feat(utils): save and load config

Store Ollama Host & Default Model in a User Config File

Introduce a `~/.code-ollama/config.json` file that persists `host` and `model`, with env-var overrides and write-back when the user picks a model via `/model`.

Approach:

- **Config location:** `~/.code-ollama/config.json`
- **Schema:** `{ "host": string, "model": string }` — both optional; missing keys fall back to hardcoded defaults.
- **Priority order (read):** env var → config file → hardcoded default.
- **Config module:** new `src/utils/config.ts` with two exports:
  - `loadConfig()` — reads and parses the file synchronously at startup.
  - `saveConfig(patch)` — merges a partial update and writes the file (creates dir if needed).
- **Barrel update:** export the new module through `src/utils/index.ts`.
- **`ollama.ts` change:** replace the two `process.env` lines with values from `loadConfig()`.
- **`App.tsx` change:** also read initial model from `loadConfig()`; call `saveConfig({ model })` inside `handleSelect` after a model is picked.
- **Tests:** `src/utils/config.test.ts` covering load (file present / missing), fallback, env-var override, and save/merge.

Files changed:

| File | Action |
| --- | --- |
| `src/utils/config.ts` | **Create** — `loadConfig` + `saveConfig` |
| `src/utils/config.test.ts` | **Create** — unit tests |
| `src/utils/index.ts` | **Edit** — add `export * as config` |
| `src/utils/ollama.ts` | **Edit** — consume `loadConfig()` values |
| `src/components/App.tsx` | **Edit** — read initial model from config; write back on select |

Author: remarkablemark

src/components/App.test.tsx

@@ -3,6 +3,16 @@ import { render } from 'ink-testing-library';
 
 import { tick } from '../utils/test';
 
+vi.mock('../utils', () => ({
+  config: {
+    loadConfig: vi.fn(() => ({
+      host: 'http://localhost:11434',
+      model: 'gemma4',
+    })),
+    saveConfig: vi.fn(),
+  },
+}));
+
 const capturedCallbacks = vi.hoisted(() => ({
   onCommand: null as ((command: string) => void) | null,
   onSelect: null as ((model: string) => void) | null,

src/components/App.tsx

@@ -1,13 +1,12 @@
 import { Box, Text } from 'ink';
 import { useCallback, useState } from 'react';
 
+import { config } from '../utils';
 import { Chat } from './Chat';
 import { ModelPicker } from './ModelPicker';
 
-const DEFAULT_MODEL = process.env.OLLAMA_MODEL ?? 'gemma4';
-
 export function App() {
-  const [model, setModel] = useState(DEFAULT_MODEL);
+  const [model, setModel] = useState(() => config.loadConfig().model);
   const [picking, setPicking] = useState(false);
 
   const handleCommand = useCallback((command: string) => {
@@ -18,6 +17,7 @@ export function App() {
 
   const handleSelect = useCallback((selected: string) => {
     setModel(selected);
+    config.saveConfig({ model: selected });
     setPicking(false);
   }, []);
 

src/utils/config.test.ts

@@ -0,0 +1,107 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const CONFIG_DIR = join(homedir(), '.code-ollama');
+const CONFIG_PATH = join(CONFIG_DIR, 'config.json');
+
+function writeConfig(data: object) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(data), 'utf8');
+}
+
+function removeConfig() {
+  if (existsSync(CONFIG_PATH)) {
+    rmSync(CONFIG_PATH);
+  }
+}
+
+describe('config', () => {
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    delete process.env.OLLAMA_HOST;
+    delete process.env.OLLAMA_MODEL;
+  });
+
+  afterEach(() => {
+    process.env.OLLAMA_HOST = originalEnv.OLLAMA_HOST;
+    process.env.OLLAMA_MODEL = originalEnv.OLLAMA_MODEL;
+    removeConfig();
+  });
+
+  describe('loadConfig', () => {
+    it('returns hardcoded defaults when no file and no env vars', async () => {
+      removeConfig();
+      const { loadConfig } = await import('./config');
+      const cfg = loadConfig();
+      expect(cfg.host).toBe('http://localhost:11434');
+      expect(cfg.model).toBe('gemma4');
+    });
+
+    it('reads host and model from config file', async () => {
+      writeConfig({ host: 'http://remote:11434', model: 'llama3' });
+      const { loadConfig } = await import('./config');
+      const cfg = loadConfig();
+      expect(cfg.host).toBe('http://remote:11434');
+      expect(cfg.model).toBe('llama3');
+    });
+
+    it('env vars override config file values', async () => {
+      writeConfig({ host: 'http://remote:11434', model: 'llama3' });
+      process.env.OLLAMA_HOST = 'http://env-host:11434';
+      process.env.OLLAMA_MODEL = 'codellama';
+      const { loadConfig } = await import('./config');
+      const cfg = loadConfig();
+      expect(cfg.host).toBe('http://env-host:11434');
+      expect(cfg.model).toBe('codellama');
+    });
+
+    it('returns defaults for missing keys in config file', async () => {
+      writeConfig({ model: 'llama3' });
+      const { loadConfig } = await import('./config');
+      const cfg = loadConfig();
+      expect(cfg.host).toBe('http://localhost:11434');
+      expect(cfg.model).toBe('llama3');
+    });
+
+    it('returns defaults when config file is malformed JSON', async () => {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+      writeFileSync(CONFIG_PATH, 'not json', 'utf8');
+      const { loadConfig } = await import('./config');
+      const cfg = loadConfig();
+      expect(cfg.host).toBe('http://localhost:11434');
+      expect(cfg.model).toBe('gemma4');
+    });
+  });
+
+  describe('saveConfig', () => {
+    it('creates the config file with given values', async () => {
+      removeConfig();
+      const { saveConfig } = await import('./config');
+      saveConfig({ model: 'mistral' });
+      const saved = JSON.parse(readFileSync(CONFIG_PATH, 'utf8')) as {
+        model: string;
+      };
+      expect(saved.model).toBe('mistral');
+    });
+
+    it('merges patch into existing config', async () => {
+      writeConfig({ host: 'http://remote:11434', model: 'llama3' });
+      const { saveConfig } = await import('./config');
+      saveConfig({ model: 'mistral' });
+      const saved = JSON.parse(readFileSync(CONFIG_PATH, 'utf8')) as {
+        host: string;
+        model: string;
+      };
+      expect(saved.host).toBe('http://remote:11434');
+      expect(saved.model).toBe('mistral');
+    });
+  });
+});

src/utils/config.ts

@@ -0,0 +1,40 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const CONFIG_DIR = join(homedir(), '.code-ollama');
+const CONFIG_PATH = join(CONFIG_DIR, 'config.json');
+
+const DEFAULTS = {
+  host: 'http://localhost:11434',
+  model: 'gemma4',
+} as const;
+
+export interface Config {
+  host: string;
+  model: string;
+}
+
+function readFile(): Partial<Config> {
+  if (!existsSync(CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, 'utf8')) as Partial<Config>;
+  } catch {
+    return {};
+  }
+}
+
+export function loadConfig(): Config {
+  const file = readFile();
+  return {
+    host: process.env.OLLAMA_HOST ?? file.host ?? DEFAULTS.host,
+    model: process.env.OLLAMA_MODEL ?? file.model ?? DEFAULTS.model,
+  };
+}
+
+export function saveConfig(patch: Partial<Config>): void {
+  const current = readFile();
+  const updated = { ...current, ...patch };
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(updated, null, 2) + '\n', 'utf8');
+}

src/utils/index.ts

@@ -1,2 +1,3 @@
+export * as config from './config';
 export * as ollama from './ollama';
 export * as screen from './screen';

src/utils/ollama.ts

@@ -1,11 +1,11 @@
 import { Ollama } from 'ollama';
 
 import type { Role } from '../constants';
+import { loadConfig } from './config';
 
-const OLLAMA_HOST = process.env.OLLAMA_HOST ?? 'http://localhost:11434';
-const DEFAULT_MODEL = process.env.OLLAMA_MODEL ?? 'gemma4';
+const { host, model: DEFAULT_MODEL } = loadConfig();
 
-const client = new Ollama({ host: OLLAMA_HOST });
+const client = new Ollama({ host });
 
 export interface Message {
   role: Role;
@@ -30,6 +30,6 @@ export async function* streamChat(
 }
 
 export async function listModels(): Promise<string[]> {
-  const response = await client.list();
-  return response.models.map(({ name }) => name);
+  const { models } = await client.list();
+  return models.map(({ name }) => name);
 }