@tekmidian/pai 0.3.2 → 0.4.0

package/dist/hooks/stop-hook.mjs

@@ -0,0 +1,625 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/hooks/ts/stop/stop-hook.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { basename as basename2, dirname } from "path";
+
+// src/hooks/ts/lib/project-utils.ts
+import { existsSync as existsSync2, mkdirSync, readdirSync, readFileSync as readFileSync2, writeFileSync, renameSync } from "fs";
+import { join as join2, basename } from "path";
+
+// src/hooks/ts/lib/pai-paths.ts
+import { homedir } from "os";
+import { resolve, join } from "path";
+import { existsSync, readFileSync } from "fs";
+function loadEnvFile() {
+  const possiblePaths = [
+    resolve(process.env.PAI_DIR || "", ".env"),
+    resolve(homedir(), ".claude", ".env")
+  ];
+  for (const envPath of possiblePaths) {
+    if (existsSync(envPath)) {
+      try {
+        const content = readFileSync(envPath, "utf-8");
+        for (const line of content.split("\n")) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith("#")) continue;
+          const eqIndex = trimmed.indexOf("=");
+          if (eqIndex > 0) {
+            const key = trimmed.substring(0, eqIndex).trim();
+            let value = trimmed.substring(eqIndex + 1).trim();
+            if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+              value = value.slice(1, -1);
+            }
+            value = value.replace(/\$HOME/g, homedir());
+            value = value.replace(/^~(?=\/|$)/, homedir());
+            if (process.env[key] === void 0) {
+              process.env[key] = value;
+            }
+          }
+        }
+        break;
+      } catch {
+      }
+    }
+  }
+}
+loadEnvFile();
+var PAI_DIR = process.env.PAI_DIR ? resolve(process.env.PAI_DIR) : resolve(homedir(), ".claude");
+var HOOKS_DIR = join(PAI_DIR, "Hooks");
+var SKILLS_DIR = join(PAI_DIR, "Skills");
+var AGENTS_DIR = join(PAI_DIR, "Agents");
+var HISTORY_DIR = join(PAI_DIR, "History");
+var COMMANDS_DIR = join(PAI_DIR, "Commands");
+function validatePAIStructure() {
+  if (!existsSync(PAI_DIR)) {
+    console.error(`PAI_DIR does not exist: ${PAI_DIR}`);
+    console.error(`   Expected ~/.claude or set PAI_DIR environment variable`);
+    process.exit(1);
+  }
+  if (!existsSync(HOOKS_DIR)) {
+    console.error(`PAI hooks directory not found: ${HOOKS_DIR}`);
+    console.error(`   Your PAI_DIR may be misconfigured`);
+    console.error(`   Current PAI_DIR: ${PAI_DIR}`);
+    process.exit(1);
+  }
+}
+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 getSessionsDirFromProjectDir(projectDir) {
+  return join2(projectDir, "sessions");
+}
+function isWhatsAppEnabled() {
+  try {
+    const { homedir: homedir2 } = __require("os");
+    const settingsPath = join2(homedir2(), ".claude", "settings.json");
+    if (!existsSync2(settingsPath)) return false;
+    const settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+    const enabled = settings.enabledMcpjsonServers || [];
+    return enabled.includes("whazaa");
+  } catch {
+    return false;
+  }
+}
+async function sendNtfyNotification(message, retries = 2) {
+  if (isWhatsAppEnabled()) {
+    console.error(`WhatsApp (Whazaa) enabled in MCP config \u2014 skipping ntfy`);
+    return true;
+  }
+  const topic = process.env.NTFY_TOPIC;
+  if (!topic) {
+    console.error("NTFY_TOPIC not set and WhatsApp not active \u2014 notifications disabled");
+    return false;
+  }
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const response = await fetch(`https://ntfy.sh/${topic}`, {
+        method: "POST",
+        body: message,
+        headers: {
+          "Title": "Claude Code",
+          "Priority": "default"
+        }
+      });
+      if (response.ok) {
+        console.error(`ntfy.sh notification sent (WhatsApp inactive): "${message}"`);
+        return true;
+      } else {
+        console.error(`ntfy.sh attempt ${attempt + 1} failed: ${response.status}`);
+      }
+    } catch (error) {
+      console.error(`ntfy.sh attempt ${attempt + 1} error: ${error}`);
+    }
+    if (attempt < retries) {
+      await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+    }
+  }
+  console.error("ntfy.sh notification failed after all retries");
+  return false;
+}
+function ensureSessionsDirFromProjectDir(projectDir) {
+  const sessionsDir = getSessionsDirFromProjectDir(projectDir);
+  if (!existsSync2(sessionsDir)) {
+    mkdirSync(sessionsDir, { recursive: true });
+    console.error(`Created sessions directory: ${sessionsDir}`);
+  }
+  return sessionsDir;
+}
+function moveSessionFilesToSessionsDir(projectDir, excludeFile, silent = false) {
+  const sessionsDir = ensureSessionsDirFromProjectDir(projectDir);
+  if (!existsSync2(projectDir)) {
+    return 0;
+  }
+  const files = readdirSync(projectDir);
+  let movedCount = 0;
+  for (const file of files) {
+    if (file.endsWith(".jsonl") && file !== excludeFile) {
+      const sourcePath = join2(projectDir, file);
+      const destPath = join2(sessionsDir, file);
+      try {
+        renameSync(sourcePath, destPath);
+        if (!silent) {
+          console.error(`Moved ${file} \u2192 sessions/`);
+        }
+        movedCount++;
+      } catch (error) {
+        if (!silent) {
+          console.error(`Could not move ${file}: ${error}`);
+        }
+      }
+    }
+  }
+  return movedCount;
+}
+function getCurrentNotePath(notesDir) {
+  if (!existsSync2(notesDir)) {
+    return null;
+  }
+  const findLatestIn = (dir) => {
+    if (!existsSync2(dir)) return null;
+    const files = readdirSync(dir).filter((f) => f.match(/^\d{3,4}[\s_-].*\.md$/)).sort((a, b) => {
+      const numA = parseInt(a.match(/^(\d+)/)?.[1] || "0", 10);
+      const numB = parseInt(b.match(/^(\d+)/)?.[1] || "0", 10);
+      return numA - numB;
+    });
+    if (files.length === 0) return null;
+    return join2(dir, files[files.length - 1]);
+  };
+  const now = /* @__PURE__ */ new Date();
+  const year = String(now.getFullYear());
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const currentMonthDir = join2(notesDir, year, month);
+  const found = findLatestIn(currentMonthDir);
+  if (found) return found;
+  const prevDate = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+  const prevYear = String(prevDate.getFullYear());
+  const prevMonth = String(prevDate.getMonth() + 1).padStart(2, "0");
+  const prevMonthDir = join2(notesDir, prevYear, prevMonth);
+  const prevFound = findLatestIn(prevMonthDir);
+  if (prevFound) return prevFound;
+  return findLatestIn(notesDir);
+}
+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 sanitizeForFilename(str) {
+  return str.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").substring(0, 50);
+}
+function extractMeaningfulName(noteContent, summary) {
+  const workDoneMatch = noteContent.match(/## Work Done\n\n([\s\S]*?)(?=\n---|\n## Next)/);
+  if (workDoneMatch) {
+    const workDoneSection = workDoneMatch[1];
+    const subheadings = workDoneSection.match(/### ([^\n]+)/g);
+    if (subheadings && subheadings.length > 0) {
+      const firstHeading = subheadings[0].replace("### ", "").trim();
+      if (firstHeading.length > 5 && firstHeading.length < 60) {
+        return sanitizeForFilename(firstHeading);
+      }
+    }
+    const boldMatches = workDoneSection.match(/\*\*([^*]+)\*\*/g);
+    if (boldMatches && boldMatches.length > 0) {
+      const firstBold = boldMatches[0].replace(/\*\*/g, "").trim();
+      if (firstBold.length > 3 && firstBold.length < 50) {
+        return sanitizeForFilename(firstBold);
+      }
+    }
+    const numberedItems = workDoneSection.match(/^\d+\.\s+\*\*([^*]+)\*\*/m);
+    if (numberedItems) {
+      return sanitizeForFilename(numberedItems[1]);
+    }
+  }
+  if (summary && summary.length > 5 && summary !== "Session completed.") {
+    const cleanSummary = summary.replace(/[^\w\s-]/g, " ").trim().split(/\s+/).slice(0, 5).join(" ");
+    if (cleanSummary.length > 3) {
+      return sanitizeForFilename(cleanSummary);
+    }
+  }
+  return "";
+}
+function renameSessionNote(notePath, meaningfulName) {
+  if (!meaningfulName || !existsSync2(notePath)) {
+    return notePath;
+  }
+  const dir = join2(notePath, "..");
+  const oldFilename = basename(notePath);
+  const correctMatch = oldFilename.match(/^(\d{3,4}) - (\d{4}-\d{2}-\d{2}) - .*\.md$/);
+  const legacyMatch = oldFilename.match(/^(\d{3,4})_(\d{4}-\d{2}-\d{2})_.*\.md$/);
+  const match = correctMatch || legacyMatch;
+  if (!match) {
+    return notePath;
+  }
+  const [, noteNumber, date] = match;
+  const titleCaseName = meaningfulName.split(/[\s_-]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ").trim();
+  const paddedNumber = noteNumber.padStart(4, "0");
+  const newFilename = `${paddedNumber} - ${date} - ${titleCaseName}.md`;
+  const newPath = join2(dir, newFilename);
+  if (newFilename === oldFilename) {
+    return notePath;
+  }
+  try {
+    renameSync(notePath, newPath);
+    console.error(`Renamed note: ${oldFilename} \u2192 ${newFilename}`);
+    return newPath;
+  } catch (error) {
+    console.error(`Could not rename note: ${error}`);
+    return notePath;
+  }
+}
+function finalizeSessionNote(notePath, summary) {
+  if (!existsSync2(notePath)) {
+    console.error(`Note file not found: ${notePath}`);
+    return notePath;
+  }
+  let content = readFileSync2(notePath, "utf-8");
+  if (content.includes("**Status:** Completed")) {
+    console.error(`Note already finalized: ${basename(notePath)}`);
+    return notePath;
+  }
+  content = content.replace("**Status:** In Progress", "**Status:** Completed");
+  if (!content.includes("**Completed:**")) {
+    const completionTime = (/* @__PURE__ */ new Date()).toISOString();
+    content = content.replace(
+      "---\n\n## Work Done",
+      `**Completed:** ${completionTime}
+
+---
+
+## Work Done`
+    );
+  }
+  const nextStepsMatch = content.match(/## Next Steps\n\n(<!-- .*? -->)/);
+  if (nextStepsMatch) {
+    content = content.replace(
+      nextStepsMatch[0],
+      `## Next Steps
+
+${summary || "Session completed."}`
+    );
+  }
+  writeFileSync(notePath, content);
+  console.error(`Session note finalized: ${basename(notePath)}`);
+  const meaningfulName = extractMeaningfulName(content, summary);
+  if (meaningfulName) {
+    const newPath = renameSessionNote(notePath, meaningfulName);
+    return newPath;
+  }
+  return notePath;
+}
+
+// src/hooks/ts/stop/stop-hook.ts
+function extractWorkFromTranscript(lines) {
+  const workItems = [];
+  const seenSummaries = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type === "assistant" && entry.message?.content) {
+        const content = contentToText(entry.message.content);
+        const summaryMatch = content.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 = content.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 = content.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
+            });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return workItems;
+}
+function generateTabTitle(prompt, completedLine) {
+  if (completedLine) {
+    const cleanCompleted = completedLine.replace(/\*+/g, "").replace(/\[.*?\]/g, "").replace(/COMPLETED:\s*/gi, "").trim();
+    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) {
+      const summary = completedWords.slice(0, 4);
+      while (summary.length < 4) {
+        summary.push("Done");
+      }
+      return summary.slice(0, 4).join(" ");
+    }
+  }
+  const cleanPrompt = prompt.replace(/[^\w\s]/g, " ").trim();
+  const words = cleanPrompt.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"].includes(word.toLowerCase())
+  );
+  const lowerPrompt = prompt.toLowerCase();
+  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 = [];
+  for (const verb of actionVerbs) {
+    if (lowerPrompt.includes(verb)) {
+      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;
+    }
+  }
+  const remainingWords = words.filter((word) => !actionVerbs.includes(word.toLowerCase())).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());
+  for (const word of remainingWords) {
+    if (titleWords.length < 4) {
+      titleWords.push(word);
+    } else {
+      break;
+    }
+  }
+  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(" ");
+}
+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 "";
+}
+async function main() {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  console.error(`
+STOP-HOOK TRIGGERED AT ${timestamp}`);
+  let input = "";
+  const decoder = new TextDecoder();
+  try {
+    for await (const chunk of process.stdin) {
+      input += decoder.decode(chunk, { stream: true });
+    }
+  } catch (e) {
+    console.error(`Error reading input: ${e}`);
+    process.exit(0);
+  }
+  if (!input) {
+    console.error("No input received");
+    process.exit(0);
+  }
+  let transcriptPath;
+  let cwd;
+  try {
+    const parsed = JSON.parse(input);
+    transcriptPath = parsed.transcript_path;
+    cwd = parsed.cwd || process.cwd();
+    console.error(`Transcript path: ${transcriptPath}`);
+    console.error(`Working directory: ${cwd}`);
+  } catch (e) {
+    console.error(`Error parsing input JSON: ${e}`);
+    process.exit(0);
+  }
+  if (!transcriptPath) {
+    console.error("No transcript_path in input");
+    process.exit(0);
+  }
+  let transcript;
+  try {
+    transcript = readFileSync3(transcriptPath, "utf-8");
+    console.error(`Transcript loaded: ${transcript.split("\n").length} lines`);
+  } catch (e) {
+    console.error(`Error reading transcript: ${e}`);
+    process.exit(0);
+  }
+  const lines = transcript.trim().split("\n");
+  let lastUserQuery = "";
+  for (let i = lines.length - 1; i >= 0; i--) {
+    try {
+      const entry = JSON.parse(lines[i]);
+      if (entry.type === "user" && entry.message?.content) {
+        const content = entry.message.content;
+        if (typeof content === "string") {
+          lastUserQuery = content;
+        } else if (Array.isArray(content)) {
+          for (const item of content) {
+            if (item.type === "text" && item.text) {
+              lastUserQuery = item.text;
+              break;
+            }
+          }
+        }
+        if (lastUserQuery) break;
+      }
+    } catch (e) {
+    }
+  }
+  let message = "";
+  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);
+      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);
+  }
+  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, "");
+    }
+  }
+  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}`);
+    }
+  }
+  console.error(`User query: ${lastUserQuery || "No query found"}`);
+  console.error(`Message: ${message || "No completion message"}`);
+  if (message) {
+    const finalTabTitle = message.slice(0, 50);
+    process.stderr.write(`\x1B]2;${finalTabTitle}\x07`);
+  }
+  if (message) {
+    await sendNtfyNotification(message);
+  } else {
+    await sendNtfyNotification("Session ended");
+  }
+  try {
+    const notesInfo = findNotesDir(cwd);
+    console.error(`Notes directory: ${notesInfo.path} (${notesInfo.isLocal ? "local" : "central"})`);
+    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: ${basename2(currentNotePath)}`);
+    }
+  } catch (noteError) {
+    console.error(`Could not finalize session note: ${noteError}`);
+  }
+  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}`);
+  }
+  console.error(`STOP-HOOK COMPLETED SUCCESSFULLY at ${(/* @__PURE__ */ new Date()).toISOString()}
+`);
+}
+main().catch(() => {
+});
+//# sourceMappingURL=stop-hook.mjs.map