@aladac/hu 0.1.0-a1 → 0.1.0-a2

package/src/lib/hook-io.ts

@@ -0,0 +1,128 @@
+/**
+ * Hook I/O utilities for safe data exchange with Claude Code hooks
+ * Uses temp files to avoid shell escaping issues
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import { getConfig } from './config.ts';
+
+/**
+ * Generate a unique temp file path for hook data
+ */
+function getTempPath(prefix: string = 'hu-hook'): string {
+  const config = getConfig();
+  const uuid = crypto.randomUUID();
+  return path.join(config.hooks.temp_dir, `${prefix}-${uuid}.json`);
+}
+
+/**
+ * Write data to a temp file as JSON
+ * Returns the path to the created file
+ */
+export function writeTempJson(data: unknown, prefix?: string): string {
+  const filePath = getTempPath(prefix);
+  const content = JSON.stringify(data, null, 2);
+  fs.writeFileSync(filePath, content, 'utf-8');
+  return filePath;
+}
+
+/**
+ * Read and parse JSON from a temp file
+ */
+export function readTempJson<T = unknown>(filePath: string): T {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  return JSON.parse(content) as T;
+}
+
+/**
+ * Delete a temp file
+ */
+export function deleteTempFile(filePath: string): void {
+  try {
+    fs.unlinkSync(filePath);
+  } catch {
+    // Ignore if file doesn't exist
+  }
+}
+
+/**
+ * Clean up old temp files based on TTL from config
+ */
+export function cleanupTempFiles(): number {
+  const config = getConfig();
+  const tempDir = config.hooks.temp_dir;
+  const ttlMs = config.hooks.temp_file_ttl * 1000;
+  const cutoff = Date.now() - ttlMs;
+  
+  if (!fs.existsSync(tempDir)) {
+    return 0;
+  }
+
+  let cleaned = 0;
+  const files = fs.readdirSync(tempDir);
+  
+  for (const file of files) {
+    if (!file.startsWith('hu-hook-') || !file.endsWith('.json')) {
+      continue;
+    }
+    
+    const filePath = path.join(tempDir, file);
+    
+    try {
+      const stat = fs.statSync(filePath);
+      if (stat.mtimeMs < cutoff) {
+        fs.unlinkSync(filePath);
+        cleaned++;
+      }
+    } catch {
+      // Ignore errors for individual files
+    }
+  }
+  
+  return cleaned;
+}
+
+/**
+ * Read hook input from stdin and write to temp file
+ * Returns the path to the temp file
+ */
+export async function readStdinToTemp(): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on('end', () => {
+      try {
+        const filePath = writeTempJson(JSON.parse(data), 'hu-stdin');
+        resolve(filePath);
+      } catch (err) {
+        reject(err);
+      }
+    });
+    process.stdin.on('error', reject);
+  });
+}
+
+/**
+ * Write hook response to stdout
+ */
+export function writeHookResponse(response: {
+  additionalContext?: string;
+  userMessage?: string;
+  continueSession?: boolean;
+}): void {
+  console.log(JSON.stringify(response));
+}
+
+/**
+ * Check if hooks are enabled in config
+ */
+export function hooksEnabled(): boolean {
+  const config = getConfig();
+  return config.hooks.enabled;
+}

package/src/lib/jsonl.ts

@@ -0,0 +1,95 @@
+/**
+ * JSONL parser for Claude Code data files
+ */
+
+import * as fs from 'node:fs';
+import * as readline from 'node:readline';
+
+/**
+ * Parse a JSONL file line by line (generator)
+ * Skips malformed lines with a warning
+ */
+export async function* parseJsonl<T = unknown>(filePath: string): AsyncGenerator<T> {
+  if (!fs.existsSync(filePath)) {
+    return;
+  }
+
+  const fileStream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+  const rl = readline.createInterface({
+    input: fileStream,
+    crlfDelay: Infinity,
+  });
+
+  let lineNum = 0;
+  for await (const line of rl) {
+    lineNum++;
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue; // Skip empty lines
+    }
+
+    try {
+      yield JSON.parse(trimmed) as T;
+    } catch (error) {
+      // Skip malformed lines, log warning
+      console.warn(`Warning: Malformed JSON at ${filePath}:${lineNum}`);
+    }
+  }
+}
+
+/**
+ * Read entire JSONL file into array
+ * Skips malformed lines with a warning
+ */
+export async function readJsonlFile<T = unknown>(filePath: string): Promise<T[]> {
+  const results: T[] = [];
+  for await (const item of parseJsonl<T>(filePath)) {
+    results.push(item);
+  }
+  return results;
+}
+
+/**
+ * Synchronous JSONL parser for smaller files
+ * Skips malformed lines with a warning
+ */
+export function readJsonlFileSync<T = unknown>(filePath: string): T[] {
+  if (!fs.existsSync(filePath)) {
+    return [];
+  }
+
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const lines = content.split('\n');
+  const results: T[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line) {
+      continue;
+    }
+
+    try {
+      results.push(JSON.parse(line) as T);
+    } catch (error) {
+      console.warn(`Warning: Malformed JSON at ${filePath}:${i + 1}`);
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Append a single item to a JSONL file
+ */
+export function appendToJsonl<T>(filePath: string, item: T): void {
+  const line = JSON.stringify(item) + '\n';
+  fs.appendFileSync(filePath, line, 'utf-8');
+}
+
+/**
+ * Write array to JSONL file
+ */
+export function writeJsonlFile<T>(filePath: string, items: T[]): void {
+  const content = items.map(item => JSON.stringify(item)).join('\n') + '\n';
+  fs.writeFileSync(filePath, content, 'utf-8');
+}

package/src/lib/schema.ts

@@ -0,0 +1,164 @@
+/**
+ * Database schema and migrations for hu
+ */
+
+import type { Database as DatabaseType } from 'better-sqlite3';
+
+interface Migration {
+  version: number;
+  up: (db: DatabaseType) => void;
+}
+
+const migrations: Migration[] = [
+  {
+    version: 1,
+    up: (db) => {
+      // Schema version tracking
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS schema_version (
+          version INTEGER PRIMARY KEY,
+          applied_at INTEGER NOT NULL
+        );
+      `);
+
+      // Sessions index
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS sessions (
+          id TEXT PRIMARY KEY,
+          project TEXT NOT NULL,
+          display TEXT,
+          started_at INTEGER NOT NULL,
+          message_count INTEGER DEFAULT 0,
+          total_cost_usd REAL DEFAULT 0
+        );
+        CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project);
+        CREATE INDEX IF NOT EXISTS idx_sessions_started_at ON sessions(started_at);
+      `);
+
+      // Messages with threading
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS messages (
+          id TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          parent_id TEXT,
+          role TEXT NOT NULL,
+          content TEXT,
+          model TEXT,
+          input_tokens INTEGER,
+          output_tokens INTEGER,
+          cost_usd REAL,
+          duration_ms INTEGER,
+          created_at INTEGER NOT NULL,
+          FOREIGN KEY (session_id) REFERENCES sessions(id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
+        CREATE INDEX IF NOT EXISTS idx_messages_created ON messages(created_at);
+      `);
+
+      // Full-text search on message content
+      db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+          content,
+          content=messages,
+          content_rowid=rowid
+        );
+      `);
+
+      // Triggers to keep FTS in sync
+      db.exec(`
+        CREATE TRIGGER IF NOT EXISTS messages_ai AFTER INSERT ON messages BEGIN
+          INSERT INTO messages_fts(rowid, content) VALUES (NEW.rowid, NEW.content);
+        END;
+        
+        CREATE TRIGGER IF NOT EXISTS messages_ad AFTER DELETE ON messages BEGIN
+          INSERT INTO messages_fts(messages_fts, rowid, content) VALUES('delete', OLD.rowid, OLD.content);
+        END;
+        
+        CREATE TRIGGER IF NOT EXISTS messages_au AFTER UPDATE ON messages BEGIN
+          INSERT INTO messages_fts(messages_fts, rowid, content) VALUES('delete', OLD.rowid, OLD.content);
+          INSERT INTO messages_fts(rowid, content) VALUES (NEW.rowid, NEW.content);
+        END;
+      `);
+
+      // Todos with status
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS todos (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id TEXT NOT NULL,
+          content TEXT NOT NULL,
+          status TEXT NOT NULL DEFAULT 'pending',
+          active_form TEXT,
+          FOREIGN KEY (session_id) REFERENCES sessions(id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_todos_session ON todos(session_id);
+        CREATE INDEX IF NOT EXISTS idx_todos_status ON todos(status);
+      `);
+
+      // Tool usage tracking
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS tool_usage (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id TEXT NOT NULL,
+          message_id TEXT,
+          tool_name TEXT NOT NULL,
+          input_json TEXT,
+          output_json TEXT,
+          duration_ms INTEGER,
+          created_at INTEGER NOT NULL,
+          FOREIGN KEY (session_id) REFERENCES sessions(id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_tool_usage_session ON tool_usage(session_id);
+        CREATE INDEX IF NOT EXISTS idx_tool_usage_tool ON tool_usage(tool_name);
+      `);
+
+      // Sync tracking
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS sync_state (
+          source TEXT PRIMARY KEY,
+          last_sync_at INTEGER NOT NULL,
+          last_modified_at INTEGER,
+          checksum TEXT
+        );
+      `);
+    },
+  },
+];
+
+/**
+ * Get current schema version
+ */
+export function getSchemaVersion(db: DatabaseType): number {
+  try {
+    const row = db.prepare('SELECT MAX(version) as version FROM schema_version').get() as { version: number | null } | undefined;
+    return row?.version ?? 0;
+  } catch {
+    // Table doesn't exist yet
+    return 0;
+  }
+}
+
+/**
+ * Run pending migrations
+ */
+export function runMigrations(db: DatabaseType): void {
+  const currentVersion = getSchemaVersion(db);
+
+  for (const migration of migrations) {
+    if (migration.version > currentVersion) {
+      db.transaction(() => {
+        migration.up(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(
+          migration.version,
+          Date.now()
+        );
+      })();
+    }
+  }
+}
+
+/**
+ * Initialize database with schema
+ */
+export function initializeSchema(db: DatabaseType): void {
+  runMigrations(db);
+}

package/src/lib/sync.ts

@@ -0,0 +1,300 @@
+/**
+ * Sync Claude Code data files to SQLite database
+ */
+
+import type { Database as DatabaseType } from 'better-sqlite3';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import {
+  getHistoryPath,
+  getProjectsDir,
+  getTodosDir,
+  listProjects,
+  listSessionsInProject,
+  decodeProjectPath,
+} from './claude-paths.ts';
+import { readJsonlFileSync } from './jsonl.ts';
+import { getConfig } from './config.ts';
+
+// Types for Claude Code data structures
+interface HistoryEntry {
+  display: string;
+  timestamp: number;
+  project: string;
+  sessionId: string;
+}
+
+interface MessageEntry {
+  uuid: string;
+  parentUuid?: string;
+  sessionId?: string;
+  type: 'user' | 'assistant' | 'summary' | 'file-history-snapshot' | 'queue-operation';
+  timestamp?: string;
+  message?: {
+    role: string;
+    content: string | Array<{ type: string; [key: string]: unknown }>;
+    model?: string;
+    usage?: {
+      input_tokens?: number;
+      output_tokens?: number;
+    };
+  };
+  costUSD?: number;
+  durationMs?: number;
+}
+
+interface TodoEntry {
+  content: string;
+  status: 'pending' | 'in_progress' | 'completed';
+  activeForm?: string;
+}
+
+/**
+ * Get last sync time for a source
+ */
+export function getLastSyncTime(db: DatabaseType, source: string): number {
+  const row = db.prepare('SELECT last_sync_at FROM sync_state WHERE source = ?').get(source) as { last_sync_at: number } | undefined;
+  return row?.last_sync_at ?? 0;
+}
+
+/**
+ * Update sync state for a source
+ */
+export function updateSyncState(db: DatabaseType, source: string, lastModified?: number): void {
+  db.prepare(`
+    INSERT OR REPLACE INTO sync_state (source, last_sync_at, last_modified_at)
+    VALUES (?, ?, ?)
+  `).run(source, Date.now(), lastModified ?? null);
+}
+
+/**
+ * Check if auto-sync is needed based on config interval
+ */
+export function needsSync(db: DatabaseType, source: string): boolean {
+  const config = getConfig();
+  const interval = config.sync.auto_sync_interval * 1000; // Convert to ms
+  
+  if (interval === 0) {
+    return false; // Manual sync only
+  }
+
+  const lastSync = getLastSyncTime(db, source);
+  return Date.now() - lastSync > interval;
+}
+
+/**
+ * Sync history.jsonl to sessions table
+ */
+export function syncHistory(db: DatabaseType): number {
+  const historyPath = getHistoryPath();
+  
+  if (!fs.existsSync(historyPath)) {
+    return 0;
+  }
+
+  const entries = readJsonlFileSync<HistoryEntry>(historyPath);
+  let count = 0;
+
+  const insertSession = db.prepare(`
+    INSERT OR IGNORE INTO sessions (id, project, display, started_at)
+    VALUES (?, ?, ?, ?)
+  `);
+
+  const transaction = db.transaction(() => {
+    for (const entry of entries) {
+      const result = insertSession.run(
+        entry.sessionId,
+        entry.project,
+        entry.display,
+        entry.timestamp
+      );
+      if (result.changes > 0) {
+        count++;
+      }
+    }
+  });
+
+  transaction();
+  updateSyncState(db, 'history');
+  
+  return count;
+}
+
+/**
+ * Sync session transcripts from projects directory
+ */
+export function syncSessions(db: DatabaseType): number {
+  const projects = listProjects();
+  let totalMessages = 0;
+
+  const insertMessage = db.prepare(`
+    INSERT OR IGNORE INTO messages (
+      id, session_id, parent_id, role, content, model,
+      input_tokens, output_tokens, cost_usd, duration_ms, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+
+  const updateSessionStats = db.prepare(`
+    UPDATE sessions SET 
+      message_count = (SELECT COUNT(*) FROM messages WHERE session_id = ?),
+      total_cost_usd = (SELECT COALESCE(SUM(cost_usd), 0) FROM messages WHERE session_id = ?)
+    WHERE id = ?
+  `);
+
+  const insertToolUsage = db.prepare(`
+    INSERT OR IGNORE INTO tool_usage (
+      session_id, message_id, tool_name, input_json, created_at
+    ) VALUES (?, ?, ?, ?, ?)
+  `);
+
+  for (const project of projects) {
+    const sessionIds = listSessionsInProject(project.dir);
+
+    for (const sessionId of sessionIds) {
+      const sessionPath = path.join(project.dir, `${sessionId}.jsonl`);
+      const messages = readJsonlFileSync<MessageEntry>(sessionPath);
+
+      const transaction = db.transaction(() => {
+        // Ensure session exists
+        db.prepare(`
+          INSERT OR IGNORE INTO sessions (id, project, started_at)
+          VALUES (?, ?, ?)
+        `).run(sessionId, project.path, Date.now());
+
+        for (const msg of messages) {
+          // Skip entries without message property (summaries, file-history-snapshot, queue-operation)
+          if (!msg.message || !msg.timestamp) {
+            continue;
+          }
+
+          // Extract content as string
+          let content: string;
+          if (typeof msg.message.content === 'string') {
+            content = msg.message.content;
+          } else {
+            content = JSON.stringify(msg.message.content);
+          }
+
+          // Use the session ID from the file name, not from the message
+          // (msg.sessionId might reference a different session that doesn't exist)
+          const effectiveSessionId = sessionId;
+
+          const result = insertMessage.run(
+            msg.uuid,
+            effectiveSessionId,
+            msg.parentUuid || null,
+            msg.message.role,
+            content,
+            msg.message.model || null,
+            msg.message.usage?.input_tokens || null,
+            msg.message.usage?.output_tokens || null,
+            msg.costUSD || null,
+            msg.durationMs || null,
+            new Date(msg.timestamp).getTime()
+          );
+
+          if (result.changes > 0) {
+            totalMessages++;
+          }
+
+          // Extract tool usage from assistant messages
+          if (msg.message.role === 'assistant' && Array.isArray(msg.message.content)) {
+            for (const block of msg.message.content) {
+              if (block.type === 'tool_use') {
+                insertToolUsage.run(
+                  effectiveSessionId,
+                  msg.uuid,
+                  (block as { name?: string }).name || 'unknown',
+                  JSON.stringify((block as { input?: unknown }).input || {}),
+                  new Date(msg.timestamp).getTime()
+                );
+              }
+            }
+          }
+        }
+
+        // Update session stats
+        updateSessionStats.run(sessionId, sessionId, sessionId);
+      });
+
+      transaction();
+    }
+  }
+
+  updateSyncState(db, 'sessions');
+  return totalMessages;
+}
+
+/**
+ * Sync todos from todos directory
+ */
+export function syncTodos(db: DatabaseType): number {
+  const todosDir = getTodosDir();
+  
+  if (!fs.existsSync(todosDir)) {
+    return 0;
+  }
+
+  const todoFiles = fs.readdirSync(todosDir).filter(f => f.endsWith('.json'));
+  let count = 0;
+
+  const deleteTodos = db.prepare('DELETE FROM todos WHERE session_id = ?');
+  const insertTodo = db.prepare(`
+    INSERT INTO todos (session_id, content, status, active_form)
+    VALUES (?, ?, ?, ?)
+  `);
+
+  const transaction = db.transaction(() => {
+    for (const file of todoFiles) {
+      const sessionId = file.replace('.json', '');
+      const filePath = path.join(todosDir, file);
+      
+      try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const todos = JSON.parse(content) as TodoEntry[];
+
+        // Clear existing todos for this session
+        deleteTodos.run(sessionId);
+
+        for (const todo of todos) {
+          insertTodo.run(
+            sessionId,
+            todo.content,
+            todo.status,
+            todo.activeForm || null
+          );
+          count++;
+        }
+      } catch (error) {
+        console.warn(`Warning: Failed to parse todos file ${filePath}`);
+      }
+    }
+  });
+
+  transaction();
+  updateSyncState(db, 'todos');
+  
+  return count;
+}
+
+/**
+ * Run full sync of all data sources
+ */
+export function syncAll(db: DatabaseType): { history: number; messages: number; todos: number } {
+  const history = syncHistory(db);
+  const messages = syncSessions(db);
+  const todos = syncTodos(db);
+  
+  return { history, messages, todos };
+}
+
+/**
+ * Run sync if needed (based on config interval)
+ */
+export function syncIfNeeded(db: DatabaseType): boolean {
+  if (needsSync(db, 'history') || needsSync(db, 'sessions') || needsSync(db, 'todos')) {
+    syncAll(db);
+    return true;
+  }
+  return false;
+}