@tekmidian/pai 0.7.1 → 0.7.3

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

@@ -16,12 +16,15 @@
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { basename, dirname, join } from 'path';
 import { tmpdir } from 'os';
+import { connect } from 'net';
+import { randomUUID } from 'crypto';
 import {
   sendNtfyNotification,
   getCurrentNotePath,
   createSessionNote,
   appendCheckpoint,
   addWorkToSessionNote,
+  isMeaningfulTitle,
   findNotesDir,
   renameSessionNote,
   updateTodoContinue,
@@ -39,6 +42,9 @@ interface HookInput {
   trigger?: string;
 }
 
+const DAEMON_SOCKET = process.env.PAI_SOCKET ?? '/tmp/pai.sock';
+const DAEMON_TIMEOUT_MS = 3_000;
+
 /** Structured data extracted from a transcript in a single pass. */
 interface TranscriptData {
   userMessages: string[];
@@ -233,50 +239,63 @@ function formatSessionState(data: TranscriptData, cwd?: string): string | null {
 // ---------------------------------------------------------------------------
 
 function deriveTitle(data: TranscriptData): string {
-  let title = '';
+  // Collect candidates in priority order, then pick the first meaningful one.
+  const candidates: string[] = [];
 
-  // 1. Last work item title (most descriptive of what was accomplished)
-  if (data.workItems.length > 0) {
-    title = data.workItems[data.workItems.length - 1].title;
+  // 1. Work item titles (most descriptive of what was accomplished)
+  for (let i = data.workItems.length - 1; i >= 0; i--) {
+    candidates.push(data.workItems[i].title);
   }
-  // 2. Last summary
-  else if (data.summaries.length > 0) {
-    title = data.summaries[data.summaries.length - 1];
+
+  // 2. Summaries
+  for (let i = data.summaries.length - 1; i >= 0; i--) {
+    candidates.push(data.summaries[i]);
   }
+
   // 3. Last completed marker
-  else if (data.lastCompleted && data.lastCompleted.length > 5) {
-    title = data.lastCompleted;
+  if (data.lastCompleted && data.lastCompleted.length > 5) {
+    candidates.push(data.lastCompleted);
   }
-  // 4. Last substantive user message
-  else if (data.userMessages.length > 0) {
-    for (let i = data.userMessages.length - 1; i >= 0; i--) {
-      const msg = data.userMessages[i].split('\n')[0].trim();
-      if (msg.length > 10 && msg.length < 80 &&
-          !msg.toLowerCase().startsWith('yes') &&
-          !msg.toLowerCase().startsWith('ok')) {
-        title = msg;
-        break;
-      }
+
+  // 4. User messages (FIRST meaningful one, not last — first is more likely
+  //    to describe the session's purpose; last is often system noise)
+  for (const msg of data.userMessages) {
+    const line = msg.split('\n')[0].trim();
+    if (line.length > 10 && line.length < 80 &&
+        !line.toLowerCase().startsWith('yes') &&
+        !line.toLowerCase().startsWith('ok')) {
+      candidates.push(line);
     }
   }
-  // 5. Derive from files modified
-  if (!title && data.filesModified.length > 0) {
+
+  // 5. Derive from files modified (fallback)
+  if (data.filesModified.length > 0) {
     const basenames = data.filesModified.slice(-5).map(f => {
       const b = basename(f);
       return b.replace(/\.[^.]+$/, '');
     });
     const unique = [...new Set(basenames)];
-    title = unique.length <= 3
-      ? `Updated ${unique.join(', ')}`
-      : `Modified ${data.filesModified.length} files`;
+    candidates.push(
+      unique.length <= 3
+        ? `Updated ${unique.join(', ')}`
+        : `Modified ${data.filesModified.length} files`
+    );
+  }
+
+  // Pick the first candidate that passes the meaningfulness filter
+  for (const raw of candidates) {
+    const cleaned = raw
+      .replace(/[^\w\s-]/g, ' ')   // Remove special chars
+      .replace(/\s+/g, ' ')        // Normalize whitespace
+      .trim()
+      .substring(0, 60);
+    if (cleaned.length >= 5 && isMeaningfulTitle(cleaned)) {
+      return cleaned;
+    }
   }
 
-  // Clean up for filename use
-  return title
-    .replace(/[^\w\s-]/g, ' ')   // Remove special chars
-    .replace(/\s+/g, ' ')        // Normalize whitespace
-    .trim()
-    .substring(0, 60);
+  // All candidates were garbage — return empty (caller will not rename)
+  return '';
 }
 
 // ---------------------------------------------------------------------------
@@ -338,6 +357,85 @@ function saveCumulativeState(notesDir: string, data: TranscriptData, notePath: s
   }
 }
 
+// ---------------------------------------------------------------------------
+// Daemon IPC — enqueue session-summary work item
+// ---------------------------------------------------------------------------
+
+/**
+ * Send a session-summary work item to the daemon via IPC.
+ * Returns true on success, false if the daemon is unreachable.
+ * Times out after DAEMON_TIMEOUT_MS to avoid blocking the hook.
+ */
+function enqueueSessionSummary(payload: {
+  cwd: string;
+  sessionId?: string;
+  transcriptPath?: 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-summary',
+          priority: 4, // lower priority than session-end (2)
+          payload: {
+            cwd: payload.cwd,
+            sessionId: payload.sessionId,
+            transcriptPath: payload.transcriptPath,
+          },
+        },
+      }) + '\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; result?: { id: string } };
+        if (response.ok) {
+          console.error(`PRE-COMPACT: Session summary enqueued with daemon (id=${response.result?.id}).`);
+          finish(true);
+        } else {
+          console.error(`PRE-COMPACT: Daemon rejected session-summary: ${response.error}`);
+          finish(false);
+        }
+      } catch {
+        finish(false);
+      }
+    });
+
+    client.on('error', (e: NodeJS.ErrnoException) => {
+      if (e.code === 'ENOENT' || e.code === 'ECONNREFUSED') {
+        console.error('PRE-COMPACT: Daemon not running — skipping session summary.');
+      } else {
+        console.error(`PRE-COMPACT: Daemon socket error: ${e.message}`);
+      }
+      finish(false);
+    });
+
+    timer = setTimeout(() => {
+      console.error('PRE-COMPACT: Daemon IPC timed out — skipping session summary.');
+      finish(false);
+    }, DAEMON_TIMEOUT_MS);
+  });
+}
+
 // ---------------------------------------------------------------------------
 // Main
 // ---------------------------------------------------------------------------
@@ -402,23 +500,32 @@ async function main() {
     }
 
     // -----------------------------------------------------------------
-    // Persist session state to numbered session note (like "pause session")
+    // Persist session state to numbered session note.
+    // RULE: ONE note per session. NEVER create a new note during compaction.
+    // If the latest note is completed, reopen it (remove completed status)
+    // rather than creating a duplicate.
     // -----------------------------------------------------------------
     let notePath: string | null = null;
 
     try {
       notePath = getCurrentNotePath(notesInfo.path);
 
-      // If no note found, or the latest note is completed, create a new one
       if (!notePath) {
+        // Truly no note exists at all — create one (first compaction of a session
+        // that started before PAI was installed, or corrupted notes dir)
         console.error('No session note found — creating one for checkpoint');
-        notePath = createSessionNote(notesInfo.path, 'Recovered Session');
+        notePath = createSessionNote(notesInfo.path, 'Untitled Session');
       } else {
+        // If the latest note is completed, reopen it for this session's checkpoints
+        // instead of creating a duplicate. This handles the case where session-stop
+        // finalized a note but the session continued (e.g., user said "end session"
+        // but kept working).
         try {
-          const noteContent = readFileSync(notePath, 'utf-8');
-          if (noteContent.includes('**Status:** Completed') || noteContent.includes('**Completed:**')) {
-            console.error(`Latest note is completed (${basename(notePath)}) — creating new one`);
-            notePath = createSessionNote(notesInfo.path, 'Continued Session');
+          let noteContent = readFileSync(notePath, 'utf-8');
+          if (noteContent.includes('**Status:** Completed')) {
+            noteContent = noteContent.replace('**Status:** Completed', '**Status:** In Progress');
+            writeFileSync(notePath, noteContent);
+            console.error(`Reopened completed note for continued session: ${basename(notePath)}`);
           }
         } catch { /* proceed with existing note */ }
       }
@@ -516,6 +623,21 @@ async function main() {
     }
   }
 
+  // -----------------------------------------------------------------------
+  // Enqueue session-summary work item with daemon for AI-powered note generation
+  // -----------------------------------------------------------------------
+  if (hookInput?.cwd) {
+    try {
+      await enqueueSessionSummary({
+        cwd: hookInput.cwd,
+        sessionId: hookInput.session_id,
+        transcriptPath: hookInput.transcript_path,
+      });
+    } catch (err) {
+      console.error(`Could not enqueue session-summary: ${err}`);
+    }
+  }
+
   // Send ntfy.sh notification
   const ntfyMessage = tokenCount > 0
     ? `Auto-pause: ~${Math.round(tokenCount / 1000)}k tokens`

package/src/hooks/ts/session-start/load-project-context.ts

@@ -17,7 +17,8 @@
  */
 
 import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
-import { join, basename, dirname } from 'path';
+import { join, basename, dirname, resolve } from 'path';
+import { homedir } from 'os';
 import { execSync } from 'child_process';
 import {
   PAI_DIR,
@@ -72,6 +73,64 @@ function getRoutedNotesPath(): string | null {
   return null;
 }
 
+/**
+ * Project signals that indicate a directory is a real project root.
+ */
+const PROJECT_SIGNALS = [
+  '.git',
+  'package.json',
+  'pubspec.yaml',
+  'Cargo.toml',
+  'go.mod',
+  'pyproject.toml',
+  'setup.py',
+  'build.gradle',
+  'pom.xml',
+  'composer.json',
+  'Gemfile',
+  'Makefile',
+  'CMakeLists.txt',
+  'tsconfig.json',
+  'CLAUDE.md',
+  join('Notes', 'PAI.md'),
+];
+
+/**
+ * Returns true if the given directory looks like a project root.
+ * Checks for the presence of well-known project signal files/dirs.
+ */
+function hasProjectSignals(dir: string): boolean {
+  for (const signal of PROJECT_SIGNALS) {
+    if (existsSync(join(dir, signal))) return true;
+  }
+  return false;
+}
+
+/**
+ * Returns true if the directory should NOT be auto-registered.
+ * Guards: home directory, shallow paths, temp directories.
+ */
+function isGuardedPath(dir: string): boolean {
+  const home = homedir();
+  const resolved = resolve(dir);
+
+  // Never register the home directory itself
+  if (resolved === home) return true;
+
+  // Depth guard: require at least 3 path segments beyond root
+  // e.g. /Users/i052341/foo is depth 3 on macOS — reject it
+  const parts = resolved.split('/').filter(Boolean);
+  if (parts.length < 3) return true;
+
+  // Temp/system directories
+  const forbidden = ['/tmp', '/var', '/private/tmp', '/private/var/folders'];
+  for (const prefix of forbidden) {
+    if (resolved === prefix || resolved.startsWith(prefix + '/')) return true;
+  }
+
+  return false;
+}
+
 interface HookInput {
   session_id: string;
   cwd: string;
@@ -311,9 +370,48 @@ async function main() {
       };
 
       if (detected.error === 'no_match') {
-        paiProjectBlock = `PAI Project Registry: No registered project matches this directory.
+        // Attempt auto-registration if the directory looks like a real project
+        let autoRegistered = false;
+
+        if (!isGuardedPath(cwd) && hasProjectSignals(cwd)) {
+          try {
+            execFileSync(paiBin, ['project', 'add', cwd], {
+              encoding: 'utf-8',
+              env: process.env,
+            });
+            console.error(`PAI auto-registered project at: ${cwd}`);
+
+            // Re-run detect to get the proper detection result
+            try {
+              const raw2 = execFileSync(paiBin, ['project', 'detect', '--json', cwd], {
+                encoding: 'utf-8',
+                env: process.env,
+              }).trim();
+
+              if (raw2) {
+                const detected2 = JSON.parse(raw2) as typeof detected;
+                if (detected2.slug) {
+                  const name2 = detected2.display_name || detected2.slug;
+                  console.error(`PAI auto-registered: "${detected2.slug}" (${detected2.match_type})`);
+                  paiProjectBlock = `PAI Project Registry: ${name2} (slug: ${detected2.slug}) [AUTO-REGISTERED]
+Match: ${detected2.match_type ?? 'exact'} | Sessions: 0`;
+                  autoRegistered = true;
+                }
+              }
+            } catch (detectErr) {
+              console.error('PAI auto-registration: project added but re-detect failed:', detectErr);
+              autoRegistered = true; // project IS registered, just can't load context
+            }
+          } catch (addErr) {
+            console.error('PAI auto-registration failed (project add):', addErr);
+          }
+        }
+
+        if (!autoRegistered) {
+          paiProjectBlock = `PAI Project Registry: No registered project matches this directory.
 Run "pai project add ." to register this project, or use /route to tag the session.`;
-        console.error('PAI detect: no match for', cwd);
+          console.error('PAI detect: no match for', cwd);
+        }
       } else if (detected.slug) {
         const name = detected.display_name || detected.slug;
         const nameSlug = ` (slug: ${detected.slug})`;

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

@@ -146,6 +146,67 @@ function enqueueWithDaemon(payload: {
   });
 }
 
+/**
+ * Enqueue a session-summary work item with the daemon for AI-powered note generation.
+ * Non-blocking — if daemon is unavailable, silently skips (the mechanical note is sufficient).
+ *
+ * Note: we intentionally omit transcriptPath here to let the worker call findLatestJsonl()
+ * itself. At session-end, Claude Code may still be moving the JSONL to sessions/, so a
+ * stale path passed from the hook could point to a file that no longer exists.
+ */
+function enqueueSessionSummaryWithDaemon(payload: {
+  cwd: 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-summary',
+          priority: 4,
+          payload: {
+            cwd: payload.cwd,
+            force: true,
+          },
+        },
+      }) + '\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; result?: { id: string } };
+        if (response.ok) {
+          console.error(`STOP-HOOK: Session summary enqueued (id=${response.result?.id}).`);
+        }
+      } catch { /* ignore */ }
+      finish(true);
+    });
+
+    client.on('error', () => finish(false));
+    client.on('end', () => { if (!done) finish(false); });
+
+    timer = setTimeout(() => finish(false), DAEMON_TIMEOUT_MS);
+  });
+}
+
 // ---------------------------------------------------------------------------
 // Direct execution — fallback path (original stop-hook logic)
 // ---------------------------------------------------------------------------
@@ -489,6 +550,11 @@ async function main() {
     await executeDirectly(lines, transcriptPath, cwd, message, lastUserQuery);
   }
 
+  // Also enqueue a session-summary for AI-powered note generation.
+  // We omit transcriptPath so the worker resolves it via findLatestJsonl(),
+  // avoiding a race where the session-end hook moves the JSONL before the worker reads it.
+  await enqueueSessionSummaryWithDaemon({ cwd });
+
   console.error(`STOP-HOOK COMPLETED SUCCESSFULLY at ${new Date().toISOString()}\n`);
 }