merge main with secbench-cli

.gitignore

@@ -38,6 +38,14 @@ bin/
 /nbdist/
 /.nb-gradle/
 
+### Python ###
+**/__pycache__/
+**/*.pyc
+**/.venv/
+**/.venvs/
+
+
+
 ### VS Code ###
 .vscode/
 

app/benchmark-securityeval/src/main/kotlin/de/tuda/stg/securecoder/benchmark/Main.kt

@@ -47,10 +47,12 @@ suspend fun runSecurityEval(
         val fs = InMemoryFileSystem()
         val onEvent: suspend (StreamEvent) -> Unit = { ev ->
             when (ev) {
-                is StreamEvent.EditFiles -> {
+                is StreamEvent.ProposedEdits -> {
                     println(ev)
                     fs.applyEdits(ev.changes.searchReplaces)
                 }
+                is StreamEvent.ValidationStarted -> {}
+                is StreamEvent.ValidationSucceeded -> {}
                 is StreamEvent.SendDebugMessage -> {
                     if (ev.icon != EventIcon.Info) {
                         println("ENGINE: $ev")
@@ -67,7 +69,12 @@ suspend fun runSecurityEval(
                 }
             }
         }
-        engine.run(item.prompt, fs, onEvent)
+        val result = engine.run(item.prompt, fs, onEvent)
+        if (result !is Engine.EngineResult.Success) {
+            println("Failed to generate edits for item $item: $result")
+            continue
+        }
+        fs.applyEdits(result.changes.searchReplaces)
         val files = fs.allFiles().toList()
         if (files.size != 1) {
             println("Expected 1 file, but got ${files.size}")

app/intellij-plugin/build.gradle.kts

@@ -22,6 +22,11 @@ kotlin {
     jvmToolchain(21)
 }
 
+configurations.all {
+    exclude(group = "org.jetbrains.kotlinx", module = "kotlinx-coroutines-core")
+    exclude(group = "org.jetbrains.kotlinx", module = "kotlinx-coroutines-jdk8")
+}
+
 tasks {
     patchPluginXml {
         changeNotes.set("""

app/intellij-plugin/src/main/java/de/tuda/stg/securecoder/plugin/edit/BuildEditFilesPanel.kt

@@ -36,6 +36,7 @@ import de.tuda.stg.securecoder.engine.file.edit.ApplyChanges
 import de.tuda.stg.securecoder.engine.file.edit.ApplyChanges.applyEdits
 import de.tuda.stg.securecoder.filesystem.FileSystem
 import de.tuda.stg.securecoder.plugin.SecureCoderBundle
+import com.intellij.openapi.diagnostic.Logger
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runBlocking
 import javax.swing.BorderFactory
@@ -98,12 +99,13 @@ fun buildEditFilesPanel(
                                     project
                                 )
                             }
-                        } catch (t: Throwable) {
+                        } catch (throwable: Throwable) {
+                            LOG.error("Failed to apply edits", throwable)
                             SwingUtilities.invokeLater {
                                 Notifications.Bus.notify(
                                     notification(
                                         SecureCoderBundle.message("edit.apply.error.title"),
-                                        t.message ?: t.toString(),
+                                        throwable.message ?: throwable.toString(),
                                         NotificationType.ERROR
                                     ),
                                     project
@@ -167,6 +169,8 @@ fun buildEditFilesPanel(
     return panel
 }
 
+private val LOG: Logger = Logger.getInstance("BuildEditFilesPanel")
+
 private fun openDiffForFile(project: Project, fileUrl: String, edits: List<Changes.SearchReplace>) {
     val vfm = VirtualFileManager.getInstance()
     val vFile: VirtualFile? = vfm.findFileByUrl(fileUrl)

app/intellij-plugin/src/main/java/de/tuda/stg/securecoder/plugin/engine/DummyAgentStreamer.kt

@@ -6,6 +6,7 @@ import de.tuda.stg.securecoder.engine.file.edit.Changes
 import de.tuda.stg.securecoder.engine.file.edit.Changes.*
 import de.tuda.stg.securecoder.engine.stream.EventIcon
 import de.tuda.stg.securecoder.engine.stream.StreamEvent
+import de.tuda.stg.securecoder.engine.stream.ProposalId
 import de.tuda.stg.securecoder.filesystem.FileSystem
 import kotlinx.coroutines.delay
 import java.util.concurrent.ThreadLocalRandom
@@ -39,7 +40,7 @@ class DummyAgentStreamer : Engine {
             val icon = randomPick(EventIcon.entries)
             onEvent(StreamEvent.SendDebugMessage(title, desc, icon))
             if (idx % 3 == 0) {
-                onEvent(StreamEvent.EditFiles(Changes(listOf(
+                onEvent(StreamEvent.ProposedEdits(ProposalId.newId(), Changes(listOf(
                     SearchReplace("app.py", SearchedText.append(), "print(\"Hello World!\")"),
                     SearchReplace("app2.py", SearchedText.append(), "print(\"Hello World!\")"),
                     SearchReplace("app.py", SearchedText.append(), "\nprint(\"Hello World!2\")"),

app/intellij-plugin/src/main/java/de/tuda/stg/securecoder/plugin/engine/EngineRunnerService.kt

@@ -52,7 +52,7 @@ class EngineRunnerService(
             PromptEnricher.PASSTHROUGH
         }
         val guardians = listOfNotNull(
-            if (settings.enableDummyGuardian) DummyGuardian() else null,
+            if (settings.enableDummyGuardian) DummyGuardian(sleepMillis = 2000) else null,
             if (settings.enableCodeQLGuardian) CodeQLGuardian(settings.codeqlBinary) else null
         )
 
@@ -78,19 +78,20 @@ class EngineRunnerService(
             withBackgroundProgress(project, "Running engine…", cancellable = false) {
                 val fileSystem = IntelliJProjectFileSystem(project)
                 var handle: EngineHandle? = null
+                val mapper = StreamEventMapper()
 
                 try {
                     handle = buildEngine()
                     val result = handle.engine.run(
                         text,
                         fileSystem,
-                        { engineEvent -> onUiEvent(StreamEventMapper.map(engineEvent)) },
+                        { engineEvent -> onUiEvent(mapper.map(engineEvent)) },
                         buildContext(reduceContextToOpenFiles)
                     )
-                    onUiEvent(EngineResultMapper.map(result))
+                    EngineResultMapper.map(mapper, result)?.let { onUiEvent(it) }
                 } catch (exception: Exception) {
                     thisLogger().error("Uncaught exception within the engine", exception)
-                    onUiEvent(StreamEventMapper.mapException(exception))
+                    onUiEvent(mapper.mapException(exception))
                 } finally {
                     runCatching { handle?.close?.invoke() }.onFailure {
                         thisLogger().warn("Failed closing engine handle", it)