@codedir/mimir-code 0.1.1 → 0.1.3

package/dist/cli.mjs

@@ -1,3 +1,5 @@
+#!/usr/bin/env node
+
 // src/cli.ts
 import { Command } from "commander";
 
@@ -5,28 +7,28 @@ import { Command } from "commander";
 import fs from "fs/promises";
 import fg from "fast-glob";
 var FileSystemAdapter = class {
-  async readFile(path8, encoding = "utf-8") {
-    return fs.readFile(path8, encoding);
+  async readFile(path9, encoding = "utf-8") {
+    return fs.readFile(path9, encoding);
   }
-  async writeFile(path8, content, encoding = "utf-8") {
-    await fs.writeFile(path8, content, encoding);
+  async writeFile(path9, content, encoding = "utf-8") {
+    await fs.writeFile(path9, content, encoding);
   }
-  async exists(path8) {
+  async exists(path9) {
     try {
-      await fs.access(path8);
+      await fs.access(path9);
       return true;
     } catch {
       return false;
     }
   }
-  async mkdir(path8, options) {
-    await fs.mkdir(path8, options);
+  async mkdir(path9, options) {
+    await fs.mkdir(path9, options);
   }
-  async readdir(path8) {
-    return fs.readdir(path8);
+  async readdir(path9) {
+    return fs.readdir(path9);
   }
-  async stat(path8) {
-    const stats = await fs.stat(path8);
+  async stat(path9) {
+    const stats = await fs.stat(path9);
     return {
       isFile: () => stats.isFile(),
       isDirectory: () => stats.isDirectory(),
@@ -34,11 +36,11 @@ var FileSystemAdapter = class {
       mtime: stats.mtime
     };
   }
-  async unlink(path8) {
-    await fs.unlink(path8);
+  async unlink(path9) {
+    await fs.unlink(path9);
   }
-  async rmdir(path8, options) {
-    await fs.rmdir(path8, options);
+  async rmdir(path9, options) {
+    await fs.rmdir(path9, options);
   }
   async copyFile(src, dest) {
     await fs.copyFile(src, dest);
@@ -51,6 +53,94 @@ var FileSystemAdapter = class {
   }
 };
 
+// src/platform/ProcessExecutorAdapter.ts
+import { execa, execaCommand } from "execa";
+var ProcessExecutorAdapter = class {
+  /**
+   * Execute command and wait for completion
+   */
+  async execute(command, args = [], options = {}) {
+    try {
+      const result = await execa(command, args, {
+        cwd: options.cwd,
+        env: options.env,
+        timeout: options.timeout,
+        shell: options.shell,
+        input: options.input,
+        reject: false
+        // Don't throw on non-zero exit codes
+      });
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode ?? (result.failed ? 1 : 0),
+        command: result.command,
+        timedOut: result.timedOut ?? false
+      };
+    } catch (error) {
+      const exitCode = error.code === "ENOENT" ? 127 : error.exitCode || 1;
+      return {
+        stdout: error.stdout || "",
+        stderr: error.stderr || error.message || String(error),
+        exitCode,
+        command: error.command || `${command} ${args.join(" ")}`,
+        timedOut: error.timedOut ?? false
+      };
+    }
+  }
+  /**
+   * Spawn process (doesn't wait for completion)
+   */
+  spawn(command, args = [], options = {}) {
+    const subprocess = execa(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      timeout: options.timeout,
+      shell: options.shell,
+      stdin: options.input ? "pipe" : "inherit",
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    if (options.input && subprocess.stdin) {
+      subprocess.stdin.write(options.input);
+      subprocess.stdin.end();
+    }
+    return subprocess;
+  }
+  /**
+   * Execute command in shell
+   */
+  async executeShell(command, options = {}) {
+    try {
+      const result = await execaCommand(command, {
+        cwd: options.cwd,
+        env: options.env,
+        timeout: options.timeout,
+        shell: true,
+        input: options.input,
+        reject: false
+        // Don't throw on non-zero exit codes
+      });
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode ?? (result.failed ? 1 : 0),
+        command: result.command,
+        timedOut: result.timedOut ?? false
+      };
+    } catch (error) {
+      const exitCode = error.code === "ENOENT" ? 127 : error.exitCode || 1;
+      return {
+        stdout: error.stdout || "",
+        stderr: error.stderr || error.message || String(error),
+        exitCode,
+        command: error.command || command,
+        timedOut: error.timedOut ?? false
+      };
+    }
+  }
+};
+
 // src/config/schemas.ts
 import { z } from "zod";
 var ThemeSchema = z.enum([
@@ -3816,6 +3906,19 @@ import { fileURLToPath } from "url";
 import { readFileSync, existsSync } from "fs";
 function locateWasmFile() {
   const wasmFileName = "sql-wasm.wasm";
+  const currentDir = dirname(fileURLToPath(import.meta.url));
+  const nodeModulesPaths = [
+    // Relative to the built module (dist/storage/Database.js)
+    join(currentDir, "..", "..", "node_modules", "sql.js", "dist", wasmFileName),
+    // Relative to current working directory (for local development)
+    join(process.cwd(), "node_modules", "sql.js", "dist", wasmFileName)
+  ];
+  for (const modulePath of nodeModulesPaths) {
+    if (existsSync(modulePath)) {
+      const buffer = readFileSync(modulePath);
+      return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+    }
+  }
   const executablePath = process.argv[0] || process.execPath;
   const binaryDir = dirname(executablePath);
   const resourcesPaths = [
@@ -3832,23 +3935,13 @@ function locateWasmFile() {
       return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
     }
   }
-  const currentDir = dirname(fileURLToPath(import.meta.url));
-  const nodeModulesPaths = [
-    join(currentDir, "..", "..", "node_modules", "sql.js", "dist", wasmFileName),
-    join(process.cwd(), "node_modules", "sql.js", "dist", wasmFileName)
-  ];
-  for (const modulePath of nodeModulesPaths) {
-    if (existsSync(modulePath)) {
-      const buffer = readFileSync(modulePath);
-      return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
-    }
-  }
   const diagnostics = [
+    `import.meta.url: ${import.meta.url}`,
+    `currentDir: ${currentDir}`,
     `process.argv[0]: ${process.argv[0]}`,
     `process.execPath: ${process.execPath}`,
     `executablePath: ${executablePath}`,
     `binaryDir: ${binaryDir}`,
-    `currentDir: ${currentDir}`,
     `process.cwd(): ${process.cwd()}`
   ];
   throw new Error(
@@ -3858,7 +3951,7 @@ Diagnostics:
 ${diagnostics.join("\n")}
 
 Tried:
-` + [...resourcesPaths, ...nodeModulesPaths].map((p) => `  - ${p}`).join("\n")
+` + [...nodeModulesPaths, ...resourcesPaths].map((p) => `  - ${p}`).join("\n")
   );
 }
 var DatabaseManager = class _DatabaseManager {
@@ -6058,13 +6151,457 @@ var InitCommand = class {
   }
 };
 
+// src/cli/commands/UninstallCommand.ts
+import path8 from "path";
+import os6 from "os";
+import React11 from "react";
+import { render as render3, Box as Box12, Text as Text11 } from "ink";
+import Spinner from "ink-spinner";
+import TextInput2 from "ink-text-input";
+var UninstallCommand = class {
+  constructor(fs4, executor2) {
+    this.fs = fs4;
+    this.executor = executor2;
+  }
+  async execute(options = {}) {
+    try {
+      const autoConfirm = options.yes || options.quiet;
+      let confirmed = autoConfirm;
+      if (!autoConfirm) {
+        confirmed = await this.promptConfirmation();
+      }
+      if (!confirmed) {
+        if (!options.quiet) {
+          logger.info("Uninstall cancelled.");
+        }
+        return;
+      }
+      let keepConfig;
+      if (options.removeConfig !== void 0) {
+        keepConfig = !options.removeConfig;
+      } else if (options.keepConfig !== void 0) {
+        keepConfig = options.keepConfig;
+      } else if (autoConfirm) {
+        keepConfig = true;
+      } else {
+        keepConfig = await this.promptKeepConfig();
+      }
+      const result = await this.uninstall(keepConfig, options.quiet);
+      if (!options.quiet) {
+        this.printSummary(result);
+      }
+      if (!result.success) {
+        process.exit(1);
+      }
+    } catch (error) {
+      if (!options.quiet) {
+        logger.error("Uninstall failed", { error });
+      }
+      process.exit(1);
+    }
+  }
+  async promptConfirmation() {
+    return new Promise((resolve) => {
+      const ConfirmPrompt = () => {
+        const [input, setInput] = React11.useState("");
+        const [submitted, setSubmitted] = React11.useState(false);
+        React11.useEffect(() => {
+          if (submitted) {
+            const answer = input.toLowerCase();
+            resolve(answer === "y" || answer === "yes");
+          }
+        }, [submitted, input]);
+        if (submitted) {
+          return null;
+        }
+        return React11.createElement(
+          Box12,
+          { flexDirection: "column", marginY: 1 },
+          React11.createElement(
+            Box12,
+            { marginBottom: 1 },
+            React11.createElement(
+              Text11,
+              { bold: true, color: "yellow" },
+              "\u26A0\uFE0F  WARNING: This will uninstall Mimir from your system."
+            )
+          ),
+          React11.createElement(
+            Box12,
+            null,
+            React11.createElement(Text11, null, "Are you sure you want to continue? (y/N): "),
+            React11.createElement(TextInput2, {
+              value: input,
+              onChange: setInput,
+              onSubmit: () => setSubmitted(true)
+            })
+          )
+        );
+      };
+      render3(React11.createElement(ConfirmPrompt));
+    });
+  }
+  async promptKeepConfig() {
+    return new Promise((resolve) => {
+      const ConfigPrompt = () => {
+        const [input, setInput] = React11.useState("");
+        const [submitted, setSubmitted] = React11.useState(false);
+        React11.useEffect(() => {
+          if (submitted) {
+            const answer = input.toLowerCase();
+            resolve(answer !== "n" && answer !== "no");
+          }
+        }, [submitted, input]);
+        if (submitted) {
+          return null;
+        }
+        return React11.createElement(
+          Box12,
+          { flexDirection: "column", marginY: 1 },
+          React11.createElement(
+            Box12,
+            { marginBottom: 1 },
+            React11.createElement(
+              Text11,
+              null,
+              "Do you want to keep your Mimir configuration and data in ~/.mimir?"
+            )
+          ),
+          React11.createElement(
+            Box12,
+            null,
+            React11.createElement(Text11, null, "Keep configuration? (Y/n): "),
+            React11.createElement(TextInput2, {
+              value: input,
+              onChange: setInput,
+              onSubmit: () => setSubmitted(true)
+            })
+          )
+        );
+      };
+      render3(React11.createElement(ConfigPrompt));
+    });
+  }
+  async uninstall(keepConfig, quiet = false) {
+    const result = {
+      success: true,
+      removed: [],
+      errors: [],
+      keepConfig
+    };
+    let clear;
+    if (!quiet) {
+      const UninstallProgress = () => React11.createElement(
+        Box12,
+        null,
+        React11.createElement(
+          Text11,
+          { color: "cyan" },
+          React11.createElement(Spinner, { type: "dots" }),
+          " Uninstalling Mimir..."
+        )
+      );
+      const rendered = render3(React11.createElement(UninstallProgress));
+      clear = rendered.clear;
+    }
+    try {
+      const homeDir = os6.homedir();
+      const installType = await this.detectInstallType();
+      if (!quiet) {
+        logger.info(`Detected installation type: ${installType}`);
+      }
+      if (installType === "binary") {
+        await this.removeBinaryInstallation(homeDir, result, quiet);
+      }
+      if (installType === "npm") {
+        await this.removeNpmInstallation(result, quiet);
+      }
+      if (!keepConfig) {
+        await this.removeGlobalConfig(homeDir, result, quiet);
+      } else if (!quiet) {
+        logger.info("Keeping global configuration at ~/.mimir");
+      }
+    } catch (error) {
+      result.success = false;
+      result.errors.push(
+        `Uninstall failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+      if (!quiet) {
+        logger.error("Uninstall error", { error });
+      }
+    } finally {
+      if (clear) {
+        clear();
+      }
+    }
+    return result;
+  }
+  async detectInstallType() {
+    try {
+      const scriptPath = process.argv[1];
+      if (!scriptPath) {
+        logger.debug("No script path found in process.argv[1]");
+        return "unknown";
+      }
+      logger.debug(`Detecting install type from script path: ${scriptPath}`);
+      const normalizedPath = path8.normalize(scriptPath).toLowerCase();
+      if (normalizedPath.includes("node_modules")) {
+        logger.debug("Detected npm installation (node_modules in path)");
+        return "npm";
+      }
+      const homeDir = os6.homedir();
+      const mimirBinPath = path8.normalize(path8.join(homeDir, ".mimir", "bin")).toLowerCase();
+      const localBinPath = path8.normalize(path8.join(homeDir, ".local", "bin")).toLowerCase();
+      if (normalizedPath.includes(mimirBinPath)) {
+        logger.debug("Detected binary installation (.mimir/bin in path)");
+        return "binary";
+      }
+      if (normalizedPath.includes(localBinPath)) {
+        logger.debug("Detected binary installation (.local/bin in path)");
+        return "binary";
+      }
+      const binaryPaths = [
+        // Unix binary locations
+        path8.join(homeDir, ".local", "bin", "mimir"),
+        path8.join(homeDir, ".mimir", "bin", "mimir"),
+        // Windows binary locations (.exe, .cmd variants)
+        path8.join(homeDir, ".local", "bin", "mimir.exe"),
+        path8.join(homeDir, ".local", "bin", "mimir.cmd"),
+        path8.join(homeDir, ".mimir", "bin", "mimir.exe"),
+        path8.join(homeDir, ".mimir", "bin", "mimir.cmd")
+      ];
+      for (const binPath of binaryPaths) {
+        if (await this.fs.exists(binPath)) {
+          logger.debug(`Detected binary installation (found file at ${binPath})`);
+          return "binary";
+        }
+      }
+      logger.debug("Could not detect installation type - defaulting to unknown");
+      return "unknown";
+    } catch (error) {
+      logger.debug("Error detecting installation type", { error });
+      return "unknown";
+    }
+  }
+  async removeNpmInstallation(result, quiet = false) {
+    if (!this.executor) {
+      if (!quiet) {
+        logger.warn("Cannot automatically uninstall npm package.");
+        logger.info("Please run manually: npm uninstall -g @codedir/mimir-code");
+      }
+      return;
+    }
+    try {
+      if (!quiet) {
+        logger.info("Removing npm global package...");
+      }
+      const npmResult = await this.executor.execute(
+        "npm",
+        ["uninstall", "-g", "@codedir/mimir-code"],
+        {
+          cwd: process.cwd()
+        }
+      );
+      if (npmResult.exitCode === 0) {
+        result.removed.push("npm global package (@codedir/mimir-code)");
+        if (!quiet) {
+          logger.info("Successfully uninstalled npm package");
+        }
+      } else {
+        throw new Error(`npm uninstall failed: ${npmResult.stderr}`);
+      }
+    } catch (error) {
+      if (!quiet) {
+        logger.error("Failed to uninstall npm package", { error });
+        logger.info("Please run manually: npm uninstall -g @codedir/mimir-code");
+      }
+      result.errors.push(
+        `npm uninstall failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  async removeBinaryInstallation(homeDir, result, quiet = false) {
+    const isWindows = process.platform === "win32";
+    const localBinPath = path8.join(homeDir, ".local", "bin", "mimir");
+    const mimirBinDir = path8.join(homeDir, ".mimir", "bin");
+    if (isWindows) {
+      await this.spawnWindowsCleanup(localBinPath, mimirBinDir, quiet);
+      await this.removeFromWindowsPath(quiet);
+      result.removed.push("Binary (scheduled for deletion after exit)");
+      result.removed.push("PATH entry");
+      if (!quiet) {
+        logger.info("\u2713 Scheduled binary deletion");
+        logger.info("\u2713 Removed from PATH");
+        logger.warn("\u26A0  Cleanup will complete in ~3 seconds");
+      }
+    } else {
+      if (await this.fs.exists(localBinPath)) {
+        await this.fs.unlink(localBinPath);
+        result.removed.push("~/.local/bin/mimir");
+        if (!quiet) {
+          logger.info("Removed binary from ~/.local/bin");
+        }
+      }
+      if (await this.fs.exists(mimirBinDir)) {
+        await this.fs.rmdir(mimirBinDir, { recursive: true });
+        result.removed.push("~/.mimir/bin/");
+        if (!quiet) {
+          logger.info("Removed binary directory");
+        }
+      }
+      if (!quiet) {
+        logger.info("\u2713 Binary uninstalled");
+        logger.warn("\u26A0  Current terminal still has mimir cached");
+        logger.info("  Run: hash -r   (to clear shell cache)");
+      }
+    }
+  }
+  async spawnWindowsCleanup(binPath, binDir, quiet) {
+    if (!this.executor) {
+      if (!quiet) {
+        logger.warn("Cannot spawn cleanup process - no executor available");
+      }
+      return;
+    }
+    try {
+      const cleanupScript = `@echo off
+REM Wait for parent process to exit
+timeout /t 3 /nobreak >nul 2>&1
+
+REM Delete binary if it exists
+if exist "${binPath}" (
+  del /f /q "${binPath}" >nul 2>&1
+)
+if exist "${binPath}.exe" (
+  del /f /q "${binPath}.exe" >nul 2>&1
+)
+if exist "${binPath}.cmd" (
+  del /f /q "${binPath}.cmd" >nul 2>&1
+)
+
+REM Delete binary directory
+if exist "${binDir}" (
+  rmdir /s /q "${binDir}" >nul 2>&1
+)
+
+REM Delete this cleanup script
+del /f /q "%~f0" >nul 2>&1
+`;
+      const tempDir = os6.tmpdir();
+      const cleanupPath = path8.join(tempDir, `mimir-cleanup-${Date.now()}.bat`);
+      await this.fs.writeFile(cleanupPath, cleanupScript);
+      const { spawn } = await import("child_process");
+      const child = spawn("cmd", ["/c", cleanupPath], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true
+      });
+      child.unref();
+      if (!quiet) {
+        logger.info("Spawned background cleanup process");
+      }
+    } catch (error) {
+      if (!quiet) {
+        logger.error("Failed to spawn cleanup process", { error });
+      }
+    }
+  }
+  async removeFromWindowsPath(quiet) {
+    if (!this.executor) return;
+    try {
+      const result = await this.executor.execute(
+        "powershell",
+        ["-NoProfile", "-Command", '[Environment]::GetEnvironmentVariable("Path", "User")'],
+        { cwd: process.cwd() }
+      );
+      if (result.exitCode !== 0) {
+        throw new Error("Failed to read PATH");
+      }
+      const currentPath = result.stdout.trim();
+      const pathEntries = currentPath.split(";").filter(Boolean);
+      const filteredEntries = pathEntries.filter((entry) => {
+        const normalizedEntry = path8.normalize(entry.trim()).toLowerCase();
+        return !normalizedEntry.includes("mimir");
+      });
+      if (filteredEntries.length < pathEntries.length) {
+        const newPath = filteredEntries.join(";");
+        await this.executor.execute(
+          "powershell",
+          [
+            "-NoProfile",
+            "-Command",
+            `[Environment]::SetEnvironmentVariable("Path", "${newPath}", "User")`
+          ],
+          { cwd: process.cwd() }
+        );
+        const removedCount = pathEntries.length - filteredEntries.length;
+        if (!quiet) {
+          logger.info(`Removed ${removedCount} PATH entry/entries containing 'mimir'`);
+        }
+      }
+    } catch (error) {
+      if (!quiet) {
+        logger.warn("Failed to remove from PATH", { error });
+        logger.info("You may need to manually remove from PATH");
+      }
+    }
+  }
+  async removeGlobalConfig(homeDir, result, quiet = false) {
+    const mimirDir = path8.join(homeDir, ".mimir");
+    if (await this.fs.exists(mimirDir)) {
+      await this.fs.rmdir(mimirDir, { recursive: true });
+      result.removed.push("~/.mimir/");
+      if (!quiet) {
+        logger.info("Removed configuration directory: ~/.mimir");
+        logger.info("All Mimir data has been deleted.");
+      }
+    }
+  }
+  /* eslint-disable no-console */
+  printSummary(result) {
+    console.log("");
+    console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+    if (result.success) {
+      console.log("\u2705 Mimir has been uninstalled");
+    } else {
+      console.log("\u274C Uninstall completed with errors");
+    }
+    console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+    if (result.removed.length > 0) {
+      console.log("");
+      console.log("Removed:");
+      result.removed.forEach((item) => console.log(`  - ${item}`));
+    }
+    if (result.keepConfig) {
+      console.log("");
+      console.log("Configuration preserved:");
+      console.log("  - ~/.mimir/ (your settings and data)");
+      console.log("");
+      console.log("To remove it later, run:");
+      console.log("  mimir uninstall --yes --remove-config");
+      console.log("  or manually: rm -rf ~/.mimir");
+    }
+    if (result.errors.length > 0) {
+      console.log("");
+      console.log("Errors:");
+      result.errors.forEach((error) => console.log(`  - ${error}`));
+    }
+    console.log("");
+    console.log("Thank you for using Mimir! \u{1F44B}");
+    console.log("");
+  }
+  /* eslint-enable no-console */
+};
+
 // src/cli.ts
 var fs3 = new FileSystemAdapter();
+var executor = new ProcessExecutorAdapter();
 var configLoader = new ConfigLoader(fs3);
 var firstRunDetector = new FirstRunDetector(fs3);
 var setupCommand = new SetupCommand(configLoader);
 var chatCommand = new ChatCommand(configLoader, firstRunDetector, setupCommand, fs3);
 var initCommand = new InitCommand(fs3, configLoader);
+var uninstallCommand = new UninstallCommand(fs3, executor);
 var program = new Command();
 program.name("mimir").description("Platform-agnostic, BYOK AI coding agent CLI").version("0.1.0");
 program.command("setup").description("Run setup wizard").action(async () => {
@@ -6079,6 +6616,12 @@ program.command("init").description("Initialize Mimir in current project").optio
   await initCommand.execute(void 0, options);
   process.exit(0);
 });
+program.command("uninstall").description("Uninstall Mimir from your system").option("-y, --yes", "Skip confirmation prompts").option("--keep-config", "Keep configuration directory (~/.mimir)").option("--remove-config", "Remove configuration directory (~/.mimir)").option("-q, --quiet", "Suppress output (implies --yes)").action(
+  async (options) => {
+    await uninstallCommand.execute(options);
+    process.exit(0);
+  }
+);
 var history = program.command("history").description("Manage conversation history");
 history.command("list").description("List recent conversations").action(() => {
   logger.warn("Listing conversations... (not implemented yet)");