@dominikcz/greg 0.9.27

package/src/lib/MarkdownDocs/searchServer.js

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+/**
+ * Greg standalone search server — for production deployments.
+ *
+ * Reads a pre-built search-index.json, loads it into Fuse.js, then serves
+ * GET /api/search?q=<query>&limit=<n> as a lightweight HTTP endpoint.
+ *
+ * Usage:
+ *   node src/lib/MarkdownDocs/searchServer.js [options]
+ *   greg search-server                            (via CLI)
+ *
+ * Options (CLI flags or environment variables):
+ *   --index  PATH          Path to search-index.json  (GREG_SEARCH_INDEX, default: dist/search-index.json)
+ *   --port   NUMBER        HTTP port                  (GREG_SEARCH_PORT,  default: 3100)
+ *   --host   HOSTNAME      Bind address               (GREG_SEARCH_HOST,  default: localhost)
+ *   --url    PATH          Search endpoint URL path   (GREG_SEARCH_URL,   default: /api/search)
+ *   --cors-origin VALUE    Access-Control-Allow-Origin (GREG_SEARCH_CORS_ORIGIN, default: *)
+ *                          Use 'request' to mirror request Origin header.
+ *   --cors-methods VALUE   Access-Control-Allow-Methods (GREG_SEARCH_CORS_METHODS, default: GET, OPTIONS)
+ *   --cors-headers VALUE   Access-Control-Allow-Headers (GREG_SEARCH_CORS_HEADERS, default: Content-Type)
+ *   --cors-max-age VALUE   Access-Control-Max-Age       (GREG_SEARCH_CORS_MAX_AGE, default: 86400)
+ *
+ * Example — run after `greg build`:
+ *   greg search-server --index dist/search-index.json --port 3100
+ *
+ * Then point greg.config.js → search.serverUrl to http://localhost:3100/api/search
+ * (or configure a reverse proxy so /api/search hits this server).
+ */
+
+import { createServer } from 'node:http';
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { statSync } from 'node:fs';
+import { buildFuseResult } from './searchIndexBuilder.js';
+import { loadGregConfig } from './loadGregConfig.js';
+import Fuse from 'fuse.js';
+
+const startupT0 = process.hrtime.bigint();
+
+function msSince(t0) {
+	return Number(process.hrtime.bigint() - t0) / 1e6;
+}
+
+function fmtMs(ms) {
+	return `${ms.toFixed(1)}ms`;
+}
+
+// ── CLI argument parser ───────────────────────────────────────────────────────
+function parseArgs(argv) {
+	const args = {};
+	for (let i = 0; i < argv.length; i++) {
+		const a = argv[i];
+		if (a.startsWith('--') && i + 1 < argv.length && !argv[i + 1].startsWith('--')) {
+			args[a.slice(2)] = argv[i + 1];
+			i++;
+		} else if (a.startsWith('--')) {
+			args[a.slice(2)] = true;
+		}
+	}
+	return args;
+}
+
+const args = parseArgs(process.argv.slice(2));
+const gregConfig = await loadGregConfig();
+const configuredFuzzy = gregConfig?.search?.fuzzy ?? {};
+const port = parseInt(args.port ?? process.env.GREG_SEARCH_PORT ?? '3100', 10);
+const host = String(args.host ?? process.env.GREG_SEARCH_HOST ?? 'localhost');
+const url = String(args.url ?? process.env.GREG_SEARCH_URL ?? '/api/search');
+const index = resolve(String(args.index ?? process.env.GREG_SEARCH_INDEX ?? 'dist/search-index.json'));
+const corsOrigin = String(args['cors-origin'] ?? process.env.GREG_SEARCH_CORS_ORIGIN ?? '*');
+const corsMethods = String(args['cors-methods'] ?? process.env.GREG_SEARCH_CORS_METHODS ?? 'GET, OPTIONS');
+const corsHeaders = String(args['cors-headers'] ?? process.env.GREG_SEARCH_CORS_HEADERS ?? 'Content-Type');
+const corsMaxAge = String(args['cors-max-age'] ?? process.env.GREG_SEARCH_CORS_MAX_AGE ?? '86400');
+const thresholdRaw =
+	args.threshold ?? process.env.GREG_SEARCH_THRESHOLD ?? configuredFuzzy.threshold;
+const threshold = Number.isFinite(Number(thresholdRaw))
+	? Number(thresholdRaw)
+	: 0.35;
+const minMatchRaw =
+	args['min-match-chars'] ??
+	process.env.GREG_SEARCH_MIN_MATCH_CHARS ??
+	configuredFuzzy.minMatchCharLength;
+const minMatchCharLength = Number.isFinite(Number(minMatchRaw))
+	? Math.max(1, Number(minMatchRaw))
+	: 3;
+const ignoreLocationRaw =
+	args['ignore-location'] ??
+	process.env.GREG_SEARCH_IGNORE_LOCATION ??
+	configuredFuzzy.ignoreLocation;
+const ignoreLocation =
+	String(ignoreLocationRaw ?? 'true').toLowerCase() !== 'false';
+
+function getCorsHeaders(req) {
+	const reflectedOrigin = req.headers.origin ? String(req.headers.origin) : '*';
+	const allowOrigin = corsOrigin === 'request' ? reflectedOrigin : corsOrigin;
+	return {
+		'Access-Control-Allow-Origin': allowOrigin,
+		'Access-Control-Allow-Methods': corsMethods,
+		'Access-Control-Allow-Headers': corsHeaders,
+		'Access-Control-Max-Age': corsMaxAge,
+		...(corsOrigin === 'request' ? { 'Vary': 'Origin' } : {}),
+	};
+}
+
+function normalizePath(value) {
+	const raw = String(value ?? '').trim();
+	if (!raw || raw === '/') return '/';
+	return '/' + raw.replace(/^\/+|\/+$/g, '');
+}
+
+function isPathInLocale(id, localeRoot, baseRoot, localeRoots) {
+	const currentRoot = normalizePath(localeRoot);
+	const normalizedBase = normalizePath(baseRoot);
+	const normalizedId = normalizePath(id);
+	const roots = (localeRoots ?? []).map(normalizePath);
+
+	const inCurrentRoot = currentRoot === '/'
+		? normalizedId.startsWith('/')
+		: (normalizedId === currentRoot || normalizedId.startsWith(currentRoot + '/'));
+
+	if (!inCurrentRoot) {
+		return false;
+	}
+
+	if (currentRoot === normalizedBase) {
+		const otherRoots = roots.filter((rp) => rp !== currentRoot);
+		if (otherRoots.some((rp) => normalizedId === rp || normalizedId.startsWith(rp + '/'))) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+// ── Load index ────────────────────────────────────────────────────────────────
+console.log(`[greg-search] Loading index: ${index}`);
+
+let data = [];
+let fuse = null;
+let sectionCount = 0;
+let loadParseMs = 0;
+let fuseBuildMs = 0;
+let indexMtimeMs = -1;
+
+function buildFuse(searchData) {
+	return new Fuse(searchData, {
+		includeScore: true,
+		includeMatches: true,
+		threshold,
+		ignoreLocation,
+		minMatchCharLength,
+		keys: [
+			{ name: 'title', weight: 3 },
+			{ name: 'sections.heading', weight: 2 },
+			{ name: 'sections.content', weight: 1 },
+		],
+	});
+}
+
+function loadIndex(force = false) {
+	let stats;
+	try {
+		stats = statSync(index);
+	} catch (/** @type {any} */ e) {
+		console.error(`[greg-search] Failed to stat index: ${e.message}`);
+		process.exit(1);
+	}
+
+	if (!force && stats.mtimeMs === indexMtimeMs && fuse) return false;
+
+	const loadParseT0 = process.hrtime.bigint();
+	let nextData;
+	try {
+		nextData = JSON.parse(readFileSync(index, 'utf-8'));
+	} catch (/** @type {any} */ e) {
+		console.error(`[greg-search] Failed to load index: ${e.message}`);
+		process.exit(1);
+	}
+	loadParseMs = msSince(loadParseT0);
+
+	const fuseBuildT0 = process.hrtime.bigint();
+	fuse = buildFuse(nextData);
+	fuseBuildMs = msSince(fuseBuildT0);
+
+	data = nextData;
+	indexMtimeMs = stats.mtimeMs;
+	sectionCount = data.reduce((sum, doc) => sum + (doc.sections?.length ?? 0), 0);
+
+	console.log(`[greg-search] Indexed ${data.length} document(s).`);
+	return true;
+}
+
+loadIndex(true);
+
+// ── HTTP server ───────────────────────────────────────────────────────────────
+const server = createServer((req, res) => {
+	const rawUrl = req.url ?? '';
+	const qIdx = rawUrl.indexOf('?');
+	const pathname = qIdx >= 0 ? rawUrl.slice(0, qIdx) : rawUrl;
+
+	// CORS preflight
+	if (req.method === 'OPTIONS') {
+		res.writeHead(204, {
+			...getCorsHeaders(req),
+		});
+		res.end();
+		return;
+	}
+
+	if (pathname !== url || req.method !== 'GET') {
+		res.writeHead(404, {
+			...getCorsHeaders(req),
+		});
+		res.end();
+		return;
+	}
+
+	const params = new URLSearchParams(qIdx >= 0 ? rawUrl.slice(qIdx + 1) : '');
+	const q = (params.get('q') ?? '').trim();
+	const limit = Math.min(Math.max(parseInt(params.get('limit') ?? '10', 10) || 10, 1), 50);
+	const localeRoot = params.get('localeRoot');
+	const baseRoot = params.get('baseRoot');
+	const localeRoots = (params.get('localeRoots') ?? '')
+		.split(',')
+		.map(v => v.trim())
+		.filter(Boolean);
+
+	loadIndex(false);
+
+	let results = q ? fuse.search(q, { limit }).map(buildFuseResult) : [];
+	if (localeRoot && baseRoot) {
+		results = results.filter((result) =>
+			isPathInLocale(result.id, localeRoot, baseRoot, localeRoots),
+		);
+	}
+	const body = JSON.stringify({ query: q, results });
+
+	res.writeHead(200, {
+		'Content-Type': 'application/json; charset=utf-8',
+		'Cache-Control': 'no-cache',
+		'Content-Length': Buffer.byteLength(body),
+		...getCorsHeaders(req),
+	});
+	res.end(body);
+});
+
+server.listen(port, host, () => {
+	console.log(`[greg-search] Listening on http://${host}:${port}${url}`);
+	const startupMs = msSince(startupT0);
+	console.log(
+		`[greg-search] Startup summary: load+parse=${fmtMs(loadParseMs)}, ` +
+		`fuse-index=${fmtMs(fuseBuildMs)}, total=${fmtMs(startupMs)}, ` +
+		`docs=${data.length}, sections=${sectionCount}`,
+	);
+	console.log(
+		`[greg-search] CORS: origin=${corsOrigin}, methods="${corsMethods}", ` +
+		`headers="${corsHeaders}", max-age=${corsMaxAge}`,
+	);
+	console.log(
+		`[greg-search] Fuzzy: threshold=${threshold}, min-match-chars=${minMatchCharLength}, ` +
+		`ignore-location=${ignoreLocation}`,
+	);
+});

package/src/lib/MarkdownDocs/treeViewTypes.ts

@@ -0,0 +1,11 @@
+export interface TreeViewItem {
+    label: string;
+    link: string;
+    target?: string;
+    rel?: string;
+    status?: string;
+    /** Optional badge displayed next to the label in the navigation tree. */
+    badge?: { text: string; type?: string };
+    type?: string;
+    children: TreeViewItem[];
+}

package/src/lib/MarkdownDocs/useRouter.svelte.ts

@@ -0,0 +1,114 @@
+import { tick } from 'svelte';
+import { flattenMenu, getBreadcrumb } from './docsUtils';
+
+type FlatItem = { label: string; link: string; type: string };
+
+/**
+ * SPA router rune for MarkdownDocs.
+ * Manages the active URL, module resolution and popstate handling.
+ *
+ * `knownPaths` is a set of known markdown file paths (e.g. from the frontmatter
+ * virtual module). Values are ignored – only keys are used for existence checks.
+ */
+function normalizePath(raw: string): string {
+	return decodeURI(raw).replace(/\/$/, '') || '/';
+}
+
+function normalizeHash(raw?: string): string {
+	if (!raw) return '';
+	const value = String(raw).trim().replace(/^#/, '');
+	return value ? `#${value}` : '';
+}
+
+export function buildNavigationUrl(path: string, anchor?: string): string {
+	const normalized = normalizePath(path);
+	const isBaseLikeRoot = /^\/[^/]+$/.test(normalized);
+	const preserveTrailingSlash =
+		isBaseLikeRoot
+		&& !anchor
+		&& String(path).endsWith('/');
+	const pathname = preserveTrailingSlash ? `${normalized}/` : normalized;
+	return `${pathname}${normalizeHash(anchor)}`;
+}
+
+export function isSameNavigationTarget(
+	currentPath: string,
+	currentHash: string | undefined,
+	nextPath: string,
+	nextAnchor?: string,
+): boolean {
+	return normalizePath(currentPath) === normalizePath(nextPath)
+		&& normalizeHash(currentHash) === normalizeHash(nextAnchor);
+}
+
+export function useRouter(
+	knownPaths: Record<string, unknown>,
+	getSrcDirForPath: (path: string) => string,
+	normalizePathForLookup: (path: string) => string = (path) => path,
+) {
+	let active = $state(normalizePath(window.location.pathname));
+
+	const lookupActive = $derived.by(() =>
+		normalizePath(normalizePathForLookup(active)),
+	);
+
+	function navigate(path: string, anchor?: string) {
+		if (isSameNavigationTarget(window.location.pathname, window.location.hash || '', path, anchor)) return;
+		history.pushState(null, '', buildNavigationUrl(path, anchor));
+		active = normalizePath(path);
+	}
+
+	function handlePopState() {
+		active = normalizePath(window.location.pathname);
+	}
+
+	$effect(() => {
+		window.addEventListener('popstate', handlePopState);
+		return () => window.removeEventListener('popstate', handlePopState);
+	});
+
+	/** Resolved .md file path for the active route, or null if unknown. */
+	const activeMarkdownPath = $derived.by(() => {
+		const srcDir = getSrcDirForPath(lookupActive);
+		const rel = lookupActive.replace(srcDir, '').replace(/^\//, '');
+		const candidates = rel
+			? (
+				srcDir === '/'
+					? [`/${rel}.md`, `/${rel}/index.md`]
+					: [`${srcDir}/${rel}.md`, `${srcDir}/${rel}/index.md`]
+			)
+			: (
+				srcDir === '/'
+					? ['/index.md']
+					: [`${srcDir}/index.md`, `${srcDir}index.md`]
+			);
+		for (const c of candidates) {
+			if (c in knownPaths) return c;
+		}
+		return null;
+	});
+
+	return {
+		get active() { return active; },
+		/** Resolved .md path suitable for fetch('/docs/guide/page.md'). */
+		get activeMarkdownPath() { return activeMarkdownPath; },
+		navigate,
+		/** Navigate and after content loads scroll to anchor. */
+		navigateWithAnchor(path: string, anchor?: string) {
+			navigate(path, anchor);
+			if (anchor) {
+				tick().then(() => setTimeout(() => {
+					document.getElementById(anchor)?.scrollIntoView({ behavior: 'smooth', block: 'start' });
+				}, 120));
+			}
+		},
+		/** Returns true when active path corresponds to a markdown page. */
+		isMarkdown(flat: FlatItem[]) {
+			const m = flat.find((x: FlatItem) => x.link === lookupActive);
+			return m ? m.type === 'md' : true;
+		},
+		title(flat: FlatItem[]) {
+			return getBreadcrumb(lookupActive, flat);
+		},
+	};
+}

package/src/lib/MarkdownDocs/useSplitter.svelte.ts

@@ -0,0 +1,33 @@
+/**
+ * Drag-to-resize rune for the left nav panel splitter.
+ * Returns refs and event handlers to bind on the aside + splitter elements.
+ */
+export function useSplitter() {
+	let aside = $state<HTMLElement | undefined>(undefined);
+	let splitter = $state<HTMLElement | undefined>(undefined);
+	let dragging = false;
+
+	function onMouseDown() {
+		dragging = true;
+	}
+
+	function onMouseMove(e: MouseEvent) {
+		if (!dragging || !aside || !splitter) return;
+		aside.style.width = e.x - splitter.getBoundingClientRect().width / 2 + 'px';
+		e.preventDefault();
+	}
+
+	function onMouseUp() {
+		dragging = false;
+	}
+
+	return {
+		get aside() { return aside; },
+		set aside(el) { aside = el; },
+		get splitter() { return splitter; },
+		set splitter(el) { splitter = el; },
+		onMouseDown,
+		onMouseMove,
+		onMouseUp,
+	};
+}

package/src/lib/MarkdownDocs/versioningDefaults.js

@@ -0,0 +1,20 @@
+export const DEFAULT_SITE_BASE = '/';
+export const DEFAULT_OUTPUT_BASE_DIR = 'dist';
+export const DEFAULT_VERSIONS_DIR_NAME = '__versions';
+export const LEGACY_VERSIONS_DIR_NAME = 'versions';
+
+export const DEFAULT_OUTPUT_ROOT = `${DEFAULT_OUTPUT_BASE_DIR}/${DEFAULT_VERSIONS_DIR_NAME}`;
+export const DEFAULT_PATH_PREFIX = `/${DEFAULT_VERSIONS_DIR_NAME}`;
+
+export function normalizeBasePath(value, fallback = DEFAULT_SITE_BASE) {
+	const raw = String(value ?? fallback).trim();
+	if (!raw || raw === '/') return '/';
+	const cleaned = raw.replace(/^\/+|\/+$/g, '');
+	return `/${cleaned}/`;
+}
+
+export function buildDefaultVersionPathPrefix(basePath) {
+	const normalizedBase = normalizeBasePath(basePath);
+	if (normalizedBase === '/') return DEFAULT_PATH_PREFIX;
+	return `${normalizedBase.replace(/\/$/, '')}/${DEFAULT_VERSIONS_DIR_NAME}`;
+}

package/src/lib/MarkdownDocs/vitePluginAiServer.js

@@ -0,0 +1,204 @@
+/**
+ * vitePluginAiServer
+ *
+ * Vite plugin that exposes an AI question-answering REST API in both
+ * dev (`configureServer`) and preview (`configurePreviewServer`) modes:
+ *
+ *   POST /api/ai/ask          — ask a question, receive an AI answer + sources
+ *   GET  /api/ai/characters   — list available personas
+ *
+ * Only active when `search.ai.enabled = true` in greg.config.js.
+ * For production deployments use the standalone `aiServer.js` instead
+ * (invoked via `greg ai-server`).
+ *
+ * @param {object} options
+ * @param {string} [options.docsDir='docs']      Docs directory relative to project root
+ * @param {string} [options.srcDir='/docs']      SPA route prefix
+ * @param {string} [options.aiUrl='/api/ai']     URL path prefix for AI endpoints
+ * @param {object} [options.ai={}]               Contents of greg.config.js → search.ai
+ */
+
+import path from 'node:path';
+import { buildSearchIndex, invalidateSearchIndexCache } from './searchIndexBuilder.js';
+import { buildChunks } from './ai/chunker.js';
+import { MemoryStore } from './ai/stores/memoryStore.js';
+import { resolveCharacters } from './ai/characters.js';
+import { RagPipeline } from './ai/ragPipeline.js';
+
+/** @typedef {import('../../../types/index.js').AiConfig} AiConfig */
+
+export function vitePluginAiServer({
+	docsDir = 'docs',
+	srcDir = '/docs',
+	aiUrl = '/api/ai',
+	ai = /** @type {AiConfig} */ ({}),
+} = {}) {
+	// Return a no-op plugin when AI is disabled — zero overhead
+	if (!ai?.enabled) {
+		return { name: 'greg:ai-server' };
+	}
+
+	let resolvedDocsDir;
+	let viteBase = '/';
+
+	/** @type {RagPipeline | null} */
+	let pipelineCache = null;
+	/** @type {Promise<RagPipeline> | null} */
+	let buildPromise = null;
+
+	async function buildPipeline() {
+		const provider = await createProvider(ai);
+		const index = await buildSearchIndex(resolvedDocsDir, srcDir);
+		const chunks = buildChunks(index, ai?.chunking ?? {});
+		const store = new MemoryStore();
+		await store.index(chunks);
+
+		const characters = resolveCharacters(
+			ai?.characters,
+			ai?.customCharacters ?? [],
+		);
+
+		return new RagPipeline(provider, store, characters);
+	}
+
+	async function loadPipeline() {
+		if (pipelineCache) return pipelineCache;
+		if (!buildPromise) {
+			buildPromise = buildPipeline()
+				.then(p => { pipelineCache = p; return p; })
+				.catch(err => { buildPromise = null; throw err; });
+		}
+		return buildPromise;
+	}
+
+	function invalidate() {
+		pipelineCache = null;
+		buildPromise = null;
+		invalidateSearchIndexCache();
+	}
+
+	function readBody(req) {
+		return new Promise((resolve, reject) => {
+			let body = '';
+			req.on('data', chunk => { body += chunk; });
+			req.on('end', () => {
+				try { resolve(JSON.parse(body || '{}')); }
+				catch { resolve({}); }
+			});
+			req.on('error', reject);
+		});
+	}
+
+	function middleware() {
+		return async (req, res, next) => {
+			const urlStr = req.url ?? '';
+			const qIdx = urlStr.indexOf('?');
+			const rawPathname = qIdx >= 0 ? urlStr.slice(0, qIdx) : urlStr;
+			const base = viteBase === '/' ? '' : viteBase.replace(/\/$/, '');
+			const pathname = (base && rawPathname.startsWith(base))
+				? '/' + rawPathname.slice(base.length).replace(/^\/+/, '')
+				: rawPathname;
+
+			// GET /api/ai/characters
+			if (pathname === `${aiUrl}/characters` && req.method === 'GET') {
+				try {
+					const pipeline = await loadPipeline();
+					const body = JSON.stringify({ characters: pipeline.getCharacters() });
+					res.writeHead(200, {
+						'Content-Type': 'application/json; charset=utf-8',
+						'Cache-Control': 'no-cache',
+					});
+					res.end(body);
+				} catch (err) {
+					console.error('[greg:ai-server] characters error:', err.message);
+					res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+					res.end(JSON.stringify({ error: err.message }));
+				}
+				return;
+			}
+
+			// POST /api/ai/ask
+			if (pathname === `${aiUrl}/ask` && req.method === 'POST') {
+				try {
+					const body = await readBody(req);
+					const query = String(body.query ?? body.q ?? '').trim();
+					if (!query) {
+						res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+						res.end(JSON.stringify({ error: 'query is required' }));
+						return;
+					}
+
+					const characterId = String(body.character ?? ai?.defaultCharacter ?? 'professional');
+					const locale = String(body.locale ?? '');
+
+					const pipeline = await loadPipeline();
+					const result = await pipeline.ask(query, characterId, locale);
+
+					const responseBody = JSON.stringify(result);
+					res.writeHead(200, {
+						'Content-Type': 'application/json; charset=utf-8',
+						'Cache-Control': 'no-cache',
+						'Content-Length': Buffer.byteLength(responseBody),
+					});
+					res.end(responseBody);
+				} catch (err) {
+					console.error('[greg:ai-server] ask error:', err.message);
+					res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+					res.end(JSON.stringify({ error: 'AI query failed', detail: err.message }));
+				}
+				return;
+			}
+
+			next();
+		};
+	}
+
+	return {
+		name: 'greg:ai-server',
+
+		configResolved(config) {
+			const dirs = Array.isArray(docsDir) ? docsDir : [docsDir];
+			resolvedDocsDir = dirs.map(d => path.resolve(config.root, d));
+			viteBase = config.base ?? '/';
+		},
+
+		configureServer(server) {
+			server.middlewares.use(middleware());
+			server.watcher.on('change', f => { if (f.endsWith('.md')) invalidate(); });
+			server.watcher.on('add', f => { if (f.endsWith('.md')) invalidate(); });
+			server.watcher.on('unlink', f => { if (f.endsWith('.md')) invalidate(); });
+		},
+
+		configurePreviewServer(server) {
+			server.middlewares.use(middleware());
+		},
+	};
+}
+
+/**
+ * Create the appropriate AiProvider from the `search.ai` config object.
+ * @param {object} aiConfig
+ */
+async function createProvider(aiConfig) {
+	const providerType = aiConfig?.provider ?? 'ollama';
+
+	if (providerType === 'ollama') {
+		const { OllamaAdapter } = await import('./ai/adapters/ollamaAdapter.js');
+		return new OllamaAdapter(aiConfig?.ollama ?? {});
+	}
+
+	if (providerType === 'openai') {
+		const { OpenAiAdapter } = await import('./ai/adapters/openaiAdapter.js');
+		return new OpenAiAdapter(aiConfig?.openai ?? {});
+	}
+
+	if (providerType === 'custom' && typeof aiConfig?.customProvider === 'function') {
+		const { CustomAdapter } = await import('./ai/adapters/customAdapter.js');
+		return new CustomAdapter(aiConfig.customProvider);
+	}
+
+	throw new Error(
+		`[greg:ai] Unknown provider: "${providerType}". ` +
+		`Supported values: "ollama", "openai", "custom".`,
+	);
+}