grov 0.1.2 → 0.2.2

package/dist/lib/settings.d.ts

@@ -0,0 +1,19 @@
+interface ClaudeSettings {
+    hooks?: Record<string, unknown>;
+    env?: {
+        ANTHROPIC_BASE_URL?: string;
+        [key: string]: string | undefined;
+    };
+    [key: string]: unknown;
+}
+export declare function readClaudeSettings(): ClaudeSettings;
+export declare function writeClaudeSettings(settings: ClaudeSettings): void;
+export declare function getSettingsPath(): string;
+/**
+ * Set or remove ANTHROPIC_BASE_URL in settings.json env section.
+ * This allows users to just type 'claude' instead of setting env var manually.
+ */
+export declare function setProxyEnv(enable: boolean): {
+    action: 'added' | 'removed' | 'unchanged';
+};
+export {};

package/dist/lib/settings.js

@@ -0,0 +1,63 @@
+// Claude Code settings management
+// Handles ~/.claude/settings.json read/write and proxy configuration
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const CLAUDE_DIR = join(homedir(), '.claude');
+const SETTINGS_PATH = join(CLAUDE_DIR, 'settings.json');
+export function readClaudeSettings() {
+    if (!existsSync(SETTINGS_PATH)) {
+        return {};
+    }
+    try {
+        const content = readFileSync(SETTINGS_PATH, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        console.error('Warning: Could not parse ~/.claude/settings.json');
+        return {};
+    }
+}
+export function writeClaudeSettings(settings) {
+    // Ensure .claude directory exists with restricted permissions
+    if (!existsSync(CLAUDE_DIR)) {
+        mkdirSync(CLAUDE_DIR, { recursive: true, mode: 0o700 });
+    }
+    writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2), { mode: 0o600 });
+}
+export function getSettingsPath() {
+    return SETTINGS_PATH;
+}
+/**
+ * Set or remove ANTHROPIC_BASE_URL in settings.json env section.
+ * This allows users to just type 'claude' instead of setting env var manually.
+ */
+export function setProxyEnv(enable) {
+    const settings = readClaudeSettings();
+    const PROXY_URL = 'http://127.0.0.1:8080';
+    if (enable) {
+        // Add env.ANTHROPIC_BASE_URL
+        if (!settings.env) {
+            settings.env = {};
+        }
+        if (settings.env.ANTHROPIC_BASE_URL === PROXY_URL) {
+            return { action: 'unchanged' };
+        }
+        settings.env.ANTHROPIC_BASE_URL = PROXY_URL;
+        writeClaudeSettings(settings);
+        return { action: 'added' };
+    }
+    else {
+        // Remove env.ANTHROPIC_BASE_URL
+        if (!settings.env?.ANTHROPIC_BASE_URL) {
+            return { action: 'unchanged' };
+        }
+        delete settings.env.ANTHROPIC_BASE_URL;
+        // Clean up empty env object
+        if (Object.keys(settings.env).length === 0) {
+            delete settings.env;
+        }
+        writeClaudeSettings(settings);
+        return { action: 'removed' };
+    }
+}

package/dist/lib/store.d.ts

@@ -1,6 +1,7 @@
 import Database from 'better-sqlite3';
 import type { ClaudeAction } from './session-parser.js';
 export type TaskStatus = 'complete' | 'question' | 'partial' | 'abandoned';
+export type TriggerReason = 'complete' | 'threshold' | 'abandoned';
 export interface Task {
     id: string;
     project_path: string;
@@ -9,7 +10,13 @@ export interface Task {
     goal?: string;
     reasoning_trace: string[];
     files_touched: string[];
+    decisions: Array<{
+        choice: string;
+        reason: string;
+    }>;
+    constraints: string[];
     status: TaskStatus;
+    trigger_reason?: TriggerReason;
     linked_commit?: string;
     parent_task_id?: string;
     turn_number?: number;
@@ -23,35 +30,21 @@ export interface CreateTaskInput {
     goal?: string;
     reasoning_trace?: string[];
     files_touched?: string[];
+    decisions?: Array<{
+        choice: string;
+        reason: string;
+    }>;
+    constraints?: string[];
     status: TaskStatus;
+    trigger_reason?: TriggerReason;
     linked_commit?: string;
     parent_task_id?: string;
     turn_number?: number;
     tags?: string[];
 }
 export type SessionStatus = 'active' | 'completed' | 'abandoned';
-export interface SessionState {
-    session_id: string;
-    user_id?: string;
-    project_path: string;
-    original_goal?: string;
-    actions_taken: string[];
-    files_explored: string[];
-    current_intent?: string;
-    drift_warnings: string[];
-    start_time: string;
-    last_update: string;
-    status: SessionStatus;
-    expected_scope: string[];
-    constraints: string[];
-    success_criteria: string[];
-    keywords: string[];
-    last_drift_score?: number;
-    escalation_count: number;
-    pending_recovery_plan?: RecoveryPlan;
-    drift_history: DriftEvent[];
-    last_checked_at: number;
-}
+export type SessionMode = 'normal' | 'drifted' | 'forced';
+export type TaskType = 'main' | 'subtask' | 'parallel';
 export interface RecoveryPlan {
     steps: Array<{
         file?: string;
@@ -64,6 +57,41 @@ export interface DriftEvent {
     level: string;
     prompt_summary: string;
 }
+interface SessionStateBase {
+    session_id: string;
+    user_id?: string;
+    project_path: string;
+    original_goal?: string;
+    expected_scope: string[];
+    constraints: string[];
+    keywords: string[];
+    escalation_count: number;
+    last_checked_at: number;
+    start_time: string;
+    last_update: string;
+    status: SessionStatus;
+}
+interface HookFields {
+    success_criteria?: string[];
+    last_drift_score?: number;
+    pending_recovery_plan?: RecoveryPlan;
+    drift_history?: DriftEvent[];
+    actions_taken?: string[];
+    files_explored?: string[];
+    current_intent?: string;
+    drift_warnings?: string[];
+}
+interface ProxyFields {
+    token_count?: number;
+    session_mode?: SessionMode;
+    waiting_for_recovery?: boolean;
+    last_clear_at?: number;
+    completed_at?: string;
+    parent_session_id?: string;
+    task_type?: TaskType;
+}
+export interface SessionState extends SessionStateBase, HookFields, ProxyFields {
+}
 export interface CreateSessionStateInput {
     session_id: string;
     user_id?: string;
@@ -71,9 +99,66 @@ export interface CreateSessionStateInput {
     original_goal?: string;
     expected_scope?: string[];
     constraints?: string[];
+    keywords?: string[];
     success_criteria?: string[];
+    parent_session_id?: string;
+    task_type?: TaskType;
+}
+export type StepActionType = 'edit' | 'write' | 'bash' | 'read' | 'glob' | 'grep' | 'task' | 'other';
+export type DriftType = 'none' | 'minor' | 'major' | 'critical';
+export type CorrectionLevel = 'nudge' | 'correct' | 'intervene' | 'halt';
+export interface StepRecord {
+    id: string;
+    session_id: string;
+    action_type: StepActionType;
+    files: string[];
+    folders: string[];
+    command?: string;
+    reasoning?: string;
+    drift_score?: number;
+    drift_type?: DriftType;
+    is_key_decision: boolean;
+    is_validated: boolean;
+    correction_given?: string;
+    correction_level?: CorrectionLevel;
+    keywords: string[];
+    timestamp: number;
+}
+export interface CreateStepInput {
+    session_id: string;
+    action_type: StepActionType;
+    files?: string[];
+    folders?: string[];
+    command?: string;
+    reasoning?: string;
+    drift_score?: number;
+    drift_type?: DriftType;
+    is_key_decision?: boolean;
+    is_validated?: boolean;
+    correction_given?: string;
+    correction_level?: CorrectionLevel;
     keywords?: string[];
 }
+export interface DriftLogEntry {
+    id: string;
+    session_id: string;
+    timestamp: number;
+    action_type?: string;
+    files: string[];
+    drift_score: number;
+    drift_reason?: string;
+    correction_given?: string;
+    recovery_plan?: Record<string, unknown>;
+}
+export interface CreateDriftLogInput {
+    session_id: string;
+    action_type?: string;
+    files?: string[];
+    drift_score: number;
+    drift_reason?: string;
+    correction_given?: string;
+    recovery_plan?: Record<string, unknown>;
+}
 export type ChangeType = 'read' | 'write' | 'edit' | 'create' | 'delete';
 export interface FileReasoning {
     id: string;
@@ -155,9 +240,17 @@ export declare function deleteSessionState(sessionId: string): void;
  */
 export declare function getActiveSessionsForProject(projectPath: string): SessionState[];
 /**
- * Correction level types for drift detection
+ * Get child sessions (subtasks and parallel tasks) for a parent session
  */
-export type CorrectionLevel = 'nudge' | 'correct' | 'intervene' | 'halt';
+export declare function getChildSessions(parentSessionId: string): SessionState[];
+/**
+ * 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[];
 /**
  * Update session drift metrics after a prompt check
  */
@@ -198,29 +291,39 @@ export declare function getFileReasoningByPathPattern(pathPattern: string, limit
  */
 export declare function getDatabasePath(): string;
 /**
- * Step record - a single Claude action stored in DB
+ * Create a new step record (proxy version)
  */
-export interface StepRecord {
-    id: string;
-    session_id: string;
-    action_type: string;
-    files: string[];
-    folders: string[];
-    command?: string;
-    reasoning?: string;
-    drift_score: number;
-    is_key_decision: boolean;
-    keywords: string[];
-    timestamp: number;
-}
+export declare function createStep(input: CreateStepInput): StepRecord;
 /**
- * Save a Claude action as a step
+ * Get steps for a session
  */
-export declare function saveStep(sessionId: string, action: ClaudeAction, driftScore: number, isKeyDecision?: boolean, keywords?: string[]): void;
+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[];
+/**
+ * Delete steps for a session
+ */
+export declare function deleteStepsForSession(sessionId: string): void;
 /**
- * Get recent steps for a session (most recent first)
+ * 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 getRecentSteps(sessionId: string, limit?: number): StepRecord[];
+export declare function updateRecentStepsReasoning(sessionId: string, reasoning: string, limit?: number): number;
+/**
+ * Get relevant steps (key decisions and write/edit actions) - proxy version
+ * Reference: plan_proxy_local.md Section 2.2
+ */
+export declare function getRelevantStepsSimple(sessionId: string, limit?: number): StepRecord[];
+/**
+ * Save a Claude action as a step (hook version - uses ClaudeAction)
+ */
+export declare function saveStep(sessionId: string, action: ClaudeAction, driftScore: number, isKeyDecision?: boolean, keywords?: string[]): void;
 /**
  * Update last_checked_at timestamp for a session
  */
@@ -242,7 +345,62 @@ export declare function getStepsByKeywords(sessionId: string, keywords: string[]
  */
 export declare function getKeyDecisionSteps(sessionId: string, limit?: number): StepRecord[];
 /**
- * Combined retrieval: runs all 4 queries and deduplicates
+ * Get steps reasoning by file path (for proxy team memory injection)
+ * Searches across ALL sessions, returns file-level reasoning from steps table
+ */
+export declare function getStepsReasoningByPath(filePath: string, limit?: number): Array<{
+    file_path: string;
+    reasoning: string;
+    anchor?: string;
+}>;
+/**
+ * Combined retrieval: runs all 4 queries and deduplicates (hook version)
  * Priority: key decisions > files > folders > keywords
  */
 export declare function getRelevantSteps(sessionId: string, currentFiles: string[], currentFolders: string[], keywords: string[], limit?: number): StepRecord[];
+/**
+ * Log a drift event (for rejected actions)
+ */
+export declare function logDriftEvent(input: CreateDriftLogInput): DriftLogEntry;
+/**
+ * Get drift log for a session
+ */
+export declare function getDriftLog(sessionId: string, limit?: number): DriftLogEntry[];
+/**
+ * Update token count for a session
+ */
+export declare function updateTokenCount(sessionId: string, tokenCount: number): void;
+/**
+ * Update session mode
+ */
+export declare function updateSessionMode(sessionId: string, mode: SessionMode): void;
+/**
+ * Mark session as waiting for recovery
+ */
+export declare function markWaitingForRecovery(sessionId: string, waiting: boolean): void;
+/**
+ * Increment escalation count
+ */
+export declare function incrementEscalation(sessionId: string): void;
+/**
+ * Update last clear timestamp and reset token count
+ */
+export declare function markCleared(sessionId: string): void;
+/**
+ * Mark session as completed (instead of deleting)
+ * Session will be cleaned up after 1 hour
+ */
+export declare function markSessionCompleted(sessionId: string): void;
+/**
+ * Cleanup sessions completed more than 24 hours ago
+ * Also deletes associated steps and drift_log entries
+ * Skips sessions that have active children (RESTRICT approach)
+ * Returns number of sessions cleaned up
+ */
+export declare function cleanupOldCompletedSessions(maxAgeMs?: number): number;
+/**
+ * Get completed session for project (for new_task detection)
+ * Returns most recent completed session if exists
+ */
+export declare function getCompletedSessionForProject(projectPath: string): SessionState | null;
+export {};