@tekmidian/pai 0.7.0 → 0.7.2

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

@@ -22,6 +22,7 @@ import {
   createSessionNote,
   appendCheckpoint,
   addWorkToSessionNote,
+  isMeaningfulTitle,
   findNotesDir,
   renameSessionNote,
   updateTodoContinue,
@@ -233,50 +234,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`
+    );
   }
 
-  // Clean up for filename use
-  return title
-    .replace(/[^\w\s-]/g, ' ')   // Remove special chars
-    .replace(/\s+/g, ' ')        // Normalize whitespace
-    .trim()
-    .substring(0, 60);
+  // 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;
+    }
+  }
+
+  // All candidates were garbage — return empty (caller will not rename)
+  return '';
 }
 
 // ---------------------------------------------------------------------------
@@ -402,23 +416,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 */ }
       }

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;
@@ -239,36 +298,20 @@ async function main() {
   if (notesDir) {  // notesDir is always set now (local or central)
     const currentNotePath = getCurrentNotePath(notesDir);
 
-    // Determine if we need a new note
-    let needsNewNote = false;
+    // Only create a new note if there is truly no note at all.
+    // A completed note is still used — it will be updated or continued.
+    // This prevents duplicate notes at month boundaries and on every compaction.
     if (!currentNotePath) {
-      needsNewNote = true;
+      // Defensive: ensure projectName is a usable string
+      const safeProjectName = (typeof projectName === 'string' && projectName.trim().length > 0)
+        ? projectName.trim()
+        : 'Untitled Session';
       console.error('\nNo previous session notes found - creating new one');
-    } else {
-      // Check if the existing note is completed
-      try {
-        const content = readFileSync(currentNotePath, 'utf-8');
-        if (content.includes('**Status:** Completed') || content.includes('**Completed:**')) {
-          needsNewNote = true;
-          console.error(`\nPrevious note completed - creating new one`);
-          const summaryMatch = content.match(/## Next Steps\n\n([^\n]+)/);
-          if (summaryMatch) {
-            console.error(`   Previous: ${summaryMatch[1].substring(0, 60)}...`);
-          }
-        } else {
-          console.error(`\nContinuing session note: ${basename(currentNotePath)}`);
-        }
-      } catch {
-        needsNewNote = true;
-      }
-    }
-
-    // Create new note if needed
-    if (needsNewNote) {
-      activeNotePath = createSessionNote(notesDir, projectName);
+      activeNotePath = createSessionNote(notesDir, String(safeProjectName));
       console.error(`Created: ${basename(activeNotePath)}`);
     } else {
       activeNotePath = currentNotePath!;
+      console.error(`\nUsing existing session note: ${basename(activeNotePath)}`);
       // Show preview of current note
       try {
         const content = readFileSync(activeNotePath, 'utf-8');
@@ -327,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})`;