grov 0.2.3 → 0.5.3

package/dist/proxy/types.d.ts

@@ -0,0 +1,13 @@
+export interface MessagesRequestBody {
+    model: string;
+    messages: Array<{
+        role: string;
+        content: unknown;
+    }>;
+    system?: string | Array<{
+        type: string;
+        text: string;
+    }>;
+    max_tokens?: number;
+    [key: string]: unknown;
+}

package/dist/proxy/types.js

@@ -0,0 +1,2 @@
+// Shared types for Grov proxy
+export {};

package/dist/proxy/utils/extractors.d.ts

@@ -0,0 +1,18 @@
+import type { AnthropicResponse } from '../action-parser.js';
+import type { ConversationMessage } from '../../lib/llm-extractor.js';
+import type { MessagesRequestBody } from '../types.js';
+export declare function detectKeyDecision(action: {
+    actionType: string;
+    files: string[];
+    command?: string;
+}, reasoning: string): boolean;
+export declare function extractTextContent(response: AnthropicResponse): string;
+export declare function extractProjectPath(body: MessagesRequestBody): string | null;
+export declare function extractGoalFromMessages(messages: Array<{
+    role: string;
+    content: unknown;
+}>): string | undefined;
+export declare function extractConversationHistory(messages: Array<{
+    role: string;
+    content: unknown;
+}>): ConversationMessage[];

package/dist/proxy/utils/extractors.js

@@ -0,0 +1,109 @@
+// Pure extraction functions for parsing request/response data
+export function detectKeyDecision(action, reasoning) {
+    // Code modifications are always key decisions
+    if (action.actionType === 'edit' || action.actionType === 'write') {
+        return true;
+    }
+    // Check for decision-related keywords in reasoning
+    const decisionKeywords = [
+        'decision', 'decided', 'chose', 'chosen', 'selected', 'picked',
+        'approach', 'strategy', 'solution', 'implementation',
+        'because', 'reason', 'rationale', 'trade-off', 'tradeoff',
+        'instead of', 'rather than', 'prefer', 'opted',
+        'conclusion', 'determined', 'resolved'
+    ];
+    const reasoningLower = reasoning.toLowerCase();
+    const hasDecisionKeyword = decisionKeywords.some(kw => reasoningLower.includes(kw));
+    // Substantial reasoning (>200 chars) with decision keyword = key decision
+    if (hasDecisionKeyword && reasoning.length > 200) {
+        return true;
+    }
+    return false;
+}
+export function extractTextContent(response) {
+    return response.content
+        .filter((block) => block.type === 'text')
+        .map(block => block.text)
+        .join('\n');
+}
+export function extractProjectPath(body) {
+    // Try to extract from system prompt or messages
+    // Handle both string and array format for system prompt
+    let systemPrompt = '';
+    if (typeof body.system === 'string') {
+        systemPrompt = body.system;
+    }
+    else if (Array.isArray(body.system)) {
+        // New API format: system is array of {type: 'text', text: '...'}
+        systemPrompt = body.system
+            .filter((block) => block && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string')
+            .map(block => block.text)
+            .join('\n');
+    }
+    const cwdMatch = systemPrompt.match(/Working directory:\s*([^\n]+)/);
+    if (cwdMatch) {
+        return cwdMatch[1].trim();
+    }
+    return null;
+}
+export function extractGoalFromMessages(messages) {
+    const userMessages = messages?.filter(m => m.role === 'user') || [];
+    // Iterate in REVERSE to get the LAST (most recent) user message
+    for (const userMsg of [...userMessages].reverse()) {
+        let rawContent = '';
+        // Handle string content
+        if (typeof userMsg.content === 'string') {
+            rawContent = userMsg.content;
+        }
+        // Handle array content - look for text blocks (skip tool_result)
+        if (Array.isArray(userMsg.content)) {
+            const textBlocks = userMsg.content
+                .filter((block) => block && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string')
+                .map(block => block.text);
+            rawContent = textBlocks.join('\n');
+        }
+        // Remove <system-reminder>...</system-reminder> tags (including orphaned tags from split content blocks)
+        const cleanContent = rawContent
+            .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '')
+            .replace(/<\/system-reminder>/g, '')
+            .replace(/<system-reminder>[^<]*/g, '')
+            .trim();
+        // If we found valid text content, return it
+        if (cleanContent && cleanContent.length >= 5) {
+            return cleanContent.substring(0, 500);
+        }
+    }
+    return undefined;
+}
+export function extractConversationHistory(messages) {
+    if (!messages || messages.length === 0)
+        return [];
+    const result = [];
+    for (const msg of messages.slice(-10)) {
+        if (msg.role !== 'user' && msg.role !== 'assistant')
+            continue;
+        let textContent = '';
+        // Handle string content
+        if (typeof msg.content === 'string') {
+            textContent = msg.content;
+        }
+        // Handle array content - extract text blocks only
+        if (Array.isArray(msg.content)) {
+            const textBlocks = msg.content
+                .filter((block) => block && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string')
+                .map(block => block.text);
+            textContent = textBlocks.join('\n');
+        }
+        // Remove system-reminder tags
+        const cleanContent = textContent
+            .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '')
+            .trim();
+        if (cleanContent && cleanContent.length > 0) {
+            result.push({
+                role: msg.role,
+                content: cleanContent,
+            });
+        }
+    }
+    return result;
+}

package/dist/proxy/utils/logging.d.ts

@@ -0,0 +1,18 @@
+export declare function setDebugMode(enabled: boolean): void;
+export declare function getNextRequestId(): number;
+export declare function taskLog(event: string, data: Record<string, unknown>): void;
+interface ProxyLogEntry {
+    timestamp: string;
+    requestId: number;
+    type: 'REQUEST' | 'RESPONSE' | 'INJECTION';
+    sessionId?: string;
+    data: Record<string, unknown>;
+}
+export declare function proxyLog(entry: Omit<ProxyLogEntry, 'timestamp'>): void;
+export declare function logTokenUsage(requestId: number, usage: {
+    cacheCreation: number;
+    cacheRead: number;
+    inputTokens: number;
+    outputTokens: number;
+}, latencyMs: number): void;
+export {};

package/dist/proxy/utils/logging.js

@@ -0,0 +1,42 @@
+// Debug and file logging utilities for Grov proxy
+import * as fs from 'fs';
+import * as path from 'path';
+let debugMode = false;
+let requestCounter = 0;
+const PROXY_LOG_PATH = path.join(process.cwd(), 'grov-proxy.log');
+const TASK_LOG_PATH = path.join(process.cwd(), 'grov-task.log');
+export function setDebugMode(enabled) {
+    debugMode = enabled;
+}
+export function getNextRequestId() {
+    return ++requestCounter;
+}
+export function taskLog(event, data) {
+    const timestamp = new Date().toISOString();
+    const sessionId = data.sessionId ? String(data.sessionId).substring(0, 8) : '-';
+    // Format: [timestamp] [session] EVENT: key=value key=value
+    const kvPairs = Object.entries(data)
+        .filter(([k]) => k !== 'sessionId')
+        .map(([k, v]) => {
+        const val = typeof v === 'string' ? v.substring(0, 100) : JSON.stringify(v);
+        return `${k}=${val}`;
+    })
+        .join(' | ');
+    const line = `[${timestamp}] [${sessionId}] ${event}: ${kvPairs}\n`;
+    fs.appendFileSync(TASK_LOG_PATH, line);
+}
+export function proxyLog(entry) {
+    if (!debugMode)
+        return;
+    const logEntry = {
+        timestamp: new Date().toISOString(),
+        ...entry,
+    };
+    const line = JSON.stringify(logEntry) + '\n';
+    fs.appendFileSync(PROXY_LOG_PATH, line);
+}
+export function logTokenUsage(requestId, usage, latencyMs) {
+    const total = usage.cacheCreation + usage.cacheRead;
+    const hitRatio = total > 0 ? ((usage.cacheRead / total) * 100).toFixed(0) : '0';
+    console.log(`[${requestId}] ${hitRatio}% cache | in:${usage.inputTokens} out:${usage.outputTokens} | create:${usage.cacheCreation} read:${usage.cacheRead} | ${latencyMs}ms`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grov",
-  "version": "0.2.3",
+  "version": "0.5.3",
   "description": "Collective AI memory for Claude Code - captures reasoning from sessions and injects context into future sessions",
   "type": "module",
   "main": "dist/cli.js",
@@ -16,14 +16,27 @@
     "README.md",
     "LICENSE"
   ],
+  "workspaces": [
+    "shared",
+    "dashboard",
+    "api",
+    "landing"
+  ],
   "scripts": {
     "build": "tsc",
+    "build:all": "turbo run build",
     "dev": "tsc --watch",
+    "dev:dashboard": "turbo run dev --filter=@grov/dashboard",
+    "dev:api": "turbo run dev --filter=@grov/api",
     "start": "node dist/cli.js",
     "proxy": "node dist/proxy/index.js",
     "test": "vitest run",
     "test:watch": "vitest",
-    "prepublishOnly": "npm run build && npm test"
+    "test:all": "turbo run test",
+    "typecheck": "turbo run typecheck",
+    "prepublishOnly": "npm run build && npm test && npm run security:scan",
+    "prepare": "husky",
+    "security:scan": "./scripts/scan-secrets.sh"
   },
   "keywords": [
     "claude",
@@ -55,19 +68,24 @@
     "debug": "^4.4.3",
     "dotenv": "^16.4.5",
     "fastify": "^5.6.2",
+    "open": "^11.0.0",
     "openai": "^4.70.0",
     "pino": "^10.1.0",
     "pino-pretty": "^13.1.2",
     "undici": "^7.16.0"
   },
   "devDependencies": {
+    "@grov/shared": "workspace:*",
     "@types/better-sqlite3": "^7.6.11",
     "@types/debug": "^4.1.12",
     "@types/node": "^22.19.1",
+    "husky": "^9.1.7",
+    "turbo": "^2.6.3",
     "typescript": "^5.7.2",
     "vitest": "^2.1.9"
   },
   "engines": {
-    "node": ">=18.0.0"
-  }
+    "node": ">=20.0.0"
+  },
+  "packageManager": "pnpm@9.15.0"
 }