@atercates/claude-deck 0.2.1

package/lib/claude/stream-parser.ts

@@ -0,0 +1,173 @@
+import { EventEmitter } from "events";
+import type {
+  StreamMessage,
+  StreamMessageSystem,
+  StreamMessageAssistant,
+  StreamMessageResult,
+  ClientEvent,
+  TextContent,
+} from "./types";
+
+export class StreamParser extends EventEmitter {
+  private buffer = "";
+  private sessionId: string;
+
+  constructor(sessionId: string) {
+    super();
+    this.sessionId = sessionId;
+  }
+
+  // Process incoming data chunk
+  write(chunk: string): void {
+    this.buffer += chunk;
+
+    // Process complete lines (NDJSON format)
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() || ""; // Keep incomplete line in buffer
+
+    for (const line of lines) {
+      if (line.trim()) {
+        this.parseLine(line);
+      }
+    }
+  }
+
+  // Flush any remaining buffer
+  end(): void {
+    if (this.buffer.trim()) {
+      this.parseLine(this.buffer);
+    }
+    this.buffer = "";
+  }
+
+  private parseLine(line: string): void {
+    try {
+      const message: StreamMessage = JSON.parse(line);
+      const event = this.transformToClientEvent(message);
+      if (event) {
+        this.emit("event", event);
+      }
+    } catch (err) {
+      console.error("Failed to parse stream line:", line, err);
+      this.emit("parse_error", { type: "parse_error", line, error: err });
+    }
+  }
+
+  private transformToClientEvent(message: StreamMessage): ClientEvent | null {
+    const timestamp = new Date().toISOString();
+
+    switch (message.type) {
+      // Handle system init event
+      case "system": {
+        const sysMsg = message as StreamMessageSystem;
+        if (sysMsg.subtype === "init") {
+          return {
+            type: "init",
+            sessionId: this.sessionId,
+            timestamp,
+            data: { claudeSessionId: sysMsg.session_id || "" },
+          };
+        }
+        return null;
+      }
+
+      // Handle assistant message (actual Claude response)
+      case "assistant": {
+        const assistantMsg = message as StreamMessageAssistant;
+        const msg = assistantMsg.message;
+        if (!msg?.content) return null;
+
+        const textBlocks = msg.content
+          .filter((c) => c.type === "text" && c.text)
+          .map((c) => c.text || "");
+
+        if (textBlocks.length > 0) {
+          return {
+            type: "text",
+            sessionId: this.sessionId,
+            timestamp,
+            data: {
+              role: msg.role || "assistant",
+              text: textBlocks.join(""),
+              content: msg.content.filter(
+                (c): c is TextContent => c.type === "text" && !!c.text
+              ),
+            },
+          };
+        }
+        return null;
+      }
+
+      // Legacy message format (if used)
+      case "message": {
+        const textBlocks = message.content
+          .filter((c): c is TextContent => c.type === "text")
+          .map((c) => c.text);
+
+        if (textBlocks.length > 0) {
+          return {
+            type: "text",
+            sessionId: this.sessionId,
+            timestamp,
+            data: {
+              role: message.role,
+              text: textBlocks.join(""),
+              content: message.content,
+            },
+          };
+        }
+        return null;
+      }
+
+      case "tool_use":
+        return {
+          type: "tool_start",
+          sessionId: this.sessionId,
+          timestamp,
+          data: {
+            toolName: message.tool_name,
+            input: message.tool_input,
+          },
+        };
+
+      case "tool_result":
+        return {
+          type: "tool_end",
+          sessionId: this.sessionId,
+          timestamp,
+          data: {
+            toolName: message.tool_name,
+            output: message.output,
+            status: message.status,
+          },
+        };
+
+      case "result": {
+        const resultMsg = message as StreamMessageResult;
+        if (resultMsg.subtype === "success" || resultMsg.status === "success") {
+          return {
+            type: "complete",
+            sessionId: this.sessionId,
+            timestamp,
+            data: {
+              durationMs: resultMsg.duration_ms,
+              output: resultMsg.result || resultMsg.output,
+            },
+          };
+        } else {
+          return {
+            type: "error",
+            sessionId: this.sessionId,
+            timestamp,
+            data: {
+              error: resultMsg.error || "Unknown error",
+            },
+          };
+        }
+      }
+
+      default:
+        return null;
+    }
+  }
+}

package/lib/claude/types.ts

@@ -0,0 +1,154 @@
+// Stream-JSON message types from Claude CLI
+
+export interface StreamMessageInit {
+  type: "init";
+  session_id: string;
+  timestamp: string;
+}
+
+export interface StreamMessageSystem {
+  type: "system";
+  subtype: "init" | string;
+  session_id?: string;
+  timestamp?: string;
+}
+
+export interface StreamMessageAssistant {
+  type: "assistant";
+  message: {
+    role: string;
+    content: Array<{ type: string; text?: string }>;
+  };
+  timestamp?: string;
+}
+
+export interface StreamMessageContent {
+  type: "message";
+  role: "assistant" | "user";
+  content: ContentBlock[];
+  timestamp: string;
+}
+
+export interface StreamMessageToolUse {
+  type: "tool_use";
+  tool_name: string;
+  tool_input: Record<string, unknown>;
+  timestamp: string;
+}
+
+export interface StreamMessageToolResult {
+  type: "tool_result";
+  tool_name: string;
+  output: string;
+  status: "success" | "error";
+  timestamp: string;
+}
+
+export interface StreamMessageResult {
+  type: "result";
+  subtype?: "success" | "error";
+  status?: "success" | "error";
+  duration_ms?: number;
+  result?: string;
+  output?: string;
+  error?: string;
+  timestamp?: string;
+}
+
+export type StreamMessage =
+  | StreamMessageInit
+  | StreamMessageSystem
+  | StreamMessageAssistant
+  | StreamMessageContent
+  | StreamMessageToolUse
+  | StreamMessageToolResult
+  | StreamMessageResult;
+
+// Content block types
+export interface TextContent {
+  type: "text";
+  text: string;
+}
+
+export interface ToolUseContent {
+  type: "tool_use";
+  id: string;
+  name: string;
+  input: Record<string, unknown>;
+}
+
+export interface ToolResultContent {
+  type: "tool_result";
+  tool_use_id: string;
+  content: string;
+}
+
+export type ContentBlock = TextContent | ToolUseContent | ToolResultContent;
+
+// Client events (sent to WebSocket clients)
+export interface ClientEventInit {
+  type: "init";
+  sessionId: string;
+  timestamp: string;
+  data: { claudeSessionId: string };
+}
+
+export interface ClientEventText {
+  type: "text";
+  sessionId: string;
+  timestamp: string;
+  data: { role: string; text: string; content: ContentBlock[] };
+}
+
+export interface ClientEventToolStart {
+  type: "tool_start";
+  sessionId: string;
+  timestamp: string;
+  data: { toolName: string; input: Record<string, unknown> };
+}
+
+export interface ClientEventToolEnd {
+  type: "tool_end";
+  sessionId: string;
+  timestamp: string;
+  data: { toolName: string; output: string; status: string };
+}
+
+export interface ClientEventComplete {
+  type: "complete";
+  sessionId: string;
+  timestamp: string;
+  data: { durationMs?: number; output?: string };
+}
+
+export interface ClientEventError {
+  type: "error";
+  sessionId: string;
+  timestamp: string;
+  data: { error: string };
+}
+
+export interface ClientEventStatus {
+  type: "status";
+  sessionId: string;
+  timestamp: string;
+  data: { status: string; exitCode?: number };
+}
+
+export type ClientEvent =
+  | ClientEventInit
+  | ClientEventText
+  | ClientEventToolStart
+  | ClientEventToolEnd
+  | ClientEventComplete
+  | ClientEventError
+  | ClientEventStatus;
+
+// Session options
+export interface ClaudeSessionOptions {
+  model?: string;
+  workingDirectory?: string;
+  resume?: boolean; // Use --continue or --resume
+  claudeSessionId?: string; // For --resume
+  systemPrompt?: string;
+}

package/lib/claude/watcher.ts

@@ -0,0 +1,71 @@
+import { watch } from "chokidar";
+import path from "path";
+import os from "os";
+import { WebSocket } from "ws";
+import { invalidateProject, invalidateAll } from "./jsonl-cache";
+
+const CLAUDE_PROJECTS_DIR = path.join(os.homedir(), ".claude", "projects");
+
+const updateClients = new Set<WebSocket>();
+
+export function addUpdateClient(ws: WebSocket): void {
+  updateClients.add(ws);
+  ws.on("close", () => updateClients.delete(ws));
+}
+
+function broadcast(msg: object): void {
+  const data = JSON.stringify(msg);
+  for (const ws of updateClients) {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(data);
+    }
+  }
+}
+
+const debounceTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+function handleFileChange(filePath: string): void {
+  const relative = path.relative(CLAUDE_PROJECTS_DIR, filePath);
+  const projectName = relative.split(path.sep)[0];
+  if (!projectName) return;
+
+  const existing = debounceTimers.get(projectName);
+  if (existing) clearTimeout(existing);
+
+  debounceTimers.set(
+    projectName,
+    setTimeout(() => {
+      debounceTimers.delete(projectName);
+      invalidateProject(projectName);
+      broadcast({ type: "project-updated", projectName });
+    }, 150)
+  );
+}
+
+export function startWatcher(): void {
+  try {
+    const watcher = watch(CLAUDE_PROJECTS_DIR, {
+      ignoreInitial: true,
+      depth: 2,
+      ignored: [/node_modules/, /\.git/, /subagents/],
+    });
+
+    watcher.on("change", handleFileChange);
+    watcher.on("add", (fp) => {
+      handleFileChange(fp);
+      const relative = path.relative(CLAUDE_PROJECTS_DIR, fp);
+      if (!relative.includes(path.sep)) {
+        invalidateAll();
+        broadcast({ type: "projects-changed" });
+      }
+    });
+    watcher.on("addDir", () => {
+      invalidateAll();
+      broadcast({ type: "projects-changed" });
+    });
+
+    console.log("> File watcher started on ~/.claude/projects/");
+  } catch (err) {
+    console.error("Failed to start file watcher:", err);
+  }
+}

package/lib/client/session-registry.ts

@@ -0,0 +1,111 @@
+/**
+ * Client-side registry for preserving terminal state across navigation
+ * Stores scroll positions and other ephemeral state that should persist
+ * when switching between tabs/sessions.
+ */
+
+interface TerminalState {
+  scrollTop: number;
+  scrollHeight: number;
+  lastActivity: number;
+  cursorY: number;
+}
+
+interface SessionEntry {
+  tabId: string;
+  sessionId?: string;
+  attachedTmux?: string;
+  terminalState?: TerminalState;
+}
+
+class SessionRegistry {
+  private sessions: Map<string, SessionEntry> = new Map();
+
+  /**
+   * Generate a unique key for a pane+tab combination
+   */
+  private getKey(paneId: string, tabId: string): string {
+    return `${paneId}:${tabId}`;
+  }
+
+  /**
+   * Register or update a session entry
+   */
+  register(
+    paneId: string,
+    tabId: string,
+    data: Partial<Omit<SessionEntry, "tabId">>
+  ): void {
+    const key = this.getKey(paneId, tabId);
+    const existing = this.sessions.get(key);
+
+    this.sessions.set(key, {
+      tabId,
+      ...existing,
+      ...data,
+    });
+  }
+
+  /**
+   * Get session entry
+   */
+  get(paneId: string, tabId: string): SessionEntry | undefined {
+    return this.sessions.get(this.getKey(paneId, tabId));
+  }
+
+  /**
+   * Save terminal state (scroll position, cursor, etc.)
+   */
+  saveTerminalState(paneId: string, tabId: string, state: TerminalState): void {
+    const key = this.getKey(paneId, tabId);
+    const existing = this.sessions.get(key);
+
+    this.sessions.set(key, {
+      tabId,
+      ...existing,
+      terminalState: state,
+    });
+  }
+
+  /**
+   * Get saved terminal state
+   */
+  getTerminalState(paneId: string, tabId: string): TerminalState | undefined {
+    return this.sessions.get(this.getKey(paneId, tabId))?.terminalState;
+  }
+
+  /**
+   * Remove session entry
+   */
+  remove(paneId: string, tabId: string): void {
+    this.sessions.delete(this.getKey(paneId, tabId));
+  }
+
+  /**
+   * Clear all entries for a pane
+   */
+  clearPane(paneId: string): void {
+    for (const key of this.sessions.keys()) {
+      if (key.startsWith(`${paneId}:`)) {
+        this.sessions.delete(key);
+      }
+    }
+  }
+
+  /**
+   * Clear all entries
+   */
+  clear(): void {
+    this.sessions.clear();
+  }
+
+  /**
+   * Get count of active sessions
+   */
+  get size(): number {
+    return this.sessions.size;
+  }
+}
+
+// Singleton instance
+export const sessionRegistry = new SessionRegistry();

package/lib/code-search.ts

@@ -0,0 +1,121 @@
+import { execSync } from "child_process";
+
+/**
+ * Check if ripgrep is available on the system
+ */
+export function isRipgrepAvailable(): boolean {
+  try {
+    execSync("which rg", { encoding: "utf-8", stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export interface SearchOptions {
+  maxResults?: number;
+  contextLines?: number;
+  filePattern?: string;
+  caseSensitive?: boolean;
+}
+
+export interface SearchMatch {
+  type: "match";
+  data: {
+    path: { text: string };
+    lines: { text: string };
+    line_number: number;
+    absolute_offset: number;
+    submatches: Array<{ match: { text: string }; start: number; end: number }>;
+  };
+}
+
+export interface FormattedMatch {
+  file: string;
+  line: number;
+  column: number;
+  matchText: string;
+  lineText: string;
+}
+
+export function searchCode(
+  workingDir: string,
+  query: string,
+  options: SearchOptions = {}
+): SearchMatch[] {
+  const {
+    maxResults = 100,
+    contextLines = 2,
+    filePattern = "*",
+    caseSensitive = false,
+  } = options;
+
+  try {
+    // Use spawn instead of execSync for better control
+    const { spawnSync } = require("child_process");
+
+    const args = [
+      "--json",
+      `--max-count=${Math.ceil(maxResults / 10)}`,
+      `--context=${contextLines}`,
+      "--ignore-case",
+      query,
+      ".", // CRITICAL: Tell ripgrep to search current directory explicitly
+    ];
+
+    const result = spawnSync("rg", args, {
+      cwd: workingDir,
+      encoding: "utf-8",
+      timeout: 10000,
+      maxBuffer: 1024 * 1024 * 5,
+      stdio: ["ignore", "pipe", "pipe"], // Ignore stdin so ripgrep doesn't wait for it
+    });
+
+    if (result.error) {
+      throw result.error;
+    }
+
+    // Status 1 = no matches (not an error for ripgrep)
+    if (result.status !== 0 && result.status !== 1) {
+      return [];
+    }
+
+    const output = result.stdout || "";
+    const matches: SearchMatch[] = [];
+    const lines = output.trim().split("\n").filter(Boolean);
+
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed.type === "match") {
+          matches.push(parsed);
+          if (matches.length >= maxResults) break;
+        }
+      } catch {
+        continue;
+      }
+    }
+
+    return matches;
+  } catch (error) {
+    console.error("Error in searchCode:", error);
+    // ENOENT = command not found
+    if ((error as any).code === "ENOENT") {
+      throw new Error(
+        "ripgrep (rg) not found. Install with: brew install ripgrep"
+      );
+    }
+    // Other errors - return empty
+    return [];
+  }
+}
+
+export function formatSearchResults(matches: SearchMatch[]): FormattedMatch[] {
+  return matches.map((match) => ({
+    file: match.data.path.text,
+    line: match.data.line_number,
+    column: match.data.submatches[0]?.start || 0,
+    matchText: match.data.submatches[0]?.match.text || "",
+    lineText: match.data.lines.text,
+  }));
+}

package/lib/db/index.ts

@@ -0,0 +1,48 @@
+import Database from "better-sqlite3";
+import path from "path";
+import os from "os";
+import { createSchema } from "./schema";
+import { runMigrations } from "./migrations";
+
+export * from "./types";
+export { queries } from "./queries";
+
+const DB_DIR = path.join(os.homedir(), ".claude-deck");
+const DB_PATH = process.env.DB_PATH || path.join(DB_DIR, "data.db");
+
+let _db: Database.Database | null = null;
+
+export function getDb(): Database.Database {
+  if (!_db) {
+    const fs = require("fs");
+    fs.mkdirSync(path.dirname(DB_PATH), { recursive: true });
+
+    _db = new Database(DB_PATH);
+    _db.pragma("journal_mode = WAL");
+    _db.pragma("foreign_keys = ON");
+    _db.pragma("busy_timeout = 5000");
+  }
+  return _db;
+}
+
+let _initialized = false;
+
+export async function initDb(): Promise<Database.Database> {
+  const db = getDb();
+
+  if (!_initialized) {
+    createSchema(db);
+    runMigrations(db);
+    _initialized = true;
+  }
+
+  return db;
+}
+
+export async function closeDb(): Promise<void> {
+  if (_db) {
+    _db.close();
+    _db = null;
+    _initialized = false;
+  }
+}