@tekmidian/pai 0.5.7 → 0.6.0

package/src/hooks/ts/post-tool-use/observe.ts

@@ -0,0 +1,327 @@
+#!/usr/bin/env node
+/**
+ * PostToolUse Hook - Observation Capture
+ *
+ * Classifies each tool call as a structured observation and sends it to the
+ * PAI daemon via IPC. Fire-and-forget with a 5-second timeout. Never blocks
+ * Claude Code (always exits 0).
+ */
+
+import { connect } from 'net';
+import { sha256 } from '../../../utils/hash.js';
+import { basename } from 'path';
+import { isProbeSession } from '../lib/project-utils.js';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+interface HookData {
+  session_id: string;
+  tool_name: string;
+  tool_input: Record<string, unknown>;
+  tool_response?: unknown;
+  cwd?: string;
+}
+
+type ObservationType = 'change' | 'discovery' | 'decision' | 'feature';
+
+interface Observation {
+  type: ObservationType;
+  title: string;
+  narrative: string;
+  tool_name: string;
+  tool_input_summary: string;
+  files_read: string[];
+  files_modified: string[];
+  concepts: string[];
+}
+
+// ---------------------------------------------------------------------------
+// Tools to skip entirely
+// ---------------------------------------------------------------------------
+
+const SKIP_TOOLS = new Set([
+  'ToolSearch',
+  'AskUserQuestion',
+  'EnterPlanMode',
+  'ExitPlanMode',
+  'Skill',
+]);
+
+// ---------------------------------------------------------------------------
+// Inline IPC sender — avoids importing src/daemon/ipc-client.ts at build time
+// ---------------------------------------------------------------------------
+
+function sendToDaemon(method: string, params: Record<string, unknown>): Promise<void> {
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => { resolve(); }, 5000);
+    try {
+      const socket = connect('/tmp/pai.sock', () => {
+        const req = JSON.stringify({ id: Date.now().toString(), method, params }) + '\n';
+        socket.write(req);
+        socket.on('data', () => { clearTimeout(timeout); socket.destroy(); resolve(); });
+        socket.on('error', () => { clearTimeout(timeout); resolve(); });
+      });
+      socket.on('error', () => { clearTimeout(timeout); resolve(); });
+    } catch {
+      clearTimeout(timeout);
+      resolve();
+    }
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Concept extraction from file paths
+// ---------------------------------------------------------------------------
+
+const SKIP_SEGMENTS = new Set([
+  'src', 'dist', 'lib', 'bin', 'test', 'tests', 'spec', 'specs',
+  'node_modules', 'Users', 'home', 'usr', 'var', 'tmp', 'etc',
+  'hooks', 'scripts', 'config', 'configs', 'assets', 'static',
+  'public', 'private', 'build', 'out', 'output', 'generated',
+  'ts', 'js', 'mjs', 'cjs',
+]);
+
+function extractConcepts(paths: string[]): string[] {
+  const concepts = new Set<string>();
+  for (const p of paths) {
+    const segments = p.split('/').filter(Boolean);
+    for (const seg of segments) {
+      // Drop extensions
+      const clean = seg.replace(/\.[^.]+$/, '');
+      if (clean.length > 2 && !SKIP_SEGMENTS.has(clean) && !/^\d+$/.test(clean)) {
+        concepts.add(clean);
+      }
+    }
+  }
+  return Array.from(concepts).slice(0, 10);
+}
+
+// ---------------------------------------------------------------------------
+// Inline classifier
+// ---------------------------------------------------------------------------
+
+function str(v: unknown): string {
+  if (typeof v === 'string') return v;
+  return '';
+}
+
+function truncate(s: string, len: number): string {
+  return s.length > len ? s.slice(0, len) : s;
+}
+
+function classify(toolName: string, toolInput: Record<string, unknown>): Observation | null {
+  if (SKIP_TOOLS.has(toolName)) return null;
+
+  let type: ObservationType = 'discovery';
+  let title = '';
+  let narrative = '';
+  let tool_input_summary = '';
+  const files_read: string[] = [];
+  const files_modified: string[] = [];
+
+  switch (toolName) {
+    case 'Edit':
+    case 'MultiEdit': {
+      const fp = str(toolInput.file_path);
+      const name = fp ? basename(fp) : 'file';
+      type = 'change';
+      title = `Modified ${name}`;
+      narrative = fp ? `Edited ${fp}` : 'Edited a file';
+      tool_input_summary = fp;
+      files_modified.push(...(fp ? [fp] : []));
+      break;
+    }
+
+    case 'Write':
+    case 'NotebookEdit': {
+      const fp = str(toolInput.file_path);
+      const name = fp ? basename(fp) : 'file';
+      type = 'change';
+      title = `Created ${name}`;
+      narrative = fp ? `Wrote ${fp}` : 'Wrote a file';
+      tool_input_summary = fp;
+      files_modified.push(...(fp ? [fp] : []));
+      break;
+    }
+
+    case 'Read': {
+      const fp = str(toolInput.file_path);
+      const name = fp ? basename(fp) : 'file';
+      type = 'discovery';
+      title = `Read ${name}`;
+      narrative = fp ? `Read ${fp}` : 'Read a file';
+      tool_input_summary = fp;
+      files_read.push(...(fp ? [fp] : []));
+      break;
+    }
+
+    case 'Grep': {
+      const pattern = str(toolInput.pattern);
+      type = 'discovery';
+      title = `Searched for '${truncate(pattern, 40)}'`;
+      narrative = `Grep search: ${pattern}`;
+      tool_input_summary = pattern;
+      const gPath = str(toolInput.path || toolInput.file_path);
+      if (gPath) files_read.push(gPath);
+      break;
+    }
+
+    case 'Glob': {
+      const pattern = str(toolInput.pattern);
+      type = 'discovery';
+      title = `Found files: ${truncate(pattern, 40)}`;
+      narrative = `Glob pattern: ${pattern}`;
+      tool_input_summary = pattern;
+      break;
+    }
+
+    case 'Bash': {
+      const cmd = str(toolInput.command);
+      const cmdLower = cmd.toLowerCase();
+
+      if (/git\s+commit/.test(cmdLower)) {
+        type = 'decision';
+        // Try to extract the commit message after -m "..."
+        const mMatch = cmd.match(/-m\s+["']([^"']+)/);
+        const msg = mMatch ? mMatch[1] : cmd;
+        title = `Committed: ${truncate(msg, 60)}`;
+        narrative = `Git commit: ${msg}`;
+        tool_input_summary = truncate(cmd, 120);
+      } else if (/git\s+push/.test(cmdLower)) {
+        type = 'decision';
+        title = 'Pushed to remote';
+        narrative = `Git push: ${truncate(cmd, 80)}`;
+        tool_input_summary = truncate(cmd, 120);
+      } else if (/\b(jest|vitest|pytest|bun\s+test|npm\s+test|yarn\s+test|pnpm\s+test|node\s+--test)\b/.test(cmdLower)) {
+        type = 'feature';
+        title = 'Ran tests';
+        narrative = `Test run: ${truncate(cmd, 80)}`;
+        tool_input_summary = truncate(cmd, 120);
+      } else if (/\b(build|compile|bun\s+run\s+build|tsc|esbuild|webpack|vite\s+build)\b/.test(cmdLower)) {
+        type = 'feature';
+        title = 'Built project';
+        narrative = `Build: ${truncate(cmd, 80)}`;
+        tool_input_summary = truncate(cmd, 120);
+      } else {
+        type = 'discovery';
+        title = `Ran: ${truncate(cmd, 60)}`;
+        narrative = `Bash: ${truncate(cmd, 120)}`;
+        tool_input_summary = truncate(cmd, 120);
+      }
+      break;
+    }
+
+    case 'Task': {
+      const prompt = str(toolInput.prompt || toolInput.description);
+      type = 'discovery';
+      title = `Delegated: ${truncate(prompt, 60)}`;
+      narrative = `Spawned agent: ${truncate(prompt, 200)}`;
+      tool_input_summary = truncate(prompt, 200);
+      break;
+    }
+
+    case 'WebFetch': {
+      const url = str(toolInput.url);
+      type = 'discovery';
+      title = `Fetched: ${truncate(url, 60)}`;
+      narrative = `Web fetch: ${url}`;
+      tool_input_summary = url;
+      break;
+    }
+
+    case 'WebSearch': {
+      const query = str(toolInput.query);
+      type = 'discovery';
+      title = `Searched web: ${truncate(query, 60)}`;
+      narrative = `Web search: ${query}`;
+      tool_input_summary = query;
+      break;
+    }
+
+    default: {
+      // mcp__* tools and anything else
+      if (toolName.startsWith('mcp__')) {
+        type = 'discovery';
+        title = `MCP: ${toolName}`;
+        narrative = `Called MCP tool ${toolName}`;
+        tool_input_summary = toolName;
+      } else {
+        // Generic fallback — still capture rather than skip
+        type = 'discovery';
+        title = `Tool: ${toolName}`;
+        narrative = `Called ${toolName}`;
+        tool_input_summary = JSON.stringify(toolInput).slice(0, 120);
+      }
+      break;
+    }
+  }
+
+  const allPaths = [...files_read, ...files_modified];
+  const concepts = extractConcepts(allPaths);
+
+  return {
+    type,
+    title,
+    narrative,
+    tool_name: toolName,
+    tool_input_summary,
+    files_read,
+    files_modified,
+    concepts,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  try {
+    // Read stdin
+    const chunks: Buffer[] = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk as Buffer);
+    }
+    const raw = Buffer.concat(chunks).toString('utf-8').trim();
+    if (!raw) process.exit(0);
+
+    const hookData: HookData = JSON.parse(raw);
+
+    // Skip probe/health-check sessions
+    if (isProbeSession(hookData.cwd)) process.exit(0);
+
+    // Skip uninteresting tools
+    if (SKIP_TOOLS.has(hookData.tool_name)) process.exit(0);
+
+    // Classify
+    const obs = classify(hookData.tool_name, hookData.tool_input);
+    if (!obs) process.exit(0);
+
+    // Content-hash dedup key
+    const hash = sha256(hookData.session_id + hookData.tool_name + obs.title).slice(0, 16);
+
+    // Fire-and-forget to daemon
+    await sendToDaemon('observation_store', {
+      session_id: hookData.session_id,
+      type: obs.type,
+      title: obs.title,
+      narrative: obs.narrative,
+      tool_name: obs.tool_name,
+      tool_input_summary: obs.tool_input_summary,
+      files_read: obs.files_read,
+      files_modified: obs.files_modified,
+      concepts: obs.concepts,
+      content_hash: hash,
+      cwd: hookData.cwd ?? '',
+    });
+
+    process.exit(0);
+  } catch {
+    // Never block Claude Code
+    process.exit(0);
+  }
+}
+
+main();

package/src/hooks/ts/session-end/capture-session-summary.ts

@@ -58,6 +58,9 @@ async function main() {
     // Write session file
     writeFileSync(join(sessionDir, filename), sessionDoc);
 
+    // Also store structured summary via daemon IPC for the observations system
+    await storeStructuredSummary(data.conversation_id, sessionInfo);
+
     // Exit successfully
     process.exit(0);
   } catch (error) {
@@ -182,4 +185,42 @@ For detailed tool outputs, see: \`\${PAI_DIR}/History/raw-outputs/${timestamp.su
 `;
 }
 
+async function storeStructuredSummary(
+  sessionId: string,
+  info: { focus: string; filesChanged: string[]; commandsExecuted: string[]; toolsUsed: string[]; duration: number }
+): Promise<void> {
+  try {
+    const cwd = process.cwd();
+    const net = await import('net');
+
+    await new Promise<void>((resolve, _reject) => {
+      const client = net.createConnection('/tmp/pai.sock', () => {
+        const msg = JSON.stringify({
+          id: 1,
+          method: 'session_summary_store',
+          params: {
+            session_id: sessionId,
+            cwd,
+            request: null,      // We don't have the original request
+            investigated: null,
+            learned: null,
+            completed: info.filesChanged.length > 0
+              ? `Modified ${info.filesChanged.length} file(s): ${info.filesChanged.slice(0, 5).join(', ')}`
+              : null,
+            next_steps: null,
+            observation_count: 0,   // Will be filled by daemon from actual count
+          }
+        }) + '\n';
+        client.write(msg);
+      });
+
+      client.on('data', () => { client.end(); resolve(); });
+      client.on('error', () => resolve());  // Silent failure
+      setTimeout(() => { client.destroy(); resolve(); }, 3000);
+    });
+  } catch {
+    // Silent failure — don't disrupt session end
+  }
+}
+
 main();

package/src/hooks/ts/session-start/inject-observations.ts

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+
+/**
+ * inject-observations.ts
+ *
+ * SessionStart hook that injects recent project observation context into Claude's
+ * session as a <system-reminder>. Provides progressive disclosure of recent activity
+ * so Claude has immediate awareness of what has been happening in this project.
+ *
+ * Flow:
+ * 1. Read session data (session_id, cwd) from stdin
+ * 2. Call daemon via IPC: observation_recent with { cwd, limit: 25 }
+ *    (daemon resolves project_id from cwd internally via registry lookup)
+ * 3. Format as progressive disclosure context block
+ * 4. Output to stdout as <system-reminder> (injected into session by Claude Code)
+ *
+ * Silent on any failure — never blocks session start.
+ */
+
+import { connect } from 'net';
+import { randomUUID } from 'crypto';
+import { isProbeSession } from '../lib/project-utils.js';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+interface HookData {
+  session_id?: string;
+  cwd?: string;
+  hook_event_name?: string;
+}
+
+interface ObservationRow {
+  id: number;
+  session_id: string;
+  project_id: number | null;
+  project_slug: string | null;
+  type: string;
+  title: string;
+  narrative: string | null;
+  created_at: string; // ISO string after JSON serialization
+}
+
+interface ObservationRecentResult {
+  rows: ObservationRow[];
+  project_slug?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Inline IPC client — mirrors the pattern in observe.ts
+// Hooks can't import from src/daemon/ at runtime, so we inline this.
+// ---------------------------------------------------------------------------
+
+async function callDaemon(method: string, params: Record<string, unknown>): Promise<unknown> {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error('timeout')), 5000);
+    let buffer = '';
+
+    try {
+      const socket = connect('/tmp/pai.sock', () => {
+        socket.write(JSON.stringify({ id: randomUUID(), method, params }) + '\n');
+      });
+
+      socket.on('data', (chunk: Buffer) => {
+        buffer += chunk.toString();
+        const nl = buffer.indexOf('\n');
+        if (nl !== -1) {
+          clearTimeout(timeout);
+          try {
+            const response = JSON.parse(buffer.slice(0, nl));
+            socket.destroy();
+            if (response.ok) resolve(response.result);
+            else reject(new Error(response.error ?? 'daemon error'));
+          } catch (e) {
+            socket.destroy();
+            reject(e);
+          }
+        }
+      });
+
+      socket.on('error', () => {
+        clearTimeout(timeout);
+        reject(new Error('daemon unavailable'));
+      });
+    } catch {
+      clearTimeout(timeout);
+      reject(new Error('daemon unavailable'));
+    }
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Time formatting
+// ---------------------------------------------------------------------------
+
+function timeAgo(date: Date): string {
+  const diffMs = Date.now() - date.getTime();
+  const diffSec = Math.floor(diffMs / 1000);
+  const diffMin = Math.floor(diffSec / 60);
+  const diffHour = Math.floor(diffMin / 60);
+  const diffDay = Math.floor(diffHour / 24);
+
+  if (diffSec < 60) return 'just now';
+  if (diffMin < 60) return `${diffMin}m ago`;
+  if (diffHour < 24) return `${diffHour}h ago`;
+  if (diffDay < 7) return `${diffDay}d ago`;
+
+  // Older than a week: show date string
+  return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' });
+}
+
+// ---------------------------------------------------------------------------
+// Type label
+// ---------------------------------------------------------------------------
+
+function typeLabel(type: string): string {
+  switch (type) {
+    case 'change':    return '[change]';
+    case 'discovery': return '[discovery]';
+    case 'decision':  return '[decision]';
+    case 'bugfix':    return '[bugfix]';
+    case 'feature':   return '[feature]';
+    case 'refactor':  return '[refactor]';
+    default:          return `[${type}]`;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Truncate
+// ---------------------------------------------------------------------------
+
+function truncate(s: string, maxLen: number): string {
+  return s.length > maxLen ? s.slice(0, maxLen - 1) + '\u2026' : s;
+}
+
+// ---------------------------------------------------------------------------
+// Format observations as progressive disclosure context
+// ---------------------------------------------------------------------------
+
+function formatContext(
+  projectSlug: string,
+  observations: ObservationRow[]
+): string {
+  if (observations.length === 0) return '';
+
+  // Count distinct sessions
+  const sessionSet = new Set(observations.map(o => o.session_id));
+  const sessionCount = sessionSet.size;
+
+  // Most recent observation
+  const newest = new Date(observations[0].created_at);
+  const lastActivity = timeAgo(newest);
+
+  // Timeline: show most recent 15, keep titles to 80 chars
+  const timelineObs = observations.slice(0, 15);
+  const timeline = timelineObs
+    .map(o => {
+      const t = timeAgo(new Date(o.created_at));
+      const label = typeLabel(o.type);
+      const title = truncate(o.title, 80);
+      return `- [${t}] ${label} ${title}`;
+    })
+    .join('\n');
+
+  const showingNote = observations.length > 15
+    ? `(showing most recent 15 of ${observations.length}, use observation_search for more)`
+    : `(showing ${observations.length} observation${observations.length !== 1 ? 's' : ''})`;
+
+  const lines: string[] = [
+    `<system-reminder>`,
+    `OBSERVATION CONTEXT (auto-injected)`,
+    ``,
+    `## Recent Activity (${projectSlug})`,
+    `${observations.length} observations across ${sessionCount} session${sessionCount !== 1 ? 's' : ''} | Last activity: ${lastActivity}`,
+    ``,
+    `### Recent Timeline`,
+    timeline,
+    showingNote,
+    `</system-reminder>`,
+  ];
+
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  try {
+    // Skip probe/health-check sessions
+    if (isProbeSession()) {
+      process.exit(0);
+    }
+
+    // Skip subagent sessions — they don't need observation context
+    const claudeProjectDir = process.env.CLAUDE_PROJECT_DIR || '';
+    const isSubagent = claudeProjectDir.includes('/.claude/agents/') ||
+                       process.env.CLAUDE_AGENT_TYPE !== undefined;
+    if (isSubagent) {
+      process.exit(0);
+    }
+
+    // Read hook data from stdin
+    let hookData: HookData = {};
+    try {
+      const chunks: Buffer[] = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(chunk as Buffer);
+      }
+      const raw = Buffer.concat(chunks).toString('utf-8').trim();
+      if (raw) {
+        hookData = JSON.parse(raw);
+      }
+    } catch {
+      // Non-fatal — fall back to process.cwd()
+    }
+
+    const cwd = hookData.cwd || process.cwd();
+
+    // Fetch recent observations for this cwd — daemon resolves the project internally
+    let observations: ObservationRow[];
+    let projectSlug: string;
+
+    try {
+      const result = await callDaemon('observation_recent', { cwd, limit: 25 }) as ObservationRecentResult;
+      observations = result?.rows ?? [];
+      projectSlug = result?.project_slug ?? '';
+    } catch {
+      // Daemon unavailable or Postgres not configured — silent exit
+      process.exit(0);
+    }
+
+    if (!observations || observations.length === 0 || !projectSlug) {
+      // No data or no matching project — nothing to inject
+      process.exit(0);
+    }
+
+    // Format and output
+    const context = formatContext(projectSlug, observations);
+    if (context) {
+      // Output to stdout — Claude Code captures this and injects into session context
+      console.log(context);
+    }
+
+    process.exit(0);
+  } catch {
+    // Never block session start
+    process.exit(0);
+  }
+}
+
+main();