shellwise 0.1.0

package/README.md

@@ -0,0 +1,141 @@
+# shellwise
+
+Smart command history with inline auto-suggest and fuzzy search for your terminal.
+
+![License](https://img.shields.io/badge/license-MIT-blue)
+![Runtime](https://img.shields.io/badge/runtime-Bun-black)
+
+## Features
+
+- **Auto-save** — commands are recorded automatically after successful execution (exit code 0)
+- **Auto-suggest** — inline dropdown appears as you type, no `Ctrl+R` needed
+- **Fuzzy search** — `Ctrl+R` opens a full interactive search with real-time filtering
+- **Smart ranking** — frecency scoring (frequency x recency) for relevant results
+- **Common commands** — suggests popular commands (git, npm, docker, etc.) even with empty history
+- **Daemon mode** — persistent background process for sub-millisecond suggest latency (~1-3ms)
+- **Zero-fork** — uses `zsh/net/tcp` persistent connection, never spawns a process while typing
+
+## How it works
+
+```
+You type:  git s
+           ┌─────────────────────────────┐
+           │ › git status          (history)
+           │   git stash           (history)
+           │   git switch main     (history)
+           │   git stash pop       (common)
+           │   git stash list      (common)
+           └─────────────────────────────┘
+Tab/Shift+Tab to navigate, Enter to select, Esc to dismiss
+```
+
+## Install
+
+```bash
+bun install -g shellwise
+```
+
+That's it. Shell integration is auto-injected into your `~/.zshrc` or `~/.bashrc` on install. Restart your terminal to activate.
+
+### Manual setup
+
+If auto-setup didn't work, add to your shell config:
+
+```bash
+# ~/.zshrc
+eval "$(sw init zsh)"
+
+# ~/.bashrc
+eval "$(sw init bash)"
+```
+
+## Usage
+
+### Auto-suggest (while typing)
+
+Just start typing — suggestions appear automatically after 2+ characters.
+
+| Key | Action |
+|-----|--------|
+| `Tab` | Next suggestion |
+| `Shift+Tab` | Previous suggestion |
+| `Enter` | Accept selected suggestion |
+| `→` (Right arrow) | Accept suggestion inline |
+| `Esc` | Dismiss suggestions |
+
+### Interactive search
+
+Press `Ctrl+R` to open full fuzzy search:
+
+| Key | Action |
+|-----|--------|
+| Type | Filter results in real-time |
+| `↑` / `↓` | Navigate results |
+| `Enter` | Accept and paste to command line |
+| `Esc` | Cancel |
+
+### Commands
+
+```bash
+sw search [--query <text>]     # Interactive fuzzy search (Ctrl+R)
+sw suggest --query <text>      # Get top suggestion (used by shell hook)
+sw add --command <cmd>         # Save a command to history
+sw init <zsh|bash>             # Output shell integration script
+sw import [zsh|bash]           # Import existing shell history
+sw stats                       # Show usage statistics
+sw prune --days <n>            # Remove entries older than n days
+sw daemon start|stop|status    # Manage background daemon
+```
+
+### Import existing history
+
+```bash
+sw import zsh    # Import from ~/.zsh_history
+sw import bash   # Import from ~/.bash_history
+```
+
+## Architecture
+
+```
+┌──────────────┐     TCP (persistent)     ┌──────────────────┐
+│   Zsh/Bash   │◄────────────────────────►│   sw daemon      │
+│   (shell)    │     ~1-3ms round-trip    │   (Bun process)  │
+└──────────────┘                          └────────┬─────────┘
+                                                   │
+                                          ┌────────▼─────────┐
+                                          │   SQLite (WAL)   │
+                                          │   history.db     │
+                                          └──────────────────┘
+```
+
+- **Shell hooks** (`preexec`/`precmd`) capture commands after execution
+- **Persistent TCP connection** opened once at shell init, reused for all queries
+- **Prepared SQLite statements** pre-warmed at daemon start for instant queries
+- **Frecency scoring** = frequency × recency_weight — recent commands rank higher
+- **Auto-idle shutdown** — daemon stops after 30 min of inactivity
+
+## Data storage
+
+```
+~/.local/share/shellwise/history.db    # SQLite database
+~/.config/shellwise/                   # Config (future use)
+/tmp/shellwise-<uid>.sock              # Unix socket
+/tmp/shellwise-<uid>.pid               # Daemon PID + port
+```
+
+## Requirements
+
+- [Bun](https://bun.sh) >= 1.0.0
+- Zsh or Bash
+
+## Uninstall
+
+```bash
+bun remove -g shellwise
+```
+
+Shell integration is automatically removed from your config on uninstall.
+
+## License
+
+MIT

package/bin/sw.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+const { execFileSync } = require("child_process");
+const { resolve } = require("path");
+
+const entry = resolve(__dirname, "..", "src", "index.ts");
+
+try {
+  execFileSync("bun", [entry, ...process.argv.slice(2)], { stdio: "inherit" });
+} catch (err) {
+  if (err.code === "ENOENT") {
+    console.error("shellwise requires Bun runtime. Install it: https://bun.sh");
+    process.exit(1);
+  }
+  process.exit(err.status ?? 1);
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "shellwise",
+  "version": "0.1.0",
+  "description": "Smart command history with inline auto-suggest and fuzzy search for your terminal",
+  "type": "module",
+  "bin": {
+    "sw": "./bin/sw.js"
+  },
+  "files": [
+    "bin/sw.js",
+    "src/**/*.ts",
+    "scripts/*.sh"
+  ],
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "bun build src/index.ts --compile --outfile dist/sw",
+    "test": "bun test",
+    "postinstall": "bash scripts/setup.sh || true",
+    "preuninstall": "bash scripts/uninstall.sh || true"
+  },
+  "keywords": [
+    "shell",
+    "history",
+    "fuzzy-search",
+    "terminal",
+    "cli",
+    "autosuggest",
+    "zsh",
+    "bash",
+    "command-history",
+    "shellwise"
+  ],
+  "author": "Vu Duc Tuan",
+  "license": "MIT",
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kurovu146/shellwise"
+  },
+  "homepage": "https://github.com/kurovu146/shellwise#readme",
+  "devDependencies": {
+    "@types/bun": "latest"
+  }
+}

package/scripts/setup.sh

@@ -0,0 +1,92 @@
+#!/bin/bash
+# Post-install: auto-add shell integration
+
+set -e
+
+# Colors
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+DIM='\033[2m'
+BOLD='\033[1m'
+RESET='\033[0m'
+
+MARKER="# shellwise shell integration"
+
+# Detect sw binary path
+SW_BIN=""
+if command -v sw &>/dev/null; then
+  SW_BIN="sw"
+else
+  # Try common global bin paths
+  for p in "$HOME/.bun/bin/sw" "$HOME/.local/bin/sw" "$(npm prefix -g 2>/dev/null)/bin/sw"; do
+    if [[ -x "$p" ]]; then
+      SW_BIN="$p"
+      break
+    fi
+  done
+fi
+
+if [[ -z "$SW_BIN" ]]; then
+  echo -e "${YELLOW}[shellwise]${RESET} Could not find sw binary. Add manually:"
+  echo '  eval "$(sw init zsh)"   # add to ~/.zshrc'
+  exit 0
+fi
+
+inject_to_rc() {
+  local rc_file="$1"
+  local shell_name="$2"
+
+  # Skip if already injected
+  if grep -qF "$MARKER" "$rc_file" 2>/dev/null; then
+    echo -e "${DIM}[shellwise] Already configured in $rc_file${RESET}"
+    return
+  fi
+
+  # Backup
+  if [[ -f "$rc_file" ]]; then
+    cp "$rc_file" "${rc_file}.shellwise-backup"
+  fi
+
+  # Append integration
+  cat >> "$rc_file" << EOF
+
+$MARKER
+eval "\$($SW_BIN init $shell_name)"
+EOF
+
+  echo -e "${GREEN}${BOLD}[shellwise]${RESET}${GREEN} Added to $rc_file${RESET}"
+}
+
+# Detect user's shell and inject
+SHELL_NAME=$(basename "${SHELL:-/bin/zsh}")
+
+case "$SHELL_NAME" in
+  zsh)
+    inject_to_rc "$HOME/.zshrc" "zsh"
+    ;;
+  bash)
+    # Prefer .bashrc, fallback to .bash_profile on macOS
+    if [[ -f "$HOME/.bashrc" ]]; then
+      inject_to_rc "$HOME/.bashrc" "bash"
+    else
+      inject_to_rc "$HOME/.bash_profile" "bash"
+    fi
+    ;;
+  *)
+    echo -e "${YELLOW}[shellwise]${RESET} Unsupported shell: $SHELL_NAME"
+    echo '  Supported: zsh, bash'
+    echo '  Add manually: eval "$(sw init zsh)"'
+    exit 0
+    ;;
+esac
+
+# Start daemon for fast suggest
+if command -v sw &>/dev/null; then
+  sw daemon start &>/dev/null || true
+fi
+
+echo -e "${GREEN}${BOLD}[shellwise]${RESET} Restart your terminal or run: ${BOLD}source ~/.${SHELL_NAME}rc${RESET}"
+echo -e "${DIM}  Auto-save:    commands are recorded automatically"
+echo -e "  Auto-suggest: inline dropdown as you type (Tab/S-Tab to navigate)"
+echo -e "  Ctrl+R:       full interactive fuzzy search"
+echo -e "  Daemon:       auto-started for ~1-3ms suggest speed${RESET}"

package/scripts/uninstall.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+# Pre-uninstall: remove shell integration
+
+MARKER="# shellwise shell integration"
+
+remove_from_rc() {
+  local rc_file="$1"
+
+  [[ ! -f "$rc_file" ]] && return
+
+  if grep -qF "$MARKER" "$rc_file" 2>/dev/null; then
+    # Remove the marker line and the eval line after it
+    sed -i.shellwise-uninstall '
+      /^'"$MARKER"'$/,/^eval /d
+    ' "$rc_file" 2>/dev/null || {
+      # macOS sed requires different syntax
+      sed -i '.shellwise-uninstall' '
+        /^'"$MARKER"'$/,/^eval /d
+      ' "$rc_file"
+    }
+
+    # Remove empty trailing lines left behind
+    sed -i'' -e :a -e '/^\n*$/{$d;N;ba' -e '}' "$rc_file" 2>/dev/null
+
+    # Cleanup backup
+    rm -f "${rc_file}.shellwise-uninstall"
+
+    echo "[shellwise] Removed from $rc_file"
+  fi
+}
+
+remove_from_rc "$HOME/.zshrc"
+remove_from_rc "$HOME/.bashrc"
+remove_from_rc "$HOME/.bash_profile"
+
+echo "[shellwise] Uninstalled. Restart your terminal to complete."

package/src/cli/add.ts

@@ -0,0 +1,40 @@
+import { insertCommand } from "../db/queries";
+import { getHostname } from "../utils/platform";
+
+interface AddOptions {
+  command: string;
+  cwd?: string;
+  exitCode?: number;
+  duration?: number;
+  session?: string;
+  shell?: string;
+}
+
+const IGNORED_COMMANDS = new Set(["ls", "cd", "pwd", "exit", "clear", "sw"]);
+
+export function runAdd(opts: AddOptions): void {
+  const cmd = opts.command.trim();
+
+  // Skip empty, very short, or ignored commands
+  if (!cmd || cmd.length < 2) return;
+
+  // Skip commands starting with space (convention)
+  if (opts.command.startsWith(" ")) return;
+
+  // Only save successful commands (exit code 0)
+  if (opts.exitCode !== undefined && opts.exitCode !== 0) return;
+
+  // Skip ignored commands (only the base command, not arguments)
+  const baseCmd = cmd.split(/\s+/)[0];
+  if (IGNORED_COMMANDS.has(baseCmd)) return;
+
+  insertCommand({
+    command: cmd,
+    cwd: opts.cwd,
+    exit_code: opts.exitCode,
+    duration_ms: opts.duration,
+    hostname: getHostname(),
+    session_id: opts.session,
+    shell: opts.shell,
+  });
+}

package/src/cli/import.ts

@@ -0,0 +1,76 @@
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { insertCommand } from "../db/queries";
+import { getHostname } from "../utils/platform";
+
+export function runImport(shell?: string): void {
+  const home = homedir();
+  let imported = 0;
+
+  if (!shell || shell === "zsh") {
+    const zshPath = join(home, ".zsh_history");
+    if (existsSync(zshPath)) {
+      imported += importZshHistory(zshPath);
+    }
+  }
+
+  if (!shell || shell === "bash") {
+    const bashPath = join(home, ".bash_history");
+    if (existsSync(bashPath)) {
+      imported += importBashHistory(bashPath);
+    }
+  }
+
+  console.log(`Imported ${imported} commands.`);
+}
+
+function importZshHistory(path: string): number {
+  const content = readFileSync(path, "utf-8");
+  const lines = content.split("\n");
+  let count = 0;
+  const hostname = getHostname();
+
+  for (const line of lines) {
+    // zsh extended format: : timestamp:0;command
+    const extMatch = line.match(/^: (\d+):\d+;(.+)$/);
+    if (extMatch) {
+      const cmd = extMatch[2].trim();
+      if (cmd && cmd.length >= 2) {
+        insertCommand({
+          command: cmd,
+          hostname,
+          shell: "zsh",
+        });
+        count++;
+      }
+      continue;
+    }
+
+    // Plain format
+    const cmd = line.trim();
+    if (cmd && cmd.length >= 2 && !cmd.startsWith("#")) {
+      insertCommand({ command: cmd, hostname, shell: "zsh" });
+      count++;
+    }
+  }
+
+  return count;
+}
+
+function importBashHistory(path: string): number {
+  const content = readFileSync(path, "utf-8");
+  const lines = content.split("\n");
+  let count = 0;
+  const hostname = getHostname();
+
+  for (const line of lines) {
+    const cmd = line.trim();
+    if (cmd && cmd.length >= 2 && !cmd.startsWith("#")) {
+      insertCommand({ command: cmd, hostname, shell: "bash" });
+      count++;
+    }
+  }
+
+  return count;
+}