@neethan/joa 0.1.0

package/dist/cli/output.js

@@ -0,0 +1,22 @@
+const enabled = !process.env.NO_COLOR && process.stdout.isTTY === true;
+function wrap(code, text) {
+    return enabled ? `\x1b[${code}m${text}\x1b[0m` : text;
+}
+export const dim = (t) => wrap("2", t);
+export const bold = (t) => wrap("1", t);
+export const green = (t) => wrap("32", t);
+export const red = (t) => wrap("31", t);
+export const yellow = (t) => wrap("33", t);
+export const cyan = (t) => wrap("36", t);
+/**
+ * Colorizes a compact-formatted line.
+ * Input format: "[YYYY-MM-DD HH:mm] category: summary"
+ */
+export function colorizeCompactLine(line) {
+    if (!enabled)
+        return line;
+    const match = line.match(/^(\[[\d-]+ [\d:]+\]) ([^:]+): (.+)$/);
+    if (!match?.[1] || !match[2])
+        return line;
+    return `${dim(match[1])} ${cyan(match[2])}: ${match[3] ?? ""}`;
+}

package/dist/core/bootstrap.js

@@ -0,0 +1,39 @@
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { getDevice, loadConfig, resolveDbPath, resolveJournalsPath } from "./config.js";
+import { openDatabase } from "./db.js";
+import { ValidationError } from "./errors.js";
+import { sessionId } from "./ids.js";
+import { checkAndSyncIfStale } from "./sync.js";
+const AGENT_RE = /^[a-zA-Z0-9_-]+$/;
+const AGENT_MAX_LEN = 64;
+/** Validates an agent name: 1-64 chars, alphanumeric plus hyphens and underscores. */
+export function validateAgentName(agent) {
+    if (agent.length === 0 || agent.length > AGENT_MAX_LEN) {
+        throw new ValidationError(`agent name must be 1-${AGENT_MAX_LEN} characters, got ${agent.length}`);
+    }
+    if (!AGENT_RE.test(agent)) {
+        throw new ValidationError(`agent name must contain only alphanumeric characters, hyphens, and underscores: "${agent}"`);
+    }
+}
+export async function bootstrap(opts) {
+    const config = loadConfig();
+    const dbPath = resolveDbPath(config);
+    mkdirSync(dirname(dbPath), { recursive: true });
+    mkdirSync(resolveJournalsPath(config), { recursive: true });
+    const db = await openDatabase(dbPath);
+    await checkAndSyncIfStale(db, resolveJournalsPath(config));
+    const sid = sessionId();
+    const agent = opts?.agent ?? config.defaults.agent ?? "cli";
+    validateAgentName(agent);
+    const readCtx = { db };
+    const logCtx = {
+        db,
+        journalsDir: resolveJournalsPath(config),
+        sessionId: sid,
+        agent,
+        device: getDevice(config),
+        defaultTags: config.defaults.tags,
+    };
+    return { config, db, readCtx, logCtx, sid };
+}

package/dist/core/config.js

@@ -0,0 +1,131 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import yaml from "js-yaml";
+import { ConfigError } from "./errors.js";
+/** Returns the hardcoded default configuration. */
+export function defaultConfig() {
+    return {
+        defaults: {
+            device: null,
+            agent: null,
+            tags: [],
+        },
+        db: { path: "~/.joa/journal.db" },
+        journals: { path: "~/.joa/journals" },
+        presets: {
+            catchup: {
+                default_limit: 50,
+            },
+            threads: { thread_limit: 20 },
+            timeline: { default_limit: 50 },
+            decisions: { categories: ["decision"], default_limit: 50 },
+            changes: { categories: ["file change"], default_limit: 50 },
+        },
+    };
+}
+function expandTilde(p) {
+    if (p.startsWith("~/")) {
+        return join(homedir(), p.slice(2));
+    }
+    return p;
+}
+function loadYamlFile(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    try {
+        const content = readFileSync(filePath, "utf8");
+        const parsed = yaml.load(content);
+        if (parsed === null || parsed === undefined)
+            return null;
+        if (typeof parsed !== "object") {
+            throw new ConfigError(`Failed to parse config: ${filePath}`);
+        }
+        return parsed;
+    }
+    catch (e) {
+        if (e instanceof ConfigError)
+            throw e;
+        throw new ConfigError(`Failed to parse config: ${filePath}`, { cause: e });
+    }
+}
+function mergeConfig(base, overlay, additiveTags) {
+    const result = structuredClone(base);
+    const defaults = overlay.defaults;
+    if (defaults) {
+        if (defaults.device !== undefined)
+            result.defaults.device = defaults.device;
+        if (defaults.agent !== undefined)
+            result.defaults.agent = defaults.agent;
+        if (Array.isArray(defaults.tags)) {
+            if (additiveTags) {
+                result.defaults.tags = [...result.defaults.tags, ...defaults.tags];
+            }
+            else {
+                result.defaults.tags = defaults.tags;
+            }
+        }
+    }
+    const db = overlay.db;
+    if (db?.path)
+        result.db.path = db.path;
+    const journals = overlay.journals;
+    if (journals?.path)
+        result.journals.path = journals.path;
+    const presets = overlay.presets;
+    if (presets) {
+        for (const [key, value] of Object.entries(presets)) {
+            if (value && typeof value === "object") {
+                result.presets[key] = {
+                    ...result.presets[key],
+                    ...value,
+                };
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Loads and merges configuration.
+ * 1. Start with defaultConfig()
+ * 2. Merge global ~/.joa/config.yaml
+ * 3. Walk CWD upward to homedir, load nearest .joa.yaml (tags are additive)
+ */
+export function loadConfig(cwd) {
+    let config = defaultConfig();
+    // Global config
+    const globalPath = join(homedir(), ".joa", "config.yaml");
+    const globalOverlay = loadYamlFile(globalPath);
+    if (globalOverlay) {
+        config = mergeConfig(config, globalOverlay, false);
+    }
+    // Directory config — walk upward from cwd, stop at homedir
+    const home = homedir();
+    const startDir = resolve(cwd ?? process.cwd());
+    let dir = startDir;
+    while (true) {
+        const candidate = join(dir, ".joa.yaml");
+        const dirOverlay = loadYamlFile(candidate);
+        if (dirOverlay) {
+            config = mergeConfig(config, dirOverlay, true);
+            break; // only nearest
+        }
+        const parent = dirname(dir);
+        if (parent === dir || dir === home)
+            break;
+        dir = parent;
+    }
+    return config;
+}
+/** Returns the device name from config, falling back to hostname. */
+export function getDevice(config) {
+    return config.defaults.device ?? hostname();
+}
+/** Resolves the database path, expanding ~ to the home directory. */
+export function resolveDbPath(config) {
+    return expandTilde(config.db.path);
+}
+/** Resolves the journals directory path, expanding ~ to the home directory. */
+export function resolveJournalsPath(config) {
+    return expandTilde(config.journals.path);
+}

package/dist/core/context.js

@@ -0,0 +1 @@
+export {};

package/dist/core/db.js

@@ -0,0 +1,254 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { statSync } from "node:fs";
+import { serializeEntry } from "./entry.js";
+import { DatabaseError } from "./errors.js";
+// Runtime shim: bun:sqlite under Bun, better-sqlite3 under Node.js.
+// Lazily resolved on first openDatabase() call so that importing this module
+// does not trigger a top-level await — fast-exit paths (--help, --version)
+// never pay the cost of dynamically importing the SQLite driver.
+let _DatabaseCtor = null;
+async function getDatabaseCtor() {
+    if (_DatabaseCtor)
+        return _DatabaseCtor;
+    // String concatenation prevents tsc/Node from resolving the bun: specifier.
+    const isBun = typeof globalThis.Bun !== "undefined";
+    if (isBun) {
+        const mod = await import(__rewriteRelativeImportExtension("bun:" + "sqlite"));
+        _DatabaseCtor = mod.Database;
+    }
+    else {
+        const mod = await import("better-sqlite3");
+        _DatabaseCtor = mod.default;
+    }
+    return _DatabaseCtor;
+}
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS metadata (
+  key   TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS entries (
+  id          TEXT PRIMARY KEY,
+  timestamp   TEXT NOT NULL,
+  category    TEXT NOT NULL,
+  summary     TEXT NOT NULL,
+  thread_id   TEXT,
+  session_id  TEXT,
+  agent       TEXT,
+  device      TEXT,
+  resources   TEXT,
+  tags        TEXT,
+  detail      TEXT,
+  annotations TEXT,
+  created_at  TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- NOTE: FTS5 external content table. INSERT is handled in writeEntry transaction.
+-- DELETE/UPDATE requires manual FTS cleanup — must be implemented when entry
+-- deletion is added. See: https://www.sqlite.org/fts5.html#external_content_tables
+CREATE VIRTUAL TABLE IF NOT EXISTS entries_fts USING fts5(
+  summary, detail, resources, tags,
+  content=entries,
+  content_rowid=rowid,
+  tokenize='porter'
+);
+
+CREATE INDEX IF NOT EXISTS idx_entries_timestamp      ON entries(timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_entries_category       ON entries(category);
+CREATE INDEX IF NOT EXISTS idx_entries_thread         ON entries(thread_id);
+CREATE INDEX IF NOT EXISTS idx_entries_session        ON entries(session_id);
+CREATE INDEX IF NOT EXISTS idx_entries_agent          ON entries(agent);
+CREATE INDEX IF NOT EXISTS idx_entries_device         ON entries(device);
+CREATE INDEX IF NOT EXISTS idx_entries_thread_ts      ON entries(thread_id, timestamp DESC);
+
+CREATE VIEW IF NOT EXISTS thread_summary AS
+SELECT
+  e.thread_id,
+  COUNT(*)                              AS entry_count,
+  MIN(e.timestamp)                      AS first_entry_at,
+  MAX(e.timestamp)                      AS last_active_at,
+  (SELECT summary FROM entries
+   WHERE thread_id = e.thread_id
+   ORDER BY timestamp ASC LIMIT 1)     AS first_summary,
+  GROUP_CONCAT(DISTINCT e.agent)        AS agents
+FROM entries e
+WHERE e.thread_id IS NOT NULL
+GROUP BY e.thread_id
+ORDER BY last_active_at DESC;
+`;
+function buildWhereClause(params) {
+    const conditions = [];
+    const values = [];
+    if (params.thread_id) {
+        conditions.push("e.thread_id = ?");
+        values.push(params.thread_id);
+    }
+    if (params.session_id) {
+        conditions.push("e.session_id = ?");
+        values.push(params.session_id);
+    }
+    if (params.category) {
+        conditions.push("e.category = ?");
+        values.push(params.category.trim().toLowerCase());
+    }
+    if (params.agent) {
+        conditions.push("e.agent = ?");
+        values.push(params.agent);
+    }
+    if (params.device) {
+        conditions.push("e.device = ?");
+        values.push(params.device);
+    }
+    if (params.since) {
+        conditions.push("e.timestamp >= ?");
+        values.push(params.since);
+    }
+    if (params.until) {
+        conditions.push("e.timestamp <= ?");
+        values.push(params.until);
+    }
+    if (params.tags?.length) {
+        for (const tag of params.tags) {
+            conditions.push("e.id IN (SELECT je.id FROM entries je, json_each(je.tags) AS t WHERE t.value = ?)");
+            values.push(tag);
+        }
+    }
+    if (params.search) {
+        conditions.push("e.rowid IN (SELECT rowid FROM entries_fts WHERE entries_fts MATCH ?)");
+        values.push(params.search);
+    }
+    const sql = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    return { sql, values };
+}
+/** Opens and initializes the joa SQLite database. Returns a JoaDb instance. */
+export async function openDatabase(dbPath) {
+    const DatabaseCtor = await getDatabaseCtor();
+    const db = new DatabaseCtor(dbPath);
+    db.exec("PRAGMA journal_mode = WAL;");
+    db.exec("PRAGMA synchronous = NORMAL;");
+    db.exec("PRAGMA foreign_keys = ON;");
+    db.exec("PRAGMA cache_size = -32000;");
+    db.exec("PRAGMA busy_timeout = 5000;");
+    db.exec(SCHEMA);
+    // Prepared statements
+    const insertEntry = db.prepare(`
+    INSERT OR IGNORE INTO entries
+      (id, timestamp, category, summary, thread_id, session_id, agent, device, resources, tags, detail, annotations)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    const insertFts = db.prepare(`
+    INSERT INTO entries_fts(rowid, summary, detail, resources, tags)
+    SELECT rowid, summary, detail, resources, tags FROM entries WHERE id = ?
+  `);
+    const getMetadata = db.prepare("SELECT value FROM metadata WHERE key = ?");
+    const setMetadata = db.prepare("INSERT INTO metadata (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value");
+    const countByCat = db.prepare("SELECT category, COUNT(*) as cnt FROM entries GROUP BY category");
+    const tsRange = db.prepare("SELECT MIN(timestamp) as oldest, MAX(timestamp) as newest FROM entries");
+    const threadSummary = db.prepare("SELECT * FROM thread_summary LIMIT ?");
+    return {
+        writeEntry(entry) {
+            try {
+                const row = serializeEntry(entry);
+                db.transaction(() => {
+                    const result = insertEntry.run(row.id, row.timestamp, row.category, row.summary, row.thread_id, row.session_id, row.agent, row.device, row.resources, row.tags, row.detail, row.annotations);
+                    if (result.changes > 0) {
+                        insertFts.run(row.id);
+                    }
+                })();
+            }
+            catch (cause) {
+                throw new DatabaseError("Failed to write entry to database", { cause });
+            }
+        },
+        writeEntries(entries) {
+            try {
+                db.transaction(() => {
+                    for (const entry of entries) {
+                        const row = serializeEntry(entry);
+                        const result = insertEntry.run(row.id, row.timestamp, row.category, row.summary, row.thread_id, row.session_id, row.agent, row.device, row.resources, row.tags, row.detail, row.annotations);
+                        if (result.changes > 0) {
+                            insertFts.run(row.id);
+                        }
+                    }
+                })();
+            }
+            catch (cause) {
+                throw new DatabaseError("Failed to write entries to database", { cause });
+            }
+        },
+        clearEntries() {
+            db.exec("DELETE FROM entries_fts");
+            db.exec("DELETE FROM entries");
+        },
+        queryEntries(params) {
+            const { sql: where, values } = buildWhereClause(params);
+            let query = `SELECT e.* FROM entries e ${where} ORDER BY e.timestamp DESC`;
+            if (params.limit) {
+                query += " LIMIT ?";
+                values.push(params.limit);
+            }
+            return db.prepare(query).all(...values);
+        },
+        countEntries(params) {
+            const { sql: where, values } = buildWhereClause(params);
+            const query = `SELECT COUNT(*) as cnt FROM entries e ${where}`;
+            const row = db.prepare(query).get(...values);
+            return row?.cnt ?? 0;
+        },
+        queryThreadSummary(limit) {
+            return threadSummary.all(limit);
+        },
+        countByCategory() {
+            const rows = countByCat.all();
+            const result = {};
+            for (const row of rows) {
+                result[row.category] = row.cnt;
+            }
+            return result;
+        },
+        getEntryTimestampRange() {
+            const row = tsRange.get();
+            return { oldest: row?.oldest ?? null, newest: row?.newest ?? null };
+        },
+        getLastIndexedAt() {
+            const row = getMetadata.get("last_indexed_at");
+            return row?.value ?? null;
+        },
+        setLastIndexedAt(ts) {
+            setMetadata.run("last_indexed_at", ts);
+        },
+        rebuildFts() {
+            db.exec("INSERT INTO entries_fts(entries_fts) VALUES('rebuild')");
+        },
+        getDbSizeBytes() {
+            if (dbPath === ":memory:")
+                return 0;
+            try {
+                return statSync(dbPath).size;
+            }
+            catch {
+                return 0;
+            }
+        },
+        isHealthy() {
+            try {
+                const row = db.prepare("PRAGMA integrity_check").get();
+                return row?.integrity_check === "ok";
+            }
+            catch {
+                return false;
+            }
+        },
+        close() {
+            db.close();
+        },
+    };
+}

package/dist/core/entry.js

@@ -0,0 +1,84 @@
+import { InvalidThreadId, ValidationError } from "./errors.js";
+import { isThreadId } from "./ids.js";
+/** Normalizes a category string: lowercase + trim. Throws if empty after normalization. */
+export function normalizeCategory(category) {
+    const normalized = category.trim().toLowerCase();
+    if (normalized.length === 0) {
+        throw new ValidationError("category must not be empty");
+    }
+    return normalized;
+}
+/** Converts an Entry to an EntryRow for SQLite storage. */
+export function serializeEntry(entry) {
+    return {
+        id: entry.id,
+        timestamp: entry.timestamp,
+        category: entry.category,
+        summary: entry.summary,
+        thread_id: entry.thread_id,
+        session_id: entry.session_id,
+        agent: entry.agent,
+        device: entry.device,
+        resources: JSON.stringify(entry.resources),
+        tags: JSON.stringify(entry.tags),
+        detail: JSON.stringify(entry.detail),
+        annotations: JSON.stringify(entry.annotations),
+    };
+}
+/** Converts an EntryRow from SQLite back to an Entry. */
+export function deserializeEntry(row) {
+    return {
+        id: row.id,
+        timestamp: row.timestamp,
+        category: row.category,
+        summary: row.summary,
+        thread_id: row.thread_id,
+        session_id: row.session_id,
+        agent: row.agent,
+        device: row.device,
+        resources: JSON.parse(row.resources),
+        tags: JSON.parse(row.tags),
+        detail: JSON.parse(row.detail),
+        annotations: JSON.parse(row.annotations),
+    };
+}
+/** Validates EntryInput. Throws ValidationError or InvalidThreadId before any I/O. */
+export function validateEntryInput(input) {
+    // category
+    const cat = input.category?.trim().toLowerCase() ?? "";
+    if (cat.length === 0) {
+        throw new ValidationError("category must not be empty");
+    }
+    // summary
+    if (!input.summary || input.summary.trim().length === 0) {
+        throw new ValidationError("summary must not be empty");
+    }
+    // thread_id
+    if (input.thread_id !== undefined && input.thread_id !== null) {
+        if (input.thread_id !== "new" && !isThreadId(input.thread_id)) {
+            throw new InvalidThreadId(`Invalid thread_id: "${input.thread_id}". Must be null, "new", or a th_ prefixed ULID.`);
+        }
+    }
+    // tags
+    if (input.tags) {
+        for (const tag of input.tags) {
+            if (typeof tag !== "string") {
+                throw new ValidationError("tags must be strings");
+            }
+            if (tag.trim().length === 0) {
+                throw new ValidationError("tag must not be empty");
+            }
+            if (tag.includes('"') || tag.includes("\\")) {
+                throw new ValidationError('tag must not contain " or \\');
+            }
+        }
+    }
+    // resources
+    if (input.resources) {
+        for (const r of input.resources) {
+            if (typeof r !== "string") {
+                throw new ValidationError("resources must be strings");
+            }
+        }
+    }
+}

package/dist/core/errors.js

@@ -0,0 +1,24 @@
+/** Base error for all joa errors. */
+export class JoaError extends Error {
+    name = "JoaError";
+}
+/** Thrown when input validation fails. */
+export class ValidationError extends JoaError {
+    name = "ValidationError";
+}
+/** Thrown when a thread_id is malformed. */
+export class InvalidThreadId extends ValidationError {
+    name = "InvalidThreadId";
+}
+/** Thrown when a database operation fails. */
+export class DatabaseError extends JoaError {
+    name = "DatabaseError";
+}
+/** Thrown when a JSONL journal write fails. */
+export class JournalWriteError extends JoaError {
+    name = "JournalWriteError";
+}
+/** Thrown when config loading or parsing fails. */
+export class ConfigError extends JoaError {
+    name = "ConfigError";
+}

package/dist/core/formatters.js

@@ -0,0 +1,54 @@
+/**
+ * Formats entries as Markdown for agent context windows.
+ * Compact enough for context efficiency; structured for readability.
+ */
+export function formatMd(entries) {
+    if (entries.length === 0) {
+        return "No entries found.";
+    }
+    const parts = [];
+    for (const entry of entries) {
+        const date = entry.timestamp.slice(0, 10);
+        let block = `## ${date} \u00b7 ${entry.category}\n\n`;
+        block += `**${entry.summary}**\n`;
+        const meta = [];
+        if (entry.thread_id)
+            meta.push(`Thread: ${entry.thread_id}`);
+        if (entry.session_id)
+            meta.push(`Session: ${entry.session_id}`);
+        if (entry.agent)
+            meta.push(`Agent: ${entry.agent}`);
+        if (meta.length > 0) {
+            block += `${meta.join(" \u00b7 ")}\n`;
+        }
+        if (entry.tags.length > 0) {
+            block += `Tags: ${entry.tags.join(", ")}\n`;
+        }
+        if (Object.keys(entry.detail).length > 0) {
+            block += `\nDetail: ${JSON.stringify(entry.detail)}\n`;
+        }
+        parts.push(block);
+    }
+    return parts.join("\n---\n\n");
+}
+/**
+ * Formats entries as a JSON string (JSON.stringify with 2-space indent).
+ */
+export function formatJson(entries) {
+    return JSON.stringify(entries, null, 2);
+}
+/**
+ * Formats entries as plain text (ANSI color to be added in Phase 1B CLI).
+ */
+export function formatCompact(entries) {
+    if (entries.length === 0) {
+        return "No entries found.";
+    }
+    return entries
+        .map((e) => {
+        const date = e.timestamp.slice(0, 10);
+        const time = e.timestamp.slice(11, 16);
+        return `[${date} ${time}] ${e.category}: ${e.summary}`;
+    })
+        .join("\n");
+}

package/dist/core/ids.js

@@ -0,0 +1,26 @@
+import { monotonicFactory } from "ulidx";
+const mono = monotonicFactory();
+/** Generate a new entry ID (e_<ulid>). */
+export function entryId() {
+    return `e_${mono()}`;
+}
+/** Generate a new thread ID (th_<ulid>). */
+export function threadId() {
+    return `th_${mono()}`;
+}
+/** Generate a new session ID (s_<ulid>). Call once at process start; pass through LogContext. */
+export function sessionId() {
+    return `s_${mono()}`;
+}
+/** Check if a string is a valid entry ID. */
+export function isEntryId(id) {
+    return id.startsWith("e_") && id.length === 28;
+}
+/** Check if a string is a valid thread ID. */
+export function isThreadId(id) {
+    return id.startsWith("th_") && id.length === 29;
+}
+/** Check if a string is a valid session ID. */
+export function isSessionId(id) {
+    return id.startsWith("s_") && id.length === 28;
+}

package/dist/core/import.js

@@ -0,0 +1,34 @@
+import { deserializeEntry } from "./entry.js";
+import { appendEntry } from "./journal.js";
+/**
+ * Import entries from JSONL lines into the journal + database.
+ * Validates each line, skips malformed entries and duplicates.
+ */
+export async function importEntries(lines, db, journalsDir) {
+    const countBefore = db.countEntries({});
+    let parsedCount = 0;
+    let malformed = 0;
+    for (const line of lines) {
+        try {
+            const parsed = JSON.parse(line);
+            if (typeof parsed !== "object" ||
+                !parsed ||
+                typeof parsed.id !== "string" ||
+                typeof parsed.summary !== "string") {
+                malformed++;
+                continue;
+            }
+            const entry = deserializeEntry(parsed);
+            await appendEntry(entry, journalsDir);
+            db.writeEntry(entry);
+            parsedCount++;
+        }
+        catch {
+            malformed++;
+        }
+    }
+    const countAfter = db.countEntries({});
+    const imported = countAfter - countBefore;
+    const skipped = parsedCount - imported;
+    return { imported, skipped, malformed };
+}