shellwise 0.2.6 → 0.2.9

package/README.md

@@ -60,14 +60,11 @@ eval "$(shellwise init bash)"
 
 ## Update
 
+`shellwise version` and `shellwise stats` will notify you when a new version is available.
+
 ```bash
-# Homebrew
 brew upgrade shellwise
-
-# Bun
 bun install -g shellwise@latest
-
-# npm
 npm install -g shellwise@latest
 ```
 
@@ -103,14 +100,29 @@ Both `shellwise` and `sw` work as the command name:
 ```bash
 shellwise search [--query <text>]     # Interactive fuzzy search (Ctrl+R)
 shellwise suggest --query <text>      # Get top suggestion (used by shell hook)
-shellwise add --command <cmd>         # Save a command to history
+shellwise add <cmd>                   # Save a command to history
+shellwise delete [query]              # Interactive search & delete a command
 shellwise init <zsh|bash>             # Output shell integration script
 shellwise import [zsh|bash]           # Import existing shell history
 shellwise stats                       # Show usage statistics
 shellwise prune --days <n>            # Remove entries older than n days
 shellwise daemon start|stop|status    # Manage background daemon
+shellwise version                    # Show current version
 ```
 
+### Delete a command
+
+Opens an interactive picker to search and delete a command from history:
+
+```bash
+shellwise delete          # Browse all commands, pick one to delete
+shellwise delete git      # Pre-filter with "git", pick one to delete
+```
+
+1. Run the command and press `Enter` to open the picker
+2. Type to filter results
+3. `Tab` / `↑↓` to navigate, `Enter` to confirm deletion, `Esc` to cancel
+
 ### Import existing history
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shellwise",
-  "version": "0.2.6",
+  "version": "0.2.9",
   "description": "Smart command history with inline auto-suggest and fuzzy search for your terminal",
   "type": "module",
   "bin": {

package/src/cli/add.ts

@@ -22,6 +22,10 @@ export function runAdd(opts: AddOptions): void {
   // Only save successful commands (exit code 0)
   if (opts.exitCode !== undefined && opts.exitCode !== 0) return;
 
+  // Skip shellwise's own commands
+  const baseCmd = cmd.split(/\s+/)[0];
+  if (baseCmd === "shellwise" || baseCmd === "sw") return;
+
   insertCommand({
     command: cmd,
     cwd: opts.cwd,

package/src/cli/init.ts

@@ -97,6 +97,14 @@ __sw_precmd() {
         --session "\$SW_SESSION_ID" \\
         --shell "zsh" &!
 
+    # Show update notice if available
+    local __sw_line
+    for __sw_line in "\${__sw_tcp_result[@]}"; do
+      if [[ "\$__sw_line" == UPDATE$'\\t'* ]]; then
+        print -P "%F{yellow}\${__sw_line#UPDATE	}%f"
+      fi
+    done
+
     unset __SW_COMMAND __SW_START_TIME
   fi
 }

package/src/cli/search.ts

@@ -25,7 +25,7 @@ interface SearchState {
   renderedLines: number;
 }
 
-export function runSearch(initialQuery: string = ""): void {
+export function pickCommand(initialQuery: string = ""): string | null {
   const cwd = process.env.PWD || process.cwd();
 
   const state: SearchState = {
@@ -78,22 +78,18 @@ export function runSearch(initialQuery: string = ""): void {
 
       if (key.type === "special" && key.key === "escape") {
         cleanup();
-        return;
+        return null;
       }
 
       if (key.type === "ctrl" && key.char === "c") {
         cleanup();
-        return;
+        return null;
       }
 
       if (key.type === "special" && key.key === "enter") {
         const selected = state.results[state.selectedIndex];
         cleanup();
-        if (selected) {
-          // Output to stdout (fd 1) for shell to capture
-          writeSync(1, selected.command);
-        }
-        return;
+        return selected?.command ?? null;
       }
 
       let needsSearch = false;
@@ -197,6 +193,13 @@ export function runSearch(initialQuery: string = ""): void {
   }
 }
 
+export function runSearch(initialQuery: string = ""): void {
+  const selected = pickCommand(initialQuery);
+  if (selected) {
+    writeSync(1, selected);
+  }
+}
+
 function getVisibleCount(): number {
   const { rows } = getTerminalSize();
   return Math.min(Math.max(rows - 4, 3), 15); // 3 minimum, 15 max

package/src/daemon/server.ts

@@ -2,6 +2,7 @@ import { getDb, closeDb } from "../db/connection";
 import { insertCommand } from "../db/queries";
 import { getHostname } from "../utils/platform";
 import { getCommonSuggestions } from "../data/common-commands";
+import { checkForUpdate, getUpdateNotice } from "../utils/update-check";
 import { parseRequest, getSocketPath, getPidPath, getDaemonPort } from "./protocol";
 import { unlinkSync, writeFileSync, existsSync } from "fs";
 import type { Socket } from "bun";
@@ -10,6 +11,7 @@ const IDLE_TIMEOUT = 30 * 60_000; // 30 min
 let idleTimer: ReturnType<typeof setTimeout> | null = null;
 let server: ReturnType<typeof Bun.listen> | null = null;
 let tcpServer: ReturnType<typeof Bun.listen> | null = null;
+let updateNotified = false;
 
 // Pre-warm DB + prepared statements on start
 let suggestPrefix: ReturnType<ReturnType<typeof getDb>["prepare"]>;
@@ -57,10 +59,14 @@ function handleRequest(raw: string): string {
       // Escape LIKE wildcards in user input
       const escapedQuery = req.query.replace(/[%_\\]/g, "\\$&");
 
-      // History: prefix matches
+      // History: prefix matches (exact match first)
       const prefixes = suggestPrefix.all(escapedQuery, historyLimit) as { command: string }[];
       for (const r of prefixes) {
-        if (r.command !== req.query) historyResults.push(r.command);
+        if (r.command === req.query) {
+          historyResults.unshift(r.command);
+        } else {
+          historyResults.push(r.command);
+        }
       }
 
       // History: contains matches (fill remaining)
@@ -71,7 +77,7 @@ function handleRequest(raw: string): string {
           command: string;
         }[];
         for (const r of contains) {
-          if (!resultSet.has(r.command) && r.command !== req.query) {
+          if (!resultSet.has(r.command)) {
             historyResults.push(r.command);
             if (historyResults.length >= historyLimit) break;
           }
@@ -81,7 +87,7 @@ function handleRequest(raw: string): string {
       // Common commands: fill with suggestions not already in history
       const seen = new Set(historyResults);
       const commonResults = getCommonSuggestions(req.query, 10)
-        .filter((cmd) => !seen.has(cmd) && cmd !== req.query)
+        .filter((cmd) => !seen.has(cmd))
         .slice(0, 5);
 
       // Merge: history first, then common
@@ -93,7 +99,9 @@ function handleRequest(raw: string): string {
     case "ADD": {
       const cmd = req.command.trim();
       if (!cmd || cmd.length < 2 || cmd.startsWith(" ")) return "OK\n\n";
-      if (req.exitCode !== 0) return "OK\n\n"; // Only save successful commands
+      if (req.exitCode !== 0) return "OK\n\n";
+      const baseCmd = cmd.split(/\s+/)[0];
+      if (baseCmd === "shellwise" || baseCmd === "sw") return "OK\n\n";
       insertCommand({
         command: cmd,
         cwd: req.cwd || undefined,
@@ -103,6 +111,22 @@ function handleRequest(raw: string): string {
         session_id: req.session || undefined,
         shell: req.shell || undefined,
       });
+
+      // Check update notice from cache (sync, fast, once per daemon session)
+      const pkg = require("../../package.json");
+      if (!updateNotified) {
+        const notice = getUpdateNotice(pkg.version);
+        if (notice) {
+          updateNotified = true;
+          // Refresh cache in background
+          checkForUpdate(pkg.version, true).catch(() => {});
+          return `OK\nUPDATE\t${notice}\n\n`;
+        }
+      }
+
+      // Refresh cache in background for next time
+      checkForUpdate(pkg.version, true).catch(() => {});
+
       return "OK\n\n";
     }
 

package/src/db/queries.ts

@@ -166,6 +166,16 @@ export function pruneOlderThan(days: number): number {
   return result.changes;
 }
 
+export function deleteCommand(command: string): boolean {
+  const db = getDb();
+  const hash = hashCommand(command);
+
+  const result = db.run("DELETE FROM commands WHERE command_hash = ?", [hash]);
+  db.run("DELETE FROM command_stats WHERE command_hash = ?", [hash]);
+
+  return result.changes > 0;
+}
+
 export function getExistingHashes(): Set<string> {
   const db = getDb();
   const rows = db

package/src/index.ts

@@ -1,13 +1,15 @@
 #!/usr/bin/env bun
 
 import { runAdd } from "./cli/add";
-import { runSearch } from "./cli/search";
+import { runSearch, pickCommand } from "./cli/search";
 import { runSuggest } from "./cli/suggest";
 import { runInit } from "./cli/init";
 import { runImport } from "./cli/import";
 import { runStats } from "./cli/stats";
 import { runPrune } from "./cli/prune";
+import { deleteCommand } from "./db/queries";
 import { closeDb } from "./db/connection";
+import { checkForUpdate } from "./utils/update-check";
 import { startServer, isDaemonRunning, getDaemonInfo } from "./daemon/server";
 import { daemonRequest } from "./daemon/client";
 
@@ -34,12 +36,14 @@ Usage: shellwise <command> [options]  (or: sw <command>)
 Commands:
   search [--query <text>]     Interactive fuzzy search (Ctrl+R)
   suggest --query <text>      Get top suggestion (used by shell hook)
-  add --command <cmd>         Save a command to history
+  add <cmd>                   Save a command to history
+  delete <cmd>                Delete a command from history
   init <zsh|bash>             Output shell integration script
   import [zsh|bash]           Import existing shell history
   stats                       Show usage statistics
   prune --days <n>            Remove entries older than n days
   daemon start|stop|status    Manage background daemon (faster suggest)
+  version                     Show current version
 
 Setup:
   Add to ~/.zshrc:   eval "$(shellwise init zsh)"
@@ -79,20 +83,21 @@ async function main(): Promise<void> {
 
       case "add": {
         const flags = parseFlags(args.slice(1));
-        if (!flags.command) {
-          console.error("Usage: shellwise add --command <cmd>");
+        const addCmd = flags.command || args.slice(1).filter(a => !a.startsWith("--")).join(" ");
+        if (!addCmd) {
+          console.error("Usage: shellwise add <cmd>");
           process.exit(1);
         }
 
         // Try daemon first
         // Strip tabs from command to avoid breaking protocol delimiter
-        const safeCommand = flags.command.replace(/\t/g, " ");
+        const safeCommand = addCmd.replace(/\t/g, " ");
         const addMsg = `ADD\t${safeCommand}\t${flags.cwd || ""}\t${flags["exit-code"] || "0"}\t${flags.duration || "0"}\t${flags.session || ""}\t${flags.shell || ""}\n`;
         const addResult = await daemonRequest(addMsg);
         if (!addResult) {
           // Fallback: direct
           runAdd({
-            command: flags.command,
+            command: addCmd,
             cwd: flags.cwd,
             exitCode: flags["exit-code"] ? parseInt(flags["exit-code"]) : undefined,
             duration: flags.duration ? parseInt(flags.duration) : undefined,
@@ -185,6 +190,28 @@ async function main(): Promise<void> {
         break;
       }
 
+      case "delete": {
+        const delQuery = args.slice(1).join(" ");
+        const delCmd = pickCommand(delQuery);
+        if (delCmd) {
+          const deleted = deleteCommand(delCmd);
+          if (deleted) {
+            console.log(`Deleted: ${delCmd}`);
+          } else {
+            console.log("Command not found in history.");
+          }
+        }
+        break;
+      }
+
+      case "version":
+      case "--version":
+      case "-v": {
+        const pkg = require("../package.json");
+        console.log(pkg.version);
+        break;
+      }
+
       case "help":
       case "--help":
       case "-h":
@@ -199,6 +226,13 @@ async function main(): Promise<void> {
     }
   } finally {
     if (command !== "daemon") closeDb();
+
+    // Check for updates on interactive commands (cached, max once per day)
+    const silentCommands = new Set(["suggest", "add", "search", "init", "daemon", "_run"]);
+    if (command && !silentCommands.has(command)) {
+      const pkg = require("../package.json");
+      await checkForUpdate(pkg.version);
+    }
   }
 }
 

package/src/search/index.ts

@@ -55,5 +55,5 @@ export function search(input: SearchInput): ScoredResult[] {
     cwdCommands = new Set(rows.map((r) => r.command_hash));
   }
 
-  return rankResults(matches, dbResults, input.cwd, cwdCommands).slice(0, limit);
+  return rankResults(matches, dbResults, input.query, input.cwd, cwdCommands).slice(0, limit);
 }

package/src/search/scorer.ts

@@ -27,6 +27,7 @@ const DEFAULT_WEIGHTS: ScoreWeights = {
 export function rankResults(
   matches: FuzzyMatch[],
   stats: CommandStats[],
+  query: string,
   currentCwd?: string,
   cwdCommands?: Set<string>,
   weights: ScoreWeights = DEFAULT_WEIGHTS
@@ -65,6 +66,11 @@ export function rankResults(
     });
   }
 
-  results.sort((a, b) => b.finalScore - a.finalScore);
+  results.sort((a, b) => {
+    const aExact = a.command.toLowerCase() === query ? 1 : 0;
+    const bExact = b.command.toLowerCase() === query ? 1 : 0;
+    if (aExact !== bExact) return bExact - aExact;
+    return b.finalScore - a.finalScore;
+  });
   return results;
 }

package/src/tui/input.ts

@@ -23,13 +23,17 @@ export type SpecialKey =
 export function parseKeypress(data: Buffer): KeyEvent {
   const str = data.toString("utf-8");
 
+  // Backspace (127 = DEL, 8 = BS)
+  if (data.length === 1 && (data[0] === 127 || data[0] === 8)) {
+    return { type: "special", key: "backspace" };
+  }
+
   // Ctrl combinations
   if (data.length === 1 && data[0] < 32) {
     const char = data[0];
     if (char === 13) return { type: "special", key: "enter" };
     if (char === 9) return { type: "special", key: "tab" };
     if (char === 27) return { type: "special", key: "escape" };
-    if (char === 127) return { type: "special", key: "backspace" };
     // Ctrl+A = 1, Ctrl+B = 2, etc.
     return { type: "ctrl", char: String.fromCharCode(char + 96) };
   }

package/src/utils/update-check.ts

@@ -0,0 +1,87 @@
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { getDataDir } from "./paths";
+import { color } from "../tui/theme";
+
+const CHECK_INTERVAL = 24 * 3600_000; // 1 day
+
+interface CachedCheck {
+  latestVersion: string;
+  checkedAt: number;
+}
+
+function getCachePath(): string {
+  return join(getDataDir(), "update-check.json");
+}
+
+function readCache(): CachedCheck | null {
+  const path = getCachePath();
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(data: CachedCheck): void {
+  try {
+    writeFileSync(getCachePath(), JSON.stringify(data));
+  } catch {}
+}
+
+function compareVersions(current: string, latest: string): number {
+  const a = current.split(".").map(Number);
+  const b = latest.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((a[i] ?? 0) < (b[i] ?? 0)) return -1;
+    if ((a[i] ?? 0) > (b[i] ?? 0)) return 1;
+  }
+  return 0;
+}
+
+export async function checkForUpdate(
+  currentVersion: string,
+  silent: boolean = false
+): Promise<void> {
+  const cache = readCache();
+  const now = Date.now();
+
+  // Cache hit — skip network, only notify if not silent
+  if (cache && now - cache.checkedAt < CHECK_INTERVAL) {
+    if (!silent && compareVersions(currentVersion, cache.latestVersion) < 0) {
+      printUpdateNotice(currentVersion, cache.latestVersion);
+    }
+    return;
+  }
+
+  // Cache miss — fetch in background, don't block
+  try {
+    const res = await fetch("https://registry.npmjs.org/shellwise/latest", {
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!res.ok) return;
+    const data = (await res.json()) as { version: string };
+    writeCache({ latestVersion: data.version, checkedAt: now });
+
+    if (!silent && compareVersions(currentVersion, data.version) < 0) {
+      printUpdateNotice(currentVersion, data.version);
+    }
+  } catch {}
+}
+
+export function getUpdateNotice(currentVersion: string): string | null {
+  const cache = readCache();
+  if (!cache) return null;
+  if (compareVersions(currentVersion, cache.latestVersion) < 0) {
+    return `Update available: ${currentVersion} → ${cache.latestVersion}. Run: brew upgrade shellwise | bun install -g shellwise@latest | npm install -g shellwise@latest`;
+  }
+  return null;
+}
+
+function printUpdateNotice(current: string, latest: string): void {
+  console.log(
+    `\n${color.yellow}Update available: ${current} → ${latest}${color.reset}` +
+      `\n${color.dim}Run: brew upgrade shellwise | bun install -g shellwise@latest | npm install -g shellwise@latest${color.reset}`
+  );
+}