grov 0.2.3 → 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];

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;