gisool 0.0.0-stage → 0.1.0

package/dist/search/lexical.js

@@ -0,0 +1,69 @@
+export const normalize = (value) => value.normalize("NFKC").toLowerCase().replace(/\s+/g, " ").trim();
+const STOPWORDS = new Set(("a an the and or to of for in on with from by is are be it this that do please use using when how me my can could would should not only then after before need want help " +
+    "해줘 해주세요 알려줘 작성해줘 만들어줘 확인해줘 검토해줘 필요 없어 있습니다 합니다 작업 사용 통해 대한 위한 관련 현재 다음 먼저 실제 하나 것 수 및 또는 하고 그리고 방법 " +
+    // Bare particles left over when a Latin/digit token carries a Korean particle ("api가", "19로").
+    "은 는 이 가 을 를 의 도 로 와 과 에").split(" "));
+export function stem(word) {
+    if (/^[가-힣]+$/.test(word) && word.length > 2) {
+        const stripped = word.replace(/(?:해주세요|해줘|하기|하게|하는|하면서|하려는|으로|에서|에게|에는|까지|부터|처럼|보다|은|는|을|를|이|가|과|와|의|도|로)$/, "");
+        return stripped.length >= 2 ? stripped : word;
+    }
+    return /^[a-z]{5,}s$/.test(word) && !word.endsWith("ss") ? word.slice(0, -1) : word;
+}
+/** Raw word tokens of normalized text, split where Hangul meets Latin/digits ("api가" -> "api", "가"). */
+export function words(text) {
+    return (normalize(text).match(/[\p{L}\p{N}]+/gu) ?? [])
+        .flatMap(word => word.split(/(?<=[가-힣])(?=[a-z0-9])|(?<=[a-z0-9])(?=[가-힣])/));
+}
+export const isStopword = (word) => STOPWORDS.has(word);
+export function terms(text) {
+    return [...new Set(words(text).filter(word => !STOPWORDS.has(word)).map(stem).filter(word => !STOPWORDS.has(word)))];
+}
+export function keywordsOf(entry) {
+    return [...entry.examples, ...entry.aliasesKo, ...(entry.whenToUse ? terms(entry.whenToUse) : [])].map(normalize).filter(Boolean);
+}
+export function buildLexical(entries) {
+    const frequency = new Map();
+    const rows = entries.map(entry => {
+        const name = normalize(entry.name), keywords = keywordsOf(entry);
+        const weights = new Map();
+        for (const [field, weight] of [[entry.description, 1], [keywords.join(" "), 4], [name, 8]]) {
+            for (const term of terms(field))
+                weights.set(term, weight);
+        }
+        for (const term of weights.keys())
+            frequency.set(term, (frequency.get(term) ?? 0) + 1);
+        return { uri: entry.uri, name, keywords, nameTerms: new Set(terms(name)), weights };
+    });
+    const size = rows.length;
+    return {
+        search(query) {
+            const text = normalize(query);
+            if (!text)
+                return [];
+            const queryTerms = terms(text);
+            const hits = [];
+            for (const { uri, name, keywords, nameTerms, weights } of rows) {
+                const anchor = name === text ? 2 : keywords.includes(text) ? 1 : 0;
+                let score = anchor === 2 ? 1000 : anchor === 1 ? 300 : 0;
+                let anchored = anchor > 0;
+                const matched = [];
+                for (const word of queryTerms) {
+                    const weight = weights.get(word);
+                    if (!weight)
+                        continue;
+                    matched.push(word);
+                    anchored ||= nameTerms.has(word) || keywords.includes(word);
+                    const rarity = Math.log(1 + (size + .5) / ((frequency.get(word) ?? 0) + .5));
+                    score += weight * rarity;
+                }
+                if (!score || (queryTerms.length > 1 && matched.length === 1 && !anchored))
+                    continue;
+                // Prefer coverage without letting unmatched narrative details erase a result.
+                score *= 1 + matched.length / Math.max(queryTerms.length, 1);
+                hits.push({ uri, score, matched, anchor });
+            }
+            return hits.sort((a, b) => b.score - a.score || (a.uri < b.uri ? -1 : a.uri > b.uri ? 1 : 0));
+        },
+    };
+}

package/dist/server.js

@@ -0,0 +1,216 @@
+import { appendFileSync, mkdirSync, renameSync, statSync } from "node:fs";
+import { createServer } from "node:http";
+import { dirname, join } from "node:path";
+import express from "express";
+import { registerRoutes } from "./api/routes.js";
+import { authGate, deny, localOnly, requireJson } from "./api/security.js";
+import { createSseHub } from "./api/sse.js";
+import { registerStatic } from "./api/static.js";
+import { createCatalog } from "./catalog/index.js";
+import { ensureGisoolHome, ensureToken, resolveGisoolHome, resolveHome } from "./config.js";
+import { createIngestDeps } from "./ingest/pipeline.js";
+import { registerMcp } from "./mcp/http.js";
+import { packageVersion } from "./mcp/tools.js";
+import { createSearchIndex } from "./search/index.js";
+import { openDb, selfCheck } from "./store/db.js";
+import { createStore } from "./store/index.js";
+import { assertNodeVersion, assertPlatform, GisoolStartupError } from "./version.js";
+export const HOST = "127.0.0.1";
+export const LOG_MAX_BYTES = 5 * 1024 * 1024;
+const DAY_MS = 86_400_000;
+export function createFileLogger(path, maxBytes = LOG_MAX_BYTES) {
+    mkdirSync(dirname(path), { recursive: true });
+    return (msg) => {
+        try {
+            if ((statSync(path, { throwIfNoEntry: false })?.size ?? 0) >= maxBytes)
+                renameSync(path, `${path}.1`);
+            appendFileSync(path, `${new Date().toISOString()} ${msg}\n`);
+        }
+        catch (error) {
+            process.stderr.write(`gisool: cannot write ${path}: ${error.message}\n${msg}\n`);
+        }
+    };
+}
+function listen(server, port) {
+    return new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off("listening", onListening);
+            reject(error.code === "EADDRINUSE" ? new GisoolStartupError("port_in_use", `${HOST}:${port} is already in use`) : error);
+        };
+        const onListening = () => {
+            server.off("error", onError);
+            resolve(server.address().port);
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        server.listen(port, HOST);
+    });
+}
+export async function startServer(config, deps = {}) {
+    assertNodeVersion();
+    assertPlatform();
+    const gisoolHome = deps.gisoolHome ?? resolveGisoolHome(process.env);
+    if (deps.gisoolHome === undefined)
+        ensureGisoolHome(process.env);
+    else
+        mkdirSync(gisoolHome, { recursive: true, mode: 0o700 });
+    const log = deps.log ?? createFileLogger(join(gisoolHome, "logs", "daemon.log"));
+    const token = ensureToken(gisoolHome);
+    const version = packageVersion();
+    const db = openDb(join(gisoolHome, "gisool.db"));
+    const cleanup = [];
+    let store;
+    try {
+        selfCheck(db);
+        store = deps.openStore ? deps.openStore() : createStore(db, { config, gisoolHome, home: resolveHome(process.env) });
+        const ownStore = store;
+        cleanup.push(() => ownStore.close());
+        if (deps.openStore)
+            cleanup.push(() => db.close());
+        const catalog = createCatalog({ roots: config.roots, watch: true, log });
+        cleanup.push(() => catalog.close());
+        await catalog.refresh();
+        const search = createSearchIndex(db);
+        search.rebuild(catalog.list());
+        ownStore.upsertSkills(catalog.list());
+        catalog.onDelta((delta) => {
+            try {
+                search.apply(delta);
+                ownStore.upsertSkills([...delta.added, ...delta.changed]);
+                if (delta.removed.length)
+                    ownStore.markRemoved(delta.removed);
+            }
+            catch (error) {
+                log(`applying catalog delta failed: ${error.message}`);
+            }
+        });
+        const sessionRowStmt = db.prepare("SELECT runtime, started_at FROM sessions WHERE id = ?");
+        const lookupRow = (id) => {
+            const meta = sessionRowStmt.get(id);
+            if (!meta)
+                return undefined;
+            return ownStore.sessions({ from: meta.started_at, to: meta.started_at + 1, runtime: [meta.runtime] }).find((r) => r.id === id);
+        };
+        const sse = createSseHub(lookupRow, log);
+        cleanup.push(() => sse.close());
+        const ingestDeps = createIngestDeps(ownStore, {
+            captureLevel: config.captureLevel,
+            publish: (change) => sse.notify(change.sessionId),
+            log: (message, error) => log(`ingest: ${message}: ${error instanceof Error ? error.message : String(error)}`),
+        });
+        let boundPort = config.port;
+        const app = express();
+        app.disable("x-powered-by");
+        // Routes match exactly as authGate classifies them; `/API/...` must not reach an `/api/...` handler.
+        app.set("case sensitive routing", true);
+        app.use(localOnly(() => boundPort));
+        // Authenticate before parsing so unauthenticated callers cannot make the daemon buffer bodies or bump reject counters.
+        app.use(authGate(token));
+        const smallJson = express.json({ limit: "1mb" });
+        const otlpJson = express.json({ limit: "8mb" });
+        app.use((req, res, next) => {
+            const parser = req.path.startsWith("/ingest/otlp/") ? otlpJson : smallJson;
+            parser(req, res, (error) => {
+                if (!error)
+                    return next();
+                const type = error.type;
+                if (type === "entity.too.large") {
+                    ownStore.countIngest("rejected", "payload_too_large");
+                    return deny(res, 413, "payload_too_large");
+                }
+                if (req.path.startsWith("/ingest/"))
+                    ownStore.countIngest("rejected", "bad_json");
+                deny(res, 400, "bad_json");
+            });
+        });
+        app.use(requireJson((req) => {
+            if (req.path.startsWith("/ingest/"))
+                ownStore.countIngest("rejected", "unsupported_media_type");
+        }));
+        registerRoutes(app, { store: ownStore, catalog, ingest: ingestDeps, sse, version, log });
+        const mcp = registerMcp(app, { catalog, search, store: ownStore, ingest: ingestDeps, token });
+        cleanup.push(() => void mcp.close());
+        registerStatic(app, { token, ...(deps.dashboardDir ? { dir: deps.dashboardDir } : {}) });
+        app.use((_req, res) => deny(res, 404, "not_found"));
+        app.use((error, req, res, _next) => {
+            const status = error.status;
+            if (status === 400)
+                return deny(res, 400, "bad_request");
+            // serve-static raises 403 for malformed paths (e.g. encoded traversal); nothing is served, so report not_found.
+            if (status === 403 || status === 404)
+                return deny(res, 404, "not_found");
+            if (status !== undefined && status > 400 && status < 500)
+                return deny(res, status, "request_rejected");
+            log(`${req.method} ${req.path} failed: ${error.stack ?? String(error)}`);
+            if (!res.headersSent)
+                deny(res, 500, "internal_error");
+        });
+        const server = createServer(app);
+        boundPort = await listen(server, config.port);
+        let retentionTimer;
+        if (config.retentionDays !== null) {
+            const days = config.retentionDays;
+            const runRetention = () => {
+                try {
+                    log(`retention removed ${ownStore.retention(days)} sessions older than ${days} days`);
+                }
+                catch (error) {
+                    log(`retention failed: ${error.message}`);
+                }
+            };
+            runRetention();
+            retentionTimer = setInterval(runRetention, DAY_MS);
+            retentionTimer.unref();
+        }
+        let closing;
+        const onSignal = (signal) => {
+            log(`received ${signal}, shutting down`);
+            void close().then(() => process.exit(0));
+        };
+        const handleSignals = deps.handleSignals ?? true;
+        if (handleSignals) {
+            process.once("SIGINT", onSignal);
+            process.once("SIGTERM", onSignal);
+        }
+        const close = () => {
+            closing ??= (async () => {
+                if (handleSignals) {
+                    process.off("SIGINT", onSignal);
+                    process.off("SIGTERM", onSignal);
+                }
+                if (retentionTimer)
+                    clearInterval(retentionTimer);
+                await mcp.close();
+                sse.close();
+                server.closeAllConnections();
+                await new Promise((resolve) => server.close(() => resolve()));
+                for (const fn of cleanup.reverse()) {
+                    try {
+                        fn();
+                    }
+                    catch (error) {
+                        log(`shutdown step failed: ${error.message}`);
+                    }
+                }
+                log("gisool stopped");
+            })();
+            return closing;
+        };
+        log(`gisool ${version} listening on http://${HOST}:${boundPort}`);
+        return { port: boundPort, host: HOST, close };
+    }
+    catch (error) {
+        for (const fn of cleanup.reverse()) {
+            try {
+                fn();
+            }
+            catch {
+                // Startup already failed; the original error is the one worth reporting.
+            }
+        }
+        if (!store)
+            db.close();
+        log(`startup failed: ${error.message}`);
+        throw error;
+    }
+}

package/dist/store/db.js

@@ -0,0 +1,74 @@
+import { mkdirSync, readFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { GisoolStartupError } from "../version.js";
+export const SCHEMA_VERSION = 1;
+/** migrations[i] upgrades user_version i -> i + 1. */
+function migrations() {
+    return [readFileSync(new URL("./schema.sql", import.meta.url), "utf8")];
+}
+function userVersion(db) {
+    const row = db.prepare("PRAGMA user_version").get();
+    return row?.user_version ?? 0;
+}
+export function openDb(path) {
+    if (path !== ":memory:")
+        mkdirSync(dirname(path), { recursive: true });
+    const db = new DatabaseSync(path);
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA busy_timeout = 5000");
+    db.exec("PRAGMA foreign_keys = ON");
+    migrate(db);
+    return db;
+}
+export function migrate(db) {
+    const steps = migrations();
+    let version = userVersion(db);
+    while (version < steps.length) {
+        const sql = steps[version];
+        db.exec("BEGIN IMMEDIATE");
+        try {
+            db.exec(sql);
+            db.exec(`PRAGMA user_version = ${version + 1}`);
+            db.exec("COMMIT");
+        }
+        catch (error) {
+            db.exec("ROLLBACK");
+            throw error;
+        }
+        version = userVersion(db);
+    }
+}
+/**
+ * Proves FTS5 with the trigram tokenizer works and matches Korean substrings.
+ * Uses a TEMP table on the given connection (or a fresh in-memory DB) and drops it afterwards.
+ */
+export function selfCheck(db) {
+    const conn = db ?? new DatabaseSync(":memory:");
+    let ok = false;
+    let detail = "";
+    try {
+        conn.exec("DROP TABLE IF EXISTS temp.gisool_selfcheck");
+        conn.exec("CREATE VIRTUAL TABLE temp.gisool_selfcheck USING fts5(body, tokenize = 'trigram')");
+        conn.prepare("INSERT INTO temp.gisool_selfcheck(body) VALUES (?)").run("커밋 메시지 작성해줘");
+        const row = conn.prepare("SELECT count(*) AS n FROM temp.gisool_selfcheck WHERE gisool_selfcheck MATCH ?").get('"메시지"');
+        ok = (row?.n ?? 0) === 1;
+        if (!ok)
+            detail = "trigram match for '메시지' returned no rows";
+    }
+    catch (error) {
+        detail = error instanceof Error ? error.message : String(error);
+    }
+    finally {
+        try {
+            conn.exec("DROP TABLE IF EXISTS temp.gisool_selfcheck");
+        }
+        catch {
+            // Cleanup failure is irrelevant once the outcome is known; the original failure is reported below.
+        }
+        if (!db)
+            conn.close();
+    }
+    if (!ok)
+        throw new GisoolStartupError("fts5_trigram_unavailable", detail);
+}

package/dist/store/export.js

@@ -0,0 +1,199 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { DEFAULT_ROOTS, expandHome } from "../config.js";
+import { parseJson, readAliasesOverrides, storeError, writeAliasesOverrides } from "./writes.js";
+export const EXPORT_FILE = "gisool-export.json";
+export const HISTORY_FILE = "history.db";
+const HISTORY_TABLES = ["sessions", "events", "loads"];
+function tildify(path, home) {
+    const h = home.replace(/\/+$/, "");
+    if (path === h)
+        return "~";
+    if (path.startsWith(h + "/"))
+        return "~/" + path.slice(h.length + 1);
+    return path;
+}
+function readConfigFile(gisoolHome) {
+    if (!gisoolHome)
+        return undefined;
+    const p = join(gisoolHome, "config.json");
+    return existsSync(p) ? parseJson(readFileSync(p, "utf8"), {}) : undefined;
+}
+export function createPortable(ctx) {
+    const { db } = ctx;
+    const home = () => ctx.opts.home ?? homedir();
+    function existingEvalKeys() {
+        const rows = db.prepare("SELECT query, expected_uri FROM eval_cases").all();
+        return new Set(rows.map((r) => JSON.stringify([r.query, r.expected_uri])));
+    }
+    function historyPlan() {
+        const counts = { sessions: 0, events: 0, loads: 0 };
+        let skipped = 0;
+        for (const t of HISTORY_TABLES) {
+            const key = t === "loads" ? "load_id" : "id";
+            const row = db.prepare(`SELECT SUM(CASE WHEN ${key} IN (SELECT ${key} FROM main.${t}) THEN 0 ELSE 1 END) AS fresh, COUNT(*) AS total FROM hist.${t}`).get();
+            counts[t] = row.fresh ?? 0;
+            skipped += row.total - (row.fresh ?? 0);
+        }
+        return { counts, skipped };
+    }
+    function copyHistory() {
+        for (const t of HISTORY_TABLES) {
+            const key = t === "loads" ? "load_id" : "id";
+            const cols = db.prepare(`PRAGMA main.table_info(${t})`).all().map((c) => c.name).join(", ");
+            db.prepare(`INSERT INTO main.${t} (${cols}) SELECT ${cols} FROM hist.${t} WHERE ${key} NOT IN (SELECT ${key} FROM main.${t})`).run();
+        }
+    }
+    return {
+        exportTo(dir, opts) {
+            mkdirSync(dir, { recursive: true });
+            const raw = readConfigFile(ctx.opts.gisoolHome);
+            const source = raw ?? (ctx.opts.config ? { ...ctx.opts.config } : {});
+            const { token: _token, roots: rawRoots, ...config } = source;
+            void _token;
+            const roots = (Array.isArray(rawRoots) ? rawRoots : [])
+                .map((r) => ({ id: r.id, path: tildify(r.path, home()) }));
+            const evalRows = db.prepare("SELECT query, expected_uri, from_trace_id FROM eval_cases ORDER BY created_at, rowid").all();
+            const doc = {
+                version: 1,
+                config,
+                roots,
+                evalCases: evalRows.map((r) => ({ query: r.query, ...(r.expected_uri !== null ? { expectedUri: r.expected_uri } : {}),
+                    ...(r.from_trace_id !== null ? { fromTraceId: r.from_trace_id } : {}) })),
+                aliasesOverrides: readAliasesOverrides(db),
+            };
+            const out = join(dir, EXPORT_FILE);
+            writeFileSync(out, JSON.stringify(doc, null, 2) + "\n", { mode: 0o600 });
+            chmodSync(out, 0o600);
+            const history = join(dir, HISTORY_FILE);
+            rmSync(history, { force: true });
+            if (opts.withHistory) {
+                db.prepare("VACUUM INTO ?").run(resolve(history));
+                chmodSync(history, 0o600);
+            }
+        },
+        importFrom(dir, opts) {
+            const file = join(dir, EXPORT_FILE);
+            if (!existsSync(file))
+                throw storeError("no_export_found", `no ${EXPORT_FILE} in ${dir}`);
+            const doc = parseJson(readFileSync(file, "utf8"), {});
+            if (doc.version !== 1)
+                throw storeError("unsupported_export_version", `unsupported export version: ${String(doc.version)}`);
+            const apply = opts.merge;
+            const evalKeys = existingEvalKeys();
+            const evalToAdd = [];
+            let evalSkipped = 0;
+            for (const c of doc.evalCases ?? []) {
+                const key = JSON.stringify([c.query, c.expectedUri ?? null]);
+                if (evalKeys.has(key))
+                    evalSkipped++;
+                else {
+                    evalKeys.add(key);
+                    evalToAdd.push(c);
+                }
+            }
+            const currentAliases = readAliasesOverrides(db);
+            const aliasAdded = Object.keys(doc.aliasesOverrides ?? {}).filter((k) => !(k in currentAliases));
+            const aliasSkipped = Object.keys(doc.aliasesOverrides ?? {}).filter((k) => k in currentAliases);
+            const gisoolHome = ctx.opts.gisoolHome;
+            const existingRaw = readConfigFile(gisoolHome);
+            const configBase = existingRaw ?? {};
+            const existingRoots = (Array.isArray(configBase.roots) ? configBase.roots : existingRaw ? [] : DEFAULT_ROOTS);
+            const rootsAdded = [];
+            const rootsSkipped = [];
+            const configAdded = [];
+            const configKept = [];
+            if (gisoolHome) {
+                const knownPaths = new Set(existingRoots.map((r) => expandHome(r.path, home())));
+                const knownIds = new Set(existingRoots.map((r) => r.id));
+                for (const r of doc.roots ?? []) {
+                    const expanded = expandHome(r.path, home());
+                    if (knownIds.has(r.id) || knownPaths.has(expanded))
+                        rootsSkipped.push(r.id);
+                    else {
+                        rootsAdded.push({ id: r.id, path: tildify(expanded, home()) });
+                        knownIds.add(r.id);
+                        knownPaths.add(expanded);
+                    }
+                }
+                for (const k of Object.keys(doc.config ?? {})) {
+                    if (k === "token" || k === "roots")
+                        continue;
+                    if (k in configBase)
+                        configKept.push(k);
+                    else
+                        configAdded.push(k);
+                }
+            }
+            const historyPath = join(dir, HISTORY_FILE);
+            let history = null;
+            const hasHistory = existsSync(historyPath);
+            if (hasHistory) {
+                db.prepare("ATTACH DATABASE ? AS hist").run(resolve(historyPath));
+                try {
+                    const version = db.prepare("PRAGMA hist.user_version").get().user_version;
+                    if (version !== 1)
+                        throw storeError("unsupported_history_version", `history.db user_version ${version}`);
+                    const plan = historyPlan();
+                    history = { ...plan.counts, skipped: plan.skipped };
+                    if (apply) {
+                        db.exec("BEGIN IMMEDIATE");
+                        try {
+                            copyHistory();
+                            db.exec("COMMIT");
+                        }
+                        catch (error) {
+                            db.exec("ROLLBACK");
+                            throw error;
+                        }
+                    }
+                }
+                finally {
+                    db.exec("DETACH DATABASE hist");
+                }
+            }
+            if (apply) {
+                const insert = db.prepare("INSERT INTO eval_cases (id, query, expected_uri, from_trace_id, created_at) VALUES (lower(hex(randomblob(16))), ?, ?, ?, ?)");
+                db.exec("BEGIN IMMEDIATE");
+                try {
+                    for (const c of evalToAdd)
+                        insert.run(c.query, c.expectedUri ?? null, c.fromTraceId ?? null, ctx.now());
+                    if (aliasAdded.length > 0) {
+                        const next = { ...currentAliases };
+                        for (const k of aliasAdded)
+                            next[k] = doc.aliasesOverrides[k];
+                        writeAliasesOverrides(db, next);
+                    }
+                    db.exec("COMMIT");
+                }
+                catch (error) {
+                    db.exec("ROLLBACK");
+                    throw error;
+                }
+                if (gisoolHome && (rootsAdded.length > 0 || configAdded.length > 0)) {
+                    const next = { ...configBase };
+                    for (const k of configAdded)
+                        next[k] = doc.config[k];
+                    next.roots = [...existingRoots, ...rootsAdded];
+                    mkdirSync(gisoolHome, { recursive: true, mode: 0o700 });
+                    const p = join(gisoolHome, "config.json");
+                    writeFileSync(p, JSON.stringify(next, null, 2) + "\n", { mode: 0o600 });
+                    chmodSync(p, 0o600);
+                }
+            }
+            const historyAdded = history ? history.sessions + history.events + history.loads : 0;
+            return {
+                added: evalToAdd.length + rootsAdded.length + configAdded.length + aliasAdded.length + historyAdded,
+                skipped: evalSkipped + rootsSkipped.length + configKept.length + aliasSkipped.length + (history?.skipped ?? 0),
+                details: {
+                    evalCases: { added: evalToAdd.length, skipped: evalSkipped },
+                    roots: { added: rootsAdded.map((r) => r.id), skipped: rootsSkipped },
+                    configKeys: { added: configAdded, kept: configKept },
+                    aliases: { added: aliasAdded, skipped: aliasSkipped },
+                    history,
+                },
+            };
+        },
+    };
+}

package/dist/store/index.js

@@ -0,0 +1,13 @@
+import { createPortable } from "./export.js";
+import { createQueries } from "./queries.js";
+import { createWrites } from "./writes.js";
+export { EXPORT_FILE, HISTORY_FILE } from "./export.js";
+export { adoptionState, classifyTaskType, localDowHour, taskTypeRules } from "./queries.js";
+/**
+ * importFrom(dir, { merge: false }) is a dry run: it returns the same counts (plus `details`) without writing anything;
+ * { merge: true } applies, never overwriting existing config keys, roots, aliases, eval cases, sessions, or events.
+ */
+export function createStore(db, opts = {}) {
+    const ctx = { db, opts, now: opts.now ?? Date.now };
+    return { ...createWrites(ctx), ...createQueries(ctx), ...createPortable(ctx), close: () => db.close() };
+}