shellwise 0.1.0

package/src/db/queries.ts

@@ -0,0 +1,181 @@
+import { getDb } from "./connection";
+import { createHash } from "crypto";
+
+export interface CommandRecord {
+  id: number;
+  command: string;
+  command_hash: string;
+  cwd: string | null;
+  exit_code: number | null;
+  duration_ms: number | null;
+  hostname: string | null;
+  session_id: string | null;
+  shell: string | null;
+  created_at: number;
+}
+
+export interface CommandStats {
+  command_hash: string;
+  command: string;
+  frequency: number;
+  last_used_at: number;
+  frecency_score: number;
+}
+
+export interface InsertCommandInput {
+  command: string;
+  cwd?: string;
+  exit_code?: number;
+  duration_ms?: number;
+  hostname?: string;
+  session_id?: string;
+  shell?: string;
+}
+
+export function hashCommand(command: string): string {
+  return createHash("sha256").update(command.trim()).digest("hex").slice(0, 16);
+}
+
+export function insertCommand(input: InsertCommandInput): void {
+  const db = getDb();
+  const hash = hashCommand(input.command);
+  const now = Date.now();
+
+  db.transaction(() => {
+    db.run(
+      `INSERT INTO commands (command, command_hash, cwd, exit_code, duration_ms, hostname, session_id, shell, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        input.command,
+        hash,
+        input.cwd ?? null,
+        input.exit_code ?? null,
+        input.duration_ms ?? null,
+        input.hostname ?? null,
+        input.session_id ?? null,
+        input.shell ?? null,
+        now,
+      ]
+    );
+
+    // Upsert command_stats
+    db.run(
+      `INSERT INTO command_stats (command_hash, command, frequency, last_used_at, frecency_score)
+       VALUES (?, ?, 1, ?, 4.0)
+       ON CONFLICT(command_hash) DO UPDATE SET
+         frequency = frequency + 1,
+         last_used_at = ?,
+         frecency_score = (frequency + 1) * ?`,
+      [hash, input.command.trim(), now, now, calculateRecencyWeight(now)]
+    );
+  })();
+}
+
+function calculateRecencyWeight(lastUsedAt: number): number {
+  const age = Date.now() - lastUsedAt;
+  const hour = 3600_000;
+  if (age < hour) return 4.0;
+  if (age < 24 * hour) return 2.0;
+  if (age < 7 * 24 * hour) return 1.5;
+  if (age < 30 * 24 * hour) return 1.0;
+  if (age < 90 * 24 * hour) return 0.5;
+  return 0.25;
+}
+
+export interface SearchOptions {
+  query?: string;
+  cwd?: string;
+  limit?: number;
+  exitCode?: number;
+}
+
+export function searchCommands(opts: SearchOptions): CommandStats[] {
+  const db = getDb();
+  const conditions: string[] = [];
+  const params: (string | number)[] = [];
+
+  if (opts.query) {
+    conditions.push("cs.command LIKE ?");
+    params.push(`%${opts.query}%`);
+  }
+
+  if (opts.cwd) {
+    conditions.push(
+      "cs.command_hash IN (SELECT DISTINCT command_hash FROM commands WHERE cwd = ?)"
+    );
+    params.push(opts.cwd);
+  }
+
+  if (opts.exitCode !== undefined) {
+    conditions.push(
+      "cs.command_hash IN (SELECT DISTINCT command_hash FROM commands WHERE exit_code = ?)"
+    );
+    params.push(opts.exitCode);
+  }
+
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = opts.limit ?? 200;
+
+  const rows = db
+    .query<CommandStats, (string | number)[]>(
+      `SELECT command_hash, command, frequency, last_used_at, frecency_score
+       FROM command_stats cs
+       ${where}
+       ORDER BY frecency_score DESC
+       LIMIT ?`
+    )
+    .all(...params, limit);
+
+  return rows;
+}
+
+export function getUniqueCommandCount(): number {
+  const db = getDb();
+  const row = db.query<{ count: number }, []>(
+    "SELECT COUNT(*) as count FROM command_stats"
+  ).get();
+  return row?.count ?? 0;
+}
+
+export function getTotalCommandCount(): number {
+  const db = getDb();
+  const row = db.query<{ count: number }, []>(
+    "SELECT COUNT(*) as count FROM commands"
+  ).get();
+  return row?.count ?? 0;
+}
+
+export function pruneOlderThan(days: number): number {
+  const db = getDb();
+  const cutoff = Date.now() - days * 24 * 3600_000;
+
+  const result = db.run("DELETE FROM commands WHERE created_at < ?", [cutoff]);
+
+  // Cleanup orphaned stats
+  db.run(
+    `DELETE FROM command_stats WHERE command_hash NOT IN (SELECT DISTINCT command_hash FROM commands)`
+  );
+
+  return result.changes;
+}
+
+export function refreshAllFrecency(): void {
+  const db = getDb();
+  const now = Date.now();
+  const stats = db
+    .query<{ command_hash: string; frequency: number; last_used_at: number }, []>(
+      "SELECT command_hash, frequency, last_used_at FROM command_stats"
+    )
+    .all();
+
+  const update = db.prepare(
+    "UPDATE command_stats SET frecency_score = ? WHERE command_hash = ?"
+  );
+
+  db.transaction(() => {
+    for (const s of stats) {
+      const weight = calculateRecencyWeight(s.last_used_at);
+      update.run(s.frequency * weight, s.command_hash);
+    }
+  })();
+}

package/src/db/schema.ts

@@ -0,0 +1,58 @@
+import type { Database } from "bun:sqlite";
+
+const MIGRATIONS = [
+  {
+    version: 1,
+    up(db: Database) {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS commands (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          command TEXT NOT NULL,
+          command_hash TEXT NOT NULL,
+          cwd TEXT,
+          exit_code INTEGER,
+          duration_ms INTEGER,
+          hostname TEXT,
+          session_id TEXT,
+          shell TEXT,
+          created_at INTEGER NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS command_stats (
+          command_hash TEXT PRIMARY KEY,
+          command TEXT NOT NULL,
+          frequency INTEGER DEFAULT 1,
+          last_used_at INTEGER NOT NULL,
+          frecency_score REAL DEFAULT 0
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_commands_hash ON commands(command_hash);
+        CREATE INDEX IF NOT EXISTS idx_commands_created ON commands(created_at DESC);
+        CREATE INDEX IF NOT EXISTS idx_commands_cwd ON commands(cwd);
+        CREATE INDEX IF NOT EXISTS idx_stats_frecency ON command_stats(frecency_score DESC);
+      `);
+    },
+  },
+];
+
+export function runMigrations(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_version (
+      version INTEGER PRIMARY KEY
+    );
+  `);
+
+  const row = db.query<{ version: number }, []>(
+    "SELECT MAX(version) as version FROM schema_version"
+  ).get();
+  const currentVersion = row?.version ?? 0;
+
+  for (const migration of MIGRATIONS) {
+    if (migration.version > currentVersion) {
+      db.transaction(() => {
+        migration.up(db);
+        db.run("INSERT INTO schema_version (version) VALUES (?)", [migration.version]);
+      })();
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,207 @@
+#!/usr/bin/env bun
+
+import { runAdd } from "./cli/add";
+import { runSearch } 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 { closeDb } from "./db/connection";
+import { startServer, isDaemonRunning, getDaemonInfo } from "./daemon/server";
+import { daemonRequest } from "./daemon/client";
+import { getSocketPath, getPidPath, getDaemonPort } from "./daemon/protocol";
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+function parseFlags(args: string[]): Record<string, string> {
+  const flags: Record<string, string> = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith("--") && i + 1 < args.length) {
+      const key = args[i].slice(2);
+      flags[key] = args[i + 1];
+      i++;
+    }
+  }
+  return flags;
+}
+
+function printHelp(): void {
+  console.log(`shellwise - Smart command history with fuzzy search
+
+Usage: sw <command> [options]
+
+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
+  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)
+
+Setup:
+  Add to ~/.zshrc:   eval "$(sw init zsh)"
+  Add to ~/.bashrc:  eval "$(sw init bash)"
+
+Features:
+  - Auto-save: commands are recorded automatically
+  - Auto-suggest: inline dropdown as you type (Tab/S-Tab to navigate)
+  - Ctrl+R: full interactive fuzzy search
+  - Daemon mode: ~1-3ms suggest via Unix socket`);
+}
+
+async function main(): Promise<void> {
+  try {
+    switch (command) {
+      case "search": {
+        const flags = parseFlags(args.slice(1));
+        await runSearch(flags.query || "");
+        break;
+      }
+
+      case "suggest": {
+        const flags = parseFlags(args.slice(1));
+        if (!flags.query) break;
+        const limit = flags.limit ? parseInt(flags.limit) : 5;
+
+        // Try daemon first (fast path ~1-3ms)
+        const result = await daemonRequest(`SUGGEST\t${flags.query}\t${limit}\n`);
+        if (result) {
+          process.stdout.write(result.join("\n"));
+        } else {
+          // Fallback: direct DB query (~20ms)
+          runSuggest(flags.query, limit);
+        }
+        break;
+      }
+
+      case "add": {
+        const flags = parseFlags(args.slice(1));
+        if (!flags.command) {
+          console.error("Usage: sw add --command <cmd>");
+          process.exit(1);
+        }
+
+        // Try daemon first
+        const addMsg = `ADD\t${flags.command}\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,
+            cwd: flags.cwd,
+            exitCode: flags["exit-code"] ? parseInt(flags["exit-code"]) : undefined,
+            duration: flags.duration ? parseInt(flags.duration) : undefined,
+            session: flags.session,
+            shell: flags.shell,
+          });
+        }
+        break;
+      }
+
+      case "init": {
+        const shell = args[1];
+        if (!shell) {
+          console.error("Usage: sw init <zsh|bash>");
+          process.exit(1);
+        }
+        runInit(shell, "sw");
+        break;
+      }
+
+      case "import": {
+        runImport(args[1]);
+        break;
+      }
+
+      case "stats": {
+        runStats();
+        break;
+      }
+
+      case "prune": {
+        const flags = parseFlags(args.slice(1));
+        const days = parseInt(flags.days || "90");
+        runPrune(days);
+        break;
+      }
+
+      case "daemon": {
+        const sub = args[1];
+        switch (sub) {
+          case "start": {
+            if (isDaemonRunning()) {
+              console.log("Daemon already running.");
+              return;
+            }
+            // Fork to background
+            const proc = Bun.spawn(["sw", "daemon", "_run"], {
+              stdio: ["ignore", "ignore", "ignore"],
+              // @ts-ignore - Bun supports detached
+              detached: true,
+            });
+            proc.unref();
+            // Wait a bit and verify
+            await new Promise((r) => setTimeout(r, 200));
+            if (isDaemonRunning()) {
+              const info = getDaemonInfo();
+              console.log(`Daemon started (pid: ${info?.pid}, port: ${info?.port})`);
+            } else {
+              console.error("Failed to start daemon.");
+              process.exit(1);
+            }
+            break;
+          }
+          case "_run":
+            // Internal: actual daemon process
+            startServer();
+            break;
+          case "stop": {
+            if (!isDaemonRunning()) {
+              console.log("Daemon not running.");
+              return;
+            }
+            await daemonRequest("STOP\n");
+            console.log("Daemon stopped.");
+            break;
+          }
+          case "status": {
+            if (isDaemonRunning()) {
+              const info = getDaemonInfo();
+              console.log(`Daemon running (pid: ${info?.pid}, port: ${info?.port})`);
+            } else {
+              console.log("Daemon not running.");
+            }
+            break;
+          }
+          default:
+            console.error("Usage: sw daemon start|stop|status");
+            process.exit(1);
+        }
+        break;
+      }
+
+      case "help":
+      case "--help":
+      case "-h":
+      case undefined:
+        printHelp();
+        break;
+
+      default:
+        console.error(`Unknown command: ${command}`);
+        printHelp();
+        process.exit(1);
+    }
+  } finally {
+    if (command !== "daemon") closeDb();
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/search/fuzzy.ts

@@ -0,0 +1,77 @@
+export interface FuzzyMatch {
+  text: string;
+  score: number;
+  positions: number[];
+}
+
+/**
+ * Fuzzy match algorithm — returns match score and character positions.
+ * Prioritizes: sequential matches > word boundary > any match
+ */
+export function fuzzyMatch(query: string, target: string): FuzzyMatch | null {
+  if (!query) return { text: target, score: 1, positions: [] };
+
+  const queryLower = query.toLowerCase();
+  const targetLower = target.toLowerCase();
+
+  // Quick check: all query chars exist in target?
+  let checkIdx = 0;
+  for (let i = 0; i < queryLower.length; i++) {
+    const found = targetLower.indexOf(queryLower[i], checkIdx);
+    if (found === -1) return null;
+    checkIdx = found + 1;
+  }
+
+  // Score matching with position tracking
+  const positions: number[] = [];
+  let score = 0;
+  let queryIdx = 0;
+  let prevMatchIdx = -2;
+
+  for (let i = 0; i < targetLower.length && queryIdx < queryLower.length; i++) {
+    if (targetLower[i] === queryLower[queryIdx]) {
+      positions.push(i);
+
+      // Consecutive match bonus
+      if (i === prevMatchIdx + 1) {
+        score += 3;
+      }
+
+      // Word boundary bonus (start, after space/slash/dash/dot)
+      if (i === 0 || " /\\-_.".includes(target[i - 1])) {
+        score += 2;
+      }
+
+      // Exact case match bonus
+      if (target[i] === query[queryIdx]) {
+        score += 0.5;
+      }
+
+      score += 1; // base score per match
+      prevMatchIdx = i;
+      queryIdx++;
+    }
+  }
+
+  if (queryIdx < queryLower.length) return null;
+
+  // Normalize score (0-1 range)
+  const maxPossible = queryLower.length * 6.5; // max per char: 3+2+0.5+1
+  const normalized = Math.min(score / maxPossible, 1);
+
+  // Bonus for shorter targets (prefer exact-ish matches)
+  const lengthBonus = query.length / target.length;
+  const finalScore = normalized * 0.8 + lengthBonus * 0.2;
+
+  return { text: target, score: finalScore, positions };
+}
+
+export function fuzzyFilter(query: string, items: string[]): FuzzyMatch[] {
+  const results: FuzzyMatch[] = [];
+  for (const item of items) {
+    const match = fuzzyMatch(query, item);
+    if (match) results.push(match);
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results;
+}

package/src/search/index.ts

@@ -0,0 +1,59 @@
+import { fuzzyMatch } from "./fuzzy";
+import { rankResults, type ScoredResult } from "./scorer";
+import { searchCommands, type CommandStats } from "../db/queries";
+import { getDb } from "../db/connection";
+
+export type { ScoredResult } from "./scorer";
+
+export interface SearchInput {
+  query: string;
+  cwd?: string;
+  limit?: number;
+}
+
+export function search(input: SearchInput): ScoredResult[] {
+  const limit = input.limit ?? 50;
+
+  // Phase 1: Pre-filter from DB (SQL LIKE)
+  const dbResults = searchCommands({
+    query: input.query || undefined,
+    limit: 200,
+  });
+
+  if (dbResults.length === 0) return [];
+
+  // Phase 2: Fuzzy match & score
+  if (!input.query) {
+    // No query = return by frecency
+    return dbResults.slice(0, limit).map((stat) => ({
+      command: stat.command,
+      commandHash: stat.command_hash,
+      frequency: stat.frequency,
+      lastUsedAt: stat.last_used_at,
+      fuzzyScore: 1,
+      frecencyScore: stat.frecency_score,
+      finalScore: stat.frecency_score,
+      matchPositions: [],
+    }));
+  }
+
+  const matches = [];
+  for (const stat of dbResults) {
+    const match = fuzzyMatch(input.query, stat.command);
+    if (match) matches.push(match);
+  }
+
+  // Get CWD-related commands for bonus scoring
+  let cwdCommands: Set<string> | undefined;
+  if (input.cwd) {
+    const db = getDb();
+    const rows = db
+      .query<{ command_hash: string }, [string]>(
+        "SELECT DISTINCT command_hash FROM commands WHERE cwd = ?"
+      )
+      .all(input.cwd);
+    cwdCommands = new Set(rows.map((r) => r.command_hash));
+  }
+
+  return rankResults(matches, dbResults, input.cwd, cwdCommands).slice(0, limit);
+}

package/src/search/scorer.ts

@@ -0,0 +1,71 @@
+import type { FuzzyMatch } from "./fuzzy";
+import type { CommandStats } from "../db/queries";
+
+export interface ScoredResult {
+  command: string;
+  commandHash: string;
+  frequency: number;
+  lastUsedAt: number;
+  fuzzyScore: number;
+  frecencyScore: number;
+  finalScore: number;
+  matchPositions: number[];
+}
+
+export interface ScoreWeights {
+  fuzzy: number;
+  frecency: number;
+  cwdBonus: number;
+}
+
+const DEFAULT_WEIGHTS: ScoreWeights = {
+  fuzzy: 0.6,
+  frecency: 0.3,
+  cwdBonus: 0.1,
+};
+
+export function rankResults(
+  matches: FuzzyMatch[],
+  stats: CommandStats[],
+  currentCwd?: string,
+  cwdCommands?: Set<string>,
+  weights: ScoreWeights = DEFAULT_WEIGHTS
+): ScoredResult[] {
+  const statsMap = new Map<string, CommandStats>();
+  for (const s of stats) {
+    statsMap.set(s.command, s);
+  }
+
+  const results: ScoredResult[] = [];
+
+  for (const match of matches) {
+    const stat = statsMap.get(match.text);
+    if (!stat) continue;
+
+    // Normalize frecency to 0-1 range
+    const maxFrecency = stats.reduce((max, s) => Math.max(max, s.frecency_score), 1);
+    const normalizedFrecency = stat.frecency_score / maxFrecency;
+
+    // CWD bonus
+    const cwd = currentCwd && cwdCommands?.has(stat.command_hash) ? 1 : 0;
+
+    const finalScore =
+      match.score * weights.fuzzy +
+      normalizedFrecency * weights.frecency +
+      cwd * weights.cwdBonus;
+
+    results.push({
+      command: match.text,
+      commandHash: stat.command_hash,
+      frequency: stat.frequency,
+      lastUsedAt: stat.last_used_at,
+      fuzzyScore: match.score,
+      frecencyScore: stat.frecency_score,
+      finalScore,
+      matchPositions: match.positions,
+    });
+  }
+
+  results.sort((a, b) => b.finalScore - a.finalScore);
+  return results;
+}