grov 0.1.1 → 0.2.2

package/dist/proxy/action-parser.d.ts

@@ -0,0 +1,58 @@
+import type { StepActionType } from '../lib/store.js';
+export interface AnthropicResponse {
+    id: string;
+    type: 'message';
+    role: 'assistant';
+    content: ContentBlock[];
+    model: string;
+    stop_reason: string | null;
+    stop_sequence: string | null;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}
+export type ContentBlock = TextBlock | ToolUseBlock;
+export interface TextBlock {
+    type: 'text';
+    text: string;
+}
+export interface ToolUseBlock {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+export interface ParsedAction {
+    toolName: string;
+    toolId: string;
+    actionType: StepActionType;
+    files: string[];
+    folders: string[];
+    command?: string;
+    rawInput: Record<string, unknown>;
+}
+/**
+ * Parse tool_use blocks from Anthropic API response
+ */
+export declare function parseToolUseBlocks(response: AnthropicResponse): ParsedAction[];
+/**
+ * Extract token usage from response
+ */
+export declare function extractTokenUsage(response: AnthropicResponse): {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+};
+/**
+ * Check if response contains any file-modifying actions
+ */
+export declare function hasModifyingActions(actions: ParsedAction[]): boolean;
+/**
+ * Get all unique files from actions
+ */
+export declare function getAllFiles(actions: ParsedAction[]): string[];
+/**
+ * Get all unique folders from actions
+ */
+export declare function getAllFolders(actions: ParsedAction[]): string[];

package/dist/proxy/action-parser.js

@@ -0,0 +1,196 @@
+// Parse tool_use blocks from Anthropic API response
+// Replaces JSONL parsing - works with API response JSON directly
+// Tool name to action type mapping
+const TOOL_ACTION_MAP = {
+    'Edit': 'edit',
+    'Write': 'write',
+    'Read': 'read',
+    'Bash': 'bash',
+    'Glob': 'glob',
+    'Grep': 'grep',
+    'Task': 'task',
+    'MultiEdit': 'edit',
+    'NotebookEdit': 'edit',
+};
+/**
+ * Parse tool_use blocks from Anthropic API response
+ */
+export function parseToolUseBlocks(response) {
+    const actions = [];
+    for (const block of response.content) {
+        if (block.type === 'tool_use') {
+            const action = parseToolUseBlock(block);
+            if (action) {
+                actions.push(action);
+            }
+        }
+    }
+    return actions;
+}
+/**
+ * Parse a single tool_use block
+ */
+function parseToolUseBlock(block) {
+    const actionType = TOOL_ACTION_MAP[block.name] || 'other';
+    const files = [];
+    const folders = [];
+    let command;
+    // Extract file paths based on tool type
+    switch (block.name) {
+        case 'Edit':
+        case 'Write':
+        case 'Read':
+        case 'NotebookEdit':
+            if (typeof block.input.file_path === 'string') {
+                files.push(block.input.file_path);
+            }
+            if (typeof block.input.notebook_path === 'string') {
+                files.push(block.input.notebook_path);
+            }
+            break;
+        case 'MultiEdit':
+            // MultiEdit has an array of edits
+            if (Array.isArray(block.input.edits)) {
+                for (const edit of block.input.edits) {
+                    if (typeof edit === 'object' && edit && typeof edit.file_path === 'string') {
+                        files.push(edit.file_path);
+                    }
+                }
+            }
+            break;
+        case 'Bash':
+            if (typeof block.input.command === 'string') {
+                command = block.input.command;
+                // Try to extract file paths from common command patterns
+                const bashFiles = extractFilesFromBashCommand(command);
+                files.push(...bashFiles);
+            }
+            break;
+        case 'Glob':
+            if (typeof block.input.path === 'string') {
+                folders.push(block.input.path);
+            }
+            if (typeof block.input.pattern === 'string') {
+                // pattern might contain path info
+                const patternPath = extractPathFromGlobPattern(block.input.pattern);
+                if (patternPath) {
+                    folders.push(patternPath);
+                }
+            }
+            break;
+        case 'Grep':
+            if (typeof block.input.path === 'string') {
+                folders.push(block.input.path);
+            }
+            break;
+    }
+    return {
+        toolName: block.name,
+        toolId: block.id,
+        actionType,
+        files: [...new Set(files)],
+        folders: [...new Set(folders)],
+        command,
+        rawInput: block.input
+    };
+}
+/**
+ * Extract file paths from bash command
+ */
+function extractFilesFromBashCommand(command) {
+    const files = [];
+    // Match absolute paths
+    const absolutePathRegex = /(?:^|\s)(\/[^\s"']+)/g;
+    let match;
+    while ((match = absolutePathRegex.exec(command)) !== null) {
+        const path = match[1];
+        // Filter out common non-file paths
+        if (!path.startsWith('/dev/') && !path.startsWith('/proc/') && !path.startsWith('/sys/')) {
+            files.push(path);
+        }
+    }
+    // Match quoted paths
+    const quotedPathRegex = /["'](\/[^"']+)["']/g;
+    while ((match = quotedPathRegex.exec(command)) !== null) {
+        files.push(match[1]);
+    }
+    return files;
+}
+/**
+ * Extract base path from glob pattern
+ */
+function extractPathFromGlobPattern(pattern) {
+    // e.g., "src/**/*.ts" -> "src"
+    const parts = pattern.split('/');
+    const nonGlobParts = [];
+    for (const part of parts) {
+        if (part.includes('*') || part.includes('?') || part.includes('[')) {
+            break;
+        }
+        nonGlobParts.push(part);
+    }
+    return nonGlobParts.length > 0 ? nonGlobParts.join('/') : null;
+}
+/**
+ * Extract token usage from response
+ */
+export function extractTokenUsage(response) {
+    return {
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+        totalTokens: response.usage.input_tokens + response.usage.output_tokens
+    };
+}
+/**
+ * Check if response contains any file-modifying actions
+ */
+export function hasModifyingActions(actions) {
+    return actions.some(a => a.actionType === 'edit' ||
+        a.actionType === 'write' ||
+        (a.actionType === 'bash' && a.command && isModifyingBashCommand(a.command)));
+}
+/**
+ * Check if bash command modifies files
+ */
+function isModifyingBashCommand(command) {
+    const modifyingPatterns = [
+        /\brm\b/,
+        /\bmv\b/,
+        /\bcp\b/,
+        /\bmkdir\b/,
+        /\btouch\b/,
+        /\bchmod\b/,
+        /\bchown\b/,
+        /\bsed\b.*-i/,
+        /\btee\b/,
+        />/, // redirect
+        /\bgit\s+(add|commit|push|checkout|reset)/,
+        /\bnpm\s+(install|uninstall)/,
+        /\byarn\s+(add|remove)/,
+    ];
+    return modifyingPatterns.some(p => p.test(command));
+}
+/**
+ * Get all unique files from actions
+ */
+export function getAllFiles(actions) {
+    const files = new Set();
+    for (const action of actions) {
+        for (const file of action.files) {
+            files.add(file);
+        }
+    }
+    return [...files];
+}
+/**
+ * Get all unique folders from actions
+ */
+export function getAllFolders(actions) {
+    const folders = new Set();
+    for (const action of actions) {
+        for (const folder of action.folders) {
+            folders.add(folder);
+        }
+    }
+    return [...folders];
+}

package/dist/proxy/config.d.ts

@@ -0,0 +1,26 @@
+export declare const config: {
+    HOST: string;
+    PORT: number;
+    ANTHROPIC_BASE_URL: string;
+    REQUEST_TIMEOUT: number;
+    BODY_LIMIT: number;
+    DRIFT_CHECK_INTERVAL: number;
+    TOKEN_WARNING_THRESHOLD: number;
+    TOKEN_CLEAR_THRESHOLD: number;
+    ENABLE_AUTH: boolean;
+    ENABLE_RATE_LIMIT: boolean;
+    ENABLE_TLS: boolean;
+    LOG_LEVEL: string;
+    LOG_REQUESTS: boolean;
+};
+export declare const FORWARD_HEADERS: string[];
+export declare const SENSITIVE_HEADERS: string[];
+/**
+ * Mask sensitive header value for logging
+ */
+export declare function maskSensitiveValue(key: string, value: string): string;
+/**
+ * Build safe headers for forwarding
+ * Handles case-insensitive header matching
+ */
+export declare function buildSafeHeaders(incomingHeaders: Record<string, string | string[] | undefined>): Record<string, string>;

package/dist/proxy/config.js

@@ -0,0 +1,67 @@
+// Proxy configuration
+export const config = {
+    // Server
+    HOST: process.env.PROXY_HOST || '127.0.0.1',
+    PORT: parseInt(process.env.PROXY_PORT || '8080', 10),
+    // Anthropic target
+    ANTHROPIC_BASE_URL: process.env.ANTHROPIC_TARGET || 'https://api.anthropic.com',
+    // Timeouts
+    REQUEST_TIMEOUT: parseInt(process.env.REQUEST_TIMEOUT || '300000', 10), // 5 minutes
+    BODY_LIMIT: parseInt(process.env.BODY_LIMIT || '10485760', 10), // 10MB
+    // Drift settings
+    DRIFT_CHECK_INTERVAL: parseInt(process.env.DRIFT_CHECK_INTERVAL || '3', 10),
+    TOKEN_WARNING_THRESHOLD: parseInt(process.env.TOKEN_WARNING_THRESHOLD || '160000', 10), // 80%
+    TOKEN_CLEAR_THRESHOLD: parseInt(process.env.TOKEN_CLEAR_THRESHOLD || '180000', 10), // 90%
+    // Security (Phase 2 - disabled for local)
+    ENABLE_AUTH: process.env.ENABLE_AUTH === 'true',
+    ENABLE_RATE_LIMIT: process.env.ENABLE_RATE_LIMIT === 'true',
+    ENABLE_TLS: process.env.ENABLE_TLS === 'true',
+    // Logging
+    LOG_LEVEL: process.env.LOG_LEVEL || 'info',
+    LOG_REQUESTS: process.env.LOG_REQUESTS !== 'false',
+};
+// Headers to forward to Anthropic (whitelist approach)
+export const FORWARD_HEADERS = [
+    'x-api-key',
+    'authorization', // Claude Code uses this instead of x-api-key
+    'anthropic-version',
+    'content-type',
+    'anthropic-beta',
+];
+// Headers to never log
+export const SENSITIVE_HEADERS = [
+    'x-api-key',
+    'authorization',
+];
+/**
+ * Mask sensitive header value for logging
+ */
+export function maskSensitiveValue(key, value) {
+    const lowerKey = key.toLowerCase();
+    if (SENSITIVE_HEADERS.includes(lowerKey)) {
+        if (value.length <= 10) {
+            return '***';
+        }
+        return value.substring(0, 7) + '...' + value.substring(value.length - 4);
+    }
+    return value;
+}
+/**
+ * Build safe headers for forwarding
+ * Handles case-insensitive header matching
+ */
+export function buildSafeHeaders(incomingHeaders) {
+    const safe = {};
+    // Create lowercase map of incoming headers
+    const lowerHeaders = {};
+    for (const [key, value] of Object.entries(incomingHeaders)) {
+        lowerHeaders[key.toLowerCase()] = value;
+    }
+    for (const header of FORWARD_HEADERS) {
+        const value = lowerHeaders[header.toLowerCase()];
+        if (value) {
+            safe[header] = Array.isArray(value) ? value[0] : value;
+        }
+    }
+    return safe;
+}

package/dist/proxy/forwarder.d.ts

@@ -0,0 +1,24 @@
+import type { AnthropicResponse } from './action-parser.js';
+export interface ForwardResult {
+    statusCode: number;
+    headers: Record<string, string | string[]>;
+    body: AnthropicResponse | Record<string, unknown>;
+    rawBody: string;
+}
+export interface ForwardError {
+    type: 'timeout' | 'network' | 'parse' | 'unknown';
+    message: string;
+    statusCode?: number;
+}
+/**
+ * Forward request to Anthropic API
+ * Buffers full response for processing
+ */
+export declare function forwardToAnthropic(body: Record<string, unknown>, headers: Record<string, string | string[] | undefined>, logger?: {
+    info: (msg: string, data?: Record<string, unknown>) => void;
+    error: (msg: string, data?: Record<string, unknown>) => void;
+}): Promise<ForwardResult>;
+/**
+ * Check if error is a ForwardError
+ */
+export declare function isForwardError(error: unknown): error is ForwardError;

package/dist/proxy/forwarder.js

@@ -0,0 +1,119 @@
+// Forward requests to Anthropic API using undici
+import { request, Agent } from 'undici';
+// Custom agent with longer connect timeout and better IPv4/IPv6 handling
+const agent = new Agent({
+    connect: {
+        timeout: 30000, // 30s connect timeout
+    },
+    // autoSelectFamily helps when IPv6 isn't working properly
+    autoSelectFamily: true,
+    autoSelectFamilyAttemptTimeout: 500, // Try next address family after 500ms
+});
+import { config, buildSafeHeaders, maskSensitiveValue } from './config.js';
+/**
+ * Forward request to Anthropic API
+ * Buffers full response for processing
+ */
+export async function forwardToAnthropic(body, headers, logger) {
+    const targetUrl = `${config.ANTHROPIC_BASE_URL}/v1/messages`;
+    const safeHeaders = buildSafeHeaders(headers);
+    // Log request (mask sensitive data)
+    if (logger && config.LOG_REQUESTS) {
+        const maskedHeaders = {};
+        for (const [key, value] of Object.entries(safeHeaders)) {
+            maskedHeaders[key] = maskSensitiveValue(key, value);
+        }
+        logger.info('Forwarding to Anthropic', {
+            url: targetUrl,
+            model: body.model,
+            messageCount: Array.isArray(body.messages) ? body.messages.length : 0,
+            headers: maskedHeaders,
+        });
+    }
+    try {
+        const response = await request(targetUrl, {
+            method: 'POST',
+            headers: {
+                ...safeHeaders,
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify(body),
+            bodyTimeout: config.REQUEST_TIMEOUT,
+            headersTimeout: config.REQUEST_TIMEOUT,
+            dispatcher: agent,
+        });
+        // Buffer the full response
+        const chunks = [];
+        for await (const chunk of response.body) {
+            chunks.push(Buffer.from(chunk));
+        }
+        const rawBody = Buffer.concat(chunks).toString('utf-8');
+        // Parse response
+        let parsedBody;
+        try {
+            parsedBody = JSON.parse(rawBody);
+        }
+        catch {
+            // Return raw body if not JSON
+            parsedBody = { error: 'Invalid JSON response', raw: rawBody.substring(0, 500) };
+        }
+        // Convert headers to record
+        const responseHeaders = {};
+        for (const [key, value] of Object.entries(response.headers)) {
+            if (value !== undefined) {
+                responseHeaders[key] = value;
+            }
+        }
+        if (logger && config.LOG_REQUESTS) {
+            logger.info('Received from Anthropic', {
+                statusCode: response.statusCode,
+                bodyLength: rawBody.length,
+                hasUsage: 'usage' in parsedBody,
+            });
+        }
+        return {
+            statusCode: response.statusCode,
+            headers: responseHeaders,
+            body: parsedBody,
+            rawBody,
+        };
+    }
+    catch (error) {
+        const err = error;
+        if (logger) {
+            logger.error('Forward error', {
+                message: err.message,
+                code: err.code,
+            });
+        }
+        // Handle specific error types
+        if (err.code === 'UND_ERR_HEADERS_TIMEOUT' || err.code === 'UND_ERR_BODY_TIMEOUT') {
+            throw createForwardError('timeout', 'Request to Anthropic timed out', 504);
+        }
+        if (err.code === 'ECONNREFUSED' || err.code === 'ENOTFOUND') {
+            throw createForwardError('network', 'Cannot connect to Anthropic API', 502);
+        }
+        if (err.code === 'ECONNRESET' || err.message?.includes('ECONNRESET')) {
+            throw createForwardError('network', 'Connection reset by Anthropic API', 502);
+        }
+        if (err.code === 'UND_ERR_CONNECT_TIMEOUT' || err.message?.includes('Connect Timeout')) {
+            throw createForwardError('timeout', 'Connection to Anthropic API timed out', 504);
+        }
+        throw createForwardError('unknown', err.message || 'Unknown error', 502);
+    }
+}
+/**
+ * Create a typed forward error
+ */
+function createForwardError(type, message, statusCode) {
+    return { type, message, statusCode };
+}
+/**
+ * Check if error is a ForwardError
+ */
+export function isForwardError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'type' in error &&
+        'message' in error);
+}

package/dist/proxy/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/proxy/index.js

@@ -0,0 +1,30 @@
+// Grov Proxy CLI entry point
+// Load .env file for API keys
+import { config } from 'dotenv';
+import { join } from 'path';
+import { homedir } from 'os';
+import { existsSync } from 'fs';
+// Load from current directory .env first
+config();
+// Also load ~/.grov/.env as fallback
+const grovEnvPath = join(homedir(), '.grov', '.env');
+if (existsSync(grovEnvPath)) {
+    config({ path: grovEnvPath });
+}
+import { startServer } from './server.js';
+// Check for API key before starting proxy
+if (!process.env.ANTHROPIC_API_KEY) {
+    console.error('Error: ANTHROPIC_API_KEY is required to run the proxy.\n');
+    console.error('To set it up:\n');
+    console.error('  1. Get your API key at:');
+    console.error('     https://console.anthropic.com/settings/keys\n');
+    console.error('  2. Add to ~/.zshrc (or ~/.bashrc):');
+    console.error('     export ANTHROPIC_API_KEY=sk-ant-...\n');
+    console.error('  3. Restart terminal or run: source ~/.zshrc\n');
+    console.error('Then try again: grov proxy');
+    process.exit(1);
+}
+startServer().catch((err) => {
+    console.error('Proxy failed:', err);
+    process.exit(1);
+});

package/dist/proxy/request-processor.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Build context from team memory for injection
+ * Queries tasks and file_reasoning tables
+ */
+export declare function buildTeamMemoryContext(projectPath: string, mentionedFiles: string[]): string | null;
+/**
+ * Extract file paths from messages
+ */
+export declare function extractFilesFromMessages(messages: Array<{
+    role: string;
+    content: unknown;
+}>): string[];

package/dist/proxy/request-processor.js

@@ -0,0 +1,94 @@
+// Request processor - handles context injection from team memory
+// Reference: plan_proxy_local.md Section 2.1
+import { getTasksForProject, getTasksByFiles, getStepsReasoningByPath, } from '../lib/store.js';
+import { truncate } from '../lib/utils.js';
+/**
+ * Build context from team memory for injection
+ * Queries tasks and file_reasoning tables
+ */
+export function buildTeamMemoryContext(projectPath, mentionedFiles) {
+    // Get recent completed tasks for this project
+    const tasks = getTasksForProject(projectPath, {
+        status: 'complete',
+        limit: 10,
+    });
+    // Get tasks that touched mentioned files
+    const fileTasks = mentionedFiles.length > 0
+        ? getTasksByFiles(projectPath, mentionedFiles, { status: 'complete', limit: 5 })
+        : [];
+    // Get file-level reasoning from steps table (proxy version)
+    const fileReasonings = mentionedFiles.length > 0
+        ? mentionedFiles.flatMap(f => getStepsReasoningByPath(f, 3))
+        : [];
+    // Combine unique tasks
+    const allTasks = [...new Map([...tasks, ...fileTasks].map(t => [t.id, t])).values()];
+    if (allTasks.length === 0 && fileReasonings.length === 0) {
+        return null;
+    }
+    return formatTeamMemoryContext(allTasks, fileReasonings, mentionedFiles);
+}
+/**
+ * Format team memory context for injection
+ */
+function formatTeamMemoryContext(tasks, fileReasonings, files) {
+    const lines = [];
+    lines.push('[GROV CONTEXT - Relevant past reasoning]');
+    lines.push('');
+    // File-level context
+    if (fileReasonings.length > 0) {
+        lines.push('File-level context:');
+        for (const fr of fileReasonings.slice(0, 5)) {
+            const anchor = fr.anchor ? ` (${fr.anchor})` : '';
+            lines.push(`- ${fr.file_path}${anchor}: ${truncate(fr.reasoning, 100)}`);
+        }
+        lines.push('');
+    }
+    // Task context with decisions and constraints
+    if (tasks.length > 0) {
+        lines.push('Related past tasks:');
+        for (const task of tasks.slice(0, 5)) {
+            lines.push(`- ${truncate(task.original_query, 60)}`);
+            if (task.files_touched.length > 0) {
+                const fileList = task.files_touched.slice(0, 3).map(f => f.split('/').pop()).join(', ');
+                lines.push(`  Files: ${fileList}`);
+            }
+            if (task.reasoning_trace.length > 0) {
+                lines.push(`  Key: ${truncate(task.reasoning_trace[0], 80)}`);
+            }
+            // Include decisions if available
+            if (task.decisions && task.decisions.length > 0) {
+                lines.push(`  Decision: ${task.decisions[0].choice} (${truncate(task.decisions[0].reason, 50)})`);
+            }
+            // Include constraints if available
+            if (task.constraints && task.constraints.length > 0) {
+                lines.push(`  Constraints: ${task.constraints.slice(0, 2).join(', ')}`);
+            }
+        }
+        lines.push('');
+    }
+    if (files.length > 0) {
+        lines.push(`You may already have context for: ${files.join(', ')}`);
+    }
+    lines.push('[END GROV CONTEXT]');
+    return lines.join('\n');
+}
+/**
+ * Extract file paths from messages
+ */
+export function extractFilesFromMessages(messages) {
+    const files = [];
+    const filePattern = /(?:^|\s|["'`])([\/\w.-]+\.[a-zA-Z]{1,10})(?:["'`]|\s|$|:|\))/g;
+    for (const msg of messages) {
+        if (typeof msg.content === 'string') {
+            let match;
+            while ((match = filePattern.exec(msg.content)) !== null) {
+                const path = match[1];
+                // Filter out common false positives
+                if (!path.includes('http') && !path.startsWith('.') && path.length > 3) {
+                    files.push(path);
+                }
+            }
+        }
+    }
+    return [...new Set(files)];
+}

package/dist/proxy/response-processor.d.ts

@@ -0,0 +1,14 @@
+import { type TriggerReason } from '../lib/store.js';
+/**
+ * Save session to team memory
+ * Called on: task complete, subtask complete, session abandoned
+ */
+export declare function saveToTeamMemory(sessionId: string, triggerReason: TriggerReason): Promise<void>;
+/**
+ * Clean up session data after save
+ */
+export declare function cleanupSession(sessionId: string): void;
+/**
+ * Save and cleanup session (for session end)
+ */
+export declare function saveAndCleanupSession(sessionId: string, triggerReason: TriggerReason): Promise<void>;