@stackmemoryai/stackmemory 0.5.49 → 0.5.52

package/dist/cli/commands/sweep.js

@@ -5,476 +5,245 @@ const __dirname = __pathDirname(__filename);
 import { Command } from "commander";
 import chalk from "chalk";
 import ora from "ora";
-import {
-  existsSync,
-  readFileSync,
-  writeFileSync,
-  mkdirSync,
-  copyFileSync,
-  chmodSync
-} from "fs";
+import { existsSync } from "fs";
 import { join } from "path";
-import { spawn, execSync } from "child_process";
-function findPythonScript() {
-  const locations = [
-    join(
-      process.cwd(),
-      "packages",
-      "sweep-addon",
-      "python",
-      "sweep_predict.py"
-    ),
-    join(
-      process.cwd(),
-      "node_modules",
-      "@stackmemoryai",
-      "sweep-addon",
-      "python",
-      "sweep_predict.py"
-    ),
-    join(process.env.HOME || "", ".stackmemory", "sweep", "sweep_predict.py")
-  ];
-  for (const loc of locations) {
-    if (existsSync(loc)) {
-      return loc;
-    }
-  }
-  return null;
-}
-function findHookSource() {
-  const locations = [
-    join(process.cwd(), "templates", "claude-hooks", "post-edit-sweep.js"),
-    join(
-      process.cwd(),
-      "node_modules",
-      "@stackmemoryai",
-      "stackmemory",
-      "templates",
-      "claude-hooks",
-      "post-edit-sweep.js"
-    ),
-    join(
-      dirname(dirname(dirname(__dirname))),
-      "templates",
-      "claude-hooks",
-      "post-edit-sweep.js"
-    )
-  ];
-  for (const loc of locations) {
-    if (existsSync(loc)) {
-      return loc;
-    }
-  }
-  return null;
-}
-async function findPython() {
-  const candidates = ["python3", "python"];
-  for (const cmd of candidates) {
-    try {
-      execSync(`${cmd} --version`, { stdio: "pipe" });
-      return cmd;
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-async function checkSweepStatus() {
-  const pythonPath = await findPython();
-  if (!pythonPath) {
-    return {
-      installed: false,
-      model_downloaded: false,
-      error: "Python not found. Install Python 3.10+"
-    };
-  }
-  const scriptPath = findPythonScript();
-  if (!scriptPath) {
-    return {
-      installed: false,
-      model_downloaded: false,
-      python_path: pythonPath,
-      error: "Sweep addon not installed. Run: stackmemory sweep setup"
-    };
-  }
-  const homeDir = process.env.HOME || "";
-  const modelPath = join(
-    homeDir,
-    ".stackmemory",
-    "models",
-    "sweep",
-    "sweep-next-edit-1.5b.q8_0.v2.gguf"
-  );
-  const modelDownloaded = existsSync(modelPath);
-  return {
-    installed: true,
-    model_downloaded: modelDownloaded,
-    python_path: pythonPath,
-    model_path: modelDownloaded ? modelPath : void 0
-  };
-}
-async function runPrediction(filePath, pythonPath, scriptPath) {
-  if (!existsSync(filePath)) {
-    return {
-      success: false,
-      error: "file_not_found",
-      message: `File not found: ${filePath}`
-    };
-  }
-  const currentContent = readFileSync(filePath, "utf-8");
-  const input = {
-    file_path: filePath,
-    current_content: currentContent
-  };
-  return new Promise((resolve) => {
-    const proc = spawn(pythonPath, [scriptPath], {
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    proc.stdout.on("data", (data) => stdout += data);
-    proc.stderr.on("data", (data) => stderr += data);
-    proc.on("close", (code) => {
-      try {
-        if (stdout.trim()) {
-          const result = JSON.parse(stdout.trim());
-          resolve(result);
-        } else if (code !== 0) {
-          resolve({
-            success: false,
-            error: "process_error",
-            message: stderr || `Process exited with code ${code}`
-          });
-        } else {
-          resolve({
-            success: false,
-            error: "no_output",
-            message: "No output from prediction script"
-          });
-        }
-      } catch {
-        resolve({
-          success: false,
-          error: "parse_error",
-          message: `Failed to parse output: ${stdout}`
-        });
-      }
-    });
-    proc.on("error", (error) => {
-      resolve({
-        success: false,
-        error: "spawn_error",
-        message: error.message
-      });
-    });
-    proc.stdin.write(JSON.stringify(input));
-    proc.stdin.end();
-  });
-}
+import {
+  createServerManager,
+  createPredictionClient,
+  launchWrapper,
+  DEFAULT_SERVER_CONFIG
+} from "../../features/sweep/index.js";
+const HOME = process.env["HOME"] || "/tmp";
 function createSweepCommand() {
-  const cmd = new Command("sweep").description(
-    "Next-edit predictions using Sweep 1.5B model (optional addon)"
-  ).addHelpText(
+  const cmd = new Command("sweep").description("Manage Sweep Next-Edit prediction server").addHelpText(
     "after",
     `
 Examples:
-  stackmemory sweep setup              Install Python dependencies
-  stackmemory sweep setup --download   Also download the model (1.5GB)
-  stackmemory sweep status             Check addon status
-  stackmemory sweep predict src/app.ts Predict next edit for a file
-
-Requirements:
-  - Python 3.10+
-  - pip packages: huggingface_hub, llama-cpp-python
+  stackmemory sweep start       Start the Sweep server
+  stackmemory sweep stop        Stop the Sweep server
+  stackmemory sweep status      Check server status
+  stackmemory sweep predict     Run a prediction manually
+  stackmemory sweep hook        Install/check Claude Code hook
 
-The Sweep 1.5B model predicts what code changes you'll make next based on:
-  - Current file content
-  - Recent changes (diffs)
-  - Context from other files
-
-Model is downloaded from HuggingFace on first prediction (~1.5GB).
+The Sweep server uses the Sweep 1.5B model for next-edit predictions.
+Predictions are triggered after file edits via Claude Code hooks.
 `
   );
-  cmd.command("setup").description("Install Python dependencies for Sweep addon").option("--download", "Also download the model now").action(async (options) => {
-    const spinner = ora("Checking Python...").start();
-    const pythonPath = await findPython();
-    if (!pythonPath) {
-      spinner.fail(chalk.red("Python not found"));
-      console.log(chalk.gray("Please install Python 3.10+"));
+  cmd.command("start").description("Start the Sweep prediction server").option(
+    "--port <number>",
+    "Server port",
+    String(DEFAULT_SERVER_CONFIG.port)
+  ).option("--model <path>", "Path to GGUF model file").option(
+    "--context <size>",
+    "Context size",
+    String(DEFAULT_SERVER_CONFIG.contextSize)
+  ).option("--gpu-layers <n>", "Number of GPU layers (0 for CPU only)", "0").action(async (options) => {
+    const spinner = ora("Starting Sweep server...").start();
+    try {
+      const config = {
+        port: parseInt(options.port, 10),
+        contextSize: parseInt(options.context, 10),
+        gpuLayers: parseInt(options.gpuLayers, 10)
+      };
+      if (options.model) {
+        config.modelPath = options.model;
+      }
+      const manager = createServerManager(config);
+      const status = await manager.startServer();
+      spinner.succeed(chalk.green("Sweep server started"));
+      console.log(chalk.gray(`  PID: ${status.pid}`));
+      console.log(chalk.gray(`  Port: ${status.port}`));
+      console.log(chalk.gray(`  Model: ${status.modelPath}`));
+    } catch (error) {
+      spinner.fail(chalk.red("Failed to start Sweep server"));
+      console.error(chalk.red(error.message));
       process.exit(1);
     }
-    spinner.text = "Installing Python dependencies...";
+  });
+  cmd.command("stop").description("Stop the Sweep prediction server").action(async () => {
+    const spinner = ora("Stopping Sweep server...").start();
     try {
-      execSync(
-        `${pythonPath} -m pip install --quiet huggingface_hub llama-cpp-python`,
-        {
-          stdio: "pipe"
-        }
-      );
-      spinner.succeed(chalk.green("Python dependencies installed"));
-    } catch {
-      spinner.fail(chalk.red("Failed to install dependencies"));
-      console.log(
-        chalk.gray(
-          `Run: ${pythonPath} -m pip install huggingface_hub llama-cpp-python`
-        )
-      );
+      const manager = createServerManager();
+      await manager.stopServer();
+      spinner.succeed(chalk.green("Sweep server stopped"));
+    } catch (error) {
+      spinner.fail(chalk.red("Failed to stop Sweep server"));
+      console.error(chalk.red(error.message));
       process.exit(1);
     }
-    if (options.download) {
-      const downloadSpinner = ora("Downloading Sweep 1.5B model...").start();
-      downloadSpinner.text = "Downloading model from HuggingFace (~1.5GB)...";
-      try {
-        execSync(
-          `${pythonPath} -c "
-from huggingface_hub import hf_hub_download
-import os
-model_dir = os.path.expanduser('~/.stackmemory/models/sweep')
-os.makedirs(model_dir, exist_ok=True)
-hf_hub_download(
-    repo_id='sweepai/sweep-next-edit-1.5B',
-    filename='sweep-next-edit-1.5b.q8_0.v2.gguf',
-    repo_type='model',
-    local_dir=model_dir,
-    local_dir_use_symlinks=False
-)
-"`,
-          { stdio: "pipe", timeout: 6e5 }
-        );
-        downloadSpinner.succeed(chalk.green("Model downloaded"));
-      } catch {
-        downloadSpinner.fail(chalk.red("Model download failed"));
-        console.log(chalk.gray("Model will be downloaded on first use"));
+  });
+  cmd.command("status").description("Check Sweep server status").action(async () => {
+    try {
+      const manager = createServerManager();
+      const status = await manager.getStatus();
+      if (status.running) {
+        console.log(chalk.green("Sweep server is running"));
+        console.log(chalk.gray(`  PID: ${status.pid}`));
+        console.log(chalk.gray(`  Port: ${status.port}`));
+        console.log(chalk.gray(`  Host: ${status.host}`));
+        if (status.startedAt) {
+          const uptime = Math.floor((Date.now() - status.startedAt) / 1e3);
+          console.log(chalk.gray(`  Uptime: ${formatUptime(uptime)}`));
+        }
+        if (status.modelPath) {
+          console.log(chalk.gray(`  Model: ${status.modelPath}`));
+        }
+      } else {
+        console.log(chalk.yellow("Sweep server is not running"));
+        console.log(chalk.gray("  Start with: stackmemory sweep start"));
       }
-    } else {
-      console.log(
-        chalk.gray("\nModel will be downloaded on first prediction (~1.5GB)")
+      const defaultModelPath = join(
+        HOME,
+        ".stackmemory",
+        "models",
+        "sweep",
+        "sweep-next-edit-1.5b.q8_0.v2.gguf"
       );
-      console.log(chalk.gray("Or run: stackmemory sweep setup --download"));
-    }
-    console.log(chalk.bold("\nSetup complete!"));
-  });
-  cmd.command("status").description("Check Sweep addon status").action(async () => {
-    console.log(chalk.bold("\nSweep 1.5B Addon Status\n"));
-    const status = await checkSweepStatus();
-    if (status.error) {
-      console.log(chalk.red(`Error: ${status.error}`));
-      console.log("");
-    }
-    console.log(
-      `Python: ${status.python_path ? chalk.green(status.python_path) : chalk.red("Not found")}`
-    );
-    console.log(
-      `Addon installed: ${status.installed ? chalk.green("Yes") : chalk.yellow("No")}`
-    );
-    console.log(
-      `Model downloaded: ${status.model_downloaded ? chalk.green("Yes") : chalk.yellow("No (will download on first use)")}`
-    );
-    if (status.model_path) {
-      console.log(chalk.gray(`Model path: ${status.model_path}`));
-    }
-    if (!status.installed) {
-      console.log(chalk.bold("\nTo install:"));
-      console.log("  stackmemory sweep setup");
-    }
-  });
-  cmd.command("predict <file>").description("Predict next edit for a file").option("-o, --output <path>", "Write prediction to file instead of stdout").option("--json", "Output raw JSON result").action(async (file, options) => {
-    const status = await checkSweepStatus();
-    if (!status.installed) {
-      console.error(chalk.red("Sweep addon not installed"));
-      console.log(chalk.gray("Run: stackmemory sweep setup"));
-      process.exit(1);
-    }
-    const scriptPath = findPythonScript();
-    if (!scriptPath || !status.python_path) {
-      console.error(chalk.red("Could not find Sweep prediction script"));
-      process.exit(1);
-    }
-    const spinner = ora("Running prediction...").start();
-    if (!status.model_downloaded) {
-      spinner.text = "Downloading model (first time only, ~1.5GB)...";
-    }
-    const result = await runPrediction(file, status.python_path, scriptPath);
-    if (!result.success) {
-      spinner.fail(
-        chalk.red(`Prediction failed: ${result.message || result.error}`)
+      if (!existsSync(defaultModelPath)) {
+        console.log("");
+        console.log(chalk.yellow("Model not found at default location"));
+        console.log(
+          chalk.gray(
+            "  Download with:\n  huggingface-cli download sweepai/sweep-next-edit-1.5B \\\n    sweep-next-edit-1.5b.q8_0.v2.gguf \\\n    --local-dir ~/.stackmemory/models/sweep"
+          )
+        );
+      }
+    } catch (error) {
+      console.error(
+        chalk.red("Error checking status:"),
+        error.message
       );
       process.exit(1);
     }
-    spinner.succeed(chalk.green("Prediction complete"));
-    if (options.json) {
-      console.log(JSON.stringify(result, null, 2));
-      return;
-    }
-    console.log(chalk.bold("\nPredicted content:"));
-    console.log(chalk.gray("\u2500".repeat(50)));
-    console.log(result.predicted_content);
-    console.log(chalk.gray("\u2500".repeat(50)));
-    if (result.latency_ms) {
-      console.log(chalk.gray(`Latency: ${result.latency_ms}ms`));
-    }
-    if (result.tokens_generated) {
-      console.log(chalk.gray(`Tokens: ${result.tokens_generated}`));
-    }
-    if (options.output) {
-      const { writeFileSync: writeFileSync2 } = await import("fs");
-      writeFileSync2(options.output, result.predicted_content || "");
-      console.log(chalk.green(`
-Written to: ${options.output}`));
-    }
   });
-  const hookCmd = cmd.command("hook").description("Manage Claude Code integration hook");
-  hookCmd.command("install").description("Install Sweep prediction hook for Claude Code").action(async () => {
-    const spinner = ora("Installing Sweep hook...").start();
-    const homeDir = process.env.HOME || "";
-    const hookDir = join(homeDir, ".claude", "hooks");
-    const sweepDir = join(homeDir, ".stackmemory", "sweep");
-    const hooksJsonPath = join(homeDir, ".claude", "hooks.json");
+  cmd.command("predict").description("Run a prediction manually (for testing)").argument("<file>", "File to predict edits for").option(
+    "--port <number>",
+    "Server port",
+    String(DEFAULT_SERVER_CONFIG.port)
+  ).action(async (file, options) => {
+    const spinner = ora("Running prediction...").start();
     try {
-      mkdirSync(hookDir, { recursive: true });
-      mkdirSync(sweepDir, { recursive: true });
-      const hookSource = findHookSource();
-      if (!hookSource) {
-        spinner.fail(chalk.red("Hook template not found"));
-        console.log(
-          chalk.gray("Ensure stackmemory is installed from the repository")
-        );
+      const { readFileSync } = await import("fs");
+      const content = readFileSync(file, "utf-8");
+      const client = createPredictionClient({
+        port: parseInt(options.port, 10)
+      });
+      const healthy = await client.checkHealth();
+      if (!healthy) {
+        spinner.fail(chalk.red("Server not running"));
+        console.log(chalk.gray("Start with: stackmemory sweep start"));
         process.exit(1);
       }
-      const hookDest = join(hookDir, "post-edit-sweep.js");
-      copyFileSync(hookSource, hookDest);
-      chmodSync(hookDest, "755");
-      const pythonScriptSource = findPythonScript();
-      if (pythonScriptSource) {
-        const pythonDest = join(sweepDir, "sweep_predict.py");
-        copyFileSync(pythonScriptSource, pythonDest);
-      }
-      if (existsSync(hooksJsonPath)) {
-        const hooks = JSON.parse(readFileSync(hooksJsonPath, "utf-8"));
-        if (!hooks["post-tool-use"]) {
-          hooks["post-tool-use"] = hookDest;
-          writeFileSync(hooksJsonPath, JSON.stringify(hooks, null, 2));
-        } else if (!hooks["post-tool-use"].includes("sweep")) {
-          spinner.warn(chalk.yellow("post-tool-use hook already configured"));
-          console.log(chalk.gray(`Existing: ${hooks["post-tool-use"]}`));
-          console.log(chalk.gray(`Hook installed at: ${hookDest}`));
-          console.log(
-            chalk.gray("You may need to manually configure the hook chain")
-          );
-          return;
+      const result = await client.predict({
+        file_path: file,
+        current_content: content,
+        recent_diffs: []
+      });
+      spinner.stop();
+      if (result.success && result.predicted_content) {
+        console.log(chalk.green("Prediction complete"));
+        console.log(chalk.gray(`Latency: ${result.latency_ms}ms`));
+        console.log(chalk.gray(`Tokens: ${result.tokens_generated}`));
+        console.log("");
+        console.log(chalk.cyan("Predicted content:"));
+        console.log(result.predicted_content.slice(0, 500));
+        if (result.predicted_content.length > 500) {
+          console.log(chalk.gray("... (truncated)"));
         }
+      } else if (result.success) {
+        console.log(chalk.yellow("No changes predicted"));
       } else {
-        const hooks = { "post-tool-use": hookDest };
-        writeFileSync(hooksJsonPath, JSON.stringify(hooks, null, 2));
+        console.log(chalk.red("Prediction failed:"), result.message);
       }
-      spinner.succeed(chalk.green("Sweep hook installed"));
-      console.log(chalk.gray(`Hook: ${hookDest}`));
-      console.log(chalk.gray(`Config: ${hooksJsonPath}`));
-      console.log("");
-      console.log(chalk.bold("Usage:"));
-      console.log("  Hook runs automatically after Edit/Write operations");
-      console.log("  Predictions appear after 2+ edits in session");
-      console.log("  Disable: export SWEEP_ENABLED=false");
     } catch (error) {
-      spinner.fail(chalk.red("Installation failed"));
-      console.log(chalk.gray(error.message));
+      spinner.fail(chalk.red("Prediction failed"));
+      console.error(chalk.red(error.message));
       process.exit(1);
     }
   });
-  hookCmd.command("status").description("Check hook installation status").action(async () => {
-    const homeDir = process.env.HOME || "";
-    const hookPath = join(homeDir, ".claude", "hooks", "post-edit-sweep.js");
-    const hooksJsonPath = join(homeDir, ".claude", "hooks.json");
-    const statePath = join(homeDir, ".stackmemory", "sweep-state.json");
-    console.log(chalk.bold("\nSweep Hook Status\n"));
-    const hookInstalled = existsSync(hookPath);
-    console.log(
-      `Hook installed: ${hookInstalled ? chalk.green("Yes") : chalk.yellow("No")}`
+  cmd.command("hook").description("Check Claude Code hook status").action(async () => {
+    const hookPath = join(HOME, ".claude", "hooks", "post-edit-sweep.js");
+    const templatePath = join(
+      process.cwd(),
+      "templates",
+      "claude-hooks",
+      "post-edit-sweep.js"
     );
-    if (existsSync(hooksJsonPath)) {
-      const hooks = JSON.parse(readFileSync(hooksJsonPath, "utf-8"));
-      const configured = hooks["post-tool-use"] && hooks["post-tool-use"].includes("sweep");
-      console.log(
-        `Hook configured: ${configured ? chalk.green("Yes") : chalk.yellow("No")}`
-      );
+    console.log(chalk.cyan("Sweep Hook Status"));
+    console.log("");
+    if (existsSync(hookPath)) {
+      console.log(chalk.green("Hook installed:"), hookPath);
     } else {
-      console.log(`Hook configured: ${chalk.yellow("No hooks.json")}`);
+      console.log(chalk.yellow("Hook not installed"));
+      console.log(chalk.gray(`  Copy from: ${templatePath}`));
+      console.log(chalk.gray(`  To: ${hookPath}`));
     }
-    const enabled = process.env.SWEEP_ENABLED !== "false";
-    console.log(
-      `Enabled: ${enabled ? chalk.green("Yes") : chalk.yellow("Disabled (SWEEP_ENABLED=false)")}`
-    );
+    const settingsPath = join(HOME, ".claude", "settings.json");
+    if (existsSync(settingsPath)) {
+      try {
+        const { readFileSync } = await import("fs");
+        const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+        const hasHook = JSON.stringify(settings).includes("post-edit-sweep");
+        if (hasHook) {
+          console.log(chalk.green("Hook registered in settings.json"));
+        } else {
+          console.log(chalk.yellow("Hook not registered in settings.json"));
+          console.log(
+            chalk.gray(
+              '  Add to hooks.PostToolUse:\n  { "matcher": "Edit", "hooks": [{ "type": "command", "command": "node ~/.claude/hooks/post-edit-sweep.js" }] }'
+            )
+          );
+        }
+      } catch {
+        console.log(chalk.yellow("Could not read settings.json"));
+      }
+    } else {
+      console.log(chalk.yellow("settings.json not found"));
+    }
+    const statePath = join(HOME, ".stackmemory", "sweep-state.json");
     if (existsSync(statePath)) {
       try {
+        const { readFileSync } = await import("fs");
         const state = JSON.parse(readFileSync(statePath, "utf-8"));
         console.log(
           chalk.gray(
-            `
-Recent diffs tracked: ${state.recentDiffs?.length || 0}`
+            `  Recent diffs tracked: ${state.recentDiffs?.length || 0}`
           )
         );
         if (state.lastPrediction) {
-          const age = Date.now() - state.lastPrediction.timestamp;
-          const ageStr = age < 6e4 ? `${Math.round(age / 1e3)}s ago` : `${Math.round(age / 6e4)}m ago`;
-          console.log(chalk.gray(`Last prediction: ${ageStr}`));
+          const ago = Math.floor(
+            (Date.now() - state.lastPrediction.timestamp) / 1e3
+          );
+          console.log(
+            chalk.gray(`  Last prediction: ${formatUptime(ago)} ago`)
+          );
         }
       } catch {
       }
     }
-    if (!hookInstalled) {
-      console.log(chalk.bold("\nTo install: stackmemory sweep hook install"));
-    }
-  });
-  hookCmd.command("disable").description("Disable the Sweep hook").action(() => {
-    console.log(chalk.bold("\nTo disable Sweep predictions:\n"));
-    console.log("  Temporarily: export SWEEP_ENABLED=false");
-    console.log("  Permanently: Add to ~/.zshrc or ~/.bashrc");
-    console.log("");
-    console.log("Or remove the hook:");
-    console.log("  rm ~/.claude/hooks/post-edit-sweep.js");
-  });
-  hookCmd.command("clear").description("Clear hook state (recent diffs and predictions)").action(() => {
-    const homeDir = process.env.HOME || "";
-    const statePath = join(homeDir, ".stackmemory", "sweep-state.json");
-    if (existsSync(statePath)) {
-      writeFileSync(
-        statePath,
-        JSON.stringify(
-          {
-            recentDiffs: [],
-            lastPrediction: null,
-            pendingPrediction: null,
-            fileContents: {}
-          },
-          null,
-          2
-        )
-      );
-      console.log(chalk.green("Sweep state cleared"));
-    } else {
-      console.log(chalk.gray("No state file found"));
-    }
   });
-  cmd.action(async () => {
-    const status = await checkSweepStatus();
-    console.log(chalk.bold("\nSweep 1.5B Addon Status\n"));
-    console.log(
-      `Installed: ${status.installed ? chalk.green("Yes") : chalk.yellow("No")}`
-    );
-    console.log(
-      `Model ready: ${status.model_downloaded ? chalk.green("Yes") : chalk.yellow("No")}`
-    );
-    if (!status.installed) {
-      console.log(chalk.bold("\nRun: stackmemory sweep setup"));
-    } else {
-      console.log(chalk.bold("\nUsage: stackmemory sweep predict <file>"));
+  cmd.command("wrap").description("Launch Claude Code with Sweep prediction status bar").option("--claude-bin <path>", "Path to claude binary").allowUnknownOption(true).action(async (options, command) => {
+    try {
+      const claudeArgs = command.args || [];
+      await launchWrapper({
+        claudeBin: options.claudeBin,
+        claudeArgs
+      });
+    } catch (error) {
+      console.error(chalk.red(error.message));
+      process.exit(1);
     }
   });
   return cmd;
 }
-var sweep_default = createSweepCommand();
+function formatUptime(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+  const hours = Math.floor(seconds / 3600);
+  const mins = Math.floor(seconds % 3600 / 60);
+  return `${hours}h ${mins}m`;
+}
 export {
-  createSweepCommand,
-  sweep_default as default
+  createSweepCommand
 };
 //# sourceMappingURL=sweep.js.map