sensemaking 0.17.0 → 0.18.0

package/dist/cjs/store/duckdb/native.js

@@ -0,0 +1,360 @@
+"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 DUCKDB_PACKAGE () {
+        return DUCKDB_PACKAGE;
+    },
+    get duckdbApi () {
+        return duckdbApi;
+    },
+    get loadOrInstall () {
+        return loadOrInstall;
+    }
+});
+var _nodefs = require("node:fs");
+var _nodemodule = /*#__PURE__*/ _interop_require_default(require("node:module"));
+var _nodepath = require("node:path");
+var _nodeurl = require("node:url");
+var _errorsts = require("../../errors.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 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 _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) return obj;
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") return {
+        default: obj
+    };
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) return cache.get(obj);
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
+            else newObj[key] = obj[key];
+        }
+    }
+    newObj.default = obj;
+    if (cache) cache.set(obj, newObj);
+    return newObj;
+}
+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 _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 _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 DUCKDB_PACKAGE = '@duckdb/node-api';
+// install-module-linked itself is small, but its target (@duckdb/node-api) is not: deferred the
+// same way embed/static.ts defers @huggingface/tokenizers, so requiring it stays inside the
+// already-gated branch below rather than running for every store/index.ts load.
+var _require = typeof require === 'undefined' ? _nodemodule.default.createRequire(require("url").pathToFileURL(__filename).toString()) : require;
+var _dirname = (0, _nodepath.dirname)(typeof __filename !== 'undefined' ? __filename : (0, _nodeurl.fileURLToPath)(require("url").pathToFileURL(__filename).toString()));
+// Walks up from this file's own directory to find the real package.json, rather than a fixed
+// dot-count from __dirname (xz-compat's `../../node_modules`): `tsds test:node` runs straight
+// off src/, one directory shallower than dist/{cjs,esm}/store/duckdb sits under the built
+// package, so a hardcoded depth is right for one and wrong for the other. Works the same way
+// for a globally-installed `sense`, whose node_modules this resolves to -- never the caller's
+// cwd.
+function packageNodeModules() {
+    var dir = _dirname;
+    for(;;){
+        var candidate = (0, _nodepath.join)(dir, 'package.json');
+        if ((0, _nodefs.existsSync)(candidate)) {
+            var pkg = JSON.parse((0, _nodefs.readFileSync)(candidate, 'utf8'));
+            if (pkg.name === 'sensemaking') return (0, _nodepath.join)(dir, 'node_modules');
+        }
+        var parent = (0, _nodepath.dirname)(dir);
+        if (parent === dir) throw new Error('could not locate the sensemaking package root to install @duckdb/node-api into');
+        dir = parent;
+    }
+}
+var installing = new Map();
+// De-dupes concurrent installs within this process (see spawn-term's loadInk for the shape).
+// The install here is async -- the load site already awaits a dynamic import -- so a bare
+// attempted flag (xz-compat's `installationAttempted`, enough for its synchronous single-target
+// install) isn't enough on its own; concurrent callers instead await the same in-flight promise,
+// keyed by specifier and target so tests exercising several installs in one process don't share
+// one slot. A failed install is not cached, so a later call retries.
+function installOnce(specifier, nodeModulesPath) {
+    var key = "".concat(specifier, "\n").concat(nodeModulesPath);
+    var promise = installing.get(key);
+    if (!promise) {
+        var installModuleLinked = _require('install-module-linked').default;
+        promise = installModuleLinked(specifier, nodeModulesPath).then(function() {}, function(err) {
+            installing.delete(key);
+            throw err;
+        });
+        installing.set(key, promise);
+    }
+    return promise;
+}
+// Node caches a bare specifier's package resolution -- including a "not found" miss -- for the
+// life of the process, so retrying `import(importName)` right after installing sees the same
+// stale miss and falls through to a bogus index.js guess instead of the package's real entry
+// (verified against a real global install: the plain-specifier retry failed there, this did
+// not). Reading the freshly-installed package's own package.json and importing its entry file
+// by an absolute file: URL sidesteps that stale cache instead of re-resolving the bare name.
+function resolveEntryUrl(importName, nodeModulesPath) {
+    var _pkg_main;
+    var pkgDir = _nodepath.join.apply(void 0, [
+        nodeModulesPath
+    ].concat(_to_consumable_array(importName.split('/'))));
+    var pkg = JSON.parse((0, _nodefs.readFileSync)((0, _nodepath.join)(pkgDir, 'package.json'), 'utf8'));
+    var entry = typeof pkg.exports === 'string' ? pkg.exports : (_pkg_main = pkg.main) !== null && _pkg_main !== void 0 ? _pkg_main : 'index.js';
+    return (0, _nodeurl.pathToFileURL)((0, _nodepath.join)(pkgDir, entry)).href;
+}
+function loadOrInstall(importName, nodeModulesPath) {
+    return _async_to_generator(function() {
+        var unused, installErr, loadErr;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        10
+                    ]);
+                    return [
+                        4,
+                        Promise.resolve(importName).then(function(p) {
+                            return /*#__PURE__*/ _interop_require_wildcard(require(p));
+                        })
+                    ];
+                case 1:
+                    return [
+                        2,
+                        _state.sent()
+                    ];
+                case 2:
+                    unused = _state.sent();
+                    console.error('sense: store "duckdb" needs '.concat(DUCKDB_PACKAGE, "; installing it now (one-time download, ~110MB)..."));
+                    _state.label = 3;
+                case 3:
+                    _state.trys.push([
+                        3,
+                        5,
+                        ,
+                        6
+                    ]);
+                    return [
+                        4,
+                        installOnce(importName, nodeModulesPath)
+                    ];
+                case 4:
+                    _state.sent();
+                    return [
+                        3,
+                        6
+                    ];
+                case 5:
+                    installErr = _state.sent();
+                    throw new _errorsts.SenseError('STORE_DEPENDENCY_MISSING', 'store "duckdb" needs '.concat(DUCKDB_PACKAGE, ", and installing it automatically failed (").concat(installErr.message, "); this can happen offline, in a sandboxed environment, or when node_modules is read-only or owned by another user (e.g. under a global install) -- run `npm install ").concat(DUCKDB_PACKAGE, "` yourself and try again"));
+                case 6:
+                    _state.trys.push([
+                        6,
+                        8,
+                        ,
+                        9
+                    ]);
+                    return [
+                        4,
+                        Promise.resolve(resolveEntryUrl(importName, nodeModulesPath)).then(function(p) {
+                            return /*#__PURE__*/ _interop_require_wildcard(require(p));
+                        })
+                    ];
+                case 7:
+                    return [
+                        2,
+                        _state.sent()
+                    ];
+                case 8:
+                    loadErr = _state.sent();
+                    throw new _errorsts.SenseError('STORE_DEPENDENCY_MISSING', 'store "duckdb" installed '.concat(DUCKDB_PACKAGE, " but it could not be loaded (").concat(loadErr.message, "); it may not be available for this platform (").concat(process.platform, "-").concat(process.arch, ") -- run `npm install ").concat(DUCKDB_PACKAGE, "` to see the underlying error"));
+                case 9:
+                    return [
+                        3,
+                        10
+                    ];
+                case 10:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+var duckdbApiPromise;
+function duckdbApi() {
+    if (!duckdbApiPromise) duckdbApiPromise = loadOrInstall(DUCKDB_PACKAGE, packageNodeModules());
+    return duckdbApiPromise;
+}
+/* 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/store/duckdb/native.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/duckdb/native.ts"],"sourcesContent":["import { existsSync, readFileSync } from 'node:fs';\nimport Module from 'node:module';\nimport { dirname, join } from 'node:path';\nimport { fileURLToPath, pathToFileURL } from 'node:url';\nimport { SenseError } from '../../errors.ts';\n\nexport const DUCKDB_PACKAGE = '@duckdb/node-api';\n\n// install-module-linked itself is small, but its target (@duckdb/node-api) is not: deferred the\n// same way embed/static.ts defers @huggingface/tokenizers, so requiring it stays inside the\n// already-gated branch below rather than running for every store/index.ts load.\nconst _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\nconst _dirname = dirname(typeof __filename !== 'undefined' ? __filename : fileURLToPath(import.meta.url));\n\n// Walks up from this file's own directory to find the real package.json, rather than a fixed\n// dot-count from __dirname (xz-compat's `../../node_modules`): `tsds test:node` runs straight\n// off src/, one directory shallower than dist/{cjs,esm}/store/duckdb sits under the built\n// package, so a hardcoded depth is right for one and wrong for the other. Works the same way\n// for a globally-installed `sense`, whose node_modules this resolves to -- never the caller's\n// cwd.\nfunction packageNodeModules(): string {\n  let dir = _dirname;\n  for (;;) {\n    const candidate = join(dir, 'package.json');\n    if (existsSync(candidate)) {\n      const pkg = JSON.parse(readFileSync(candidate, 'utf8')) as { name?: string };\n      if (pkg.name === 'sensemaking') return join(dir, 'node_modules');\n    }\n    const parent = dirname(dir);\n    if (parent === dir) throw new Error('could not locate the sensemaking package root to install @duckdb/node-api into');\n    dir = parent;\n  }\n}\n\nconst installing = new Map<string, Promise<void>>();\n\n// De-dupes concurrent installs within this process (see spawn-term's loadInk for the shape).\n// The install here is async -- the load site already awaits a dynamic import -- so a bare\n// attempted flag (xz-compat's `installationAttempted`, enough for its synchronous single-target\n// install) isn't enough on its own; concurrent callers instead await the same in-flight promise,\n// keyed by specifier and target so tests exercising several installs in one process don't share\n// one slot. A failed install is not cached, so a later call retries.\nfunction installOnce(specifier: string, nodeModulesPath: string): Promise<void> {\n  const key = `${specifier}\\n${nodeModulesPath}`;\n  let promise = installing.get(key);\n  if (!promise) {\n    const installModuleLinked = (_require('install-module-linked') as { default: (specifier: string, nodeModulesPath: string) => Promise<string> }).default;\n    promise = installModuleLinked(specifier, nodeModulesPath).then(\n      () => {},\n      (err) => {\n        installing.delete(key);\n        throw err;\n      }\n    );\n    installing.set(key, promise);\n  }\n  return promise;\n}\n\n// Node caches a bare specifier's package resolution -- including a \"not found\" miss -- for the\n// life of the process, so retrying `import(importName)` right after installing sees the same\n// stale miss and falls through to a bogus index.js guess instead of the package's real entry\n// (verified against a real global install: the plain-specifier retry failed there, this did\n// not). Reading the freshly-installed package's own package.json and importing its entry file\n// by an absolute file: URL sidesteps that stale cache instead of re-resolving the bare name.\nfunction resolveEntryUrl(importName: string, nodeModulesPath: string): string {\n  const pkgDir = join(nodeModulesPath, ...importName.split('/'));\n  const pkg = JSON.parse(readFileSync(join(pkgDir, 'package.json'), 'utf8')) as { main?: string; exports?: string };\n  const entry = typeof pkg.exports === 'string' ? pkg.exports : (pkg.main ?? 'index.js');\n  return pathToFileURL(join(pkgDir, entry)).href;\n}\n\n// Import-then-install-then-retry, over an injectable target so the failure path (import AND\n// install both fail) can be exercised for real in tests without downloading @duckdb/node-api's\n// real ~110MB native binding. Production always passes @duckdb/node-api's own name; the thrown\n// error names @duckdb/node-api regardless, since that is what a real user needs to install.\nexport async function loadOrInstall<T>(importName: string, nodeModulesPath: string): Promise<T> {\n  try {\n    return (await import(importName)) as T;\n  } catch {\n    console.error(`sense: store \"duckdb\" needs ${DUCKDB_PACKAGE}; installing it now (one-time download, ~110MB)...`);\n    try {\n      await installOnce(importName, nodeModulesPath);\n    } catch (installErr) {\n      throw new SenseError(\n        'STORE_DEPENDENCY_MISSING',\n        `store \"duckdb\" needs ${DUCKDB_PACKAGE}, and installing it automatically failed (${(installErr as Error).message}); this can happen offline, in a sandboxed environment, or when node_modules is read-only or owned by another user (e.g. under a global install) -- run \\`npm install ${DUCKDB_PACKAGE}\\` yourself and try again`\n      );\n    }\n    try {\n      return (await import(resolveEntryUrl(importName, nodeModulesPath))) as T;\n    } catch (loadErr) {\n      throw new SenseError('STORE_DEPENDENCY_MISSING', `store \"duckdb\" installed ${DUCKDB_PACKAGE} but it could not be loaded (${(loadErr as Error).message}); it may not be available for this platform (${process.platform}-${process.arch}) -- run \\`npm install ${DUCKDB_PACKAGE}\\` to see the underlying error`);\n    }\n  }\n}\n\nlet duckdbApiPromise: Promise<typeof import('@duckdb/node-api')> | undefined;\n\n// The one accessor every consumer of @duckdb/node-api (open.ts, sql-functions.ts, vectors.ts)\n// must go through, rather than each doing its own `import('@duckdb/node-api')`: once a fresh\n// install has happened in this process, Node keeps returning that pre-install \"not found\" miss\n// to any NEW bare-specifier lookup of the same path, so a second independent import elsewhere\n// in the process fails even though the package is now genuinely on disk (the same stale-cache\n// problem loadOrInstall works around for its own retry). Caching the resolved module here means\n// only the first caller ever resolves the bare specifier at all.\nexport function duckdbApi(): Promise<typeof import('@duckdb/node-api')> {\n  if (!duckdbApiPromise) duckdbApiPromise = loadOrInstall<typeof import('@duckdb/node-api')>(DUCKDB_PACKAGE, packageNodeModules());\n  return duckdbApiPromise;\n}\n"],"names":["DUCKDB_PACKAGE","duckdbApi","loadOrInstall","_require","require","Module","createRequire","_dirname","dirname","__filename","fileURLToPath","packageNodeModules","dir","candidate","join","existsSync","pkg","JSON","parse","readFileSync","name","parent","Error","installing","Map","installOnce","specifier","nodeModulesPath","key","promise","get","installModuleLinked","default","then","err","delete","set","resolveEntryUrl","importName","pkgDir","split","entry","exports","main","pathToFileURL","href","installErr","loadErr","console","error","SenseError","message","process","platform","arch","duckdbApiPromise"],"mappings":"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"}

package/dist/cjs/store/duckdb/open.d.cts

@@ -0,0 +1,12 @@
+import type { ResolvedConfig } from '../../config/index.js';
+import type { Store } from '../types.js';
+export declare const DB_FILENAME = "cache.duckdb";
+export declare const SCHEMA_VERSION = "2";
+export interface OpenResult {
+    store: Store;
+    cfg: ResolvedConfig;
+    dbPath: string;
+    parsed: number;
+    warnings: string[];
+}
+export declare function openDuckdb(cfg: ResolvedConfig): Promise<OpenResult>;

package/dist/cjs/store/duckdb/open.d.ts

@@ -0,0 +1,12 @@
+import type { ResolvedConfig } from '../../config/index.js';
+import type { Store } from '../types.js';
+export declare const DB_FILENAME = "cache.duckdb";
+export declare const SCHEMA_VERSION = "2";
+export interface OpenResult {
+    store: Store;
+    cfg: ResolvedConfig;
+    dbPath: string;
+    parsed: number;
+    warnings: string[];
+}
+export declare function openDuckdb(cfg: ResolvedConfig): Promise<OpenResult>;