browzy 1.0.0

package/dist/core/lint/linter.js

@@ -0,0 +1,147 @@
+import { FilesystemStorage } from '../storage/filesystem.js';
+import { LINTER_SYSTEM_PROMPT } from '../prompts.js';
+export class WikiLinter {
+    fs;
+    llm;
+    constructor(dataDir, llm) {
+        this.fs = new FilesystemStorage(dataDir);
+        this.llm = llm;
+    }
+    /**
+     * Run all lint checks on the wiki.
+     */
+    async lint() {
+        const articles = this.fs.listArticles();
+        const issues = [];
+        issues.push(...this.checkBrokenLinks(articles));
+        issues.push(...this.checkOrphanArticles(articles));
+        issues.push(...this.checkMissingFields(articles));
+        issues.push(...await this.checkConsistency(articles));
+        return issues;
+    }
+    /**
+     * Check for [[wiki-links]] that point to non-existent articles.
+     */
+    checkBrokenLinks(articles) {
+        const slugs = new Set(articles.map(a => a.slug));
+        const issues = [];
+        for (const article of articles) {
+            const links = article.content.match(/\[\[([^\]]+)\]\]/g) || [];
+            for (const link of links) {
+                const target = link.slice(2, -2).trim();
+                if (!slugs.has(target)) {
+                    issues.push({
+                        severity: 'warning',
+                        article: article.slug,
+                        message: `Broken wiki link: [[${target}]]`,
+                        suggestion: `Create article "${target}" or fix the link`,
+                    });
+                }
+            }
+        }
+        return issues;
+    }
+    /**
+     * Find articles with no incoming links (orphans).
+     */
+    checkOrphanArticles(articles) {
+        const linked = new Set();
+        for (const article of articles) {
+            const links = article.content.match(/\[\[([^\]]+)\]\]/g) || [];
+            for (const link of links) {
+                linked.add(link.slice(2, -2).trim());
+            }
+        }
+        return articles
+            .filter(a => !linked.has(a.slug) && a.frontmatter.backlinks.length === 0)
+            .map(a => ({
+            severity: 'suggestion',
+            article: a.slug,
+            message: 'Orphan article — no other articles link to this one',
+            suggestion: 'Add links from related articles or merge into a broader article',
+        }));
+    }
+    /**
+     * Check for missing frontmatter fields.
+     */
+    checkMissingFields(articles) {
+        const issues = [];
+        for (const article of articles) {
+            const fm = article.frontmatter;
+            if (!fm.summary) {
+                issues.push({
+                    severity: 'warning',
+                    article: article.slug,
+                    message: 'Missing summary in frontmatter',
+                });
+            }
+            if (!fm.tags || fm.tags.length === 0) {
+                issues.push({
+                    severity: 'warning',
+                    article: article.slug,
+                    message: 'No tags assigned',
+                });
+            }
+            if (!fm.sources || fm.sources.length === 0) {
+                issues.push({
+                    severity: 'suggestion',
+                    article: article.slug,
+                    message: 'No source references',
+                });
+            }
+        }
+        return issues;
+    }
+    /**
+     * Use LLM to check for inconsistencies, duplicates, and gaps.
+     */
+    async checkConsistency(articles) {
+        if (articles.length < 2)
+            return [];
+        const summaries = articles
+            .map(a => `- ${a.slug}: ${a.frontmatter.title} — ${a.frontmatter.summary || '(no summary)'}`)
+            .join('\n');
+        const response = await this.llm.chat([
+            {
+                role: 'user',
+                content: `Review this wiki for issues. Check for:
+1. Contradictory information between articles
+2. Duplicate/overlapping articles that should be merged
+3. Notable gaps in coverage
+4. Inconsistent terminology
+
+ARTICLES:
+${summaries}
+
+Output a JSON array of objects with "severity" (error/warning/suggestion), "article" (slug), "message", and optional "suggestion" fields. If no issues found, output [].`,
+            },
+        ], {
+            system: LINTER_SYSTEM_PROMPT,
+            maxTokens: 2048,
+        });
+        try {
+            const jsonMatch = response.content.match(/\[[\s\S]*\]/);
+            if (!jsonMatch)
+                return [];
+            const parsed = JSON.parse(jsonMatch[0]);
+            if (!Array.isArray(parsed))
+                return [];
+            const validSeverities = new Set(['error', 'warning', 'suggestion']);
+            return parsed
+                .filter((item) => typeof item === 'object' && item !== null &&
+                typeof item.severity === 'string' &&
+                typeof item.article === 'string' &&
+                typeof item.message === 'string' &&
+                validSeverities.has(item.severity))
+                .map((item) => ({
+                severity: item.severity,
+                article: String(item.article),
+                message: String(item.message),
+                suggestion: typeof item.suggestion === 'string' ? item.suggestion : undefined,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/dist/core/llm/index.d.ts

@@ -0,0 +1,2 @@
+export { createProvider } from './provider.js';
+export type { LLMProvider, ChatOptions, StreamChunk } from './provider.js';

package/dist/core/llm/index.js

@@ -0,0 +1 @@
+export { createProvider } from './provider.js';

package/dist/core/llm/provider.d.ts

@@ -0,0 +1,15 @@
+import type { LLMConfig, LLMMessage, LLMResponse } from '../types.js';
+export interface LLMProvider {
+    chat(messages: LLMMessage[], options?: ChatOptions): Promise<LLMResponse>;
+    stream(messages: LLMMessage[], options?: ChatOptions): AsyncIterable<StreamChunk>;
+}
+export interface ChatOptions {
+    maxTokens?: number;
+    temperature?: number;
+    system?: string;
+}
+export interface StreamChunk {
+    delta: string;
+    snapshot: string;
+}
+export declare function createProvider(config: LLMConfig): LLMProvider;

package/dist/core/llm/provider.js

@@ -0,0 +1,241 @@
+const MAX_RETRIES = 3;
+const BASE_DELAY_MS = 1000;
+function sanitizeError(err, provider) {
+    const message = typeof err?.message === 'string' ? err.message : String(err);
+    // Strip anything that looks like an API key from error messages
+    const cleaned = message.replace(/sk-[a-zA-Z0-9_-]{20,}/g, 'sk-***');
+    const error = new Error(`${provider}: ${cleaned}`);
+    if (typeof err?.status === 'number') {
+        error.status = err.status;
+    }
+    return error;
+}
+function getRetryDelay(attempt, retryAfterHeader) {
+    if (retryAfterHeader) {
+        const seconds = parseInt(retryAfterHeader, 10);
+        if (!isNaN(seconds) && seconds > 0)
+            return seconds * 1000;
+    }
+    // Exponential backoff with jitter: 1s, 2s, 4s (capped)
+    const base = Math.min(BASE_DELAY_MS * Math.pow(2, attempt), 16_000);
+    return base + Math.random() * 0.25 * base;
+}
+export function createProvider(config) {
+    switch (config.provider) {
+        case 'claude':
+            return new ClaudeProvider(config);
+        case 'openai':
+            return new OpenAIProvider(config);
+        case 'openrouter':
+            return new OpenRouterProvider(config);
+        default:
+            throw new Error(`Unknown LLM provider: ${config.provider}`);
+    }
+}
+class ClaudeProvider {
+    config;
+    constructor(config) {
+        this.config = config;
+        if (!config.apiKey) {
+            throw new Error('Claude API key required. Set ANTHROPIC_API_KEY or configure in browzy.config.json');
+        }
+    }
+    async chat(messages, options) {
+        const { default: Anthropic } = await import('@anthropic-ai/sdk');
+        const client = new Anthropic({ apiKey: this.config.apiKey });
+        const systemMsg = options?.system ?? messages.find(m => m.role === 'system')?.content;
+        const nonSystemMessages = messages
+            .filter(m => m.role !== 'system')
+            .map(m => ({ role: m.role, content: m.content }));
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                const response = await client.messages.create({
+                    model: this.config.model || 'claude-sonnet-4-20250514',
+                    max_tokens: options?.maxTokens ?? 4096,
+                    ...(systemMsg ? { system: systemMsg } : {}),
+                    messages: nonSystemMessages,
+                });
+                const textBlock = response.content.find(b => b.type === 'text');
+                return {
+                    content: textBlock?.text ?? '',
+                    usage: {
+                        inputTokens: response.usage.input_tokens,
+                        outputTokens: response.usage.output_tokens,
+                    },
+                };
+            }
+            catch (err) {
+                if (err.status === 429 && attempt < MAX_RETRIES) {
+                    const delay = getRetryDelay(attempt, err.headers?.get?.('retry-after'));
+                    await new Promise(r => setTimeout(r, delay));
+                    continue;
+                }
+                throw sanitizeError(err, 'Claude');
+            }
+        }
+        throw new Error('Unreachable');
+    }
+    async *stream(messages, options) {
+        const { default: Anthropic } = await import('@anthropic-ai/sdk');
+        const client = new Anthropic({ apiKey: this.config.apiKey });
+        const systemMsg = options?.system ?? messages.find(m => m.role === 'system')?.content;
+        const nonSystemMessages = messages
+            .filter(m => m.role !== 'system')
+            .map(m => ({ role: m.role, content: m.content }));
+        const stream = client.messages.stream({
+            model: this.config.model || 'claude-sonnet-4-20250514',
+            max_tokens: options?.maxTokens ?? 4096,
+            ...(systemMsg ? { system: systemMsg } : {}),
+            messages: nonSystemMessages,
+        });
+        let accumulated = '';
+        for await (const event of stream) {
+            if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
+                accumulated += event.delta.text;
+                yield { delta: event.delta.text, snapshot: accumulated };
+            }
+        }
+    }
+}
+class OpenAIProvider {
+    config;
+    constructor(config) {
+        this.config = config;
+        if (!config.apiKey) {
+            throw new Error('OpenAI API key required. Set OPENAI_API_KEY or configure in browzy.config.json');
+        }
+    }
+    async chat(messages, options) {
+        const { default: OpenAI } = await import('openai');
+        const client = new OpenAI({ apiKey: this.config.apiKey });
+        const allMessages = options?.system
+            ? [{ role: 'system', content: options.system }, ...messages.filter(m => m.role !== 'system')]
+            : messages;
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                const response = await client.chat.completions.create({
+                    model: this.config.model || 'gpt-4o',
+                    max_tokens: options?.maxTokens ?? 4096,
+                    messages: allMessages.map(m => ({ role: m.role, content: m.content })),
+                });
+                return {
+                    content: response.choices[0]?.message?.content ?? '',
+                    usage: response.usage
+                        ? {
+                            inputTokens: response.usage.prompt_tokens,
+                            outputTokens: response.usage.completion_tokens ?? 0,
+                        }
+                        : undefined,
+                };
+            }
+            catch (err) {
+                if (err.status === 429 && attempt < MAX_RETRIES) {
+                    const delay = getRetryDelay(attempt, err.headers?.get?.('retry-after'));
+                    await new Promise(r => setTimeout(r, delay));
+                    continue;
+                }
+                throw sanitizeError(err, 'OpenAI');
+            }
+        }
+        throw new Error('Unreachable');
+    }
+    async *stream(messages, options) {
+        const { default: OpenAI } = await import('openai');
+        const client = new OpenAI({ apiKey: this.config.apiKey });
+        const allMessages = options?.system
+            ? [{ role: 'system', content: options.system }, ...messages.filter(m => m.role !== 'system')]
+            : messages;
+        const response = await client.chat.completions.create({
+            model: this.config.model || 'gpt-4o',
+            max_tokens: options?.maxTokens ?? 4096,
+            stream: true,
+            messages: allMessages.map(m => ({ role: m.role, content: m.content })),
+        });
+        let accumulated = '';
+        for await (const chunk of response) {
+            const delta = chunk.choices[0]?.delta?.content;
+            if (delta) {
+                accumulated += delta;
+                yield { delta, snapshot: accumulated };
+            }
+        }
+    }
+}
+/**
+ * OpenRouter provider — uses OpenAI-compatible API with openrouter.ai base URL.
+ * Gives access to Claude, GPT-4o, Gemini, Llama, Mistral, and 200+ models.
+ * Set OPENROUTER_API_KEY or configure apiKey in browzy.config.json.
+ */
+class OpenRouterProvider {
+    config;
+    constructor(config) {
+        this.config = config;
+        if (!config.apiKey) {
+            throw new Error('OpenRouter API key required. Set OPENROUTER_API_KEY or configure in browzy.config.json');
+        }
+    }
+    async getClient() {
+        const { default: OpenAI } = await import('openai');
+        return new OpenAI({
+            apiKey: this.config.apiKey,
+            baseURL: 'https://openrouter.ai/api/v1',
+            defaultHeaders: {
+                'HTTP-Referer': 'https://browzy.ai',
+                'X-Title': 'browzy.ai',
+            },
+        });
+    }
+    async chat(messages, options) {
+        const client = await this.getClient();
+        const allMessages = options?.system
+            ? [{ role: 'system', content: options.system }, ...messages.filter(m => m.role !== 'system')]
+            : messages;
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                const response = await client.chat.completions.create({
+                    model: this.config.model || 'anthropic/claude-sonnet-4',
+                    max_tokens: options?.maxTokens ?? 4096,
+                    messages: allMessages.map(m => ({ role: m.role, content: m.content })),
+                });
+                return {
+                    content: response.choices[0]?.message?.content ?? '',
+                    usage: response.usage
+                        ? {
+                            inputTokens: response.usage.prompt_tokens,
+                            outputTokens: response.usage.completion_tokens ?? 0,
+                        }
+                        : undefined,
+                };
+            }
+            catch (err) {
+                if (err.status === 429 && attempt < MAX_RETRIES) {
+                    const delay = getRetryDelay(attempt, err.headers?.get?.('retry-after'));
+                    await new Promise(r => setTimeout(r, delay));
+                    continue;
+                }
+                throw sanitizeError(err, 'OpenRouter');
+            }
+        }
+        throw new Error('Unreachable');
+    }
+    async *stream(messages, options) {
+        const client = await this.getClient();
+        const allMessages = options?.system
+            ? [{ role: 'system', content: options.system }, ...messages.filter(m => m.role !== 'system')]
+            : messages;
+        const response = await client.chat.completions.create({
+            model: this.config.model || 'anthropic/claude-sonnet-4',
+            max_tokens: options?.maxTokens ?? 4096,
+            stream: true,
+            messages: allMessages.map(m => ({ role: m.role, content: m.content })),
+        });
+        let accumulated = '';
+        for await (const chunk of response) {
+            const delta = chunk.choices[0]?.delta?.content;
+            if (delta) {
+                accumulated += delta;
+                yield { delta, snapshot: accumulated };
+            }
+        }
+    }
+}

package/dist/core/prompts.d.ts

@@ -0,0 +1,28 @@
+/**
+ * browzy.ai — System prompts.
+ *
+ * Architecture follows Claude Code's pattern: multi-section prompts
+ * assembled from focused functions. Each section is independently
+ * testable and the order matters for prompt cache efficiency.
+ *
+ * Sections:
+ * 1. Identity & role
+ * 2. Knowledge base context rules
+ * 3. Citation & attribution
+ * 4. Formatting & output
+ * 5. Math & technical content
+ * 6. Limitations & honesty
+ * 7. Tone & style
+ * 8. Anti-patterns (what NOT to do)
+ */
+export declare const QUERY_SYSTEM_PROMPT: string;
+export declare const COMPILER_SYSTEM_PROMPT = "You are browzy's wiki compiler. Your job is to transform raw source material into well-structured, interconnected wiki articles that serve as a persistent knowledge base.\n\n# Your task\n\nYou receive raw ingested content (web articles, PDFs, notes, research papers, transcripts) and must compile it into wiki articles that integrate with the user's existing knowledge base. This is the core value of browzy \u2014 the quality of the wiki depends entirely on how well you compile.\n\n# Article quality standards\n\n1. **Write encyclopedic prose, not summaries.** Don't just say \"this paper discusses X.\" Extract the key information, present it clearly, and connect it to existing knowledge. The article should be useful to someone who hasn't read the source.\n\n2. **Preserve specifics.** Numbers, dates, formulas, code snippets, direct quotes, experimental results, data points. A wiki that loses specifics is useless for research. If the source says \"accuracy improved from 94.2% to 97.1%\", keep those numbers.\n\n3. **Use proper formatting:**\n   - Headers (##, ###) for logical sections\n   - Bold for key terms being defined\n   - Bullet lists for enumerations and properties\n   - Code blocks for code, commands, and algorithms\n   - LaTeX for math: $\\alpha$, $$\\sum_{i=1}^n x_i$$\n   - Tables for structured data and comparisons\n\n4. **Create cross-references** using [[article-slug]] wiki-link syntax. Every article should link to at least 2-3 other related articles. If a related article doesn't exist yet, still create the link \u2014 it signals a gap in coverage.\n\n5. **Cite sources** using [source-id] notation so every claim is traceable back to its origin. This is critical for research credibility.\n\n6. **Extract and name key concepts.** If the source introduces important terms, definitions, theorems, algorithms, or frameworks, make them prominent. These become the skeleton of the wiki that other articles reference.\n\n7. **Avoid redundancy.** If an existing article already covers a topic, merge the new information into it rather than creating a duplicate. Update the existing article's content, add the new source to its citations, and strengthen the existing structure.\n\n8. **Write for future queries.** The articles you write will be searched and retrieved to answer questions. Include enough context and keywords that relevant searches will find the right articles. A well-indexed wiki is one where article titles, headers, and opening paragraphs contain the terms a user would search for.\n\n# What makes a bad wiki article\n\n- Too short (under 200 words) \u2014 probably needs more detail\n- No cross-references \u2014 orphaned knowledge is wasted knowledge\n- No source citations \u2014 untraceable claims\n- Generic overview that ignores specific data from the source\n- Duplicate of an existing article under a different slug\n- Missing the \"so what\" \u2014 lists facts without explaining their significance";
+export declare const LINTER_SYSTEM_PROMPT = "You are browzy's wiki quality auditor. Your job is to find real problems in the knowledge base \u2014 not style preferences, not nitpicks, but issues that would cause a researcher to get wrong answers, miss connections, or waste time.\n\n# What to check\n\n1. **Contradictions.** Do any articles make conflicting factual claims? This is the most serious issue. Flag with specific quotes from both articles so the user can resolve the conflict.\n\n2. **Duplicates.** Are there articles covering substantially the same topic under different slugs? If \"neural-networks\" and \"artificial-neural-networks\" both exist with similar content, one should be merged into the other.\n\n3. **Terminology inconsistency.** Is the same concept called different things in different articles? If one article says \"feature vectors\" and another says \"embeddings\" for the same concept, flag it.\n\n4. **Broken references.** Are there [[wiki-links]] pointing to articles that don't exist? Are there [source-id] citations with no matching source? These indicate incomplete compilation.\n\n5. **Coverage gaps.** Based on the pattern of existing articles, what obvious related topics are missing? If the wiki has articles on \"transformers\", \"attention-mechanism\", and \"BERT\" but no \"GPT\" article, that's a gap worth flagging.\n\n6. **Stale or thin content.** Articles under 100 words, articles with no source citations, articles that are just a title and one sentence. These need expansion.\n\n7. **Orphan articles.** Articles with no incoming links from other articles. These are isolated knowledge that should be connected to the rest of the wiki.\n\n# Output format\n\nReturn a JSON array of issue objects. Each must have:\n- \"severity\": \"error\" (contradictions, broken facts) | \"warning\" (duplicates, inconsistencies, quality issues) | \"suggestion\" (gaps, enhancements)\n- \"article\": the slug of the affected article\n- \"message\": clear, specific description of the issue\n- \"suggestion\": (optional) concrete recommendation for how to fix it\n\nIf no issues are found, return [].\n\n# Rules\n- Be precise. \"Article X contradicts article Y on the value of Z\" is useful. \"Some articles could be improved\" is not.\n- Only flag real issues. Don't generate issues to look thorough.\n- Prioritize by impact. Contradictions > duplicates > gaps > style.";
+export declare const CONCEPT_EXTRACTION_PROMPT = "Given the existing wiki articles below, suggest new concept articles that would improve the wiki's coverage, depth, and interconnectedness.\n\nFocus on:\n- **Bridging concepts** \u2014 topics that would connect two or more currently disconnected article clusters. If the wiki has articles on \"deep learning\" and \"drug discovery\" but nothing connecting them, \"AI for drug discovery\" is a valuable bridge.\n- **Foundational concepts** \u2014 terms and frameworks that existing articles reference or assume but don't define. If multiple articles mention \"gradient descent\" but there's no article for it, that's a gap.\n- **Missing counterparts** \u2014 if the wiki has \"supervised learning\" but not \"unsupervised learning\", the counterpart is worth suggesting.\n\nDo NOT suggest:\n- Obvious padding (articles that would just be a sentence or two)\n- Topics that overlap heavily with existing articles\n- Meta-articles about the wiki itself\n\nOutput a JSON array of objects with \"slug\", \"title\", and \"reason\" fields. The reason should explain which existing articles this new article would connect and why it matters. Output 3-5 suggestions max.";
+export declare const IMAGE_DESCRIPTION_PROMPT = "You are analyzing an image for indexing in a research knowledge base. Your description will be used for search, retrieval, and cross-referencing with wiki articles.\n\nDescribe systematically:\n\n1. **Text and labels.** Transcribe ALL visible text, annotations, axis labels, legends, titles, and captions exactly as they appear.\n\n2. **Visual structure.** For diagrams: describe nodes, edges, flow direction, and what each element represents. For charts: describe type (bar, line, scatter, etc.), axes, scales, and data trends. For tables: transcribe the data. For photos: describe subject, setting, and notable details.\n\n3. **Data and quantities.** Extract any numbers, percentages, dates, measurements, or statistical values visible in the image. Be precise \u2014 \"approximately 95%\" is better than \"high accuracy.\"\n\n4. **Equations and formulas.** Transcribe in LaTeX notation: $E = mc^2$, $\\frac{\\partial f}{\\partial x}$, etc.\n\n5. **Context clues.** Note any logos, watermarks, publication info, or source attribution visible in the image.\n\n6. **Research relevance.** In one sentence, state what this image is primarily showing or proving \u2014 this helps with search relevance.\n\nBe factual and specific. Don't interpret beyond what's visible. Don't add opinions or evaluations.";
+export declare const SEARCH_EXTRACTION_PROMPT = "You are a search query optimizer for a personal knowledge base wiki. Given a user's natural language question, extract the best search terms to find relevant wiki articles.\n\n# Your task\n\nThe wiki uses SQLite FTS5 full-text search. Your extracted terms will be used to query an index of article titles, summaries, tags, and content. The better your terms, the more relevant articles the user sees.\n\n# Rules\n\n1. Extract 3-5 key search terms from the question.\n2. Prefer specific nouns, proper names, and technical terms over generic words.\n3. Include both the exact terms used AND likely synonyms. If the user asks about \"neural nets\", also include \"neural networks\".\n4. Drop stop words (the, is, a, what, how, why, can, does) \u2014 they waste search capacity.\n5. If the question references a specific paper, person, theorem, or algorithm by name, that name should be the first search term.\n6. Consider the domain: in a research wiki, \"attention\" likely means \"attention mechanism\" not \"paying attention.\"\n\n# Output format\n\nOutput only the search terms, one per line. No numbering, no explanation, no formatting. Just the terms.\n\n# Examples\n\nQuestion: \"What did the 2017 Vaswani paper say about multi-head attention?\"\n\u2192 Vaswani\n\u2192 multi-head attention\n\u2192 attention mechanism\n\u2192 transformer\n\nQuestion: \"How does Helly's theorem relate to convex optimization?\"\n\u2192 Helly's theorem\n\u2192 convex optimization\n\u2192 convex geometry\n\u2192 intersection";
+export declare const CONTRADICTION_HANDLING_PROMPT = "When new source material contradicts information already in the wiki, follow this protocol:\n\n1. **Never silently override.** If the new source says X but the existing wiki says Y, don't just replace Y with X. Both may be partially correct, or the difference may reflect different contexts, time periods, or methodologies.\n\n2. **Present both views.** Update the article to acknowledge the discrepancy:\n   - \"According to [source-A], the value is X. However, [source-B] reports Y, possibly due to [methodological differences / different datasets / updated findings].\"\n\n3. **Flag for review.** Add a note that the user should review: \"**Note:** Sources disagree on this point \u2014 see [source-A] vs [source-B].\"\n\n4. **Prefer more recent sources** when the contradiction is clearly temporal (e.g., a 2024 paper superseding a 2019 result), but still preserve the historical context.\n\n5. **Prefer primary sources** over secondary sources when both are available.\n\n6. **Never resolve contradictions by omission** \u2014 dropping one source's claim to avoid the conflict is worse than presenting both.";
+export declare const CONVERSATION_CONTEXT_PROMPT = "# Conversation continuity\n\nYou are in a multi-turn conversation. The user may ask follow-up questions that reference previous answers.\n\nRules:\n- **Resolve pronouns.** If the user says \"tell me more about that\" or \"what's the connection to the previous topic\", refer back to the conversation history to understand what \"that\" or \"the previous topic\" refers to.\n- **Build on prior answers.** Don't repeat information you already provided. If you explained concept X in turn 1 and the user asks about X's relationship to Y in turn 2, reference your earlier explanation rather than restating it.\n- **Track the research thread.** The user is often following a line of inquiry. If they asked about transformers, then attention, then positional encoding \u2014 they're drilling deeper into the same topic tree. Use this to provide more targeted, deeper answers.\n- **Remember corrections.** If the user corrected you or clarified something, don't revert to your original (wrong) answer in subsequent turns.\n- **Don't assume topic changes.** Unless the user explicitly switches topics, assume follow-up questions relate to the current thread. \"What about efficiency?\" after discussing transformers means transformer efficiency, not efficiency in general.";
+export declare const ARTICLE_OUTPUT_FORMAT = "# Output format\n\nOutput one or more articles in this EXACT format. The parser depends on these markers:\n\n===ARTICLE===\nSLUG: lowercase-hyphenated-slug (max 80 chars, a-z 0-9 hyphens only)\nTITLE: Human-Readable Article Title\nTAGS: tag1, tag2, tag3 (comma-separated, lowercase)\nSUMMARY: One-sentence summary of the article content. This appears in the wiki index and is used for search.\n---\nArticle content in markdown here. Use ## and ### headers for sections.\n\nInclude [[cross-references]] to other articles.\nCite sources with [source-id] notation.\nUse LaTeX for math: $\\alpha$, $$\\sum_{i=1}^n x_i$$.\n\nContent should be 200-1000 words for a focused topic.\n===END===\n\nRules for slugs:\n- Use lowercase letters, numbers, and hyphens only\n- Descriptive but concise: \"transformer-architecture\" not \"the-transformer-architecture-paper\"\n- Match existing article slugs when updating them\n\nRules for tags:\n- 2-5 tags per article\n- Use existing tags from the wiki when applicable\n- Tags should be broad enough to connect multiple articles\n\nRules for summaries:\n- One sentence, 15-30 words\n- Should be independently understandable (don't reference other articles)\n- Include key terms for search discoverability";
+export declare const MARP_OUTPUT_PROMPT = "Output your answer as a Marp slide deck. Use this exact format:\n\n---\nmarp: true\ntheme: default\npaginate: true\n---\n\n# Slide Title\n\nMain point or question\n\n---\n\n## Key Concept\n\n- Bullet point 1\n- Bullet point 2\n- Bullet point 3\n\n---\n\n## Details\n\nMore detailed explanation with **bold emphasis** and *italic* for nuance.\n\n---\n\n## Summary\n\nKey takeaway in one sentence.\n\nRules:\n- 4-8 slides for a typical answer\n- One main idea per slide\n- Use headers on every slide\n- Keep bullet points to 3-5 per slide\n- Include citations [[slug]] where relevant\n- Last slide should summarize or pose the next question";
+export declare const JSON_OUTPUT_PROMPT = "Output your answer as a JSON object with this structure:\n\n{\n  \"title\": \"Answer title\",\n  \"summary\": \"One-sentence summary\",\n  \"sections\": [\n    {\n      \"heading\": \"Section heading\",\n      \"content\": \"Section content in markdown\"\n    }\n  ],\n  \"sources\": [\"slug-1\", \"slug-2\"],\n  \"relatedArticles\": [\"slug-3\", \"slug-4\"],\n  \"confidence\": \"high|medium|low\",\n  \"gaps\": [\"Topics not covered by the wiki that would improve this answer\"]\n}\n\nRules:\n- 2-5 sections\n- Content within sections should be markdown-formatted\n- confidence reflects how well the wiki covers this question\n- gaps identifies what sources the user should add for better coverage";