shellwise 0.1.0

package/src/cli/suggest.ts

@@ -0,0 +1,60 @@
+import { getDb } from "../db/connection";
+import { getCommonSuggestions } from "../data/common-commands";
+
+/**
+ * Suggest: 5 history + 5 common commands, deduplicated.
+ */
+export function runSuggest(query: string, limit: number = 5): void {
+  if (!query || query.length < 2) return;
+
+  const db = getDb();
+  const historyResults: string[] = [];
+
+  // History: prefix matches
+  const prefixes = db
+    .query<{ command: string }, [string, number]>(
+      `SELECT command FROM command_stats
+       WHERE command LIKE ? || '%'
+       ORDER BY frecency_score DESC
+       LIMIT ?`
+    )
+    .all(query, limit);
+
+  for (const r of prefixes) {
+    if (r.command !== query) historyResults.push(r.command);
+  }
+
+  // History: contains matches (fill remaining)
+  if (historyResults.length < limit) {
+    const remaining = limit - historyResults.length;
+    const resultSet = new Set(historyResults);
+
+    const contains = db
+      .query<{ command: string }, [string, string, number]>(
+        `SELECT command FROM command_stats
+         WHERE command LIKE '%' || ? || '%' AND command != ?
+         ORDER BY frecency_score DESC
+         LIMIT ?`
+      )
+      .all(query, query, remaining + historyResults.length);
+
+    for (const r of contains) {
+      if (!resultSet.has(r.command) && r.command !== query) {
+        historyResults.push(r.command);
+        if (historyResults.length >= limit) break;
+      }
+    }
+  }
+
+  // Common commands (deduplicated)
+  const seen = new Set(historyResults);
+  const commonResults = getCommonSuggestions(query, 10)
+    .filter((cmd) => !seen.has(cmd) && cmd !== query)
+    .slice(0, 5);
+
+  const merged = [...historyResults, ...commonResults];
+
+  if (merged.length > 0) {
+    process.stdout.write(merged.join("\n"));
+  }
+}

package/src/daemon/client.ts

@@ -0,0 +1,41 @@
+import { getSocketPath } from "./protocol";
+import { existsSync } from "fs";
+import { connect } from "net";
+
+/**
+ * Send request to daemon via Unix socket.
+ * Returns response lines or null if daemon unavailable.
+ */
+export function daemonRequest(message: string, timeoutMs: number = 500): Promise<string[] | null> {
+  const socketPath = getSocketPath();
+  if (!existsSync(socketPath)) return Promise.resolve(null);
+
+  return new Promise((resolve) => {
+    const socket = connect(socketPath);
+    let data = "";
+    const timer = setTimeout(() => {
+      socket.destroy();
+      resolve(null);
+    }, timeoutMs);
+
+    socket.on("connect", () => {
+      socket.write(message);
+    });
+
+    socket.on("data", (chunk) => {
+      data += chunk.toString();
+      // Response ends with double newline
+      if (data.includes("\n\n")) {
+        clearTimeout(timer);
+        socket.destroy();
+        const lines = data.trim().split("\n").filter(Boolean);
+        resolve(lines);
+      }
+    });
+
+    socket.on("error", () => {
+      clearTimeout(timer);
+      resolve(null);
+    });
+  });
+}

package/src/daemon/protocol.ts

@@ -0,0 +1,89 @@
+/**
+ * Simple text protocol over Unix socket.
+ * Request:  COMMAND\targ1\targ2\n
+ * Response: line1\nline2\n\n  (empty line = end)
+ */
+
+export type RequestType = "SUGGEST" | "ADD" | "STOP" | "PING";
+
+export interface SuggestRequest {
+  type: "SUGGEST";
+  query: string;
+  limit: number;
+}
+
+export interface AddRequest {
+  type: "ADD";
+  command: string;
+  cwd: string;
+  exitCode: number;
+  duration: number;
+  session: string;
+  shell: string;
+}
+
+export interface StopRequest {
+  type: "STOP";
+}
+
+export interface PingRequest {
+  type: "PING";
+}
+
+export type Request = SuggestRequest | AddRequest | StopRequest | PingRequest;
+
+export function serializeRequest(req: Request): string {
+  switch (req.type) {
+    case "SUGGEST":
+      return `SUGGEST\t${req.query}\t${req.limit}\n`;
+    case "ADD":
+      return `ADD\t${req.command}\t${req.cwd}\t${req.exitCode}\t${req.duration}\t${req.session}\t${req.shell}\n`;
+    case "STOP":
+      return `STOP\n`;
+    case "PING":
+      return `PING\n`;
+  }
+}
+
+export function parseRequest(raw: string): Request | null {
+  const line = raw.trim();
+  const parts = line.split("\t");
+  const type = parts[0] as RequestType;
+
+  switch (type) {
+    case "SUGGEST":
+      return { type: "SUGGEST", query: parts[1] || "", limit: parseInt(parts[2]) || 5 };
+    case "ADD":
+      return {
+        type: "ADD",
+        command: parts[1] || "",
+        cwd: parts[2] || "",
+        exitCode: parseInt(parts[3]) || 0,
+        duration: parseInt(parts[4]) || 0,
+        session: parts[5] || "",
+        shell: parts[6] || "",
+      };
+    case "STOP":
+      return { type: "STOP" };
+    case "PING":
+      return { type: "PING" };
+    default:
+      return null;
+  }
+}
+
+export function getSocketPath(): string {
+  const uid = process.getuid?.() ?? process.pid;
+  return `/tmp/shellwise-${uid}.sock`;
+}
+
+/** TCP port = 19850 + (uid % 100) to avoid collisions */
+export function getDaemonPort(): number {
+  const uid = process.getuid?.() ?? 501;
+  return 19850 + (uid % 100);
+}
+
+export function getPidPath(): string {
+  const uid = process.getuid?.() ?? process.pid;
+  return `/tmp/shellwise-${uid}.pid`;
+}

package/src/daemon/server.ts

@@ -0,0 +1,222 @@
+import { getDb, closeDb } from "../db/connection";
+import { insertCommand } from "../db/queries";
+import { getHostname } from "../utils/platform";
+import { getCommonSuggestions } from "../data/common-commands";
+import { parseRequest, getSocketPath, getPidPath, getDaemonPort } from "./protocol";
+import { unlinkSync, writeFileSync, existsSync } from "fs";
+import type { Socket } from "bun";
+
+const IGNORED_COMMANDS = new Set(["ls", "cd", "pwd", "exit", "clear", "sw"]);
+const IDLE_TIMEOUT = 30 * 60_000; // 30 min
+
+let idleTimer: ReturnType<typeof setTimeout> | null = null;
+let server: ReturnType<typeof Bun.listen> | null = null;
+
+// Pre-warm DB + prepared statements on start
+let suggestPrefix: ReturnType<ReturnType<typeof getDb>["prepare"]>;
+let suggestContains: ReturnType<ReturnType<typeof getDb>["prepare"]>;
+
+function initPreparedStatements() {
+  const db = getDb();
+  suggestPrefix = db.prepare(
+    `SELECT command FROM command_stats
+     WHERE command LIKE ?1 || '%'
+     ORDER BY frecency_score DESC
+     LIMIT ?2`
+  );
+  suggestContains = db.prepare(
+    `SELECT command FROM command_stats
+     WHERE command LIKE '%' || ?1 || '%' AND command != ?1
+     ORDER BY frecency_score DESC
+     LIMIT ?2`
+  );
+}
+
+function resetIdleTimer() {
+  if (idleTimer) clearTimeout(idleTimer);
+  idleTimer = setTimeout(() => {
+    stopServer();
+  }, IDLE_TIMEOUT);
+}
+
+function handleRequest(raw: string): string {
+  const req = parseRequest(raw);
+  if (!req) return "\n";
+
+  resetIdleTimer();
+
+  switch (req.type) {
+    case "PING":
+      return "PONG\n\n";
+
+    case "SUGGEST": {
+      if (!req.query || req.query.length < 2) return "\n";
+
+      const historyResults: string[] = [];
+      const historyLimit = 5;
+
+      // History: prefix matches
+      const prefixes = suggestPrefix.all(req.query, historyLimit) as { command: string }[];
+      for (const r of prefixes) {
+        if (r.command !== req.query) historyResults.push(r.command);
+      }
+
+      // History: contains matches (fill remaining)
+      if (historyResults.length < historyLimit) {
+        const remaining = historyLimit - historyResults.length;
+        const resultSet = new Set(historyResults);
+        const contains = suggestContains.all(req.query, remaining + historyResults.length) as {
+          command: string;
+        }[];
+        for (const r of contains) {
+          if (!resultSet.has(r.command) && r.command !== req.query) {
+            historyResults.push(r.command);
+            if (historyResults.length >= historyLimit) break;
+          }
+        }
+      }
+
+      // 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)
+        .slice(0, 5);
+
+      // Merge: history first, then common
+      const merged = [...historyResults, ...commonResults];
+
+      return merged.length > 0 ? merged.join("\n") + "\n\n" : "\n";
+    }
+
+    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
+      const baseCmd = cmd.split(/\s+/)[0];
+      if (IGNORED_COMMANDS.has(baseCmd)) return "OK\n\n";
+
+      insertCommand({
+        command: cmd,
+        cwd: req.cwd || undefined,
+        exit_code: req.exitCode,
+        duration_ms: req.duration,
+        hostname: getHostname(),
+        session_id: req.session || undefined,
+        shell: req.shell || undefined,
+      });
+      return "OK\n\n";
+    }
+
+    case "STOP":
+      setTimeout(() => stopServer(), 50);
+      return "BYE\n\n";
+  }
+}
+
+export function startServer(): void {
+  const socketPath = getSocketPath();
+  const pidPath = getPidPath();
+
+  // Cleanup stale socket
+  if (existsSync(socketPath)) {
+    try {
+      unlinkSync(socketPath);
+    } catch {}
+  }
+
+  // Init DB + prepared statements
+  initPreparedStatements();
+
+  const socketHandlers = {
+    data(socket: Socket, data: Buffer) {
+      const lines = data.toString().split("\n");
+      for (const line of lines) {
+        if (line.trim()) {
+          const response = handleRequest(line);
+          socket.write(response);
+        }
+      }
+    },
+    open() {},
+    close() {},
+    error(_socket: Socket, error: Error) {
+      console.error("[shellwise daemon] socket error:", error.message);
+    },
+  };
+
+  // Listen on both Unix socket and TCP (for ztcp from zsh)
+  server = Bun.listen({
+    unix: socketPath,
+    socket: socketHandlers,
+  });
+
+  const port = getDaemonPort();
+  Bun.listen({
+    hostname: "127.0.0.1",
+    port,
+    socket: socketHandlers,
+  });
+
+  // Save PID + port
+  writeFileSync(pidPath, `${process.pid}\n${port}`);
+
+  resetIdleTimer();
+
+  // Cleanup on exit
+  const cleanup = () => {
+    stopServer();
+    process.exit(0);
+  };
+  process.on("SIGTERM", cleanup);
+  process.on("SIGINT", cleanup);
+}
+
+export function stopServer(): void {
+  if (idleTimer) clearTimeout(idleTimer);
+  if (server) {
+    server.stop(true);
+    server = null;
+  }
+  closeDb();
+
+  const socketPath = getSocketPath();
+  const pidPath = getPidPath();
+  try {
+    unlinkSync(socketPath);
+  } catch {}
+  try {
+    unlinkSync(pidPath);
+  } catch {}
+
+  process.exit(0);
+}
+
+export function isDaemonRunning(): boolean {
+  const pidPath = getPidPath();
+  if (!existsSync(pidPath)) return false;
+
+  try {
+    const content = require("fs").readFileSync(pidPath, "utf-8").trim();
+    const pid = parseInt(content.split("\n")[0]);
+    process.kill(pid, 0); // Check if process exists
+    return true;
+  } catch {
+    // Stale PID file
+    try {
+      unlinkSync(pidPath);
+    } catch {}
+    return false;
+  }
+}
+
+export function getDaemonInfo(): { pid: number; port: number } | null {
+  const pidPath = getPidPath();
+  if (!existsSync(pidPath)) return null;
+  try {
+    const content = require("fs").readFileSync(pidPath, "utf-8").trim();
+    const lines = content.split("\n");
+    return { pid: parseInt(lines[0]), port: parseInt(lines[1]) };
+  } catch {
+    return null;
+  }
+}

package/src/data/common-commands.ts

@@ -0,0 +1,276 @@
+/**
+ * Common commands grouped by prefix.
+ * Used to suggest commands even when user has no history.
+ */
+const COMMANDS: Record<string, string[]> = {
+  git: [
+    "git status",
+    "git add .",
+    "git commit -m ''",
+    "git push",
+    "git pull",
+    "git branch",
+    "git checkout",
+    "git diff",
+    "git log --oneline",
+    "git stash",
+    "git merge",
+    "git rebase",
+    "git fetch",
+    "git clone",
+    "git reset --soft HEAD~1",
+    "git cherry-pick",
+    "git remote -v",
+    "git tag",
+  ],
+  npm: [
+    "npm install",
+    "npm run dev",
+    "npm run build",
+    "npm run test",
+    "npm run start",
+    "npm init -y",
+    "npm update",
+    "npm outdated",
+    "npm list --depth=0",
+    "npm publish",
+    "npm link",
+    "npm uninstall",
+    "npm cache clean --force",
+    "npm audit fix",
+  ],
+  npx: [
+    "npx create-next-app@latest",
+    "npx create-react-app",
+    "npx prisma generate",
+    "npx prisma migrate dev",
+    "npx tsc --noEmit",
+    "npx eslint .",
+    "npx prettier --write .",
+  ],
+  bun: [
+    "bun install",
+    "bun run dev",
+    "bun run build",
+    "bun test",
+    "bun add",
+    "bun remove",
+    "bun init",
+    "bun upgrade",
+    "bun run start",
+    "bun link",
+    "bun build --compile",
+  ],
+  docker: [
+    "docker compose up -d",
+    "docker compose down",
+    "docker compose logs -f",
+    "docker compose build",
+    "docker compose ps",
+    "docker ps",
+    "docker images",
+    "docker build -t",
+    "docker run -it",
+    "docker exec -it",
+    "docker stop",
+    "docker rm",
+    "docker rmi",
+    "docker system prune -f",
+    "docker volume ls",
+    "docker network ls",
+  ],
+  yarn: [
+    "yarn install",
+    "yarn dev",
+    "yarn build",
+    "yarn test",
+    "yarn add",
+    "yarn remove",
+    "yarn upgrade",
+    "yarn start",
+  ],
+  pnpm: [
+    "pnpm install",
+    "pnpm run dev",
+    "pnpm run build",
+    "pnpm add",
+    "pnpm remove",
+    "pnpm dlx",
+  ],
+  brew: [
+    "brew install",
+    "brew update",
+    "brew upgrade",
+    "brew list",
+    "brew search",
+    "brew uninstall",
+    "brew cleanup",
+    "brew info",
+    "brew doctor",
+    "brew services list",
+    "brew services start",
+    "brew services stop",
+  ],
+  curl: [
+    "curl -X GET",
+    "curl -X POST",
+    "curl -sL",
+    "curl -o",
+    "curl -I",
+    "curl -H 'Content-Type: application/json'",
+    "curl -d '{}'",
+  ],
+  ssh: [
+    "ssh-keygen -t ed25519",
+    "ssh-copy-id",
+    "ssh -i",
+    "ssh -L",
+    "ssh -p",
+  ],
+  python: [
+    "python -m venv venv",
+    "python -m pip install",
+    "python -m pytest",
+    "python manage.py runserver",
+    "python manage.py migrate",
+  ],
+  pip: [
+    "pip install",
+    "pip install -r requirements.txt",
+    "pip freeze > requirements.txt",
+    "pip list",
+    "pip uninstall",
+  ],
+  go: [
+    "go run .",
+    "go build",
+    "go test ./...",
+    "go mod tidy",
+    "go mod init",
+    "go get",
+    "go fmt ./...",
+    "go vet ./...",
+  ],
+  cargo: [
+    "cargo build",
+    "cargo run",
+    "cargo test",
+    "cargo add",
+    "cargo fmt",
+    "cargo clippy",
+    "cargo init",
+    "cargo publish",
+  ],
+  make: [
+    "make build",
+    "make test",
+    "make clean",
+    "make install",
+    "make all",
+  ],
+  kubectl: [
+    "kubectl get pods",
+    "kubectl get services",
+    "kubectl get deployments",
+    "kubectl logs",
+    "kubectl describe pod",
+    "kubectl apply -f",
+    "kubectl delete",
+    "kubectl exec -it",
+    "kubectl port-forward",
+    "kubectl config use-context",
+  ],
+  systemctl: [
+    "systemctl status",
+    "systemctl start",
+    "systemctl stop",
+    "systemctl restart",
+    "systemctl enable",
+    "systemctl disable",
+    "systemctl list-units",
+  ],
+  pm2: [
+    "pm2 list",
+    "pm2 start",
+    "pm2 stop",
+    "pm2 restart",
+    "pm2 logs",
+    "pm2 delete",
+    "pm2 monit",
+    "pm2 save",
+  ],
+  tar: [
+    "tar -czf archive.tar.gz",
+    "tar -xzf",
+    "tar -xvf",
+    "tar -tf",
+  ],
+  find: [
+    "find . -name",
+    "find . -type f",
+    "find . -type d",
+    "find . -mtime",
+    "find . -size",
+  ],
+  grep: [
+    "grep -r",
+    "grep -rn",
+    "grep -ri",
+    "grep -l",
+    "grep -v",
+  ],
+  chmod: [
+    "chmod +x",
+    "chmod 755",
+    "chmod 644",
+    "chmod -R",
+  ],
+  vercel: [
+    "vercel deploy",
+    "vercel dev",
+    "vercel env pull",
+    "vercel logs",
+    "vercel ls",
+  ],
+  supabase: [
+    "supabase start",
+    "supabase stop",
+    "supabase db reset",
+    "supabase migration new",
+    "supabase gen types typescript",
+    "supabase db push",
+  ],
+};
+
+/** Get common command suggestions for a query */
+export function getCommonSuggestions(query: string, limit: number = 5): string[] {
+  const q = query.toLowerCase();
+  const results: string[] = [];
+
+  // Try prefix match on command groups
+  for (const [prefix, commands] of Object.entries(COMMANDS)) {
+    if (prefix.startsWith(q) || q.startsWith(prefix)) {
+      for (const cmd of commands) {
+        if (cmd.toLowerCase().startsWith(q) || cmd.toLowerCase().includes(q)) {
+          results.push(cmd);
+          if (results.length >= limit) return results;
+        }
+      }
+    }
+  }
+
+  // Fallback: search all commands
+  if (results.length < limit) {
+    const seen = new Set(results);
+    for (const commands of Object.values(COMMANDS)) {
+      for (const cmd of commands) {
+        if (!seen.has(cmd) && cmd.toLowerCase().includes(q)) {
+          results.push(cmd);
+          if (results.length >= limit) return results;
+        }
+      }
+    }
+  }
+
+  return results;
+}

package/src/db/connection.ts

@@ -0,0 +1,29 @@
+import { Database } from "bun:sqlite";
+import { getDbPath } from "../utils/paths";
+import { runMigrations } from "./schema";
+
+let db: Database | null = null;
+
+export function getDb(): Database {
+  if (db) return db;
+
+  const dbPath = getDbPath();
+  db = new Database(dbPath, { create: true });
+
+  // Performance: WAL mode for concurrent read/write
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA busy_timeout = 5000");
+  db.exec("PRAGMA synchronous = NORMAL");
+  db.exec("PRAGMA foreign_keys = ON");
+
+  runMigrations(db);
+
+  return db;
+}
+
+export function closeDb(): void {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}