@dominikcz/greg 0.9.27

package/src/lib/MarkdownDocs/__tests__/markdownRendererRuntime.test.js

@@ -0,0 +1,65 @@
+import { describe, it, expect, vi } from 'vitest';
+import {
+	getRuntimeRenderHandlers,
+	getThemeChangeRenderHandlers,
+	runRenderHandlers,
+} from '../markdownRendererRuntime';
+
+describe('markdownRendererRuntime registries', () => {
+	it('builds runtime handlers in stable order', () => {
+		const handlers = getRuntimeRenderHandlers({
+			hydrateComponents: vi.fn(),
+			initMermaid: vi.fn(),
+		});
+
+		expect(handlers.map((h) => h.name)).toEqual([
+			'hydrate-components',
+			'init-mermaid',
+		]);
+	});
+
+	it('builds theme-change handlers in stable order', () => {
+		const handlers = getThemeChangeRenderHandlers({
+			rerenderMermaid: vi.fn(),
+		});
+
+		expect(handlers.map((h) => h.name)).toEqual(['rerender-mermaid']);
+	});
+});
+
+describe('runRenderHandlers', () => {
+	it('runs handlers in sequence and keeps going after an error', async () => {
+		const calls = [];
+		const root = /** @type {HTMLElement} */ ({});
+		const context = { mermaidThemeConfig: { theme: 'material' } };
+
+		const handlers = [
+			{
+				name: 'first',
+				run: vi.fn(async (_root, _ctx) => {
+					calls.push('first');
+				}),
+			},
+			{
+				name: 'broken',
+				run: vi.fn(async () => {
+					calls.push('broken');
+					throw new Error('boom');
+				}),
+			},
+			{
+				name: 'last',
+				run: vi.fn(async () => {
+					calls.push('last');
+				}),
+			},
+		];
+
+		await runRenderHandlers(root, handlers, context);
+
+		expect(calls).toEqual(['first', 'broken', 'last']);
+		expect(handlers[0].run).toHaveBeenCalledWith(root, context);
+		expect(handlers[1].run).toHaveBeenCalledWith(root, context);
+		expect(handlers[2].run).toHaveBeenCalledWith(root, context);
+	});
+});

package/src/lib/MarkdownDocs/__tests__/searchIndexBuilder.test.js

@@ -0,0 +1,117 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { buildSearchIndex, invalidateSearchIndexCache } from '../searchIndexBuilder.js';
+
+describe('buildSearchIndex', () => {
+	const tempDirs = [];
+
+	afterEach(() => {
+		invalidateSearchIndexCache();
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it('indexes text from markdown includes located in __partials', async () => {
+		const rootDir = mkdtempSync(join(tmpdir(), 'greg-search-index-'));
+		tempDirs.push(rootDir);
+
+		const docsDir = join(rootDir, 'docs');
+		mkdirSync(join(docsDir, '__partials'), { recursive: true });
+
+		writeFileSync(
+			join(docsDir, 'index.md'),
+			[
+				'# Home',
+				'',
+				'Intro section.',
+				'',
+				'<!--@include: /__partials/note.md-->',
+				'',
+				'Outro section.',
+			].join('\n'),
+			'utf8',
+		);
+		writeFileSync(
+			join(docsDir, '__partials', 'note.md'),
+			'Searchable phrase from included partial.',
+			'utf8',
+		);
+
+		const index = await buildSearchIndex(docsDir, '/docs');
+		const homeDoc = index.find(entry => entry.id === '/docs');
+
+		expect(homeDoc).toBeTruthy();
+		expect(homeDoc.sections.some(section => section.content.includes('Searchable phrase from included partial.'))).toBe(true);
+	});
+
+	it('indexes text from markdown includes loaded via @/ alias', async () => {
+		const rootDir = mkdtempSync(join(tmpdir(), 'greg-search-index-'));
+		tempDirs.push(rootDir);
+
+		const docsDir = join(rootDir, 'docs');
+		mkdirSync(docsDir, { recursive: true });
+		mkdirSync(join(rootDir, 'snippets'), { recursive: true });
+
+		writeFileSync(
+			join(docsDir, 'index.md'),
+			[
+				'# Home',
+				'',
+				'Intro section.',
+				'',
+				'<!--@include: @/snippets/shared.md-->',
+			].join('\n'),
+			'utf8',
+		);
+		writeFileSync(
+			join(rootDir, 'snippets', 'shared.md'),
+			'Alias include searchable sentence.',
+			'utf8',
+		);
+
+		const index = await buildSearchIndex(docsDir, '/docs');
+		const homeDoc = index.find(entry => entry.id === '/docs');
+
+		expect(homeDoc).toBeTruthy();
+		expect(homeDoc.sections.some(section => section.content.includes('Alias include searchable sentence.'))).toBe(true);
+	});
+
+	it('merges index from multiple docs directories', async () => {
+		const rootDir = mkdtempSync(join(tmpdir(), 'greg-search-index-multi-'));
+		tempDirs.push(rootDir);
+
+		const docsDir1 = join(rootDir, 'docs');
+		const docsDir2 = join(rootDir, 'extra-docs');
+		mkdirSync(docsDir1, { recursive: true });
+		mkdirSync(docsDir2, { recursive: true });
+
+		writeFileSync(join(docsDir1, 'guide.md'), '# Guide\n\nContent from first dir.', 'utf8');
+		writeFileSync(join(docsDir2, 'api.md'), '# API\n\nContent from second dir.', 'utf8');
+
+		const index = await buildSearchIndex([docsDir1, docsDir2], '/docs');
+
+		expect(index.length).toBe(2);
+		expect(index.find(e => e.id === '/docs/guide')).toBeTruthy();
+		expect(index.find(e => e.id === '/docs/api')).toBeTruthy();
+	});
+
+	it('returns same result as single-dir call when given single-element array', async () => {
+		const rootDir = mkdtempSync(join(tmpdir(), 'greg-search-index-single-'));
+		tempDirs.push(rootDir);
+
+		const docsDir = join(rootDir, 'docs');
+		mkdirSync(docsDir, { recursive: true });
+		writeFileSync(join(docsDir, 'page.md'), '# Page\n\nSome content.', 'utf8');
+
+		const [stringResult, arrayResult] = await Promise.all([
+			buildSearchIndex(docsDir, '/docs'),
+			(invalidateSearchIndexCache(), buildSearchIndex([docsDir], '/docs')),
+		]);
+
+		expect(arrayResult.length).toBe(stringResult.length);
+		expect(arrayResult[0].id).toBe(stringResult[0].id);
+	});
+});

package/src/lib/MarkdownDocs/__tests__/sqliteStore.test.js

@@ -0,0 +1,202 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { SqliteStore } from '../ai/stores/sqliteStore';
+
+/** Helper: build a small set of doc chunks for testing. */
+function sampleChunks() {
+	return [
+		{
+			pageId: '/docs/guide/routing',
+			pageTitle: 'Routing',
+			sectionHeading: 'Dynamic Routes',
+			sectionAnchor: 'dynamic-routes',
+			content: 'Greg supports dynamic routes using square bracket syntax in file names.',
+		},
+		{
+			pageId: '/docs/guide/deploying',
+			pageTitle: 'Deploying',
+			sectionHeading: 'Static hosting',
+			sectionAnchor: 'static-hosting',
+			content: 'You can deploy greg docs to any static hosting provider like Netlify or Vercel.',
+		},
+		{
+			pageId: '/docs/guide/localization',
+			pageTitle: 'Localization',
+			sectionHeading: 'Adding a language',
+			sectionAnchor: 'adding-a-language',
+			content: 'To add a new language, create a folder under docs with the locale code.',
+		},
+		{
+			pageId: '/docs/reference/search',
+			pageTitle: 'Search',
+			sectionHeading: 'Server search',
+			sectionAnchor: 'server-search',
+			content: 'Server-side search uses BM25 ranking for fast full-text retrieval.',
+		},
+		{
+			pageId: '/pl/docs/guide/routing',
+			pageTitle: 'Routing',
+			sectionHeading: 'Dynamiczne trasy',
+			sectionAnchor: 'dynamiczne-trasy',
+			content: 'Greg obsługuje dynamiczne trasy za pomocą składni nawiasów kwadratowych.',
+		},
+	];
+}
+
+describe('SqliteStore', () => {
+	/** @type {SqliteStore | null} */
+	let store = null;
+
+	afterEach(() => {
+		if (store) {
+			store.close();
+			store = null;
+		}
+	});
+
+	it('indexes chunks and reports correct size', async () => {
+		store = new SqliteStore({ dbPath: ':memory:' });
+		const chunks = sampleChunks();
+		await store.index(chunks);
+		expect(store.size()).toBe(chunks.length);
+	});
+
+	it('returns empty array when searching empty store', async () => {
+		store = new SqliteStore({ dbPath: ':memory:' });
+		const results = await store.search('routing');
+		expect(results).toEqual([]);
+	});
+
+	it('finds relevant chunks via BM25 full-text search', async () => {
+		store = new SqliteStore({ dbPath: ':memory:' });
+		await store.index(sampleChunks());
+
+		const results = await store.search('dynamic routes');
+		expect(results.length).toBeGreaterThan(0);
+		expect(results[0].pageId).toBe('/docs/guide/routing');
+		expect(results[0].score).toBeGreaterThan(0);
+		expect(results[0].score).toBeLessThanOrEqual(1);
+	});
+
+	it('returns results with all DocChunk fields', async () => {
+		store = new SqliteStore({ dbPath: ':memory:' });
+		await store.index(sampleChunks());
+
+		const results = await store.search('deploy');
+		expect(results.length).toBeGreaterThan(0);
+		const first = results[0];
+		expect(first).toHaveProperty('pageId');
+		expect(first).toHaveProperty('pageTitle');
+		expect(first).toHaveProperty('sectionHeading');
+		expect(first).toHaveProperty('sectionAnchor');
+		expect(first).toHaveProperty('content');
+		expect(first).toHaveProperty('score');
+	});
+
+	it('respects the limit parameter', async () => {
+		store = new SqliteStore({ dbPath: ':memory:' });
+		await store.index(sampleChunks());
+
+		const results = await store.search('docs', 2);
+		expect(results.length).toBeLessThanOrEqual(2);
+	});
+
+	it('returns scores normalized to 0–1 with top result at 1', async () => {
+		store = new SqliteStore({ dbPath: ':memory:' });
+		await store.index(sampleChunks());
+
+		const results = await store.search('static hosting deploy');
+		expect(results.length).toBeGreaterThan(0);
+		expect(results[0].score).toBe(1);
+		for (const r of results) {
+			expect(r.score).toBeGreaterThan(0);
+			expect(r.score).toBeLessThanOrEqual(1);
+		}
+	});
+
+	it('returns empty for queries with no matching terms', async () => {
+		store = new SqliteStore({ dbPath: ':memory:' });
+		await store.index(sampleChunks());
+
+		const results = await store.search('xyznonexistent');
+		expect(results).toEqual([]);
+	});
+
+	it('re-indexes correctly (replaces old data)', async () => {
+		store = new SqliteStore({ dbPath: ':memory:' });
+		await store.index(sampleChunks());
+		expect(store.size()).toBe(5);
+
+		// Re-index with fewer chunks
+		await store.index([sampleChunks()[0]]);
+		expect(store.size()).toBe(1);
+
+		const results = await store.search('deploy');
+		expect(results).toEqual([]);
+	});
+
+	it('handles queries with special characters gracefully', async () => {
+		store = new SqliteStore({ dbPath: ':memory:' });
+		await store.index(sampleChunks());
+
+		// Should not throw — special chars are escaped
+		const results = await store.search('"routing" OR "deploy"');
+		expect(Array.isArray(results)).toBe(true);
+	});
+
+	it('searches across title, heading, and content', async () => {
+		store = new SqliteStore({ dbPath: ':memory:' });
+		await store.index(sampleChunks());
+
+		// "Localization" appears only in pageTitle
+		const byTitle = await store.search('Localization');
+		expect(byTitle.length).toBeGreaterThan(0);
+		expect(byTitle[0].pageId).toBe('/docs/guide/localization');
+
+		// "BM25" appears only in content
+		const byContent = await store.search('BM25');
+		expect(byContent.length).toBeGreaterThan(0);
+		expect(byContent[0].pageId).toBe('/docs/reference/search');
+	});
+
+	it('works with non-ASCII content (Polish)', async () => {
+		store = new SqliteStore({ dbPath: ':memory:' });
+		await store.index(sampleChunks());
+
+		const results = await store.search('dynamiczne trasy');
+		expect(results.length).toBeGreaterThan(0);
+		expect(results[0].pageId).toBe('/pl/docs/guide/routing');
+	});
+});
+
+describe('SqliteStore hybrid search (with mock embeddings)', () => {
+	/** @type {SqliteStore | null} */
+	let store = null;
+
+	afterEach(() => {
+		if (store) {
+			store.close();
+			store = null;
+		}
+	});
+
+	it('falls back to BM25-only when provider has no embed()', async () => {
+		const mockProvider = {
+			name: 'mock',
+			chat: vi.fn(),
+			isAvailable: vi.fn().mockResolvedValue(true),
+			// No embed method
+		};
+
+		store = new SqliteStore({
+			dbPath: ':memory:',
+			provider: mockProvider,
+			embeddingDimensions: 0, // No vector search
+		});
+
+		await store.index(sampleChunks());
+		const results = await store.search('routing');
+		expect(results.length).toBeGreaterThan(0);
+		// Both EN and PL routing pages match — just verify it finds something relevant
+		expect(results.some(r => r.pageId.includes('routing'))).toBe(true);
+	});
+});

package/src/lib/MarkdownDocs/__tests__/useRouter.test.js

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import { buildNavigationUrl, isSameNavigationTarget } from '../useRouter.svelte.ts';
+
+describe('useRouter helpers', () => {
+	it('builds URL with normalized path and optional hash', () => {
+		expect(buildNavigationUrl('/docs/guide/', 'intro')).toBe('/docs/guide#intro');
+		expect(buildNavigationUrl('/docs/guide', '#intro')).toBe('/docs/guide#intro');
+		expect(buildNavigationUrl('/docs/guide/', '')).toBe('/docs/guide');
+	});
+
+	it('treats same path with different hash as a different navigation target', () => {
+		expect(isSameNavigationTarget('/docs/guide', '', '/docs/guide', 'intro')).toBe(false);
+		expect(isSameNavigationTarget('/docs/guide', '#overview', '/docs/guide', 'intro')).toBe(false);
+		expect(isSameNavigationTarget('/docs/guide', '#intro', '/docs/guide', 'intro')).toBe(true);
+	});
+});

package/src/lib/MarkdownDocs/ai/adapters/customAdapter.js

@@ -0,0 +1,14 @@
+export class CustomAdapter {
+	constructor(fn) {
+		this.name = 'custom';
+		this.fn = fn;
+	}
+
+	chat(messages, options) {
+		return this.fn(messages, options);
+	}
+
+	async isAvailable() {
+		return true;
+	}
+}

package/src/lib/MarkdownDocs/ai/adapters/customAdapter.ts

@@ -0,0 +1,43 @@
+import type { AiProvider } from '../aiProvider.js';
+import type { AiProviderOptions, ChatMessage } from '../types.js';
+
+/**
+ * A user-provided async function that implements the LLM call.
+ * Mirrors the `search.provider: "custom"` pattern from the search system.
+ */
+export type CustomProviderFn = (
+	messages: ChatMessage[],
+	options?: AiProviderOptions,
+) => Promise<string>;
+
+/**
+ * Thin wrapper that turns any async function into an AiProvider.
+ *
+ * Usage in greg.config.js:
+ *   search: {
+ *     ai: {
+ *       enabled: true,
+ *       provider: 'custom',
+ *       customProvider: async (messages, opts) => {
+ *         // call your own LLM backend
+ *         return "answer text";
+ *       }
+ *     }
+ *   }
+ */
+export class CustomAdapter implements AiProvider {
+	readonly name = 'custom';
+	private readonly fn: CustomProviderFn;
+
+	constructor(fn: CustomProviderFn) {
+		this.fn = fn;
+	}
+
+	chat(messages: ChatMessage[], options?: AiProviderOptions): Promise<string> {
+		return this.fn(messages, options);
+	}
+
+	async isAvailable(): Promise<boolean> {
+		return true;
+	}
+}

package/src/lib/MarkdownDocs/ai/adapters/ollamaAdapter.js

@@ -0,0 +1,81 @@
+export class OllamaAdapter {
+	constructor(options = {}) {
+		this.name = 'ollama';
+		this.baseUrl = (options.baseUrl ?? 'http://localhost:11434').replace(/\/$/, '');
+		this.model = options.model ?? 'llama3.2';
+		this.embeddingModel = options.embeddingModel !== undefined
+			? (options.embeddingModel ?? null)
+			: 'nomic-embed-text';
+		this.timeout = options.timeout ?? 60000;
+	}
+
+	async chat(messages, options) {
+		const body = JSON.stringify({
+			model: options?.model ?? this.model,
+			messages,
+			stream: false,
+			options: {
+				temperature: options?.temperature ?? 0.3,
+				...(options?.maxTokens ? { num_predict: options.maxTokens } : {}),
+			},
+		});
+
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), this.timeout);
+		let response;
+		try {
+			response = await fetch(`${this.baseUrl}/api/chat`, {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body,
+				signal: controller.signal,
+			});
+		} finally {
+			clearTimeout(timer);
+		}
+
+		if (!response.ok) {
+			const text = await response.text().catch(() => '');
+			throw new Error(`Ollama chat error ${response.status}: ${text}`);
+		}
+
+		const data = await response.json();
+		if (data.error) throw new Error(`Ollama error: ${data.error}`);
+		return data.message?.content ?? '';
+	}
+
+	async embed(texts) {
+		if (!this.embeddingModel) {
+			throw new Error('OllamaAdapter: embeddingModel is disabled (null). Set embeddingModel to use embeddings.');
+		}
+
+		const results = [];
+		for (const text of texts) {
+			const response = await fetch(`${this.baseUrl}/api/embed`, {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({ model: this.embeddingModel, input: text }),
+			});
+			if (!response.ok) {
+				const err = await response.text().catch(() => '');
+				throw new Error(`Ollama embed error ${response.status}: ${err}`);
+			}
+			const data = await response.json();
+			results.push(data.embeddings?.[0] ?? []);
+		}
+		return results;
+	}
+
+	async isAvailable() {
+		try {
+			const controller = new AbortController();
+			setTimeout(() => controller.abort(), 3000);
+			const response = await fetch(`${this.baseUrl}/api/tags`, {
+				signal: controller.signal,
+			});
+			return response.ok;
+		} catch {
+			return false;
+		}
+	}
+}

package/src/lib/MarkdownDocs/ai/adapters/ollamaAdapter.ts

@@ -0,0 +1,116 @@
+import type { AiProvider } from '../aiProvider.js';
+import type { AiProviderOptions, ChatMessage } from '../types.js';
+
+export type OllamaAdapterOptions = {
+	/** Base URL of the Ollama service. Default: http://localhost:11434 */
+	baseUrl?: string;
+	/** Chat model to use. Default: llama3.2 */
+	model?: string;
+	/**
+	 * Embedding model to use for dense retrieval.
+	 * Set to null to disable embeddings (BM25-only mode).
+	 * Default: nomic-embed-text
+	 */
+	embeddingModel?: string | null;
+	/** Request timeout in milliseconds. Default: 60_000 */
+	timeout?: number;
+};
+
+/**
+ * Adapter for Ollama — a local LLM runtime.
+ * https://ollama.com
+ *
+ * Requires Ollama to be running locally. Pull a model before use:
+ *   ollama pull llama3.2
+ *   ollama pull nomic-embed-text   (for semantic search)
+ */
+export class OllamaAdapter implements AiProvider {
+	readonly name = 'ollama';
+	private readonly baseUrl: string;
+	private readonly model: string;
+	private readonly embeddingModel: string | null;
+	private readonly timeout: number;
+
+	constructor(options: OllamaAdapterOptions = {}) {
+		this.baseUrl = (options.baseUrl ?? 'http://localhost:11434').replace(/\/$/, '');
+		this.model = options.model ?? 'llama3.2';
+		this.embeddingModel = options.embeddingModel !== undefined
+			? (options.embeddingModel ?? null)
+			: 'nomic-embed-text';
+		this.timeout = options.timeout ?? 60_000;
+	}
+
+	async chat(messages: ChatMessage[], options?: AiProviderOptions): Promise<string> {
+		const body = JSON.stringify({
+			model: options?.model ?? this.model,
+			messages,
+			stream: false,
+			options: {
+				temperature: options?.temperature ?? 0.3,
+				...(options?.maxTokens ? { num_predict: options.maxTokens } : {}),
+			},
+		});
+
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), this.timeout);
+		let response: Response;
+		try {
+			response = await fetch(`${this.baseUrl}/api/chat`, {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body,
+				signal: controller.signal,
+			});
+		} finally {
+			clearTimeout(timer);
+		}
+
+		if (!response.ok) {
+			const text = await response.text().catch(() => '');
+			throw new Error(`Ollama chat error ${response.status}: ${text}`);
+		}
+
+		const data = await response.json() as {
+			message?: { content?: string };
+			error?: string;
+		};
+
+		if (data.error) throw new Error(`Ollama error: ${data.error}`);
+		return data.message?.content ?? '';
+	}
+
+	async embed(texts: string[]): Promise<number[][]> {
+		if (!this.embeddingModel) {
+			throw new Error('OllamaAdapter: embeddingModel is disabled (null). Set embeddingModel to use embeddings.');
+		}
+
+		const results: number[][] = [];
+		for (const text of texts) {
+			const response = await fetch(`${this.baseUrl}/api/embed`, {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({ model: this.embeddingModel, input: text }),
+			});
+			if (!response.ok) {
+				const err = await response.text().catch(() => '');
+				throw new Error(`Ollama embed error ${response.status}: ${err}`);
+			}
+			const data = await response.json() as { embeddings?: number[][] };
+			results.push(data.embeddings?.[0] ?? []);
+		}
+		return results;
+	}
+
+	async isAvailable(): Promise<boolean> {
+		try {
+			const controller = new AbortController();
+			setTimeout(() => controller.abort(), 3_000);
+			const response = await fetch(`${this.baseUrl}/api/tags`, {
+				signal: controller.signal,
+			});
+			return response.ok;
+		} catch {
+			return false;
+		}
+	}
+}