target: string;

workspacePath: string;

args?: string[];

skipBuild?: boolean;

classpath?: string;

waitForSession?: boolean;

success: boolean;

message: string;

terminalName?: string;

status?: 'started' | 'timeout' | 'sent'; // More specific status

sessionId?: string; // Session ID if detected

// Check if the Language Model API is available

const lmApi = (vscode as any).lm;

if (!lmApi || typeof lmApi.registerTool !== 'function') {

// Language Model API not available in this VS Code version

return undefined;

}

const tool: LanguageModelTool<DebugJavaApplicationInput> = {

async invoke(options: { input: DebugJavaApplicationInput }, token: vscode.CancellationToken): Promise<any> {

sendInfo('', {

operationName: 'languageModelTool.debugJavaApplication.invoke',

target: options.input.target,

skipBuild: options.input.skipBuild?.toString() || 'false',

});

try {

const result = await debugJavaApplication(options.input, token);

// Format the message for AI - use simple text, not JSON

const message = result.success

? `✓ ${result.message}`

: `✗ ${result.message}`;

// Return result in the expected format - simple text part

return new (vscode as any).LanguageModelToolResult([

new (vscode as any).LanguageModelTextPart(message)

]);

} catch (error) {

sendError(error as Error);

const errorMessage = error instanceof Error ? error.message : String(error);

return new (vscode as any).LanguageModelToolResult([

new (vscode as any).LanguageModelTextPart(`✗ Debug failed: ${errorMessage}`)

]);

}

}

};

const disposable = lmApi.registerTool('debug_java_application', tool);

context.subscriptions.push(disposable);

return disposable;

input: DebugJavaApplicationInput,

token: vscode.CancellationToken

): Promise<DebugJavaApplicationResult> {

if (token.isCancellationRequested) {

return {

success: false,

message: 'Operation cancelled by user'

};

}

// Step 0: Cleanup any existing Java debug session to avoid port conflicts

const existingSession = vscode.debug.activeDebugSession;

if (existingSession && existingSession.type === 'java') {

sendInfo('', {

operationName: 'languageModelTool.cleanupExistingSession',

sessionId: existingSession.id,

sessionName: existingSession.name

});

try {

await vscode.debug.stopDebugging(existingSession);

// Give VS Code a moment to clean up the session

await new Promise(resolve => setTimeout(resolve, 500));

} catch (error) {

// Log but continue - the old session might already be dead

sendInfo('', {

operationName: 'languageModelTool.cleanupExistingSessionFailed',

error: String(error)

});

}

}

// Also close any existing "Java Debug" terminals to avoid confusion

for (const existingTerminal of vscode.window.terminals) {

if (existingTerminal.name === 'Java Debug') {

existingTerminal.dispose();

}

}

// Validate workspace path

const workspaceUri = vscode.Uri.file(input.workspacePath);

if (!fs.existsSync(input.workspacePath)) {

return {

success: false,

message: `Workspace path does not exist: ${input.workspacePath}`

};

}

// Step 1: Detect project type

const projectType = detectProjectType(input.workspacePath);

// Step 2: Build the project if needed

if (!input.skipBuild) {

const buildResult = await buildProject(workspaceUri, projectType, token);

if (!buildResult.success) {

return buildResult;

}

}

// Step 3: Construct and execute the debugjava command

const debugCommand = constructDebugCommand(input, projectType);

// Validate that we can construct a valid command

if (!debugCommand || debugCommand === 'debugjava') {

return {

success: false,

message: 'Failed to construct debug command. Please check the target parameter.'

};

}

// Step 4: Execute in terminal and optionally wait for debug session

const terminal = vscode.window.createTerminal({

name: 'Java Debug',

cwd: input.workspacePath,

hideFromUser: false,

isTransient: false // Keep terminal alive even after process exits

});

terminal.show();

// Build info message for AI

let targetInfo = input.target;

let warningNote = '';

if (input.target.endsWith('.jar')) {

targetInfo = input.target;

} else if (input.target.includes('.')) {

targetInfo = input.target;

} else {

// Simple class name - check if we successfully detected the full name

const detectedClassName = findFullyQualifiedClassName(input.workspacePath, input.target, projectType);

if (detectedClassName) {

targetInfo = `${detectedClassName} (detected from ${input.target})`;

} else {

targetInfo = input.target;

warningNote = ' ⚠️ Note: Could not auto-detect package name. If you see "ClassNotFoundException", please provide the fully qualified class name (e.g., "com.example.App" instead of "App").';

}

}

// If waitForSession is true, wait for the debug session to start

if (input.waitForSession) {

return new Promise<DebugJavaApplicationResult>((resolve) => {

let sessionStarted = false;

// Listen for debug session start

const sessionDisposable = vscode.debug.onDidStartDebugSession((session) => {

if (session.type === 'java' && !sessionStarted) {

sessionStarted = true;

sessionDisposable.dispose();

if (timeoutHandle) {

clearTimeout(timeoutHandle);

}

sendInfo('', {

operationName: 'languageModelTool.debugSessionStarted.eventBased',

sessionId: session.id,

sessionName: session.name

});

resolve({

success: true,

status: 'started',

sessionId: session.id,

message: `✓ Debug session started for ${targetInfo}. Session ID: ${session.id}. The debugger is now attached and ready. Any breakpoints you set will be active.${warningNote}`,

terminalName: terminal.name

});

}

});

// Send the command after setting up the listener

terminal.sendText(debugCommand);

// Set a timeout for large applications

const timeoutHandle = setTimeout(() => {

if (!sessionStarted) {

sessionDisposable.dispose();

sendInfo('', {

operationName: 'languageModelTool.debugSessionTimeout.eventBased',

target: targetInfo

});

resolve({

success: false,

status: 'timeout',

message: `❌ Debug session failed to start within ${CONSTANTS.SESSION_WAIT_TIMEOUT / 1000} seconds for ${targetInfo}.\n\n` +

`This usually indicates a problem:\n` +

`• Compilation errors preventing startup\n` +

`• ClassNotFoundException or NoClassDefFoundError\n` +

`• Application crashed during initialization\n` +

`• Incorrect main class or classpath configuration\n\n` +

`Action required:\n` +

`1. Check terminal '${terminal.name}' for error messages\n` +

`2. Verify the target class name is correct\n` +

`3. Ensure the project is compiled successfully\n` +

`4. Use get_debug_session_info() to confirm session status${warningNote}`,

terminalName: terminal.name

});

}

}, CONSTANTS.SESSION_WAIT_TIMEOUT);

});

} else {

// Default behavior: send command and use smart polling to detect session start

terminal.sendText(debugCommand);

// Smart polling to detect session start

const maxWaitTime = CONSTANTS.SMART_POLLING_MAX_WAIT;

const pollInterval = CONSTANTS.SMART_POLLING_INTERVAL;

const startTime = Date.now();

while (Date.now() - startTime < maxWaitTime) {

// Check if debug session has started

const session = vscode.debug.activeDebugSession;

if (session && session.type === 'java') {

const elapsedTime = ((Date.now() - startTime) / 1000).toFixed(1);

sendInfo('', {

operationName: 'languageModelTool.debugSessionDetected',

sessionId: session.id,

elapsedTime

});

return {

success: true,

status: 'started',

sessionId: session.id,

message: `✓ Debug session started for ${targetInfo} (detected in ${elapsedTime}s). Session ID: ${session.id}. The debugger is attached and ready.${warningNote}`,

terminalName: terminal.name

};

}

// Wait before next check

await new Promise(resolve => setTimeout(resolve, pollInterval));

}

// Timeout: session not detected within 15 seconds

sendInfo('', {

operationName: 'languageModelTool.debugSessionTimeout.smartPolling',

target: targetInfo,

maxWaitTime

});

return {

success: true,

status: 'timeout',

message: `⚠️ Debug command sent for ${targetInfo}, but session not detected within ${CONSTANTS.SMART_POLLING_MAX_WAIT / 1000} seconds.\n\n` +

`Possible reasons:\n` +

`• Application is still starting (large projects may take longer)\n` +

`• Compilation errors (check terminal '${terminal.name}' for errors)\n` +

`• Application may have started and already terminated\n\n` +

`Next steps:\n` +

`• Use get_debug_session_info() to check if session is now active\n` +

`• Check terminal '${terminal.name}' for error messages\n` +

`• If starting slowly, wait a bit longer and check again${warningNote}`,

terminalName: terminal.name

};

}

if (fs.existsSync(path.join(workspacePath, 'pom.xml'))) {

return 'maven';

}

if (fs.existsSync(path.join(workspacePath, 'build.gradle')) ||

fs.existsSync(path.join(workspacePath, 'build.gradle.kts'))) {

return 'gradle';

}

// Check if VS Code Java extension is likely managing compilation

const workspaceFolder = vscode.workspace.getWorkspaceFolder(vscode.Uri.file(workspacePath));

if (workspaceFolder) {

const javaExt = vscode.extensions.getExtension('redhat.java');

if (javaExt?.isActive) {

return 'vscode';

}

}

return 'unknown';

workspaceUri: vscode.Uri,

projectType: 'maven' | 'gradle' | 'vscode' | 'unknown',

_token: vscode.CancellationToken

): Promise<DebugJavaApplicationResult> {

switch (projectType) {

case 'maven':

return buildMavenProject(workspaceUri);

case 'gradle':

return buildGradleProject(workspaceUri);

case 'vscode':

return ensureVSCodeCompilation(workspaceUri);

case 'unknown':

// Try to proceed anyway - user might have manually compiled

return {

success: true,

message: 'Unknown project type. Skipping build step. Ensure your Java files are compiled.'

};

}

workspaceUri: vscode.Uri,

taskId: string,

taskName: string,

command: string,

successMessage: string,

timeoutMessage: string,

failureMessagePrefix: string

): Promise<DebugJavaApplicationResult> {

return new Promise((resolve) => {

const workspaceFolder = vscode.workspace.getWorkspaceFolder(workspaceUri);

if (!workspaceFolder) {

resolve({

success: false,

message: `Cannot find workspace folder for ${workspaceUri.fsPath}`

});

return;

}

const task = new vscode.Task(

{ type: 'shell', task: taskId },

workspaceFolder,

taskName,

'Java Debug',

new vscode.ShellExecution(command, { cwd: workspaceUri.fsPath })

);

let resolved = false;

let taskDisposable: vscode.Disposable | undefined;

let errorDisposable: vscode.Disposable | undefined;

const cleanup = () => {

clearTimeout(timeoutHandle);

taskDisposable?.dispose();

errorDisposable?.dispose();

};

// Set a timeout to avoid hanging indefinitely

const timeoutHandle = setTimeout(() => {

if (!resolved) {

resolved = true;

cleanup();

resolve({

success: true,

message: timeoutMessage

});

}

}, CONSTANTS.BUILD_TIMEOUT);

vscode.tasks.executeTask(task).then(

(execution) => {

taskDisposable = vscode.tasks.onDidEndTask((e) => {

if (e.execution === execution && !resolved) {

resolved = true;

cleanup();

resolve({

success: true,

message: successMessage

});

}

});

errorDisposable = vscode.tasks.onDidEndTaskProcess((e) => {

if (e.execution === execution && e.exitCode !== 0 && !resolved) {

resolved = true;

cleanup();

resolve({

success: false,

message: `${failureMessagePrefix} with exit code ${e.exitCode}. Please check the terminal output.`

});

}

});

},

(error: Error) => {

if (!resolved) {

resolved = true;

cleanup();

resolve({

success: false,

message: `Failed to execute task: ${error.message}`

});

}

}

);

});

workspaceUri: vscode.Uri

): Promise<DebugJavaApplicationResult> {

return executeShellTask(

workspaceUri,

'maven-compile',

'Maven Compile',

'mvn compile',

'Maven project compiled successfully',

'Maven compile command sent. Build may still be in progress.',

'Maven build failed'

);

workspaceUri: vscode.Uri

): Promise<DebugJavaApplicationResult> {

const gradleWrapper = process.platform === 'win32' ? 'gradlew.bat' : './gradlew';

const gradleCommand = fs.existsSync(path.join(workspaceUri.fsPath, gradleWrapper))

? gradleWrapper

: 'gradle';

return executeShellTask(

workspaceUri,

'gradle-classes',

'Gradle Classes',

`${gradleCommand} classes`,

'Gradle project compiled successfully',

'Gradle compile command sent. Build may still be in progress.',

'Gradle build failed'

);

try {

// Check for compilation errors using VS Code diagnostics

const javaFiles = await vscode.workspace.findFiles(

new vscode.RelativePattern(workspaceUri, '**/*.java'),

'**/node_modules/**',

CONSTANTS.MAX_JAVA_FILES_TO_CHECK

);

let hasErrors = false;

for (const file of javaFiles) {

const diagnostics = vscode.languages.getDiagnostics(file);

const errors = diagnostics.filter(d => d.severity === vscode.DiagnosticSeverity.Error);

if (errors.length > 0) {

hasErrors = true;

break;

}

}

if (hasErrors) {

return {

success: false,

message: 'Compilation errors detected in the project. Please fix the errors before debugging.'

};

}

// Check if Java extension is active and in standard mode

const javaExt = vscode.extensions.getExtension('redhat.java');

if (!javaExt?.isActive) {

return {

success: true,

message: 'Java Language Server is not active. Proceeding with debug, but ensure your code is compiled.'

};

}

return {

success: true,

message: 'VS Code Java compilation verified'

};

} catch (error) {

// If we can't verify, proceed anyway

return {

success: true,

message: 'Unable to verify compilation status. Proceeding with debug.'

};

}

input: DebugJavaApplicationInput,

projectType: 'maven' | 'gradle' | 'vscode' | 'unknown'

): string {

let command = 'debugjava';

// Handle JAR files

if (input.target.endsWith('.jar')) {

command += ` -jar ${input.target}`;

}

// Handle raw java command arguments (starts with - like -cp, -jar, etc)

else if (input.target.startsWith('-')) {

command += ` ${input.target}`;

}

// Handle class name (with or without package)

else {

let className = input.target;

// If target doesn't contain a dot and we can find the Java file,

// try to detect the fully qualified class name

if (!input.target.includes('.')) {

const detectedClassName = findFullyQualifiedClassName(input.workspacePath, input.target, projectType);

if (detectedClassName) {

sendInfo('', {

operationName: 'languageModelTool.classNameDetection',

simpleClassName: input.target,

detectedClassName,

projectType

});

className = detectedClassName;

} else {

// No package detected - class is in default package

sendInfo('', {

operationName: 'languageModelTool.classNameDetection.noPackage',

simpleClassName: input.target,

projectType

});

}

}

// Use provided classpath if available, otherwise infer it

const classpath = input.classpath || inferClasspath(input.workspacePath, projectType);

command += ` -cp "${classpath}" ${className}`;

}

// Add arguments if provided

if (input.args && input.args.length > 0) {

command += ' ' + input.args.join(' ');

}

return command;

workspacePath: string,

simpleClassName: string,

projectType: 'maven' | 'gradle' | 'vscode' | 'unknown'

): string | null {

// Determine source directories based on project type

const sourceDirs: string[] = [];

switch (projectType) {

case 'maven':

sourceDirs.push(path.join(workspacePath, 'src', 'main', 'java'));

break;

case 'gradle':

sourceDirs.push(path.join(workspacePath, 'src', 'main', 'java'));

break;

case 'vscode':

sourceDirs.push(path.join(workspacePath, 'src'));

break;

case 'unknown':

// Try all common locations

sourceDirs.push(

path.join(workspacePath, 'src', 'main', 'java'),

path.join(workspacePath, 'src'),

workspacePath

);

break;

}

// Search for the Java file

for (const srcDir of sourceDirs) {

if (!fs.existsSync(srcDir)) {

continue;

}

try {

const javaFile = findJavaFile(srcDir, simpleClassName, 0);

if (javaFile) {

// Extract package name from the file

const packageName = extractPackageName(javaFile);

if (packageName) {

return `${packageName}.${simpleClassName}`;

} else {

// No package, use simple name

return simpleClassName;

}

}

} catch (error) {

// Continue searching in other directories

}

}

return null;

// Limit recursion depth to prevent performance issues

if (depth > CONSTANTS.MAX_FILE_SEARCH_DEPTH) {

return null;

}

try {

const files = fs.readdirSync(dir);

for (const file of files) {

const filePath = path.join(dir, file);

const stat = fs.statSync(filePath);

if (stat.isDirectory()) {

// Skip common non-source directories

if (file === 'node_modules' || file === '.git' || file === 'target' || file === 'build') {

continue;

}

const found = findJavaFile(filePath, className, depth + 1);

if (found) {

return found;

}

} else if (file === `${className}.java`) {

return filePath;

}

}

} catch (error) {

// Ignore permission errors or other file system issues

}

return null;

try {

const content = fs.readFileSync(javaFilePath, 'utf-8');

const packageMatch = content.match(/^\s*package\s+([\w.]+)\s*;/m);

return packageMatch ? packageMatch[1] : null;

} catch (error) {

return null;

}

// Limit recursion depth to prevent performance issues

if (depth > CONSTANTS.MAX_FILE_SEARCH_DEPTH) {

return false;

}

try {

const files = fs.readdirSync(dir);

for (const file of files) {

const filePath = path.join(dir, file);

const stat = fs.statSync(filePath);

if (stat.isFile() && file.endsWith('.class')) {

return true;

} else if (stat.isDirectory()) {

if (hasClassFiles(filePath, depth + 1)) {

return true;

}

}

}

} catch (error) {

// Ignore errors

}

return false;

const classpaths: string[] = [];

switch (projectType) {

case 'maven':

// Maven standard output directory

const mavenTarget = path.join(workspacePath, 'target', 'classes');

if (fs.existsSync(mavenTarget)) {

classpaths.push(mavenTarget);

}

break;

case 'gradle':

// Gradle standard output directories

const gradleMain = path.join(workspacePath, 'build', 'classes', 'java', 'main');

if (fs.existsSync(gradleMain)) {

classpaths.push(gradleMain);

}

break;

case 'vscode':

// VS Code Java extension default output

const vscodeOut = path.join(workspacePath, 'bin');

if (fs.existsSync(vscodeOut)) {

classpaths.push(vscodeOut);

}

break;

}

// Fallback to common locations

if (classpaths.length === 0) {

const commonPaths = [

path.join(workspacePath, 'bin'), // VS Code default

path.join(workspacePath, 'out'), // IntelliJ default

path.join(workspacePath, 'target', 'classes'), // Maven

path.join(workspacePath, 'build', 'classes', 'java', 'main'), // Gradle

path.join(workspacePath, 'build', 'classes'),

];

// Check each common path

for (const p of commonPaths) {

if (fs.existsSync(p)) {

// Check if there are actually .class files in this directory

if (hasClassFiles(p)) {

classpaths.push(p);

break;

}

}

}

}

// If still no classpath found, use current directory

// This is common for simple projects where .class files are alongside .java files

if (classpaths.length === 0) {

classpaths.push('.');

}

return classpaths.join(path.delimiter);

filePath: string;

lineNumber: number;

condition?: string;

hitCondition?: string;

logMessage?: string;

threadId?: number;

frameId?: number;

scopeType?: 'local' | 'static' | 'all';

filter?: string;

expression: string;

threadId?: number;

frameId?: number;

context?: 'watch' | 'repl' | 'hover';

try {

const threadsResponse = await session.customRequest('threads');

for (const thread of threadsResponse.threads || []) {

try {

const stackResponse = await session.customRequest('stackTrace', {

threadId: thread.id,

startFrame: 0,

levels: 1

});

if (stackResponse?.stackFrames?.length > 0) {

return {

threadId: thread.id,

frameId: stackResponse.stackFrames[0].id

};

}

} catch {

// Thread is running, continue to next

continue;

}

}

} catch {

// Failed to get threads

}

return null;

const lmApi = (vscode as any).lm;

if (!lmApi || typeof lmApi.registerTool !== 'function') {

return [];

}

const disposables: vscode.Disposable[] = [];

// Tool 1: Set Breakpoint

const setBreakpointTool: LanguageModelTool<SetBreakpointInput> = {

async invoke(options: { input: SetBreakpointInput }, _token: vscode.CancellationToken): Promise<any> {

try {

const { filePath, lineNumber, condition, hitCondition, logMessage } = options.input;

// Set breakpoint through VS Code API (no active session required)

const uri = vscode.Uri.file(filePath);

const breakpoint = new vscode.SourceBreakpoint(

new vscode.Location(uri, new vscode.Position(lineNumber - 1, 0)),

true, // enabled

condition,

hitCondition,

logMessage

);

vscode.debug.addBreakpoints([breakpoint]);

const bpType = logMessage ? 'Logpoint' : 'Breakpoint';

const session = vscode.debug.activeDebugSession;

const sessionInfo = (session && session.type === 'java')

? ' (active in current session)'

: ' (will activate when debugging starts)';

return new (vscode as any).LanguageModelToolResult([

new (vscode as any).LanguageModelTextPart(

`✓ ${bpType} set at ${path.basename(filePath)}:${lineNumber}${condition ? ` (condition: ${condition})` : ''}${sessionInfo}`