@biaoo/tiangong-wiki 0.2.0

package/dist/core/codex-workflow.js

@@ -0,0 +1,233 @@
+import path from "node:path";
+import { Codex } from "@openai/codex-sdk";
+import { readWorkflowResult } from "./workflow-result.js";
+import { readTextFileSync, writeTextFileSync } from "../utils/fs.js";
+import { AppError } from "../utils/errors.js";
+export const CODEX_WORKFLOW_VERSION = "2026-04-07";
+function normalizeEnv(input) {
+    const normalized = {};
+    for (const [key, value] of Object.entries({
+        ...process.env,
+        ...input.env,
+        ...(input.env?.WIKI_AGENT_API_KEY && !input.env.OPENAI_API_KEY ? { OPENAI_API_KEY: input.env.WIKI_AGENT_API_KEY } : {}),
+    })) {
+        if (typeof value === "string") {
+            normalized[key] = value;
+        }
+    }
+    normalized.PATH = [input.skillArtifactsPath, normalized.PATH].filter(Boolean).join(path.delimiter);
+    return normalized;
+}
+function createCodexClient(input) {
+    const env = normalizeEnv(input);
+    const baseUrl = input.env?.WIKI_AGENT_BASE_URL?.trim();
+    const apiKey = input.env?.WIKI_AGENT_API_KEY?.trim();
+    const options = {
+        apiKey: apiKey || undefined,
+        env,
+    };
+    if (baseUrl) {
+        // Define a custom model_provider to override any global ~/.codex/config.toml settings.
+        // The SDK's `baseUrl` option maps to `openai_base_url` which gets overridden by
+        // model_provider; using `config` directly avoids this precedence issue.
+        options.config = {
+            model_provider: "tiangong-wiki-agent",
+            model_providers: {
+                "tiangong-wiki-agent": {
+                    name: "tiangong-wiki-agent",
+                    base_url: baseUrl,
+                    wire_api: "responses",
+                    experimental_bearer_token: apiKey || "",
+                },
+            },
+        };
+    }
+    return new Codex(options);
+}
+function persistWorkflowThreadId(queueItemPath, threadId) {
+    try {
+        const raw = readTextFileSync(queueItemPath);
+        const parsed = raw.trim() ? JSON.parse(raw) : {};
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error("queue-item.json must contain an object");
+        }
+        writeTextFileSync(queueItemPath, `${JSON.stringify({ ...parsed, threadId }, null, 2)}\n`);
+    }
+    catch (error) {
+        throw new AppError("Failed to persist workflow thread id into queue-item.json", "runtime", {
+            queueItemPath,
+            threadId,
+            cause: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+async function runThread(thread, input) {
+    let activeThreadId = thread.id ?? null;
+    let emittedThreadId = null;
+    const emitThreadStarted = (threadId) => {
+        if (threadId === emittedThreadId) {
+            return;
+        }
+        emittedThreadId = threadId;
+        input.onThreadStarted?.(threadId);
+    };
+    if (activeThreadId) {
+        persistWorkflowThreadId(input.queueItemPath, activeThreadId);
+        emitThreadStarted(activeThreadId);
+    }
+    try {
+        const streamed = await thread.runStreamed(input.promptText, input.signal ? { signal: input.signal } : undefined);
+        for await (const event of streamed.events) {
+            if (event.type === "thread.started") {
+                activeThreadId = event.thread_id;
+                persistWorkflowThreadId(input.queueItemPath, activeThreadId);
+                emitThreadStarted(activeThreadId);
+                continue;
+            }
+            if (event.type === "turn.failed") {
+                throw new AppError("Codex workflow turn failed", "runtime", {
+                    cause: event.error.message,
+                    threadId: activeThreadId,
+                });
+            }
+            if (event.type === "error") {
+                throw new AppError("Codex workflow stream failed", "runtime", {
+                    cause: event.message,
+                    threadId: activeThreadId,
+                });
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof AppError) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new AppError("Codex workflow turn failed", "runtime", {
+            cause: message,
+            threadId: activeThreadId,
+        });
+    }
+    if (!activeThreadId && thread.id) {
+        activeThreadId = thread.id;
+    }
+    if (!activeThreadId) {
+        throw new AppError("Codex workflow did not provide a thread id", "runtime");
+    }
+    persistWorkflowThreadId(input.queueItemPath, activeThreadId);
+    return activeThreadId;
+}
+export class CodexSdkWorkflowRunner {
+    // The SDK can only continue a thread by sending a new input, so queue retries
+    // must not automatically resume real workflow threads inline.
+    async startWorkflow(input) {
+        const codex = createCodexClient(input);
+        const thread = codex.startThread({
+            model: input.model ?? undefined,
+            modelReasoningEffort: "low",
+            workingDirectory: input.workspaceRoot,
+            skipGitRepoCheck: true,
+            sandboxMode: "workspace-write",
+            networkAccessEnabled: true,
+            approvalPolicy: "never",
+            webSearchMode: "disabled",
+            additionalDirectories: [input.packageRoot, input.skillArtifactsPath],
+        });
+        const threadId = await runThread(thread, input);
+        return { threadId, mode: "start" };
+    }
+    async resumeWorkflow(threadId, input) {
+        const codex = createCodexClient(input);
+        const thread = codex.resumeThread(threadId, {
+            model: input.model ?? undefined,
+            modelReasoningEffort: "low",
+            workingDirectory: input.workspaceRoot,
+            skipGitRepoCheck: true,
+            sandboxMode: "workspace-write",
+            networkAccessEnabled: true,
+            approvalPolicy: "never",
+            webSearchMode: "disabled",
+            additionalDirectories: [input.packageRoot, input.skillArtifactsPath],
+        });
+        const resumedThreadId = await runThread(thread, input);
+        return { threadId: resumedThreadId, mode: "resume" };
+    }
+    async collectResult(handle, input) {
+        const manifest = readWorkflowResult(input.resultPath);
+        if (manifest.threadId !== handle.threadId) {
+            throw new AppError(`Workflow result threadId mismatch: expected ${handle.threadId}, got ${manifest.threadId}`, "runtime");
+        }
+        return manifest;
+    }
+}
+export class FakeCodexWorkflowRunner {
+    handler;
+    calls = [];
+    counter = 0;
+    constructor(handler) {
+        this.handler = handler;
+    }
+    async startWorkflow(input) {
+        const threadId = `fake-thread-${++this.counter}`;
+        input.onThreadStarted?.(threadId);
+        this.calls.push({ mode: "start", queueItemId: input.queueItemId, threadId });
+        const manifest = await this.handler({
+            mode: "start",
+            queueItemId: input.queueItemId,
+            threadId,
+            input,
+        });
+        writeTextFileSync(input.resultPath, `${JSON.stringify(manifest, null, 2)}\n`);
+        return { threadId, mode: "start" };
+    }
+    async resumeWorkflow(threadId, input) {
+        input.onThreadStarted?.(threadId);
+        this.calls.push({ mode: "resume", queueItemId: input.queueItemId, threadId });
+        const manifest = await this.handler({
+            mode: "resume",
+            queueItemId: input.queueItemId,
+            threadId,
+            input,
+        });
+        writeTextFileSync(input.resultPath, `${JSON.stringify(manifest, null, 2)}\n`);
+        return { threadId, mode: "resume" };
+    }
+    async collectResult(_handle, input) {
+        return readWorkflowResult(input.resultPath);
+    }
+}
+async function delay(ms) {
+    if (ms <= 0) {
+        return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createSkipOnlyTestWorkflowRunner(options) {
+    const delayMs = Math.max(0, options.delayMs ?? 0);
+    return new FakeCodexWorkflowRunner(async ({ threadId }) => {
+        await delay(delayMs);
+        return {
+            status: "skipped",
+            decision: "skip",
+            reason: `Skipped by WIKI_TEST_FAKE_WORKFLOW_MODE=${options.mode}.`,
+            threadId,
+            skillsUsed: ["tiangong-wiki-skill"],
+            createdPageIds: [],
+            updatedPageIds: [],
+            appliedTypeNames: [],
+            proposedTypes: [],
+            actions: [],
+            lint: [],
+        };
+    });
+}
+export function createDefaultWorkflowRunner(env = process.env) {
+    if (env.WIKI_TEST_FAKE_WORKFLOW_MODE === "skip") {
+        return createSkipOnlyTestWorkflowRunner({ mode: "skip" });
+    }
+    if (env.WIKI_TEST_FAKE_WORKFLOW_MODE === "delay-skip") {
+        const delayMs = Number.parseInt(env.WIKI_TEST_FAKE_WORKFLOW_DELAY_MS ?? "0", 10) || 0;
+        return createSkipOnlyTestWorkflowRunner({ delayMs, mode: "delay-skip" });
+    }
+    return new CodexSdkWorkflowRunner();
+}

package/dist/core/config.js

@@ -0,0 +1,126 @@
+import path from "node:path";
+import { AppError, assertCondition } from "../utils/errors.js";
+import { camelToSnake } from "../utils/case.js";
+import { pathExistsSync, readTextFileSync, sha256Text } from "../utils/fs.js";
+const ALLOWED_SQLITE_TYPES = new Set(["text", "integer", "real", "numeric", "blob"]);
+export const DEFAULT_VAULT_FILE_TYPES = ["md", "txt", "pdf", "docx", "pptx", "xlsx", "csv", "json", "yaml", "yml"];
+function ensureObject(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new AppError(`${label} must be an object`, "config");
+    }
+    return value;
+}
+function ensureStringArray(value, label) {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        throw new AppError(`${label} must be a string array`, "config");
+    }
+    return value;
+}
+function ensureVaultFileTypes(value, label) {
+    const normalized = ensureStringArray(value, label).map((item, index) => {
+        const fileType = item.trim().replace(/^\./, "").toLowerCase();
+        if (!fileType) {
+            throw new AppError(`${label}[${index}] must not be empty`, "config");
+        }
+        return fileType;
+    });
+    return [...new Set(normalized)];
+}
+function ensureColumnMap(value, label) {
+    const objectValue = ensureObject(value, label);
+    const entries = Object.entries(objectValue).map(([key, rawType]) => {
+        if (typeof rawType !== "string" || !ALLOWED_SQLITE_TYPES.has(rawType)) {
+            throw new AppError(`${label}.${key} must be a valid SQLite column type`, "config");
+        }
+        return [key, rawType];
+    });
+    return Object.fromEntries(entries);
+}
+function ensureEdgeRule(value, label) {
+    const objectValue = ensureObject(value, label);
+    assertCondition(typeof objectValue.edgeType === "string" && objectValue.edgeType, `${label}.edgeType is required`, "config");
+    assertCondition(objectValue.resolve === "nodeId" || objectValue.resolve === "path", `${label}.resolve must be "nodeId" or "path"`, "config");
+    if (objectValue.match !== undefined && typeof objectValue.match !== "string") {
+        throw new AppError(`${label}.match must be a string when provided`, "config");
+    }
+    return {
+        edgeType: objectValue.edgeType,
+        resolve: objectValue.resolve,
+        ...(objectValue.match ? { match: objectValue.match } : {}),
+    };
+}
+function ensureEdgeMap(value, label) {
+    const objectValue = ensureObject(value, label);
+    return Object.fromEntries(Object.entries(objectValue).map(([field, rule]) => [field, ensureEdgeRule(rule, `${label}.${field}`)]));
+}
+function ensureTemplateConfig(value, label) {
+    const objectValue = ensureObject(value, label);
+    assertCondition(typeof objectValue.file === "string" && objectValue.file, `${label}.file is required`, "config");
+    return {
+        file: objectValue.file,
+        columns: ensureColumnMap(objectValue.columns ?? {}, `${label}.columns`),
+        edges: ensureEdgeMap(objectValue.edges ?? {}, `${label}.edges`),
+        summaryFields: ensureStringArray(objectValue.summaryFields ?? [], `${label}.summaryFields`),
+    };
+}
+export function loadConfig(configPath) {
+    if (!pathExistsSync(configPath)) {
+        throw new AppError(`Config file not found: ${configPath}`, "config");
+    }
+    let parsedJson;
+    const rawContent = readTextFileSync(configPath);
+    try {
+        parsedJson = JSON.parse(rawContent);
+    }
+    catch (error) {
+        throw new AppError(`Failed to parse config JSON: ${configPath}`, "config", {
+            cause: error instanceof Error ? error.message : String(error),
+        });
+    }
+    const raw = ensureObject(parsedJson, "wiki.config.json");
+    assertCondition(Number.isInteger(raw.schemaVersion), "schemaVersion must be an integer", "config");
+    const baseConfig = {
+        schemaVersion: Number(raw.schemaVersion),
+        customColumns: ensureColumnMap(raw.customColumns ?? {}, "customColumns"),
+        defaultSummaryFields: ensureStringArray(raw.defaultSummaryFields ?? [], "defaultSummaryFields"),
+        vaultFileTypes: ensureVaultFileTypes(raw.vaultFileTypes ?? DEFAULT_VAULT_FILE_TYPES, "vaultFileTypes"),
+        commonEdges: ensureEdgeMap(raw.commonEdges ?? {}, "commonEdges"),
+        templates: Object.fromEntries(Object.entries(ensureObject(raw.templates, "templates")).map(([pageType, template]) => [
+            pageType,
+            ensureTemplateConfig(template, `templates.${pageType}`),
+        ])),
+    };
+    assertCondition(Object.keys(baseConfig.templates).length > 0, "templates must not be empty", "config");
+    const allColumnDefinitions = {};
+    for (const [field, type] of Object.entries(baseConfig.customColumns)) {
+        allColumnDefinitions[camelToSnake(field)] = type;
+    }
+    for (const [pageType, template] of Object.entries(baseConfig.templates)) {
+        assertCondition(template.file.endsWith(".md"), `templates.${pageType}.file must point to a .md file`, "config");
+        for (const [field, type] of Object.entries(template.columns)) {
+            const columnName = camelToSnake(field);
+            if (allColumnDefinitions[columnName] && allColumnDefinitions[columnName] !== type) {
+                throw new AppError(`Column ${field} is declared with conflicting types`, "config");
+            }
+            allColumnDefinitions[columnName] = type;
+        }
+    }
+    return {
+        ...baseConfig,
+        configPath: path.resolve(configPath),
+        configVersion: sha256Text(rawContent),
+        allColumnDefinitions,
+        allColumnNames: Object.keys(allColumnDefinitions).sort(),
+    };
+}
+export function getTemplate(config, pageType) {
+    const template = config.templates[pageType];
+    if (!template) {
+        throw new AppError(`Unknown pageType: ${pageType}`, "config");
+    }
+    return template;
+}
+export function resolveTemplateFilePath(config, wikiRoot, pageType) {
+    const template = getTemplate(config, pageType);
+    return path.resolve(wikiRoot, template.file);
+}

package/dist/core/db.js

@@ -0,0 +1,292 @@
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+import { AppError } from "../utils/errors.js";
+import { segmentForFts } from "../utils/segmenter.js";
+export const SCHEMA_VERSION = "1";
+const FTS_INDEX_VERSION = "2";
+function tableExists(db, tableName) {
+    const row = db
+        .prepare("SELECT name FROM sqlite_master WHERE type IN ('table', 'view') AND name = ?")
+        .get(tableName);
+    return Boolean(row?.name);
+}
+function getTableSql(db, tableName) {
+    const row = db
+        .prepare("SELECT sql FROM sqlite_master WHERE type IN ('table', 'view') AND name = ?")
+        .get(tableName);
+    return row?.sql ?? null;
+}
+function getExistingTableColumns(db, tableName) {
+    const rows = db.prepare(`PRAGMA table_info(${tableName})`).all();
+    return new Set(rows.map((row) => row.name));
+}
+function ensureTableColumns(db, tableName, definitions) {
+    const existingColumns = getExistingTableColumns(db, tableName);
+    for (const [columnName, definition] of Object.entries(definitions)) {
+        if (!existingColumns.has(columnName)) {
+            db.exec(`ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${definition}`);
+        }
+    }
+}
+function createFtsTable(db) {
+    db.exec(`
+    CREATE VIRTUAL TABLE pages_fts USING fts5(
+      title,
+      tags,
+      summary_text
+    );
+  `);
+}
+function normalizeTagsForFts(rawTags) {
+    if (!rawTags) {
+        return "";
+    }
+    try {
+        const parsed = JSON.parse(rawTags);
+        if (Array.isArray(parsed)) {
+            return parsed
+                .map((value) => String(value).trim())
+                .filter(Boolean)
+                .join(" ");
+        }
+    }
+    catch {
+        // Fall back to the stored value if legacy data is not valid JSON.
+    }
+    return rawTags;
+}
+function buildFtsRow(row) {
+    return {
+        rowid: row.rowid,
+        title: segmentForFts(row.title),
+        tags: segmentForFts(normalizeTagsForFts(row.tags)),
+        summary_text: segmentForFts(row.summaryText ?? ""),
+    };
+}
+function isLegacyExternalContentFts(db) {
+    const sql = getTableSql(db, "pages_fts");
+    return typeof sql === "string" && /content\s*=\s*'pages'/i.test(sql);
+}
+function ensureBaseTables(db, embeddingDimensions) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS pages (
+      id TEXT PRIMARY KEY,
+      node_id TEXT UNIQUE,
+      title TEXT NOT NULL,
+      page_type TEXT NOT NULL,
+      status TEXT DEFAULT 'draft',
+      visibility TEXT DEFAULT 'private',
+      tags TEXT,
+      extra TEXT,
+      file_path TEXT NOT NULL,
+      content_hash TEXT,
+      summary_text TEXT,
+      embedding_status TEXT DEFAULT 'pending',
+      file_mtime REAL,
+      created_at TEXT,
+      updated_at TEXT,
+      indexed_at TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_pages_type ON pages(page_type);
+    CREATE INDEX IF NOT EXISTS idx_pages_status ON pages(status);
+    CREATE INDEX IF NOT EXISTS idx_pages_node ON pages(node_id);
+
+    CREATE TABLE IF NOT EXISTS edges (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      source TEXT NOT NULL,
+      target TEXT NOT NULL,
+      edge_type TEXT NOT NULL,
+      source_page TEXT,
+      metadata TEXT,
+      UNIQUE(source, target, edge_type, source_page)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source);
+    CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target);
+    CREATE INDEX IF NOT EXISTS idx_edges_type ON edges(edge_type);
+
+    CREATE TABLE IF NOT EXISTS vault_files (
+      id TEXT PRIMARY KEY,
+      file_name TEXT NOT NULL,
+      file_ext TEXT,
+      source_type TEXT,
+      file_size INTEGER,
+      file_path TEXT NOT NULL,
+      content_hash TEXT,
+      file_mtime REAL,
+      indexed_at TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS vault_changelog (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_id TEXT NOT NULL,
+      action TEXT NOT NULL,
+      detected_at TEXT NOT NULL,
+      sync_id TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_vchangelog_sync ON vault_changelog(sync_id);
+    CREATE INDEX IF NOT EXISTS idx_vchangelog_time ON vault_changelog(detected_at);
+
+    CREATE TABLE IF NOT EXISTS vault_processing_queue (
+      file_id TEXT PRIMARY KEY,
+      status TEXT DEFAULT 'pending',
+      priority INTEGER DEFAULT 0,
+      queued_at TEXT NOT NULL,
+      claimed_at TEXT,
+      started_at TEXT,
+      processed_at TEXT,
+      result_page_id TEXT,
+      error_message TEXT,
+      attempts INTEGER DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_vpq_status ON vault_processing_queue(status);
+    CREATE INDEX IF NOT EXISTS idx_vpq_priority ON vault_processing_queue(priority DESC, queued_at ASC);
+
+    CREATE TABLE IF NOT EXISTS sync_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT
+    );
+  `);
+    ensureTableColumns(db, "vault_processing_queue", {
+        claimed_at: "TEXT",
+        started_at: "TEXT",
+        thread_id: "TEXT",
+        workflow_version: "TEXT",
+        decision: "TEXT",
+        result_manifest_path: "TEXT",
+        last_error_at: "TEXT",
+        retry_after: "TEXT",
+        created_page_ids: "TEXT",
+        updated_page_ids: "TEXT",
+        applied_type_names: "TEXT",
+        proposed_type_names: "TEXT",
+        skills_used: "TEXT",
+    });
+    if (!tableExists(db, "vec_pages")) {
+        db.exec(`
+      CREATE VIRTUAL TABLE vec_pages USING vec0(
+        page_rowid INTEGER PRIMARY KEY,
+        page_id TEXT,
+        embedding float[${embeddingDimensions}]
+      );
+    `);
+    }
+}
+function getExistingColumns(db) {
+    return getExistingTableColumns(db, "pages");
+}
+function ensureDynamicColumns(db, config) {
+    const existingColumns = getExistingColumns(db);
+    for (const [columnName, columnType] of Object.entries(config.allColumnDefinitions)) {
+        if (!existingColumns.has(columnName)) {
+            db.exec(`ALTER TABLE pages ADD COLUMN ${columnName} ${columnType.toUpperCase()}`);
+            db.exec(`CREATE INDEX IF NOT EXISTS idx_pages_${columnName} ON pages(${columnName})`);
+        }
+    }
+}
+export function getMeta(db, key) {
+    const row = db.prepare("SELECT value FROM sync_meta WHERE key = ?").get(key);
+    return row?.value ?? null;
+}
+export function setMeta(db, key, value) {
+    if (value === null) {
+        db.prepare("DELETE FROM sync_meta WHERE key = ?").run(key);
+        return;
+    }
+    db.prepare(`
+      INSERT INTO sync_meta(key, value)
+      VALUES(@key, @value)
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value
+    `).run({ key, value });
+}
+export function setMetaValues(db, values) {
+    const transaction = db.transaction((payload) => {
+        for (const [key, value] of Object.entries(payload)) {
+            setMeta(db, key, value);
+        }
+    });
+    transaction(values);
+}
+export function rebuildFts(db) {
+    if (!tableExists(db, "pages_fts")) {
+        return;
+    }
+    const rows = db.prepare("SELECT rowid, title, tags, summary_text AS summaryText FROM pages ORDER BY rowid").all();
+    const clearStatement = db.prepare("DELETE FROM pages_fts");
+    const insertStatement = db.prepare("INSERT INTO pages_fts(rowid, title, tags, summary_text) VALUES (@rowid, @title, @tags, @summary_text)");
+    const transaction = db.transaction(() => {
+        clearStatement.run();
+        for (const row of rows) {
+            insertStatement.run(buildFtsRow(row));
+        }
+    });
+    transaction();
+}
+function ensureFtsTable(db) {
+    const hasTable = tableExists(db, "pages_fts");
+    const storedFtsIndexVersion = getMeta(db, "fts_index_version");
+    const needsRecreate = !hasTable || isLegacyExternalContentFts(db);
+    const needsRebuild = needsRecreate || storedFtsIndexVersion !== FTS_INDEX_VERSION;
+    if (needsRecreate && hasTable) {
+        db.exec("DROP TABLE pages_fts");
+    }
+    if (needsRecreate) {
+        createFtsTable(db);
+    }
+    if (needsRebuild) {
+        rebuildFts(db);
+    }
+    if (needsRebuild || storedFtsIndexVersion !== FTS_INDEX_VERSION) {
+        setMeta(db, "fts_index_version", FTS_INDEX_VERSION);
+    }
+}
+export function resetVectorTable(db, embeddingDimensions) {
+    db.exec("DROP TABLE IF EXISTS vec_pages");
+    db.exec(`
+    CREATE VIRTUAL TABLE vec_pages USING vec0(
+      page_rowid INTEGER PRIMARY KEY,
+      page_id TEXT,
+      embedding float[${embeddingDimensions}]
+    );
+  `);
+}
+export function clearAllIndexedData(db) {
+    db.exec(`
+    DELETE FROM edges;
+    DELETE FROM pages;
+    DELETE FROM vault_files;
+    DELETE FROM vault_changelog;
+    DELETE FROM vault_processing_queue;
+  `);
+    if (tableExists(db, "vec_pages")) {
+        db.exec("DELETE FROM vec_pages");
+    }
+    if (tableExists(db, "pages_fts")) {
+        rebuildFts(db);
+    }
+    db.prepare("DELETE FROM sync_meta WHERE key IN ('last_sync_at', 'last_sync_id', 'last_full_rebuild_at', 'embedding_profile')").run();
+}
+export function openDb(dbPath, config, embeddingDimensions) {
+    const db = new Database(dbPath);
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    sqliteVec.load(db);
+    ensureBaseTables(db, embeddingDimensions);
+    ensureFtsTable(db);
+    const storedSchemaVersion = getMeta(db, "schema_version");
+    if (storedSchemaVersion && storedSchemaVersion !== SCHEMA_VERSION) {
+        db.close();
+        throw new AppError(`Schema version mismatch: expected ${SCHEMA_VERSION}, found ${storedSchemaVersion}. Run tiangong-wiki init --force.`, "config");
+    }
+    ensureDynamicColumns(db, config);
+    const storedConfigVersion = getMeta(db, "config_version");
+    const configChanged = Boolean(storedConfigVersion && storedConfigVersion !== config.configVersion);
+    setMetaValues(db, {
+        schema_version: SCHEMA_VERSION,
+        ...(storedConfigVersion === null ? { config_version: config.configVersion } : {}),
+    });
+    return { db, configChanged };
+}