shellwise 0.2.7 → 0.2.10

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
 ```
 
@@ -110,9 +107,22 @@ 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
+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.7",
+  "version": "0.2.10",
   "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

@@ -25,25 +25,48 @@ typeset -ga __sw_suggestions=()
 typeset -g __sw_selected=0
 typeset -g __sw_fd=""
 typeset -g __sw_ready=0
+typeset -g __sw_port=0
+
+# ─── Daemon connection (self-healing) ──────────────────────
+# The daemon idle-exits after inactivity and the TCP port is
+# deterministic, so the shell must be able to reconnect on
+# demand — otherwise a long-idle pane loses suggest forever.
+
+# Read daemon port from PID file (line 2). No fork (\$(<file) is builtin).
+__sw_read_port() {
+  local pf="/tmp/shellwise-\${UID}.pid"
+  [[ -f "\$pf" ]] || return 1
+  local lines=("\${(@f)\$(<\$pf)}")
+  __sw_port=\${lines[2]:-0}
+  [[ \$__sw_port -gt 0 ]]
+}
+
+# Is the daemon process alive? No fork (kill -0 is a builtin).
+__sw_daemon_alive() {
+  local pf="/tmp/shellwise-\${UID}.pid"
+  [[ -f "\$pf" ]] || return 1
+  local lines=("\${(@f)\$(<\$pf)}")
+  kill -0 \${lines[1]:-0} 2>/dev/null
+}
+
+# (Re)establish the persistent TCP connection. No fork while typing.
+__sw_connect() {
+  __sw_ready=0
+  [[ -n "\$__sw_fd" ]] && { ztcp -c \$__sw_fd 2>/dev/null; __sw_fd="" }
+  [[ \$__sw_port -gt 0 ]] || __sw_read_port || return 1
+  ztcp 127.0.0.1 \$__sw_port 2>/dev/null || return 1
+  __sw_fd=\$REPLY
+  __sw_ready=1
+}
 
 # Load TCP module + connect at shell startup
 zmodload zsh/net/tcp 2>/dev/null && {
-  # Read daemon port from PID file
-  local __sw_pidfile="/tmp/shellwise-\${UID}.pid"
-  if [[ ! -f "\$__sw_pidfile" ]]; then
+  if [[ ! -f "/tmp/shellwise-\${UID}.pid" ]]; then
     # Start daemon in background (non-blocking)
     command ${bin} daemon start &>/dev/null &!
     sleep 0.3
   fi
-  if [[ -f "\$__sw_pidfile" ]]; then
-    local __sw_port=\${"\$(sed -n 2p "\$__sw_pidfile")":-0}
-    if [[ \$__sw_port -gt 0 ]]; then
-      ztcp 127.0.0.1 \$__sw_port 2>/dev/null && {
-        __sw_fd=\$REPLY
-        __sw_ready=1
-      }
-    fi
-  fi
+  __sw_connect
 }
 
 # ─── Persistent TCP query (no connect/disconnect overhead) ─
@@ -52,14 +75,19 @@ typeset -ga __sw_tcp_result=()
 
 __sw_tcp_query() {
   __sw_tcp_result=()
-  [[ \$__sw_ready -ne 1 ]] && return 1
 
-  # Send request
-  print -u \$__sw_fd "\$1" 2>/dev/null || {
-    # Connection broken — mark unavailable
-    __sw_ready=0
-    return 1
-  }
+  # Neutralize SIGPIPE: writing to a daemon that has idle-exited must return
+  # a recoverable error, never raise a signal that freezes the line editor.
+  setopt local_options local_traps
+  trap '' PIPE
+
+  # (Re)connect if needed — daemon may have idle-exited or restarted
+  [[ \$__sw_ready -ne 1 ]] && { __sw_connect || return 1 }
+
+  # Send request; one transparent reconnect+retry on a stale connection
+  if ! print -u \$__sw_fd "\$1" 2>/dev/null; then
+    __sw_connect && print -u \$__sw_fd "\$1" 2>/dev/null || { __sw_ready=0; return 1 }
+  fi
 
   # Read response lines until empty line
   local line
@@ -87,8 +115,11 @@ __sw_precmd() {
       duration=\${duration%%.*}
     fi
 
-    # Save via persistent TCP (instant) or fallback to background process
-    __sw_tcp_query "ADD\\t\$__SW_COMMAND\\t\$PWD\\t\$exit_code\\t\$duration\\t\$SW_SESSION_ID\\tzsh" || \\
+    # Save via persistent TCP (instant). On failure, restart a dead daemon
+    # (a fork between commands is fine) so the next keystroke can reconnect,
+    # and fall back to a direct write for this command.
+    if ! __sw_tcp_query "ADD\\t\$__SW_COMMAND\\t\$PWD\\t\$exit_code\\t\$duration\\t\$SW_SESSION_ID\\tzsh"; then
+      __sw_daemon_alive || command ${bin} daemon start &>/dev/null &!
       command ${bin} add \\
         --command "\$__SW_COMMAND" \\
         --cwd "\$PWD" \\
@@ -96,6 +127,15 @@ __sw_precmd() {
         --duration "\$duration" \\
         --session "\$SW_SESSION_ID" \\
         --shell "zsh" &!
+    fi
+
+    # 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/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/index.ts

@@ -9,6 +9,7 @@ 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";
 
@@ -225,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}`
+  );
+}