@nicknisi/pi-model-switch 0.2.0 → 0.3.0

package/README.md

@@ -34,6 +34,18 @@ These extension-owned action IDs are ignored by Pi's built-in keybinding manager
 
 ## Configure models
 
+### Add models from Pi
+
+Run `/model-switch add` to search Pi's available model catalog, pick a model, then choose an existing section to save it in. Run `/model-switch add-current` to save the model you're already using without opening the catalog picker. Both subcommands have argument completion.
+
+If the config file is missing, either command asks you to name the first section and creates the file. With an existing config, the section picker includes empty sections too. Add more sections by editing the config below.
+
+Adding a model does not switch the active model. Duplicate references in the chosen section are skipped, but the same model can belong to multiple sections. Escape cancels without writing. Saves preserve the legacy flat format, other sections, and extra config fields. Invalid configs produce a warning and are not overwritten.
+
+The catalog picker requires Pi's terminal UI. `add-current` also works with RPC clients that support Pi's selection and input dialogs. Neither command registers new providers or model definitions. The model must already be known to Pi.
+
+### Edit the config file
+
 Copy the example config:
 
 ```bash
@@ -125,7 +137,7 @@ The config may be missing, empty, malformed, or contain only missing/unauthentic
 - The picker uses a custom search + list component with `ctx.ui.custom()`; native `/model` and Ctrl+L remain available for the full catalog.
 - Terminal support for multi-modifier keys varies; configure simpler non-conflicting keys or use a terminal with the Kitty keyboard protocol when modified keys are not distinguishable.
 - Availability is checked on each interaction, which may resolve provider credentials before switching.
-- Duplicate references within a section are preserved as written; avoid them unless repeated cycle positions are intentional.
+- Duplicate references within a section are preserved as written; avoid them unless repeated cycle positions are intentional. The add commands never insert another copy of an existing reference.
 
 ## Development
 

package/config.ts

@@ -1,5 +1,16 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import { dirname, join } from 'node:path';
 import { getAgentDir } from '@earendil-works/pi-coding-agent';
 
 export interface ModelSwitchSection {
@@ -91,14 +102,21 @@ export function loadModelSwitchConfig(path = modelCycleConfigPath()): ConfigLoad
     return { ok: false, error: `Invalid model-switch config at ${path}: ${message}` };
   }
 
-  if (!value || typeof value !== 'object') {
+  return parseModelSwitchConfig(value, path);
+}
+
+function parseModelSwitchConfig(value: unknown, path: string): ConfigLoadResult {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
     return { ok: false, error: `Invalid model-switch config at ${path}: expected an object` };
   }
 
   const obj = value as Record<string, unknown>;
 
   // Prefer "sections" if present; fall back to legacy "models" as a single section.
-  if ('sections' in obj && obj.sections && typeof obj.sections === 'object') {
+  if ('sections' in obj) {
+    if (!obj.sections || typeof obj.sections !== 'object' || Array.isArray(obj.sections)) {
+      return { ok: false, error: `Invalid model-switch config at ${path}: expected "sections" to be an object` };
+    }
     const sectionsRaw = obj.sections as Record<string, unknown>;
     const sections: ModelSwitchSection[] = [];
 
@@ -129,3 +147,44 @@ export function loadModelSwitchConfig(path = modelCycleConfigPath()): ConfigLoad
     error: `Invalid model-switch config at ${path}: expected { "sections": { ... } } or { "models": [...] }`,
   };
 }
+
+export function addModelToSection(
+  reference: string,
+  sectionName: string,
+  path = modelCycleConfigPath(),
+): { ok: true; added: boolean } | { ok: false; error: string } {
+  try {
+    // Read again after the dialogs so edits made while they were open are retained.
+    const existing = lstatSync(path, { throwIfNoEntry: false });
+    const target = existing ? realpathSync(path) : path;
+    const value = existing ? JSON.parse(readFileSync(target, 'utf8')) : { sections: { [sectionName]: [] } };
+    const loaded = parseModelSwitchConfig(value, path);
+    if (!loaded.ok) return loaded;
+
+    const section = loaded.config.sections.find((item) => item.name === sectionName);
+    if (!section) {
+      return { ok: false, error: `Section "${sectionName}" no longer exists in ${path}` };
+    }
+    if (section.models.includes(reference)) return { ok: true, added: false };
+
+    const models: string[] = 'sections' in value ? value.sections[sectionName] : value.models;
+    models.push(reference);
+
+    // Replace the file atomically, following config symlinks rather than replacing them.
+    mkdirSync(dirname(target), { recursive: true });
+    const temporaryPath = `${target}.${randomUUID()}.tmp`;
+    try {
+      writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, {
+        flag: 'wx',
+        mode: existing ? statSync(target).mode & 0o777 : 0o600,
+      });
+      renameSync(temporaryPath, target);
+    } finally {
+      rmSync(temporaryPath, { force: true });
+    }
+    return { ok: true, added: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, error: `Could not update model-switch config at ${path}: ${message}` };
+  }
+}

package/dist/config.d.ts

@@ -22,3 +22,10 @@ export declare function modelCycleConfigPath(): string;
 export declare function modelCycleKeybindingsPath(): string;
 export declare function loadModelSwitchKeybindings(path?: string): ModelSwitchKeybindings;
 export declare function loadModelSwitchConfig(path?: string): ConfigLoadResult;
+export declare function addModelToSection(reference: string, sectionName: string, path?: string): {
+    ok: true;
+    added: boolean;
+} | {
+    ok: false;
+    error: string;
+};

package/dist/config.js

@@ -1,5 +1,6 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { getAgentDir } from '@earendil-works/pi-coding-agent';
 export const DEFAULT_MODEL_CYCLE_KEYBINDINGS = {
     forward: 'ctrl+shift+m',
@@ -62,12 +63,18 @@ export function loadModelSwitchConfig(path = modelCycleConfigPath()) {
         const message = error instanceof Error ? error.message : String(error);
         return { ok: false, error: `Invalid model-switch config at ${path}: ${message}` };
     }
-    if (!value || typeof value !== 'object') {
+    return parseModelSwitchConfig(value, path);
+}
+function parseModelSwitchConfig(value, path) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
         return { ok: false, error: `Invalid model-switch config at ${path}: expected an object` };
     }
     const obj = value;
     // Prefer "sections" if present; fall back to legacy "models" as a single section.
-    if ('sections' in obj && obj.sections && typeof obj.sections === 'object') {
+    if ('sections' in obj) {
+        if (!obj.sections || typeof obj.sections !== 'object' || Array.isArray(obj.sections)) {
+            return { ok: false, error: `Invalid model-switch config at ${path}: expected "sections" to be an object` };
+        }
         const sectionsRaw = obj.sections;
         const sections = [];
         for (const [name, modelsRaw] of Object.entries(sectionsRaw)) {
@@ -95,3 +102,40 @@ export function loadModelSwitchConfig(path = modelCycleConfigPath()) {
         error: `Invalid model-switch config at ${path}: expected { "sections": { ... } } or { "models": [...] }`,
     };
 }
+export function addModelToSection(reference, sectionName, path = modelCycleConfigPath()) {
+    try {
+        // Read again after the dialogs so edits made while they were open are retained.
+        const existing = lstatSync(path, { throwIfNoEntry: false });
+        const target = existing ? realpathSync(path) : path;
+        const value = existing ? JSON.parse(readFileSync(target, 'utf8')) : { sections: { [sectionName]: [] } };
+        const loaded = parseModelSwitchConfig(value, path);
+        if (!loaded.ok)
+            return loaded;
+        const section = loaded.config.sections.find((item) => item.name === sectionName);
+        if (!section) {
+            return { ok: false, error: `Section "${sectionName}" no longer exists in ${path}` };
+        }
+        if (section.models.includes(reference))
+            return { ok: true, added: false };
+        const models = 'sections' in value ? value.sections[sectionName] : value.models;
+        models.push(reference);
+        // Replace the file atomically, following config symlinks rather than replacing them.
+        mkdirSync(dirname(target), { recursive: true });
+        const temporaryPath = `${target}.${randomUUID()}.tmp`;
+        try {
+            writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, {
+                flag: 'wx',
+                mode: existing ? statSync(target).mode & 0o777 : 0o600,
+            });
+            renameSync(temporaryPath, target);
+        }
+        finally {
+            rmSync(temporaryPath, { force: true });
+        }
+        return { ok: true, added: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { ok: false, error: `Could not update model-switch config at ${path}: ${message}` };
+    }
+}

package/dist/config.test.js

@@ -1,8 +1,10 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import * as fs from 'node:fs';
+import { lstatSync, mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { DEFAULT_MODEL_CYCLE_KEYBINDINGS, loadModelSwitchConfig, loadModelSwitchKeybindings } from './config.js';
+import { addModelToSection, DEFAULT_MODEL_CYCLE_KEYBINDINGS, loadModelSwitchConfig, loadModelSwitchKeybindings, } from './config.js';
+vi.mock('node:fs', async (importOriginal) => ({ ...(await importOriginal()) }));
 const tempDirs = [];
 function tempConfig(content) {
     const dir = mkdtempSync(join(tmpdir(), 'pi-model-switch-'));
@@ -13,6 +15,7 @@ function tempConfig(content) {
     return path;
 }
 afterEach(() => {
+    vi.restoreAllMocks();
     for (const dir of tempDirs.splice(0)) {
         rmSync(dir, { recursive: true, force: true });
     }
@@ -99,6 +102,8 @@ describe('loadModelSwitchConfig', () => {
         ['missing sections and models', '{}'],
         ['non-object sections', JSON.stringify({ sections: 'nope' })],
         ['empty sections object', JSON.stringify({ sections: {} })],
+        ['array sections', JSON.stringify({ sections: [['provider/model']] })],
+        ['invalid sections with legacy models', JSON.stringify({ sections: null, models: ['provider/model'] })],
         ['non-array section models', JSON.stringify({ sections: { work: 'nope' } })],
         ['non-string model in section', JSON.stringify({ sections: { work: [42] } })],
         ['empty model in section', JSON.stringify({ sections: { work: ['  '] } })],
@@ -111,3 +116,96 @@ describe('loadModelSwitchConfig', () => {
             expect(result.error).toContain(path);
     });
 });
+describe('addModelToSection', () => {
+    it('appends only to the selected section and preserves other config fields', () => {
+        const config = {
+            sections: { work: ['provider/old'], personal: ['provider/new'] },
+            models: ['legacy/ignored'],
+            note: 'keep me',
+        };
+        const path = tempConfig(JSON.stringify(config));
+        expect(addModelToSection('provider/new', 'work', path)).toEqual({ ok: true, added: true });
+        expect(JSON.parse(readFileSync(path, 'utf8'))).toEqual({
+            ...config,
+            sections: { work: ['provider/old', 'provider/new'], personal: ['provider/new'] },
+        });
+    });
+    it('does not rewrite a duplicate, including a whitespace-padded reference', () => {
+        const content = '{ "sections": { "work": [" provider/model "] } }';
+        const path = tempConfig(content);
+        expect(addModelToSection('provider/model', 'work', path)).toEqual({ ok: true, added: false });
+        expect(readFileSync(path, 'utf8')).toBe(content);
+    });
+    it('keeps the legacy flat format', () => {
+        const path = tempConfig(JSON.stringify({ models: ['provider/old'], note: 'keep' }));
+        expect(addModelToSection('provider/new', 'models', path)).toEqual({ ok: true, added: true });
+        expect(JSON.parse(readFileSync(path, 'utf8'))).toEqual({
+            models: ['provider/old', 'provider/new'],
+            note: 'keep',
+        });
+    });
+    it('creates missing config directories and preserves slashes in model IDs', () => {
+        const path = join(tempConfig(), 'configs', 'model-switch.json');
+        expect(addModelToSection('fireworks/accounts/fireworks/models/kimi-k3', 'personal', path)).toEqual({
+            ok: true,
+            added: true,
+        });
+        expect(loadModelSwitchConfig(path)).toEqual({
+            ok: true,
+            config: { sections: [{ name: 'personal', models: ['fireworks/accounts/fireworks/models/kimi-k3'] }] },
+        });
+    });
+    it('supports section names that match object prototype properties', () => {
+        const path = tempConfig();
+        expect(addModelToSection('provider/model', '__proto__', path)).toEqual({ ok: true, added: true });
+        expect(loadModelSwitchConfig(path)).toEqual({
+            ok: true,
+            config: { sections: [{ name: '__proto__', models: ['provider/model'] }] },
+        });
+    });
+    it.each(['{ nope', '{"sections":null,"models":[]}', '{"sections":[[]]}', '{"sections":{"work":[42]}}'])('does not overwrite malformed config: %s', (content) => {
+        const path = tempConfig(content);
+        const result = addModelToSection('provider/new', 'work', path);
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error).toContain(path);
+        expect(readFileSync(path, 'utf8')).toBe(content);
+    });
+    it('does not recreate a section removed while the picker was open', () => {
+        const content = '{"sections":{"personal":[]}}';
+        const path = tempConfig(content);
+        expect(addModelToSection('provider/new', 'work', path)).toEqual({
+            ok: false,
+            error: `Section "work" no longer exists in ${path}`,
+        });
+        expect(readFileSync(path, 'utf8')).toBe(content);
+    });
+    it('updates a symlink target without replacing the link', () => {
+        const path = tempConfig('{"sections":{"work":[]}}');
+        const link = `${path}.link`;
+        symlinkSync(path, link);
+        expect(addModelToSection('provider/new', 'work', link)).toEqual({ ok: true, added: true });
+        expect(lstatSync(link).isSymbolicLink()).toBe(true);
+        expect(JSON.parse(readFileSync(path, 'utf8'))).toEqual({ sections: { work: ['provider/new'] } });
+    });
+    it('does not replace a dangling config symlink', () => {
+        const path = tempConfig();
+        const link = `${path}.link`;
+        symlinkSync(path, link);
+        expect(addModelToSection('provider/new', 'work', link).ok).toBe(false);
+        expect(lstatSync(link).isSymbolicLink()).toBe(true);
+    });
+    it('preserves the original config and cleans up when replacing the file fails', () => {
+        const content = '{"sections":{"work":[]}}';
+        const path = tempConfig(content);
+        vi.spyOn(fs, 'renameSync').mockImplementation(() => {
+            throw new Error('disk error');
+        });
+        expect(addModelToSection('provider/new', 'work', path)).toEqual({
+            ok: false,
+            error: `Could not update model-switch config at ${path}: disk error`,
+        });
+        expect(readFileSync(path, 'utf8')).toBe(content);
+        expect(readdirSync(join(path, '..'))).toEqual(['model-switch.json']);
+    });
+});

package/dist/index.js

@@ -1,4 +1,4 @@
-import { loadModelSwitchConfig, loadModelSwitchKeybindings, modelCycleConfigPath } from './config.js';
+import { addModelToSection, loadModelSwitchConfig, loadModelSwitchKeybindings, modelCycleConfigPath, } from './config.js';
 import { findActiveSection, resolveAvailableModels, selectCycleTarget } from './cycle.js';
 import { SectionPicker } from './section-picker.js';
 async function resolveSectionModels(references, ctx) {
@@ -73,6 +73,54 @@ async function showModelPicker(pi, ctx) {
     if (target)
         await switchModel(pi, ctx, target);
 }
+async function addConfiguredModel(ctx, useCurrent) {
+    if (!ctx.hasUI)
+        return;
+    if (!useCurrent && ctx.mode !== 'tui') {
+        ctx.ui.notify('/model-switch add requires the terminal UI', 'warning');
+        return;
+    }
+    const loaded = loadModelSwitchConfig();
+    if (!loaded.ok) {
+        ctx.ui.notify(loaded.error, 'warning');
+        return;
+    }
+    let target = ctx.model;
+    if (!useCurrent) {
+        const available = ctx.modelRegistry.getAvailable();
+        if (available.length === 0) {
+            ctx.ui.notify('No available models to add. Configure a provider with /login first.', 'warning');
+            return;
+        }
+        const selected = await ctx.ui.custom((_tui, theme, _keybindings, done) => {
+            return new SectionPicker([{ name: 'Add a model', items: buildSectionItems(available, ctx.model) }], theme, done);
+        });
+        if (!selected)
+            return;
+        target = available.find((model) => `${model.provider}/${model.id}` === selected);
+    }
+    if (!target) {
+        ctx.ui.notify('No model selected to add', 'warning');
+        return;
+    }
+    const reference = `${target.provider}/${target.id}`;
+    const sections = loaded.config.sections.map((section) => section.name);
+    const sectionName = sections.length > 0
+        ? await ctx.ui.select(`Add ${reference} to section`, sections)
+        : (await ctx.ui.input('Name your first model-switch section', 'models'))?.trim();
+    if (sectionName === undefined)
+        return;
+    if (sections.length === 0 && !sectionName) {
+        ctx.ui.notify('Section name must not be empty', 'warning');
+        return;
+    }
+    const result = addModelToSection(reference, sectionName);
+    if (!result.ok) {
+        ctx.ui.notify(result.error, 'warning');
+        return;
+    }
+    ctx.ui.notify(result.added ? `Added ${reference} to "${sectionName}"` : `${reference} is already in "${sectionName}"`, 'info');
+}
 export default function modelCycle(pi) {
     const keybindings = loadModelSwitchKeybindings();
     pi.registerShortcut(keybindings.forward, {
@@ -88,7 +136,25 @@ export default function modelCycle(pi) {
         handler: async (ctx) => showModelPicker(pi, ctx),
     });
     pi.registerCommand('model-switch', {
-        description: 'Select from configured models',
-        handler: async (_args, ctx) => showModelPicker(pi, ctx),
+        description: 'Select configured models, add a model, or add-current',
+        getArgumentCompletions: (prefix) => {
+            const items = [
+                { value: 'add', label: 'add', description: 'Pick an available model to save' },
+                { value: 'add-current', label: 'add-current', description: 'Save the current model' },
+            ].filter((item) => item.value.startsWith(prefix));
+            return items.length > 0 ? items : null;
+        },
+        handler: async (args, ctx) => {
+            switch (args.trim()) {
+                case '':
+                    return showModelPicker(pi, ctx);
+                case 'add':
+                    return addConfiguredModel(ctx, false);
+                case 'add-current':
+                    return addConfiguredModel(ctx, true);
+                default:
+                    ctx.ui.notify('Usage: /model-switch [add | add-current]', 'warning');
+            }
+        },
     });
 }

package/dist/index.test.js

@@ -1,7 +1,9 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { loadModelSwitchConfig, modelCycleConfigPath } from './config.js';
+import { SectionPicker } from './section-picker.js';
 import modelCycle from './index.js';
 const tempDirs = [];
 const originalAgentDir = process.env.PI_CODING_AGENT_DIR;
@@ -34,6 +36,8 @@ function harness(options = {}) {
     const setModel = vi.fn(async () => options.switchResult ?? true);
     const notify = vi.fn();
     const custom = vi.fn(async () => options.customResult ?? null);
+    const select = vi.fn(async () => options.selectResult);
+    const input = vi.fn(async () => options.inputResult);
     const models = options.models ?? [];
     const byReference = new Map(models.map((item) => [`${item.provider}/${item.id}`, item]));
     const unauthenticated = new Set(options.unauthenticated ?? []);
@@ -49,7 +53,9 @@ function harness(options = {}) {
     const ctx = {
         model: options.current,
         hasUI: options.hasUI ?? true,
+        mode: options.mode ?? 'tui',
         modelRegistry: {
+            getAvailable: () => models.filter((item) => !unauthenticated.has(`${item.provider}/${item.id}`)),
             find(provider, modelId) {
                 return byReference.get(`${provider}/${modelId}`);
             },
@@ -60,10 +66,10 @@ function harness(options = {}) {
                     : { ok: true, apiKey: 'test' };
             },
         },
-        ui: { notify, custom },
+        ui: { notify, custom, select, input },
     };
     modelCycle(pi);
-    return { shortcuts, commands, setModel, notify, custom, ctx };
+    return { shortcuts, commands, setModel, notify, custom, select, input, ctx };
 }
 beforeEach(() => {
     delete process.env.PI_CODING_AGENT_DIR;
@@ -196,4 +202,158 @@ describe('model-switch extension', () => {
         await commands.get('model-switch')('', ctx);
         expect(notify).toHaveBeenCalledWith('Could not switch to provider/target', 'warning');
     });
+    it('picks from available models and appends to the chosen section without switching', async () => {
+        const target = model('provider', 'new');
+        writeConfig({ work: ['provider/old'], personal: [] });
+        const { commands, ctx, custom, select, notify, setModel } = harness({
+            models: [target, model('locked', 'hidden')],
+            unauthenticated: ['locked/hidden'],
+            customResult: 'provider/new',
+            selectResult: 'personal',
+        });
+        await commands.get('model-switch')('add', ctx);
+        expect(select).toHaveBeenCalledWith('Add provider/new to section', ['work', 'personal']);
+        expect(loadModelSwitchConfig()).toEqual({
+            ok: true,
+            config: {
+                sections: [
+                    { name: 'work', models: ['provider/old'] },
+                    { name: 'personal', models: ['provider/new'] },
+                ],
+            },
+        });
+        expect(setModel).not.toHaveBeenCalled();
+        expect(notify).toHaveBeenCalledWith('Added provider/new to "personal"', 'info');
+        // Exercise the actual picker factory, not just the mocked dialog result.
+        const factory = custom.mock.calls[0][0];
+        const done = vi.fn();
+        const picker = (await factory({}, { fg: (_color, text) => text, bold: (text) => text }, {}, done));
+        expect(picker.render(160).join('\n')).not.toContain('locked/hidden');
+        for (const key of 'new')
+            picker.handleInput(key);
+        picker.handleInput('\r');
+        expect(done).toHaveBeenCalledWith('provider/new');
+    });
+    it('saves the current model and skips a duplicate on the next invocation', async () => {
+        writeConfig({ work: [] });
+        const { commands, ctx, custom, notify, setModel } = harness({
+            current: model('provider', 'current'),
+            selectResult: 'work',
+        });
+        await commands.get('model-switch')('add-current', ctx);
+        await commands.get('model-switch')('add-current', ctx);
+        expect(custom).not.toHaveBeenCalled();
+        expect(setModel).not.toHaveBeenCalled();
+        expect(loadModelSwitchConfig()).toEqual({
+            ok: true,
+            config: { sections: [{ name: 'work', models: ['provider/current'] }] },
+        });
+        expect(notify).toHaveBeenLastCalledWith('provider/current is already in "work"', 'info');
+    });
+    it('creates a first section when no config exists', async () => {
+        const { commands, ctx, input } = harness({ current: model('provider', 'current'), inputResult: ' personal ' });
+        await commands.get('model-switch')('add-current', ctx);
+        expect(input).toHaveBeenCalled();
+        expect(loadModelSwitchConfig()).toEqual({
+            ok: true,
+            config: { sections: [{ name: 'personal', models: ['provider/current'] }] },
+        });
+    });
+    it.each(['add', 'add-current'])('does not write when the section selection is cancelled for %s', async (command) => {
+        writeConfig({ work: [] });
+        const content = readFileSync(modelCycleConfigPath(), 'utf8');
+        const target = model('provider', 'new');
+        const { commands, ctx, notify } = harness({ current: target, models: [target], customResult: 'provider/new' });
+        await commands.get('model-switch')(command, ctx);
+        expect(readFileSync(modelCycleConfigPath(), 'utf8')).toBe(content);
+        expect(notify).not.toHaveBeenCalled();
+    });
+    it('does not ask for a section or write when the catalog picker is cancelled', async () => {
+        const { commands, ctx, select, input } = harness({ models: [model('provider', 'new')] });
+        await commands.get('model-switch')('add', ctx);
+        expect(select).not.toHaveBeenCalled();
+        expect(input).not.toHaveBeenCalled();
+        expect(existsSync(modelCycleConfigPath())).toBe(false);
+    });
+    it.each([undefined, '', '   '])('does not create a config without a section name: %s', async (inputResult) => {
+        const { commands, ctx } = harness({ current: model('provider', 'new'), inputResult });
+        await commands.get('model-switch')('add-current', ctx);
+        expect(existsSync(modelCycleConfigPath())).toBe(false);
+    });
+    it.each(['add', 'add-current'])('does not prompt or write without UI for %s', async (command) => {
+        const target = model('provider', 'new');
+        const { commands, ctx, custom, select, input } = harness({
+            hasUI: false,
+            current: target,
+            models: [target],
+            customResult: 'provider/new',
+            inputResult: 'work',
+        });
+        await commands.get('model-switch')(command, ctx);
+        expect(custom).not.toHaveBeenCalled();
+        expect(select).not.toHaveBeenCalled();
+        expect(input).not.toHaveBeenCalled();
+        expect(existsSync(modelCycleConfigPath())).toBe(false);
+    });
+    it('warns when no current model or available catalog model exists', async () => {
+        const { commands, ctx, notify, custom, select } = harness();
+        await commands.get('model-switch')('add-current', ctx);
+        expect(notify).toHaveBeenLastCalledWith('No model selected to add', 'warning');
+        await commands.get('model-switch')('add', ctx);
+        expect(notify).toHaveBeenLastCalledWith(expect.stringContaining('No available models to add'), 'warning');
+        expect(custom).not.toHaveBeenCalled();
+        expect(select).not.toHaveBeenCalled();
+        expect(existsSync(modelCycleConfigPath())).toBe(false);
+    });
+    it('refuses custom catalog UI in RPC mode', async () => {
+        const { commands, ctx, notify, custom } = harness({ mode: 'rpc' });
+        await commands.get('model-switch')('add', ctx);
+        expect(custom).not.toHaveBeenCalled();
+        expect(notify).toHaveBeenCalledWith('/model-switch add requires the terminal UI', 'warning');
+    });
+    it.each(['add', 'add-current'])('refuses malformed config before prompting for %s', async (command) => {
+        writeConfig({ work: [] });
+        writeFileSync(modelCycleConfigPath(), '{ nope');
+        const { commands, ctx, notify, custom, select } = harness({ current: model('provider', 'new') });
+        await commands.get('model-switch')(command, ctx);
+        expect(custom).not.toHaveBeenCalled();
+        expect(select).not.toHaveBeenCalled();
+        expect(notify).toHaveBeenCalledWith(expect.stringContaining(modelCycleConfigPath()), 'warning');
+        expect(readFileSync(modelCycleConfigPath(), 'utf8')).toBe('{ nope');
+    });
+    it('retains edits made while the section prompt was open', async () => {
+        writeConfig({ work: [] });
+        const { commands, ctx, select } = harness({ current: model('provider', 'new') });
+        select.mockImplementation(async () => {
+            writeFileSync(modelCycleConfigPath(), JSON.stringify({ sections: { work: ['provider/edited'], personal: [] } }));
+            return 'work';
+        });
+        await commands.get('model-switch')('add-current', ctx);
+        expect(loadModelSwitchConfig()).toEqual({
+            ok: true,
+            config: {
+                sections: [
+                    { name: 'work', models: ['provider/edited', 'provider/new'] },
+                    { name: 'personal', models: [] },
+                ],
+            },
+        });
+    });
+    it('reports save errors instead of claiming the model was added', async () => {
+        writeConfig({ work: [] });
+        const { commands, ctx, select, notify } = harness({ current: model('provider', 'new') });
+        select.mockImplementation(async () => {
+            writeFileSync(modelCycleConfigPath(), '{ broken during selection');
+            return 'work';
+        });
+        await commands.get('model-switch')('add-current', ctx);
+        expect(notify).toHaveBeenCalledTimes(1);
+        expect(notify).toHaveBeenCalledWith(expect.stringContaining('Could not update model-switch config'), 'warning');
+    });
+    it('shows usage for unknown arguments without opening a picker', async () => {
+        const { commands, ctx, notify, custom } = harness();
+        await commands.get('model-switch')('typo', ctx);
+        expect(custom).not.toHaveBeenCalled();
+        expect(notify).toHaveBeenCalledWith('Usage: /model-switch [add | add-current]', 'warning');
+    });
 });

package/dist/section-picker.d.ts

@@ -16,7 +16,10 @@ export declare class SectionPicker implements Component {
     private readonly selectTheme;
     constructor(sections: PickerSection[], theme: Theme, done: (value: string | null) => void);
     private renderTabBar;
+    private wireSelectList;
     private switchSection;
+    private filteredItems;
+    private rebuildList;
     render(width: number): string[];
     invalidate(): void;
     handleInput(data: string): void;

package/dist/section-picker.js

@@ -21,8 +21,7 @@ export class SectionPicker {
             noMatch: (text) => theme.fg('warning', text),
         };
         this.selectList = new SelectList(sections[0]?.items ?? [], 10, this.selectTheme);
-        this.selectList.onSelect = (item) => this.done(item.value);
-        this.selectList.onCancel = () => this.done(null);
+        this.wireSelectList();
         this.container.addChild(this.tabBar);
         this.container.addChild(this.searchInput);
         this.container.addChild(this.selectList);
@@ -37,12 +36,42 @@ export class SectionPicker {
         });
         this.tabBar.setText(parts.join(''));
     }
+    wireSelectList() {
+        this.selectList.onSelect = (item) => this.done(item.value);
+        this.selectList.onCancel = () => this.done(null);
+    }
     switchSection(direction) {
         this.activeSectionIndex = (this.activeSectionIndex + direction + this.sections.length) % this.sections.length;
         this.searchInput.setValue('');
-        this.selectList = new SelectList(this.sections[this.activeSectionIndex]?.items ?? [], 10, this.selectTheme);
-        this.selectList.onSelect = (item) => this.done(item.value);
-        this.selectList.onCancel = () => this.done(null);
+        this.rebuildList();
+    }
+    filteredItems() {
+        const query = this.searchInput.getValue().trim().toLowerCase();
+        if (query.length === 0)
+            return this.sections[this.activeSectionIndex]?.items ?? [];
+        // SelectList.setFilter only matches value.startsWith(query), which can never
+        // match a model name inside "provider/modelId" — filter here instead, with a
+        // substring match across every section.
+        const seen = new Set();
+        const matches = [];
+        for (const section of this.sections) {
+            for (const item of section.items) {
+                if (seen.has(item.value) || !item.value.toLowerCase().includes(query))
+                    continue;
+                seen.add(item.value);
+                matches.push({ ...item, description: section.name });
+            }
+        }
+        return matches;
+    }
+    rebuildList() {
+        // Size the primary column to the content so section descriptions never
+        // truncate long provider/modelId labels (SelectList caps it at 32 otherwise).
+        this.selectList = new SelectList(this.filteredItems(), 10, this.selectTheme, {
+            minPrimaryColumnWidth: 1,
+            maxPrimaryColumnWidth: Number.MAX_SAFE_INTEGER,
+        });
+        this.wireSelectList();
         this.container.clear();
         this.container.addChild(this.tabBar);
         this.container.addChild(this.searchInput);
@@ -69,7 +98,7 @@ export class SectionPicker {
         }
         else {
             this.searchInput.handleInput(data);
-            this.selectList.setFilter(this.searchInput.getValue());
+            this.rebuildList();
         }
     }
 }

package/dist/section-picker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/section-picker.test.js

@@ -0,0 +1,73 @@
+import { describe, expect, it, vi } from 'vitest';
+import { SectionPicker } from './section-picker.js';
+const theme = {
+    fg: (_color, text) => text,
+    bold: (text) => text,
+};
+function sections() {
+    return [
+        {
+            name: 'work',
+            items: [
+                { value: 'cloudflare-ai-gateway/gpt-5.6-sol', label: '  cloudflare-ai-gateway/gpt-5.6-sol' },
+                { value: 'cloudflare-ai-gateway/claude-opus-5', label: '  cloudflare-ai-gateway/claude-opus-5' },
+                {
+                    value: 'fireworks/accounts/fireworks/models/kimi-k3',
+                    label: '  fireworks/accounts/fireworks/models/kimi-k3',
+                },
+            ],
+        },
+        {
+            name: 'personal',
+            items: [
+                {
+                    value: 'fireworks/accounts/fireworks/models/kimi-k3',
+                    label: '  fireworks/accounts/fireworks/models/kimi-k3',
+                },
+            ],
+        },
+    ];
+}
+function render(picker) {
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: stripping ANSI escape codes
+    return picker
+        .render(240)
+        .join('\n')
+        .replace(/\x1b\[[0-9;]*m/g, '');
+}
+function type(picker, text) {
+    for (const char of text)
+        picker.handleInput(char);
+}
+describe('SectionPicker filtering', () => {
+    it('matches a model name substring inside provider/modelId', () => {
+        const picker = new SectionPicker(sections(), theme, vi.fn());
+        type(picker, 'claude');
+        const output = render(picker);
+        expect(output).toContain('cloudflare-ai-gateway/claude-opus-5');
+        expect(output).not.toContain('gpt-5.6-sol');
+        expect(output).not.toContain('kimi-k3');
+    });
+    it('searches across all sections and dedupes models present in multiple sections', () => {
+        const picker = new SectionPicker(sections(), theme, vi.fn());
+        type(picker, 'kimi');
+        const output = render(picker);
+        const occurrences = output.split('kimi-k3').length - 1;
+        expect(occurrences).toBe(1);
+    });
+    it('shows only the active section when the query is empty', () => {
+        const picker = new SectionPicker(sections(), theme, vi.fn());
+        type(picker, 'claude');
+        type(picker, '\x7f'.repeat(7)); // backspace away the query
+        const output = render(picker);
+        expect(output).toContain('cloudflare-ai-gateway/claude-opus-5');
+        expect(output).toContain('cloudflare-ai-gateway/gpt-5.6-sol');
+    });
+    it('confirms the highlighted filtered match on enter', () => {
+        const done = vi.fn();
+        const picker = new SectionPicker(sections(), theme, done);
+        type(picker, 'kimi');
+        picker.handleInput('\r');
+        expect(done).toHaveBeenCalledWith('fireworks/accounts/fireworks/models/kimi-k3');
+    });
+});

package/index.ts

@@ -1,7 +1,12 @@
 import type { Api, Model } from '@earendil-works/pi-ai';
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
 import type { SelectItem } from '@earendil-works/pi-tui';
-import { loadModelSwitchConfig, loadModelSwitchKeybindings, modelCycleConfigPath } from './config.js';
+import {
+  addModelToSection,
+  loadModelSwitchConfig,
+  loadModelSwitchKeybindings,
+  modelCycleConfigPath,
+} from './config.js';
 import { findActiveSection, resolveAvailableModels, selectCycleTarget, type CycleDirection } from './cycle.js';
 import { SectionPicker, type PickerSection } from './section-picker.js';
 
@@ -88,6 +93,60 @@ async function showModelPicker(pi: ExtensionAPI, ctx: ExtensionContext): Promise
   if (target) await switchModel(pi, ctx, target);
 }
 
+async function addConfiguredModel(ctx: ExtensionContext, useCurrent: boolean): Promise<void> {
+  if (!ctx.hasUI) return;
+  if (!useCurrent && ctx.mode !== 'tui') {
+    ctx.ui.notify('/model-switch add requires the terminal UI', 'warning');
+    return;
+  }
+
+  const loaded = loadModelSwitchConfig();
+  if (!loaded.ok) {
+    ctx.ui.notify(loaded.error, 'warning');
+    return;
+  }
+
+  let target = ctx.model;
+  if (!useCurrent) {
+    const available = ctx.modelRegistry.getAvailable();
+    if (available.length === 0) {
+      ctx.ui.notify('No available models to add. Configure a provider with /login first.', 'warning');
+      return;
+    }
+    const selected = await ctx.ui.custom<string | null>((_tui, theme, _keybindings, done) => {
+      return new SectionPicker([{ name: 'Add a model', items: buildSectionItems(available, ctx.model) }], theme, done);
+    });
+    if (!selected) return;
+    target = available.find((model) => `${model.provider}/${model.id}` === selected);
+  }
+  if (!target) {
+    ctx.ui.notify('No model selected to add', 'warning');
+    return;
+  }
+
+  const reference = `${target.provider}/${target.id}`;
+  const sections = loaded.config.sections.map((section) => section.name);
+  const sectionName =
+    sections.length > 0
+      ? await ctx.ui.select(`Add ${reference} to section`, sections)
+      : (await ctx.ui.input('Name your first model-switch section', 'models'))?.trim();
+  if (sectionName === undefined) return;
+  if (sections.length === 0 && !sectionName) {
+    ctx.ui.notify('Section name must not be empty', 'warning');
+    return;
+  }
+
+  const result = addModelToSection(reference, sectionName);
+  if (!result.ok) {
+    ctx.ui.notify(result.error, 'warning');
+    return;
+  }
+  ctx.ui.notify(
+    result.added ? `Added ${reference} to "${sectionName}"` : `${reference} is already in "${sectionName}"`,
+    'info',
+  );
+}
+
 export default function modelCycle(pi: ExtensionAPI) {
   const keybindings = loadModelSwitchKeybindings();
   type ShortcutKey = Parameters<ExtensionAPI['registerShortcut']>[0];
@@ -108,7 +167,25 @@ export default function modelCycle(pi: ExtensionAPI) {
   });
 
   pi.registerCommand('model-switch', {
-    description: 'Select from configured models',
-    handler: async (_args, ctx) => showModelPicker(pi, ctx),
+    description: 'Select configured models, add a model, or add-current',
+    getArgumentCompletions: (prefix) => {
+      const items = [
+        { value: 'add', label: 'add', description: 'Pick an available model to save' },
+        { value: 'add-current', label: 'add-current', description: 'Save the current model' },
+      ].filter((item) => item.value.startsWith(prefix));
+      return items.length > 0 ? items : null;
+    },
+    handler: async (args, ctx) => {
+      switch (args.trim()) {
+        case '':
+          return showModelPicker(pi, ctx);
+        case 'add':
+          return addConfiguredModel(ctx, false);
+        case 'add-current':
+          return addConfiguredModel(ctx, true);
+        default:
+          ctx.ui.notify('Usage: /model-switch [add | add-current]', 'warning');
+      }
+    },
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nicknisi/pi-model-switch",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Cycle or fuzzy-pick from a machine-local, sectioned list of preferred Pi models",
   "keywords": [
     "pi",

package/section-picker.ts

@@ -38,8 +38,7 @@ export class SectionPicker implements Component {
     };
 
     this.selectList = new SelectList(sections[0]?.items ?? [], 10, this.selectTheme);
-    this.selectList.onSelect = (item) => this.done(item.value);
-    this.selectList.onCancel = () => this.done(null);
+    this.wireSelectList();
 
     this.container.addChild(this.tabBar);
     this.container.addChild(this.searchInput);
@@ -57,12 +56,44 @@ export class SectionPicker implements Component {
     this.tabBar.setText(parts.join(''));
   }
 
+  private wireSelectList(): void {
+    this.selectList.onSelect = (item) => this.done(item.value);
+    this.selectList.onCancel = () => this.done(null);
+  }
+
   private switchSection(direction: 1 | -1): void {
     this.activeSectionIndex = (this.activeSectionIndex + direction + this.sections.length) % this.sections.length;
     this.searchInput.setValue('');
-    this.selectList = new SelectList(this.sections[this.activeSectionIndex]?.items ?? [], 10, this.selectTheme);
-    this.selectList.onSelect = (item) => this.done(item.value);
-    this.selectList.onCancel = () => this.done(null);
+    this.rebuildList();
+  }
+
+  private filteredItems(): SelectItem[] {
+    const query = this.searchInput.getValue().trim().toLowerCase();
+    if (query.length === 0) return this.sections[this.activeSectionIndex]?.items ?? [];
+
+    // SelectList.setFilter only matches value.startsWith(query), which can never
+    // match a model name inside "provider/modelId" — filter here instead, with a
+    // substring match across every section.
+    const seen = new Set<string>();
+    const matches: SelectItem[] = [];
+    for (const section of this.sections) {
+      for (const item of section.items) {
+        if (seen.has(item.value) || !item.value.toLowerCase().includes(query)) continue;
+        seen.add(item.value);
+        matches.push({ ...item, description: section.name });
+      }
+    }
+    return matches;
+  }
+
+  private rebuildList(): void {
+    // Size the primary column to the content so section descriptions never
+    // truncate long provider/modelId labels (SelectList caps it at 32 otherwise).
+    this.selectList = new SelectList(this.filteredItems(), 10, this.selectTheme, {
+      minPrimaryColumnWidth: 1,
+      maxPrimaryColumnWidth: Number.MAX_SAFE_INTEGER,
+    });
+    this.wireSelectList();
     this.container.clear();
     this.container.addChild(this.tabBar);
     this.container.addChild(this.searchInput);
@@ -94,7 +125,7 @@ export class SectionPicker implements Component {
       this.selectList.handleInput(data);
     } else {
       this.searchInput.handleInput(data);
-      this.selectList.setFilter(this.searchInput.getValue());
+      this.rebuildList();
     }
   }
 }