@tekmidian/pai 0.3.2 → 0.4.0

package/src/hooks/ts/post-tool-use/capture-tool-output.ts

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+/**
+ * PostToolUse Hook - Captures tool outputs for UOCS
+ *
+ * Automatically logs all tool executions to daily JSONL files
+ * for later processing and analysis.
+ */
+
+import { appendFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { PAI_DIR, HISTORY_DIR } from '../lib/pai-paths';
+
+interface ToolUseData {
+  tool_name: string;
+  tool_input: Record<string, any>;
+  tool_response: Record<string, any>;
+  conversation_id: string;
+  timestamp: string;
+}
+
+// Configuration
+const CAPTURE_DIR = join(HISTORY_DIR, 'raw-outputs');
+const INTERESTING_TOOLS = ['Bash', 'Edit', 'Write', 'Read', 'Task', 'NotebookEdit'];
+
+async function main() {
+  try {
+    // Read input 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 || input.trim() === '') {
+      process.exit(0);
+    }
+
+    const data: ToolUseData = JSON.parse(input);
+
+    // Only capture interesting tools
+    if (!INTERESTING_TOOLS.includes(data.tool_name)) {
+      process.exit(0);
+    }
+
+    // Get today's date for organization
+    const now = new Date();
+    const today = now.toISOString().split('T')[0]; // YYYY-MM-DD
+    const yearMonth = today.substring(0, 7); // YYYY-MM
+
+    // Ensure capture directory exists
+    const dateDir = join(CAPTURE_DIR, yearMonth);
+    if (!existsSync(dateDir)) {
+      mkdirSync(dateDir, { recursive: true });
+    }
+
+    // Format output as JSONL (one JSON object per line)
+    const captureFile = join(dateDir, `${today}_tool-outputs.jsonl`);
+    const captureEntry = JSON.stringify({
+      timestamp: data.timestamp || now.toISOString(),
+      tool: data.tool_name,
+      input: data.tool_input,
+      output: data.tool_response,
+      session: data.conversation_id
+    }) + '\n';
+
+    // Append to daily log
+    appendFileSync(captureFile, captureEntry);
+
+    // Exit successfully (code 0 = continue normally)
+    process.exit(0);
+  } catch (error) {
+    // Silent failure - don't disrupt workflow
+    console.error(`[UOCS] PostToolUse hook error: ${error}`);
+    process.exit(0);
+  }
+}
+
+main();

package/src/hooks/ts/post-tool-use/sync-todo-to-md.ts

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+/**
+ * sync-todo-to-md.ts
+ *
+ * PostToolUse hook for TodoWrite that:
+ * 1. Syncs Claude's todos to TODO.md "Current Session" section
+ * 2. PRESERVES all user-managed sections (Plans, Completed, Backlog, etc.)
+ * 3. Adds completed items to the session note
+ *
+ * IMPORTANT: This hook PRESERVES user content. It only updates "Current Session".
+ */
+
+import { writeFileSync, existsSync, readFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import {
+  findTodoPath,
+  findNotesDir,
+  getCurrentNotePath,
+  addWorkToSessionNote,
+  type WorkItem
+} from '../lib/project-utils';
+
+interface TodoItem {
+  content: string;
+  status: 'pending' | 'in_progress' | 'completed';
+  activeForm: string;
+}
+
+interface HookInput {
+  session_id: string;
+  cwd: string;
+  tool_name: string;
+  tool_input: {
+    todos: TodoItem[];
+  };
+}
+
+/**
+ * Format current session todos as markdown
+ */
+function formatSessionTodos(todos: TodoItem[]): string {
+  const inProgress = todos.filter(t => t.status === 'in_progress');
+  const pending = todos.filter(t => t.status === 'pending');
+  const completed = todos.filter(t => t.status === 'completed');
+
+  let content = '';
+
+  if (inProgress.length > 0) {
+    content += `### In Progress\n\n`;
+    for (const todo of inProgress) {
+      content += `- [ ] **${todo.content}** _(${todo.activeForm})_\n`;
+    }
+    content += '\n';
+  }
+
+  if (pending.length > 0) {
+    content += `### Pending\n\n`;
+    for (const todo of pending) {
+      content += `- [ ] ${todo.content}\n`;
+    }
+    content += '\n';
+  }
+
+  if (completed.length > 0) {
+    content += `### Completed\n\n`;
+    for (const todo of completed) {
+      content += `- [x] ${todo.content}\n`;
+    }
+    content += '\n';
+  }
+
+  if (todos.length === 0) {
+    content += `_(No active session tasks)_\n\n`;
+  }
+
+  return content;
+}
+
+/**
+ * Extract all sections from TODO.md EXCEPT "Current Session"
+ * These are user-managed sections that should be preserved.
+ */
+function extractPreservedSections(content: string): string {
+  let preserved = '';
+
+  // Match all ## sections that are NOT "Current Session"
+  const sectionRegex = /\n(## (?!Current Session)[^\n]+[\s\S]*?)(?=\n## |\n---\n+\*Last updated|$)/g;
+  const matches = content.matchAll(sectionRegex);
+
+  for (const match of matches) {
+    preserved += match[1];
+  }
+
+  return preserved;
+}
+
+/**
+ * Fix malformed headings: Remove --- prefix from headings (---# → #)
+ * Claude sometimes incorrectly merges horizontal rules with headings.
+ */
+function fixMalformedHeadings(content: string): string {
+  return content.replace(/^---#/gm, '#');
+}
+
+/**
+ * Build new TODO.md preserving user sections
+ */
+function buildTodoContent(todos: TodoItem[], existingContent: string): string {
+  const now = new Date().toISOString();
+
+  // Get all preserved sections (everything except Current Session)
+  const preserved = extractPreservedSections(existingContent);
+
+  // Build new content
+  let content = `# TODO
+
+## Current Session
+
+${formatSessionTodos(todos)}`;
+
+  // Add preserved sections
+  if (preserved.trim()) {
+    content += preserved;
+  }
+
+  // Ensure we end with exactly one timestamp
+  content = content.replace(/(\n---\s*)*(\n\*Last updated:.*\*\s*)*$/, '');
+  content += `\n---\n\n*Last updated: ${now}*\n`;
+
+  return content;
+}
+
+async function main() {
+  try {
+    const chunks: Buffer[] = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    const stdinData = Buffer.concat(chunks).toString('utf-8');
+
+    if (!stdinData.trim()) {
+      console.error('No input received');
+      process.exit(0);
+    }
+
+    const hookInput: HookInput = JSON.parse(stdinData);
+
+    if (hookInput.tool_name !== 'TodoWrite') {
+      process.exit(0);
+    }
+
+    const todos = hookInput.tool_input?.todos;
+
+    if (!todos || !Array.isArray(todos)) {
+      console.error('No todos in tool input');
+      process.exit(0);
+    }
+
+    const cwd = hookInput.cwd || process.cwd();
+
+    // Find TODO.md path
+    const todoPath = findTodoPath(cwd);
+
+    // Create TODO.md if it doesn't exist
+    if (!existsSync(todoPath)) {
+      const parentDir = todoPath.replace(/\/[^/]+$/, '');
+      mkdirSync(parentDir, { recursive: true });
+      console.error(`Creating TODO.md at ${todoPath}`);
+    }
+
+    // Read existing content to preserve user sections
+    let existingContent = '';
+    try {
+      existingContent = readFileSync(todoPath, 'utf-8');
+    } catch (e) {
+      // New file, no content to preserve
+    }
+
+    // Build and write new content (with heading fix)
+    let newContent = buildTodoContent(todos, existingContent);
+    newContent = fixMalformedHeadings(newContent);
+    writeFileSync(todoPath, newContent);
+
+    const stats = {
+      inProgress: todos.filter(t => t.status === 'in_progress').length,
+      pending: todos.filter(t => t.status === 'pending').length,
+      completed: todos.filter(t => t.status === 'completed').length
+    };
+    console.error(`TODO.md synced: ${stats.inProgress} in progress, ${stats.pending} pending, ${stats.completed} completed`);
+
+    // Add completed items to session note (if local Notes/ exists)
+    const completedTodos = todos.filter(t => t.status === 'completed');
+
+    if (completedTodos.length > 0) {
+      const notesInfo = findNotesDir(cwd);
+
+      if (notesInfo.isLocal) {
+        const currentNotePath = getCurrentNotePath(notesInfo.path);
+
+        if (currentNotePath) {
+          let noteContent = '';
+          try {
+            noteContent = readFileSync(currentNotePath, 'utf-8');
+          } catch (e) {
+            console.error('Could not read session note:', e);
+          }
+
+          const newlyCompleted = completedTodos.filter(t => !noteContent.includes(t.content));
+
+          if (newlyCompleted.length > 0) {
+            const workItems: WorkItem[] = newlyCompleted.map(t => ({
+              title: t.content,
+              completed: true
+            }));
+
+            addWorkToSessionNote(currentNotePath, workItems);
+            console.error(`Added ${newlyCompleted.length} completed item(s) to session note`);
+          }
+        }
+      }
+    }
+
+  } catch (error) {
+    console.error('sync-todo-to-md error:', error);
+  }
+
+  process.exit(0);
+}
+
+main();

package/src/hooks/ts/post-tool-use/update-tab-on-action.ts

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+/**
+ * Tab Title Update on Action Tools
+ * Updates Kitty tab title when action tools complete (Edit, Write, Bash, Task)
+ * Uses the tool's description directly - no AI call needed
+ *
+ * PAI-safe: No sensitive data, just tool descriptions
+ */
+
+import { execSync } from 'child_process';
+
+// Action tools that warrant a tab title update
+const ACTION_TOOLS = new Set([
+  'Edit',
+  'Write',
+  'Bash',
+  'Task',
+  'NotebookEdit',
+  'MultiEdit'
+]);
+
+interface HookInput {
+  session_id: string;
+  tool_name: string;
+  tool_input: {
+    description?: string;
+    command?: string;
+    file_path?: string;
+    prompt?: string;
+    subagent_type?: string;
+  };
+  tool_response?: unknown;
+  hook_event_name: string;
+}
+
+/**
+ * Read stdin with timeout
+ */
+async function readStdinWithTimeout(timeout: number = 3000): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    const timer = setTimeout(() => {
+      reject(new Error('Timeout'));
+    }, timeout);
+
+    process.stdin.on('data', (chunk) => {
+      data += chunk.toString();
+    });
+
+    process.stdin.on('end', () => {
+      clearTimeout(timer);
+      resolve(data);
+    });
+
+    process.stdin.on('error', (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Update Kitty tab title using escape codes
+ */
+function setTabTitle(title: string): void {
+  try {
+    // Truncate to reasonable length
+    const truncated = title.length > 50 ? title.slice(0, 47) + '...' : title;
+    const escaped = truncated.replace(/'/g, "'\\''");
+
+    // Multiple escape sequences for compatibility
+    execSync(`printf '\\033]0;${escaped}\\007' >&2`, { stdio: ['pipe', 'pipe', 'inherit'] });
+    execSync(`printf '\\033]2;${escaped}\\007' >&2`, { stdio: ['pipe', 'pipe', 'inherit'] });
+    execSync(`printf '\\033]30;${escaped}\\007' >&2`, { stdio: ['pipe', 'pipe', 'inherit'] });
+  } catch {
+    // Silently fail - don't interrupt Claude's work
+  }
+}
+
+/**
+ * Generate a human-readable title from tool input
+ */
+function generateTitle(toolName: string, input: HookInput['tool_input']): string {
+  // Use explicit description if provided
+  if (input.description) {
+    return input.description;
+  }
+
+  // Generate based on tool type
+  switch (toolName) {
+    case 'Edit':
+    case 'Write':
+    case 'MultiEdit':
+    case 'NotebookEdit':
+      if (input.file_path) {
+        const filename = input.file_path.split('/').pop() || input.file_path;
+        return `Editing ${filename}`;
+      }
+      return `Editing file`;
+
+    case 'Bash':
+      if (input.command) {
+        // Extract first command word
+        const cmd = input.command.split(/\s+/)[0].split('/').pop() || 'command';
+        return `Running ${cmd}`;
+      }
+      return 'Running command';
+
+    case 'Task':
+      if (input.subagent_type) {
+        return `Agent: ${input.subagent_type}`;
+      }
+      if (input.prompt) {
+        const words = input.prompt.slice(0, 30).split(/\s+/).slice(0, 3).join(' ');
+        return `Task: ${words}...`;
+      }
+      return 'Spawning agent';
+
+    default:
+      return `${toolName}...`;
+  }
+}
+
+async function main() {
+  try {
+    const input = await readStdinWithTimeout();
+    const data: HookInput = JSON.parse(input);
+
+    // Only process action tools
+    if (!ACTION_TOOLS.has(data.tool_name)) {
+      process.exit(0);
+    }
+
+    // Generate and set title
+    const title = generateTitle(data.tool_name, data.tool_input);
+    setTabTitle(title);
+
+    process.exit(0);
+  } catch {
+    // Silently exit - don't interrupt Claude's flow
+    process.exit(0);
+  }
+}
+
+main();

package/src/hooks/ts/pre-compact/context-compression-hook.ts

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+/**
+ * PreCompact Hook - Triggered before context compression
+ * Extracts context information from transcript and notifies about compression
+ *
+ * Enhanced to:
+ * - Save checkpoint to current session note
+ * - Send ntfy.sh notification
+ * - Calculate approximate token count
+ */
+
+import { readFileSync } from 'fs';
+import { join, basename, dirname } from 'path';
+import {
+  sendNtfyNotification,
+  getCurrentNotePath,
+  appendCheckpoint,
+  calculateSessionTokens
+} from '../lib/project-utils';
+
+interface HookInput {
+  session_id: string;
+  transcript_path: string;
+  hook_event_name: string;
+  compact_type?: string;
+}
+
+interface TranscriptEntry {
+  type: string;
+  message?: {
+    role?: string;
+    content?: Array<{
+      type: string;
+      text: string;
+    }>
+  };
+  timestamp?: string;
+}
+
+/**
+ * Count messages in transcript to provide context
+ */
+function getTranscriptStats(transcriptPath: string): { messageCount: number; isLarge: boolean } {
+  try {
+    const content = readFileSync(transcriptPath, 'utf-8');
+    const lines = content.trim().split('\n');
+
+    let userMessages = 0;
+    let assistantMessages = 0;
+
+    for (const line of lines) {
+      if (line.trim()) {
+        try {
+          const entry = JSON.parse(line) as TranscriptEntry;
+          if (entry.type === 'user') {
+            userMessages++;
+          } else if (entry.type === 'assistant') {
+            assistantMessages++;
+          }
+        } catch {
+          // Skip invalid JSON lines
+        }
+      }
+    }
+
+    const totalMessages = userMessages + assistantMessages;
+    const isLarge = totalMessages > 50; // Consider large if more than 50 messages
+
+    return { messageCount: totalMessages, isLarge };
+  } catch (error) {
+    return { messageCount: 0, isLarge: false };
+  }
+}
+
+async function main() {
+  let hookInput: HookInput | null = null;
+
+  try {
+    // Read the JSON input from stdin
+    const decoder = new TextDecoder();
+    let input = '';
+
+    const timeoutPromise = new Promise<void>((resolve) => {
+      setTimeout(() => resolve(), 500);
+    });
+
+    const readPromise = (async () => {
+      for await (const chunk of process.stdin) {
+        input += decoder.decode(chunk, { stream: true });
+      }
+    })();
+
+    await Promise.race([readPromise, timeoutPromise]);
+
+    if (input.trim()) {
+      hookInput = JSON.parse(input) as HookInput;
+    }
+  } catch (error) {
+    // Silently handle input errors
+  }
+
+  // Determine the type of compression
+  const compactType = hookInput?.compact_type || 'auto';
+  let message = 'Compressing context to continue';
+
+  // Get transcript statistics if available
+  let tokenCount = 0;
+  if (hookInput && hookInput.transcript_path) {
+    const stats = getTranscriptStats(hookInput.transcript_path);
+
+    // Calculate approximate token count
+    tokenCount = calculateSessionTokens(hookInput.transcript_path);
+    const tokenDisplay = tokenCount > 1000
+      ? `${Math.round(tokenCount / 1000)}k`
+      : String(tokenCount);
+
+    if (stats.messageCount > 0) {
+      if (compactType === 'manual') {
+        message = `Manually compressing ${stats.messageCount} messages (~${tokenDisplay} tokens)`;
+      } else {
+        message = stats.isLarge
+          ? `Auto-compressing large context (~${tokenDisplay} tokens)`
+          : `Compressing context (~${tokenDisplay} tokens)`;
+      }
+    }
+
+    // Save checkpoint to session note before compression
+    try {
+      const transcriptDir = dirname(hookInput.transcript_path);
+      const notesDir = join(transcriptDir, 'Notes');
+      const currentNotePath = getCurrentNotePath(notesDir);
+
+      if (currentNotePath) {
+        const checkpoint = `Context compression triggered at ~${tokenDisplay} tokens with ${stats.messageCount} messages.`;
+        appendCheckpoint(currentNotePath, checkpoint);
+        console.error(`Checkpoint saved before compression: ${basename(currentNotePath)}`);
+      }
+    } catch (noteError) {
+      console.error(`Could not save checkpoint: ${noteError}`);
+    }
+  }
+
+  // Send ntfy.sh notification
+  const ntfyMessage = tokenCount > 0
+    ? `Auto-pause: ~${Math.round(tokenCount / 1000)}k tokens`
+    : 'Context compressing';
+  await sendNtfyNotification(ntfyMessage);
+
+  process.exit(0);
+}
+
+// Run the hook
+main().catch(() => {
+  process.exit(0);
+});