@recall_v3/mcp-server 0.1.0 → 3.0.0

package/dist/tools/saveSession.js

@@ -3,38 +3,107 @@
  * 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.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.saveSession = saveSession;
 const client_js_1 = require("../api/client.js");
 const index_js_1 = require("../config/index.js");
+const index_js_2 = require("../crypto/index.js");
 const types_js_1 = require("./types.js");
 const utils_js_1 = require("./utils.js");
+/**
+ * Build the full session content to encrypt
+ */
+function buildSessionContent(args) {
+    const parts = [];
+    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) {
+    const tldr = {
+        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
  */
 async function saveSession(args) {
     try {
-        // Validate required fields
-        if (!args.summary || args.summary.trim().length === 0) {
-            return (0, types_js_1.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 (0, types_js_1.errorResponse)('Either summary or transcript is required. Please provide a description of what was accomplished or the session transcript.');
         }
         // Get API token
         const token = (0, index_js_1.getApiToken)();
         if (!token) {
             return (0, types_js_1.errorResponse)('Not authenticated. Run `recall auth` to connect your account, or set RECALL_API_TOKEN environment variable.');
         }
-        // Resolve project path (use cwd since projectPath is not in args)
-        const projectPath = (0, utils_js_1.resolveProjectPath)(undefined);
+        // Resolve project path (use args.projectPath if provided, otherwise cwd)
+        const projectPath = (0, utils_js_1.resolveProjectPath)(args.projectPath);
         // Get repo info from git
         const repoInfo = await (0, utils_js_1.getRepoInfo)(projectPath);
         if (!repoInfo) {
             return (0, types_js_1.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.');
         }
         // Create API client
         const client = new client_js_1.RecallApiClient({
@@ -50,51 +119,123 @@ async function saveSession(args) {
             teamKey = keyResponse.encryptionKey;
             (0, index_js_1.setTeamKey)(teamId, teamKey);
         }
-        // Build the session request
-        const sessionRequest = {
-            summary: args.summary.trim(),
-        };
-        if (args.decisions && args.decisions.length > 0) {
-            sessionRequest.decisions = args.decisions;
-        }
-        if (args.mistakes && args.mistakes.length > 0) {
-            sessionRequest.mistakes = args.mistakes;
-        }
-        if (args.filesChanged && args.filesChanged.length > 0) {
-            sessionRequest.filesChanged = args.filesChanged;
-        }
-        if (args.nextSteps && args.nextSteps.trim().length > 0) {
-            sessionRequest.nextSteps = args.nextSteps.trim();
+        // If transcript provided, call summarize API to generate structured summary
+        let summarizedArgs = { ...args };
+        let aiSummary = null;
+        if (args.transcript && args.transcript.trim().length >= 50) {
+            try {
+                // Build the API request
+                const now = new Date().toISOString();
+                const summarizeRequest = {
+                    transcript: args.transcript,
+                    repo_name: repoInfo.fullName,
+                    tool: 'claude-code',
+                    started_at: now,
+                    ended_at: now,
+                };
+                // Call the summarize API using the raw method to avoid type mismatch
+                aiSummary = await client.summarizeRaw(summarizeRequest);
+                // 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)';
+                }
+            }
         }
-        if (args.blockers && args.blockers.trim().length > 0) {
-            sessionRequest.blockers = args.blockers.trim();
+        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';
         }
+        // Build the session content to encrypt
+        const sessionContent = buildSessionContent(summarizedArgs);
+        // Encrypt the content with team key
+        const encryptedContent = (0, index_js_2.encryptForApi)(sessionContent, teamKey);
+        // Build TLDR metadata (use summarized args if available)
+        const tldr = buildTldr(summarizedArgs);
+        // 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',
+        };
         // Save session via API
-        const response = await client.saveSession(repoId, sessionRequest);
-        // Build success message
-        const parts = [
-            `Session saved successfully.`,
-            ``,
-            `Session ID: ${response.sessionId}`,
-            `Repository: ${repoInfo.fullName}`,
-        ];
-        if (args.decisions && args.decisions.length > 0) {
-            parts.push(`Decisions logged: ${args.decisions.length}`);
+        const response = await client.saveSessionV3(repoId, requestBody);
+        // Build a clean, informative success message
+        const parts = [];
+        parts.push(`Session saved to ${repoInfo.fullName}`);
+        if (aiSummary) {
+            parts.push(`  (AI summarized)`);
         }
-        if (args.mistakes && args.mistakes.length > 0) {
-            parts.push(`Mistakes documented: ${args.mistakes.length}`);
+        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}`);
+        // 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)`);
+            }
+        }
+        // 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.filesChanged && args.filesChanged.length > 0) {
-            parts.push(`Files tracked: ${args.filesChanged.length}`);
+        // 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.nextSteps) {
-            parts.push(`Next steps: ${args.nextSteps}`);
+        // 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`);
+            }
         }
-        if (args.blockers) {
-            parts.push(`Blockers: ${args.blockers}`);
+        // 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}`);
+            }
         }
-        parts.push(``);
-        parts.push(`Team memory has been updated.`);
         return (0, types_js_1.successResponse)(parts.join('\n'));
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@recall_v3/mcp-server",
-  "version": "0.1.0",
+  "version": "3.0.0",
   "description": "Recall MCP Server - Team memory for AI coding assistants",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/api/client.ts

@@ -94,16 +94,18 @@ export class RecallApiClient {
   private async request<T>(
     method: 'GET' | 'POST' | 'PUT' | 'DELETE',
     path: string,
-    body?: unknown
+    body?: unknown,
+    options?: { timeout?: number }
   ): Promise<T> {
     const url = `${this.baseUrl}${path}`;
+    const timeout = options?.timeout ?? this.timeout;
 
     let lastError: Error | undefined;
 
     for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
       try {
         const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
 
         try {
           const response = await fetch(url, {
@@ -139,13 +141,20 @@ export class RecallApiClient {
           }
 
           // Parse successful response
-          const data = await response.json() as ApiResponse<T>;
-
-          if (!data.success && data.error) {
-            throw new RecallApiError(data.error.message, data.error.code, response.status, false);
+          // API may return { success: true, data: T } or T directly
+          const rawData = await response.json();
+
+          // Check if it's a wrapped response
+          if (rawData && typeof rawData === 'object' && 'success' in rawData) {
+            const wrapped = rawData as ApiResponse<T>;
+            if (!wrapped.success && wrapped.error) {
+              throw new RecallApiError(wrapped.error.message, wrapped.error.code, response.status, false);
+            }
+            return wrapped.data as T;
           }
 
-          return data.data as T;
+          // Direct response (not wrapped)
+          return rawData as T;
         } finally {
           clearTimeout(timeoutId);
         }
@@ -218,31 +227,141 @@ export class RecallApiClient {
    * Called by saveSession tool after reading JSONL from disk
    */
   async summarize(request: SummarizeRequest): Promise<SummarizeResponse> {
-    return this.request<SummarizeResponse>('POST', '/api/v1/summarize', request);
+    return this.request<SummarizeResponse>('POST', '/v1/summarize', request);
+  }
+
+  /**
+   * Summarize a session transcript using the actual API format
+   * This bypasses the strict shared types which don't match the real API
+   * Uses 2 minute timeout since AI summarization can take time
+   */
+  async summarizeRaw<TRequest, TResponse>(request: TRequest): Promise<TResponse> {
+    return this.request<TResponse>('POST', '/v1/summarize', request, { timeout: 120000 });
   }
 
   /**
    * Save a session with manual input (not from transcript)
    * Used when user provides summary directly via MCP tool
+   * @deprecated Use saveSessionV3 for proper encrypted format
    */
   async saveSession(repoId: string, data: SaveSessionRequest): Promise<SaveSessionResponse> {
-    return this.request<SaveSessionResponse>('POST', `/api/v1/repos/${repoId}/sessions`, data);
+    return this.request<SaveSessionResponse>('POST', `/v1/repos/${repoId}/sessions`, data);
+  }
+
+  /**
+   * Save a session with encrypted content (v3 format)
+   * This is the correct format for the v3 API
+   */
+  async saveSessionV3(repoId: string, data: {
+    encrypted_content: string;
+    tldr: {
+      summary: string;
+      status: 'complete' | 'in-progress' | 'blocked';
+      decisions?: string[];
+      mistakes?: string[];
+      tags?: string[];
+      files_changed?: string[];
+      blockers?: string | null;
+      next_steps?: string | null;
+    };
+    started_at: string;
+    ended_at: string;
+    tool?: string;
+  }): Promise<{ id: string; created_at: string; warnings?: string[] }> {
+    return this.request<{ id: string; created_at: string; warnings?: string[] }>('POST', `/v1/repos/${repoId}/sessions`, data);
   }
 
   /**
    * Get context for a repository (context.md)
    * Returns the distilled team brain for this repo
+   * @deprecated Use getContextV3 for proper v3 API format
    */
   async getContext(repoId: string): Promise<GetContextResponse> {
-    return this.request<GetContextResponse>('GET', `/api/v1/repos/${repoId}/context`);
+    return this.request<GetContextResponse>('GET', `/v1/repos/${repoId}/context`);
+  }
+
+  /**
+   * Get context for a repository (v3 format)
+   * Returns sessions with encrypted content for client-side decryption
+   */
+  async getContextV3(repoId: string): Promise<{
+    sessions: Array<{
+      id: string;
+      encrypted_content: string;
+      started_at: string;
+      ended_at: string;
+      status: string;
+      tldr_summary: string | null;
+      user: {
+        id: string;
+        name: string | null;
+        github_username: string | null;
+        avatar_url: string | null;
+      };
+    }>;
+    cached_context: string;
+    updated_at: string;
+    session_count: number;
+    tier: string;
+  }> {
+    return this.request('GET', `/v1/repos/${repoId}/context`);
   }
 
   /**
    * Get history for a repository (context.md + history.md)
    * Returns more detail than getContext
+   * @deprecated Use getHistoryV3 for proper v3 API format
    */
   async getHistory(repoId: string): Promise<GetHistoryResponse> {
-    return this.request<GetHistoryResponse>('GET', `/api/v1/repos/${repoId}/history`);
+    return this.request<GetHistoryResponse>('GET', `/v1/repos/${repoId}/history`);
+  }
+
+  /**
+   * Get history for a repository (v3 format)
+   * Returns sessions, decisions, and mistakes with encrypted content
+   */
+  async getHistoryV3(repoId: string, days: number = 30): Promise<{
+    sessions: Array<{
+      id: string;
+      encrypted_content: string;
+      started_at: string;
+      ended_at: string;
+      status: string;
+      tldr_summary: string | null;
+      user: {
+        id: string;
+        name: string | null;
+        github_username: string | null;
+        avatar_url: string | null;
+      };
+    }>;
+    decisions: Array<{
+      id: string;
+      title: string;
+      encrypted_content: string;
+      created_at: string;
+      user: {
+        id: string;
+        name: string | null;
+        github_username: string | null;
+        avatar_url: string | null;
+      };
+    }>;
+    mistakes: Array<{
+      id: string;
+      title: string;
+      encrypted_content: string;
+      created_at: string;
+      user: {
+        id: string;
+        name: string | null;
+        github_username: string | null;
+        avatar_url: string | null;
+      };
+    }>;
+    token_warning?: string;
+  }> {
+    return this.request('GET', `/v1/repos/${repoId}/history?days=${days}`);
   }
 
   /**
@@ -250,14 +369,14 @@ export class RecallApiClient {
    * WARNING: Can be very large, uses many tokens
    */
   async getTranscripts(repoId: string): Promise<GetTranscriptsResponse> {
-    return this.request<GetTranscriptsResponse>('GET', `/api/v1/repos/${repoId}/transcripts`);
+    return this.request<GetTranscriptsResponse>('GET', `/v1/repos/${repoId}/transcripts`);
   }
 
   /**
    * Log a decision for a repository
    */
   async logDecision(repoId: string, data: LogDecisionRequest): Promise<LogDecisionResponse> {
-    return this.request<LogDecisionResponse>('POST', `/api/v1/repos/${repoId}/decisions`, data);
+    return this.request<LogDecisionResponse>('POST', `/v1/repos/${repoId}/decisions`, data);
   }
 
   /**
@@ -265,21 +384,39 @@ export class RecallApiClient {
    * Used to decrypt content locally
    */
   async getTeamKey(teamId: string): Promise<TeamKeyResponse> {
-    return this.request<TeamKeyResponse>('GET', `/api/v1/teams/${teamId}/key`);
+    // API returns { hasAccess, key, keyVersion, teamId, teamName, teamSlug, tier }
+    // Map to TeamKeyResponse type
+    const response = await this.request<{
+      hasAccess: boolean;
+      key: string;
+      keyVersion: number;
+      teamId: string;
+      teamName: string;
+      teamSlug: string;
+      tier: string;
+    }>('GET', '/v1/keys/team');
+
+    return {
+      teamId: response.teamId,
+      encryptionKey: response.key,
+      keyVersion: response.keyVersion,
+      teamName: response.teamName,
+      tier: response.tier as 'team' | 'pro' | 'enterprise',
+    };
   }
 
   /**
    * List teams the user belongs to
    */
   async listTeams(): Promise<ListTeamsResponse> {
-    return this.request<ListTeamsResponse>('GET', '/api/v1/teams');
+    return this.request<ListTeamsResponse>('GET', '/v1/teams');
   }
 
   /**
    * Get authentication status
    */
   async getStatus(): Promise<RecallStatusResponse> {
-    return this.request<RecallStatusResponse>('GET', '/api/v1/status');
+    return this.request<RecallStatusResponse>('GET', '/v1/status');
   }
 
   /**
@@ -287,7 +424,7 @@ export class RecallApiClient {
    * Returns the repo ID for subsequent API calls
    */
   async resolveRepo(fullName: string, defaultBranch?: string): Promise<{ repoId: string; teamId: string }> {
-    return this.request<{ repoId: string; teamId: string }>('POST', '/api/v1/repos/resolve', {
+    return this.request<{ repoId: string; teamId: string }>('POST', '/v1/repos/resolve', {
       fullName,
       defaultBranch,
     });