grov 0.2.3 → 0.5.3

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

@@ -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
  */
@@ -58,19 +24,26 @@ 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
  */
 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>;