grov 0.5.11 → 0.6.13

package/dist/proxy/cache.d.ts

@@ -1,32 +0,0 @@
-/**
- * Global team memory cache
- * - Calculated ONCE on first request, reused for ALL subsequent requests
- * - Invalidated only on: sync completion (in .then() callback), proxy restart
- * - Ensures system prompt prefix stays CONSTANT for Anthropic cache preservation
- */
-export declare let globalTeamMemoryCache: {
-    projectPath: string;
-    content: string;
-} | null;
-/**
- * Invalidate the global team memory cache
- * Called after successful sync to cloud (in .then() callback)
- * This ensures cache is only invalidated AFTER data is in cloud
- */
-export declare function invalidateTeamMemoryCache(): void;
-/**
- * Set the global team memory cache
- * @param projectPath - Project path for cache key
- * @param content - Formatted team memory content
- */
-export declare function setTeamMemoryCache(projectPath: string, content: string): void;
-/**
- * Get the current cache content if it matches the project path
- * @param projectPath - Project path to check
- * @returns Cached content or null if not cached/different project
- */
-export declare function getTeamMemoryCache(projectPath: string): string | null;
-/**
- * Check if cache exists for a specific project
- */
-export declare function hasCacheForProject(projectPath: string): boolean;

package/dist/proxy/cache.js

@@ -1,47 +0,0 @@
-// Phase 0 verified
-// Cache management for team memory injection
-// Shared between server.ts and response-processor.ts to avoid circular dependencies
-/**
- * Global team memory cache
- * - Calculated ONCE on first request, reused for ALL subsequent requests
- * - Invalidated only on: sync completion (in .then() callback), proxy restart
- * - Ensures system prompt prefix stays CONSTANT for Anthropic cache preservation
- */
-export let globalTeamMemoryCache = null;
-/**
- * Invalidate the global team memory cache
- * Called after successful sync to cloud (in .then() callback)
- * This ensures cache is only invalidated AFTER data is in cloud
- */
-export function invalidateTeamMemoryCache() {
-    globalTeamMemoryCache = null;
-    // DEBUG: Commented out for cleaner terminal - uncomment when debugging
-    // console.log('[CACHE] Team memory cache invalidated');
-}
-/**
- * Set the global team memory cache
- * @param projectPath - Project path for cache key
- * @param content - Formatted team memory content
- */
-export function setTeamMemoryCache(projectPath, content) {
-    globalTeamMemoryCache = { projectPath, content };
-    // DEBUG: Commented out for cleaner terminal - uncomment when debugging
-    // console.log(`[CACHE] Team memory cache set for project: ${projectPath} (${content.length} chars)`);
-}
-/**
- * Get the current cache content if it matches the project path
- * @param projectPath - Project path to check
- * @returns Cached content or null if not cached/different project
- */
-export function getTeamMemoryCache(projectPath) {
-    if (globalTeamMemoryCache && globalTeamMemoryCache.projectPath === projectPath) {
-        return globalTeamMemoryCache.content;
-    }
-    return null;
-}
-/**
- * Check if cache exists for a specific project
- */
-export function hasCacheForProject(projectPath) {
-    return globalTeamMemoryCache?.projectPath === projectPath;
-}

package/dist/proxy/handlers/preprocess.js

@@ -1,186 +0,0 @@
-// Pre-process requests before forwarding to Anthropic
-import { config } from '../config.js';
-import { extractLastUserPrompt, extractFilesFromMessages, buildTeamMemoryContextCloud } from '../request-processor.js';
-import { getSessionState, updateSessionState, markCleared, } from '../../lib/store.js';
-import { isSyncEnabled, getSyncTeamId } from '../../lib/cloud-sync.js';
-import { globalTeamMemoryCache, setTeamMemoryCache, invalidateTeamMemoryCache } from '../cache.js';
-import { buildDynamicInjection, clearSessionTracking } from '../injection/delta-tracking.js';
-import { appendToSystemPrompt } from '../injection/injectors.js';
-// Pending plan summary state - triggers CLEAR-like reset after planning task completes
-let pendingPlanClear = null;
-export function getPendingPlanClear() {
-    return pendingPlanClear;
-}
-export function setPendingPlanClear(value) {
-    pendingPlanClear = value;
-}
-export function clearPendingPlan() {
-    pendingPlanClear = null;
-}
-export async function preProcessRequest(body, sessionInfo, logger, detectRequestType) {
-    const modified = { ...body };
-    // Skip warmup requests - Claude Code sends "Warmup" as health check
-    // No need to do semantic search or cache operations for these
-    const earlyUserPrompt = extractLastUserPrompt(modified.messages || []);
-    if (earlyUserPrompt === 'Warmup') {
-        // DEBUG: Commented out for cleaner terminal - uncomment when debugging
-        // console.log('[INJECT] Skipping warmup request (no search, no cache)');
-        return modified;
-    }
-    // Detect request type: first, continuation, or retry
-    const requestType = detectRequestType(modified.messages || [], sessionInfo.projectPath);
-    // === NEW ARCHITECTURE: Separate static and dynamic injection ===
-    //
-    // STATIC (system prompt, cached):
-    //   - Team memory from PAST sessions only
-    //   - CLEAR summary when triggered
-    //   -> Uses __grovInjection + injectIntoRawBody()
-    //
-    // DYNAMIC (user message, delta only):
-    //   - Files edited in current session
-    //   - Key decisions with reasoning
-    //   - Drift correction, forced recovery
-    //   -> Uses __grovUserMsgInjection + appendToLastUserMessage()
-    // Get session state
-    const sessionState = getSessionState(sessionInfo.sessionId);
-    // === PLANNING CLEAR: Reset after planning task completes ===
-    // This ensures implementation phase starts fresh with planning context from team memory
-    if (pendingPlanClear && pendingPlanClear.projectPath === sessionInfo.projectPath) {
-        // 1. Extract context BEFORE emptying messages (for hybrid search)
-        const mentionedFiles = extractFilesFromMessages(modified.messages || []);
-        const userPrompt = extractLastUserPrompt(modified.messages || []);
-        // 2. Empty messages array (fresh start)
-        modified.messages = [];
-        // 3. Inject planning summary into system prompt
-        appendToSystemPrompt(modified, pendingPlanClear.summary);
-        // 4. Rebuild team memory NOW (includes the just-saved planning task)
-        // Use cloud-first approach if sync is enabled
-        let teamContext = null;
-        const teamId = getSyncTeamId();
-        if (isSyncEnabled() && teamId) {
-            // DEBUG: Commented out for cleaner terminal - uncomment when debugging
-            // console.log(`[INJECT] PLANNING_CLEAR: Using cloud team memory (teamId=${teamId.substring(0, 8)}...)`);
-            teamContext = await buildTeamMemoryContextCloud(teamId, sessionInfo.projectPath, mentionedFiles, userPrompt // For hybrid semantic search
-            );
-        }
-        else {
-            // Sync not enabled - no injection (cloud-first approach)
-            // console.log('[INJECT] Sync not enabled. Enable sync for team memory injection.');
-            teamContext = null;
-        }
-        if (teamContext) {
-            modified.__grovInjection = teamContext;
-            modified.__grovInjectionCached = false;
-            // Update cache with fresh team memory
-            setTeamMemoryCache(sessionInfo.projectPath, teamContext);
-        }
-        // 4. Clear the pending plan (one-time use)
-        pendingPlanClear = null;
-        // 5. Clear tracking (fresh start)
-        clearSessionTracking(sessionInfo.sessionId);
-        return modified; // Skip other injections - this is a complete reset
-    }
-    // === CLEAR MODE (100% threshold) ===
-    // If token count exceeds threshold AND we have a pre-computed summary, apply CLEAR
-    if (sessionState) {
-        const currentTokenCount = sessionState.token_count || 0;
-        // DEBUG: Commented out for cleaner terminal - uncomment when debugging
-        // console.log('[CLEAR-CHECK] ═══════════════════════════════════════════');
-        // console.log('[CLEAR-CHECK] currentTokenCount:', currentTokenCount);
-        // console.log('[CLEAR-CHECK] threshold:', config.TOKEN_CLEAR_THRESHOLD);
-        // console.log('[CLEAR-CHECK] exceedsThreshold:', currentTokenCount > config.TOKEN_CLEAR_THRESHOLD);
-        // console.log('[CLEAR-CHECK] hasPendingSummary:', !!sessionState.pending_clear_summary);
-        // console.log('[CLEAR-CHECK] summaryLength:', sessionState.pending_clear_summary?.length || 0);
-        // console.log('[CLEAR-CHECK] shouldClear:', currentTokenCount > config.TOKEN_CLEAR_THRESHOLD && !!sessionState.pending_clear_summary);
-        // console.log('[CLEAR-CHECK] ═══════════════════════════════════════════');
-        if (currentTokenCount > config.TOKEN_CLEAR_THRESHOLD &&
-            sessionState.pending_clear_summary) {
-            // console.log('[CLEAR-CHECK] >>> CLEAR MODE TRIGGERED! <<<');
-            logger.info({
-                msg: 'CLEAR MODE ACTIVATED - resetting conversation',
-                tokenCount: currentTokenCount,
-                threshold: config.TOKEN_CLEAR_THRESHOLD,
-                summaryLength: sessionState.pending_clear_summary.length,
-            });
-            // 1. Empty messages array (fundamental reset)
-            modified.messages = [];
-            // 2. Inject summary into system prompt (this will cause cache miss - intentional)
-            appendToSystemPrompt(modified, sessionState.pending_clear_summary);
-            // 3. Mark session as cleared
-            markCleared(sessionInfo.sessionId);
-            console.log(`[CLEAR] Context reset (${sessionState.pending_clear_summary?.length || 0} chars summary)`);
-            // 4. Clear pending summary and invalidate GLOBAL team memory cache (new baseline)
-            updateSessionState(sessionInfo.sessionId, { pending_clear_summary: undefined });
-            invalidateTeamMemoryCache(); // Force recalculation on next request (CLEAR mode)
-            // 5. Clear tracking (fresh start after CLEAR)
-            clearSessionTracking(sessionInfo.sessionId);
-            logger.info({ msg: 'CLEAR complete - conversation reset with summary' });
-            return modified; // Skip other injections - this is a complete reset
-        }
-    }
-    // === STATIC INJECTION: Team memory (PAST sessions only) ===
-    // Cached per session - identical across all requests for cache preservation
-    // GLOBAL cache: same team memory for ALL requests (regardless of sessionId changes)
-    // Only recalculate on: first request ever, CLEAR/Summary, project change, proxy restart
-    const isSameProject = globalTeamMemoryCache?.projectPath === sessionInfo.projectPath;
-    if (globalTeamMemoryCache && isSameProject) {
-        // Reuse GLOBAL cached team memory (constant for entire conversation)
-        modified.__grovInjection = globalTeamMemoryCache.content;
-        modified.__grovInjectionCached = true;
-        // Using cached team memory
-    }
-    else {
-        // First request OR project changed OR cache was invalidated: compute team memory
-        const mentionedFiles = extractFilesFromMessages(modified.messages || []);
-        const userPrompt = extractLastUserPrompt(modified.messages || []);
-        // Use cloud-first approach if sync is enabled
-        let teamContext = null;
-        const teamId = getSyncTeamId();
-        if (isSyncEnabled() && teamId) {
-            teamContext = await buildTeamMemoryContextCloud(teamId, sessionInfo.projectPath, mentionedFiles, userPrompt // For hybrid semantic search
-            );
-        }
-        else {
-            // Sync not enabled - no injection (cloud-first approach)
-            // console.log('[INJECT] Sync not enabled. Enable sync for team memory injection.');
-            teamContext = null;
-        }
-        // console.log(`[CACHE] Computing team memory (first/new), files=${mentionedFiles.length}, result=${teamContext ? teamContext.length : 'null'}`);
-        if (teamContext) {
-            modified.__grovInjection = teamContext;
-            modified.__grovInjectionCached = false;
-            // Store in GLOBAL cache - stays constant until CLEAR or restart
-            setTeamMemoryCache(sessionInfo.projectPath, teamContext);
-        }
-        else {
-            // No team memory available - clear global cache for this project
-            // DEBUG: Commented out for cleaner terminal - uncomment when debugging
-            // console.log('[CACHE-INVALIDATE] teamContext is NULL - why?');
-            // console.log('[CACHE-INVALIDATE] isSameProject:', isSameProject);
-            if (isSameProject) {
-                // console.log('[CACHE-INVALIDATE] >>> INVALIDATING CACHE (teamContext null) <<<');
-                invalidateTeamMemoryCache();
-            }
-        }
-    }
-    // SKIP dynamic injection for retries and continuations
-    if (requestType !== 'first') {
-        return modified;
-    }
-    // === DYNAMIC INJECTION: User message (delta only) ===
-    // Includes: edited files, key decisions, drift correction, forced recovery
-    // This goes into the LAST user message, not system prompt
-    const dynamicInjection = buildDynamicInjection(sessionInfo.sessionId, sessionState, logger);
-    if (dynamicInjection) {
-        modified.__grovUserMsgInjection = dynamicInjection;
-        logger.info({ msg: 'Dynamic injection ready for user message', size: dynamicInjection.length });
-        // Clear pending corrections after building injection
-        if (sessionState?.pending_correction || sessionState?.pending_forced_recovery) {
-            updateSessionState(sessionInfo.sessionId, {
-                pending_correction: undefined,
-                pending_forced_recovery: undefined,
-            });
-        }
-    }
-    return modified;
-}

package/dist/proxy/index.js

@@ -1,30 +0,0 @@
-// 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/injection/delta-tracking.d.ts

@@ -1,11 +0,0 @@
-import type { SessionState } from '../../lib/store.js';
-export interface SessionInjectionTracking {
-    files: Set<string>;
-    decisionIds: Set<string>;
-    reasonings: Set<string>;
-}
-export declare function getOrCreateTracking(sessionId: string): SessionInjectionTracking;
-export declare function clearSessionTracking(sessionId: string): void;
-export declare function buildDynamicInjection(sessionId: string, sessionState: SessionState | null, logger?: {
-    info: (data: Record<string, unknown>) => void;
-}): string | null;

package/dist/proxy/injection/delta-tracking.js

@@ -1,94 +0,0 @@
-// Delta tracking - avoid duplicate injections across requests
-import { getEditedFiles, getKeyDecisions } from '../../lib/store.js';
-import { smartTruncate } from '../../lib/utils.js';
-const sessionInjectionTracking = new Map();
-export function getOrCreateTracking(sessionId) {
-    if (!sessionInjectionTracking.has(sessionId)) {
-        sessionInjectionTracking.set(sessionId, {
-            files: new Set(),
-            decisionIds: new Set(),
-            reasonings: new Set(),
-        });
-    }
-    return sessionInjectionTracking.get(sessionId);
-}
-export function clearSessionTracking(sessionId) {
-    sessionInjectionTracking.delete(sessionId);
-}
-export function buildDynamicInjection(sessionId, sessionState, logger) {
-    const tracking = getOrCreateTracking(sessionId);
-    const parts = [];
-    const debugInfo = {};
-    // 1. Get edited files (delta - not already injected)
-    const allEditedFiles = getEditedFiles(sessionId);
-    const newFiles = allEditedFiles.filter(f => !tracking.files.has(f));
-    debugInfo.totalEditedFiles = allEditedFiles.length;
-    debugInfo.newEditedFiles = newFiles.length;
-    debugInfo.alreadyTrackedFiles = tracking.files.size;
-    if (newFiles.length > 0) {
-        // Track and add to injection
-        newFiles.forEach(f => tracking.files.add(f));
-        const fileNames = newFiles.slice(0, 5).map(f => f.split('/').pop());
-        parts.push(`[EDITED: ${fileNames.join(', ')}]`);
-        debugInfo.editedFilesInjected = fileNames;
-    }
-    // 2. Get key decisions with reasoning (delta - not already injected)
-    const keyDecisions = getKeyDecisions(sessionId, 5);
-    debugInfo.totalKeyDecisions = keyDecisions.length;
-    debugInfo.alreadyTrackedDecisions = tracking.decisionIds.size;
-    const newDecisions = keyDecisions.filter(d => !tracking.decisionIds.has(d.id) &&
-        d.reasoning &&
-        !tracking.reasonings.has(d.reasoning));
-    debugInfo.newKeyDecisions = newDecisions.length;
-    for (const decision of newDecisions.slice(0, 3)) {
-        tracking.decisionIds.add(decision.id);
-        tracking.reasonings.add(decision.reasoning);
-        const truncated = smartTruncate(decision.reasoning, 120);
-        parts.push(`[DECISION: ${truncated}]`);
-        // Log the original and truncated reasoning for debugging
-        if (logger) {
-            logger.info({
-                msg: 'Key decision reasoning extracted',
-                originalLength: decision.reasoning.length,
-                truncatedLength: truncated.length,
-                original: decision.reasoning.substring(0, 200) + (decision.reasoning.length > 200 ? '...' : ''),
-                truncated,
-            });
-        }
-    }
-    debugInfo.decisionsInjected = newDecisions.slice(0, 3).length;
-    // 3. Add drift correction if pending
-    if (sessionState?.pending_correction) {
-        parts.push(`[DRIFT: ${sessionState.pending_correction}]`);
-        debugInfo.hasDriftCorrection = true;
-        debugInfo.driftCorrectionLength = sessionState.pending_correction.length;
-        console.log(`[DRIFT] Correction injected (${sessionState.pending_correction.length} chars)`);
-    }
-    // 4. Add forced recovery if pending
-    if (sessionState?.pending_forced_recovery) {
-        parts.push(`[RECOVERY: ${sessionState.pending_forced_recovery}]`);
-        debugInfo.hasForcedRecovery = true;
-        debugInfo.forcedRecoveryLength = sessionState.pending_forced_recovery.length;
-    }
-    // Log debug info
-    if (logger) {
-        logger.info({
-            msg: 'Dynamic injection build details',
-            ...debugInfo,
-            partsCount: parts.length,
-        });
-    }
-    if (parts.length === 0) {
-        return null;
-    }
-    const injection = '---\n[GROV CONTEXT]\n' + parts.join('\n');
-    // Log final injection content
-    if (logger) {
-        logger.info({
-            msg: 'Dynamic injection content',
-            size: injection.length,
-            content: injection,
-        });
-    }
-    return injection;
-}

package/dist/proxy/injection/injectors.d.ts

@@ -1,7 +0,0 @@
-import type { MessagesRequestBody } from '../types.js';
-export declare function appendToLastUserMessage(rawBody: string, injection: string): string;
-export declare function appendToSystemPrompt(body: MessagesRequestBody, textToAppend: string): void;
-export declare function injectIntoRawBody(rawBody: string, injectionText: string): {
-    modified: string;
-    success: boolean;
-};

package/dist/proxy/injection/injectors.js

@@ -1,139 +0,0 @@
-// Injection helpers for modifying request bodies
-export function appendToLastUserMessage(rawBody, injection) {
-    // Find the last occurrence of "role":"user" followed by content
-    // We need to find the content field of the last user message and append to it
-    // Strategy: Find all user messages, get the last one, append to its content
-    // This is tricky because content can be string or array
-    // Simpler approach: Find the last user message's closing content
-    // Look for pattern: "role":"user","content":"..." or "role":"user","content":[...]
-    // Find last "role":"user"
-    const userRolePattern = /"role"\s*:\s*"user"/g;
-    let lastUserMatch = null;
-    let match;
-    while ((match = userRolePattern.exec(rawBody)) !== null) {
-        lastUserMatch = match;
-    }
-    if (!lastUserMatch) {
-        // No user message found, can't inject
-        return rawBody;
-    }
-    // From lastUserMatch position, find the content field
-    const afterRole = rawBody.slice(lastUserMatch.index);
-    // Find "content" field after role
-    const contentMatch = afterRole.match(/"content"\s*:\s*/);
-    if (!contentMatch || contentMatch.index === undefined) {
-        return rawBody;
-    }
-    const contentStartGlobal = lastUserMatch.index + contentMatch.index + contentMatch[0].length;
-    const afterContent = rawBody.slice(contentStartGlobal);
-    // Determine if content is string or array
-    if (afterContent.startsWith('"')) {
-        // String content - find closing quote (handling escapes)
-        let i = 1; // Skip opening quote
-        while (i < afterContent.length) {
-            if (afterContent[i] === '\\') {
-                i += 2; // Skip escaped char
-            }
-            else if (afterContent[i] === '"') {
-                // Found closing quote
-                const insertPos = contentStartGlobal + i;
-                // Insert before closing quote, escape the injection for JSON
-                const escapedInjection = injection
-                    .replace(/\\/g, '\\\\')
-                    .replace(/"/g, '\\"')
-                    .replace(/\n/g, '\\n');
-                return rawBody.slice(0, insertPos) + '\\n\\n' + escapedInjection + rawBody.slice(insertPos);
-            }
-            else {
-                i++;
-            }
-        }
-    }
-    else if (afterContent.startsWith('[')) {
-        // Array content - find last text block and append, or add new text block
-        // Find the closing ] of the content array
-        let depth = 1;
-        let i = 1;
-        while (i < afterContent.length && depth > 0) {
-            const char = afterContent[i];
-            if (char === '[')
-                depth++;
-            else if (char === ']')
-                depth--;
-            else if (char === '"') {
-                // Skip string
-                i++;
-                while (i < afterContent.length && afterContent[i] !== '"') {
-                    if (afterContent[i] === '\\')
-                        i++;
-                    i++;
-                }
-            }
-            i++;
-        }
-        if (depth === 0) {
-            // Found closing bracket at position i-1
-            const insertPos = contentStartGlobal + i - 1;
-            // Add new text block before closing bracket
-            const escapedInjection = injection
-                .replace(/\\/g, '\\\\')
-                .replace(/"/g, '\\"')
-                .replace(/\n/g, '\\n');
-            const newBlock = `,{"type":"text","text":"\\n\\n${escapedInjection}"}`;
-            return rawBody.slice(0, insertPos) + newBlock + rawBody.slice(insertPos);
-        }
-    }
-    // Fallback: couldn't parse, return unchanged
-    return rawBody;
-}
-export function appendToSystemPrompt(body, textToAppend) {
-    if (typeof body.system === 'string') {
-        body.system = body.system + textToAppend;
-    }
-    else if (Array.isArray(body.system)) {
-        // Append as new text block WITHOUT cache_control
-        // Anthropic allows max 4 cache blocks - Claude Code already uses 2+
-        // Grov's injections are small (~2KB) so uncached is fine
-        body.system.push({
-            type: 'text',
-            text: textToAppend,
-        });
-    }
-    else {
-        // No system prompt yet, create as string
-        body.system = textToAppend;
-    }
-}
-export function injectIntoRawBody(rawBody, injectionText) {
-    // Find the system array in the raw JSON
-    // Pattern: "system": [....]
-    const systemMatch = rawBody.match(/"system"\s*:\s*\[/);
-    if (!systemMatch || systemMatch.index === undefined) {
-        return { modified: rawBody, success: false };
-    }
-    // Find the matching closing bracket for the system array
-    const startIndex = systemMatch.index + systemMatch[0].length;
-    let bracketCount = 1;
-    let endIndex = startIndex;
-    for (let i = startIndex; i < rawBody.length && bracketCount > 0; i++) {
-        const char = rawBody[i];
-        if (char === '[')
-            bracketCount++;
-        else if (char === ']')
-            bracketCount--;
-        if (bracketCount === 0) {
-            endIndex = i;
-            break;
-        }
-    }
-    if (bracketCount !== 0) {
-        return { modified: rawBody, success: false };
-    }
-    // Escape the injection text for JSON
-    const escapedText = JSON.stringify(injectionText).slice(1, -1); // Remove outer quotes
-    // Create the new block (without cache_control - will be cache_creation)
-    const newBlock = `,{"type":"text","text":"${escapedText}"}`;
-    // Insert before the closing bracket
-    const modified = rawBody.slice(0, endIndex) + newBlock + rawBody.slice(endIndex);
-    return { modified, success: true };
-}

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

@@ -1,27 +0,0 @@
-/**
- * Build context from CLOUD team memory for injection
- * Fetches memories from Supabase via API (cloud-first approach)
- * Uses hybrid search (semantic + lexical) when userPrompt is provided
- *
- * @param teamId - Team UUID from sync configuration
- * @param projectPath - Project path to filter by
- * @param mentionedFiles - Files mentioned in user messages (for boost)
- * @param userPrompt - User's prompt for semantic search (optional)
- * @returns Formatted context string or null if no memories found
- */
-export declare function buildTeamMemoryContextCloud(teamId: string, projectPath: string, mentionedFiles: string[], userPrompt?: string): Promise<string | null>;
-/**
- * Extract file paths from messages (user messages only, clean text)
- */
-export declare function extractFilesFromMessages(messages: Array<{
-    role: string;
-    content: unknown;
-}>): string[];
-/**
- * Extract the last user prompt from messages for semantic search
- * Returns clean text without system tags
- */
-export declare function extractLastUserPrompt(messages: Array<{
-    role: string;
-    content: unknown;
-}>): string | undefined;