@tekmidian/pai 0.3.2 → 0.4.0

package/dist/hooks/load-project-context.mjs

@@ -0,0 +1,548 @@
+#!/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/session-start/load-project-context.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync } from "fs";
+import { join as join3, basename as basename2, dirname } from "path";
+import { execSync } from "child_process";
+
+// 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 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 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;
+  }
+  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 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 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 findAllClaudeMdPaths(cwd) {
+  const foundPaths = [];
+  const localPaths = [
+    join2(cwd, ".claude", "CLAUDE.md"),
+    join2(cwd, "CLAUDE.md"),
+    join2(cwd, "Notes", "CLAUDE.md"),
+    join2(cwd, "notes", "CLAUDE.md"),
+    join2(cwd, "Prompts", "CLAUDE.md"),
+    join2(cwd, "prompts", "CLAUDE.md")
+  ];
+  for (const path of localPaths) {
+    if (existsSync2(path)) {
+      foundPaths.push(path);
+    }
+  }
+  return foundPaths;
+}
+
+// src/hooks/ts/session-start/load-project-context.ts
+function findPaiBinary() {
+  try {
+    return execSync("which pai", { encoding: "utf-8" }).trim();
+  } catch {
+    const fallbacks = [
+      "/usr/local/bin/pai",
+      "/opt/homebrew/bin/pai",
+      `${process.env.HOME}/.local/bin/pai`
+    ];
+    for (const p of fallbacks) {
+      if (existsSync3(p)) return p;
+    }
+  }
+  return "pai";
+}
+function getRoutedNotesPath() {
+  const routingFile = join3(PAI_DIR, "session-routing.json");
+  if (!existsSync3(routingFile)) return null;
+  try {
+    const routing = JSON.parse(readFileSync3(routingFile, "utf-8"));
+    const active = routing?.active_session;
+    if (active?.notes_path) {
+      return active.notes_path;
+    }
+  } catch {
+  }
+  return null;
+}
+async function main() {
+  console.error("\nload-project-context.ts starting...");
+  let hookInput = null;
+  try {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    const input = Buffer.concat(chunks).toString("utf-8");
+    if (input.trim()) {
+      hookInput = JSON.parse(input);
+    }
+  } catch (error) {
+    console.error("Could not parse hook input, using process.cwd()");
+  }
+  const cwd = hookInput?.cwd || process.cwd();
+  let projectName = basename2(cwd);
+  if (projectName.toLowerCase() === "notes") {
+    projectName = basename2(dirname(cwd));
+  }
+  console.error(`Working directory: ${cwd}`);
+  console.error(`Project: ${projectName}`);
+  const isSubagent = process.env.CLAUDE_AGENT_TYPE !== void 0 || (process.env.CLAUDE_PROJECT_DIR || "").includes("/.claude/agents/");
+  if (isSubagent) {
+    console.error("Subagent session - skipping project context setup");
+    process.exit(0);
+  }
+  const claudeMdPaths = findAllClaudeMdPaths(cwd);
+  const claudeMdContents = [];
+  if (claudeMdPaths.length > 0) {
+    console.error(`Found ${claudeMdPaths.length} CLAUDE.md file(s):`);
+    for (const path of claudeMdPaths) {
+      console.error(`   - ${path}`);
+      try {
+        const content = readFileSync3(path, "utf-8");
+        claudeMdContents.push({ path, content });
+        console.error(`     Read ${content.length} chars`);
+      } catch (error) {
+        console.error(`     Could not read: ${error}`);
+      }
+    }
+  } else {
+    console.error("No CLAUDE.md found in project");
+    console.error("   Consider creating one at ./CLAUDE.md or ./.claude/CLAUDE.md");
+  }
+  const routedPath = getRoutedNotesPath();
+  let notesDir;
+  if (routedPath) {
+    const { mkdirSync: mkdirSync2 } = await import("fs");
+    if (!existsSync3(routedPath)) {
+      mkdirSync2(routedPath, { recursive: true });
+      console.error(`Created routed Notes: ${routedPath}`);
+    } else {
+      console.error(`Notes directory: ${routedPath} (routed via pai route)`);
+    }
+    notesDir = routedPath;
+  } else {
+    const notesInfo = findNotesDir(cwd);
+    if (notesInfo.isLocal) {
+      notesDir = notesInfo.path;
+      console.error(`Notes directory: ${notesDir} (local)`);
+    } else {
+      if (!existsSync3(notesInfo.path)) {
+        const { mkdirSync: mkdirSync2 } = await import("fs");
+        mkdirSync2(notesInfo.path, { recursive: true });
+        console.error(`Created central Notes: ${notesInfo.path}`);
+      } else {
+        console.error(`Notes directory: ${notesInfo.path} (central)`);
+      }
+      notesDir = notesInfo.path;
+    }
+  }
+  const projectDir = getProjectDir(cwd);
+  if (existsSync3(projectDir)) {
+    try {
+      const files = readdirSync2(projectDir);
+      const jsonlFiles = files.filter((f) => f.endsWith(".jsonl")).map((f) => ({
+        name: f,
+        path: join3(projectDir, f),
+        mtime: statSync(join3(projectDir, f)).mtime.getTime()
+      })).sort((a, b) => b.mtime - a.mtime);
+      if (jsonlFiles.length > 1) {
+        const { mkdirSync: mkdirSync2, renameSync: renameSync2 } = await import("fs");
+        const sessionsDir = join3(projectDir, "sessions");
+        if (!existsSync3(sessionsDir)) {
+          mkdirSync2(sessionsDir, { recursive: true });
+        }
+        for (let i = 1; i < jsonlFiles.length; i++) {
+          const file = jsonlFiles[i];
+          const destPath = join3(sessionsDir, file.name);
+          if (!existsSync3(destPath)) {
+            renameSync2(file.path, destPath);
+            console.error(`Moved old session: ${file.name} \u2192 sessions/`);
+          }
+        }
+      }
+    } catch (error) {
+      console.error(`Could not cleanup old .jsonl files: ${error}`);
+    }
+  }
+  const todoPath = findTodoPath(cwd);
+  const hasTodo = existsSync3(todoPath);
+  if (hasTodo) {
+    console.error(`TODO.md: ${todoPath}`);
+  } else {
+    const newTodoPath = join3(notesDir, "TODO.md");
+    const { writeFileSync: writeFileSync2 } = await import("fs");
+    writeFileSync2(newTodoPath, `# TODO
+
+## Offen
+
+- [ ] 
+
+---
+
+*Created: ${(/* @__PURE__ */ new Date()).toISOString()}*
+`);
+    console.error(`Created TODO.md: ${newTodoPath}`);
+  }
+  let activeNotePath = null;
+  if (notesDir) {
+    const currentNotePath = getCurrentNotePath(notesDir);
+    let needsNewNote = false;
+    if (!currentNotePath) {
+      needsNewNote = true;
+      console.error("\nNo previous session notes found - creating new one");
+    } else {
+      try {
+        const content = readFileSync3(currentNotePath, "utf-8");
+        if (content.includes("**Status:** Completed") || content.includes("**Completed:**")) {
+          needsNewNote = true;
+          console.error(`
+Previous 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(`
+Continuing session note: ${basename2(currentNotePath)}`);
+        }
+      } catch {
+        needsNewNote = true;
+      }
+    }
+    if (needsNewNote) {
+      activeNotePath = createSessionNote(notesDir, projectName);
+      console.error(`Created: ${basename2(activeNotePath)}`);
+    } else {
+      activeNotePath = currentNotePath;
+      try {
+        const content = readFileSync3(activeNotePath, "utf-8");
+        const lines = content.split("\n").slice(0, 12);
+        console.error("--- Current Note Preview ---");
+        for (const line of lines) {
+          console.error(line);
+        }
+        console.error("--- End Preview ---\n");
+      } catch {
+      }
+    }
+  }
+  if (existsSync3(todoPath)) {
+    try {
+      const todoContent = readFileSync3(todoPath, "utf-8");
+      const todoLines = todoContent.split("\n").filter((l) => l.includes("[ ]")).slice(0, 5);
+      if (todoLines.length > 0) {
+        console.error("\nOpen TODOs:");
+        for (const line of todoLines) {
+          console.error(`   ${line.trim()}`);
+        }
+      }
+    } catch {
+    }
+  }
+  await sendNtfyNotification(`Session started in ${projectName}`);
+  const paiBin = findPaiBinary();
+  let paiProjectBlock = "";
+  try {
+    const { execFileSync } = await import("child_process");
+    const raw = execFileSync(paiBin, ["project", "detect", "--json", cwd], {
+      encoding: "utf-8",
+      env: process.env
+    }).trim();
+    if (raw) {
+      const detected = JSON.parse(raw);
+      if (detected.error === "no_match") {
+        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);
+      } else if (detected.slug) {
+        const name = detected.display_name || detected.slug;
+        const nameSlug = ` (slug: ${detected.slug})`;
+        const matchDesc = detected.match_type === "exact" ? "exact" : `parent (+${detected.relative_path ?? ""})`;
+        const statusFlag = detected.status && detected.status !== "active" ? ` [${detected.status.toUpperCase()}]` : "";
+        paiProjectBlock = `PAI Project Registry: ${name}${statusFlag}${nameSlug}
+Match: ${matchDesc} | Sessions: ${detected.session_count ?? 0}${detected.status && detected.status !== "active" ? `
+WARNING: Project status is "${detected.status}". Run: pai project health --fix` : ""}`;
+        console.error(`PAI detect: matched "${detected.slug}" (${detected.match_type})`);
+      }
+    }
+  } catch (e) {
+    console.error("pai project detect failed:", e);
+  }
+  const reminder = `
+<system-reminder>
+PROJECT CONTEXT LOADED
+
+Project: ${projectName}
+Working Directory: ${cwd}
+${notesDir ? `Notes Directory: ${notesDir}${routedPath ? " (routed via pai route)" : ""}` : "Notes: disabled (no local Notes/ directory)"}
+${hasTodo ? `TODO: ${todoPath}` : "TODO: not found"}
+${claudeMdPaths.length > 0 ? `CLAUDE.md: ${claudeMdPaths.join(", ")}` : "No CLAUDE.md found"}
+${activeNotePath ? `Active Note: ${basename2(activeNotePath)}` : ""}
+${routedPath ? `
+Note Routing: ACTIVE (pai route is set - notes go to Obsidian vault)` : ""}
+${paiProjectBlock ? `
+${paiProjectBlock}` : ""}
+Session Commands:
+- "pause session" \u2192 Save checkpoint, update TODO, exit (no compact)
+- "end session" \u2192 Finalize note, commit if needed, start fresh next time
+- "pai route clear" \u2192 Clear note routing (in a new session)
+</system-reminder>
+`;
+  console.log(reminder);
+  for (const { path, content } of claudeMdContents) {
+    const claudeMdReminder = `
+<system-reminder>
+LOCAL CLAUDE.md LOADED (MANDATORY - READ AND FOLLOW)
+
+Source: ${path}
+
+${content}
+
+---
+THE ABOVE INSTRUCTIONS ARE MANDATORY. Follow them exactly.
+</system-reminder>
+`;
+    console.log(claudeMdReminder);
+    console.error(`Injected CLAUDE.md content from: ${path}`);
+  }
+  console.error("\nProject context setup complete\n");
+  process.exit(0);
+}
+main().catch((error) => {
+  console.error("load-project-context.ts error:", error);
+  process.exit(0);
+});
+//# sourceMappingURL=load-project-context.mjs.map