grov 0.5.2 → 0.5.3

package/README.md

@@ -36,7 +36,7 @@ Every time you start a new Claude Code session:
 
 Grov captures what Claude learns and injects it back on the next session.
 
-![grov status](docs/grov-status.jpeg)
+![grov demo](demo-converted.gif)
 
 ### What Gets Captured
 
@@ -129,6 +129,24 @@ Grov monitors what Claude **does** (not what you ask) and corrects if it drifts
 grov drift-test "refactor the auth system" --goal "fix login bug"
 ```
 
+### Extended Cache (Experimental)
+
+Anthropic's prompt cache expires after 5 minutes of inactivity. If you pause to think between prompts, the cache expires and must be recreated (costs more, takes longer).
+
+```bash
+grov proxy --extended-cache
+```
+
+**What this does:** Sends minimal keep-alive requests (~$0.002 each) during idle periods to preserve your cache.
+
+**Important:** By using `--extended-cache`, you consent to Grov making API requests on your behalf to keep the cache active. These requests:
+- Use your Anthropic API key
+- Are sent automatically during idle periods (every ~4 minutes)
+- Cost approximately $0.002 per keep-alive
+- Are discarded (not added to your conversation)
+
+This feature is **disabled by default** and requires explicit opt-in.
+
 ### Environment Variables
 
 ```bash

package/dist/cli.js

@@ -78,7 +78,15 @@ program
     .command('proxy')
     .description('Start the Grov proxy server (intercepts Claude API calls)')
     .option('-d, --debug', 'Enable debug logging to grov-proxy.log')
+    .option('--extended-cache', 'Keep Anthropic cache alive during idle (sends requests on your behalf)')
     .action(async (options) => {
+    if (options.extendedCache) {
+        process.env.GROV_EXTENDED_CACHE = 'true';
+        console.log('\n⚠️  Extended Cache Enabled');
+        console.log('   By using --extended-cache, you consent to Grov making');
+        console.log('   minimal keep-alive requests on your behalf to preserve');
+        console.log('   Anthropic\'s prompt cache during idle periods.\n');
+    }
     const { startServer } = await import('./proxy/server.js');
     await startServer({ debug: options.debug ?? false });
 });

package/dist/lib/api-client.d.ts

@@ -1,4 +1,4 @@
-import type { Team, MemorySyncRequest, MemorySyncResponse, DeviceFlowStartResponse, DeviceFlowPollResponse } from '@grov/shared';
+import type { Team, Memory, MemorySyncRequest, MemorySyncResponse, DeviceFlowStartResponse, DeviceFlowPollResponse } from '@grov/shared';
 export interface ApiResponse<T> {
     data?: T;
     error?: string;
@@ -30,6 +30,23 @@ export declare function fetchTeam(teamId: string): Promise<Team>;
  * Sync memories to team
  */
 export declare function syncMemories(teamId: string, request: MemorySyncRequest): Promise<MemorySyncResponse>;
+/**
+ * Fetch team memories from cloud (Supabase via API)
+ * Cloud equivalent of getTasksForProject() from store.ts
+ * Supports hybrid search when context is provided
+ *
+ * @param teamId - Team UUID
+ * @param projectPath - Project path to filter by (exact match)
+ * @param options - Optional filters (files, status, limit, context, current_files)
+ * @returns Array of memories (empty array on error - fail silent)
+ */
+export declare function fetchTeamMemories(teamId: string, projectPath: string, options?: {
+    files?: string[];
+    status?: string;
+    limit?: number;
+    context?: string;
+    current_files?: string[];
+}): Promise<Memory[]>;
 /**
  * Sleep helper for polling
  */

package/dist/lib/api-client.js

@@ -102,6 +102,63 @@ export async function syncMemories(teamId, request) {
     }
     return response.data;
 }
+// Security limits for API params
+const MAX_CONTEXT_LENGTH = 2000; // Max chars for semantic search context
+const MAX_FILES_COUNT = 20; // Max files for boost/filter
+/**
+ * Fetch team memories from cloud (Supabase via API)
+ * Cloud equivalent of getTasksForProject() from store.ts
+ * Supports hybrid search when context is provided
+ *
+ * @param teamId - Team UUID
+ * @param projectPath - Project path to filter by (exact match)
+ * @param options - Optional filters (files, status, limit, context, current_files)
+ * @returns Array of memories (empty array on error - fail silent)
+ */
+export async function fetchTeamMemories(teamId, projectPath, options) {
+    // Build query params
+    const params = new URLSearchParams();
+    params.set('project_path', projectPath);
+    if (options?.status) {
+        params.set('status', options.status);
+    }
+    if (options?.limit) {
+        params.set('limit', options.limit.toString());
+    }
+    if (options?.files && options.files.length > 0) {
+        // API expects multiple 'files' params for array
+        options.files.slice(0, MAX_FILES_COUNT).forEach(f => params.append('files', f));
+    }
+    // Hybrid search params (with security limits)
+    if (options?.context) {
+        params.set('context', options.context.substring(0, MAX_CONTEXT_LENGTH));
+    }
+    if (options?.current_files && options.current_files.length > 0) {
+        // Comma-separated for current_files (boost)
+        const files = options.current_files.slice(0, MAX_FILES_COUNT);
+        params.set('current_files', files.join(','));
+    }
+    const url = `/teams/${teamId}/memories?${params.toString()}`;
+    console.log(`[API] fetchTeamMemories: GET ${url}`);
+    try {
+        const response = await apiRequest('GET', url);
+        if (response.error) {
+            console.warn(`[API] fetchTeamMemories failed: ${response.error} (status: ${response.status})`);
+            return []; // Fail silent - don't block Claude Code
+        }
+        if (!response.data || !response.data.memories) {
+            console.log('[API] fetchTeamMemories: No memories returned');
+            return [];
+        }
+        console.log(`[API] fetchTeamMemories: Got ${response.data.memories.length} memories`);
+        return response.data.memories;
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : 'Unknown error';
+        console.error(`[API] fetchTeamMemories exception: ${errorMsg}`);
+        return []; // Fail silent - don't block Claude Code
+    }
+}
 // ============= Utility Functions =============
 /**
  * Sleep helper for polling

package/dist/lib/llm-extractor.d.ts

@@ -1,22 +1,4 @@
-import type { ParsedSession } from './jsonl-parser.js';
-import type { TaskStatus, SessionState, StepRecord } from './store.js';
-export interface ExtractedReasoning {
-    task: string;
-    goal: string;
-    reasoning_trace: string[];
-    files_touched: string[];
-    decisions: Array<{
-        choice: string;
-        reason: string;
-    }>;
-    constraints: string[];
-    status: TaskStatus;
-    tags: string[];
-}
-/**
- * Check if LLM extraction is available (OpenAI API key set)
- */
-export declare function isLLMAvailable(): boolean;
+import type { SessionState, StepRecord } from './store.js';
 export interface ExtractedIntent {
     goal: string;
     expected_scope: string[];
@@ -34,22 +16,6 @@ export declare function extractIntent(firstPrompt: string): Promise<ExtractedInt
  * Check if intent extraction is available
  */
 export declare function isIntentExtractionAvailable(): boolean;
-/**
- * Check if Anthropic API is available (for drift detection)
- */
-export declare function isAnthropicAvailable(): boolean;
-/**
- * Get the drift model to use (from env or default)
- */
-export declare function getDriftModel(): string;
-/**
- * Extract structured reasoning from a parsed session using GPT-3.5-turbo
- */
-export declare function extractReasoning(session: ParsedSession): Promise<ExtractedReasoning>;
-/**
- * Classify just the task status (lighter weight than full extraction)
- */
-export declare function classifyTaskStatus(session: ParsedSession): Promise<TaskStatus>;
 /**
  * Check if session summary generation is available
  */
@@ -63,14 +29,21 @@ export declare function generateSessionSummary(sessionState: SessionState, steps
  * Task analysis result from Haiku
  */
 export interface TaskAnalysis {
+    task_type: 'information' | 'planning' | 'implementation';
     action: 'continue' | 'new_task' | 'subtask' | 'parallel_task' | 'task_complete' | 'subtask_complete';
-    topic_match?: 'YES' | 'NO';
     task_id: string;
     current_goal: string;
     parent_task_id?: string;
     reasoning: string;
     step_reasoning?: string;
 }
+/**
+ * Conversation message for task analysis
+ */
+export interface ConversationMessage {
+    role: 'user' | 'assistant';
+    content: string;
+}
 /**
  * Check if task analysis is available
  */
@@ -80,7 +53,7 @@ export declare function isTaskAnalysisAvailable(): boolean;
  * Called after each main model response to orchestrate sessions
  * Also compresses reasoning for steps if assistantResponse > 1000 chars
  */
-export declare function analyzeTaskContext(currentSession: SessionState | null, latestUserMessage: string, recentSteps: StepRecord[], assistantResponse: string): Promise<TaskAnalysis>;
+export declare function analyzeTaskContext(currentSession: SessionState | null, latestUserMessage: string, recentSteps: StepRecord[], assistantResponse: string, conversationHistory?: ConversationMessage[]): Promise<TaskAnalysis>;
 export interface ExtractedReasoningAndDecisions {
     reasoning_trace: string[];
     decisions: Array<{
@@ -95,5 +68,8 @@ export declare function isReasoningExtractionAvailable(): boolean;
 /**
  * Extract reasoning trace and decisions from steps
  * Called at task_complete to populate team memory with rich context
+ *
+ * @param formattedSteps - Pre-formatted XML string with grouped steps and actions
+ * @param originalGoal - The original task goal
  */
-export declare function extractReasoningAndDecisions(stepsReasoning: string[], originalGoal: string): Promise<ExtractedReasoningAndDecisions>;
+export declare function extractReasoningAndDecisions(formattedSteps: string, originalGoal: string): Promise<ExtractedReasoningAndDecisions>;