@tekmidian/pai 0.7.0 → 0.7.2

package/src/hooks/ts/stop/stop-hook.ts

@@ -2,6 +2,8 @@
 
 import { readFileSync } from 'fs';
 import { join, basename, dirname } from 'path';
+import { connect } from 'net';
+import { randomUUID } from 'crypto';
 import {
   sendNtfyNotification,
   getCurrentNotePath,
@@ -14,15 +16,148 @@ import {
   WorkItem
 } from '../lib/project-utils';
 
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const DAEMON_SOCKET = process.env.PAI_SOCKET ?? '/tmp/pai.sock';
+const DAEMON_TIMEOUT_MS = 3_000;
+
+// ---------------------------------------------------------------------------
+// Helper: safely convert Claude content (string | Block[]) to plain text
+// ---------------------------------------------------------------------------
+
+function contentToText(content: any): string {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((c) => {
+        if (typeof c === 'string') return c;
+        if (c?.text) return c.text;
+        if (c?.content) return String(c.content);
+        return '';
+      })
+      .join(' ')
+      .trim();
+  }
+  return '';
+}
+
+// ---------------------------------------------------------------------------
+// Helper: extract COMPLETED: line from the last assistant response
+// ---------------------------------------------------------------------------
+
+function extractCompletedMessage(lines: string[]): string {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    try {
+      const entry = JSON.parse(lines[i]);
+      if (entry.type === 'assistant' && entry.message?.content) {
+        const content = contentToText(entry.message.content);
+        const m = content.match(/COMPLETED:\s*(.+?)(?:\n|$)/i);
+        if (m) {
+          return m[1].trim().replace(/\*+/g, '').replace(/\[.*?\]/g, '').trim();
+        }
+      }
+    } catch {
+      // Skip invalid JSON
+    }
+  }
+  return '';
+}
+
+// ---------------------------------------------------------------------------
+// Daemon IPC relay — fast path
+// ---------------------------------------------------------------------------
+
+/**
+ * Try to enqueue work with the daemon over its Unix socket.
+ * Returns true on success, false if the daemon is unreachable.
+ * Times out after DAEMON_TIMEOUT_MS so the hook doesn't block.
+ */
+function enqueueWithDaemon(payload: {
+  transcriptPath: string;
+  cwd: string;
+  message: string;
+}): Promise<boolean> {
+  return new Promise((resolve) => {
+    let done = false;
+    let buffer = '';
+    let timer: ReturnType<typeof setTimeout> | null = null;
+
+    function finish(ok: boolean): void {
+      if (done) return;
+      done = true;
+      if (timer !== null) { clearTimeout(timer); timer = null; }
+      try { client.destroy(); } catch { /* ignore */ }
+      resolve(ok);
+    }
+
+    const client = connect(DAEMON_SOCKET, () => {
+      const msg = JSON.stringify({
+        id: randomUUID(),
+        method: 'work_queue_enqueue',
+        params: {
+          type: 'session-end',
+          priority: 2,
+          payload: {
+            transcriptPath: payload.transcriptPath,
+            cwd: payload.cwd,
+            message: payload.message,
+          },
+        },
+      }) + '\n';
+      client.write(msg);
+    });
+
+    client.on('data', (chunk: Buffer) => {
+      buffer += chunk.toString();
+      const nl = buffer.indexOf('\n');
+      if (nl === -1) return;
+      const line = buffer.slice(0, nl);
+      try {
+        const response = JSON.parse(line) as { ok: boolean; error?: string };
+        if (response.ok) {
+          console.error(`STOP-HOOK: Work enqueued with daemon (id=${(response as any).result?.id}).`);
+          finish(true);
+        } else {
+          console.error(`STOP-HOOK: Daemon rejected enqueue: ${response.error}`);
+          finish(false);
+        }
+      } catch {
+        finish(false);
+      }
+    });
+
+    client.on('error', (e: NodeJS.ErrnoException) => {
+      if (e.code === 'ENOENT' || e.code === 'ECONNREFUSED') {
+        console.error('STOP-HOOK: Daemon not running — falling back to direct execution.');
+      } else {
+        console.error(`STOP-HOOK: Daemon socket error: ${e.message}`);
+      }
+      finish(false);
+    });
+
+    client.on('end', () => { if (!done) finish(false); });
+
+    timer = setTimeout(() => {
+      console.error(`STOP-HOOK: Daemon timeout after ${DAEMON_TIMEOUT_MS}ms — falling back.`);
+      finish(false);
+    }, DAEMON_TIMEOUT_MS);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Direct execution — fallback path (original stop-hook logic)
+// ---------------------------------------------------------------------------
+
 /**
- * Extract work items from transcript for session note
- * Looks for SUMMARY, ACTIONS, RESULTS sections in assistant responses
+ * Extract work items from transcript for session note.
+ * Looks for SUMMARY, ACTIONS, RESULTS sections in assistant responses.
  */
 function extractWorkFromTranscript(lines: string[]): WorkItem[] {
   const workItems: WorkItem[] = [];
   const seenSummaries = new Set<string>();
 
-  // Process all assistant messages to find work summaries
   for (const line of lines) {
     try {
       const entry = JSON.parse(line);
@@ -36,16 +171,14 @@ function extractWorkFromTranscript(lines: string[]): WorkItem[] {
           if (summary && !seenSummaries.has(summary) && summary.length > 5) {
             seenSummaries.add(summary);
 
-            // Try to extract details from ACTIONS or RESULTS
+            // Try to extract details from ACTIONS section
             const details: string[] = [];
-
             const actionsMatch = content.match(/ACTIONS:\s*(.+?)(?=\n[A-Z]+:|$)/is);
             if (actionsMatch) {
-              // Extract bullet points or numbered items
               const actionLines = actionsMatch[1].split('\n')
                 .map(l => l.replace(/^[-*•]\s*/, '').replace(/^\d+\.\s*/, '').trim())
                 .filter(l => l.length > 3 && l.length < 100);
-              details.push(...actionLines.slice(0, 3)); // Max 3 action items
+              details.push(...actionLines.slice(0, 3));
             }
 
             workItems.push({
@@ -59,13 +192,10 @@ function extractWorkFromTranscript(lines: string[]): WorkItem[] {
         // Also look for COMPLETED: lines as backup
         const completedMatch = content.match(/COMPLETED:\s*(.+?)(?:\n|$)/i);
         if (completedMatch && workItems.length === 0) {
-          const completed = completedMatch[1].trim().replace(/\*+/g, '');
+          const completed = completedMatch[1].trim().replace(/\*+/g, '').replace(/\[.*?\]/g, '');
           if (completed && !seenSummaries.has(completed) && completed.length > 5) {
             seenSummaries.add(completed);
-            workItems.push({
-              title: completed,
-              completed: true
-            });
+            workItems.push({ title: completed, completed: true });
           }
         }
       }
@@ -78,10 +208,9 @@ function extractWorkFromTranscript(lines: string[]): WorkItem[] {
 }
 
 /**
- * Generate 4-word tab title summarizing what was done
+ * Generate 4-word tab title summarizing what was done.
  */
 function generateTabTitle(prompt: string, completedLine?: string): string {
-  // If we have a completed line, try to use it for a better summary
   if (completedLine) {
     const cleanCompleted = completedLine
       .replace(/\*+/g, '')
@@ -89,23 +218,18 @@ function generateTabTitle(prompt: string, completedLine?: string): string {
       .replace(/COMPLETED:\s*/gi, '')
       .trim();
 
-    // Extract meaningful words from the completed line
     const completedWords = cleanCompleted.split(/\s+/)
       .filter(word => word.length > 2 &&
         !['the', 'and', 'but', 'for', 'are', 'with', 'his', 'her', 'this', 'that', 'you', 'can', 'will', 'have', 'been', 'your', 'from', 'they', 'were', 'said', 'what', 'them', 'just', 'told', 'how', 'does', 'into', 'about', 'completed'].includes(word.toLowerCase()))
       .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());
 
     if (completedWords.length >= 2) {
-      // Build a 4-word summary from completed line
       const summary = completedWords.slice(0, 4);
-      while (summary.length < 4) {
-        summary.push('Done');
-      }
+      while (summary.length < 4) summary.push('Done');
       return summary.slice(0, 4).join(' ');
     }
   }
 
-  // Fall back to parsing the prompt
   const cleanPrompt = prompt.replace(/[^\w\s]/g, ' ').trim();
   const words = cleanPrompt.split(/\s+/).filter(word =>
     word.length > 2 &&
@@ -113,103 +237,132 @@ function generateTabTitle(prompt: string, completedLine?: string): string {
   );
 
   const lowerPrompt = prompt.toLowerCase();
-
-  // Find action verb if present
   const actionVerbs = ['test', 'rename', 'fix', 'debug', 'research', 'write', 'create', 'make', 'build', 'implement', 'analyze', 'review', 'update', 'modify', 'generate', 'develop', 'design', 'deploy', 'configure', 'setup', 'install', 'remove', 'delete', 'add', 'check', 'verify', 'validate', 'optimize', 'refactor', 'enhance', 'improve', 'send', 'email', 'help', 'updated', 'fixed', 'created', 'built', 'added'];
-
   let titleWords: string[] = [];
 
-  // Check for action verb
   for (const verb of actionVerbs) {
     if (lowerPrompt.includes(verb)) {
-      // Convert to past tense for summary
       let pastTense = verb;
       if (verb === 'write') pastTense = 'Wrote';
       else if (verb === 'make') pastTense = 'Made';
       else if (verb === 'send') pastTense = 'Sent';
       else if (verb.endsWith('e')) pastTense = verb.charAt(0).toUpperCase() + verb.slice(1, -1) + 'ed';
       else pastTense = verb.charAt(0).toUpperCase() + verb.slice(1) + 'ed';
-
       titleWords.push(pastTense);
       break;
     }
   }
 
-  // Add most meaningful remaining words
   const remainingWords = words
     .filter(word => !actionVerbs.includes(word.toLowerCase()))
     .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());
 
-  // Fill up to 4 words total
   for (const word of remainingWords) {
-    if (titleWords.length < 4) {
-      titleWords.push(word);
-    } else {
-      break;
-    }
+    if (titleWords.length < 4) titleWords.push(word);
+    else break;
   }
 
-  // If we don't have enough words, add generic ones
-  if (titleWords.length === 0) {
-    titleWords.push('Completed');
-  }
-  if (titleWords.length === 1) {
-    titleWords.push('Task');
-  }
-  if (titleWords.length === 2) {
-    titleWords.push('Successfully');
-  }
-  if (titleWords.length === 3) {
-    titleWords.push('Done');
-  }
+  if (titleWords.length === 0) titleWords.push('Completed');
+  if (titleWords.length === 1) titleWords.push('Task');
+  if (titleWords.length === 2) titleWords.push('Successfully');
+  if (titleWords.length === 3) titleWords.push('Done');
 
   return titleWords.slice(0, 4).join(' ');
 }
 
 /**
- * Set terminal tab title (works with Kitty, Ghostty, iTerm2, etc.)
+ * Do the heavy work directly in the hook process.
+ * Used when the daemon is unreachable.
  */
-function setTerminalTabTitle(title: string): void {
-  const term = process.env.TERM || '';
-
-  if (term.includes('ghostty')) {
-    process.stderr.write(`\x1b]2;${title}\x07`);
-    process.stderr.write(`\x1b]0;${title}\x07`);
-    process.stderr.write(`\x1b]7;${title}\x07`);
-    process.stderr.write(`\x1b]2;${title}\x1b\\`);
-  } else if (term.includes('kitty')) {
-    process.stderr.write(`\x1b]0;${title}\x07`);
-    process.stderr.write(`\x1b]2;${title}\x07`);
-    process.stderr.write(`\x1b]30;${title}\x07`);
-  } else {
-    process.stderr.write(`\x1b]0;${title}\x07`);
-    process.stderr.write(`\x1b]2;${title}\x07`);
+async function executeDirectly(
+  lines: string[],
+  transcriptPath: string,
+  cwd: string,
+  message: string,
+  lastUserQuery: string
+): Promise<void> {
+  // Set terminal tab title
+  let tabTitle = message || '';
+  if (!tabTitle && lastUserQuery) {
+    tabTitle = generateTabTitle(lastUserQuery, '');
   }
 
-  if (process.stderr.isTTY) {
-    process.stderr.write('');
+  if (tabTitle) {
+    try {
+      const escapedTitle = tabTitle.replace(/'/g, "'\\''");
+      const { execSync } = await import('child_process');
+      execSync(`printf '\\033]0;${escapedTitle}\\007' >&2`);
+      execSync(`printf '\\033]2;${escapedTitle}\\007' >&2`);
+      execSync(`printf '\\033]30;${escapedTitle}\\007' >&2`);
+      console.error(`Tab title set to: "${tabTitle}"`);
+    } catch (e) {
+      console.error(`Failed to set tab title: ${e}`);
+    }
   }
-}
 
-// Helper to safely turn Claude content (string or array of blocks) into plain text
-function contentToText(content: any): string {
-  if (typeof content === 'string') return content;
-  if (Array.isArray(content)) {
-    return content
-      .map((c) => {
-        if (typeof c === 'string') return c;
-        if (c?.text) return c.text;
-        if (c?.content) return String(c.content);
-        return '';
-      })
-      .join(' ')
-      .trim();
+  // Final tab title override
+  if (message) {
+    const finalTabTitle = message.slice(0, 50);
+    process.stderr.write(`\x1b]2;${finalTabTitle}\x07`);
+  }
+
+  // Finalize session note
+  try {
+    const notesInfo = findNotesDir(cwd);
+    const currentNotePath = getCurrentNotePath(notesInfo.path);
+
+    if (currentNotePath) {
+      const workItems = extractWorkFromTranscript(lines);
+      if (workItems.length > 0) {
+        addWorkToSessionNote(currentNotePath, workItems);
+        console.error(`Added ${workItems.length} work item(s) to session note`);
+      } else if (message) {
+        addWorkToSessionNote(currentNotePath, [{ title: message, completed: true }]);
+        console.error(`Added completion message to session note`);
+      }
+
+      const summary = message || 'Session completed.';
+      finalizeSessionNote(currentNotePath, summary);
+      console.error(`Session note finalized: ${basename(currentNotePath)}`);
+
+      try {
+        const stateLines: string[] = [];
+        stateLines.push(`Working directory: ${cwd}`);
+        if (workItems.length > 0) {
+          stateLines.push('', 'Work completed:');
+          for (const item of workItems.slice(0, 5)) {
+            stateLines.push(`- ${item.title}`);
+          }
+        }
+        if (message) {
+          stateLines.push('', `Last completed: ${message}`);
+        }
+        updateTodoContinue(cwd, basename(currentNotePath), stateLines.join('\n'), 'session-end');
+      } catch (todoError) {
+        console.error(`Could not update TODO.md: ${todoError}`);
+      }
+    }
+  } catch (noteError) {
+    console.error(`Could not finalize session note: ${noteError}`);
+  }
+
+  // Move session .jsonl files to sessions/
+  try {
+    const transcriptDir = dirname(transcriptPath);
+    const movedCount = moveSessionFilesToSessionsDir(transcriptDir);
+    if (movedCount > 0) {
+      console.error(`Moved ${movedCount} session file(s) to sessions/`);
+    }
+  } catch (moveError) {
+    console.error(`Could not move session files: ${moveError}`);
   }
-  return '';
 }
 
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
 async function main() {
-  // Skip probe/health-check sessions (e.g. CodexBar ClaudeProbe)
   if (isProbeSession()) {
     process.exit(0);
   }
@@ -217,10 +370,9 @@ async function main() {
   const timestamp = new Date().toISOString();
   console.error(`\nSTOP-HOOK TRIGGERED AT ${timestamp}`);
 
-  // Get input
+  // Read stdin
   let input = '';
   const decoder = new TextDecoder();
-
   try {
     for await (const chunk of process.stdin) {
       input += decoder.decode(chunk, { stream: true });
@@ -253,8 +405,8 @@ async function main() {
     process.exit(0);
   }
 
-  // Read the transcript
-  let transcript;
+  // Read transcript
+  let transcript: string;
   try {
     transcript = readFileSync(transcriptPath, 'utf-8');
     console.error(`Transcript loaded: ${transcript.split('\n').length} lines`);
@@ -263,10 +415,9 @@ async function main() {
     process.exit(0);
   }
 
-  // Parse the JSON lines to find what happened in this session
   const lines = transcript.trim().split('\n');
 
-  // Get the last user query for context
+  // Extract last user query for tab title / fallback
   let lastUserQuery = '';
   for (let i = lines.length - 1; i >= 0; i--) {
     try {
@@ -285,61 +436,26 @@ async function main() {
         }
         if (lastUserQuery) break;
       }
-    } catch (e) {
+    } catch {
       // Skip invalid JSON
     }
   }
 
-  // Extract the completion message from the last assistant response
-  let message = '';
+  // Extract completion message
+  const message = extractCompletedMessage(lines);
 
-  const lastResponse = lines[lines.length - 1];
-  try {
-    const entry = JSON.parse(lastResponse);
-    if (entry.type === 'assistant' && entry.message?.content) {
-      const content = contentToText(entry.message.content);
-
-      // Look for COMPLETED line
-      const completedMatch = content.match(/COMPLETED:\s*(.+?)(?:\n|$)/i);
-      if (completedMatch) {
-        message = completedMatch[1].trim()
-          .replace(/\*+/g, '')
-          .replace(/\[.*?\]/g, '')
-          .trim();
-        console.error(`COMPLETION: ${message}`);
-      }
-    }
-  } catch (e) {
-    console.error('Error parsing assistant response:', e);
-  }
+  console.error(`User query: ${lastUserQuery || 'No query found'}`);
+  console.error(`Message: ${message || 'No completion message'}`);
 
-  // Set tab title
+  // Always set terminal tab title immediately (fast, no daemon needed)
   let tabTitle = message || '';
-
   if (!tabTitle && lastUserQuery) {
-    try {
-      const entry = JSON.parse(lastResponse);
-      if (entry.type === 'assistant' && entry.message?.content) {
-        const content = contentToText(entry.message.content);
-        const completedMatch = content.match(/COMPLETED:\s*(.+?)(?:\n|$)/im);
-        if (completedMatch) {
-          tabTitle = completedMatch[1].trim()
-            .replace(/\*+/g, '')
-            .replace(/\[.*?\]/g, '')
-            .trim();
-        }
-      }
-    } catch (e) {}
-
-    if (!tabTitle) {
-      tabTitle = generateTabTitle(lastUserQuery, '');
-    }
+    tabTitle = generateTabTitle(lastUserQuery, '');
   }
-
   if (tabTitle) {
     try {
-      const escapedTitle = tabTitle.replace(/'/g, "'\\''");
       const { execSync } = await import('child_process');
+      const escapedTitle = tabTitle.replace(/'/g, "'\\''");
       execSync(`printf '\\033]0;${escapedTitle}\\007' >&2`);
       execSync(`printf '\\033]2;${escapedTitle}\\007' >&2`);
       execSync(`printf '\\033]30;${escapedTitle}\\007' >&2`);
@@ -348,85 +464,29 @@ async function main() {
       console.error(`Failed to set tab title: ${e}`);
     }
   }
-
-  console.error(`User query: ${lastUserQuery || 'No query found'}`);
-  console.error(`Message: ${message || 'No completion message'}`);
-
-  // Final tab title override as the very last action
   if (message) {
-    const finalTabTitle = message.slice(0, 50);
-    process.stderr.write(`\x1b]2;${finalTabTitle}\x07`);
+    process.stderr.write(`\x1b]2;${message.slice(0, 50)}\x07`);
   }
 
-  // Send ntfy.sh notification
+  // Send ntfy.sh notification (fast, fire-and-forget)
   if (message) {
     await sendNtfyNotification(message);
   } else {
     await sendNtfyNotification('Session ended');
   }
 
-  // Finalize session note if one exists
-  try {
-    const notesInfo = findNotesDir(cwd);
-    console.error(`Notes directory: ${notesInfo.path} (${notesInfo.isLocal ? 'local' : 'central'})`);
-    const currentNotePath = getCurrentNotePath(notesInfo.path);
-
-    if (currentNotePath) {
-      // FIRST: Extract and add work items from transcript
-      const workItems = extractWorkFromTranscript(lines);
-      if (workItems.length > 0) {
-        addWorkToSessionNote(currentNotePath, workItems);
-        console.error(`Added ${workItems.length} work item(s) to session note`);
-      } else {
-        // If no structured work items found, at least add the completion message
-        if (message) {
-          addWorkToSessionNote(currentNotePath, [{
-            title: message,
-            completed: true
-          }]);
-          console.error(`Added completion message to session note`);
-        }
-      }
-
-      // THEN: Finalize the note
-      const summary = message || 'Session completed.';
-      finalizeSessionNote(currentNotePath, summary);
-      console.error(`Session note finalized: ${basename(currentNotePath)}`);
-
-      // Update TODO.md ## Continue section so next session has context
-      try {
-        const stateLines: string[] = [];
-        stateLines.push(`Working directory: ${cwd}`);
-        if (workItems.length > 0) {
-          stateLines.push('');
-          stateLines.push('Work completed:');
-          for (const item of workItems.slice(0, 5)) {
-            stateLines.push(`- ${item.title}`);
-          }
-        }
-        if (message) {
-          stateLines.push('');
-          stateLines.push(`Last completed: ${message}`);
-        }
-        const state = stateLines.join('\n');
-        updateTodoContinue(cwd, basename(currentNotePath), state, 'session-end');
-      } catch (todoError) {
-        console.error(`Could not update TODO.md: ${todoError}`);
-      }
-    }
-  } catch (noteError) {
-    console.error(`Could not finalize session note: ${noteError}`);
-  }
-
-  // Move all session .jsonl files to sessions/ subdirectory
-  try {
-    const transcriptDir = dirname(transcriptPath);
-    const movedCount = moveSessionFilesToSessionsDir(transcriptDir);
-    if (movedCount > 0) {
-      console.error(`Moved ${movedCount} session file(s) to sessions/`);
-    }
-  } catch (moveError) {
-    console.error(`Could not move session files: ${moveError}`);
+  // -----------------------------------------------------------------------
+  // Relay heavy work to daemon — fall back to direct execution if unavailable
+  // -----------------------------------------------------------------------
+  const relayed = await enqueueWithDaemon({
+    transcriptPath,
+    cwd,
+    message,
+  });
+
+  if (!relayed) {
+    console.error('STOP-HOOK: Using direct execution fallback.');
+    await executeDirectly(lines, transcriptPath, cwd, message, lastUserQuery);
   }
 
   console.error(`STOP-HOOK COMPLETED SUCCESSFULLY at ${new Date().toISOString()}\n`);