browzy 1.0.0

package/dist/core/compile/index.js

@@ -0,0 +1 @@
+export { WikiCompiler } from './compiler.js';

package/dist/core/config.d.ts

@@ -0,0 +1,10 @@
+import type { BrowzyConfig } from './types.js';
+/**
+ * Load config from browzy.config.json in the current directory,
+ * or from ~/.browzy/config.json, or use defaults.
+ */
+export declare function loadConfig(configPath?: string): BrowzyConfig;
+/**
+ * Ensure the data directory structure exists.
+ */
+export declare function ensureDataDirs(config: BrowzyConfig): void;

package/dist/core/config.js

@@ -0,0 +1,92 @@
+import { readFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const DEFAULT_DATA_DIR = join(homedir(), '.browzy', 'default');
+const DEFAULT_CONFIG = {
+    dataDir: DEFAULT_DATA_DIR,
+    llm: {
+        provider: 'claude',
+        apiKey: '',
+        model: 'claude-sonnet-4-20250514',
+    },
+    compile: {
+        batchSize: 20,
+        extractConcepts: true,
+    },
+};
+/**
+ * Load config from browzy.config.json in the current directory,
+ * or from ~/.browzy/config.json, or use defaults.
+ */
+export function loadConfig(configPath) {
+    const candidates = configPath
+        ? [configPath]
+        : [
+            join(process.cwd(), 'browzy.config.json'),
+            join(homedir(), '.browzy', 'config.json'),
+        ];
+    for (const path of candidates) {
+        if (existsSync(path)) {
+            let parsed;
+            try {
+                parsed = JSON.parse(readFileSync(path, 'utf-8'));
+            }
+            catch {
+                throw new Error(`Invalid JSON in config file: ${path}`);
+            }
+            if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+                throw new Error(`Invalid config: expected an object in ${path}`);
+            }
+            const obj = parsed;
+            if (obj.dataDir !== undefined && typeof obj.dataDir !== 'string') {
+                throw new Error(`Invalid config: dataDir must be a string`);
+            }
+            if (obj.llm !== undefined && (typeof obj.llm !== 'object' || obj.llm === null)) {
+                throw new Error(`Invalid config: llm must be an object`);
+            }
+            return mergeConfig(DEFAULT_CONFIG, obj);
+        }
+    }
+    // Apply env vars as overrides
+    return applyEnvOverrides(DEFAULT_CONFIG);
+}
+function mergeConfig(defaults, overrides) {
+    const merged = {
+        ...defaults,
+        ...overrides,
+        llm: { ...defaults.llm, ...overrides.llm },
+        compile: { ...defaults.compile, ...overrides.compile },
+    };
+    return applyEnvOverrides(merged);
+}
+function applyEnvOverrides(config) {
+    if (process.env.ANTHROPIC_API_KEY && config.llm.provider === 'claude') {
+        config.llm.apiKey = process.env.ANTHROPIC_API_KEY;
+    }
+    if (process.env.OPENAI_API_KEY && config.llm.provider === 'openai') {
+        config.llm.apiKey = process.env.OPENAI_API_KEY;
+    }
+    if (process.env.OPENROUTER_API_KEY && config.llm.provider === 'openrouter') {
+        config.llm.apiKey = process.env.OPENROUTER_API_KEY;
+    }
+    if (process.env.BROWZY_DATA_DIR) {
+        config.dataDir = process.env.BROWZY_DATA_DIR;
+    }
+    return config;
+}
+/**
+ * Ensure the data directory structure exists.
+ */
+export function ensureDataDirs(config) {
+    const dirs = [
+        config.dataDir,
+        join(config.dataDir, 'raw'),
+        join(config.dataDir, 'raw', 'images'),
+        join(config.dataDir, 'wiki'),
+        join(config.dataDir, 'output'),
+        join(config.dataDir, '.browzy'),
+    ];
+    for (const dir of dirs) {
+        mkdirSync(dir, { recursive: true });
+    }
+}

package/dist/core/index.d.ts

@@ -0,0 +1,12 @@
+export { loadConfig, ensureDataDirs } from './config.js';
+export { createProvider } from './llm/index.js';
+export { FilesystemStorage } from './storage/filesystem.js';
+export { SQLiteStorage } from './storage/sqlite.js';
+export { ingest, detectSourceType } from './ingest/index.js';
+export { WikiCompiler } from './compile/index.js';
+export { QueryEngine } from './query/index.js';
+export { WikiLinter } from './lint/index.js';
+export { Wiki } from './wiki/index.js';
+export { sanitizeUnicode, sanitizeDeep } from './sanitization.js';
+export { slugify, safePath, safeParseJSON, checkFileSize, fetchWithTimeout, clampInt } from './utils.js';
+export type * from './types.js';

package/dist/core/index.js

@@ -0,0 +1,11 @@
+export { loadConfig, ensureDataDirs } from './config.js';
+export { createProvider } from './llm/index.js';
+export { FilesystemStorage } from './storage/filesystem.js';
+export { SQLiteStorage } from './storage/sqlite.js';
+export { ingest, detectSourceType } from './ingest/index.js';
+export { WikiCompiler } from './compile/index.js';
+export { QueryEngine } from './query/index.js';
+export { WikiLinter } from './lint/index.js';
+export { Wiki } from './wiki/index.js';
+export { sanitizeUnicode, sanitizeDeep } from './sanitization.js';
+export { slugify, safePath, safeParseJSON, checkFileSize, fetchWithTimeout, clampInt } from './utils.js';

package/dist/core/ingest/image.d.ts

@@ -0,0 +1,3 @@
+import type { RawSource } from '../types.js';
+import type { LLMProvider } from '../llm/provider.js';
+export declare function ingestImage(filePath: string, dataDir: string, llm?: LLMProvider): Promise<RawSource>;

package/dist/core/ingest/image.js

@@ -0,0 +1,61 @@
+import { readFileSync, writeFileSync, existsSync, copyFileSync } from 'fs';
+import { join, basename, extname } from 'path';
+import { createHash } from 'crypto';
+import { lookup } from 'mime-types';
+import { IMAGE_DESCRIPTION_PROMPT } from '../prompts.js';
+import { slugify, checkFileSize } from '../utils.js';
+import { sanitizeUnicode } from '../sanitization.js';
+const MAX_IMAGE_SIZE = 50 * 1024 * 1024; // 50 MB
+export async function ingestImage(filePath, dataDir, llm) {
+    if (!existsSync(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    checkFileSize(filePath, MAX_IMAGE_SIZE);
+    const ext = extname(filePath).toLowerCase();
+    const title = sanitizeUnicode(basename(filePath, ext));
+    const id = createHash('sha256').update(filePath).digest('hex').slice(0, 12);
+    // Copy image to images directory
+    const imgFilename = `${id}${ext}`;
+    const imgDest = join(dataDir, 'raw', 'images', imgFilename);
+    copyFileSync(filePath, imgDest);
+    // Generate description via LLM if available
+    let description = `![${title}](images/${imgFilename})`;
+    if (llm) {
+        const imageData = readFileSync(filePath).toString('base64');
+        const mimeType = lookup(ext) || 'image/png';
+        try {
+            const response = await llm.chat([
+                {
+                    role: 'user',
+                    content: `Describe this image in detail. The image is: ${title}`,
+                },
+            ], { system: IMAGE_DESCRIPTION_PROMPT });
+            description = `![${title}](images/${imgFilename})\n\n## Description\n\n${sanitizeUnicode(response.content)}`;
+        }
+        catch {
+            description = `![${title}](images/${imgFilename})\n\n*Image description pending — LLM unavailable during ingest.*`;
+        }
+    }
+    const filename = `${slugify(title)}-${id}.md`;
+    const frontmatter = [
+        '---',
+        `title: ${JSON.stringify(title)}`,
+        `source: ${JSON.stringify(filePath)}`,
+        `type: image`,
+        `image: ${JSON.stringify('images/' + imgFilename)}`,
+        `ingested: ${JSON.stringify(new Date().toISOString())}`,
+        '---',
+        '',
+    ].join('\n');
+    const outputPath = join(dataDir, 'raw', filename);
+    writeFileSync(outputPath, frontmatter + description, 'utf-8');
+    return {
+        id,
+        type: 'image',
+        title,
+        origin: filePath,
+        path: outputPath,
+        images: [imgDest],
+        ingestedAt: new Date().toISOString(),
+    };
+}

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

@@ -0,0 +1,18 @@
+import type { RawSource, SourceType } from '../types.js';
+import type { LLMProvider } from '../llm/provider.js';
+import { ingestWeb } from './web.js';
+import { ingestPdf } from './pdf.js';
+import { ingestText } from './text.js';
+import { ingestImage } from './image.js';
+/**
+ * Detect source type from input string (URL or file path).
+ */
+export declare function detectSourceType(input: string): SourceType;
+/**
+ * Ingest a source into the knowledge base.
+ */
+export declare function ingest(input: string, dataDir: string, options?: {
+    llm?: LLMProvider;
+    type?: SourceType;
+}): Promise<RawSource>;
+export { ingestWeb, ingestPdf, ingestText, ingestImage };

package/dist/core/ingest/index.js

@@ -0,0 +1,79 @@
+import { extname } from 'path';
+import { FilesystemStorage } from '../storage/filesystem.js';
+import { SQLiteStorage } from '../storage/sqlite.js';
+import { ingestWeb } from './web.js';
+import { ingestPdf } from './pdf.js';
+import { ingestText } from './text.js';
+import { ingestImage } from './image.js';
+const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.bmp']);
+/**
+ * Detect source type from input string (URL or file path).
+ */
+export function detectSourceType(input) {
+    if (input.startsWith('http://') || input.startsWith('https://')) {
+        return 'web';
+    }
+    const ext = extname(input).toLowerCase();
+    if (ext === '.pdf')
+        return 'pdf';
+    if (IMAGE_EXTS.has(ext))
+        return 'image';
+    if (ext === '.md')
+        return 'markdown';
+    return 'text';
+}
+/**
+ * Ingest a source into the knowledge base.
+ */
+export async function ingest(input, dataDir, options) {
+    const type = options?.type ?? detectSourceType(input);
+    let source;
+    switch (type) {
+        case 'web':
+            source = await ingestWeb(input, dataDir);
+            break;
+        case 'pdf':
+            source = await ingestPdf(input, dataDir);
+            break;
+        case 'image':
+            source = await ingestImage(input, dataDir, options?.llm);
+            break;
+        case 'markdown':
+        case 'text':
+            source = await ingestText(input, dataDir);
+            break;
+        default:
+            throw new Error(`Unsupported source type: ${type}`);
+    }
+    // Update manifest
+    const fs = new FilesystemStorage(dataDir);
+    const manifest = fs.getRawManifest();
+    // Replace if same origin exists, otherwise append
+    const existing = manifest.findIndex(s => s.origin === source.origin);
+    if (existing >= 0) {
+        manifest[existing] = source;
+    }
+    else {
+        manifest.push(source);
+    }
+    fs.writeRawManifest(manifest);
+    // Index in SQLite
+    const db = new SQLiteStorage(dataDir);
+    try {
+        db.upsertSource({
+            id: source.id,
+            type: source.type,
+            title: source.title,
+            origin: source.origin,
+            path: source.path,
+            summary: source.summary,
+            tags: source.tags,
+            ingestedAt: source.ingestedAt,
+        });
+    }
+    finally {
+        db.close();
+    }
+    return source;
+}
+export { ingestWeb, ingestPdf, ingestText, ingestImage };

package/dist/core/ingest/pdf.d.ts

@@ -0,0 +1,2 @@
+import type { RawSource } from '../types.js';
+export declare function ingestPdf(filePath: string, dataDir: string): Promise<RawSource>;

package/dist/core/ingest/pdf.js

@@ -0,0 +1,36 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { join, basename } from 'path';
+import { createHash } from 'crypto';
+import { slugify, checkFileSize } from '../utils.js';
+import { sanitizeUnicode } from '../sanitization.js';
+const MAX_PDF_SIZE = 50 * 1024 * 1024; // 50 MB
+export async function ingestPdf(filePath, dataDir) {
+    checkFileSize(filePath, MAX_PDF_SIZE);
+    const pdfParse = (await import('pdf-parse')).default;
+    const buffer = readFileSync(filePath);
+    const data = await pdfParse(buffer);
+    const title = sanitizeUnicode(data.info?.Title || basename(filePath, '.pdf'));
+    const id = createHash('sha256').update(filePath).digest('hex').slice(0, 12);
+    const filename = `${slugify(title)}-${id}.md`;
+    const frontmatter = [
+        '---',
+        `title: ${JSON.stringify(title)}`,
+        `source: ${JSON.stringify(filePath)}`,
+        `type: pdf`,
+        `pages: ${data.numpages}`,
+        `ingested: ${JSON.stringify(new Date().toISOString())}`,
+        '---',
+        '',
+    ].join('\n');
+    const outputPath = join(dataDir, 'raw', filename);
+    writeFileSync(outputPath, frontmatter + sanitizeUnicode(data.text), 'utf-8');
+    return {
+        id,
+        type: 'pdf',
+        title,
+        origin: filePath,
+        path: outputPath,
+        images: [],
+        ingestedAt: new Date().toISOString(),
+    };
+}

package/dist/core/ingest/text.d.ts

@@ -0,0 +1,2 @@
+import type { RawSource } from '../types.js';
+export declare function ingestText(filePath: string, dataDir: string): Promise<RawSource>;

package/dist/core/ingest/text.js

@@ -0,0 +1,38 @@
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join, basename, extname } from 'path';
+import { createHash } from 'crypto';
+import { slugify, checkFileSize } from '../utils.js';
+import { sanitizeUnicode } from '../sanitization.js';
+const MAX_TEXT_SIZE = 50 * 1024 * 1024; // 50 MB
+export async function ingestText(filePath, dataDir) {
+    if (!existsSync(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    checkFileSize(filePath, MAX_TEXT_SIZE);
+    const content = sanitizeUnicode(readFileSync(filePath, 'utf-8'));
+    const ext = extname(filePath).toLowerCase();
+    const type = ext === '.md' ? 'markdown' : 'text';
+    const title = sanitizeUnicode(basename(filePath, ext));
+    const id = createHash('sha256').update(filePath).digest('hex').slice(0, 12);
+    const filename = `${slugify(title)}-${id}.md`;
+    const frontmatter = [
+        '---',
+        `title: ${JSON.stringify(title)}`,
+        `source: ${JSON.stringify(filePath)}`,
+        `type: ${type}`,
+        `ingested: ${JSON.stringify(new Date().toISOString())}`,
+        '---',
+        '',
+    ].join('\n');
+    const outputPath = join(dataDir, 'raw', filename);
+    writeFileSync(outputPath, frontmatter + content, 'utf-8');
+    return {
+        id,
+        type,
+        title,
+        origin: filePath,
+        path: outputPath,
+        images: [],
+        ingestedAt: new Date().toISOString(),
+    };
+}

package/dist/core/ingest/web.d.ts

@@ -0,0 +1,2 @@
+import type { RawSource } from '../types.js';
+export declare function ingestWeb(url: string, dataDir: string): Promise<RawSource>;

package/dist/core/ingest/web.js

@@ -0,0 +1,202 @@
+import TurndownService from 'turndown';
+import { createHash } from 'node:crypto';
+import { writeFileSync } from 'fs';
+import { join, extname as pathExtname } from 'path';
+import { slugify, fetchWithTimeout } from '../utils.js';
+import { sanitizeUnicode } from '../sanitization.js';
+const MAX_IMAGES = 50;
+const MAX_IMAGE_BYTES = 10 * 1024 * 1024; // 10 MB per image
+const MAX_HTML_BYTES = 10 * 1024 * 1024; // 10 MB for page HTML
+const MAX_REDIRECTS = 5;
+const HEADERS = {
+    'User-Agent': 'browzy/0.1.0',
+    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+};
+// ── SSRF Protection ──────────────────────────────────────────────
+function isPrivateUrl(urlStr) {
+    let parsed;
+    try {
+        parsed = new URL(urlStr);
+    }
+    catch {
+        return true; // Block unparseable URLs
+    }
+    const host = parsed.hostname.toLowerCase();
+    // Obvious private hostnames
+    if (host === 'localhost' ||
+        host === '0.0.0.0' ||
+        host.endsWith('.local') ||
+        host.endsWith('.internal'))
+        return true;
+    const stripped = host.replace(/^\[|\]$/g, ''); // strip brackets for IPv6
+    // Block octal/hex IP notation (bypass attempts like 0x7f000001, 0177.0.0.1)
+    if (/^[0-9a-fx.:]+$/i.test(stripped) && (/0x/i.test(stripped) || /^0\d/.test(stripped))) {
+        return true;
+    }
+    // IPv4 loopback and private ranges
+    const v4Parts = stripped.split('.').map(Number);
+    if (v4Parts.length === 4 && v4Parts.every(n => !isNaN(n))) {
+        if (v4Parts[0] === 127)
+            return true; // 127.0.0.0/8
+        if (v4Parts[0] === 10)
+            return true; // 10.0.0.0/8
+        if (v4Parts[0] === 172 && v4Parts[1] >= 16 && v4Parts[1] <= 31)
+            return true; // 172.16.0.0/12
+        if (v4Parts[0] === 192 && v4Parts[1] === 168)
+            return true; // 192.168.0.0/16
+        if (v4Parts[0] === 169 && v4Parts[1] === 254)
+            return true; // 169.254.0.0/16 (link-local / cloud metadata)
+        if (v4Parts[0] === 0)
+            return true; // 0.0.0.0/8
+    }
+    // Block bare decimal IP (e.g., 2130706433 = 127.0.0.1)
+    if (/^\d+$/.test(stripped) && parseInt(stripped, 10) > 0)
+        return true;
+    // IPv6 private ranges
+    if (stripped === '::1')
+        return true; // loopback
+    if (stripped.startsWith('fc') || stripped.startsWith('fd'))
+        return true; // fc00::/7 unique local
+    if (stripped.startsWith('fe80'))
+        return true; // fe80::/10 link-local
+    if (stripped.startsWith('::ffff:'))
+        return true; // IPv4-mapped IPv6
+    return false;
+}
+// ── Redirect Validation ──────────────────────────────────────────
+function isPermittedRedirect(originalUrl, redirectUrl) {
+    try {
+        const orig = new URL(originalUrl);
+        const redir = new URL(redirectUrl);
+        // Block private redirect targets
+        if (isPrivateUrl(redirectUrl))
+            return false;
+        // No credentials in redirect
+        if (redir.username || redir.password)
+            return false;
+        // Must stay same host (allow www add/remove)
+        const stripWww = (h) => h.replace(/^www\./, '');
+        return stripWww(orig.hostname) === stripWww(redir.hostname);
+    }
+    catch {
+        return false;
+    }
+}
+async function fetchFollowingSafeRedirects(url, options = {}, depth = 0) {
+    if (depth > MAX_REDIRECTS) {
+        throw new Error(`Too many redirects (exceeded ${MAX_REDIRECTS})`);
+    }
+    const response = await fetchWithTimeout(url, { ...options, timeoutMs: 30_000 });
+    if ([301, 302, 307, 308].includes(response.status)) {
+        const location = response.headers.get('location');
+        if (!location)
+            throw new Error('Redirect missing Location header');
+        const redirectUrl = new URL(location, url).href;
+        if (!isPermittedRedirect(url, redirectUrl)) {
+            throw new Error(`Blocked redirect from ${new URL(url).hostname} to ${new URL(redirectUrl).hostname}`);
+        }
+        return fetchFollowingSafeRedirects(redirectUrl, options, depth + 1);
+    }
+    return response;
+}
+// ── Image Extension Extraction ───────────────────────────────────
+function safeImageExt(imgUrl) {
+    try {
+        const pathname = new URL(imgUrl).pathname;
+        const ext = pathExtname(pathname).toLowerCase().replace(/^\./, '');
+        const allowed = new Set(['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg', 'bmp', 'ico']);
+        return allowed.has(ext) ? ext : 'png';
+    }
+    catch {
+        return 'png';
+    }
+}
+// ── Main ─────────────────────────────────────────────────────────
+const turndown = new TurndownService({
+    headingStyle: 'atx',
+    codeBlockStyle: 'fenced',
+});
+export async function ingestWeb(url, dataDir) {
+    if (url.length > 2000) {
+        throw new Error('URL exceeds maximum length of 2000 characters');
+    }
+    if (isPrivateUrl(url)) {
+        throw new Error('Cannot fetch private or internal URLs');
+    }
+    const response = await fetchFollowingSafeRedirects(url, { headers: HEADERS });
+    if (!response.ok) {
+        throw new Error(`Fetch failed: ${response.status} ${response.statusText}`);
+    }
+    // Content-type guard
+    const contentType = response.headers.get('content-type') || '';
+    if (!contentType.includes('text/') && !contentType.includes('html') && !contentType.includes('xml')) {
+        throw new Error(`Unexpected content type: ${contentType}. Expected HTML or text.`);
+    }
+    // Content-length guard (pre-read)
+    const contentLength = parseInt(response.headers.get('content-length') || '0', 10);
+    if (contentLength > MAX_HTML_BYTES) {
+        throw new Error(`Page too large: ${(contentLength / 1024 / 1024).toFixed(1)}MB exceeds ${(MAX_HTML_BYTES / 1024 / 1024).toFixed(0)}MB limit`);
+    }
+    const html = await response.text();
+    // Post-read size check (content-length can be missing or wrong)
+    if (Buffer.byteLength(html) > MAX_HTML_BYTES) {
+        throw new Error('Page content exceeds size limit');
+    }
+    const markdown = sanitizeUnicode(turndown.turndown(html));
+    // Extract title
+    const titleMatch = html.match(/<title[^>]*>([^<]+)<\/title>/i);
+    const title = sanitizeUnicode(titleMatch?.[1]?.trim() || url);
+    // Download images (capped, with SSRF + size checks)
+    const images = [];
+    const imgRegex = /<img[^>]+src="([^"]+)"/g;
+    let match;
+    while ((match = imgRegex.exec(html)) !== null && images.length < MAX_IMAGES) {
+        try {
+            const imgUrl = new URL(match[1], url).href;
+            if (isPrivateUrl(imgUrl))
+                continue;
+            const imgResponse = await fetchWithTimeout(imgUrl, {
+                headers: { 'User-Agent': 'browzy/0.1.0' },
+                timeoutMs: 15_000,
+            });
+            if (!imgResponse.ok)
+                continue;
+            const contentLength = parseInt(imgResponse.headers.get('content-length') || '0', 10);
+            if (contentLength > MAX_IMAGE_BYTES)
+                continue;
+            const buffer = Buffer.from(await imgResponse.arrayBuffer());
+            if (buffer.length > MAX_IMAGE_BYTES)
+                continue;
+            const ext = safeImageExt(imgUrl);
+            const imgFilename = `${createHash('sha256').update(imgUrl).digest('hex').slice(0, 12)}.${ext}`;
+            const imgPath = join(dataDir, 'raw', 'images', imgFilename);
+            writeFileSync(imgPath, buffer);
+            images.push(imgPath);
+        }
+        catch {
+            // Skip failed image downloads
+        }
+    }
+    const id = createHash('sha256').update(url).digest('hex').slice(0, 12);
+    const filename = `${slugify(title)}-${id}.md`;
+    const frontmatter = [
+        '---',
+        `title: ${JSON.stringify(title)}`,
+        `source: ${JSON.stringify(url)}`,
+        `type: web`,
+        `ingested: ${JSON.stringify(new Date().toISOString())}`,
+        '---',
+        '',
+    ].join('\n');
+    const path = join(dataDir, 'raw', filename);
+    writeFileSync(path, frontmatter + markdown, 'utf-8');
+    return {
+        id,
+        type: 'web',
+        title,
+        origin: url,
+        path,
+        images,
+        ingestedAt: new Date().toISOString(),
+    };
+}

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

@@ -0,0 +1 @@
+export { WikiLinter } from './linter.js';

package/dist/core/lint/index.js

@@ -0,0 +1 @@
+export { WikiLinter } from './linter.js';

package/dist/core/lint/linter.d.ts

@@ -0,0 +1,27 @@
+import type { LLMProvider } from '../llm/provider.js';
+import type { LintIssue } from '../types.js';
+export declare class WikiLinter {
+    private fs;
+    private llm;
+    constructor(dataDir: string, llm: LLMProvider);
+    /**
+     * Run all lint checks on the wiki.
+     */
+    lint(): Promise<LintIssue[]>;
+    /**
+     * Check for [[wiki-links]] that point to non-existent articles.
+     */
+    private checkBrokenLinks;
+    /**
+     * Find articles with no incoming links (orphans).
+     */
+    private checkOrphanArticles;
+    /**
+     * Check for missing frontmatter fields.
+     */
+    private checkMissingFields;
+    /**
+     * Use LLM to check for inconsistencies, duplicates, and gaps.
+     */
+    private checkConsistency;
+}