shellwise 0.1.0

package/src/cli/init.ts

@@ -0,0 +1,325 @@
+export function runInit(shell: string, binaryPath: string): void {
+  switch (shell) {
+    case "zsh":
+      process.stdout.write(generateZshScript(binaryPath));
+      break;
+    case "bash":
+      process.stdout.write(generateBashScript(binaryPath));
+      break;
+    default:
+      console.error(`Unsupported shell: ${shell}. Supported: zsh, bash`);
+      process.exit(1);
+  }
+}
+
+function generateZshScript(bin: string): string {
+  return `
+# --- shellwise shell integration ---
+
+# Session tracking
+export SW_SESSION_ID="\$(command uuidgen 2>/dev/null || echo "\$\$-\$RANDOM")"
+
+# State
+typeset -g __sw_prev_buffer=""
+typeset -ga __sw_suggestions=()
+typeset -g __sw_selected=0
+typeset -g __sw_fd=""
+typeset -g __sw_ready=0
+
+# 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
+    # 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
+}
+
+# ─── Persistent TCP query (no connect/disconnect overhead) ─
+
+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
+  }
+
+  # Read response lines until empty line
+  local line
+  while IFS= read -r -t 0.1 -u \$__sw_fd line 2>/dev/null; do
+    [[ -z "\$line" ]] && break
+    __sw_tcp_result+=("\$line")
+  done
+
+  [[ \${#__sw_tcp_result} -gt 0 ]]
+}
+
+# ─── Command Capture (auto-save) ───────────────────────────
+
+__sw_preexec() {
+  export __SW_START_TIME=\$EPOCHREALTIME
+  export __SW_COMMAND="\$1"
+}
+
+__sw_precmd() {
+  local exit_code=\$?
+  if [[ -n "\$__SW_COMMAND" ]]; then
+    local duration=0
+    if [[ -n "\$__SW_START_TIME" ]]; then
+      duration=\$(( (EPOCHREALTIME - __SW_START_TIME) * 1000 ))
+      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" || \\
+      command ${bin} add \\
+        --command "\$__SW_COMMAND" \\
+        --cwd "\$PWD" \\
+        --exit-code "\$exit_code" \\
+        --duration "\$duration" \\
+        --session "\$SW_SESSION_ID" \\
+        --shell "zsh" &!
+
+    unset __SW_COMMAND __SW_START_TIME
+  fi
+}
+
+# ─── Render dropdown ───────────────────────────────────────
+
+__sw_render() {
+  POSTDISPLAY=""
+  region_highlight=()
+
+  [[ \${#__sw_suggestions} -eq 0 ]] && return
+
+  local buf_len=\${#BUFFER}
+  local offset=\$buf_len
+
+  local i
+  for (( i=1; i<=\${#__sw_suggestions}; i++ )); do
+    local item="\${__sw_suggestions[\$i]}"
+    local marker="  "
+    if [[ \$(( i - 1 )) -eq \$__sw_selected ]]; then
+      marker="› "
+    fi
+    local line=\$'\\n'"  \${marker}\${item}"
+    local start=\$offset
+    POSTDISPLAY+="\$line"
+    offset=\$(( offset + \${#line} ))
+
+    if [[ \$(( i - 1 )) -eq \$__sw_selected ]]; then
+      region_highlight+=("\$start \$offset fg=cyan,bold")
+    else
+      region_highlight+=("\$start \$offset fg=245")
+    fi
+  done
+}
+
+# ─── Auto-suggest (zero-fork, never blocks typing) ───────
+
+__sw_suggest() {
+  [[ "\$BUFFER" == "\$__sw_prev_buffer" ]] && return
+  __sw_prev_buffer="\$BUFFER"
+  __sw_selected=0
+  __sw_suggestions=()
+  POSTDISPLAY=""
+  region_highlight=()
+
+  [[ \${#BUFFER} -lt 2 ]] && return
+
+  # TCP query only — no fallback, never spawn process during typing
+  __sw_tcp_query "SUGGEST\\t\$BUFFER\\t5" || return
+
+  __sw_suggestions=("\${__sw_tcp_result[@]}")
+  __sw_render
+}
+
+# ─── Widget wrappers (trigger suggest on keystroke) ────────
+
+__sw_self_insert() {
+  zle .self-insert
+  __sw_suggest
+}
+
+__sw_backward_delete_char() {
+  zle .backward-delete-char
+  __sw_suggest
+}
+
+__sw_backward_kill_word() {
+  zle .backward-kill-word
+  __sw_suggest
+}
+
+# ─── Tab: next result ──────────────────────────────────────
+
+__sw_next() {
+  if [[ \${#__sw_suggestions} -gt 0 ]]; then
+    __sw_selected=\$(( (__sw_selected + 1) % \${#__sw_suggestions} ))
+    __sw_render
+  else
+    zle expand-or-complete
+  fi
+}
+
+# ─── Shift+Tab: previous result ────────────────────────────
+
+__sw_prev() {
+  if [[ \${#__sw_suggestions} -gt 0 ]]; then
+    __sw_selected=\$(( (__sw_selected - 1 + \${#__sw_suggestions}) % \${#__sw_suggestions} ))
+    __sw_render
+  else
+    zle .reverse-menu-complete
+  fi
+}
+
+# ─── Enter: accept selected or execute ─────────────────────
+
+__sw_accept_line() {
+  if [[ \${#__sw_suggestions} -gt 0 ]]; then
+    BUFFER="\${__sw_suggestions[\$(( __sw_selected + 1 ))]}"
+    CURSOR=\${#BUFFER}
+    POSTDISPLAY=""
+    region_highlight=()
+    __sw_suggestions=()
+    __sw_prev_buffer="\$BUFFER"
+  else
+    zle .accept-line
+  fi
+}
+
+# ─── Escape: clear suggestions ─────────────────────────────
+
+__sw_dismiss() {
+  if [[ \${#__sw_suggestions} -gt 0 ]]; then
+    POSTDISPLAY=""
+    region_highlight=()
+    __sw_suggestions=()
+    __sw_prev_buffer="\$BUFFER"
+  else
+    zle .send-break
+  fi
+}
+
+# ─── Right arrow: accept top suggestion inline ─────────────
+
+__sw_forward_char() {
+  if [[ \${#__sw_suggestions} -gt 0 && \$CURSOR -eq \${#BUFFER} ]]; then
+    BUFFER="\${__sw_suggestions[\$(( __sw_selected + 1 ))]}"
+    CURSOR=\${#BUFFER}
+    POSTDISPLAY=""
+    region_highlight=()
+    __sw_suggestions=()
+    __sw_prev_buffer="\$BUFFER"
+  else
+    zle .forward-char
+  fi
+}
+
+# ─── Ctrl+R: full interactive search ───────────────────────
+
+__sw_search_widget() {
+  POSTDISPLAY=""
+  region_highlight=()
+  __sw_suggestions=()
+  local selected
+  selected="\$(command ${bin} search --query "\$LBUFFER" </dev/tty 2>/dev/tty)"
+  local ret=\$?
+  if [[ \$ret -eq 0 && -n "\$selected" ]]; then
+    BUFFER="\$selected"
+    CURSOR=\${#BUFFER}
+  fi
+  __sw_prev_buffer="\$BUFFER"
+  zle reset-prompt
+}
+
+# ─── Register widgets & bindings ───────────────────────────
+
+zle -N self-insert __sw_self_insert
+zle -N backward-delete-char __sw_backward_delete_char
+zle -N backward-kill-word __sw_backward_kill_word
+zle -N __sw_next
+zle -N __sw_prev
+zle -N __sw_accept_line
+zle -N __sw_dismiss
+zle -N __sw_forward_char
+zle -N __sw_search_widget
+
+autoload -Uz add-zsh-hook
+add-zsh-hook preexec __sw_preexec
+add-zsh-hook precmd __sw_precmd
+
+bindkey '^R' __sw_search_widget
+bindkey '\\t' __sw_next
+bindkey '^[[Z' __sw_prev
+bindkey '^M' __sw_accept_line
+bindkey '^[' __sw_dismiss
+bindkey '^[[C' __sw_forward_char
+bindkey '^[OC' __sw_forward_char
+`;
+}
+
+function generateBashScript(bin: string): string {
+  return `
+# --- shellwise shell integration ---
+
+export SW_SESSION_ID="\$(command uuidgen 2>/dev/null || echo "\$\$-\$RANDOM")"
+
+# ─── Command Capture ───────────────────────────────────────
+
+__sw_preexec() {
+  export __SW_START_TIME=\$SECONDS
+  export __SW_COMMAND="\$(HISTTIMEFORMAT= history 1 | sed 's/^[ ]*[0-9]*[ ]*//')"
+}
+
+__sw_precmd() {
+  local exit_code=\$?
+  if [[ -n "\$__SW_COMMAND" ]]; then
+    local duration=\$(( (SECONDS - __SW_START_TIME) * 1000 ))
+
+    command ${bin} add \\
+      --command "\$__SW_COMMAND" \\
+      --cwd "\$PWD" \\
+      --exit-code "\$exit_code" \\
+      --duration "\$duration" \\
+      --session "\$SW_SESSION_ID" \\
+      --shell "bash" &
+
+    unset __SW_COMMAND __SW_START_TIME
+  fi
+}
+
+PROMPT_COMMAND="__sw_precmd;\${PROMPT_COMMAND}"
+trap '__sw_preexec' DEBUG
+
+# ─── Ctrl+R: interactive search ────────────────────────────
+
+__sw_search() {
+  local selected
+  selected="\$(command ${bin} search --query "\$READLINE_LINE" </dev/tty 2>/dev/tty)"
+  if [[ -n "\$selected" ]]; then
+    READLINE_LINE="\$selected"
+    READLINE_POINT=\${#READLINE_LINE}
+  fi
+}
+
+bind -x '"\\C-r": __sw_search'
+`;
+}

package/src/cli/prune.ts

@@ -0,0 +1,6 @@
+import { pruneOlderThan } from "../db/queries";
+
+export function runPrune(days: number): void {
+  const deleted = pruneOlderThan(days);
+  console.log(`Pruned ${deleted} entries older than ${days} days.`);
+}

package/src/cli/search.ts

@@ -0,0 +1,291 @@
+import { search, type ScoredResult } from "../search";
+import { enableRawMode, disableRawMode, parseKeypress } from "../tui/input";
+import {
+  write,
+  clearLine,
+  moveCursorUp,
+  moveCursorToColumn,
+  hideCursor,
+  showCursor,
+  getTerminalSize,
+  clearDown,
+} from "../tui/renderer";
+import { renderSearchBox, getSearchBoxCursorCol } from "../tui/components/search-box";
+import { renderResultList } from "../tui/components/result-list";
+import { renderStatusBar } from "../tui/components/status-bar";
+
+interface SearchState {
+  query: string;
+  cursorPos: number;
+  results: ScoredResult[];
+  selectedIndex: number;
+  scrollOffset: number;
+  renderedLines: number;
+}
+
+export async function runSearch(initialQuery: string = ""): Promise<void> {
+  const cwd = process.env.PWD || process.cwd();
+
+  const state: SearchState = {
+    query: initialQuery,
+    cursorPos: initialQuery.length,
+    results: [],
+    selectedIndex: 0,
+    scrollOffset: 0,
+    renderedLines: 0,
+  };
+
+  // Initial search
+  state.results = search({ query: state.query, cwd });
+
+  // Setup
+  enableRawMode();
+  write(hideCursor());
+
+  const cleanup = () => {
+    // Clear rendered UI
+    if (state.renderedLines > 0) {
+      write(moveCursorUp(state.renderedLines));
+    }
+    write(clearDown());
+    write(showCursor());
+    write(moveCursorToColumn(1));
+    disableRawMode();
+  };
+
+  // Handle unexpected exit
+  const onExit = () => {
+    cleanup();
+    process.exit(0);
+  };
+  process.on("SIGINT", onExit);
+  process.on("SIGTERM", onExit);
+
+  // Render initial frame
+  render(state);
+
+  // Input loop
+  try {
+    for await (const chunk of readStdin()) {
+      const key = parseKeypress(chunk);
+
+      if (key.type === "special" && key.key === "escape") {
+        cleanup();
+        // Output nothing = cancel
+        return;
+      }
+
+      if (key.type === "ctrl" && key.char === "c") {
+        cleanup();
+        return;
+      }
+
+      if (key.type === "special" && key.key === "enter") {
+        const selected = state.results[state.selectedIndex];
+        cleanup();
+        if (selected) {
+          // Output to stdout for shell to capture
+          process.stdout.write(selected.command);
+        }
+        return;
+      }
+
+      let needsSearch = false;
+
+      if (key.type === "char") {
+        state.query =
+          state.query.slice(0, state.cursorPos) +
+          key.char +
+          state.query.slice(state.cursorPos);
+        state.cursorPos += key.char.length;
+        needsSearch = true;
+      } else if (key.type === "special") {
+        switch (key.key) {
+          case "backspace":
+            if (state.cursorPos > 0) {
+              state.query =
+                state.query.slice(0, state.cursorPos - 1) +
+                state.query.slice(state.cursorPos);
+              state.cursorPos--;
+              needsSearch = true;
+            }
+            break;
+
+          case "delete":
+            if (state.cursorPos < state.query.length) {
+              state.query =
+                state.query.slice(0, state.cursorPos) +
+                state.query.slice(state.cursorPos + 1);
+              needsSearch = true;
+            }
+            break;
+
+          case "left":
+            if (state.cursorPos > 0) state.cursorPos--;
+            break;
+
+          case "right":
+            if (state.cursorPos < state.query.length) state.cursorPos++;
+            break;
+
+          case "home":
+            state.cursorPos = 0;
+            break;
+
+          case "end":
+            state.cursorPos = state.query.length;
+            break;
+
+          case "tab":
+          case "down":
+            if (state.results.length > 0) {
+              state.selectedIndex = (state.selectedIndex + 1) % state.results.length;
+              adjustScroll(state);
+            }
+            break;
+
+          case "shift-tab":
+          case "up":
+            if (state.results.length > 0) {
+              state.selectedIndex =
+                (state.selectedIndex - 1 + state.results.length) % state.results.length;
+              adjustScroll(state);
+            }
+            break;
+        }
+      } else if (key.type === "ctrl") {
+        switch (key.char) {
+          case "a":
+            state.cursorPos = 0;
+            break;
+          case "e":
+            state.cursorPos = state.query.length;
+            break;
+          case "u":
+            state.query = state.query.slice(state.cursorPos);
+            state.cursorPos = 0;
+            needsSearch = true;
+            break;
+          case "w": {
+            // Delete word backward
+            const before = state.query.slice(0, state.cursorPos);
+            const trimmed = before.replace(/\S+\s*$/, "");
+            state.query = trimmed + state.query.slice(state.cursorPos);
+            state.cursorPos = trimmed.length;
+            needsSearch = true;
+            break;
+          }
+        }
+      }
+
+      if (needsSearch) {
+        state.results = search({ query: state.query, cwd });
+        state.selectedIndex = 0;
+        state.scrollOffset = 0;
+      }
+
+      render(state);
+    }
+  } finally {
+    cleanup();
+  }
+}
+
+function getVisibleCount(): number {
+  const { rows } = getTerminalSize();
+  return Math.min(Math.max(rows - 4, 3), 15); // 3 minimum, 15 max
+}
+
+function adjustScroll(state: SearchState): void {
+  const visibleCount = getVisibleCount();
+  if (state.selectedIndex < state.scrollOffset) {
+    state.scrollOffset = state.selectedIndex;
+  } else if (state.selectedIndex >= state.scrollOffset + visibleCount) {
+    state.scrollOffset = state.selectedIndex - visibleCount + 1;
+  }
+}
+
+function render(state: SearchState): void {
+  const { cols } = getTerminalSize();
+  const visibleCount = getVisibleCount();
+
+  // Move up to clear previous render
+  if (state.renderedLines > 0) {
+    write(moveCursorUp(state.renderedLines));
+  }
+
+  const lines: string[] = [];
+
+  // Search box
+  lines.push(
+    clearLine() +
+      renderSearchBox({ query: state.query, cursorPos: state.cursorPos }, cols)
+  );
+
+  // Separator
+  lines.push(clearLine() + `\x1b[90m${"─".repeat(cols)}\x1b[0m`);
+
+  // Results
+  const resultLines = renderResultList(
+    {
+      results: state.results,
+      selectedIndex: state.selectedIndex,
+      scrollOffset: state.scrollOffset,
+      visibleCount,
+    },
+    cols
+  );
+
+  for (const line of resultLines) {
+    lines.push(clearLine() + line);
+  }
+
+  // Pad remaining visible slots
+  for (let i = resultLines.length; i < visibleCount; i++) {
+    lines.push(clearLine());
+  }
+
+  // Separator + Status bar
+  lines.push(clearLine() + `\x1b[90m${"─".repeat(cols)}\x1b[0m`);
+  lines.push(clearLine() + renderStatusBar(state.results.length, cols));
+
+  // Write all lines
+  write(lines.join("\r\n") + "\r\n");
+
+  // Track rendered lines for next clear
+  state.renderedLines = lines.length;
+
+  // Position cursor at search box
+  write(moveCursorUp(lines.length));
+  write(
+    moveCursorToColumn(getSearchBoxCursorCol({ query: state.query, cursorPos: state.cursorPos }))
+  );
+  write(showCursor());
+}
+
+async function* readStdin(): AsyncGenerator<Buffer> {
+  const stdin = process.stdin;
+  stdin.resume();
+
+  const buffers: Buffer[] = [];
+  let resolve: (() => void) | null = null;
+
+  stdin.on("data", (data: Buffer) => {
+    buffers.push(data);
+    if (resolve) {
+      resolve();
+      resolve = null;
+    }
+  });
+
+  while (true) {
+    if (buffers.length === 0) {
+      await new Promise<void>((r) => {
+        resolve = r;
+      });
+    }
+    while (buffers.length > 0) {
+      yield buffers.shift()!;
+    }
+  }
+}

package/src/cli/stats.ts

@@ -0,0 +1,42 @@
+import { getDb } from "../db/connection";
+import { getTotalCommandCount, getUniqueCommandCount } from "../db/queries";
+import { color } from "../tui/theme";
+
+export function runStats(): void {
+  const total = getTotalCommandCount();
+  const unique = getUniqueCommandCount();
+
+  const db = getDb();
+  const top = db
+    .query<{ command: string; frequency: number }, []>(
+      "SELECT command, frequency FROM command_stats ORDER BY frequency DESC LIMIT 10"
+    )
+    .all();
+
+  const oldest = db
+    .query<{ created_at: number }, []>(
+      "SELECT MIN(created_at) as created_at FROM commands"
+    )
+    .get();
+
+  console.log(`${color.bold}shellwise stats${color.reset}`);
+  console.log(`${color.dim}─────────────────────────${color.reset}`);
+  console.log(`Total executions:  ${color.cyan}${total}${color.reset}`);
+  console.log(`Unique commands:   ${color.cyan}${unique}${color.reset}`);
+
+  if (oldest?.created_at) {
+    const date = new Date(oldest.created_at).toLocaleDateString();
+    console.log(`History since:     ${color.cyan}${date}${color.reset}`);
+  }
+
+  if (top.length > 0) {
+    console.log(`\n${color.bold}Top commands${color.reset}`);
+    console.log(`${color.dim}─────────────────────────${color.reset}`);
+    for (let i = 0; i < top.length; i++) {
+      const num = String(i + 1).padStart(2);
+      console.log(
+        `${color.dim}${num}.${color.reset} ${top[i].command} ${color.dim}(${top[i].frequency}x)${color.reset}`
+      );
+    }
+  }
+}