grov 0.5.2 → 0.5.4

package/dist/lib/store/sessions.d.ts

@@ -0,0 +1,32 @@
+import type { SessionState, CreateSessionStateInput } from './types.js';
+/**
+ * Create a new session state.
+ * Uses INSERT OR IGNORE to handle race conditions safely.
+ */
+export declare function createSessionState(input: CreateSessionStateInput): SessionState;
+/**
+ * Get a session state by ID
+ */
+export declare function getSessionState(sessionId: string): SessionState | null;
+/**
+ * Update a session state.
+ * Uses transaction for atomic updates to prevent race conditions.
+ */
+export declare function updateSessionState(sessionId: string, updates: Partial<Omit<SessionState, 'session_id' | 'start_time'>>): void;
+/**
+ * Delete a session state
+ */
+export declare function deleteSessionState(sessionId: string): void;
+/**
+ * Get active session for a specific user in a project
+ */
+export declare function getActiveSessionForUser(projectPath: string, userId?: string): SessionState | null;
+/**
+ * Get all active sessions (for proxy-status command)
+ */
+export declare function getActiveSessionsForStatus(): SessionState[];
+/**
+ * Get completed session for project (for new_task detection)
+ * Returns most recent completed session if exists
+ */
+export declare function getCompletedSessionForProject(projectPath: string): SessionState | null;

package/dist/lib/store/sessions.js

@@ -0,0 +1,240 @@
+// Session state CRUD operations
+import { getDb, safeJsonParse } from './database.js';
+/**
+ * Convert database row to SessionState object
+ */
+function rowToSessionState(row) {
+    return {
+        // Base fields
+        session_id: row.session_id,
+        user_id: row.user_id,
+        project_path: row.project_path,
+        original_goal: row.original_goal,
+        expected_scope: safeJsonParse(row.expected_scope, []),
+        constraints: safeJsonParse(row.constraints, []),
+        keywords: safeJsonParse(row.keywords, []),
+        escalation_count: row.escalation_count || 0,
+        last_checked_at: row.last_checked_at || 0,
+        start_time: row.start_time,
+        last_update: row.last_update,
+        status: row.status,
+        // Hook-specific fields
+        success_criteria: safeJsonParse(row.success_criteria, []),
+        last_drift_score: row.last_drift_score,
+        pending_recovery_plan: safeJsonParse(row.pending_recovery_plan, undefined),
+        drift_history: safeJsonParse(row.drift_history, []),
+        actions_taken: safeJsonParse(row.actions_taken, []),
+        files_explored: safeJsonParse(row.files_explored, []),
+        current_intent: row.current_intent,
+        drift_warnings: safeJsonParse(row.drift_warnings, []),
+        // Proxy-specific fields
+        token_count: row.token_count || 0,
+        session_mode: row.session_mode || 'normal',
+        waiting_for_recovery: Boolean(row.waiting_for_recovery),
+        last_clear_at: row.last_clear_at,
+        completed_at: row.completed_at,
+        parent_session_id: row.parent_session_id,
+        task_type: row.task_type || 'main',
+        pending_correction: row.pending_correction,
+        pending_forced_recovery: row.pending_forced_recovery,
+        pending_clear_summary: row.pending_clear_summary,
+        final_response: row.final_response,
+    };
+}
+/**
+ * Create a new session state.
+ * Uses INSERT OR IGNORE to handle race conditions safely.
+ */
+export function createSessionState(input) {
+    const database = getDb();
+    const now = new Date().toISOString();
+    const sessionState = {
+        // Base fields
+        session_id: input.session_id,
+        user_id: input.user_id,
+        project_path: input.project_path,
+        original_goal: input.original_goal,
+        expected_scope: input.expected_scope || [],
+        constraints: input.constraints || [],
+        keywords: input.keywords || [],
+        escalation_count: 0,
+        last_checked_at: 0,
+        start_time: now,
+        last_update: now,
+        status: 'active',
+        // Hook-specific fields
+        success_criteria: input.success_criteria || [],
+        last_drift_score: undefined,
+        pending_recovery_plan: undefined,
+        drift_history: [],
+        actions_taken: [],
+        files_explored: [],
+        current_intent: undefined,
+        drift_warnings: [],
+        // Proxy-specific fields
+        token_count: 0,
+        session_mode: 'normal',
+        waiting_for_recovery: false,
+        last_clear_at: undefined,
+        completed_at: undefined,
+        parent_session_id: input.parent_session_id,
+        task_type: input.task_type || 'main',
+    };
+    const stmt = database.prepare(`
+    INSERT OR IGNORE INTO session_states (
+      session_id, user_id, project_path, original_goal,
+      expected_scope, constraints, keywords,
+      token_count, escalation_count, session_mode,
+      waiting_for_recovery, last_checked_at, last_clear_at,
+      start_time, last_update, status,
+      parent_session_id, task_type,
+      success_criteria, last_drift_score, pending_recovery_plan, drift_history,
+      completed_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    stmt.run(sessionState.session_id, sessionState.user_id || null, sessionState.project_path, sessionState.original_goal || null, JSON.stringify(sessionState.expected_scope), JSON.stringify(sessionState.constraints), JSON.stringify(sessionState.keywords), sessionState.token_count, sessionState.escalation_count, sessionState.session_mode, sessionState.waiting_for_recovery ? 1 : 0, sessionState.last_checked_at, sessionState.last_clear_at || null, sessionState.start_time, sessionState.last_update, sessionState.status, sessionState.parent_session_id || null, sessionState.task_type, JSON.stringify(sessionState.success_criteria || []), sessionState.last_drift_score || null, sessionState.pending_recovery_plan ? JSON.stringify(sessionState.pending_recovery_plan) : null, JSON.stringify(sessionState.drift_history || []), sessionState.completed_at || null);
+    return sessionState;
+}
+/**
+ * Get a session state by ID
+ */
+export function getSessionState(sessionId) {
+    const database = getDb();
+    const stmt = database.prepare('SELECT * FROM session_states WHERE session_id = ?');
+    const row = stmt.get(sessionId);
+    return row ? rowToSessionState(row) : null;
+}
+/**
+ * Update a session state.
+ * Uses transaction for atomic updates to prevent race conditions.
+ */
+export function updateSessionState(sessionId, updates) {
+    const database = getDb();
+    const setClauses = [];
+    const params = [];
+    if (updates.user_id !== undefined) {
+        setClauses.push('user_id = ?');
+        params.push(updates.user_id || null);
+    }
+    if (updates.project_path !== undefined) {
+        setClauses.push('project_path = ?');
+        params.push(updates.project_path);
+    }
+    if (updates.original_goal !== undefined) {
+        setClauses.push('original_goal = ?');
+        params.push(updates.original_goal || null);
+    }
+    if (updates.expected_scope !== undefined) {
+        setClauses.push('expected_scope = ?');
+        params.push(JSON.stringify(updates.expected_scope));
+    }
+    if (updates.constraints !== undefined) {
+        setClauses.push('constraints = ?');
+        params.push(JSON.stringify(updates.constraints));
+    }
+    if (updates.keywords !== undefined) {
+        setClauses.push('keywords = ?');
+        params.push(JSON.stringify(updates.keywords));
+    }
+    if (updates.token_count !== undefined) {
+        setClauses.push('token_count = ?');
+        params.push(updates.token_count);
+    }
+    if (updates.escalation_count !== undefined) {
+        setClauses.push('escalation_count = ?');
+        params.push(updates.escalation_count);
+    }
+    if (updates.session_mode !== undefined) {
+        setClauses.push('session_mode = ?');
+        params.push(updates.session_mode);
+    }
+    if (updates.waiting_for_recovery !== undefined) {
+        setClauses.push('waiting_for_recovery = ?');
+        params.push(updates.waiting_for_recovery ? 1 : 0);
+    }
+    if (updates.last_checked_at !== undefined) {
+        setClauses.push('last_checked_at = ?');
+        params.push(updates.last_checked_at);
+    }
+    if (updates.last_clear_at !== undefined) {
+        setClauses.push('last_clear_at = ?');
+        params.push(updates.last_clear_at);
+    }
+    if (updates.status !== undefined) {
+        setClauses.push('status = ?');
+        params.push(updates.status);
+    }
+    if (updates.pending_correction !== undefined) {
+        setClauses.push('pending_correction = ?');
+        params.push(updates.pending_correction || null);
+    }
+    if (updates.pending_forced_recovery !== undefined) {
+        setClauses.push('pending_forced_recovery = ?');
+        params.push(updates.pending_forced_recovery || null);
+    }
+    if (updates.pending_clear_summary !== undefined) {
+        setClauses.push('pending_clear_summary = ?');
+        params.push(updates.pending_clear_summary || null);
+    }
+    if (updates.final_response !== undefined) {
+        setClauses.push('final_response = ?');
+        params.push(updates.final_response || null);
+    }
+    // Always update last_update
+    setClauses.push('last_update = ?');
+    params.push(new Date().toISOString());
+    if (setClauses.length === 0)
+        return;
+    params.push(sessionId);
+    const sql = `UPDATE session_states SET ${setClauses.join(', ')} WHERE session_id = ?`;
+    const transaction = database.transaction(() => {
+        database.prepare(sql).run(...params);
+    });
+    transaction();
+}
+/**
+ * Delete a session state
+ */
+export function deleteSessionState(sessionId) {
+    const database = getDb();
+    database.prepare('DELETE FROM session_states WHERE session_id = ?').run(sessionId);
+}
+/**
+ * Get active session for a specific user in a project
+ */
+export function getActiveSessionForUser(projectPath, userId) {
+    const database = getDb();
+    if (userId) {
+        const stmt = database.prepare("SELECT * FROM session_states WHERE project_path = ? AND user_id = ? AND status = 'active' ORDER BY last_update DESC LIMIT 1");
+        const row = stmt.get(projectPath, userId);
+        return row ? rowToSessionState(row) : null;
+    }
+    else {
+        const stmt = database.prepare("SELECT * FROM session_states WHERE project_path = ? AND status = 'active' ORDER BY last_update DESC LIMIT 1");
+        const row = stmt.get(projectPath);
+        return row ? rowToSessionState(row) : null;
+    }
+}
+/**
+ * Get all active sessions (for proxy-status command)
+ */
+export function getActiveSessionsForStatus() {
+    const database = getDb();
+    const stmt = database.prepare("SELECT * FROM session_states WHERE status = 'active' ORDER BY last_update DESC LIMIT 20");
+    const rows = stmt.all();
+    return rows.map(rowToSessionState);
+}
+/**
+ * Get completed session for project (for new_task detection)
+ * Returns most recent completed session if exists
+ */
+export function getCompletedSessionForProject(projectPath) {
+    const database = getDb();
+    const row = database.prepare(`
+    SELECT * FROM session_states
+    WHERE project_path = ? AND status = 'completed'
+    ORDER BY completed_at DESC
+    LIMIT 1
+  `).get(projectPath);
+    return row ? rowToSessionState(row) : null;
+}

package/dist/lib/store/steps.d.ts

@@ -0,0 +1,40 @@
+import type { StepRecord, CreateStepInput } from './types.js';
+/**
+ * Create a new step record
+ */
+export declare function createStep(input: CreateStepInput): StepRecord;
+/**
+ * Get steps for a session
+ */
+export declare function getStepsForSession(sessionId: string, limit?: number): StepRecord[];
+/**
+ * Get recent steps for a session (most recent N)
+ */
+export declare function getRecentSteps(sessionId: string, count?: number): StepRecord[];
+/**
+ * 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
+ */
+export declare function deleteStepsForSession(sessionId: string): void;
+/**
+ * Update reasoning for recent steps that don't have reasoning yet
+ * Called at end_turn to backfill reasoning from Claude's text response
+ */
+export declare function updateRecentStepsReasoning(sessionId: string, reasoning: string, limit?: number): number;
+/**
+ * Update last_checked_at timestamp for a session
+ */
+export declare function updateLastChecked(sessionId: string, timestamp: number): void;

package/dist/lib/store/steps.js

@@ -0,0 +1,161 @@
+// Step record CRUD operations
+import { randomUUID } from 'crypto';
+import { getDb, safeJsonParse } from './database.js';
+/**
+ * Convert database row to StepRecord object
+ */
+function rowToStep(row) {
+    return {
+        id: row.id,
+        session_id: row.session_id,
+        action_type: row.action_type,
+        files: safeJsonParse(row.files, []),
+        folders: safeJsonParse(row.folders, []),
+        command: row.command,
+        reasoning: row.reasoning,
+        drift_score: row.drift_score,
+        drift_type: row.drift_type,
+        is_key_decision: Boolean(row.is_key_decision),
+        is_validated: Boolean(row.is_validated),
+        correction_given: row.correction_given,
+        correction_level: row.correction_level,
+        keywords: safeJsonParse(row.keywords, []),
+        timestamp: row.timestamp
+    };
+}
+/**
+ * Create a new step record
+ */
+export function createStep(input) {
+    const database = getDb();
+    const step = {
+        id: randomUUID(),
+        session_id: input.session_id,
+        action_type: input.action_type,
+        files: input.files || [],
+        folders: input.folders || [],
+        command: input.command,
+        reasoning: input.reasoning,
+        drift_score: input.drift_score,
+        drift_type: input.drift_type,
+        is_key_decision: input.is_key_decision || false,
+        is_validated: input.is_validated !== false,
+        correction_given: input.correction_given,
+        correction_level: input.correction_level,
+        keywords: input.keywords || [],
+        timestamp: Date.now()
+    };
+    const stmt = database.prepare(`
+    INSERT INTO steps (
+      id, session_id, action_type, files, folders, command, reasoning,
+      drift_score, drift_type, is_key_decision, is_validated,
+      correction_given, correction_level, keywords, timestamp
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    stmt.run(step.id, step.session_id, step.action_type, JSON.stringify(step.files), JSON.stringify(step.folders), step.command || null, step.reasoning || null, step.drift_score || null, step.drift_type || null, step.is_key_decision ? 1 : 0, step.is_validated ? 1 : 0, step.correction_given || null, step.correction_level || null, JSON.stringify(step.keywords), step.timestamp);
+    return step;
+}
+/**
+ * Get steps for a session
+ */
+export function getStepsForSession(sessionId, limit) {
+    const database = getDb();
+    let sql = 'SELECT * FROM steps WHERE session_id = ? ORDER BY timestamp DESC';
+    const params = [sessionId];
+    if (limit) {
+        sql += ' LIMIT ?';
+        params.push(limit);
+    }
+    const stmt = database.prepare(sql);
+    const rows = stmt.all(...params);
+    return rows.map(rowToStep);
+}
+/**
+ * Get recent steps for a session (most recent N)
+ */
+export function getRecentSteps(sessionId, count = 10) {
+    return getStepsForSession(sessionId, count);
+}
+/**
+ * Get validated steps only (for summary generation)
+ */
+export function getValidatedSteps(sessionId) {
+    const database = getDb();
+    const stmt = database.prepare('SELECT * FROM steps WHERE session_id = ? AND is_validated = 1 ORDER BY timestamp ASC');
+    const rows = stmt.all(sessionId);
+    return rows.map(rowToStep);
+}
+/**
+ * Get key decision steps for a session (is_key_decision = 1)
+ * Used for user message injection - important decisions with reasoning
+ */
+export function getKeyDecisions(sessionId, limit = 5) {
+    const database = getDb();
+    const stmt = database.prepare(`SELECT * FROM steps
+     WHERE session_id = ? AND is_key_decision = 1 AND reasoning IS NOT NULL
+     ORDER BY timestamp DESC
+     LIMIT ?`);
+    const rows = stmt.all(sessionId, limit);
+    return rows.map(rowToStep);
+}
+/**
+ * Get edited files for a session (action_type IN ('edit', 'write'))
+ * Used for user message injection - prevent re-work
+ */
+export function getEditedFiles(sessionId) {
+    const database = getDb();
+    const stmt = database.prepare(`SELECT DISTINCT files FROM steps
+     WHERE session_id = ? AND action_type IN ('edit', 'write')
+     ORDER BY timestamp DESC`);
+    const rows = stmt.all(sessionId);
+    const allFiles = [];
+    for (const row of rows) {
+        try {
+            const files = JSON.parse(row.files || '[]');
+            if (Array.isArray(files)) {
+                allFiles.push(...files);
+            }
+        }
+        catch {
+            // Skip invalid JSON
+        }
+    }
+    return [...new Set(allFiles)];
+}
+/**
+ * Delete steps for a session
+ */
+export function deleteStepsForSession(sessionId) {
+    const database = getDb();
+    database.prepare('DELETE FROM steps WHERE session_id = ?').run(sessionId);
+}
+/**
+ * Update reasoning for recent steps that don't have reasoning yet
+ * Called at end_turn to backfill reasoning from Claude's text response
+ */
+export function updateRecentStepsReasoning(sessionId, reasoning, limit = 10) {
+    const database = getDb();
+    const stmt = database.prepare(`
+    UPDATE steps
+    SET reasoning = ?
+    WHERE session_id = ?
+    AND (reasoning IS NULL OR reasoning = '')
+    AND id IN (
+      SELECT id FROM steps
+      WHERE session_id = ?
+      ORDER BY timestamp DESC
+      LIMIT ?
+    )
+  `);
+    const result = stmt.run(reasoning, sessionId, sessionId, limit);
+    return result.changes;
+}
+/**
+ * Update last_checked_at timestamp for a session
+ */
+export function updateLastChecked(sessionId, timestamp) {
+    const database = getDb();
+    database.prepare(`
+    UPDATE session_states SET last_checked_at = ? WHERE session_id = ?
+  `).run(timestamp, sessionId);
+}

package/dist/lib/store/tasks.d.ts

@@ -0,0 +1,33 @@
+import type { Task, CreateTaskInput, TaskStatus } from './types.js';
+/**
+ * Create a new task
+ */
+export declare function createTask(input: CreateTaskInput): Task;
+/**
+ * Get tasks for a project from LOCAL SQLite database
+ *
+ * Used by:
+ * - `grov status` command (CLI)
+ *
+ * For CLOUD injection, use fetchTeamMemories() from api-client.ts instead.
+ */
+export declare function getTasksForProject(projectPath: string, options?: {
+    status?: TaskStatus;
+    limit?: number;
+}): Task[];
+/**
+ * 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;

package/dist/lib/store/tasks.js

@@ -0,0 +1,133 @@
+// Task CRUD operations
+import { randomUUID } from 'crypto';
+import { getDb, safeJsonParse } from './database.js';
+/**
+ * Convert database row to Task object
+ */
+function rowToTask(row) {
+    return {
+        id: row.id,
+        project_path: row.project_path,
+        user: row.user,
+        original_query: row.original_query,
+        goal: row.goal,
+        reasoning_trace: safeJsonParse(row.reasoning_trace, []),
+        files_touched: safeJsonParse(row.files_touched, []),
+        decisions: safeJsonParse(row.decisions, []),
+        constraints: safeJsonParse(row.constraints, []),
+        status: row.status,
+        trigger_reason: row.trigger_reason,
+        linked_commit: row.linked_commit,
+        parent_task_id: row.parent_task_id,
+        turn_number: row.turn_number,
+        tags: safeJsonParse(row.tags, []),
+        created_at: row.created_at,
+        synced_at: row.synced_at,
+        sync_error: row.sync_error
+    };
+}
+/**
+ * Create a new task
+ */
+export function createTask(input) {
+    const database = getDb();
+    const task = {
+        id: randomUUID(),
+        project_path: input.project_path,
+        user: input.user,
+        original_query: input.original_query,
+        goal: input.goal,
+        reasoning_trace: input.reasoning_trace || [],
+        files_touched: input.files_touched || [],
+        decisions: input.decisions || [],
+        constraints: input.constraints || [],
+        status: input.status,
+        trigger_reason: input.trigger_reason,
+        linked_commit: input.linked_commit,
+        parent_task_id: input.parent_task_id,
+        turn_number: input.turn_number,
+        tags: input.tags || [],
+        created_at: new Date().toISOString(),
+        synced_at: null,
+        sync_error: null
+    };
+    const stmt = database.prepare(`
+    INSERT INTO tasks (
+      id, project_path, user, original_query, goal,
+      reasoning_trace, files_touched, decisions, constraints,
+      status, trigger_reason, linked_commit,
+      parent_task_id, turn_number, tags, created_at, synced_at, sync_error
+    ) VALUES (
+      ?, ?, ?, ?, ?,
+      ?, ?, ?, ?,
+      ?, ?, ?,
+      ?, ?, ?, ?, ?, ?
+    )
+  `);
+    stmt.run(task.id, task.project_path, task.user || null, task.original_query, task.goal || null, JSON.stringify(task.reasoning_trace), JSON.stringify(task.files_touched), JSON.stringify(task.decisions), JSON.stringify(task.constraints), task.status, task.trigger_reason || null, task.linked_commit || null, task.parent_task_id || null, task.turn_number || null, JSON.stringify(task.tags), task.created_at, task.synced_at, task.sync_error);
+    return task;
+}
+/**
+ * Get tasks for a project from LOCAL SQLite database
+ *
+ * Used by:
+ * - `grov status` command (CLI)
+ *
+ * For CLOUD injection, use fetchTeamMemories() from api-client.ts instead.
+ */
+export function getTasksForProject(projectPath, options = {}) {
+    const database = getDb();
+    let sql = 'SELECT * FROM tasks WHERE project_path = ?';
+    const params = [projectPath];
+    if (options.status) {
+        sql += ' AND status = ?';
+        params.push(options.status);
+    }
+    sql += ' ORDER BY created_at DESC';
+    if (options.limit) {
+        sql += ' LIMIT ?';
+        params.push(options.limit);
+    }
+    const stmt = database.prepare(sql);
+    const rows = stmt.all(...params);
+    return rows.map(rowToTask);
+}
+/**
+ * Get task count for a project
+ */
+export function getTaskCount(projectPath) {
+    const database = getDb();
+    const stmt = database.prepare('SELECT COUNT(*) as count FROM tasks WHERE project_path = ?');
+    const row = stmt.get(projectPath);
+    return row?.count ?? 0;
+}
+/**
+ * Get unsynced tasks for a project (synced_at is NULL)
+ */
+export function getUnsyncedTasks(projectPath, limit) {
+    const database = getDb();
+    let sql = 'SELECT * FROM tasks WHERE project_path = ? AND synced_at IS NULL ORDER BY created_at DESC';
+    const params = [projectPath];
+    if (limit) {
+        sql += ' LIMIT ?';
+        params.push(limit);
+    }
+    const stmt = database.prepare(sql);
+    const rows = stmt.all(...params);
+    return rows.map(rowToTask);
+}
+/**
+ * Mark a task as synced and clear any previous sync error
+ */
+export function markTaskSynced(id) {
+    const database = getDb();
+    const now = new Date().toISOString();
+    database.prepare('UPDATE tasks SET synced_at = ?, sync_error = NULL WHERE id = ?').run(now, id);
+}
+/**
+ * Record a sync error for a task
+ */
+export function setTaskSyncError(id, error) {
+    const database = getDb();
+    database.prepare('UPDATE tasks SET sync_error = ? WHERE id = ?').run(error, id);
+}