grov 0.5.11 → 0.6.13

package/dist/integrations/proxy/injection/memory-injection.js

@@ -0,0 +1,252 @@
+// Memory injection - Preview + Expand system for team memory
+// Reference: docs/new_injection.md
+const sessionState = new Map();
+export function getOrCreateState(sessionId) {
+    if (!sessionState.has(sessionId)) {
+        sessionState.set(sessionId, {
+            memoriesById: new Map(),
+            injectionHistory: [],
+            pendingRecords: [],
+            lastOriginalMsgCount: 0,
+        });
+    }
+    return sessionState.get(sessionId);
+}
+export function clearSessionState(sessionId) {
+    sessionState.delete(sessionId);
+}
+export function cacheMemories(sessionId, memories) {
+    const state = getOrCreateState(sessionId);
+    state.memoriesById = new Map();
+    for (const memory of memories) {
+        state.memoriesById.set(memory.id, memory);
+    }
+}
+// ID-based lookup
+export function getCachedMemoryById(sessionId, memoryId) {
+    const state = sessionState.get(sessionId);
+    if (!state?.memoriesById) {
+        return null;
+    }
+    // Support both full ID and 8-char prefix
+    if (state.memoriesById.has(memoryId)) {
+        return state.memoriesById.get(memoryId) || null;
+    }
+    // Try prefix match (first 8 chars)
+    for (const [id, memory] of state.memoriesById) {
+        if (id.startsWith(memoryId) || memoryId.startsWith(id.substring(0, 8))) {
+            return memory;
+        }
+    }
+    return null;
+}
+export function setCachedPreview(sessionId, preview, msgCount) {
+    const state = getOrCreateState(sessionId);
+    state.cachedPreview = { preview, msgCount };
+}
+export function getCachedPreview(sessionId, currentMsgCount) {
+    const state = sessionState.get(sessionId);
+    if (!state?.cachedPreview)
+        return null;
+    if (state.cachedPreview.msgCount !== currentMsgCount)
+        return null;
+    return state.cachedPreview.preview;
+}
+// Add record to PENDING (not committed yet - waits for next turn)
+export function addInjectionRecord(sessionId, record) {
+    const state = getOrCreateState(sessionId);
+    state.pendingRecords.push(record);
+}
+// Commit pending records to history (called at start of NEW turn)
+export function commitPendingRecords(sessionId) {
+    const state = sessionState.get(sessionId);
+    if (!state || state.pendingRecords.length === 0)
+        return 0;
+    const count = state.pendingRecords.length;
+    state.injectionHistory.push(...state.pendingRecords);
+    state.pendingRecords = [];
+    return count;
+}
+// Check if tool_cycle already exists for position (in committed OR pending)
+export function hasToolCycleAtPosition(sessionId, position) {
+    const state = sessionState.get(sessionId);
+    if (!state)
+        return false;
+    // Check both committed history and pending records
+    const inHistory = state.injectionHistory.some((r) => r.type === 'tool_cycle' && r.position === position);
+    const inPending = state.pendingRecords.some((r) => r.type === 'tool_cycle' && r.position === position);
+    return inHistory || inPending;
+}
+export function formatAge(updatedAt) {
+    if (!updatedAt)
+        return 'unknown';
+    const diffMs = Date.now() - new Date(updatedAt).getTime();
+    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    if (diffDays === 0)
+        return 'today';
+    if (diffDays === 1)
+        return '1 day ago';
+    if (diffDays < 7)
+        return `${diffDays} days ago`;
+    const diffWeeks = Math.floor(diffDays / 7);
+    if (diffWeeks === 1)
+        return '1 week ago';
+    if (diffWeeks < 4)
+        return `${diffWeeks} weeks ago`;
+    const diffMonths = Math.floor(diffDays / 30);
+    if (diffMonths === 1)
+        return '1 month ago';
+    return `${diffMonths} months ago`;
+}
+export function buildMemoryPreview(memories) {
+    if (!memories || memories.length === 0)
+        return null;
+    const lines = [`[PROJECT KNOWLEDGE BASE: ${memories.length} verified entries - CURRENT]`];
+    memories.forEach((memory) => {
+        const idShort = memory.id.substring(0, 8);
+        const goal = memory.goal || 'No goal';
+        const summary = memory.summary || 'No summary';
+        const age = formatAge(memory.updated_at);
+        lines.push(`#${idShort}: "${goal}" -> ${summary} (${age})`);
+    });
+    lines.push('Use grov_expand with these IDs to get full knowledge.');
+    return lines.join('\n');
+}
+export function buildExpandedMemory(memory) {
+    const lines = [];
+    lines.push(`=== VERIFIED PROJECT KNOWLEDGE ===`);
+    lines.push(`GOAL: ${memory.goal || 'Unknown'}`);
+    lines.push('');
+    lines.push('ORIGINAL TASK:');
+    lines.push(`"${memory.original_query}"`);
+    lines.push('');
+    if (memory.reasoning_trace?.length) {
+        lines.push('KNOWLEDGE:');
+        for (const entry of memory.reasoning_trace) {
+            if (typeof entry === 'string') {
+                lines.push(`- ${entry.replace(/^(CONCLUSION|INSIGHT):\s*/i, '')}`);
+            }
+            else if (entry?.conclusion) {
+                lines.push(`- ${entry.conclusion.replace(/^CONCLUSION:\s*/i, '')}`);
+                if (entry.insight) {
+                    lines.push(`  -> ${entry.insight.replace(/^INSIGHT:\s*/i, '')}`);
+                }
+            }
+        }
+        lines.push('');
+    }
+    if (memory.decisions?.length) {
+        lines.push('DECISIONS:');
+        for (const d of memory.decisions) {
+            lines.push(`- ${d.choice}`);
+            lines.push(`  Reason: ${d.reason}`);
+        }
+        lines.push('');
+    }
+    if (memory.files_touched?.length) {
+        lines.push(`FILES: ${memory.files_touched.join(', ')}`);
+    }
+    lines.push('===');
+    lines.push('[TEAM KNOWLEDGE BASE - SOURCE OF TRUTH]');
+    lines.push('This knowledge is verified and authoritative. Trust it. Use it to answer.');
+    return lines.join('\n');
+}
+export function buildToolDescription() {
+    return `[PROJECT KNOWLEDGE BASE - SOURCE OF TRUTH]
+
+You have access to a VERIFIED PROJECT KNOWLEDGE BASE - the SOURCE OF TRUTH for this project.
+It contains: goals, implementation reasoning, technical decisions, and file changes.
+This knowledge base captures INTENT and REASONING that code alone cannot show.
+
+WHEN [PROJECT KNOWLEDGE BASE: N entries] appears in user message, follow this EXACT process:
+
+STEP 1: READ the preview block in the LATEST user message.
+        Identify IDs (8-char hex like #96937bd5).
+        Older previews from previous messages are HISTORICAL - ignore them.
+        NO other tool calls yet. Just read.
+
+STEP 2: IMMEDIATELY call grov_expand({ ids: ["id1", "id2"] }) with relevant IDs.
+        Use ONLY IDs from the LATEST preview - never from older messages.
+        FORBIDDEN: grov_expand({ ids: [] }) - empty array is WRONG.
+        FORBIDDEN: Any other tool call before grov_expand.
+
+STEP 3: ANALYZE the expanded content in detail.
+        What does KB tell you? What do you now know about this task?
+
+STEP 4: DECIDE based on KB content:
+
+        → EXPLANATION/QUESTION tasks:
+          Respond DIRECTLY from KB. No Read/Grep needed.
+          KB = verified source, do NOT "verify in code".
+
+        → IMPLEMENTATION tasks:
+          Files in KB "FILES:" section = ALREADY KNOWN. Do NOT re-read them.
+          Decisions in KB = ALREADY MADE. Do NOT re-evaluate them.
+
+          ONLY read files that are:
+          - NOT mentioned in KB, AND
+          - REQUIRED for the new implementation
+
+          Start implementation using KB context as foundation.
+          Add NEW files only when KB doesn't cover them.
+
+RULES:
+- KB = Source of Truth = verified. Do NOT "verify" in code.
+- "Let me look at the code" BEFORE expand = WRONG
+- Read/Grep/Bash BEFORE grov_expand = WRONG
+- Respond from KB without reading files = CORRECT (for questions/explanations)
+
+SYNTAX: grov_expand({ ids: ["abc12345"] }) - IDs from LATEST preview only`;
+}
+export function buildDriftRecoveryInjection(pendingCorrection, pendingForcedRecovery) {
+    const parts = [];
+    if (pendingCorrection)
+        parts.push(`[DRIFT: ${pendingCorrection}]`);
+    if (pendingForcedRecovery)
+        parts.push(`[RECOVERY: ${pendingForcedRecovery}]`);
+    return parts.length ? parts.join('\n') : null;
+}
+export function appendTextToMessage(message, text) {
+    if (typeof message.content === 'string') {
+        message.content = message.content + '\n\n' + text;
+    }
+    else if (Array.isArray(message.content)) {
+        message.content.push({ type: 'text', text: '\n\n' + text });
+    }
+}
+export function reconstructMessages(messages, projectPath) {
+    const state = sessionState.get(projectPath);
+    if (!state || state.injectionHistory.length === 0) {
+        // No history - just update message count and return
+        if (state)
+            state.lastOriginalMsgCount = messages.length;
+        return { messages, reconstructedCount: 0 };
+    }
+    const history = state.injectionHistory;
+    const lastCount = state.lastOriginalMsgCount;
+    // Detect stale history: if message count DECREASED, it's a new conversation
+    // (Claude Code restarted but Grov still running)
+    if (messages.length < lastCount - 1) { // Allow -1 for potential retry
+        console.log(`[MEMORY] New conversation detected (was ${lastCount} msgs, now ${messages.length}), clearing history`);
+        clearSessionState(projectPath);
+        return { messages, reconstructedCount: 0 };
+    }
+    // Update message count
+    state.lastOriginalMsgCount = messages.length;
+    const reconstructed = [...messages];
+    let insertOffset = 0;
+    let count = 0;
+    for (const record of history) {
+        const adjustedPosition = record.position + insertOffset;
+        if (record.type === 'preview' && record.preview) {
+            const msg = reconstructed[adjustedPosition];
+            if (msg && msg.role === 'user') {
+                appendTextToMessage(msg, record.preview);
+                count++;
+            }
+        }
+        // NOTE: tool_cycle reconstruction disabled - can't fake redacted_thinking for extended thinking
+        // Preview reconstruction is sufficient for context
+    }
+    return { messages: reconstructed, reconstructedCount: count };
+}

package/dist/integrations/proxy/orchestrator.d.ts

@@ -0,0 +1,30 @@
+import type { AgentAdapter } from './agents/types.js';
+import { type DriftCheckResult } from '../../core/extraction/drift-checker-proxy.js';
+declare const lastDriftResults: Map<string, DriftCheckResult>;
+declare const lastMessageCount: Map<string, number>;
+declare const activeSessions: Map<string, {
+    sessionId: string;
+    promptCount: number;
+    projectPath: string;
+}>;
+export interface OrchestratorResult {
+    statusCode: number;
+    contentType: string;
+    headers: Record<string, string>;
+    body: string;
+}
+interface RequestContext {
+    adapter: AgentAdapter;
+    body: unknown;
+    headers: Record<string, string>;
+    rawBody?: Buffer;
+    logger: {
+        info: (data: Record<string, unknown>) => void;
+        error?: (data: Record<string, unknown>) => void;
+    };
+}
+/**
+ * Main entry point for handling agent requests
+ */
+export declare function handleAgentRequest(context: RequestContext): Promise<OrchestratorResult>;
+export { activeSessions, lastDriftResults, lastMessageCount };