sensemaking 0.12.2 → 0.13.0

package/dist/cjs/db/open.js

@@ -0,0 +1,223 @@
+// The Node floor (>=22.20) is explained here and nowhere else: 22.20 is the first release with
+// both FTS5 and row-returning INSERT ... RETURNING. Raise it only for a load-bearing capability.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DB_FILENAME () {
+        return DB_FILENAME;
+    },
+    get SCHEMA_VERSION () {
+        return SCHEMA_VERSION;
+    },
+    get clearCache () {
+        return clearCache;
+    },
+    get docCount () {
+        return docCount;
+    },
+    get open () {
+        return open;
+    }
+});
+var _nodefs = require("node:fs");
+var _nodepath = require("node:path");
+var _nodesqlite = require("node:sqlite");
+var _indexts = require("../config/index.js");
+var _errorsts = require("../errors.js");
+var _indexts1 = require("../features/index.js");
+var _sqlfunctionsts = require("../sql-functions.js");
+var _reconcilets = require("./reconcile.js");
+var _sharedts = require("./shared.js");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var DB_FILENAME = 'cache.db';
+var SCHEMA_VERSION = '13';
+// Stemming is English-only, but the segmentation underneath it is what decides coverage:
+// unicode61 splits on spaces, so a language written without them (Chinese, Japanese, Thai)
+// indexes a whole run as one token and word search finds nothing. `content.tokenize` is how
+// such a tree picks trigram instead.
+var DEFAULT_TOKENIZE = 'porter unicode61';
+// FTS5 takes its tokenizer as a string literal inside DDL, where nothing can bind, so a
+// configured value has to be concatenated. Probing a throwaway table is what makes that safe
+// and is also the whole validation: anything the linked SQLite accepts passes, anything else
+// fails here with SQLite's own message rather than against the real table. It means no table
+// of which version added which tokenizer has to be maintained.
+function resolveTokenize(db, cfg) {
+    var configured = (0, _indexts.contentTokenize)(cfg);
+    if (configured === undefined) return DEFAULT_TOKENIZE;
+    var literal = configured.replace(/'/g, "''");
+    try {
+        db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');
+        db.exec("CREATE VIRTUAL TABLE temp.sense_tokenize_probe USING fts5(x, tokenize = '".concat(literal, "')"));
+        db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');
+    } catch (err) {
+        throw new _errorsts.SenseError('CONFIG_INVALID', 'content.tokenize "'.concat(configured, '" is not a tokenizer this SQLite accepts (').concat(err.message, "); the built-in choices are unicode61, ascii, porter, and trigram, each with their own options"));
+    }
+    return literal;
+}
+// The tokenizer the content table was actually built with, from its own DDL -- the one
+// record that cannot desynchronize from the table. NULL when the table does not exist yet.
+function storedTokenize(db) {
+    var row = db.prepare("SELECT sql FROM sqlite_master WHERE name = 'content'").get();
+    if (!row) return null;
+    var m = row.sql.match(/tokenize = '((?:[^']|'')*)'/);
+    return m ? m[1] : null;
+}
+// Content is a separate table (not a column on frontmatter) so `SELECT * FROM frontmatter`
+// can't dump file text into context. Features add their own tables after the core ones.
+function ensureSchema(db, cfg, tokenize) {
+    db.exec('CREATE TABLE IF NOT EXISTS frontmatter ("path" TEXT PRIMARY KEY, "_mtime" REAL, "_ctime" REAL, "_size" INTEGER, "_parse_error" TEXT)');
+    // IF NOT EXISTS is safe against a tokenizer change: open() compares the table's own DDL
+    // against the resolved tokenizer before this runs, so a stale table is already gone by now.
+    // The three `_seg` sidecars are appended after path, never inserted: bm25(content, ...) and
+    // snippet(content, 2, ...) are documented against the first three columns and keep working
+    // (FTS5 defaults the weights it was not given). Each carries its field's exploded unspaced
+    // runs for text that needs it, and an empty string for text that does not.
+    db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS content USING fts5(title, summary, text, path UNINDEXED, title_seg, summary_seg, text_seg, tokenize = '".concat(tokenize, "')"));
+    // Coverage, not ownership: a path can appear under several presets. path leads the PK so the
+    // per-doc delete is an index hit -- keyed the other way, cold builds went quadratic.
+    db.exec('CREATE TABLE IF NOT EXISTS preset_files ("path" TEXT, preset TEXT, PRIMARY KEY ("path", preset))');
+    db.exec('CREATE INDEX IF NOT EXISTS preset_files_preset ON preset_files(preset)');
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = (0, _indexts1.activeFeatures)(cfg)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var feature = _step.value;
+            feature.schema(db);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    if ((0, _sharedts.getMeta)(db, 'schema_version') === null) (0, _sharedts.setMeta)(db, 'schema_version', SCHEMA_VERSION);
+    if ((0, _sharedts.getMeta)(db, 'features') === null) (0, _sharedts.setMeta)(db, 'features', (0, _indexts.featureSignature)(cfg));
+}
+function docCount(db) {
+    var row = db.prepare('SELECT COUNT(*) AS n FROM frontmatter').get();
+    return row.n;
+}
+function open(cfg) {
+    var _getMeta;
+    var stateDir = (0, _nodepath.join)(cfg.baseDir, _indexts.STATE_DIR);
+    (0, _nodefs.mkdirSync)(stateDir, {
+        recursive: true
+    });
+    var dbPath = (0, _nodepath.join)(stateDir, DB_FILENAME);
+    var db = new _nodesqlite.DatabaseSync(dbPath);
+    db.exec('PRAGMA journal_mode = WAL');
+    // Covers a concurrent watcher's bulk reconcile (~5s for 500 files at 26k notes). A query
+    // that outwaits it still fails loudly.
+    db.exec('PRAGMA busy_timeout = 30000');
+    (0, _sqlfunctionsts.registerFunctions)(db, (0, _indexts.contentTokenize)(cfg) === undefined);
+    db.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)');
+    // Before the rebuild branch below, never after: that branch deletes the cache, so a typo'd
+    // tokenizer validated later would cost a full re-index (and re-embed) to reach its own error.
+    var tokenize = resolveTokenize(db, cfg);
+    // Schema-version or feature-set mismatch: reconcile only reparses changed files, so an
+    // old cache can't be patched incrementally -- rebuild instead (cheap: nothing expensive lives here).
+    var version = (0, _sharedts.getMeta)(db, 'schema_version');
+    var features = (0, _sharedts.getMeta)(db, 'features');
+    var wantFeatures = (0, _indexts.featureSignature)(cfg);
+    var tokenizeOnlyRebuild = false;
+    if (version !== null && version !== SCHEMA_VERSION || features !== null && features !== wantFeatures) {
+        // Indexing derives from presets, so a config edit rebuilding the cache must say so and
+        // name what changed -- silent rebuilds make derived indexing look like a hang or a bug.
+        if (version !== null && version !== SCHEMA_VERSION) {
+            console.error('sense: cache format changed (new sensemaking version); rebuilding the index');
+            db.close();
+            clearCache(cfg);
+            return open(cfg);
+        }
+        var changedKeys = (0, _reconcilets.changedSignatureKeys)(features !== null && features !== void 0 ? features : '', wantFeatures);
+        // Only the tokenizer moved: frontmatter, links, sections, and embeddings are file-derived
+        // and tokenizer-independent, so they don't need re-deriving. Everything else -- a preset
+        // edit, an embed model change -- still takes the full clear/reopen below.
+        if (changedKeys.size === 1 && changedKeys.has('tokenize')) {
+            console.error('sense: config change (content tokenizer) rebuilds the text index; vectors, links, and sections are kept');
+            db.exec('DROP TABLE content');
+            tokenizeOnlyRebuild = true;
+        } else {
+            var changed = (0, _reconcilets.signatureDiff)(features !== null && features !== void 0 ? features : '', wantFeatures);
+            console.error("sense: config change (".concat(changed, ") rebuilds the index"));
+            db.close();
+            clearCache(cfg);
+            return open(cfg);
+        }
+    }
+    // Meta can lie after a crash between table creation and the signature write; the table's
+    // own DDL cannot. A mismatch here rebuilds no matter what meta says. A tokenize-only rebuild
+    // just dropped content above, so storedTokenize sees no table and this guard is skipped
+    // naturally rather than needing its own case.
+    var stored = storedTokenize(db);
+    if (stored !== null && stored !== tokenize) {
+        console.error('sense: cache was built with a different content tokenizer; rebuilding the index');
+        db.close();
+        clearCache(cfg);
+        return open(cfg);
+    }
+    ensureSchema(db, cfg, tokenize);
+    var rebuildWarnings = [];
+    if (tokenizeOnlyRebuild) {
+        rebuildWarnings = (0, _reconcilets.rebuildContentTable)(db, cfg, cfg.baseDir);
+        (0, _sharedts.setMeta)(db, 'features', wantFeatures);
+    }
+    // 3x the largest reconcile this cache has recorded, floored at 30s and capped at 10min.
+    // Installed before reconcile() -- that call is the one that races a watcher's transaction.
+    var recordedMaxMs = Number((_getMeta = (0, _sharedts.getMeta)(db, 'reconcile_max_ms')) !== null && _getMeta !== void 0 ? _getMeta : '0');
+    db.exec("PRAGMA busy_timeout = ".concat(Math.min(Math.max(30000, 3 * recordedMaxMs), 600000)));
+    var _reconcile = (0, _reconcilets.reconcile)(db, cfg, cfg.baseDir), parsed = _reconcile.parsed, warnings = _reconcile.warnings;
+    return {
+        db: db,
+        cfg: cfg,
+        dbPath: dbPath,
+        parsed: parsed,
+        warnings: _to_consumable_array(rebuildWarnings).concat(_to_consumable_array(warnings))
+    };
+}
+function clearCache(cfg) {
+    (0, _nodefs.rmSync)((0, _nodepath.join)(cfg.baseDir, _indexts.STATE_DIR), {
+        recursive: true,
+        force: true
+    });
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/db/open.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/db/open.ts"],"sourcesContent":["// The Node floor (>=22.20) is explained here and nowhere else: 22.20 is the first release with\n// both FTS5 and row-returning INSERT ... RETURNING. Raise it only for a load-bearing capability.\nimport { mkdirSync, rmSync } from 'node:fs';\nimport { join } from 'node:path';\nimport { DatabaseSync } from 'node:sqlite';\nimport type { Config, ResolvedConfig } from '../config/index.ts';\nimport { contentTokenize, featureSignature, STATE_DIR } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { activeFeatures } from '../features/index.ts';\nimport { registerFunctions } from '../sql-functions.ts';\nimport { changedSignatureKeys, rebuildContentTable, reconcile, signatureDiff } from './reconcile.ts';\nimport { getMeta, setMeta } from './shared.ts';\n\nexport const DB_FILENAME = 'cache.db';\n// Cache shape version, independent of the config's own `version`. Bumping it rebuilds\n// existing trees on first query.\nexport const SCHEMA_VERSION = '13';\n\nexport interface OpenResult {\n  db: DatabaseSync;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n}\n\n// Stemming is English-only, but the segmentation underneath it is what decides coverage:\n// unicode61 splits on spaces, so a language written without them (Chinese, Japanese, Thai)\n// indexes a whole run as one token and word search finds nothing. `content.tokenize` is how\n// such a tree picks trigram instead.\nconst DEFAULT_TOKENIZE = 'porter unicode61';\n\n// FTS5 takes its tokenizer as a string literal inside DDL, where nothing can bind, so a\n// configured value has to be concatenated. Probing a throwaway table is what makes that safe\n// and is also the whole validation: anything the linked SQLite accepts passes, anything else\n// fails here with SQLite's own message rather than against the real table. It means no table\n// of which version added which tokenizer has to be maintained.\nfunction resolveTokenize(db: DatabaseSync, cfg: Config): string {\n  const configured = contentTokenize(cfg);\n  if (configured === undefined) return DEFAULT_TOKENIZE;\n  const literal = configured.replace(/'/g, \"''\");\n  try {\n    db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');\n    db.exec(`CREATE VIRTUAL TABLE temp.sense_tokenize_probe USING fts5(x, tokenize = '${literal}')`);\n    db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');\n  } catch (err) {\n    throw new SenseError('CONFIG_INVALID', `content.tokenize \"${configured}\" is not a tokenizer this SQLite accepts (${(err as Error).message}); the built-in choices are unicode61, ascii, porter, and trigram, each with their own options`);\n  }\n  return literal;\n}\n\n// The tokenizer the content table was actually built with, from its own DDL -- the one\n// record that cannot desynchronize from the table. NULL when the table does not exist yet.\nfunction storedTokenize(db: DatabaseSync): string | null {\n  const row = db.prepare(`SELECT sql FROM sqlite_master WHERE name = 'content'`).get() as { sql: string } | undefined;\n  if (!row) return null;\n  const m = row.sql.match(/tokenize = '((?:[^']|'')*)'/);\n  return m ? m[1] : null;\n}\n\n// Content is a separate table (not a column on frontmatter) so `SELECT * FROM frontmatter`\n// can't dump file text into context. Features add their own tables after the core ones.\nfunction ensureSchema(db: DatabaseSync, cfg: Config, tokenize: string): void {\n  db.exec(`CREATE TABLE IF NOT EXISTS frontmatter (\"path\" TEXT PRIMARY KEY, \"_mtime\" REAL, \"_ctime\" REAL, \"_size\" INTEGER, \"_parse_error\" TEXT)`);\n  // IF NOT EXISTS is safe against a tokenizer change: open() compares the table's own DDL\n  // against the resolved tokenizer before this runs, so a stale table is already gone by now.\n  // The three `_seg` sidecars are appended after path, never inserted: bm25(content, ...) and\n  // snippet(content, 2, ...) are documented against the first three columns and keep working\n  // (FTS5 defaults the weights it was not given). Each carries its field's exploded unspaced\n  // runs for text that needs it, and an empty string for text that does not.\n  db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS content USING fts5(title, summary, text, path UNINDEXED, title_seg, summary_seg, text_seg, tokenize = '${tokenize}')`);\n  // Coverage, not ownership: a path can appear under several presets. path leads the PK so the\n  // per-doc delete is an index hit -- keyed the other way, cold builds went quadratic.\n  db.exec(`CREATE TABLE IF NOT EXISTS preset_files (\"path\" TEXT, preset TEXT, PRIMARY KEY (\"path\", preset))`);\n  db.exec('CREATE INDEX IF NOT EXISTS preset_files_preset ON preset_files(preset)');\n  for (const feature of activeFeatures(cfg)) feature.schema(db);\n  if (getMeta(db, 'schema_version') === null) setMeta(db, 'schema_version', SCHEMA_VERSION);\n  if (getMeta(db, 'features') === null) setMeta(db, 'features', featureSignature(cfg));\n}\n\nexport function docCount(db: DatabaseSync): number {\n  const row = db.prepare('SELECT COUNT(*) AS n FROM frontmatter').get() as { n: number };\n  return row.n;\n}\n\nexport function open(cfg: ResolvedConfig): OpenResult {\n  const stateDir = join(cfg.baseDir, STATE_DIR);\n  mkdirSync(stateDir, { recursive: true });\n  const dbPath = join(stateDir, DB_FILENAME);\n\n  const db = new DatabaseSync(dbPath);\n  db.exec('PRAGMA journal_mode = WAL');\n  // Covers a concurrent watcher's bulk reconcile (~5s for 500 files at 26k notes). A query\n  // that outwaits it still fails loudly.\n  db.exec('PRAGMA busy_timeout = 30000');\n  registerFunctions(db, contentTokenize(cfg) === undefined);\n\n  db.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)');\n\n  // Before the rebuild branch below, never after: that branch deletes the cache, so a typo'd\n  // tokenizer validated later would cost a full re-index (and re-embed) to reach its own error.\n  const tokenize = resolveTokenize(db, cfg);\n\n  // Schema-version or feature-set mismatch: reconcile only reparses changed files, so an\n  // old cache can't be patched incrementally -- rebuild instead (cheap: nothing expensive lives here).\n  const version = getMeta(db, 'schema_version');\n  const features = getMeta(db, 'features');\n  const wantFeatures = featureSignature(cfg);\n  let tokenizeOnlyRebuild = false;\n  if ((version !== null && version !== SCHEMA_VERSION) || (features !== null && features !== wantFeatures)) {\n    // Indexing derives from presets, so a config edit rebuilding the cache must say so and\n    // name what changed -- silent rebuilds make derived indexing look like a hang or a bug.\n    if (version !== null && version !== SCHEMA_VERSION) {\n      console.error('sense: cache format changed (new sensemaking version); rebuilding the index');\n      db.close();\n      clearCache(cfg);\n      return open(cfg);\n    }\n    const changedKeys = changedSignatureKeys(features ?? '', wantFeatures);\n    // Only the tokenizer moved: frontmatter, links, sections, and embeddings are file-derived\n    // and tokenizer-independent, so they don't need re-deriving. Everything else -- a preset\n    // edit, an embed model change -- still takes the full clear/reopen below.\n    if (changedKeys.size === 1 && changedKeys.has('tokenize')) {\n      console.error('sense: config change (content tokenizer) rebuilds the text index; vectors, links, and sections are kept');\n      db.exec('DROP TABLE content');\n      tokenizeOnlyRebuild = true;\n    } else {\n      const changed = signatureDiff(features ?? '', wantFeatures);\n      console.error(`sense: config change (${changed}) rebuilds the index`);\n      db.close();\n      clearCache(cfg);\n      return open(cfg);\n    }\n  }\n\n  // Meta can lie after a crash between table creation and the signature write; the table's\n  // own DDL cannot. A mismatch here rebuilds no matter what meta says. A tokenize-only rebuild\n  // just dropped content above, so storedTokenize sees no table and this guard is skipped\n  // naturally rather than needing its own case.\n  const stored = storedTokenize(db);\n  if (stored !== null && stored !== tokenize) {\n    console.error('sense: cache was built with a different content tokenizer; rebuilding the index');\n    db.close();\n    clearCache(cfg);\n    return open(cfg);\n  }\n\n  ensureSchema(db, cfg, tokenize);\n\n  let rebuildWarnings: string[] = [];\n  if (tokenizeOnlyRebuild) {\n    rebuildWarnings = rebuildContentTable(db, cfg, cfg.baseDir);\n    setMeta(db, 'features', wantFeatures);\n  }\n\n  // 3x the largest reconcile this cache has recorded, floored at 30s and capped at 10min.\n  // Installed before reconcile() -- that call is the one that races a watcher's transaction.\n  const recordedMaxMs = Number(getMeta(db, 'reconcile_max_ms') ?? '0');\n  db.exec(`PRAGMA busy_timeout = ${Math.min(Math.max(30000, 3 * recordedMaxMs), 600_000)}`);\n\n  const { parsed, warnings } = reconcile(db, cfg, cfg.baseDir);\n\n  return { db, cfg, dbPath, parsed, warnings: [...rebuildWarnings, ...warnings] };\n}\n\n// Deletes the cache directory, and only that. The rebuild is not this function's job: the next\n// open() reconciles, which is what running any command already does, so a verb that bundled the\n// two described the half that was not its own. Manual reset for a doubted cache; the schema and\n// config-signature mismatches below reset themselves.\nexport function clearCache(cfg: ResolvedConfig): void {\n  rmSync(join(cfg.baseDir, STATE_DIR), { recursive: true, force: true });\n}\n"],"names":["DB_FILENAME","SCHEMA_VERSION","clearCache","docCount","open","DEFAULT_TOKENIZE","resolveTokenize","db","cfg","configured","contentTokenize","undefined","literal","replace","exec","err","SenseError","message","storedTokenize","row","prepare","get","m","sql","match","ensureSchema","tokenize","activeFeatures","feature","schema","getMeta","setMeta","featureSignature","n","stateDir","join","baseDir","STATE_DIR","mkdirSync","recursive","dbPath","DatabaseSync","registerFunctions","version","features","wantFeatures","tokenizeOnlyRebuild","console","error","close","changedKeys","changedSignatureKeys","size","has","changed","signatureDiff","stored","rebuildWarnings","rebuildContentTable","recordedMaxMs","Number","Math","min","max","reconcile","parsed","warnings","rmSync","force"],"mappings":"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"}

package/dist/cjs/db/reconcile.d.cts

@@ -0,0 +1,9 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { Config } from '../config/index.js';
+export declare function reconcile(db: DatabaseSync, cfg: Config, baseDir: string): {
+    parsed: number;
+    warnings: string[];
+};
+export declare function changedSignatureKeys(before: string, after: string): Set<string>;
+export declare function signatureDiff(before: string, after: string): string;
+export declare function rebuildContentTable(db: DatabaseSync, cfg: Config, baseDir: string): string[];

package/dist/cjs/db/reconcile.d.ts

@@ -0,0 +1,9 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { Config } from '../config/index.js';
+export declare function reconcile(db: DatabaseSync, cfg: Config, baseDir: string): {
+    parsed: number;
+    warnings: string[];
+};
+export declare function changedSignatureKeys(before: string, after: string): Set<string>;
+export declare function signatureDiff(before: string, after: string): string;
+export declare function rebuildContentTable(db: DatabaseSync, cfg: Config, baseDir: string): string[];