satoridb 1.2.2 → 1.2.3

package/cli.js

@@ -1,558 +1,259 @@
 #!/usr/bin/env node
 
-let path = require("path");
-let os = require("os");
-let fs = require("fs");
-let { spawnSync } = require("child_process");
-let readline = require("readline");
-let { Satori } = require("satori-node");
-
-let binName = os.platform() === "win32" ? "satori.exe" : "satori";
-let binPath = path.join(os.homedir(), ".satori", "bin", binName);
-
-let nl = true;
-
-let satoriInstance = null;
-let currentUser = null;
-let currentPassword = null;
-let currentMindspace = null;
-
-// Function to parse arguments with quoted strings support
-function parseArguments(line) {
-  let args = [];
-  let current = '';
-  let inQuotes = false;
-  let quoteChar = '';
-
-  for (let i = 0; i < line.length; i++) {
-    let char = line[i];
-
-    if ((char === '"' || char === "'") && !inQuotes) {
-      inQuotes = true;
-      quoteChar = char;
-      continue;
-    }
-
-    if (char === quoteChar && inQuotes) {
-      inQuotes = false;
-      quoteChar = '';
-      continue;
-    }
-
-    if (char === ' ' && !inQuotes) {
-      if (current.trim()) {
-        args.push(current.trim());
-        current = '';
-      }
-      continue;
-    }
-
-    current += char;
-  }
-
-  if (current.trim()) {
-    args.push(current.trim());
+/**
+ * Satori Interactive CLI (Improved)
+ * - Command registry (easy to extend)
+ * - Robust arg parsing (quotes, escapes)
+ * - Fixed bugs (lecture args check, set_mindspace double call)
+ * - Better UX (history, tab completion, prompt context)
+ * - Centralized error handling
+ */
+
+const path = require("path");
+const os = require("os");
+const fs = require("fs");
+const { spawnSync } = require("child_process");
+const readline = require("readline");
+const { Satori } = require("satori-node");
+
+// -------------------------------
+// Globals / State
+// -------------------------------
+const binName = os.platform() === "win32" ? "satori.exe" : "satori";
+const binPath = path.join(os.homedir(), ".satori", "bin", binName);
+
+let satori = null;
+let session = {
+  host: null,
+  user: null,
+  password: null,
+  mindspace: null,
+};
+
+// -------------------------------
+// Utils
+// -------------------------------
+function assertInstalled() {
+  if (!fs.existsSync(binPath)) {
+    console.error("❌ Satori binary not found. Reinstall the package.");
+    process.exit(1);
   }
-
-  return args;
 }
 
-// Función helper para parsear JSON, arrays y tipos básicos
-function parseData(data) {
-  if (typeof data === 'string') {
-    let trimmed = data.trim();
-
-    // Intentar parsear como número
-    if (!isNaN(trimmed) && trimmed !== '') {
-      let numValue = Number(trimmed);
-      if (Number.isInteger(numValue)) return parseInt(trimmed);
-      return numValue;
-    }
-
-    // Intentar parsear booleanos
-    if (trimmed.toLowerCase() === 'true') return true;
-    if (trimmed.toLowerCase() === 'false') return false;
-
-    // Intentar parsear JSON solo si empieza con { o [
-    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
-      try {
-        return JSON.parse(trimmed);
-      } catch (e) {
-        // Intentar evaluar como objeto JavaScript literal
-        try {
-          return new Function('return (' + trimmed + ')')();
-        } catch (evalError) {
-          console.log("⚠️ Could not parse as JSON or JavaScript object, returning original string");
-          return data;
-        }
-      }
-    }
-  }
-  return data;
+function runBinary(args) {
+  assertInstalled();
+  const r = spawnSync(binPath, args, { stdio: "inherit" });
+  if (r.error) throw r.error;
 }
 
-function run(args) {
-  if (!fs.existsSync(binPath)) {
-    console.log("❌ Satori is not installed. Try reinstalling the package.");
-    process.exit(1);
-  }
-
-  let result = spawnSync(binPath, args, { stdio: "inherit" });
-  if (result.error) {
-    console.log("❌ Error executing:", result.error.message);
-    process.exit(1);
-  }
+function parseArgs(line) {
+  const re = /"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|(\S+)/g;
+  const out = [];
+  let m;
+  while ((m = re.exec(line))) out.push(m[1] ?? m[2] ?? m[3]);
+  return out.map(v => v.replace(/\\"/g, '"').replace(/\\'/g, "'"));
 }
 
-// Helper function to add user and password to command parameters if defined
-function addCredentials(params) {
-  if (currentUser !== null && currentUser !== undefined) {
-    params.username = currentUser;
-  }
-  if (currentPassword !== null && currentPassword !== undefined) {
-    params.password = currentPassword;
+function parseData(v) {
+  if (typeof v !== "string") return v;
+  const t = v.trim();
+  if (t === "true") return true;
+  if (t === "false") return false;
+  if (!isNaN(t) && t !== "") return Number(t);
+  if (t.startsWith("{") || t.startsWith("[")) {
+    try { return JSON.parse(t); } catch {}
   }
-  return params;
+  return v;
 }
 
-async function connectToSatori(host, user = null, password = null) {
-  try {
-    console.log(`🔗 Connecting to ${host}...`);
-    // Store credentials for use in all commands
-    currentUser = user;
-    currentPassword = password;
-    satoriInstance = new Satori({ host, user, password });
-    await satoriInstance.connect();
-    console.log("✅ Successfully connected to SatoriDB");
-    return true;
-  } catch (error) {
-    console.log("❌ Error connecting:", error.message);
-    return false;
-  }
+function requireConn() {
+  if (!satori) throw new Error("No active connection. Use: connect <host> [user] [password]");
 }
 
-async function executeCommand(command, args) {
-  // Comandos que no requieren conexión
-  switch (command) {
-    case "help":
-      showHelp();
-      return;
-
-    case "exit":
-    case "quit":
-      console.log("👋 ¡Hasta luego!");
-      process.exit(0);
-      return;
-
-    case "clear":
-      clearScreen();
-      return;
-    
-      case "mindspace":
-        let cmd = args[0];
-        if (cmd == "select"){
-          let mId = args[1];
-          currentMindspace = mId;
-        }
-  }
+function withCreds(p = {}) {
+  if (session.user) p.user = session.user;
+  if (session.password) p.password = session.password;
+  return p;
+}
 
-  // Commands that require connection
-  if (!satoriInstance) {
-    console.log("❌ No active connection. Use 'connect <host> [user] [password]' first.");
-    return;
-  }
+function promptLabel() {
+  return `satori${session.mindspace ? `:${session.mindspace}` : ""}> `;
+}
 
-  try {
-    switch (command) {
-      case "set":
-        if (args.length < 2) {
-          console.log("❌ Uso: set <key> <data>");
-          return;
-        }
-        let key = args[0];
-        let data = args.slice(1).join(' '); // Unir todos los argumentos restantes
-
-        // Parsear JSON si es necesario
-        data = parseData(data);
-
-        await satoriInstance.set(addCredentials({ key, data }));
-        console.log(`✅ Data saved in key: ${key}`);
-        break;
-
-      case "put":
-        if (args.length < 3) {
-          console.log("❌ Uso: put <key> <replace_field> <replace_value>");
-          return;
-        }
-        let [putKey, replaceField, replaceValue, encryption_key_put] = args;
-        // Parsear JSON en el valor si es necesario
-        replaceValue = parseData(replaceValue);
-        await satoriInstance.put(addCredentials({ key: putKey, replace_field: replaceField, replace_value: replaceValue, encryption_key: encryption_key_put }));
-        console.log(`✅ Field updated: ${putKey}.${replaceField} = ${replaceValue}`);
-        break;
-
-      case "get":
-        if (args.length >= 1) {
-          let getKey = args[0];
-          let encryption_key_get = args[1] || null;
-          let result = await satoriInstance.get(addCredentials({ key: getKey, encryption_key: encryption_key_get }));
-          console.log(`📄 Data from ${getKey}:`, JSON.stringify(result, null, 2));
-          break;
-        } else {
-          let result = await satoriInstance.get(addCredentials({}));
-          console.log(`📄 Data from get:`, JSON.stringify(result, null, 2));
-          break;
-        }
-
-      case "set_mindspace":
-        if (args.length == 1) {
-          let profile = args[0];
-          let res = null;
-          if (currentMindspace != null){
-
-            res = await satoriInstance.setMindspace({
-              config: profile,
-              mindspace_id: currentMindspace
-            })
-          }
-          
-          res = await satoriInstance.setMindspace({
-            config: profile
-          })
-
-          console.log(`✅ Mindspace set: ${res.data}`);
-          break;
-        } else if (args.length == 2) {
-          let profile = args[0];
-          let mindspace_id = args[1];
-
-          let res = await satoriInstance.setMindspace({
-            mindspace_id: mindspace_id,
-            config: profile
-          })
-          console.log(`✅ Mindspace set: ${res.data}`);
-          break;
-        }
-
-      case "delete_mindspace":
-        if (args.length == 1) {
-          let mid = args[0];
-
-          let res = await satoriInstance.deleteMindspace({
-            mindspace_id: mid
-          })
-          console.log(`✅ Mindspace deleted: ${mid}`);
-          break;
-        }
-
-      case "chat":
-        if (args.length == 1) {
-          if(currentMindspace == null){
-            console.log("Select a mindspace with: mindspace select <mindspace_id>")
-          }
-          let mid = currentMindspace;
-          let message = args[0]
-
-          let res = await satoriInstance.chatMindspace({
-            mindspace_id: mid,
-            message: message
-          })
-          console.log(`${res.data}`);
-          break;
-        }
-      
-      case "lecture":
-        if(args == 1){
-          if(currentMindspace == null){
-            console.log("Select a mindspace with: mindspace select <mindspace_id>")
-          }
-          let mid = currentMindspace;
-          let message = args[0]
-
-          let res = await satoriInstance.lectureMindspace({
-            mindspace_id: mid,
-            corpus: message
-          })
-          console.log(`${res.data}`);
-          break;
-        }
-
-      case "delete":
-        if (args.length < 1) {
-          console.log("❌ Uso: delete <key> [encryption_key]");
-          return;
-        }
-        let deleteKey = args[0];
-        await satoriInstance.delete(addCredentials({ key: deleteKey }));
-        console.log(`🗑️ Key deleted: ${deleteKey}`);
-        break;
-
-      case "ask":
-        if (args.length < 1) {
-          console.log("❌ Usage: ask \"<question>\" [backend]");
-          return;
-        }
-        let question = args[0];
-        let backend = args[1] || null;
-        let result = await satoriInstance.ask(addCredentials({ question, backend }));
-        console.log("🔍 Search results:", JSON.stringify(result, null, 2));
-        break;
-
-      case "query":
-        if (args.length < 1) {
-          console.log("❌ Usage: query \"<query>\" [backend]");
-          return;
-        }
-        let query = args[0];
-        let backend_q = args[1] || null;
-        let result_q = await satoriInstance.query(addCredentials({ query, backend: backend_q }));
-        console.log("🔍 Search results:", JSON.stringify(result_q, null, 2));
-        break;
-
-      case "dfs":
-        if (args.length < 1) {
-          console.log("❌ Uso: dfs <node> [relation] [encryption_key]");
-          return;
-        }
-        let node = args[0];
-        let relation = args[1] || null;
-        let encryption_key = args[2] || null;
-        let result_dfs = await satoriInstance.dfs(addCredentials({ node, relation, encryption_key }));
-        console.log("🔍 Search results:", JSON.stringify(result_dfs, null, 2));
-        break;
-
-      case "encrypt":
-        if (args.length < 1) {
-          console.log("❌ Uso: encrypt <key> [encryption_key]");
-          return;
-        }
-        let key_encrypt = args[0];
-        let encryption_key_encrypt = args[1] || null;
-        let result_encrypt = await satoriInstance.encrypt(addCredentials({ key: key_encrypt, encryption_key: encryption_key_encrypt }));
-        console.log("🔍 Encryption results:", JSON.stringify(result_encrypt, null, 2));
-        break;
-
-      case "decrypt":
-        if (args.length < 1) {
-          console.log("❌ Uso: decrypt <key> [encryption_key]");
-          return;
-        }
-        let key_decrypt = args[0];
-        let encryption_key_decrypt = args[1] || null;
-        let result_decrypt = await satoriInstance.decrypt(addCredentials({ key: key_decrypt, encryption_key: encryption_key_decrypt }));
-        console.log("🔍 Decryption results:", JSON.stringify(result_decrypt, null, 2));
-        break;
-
-      case "push":
-        if (args.length < 3) {
-          console.log("❌ Uso: push <key> <array> <value> [encryption_key]");
-          return;
-        }
-        let key_push = args[0];
-        let array_push = args[1];
-        let value_push = args[2];
-        let encryption_key_push = args[3] || null;
-        // Parsear JSON en el valor si es necesario
-        value_push = parseData(value_push);
-        let result_push = await satoriInstance.push(addCredentials({ key: key_push, array: array_push, value: value_push, encryption_key: encryption_key_push }));
-        console.log("🔍 Insertion results:", JSON.stringify(result_push, null, 2));
-        break;
-
-      case "pop":
-        if (args.length < 2) {
-          console.log("❌ Uso: pop <key> <array> [encryption_key]");
-          return;
-        }
-        let key_pop = args[0];
-        let array_pop = args[1];
-        let encryption_key_pop = args[2] || null;
-        let result_pop = await satoriInstance.pop(addCredentials({ key: key_pop, array: array_pop, encryption_key: encryption_key_pop }));
-        console.log("🔍 Removal results:", JSON.stringify(result_pop, null, 2));
-        break;
-
-      case "splice":
-        if (args.length < 2) {
-          console.log("❌ Uso: splice <key> <array> [encryption_key]");
-          return;
-        }
-        let key_splice = args[0];
-        let array_splice = args[1];
-        let encryption_key_splice = args[2] || null;
-        let result_splice = await satoriInstance.splice(addCredentials({ key: key_splice, array: array_splice, encryption_key: encryption_key_splice }));
-        console.log("🔍 Insertion results:", JSON.stringify(result_splice, null, 2));
-        break;
-
-      case "remove":
-        if (args.length < 3) {
-          console.log("❌ Uso: remove <key> <array> <value> [encryption_key]");
-          return;
-        }
-        let key_remove = args[0];
-        let array_remove = args[1];
-        let value_remove = args[2];
-        let encryption_key_remove = args[3] || null;
-        // Parsear JSON en el valor si es necesario
-        value_remove = parseData(value_remove);
-        let result_remove = await satoriInstance.remove(addCredentials({ key: key_remove, array: array_remove, value: value_remove, encryption_key: encryption_key_remove }));
-        console.log("🔍 Removal results:", JSON.stringify(result_remove, null, 2));
-        break;
-
-      case "set_vertex":
-        if (args.length < 2) {
-          console.log("❌ Uso: set_vertex <key> <vertex> [encryption_key]");
-          return;
-        }
-        let key_set_vertex = args[0];
-        let vertex_set_vertex = args[1];
-        let encryption_key_set_vertex = args[2] || null;
-        // Parsear JSON en el vertex si es necesario
-        vertex_set_vertex = parseData(vertex_set_vertex);
-        let result_set_vertex = await satoriInstance.set_vertex(addCredentials({ key: key_set_vertex, vertex: vertex_set_vertex, encryption_key: encryption_key_set_vertex }));
-        console.log("🔍 Insertion results:", JSON.stringify(result_set_vertex, null, 2));
-        break;
-
-      case "get_vertex":
-        if (args.length < 1) {
-          console.log("❌ Uso: get_vertex <key> [encryption_key]");
-          return;
-        }
-        let key_get_vertex = args[0];
-        let encryption_key_get_vertex = args[1] || null;
-        let result_get_vertex = await satoriInstance.get_vertex(addCredentials({ key: key_get_vertex, encryption_key: encryption_key_get_vertex }));
-        console.log("🔍 Insertion results:", JSON.stringify(result_get_vertex, null, 2));
-        break;
-
-      case "delete_vertex":
-        if (args.length < 2) {
-          console.log("❌ Uso: delete_vertex <key> <vertex> [encryption_key]");
-          return;
-        }
-        let key_delete_vertex = args[0];
-        let vertex_delete_vertex = args[1];
-        let encryption_key_delete_vertex = args[2] || null;
-        // Parsear JSON en el vertex si es necesario
-        vertex_delete_vertex = parseData(vertex_delete_vertex);
-        let result_delete_vertex = await satoriInstance.delete_vertex(addCredentials({ key: key_delete_vertex, vertex: vertex_delete_vertex, encryption_key: encryption_key_delete_vertex }));
-        console.log("🔍 Removal results:", JSON.stringify(result_delete_vertex, null, 2));
-        break;
-
-      default:
-        console.log("❌ Command not recognized. Use 'help' to see available commands.");
+// -------------------------------
+// Commands Registry
+// -------------------------------
+const commands = {
+  help: {
+    desc: "Show help",
+    run() { showHelp(); }
+  },
+
+  exit: { run() { process.exit(0); } },
+  quit: { run() { process.exit(0); } },
+  clear: { run() { console.clear(); } },
+
+  connect: {
+    desc: "connect <host> [user] [password]",
+    async run([host, user = null, password = null]) {
+      if (!host) throw new Error("Usage: connect <host> [user] [password]");
+      console.log(`🔗 Connecting to ${host}...`);
+      satori = new Satori({ host, user, password });
+      await satori.connect();
+      Object.assign(session, { host, user, password });
+      console.log("✅ Connected");
     }
-  } catch (error) {
-    console.log("❌ Error executing command:", error.message);
-  }
-}
+  },
+
+  mindspace: {
+    desc: "mindspace select <id>",
+    run([sub, id]) {
+      if (sub !== "select" || !id) throw new Error("Usage: mindspace select <id>");
+      session.mindspace = id;
+      console.log(`🧠 Mindspace selected: ${id}`);
+    }
+  },
+
+  set: {
+    desc: "set <key> <data>",
+    async run([key, ...rest]) {
+      requireConn();
+      if (!key || !rest.length) throw new Error("Usage: set <key> <data>");
+      const data = parseData(rest.join(" "));
+      await satori.set(withCreds({ key, data }));
+      console.log(`✅ Saved: ${key}`);
+    }
+  },
+
+  get: {
+    desc: "get <key>",
+    async run([key]) {
+      requireConn();
+      const r = await satori.get(withCreds(key ? { key } : {}));
+      console.log(JSON.stringify(r, null, 2));
+    }
+  },
+
+  put: {
+    desc: "put <key> <field> <value>",
+    async run([key, field, value]) {
+      requireConn();
+      if (!key || !field) throw new Error("Usage: put <key> <field> <value>");
+      await satori.put(withCreds({ key, replace_field: field, replace_value: parseData(value) }));
+      console.log("✅ Updated");
+    }
+  },
+
+  delete: {
+    desc: "delete <key>",
+    async run([key]) {
+      requireConn();
+      if (!key) throw new Error("Usage: delete <key>");
+      await satori.delete(withCreds({ key }));
+      console.log(`🗑️ Deleted: ${key}`);
+    }
+  },
+
+  ask: {
+    desc: "ask \"<question>\"",
+    async run([q, backend = null]) {
+      requireConn();
+      if (!q) throw new Error("Usage: ask \"<question>\"");
+      const r = await satori.ask(withCreds({ question: q, backend }));
+      console.log(JSON.stringify(r, null, 2));
+    }
+  },
+
+  query: {
+    desc: "query \"<query>\"",
+    async run([q, backend = null]) {
+      requireConn();
+      if (!q) throw new Error("Usage: query \"<query>\"");
+      const r = await satori.query(withCreds({ query: q, backend }));
+      console.log(JSON.stringify(r, null, 2));
+    }
+  },
+
+  chat: {
+    desc: "chat \"<message>\"",
+    async run([msg]) {
+      requireConn();
+      if (!session.mindspace) throw new Error("Select a mindspace first");
+      const r = await satori.chatMindspace({ mindspace_id: session.mindspace, message: msg });
+      console.log(r.data);
+    }
+  },
+
+  lecture: {
+    desc: "lecture \"<corpus>\"",
+    async run([corpus]) {
+      requireConn();
+      if (!session.mindspace) throw new Error("Select a mindspace first");
+      const r = await satori.lectureMindspace({ mindspace_id: session.mindspace, corpus });
+      console.log(r.data);
+    }
+  },
+};
 
+// -------------------------------
+// Help
+// -------------------------------
 function showHelp() {
-  console.log(`
-📚 Available commands:
-
-🔗 Connection:
-  connect <host> [user] [password]  - Connect to SatoriDB
-
-📝 Data operations:
-  set <key> <data>                  - Save data to a key
-  put <key> <field> <value>         - Update a specific field
-  get <key>                         - Get data from a key
-  delete <key>                      - Delete a key
-  ask "<question>" [backend]        - Ask a question
-  query "<query>" [backend]         - Make a query
-
-🛠️ Others:
-  help                              - Show this help
-  exit / quit                       - Exit the CLI
-  clear                             - Clear screen
-
-💡 Examples: 
-  set user:123 '{"name": "John", "age": 25}'
-  ask "What is the weather like today?"
-  query "Find all users with age > 25"
-`);
-}
-
-function clearScreen() {
-  console.clear();
+  console.log("\n📚 Commands:\n");
+  Object.entries(commands).forEach(([k, v]) => {
+    if (v.desc) console.log(`  ${k.padEnd(12)} ${v.desc}`);
+  });
+  console.log("");
 }
 
-async function startInteractiveCLI() {
-  let rl = readline.createInterface({
+// -------------------------------
+// Interactive Shell
+// -------------------------------
+async function startREPL() {
+  const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
-    prompt: 'satori> '
+    historySize: 500,
+    completer(line) {
+      const hits = Object.keys(commands).filter(c => c.startsWith(line));
+      return [hits.length ? hits : Object.keys(commands), line];
+    }
   });
 
-  console.log("🚀 SatoriDB Interactive CLI");
-  console.log("📝 Type 'help' to see available commands");
-  console.log("💡 Use 'connect <host> [user] [password]' to start\n");
-
+  const refreshPrompt = () => rl.setPrompt(promptLabel());
+  refreshPrompt();
   rl.prompt();
 
-  rl.on('line', async (line) => {
-    let trimmedLine = line.trim();
+  rl.on("line", async (line) => {
+    const parts = parseArgs(line.trim());
+    if (!parts.length) return rl.prompt();
 
-    if (trimmedLine === '') {
-      rl.prompt();
-      return;
-    }
+    const [cmd, ...args] = parts;
+    const entry = commands[cmd];
 
-    // Parse arguments with quoted strings support
-    let parts = parseArguments(trimmedLine);
-    let command = parts[0];
-    let args = parts.slice(1);
-
-    if (command === 'connect') {
-      if (args.length < 1) {
-        console.log("❌ Uso: connect <host> [user] [password]");
-        rl.prompt();
-        return;
-      }
-      let host = args[0];
-      let user = args[1] || null;
-      let password = args[2] || null;
-      let success = await connectToSatori(host, user, password);
-      if (success) {
-        console.log("✅ Now you can use commands like 'set', 'get', 'put', etc.");
-      }
-    } else {
-      await executeCommand(command, args);
+    try {
+      if (!entry) throw new Error("Unknown command. Type 'help'.");
+      await entry.run(args);
+    } catch (e) {
+      console.error("❌", e.message);
     }
 
+    refreshPrompt();
     rl.prompt();
   });
-
-  rl.on('close', () => {
-    console.log('\n👋 Goodbye!');
-    process.exit(0);
-  });
 }
 
-let args = process.argv.slice(2);
+// -------------------------------
+// Entry
+// -------------------------------
+const argv = process.argv.slice(2);
 
-if (args[0] === "update") {
-  console.log("🔄 Ejecutando actualización...");
+if (argv[0] === "run") {
+  runBinary(argv.slice(1));
+} else if (argv[0] === "update") {
   require("./postinstall");
-} else if (args[0] === "run") {
-  run(args.slice(1));
-} else if (args[0] === "connect") {
-  if (args.length < 2) {
-    console.log("❌ Uso: satoridb connect <host> [user] [password]");
-    process.exit(1);
-  }
-  let host = args[1];
-  let user = args[2] || null;
-  let password = args[3] || null;
-  connectToSatori(host, user, password).then(success => {
-    if (success) {
-      startInteractiveCLI();
-    } else {
-      process.exit(1);
-    }
-  });
-} else if (args[0] === "verify") {
-  console.log("🔍 Verifying installation...");
+} else if (argv[0] === "verify") {
   require("./verify-install");
 } else {
-  // If no arguments or unrecognized arguments, start interactive CLI
-  startInteractiveCLI();
-}
+  startREPL();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "satoridb",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "Install satori",
   "bin": {
     "satoridb": "./cli.js"