local-kv-cli 1.0.0 → 2.0.0

package/dist/cli.js

@@ -1,100 +1,350 @@
 #!/usr/bin/env node
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = run;
+exports.main = main;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const args_1 = require("./args");
+const clipboard_1 = require("./clipboard");
+const env_1 = require("./env");
+const format_1 = require("./format");
+const locate_1 = require("./locate");
 const store_1 = require("./store");
+const values_1 = require("./values");
 const HELP = `lkv - store key-value pairs locally
 
 Usage:
-  lkv set <key> <value> [--force]   Create a pair (--force overwrites)
-  lkv get <key>                     Print the value of a key
-  lkv update <key> <value>          Change the value of an existing key
-  lkv delete <key>                  Remove a pair
-  lkv list [--json]                 Show all pairs
-  lkv clear                         Remove all pairs
-  lkv path                          Show where the data file lives
-  lkv help                          Show this help
+  lkv set <key> <value>          Create a pair (--force to overwrite)
+  lkv get <key>                  Print a value (--copy to copy it, --json for JSON)
+  lkv update <key> <value>       Change an existing value
+  lkv delete <key>               Remove a pair                        (alias: rm)
+  lkv rename <old> <new>         Rename a key (--force to overwrite)  (alias: mv)
+  lkv incr <key> [amount]        Add to a number (starts at 0)
+  lkv decr <key> [amount]        Subtract from a number
+  lkv list                       Show all pairs                       (alias: ls)
+                                   --long     show type and last update
+                                   --filter   only keys containing some text
+                                   --json     print as JSON
+  lkv search <text>              Find pairs whose key or value contains text
+  lkv history <key>              Show previous values of a key
+  lkv namespaces                 List namespaces                      (alias: ns)
+  lkv clear                      Remove all pairs in the namespace
+  lkv export [file]              Back up as JSON (--all for every namespace)
+  lkv import <file>              Restore a backup (--force to overwrite existing keys)
+  lkv env                        Print pairs as environment variables
+                                   --shell sh|powershell|cmd, --upper for UPPERCASE names
+  lkv run <command...>           Run a command with the pairs as environment variables
+  lkv init                       Create a project store (.lkv.json) in this folder
+  lkv path                       Show which store file is in use
+
+Options:
+  -n, --namespace <name>         Work in a namespace (default: "default")
+  -t, --type <type>              Value type for set/update: ${values_1.VALUE_TYPES.join(", ")}
+  -g, --global                   Use the global store even inside a project
+  -v, --version                  Show the version
+
+Values like 42, true or {"a":1} are stored as numbers, booleans and JSON.
+Use --type string to keep them as text. Quote values that contain spaces.
 
-Tip: quote values with spaces, e.g.  lkv set greeting "hello world"`;
-function fail(message) {
-    console.error(`Error: ${message}`);
-    process.exit(1);
+Examples:
+  lkv set api_url https://example.com
+  lkv incr build_count
+  lkv -n work set token abc123
+  eval "$(lkv env)"                 (bash/zsh)
+  lkv env | Invoke-Expression       (PowerShell)`;
+class CliError extends Error {
 }
-function requireArgs(args, count, usage) {
+function need(args, count, usage) {
     if (args.length < count)
-        fail(`Usage: lkv ${usage}`);
+        throw new CliError(`Usage: lkv ${usage}`);
 }
-function run(argv, store = new store_1.Store()) {
-    const flags = new Set(argv.filter((a) => a.startsWith("--")));
-    const [command, ...args] = argv.filter((a) => !a.startsWith("--"));
+/** Runs the CLI and returns the exit code. */
+function main(argv) {
+    const parsed = (0, args_1.parseArgs)(argv);
+    const { command, flags } = parsed;
+    if (flags.has("version")) {
+        console.log(readVersion());
+        return 0;
+    }
+    if (flags.has("help") || command === undefined || command === "help") {
+        console.log(HELP);
+        return 0;
+    }
+    if (command === "init")
+        return init();
+    const store = new store_1.Store({ namespace: parsed.options.namespace, global: flags.has("global") });
+    try {
+        return runCommand(store, parsed);
+    }
+    finally {
+        if (store.migratedBackup) {
+            console.error(`Note: upgraded your data to the v2 format (backup saved to ${store.migratedBackup})`);
+        }
+    }
+}
+function runCommand(store, { command, args, options, flags }) {
     switch (command) {
         case "set": {
-            requireArgs(args, 2, "set <key> <value>");
+            need(args, 2, "set <key> <value>");
             const [key, ...rest] = args;
-            store.set(key, rest.join(" "), flags.has("--force"));
+            store.set(key, readValue(rest, options.type), { force: flags.has("force") });
             console.log(`Saved "${key}"`);
-            break;
+            return 0;
         }
         case "get": {
-            requireArgs(args, 1, "get <key>");
+            need(args, 1, "get <key>");
             const value = store.get(args[0]);
             if (value === undefined)
-                fail(`Key "${args[0]}" not found`);
-            console.log(value);
-            break;
+                throw new CliError(`Key "${args[0]}" not found`);
+            if (flags.has("copy")) {
+                (0, clipboard_1.copyToClipboard)((0, values_1.formatValue)(value));
+                console.error(`Copied "${args[0]}" to the clipboard`);
+            }
+            else {
+                console.log(flags.has("json") ? JSON.stringify(value) : (0, values_1.formatValue)(value, true));
+            }
+            return 0;
         }
         case "update": {
-            requireArgs(args, 2, "update <key> <value>");
+            need(args, 2, "update <key> <value>");
             const [key, ...rest] = args;
-            store.update(key, rest.join(" "));
+            store.update(key, readValue(rest, options.type));
             console.log(`Updated "${key}"`);
-            break;
+            return 0;
         }
         case "delete":
         case "rm": {
-            requireArgs(args, 1, "delete <key>");
+            need(args, 1, "delete <key>");
             if (!store.delete(args[0]))
-                fail(`Key "${args[0]}" not found`);
+                throw new CliError(`Key "${args[0]}" not found`);
             console.log(`Deleted "${args[0]}"`);
-            break;
+            return 0;
+        }
+        case "rename":
+        case "mv": {
+            need(args, 2, "rename <old> <new>");
+            store.rename(args[0], args[1], { force: flags.has("force") });
+            console.log(`Renamed "${args[0]}" to "${args[1]}"`);
+            return 0;
+        }
+        case "incr":
+        case "decr": {
+            need(args, 1, `${command} <key> [amount]`);
+            const amount = args[1] === undefined ? 1 : Number(args[1]);
+            if (args[1] !== undefined && (args[1].trim() === "" || !Number.isFinite(amount))) {
+                throw new CliError(`"${args[1]}" is not a number`);
+            }
+            // String() so console.log never colors the number (it does when FORCE_COLOR is set).
+            console.log(String(store.incr(args[0], command === "incr" ? amount : -amount)));
+            return 0;
         }
         case "list":
         case "ls": {
-            const data = store.all();
-            if (flags.has("--json")) {
-                console.log(JSON.stringify(data, null, 2));
-                break;
+            let data = store.all();
+            if (options.filter !== undefined) {
+                const needle = options.filter.toLowerCase();
+                data = pick(data, Object.keys(data).filter((k) => k.toLowerCase().includes(needle)));
+            }
+            printPairs(store, data, flags);
+            return 0;
+        }
+        case "search": {
+            need(args, 1, "search <text>");
+            printPairs(store, store.search(args.join(" ")), flags);
+            return 0;
+        }
+        case "history": {
+            need(args, 1, "history <key>");
+            const entry = store.entry(args[0]);
+            if (!entry)
+                throw new CliError(`Key "${args[0]}" not found`);
+            if (flags.has("json")) {
+                console.log(JSON.stringify(entry, null, 2));
+                return 0;
+            }
+            console.log(`${formatDate(entry.updated)}  ${oneLine(entry.value)}  (current)`);
+            for (const item of [...entry.history].reverse()) {
+                console.log(`${formatDate(item.updated)}  ${oneLine(item.value)}`);
+            }
+            if (entry.history.length === 0)
+                console.log("(no previous values)");
+            return 0;
+        }
+        case "namespaces":
+        case "ns": {
+            const counts = store.namespaces();
+            const names = Object.keys(counts).sort();
+            const width = Math.max(...names.map((n) => n.length));
+            for (const name of names) {
+                const marker = name === store.namespace ? "*" : " ";
+                const n = counts[name];
+                console.log(`${marker} ${name.padEnd(width)}  ${n} ${n === 1 ? "key" : "keys"}`);
+            }
+            return 0;
+        }
+        case "clear": {
+            const removed = store.clear();
+            console.log(`Removed ${removed} ${removed === 1 ? "pair" : "pairs"} from "${store.namespace}"`);
+            return 0;
+        }
+        case "export": {
+            const data = store.export(flags.has("all"));
+            const json = JSON.stringify(data, null, 2);
+            if (args[0]) {
+                fs.writeFileSync(args[0], json + "\n");
+                const count = Object.values(data.namespaces).reduce((sum, ns) => sum + Object.keys(ns).length, 0);
+                console.log(`Exported ${count} ${count === 1 ? "pair" : "pairs"} to ${args[0]}`);
+            }
+            else {
+                console.log(json);
             }
-            const keys = Object.keys(data);
-            if (keys.length === 0) {
-                console.log("(empty)");
-                break;
+            return 0;
+        }
+        case "import": {
+            need(args, 1, "import <file>   (use - to read from stdin)");
+            const text = (0, store_1.decodeText)(fs.readFileSync(args[0] === "-" ? 0 : args[0]));
+            let data;
+            try {
+                data = JSON.parse(text);
+            }
+            catch {
+                throw new CliError(`${args[0]} is not valid JSON`);
             }
-            const width = Math.max(...keys.map((k) => k.length));
-            for (const key of keys)
-                console.log(`${key.padEnd(width)}  ${data[key]}`);
-            break;
-        }
-        case "clear":
-            store.clear();
-            console.log("All pairs removed");
-            break;
+            const r = store.import(data, { force: flags.has("force") });
+            console.log(`Imported: ${r.added} added, ${r.overwritten} overwritten, ${r.skipped} skipped`);
+            if (r.skipped > 0)
+                console.log("Use --force to overwrite existing keys.");
+            return 0;
+        }
+        case "env": {
+            const shell = (options.shell ?? (0, env_1.defaultShell)());
+            if (!env_1.SHELLS.includes(shell))
+                throw new CliError(`Unknown shell "${shell}". Use one of: ${env_1.SHELLS.join(", ")}`);
+            const { vars, skipped } = (0, env_1.toEnv)(store.all(), flags.has("upper"));
+            warnSkipped(skipped);
+            const script = (0, env_1.envScript)(vars, shell);
+            if (script)
+                console.log(script);
+            return 0;
+        }
+        case "run": {
+            need(args, 1, "run <command...>");
+            const { vars, skipped } = (0, env_1.toEnv)(store.all(), flags.has("upper"));
+            warnSkipped(skipped);
+            return (0, env_1.runWithEnv)(args, vars);
+        }
         case "path":
             console.log(store.path);
-            break;
-        case undefined:
-        case "help":
-            console.log(HELP);
-            break;
+            console.error(`(${store.kind} store, namespace "${store.namespace}")`);
+            return 0;
         default:
-            fail(`Unknown command "${command}". Run "lkv help".`);
+            throw new CliError(`Unknown command "${command}". Run "lkv help".`);
+    }
+}
+function init() {
+    const file = path.join(process.cwd(), locate_1.PROJECT_FILE);
+    if (fs.existsSync(file))
+        throw new CliError(`${locate_1.PROJECT_FILE} already exists here`);
+    fs.writeFileSync(file, JSON.stringify((0, format_1.emptyFile)(), null, 2));
+    console.log(`Created ${file}`);
+    console.log(`lkv commands run in this folder (and below) now use it. Use --global for the global store.`);
+    console.log(`Tip: add ${locate_1.PROJECT_FILE} to .gitignore if it will hold private values.`);
+    return 0;
+}
+function readValue(words, type) {
+    if (type !== undefined && !(0, values_1.isValueType)(type)) {
+        throw new CliError(`Unknown type "${type}". Use one of: ${values_1.VALUE_TYPES.join(", ")}`);
     }
+    return (0, values_1.parseValue)(words.join(" "), type);
+}
+function printPairs(store, data, flags) {
+    if (flags.has("json")) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    const keys = Object.keys(data);
+    if (keys.length === 0) {
+        console.log("(empty)");
+        return;
+    }
+    const width = Math.max(...keys.map((k) => k.length));
+    if (!flags.has("long")) {
+        for (const key of keys)
+            console.log(`${key.padEnd(width)}  ${oneLine(data[key])}`);
+        return;
+    }
+    const entries = store.entries();
+    const keyW = Math.max(width, 3);
+    console.log(`${"KEY".padEnd(keyW)}  TYPE     UPDATED           VALUE`);
+    for (const key of keys) {
+        const e = entries[key];
+        console.log(`${key.padEnd(keyW)}  ${e.type.padEnd(7)}  ${formatDate(e.updated)}  ${oneLine(e.value)}`);
+    }
+}
+function pick(data, keys) {
+    const out = Object.create(null);
+    for (const key of keys)
+        out[key] = data[key];
+    return out;
+}
+function oneLine(value) {
+    return (0, values_1.formatValue)(value).replace(/\r?\n/g, "\\n");
+}
+function formatDate(iso) {
+    const d = new Date(iso);
+    if (isNaN(d.getTime()))
+        return iso;
+    const p = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+}
+function warnSkipped(keys) {
+    if (keys.length > 0) {
+        console.error(`Skipped keys that aren't valid variable names: ${keys.join(", ")}`);
+    }
+}
+function readVersion() {
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8"));
+    return pkg.version;
 }
 if (require.main === module) {
     try {
-        run(process.argv.slice(2));
+        process.exitCode = main(process.argv.slice(2));
     }
     catch (err) {
-        fail(err instanceof Error ? err.message : String(err));
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        process.exitCode = 1;
     }
 }

package/dist/clipboard.d.ts

@@ -0,0 +1,2 @@
+/** Copy text to the system clipboard using the OS's own tool. */
+export declare function copyToClipboard(text: string): void;

package/dist/clipboard.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyToClipboard = copyToClipboard;
+const child_process_1 = require("child_process");
+/** Copy text to the system clipboard using the OS's own tool. */
+function copyToClipboard(text) {
+    const attempts = [];
+    if (process.platform === "win32") {
+        // clip.exe detects UTF-16 input (a byte order mark would end up in the clipboard).
+        attempts.push(["clip", [], Buffer.from(text, "utf16le")]);
+    }
+    else if (process.platform === "darwin") {
+        attempts.push(["pbcopy", [], Buffer.from(text)]);
+    }
+    else {
+        attempts.push(["wl-copy", [], Buffer.from(text)], ["xclip", ["-selection", "clipboard"], Buffer.from(text)], ["xsel", ["--clipboard", "--input"], Buffer.from(text)]);
+    }
+    for (const [cmd, args, input] of attempts) {
+        const result = (0, child_process_1.spawnSync)(cmd, args, { input });
+        if (!result.error && result.status === 0)
+            return;
+    }
+    throw new Error("Could not access the clipboard (on Linux, install wl-clipboard, xclip or xsel)");
+}

package/dist/env.d.ts

@@ -0,0 +1,13 @@
+import { Value } from "./values";
+export type Shell = "sh" | "powershell" | "cmd";
+export declare const SHELLS: readonly Shell[];
+export declare function defaultShell(): Shell;
+/** Turn stored pairs into environment variables. Keys that aren't valid names are reported. */
+export declare function toEnv(data: Record<string, Value>, upper?: boolean): {
+    vars: Record<string, string>;
+    skipped: string[];
+};
+/** Lines that set the variables when evaluated by the given shell. */
+export declare function envScript(vars: Record<string, string>, shell: Shell): string;
+/** Run a command with extra environment variables. Returns its exit code. */
+export declare function runWithEnv(command: string[], vars: Record<string, string>): number;

package/dist/env.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHELLS = void 0;
+exports.defaultShell = defaultShell;
+exports.toEnv = toEnv;
+exports.envScript = envScript;
+exports.runWithEnv = runWithEnv;
+const child_process_1 = require("child_process");
+const values_1 = require("./values");
+exports.SHELLS = ["sh", "powershell", "cmd"];
+const ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function defaultShell() {
+    return process.platform === "win32" ? "powershell" : "sh";
+}
+/** Turn stored pairs into environment variables. Keys that aren't valid names are reported. */
+function toEnv(data, upper = false) {
+    const vars = {};
+    const skipped = [];
+    for (const key of Object.keys(data)) {
+        const name = upper ? key.toUpperCase() : key;
+        if (ENV_NAME.test(name))
+            vars[name] = (0, values_1.formatValue)(data[key]);
+        else
+            skipped.push(key);
+    }
+    return { vars, skipped };
+}
+/** Lines that set the variables when evaluated by the given shell. */
+function envScript(vars, shell) {
+    return Object.keys(vars)
+        .map((name) => {
+        const value = vars[name];
+        switch (shell) {
+            case "sh":
+                return `export ${name}='${value.replace(/'/g, `'\\''`)}'`;
+            case "powershell":
+                return `$env:${name} = '${value.replace(/'/g, "''")}'`;
+            case "cmd":
+                return `set "${name}=${value}"`;
+        }
+    })
+        .join("\n");
+}
+/** Run a command with extra environment variables. Returns its exit code. */
+function runWithEnv(command, vars) {
+    // Go through the shell so things like `npm` (npm.cmd on Windows) resolve.
+    const line = command.map(quoteArg).join(" ");
+    const result = (0, child_process_1.spawnSync)(line, { stdio: "inherit", shell: true, env: { ...process.env, ...vars } });
+    if (result.error)
+        throw result.error;
+    return result.status ?? 1;
+}
+function quoteArg(arg) {
+    if (/^[\w@%+=:,./\\-]+$/.test(arg))
+        return arg;
+    return process.platform === "win32"
+        ? `"${arg.replace(/"/g, '\\"')}"`
+        : `'${arg.replace(/'/g, `'\\''`)}'`;
+}

package/dist/format.d.ts

@@ -0,0 +1,34 @@
+import { Value, ValueType } from "./values";
+export declare const FORMAT_VERSION = 2;
+export declare const DEFAULT_NAMESPACE = "default";
+/** How many previous values are kept per key. */
+export declare const HISTORY_LIMIT = 20;
+export interface HistoryItem {
+    value: Value;
+    type: ValueType;
+    updated: string;
+}
+export interface Entry {
+    value: Value;
+    type: ValueType;
+    created: string;
+    updated: string;
+    history: HistoryItem[];
+}
+export type Namespace = Record<string, Entry>;
+export interface StoreFile {
+    version: typeof FORMAT_VERSION;
+    namespaces: Record<string, Namespace>;
+}
+/** Prototype-less object, so keys like "constructor" or "__proto__" are just normal keys. */
+export declare function dict<T>(source?: Record<string, T>): Record<string, T>;
+export declare function emptyFile(): StoreFile;
+export declare function isV2(data: unknown): data is StoreFile;
+export declare function isPlainObject(x: unknown): x is Record<string, unknown>;
+export declare function newEntry(value: Value, now: string): Entry;
+/** Build a clean Entry from untrusted JSON (a store file or an import). */
+export declare function toEntry(raw: unknown, now: string): Entry;
+/** Parse a v2 file (keeps the null prototypes throughout). */
+export declare function normalizeV2(data: StoreFile, now: string): StoreFile;
+/** v1 files were a flat { key: "string value" } object. Values stay strings. */
+export declare function migrateV1(data: Record<string, unknown>, now: string): StoreFile;

package/dist/format.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HISTORY_LIMIT = exports.DEFAULT_NAMESPACE = exports.FORMAT_VERSION = void 0;
+exports.dict = dict;
+exports.emptyFile = emptyFile;
+exports.isV2 = isV2;
+exports.isPlainObject = isPlainObject;
+exports.newEntry = newEntry;
+exports.toEntry = toEntry;
+exports.normalizeV2 = normalizeV2;
+exports.migrateV1 = migrateV1;
+const values_1 = require("./values");
+exports.FORMAT_VERSION = 2;
+exports.DEFAULT_NAMESPACE = "default";
+/** How many previous values are kept per key. */
+exports.HISTORY_LIMIT = 20;
+/** Prototype-less object, so keys like "constructor" or "__proto__" are just normal keys. */
+function dict(source) {
+    const out = Object.create(null);
+    if (source)
+        for (const key of Object.keys(source))
+            out[key] = source[key];
+    return out;
+}
+function emptyFile() {
+    return { version: exports.FORMAT_VERSION, namespaces: dict({ [exports.DEFAULT_NAMESPACE]: dict() }) };
+}
+function isV2(data) {
+    return (isPlainObject(data) &&
+        data.version === exports.FORMAT_VERSION &&
+        isPlainObject(data.namespaces));
+}
+function isPlainObject(x) {
+    return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function newEntry(value, now) {
+    return { value, type: (0, values_1.typeOf)(value), created: now, updated: now, history: [] };
+}
+/** Build a clean Entry from untrusted JSON (a store file or an import). */
+function toEntry(raw, now) {
+    if (!isPlainObject(raw) || !("value" in raw))
+        throw new Error("Invalid entry in data");
+    const value = raw.value;
+    const history = Array.isArray(raw.history)
+        ? raw.history
+            .filter((h) => isPlainObject(h) && "value" in h)
+            .map((h) => ({
+            value: h.value,
+            type: (0, values_1.typeOf)(h.value),
+            updated: typeof h.updated === "string" ? h.updated : now,
+        }))
+        : [];
+    return {
+        value,
+        type: (0, values_1.typeOf)(value),
+        created: typeof raw.created === "string" ? raw.created : now,
+        updated: typeof raw.updated === "string" ? raw.updated : now,
+        history: history.slice(-exports.HISTORY_LIMIT),
+    };
+}
+/** Parse a v2 file (keeps the null prototypes throughout). */
+function normalizeV2(data, now) {
+    const namespaces = dict();
+    for (const name of Object.keys(data.namespaces)) {
+        const ns = data.namespaces[name];
+        if (!isPlainObject(ns))
+            continue;
+        const entries = dict();
+        for (const key of Object.keys(ns))
+            entries[key] = toEntry(ns[key], now);
+        namespaces[name] = entries;
+    }
+    if (!(exports.DEFAULT_NAMESPACE in namespaces))
+        namespaces[exports.DEFAULT_NAMESPACE] = dict();
+    return { version: exports.FORMAT_VERSION, namespaces };
+}
+/** v1 files were a flat { key: "string value" } object. Values stay strings. */
+function migrateV1(data, now) {
+    const file = emptyFile();
+    const ns = file.namespaces[exports.DEFAULT_NAMESPACE];
+    for (const key of Object.keys(data)) {
+        const value = data[key];
+        ns[key] = newEntry(typeof value === "string" ? value : JSON.stringify(value), now);
+    }
+    return file;
+}

package/dist/index.d.ts

@@ -1,2 +1,7 @@
-export { Store, getStorePath } from "./store";
-export type { Data } from "./store";
+export { Store } from "./store";
+export type { StoreOptions, ImportResult } from "./store";
+export type { Entry, HistoryItem, StoreFile } from "./format";
+export { locateStore, globalStorePath, PROJECT_FILE } from "./locate";
+export type { StoreLocation } from "./locate";
+export { parseValue, formatValue, typeOf } from "./values";
+export type { Value, ValueType } from "./values";

package/dist/index.js

@@ -1,7 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStorePath = exports.Store = void 0;
+exports.typeOf = exports.formatValue = exports.parseValue = exports.PROJECT_FILE = exports.globalStorePath = exports.locateStore = exports.Store = void 0;
 // Public API, so the store can also be used from code: import { Store } from "local-kv-cli"
 var store_1 = require("./store");
 Object.defineProperty(exports, "Store", { enumerable: true, get: function () { return store_1.Store; } });
-Object.defineProperty(exports, "getStorePath", { enumerable: true, get: function () { return store_1.getStorePath; } });
+var locate_1 = require("./locate");
+Object.defineProperty(exports, "locateStore", { enumerable: true, get: function () { return locate_1.locateStore; } });
+Object.defineProperty(exports, "globalStorePath", { enumerable: true, get: function () { return locate_1.globalStorePath; } });
+Object.defineProperty(exports, "PROJECT_FILE", { enumerable: true, get: function () { return locate_1.PROJECT_FILE; } });
+var values_1 = require("./values");
+Object.defineProperty(exports, "parseValue", { enumerable: true, get: function () { return values_1.parseValue; } });
+Object.defineProperty(exports, "formatValue", { enumerable: true, get: function () { return values_1.formatValue; } });
+Object.defineProperty(exports, "typeOf", { enumerable: true, get: function () { return values_1.typeOf; } });