@recall_v3/mcp-server 0.1.0 → 3.0.0

package/src/tools/saveSession.ts

@@ -2,18 +2,22 @@
  * saveSession Tool Implementation
  *
  * Saves a summary of what was accomplished in this coding session.
- * Updates the team memory files via the Recall API.
+ * Encrypts content with team key and sends to Recall v3 API.
  */
 
 import { RecallApiClient, AuthenticationError, RecallApiError } from '../api/client.js';
 import { getApiBaseUrl, getApiToken, getTeamKey, setTeamKey } from '../config/index.js';
-import { encryptContent } from '../crypto/index.js';
+import { encryptForApi } from '../crypto/index.js';
 import { successResponse, errorResponse, type ToolResponse } from './types.js';
 import { resolveProjectPath, getRepoInfo } from './utils.js';
-import type { SaveSessionRequest } from '@recall_v3/shared';
 
 export interface SaveSessionArgs {
-  summary: string;
+  /** Pre-written summary (if transcript not provided) */
+  summary?: string;
+  /** Raw conversation transcript - will be summarized by AI */
+  transcript?: string;
+  /** Git repository path (defaults to cwd if not provided) */
+  projectPath?: string;
   decisions?: Array<{
     what: string;
     why: string;
@@ -24,17 +28,172 @@ export interface SaveSessionArgs {
   blockers?: string;
 }
 
+/**
+ * Request body for the summarize API (matches actual API, not shared types)
+ */
+interface SummarizeApiRequest {
+  transcript: string;
+  repo_name?: string;
+  developer?: string;
+  tool?: 'claude-code' | 'cursor' | 'copilot' | 'other';
+  tier?: 'team' | 'pro' | 'enterprise';
+  started_at?: string;
+  ended_at?: string;
+}
+
+/**
+ * Response from the summarize API (matches actual API response)
+ */
+interface SummarizeApiResponse {
+  session_title: string;
+  summary: string;
+  detailed_summary?: string;
+  status: string;
+  tldr: {
+    summary: string;
+    status: string;
+    decisions: string[];
+    mistakes: string[];
+    tags: string[];
+    files_changed: string[];
+  };
+  decisions: Array<{
+    title: string;
+    what: string;
+    why: string;
+    alternatives: Array<{ option: string; rejected_because: string }>;
+    confidence: string;
+  }>;
+  failures: Array<{
+    title: string;
+    what_tried: string;
+    what_happened: string;
+    root_cause: string;
+    resolution: string;
+  }>;
+  lessons: Array<{
+    title: string;
+    lesson: string;
+    when_applies: string;
+  }>;
+  quality_metadata: {
+    understandingScore: number;
+    accuracyScore: number;
+    attempts: number;
+  };
+}
+
+/**
+ * Build the full session content to encrypt
+ */
+function buildSessionContent(args: SaveSessionArgs): string {
+  const parts: string[] = [];
+
+  parts.push('## Summary');
+  parts.push((args.summary || 'Session saved').trim());
+  parts.push('');
+
+  if (args.decisions && args.decisions.length > 0) {
+    parts.push('## Decisions');
+    for (const decision of args.decisions) {
+      parts.push(`- **${decision.what}**: ${decision.why}`);
+    }
+    parts.push('');
+  }
+
+  if (args.mistakes && args.mistakes.length > 0) {
+    parts.push('## Mistakes / Gotchas');
+    for (const mistake of args.mistakes) {
+      parts.push(`- ${mistake}`);
+    }
+    parts.push('');
+  }
+
+  if (args.filesChanged && args.filesChanged.length > 0) {
+    parts.push('## Files Changed');
+    for (const file of args.filesChanged) {
+      parts.push(`- ${file}`);
+    }
+    parts.push('');
+  }
+
+  if (args.nextSteps) {
+    parts.push('## Next Steps');
+    parts.push(args.nextSteps.trim());
+    parts.push('');
+  }
+
+  if (args.blockers) {
+    parts.push('## Blockers');
+    parts.push(args.blockers.trim());
+    parts.push('');
+  }
+
+  return parts.join('\n');
+}
+
+/**
+ * Build TLDR metadata for the session
+ */
+function buildTldr(args: SaveSessionArgs): {
+  summary: string;
+  status: 'complete' | 'in-progress' | 'blocked';
+  decisions?: string[];
+  mistakes?: string[];
+  tags?: string[];
+  files_changed?: string[];
+  blockers?: string | null;
+  next_steps?: string | null;
+} {
+  const tldr: {
+    summary: string;
+    status: 'complete' | 'in-progress' | 'blocked';
+    decisions?: string[];
+    mistakes?: string[];
+    tags?: string[];
+    files_changed?: string[];
+    blockers?: string | null;
+    next_steps?: string | null;
+  } = {
+    summary: (args.summary || 'Session saved').trim().substring(0, 200),
+    status: args.blockers ? 'blocked' : 'complete',
+  };
+
+  if (args.decisions && args.decisions.length > 0) {
+    tldr.decisions = args.decisions.map(d => d.what);
+  }
+
+  if (args.mistakes && args.mistakes.length > 0) {
+    tldr.mistakes = args.mistakes;
+  }
+
+  if (args.filesChanged && args.filesChanged.length > 0) {
+    tldr.files_changed = args.filesChanged;
+  }
+
+  if (args.nextSteps) {
+    tldr.next_steps = args.nextSteps.trim();
+  }
+
+  if (args.blockers) {
+    tldr.blockers = args.blockers.trim();
+  }
+
+  return tldr;
+}
+
 /**
  * Execute the saveSession tool
  *
- * @param args - Tool arguments with session summary and metadata
+ * @param args - Tool arguments with session summary/transcript and metadata
  * @returns MCP tool response with save confirmation
  */
 export async function saveSession(args: SaveSessionArgs): Promise<ToolResponse> {
   try {
-    // Validate required fields
-    if (!args.summary || args.summary.trim().length === 0) {
-      return errorResponse('Summary is required. Please provide a description of what was accomplished.');
+    // Validate required fields - need either summary or transcript
+    if ((!args.summary || args.summary.trim().length === 0) &&
+        (!args.transcript || args.transcript.trim().length === 0)) {
+      return errorResponse('Either summary or transcript is required. Please provide a description of what was accomplished or the session transcript.');
     }
 
     // Get API token
@@ -45,15 +204,16 @@ export async function saveSession(args: SaveSessionArgs): Promise<ToolResponse>
       );
     }
 
-    // Resolve project path (use cwd since projectPath is not in args)
-    const projectPath = resolveProjectPath(undefined);
+    // Resolve project path (use args.projectPath if provided, otherwise cwd)
+    const projectPath = resolveProjectPath(args.projectPath);
 
     // Get repo info from git
     const repoInfo = await getRepoInfo(projectPath);
     if (!repoInfo) {
       return errorResponse(
         `Could not determine repository info for: ${projectPath}\n` +
-        'Make sure this is a git repository with a remote origin.'
+        'Make sure this is a git repository with a remote origin.\n' +
+        'If running from Claude Code hooks, use --project-path to specify the repo path.'
       );
     }
 
@@ -74,64 +234,136 @@ export async function saveSession(args: SaveSessionArgs): Promise<ToolResponse>
       setTeamKey(teamId, teamKey);
     }
 
-    // Build the session request
-    const sessionRequest: SaveSessionRequest = {
-      summary: args.summary.trim(),
-    };
+    // If transcript provided, call summarize API to generate structured summary
+    let summarizedArgs = { ...args };
+    let aiSummary: SummarizeApiResponse | null = null;
 
-    if (args.decisions && args.decisions.length > 0) {
-      sessionRequest.decisions = args.decisions;
-    }
+    if (args.transcript && args.transcript.trim().length >= 50) {
+      try {
+        // Build the API request
+        const now = new Date().toISOString();
+        const summarizeRequest: SummarizeApiRequest = {
+          transcript: args.transcript,
+          repo_name: repoInfo.fullName,
+          tool: 'claude-code',
+          started_at: now,
+          ended_at: now,
+        };
 
-    if (args.mistakes && args.mistakes.length > 0) {
-      sessionRequest.mistakes = args.mistakes;
-    }
+        // Call the summarize API using the raw method to avoid type mismatch
+        aiSummary = await client.summarizeRaw<SummarizeApiRequest, SummarizeApiResponse>(summarizeRequest);
 
-    if (args.filesChanged && args.filesChanged.length > 0) {
-      sessionRequest.filesChanged = args.filesChanged;
+        // Update args with AI-generated content
+        summarizedArgs = {
+          ...args,
+          summary: aiSummary.tldr.summary || aiSummary.summary,
+          decisions: aiSummary.decisions.map(d => ({
+            what: d.what,
+            why: d.why,
+          })),
+          mistakes: aiSummary.tldr.mistakes,
+          filesChanged: aiSummary.tldr.files_changed,
+          nextSteps: undefined, // Could extract from lessons
+          blockers: aiSummary.tldr.status === 'blocked' ? 'Session blocked' : undefined,
+        };
+      } catch (error) {
+        // If summarization fails, fall back to provided summary or placeholder
+        console.error('[Recall] AI summarization failed, using fallback:', error);
+        if (!args.summary || args.summary.trim().length === 0) {
+          summarizedArgs.summary = 'Session saved (AI summarization unavailable)';
+        }
+      }
+    } else if (!args.summary || args.summary.trim().length === 0) {
+      // No transcript and no summary - this shouldn't happen due to validation
+      summarizedArgs.summary = 'Session saved';
     }
 
-    if (args.nextSteps && args.nextSteps.trim().length > 0) {
-      sessionRequest.nextSteps = args.nextSteps.trim();
-    }
+    // Build the session content to encrypt
+    const sessionContent = buildSessionContent(summarizedArgs);
 
-    if (args.blockers && args.blockers.trim().length > 0) {
-      sessionRequest.blockers = args.blockers.trim();
-    }
+    // Encrypt the content with team key
+    const encryptedContent = encryptForApi(sessionContent, teamKey);
 
-    // Save session via API
-    const response = await client.saveSession(repoId, sessionRequest);
+    // Build TLDR metadata (use summarized args if available)
+    const tldr = buildTldr(summarizedArgs);
 
-    // Build success message
-    const parts: string[] = [
-      `Session saved successfully.`,
-      ``,
-      `Session ID: ${response.sessionId}`,
-      `Repository: ${repoInfo.fullName}`,
-    ];
+    // Create timestamps (session is "now")
+    const now = new Date().toISOString();
+
+    // Build the API request body (matches CreateSessionRequestBody in API)
+    const requestBody = {
+      encrypted_content: encryptedContent,
+      tldr,
+      started_at: now,
+      ended_at: now,
+      tool: 'claude-code' as const,
+    };
+
+    // Save session via API
+    const response = await client.saveSessionV3(repoId, requestBody);
 
-    if (args.decisions && args.decisions.length > 0) {
-      parts.push(`Decisions logged: ${args.decisions.length}`);
+    // Build a clean, informative success message
+    const parts: string[] = [];
+    parts.push(`Session saved to ${repoInfo.fullName}`);
+    if (aiSummary) {
+      parts.push(`  (AI summarized)`);
     }
+    parts.push(``);
+    parts.push(`  Saved:`);
+
+    // Summary (truncate if too long)
+    const summaryText = summarizedArgs.summary || 'Session saved';
+    const summaryPreview = summaryText.trim().length > 80
+      ? summaryText.trim().substring(0, 77) + '...'
+      : summaryText.trim();
+    parts.push(`  - Summary: ${summaryPreview}`);
 
-    if (args.mistakes && args.mistakes.length > 0) {
-      parts.push(`Mistakes documented: ${args.mistakes.length}`);
+    // Key decisions (show first one if any)
+    if (summarizedArgs.decisions && summarizedArgs.decisions.length > 0) {
+      const firstDecision = summarizedArgs.decisions[0].what;
+      if (summarizedArgs.decisions.length === 1) {
+        parts.push(`  - Decision: ${firstDecision}`);
+      } else {
+        parts.push(`  - Decisions: ${firstDecision} (+${summarizedArgs.decisions.length - 1} more)`);
+      }
     }
 
-    if (args.filesChanged && args.filesChanged.length > 0) {
-      parts.push(`Files tracked: ${args.filesChanged.length}`);
+    // Blockers (if any)
+    if (summarizedArgs.blockers) {
+      const blockerPreview = summarizedArgs.blockers.trim().length > 60
+        ? summarizedArgs.blockers.trim().substring(0, 57) + '...'
+        : summarizedArgs.blockers.trim();
+      parts.push(`  - Blocker: ${blockerPreview}`);
     }
 
-    if (args.nextSteps) {
-      parts.push(`Next steps: ${args.nextSteps}`);
+    // Next steps (if any)
+    if (summarizedArgs.nextSteps) {
+      const nextPreview = summarizedArgs.nextSteps.trim().length > 60
+        ? summarizedArgs.nextSteps.trim().substring(0, 57) + '...'
+        : summarizedArgs.nextSteps.trim();
+      parts.push(`  - Next: ${nextPreview}`);
     }
 
-    if (args.blockers) {
-      parts.push(`Blockers: ${args.blockers}`);
+    // Files changed (count only if many)
+    if (summarizedArgs.filesChanged && summarizedArgs.filesChanged.length > 0) {
+      if (summarizedArgs.filesChanged.length <= 3) {
+        parts.push(`  - Files: ${summarizedArgs.filesChanged.join(', ')}`);
+      } else {
+        parts.push(`  - Files: ${summarizedArgs.filesChanged.length} files changed`);
+      }
     }
 
-    parts.push(``);
-    parts.push(`Team memory has been updated.`);
+    // Footer
+    parts.push(`  - Updated team memory for next session`);
+
+    // Show warnings if any (non-critical issues that didn't prevent save)
+    if (response.warnings && response.warnings.length > 0) {
+      parts.push(``);
+      parts.push(`  Warnings:`);
+      for (const warning of response.warnings) {
+        parts.push(`  ⚠️ ${warning}`);
+      }
+    }
 
     return successResponse(parts.join('\n'));