@tekmidian/pai 0.5.2 → 0.5.4

package/dist/hooks/context-compression-hook.mjs

@@ -7,8 +7,9 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/hooks/ts/pre-compact/context-compression-hook.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { join as join3, basename as basename2, dirname } from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename2, dirname, join as join3 } from "path";
+import { tmpdir } from "os";
 
 // src/hooks/ts/lib/project-utils.ts
 import { existsSync as existsSync2, mkdirSync, readdirSync, readFileSync as readFileSync2, writeFileSync, renameSync } from "fs";
@@ -74,6 +75,33 @@ validatePAIStructure();
 
 // src/hooks/ts/lib/project-utils.ts
 var PROJECTS_DIR = join2(PAI_DIR, "projects");
+function encodePath(path) {
+  return path.replace(/\//g, "-").replace(/\./g, "-").replace(/ /g, "-");
+}
+function getProjectDir(cwd) {
+  const encoded = encodePath(cwd);
+  return join2(PROJECTS_DIR, encoded);
+}
+function getNotesDir(cwd) {
+  return join2(getProjectDir(cwd), "Notes");
+}
+function findNotesDir(cwd) {
+  const cwdBasename = basename(cwd).toLowerCase();
+  if (cwdBasename === "notes" && existsSync2(cwd)) {
+    return { path: cwd, isLocal: true };
+  }
+  const localPaths = [
+    join2(cwd, "Notes"),
+    join2(cwd, "notes"),
+    join2(cwd, ".claude", "Notes")
+  ];
+  for (const path of localPaths) {
+    if (existsSync2(path)) {
+      return { path, isLocal: true };
+    }
+  }
+  return { path: getNotesDir(cwd), isLocal: false };
+}
 function isWhatsAppEnabled() {
   try {
     const { homedir: homedir2 } = __require("os");
@@ -122,6 +150,32 @@ async function sendNtfyNotification(message, retries = 2) {
   console.error("ntfy.sh notification failed after all retries");
   return false;
 }
+function getMonthDir(notesDir) {
+  const now = /* @__PURE__ */ new Date();
+  const year = String(now.getFullYear());
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const monthDir = join2(notesDir, year, month);
+  if (!existsSync2(monthDir)) {
+    mkdirSync(monthDir, { recursive: true });
+  }
+  return monthDir;
+}
+function getNextNoteNumber(notesDir) {
+  const monthDir = getMonthDir(notesDir);
+  const files = readdirSync(monthDir).filter((f) => f.match(/^\d{3,4}[\s_-]/)).filter((f) => f.endsWith(".md")).sort();
+  if (files.length === 0) {
+    return "0001";
+  }
+  let maxNumber = 0;
+  for (const file of files) {
+    const digitMatch = file.match(/^(\d+)/);
+    if (digitMatch) {
+      const num = parseInt(digitMatch[1], 10);
+      if (num > maxNumber) maxNumber = num;
+    }
+  }
+  return String(maxNumber + 1).padStart(4, "0");
+}
 function getCurrentNotePath(notesDir) {
   if (!existsSync2(notesDir)) {
     return null;
@@ -150,10 +204,77 @@ function getCurrentNotePath(notesDir) {
   if (prevFound) return prevFound;
   return findLatestIn(notesDir);
 }
+function createSessionNote(notesDir, description) {
+  const noteNumber = getNextNoteNumber(notesDir);
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const safeDescription = "New Session";
+  const monthDir = getMonthDir(notesDir);
+  const filename = `${noteNumber} - ${date} - ${safeDescription}.md`;
+  const filepath = join2(monthDir, filename);
+  const content = `# Session ${noteNumber}: ${description}
+
+**Date:** ${date}
+**Status:** In Progress
+
+---
+
+## Work Done
+
+<!-- PAI will add completed work here during session -->
+
+---
+
+## Next Steps
+
+<!-- To be filled at session end -->
+
+---
+
+**Tags:** #Session
+`;
+  writeFileSync(filepath, content);
+  console.error(`Created session note: ${filename}`);
+  return filepath;
+}
 function appendCheckpoint(notePath, checkpoint) {
   if (!existsSync2(notePath)) {
-    console.error(`Note file not found: ${notePath}`);
-    return;
+    console.error(`Note file not found, recreating: ${notePath}`);
+    try {
+      const parentDir = join2(notePath, "..");
+      if (!existsSync2(parentDir)) {
+        mkdirSync(parentDir, { recursive: true });
+      }
+      const noteFilename = basename(notePath);
+      const numberMatch = noteFilename.match(/^(\d+)/);
+      const noteNumber = numberMatch ? numberMatch[1] : "0000";
+      const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      const content2 = `# Session ${noteNumber}: Recovered
+
+**Date:** ${date}
+**Status:** In Progress
+
+---
+
+## Work Done
+
+<!-- PAI will add completed work here during session -->
+
+---
+
+## Next Steps
+
+<!-- To be filled at session end -->
+
+---
+
+**Tags:** #Session
+`;
+      writeFileSync(notePath, content2);
+      console.error(`Recreated session note: ${noteFilename}`);
+    } catch (err) {
+      console.error(`Failed to recreate note: ${err}`);
+      return;
+    }
   }
   const content = readFileSync2(notePath, "utf-8");
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -172,6 +293,43 @@ ${checkpoint}
   writeFileSync(notePath, newContent);
   console.error(`Checkpoint added to: ${basename(notePath)}`);
 }
+function addWorkToSessionNote(notePath, workItems, sectionTitle) {
+  if (!existsSync2(notePath)) {
+    console.error(`Note file not found: ${notePath}`);
+    return;
+  }
+  let content = readFileSync2(notePath, "utf-8");
+  let workText = "";
+  if (sectionTitle) {
+    workText += `
+### ${sectionTitle}
+
+`;
+  }
+  for (const item of workItems) {
+    const checkbox = item.completed !== false ? "[x]" : "[ ]";
+    workText += `- ${checkbox} **${item.title}**
+`;
+    if (item.details && item.details.length > 0) {
+      for (const detail of item.details) {
+        workText += `  - ${detail}
+`;
+      }
+    }
+  }
+  const workDoneMatch = content.match(/## Work Done\n\n(<!-- .*? -->)?/);
+  if (workDoneMatch) {
+    const insertPoint = content.indexOf(workDoneMatch[0]) + workDoneMatch[0].length;
+    content = content.substring(0, insertPoint) + workText + content.substring(insertPoint);
+  } else {
+    const nextStepsIndex = content.indexOf("## Next Steps");
+    if (nextStepsIndex !== -1) {
+      content = content.substring(0, nextStepsIndex) + workText + "\n" + content.substring(nextStepsIndex);
+    }
+  }
+  writeFileSync(notePath, content);
+  console.error(`Added ${workItems.length} work item(s) to: ${basename(notePath)}`);
+}
 function calculateSessionTokens(jsonlPath) {
   if (!existsSync2(jsonlPath)) {
     return 0;
@@ -199,8 +357,94 @@ function calculateSessionTokens(jsonlPath) {
     return 0;
   }
 }
+function findTodoPath(cwd) {
+  const localPaths = [
+    join2(cwd, "TODO.md"),
+    join2(cwd, "notes", "TODO.md"),
+    join2(cwd, "Notes", "TODO.md"),
+    join2(cwd, ".claude", "TODO.md")
+  ];
+  for (const path of localPaths) {
+    if (existsSync2(path)) {
+      return path;
+    }
+  }
+  return join2(getNotesDir(cwd), "TODO.md");
+}
+function ensureTodoMd(cwd) {
+  const todoPath = findTodoPath(cwd);
+  if (!existsSync2(todoPath)) {
+    const parentDir = join2(todoPath, "..");
+    if (!existsSync2(parentDir)) {
+      mkdirSync(parentDir, { recursive: true });
+    }
+    const content = `# TODO
+
+## Current Session
+
+- [ ] (Tasks will be tracked here)
+
+## Backlog
+
+- [ ] (Future tasks)
+
+---
+
+*Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}*
+`;
+    writeFileSync(todoPath, content);
+    console.error(`Created TODO.md: ${todoPath}`);
+  }
+  return todoPath;
+}
+function addTodoCheckpoint(cwd, checkpoint) {
+  const todoPath = ensureTodoMd(cwd);
+  let content = readFileSync2(todoPath, "utf-8");
+  content = content.replace(/(\n---\s*)*(\n\*Last updated:.*\*\s*)+$/g, "");
+  const checkpointText = `
+**Checkpoint (${(/* @__PURE__ */ new Date()).toISOString()}):** ${checkpoint}
+
+`;
+  const backlogIndex = content.indexOf("## Backlog");
+  if (backlogIndex !== -1) {
+    content = content.substring(0, backlogIndex) + checkpointText + content.substring(backlogIndex);
+  } else {
+    const continueIndex = content.indexOf("## Continue");
+    if (continueIndex !== -1) {
+      const afterContinue = content.indexOf("\n---", continueIndex);
+      if (afterContinue !== -1) {
+        const insertAt = afterContinue + 4;
+        content = content.substring(0, insertAt) + "\n" + checkpointText + content.substring(insertAt);
+      } else {
+        content = content.trimEnd() + "\n" + checkpointText;
+      }
+    } else {
+      content = content.trimEnd() + "\n" + checkpointText;
+    }
+  }
+  content = content.trimEnd() + `
+
+---
+
+*Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}*
+`;
+  writeFileSync(todoPath, content);
+  console.error(`Checkpoint added to TODO.md`);
+}
 
 // src/hooks/ts/pre-compact/context-compression-hook.ts
+function contentToText(content) {
+  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 "";
+}
 function getTranscriptStats(transcriptPath) {
   try {
     const content = readFileSync3(transcriptPath, "utf-8");
@@ -208,32 +452,165 @@ function getTranscriptStats(transcriptPath) {
     let userMessages = 0;
     let assistantMessages = 0;
     for (const line of lines) {
-      if (line.trim()) {
-        try {
-          const entry = JSON.parse(line);
-          if (entry.type === "user") {
-            userMessages++;
-          } else if (entry.type === "assistant") {
-            assistantMessages++;
-          }
-        } catch {
-        }
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === "user") userMessages++;
+        else if (entry.type === "assistant") assistantMessages++;
+      } catch {
       }
     }
     const totalMessages = userMessages + assistantMessages;
-    const isLarge = totalMessages > 50;
-    return { messageCount: totalMessages, isLarge };
-  } catch (error) {
+    return { messageCount: totalMessages, isLarge: totalMessages > 50 };
+  } catch {
     return { messageCount: 0, isLarge: false };
   }
 }
+function extractSessionState(transcriptPath, cwd) {
+  try {
+    const raw = readFileSync3(transcriptPath, "utf-8");
+    const lines = raw.trim().split("\n");
+    const userMessages = [];
+    const summaries = [];
+    const captures = [];
+    let lastCompleted = "";
+    const filesModified = /* @__PURE__ */ new Set();
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (entry.type === "user" && entry.message?.content) {
+        const text = contentToText(entry.message.content).slice(0, 300);
+        if (text) userMessages.push(text);
+      }
+      if (entry.type === "assistant" && entry.message?.content) {
+        const text = contentToText(entry.message.content);
+        const summaryMatch = text.match(/SUMMARY:\s*(.+?)(?:\n|$)/i);
+        if (summaryMatch) {
+          const s = summaryMatch[1].trim();
+          if (s.length > 5 && !summaries.includes(s)) summaries.push(s);
+        }
+        const captureMatch = text.match(/CAPTURE:\s*(.+?)(?:\n|$)/i);
+        if (captureMatch) {
+          const c = captureMatch[1].trim();
+          if (c.length > 5 && !captures.includes(c)) captures.push(c);
+        }
+        const completedMatch = text.match(/COMPLETED:\s*(.+?)(?:\n|$)/i);
+        if (completedMatch) {
+          lastCompleted = completedMatch[1].trim().replace(/\*+/g, "");
+        }
+      }
+      if (entry.type === "assistant" && entry.message?.content && Array.isArray(entry.message.content)) {
+        for (const block of entry.message.content) {
+          if (block.type === "tool_use") {
+            const tool = block.name;
+            if ((tool === "Edit" || tool === "Write") && block.input?.file_path) {
+              filesModified.add(block.input.file_path);
+            }
+          }
+        }
+      }
+    }
+    const parts = [];
+    if (cwd) {
+      parts.push(`Working directory: ${cwd}`);
+    }
+    const recentUser = userMessages.slice(-3);
+    if (recentUser.length > 0) {
+      parts.push("\nRecent user requests:");
+      for (const msg of recentUser) {
+        const firstLine = msg.split("\n")[0].slice(0, 200);
+        parts.push(`- ${firstLine}`);
+      }
+    }
+    const recentSummaries = summaries.slice(-3);
+    if (recentSummaries.length > 0) {
+      parts.push("\nWork summaries:");
+      for (const s of recentSummaries) {
+        parts.push(`- ${s.slice(0, 150)}`);
+      }
+    }
+    const recentCaptures = captures.slice(-5);
+    if (recentCaptures.length > 0) {
+      parts.push("\nCaptured context:");
+      for (const c of recentCaptures) {
+        parts.push(`- ${c.slice(0, 150)}`);
+      }
+    }
+    const files = Array.from(filesModified).slice(-10);
+    if (files.length > 0) {
+      parts.push("\nFiles modified this session:");
+      for (const f of files) {
+        parts.push(`- ${f}`);
+      }
+    }
+    if (lastCompleted) {
+      parts.push(`
+Last completed: ${lastCompleted.slice(0, 150)}`);
+    }
+    const result = parts.join("\n");
+    return result.length > 50 ? result : null;
+  } catch (err) {
+    console.error(`extractSessionState error: ${err}`);
+    return null;
+  }
+}
+function extractWorkFromTranscript(transcriptPath) {
+  try {
+    const raw = readFileSync3(transcriptPath, "utf-8");
+    const lines = raw.trim().split("\n");
+    const workItems = [];
+    const seenSummaries = /* @__PURE__ */ new Set();
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (entry.type === "assistant" && entry.message?.content) {
+        const text = contentToText(entry.message.content);
+        const summaryMatch = text.match(/SUMMARY:\s*(.+?)(?:\n|$)/i);
+        if (summaryMatch) {
+          const summary = summaryMatch[1].trim();
+          if (summary && !seenSummaries.has(summary) && summary.length > 5) {
+            seenSummaries.add(summary);
+            const details = [];
+            const actionsMatch = text.match(/ACTIONS:\s*(.+?)(?=\n[A-Z]+:|$)/is);
+            if (actionsMatch) {
+              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));
+            }
+            workItems.push({ title: summary, details: details.length > 0 ? details : void 0, completed: true });
+          }
+        }
+        const completedMatch = text.match(/COMPLETED:\s*(.+?)(?:\n|$)/i);
+        if (completedMatch && workItems.length === 0) {
+          const completed = completedMatch[1].trim().replace(/\*+/g, "");
+          if (completed && !seenSummaries.has(completed) && completed.length > 5) {
+            seenSummaries.add(completed);
+            workItems.push({ title: completed, completed: true });
+          }
+        }
+      }
+    }
+    return workItems;
+  } catch {
+    return [];
+  }
+}
 async function main() {
   let hookInput = null;
   try {
     const decoder = new TextDecoder();
     let input = "";
     const timeoutPromise = new Promise((resolve2) => {
-      setTimeout(() => resolve2(), 500);
+      setTimeout(resolve2, 500);
     });
     const readPromise = (async () => {
       for await (const chunk of process.stdin) {
@@ -244,34 +621,74 @@ async function main() {
     if (input.trim()) {
       hookInput = JSON.parse(input);
     }
-  } catch (error) {
+  } catch {
   }
-  const compactType = hookInput?.compact_type || "auto";
-  let message = "Compressing context to continue";
+  const compactType = hookInput?.compact_type || hookInput?.trigger || "auto";
   let tokenCount = 0;
-  if (hookInput && hookInput.transcript_path) {
+  if (hookInput?.transcript_path) {
     const stats = getTranscriptStats(hookInput.transcript_path);
     tokenCount = calculateSessionTokens(hookInput.transcript_path);
     const tokenDisplay = tokenCount > 1e3 ? `${Math.round(tokenCount / 1e3)}k` : String(tokenCount);
-    if (stats.messageCount > 0) {
-      if (compactType === "manual") {
-        message = `Manually compressing ${stats.messageCount} messages (~${tokenDisplay} tokens)`;
+    const state = extractSessionState(hookInput.transcript_path, hookInput.cwd);
+    try {
+      const notesInfo = hookInput.cwd ? findNotesDir(hookInput.cwd) : { path: join3(dirname(hookInput.transcript_path), "Notes"), isLocal: false };
+      let notePath = getCurrentNotePath(notesInfo.path);
+      if (!notePath) {
+        console.error("No session note found \u2014 creating one for checkpoint");
+        notePath = createSessionNote(notesInfo.path, "Recovered Session");
       } else {
-        message = stats.isLarge ? `Auto-compressing large context (~${tokenDisplay} tokens)` : `Compressing context (~${tokenDisplay} tokens)`;
+        try {
+          const noteContent = readFileSync3(notePath, "utf-8");
+          if (noteContent.includes("**Status:** Completed") || noteContent.includes("**Completed:**")) {
+            console.error(`Latest note is completed (${basename2(notePath)}) \u2014 creating new one`);
+            notePath = createSessionNote(notesInfo.path, "Continued Session");
+          }
+        } catch {
+        }
       }
-    }
-    try {
-      const transcriptDir = dirname(hookInput.transcript_path);
-      const notesDir = join3(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: ${basename2(currentNotePath)}`);
+      const checkpointBody = state ? `Context compression triggered at ~${tokenDisplay} tokens with ${stats.messageCount} messages.
+
+${state}` : `Context compression triggered at ~${tokenDisplay} tokens with ${stats.messageCount} messages.`;
+      appendCheckpoint(notePath, checkpointBody);
+      const workItems = extractWorkFromTranscript(hookInput.transcript_path);
+      if (workItems.length > 0) {
+        addWorkToSessionNote(notePath, workItems, `Pre-Compact (~${tokenDisplay} tokens)`);
+        console.error(`Added ${workItems.length} work item(s) to session note`);
       }
+      console.error(`Rich checkpoint saved: ${basename2(notePath)}`);
     } catch (noteError) {
       console.error(`Could not save checkpoint: ${noteError}`);
     }
+    if (hookInput.cwd && state) {
+      try {
+        addTodoCheckpoint(hookInput.cwd, `Pre-compact checkpoint (~${tokenDisplay} tokens):
+${state}`);
+        console.error("TODO.md checkpoint added");
+      } catch (todoError) {
+        console.error(`Could not update TODO.md: ${todoError}`);
+      }
+    }
+    if (state && hookInput.session_id) {
+      const injection = [
+        "<system-reminder>",
+        `SESSION STATE RECOVERED AFTER COMPACTION (${compactType}, ~${tokenDisplay} tokens)`,
+        "",
+        state,
+        "",
+        "IMPORTANT: This session state was captured before context compaction.",
+        "Use it to maintain continuity. Continue the conversation from where",
+        "it left off without asking the user to repeat themselves.",
+        "Continue with the last task that you were asked to work on.",
+        "</system-reminder>"
+      ].join("\n");
+      try {
+        const stateFile = join3(tmpdir(), `pai-compact-state-${hookInput.session_id}.txt`);
+        writeFileSync2(stateFile, injection, "utf-8");
+        console.error(`Session state saved to ${stateFile} (${injection.length} chars)`);
+      } catch (err) {
+        console.error(`Failed to save state file: ${err}`);
+      }
+    }
   }
   const ntfyMessage = tokenCount > 0 ? `Auto-pause: ~${Math.round(tokenCount / 1e3)}k tokens` : "Context compressing";
   await sendNtfyNotification(ntfyMessage);