cc-sidebar 0.1.0

package/src/ipc/server.ts

@@ -0,0 +1,92 @@
+/**
+ * IPC Server for sidebar communication
+ * Uses Unix domain sockets for real-time updates
+ */
+
+import { unlinkSync, existsSync } from "fs";
+
+export interface IPCMessage {
+  type: string;
+  data?: unknown;
+}
+
+export interface IPCServerOptions {
+  socketPath: string;
+  onMessage?: (message: IPCMessage) => void;
+  onConnect?: () => void;
+  onDisconnect?: () => void;
+  onError?: (error: Error) => void;
+}
+
+export interface IPCServer {
+  broadcast: (message: IPCMessage) => void;
+  close: () => void;
+}
+
+export function createIPCServer(options: IPCServerOptions): IPCServer {
+  const { socketPath, onMessage, onConnect, onDisconnect, onError } = options;
+
+  // Clean up existing socket file
+  if (existsSync(socketPath)) {
+    try {
+      unlinkSync(socketPath);
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+
+  const clients = new Set<ReturnType<typeof Bun.listen>["data"]>();
+
+  const server = Bun.listen({
+    unix: socketPath,
+    socket: {
+      open(socket) {
+        clients.add(socket);
+        onConnect?.();
+      },
+      close(socket) {
+        clients.delete(socket);
+        onDisconnect?.();
+      },
+      data(socket, data) {
+        try {
+          const text = Buffer.from(data).toString("utf-8");
+          // Handle line-delimited JSON
+          const lines = text.split("\n").filter((line) => line.trim());
+          for (const line of lines) {
+            const message = JSON.parse(line) as IPCMessage;
+            onMessage?.(message);
+          }
+        } catch (err) {
+          onError?.(err instanceof Error ? err : new Error(String(err)));
+        }
+      },
+      error(socket, error) {
+        onError?.(error);
+      },
+    },
+  });
+
+  return {
+    broadcast(message: IPCMessage) {
+      const data = JSON.stringify(message) + "\n";
+      for (const client of clients) {
+        try {
+          (client as { write: (data: string) => void }).write(data);
+        } catch {
+          // Client may have disconnected
+        }
+      }
+    },
+    close() {
+      server.stop();
+      if (existsSync(socketPath)) {
+        try {
+          unlinkSync(socketPath);
+        } catch {
+          // Ignore cleanup errors
+        }
+      }
+    },
+  };
+}

package/src/minimal-test.ts

@@ -0,0 +1,45 @@
+#!/usr/bin/env bun
+/**
+ * Minimal terminal input test - absolutely no rendering during input
+ */
+
+// Hide cursor and clear screen once
+process.stdout.write('\x1b[?25l\x1b[2J\x1b[H');
+process.stdout.write('Type something (press Enter to echo, Escape to quit):\n> ');
+process.stdout.write('\x1b[?25h'); // Show cursor
+
+let buffer = '';
+
+process.stdin.setRawMode(true);
+process.stdin.resume();
+process.stdin.setEncoding('utf8');
+
+process.stdin.on('data', (key: string) => {
+  // Escape - quit
+  if (key === '\x1b') {
+    process.stdout.write('\n\x1b[?25h\x1b[0m');
+    process.exit(0);
+  }
+
+  // Enter - echo and reset
+  if (key === '\r' || key === '\n') {
+    process.stdout.write(`\nYou typed: ${buffer}\n> `);
+    buffer = '';
+    return;
+  }
+
+  // Backspace
+  if (key === '\x7f') {
+    if (buffer.length > 0) {
+      buffer = buffer.slice(0, -1);
+      process.stdout.write('\b \b');
+    }
+    return;
+  }
+
+  // Regular character - just echo it
+  if (key.length === 1 && key.charCodeAt(0) >= 32) {
+    buffer += key;
+    process.stdout.write(key);
+  }
+});

package/src/node-test.mjs

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+/**
+ * Node.js minimal terminal input test
+ * Testing if the flicker is Bun-specific
+ */
+
+import * as readline from 'readline';
+
+// Clear screen and show prompt
+process.stdout.write('\x1b[2J\x1b[H');
+process.stdout.write('Node.js test - Type something (Enter to echo, Escape to quit):\n> ');
+
+readline.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY) {
+  process.stdin.setRawMode(true);
+}
+
+let buffer = '';
+
+process.stdin.on('keypress', (str, key) => {
+  // Escape or Ctrl+C - quit
+  if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
+    process.stdout.write('\n');
+    process.exit(0);
+  }
+
+  // Enter - echo and reset
+  if (key.name === 'return') {
+    process.stdout.write(`\nYou typed: ${buffer}\n> `);
+    buffer = '';
+    return;
+  }
+
+  // Backspace
+  if (key.name === 'backspace') {
+    if (buffer.length > 0) {
+      buffer = buffer.slice(0, -1);
+      process.stdout.write('\b \b');
+    }
+    return;
+  }
+
+  // Regular character
+  if (str && str.length === 1 && str.charCodeAt(0) >= 32) {
+    buffer += str;
+    process.stdout.write(str);
+  }
+});
+
+process.stdin.resume();

package/src/persistence/store.ts

@@ -0,0 +1,346 @@
+/**
+ * Persistence layer for sidebar data
+ * Stores tasks (queue), active task, and history per-project in ~/.claude-sidebar/projects/<hash>/
+ * Global data (statusline, socket) stored in ~/.claude-sidebar/
+ */
+
+import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync } from "fs";
+import { createHash } from "crypto";
+import { homedir } from "os";
+import { join } from "path";
+
+const SIDEBAR_DIR = join(homedir(), ".claude-sidebar");
+
+// Get a short hash of the working directory for project isolation
+function getProjectHash(): string {
+  const cwd = process.cwd();
+  return createHash("sha256").update(cwd).digest("hex").slice(0, 12);
+}
+
+// Get the project-specific directory
+function getProjectDir(): string {
+  return join(SIDEBAR_DIR, "projects", getProjectHash());
+}
+
+// Store a mapping of hash -> path for easier debugging
+function updateProjectMapping(): void {
+  const mappingPath = join(SIDEBAR_DIR, "projects", "mapping.json");
+  let mapping: Record<string, string> = {};
+  try {
+    if (existsSync(mappingPath)) {
+      mapping = JSON.parse(readFileSync(mappingPath, "utf-8"));
+    }
+  } catch {}
+  mapping[getProjectHash()] = process.cwd();
+  ensureDir();
+  mkdirSync(join(SIDEBAR_DIR, "projects"), { recursive: true });
+  writeFileSync(mappingPath, JSON.stringify(mapping, null, 2));
+}
+
+export interface Task {
+  id: string;
+  content: string;
+  createdAt: string;
+  clarified?: boolean;      // Was this task clarified via interview/brain-dump?
+  priority?: number;        // Sort order (lower = higher priority, 1 = most important)
+  recommended?: boolean;    // Claude's top picks (shown with star)
+  planPath?: string;        // Filename of associated Atomic Plan
+}
+
+export interface ActiveTask {
+  id: string;
+  content: string;
+  sentAt: string;
+}
+
+export interface DoneTask {
+  id: string;
+  content: string;
+  completedAt: string;
+}
+
+export interface StatuslineData {
+  contextPercent: number;
+  contextTokens: number;
+  contextSize: number;
+  costUsd: number;
+  durationMin: number;
+  model: string;
+  branch: string;
+  repo: string;
+  updatedAt: string;
+}
+
+export interface ClaudeConfig {
+  enabledPlugins: string[];
+  mcpServers: string[];
+}
+
+export interface ClaudeTodo {
+  content: string;
+  status: "pending" | "in_progress" | "completed";
+}
+
+export interface ClaudeTodosData {
+  todos: ClaudeTodo[];
+  updatedAt: string;
+}
+
+// Get the data directory path
+export function getDataDir(): string {
+  return SIDEBAR_DIR;
+}
+
+// Ensure the sidebar directory exists
+export function ensureDir(): void {
+  if (!existsSync(SIDEBAR_DIR)) {
+    mkdirSync(SIDEBAR_DIR, { recursive: true });
+  }
+}
+
+// Generic read/write helpers for GLOBAL data
+function readJson<T>(filename: string, defaultValue: T): T {
+  const filepath = join(SIDEBAR_DIR, filename);
+  try {
+    if (existsSync(filepath)) {
+      return JSON.parse(readFileSync(filepath, "utf-8"));
+    }
+  } catch {
+    // Return default on error
+  }
+  return defaultValue;
+}
+
+function writeJson<T>(filename: string, data: T): void {
+  ensureDir();
+  const filepath = join(SIDEBAR_DIR, filename);
+  writeFileSync(filepath, JSON.stringify(data, null, 2));
+}
+
+// Read/write helpers for PROJECT-SPECIFIC data
+function readProjectJson<T>(filename: string, defaultValue: T): T {
+  const projectDir = getProjectDir();
+  const filepath = join(projectDir, filename);
+  try {
+    if (existsSync(filepath)) {
+      return JSON.parse(readFileSync(filepath, "utf-8"));
+    }
+  } catch {
+    // Return default on error
+  }
+  return defaultValue;
+}
+
+function writeProjectJson<T>(filename: string, data: T): void {
+  const projectDir = getProjectDir();
+  mkdirSync(projectDir, { recursive: true });
+  updateProjectMapping();
+  const filepath = join(projectDir, filename);
+  writeFileSync(filepath, JSON.stringify(data, null, 2));
+}
+
+// Tasks (user's task queue) - PROJECT SPECIFIC
+export function getTasks(): Task[] {
+  return readProjectJson<Task[]>("tasks.json", []);
+}
+
+export function setTasks(tasks: Task[]): void {
+  writeProjectJson("tasks.json", tasks);
+}
+
+export function addTask(
+  content: string,
+  options?: {
+    clarified?: boolean;
+    priority?: number;
+    recommended?: boolean;
+    planPath?: string;
+  }
+): Task {
+  const tasks = getTasks();
+  const task: Task = {
+    id: crypto.randomUUID(),
+    content,
+    createdAt: new Date().toISOString(),
+    clarified: options?.clarified,
+    priority: options?.priority,
+    recommended: options?.recommended,
+    planPath: options?.planPath,
+  };
+  tasks.push(task);
+  setTasks(tasks);
+  return task;
+}
+
+export function updateTask(id: string, content: string): void {
+  const tasks = getTasks();
+  const task = tasks.find((t) => t.id === id);
+  if (task) {
+    task.content = content;
+    setTasks(tasks);
+  }
+}
+
+export function markTaskClarified(id: string): void {
+  const tasks = getTasks();
+  const task = tasks.find((t) => t.id === id);
+  if (task) {
+    task.clarified = true;
+    setTasks(tasks);
+  }
+}
+
+export function removeTask(id: string): void {
+  const tasks = getTasks().filter((t) => t.id !== id);
+  setTasks(tasks);
+}
+
+// Active task (currently being worked on by Claude) - PROJECT SPECIFIC
+export function getActiveTask(): ActiveTask | null {
+  return readProjectJson<ActiveTask | null>("active.json", null);
+}
+
+// Statusline data (from Claude Code)
+export function getStatusline(): StatuslineData | null {
+  return readJson<StatuslineData | null>("statusline.json", null);
+}
+
+// Claude's todo list (from TodoWrite hook)
+export function getClaudeTodos(): ClaudeTodosData | null {
+  return readJson<ClaudeTodosData | null>("claude-todos.json", null);
+}
+
+// Claude Code config (plugins and MCPs)
+export function getClaudeConfig(): ClaudeConfig {
+  const claudeSettingsPath = join(homedir(), ".claude", "settings.json");
+  const defaultConfig: ClaudeConfig = { enabledPlugins: [], mcpServers: [] };
+
+  try {
+    if (existsSync(claudeSettingsPath)) {
+      const settings = JSON.parse(readFileSync(claudeSettingsPath, "utf-8"));
+
+      // Extract enabled plugins (keys where value is true)
+      const enabledPlugins: string[] = settings.enabledPlugins
+        ? Object.entries(settings.enabledPlugins)
+            .filter(([_, enabled]) => enabled === true)
+            .map(([name]) => name.split("@")[0] || name)
+        : [];
+
+      // Extract MCP server names
+      const mcpServers: string[] = settings.mcpServers
+        ? Object.keys(settings.mcpServers)
+        : [];
+
+      return { enabledPlugins, mcpServers };
+    }
+  } catch {
+    // Return default on error
+  }
+  return defaultConfig;
+}
+
+export function setActiveTask(task: Task | null): void {
+  if (task) {
+    writeProjectJson("active.json", {
+      id: task.id,
+      content: task.content,
+      sentAt: new Date().toISOString(),
+    });
+  } else {
+    writeProjectJson("active.json", null);
+  }
+}
+
+export function clearActiveTask(): void {
+  writeProjectJson("active.json", null);
+}
+
+// History (completed tasks - append-only log) - PROJECT SPECIFIC
+export function appendToHistory(content: string): void {
+  const projectDir = getProjectDir();
+  mkdirSync(projectDir, { recursive: true });
+  const filepath = join(projectDir, "history.log");
+  const timestamp = new Date().toISOString();
+  const entry = `${timestamp} | ${content}\n`;
+  appendFileSync(filepath, entry);
+}
+
+// Move task from queue to active - PROJECT SPECIFIC
+export function activateTask(taskId: string): ActiveTask | null {
+  const tasks = getTasks();
+  const taskIndex = tasks.findIndex((t) => t.id === taskId);
+  const task = tasks[taskIndex];
+
+  if (taskIndex === -1 || !task) return null;
+
+  // Remove from queue
+  tasks.splice(taskIndex, 1);
+  setTasks(tasks);
+
+  // Set as active
+  const activeTask: ActiveTask = {
+    id: task.id,
+    content: task.content,
+    sentAt: new Date().toISOString(),
+  };
+  writeProjectJson("active.json", activeTask);
+
+  return activeTask;
+}
+
+// Recently done tasks - PROJECT SPECIFIC
+export function getRecentlyDone(): DoneTask[] {
+  return readProjectJson<DoneTask[]>("done.json", []);
+}
+
+export function addToDone(task: { id: string; content: string }): void {
+  const done = getRecentlyDone();
+  const doneTask: DoneTask = {
+    id: task.id,
+    content: task.content,
+    completedAt: new Date().toISOString(),
+  };
+  // Keep only last 10 done tasks
+  done.unshift(doneTask);
+  if (done.length > 10) done.pop();
+  writeProjectJson("done.json", done);
+}
+
+export function removeFromDone(id: string): void {
+  const done = getRecentlyDone().filter((t) => t.id !== id);
+  writeProjectJson("done.json", done);
+}
+
+// Return a done task back to active (user says "not done yet")
+export function returnToActive(id: string): void {
+  const done = getRecentlyDone();
+  const task = done.find((t) => t.id === id);
+  if (task) {
+    // Remove from done
+    writeProjectJson("done.json", done.filter((t) => t.id !== id));
+    // Set as active
+    writeProjectJson("active.json", {
+      id: task.id,
+      content: task.content,
+      sentAt: new Date().toISOString(),
+    });
+  }
+}
+
+// Complete active task (move to done list and history)
+export function completeActiveTask(): void {
+  const active = getActiveTask();
+  if (active) {
+    addToDone(active);
+    appendToHistory(active.content);
+    clearActiveTask();
+  }
+}
+
+// Socket path for IPC
+export function getSocketPath(): string {
+  return join(SIDEBAR_DIR, "sidebar.sock");
+}
+
+// Export the directory path
+export { SIDEBAR_DIR };

package/src/standalone-input.ts

@@ -0,0 +1,101 @@
+#!/usr/bin/env bun
+/**
+ * Standalone input test - completely isolated from sidebar code
+ * Tests if basic terminal input causes flicker
+ */
+
+const CSI = '\x1b[';
+
+// Clear screen, draw a simple UI
+process.stdout.write(`${CSI}2J${CSI}H`);
+process.stdout.write(`${CSI}?25l`); // Hide cursor initially
+
+// Draw simple box
+const width = process.stdout.columns || 50;
+const height = process.stdout.rows || 20;
+
+function drawUI(inputText: string = '', inputMode: boolean = false) {
+  let output = `${CSI}?2026h`; // Begin sync
+  output += `${CSI}H`; // Home
+
+  output += `  Simple Input Test\n`;
+  output += `  ─────────────────\n`;
+  output += `\n`;
+  output += `  Status: ${inputMode ? 'INPUT MODE' : 'Normal'}\n`;
+  output += `\n`;
+  output += `  Text: [${inputText}]${' '.repeat(Math.max(0, width - inputText.length - 12))}\n`;
+  output += `\n`;
+  output += `  Press 'i' to enter input mode\n`;
+  output += `  Press 'Esc' to exit input mode or quit\n`;
+
+  if (inputMode) {
+    output += `${CSI}?25h`; // Show cursor
+  } else {
+    output += `${CSI}?25l`; // Hide cursor
+  }
+
+  output += `${CSI}?2026l`; // End sync
+  process.stdout.write(output);
+}
+
+// Initial draw
+drawUI();
+
+// Setup input
+process.stdin.setRawMode(true);
+process.stdin.resume();
+
+let inputMode = false;
+let inputBuffer = '';
+
+process.stdin.on('data', (data) => {
+  const key = data.toString();
+
+  if (inputMode) {
+    // In input mode
+    if (key === '\x1b') {
+      // Escape - exit input mode
+      inputMode = false;
+      drawUI(inputBuffer, false);
+      return;
+    }
+
+    if (key === '\r' || key === '\n') {
+      // Enter - submit
+      inputMode = false;
+      drawUI(inputBuffer, false);
+      return;
+    }
+
+    if (key === '\x7f') {
+      // Backspace
+      if (inputBuffer.length > 0) {
+        inputBuffer = inputBuffer.slice(0, -1);
+        // Just update the text line, not full redraw
+        process.stdout.write(`${CSI}?2026h${CSI}6;10H[${inputBuffer}]${' '.repeat(20)}${CSI}?2026l`);
+      }
+      return;
+    }
+
+    // Regular char
+    if (key.length === 1 && key.charCodeAt(0) >= 32 && key.charCodeAt(0) < 127) {
+      inputBuffer += key;
+      // Just update the text line
+      process.stdout.write(`${CSI}?2026h${CSI}6;10H[${inputBuffer}]${CSI}?2026l`);
+    }
+  } else {
+    // Normal mode
+    if (key === '\x1b') {
+      // Escape - quit
+      process.stdout.write(`${CSI}?25h${CSI}0m${CSI}2J${CSI}H`);
+      process.exit(0);
+    }
+
+    if (key === 'i') {
+      // Enter input mode
+      inputMode = true;
+      inputBuffer = '';
+      drawUI('', true);
+    }
+  }
+});