cc-sidebar 0.1.0

package/src/sync-todos.ts

@@ -0,0 +1,157 @@
+#!/usr/bin/env bun
+/**
+ * Syncs Claude Code's TodoWrite output to the sidebar
+ * Called via PostToolUse hook whenever Claude updates its todo list
+ *
+ * Two functions:
+ * 1. Sync Claude's todos to sidebar display (claude-todos.json)
+ * 2. Auto-complete sidebar queue items when Claude marks related work done
+ *
+ * Receives JSON via stdin with structure:
+ * {
+ *   "tool_name": "TodoWrite",
+ *   "tool_input": { "todos": [...] },
+ *   "tool_result": "..."
+ * }
+ */
+
+import { writeFileSync, readFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { createHash } from "crypto";
+
+const SIDEBAR_DIR = join(homedir(), ".claude-sidebar");
+
+interface TodoItem {
+  content: string;
+  status: "pending" | "in_progress" | "completed";
+}
+
+interface HookPayload {
+  tool_name: string;
+  tool_input: {
+    todos: TodoItem[];
+  };
+}
+
+interface SidebarTask {
+  id: string;
+  content: string;
+  createdAt: string;
+}
+
+interface DoneTask {
+  id: string;
+  content: string;
+  completedAt: string;
+}
+
+// Get project-specific directory using same hash as sidebar
+function getProjectDir(): string {
+  const cwd = process.cwd();
+  const hash = createHash("sha256").update(cwd).digest("hex").slice(0, 12);
+  return join(SIDEBAR_DIR, "projects", hash);
+}
+
+// Normalize text for comparison: lowercase, keep only alphanumeric, collapse whitespace
+function normalizeText(s: string): string {
+  return s.toLowerCase().replace(/[^a-z0-9]/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+// Extract significant words (length > 2) from text
+function extractWords(s: string): Set<string> {
+  return new Set(normalizeText(s).split(' ').filter(w => w.length > 2));
+}
+
+// Check if strings are similar based on word overlap (50% threshold)
+function isSimilar(a: string, b: string): boolean {
+  const wordsA = extractWords(a);
+  const wordsB = extractWords(b);
+
+  if (wordsA.size === 0 || wordsB.size === 0) return false;
+
+  let overlap = 0;
+  for (const word of wordsA) {
+    if (wordsB.has(word)) overlap++;
+  }
+
+  const minSize = Math.min(wordsA.size, wordsB.size);
+  return overlap >= minSize * 0.5;
+}
+
+// Check completed Claude todos against sidebar queue and move matches to Done
+function autoCompleteSidebarTasks(completedTodos: TodoItem[]): void {
+  const projectDir = getProjectDir();
+  const tasksPath = join(projectDir, "tasks.json");
+  const donePath = join(projectDir, "done.json");
+
+  if (!existsSync(tasksPath)) return;
+
+  try {
+    const tasks: SidebarTask[] = JSON.parse(readFileSync(tasksPath, "utf-8"));
+    const done: DoneTask[] = existsSync(donePath)
+      ? JSON.parse(readFileSync(donePath, "utf-8"))
+      : [];
+
+    const now = new Date().toISOString();
+    const remaining: SidebarTask[] = [];
+    const newDone: DoneTask[] = [];
+
+    for (const task of tasks) {
+      const matchesCompleted = completedTodos.some(todo => isSimilar(todo.content, task.content));
+      if (matchesCompleted) {
+        newDone.push({ id: task.id, content: task.content, completedAt: now });
+      } else {
+        remaining.push(task);
+      }
+    }
+
+    if (newDone.length > 0) {
+      const updatedDone = [...newDone, ...done].slice(0, 10);
+      writeFileSync(tasksPath, JSON.stringify(remaining, null, 2));
+      writeFileSync(donePath, JSON.stringify(updatedDone, null, 2));
+    }
+  } catch {
+    // Silently fail - don't interrupt Claude Code
+  }
+}
+
+async function main() {
+  // Read JSON from stdin
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  const input = Buffer.concat(chunks).toString("utf-8");
+
+  if (!input.trim()) {
+    process.exit(0);
+  }
+
+  try {
+    const payload: HookPayload = JSON.parse(input);
+
+    if (payload.tool_name === "TodoWrite" && payload.tool_input?.todos) {
+      // Ensure directory exists
+      mkdirSync(SIDEBAR_DIR, { recursive: true });
+
+      // Write todos to file for sidebar to poll
+      const todosPath = join(SIDEBAR_DIR, "claude-todos.json");
+      writeFileSync(todosPath, JSON.stringify({
+        todos: payload.tool_input.todos,
+        updatedAt: new Date().toISOString()
+      }, null, 2));
+
+      // Check for completed todos and auto-complete matching sidebar tasks
+      const completedTodos = payload.tool_input.todos.filter(t => t.status === "completed");
+      if (completedTodos.length > 0) {
+        autoCompleteSidebarTasks(completedTodos);
+      }
+    }
+  } catch (err) {
+    // Silently fail - don't interrupt Claude Code
+    console.error("sync-todos error:", err);
+  }
+}
+
+main();

package/src/terminal/iterm.ts

@@ -0,0 +1,187 @@
+/**
+ * iTerm2 integration for spawning sidebar in split pane
+ * Uses AppleScript to create native iTerm2 splits (no tmux needed)
+ */
+
+import { $ } from "bun";
+
+/**
+ * Check if we're running in iTerm2
+ */
+export function isInITerm(): boolean {
+  return process.env.TERM_PROGRAM === "iTerm.app";
+}
+
+/**
+ * Get the current session's unique ID for reference
+ */
+export async function getCurrentSessionId(): Promise<string | null> {
+  try {
+    const script = `
+      tell application "iTerm2"
+        tell current session of current tab of current window
+          return unique id
+        end tell
+      end tell
+    `;
+    const result = await $`osascript -e ${script}`.text();
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Create an iTerm2 vertical split (sidebar on right) and run command
+ * Returns the unique ID of the new session
+ */
+export async function spawnITermSidebarPane(command: string): Promise<string | null> {
+  try {
+    const escapedCommand = command.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    // Split first, then send command to the new session
+    const script = `
+      tell application "iTerm2"
+        tell current session of current tab of current window
+          set newSession to (split vertically with default profile)
+        end tell
+        tell newSession
+          write text "${escapedCommand}"
+          return unique id
+        end tell
+      end tell
+    `;
+    const result = await $`osascript -e ${script}`.text();
+    return result.trim();
+  } catch (err) {
+    console.error("Failed to spawn iTerm sidebar:", err);
+    return null;
+  }
+}
+
+/**
+ * Send text to a specific iTerm2 session by index (1-based)
+ * Session 1 is typically the first/left pane, session 2 is the right pane
+ */
+export async function sendToSession(sessionIndex: number, text: string): Promise<boolean> {
+  try {
+    const escapedText = text.replace(/"/g, '\\"');
+    const script = `
+      tell application "iTerm2"
+        tell session ${sessionIndex} of current tab of current window
+          write text "${escapedText}"
+        end tell
+      end tell
+    `;
+    await $`osascript -e ${script}`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Send text to the first session (Claude Code pane)
+ * Assumes sidebar is in session 2 and Claude is in session 1
+ */
+export async function sendToClaudePane(text: string): Promise<boolean> {
+  return sendToSession(1, text);
+}
+
+/**
+ * Get the number of sessions in the current tab
+ */
+export async function getSessionCount(): Promise<number> {
+  try {
+    const script = `
+      tell application "iTerm2"
+        return count of sessions of current tab of current window
+      end tell
+    `;
+    const result = await $`osascript -e ${script}`.text();
+    return parseInt(result.trim(), 10);
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Close a session by index
+ */
+export async function closeSession(sessionIndex: number): Promise<boolean> {
+  try {
+    const script = `
+      tell application "iTerm2"
+        tell session ${sessionIndex} of current tab of current window
+          close
+        end tell
+      end tell
+    `;
+    await $`osascript -e ${script}`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Focus a specific session by index
+ */
+export async function focusSession(sessionIndex: number): Promise<boolean> {
+  try {
+    const script = `
+      tell application "iTerm2"
+        tell session ${sessionIndex} of current tab of current window
+          select
+        end tell
+      end tell
+    `;
+    await $`osascript -e ${script}`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Capture the last N lines from Claude's pane (session 1)
+ */
+export async function captureClaudePane(lines: number = 5): Promise<string | null> {
+  try {
+    const script = `
+      tell application "iTerm2"
+        tell session 1 of current tab of current window
+          return contents
+        end tell
+      end tell
+    `;
+    const result = await $`osascript -e ${script}`.text();
+    // Get last N lines
+    const allLines = result.trim().split("\n");
+    return allLines.slice(-lines).join("\n");
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if Claude Code is at a prompt (waiting for input)
+ */
+export async function isClaudeAtPrompt(): Promise<boolean> {
+  const { checkOutputForPrompt } = await import("./prompt");
+  const output = await captureClaudePane(10);
+  if (!output) return false;
+  return checkOutputForPrompt(output);
+}
+
+/**
+ * Get environment info for debugging
+ */
+export function getITermEnvInfo(): {
+  inITerm: boolean;
+  termProgram: string;
+} {
+  return {
+    inITerm: isInITerm(),
+    termProgram: process.env.TERM_PROGRAM || "unknown",
+  };
+}

package/src/terminal/prompt.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared prompt detection logic for Claude Code terminals
+ * Used by both iTerm2 and tmux integrations
+ */
+
+/**
+ * Patterns that indicate Claude Code is waiting for input
+ */
+const PROMPT_PATTERNS = [
+  /^❯\s*$/,  // Just the prompt character with optional whitespace
+  /^>\s*$/,  // Fallback prompt character
+];
+
+/**
+ * Check if terminal output indicates Claude is at a prompt
+ * Analyzes the last few lines of output for prompt patterns
+ */
+export function checkOutputForPrompt(output: string): boolean {
+  const lines = output.trim().split("\n");
+  const linesToCheck = 5;
+
+  for (let i = lines.length - 1; i >= Math.max(0, lines.length - linesToCheck); i--) {
+    const line = lines[i] || "";
+    if (PROMPT_PATTERNS.some((pattern) => pattern.test(line))) {
+      return true;
+    }
+  }
+
+  return false;
+}

package/src/terminal/tmux.ts

@@ -0,0 +1,246 @@
+/**
+ * tmux integration for spawning sidebar in split pane
+ * Based on patterns from claude-canvas
+ */
+
+import { $ } from "bun";
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+
+const PANE_FILE = "/tmp/claude-sidebar-pane-id";
+
+/**
+ * Check if we're running inside tmux
+ */
+export function isInTmux(): boolean {
+  return !!process.env.TMUX;
+}
+
+/**
+ * Get stored pane ID from file
+ */
+function getStoredPaneId(): string | null {
+  try {
+    if (existsSync(PANE_FILE)) {
+      return readFileSync(PANE_FILE, "utf-8").trim();
+    }
+  } catch {
+    // Ignore
+  }
+  return null;
+}
+
+/**
+ * Store pane ID to file
+ */
+function storePaneId(paneId: string): void {
+  writeFileSync(PANE_FILE, paneId);
+}
+
+/**
+ * Clear stored pane ID
+ */
+function clearStoredPaneId(): void {
+  try {
+    if (existsSync(PANE_FILE)) {
+      unlinkSync(PANE_FILE);
+    }
+  } catch {
+    // Ignore
+  }
+}
+
+/**
+ * Check if a pane ID is still valid
+ */
+async function isPaneValid(paneId: string): Promise<boolean> {
+  try {
+    const result = await $`tmux display-message -t ${paneId} -p "#{pane_id}"`.text();
+    return result.trim() === paneId;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Create a new tmux pane and run command in it
+ */
+async function createNewPane(command: string): Promise<string> {
+  // Save current history-limit so we can restore it after creating the pane
+  // (history-limit is a session option, not per-pane, so we must set it before creating)
+  let originalLimit = "2000";
+  try {
+    originalLimit = (await $`tmux show-options -gv history-limit`.text()).trim();
+  } catch {}
+
+  // Set minimal history-limit (1 = minimum, 0 = unlimited!) before creating sidebar pane
+  await $`tmux set-option -g history-limit 1`.quiet();
+
+  // Create horizontal split with fixed 50 character width for sidebar
+  // -h = horizontal split (side by side)
+  // -l 50 = new pane gets 50 columns (fixed width)
+  // -d = don't switch focus to new pane
+  // -P -F "#{pane_id}" = print the new pane ID
+  const result = await $`tmux split-window -h -l 50 -d -P -F "#{pane_id}"`.text();
+  const paneId = result.trim();
+
+  // Restore original history-limit for future panes
+  await $`tmux set-option -g history-limit ${originalLimit}`.quiet();
+
+  // Store the pane ID for future reuse
+  storePaneId(paneId);
+
+  // Send the command to the new pane
+  await $`tmux send-keys -t ${paneId} ${command} Enter`.quiet();
+
+  return paneId;
+}
+
+/**
+ * Reuse an existing pane by sending a new command to it
+ */
+async function reuseExistingPane(paneId: string, command: string): Promise<void> {
+  // Send Ctrl+C to stop any running process
+  await $`tmux send-keys -t ${paneId} C-c`.quiet();
+
+  // Wait a moment for the process to stop
+  await new Promise((resolve) => setTimeout(resolve, 150));
+
+  // Clear and run the new command
+  await $`tmux send-keys -t ${paneId} "clear && ${command}" Enter`.quiet();
+}
+
+/**
+ * Spawn sidebar in a tmux pane (creates new or reuses existing)
+ */
+export async function spawnSidebarPane(command: string): Promise<string> {
+  if (!isInTmux()) {
+    throw new Error("Sidebar requires tmux. Please run inside a tmux session.");
+  }
+
+  // Check for existing pane
+  const existingPaneId = getStoredPaneId();
+
+  if (existingPaneId && (await isPaneValid(existingPaneId))) {
+    console.log(`Reusing existing sidebar pane: ${existingPaneId}`);
+    await reuseExistingPane(existingPaneId, command);
+    return existingPaneId;
+  }
+
+  // Clear stale pane reference if any
+  if (existingPaneId) {
+    console.log("Clearing stale pane reference...");
+    clearStoredPaneId();
+  }
+
+  // Create new pane
+  console.log("Creating new sidebar pane...");
+  const paneId = await createNewPane(command);
+  console.log(`Created sidebar pane: ${paneId}`);
+
+  return paneId;
+}
+
+/**
+ * Close the sidebar pane
+ */
+export async function closeSidebarPane(): Promise<void> {
+  const paneId = getStoredPaneId();
+  if (paneId && (await isPaneValid(paneId))) {
+    try {
+      await $`tmux kill-pane -t ${paneId}`.quiet();
+    } catch {
+      // Pane might already be gone
+    }
+  }
+  clearStoredPaneId();
+}
+
+/**
+ * Get environment info for debugging
+ */
+export function getEnvInfo(): {
+  inTmux: boolean;
+  term: string;
+  shell: string;
+  storedPaneId: string | null;
+} {
+  return {
+    inTmux: isInTmux(),
+    term: process.env.TERM || "unknown",
+    shell: process.env.SHELL || "unknown",
+    storedPaneId: getStoredPaneId(),
+  };
+}
+
+/**
+ * Get Claude Code's pane ID (the pane that isn't the sidebar)
+ */
+export async function getClaudePaneId(): Promise<string | null> {
+  if (!isInTmux()) return null;
+
+  const sidebarPaneId = getStoredPaneId();
+  if (!sidebarPaneId) return null;
+
+  try {
+    const panesOutput = await $`tmux list-panes -F "#{pane_id}"`.text();
+    const panes = panesOutput.trim().split("\n");
+    return panes.find((p) => p !== sidebarPaneId) || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Focus the Claude Code pane (switch tmux focus to it)
+ */
+export async function focusClaudePane(): Promise<boolean> {
+  const claudePane = await getClaudePaneId();
+  if (!claudePane) return false;
+
+  try {
+    await $`tmux select-pane -t ${claudePane}`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Send a message to the Claude Code pane (the pane that isn't the sidebar)
+ */
+export async function sendToClaudePane(message: string): Promise<boolean> {
+  const claudePane = await getClaudePaneId();
+  if (!claudePane) return false;
+
+  try {
+    await $`tmux send-keys -t ${claudePane} ${message} Enter`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Capture the last N lines of Claude's pane output
+ */
+export async function captureClaudePane(lines: number = 10): Promise<string | null> {
+  const claudePane = await getClaudePaneId();
+  if (!claudePane) return null;
+
+  try {
+    const output = await $`tmux capture-pane -t ${claudePane} -p -S -${lines}`.text();
+    return output;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if Claude Code is at an input prompt (waiting for input)
+ */
+export async function isClaudeAtPrompt(): Promise<boolean> {
+  const { checkOutputForPrompt } = await import("./prompt");
+  const output = await captureClaudePane(10);
+  if (!output) return false;
+  return checkOutputForPrompt(output);
+}