fix: move promptContent

Author: astandrik

src/services/codeCompletion/CodeCompletionService.ts

@@ -1,8 +1,8 @@
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 
 import type {DiscardReason} from '../../types/api/codeAssistant';
-import {getPromptFileContent} from '../../utils/monaco/codeAssistTelemetry';
 
+import {getPromptFileContent} from './promptContent';
 import type {
     EnrichedCompletion,
     ICodeCompletionAPI,

src/services/codeCompletion/README.md

@@ -21,17 +21,24 @@ The code completion system consists of several key components working together:
    - Records acceptance, decline, and ignore events
    - Captures timing and interaction data
 
-3. **Factory** (`factory.ts`)
+3. **PromptContent** (`promptContent.ts`)
+
+   - Handles extraction of code context for suggestions
+   - Manages text fragments before and after cursor
+   - Implements text length limits and cursor positioning
+   - Creates structured prompt data for API requests
+
+4. **Factory** (`factory.ts`)
 
    - Creates and configures the completion provider
    - Wires together the completion and telemetry services
 
-4. **Command Registration** (`registerCommands.ts`)
+5. **Command Registration** (`registerCommands.ts`)
 
    - Registers Monaco editor commands for completion actions
    - Handles accept/decline completion commands
 
-5. **CodeAssistantTelemetry** (`CodeAssistantTelemetry.tsx`)
+6. **CodeAssistantTelemetry** (`CodeAssistantTelemetry.tsx`)
    - Optional context caching mechanism
    - Tracks query history as virtual "open tabs"
    - Sends historical queries to the backend for context-aware suggestions
@@ -60,48 +67,62 @@ The code completion system consists of several key components working together:
    -> sendOpenTabs -> Backend Context Cache
    ```
 
-2. **Suggestion Generation**
+2. **Prompt Generation**
+
+   ```
+   Editor Change -> PromptContent.getPromptFileContent
+   -> Text Fragments with Cursor Position -> API Request
+   ```
+
+3. **Suggestion Generation**
 
    ```
-   Editor Change -> CodeCompletionService.provideInlineCompletions
+   Prompt Data -> CodeCompletionService.provideInlineCompletions
    -> API Request (with cached context) -> Suggestions Returned -> Monaco Display
    ```
 
-3. **Suggestion Acceptance**
+4. **Suggestion Acceptance**
 
    ```
    User Accept -> handleAccept -> TelemetryService.sendAcceptTelemetry
    -> API Telemetry Event
    ```
 
-4. **Suggestion Rejection**
+5. **Suggestion Rejection**
    ```
    User Decline -> commandDiscard -> TelemetryService.sendDeclineTelemetry
    -> API Telemetry Event
    ```
 
 ## Key Features
 
-1. **Context Caching**
+1. **Prompt Generation**
+
+   - Extracts relevant code context around cursor
+   - Implements smart text truncation (8000 chars before, 1000 after cursor)
+   - Maintains cursor position information
+   - Creates structured prompt format for API
+
+2. **Context Caching**
 
    - Maintains history of queries as virtual open tabs
    - Each query is assigned a unique ID and treated as a `.yql` file
    - Provides historical context to improve suggestion relevance
    - Optional feature that can be enabled/disabled
 
-2. **Suggestion Caching**
+3. **Suggestion Caching**
 
    - Caches suggestions to reduce API calls
    - Tracks suggestion display count
    - Manages suggestion lifecycle
 
-3. **Telemetry**
+4. **Telemetry**
 
    - Tracks suggestion acceptance rate
    - Records user interaction patterns
    - Monitors suggestion quality
 
-4. **Command Integration**
+5. **Command Integration**
    - Keyboard shortcuts for completion actions
    - Context menu integration
    - Custom commands for completion workflow
@@ -117,6 +138,22 @@ interface ICodeCompletionAPI {
 }
 ```
 
+## Prompt Format
+
+The prompt generation creates structured data in this format:
+
+```typescript
+interface PromptFile {
+  Fragments: {
+    Text: string;
+    Start: {Ln: number; Col: number};
+    End: {Ln: number; Col: number};
+  }[];
+  Cursor: {Ln: number; Col: number};
+  Path: string;
+}
+```
+
 ## Context Caching Format
 
 When using the context caching feature, queries are sent in this format:
@@ -164,25 +201,31 @@ registerCompletionCommands(editor, monaco, completionService);
 
 ## Best Practices
 
-1. **Context Management**
+1. **Prompt Generation**
+
+   - Consider text limits for optimal performance
+   - Maintain cursor position accuracy
+   - Handle edge cases in text extraction
+
+2. **Context Management**
 
    - Consider enabling context caching for better suggestions
    - Monitor the size of historical context
    - Clean up old context when no longer relevant
 
-2. **Error Handling**
+3. **Error Handling**
 
    - All API calls should be wrapped in try-catch blocks
    - Failed suggestions should not break the editor
    - Telemetry failures should be logged but not impact user experience
 
-3. **Performance**
+4. **Performance**
 
    - Suggestions are throttled to prevent excessive API calls
    - Caching reduces server load
    - Completion provider is disposed when not needed
 
-4. **User Experience**
+5. **User Experience**
    - Suggestions appear inline with minimal delay
    - Clear feedback for acceptance/rejection
    - Non-intrusive telemetry collection
@@ -197,6 +240,7 @@ When modifying the code completion system:
 4. Consider performance implications of changes
 5. Document new features or changes
 6. Consider impact on context caching when modifying query handling
+7. Follow text limit guidelines in prompt generation
 
 ## Related Components
 

src/services/codeCompletion/promptContent.ts

@@ -0,0 +1,61 @@
+import type Monaco from 'monaco-editor';
+import {v4} from 'uuid';
+
+import type {PromptFile} from '../../types/api/codeAssistant';
+
+const limitBeforeCursor = 8_000;
+const limitAfterCursor = 1_000;
+
+const sessionId = v4();
+
+export function getPromptFileContent(
+    model: Monaco.editor.ITextModel,
+    position: Monaco.Position,
+): PromptFile[] | undefined {
+    const linesContent = model.getLinesContent();
+    const prevTextInCurrentLine = linesContent[position.lineNumber - 1].slice(
+        0,
+        position.column - 1,
+    );
+    const postTextInCurrentLine = linesContent[position.lineNumber - 1].slice(position.column - 1);
+    const prevText = linesContent
+        .slice(0, position.lineNumber - 1)
+        .concat([prevTextInCurrentLine])
+        .join('\n');
+    const postText = [postTextInCurrentLine]
+        .concat(linesContent.slice(position.lineNumber))
+        .join('\n');
+    const cursorPostion = {Ln: position.lineNumber, Col: position.column};
+
+    const fragments = [];
+    if (prevText) {
+        fragments.push({
+            Text:
+                prevText.length > limitBeforeCursor
+                    ? prevText.slice(prevText.length - limitBeforeCursor)
+                    : prevText,
+            Start: {Ln: 1, Col: 1},
+            End: cursorPostion,
+        });
+    }
+    if (postText) {
+        fragments.push({
+            Text: postText.slice(0, limitAfterCursor),
+            Start: cursorPostion,
+            End: {
+                Ln: linesContent.length,
+                Col: linesContent[linesContent.length - 1].length,
+            },
+        });
+    }
+
+    return fragments.length
+        ? [
+              {
+                  Fragments: fragments,
+                  Cursor: cursorPostion,
+                  Path: `${sessionId}/query.yql`,
+              },
+          ]
+        : undefined;
+}