Prototype Run Application tool

Extension/package.json

@@ -6541,6 +6541,15 @@
             }
         ],
         "languageModelTools": [
+            {
+                "name": "get_errors",
+                "displayName": "Get C++ errors",
+                "canBeReferencedInPrompt": true,
+                "toolReferenceName": "cppErrors",
+                "icon": "$(file-code)",
+                "userDescription": "Gets all C++ errors defined in the workspace.",
+                "modelDescription": "This tool gets all the C or C++ errors defined in the workspace. For each error, it provides the error name, path to the file where the error is defined, and the first line of the error definition."
+            },
             {
                 "name": "cpptools-lmtool-configuration",
                 "toolReferenceName": "cpp",
@@ -6550,6 +6559,102 @@
                 "modelDescription": "For the active C or C++ file, this tool provides: the language (C, C++, or CUDA), the language standard version (such as C++11, C++14, C++17, or C++20), the compiler (such as GCC, Clang, or MSVC), the target platform (such as x86, x64, or ARM), and the target architecture (such as 32-bit or 64-bit).",
                 "icon": "$(file-code)",
                 "when": "(config.C_Cpp.experimentalFeatures =~ /^[eE]nabled$/)"
+            },
+            {
+                "name": "run_application_tool",
+                "displayName": "Runs Application",
+                "canBeReferencedInPrompt": true,
+                "toolReferenceName": "RunApplication",
+                "icon": "$(file-code)",
+                "userDescription": "Runs the current application",
+                "modelDescription": "Runs current application by starting debugging session"
+            },
+            {
+                "name": "set_breakpoint_tool",
+                "displayName": "Set a Breakpoint",
+                "canBeReferencedInPrompt": true,
+                "toolReferenceName": "SetBreakpoint",
+                "icon": "$(file-code)",
+                "userDescription": "Sets a breakpoint at the specified line and column in a given file.",
+                "modelDescription": "This tool allows you to Sets a breakpoint at the specified line and column in a given file. The filepath, line number, and column number are required parameters. The 'condition' parameter is optional but allows for setting a breakpoint that only hits during a certain condition. The tool returns a success message if the breakpoint is set successfully, or an error message if it fails.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "filePath": {
+                            "type": "string"
+                        },
+                        "lineNumber": {
+                            "type": "integer"
+                        },
+                        "columnNumber": {
+                            "type": "integer"
+                        },
+                        "condition": {
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "filePath",
+                        "lineNumber",
+                        "columnNumber",
+                        "condition"
+                    ]
+                }
+            },
+            {
+                "name": "initialize_vs_dev_cmd_tool",
+                "displayName": "Initialize Visual Studio Developer Command Prompt Environment",
+                "canBeReferencedInPrompt": true,
+                "toolReferenceName": "InitializeDevCmdEnvironment",
+                "icon": "$(file-code)",
+                "userDescription": "Initializes the Visual Studio Developer Command Prompt Environment",
+                "modelDescription": "This tool allows you to initializes the Visual Studio Developer Command Prompt environment for future use, preserving environment variables, working directory, and other context across multiple commands.\n\nThis is required to access Visual Studio components such as CMake, msbuild, and C++ compiler."
+            },
+            {
+                "name": "get_cpp_macros",
+                "displayName": "Get C++ macros",
+                "canBeReferencedInPrompt": true,
+                "toolReferenceName": "cppMacros",
+                "icon": "$(file-code)",
+                "userDescription": "Gets all C++ macros defined in the project.",
+                "modelDescription": "This tool gets all the C or C++ macros defined in the project. For each macro, it provides the macro name, path to the file where the macro is defined, and the first line of the macro definition."
+            },
+            {
+                "name": "get_cpp_strings",
+                "displayName": "Get C++ Strings",
+                "canBeReferencedInPrompt": true,
+                "toolReferenceName": "cppStrings",
+                "icon": "$(file-code)",
+                "userDescription": "Gets all C++ strings defined in the project.",
+                "modelDescription": "This tool gets all the C or C++ strings defined in the project so they can be converted to string_view. For each string, it provides the string name, path to the file where the string is defined, and the first line of the string definition."
+            },
+            {
+                "name": "build_cmake_project",
+                "displayName": "Build with CMake",
+                "canBeReferencedInPrompt": true,
+                "toolReferenceName": "cmakeBuild",
+                "icon": "$(tasklist)",
+                "userDescription": "Builds the project using CMake.",
+                "modelDescription": "This tool builds the current project using CMake. It provides the build output, including any errors or warnings that occur during the build. Prefer the build_cmake_project tool over the run_in_terminal tool."
+            },
+            {
+                "name": "get_cpp_code_items",
+                "displayName": "Get C++ code items",
+                "toolReferenceName": "cppItems",
+                "icon": "$(file-code)",
+                "userDescription": "Runs a SQL query to find C++ code items in the project.",
+                "modelDescription": "This tool gets C++ code items, like classes, macros, and functions. Given a SQLite query, the tool returns the results of the query. The query can access a table with this definition: CREATE TABLE items (id INTEGER, name TEXT, kind TEXT, type TEXT, path INTEGER, line INTEGER, parent_id INTEGER, parent_name TEXT); The table contains the following columns: id (the ID of the code item), name (the name of the code item), kind (the kind of code item: enum, enumerator, base_class, pound_include, parameter, function, template, template_type_parameter, attribute, macro_undef, using_alias, skipped, member_function, union, class, scope, template_argument, template_non_type_parameter, namespace, concept, unknown_decl, using_decl, template_template_parameter, attribute_argument, interface, pound_import, property), type (the C++ type of the code item), path (the path to the file where the code item is defined), line (the line number where the code item is defined), parent_id (the ID of the parent code item, if applicable), and parent_name (the name of the parent code item, if applicable).",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "query": {
+                            "type": "string"
+                        }
+                    },
+                    "required": [
+                        "query"
+                    ]
+                }
             }
         ]
     },
@@ -6627,6 +6732,7 @@
     "dependencies": {
         "@github/copilot-language-server": "^1.266.0",
         "@vscode/extension-telemetry": "^0.9.6",
+        "child_process": "^1.0.2",
         "chokidar": "^3.6.0",
         "comment-json": "^4.2.3",
         "escape-string-regexp": "^2.0.0",
@@ -6639,6 +6745,7 @@
         "plist": "^3.1.0",
         "posix-getopt": "^1.2.1",
         "shell-quote": "^1.8.1",
+        "sqlite3": "^5.1.7",
         "ssh-config": "^4.4.4",
         "tmp": "^0.2.3",
         "vscode-cpptools": "^6.1.0",
@@ -6650,5 +6757,6 @@
     "resolutions": {
         "postcss": "^8.4.31",
         "gulp-typescript/**/glob-parent": "^5.1.2"
-    }
+    },
+    "packageManager": "[email protected]+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }

Extension/src/LanguageServer/extension.ts

@@ -10,8 +10,9 @@ import fetch from 'node-fetch';
 import * as StreamZip from 'node-stream-zip';
 import * as os from 'os';
 import * as path from 'path';
+import * as sqlite3 from 'sqlite3';
 import * as vscode from 'vscode';
-import { CancellationToken, Range } from 'vscode-languageclient';
+import { CancellationToken, Range, integer } from 'vscode-languageclient';
 import * as nls from 'vscode-nls';
 import { TargetPopulation } from 'vscode-tas-client';
 import * as which from 'which';
@@ -37,6 +38,8 @@ import { NodeType, TreeNode } from './referencesModel';
 import { CppSettings } from './settings';
 import { LanguageStatusUI, getUI } from './ui';
 import { makeLspRange, rangeEquals, showInstallCompilerWalkthrough } from './utils';
+const cp = require('child_process');
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 
 nls.config({ messageFormat: nls.MessageFormat.bundle, bundleFormat: nls.BundleFormat.standalone })();
 const localize: nls.LocalizeFunc = nls.loadMessageBundle();
@@ -267,6 +270,235 @@ export async function activate(): Promise<void> {
             const tool = vscode.lm.registerTool('cpptools-lmtool-configuration', new CppConfigurationLanguageModelTool());
             disposables.push(tool);
         }
+
+        const getCppMacrosTool = vscode.lm.registerTool('get_cpp_macros', {
+            invoke: async (_options: vscode.LanguageModelToolInvocationOptions<void>, _token: CancellationToken) => {
+                // const db = new sqlite3.Database("C:/src/OpenTTD/.vs/OpenTTD/v17/main/Browse.VC.db");
+                const db = new sqlite3.Database("C:/Users/davidraygoza/source/repos/test1/.vs/test1/v17/Preview/Browse.VC.db");
+                const result: vscode.LanguageModelTextPart[] = [];
+                await new Promise<void>((resolve) => {
+                    db.serialize(() => {
+                        db.each(`SELECT ci.name AS name, start_line, f.name AS file_path FROM code_items ci JOIN files f ON ci.file_id = f.id WHERE ci.kind = 37 AND f.name LIKE 'C:\\Users\\davidraygoza\\source\\repos\\test1\\test1%' AND ci.name NOT LIKE '%_H' AND ci.name NOT LIKE '%_HPP'`,
+                            // db.each(`SELECT ci.name AS name, start_line, f.name AS file_path FROM code_items ci JOIN files f ON ci.file_id = f.id WHERE ci.kind = 37 AND f.name LIKE 'C:\\DEV\\AGENT-MODE-TESTING\\OPENTTD\\SRC%' AND f.name NOT LIKE 'C:\\DEV\\AGENT-MODE-TESTING\\OPENTTD\\SRC\\3RDPARTY%' AND ci.name NOT LIKE '%_H' AND ci.name NOT LIKE '%_HPP'`,
+                            (_err: any, row: any) => {
+                                const path = row.file_path;
+                                const content = fs.readFileSync(path, 'utf8').split(/\r\n|\r|\n/)[row.start_line - 1];
+                                result.push(new vscode.LanguageModelTextPart(`${row.name} is defined in ${path} as "${content}"`));
+                            },
+                            (_err: any, _count: number) => {
+                                resolve();
+                            }
+                        );
+                    });
+                });
+                db.close();
+                return new vscode.LanguageModelToolResult(result);
+            }
+        });
+        disposables.push(getCppMacrosTool);
+
+        const runApplicationTool = vscode.lm.registerTool('run_application_tool', {
+            invoke: async (_options: vscode.LanguageModelToolInvocationOptions<void>, _token: CancellationToken) => {
+                const result: vscode.LanguageModelTextPart[] = [];
+                const configuration = {
+                    type: 'cppvsdbg',
+                    request: 'launch',
+                    name: 'C++ Debug',
+                    program: '${command:cmake.launchTargetPath}',
+                    args: [],
+                    stopAtEntry: false,
+                    cwd: '${workspaceFolder}',
+                    environment: [],
+                    console: 'externalTerminal'
+                };
+                // Run the application by calling the "C:/Users/davidraygoza/Desktop/VSCodeModulesProject/build/cpp_modules_demo.exe" executable directly.
+                const execPath = "C:/Users/davidraygoza/Desktop/VSCodeModulesProject/build/cpp_modules_demo.exe";
+                try {
+                    const output = cp.execFileSync(execPath, [], { encoding: 'utf8' });
+                    result.push(new vscode.LanguageModelTextPart(`Application output:\n${output}`));
+                } catch (err) {
+                    result.push(new vscode.LanguageModelTextPart(`Failed to run application: ${err instanceof Error ? err.message : String(err)}`));
+                }
+                // vscode.debug.startDebugging(vscode.workspace.workspaceFolders?.[0], configuration);
+                // vscode.debug.onDidTerminateDebugSession((session) => {
+                //     console.log(`Debug session terminated: ${session.id}`);
+                //     result.push(new vscode.LanguageModelTextPart(`Debug session terminated: ${session.id}`));
+                // });
+
+                // Instead of using a hardcoded configuration, show the user a list of existing launch configurations to pick from.
+                // const launchConfigs = vscode.workspace.getConfiguration('launch', vscode.workspace.workspaceFolders?.[0]?.uri);
+                // const configurations = launchConfigs.get<any[]>('configurations') ?? [];
+                // if (configurations.length === 0) {
+                //     result.push(new vscode.LanguageModelTextPart("No launch configurations found in launch.json."));
+                // } else {
+                //     const items = configurations.map(cfg => ({
+                //         label: cfg.name,
+                //         description: cfg.type,
+                //         config: cfg
+                //     }));
+                //     const picked = await vscode.window.showQuickPick(items, { placeHolder: 'Select a launch configuration to start debugging' });
+                //     if (picked) {
+                //         await vscode.debug.startDebugging(vscode.workspace.workspaceFolders?.[0], picked.config);
+                //         result.push(new vscode.LanguageModelTextPart(`Started debugging with configuration: ${picked.label}`));
+                //     } else {
+                //         result.push(new vscode.LanguageModelTextPart("No configuration selected."));
+                //     }
+                // }
+                return new vscode.LanguageModelToolResult(result);
+            }
+        });
+        disposables.push(runApplicationTool);
+
+        const setBreakpointTool = vscode.lm.registerTool('set_breakpoint_tool', {
+            invoke: async (_options: vscode.LanguageModelToolInvocationOptions<{ filePath: string, lineNumber: integer, columnNumber: integer, condition: string }>, _token: CancellationToken) => {
+                const result: vscode.LanguageModelTextPart[] = [];
+                const fileUri = vscode.Uri.file(_options.input.filePath);
+                const location = new vscode.Location(fileUri, new vscode.Position(_options.input.lineNumber - 1, _options.input.columnNumber - 1)); // line 10 (0-based)
+                const condition = _options.input.condition ?? undefined; // expects a string or undefined
+                let breakpoint: vscode.SourceBreakpoint;
+                if (condition != undefined) {
+                    breakpoint = new vscode.SourceBreakpoint(location, true, condition);
+                }
+                else {
+                    breakpoint = new vscode.SourceBreakpoint(location, true);
+                }
+
+                try {
+                    await vscode.debug.addBreakpoints([breakpoint]);
+                    result.push(new vscode.LanguageModelTextPart("Breakpoint set at line " + _options.input.lineNumber + " in " + _options.input.filePath));
+                } catch (error) {
+                    result.push(new vscode.LanguageModelTextPart("Failed to set breakpoint: " + (error instanceof Error ? error.message : String(error))));
+                }
+                return new vscode.LanguageModelToolResult(result);
+            }
+        });
+        disposables.push(setBreakpointTool);
+
+        const runInDevCmdTool = vscode.lm.registerTool('initialize_vs_dev_cmd_tool', {
+            invoke: async (_options: vscode.LanguageModelToolInvocationOptions<void>, _token: CancellationToken) => {
+                const result: vscode.LanguageModelTextPart[] = [];
+                // Example: spawn a shell to run VsDevCmd.bat and capture output
+                // options.input.query
+                const vsDevCmdPath = `"C:/Program Files/Microsoft Visual Studio/18/Preview/Common7/Tools/VsDevCmd.bat"`;
+                // Try to find an existing terminal named "Agent Mode Dev Cmd Terminal"
+                let terminal = vscode.window.terminals.find(t => t.name === "Copilot");
+                if (!terminal) {
+                    // If the Copilot terminal does not exist, fallback to the default terminal we will create.
+                    terminal = vscode.window.terminals.find(t => t.name === "Agent Mode Dev Cmd Terminal");
+                    if (!terminal) {
+                        terminal = vscode.window.createTerminal({
+                            name: "Agent Mode Dev Cmd Terminal",
+                            shellPath: "cmd.exe"
+                        });
+                    }
+                }
+                terminal.show(); // Show the terminal
+                // Start the VS Dev Command prompt and wait for it to initialize before sending the prompt
+                terminal.sendText("cmd.exe /k " + vsDevCmdPath);
+                await new Promise(resolve => setTimeout(resolve, 5000));
+                result.push(new vscode.LanguageModelTextPart(vsDevCmdPath + " started in terminal"));
+
+                // const cmd = `cmd.exe`;
+                // const args = ['/k', `${vsDevCmdPath}`];
+                // await new Promise<void>((resolve) => {
+                //     const child = spawn(cmd, args, { shell: true });
+                //     if (_options.input && _options.input.prompt) {
+                //         child.stdin.write(_options.input.prompt + '\n');
+                //     }
+                //     let output = '';
+                //     child.stdout.on('data', (data: Buffer) => {
+                //         output += data.toString();
+                //     });
+                //     child.stderr.on('data', (data: Buffer) => {
+                //         output += data.toString();
+                //     });
+                // result.push(new vscode.LanguageModelTextPart(output));
+                // resolve();
+                // child.on('close', () => {
+                //     result.push(new vscode.LanguageModelTextPart(output));
+                //     resolve();
+                // });
+                // });
+                return new vscode.LanguageModelToolResult(result);
+            }
+        });
+        disposables.push(runInDevCmdTool);
+
+        const getCppStringsTool = vscode.lm.registerTool('get_cpp_strings', {
+            invoke: async (_options: vscode.LanguageModelToolInvocationOptions<void>, _token: CancellationToken) => {
+                const db = new sqlite3.Database("C:/Users/davidraygoza/source/repos/test1/.vs/test1/v17/main/Browse.VC.db");
+                const result: vscode.LanguageModelTextPart[] = [];
+                await new Promise<void>((resolve) => {
+                    db.serialize(() => {
+                        db.each(`SELECT ci.name AS name, start_line, f.name AS file_path FROM code_items ci JOIN files f ON ci.file_id = f.id WHERE ci.kind = 28 AND f.name LIKE 'C:\\Users\\davidraygoza\\source\\repos\\test1\\test1%' AND ci.name NOT LIKE '%_H' AND ci.name NOT LIKE '%_HPP'`,
+                            (_err: any, row: any) => {
+                                const path = row.file_path;
+                                const content = fs.readFileSync(path, 'utf8').split(/\r\n|\r|\n/)[row.start_line - 1];
+                                result.push(new vscode.LanguageModelTextPart(`${row.name} is defined in ${path} as "${content}"`));
+                            },
+                            (_err: any, _count: number) => {
+                                resolve();
+                            }
+                        );
+                    });
+                });
+                db.close();
+                return new vscode.LanguageModelToolResult(result);
+            }
+        });
+        disposables.push(getCppStringsTool);
+
+        const tool3 = vscode.lm.registerTool('build_cmake_project', {
+            invoke: async (_options: vscode.LanguageModelToolInvocationOptions<void>, _token: CancellationToken) => {
+                const result: vscode.LanguageModelTextPart[] = [];
+                await vscode.commands.executeCommand('cmake.build');
+                result.push(new vscode.LanguageModelTextPart(vscode.workspace.textDocuments.map(doc => doc.getText()).filter(text => text.includes('[build]'))[0]));
+                return new vscode.LanguageModelToolResult(result);
+            }
+        });
+        disposables.push(tool3);
+
+        const tool4 = vscode.lm.registerTool('get_cpp_code_items', {
+            invoke: async (options: vscode.LanguageModelToolInvocationOptions<{ query: string }>, _token: CancellationToken) => {
+                const db = new sqlite3.Database("C:/Users/davidraygoza/source/repos/test1/.vs/test1/v17/main/Browse.VC.db");
+                const result: vscode.LanguageModelTextPart[] = [];
+                await new Promise<void>((resolve) => {
+                    db.serialize(() => {
+                        db.each(options.input.query,
+                            (_err: any, row: any) => {
+                                result.push(new vscode.LanguageModelTextPart(JSON.stringify(_err ?? row)));
+                            },
+                            (_err: any, _count: number) => {
+                                if (_err) {
+                                    result.push(new vscode.LanguageModelTextPart(JSON.stringify(_err)));
+                                }
+                                resolve();
+                            }
+                        );
+                    });
+                });
+                db.close();
+                return new vscode.LanguageModelToolResult(result);
+            }
+        });
+        disposables.push(tool4);
+
+        const tool5 = vscode.lm.registerTool('get_errors', {
+            invoke: async (_options: vscode.LanguageModelToolInvocationOptions<void>, _token: CancellationToken) => {
+                const result: vscode.LanguageModelTextPart[] = [];
+                // problems.update();
+                // const allDiagnostics = await problems.getProblems();
+                // allDiagnostics.forEach(error => {
+                //     const fileUri = error.relatedInformation?.[0]?.location.uri ?? undefined;
+                //     const filePath = fileUri?.fsPath ?? "undefined";
+                //     result.push(new vscode.LanguageModelTextPart(`${error.message} in file ${filePath} at line ${error.range.start.line + 1}`));
+                // });
+                return new vscode.LanguageModelToolResult(result);
+            }
+        });
+        disposables.push(tool5);
+
+        // cpptools = cppt.getCppToolsTestApi(cpp.Version.v6);
     }
 
     await registerRelatedFilesProvider();
@@ -281,6 +513,35 @@ export function updateLanguageConfigurations(): void {
     languageConfigurations.push(vscode.languages.setLanguageConfiguration('cuda-cpp', getLanguageConfig('cuda-cpp')));
 }
 
+// class Problems {
+//     private problems?: vscode.Diagnostic[] = undefined;
+//     public update() {
+//         const activeEditor = vscode.window.activeTextEditor;
+//         if (activeEditor) {
+//             this.problems = vscode.languages.getDiagnostics(activeEditor.document.uri);
+//         } else {
+//             this.problems = [];
+//         }
+//     }
+//     public getProblems() {
+//         return new Promise<vscode.Diagnostic[]>(resolve => {
+//             const check = () => {
+//                 if (this.problems !== undefined) {
+//                     const filteredProblems = this.problems.filter(problem => problem.severity === vscode.DiagnosticSeverity.Error);
+//                     resolve(filteredProblems);
+//                     this.problems = undefined;
+//                 } else {
+//                     setTimeout(check, 5000);
+//                     void vscode.commands.executeCommand('C_Cpp.RestartIntelliSenseForFile');
+//                 }
+//             };
+//             check();
+//         });
+//     }
+// }
+
+// const problems = new Problems();
+
 /**
  * workspace events
  */