sensemaking 0.17.1 → 0.18.1

package/dist/cjs/commands/map.js

@@ -11,80 +11,386 @@ Object.defineProperty(exports, "mapTree", {
 var _indexts = require("../config/index.js");
 var _scopets = require("./scope.js");
 var _statusts = require("./status.js");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+function _ts_values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) {
+        return m.call(o);
+    }
+    if (o && typeof o.length === "number") {
+        return {
+            next: function() {
+                if (o && i >= o.length) {
+                    o = void 0;
+                }
+                return {
+                    value: o && o[i++],
+                    done: !o
+                };
+            }
+        };
+    }
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
 // A result row is capped at SQLITE_MAX_COLUMN (2000, default); two aggregate expressions
 // per field keeps a chunk's row safely under that regardless of how many fields the tree has.
 var MAP_COLUMN_CHUNK = 300;
+// "YYYY-MM-DD HH:MM:SS" UTC, the exact shape sqlite's datetime(ms / 1000, 'unixepoch') prints;
+// formatted in JS so the query stays dialect-free.
+function utcSecond(ms) {
+    return new Date(ms).toISOString().slice(0, 19).replace('T', ' ');
+}
 function chunk(items, size) {
     var out = [];
     for(var i = 0; i < items.length; i += size)out.push(items.slice(i, i + size));
     return out;
 }
-function mapTree(db, cfg) {
-    var overrides = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-    (0, _scopets.setupMapScope)(db, (0, _scopets.scopedPaths)(db, cfg, overrides));
-    var scopeWhere = 'WHERE "path" IN (SELECT "path" FROM _map_scope)';
-    var scopeAnd = 'AND f."path" IN (SELECT "path" FROM _map_scope)';
-    var docs = db.prepare('SELECT COUNT(*) AS count, COALESCE(SUM("_size"), 0) AS bytes FROM frontmatter '.concat(scopeWhere)).get();
-    var columns = db.prepare('PRAGMA table_info(frontmatter)').all().map(function(r) {
-        return r.name;
-    }).filter(function(name) {
-        return !_scopets.INTERNAL_COLUMNS.has(name);
-    });
-    // Observed types, not declared: SQLite types per value, so a field can be text in most notes
-    // and numeric in a few. One aggregate scan per chunk of columns; FILTER matches COUNT's nulls.
-    var allFields = [];
-    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-    try {
-        var _loop = function() {
-            var group = _step.value;
-            var exprs = group.map(function(name, i) {
-                var quoted = '"'.concat(name.split('"').join('""'), '"');
-                return "COUNT(".concat(quoted, ") AS n").concat(i, ", GROUP_CONCAT(DISTINCT typeof(").concat(quoted, ")) FILTER (WHERE ").concat(quoted, " IS NOT NULL) AS t").concat(i);
-            });
-            var result = db.prepare("SELECT ".concat(exprs.join(', '), " FROM frontmatter ").concat(scopeWhere)).get();
-            group.forEach(function(name, i) {
-                var _result_;
-                return allFields.push({
-                    field: name,
-                    coverage: result["n".concat(i)],
-                    type: (_result_ = result["t".concat(i)]) !== null && _result_ !== void 0 ? _result_ : ''
-                });
-            });
-        };
-        for(var _iterator = chunk(columns, MAP_COLUMN_CHUNK)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
-    } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-    } finally{
-        try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-                _iterator.return();
-            }
-        } finally{
-            if (_didIteratorError) {
-                throw _iteratorError;
-            }
-        }
-    }
-    allFields.sort(function(a, b) {
-        return b.coverage - a.coverage;
-    });
-    var fields = allFields.slice(0, 20);
-    var hubs = (0, _indexts.featureEnabled)(cfg, 'rank') ? db.prepare('SELECT f."path" AS path, round(f."_rank" * 100, 2) AS rank, content.title FROM frontmatter f JOIN content ON content.path = f."path" WHERE f."_rank" IS NOT NULL '.concat(scopeAnd, ' ORDER BY f."_rank" DESC LIMIT 8')).all() : [];
-    var recent = db.prepare('SELECT "path", datetime("_mtime" / 1000, \'unixepoch\') AS modified FROM frontmatter '.concat(scopeWhere, ' ORDER BY "_mtime" DESC LIMIT 5')).all();
-    // A fresh clone/copy stamps files with checkout time, not edit history; second granularity
-    // matches the `recent` table above and is coarse enough to catch that without an exact-ms match.
-    var topSecond = db.prepare("SELECT COUNT(*) AS n FROM frontmatter ".concat(scopeWhere, ' GROUP BY CAST("_mtime" / 1000 AS INTEGER) ORDER BY n DESC LIMIT 1')).get();
-    var recentCaveat = topSecond && docs.count > 1 && topSecond.n > docs.count / 2 ? "".concat(topSecond.n, " of ").concat(docs.count, " files share one modified second, so recency likely reflects a checkout or copy, not edit history") : null;
-    return {
-        docs: docs,
-        fields: fields,
-        fieldsTotal: allFields.length,
-        features: (0, _indexts.featureStates)(cfg),
-        presets: (0, _statusts.presetCoverage)(db, cfg),
-        hubs: hubs,
-        recent: recent,
-        recentCaveat: recentCaveat
-    };
+function mapTree(_0, _1) {
+    return _async_to_generator(function(store, cfg) {
+        var overrides;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            overrides = _arguments.length > 2 && _arguments[2] !== void 0 ? _arguments[2] : {};
+            return [
+                2,
+                store.transaction(function() {
+                    return _async_to_generator(function() {
+                        var _tmp, scopeWhere, scopeAnd, docs, columns, allFields, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, err, fields, hubs, _tmp1, recent, topSecond, recentCaveat, _tmp2;
+                        return _ts_generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    _tmp = [
+                                        store
+                                    ];
+                                    return [
+                                        4,
+                                        (0, _scopets.scopedPaths)(store, cfg, overrides)
+                                    ];
+                                case 1:
+                                    return [
+                                        4,
+                                        _scopets.setupMapScope.apply(void 0, _tmp.concat([
+                                            _state.sent()
+                                        ]))
+                                    ];
+                                case 2:
+                                    _state.sent();
+                                    scopeWhere = 'WHERE "path" IN (SELECT "path" FROM _map_scope)';
+                                    scopeAnd = 'AND f."path" IN (SELECT "path" FROM _map_scope)';
+                                    return [
+                                        4,
+                                        store.prepare('SELECT COUNT(*) AS count, COALESCE(SUM("_size"), 0) AS bytes FROM frontmatter '.concat(scopeWhere))
+                                    ];
+                                case 3:
+                                    return [
+                                        4,
+                                        _state.sent().get()
+                                    ];
+                                case 4:
+                                    docs = _state.sent();
+                                    return [
+                                        4,
+                                        store.docs.columns()
+                                    ];
+                                case 5:
+                                    columns = _state.sent().filter(function(name) {
+                                        return !_scopets.INTERNAL_COLUMNS.has(name);
+                                    });
+                                    // Observed types, not declared: SQLite types per value, so a field can be text in most notes
+                                    // and numeric in a few. One aggregate scan per chunk of columns; FILTER matches COUNT's nulls.
+                                    allFields = [];
+                                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                    _state.label = 6;
+                                case 6:
+                                    _state.trys.push([
+                                        6,
+                                        11,
+                                        12,
+                                        13
+                                    ]);
+                                    _loop = function() {
+                                        var group, exprs, result;
+                                        return _ts_generator(this, function(_state) {
+                                            switch(_state.label){
+                                                case 0:
+                                                    group = _step.value;
+                                                    exprs = group.map(function(name, i) {
+                                                        var quoted = '"'.concat(name.split('"').join('""'), '"');
+                                                        return "COUNT(".concat(quoted, ") AS n").concat(i, ", GROUP_CONCAT(DISTINCT typeof(").concat(quoted, ")) FILTER (WHERE ").concat(quoted, " IS NOT NULL) AS t").concat(i);
+                                                    });
+                                                    return [
+                                                        4,
+                                                        store.prepare("SELECT ".concat(exprs.join(', '), " FROM frontmatter ").concat(scopeWhere))
+                                                    ];
+                                                case 1:
+                                                    return [
+                                                        4,
+                                                        _state.sent().get()
+                                                    ];
+                                                case 2:
+                                                    result = _state.sent();
+                                                    group.forEach(function(name, i) {
+                                                        var _result_;
+                                                        return allFields.push({
+                                                            field: name,
+                                                            coverage: result["n".concat(i)],
+                                                            type: (_result_ = result["t".concat(i)]) !== null && _result_ !== void 0 ? _result_ : ''
+                                                        });
+                                                    });
+                                                    return [
+                                                        2
+                                                    ];
+                                            }
+                                        });
+                                    };
+                                    _iterator = chunk(columns, MAP_COLUMN_CHUNK)[Symbol.iterator]();
+                                    _state.label = 7;
+                                case 7:
+                                    if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                        3,
+                                        10
+                                    ];
+                                    return [
+                                        5,
+                                        _ts_values(_loop())
+                                    ];
+                                case 8:
+                                    _state.sent();
+                                    _state.label = 9;
+                                case 9:
+                                    _iteratorNormalCompletion = true;
+                                    return [
+                                        3,
+                                        7
+                                    ];
+                                case 10:
+                                    return [
+                                        3,
+                                        13
+                                    ];
+                                case 11:
+                                    err = _state.sent();
+                                    _didIteratorError = true;
+                                    _iteratorError = err;
+                                    return [
+                                        3,
+                                        13
+                                    ];
+                                case 12:
+                                    try {
+                                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                            _iterator.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError) {
+                                            throw _iteratorError;
+                                        }
+                                    }
+                                    return [
+                                        7
+                                    ];
+                                case 13:
+                                    allFields.sort(function(a, b) {
+                                        return b.coverage - a.coverage;
+                                    });
+                                    fields = allFields.slice(0, 20);
+                                    if (!(0, _indexts.featureEnabled)(cfg, 'rank')) return [
+                                        3,
+                                        16
+                                    ];
+                                    return [
+                                        4,
+                                        store.prepare('SELECT f."path" AS path, round(f."_rank" * 100, 2) AS rank, content.title FROM frontmatter f JOIN content ON content.path = f."path" WHERE f."_rank" IS NOT NULL '.concat(scopeAnd, ' ORDER BY f."_rank" DESC LIMIT 8'))
+                                    ];
+                                case 14:
+                                    return [
+                                        4,
+                                        _state.sent().all()
+                                    ];
+                                case 15:
+                                    _tmp1 = _state.sent();
+                                    return [
+                                        3,
+                                        17
+                                    ];
+                                case 16:
+                                    _tmp1 = [];
+                                    _state.label = 17;
+                                case 17:
+                                    hubs = _tmp1;
+                                    return [
+                                        4,
+                                        store.prepare('SELECT "path", "_mtime" AS mtime FROM frontmatter '.concat(scopeWhere, ' ORDER BY "_mtime" DESC LIMIT 5'))
+                                    ];
+                                case 18:
+                                    return [
+                                        4,
+                                        _state.sent().all()
+                                    ];
+                                case 19:
+                                    recent = _state.sent().map(function(r) {
+                                        return {
+                                            path: r.path,
+                                            modified: utcSecond(r.mtime)
+                                        };
+                                    });
+                                    return [
+                                        4,
+                                        store.prepare("SELECT COUNT(*) AS n FROM frontmatter ".concat(scopeWhere, ' GROUP BY CAST("_mtime" / 1000 AS INTEGER) ORDER BY n DESC LIMIT 1'))
+                                    ];
+                                case 20:
+                                    return [
+                                        4,
+                                        _state.sent().get()
+                                    ];
+                                case 21:
+                                    topSecond = _state.sent();
+                                    recentCaveat = topSecond && docs.count > 1 && topSecond.n > docs.count / 2 ? "".concat(topSecond.n, " of ").concat(docs.count, " files share one modified second, so recency likely reflects a checkout or copy, not edit history") : null;
+                                    _tmp2 = {
+                                        docs: docs,
+                                        fields: fields,
+                                        fieldsTotal: allFields.length,
+                                        features: (0, _indexts.featureStates)(cfg)
+                                    };
+                                    return [
+                                        4,
+                                        (0, _statusts.presetCoverage)(store, cfg)
+                                    ];
+                                case 22:
+                                    return [
+                                        2,
+                                        (_tmp2.presets = _state.sent(), _tmp2.hubs = hubs, _tmp2.recent = recent, _tmp2.recentCaveat = recentCaveat, _tmp2)
+                                    ];
+                            }
+                        });
+                    })();
+                })
+            ];
+        });
+    }).apply(this, arguments);
 }
 /* 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/commands/map.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/map.ts"],"sourcesContent":["import type { DatabaseSync } from 'node:sqlite';\nimport type { FeatureName, ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { featureEnabled, featureStates } from '../config/index.ts';\nimport type { Row } from '../output/output.ts';\nimport { INTERNAL_COLUMNS, scopedPaths, setupMapScope } from './scope.ts';\nimport type { PresetCoverage } from './status.ts';\nimport { presetCoverage } from './status.ts';\n\nexport interface TreeMap {\n  docs: { count: number; bytes: number };\n  fields: Row[]; // top 20 by coverage; fieldsTotal carries the real count\n  fieldsTotal: number;\n  features: { on: FeatureName[]; off: FeatureName[] };\n  presets: PresetCoverage[];\n  hubs: Row[];\n  recent: Row[];\n  recentCaveat: string | null;\n}\n\n// A result row is capped at SQLITE_MAX_COLUMN (2000, default); two aggregate expressions\n// per field keeps a chunk's row safely under that regardless of how many fields the tree has.\nconst MAP_COLUMN_CHUNK = 300;\n\nfunction chunk<T>(items: T[], size: number): T[][] {\n  const out: T[][] = [];\n  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));\n  return out;\n}\n\n// What is this scope: fixed-size output regardless of tree size. Coverage and features stay\n// global -- they describe the tree, not the current question.\nexport function mapTree(db: DatabaseSync, cfg: ResolvedConfig, overrides: SearchOverrides = {}): TreeMap {\n  setupMapScope(db, scopedPaths(db, cfg, overrides));\n  const scopeWhere = 'WHERE \"path\" IN (SELECT \"path\" FROM _map_scope)';\n  const scopeAnd = 'AND f.\"path\" IN (SELECT \"path\" FROM _map_scope)';\n\n  const docs = db.prepare(`SELECT COUNT(*) AS count, COALESCE(SUM(\"_size\"), 0) AS bytes FROM frontmatter ${scopeWhere}`).get() as { count: number; bytes: number };\n\n  const columns = (db.prepare('PRAGMA table_info(frontmatter)').all() as Array<{ name: string }>).map((r) => r.name).filter((name) => !INTERNAL_COLUMNS.has(name));\n  // Observed types, not declared: SQLite types per value, so a field can be text in most notes\n  // and numeric in a few. One aggregate scan per chunk of columns; FILTER matches COUNT's nulls.\n  const allFields: Row[] = [];\n  for (const group of chunk(columns, MAP_COLUMN_CHUNK)) {\n    const exprs = group.map((name, i) => {\n      const quoted = `\"${name.split('\"').join('\"\"')}\"`;\n      return `COUNT(${quoted}) AS n${i}, GROUP_CONCAT(DISTINCT typeof(${quoted})) FILTER (WHERE ${quoted} IS NOT NULL) AS t${i}`;\n    });\n    const result = db.prepare(`SELECT ${exprs.join(', ')} FROM frontmatter ${scopeWhere}`).get() as Record<string, number | string | null>;\n    group.forEach((name, i) => allFields.push({ field: name, coverage: result[`n${i}`] as number, type: (result[`t${i}`] as string) ?? '' }));\n  }\n  allFields.sort((a, b) => (b.coverage as number) - (a.coverage as number));\n  const fields = allFields.slice(0, 20);\n\n  const hubs = featureEnabled(cfg, 'rank') ? (db.prepare(`SELECT f.\"path\" AS path, round(f.\"_rank\" * 100, 2) AS rank, content.title FROM frontmatter f JOIN content ON content.path = f.\"path\" WHERE f.\"_rank\" IS NOT NULL ${scopeAnd} ORDER BY f.\"_rank\" DESC LIMIT 8`).all() as Row[]) : [];\n\n  const recent = db.prepare(`SELECT \"path\", datetime(\"_mtime\" / 1000, 'unixepoch') AS modified FROM frontmatter ${scopeWhere} ORDER BY \"_mtime\" DESC LIMIT 5`).all() as Row[];\n\n  // A fresh clone/copy stamps files with checkout time, not edit history; second granularity\n  // matches the `recent` table above and is coarse enough to catch that without an exact-ms match.\n  const topSecond = db.prepare(`SELECT COUNT(*) AS n FROM frontmatter ${scopeWhere} GROUP BY CAST(\"_mtime\" / 1000 AS INTEGER) ORDER BY n DESC LIMIT 1`).get() as { n: number } | undefined;\n  const recentCaveat = topSecond && docs.count > 1 && topSecond.n > docs.count / 2 ? `${topSecond.n} of ${docs.count} files share one modified second, so recency likely reflects a checkout or copy, not edit history` : null;\n\n  return { docs, fields, fieldsTotal: allFields.length, features: featureStates(cfg), presets: presetCoverage(db, cfg), hubs, recent, recentCaveat };\n}\n"],"names":["mapTree","MAP_COLUMN_CHUNK","chunk","items","size","out","i","length","push","slice","db","cfg","overrides","setupMapScope","scopedPaths","scopeWhere","scopeAnd","docs","prepare","get","columns","all","map","r","name","filter","INTERNAL_COLUMNS","has","allFields","group","exprs","quoted","split","join","result","forEach","field","coverage","type","sort","a","b","fields","hubs","featureEnabled","recent","topSecond","recentCaveat","count","n","fieldsTotal","features","featureStates","presets","presetCoverage"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/map.ts"],"sourcesContent":["import type { FeatureName, ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { featureEnabled, featureStates } from '../config/index.ts';\nimport type { Row } from '../output/output.ts';\nimport type { Store } from '../store/types.ts';\nimport { INTERNAL_COLUMNS, scopedPaths, setupMapScope } from './scope.ts';\nimport type { PresetCoverage } from './status.ts';\nimport { presetCoverage } from './status.ts';\n\nexport interface TreeMap {\n  docs: { count: number; bytes: number };\n  fields: Row[]; // top 20 by coverage; fieldsTotal carries the real count\n  fieldsTotal: number;\n  features: { on: FeatureName[]; off: FeatureName[] };\n  presets: PresetCoverage[];\n  hubs: Row[];\n  recent: Row[];\n  recentCaveat: string | null;\n}\n\n// A result row is capped at SQLITE_MAX_COLUMN (2000, default); two aggregate expressions\n// per field keeps a chunk's row safely under that regardless of how many fields the tree has.\nconst MAP_COLUMN_CHUNK = 300;\n\n// \"YYYY-MM-DD HH:MM:SS\" UTC, the exact shape sqlite's datetime(ms / 1000, 'unixepoch') prints;\n// formatted in JS so the query stays dialect-free.\nfunction utcSecond(ms: number): string {\n  return new Date(ms).toISOString().slice(0, 19).replace('T', ' ');\n}\n\nfunction chunk<T>(items: T[], size: number): T[][] {\n  const out: T[][] = [];\n  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));\n  return out;\n}\n\n// What is this scope: fixed-size output regardless of tree size. Coverage and features stay\n// global -- they describe the tree, not the current question.\nexport async function mapTree(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides = {}): Promise<TreeMap> {\n  return store.transaction(async () => {\n    await setupMapScope(store, await scopedPaths(store, cfg, overrides));\n    const scopeWhere = 'WHERE \"path\" IN (SELECT \"path\" FROM _map_scope)';\n    const scopeAnd = 'AND f.\"path\" IN (SELECT \"path\" FROM _map_scope)';\n\n    const docs = (await (await store.prepare(`SELECT COUNT(*) AS count, COALESCE(SUM(\"_size\"), 0) AS bytes FROM frontmatter ${scopeWhere}`)).get()) as { count: number; bytes: number };\n\n    const columns = (await store.docs.columns()).filter((name) => !INTERNAL_COLUMNS.has(name));\n    // Observed types, not declared: SQLite types per value, so a field can be text in most notes\n    // and numeric in a few. One aggregate scan per chunk of columns; FILTER matches COUNT's nulls.\n    const allFields: Row[] = [];\n    for (const group of chunk(columns, MAP_COLUMN_CHUNK)) {\n      const exprs = group.map((name, i) => {\n        const quoted = `\"${name.split('\"').join('\"\"')}\"`;\n        return `COUNT(${quoted}) AS n${i}, GROUP_CONCAT(DISTINCT typeof(${quoted})) FILTER (WHERE ${quoted} IS NOT NULL) AS t${i}`;\n      });\n      const result = (await (await store.prepare(`SELECT ${exprs.join(', ')} FROM frontmatter ${scopeWhere}`)).get()) as Record<string, number | string | null>;\n      group.forEach((name, i) => allFields.push({ field: name, coverage: result[`n${i}`] as number, type: (result[`t${i}`] as string) ?? '' }));\n    }\n    allFields.sort((a, b) => (b.coverage as number) - (a.coverage as number));\n    const fields = allFields.slice(0, 20);\n\n    const hubs = featureEnabled(cfg, 'rank') ? ((await (await store.prepare(`SELECT f.\"path\" AS path, round(f.\"_rank\" * 100, 2) AS rank, content.title FROM frontmatter f JOIN content ON content.path = f.\"path\" WHERE f.\"_rank\" IS NOT NULL ${scopeAnd} ORDER BY f.\"_rank\" DESC LIMIT 8`)).all()) as Row[]) : [];\n\n    const recent = ((await (await store.prepare(`SELECT \"path\", \"_mtime\" AS mtime FROM frontmatter ${scopeWhere} ORDER BY \"_mtime\" DESC LIMIT 5`)).all()) as Array<{ path: string; mtime: number }>).map((r) => ({ path: r.path, modified: utcSecond(r.mtime) }));\n\n    // A fresh clone/copy stamps files with checkout time, not edit history; second granularity\n    // matches the `recent` table above and is coarse enough to catch that without an exact-ms match.\n    const topSecond = (await (await store.prepare(`SELECT COUNT(*) AS n FROM frontmatter ${scopeWhere} GROUP BY CAST(\"_mtime\" / 1000 AS INTEGER) ORDER BY n DESC LIMIT 1`)).get()) as { n: number } | undefined;\n    const recentCaveat = topSecond && docs.count > 1 && topSecond.n > docs.count / 2 ? `${topSecond.n} of ${docs.count} files share one modified second, so recency likely reflects a checkout or copy, not edit history` : null;\n\n    return { docs, fields, fieldsTotal: allFields.length, features: featureStates(cfg), presets: await presetCoverage(store, cfg), hubs, recent, recentCaveat };\n  });\n}\n"],"names":["mapTree","MAP_COLUMN_CHUNK","utcSecond","ms","Date","toISOString","slice","replace","chunk","items","size","out","i","length","push","store","cfg","overrides","transaction","scopeWhere","scopeAnd","docs","columns","allFields","fields","hubs","recent","topSecond","recentCaveat","scopedPaths","setupMapScope","prepare","get","filter","name","INTERNAL_COLUMNS","has","group","exprs","result","map","quoted","split","join","forEach","field","coverage","type","sort","a","b","featureEnabled","all","r","path","modified","mtime","count","n","fieldsTotal","features","featureStates","presetCoverage","presets"],"mappings":"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"}

package/dist/cjs/commands/peek.d.cts

@@ -1,6 +1,6 @@
-import type { DatabaseSync } from 'node:sqlite';
 import type { FeatureName, ResolvedConfig, SearchOverrides } from '../config/index.js';
 import type { Row } from '../output/output.js';
+import type { Store } from '../store/types.js';
 export declare function resolveNote(paths: string[], arg: string): string;
 export interface Peek {
     path: string;
@@ -17,4 +17,4 @@ export interface Peek {
     unresolvedTotal: number;
     off: FeatureName[];
 }
-export declare function peek(db: DatabaseSync, cfg: ResolvedConfig, pathArg: string, overrides?: SearchOverrides): Peek;
+export declare function peek(store: Store, cfg: ResolvedConfig, pathArg: string, overrides?: SearchOverrides): Promise<Peek>;

package/dist/cjs/commands/peek.d.ts

@@ -1,6 +1,6 @@
-import type { DatabaseSync } from 'node:sqlite';
 import type { FeatureName, ResolvedConfig, SearchOverrides } from '../config/index.js';
 import type { Row } from '../output/output.js';
+import type { Store } from '../store/types.js';
 export declare function resolveNote(paths: string[], arg: string): string;
 export interface Peek {
     path: string;
@@ -17,4 +17,4 @@ export interface Peek {
     unresolvedTotal: number;
     off: FeatureName[];
 }
-export declare function peek(db: DatabaseSync, cfg: ResolvedConfig, pathArg: string, overrides?: SearchOverrides): Peek;
+export declare function peek(store: Store, cfg: ResolvedConfig, pathArg: string, overrides?: SearchOverrides): Promise<Peek>;