grov 0.2.2 → 0.5.2

package/dist/lib/cloud-sync.js

@@ -0,0 +1,176 @@
+// Cloud sync logic - Upload memories from local database to API
+// Handles batching, retries, and conversion from Task to Memory format
+import { getSyncStatus, getAccessToken } from './credentials.js';
+import { syncMemories, sleep, getApiUrl } from './api-client.js';
+// Sync configuration
+const SYNC_CONFIG = {
+    batchSize: 10, // Number of memories per batch
+    retryAttempts: 3, // Number of retry attempts per batch
+    retryDelay: 1000, // Base delay between retries (ms)
+};
+/**
+ * Convert local Task to CreateMemoryInput for API
+ */
+export function taskToMemory(task) {
+    return {
+        client_task_id: task.id,
+        project_path: task.project_path,
+        original_query: task.original_query,
+        goal: task.goal,
+        reasoning_trace: task.reasoning_trace,
+        files_touched: task.files_touched,
+        decisions: task.decisions,
+        constraints: task.constraints,
+        tags: task.tags,
+        status: task.status,
+        linked_commit: task.linked_commit,
+    };
+}
+/**
+ * Check if sync is enabled and configured
+ */
+export function isSyncEnabled() {
+    const status = getSyncStatus();
+    return status?.enabled === true && !!status.teamId;
+}
+/**
+ * Get the configured team ID for sync
+ */
+export function getSyncTeamId() {
+    const status = getSyncStatus();
+    return status?.teamId || null;
+}
+/**
+ * Sync a single task to the cloud
+ * Called when a task is completed
+ */
+export async function syncTask(task) {
+    if (!isSyncEnabled()) {
+        return false;
+    }
+    const teamId = getSyncTeamId();
+    if (!teamId) {
+        return false;
+    }
+    const token = await getAccessToken();
+    if (!token) {
+        return false;
+    }
+    try {
+        const memory = taskToMemory(task);
+        const result = await syncMemories(teamId, { memories: [memory] });
+        return result.synced === 1;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Sync multiple tasks with batching and retry
+ */
+export async function syncTasks(tasks) {
+    if (!isSyncEnabled()) {
+        return {
+            synced: 0,
+            failed: tasks.length,
+            errors: [`Sync is not enabled. Run "grov sync --enable --team <team-id>" first. (API: ${getApiUrl()})`],
+            syncedIds: [],
+            failedIds: tasks.map(t => t.id),
+        };
+    }
+    const teamId = getSyncTeamId();
+    if (!teamId) {
+        return {
+            synced: 0,
+            failed: tasks.length,
+            errors: [`No team configured. Run "grov sync --enable --team <team-id>" first. (API: ${getApiUrl()})`],
+            syncedIds: [],
+            failedIds: tasks.map(t => t.id),
+        };
+    }
+    const token = await getAccessToken();
+    if (!token) {
+        return {
+            synced: 0,
+            failed: tasks.length,
+            errors: [`Not authenticated. Run "grov login" first. (API: ${getApiUrl()})`],
+            syncedIds: [],
+            failedIds: tasks.map(t => t.id),
+        };
+    }
+    // Convert tasks to memories
+    const memories = tasks.map(taskToMemory);
+    // Batch and sync
+    const batches = [];
+    for (let i = 0; i < memories.length; i += SYNC_CONFIG.batchSize) {
+        batches.push(memories.slice(i, i + SYNC_CONFIG.batchSize));
+    }
+    let totalSynced = 0;
+    let totalFailed = 0;
+    const allErrors = [];
+    const syncedIds = [];
+    const failedIds = [];
+    for (const batch of batches) {
+        const batchResult = await syncBatchWithRetry(teamId, batch);
+        totalSynced += batchResult.synced;
+        totalFailed += batchResult.failed;
+        if (batchResult.errors) {
+            allErrors.push(...batchResult.errors);
+        }
+        const batchIds = batch.map((m) => m.client_task_id || '');
+        if (batchResult.synced === batch.length) {
+            syncedIds.push(...batchIds);
+        }
+        else if (batchResult.failed === batch.length) {
+            failedIds.push(...batchIds);
+        }
+    }
+    return {
+        synced: totalSynced,
+        failed: totalFailed,
+        errors: allErrors,
+        syncedIds: syncedIds.filter(Boolean),
+        failedIds: failedIds.filter(Boolean),
+    };
+}
+/**
+ * Sync a batch with retry logic
+ */
+async function syncBatchWithRetry(teamId, memories) {
+    let lastError;
+    for (let attempt = 0; attempt < SYNC_CONFIG.retryAttempts; attempt++) {
+        try {
+            return await syncMemories(teamId, { memories });
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err.message : 'Unknown error';
+            // Exponential backoff
+            if (attempt < SYNC_CONFIG.retryAttempts - 1) {
+                const delay = SYNC_CONFIG.retryDelay * Math.pow(2, attempt);
+                await sleep(delay);
+            }
+        }
+    }
+    // All retries failed
+    return {
+        synced: 0,
+        failed: memories.length,
+        errors: [lastError || 'Sync failed after retries'],
+    };
+}
+/**
+ * Get sync status summary
+ */
+export function getSyncStatusSummary() {
+    const status = getSyncStatus();
+    if (!status) {
+        return 'Not logged in';
+    }
+    if (!status.enabled) {
+        return 'Sync disabled';
+    }
+    if (!status.teamId) {
+        return 'No team configured';
+    }
+    return `Syncing to team: ${status.teamId}`;
+}

package/dist/lib/credentials.d.ts

@@ -0,0 +1,53 @@
+export interface Credentials {
+    access_token: string;
+    refresh_token: string;
+    expires_at: string;
+    user_id: string;
+    email: string;
+    team_id?: string;
+    sync_enabled: boolean;
+}
+/**
+ * Read credentials from disk
+ * @returns Credentials or null if not found/invalid
+ */
+export declare function readCredentials(): Credentials | null;
+/**
+ * Write credentials to disk with secure permissions
+ */
+export declare function writeCredentials(creds: Credentials): void;
+/**
+ * Clear credentials (logout)
+ */
+export declare function clearCredentials(): void;
+/**
+ * Check if user is authenticated (has valid credentials)
+ */
+export declare function isAuthenticated(): boolean;
+/**
+ * Get a valid access token, refreshing if necessary
+ * @returns Access token or null if not authenticated
+ */
+export declare function getAccessToken(): Promise<string | null>;
+/**
+ * Set the team ID for sync
+ */
+export declare function setTeamId(teamId: string): void;
+/**
+ * Enable or disable sync
+ */
+export declare function setSyncEnabled(enabled: boolean): void;
+/**
+ * Get current sync status
+ */
+export declare function getSyncStatus(): {
+    enabled: boolean;
+    teamId: string | undefined;
+} | null;
+/**
+ * Get current user info
+ */
+export declare function getCurrentUser(): {
+    id: string;
+    email: string;
+} | null;

package/dist/lib/credentials.js

@@ -0,0 +1,201 @@
+// Secure credential storage for CLI authentication
+// Stores tokens at ~/.grov/credentials.json with 0o600 permissions
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, chmodSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { request } from 'undici';
+const GROV_DIR = join(homedir(), '.grov');
+const CREDENTIALS_PATH = join(GROV_DIR, 'credentials.json');
+/**
+ * Ensure .grov directory exists with proper permissions
+ */
+function ensureGrovDir() {
+    if (!existsSync(GROV_DIR)) {
+        mkdirSync(GROV_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+/**
+ * Read credentials from disk
+ * @returns Credentials or null if not found/invalid
+ */
+export function readCredentials() {
+    if (!existsSync(CREDENTIALS_PATH)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(CREDENTIALS_PATH, 'utf-8');
+        const creds = JSON.parse(content);
+        // Validate required fields
+        if (!creds.access_token || !creds.refresh_token || !creds.expires_at) {
+            return null;
+        }
+        return creds;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write credentials to disk with secure permissions
+ */
+export function writeCredentials(creds) {
+    ensureGrovDir();
+    // Write with restrictive permissions (owner read/write only)
+    writeFileSync(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), { mode: 0o600 });
+    // Ensure permissions are correct even if file existed
+    chmodSync(CREDENTIALS_PATH, 0o600);
+}
+/**
+ * Clear credentials (logout)
+ */
+export function clearCredentials() {
+    if (existsSync(CREDENTIALS_PATH)) {
+        unlinkSync(CREDENTIALS_PATH);
+    }
+}
+/**
+ * Check if user is authenticated (has valid credentials)
+ */
+export function isAuthenticated() {
+    const creds = readCredentials();
+    return creds !== null;
+}
+/**
+ * Check if access token is expired or will expire soon (within 5 minutes)
+ */
+function isTokenExpiringSoon(expiresAt) {
+    const expiryTime = new Date(expiresAt).getTime();
+    const bufferTime = 5 * 60 * 1000; // 5 minutes
+    return Date.now() > expiryTime - bufferTime;
+}
+/**
+ * Refresh tokens using the API
+ * @returns New credentials or null if refresh failed
+ */
+async function refreshTokens(refreshToken, apiUrl) {
+    try {
+        const response = await request(`${apiUrl}/auth/refresh`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ refresh_token: refreshToken }),
+        });
+        if (response.statusCode !== 200) {
+            return null;
+        }
+        const data = await response.body.json();
+        // Decode user info from new token (basic decode, no verification needed here)
+        const payload = decodeTokenPayload(data.access_token);
+        if (!payload) {
+            return null;
+        }
+        // Read existing credentials to preserve team_id and sync_enabled
+        const existing = readCredentials();
+        return {
+            access_token: data.access_token,
+            refresh_token: data.refresh_token,
+            expires_at: data.expires_at,
+            user_id: payload.sub,
+            email: payload.email,
+            team_id: existing?.team_id,
+            sync_enabled: existing?.sync_enabled ?? false,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Decode JWT payload without verification (for extracting user info)
+ * WARNING: Do not use for authentication - tokens are verified server-side
+ */
+function decodeTokenPayload(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3)
+            return null;
+        const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf-8'));
+        return {
+            sub: payload.sub,
+            email: payload.email,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get a valid access token, refreshing if necessary
+ * @returns Access token or null if not authenticated
+ */
+export async function getAccessToken() {
+    const creds = readCredentials();
+    if (!creds) {
+        return null;
+    }
+    // Check if token needs refresh
+    if (isTokenExpiringSoon(creds.expires_at)) {
+        const apiUrl = process.env.GROV_API_URL || 'https://api.grov.dev';
+        const newCreds = await refreshTokens(creds.refresh_token, apiUrl);
+        if (newCreds) {
+            writeCredentials(newCreds);
+            return newCreds.access_token;
+        }
+        // Refresh failed - user needs to login again
+        return null;
+    }
+    return creds.access_token;
+}
+/**
+ * Set the team ID for sync
+ */
+export function setTeamId(teamId) {
+    const creds = readCredentials();
+    if (!creds) {
+        throw new Error('Not authenticated. Please run: grov login');
+    }
+    writeCredentials({
+        ...creds,
+        team_id: teamId,
+    });
+}
+/**
+ * Enable or disable sync
+ */
+export function setSyncEnabled(enabled) {
+    const creds = readCredentials();
+    if (!creds) {
+        throw new Error('Not authenticated. Please run: grov login');
+    }
+    writeCredentials({
+        ...creds,
+        sync_enabled: enabled,
+    });
+}
+/**
+ * Get current sync status
+ */
+export function getSyncStatus() {
+    const creds = readCredentials();
+    if (!creds) {
+        return null;
+    }
+    return {
+        enabled: creds.sync_enabled,
+        teamId: creds.team_id,
+    };
+}
+/**
+ * Get current user info
+ */
+export function getCurrentUser() {
+    const creds = readCredentials();
+    if (!creds) {
+        return null;
+    }
+    return {
+        id: creds.user_id,
+        email: creds.email,
+    };
+}

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

@@ -58,7 +58,7 @@ export declare function isSummaryAvailable(): boolean;
  * Generate session summary for CLEAR operation
  * Reference: plan_proxy_local.md Section 2.3, 4.5
  */
-export declare function generateSessionSummary(sessionState: SessionState, steps: StepRecord[]): Promise<string>;
+export declare function generateSessionSummary(sessionState: SessionState, steps: StepRecord[], maxTokens?: number): Promise<string>;
 /**
  * Task analysis result from Haiku
  */

package/dist/lib/llm-extractor.js

@@ -456,23 +456,30 @@ export function isSummaryAvailable() {
  * Generate session summary for CLEAR operation
  * Reference: plan_proxy_local.md Section 2.3, 4.5
  */
-export async function generateSessionSummary(sessionState, steps) {
+export async function generateSessionSummary(sessionState, steps, maxTokens = 800 // Default 800, CLEAR mode uses 15000
+) {
     const client = getAnthropicClient();
+    // For larger summaries, include more steps
+    const stepLimit = maxTokens > 5000 ? 50 : 20;
+    const wordLimit = Math.min(Math.floor(maxTokens / 2), 10000); // ~2 tokens per word
     const stepsText = steps
         .filter(s => s.is_validated)
-        .slice(-20)
+        .slice(-stepLimit)
         .map(step => {
         let desc = `- ${step.action_type}`;
         if (step.files.length > 0) {
             desc += `: ${step.files.join(', ')}`;
         }
         if (step.command) {
-            desc += ` (${step.command.substring(0, 50)})`;
+            desc += ` (${step.command.substring(0, 100)})`;
+        }
+        if (step.reasoning && maxTokens > 5000) {
+            desc += `\n  Reasoning: ${step.reasoning.substring(0, 200)}`;
         }
         return desc;
     })
         .join('\n');
-    const prompt = `Create a concise summary of this coding session for context continuation.
+    const prompt = `Create a ${maxTokens > 5000 ? 'comprehensive' : 'concise'} summary of this coding session for context continuation.
 
 ORIGINAL GOAL: ${sessionState.original_goal || 'Not specified'}
 
@@ -483,18 +490,19 @@ CONSTRAINTS: ${sessionState.constraints.join(', ') || 'None'}
 ACTIONS TAKEN:
 ${stepsText || 'No actions recorded'}
 
-Create a summary with these sections (keep total under 500 words):
-1. ORIGINAL GOAL: (1 sentence)
-2. PROGRESS: (2-3 bullet points of what was accomplished)
-3. KEY DECISIONS: (any important choices made)
-4. FILES MODIFIED: (list of files)
-5. CURRENT STATE: (where the work left off)
-6. NEXT STEPS: (recommended next actions)
+Create a summary with these sections (keep total under ${wordLimit} words):
+1. ORIGINAL GOAL: (1-2 sentences)
+2. PROGRESS: (${maxTokens > 5000 ? '5-10' : '2-3'} bullet points of what was accomplished)
+3. KEY DECISIONS: (important architectural/design choices made, with reasoning)
+4. FILES MODIFIED: (list of files with brief description of changes)
+5. CURRENT STATE: (detailed status of where the work left off)
+6. NEXT STEPS: (recommended next actions to continue)
+${maxTokens > 5000 ? '7. IMPORTANT CONTEXT: (any critical information that must not be lost)' : ''}
 
 Format as plain text, not JSON.`;
     const response = await client.messages.create({
         model: 'claude-haiku-4-5-20251001',
-        max_tokens: 800,
+        max_tokens: maxTokens,
         messages: [{ role: 'user', content: prompt }],
     });
     const content = response.content?.[0];
@@ -544,10 +552,10 @@ export async function analyzeTaskContext(currentSession, latestUserMessage, rece
     // Check if we need to compress reasoning
     const needsCompression = assistantResponse.length > 1000;
     const compressionInstruction = needsCompression
-        ? `\n  "step_reasoning": "compressed summary of assistant's actions and reasoning (max 800 chars)"`
+        ? `\n  "step_reasoning": "Extract CONCLUSIONS and SPECIFIC RECOMMENDATIONS only. Include: exact file paths (e.g., src/lib/utils.ts), function/component names, architectural patterns discovered, and WHY decisions were made. DO NOT write process descriptions like 'explored' or 'analyzed'. Max 800 chars."`
         : '';
     const compressionRule = needsCompression
-        ? '\n- step_reasoning: Summarize what the assistant did and WHY in a concise way (max 800 chars)'
+        ? '\n- step_reasoning: Extract CONCLUSIONS (specific files, patterns, decisions) NOT process descriptions. Example GOOD: "Utilities belong in src/lib/utils.ts alongside cn(), formatDate()". Example BAD: "Explored codebase structure".'
         : '';
     // Extract topic keywords from goal for comparison
     const currentGoalKeywords = currentSession?.original_goal
@@ -660,40 +668,51 @@ export async function extractReasoningAndDecisions(stepsReasoning, originalGoal)
     if (combinedReasoning.length < 50) {
         return { reasoning_trace: [], decisions: [] };
     }
-    const prompt = `Analyze Claude's work session and extract structured reasoning and decisions.
+    const prompt = `Extract CONCLUSIONS and KNOWLEDGE from Claude's work - NOT process descriptions.
 
 ORIGINAL GOAL:
 ${originalGoal || 'Not specified'}
 
-CLAUDE'S WORK (reasoning from each step):
+CLAUDE'S RESPONSE:
 ${combinedReasoning}
 
 ═══════════════════════════════════════════════════════════════
-EXTRACT TWO THINGS:
+EXTRACT ACTIONABLE CONCLUSIONS - NOT PROCESS
 ═══════════════════════════════════════════════════════════════
 
-1. REASONING TRACE (what was done and WHY):
-   - Each entry: "[ACTION] [target] because/to [reason]"
-   - Include specific file names, function names when mentioned
-   - Focus on WHY decisions were made, not just what
-   - Max 10 entries, most important first
-
-2. DECISIONS (choices made between alternatives):
-   - Only include actual choices/tradeoffs
-   - Each must have: what was chosen, why it was chosen
-   - Examples: "Chose X over Y because Z"
+GOOD examples (specific, reusable knowledge):
+- "Utility functions belong in frontend/lib/utils.ts - existing utils: cn(), formatDate(), debounce()"
+- "Auth tokens stored in localStorage with 15min expiry for long form sessions"
+- "API routes follow REST pattern in /api/v1/ with Zod validation"
+- "Database migrations go in prisma/migrations/ using prisma migrate"
+
+BAD examples (process descriptions - DO NOT EXTRACT THESE):
+- "Explored the codebase structure"
+- "Analyzed several approaches"
+- "Searched for utility directories"
+- "Looked at the file organization"
+
+1. REASONING TRACE (conclusions and recommendations):
+   - WHAT was discovered or decided (specific file paths, patterns)
+   - WHY this is the right approach
+   - WHERE this applies in the codebase
+   - Max 10 entries, prioritize specific file/function recommendations
+
+2. DECISIONS (architectural choices):
+   - Only significant choices that affect future work
+   - What was chosen and why
    - Max 5 decisions
 
 Return JSON:
 {
   "reasoning_trace": [
-    "Created auth/token-store.ts to separate storage logic from validation",
-    "Used Map instead of Object for O(1) lookup performance",
-    "Added expiry check in validateToken to prevent stale token usage"
+    "Utility functions belong in frontend/lib/utils.ts alongside cn(), formatDate(), debounce(), generateId()",
+    "Backend utilities go in backend/app/utils/ with domain-specific files like validation.py",
+    "The @/lib/utils import alias is configured for frontend utility access"
   ],
   "decisions": [
-    {"choice": "Used SHA256 for token hashing", "reason": "Fast, secure enough for this use case, no external deps"},
-    {"choice": "Split into separate files", "reason": "Better testability and single responsibility"}
+    {"choice": "Add to existing utils.ts rather than new file", "reason": "Maintains established pattern, easier discoverability"},
+    {"choice": "Use frontend/lib/ over src/utils/", "reason": "Follows Next.js conventions used throughout project"}
   ]
 }
 
@@ -701,7 +720,8 @@ RESPONSE RULES:
 - English only
 - No emojis
 - Valid JSON only
-- Be specific, not vague (bad: "Fixed bug", good: "Fixed null check in validateToken")`;
+- Extract WHAT and WHERE, not just WHAT was done
+- If no specific conclusions found, return empty arrays`;
     debugLLM('extractReasoningAndDecisions', `Analyzing ${stepsReasoning.length} steps, ${combinedReasoning.length} chars`);
     try {
         const response = await client.messages.create({

package/dist/lib/store.d.ts

@@ -22,6 +22,8 @@ export interface Task {
     turn_number?: number;
     tags: string[];
     created_at: string;
+    synced_at?: string | null;
+    sync_error?: string | null;
 }
 export interface CreateTaskInput {
     project_path: string;
@@ -89,6 +91,11 @@ interface ProxyFields {
     completed_at?: string;
     parent_session_id?: string;
     task_type?: TaskType;
+    pending_correction?: string;
+    pending_forced_recovery?: string;
+    pending_clear_summary?: string;
+    cached_injection?: string;
+    final_response?: string;
 }
 export interface SessionState extends SessionStateBase, HookFields, ProxyFields {
 }
@@ -217,6 +224,18 @@ export declare function updateTaskStatus(id: string, status: TaskStatus): void;
  * Get task count for a project
  */
 export declare function getTaskCount(projectPath: string): number;
+/**
+ * Get unsynced tasks for a project (synced_at is NULL)
+ */
+export declare function getUnsyncedTasks(projectPath: string, limit?: number): Task[];
+/**
+ * Mark a task as synced and clear any previous sync error
+ */
+export declare function markTaskSynced(id: string): void;
+/**
+ * Record a sync error for a task
+ */
+export declare function setTaskSyncError(id: string, error: string): void;
 /**
  * Create a new session state.
  * FIXED: Uses INSERT OR IGNORE to handle race conditions safely.
@@ -306,6 +325,16 @@ export declare function getRecentSteps(sessionId: string, count?: number): StepR
  * Get validated steps only (for summary generation)
  */
 export declare function getValidatedSteps(sessionId: string): StepRecord[];
+/**
+ * Get key decision steps for a session (is_key_decision = 1)
+ * Used for user message injection - important decisions with reasoning
+ */
+export declare function getKeyDecisions(sessionId: string, limit?: number): StepRecord[];
+/**
+ * Get edited files for a session (action_type IN ('edit', 'write'))
+ * Used for user message injection - prevent re-work
+ */
+export declare function getEditedFiles(sessionId: string): string[];
 /**
  * Delete steps for a session
  */
@@ -346,9 +375,10 @@ export declare function getStepsByKeywords(sessionId: string, keywords: string[]
 export declare function getKeyDecisionSteps(sessionId: string, limit?: number): StepRecord[];
 /**
  * Get steps reasoning by file path (for proxy team memory injection)
- * Searches across ALL sessions, returns file-level reasoning from steps table
+ * Searches across sessions, returns file-level reasoning from steps table
+ * @param excludeSessionId - Optional session ID to exclude (for filtering current session)
  */
-export declare function getStepsReasoningByPath(filePath: string, limit?: number): Array<{
+export declare function getStepsReasoningByPath(filePath: string, limit?: number, excludeSessionId?: string): Array<{
     file_path: string;
     reasoning: string;
     anchor?: string;