fix test types & fix some inconsistent schemas

Author: KTrain5169

src/edit_files.ts

@@ -52,7 +52,7 @@ export const editFileActions = {
             text: z.string().meta({
                 description: 'The text to insert.',
             }),
-            position: _POSITION_SCHEMA,
+            position: _POSITION_SCHEMA.optional(),
         }),
         handler: ({ data: { params } }) => returnHandleInsertText(params.text, params.position),
         preview: (context) => {
@@ -488,7 +488,7 @@ export function addEditingActions() {
     ]);
 }
 
-function returnHandleInsertText(text: string, position: { line: number, column: number, type: 'relative' | 'absolute' }) {
+function returnHandleInsertText(text: string, position?: { line: number, column: number, type: 'relative' | 'absolute' }) {
     const cursor = getVirtualCursor()!;
     let line: number;
     let column: number;
@@ -541,7 +541,7 @@ function returnHandleInsertText(text: string, position: { line: number, column:
 }
 
 /** @deprecated Functions should now be inlined */
-export function handleInsertText(context: RCEContext<{ text: string; position: { line: number, column: number, type: 'relative' | 'absolute' } }>): RCEHandlerReturns {
+export function handleInsertText(context: RCEContext<{ text: string; position?: { line: number, column: number, type: 'relative' | 'absolute' } }>): RCEHandlerReturns {
     const { data: actionData } = context;
     const text: string = actionData.params!.text;
     const position = actionData.params!.position;

src/read_files.ts

@@ -225,7 +225,7 @@ export const readFileActions = {
             }).optional(),
             highlight: z.boolean().meta({
                 description: 'Set to true to highlight all matches.',
-            }),
+            }).optional(),
         }),
         handler(ctx) {
             const { find, match, highlight, useRegex, lineRange, moveCursor } = ctx.data.params;

src/test/suite/common/actionMetadataValidation.test.ts

@@ -44,7 +44,7 @@ suite('Validate action metadata', async () => {
         const actions = Object.keys(gitActions) as (keyof typeof gitActions)[];
         for (const a of actions) {
             assert.strictEqual(a, gitActions[a].name);
-            assert.ok([CATEGORY_GIT, CATEGORY_GIT_CONFIG, CATEGORY_GIT_REMOTES].includes(gitActions[a].category));
+            assert.ok([CATEGORY_GIT, CATEGORY_GIT_CONFIG, CATEGORY_GIT_REMOTES].includes(gitActions[a].category ?? ''));
             if ('schema' in gitActions[a] && gitActions[a].schema) {
                 // gitActions[a].schema is now safely accessible
                 const schema = gitActions[a].schema;

src/test/suite/file_actions.test.ts

@@ -2,15 +2,14 @@ import * as assert from 'assert';
 import * as vscode from 'vscode';
 import * as fileActions from '@/file_operations';
 import * as readFiles from '@/read_files';
-import { assertProperties, checkNoErrorWithTimeout, createTestDirectory, createTestFile, returnMockFunction } from '@test/test_utils';
+import { assertProperties, checkNoErrorWithTimeout, createTestDirectory, createTestFile, fakeContext } from '@test/test_utils';
 import { ActionData } from 'neuro-game-sdk';
-import type { RCEContext } from '@/context/rce';
 import { getPermissionLevel, PermissionLevel } from '@/config';
 import { NeuroClient } from 'neuro-game-sdk';
 import { NEURO } from '@/constants';
 import { anything, capture, instance, mock, verify } from 'ts-mockito';
 
-const makeContext = <const TData extends unknown | undefined>(data: ActionData<TData>) => ({ data, updateStatus: returnMockFunction() } as unknown as RCEContext<TData>);
+const makeContext = (data: ActionData['params']) => fakeContext('igiveup', data);
 
 const { readFileActions } = readFiles;
 

src/test/test_utils.ts

@@ -1,6 +1,15 @@
-import * as assert from 'assert';
+import assert from 'assert';
 import * as vscode from 'vscode';
 import { setVirtualCursor } from '@/utils/misc';
+import { RCEContext } from '@ctx/rce';
+import { ActionData } from 'neuro-game-sdk';
+import { randomUUID } from 'crypto';
+
+export const fakeContext = <const TParams extends ActionData['params']>(name: string, params: TParams) => {
+    const ctx = new RCEContext({ id: randomUUID(), name, params });
+    ctx['_updateStatus'] = returnMockFunction();
+    return ctx;
+};
 
 /**
  * Asserts that an object has the same properties as the expected object,

src/test/unit-test/delete_lines.simple.test.ts

@@ -1,14 +1,13 @@
-import * as assert from 'assert';
+import assert from 'assert';
 import { editFileActions } from '@/edit_files';
-import type { RCEContext } from '@/context/rce';
+import { fakeContext } from '@test/test_utils';
 
 // Tests for the delete_lines action prompt generator using real logic
 suite('delete_lines Action', () => {
     test('generates a prompt and includes start and end for a normal range', () => {
+        assert.ok(editFileActions.delete_lines.promptGenerator && typeof editFileActions.delete_lines.promptGenerator !== 'string');
         // === Arrange & Act ===
-        const prompt = editFileActions.delete_lines.promptGenerator({
-            data: { params: { startLine: 3, endLine: 7 } },
-        } as RCEContext);
+        const prompt = editFileActions.delete_lines.promptGenerator(fakeContext('delete_lines', { startLine: 3, endLine: 7 }));
 
         // === Assert ===
         assert.ok(typeof prompt === 'string' && prompt.length > 0, 'prompt should be a non-empty string');
@@ -17,21 +16,19 @@ suite('delete_lines Action', () => {
     });
 
     test('generates a prompt and includes the single line when start=end', () => {
+        assert.ok(editFileActions.delete_lines.promptGenerator && typeof editFileActions.delete_lines.promptGenerator !== 'string');
         // === Arrange & Act ===
-        const prompt = editFileActions.delete_lines.promptGenerator({
-            data: { params: { startLine: 5, endLine: 5 } },
-        } as RCEContext);
+        const prompt = editFileActions.delete_lines.promptGenerator(fakeContext('delete_lines', { startLine: 5, endLine: 5 }));
 
         // === Assert ===
         assert.ok(typeof prompt === 'string' && prompt.length > 0, 'prompt should be a non-empty string');
         assert.ok(prompt.includes('5'), 'prompt should include the line number');
     });
 
     test('generates a prompt even for reversed ranges (format-only responsibility)', () => {
+        assert.ok(editFileActions.delete_lines.promptGenerator && typeof editFileActions.delete_lines.promptGenerator !== 'string');
         // === Arrange & Act ===
-        const prompt = editFileActions.delete_lines.promptGenerator({
-            data: { params: { startLine: 7, endLine: 3 } },
-        } as RCEContext);
+        const prompt = editFileActions.delete_lines.promptGenerator(fakeContext('delete_lines', { startLine: 7, endLine: 3 }));
         // Prompt generator formats only; validation handles correctness elsewhere        
 
         // === Assert ===

src/test/unit-test/delete_text.simple.test.ts

@@ -1,25 +1,23 @@
 import * as assert from 'assert';
 import { editFileActions } from '@/edit_files';
-import type { RCEContext } from '@/context/rce';
+import { fakeContext } from '@test/test_utils';
 
 // Tests for the delete_text action prompt generator using real logic
 suite('delete_text Action', () => {
     test('generates a prompt and includes raw find when useRegex is true', () => {
+        assert.ok(editFileActions.delete_text.promptGenerator && typeof editFileActions.delete_text.promptGenerator !== 'string');
         // === Arrange & Act ===
-        const prompt = editFileActions.delete_text.promptGenerator({
-            data: { params: { find: 'a+b', useRegex: true } },
-        } as RCEContext);
+        const prompt = editFileActions.delete_text.promptGenerator(fakeContext('delete_text', { find: 'a+b', match: 'firstInFile', useRegex: true }));
 
         // === Assert ===
         assert.ok(typeof prompt === 'string' && prompt.length > 0);
         assert.ok(prompt.includes('a+b'));
     });
 
     test('generates a prompt and includes raw find when useRegex is false', () => {
+        assert.ok(editFileActions.delete_text.promptGenerator && typeof editFileActions.delete_text.promptGenerator !== 'string');
         // === Arrange ===
-        const prompt = editFileActions.delete_text.promptGenerator({
-            data: { params: { find: 'hello', useRegex: false } },
-        } as RCEContext);
+        const prompt = editFileActions.delete_text.promptGenerator(fakeContext('delete_text', { find: 'hello', match: 'firstInFile', useRegex: false }));
 
         // === Act ===
 

src/test/unit-test/file_actions.simple.test.ts

@@ -1,84 +1,93 @@
 import * as assert from 'assert';
 import { fileActions } from '@/file_operations';
 import { readFileActions } from '@/read_files';
-import type { RCEContext } from '@/context/rce';
+import { fakeContext } from '@test/test_utils';
 
 // Tests for file action prompt generators using real logic with loose checks
 suite('file Actions', () => {
     test('get_workspace_files has a non-empty prompt', () => {
+        assert.ok(fileActions.list_files_and_folders.promptGenerator && typeof fileActions.list_files_and_folders.promptGenerator !== 'string');
         // === Arrange & Act ===
-        const prompt = fileActions.list_files_and_folders.promptGenerator({ data: { params: {} } } as RCEContext);
+        const prompt = fileActions.list_files_and_folders.promptGenerator(fakeContext('list_files_and_folders', {}));
 
         // === Assert ===
         assert.ok(typeof prompt === 'string' && prompt.length > 0);
     });
 
     test('get_workspace_files correctly includes the folder in prompt', () => {
+        assert.ok(fileActions.list_files_and_folders.promptGenerator && typeof fileActions.list_files_and_folders.promptGenerator !== 'string');
         // === Arrange & Act ===
-        const prompt = fileActions.list_files_and_folders.promptGenerator({ data: { params: { folder: 'src/' } } } as RCEContext);
+        const prompt = fileActions.list_files_and_folders.promptGenerator(fakeContext('list_files_and_folders', { folder: 'src/' }));
 
         // === Assert ===
         assert.ok(typeof prompt === 'string' && prompt.length > 0);
         assert.ok(prompt.includes('src'));
     });
 
     test('get_workspace_files correctly states if Neuro asked for recursive', () => {
+        assert.ok(fileActions.list_files_and_folders.promptGenerator && typeof fileActions.list_files_and_folders.promptGenerator !== 'string');
         // === Arrange & Act ===
-        const prompt = fileActions.list_files_and_folders.promptGenerator({ data: { params: { recursive: true } } } as RCEContext);
+        const prompt = fileActions.list_files_and_folders.promptGenerator(fakeContext('list_files_and_folders', { recursive: true }));
 
         // === Assert ===
         assert.ok(typeof prompt === 'string' && prompt.length > 0);
         assert.ok(prompt.toLowerCase().includes('recursively'));
     });
 
     test('get_workspace_files correctly omits recursive if Neuro didn\'t ask', () => {
+        assert.ok(fileActions.list_files_and_folders.promptGenerator && typeof fileActions.list_files_and_folders.promptGenerator !== 'string');
         // === Arrange & Act ===
-        const prompt = fileActions.list_files_and_folders.promptGenerator({ data: { params: { recursive: false } } } as RCEContext);
+        const prompt = fileActions.list_files_and_folders.promptGenerator(fakeContext('list_files_and_folders', { recursive: false }));
 
         // === Assert ===
         assert.ok(typeof prompt === 'string' && prompt.length > 0);
         assert.ok(!prompt.includes('recursively'));
     });
 
     test('open_file prompt formats path', () => {
+        assert.ok(readFileActions.switch_files.promptGenerator && typeof readFileActions.switch_files.promptGenerator !== 'string');
         // === Arrange & Act ===
-        const prompt = readFileActions.switch_files.promptGenerator({ data: { params: { filePath: 'src/index.ts' } } } as RCEContext);
+        const prompt = readFileActions.switch_files.promptGenerator(fakeContext('switch_files', { filePath: 'src/index.ts' }));
 
         // === Assert ===
         assert.ok(typeof prompt === 'string' && prompt.length > 0);
         assert.ok(prompt.includes('src/index.ts'));
     });
 
     test('read_file prompt formats path', () => {
+        assert.ok(readFileActions.read_file.promptGenerator && typeof readFileActions.read_file.promptGenerator !== 'string');
         // === Arrange & Act ===
-        const prompt = readFileActions.read_file.promptGenerator({ data: { params: { filePath: 'README.md' } } } as RCEContext);
+        const prompt = readFileActions.read_file.promptGenerator(fakeContext('read_files', { filePath: 'README.md' }));
 
         // === Assert ===
         assert.ok(typeof prompt === 'string' && prompt.length > 0);
         assert.ok(prompt.includes('README.md'));
     });
 
     test('create_file prompt formats path', () => {
+        assert.ok(fileActions.create_file.promptGenerator && typeof fileActions.create_file.promptGenerator !== 'string');
         // === Arrange & Act ===
-        const prompt = fileActions.create_file.promptGenerator({ data: { params: { filePath: 'new/file.txt' } } } as RCEContext);
+        const prompt = fileActions.create_file.promptGenerator(fakeContext('create_file', { filePath: 'new/file.txt' }));
 
         // === Assert ===
         assert.ok(typeof prompt === 'string' && prompt.length > 0);
         assert.ok(prompt.includes('new/file.txt'));
     });
 
     test('create_folder prompt formats path', () => {
+        assert.ok(fileActions.create_folder.promptGenerator && typeof fileActions.create_folder.promptGenerator !== 'string');
         // === Arrange & Act ===
-        const prompt = fileActions.create_folder.promptGenerator({ data: { params: { folderPath: 'new/folder' } } } as RCEContext);
+        const prompt = fileActions.create_folder.promptGenerator(fakeContext('create_folder', { folderPath: 'new/folder' }));
 
         // === Assert ===
         assert.ok(typeof prompt === 'string' && prompt.length > 0);
         assert.ok(prompt.includes('new/folder'));
     });
 
     test('rename_file_or_folder prompt formats paths', () => {
+        assert.ok(fileActions.rename_file_or_folder.promptGenerator && typeof fileActions.rename_file_or_folder.promptGenerator !== 'string');
         // === Arrange & Act ===
-        const prompt = fileActions.rename_file_or_folder.promptGenerator({ data: { params: { oldPath: 'old/a.txt', newPath: 'new/a.txt' } } } as RCEContext);
+        const prompt = fileActions.rename_file_or_folder.promptGenerator(fakeContext('rename_file_or_folder', { oldPath: 'old/a.txt', newPath: 'new/a.txt' }));
 
         // === Assert ===
         assert.ok(typeof prompt === 'string' && prompt.length > 0);
@@ -87,8 +96,9 @@ suite('file Actions', () => {
     });
 
     test('delete_file_or_folder prompt formats path', () => {
+        assert.ok(fileActions.delete_file_or_folder.promptGenerator && typeof fileActions.delete_file_or_folder.promptGenerator !== 'string');
         // === Arrange & Act ===
-        const prompt = fileActions.delete_file_or_folder.promptGenerator({ data: { params: { path: 'old/file.txt' } } } as RCEContext);
+        const prompt = fileActions.delete_file_or_folder.promptGenerator(fakeContext('delete_file_or_folder', { path: 'old/file.txt' }));
 
         // === Assert ===
         assert.ok(typeof prompt === 'string' && prompt.length > 0);

src/test/unit-test/find_text.simple.test.ts

@@ -1,25 +1,23 @@
 import * as assert from 'assert';
 import { readFileActions } from '@/read_files';
-import type { RCEContext } from '@/context/rce';
+import { fakeContext } from '@test/test_utils';
 
 // Tests for the find_text action prompt generator using real logic
 suite('find_text Action', () => {
     test('generates a prompt and includes raw find when useRegex is true', () => {
+        assert.ok(readFileActions.find_text.promptGenerator && typeof readFileActions.find_text.promptGenerator !== 'string');
         // === Arrange & Act ===
-        const prompt = readFileActions.find_text.promptGenerator({
-            data: { params: { find: 'foo(bar)', useRegex: true } },
-        } as RCEContext);
+        const prompt = readFileActions.find_text.promptGenerator(fakeContext('find_text', { find: 'foo(bar)', match: 'firstInFile', useRegex: true }));
 
         // === Assert ===
         assert.ok(typeof prompt === 'string' && prompt.length > 0);
         assert.ok(prompt.includes('foo(bar)'));
     });
 
     test('generates a prompt and includes raw find when useRegex is false', () => {
+        assert.ok(readFileActions.find_text.promptGenerator && typeof readFileActions.find_text.promptGenerator !== 'string');
         // === Arrange & Act ===
-        const prompt = readFileActions.find_text.promptGenerator({
-            data: { params: { find: 'baz', useRegex: false } },
-        } as RCEContext);
+        const prompt = readFileActions.find_text.promptGenerator(fakeContext('find_text', { find: 'baz', match: 'firstInFile', useRegex: false }));
 
         // === Assert ===
         assert.ok(typeof prompt === 'string' && prompt.length > 0);