@aion0/forge 0.5.44 → 0.5.46

package/intellij-plugin/src/main/kotlin/com/aion0/forge/ui/toolwindow/PipelinesView.kt

@@ -1,226 +0,0 @@
-package com.aion0.forge.ui.toolwindow
-
-import com.aion0.forge.api.ForgeClient
-import com.intellij.icons.AllIcons
-import com.intellij.openapi.actionSystem.AnAction
-import com.intellij.openapi.actionSystem.AnActionEvent
-import com.intellij.openapi.fileEditor.FileEditorManager
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.ui.Messages
-import com.intellij.testFramework.LightVirtualFile
-import java.net.URLEncoder
-import javax.swing.tree.DefaultMutableTreeNode
-
-class PipelinesView(project: Project) : ForgeTreeView(project) {
-
-    override fun rootLabel() = "pipelines"
-
-    override fun reload(): List<DefaultMutableTreeNode> {
-        val r = ForgeClient.get().request("/api/projects")
-        if (r.status == 401 || r.status == 403) return listOf(DefaultMutableTreeNode(TreeNodeData.Hint("🔑 Tools → Forge: Login")))
-        if (!r.ok || r.data == null || !r.data.isJsonArray) {
-            return listOf(DefaultMutableTreeNode(TreeNodeData.Hint("⚠ ${r.error ?: "Not connected"}")))
-        }
-        val arr = r.data.asJsonArray
-        if (arr.size() == 0) return listOf(DefaultMutableTreeNode(TreeNodeData.Hint("No projects")))
-
-        return arr.toList().sortedBy { it.asJsonObject.get("name")?.asString ?: "" }.mapNotNull { el ->
-            val p = el.asJsonObject
-            val name = p.get("name")?.asString ?: return@mapNotNull null
-            val path = p.get("path")?.asString ?: return@mapNotNull null
-            val node = DefaultMutableTreeNode(TreeNodeData.PipelineProject("📁 $name", path, name))
-
-            val pp = ForgeClient.get().request("/api/project-pipelines?project=${URLEncoder.encode(path, "UTF-8")}")
-            if (pp.ok && pp.data?.isJsonObject == true) {
-                val obj = pp.data.asJsonObject
-                val bindings = obj.getAsJsonArray("bindings")
-                val runs = obj.getAsJsonArray("runs")
-                if (bindings == null || bindings.size() == 0) {
-                    node.add(DefaultMutableTreeNode(TreeNodeData.Hint("＋ No pipelines yet — right-click to add")))
-                } else {
-                    for (bEl in bindings) {
-                        val b = bEl.asJsonObject
-                        val wf = b.get("workflowName")?.asString ?: "?"
-                        val enabled = b.get("enabled")?.asBoolean ?: true
-                        val schedule = b.getAsJsonObject("config")?.get("schedule")?.asString
-                            ?: b.getAsJsonObject("config")?.get("cron")?.asString
-                            ?: "manual"
-                        val mark = if (enabled) "⚙" else "⊘"
-                        node.add(DefaultMutableTreeNode(
-                            TreeNodeData.PipelineBinding("$mark $wf  ($schedule)", path, name, wf, enabled),
-                        ))
-                    }
-                }
-                if (runs != null && runs.size() > 0) {
-                    val runsHead = DefaultMutableTreeNode(TreeNodeData.Hint("📜 Recent Runs"))
-                    runs.take(10).forEach { rEl ->
-                        val run = rEl.asJsonObject
-                        val status = run.get("status")?.asString ?: "?"
-                        val wf = run.get("workflowName")?.asString ?: "?"
-                        val pipelineId = run.get("pipelineId")?.asString ?: run.get("id")?.asString ?: ""
-                        val createdAt = run.get("createdAt")?.asString ?: ""
-                        val emoji = when (status) {
-                            "running" -> "▶"; "done" -> "✓"; "failed" -> "✕"; "cancelled" -> "⊘"; else -> "·"
-                        }
-                        runsHead.add(DefaultMutableTreeNode(
-                            TreeNodeData.PipelineRun("$emoji $wf  ·  $createdAt", pipelineId, wf, status),
-                        ))
-                    }
-                    node.add(runsHead)
-                }
-            }
-            node
-        }
-    }
-
-    override fun onDoubleClick(data: TreeNodeData, node: DefaultMutableTreeNode) {
-        when (data) {
-            is TreeNodeData.PipelineBinding -> triggerBinding(data)
-            is TreeNodeData.PipelineRun     -> expandRun(node, data)
-            is TreeNodeData.PipelineNode    -> showNodeResult(data)
-            else -> {}
-        }
-    }
-
-    override fun contextActions(data: TreeNodeData, node: DefaultMutableTreeNode): List<AnAction> = when (data) {
-        is TreeNodeData.PipelineProject -> listOf(
-            act("Add Pipeline…", AllIcons.General.Add) { addPipeline(data) },
-        )
-        is TreeNodeData.PipelineBinding -> listOf(
-            act("Trigger Now",        AllIcons.Actions.Execute) { triggerBinding(data) },
-            act(if (data.enabled) "Disable" else "Enable", AllIcons.Actions.ToggleSoftWrap) { toggleBinding(data) },
-            act("Remove…",            AllIcons.Actions.Cancel)  { removeBinding(data) },
-        )
-        is TreeNodeData.PipelineRun -> listOf(
-            act("Show Nodes", AllIcons.Actions.Expandall) { expandRun(node, data) },
-        )
-        is TreeNodeData.PipelineNode -> listOf(
-            act("Show Result", AllIcons.Actions.Preview) { showNodeResult(data) },
-        )
-        else -> emptyList()
-    }
-
-    private fun triggerBinding(b: TreeNodeData.PipelineBinding) {
-        runApi(project, "Trigger ${b.workflowName}", {
-            ForgeClient.get().request(
-                "/api/project-pipelines",
-                method = "POST",
-                body = mapOf("action" to "trigger", "projectPath" to b.projectPath, "projectName" to b.projectName, "workflowName" to b.workflowName, "input" to emptyMap<String, String>()),
-            )
-        }) { refresh() }
-    }
-
-    private fun toggleBinding(b: TreeNodeData.PipelineBinding) {
-        val next = !b.enabled
-        runApi(project, if (next) "Enable ${b.workflowName}" else "Disable ${b.workflowName}", {
-            ForgeClient.get().request(
-                "/api/project-pipelines",
-                method = "POST",
-                body = mapOf("action" to "update", "projectPath" to b.projectPath, "workflowName" to b.workflowName, "enabled" to next),
-            )
-        }) { refresh() }
-    }
-
-    private fun removeBinding(b: TreeNodeData.PipelineBinding) {
-        val r = Messages.showYesNoDialog(project, "Remove pipeline \"${b.workflowName}\"?", "Forge", Messages.getQuestionIcon())
-        if (r != Messages.YES) return
-        runApi(project, "Remove ${b.workflowName}", {
-            ForgeClient.get().request(
-                "/api/project-pipelines",
-                method = "POST",
-                body = mapOf("action" to "remove", "projectPath" to b.projectPath, "workflowName" to b.workflowName),
-            )
-        }) { refresh() }
-    }
-
-    private fun addPipeline(p: TreeNodeData.PipelineProject) {
-        val pp = ForgeClient.get().request("/api/project-pipelines?project=${URLEncoder.encode(p.projectPath, "UTF-8")}")
-        val workflows = pp.data?.asJsonObject?.getAsJsonArray("workflows")?.map { it.asJsonObject.get("name").asString } ?: return
-        val bound = pp.data.asJsonObject.getAsJsonArray("bindings")?.map { it.asJsonObject.get("workflowName").asString }?.toSet() ?: emptySet()
-        val candidates = workflows.filter { it !in bound }
-        if (candidates.isEmpty()) { notify(project, "Forge: all workflows are already bound to ${p.projectName}"); return }
-        val choice = Messages.showEditableChooseDialog("Workflow to bind", "Add Pipeline", null, candidates.toTypedArray(), candidates.first(), null) ?: return
-        runApi(project, "Add $choice to ${p.projectName}", {
-            ForgeClient.get().request(
-                "/api/project-pipelines",
-                method = "POST",
-                body = mapOf("action" to "add", "projectPath" to p.projectPath, "projectName" to p.projectName, "workflowName" to choice, "config" to emptyMap<String, Any>()),
-            )
-        }) { refresh() }
-    }
-
-    private fun expandRun(parent: DefaultMutableTreeNode, run: TreeNodeData.PipelineRun) {
-        if (run.pipelineId.isBlank()) { notify(project, "Forge: this run has no pipeline detail id."); return }
-        val r = ForgeClient.get().request("/api/pipelines/${run.pipelineId}")
-        if (!r.ok || r.data == null || !r.data.isJsonObject) {
-            notify(project, "Forge: ${r.error ?: "failed to load run"}", com.intellij.notification.NotificationType.WARNING)
-            return
-        }
-        val nodes = r.data.asJsonObject.getAsJsonObject("nodes")
-        val order = r.data.asJsonObject.getAsJsonArray("nodeOrder")
-            ?.map { it.asString } ?: nodes?.keySet()?.toList() ?: emptyList()
-        com.intellij.openapi.application.ApplicationManager.getApplication().invokeLater {
-            parent.removeAllChildren()
-            for (name in order) {
-                val n = nodes?.getAsJsonObject(name) ?: continue
-                val st = n.get("status")?.asString ?: "pending"
-                val err = n.get("error")?.asString
-                val taskId = n.get("taskId")?.asString
-                val emoji = when (st) {
-                    "running" -> "▶"; "done" -> "✓"; "failed" -> "✕"
-                    "cancelled" -> "⊘"; "skipped" -> "·"; else -> "·"
-                }
-                parent.add(DefaultMutableTreeNode(
-                    TreeNodeData.PipelineNode("$emoji $name  ($st)", run.pipelineId, name, st, err, taskId),
-                ))
-            }
-            treeModel.reload(parent)
-            tree.expandPath(javax.swing.tree.TreePath(parent.path))
-        }
-    }
-
-    /** Open a markdown buffer with status + error + (if available) the linked
-     *  task's prompt / result / log / git diff. */
-    private fun showNodeResult(n: TreeNodeData.PipelineNode) {
-        runBg(project, "Loading node result") {
-            val sb = StringBuilder()
-            sb.append("# Pipeline node: `${n.nodeName}`\n\n")
-            sb.append("**Status:** ${n.status}\n")
-            if (n.taskId != null) sb.append("**Task ID:** `${n.taskId}`\n")
-            sb.append("\n")
-
-            if (n.taskId != null) {
-                val t = ForgeClient.get().request("/api/tasks/${n.taskId}")
-                if (t.ok && t.data?.isJsonObject == true) {
-                    val task = t.data.asJsonObject
-                    task.get("prompt")?.asString?.let { sb.append("## Prompt\n```\n$it\n```\n\n") }
-                    task.get("resultSummary")?.asString?.let { sb.append("## Result\n$it\n\n") }
-                    task.get("gitDiff")?.asString?.let { sb.append("## Git Diff\n```diff\n$it\n```\n\n") }
-                    val log = task.getAsJsonArray("log")
-                    if (log != null && log.size() > 0) {
-                        sb.append("## Log (last 20)\n")
-                        log.toList().takeLast(20).forEach { e ->
-                            val o = e.asJsonObject
-                            val tag = o.get("subtype")?.asString ?: o.get("type")?.asString ?: "log"
-                            val content = o.get("content")?.asString ?: ""
-                            sb.append("- `[$tag]` ${content.take(500).replace("\n", " ")}\n")
-                        }
-                        sb.append("\n")
-                    }
-                }
-            }
-            if (!n.error.isNullOrBlank()) sb.append("## Error\n```\n${n.error}\n```\n")
-
-            val content = sb.toString()
-            com.intellij.openapi.application.ApplicationManager.getApplication().invokeLater {
-                val vf = LightVirtualFile("forge-node-${n.nodeName}.md", content)
-                vf.isWritable = false
-                FileEditorManager.getInstance(project).openFile(vf, true)
-            }
-        }
-    }
-
-    private fun act(name: String, icon: javax.swing.Icon?, run: () -> Unit) = object : AnAction(name, null, icon) {
-        override fun actionPerformed(e: AnActionEvent) = run()
-    }
-}

package/intellij-plugin/src/main/kotlin/com/aion0/forge/ui/toolwindow/TerminalsView.kt

@@ -1,309 +0,0 @@
-package com.aion0.forge.ui.toolwindow
-
-import com.aion0.forge.api.ForgeClient
-import com.intellij.icons.AllIcons
-import com.intellij.openapi.actionSystem.AnAction
-import com.intellij.openapi.actionSystem.AnActionEvent
-import com.intellij.openapi.actionSystem.DefaultActionGroup
-import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.ui.Messages
-import org.jetbrains.plugins.terminal.LocalTerminalDirectRunner
-import org.jetbrains.plugins.terminal.ShellStartupOptions
-import org.jetbrains.plugins.terminal.TerminalTabState
-import org.jetbrains.plugins.terminal.TerminalToolWindowManager
-import java.net.URLEncoder
-import javax.swing.tree.DefaultMutableTreeNode
-
-/**
- * Project-keyed terminal launcher.
- *
- * Each top-level node is a forge project. Expand it to see its claude sessions
- * (most-recent first, bound session marked ★). Double-click a session resumes
- * exactly that session via `claude --resume <id>`. Right-click → Open With
- * lists every configured agent for a fresh launch.
- *
- * Agents are spawned **directly as the pty process** via a custom
- * [LocalTerminalDirectRunner]: no shell, no `executeCommand`, so there is no
- * race with prompt-detection or shell startup that could swallow keystrokes.
- */
-class TerminalsView(project: Project) : ForgeTreeView(project) {
-
-    /** Cached list of enabled agents — refreshed on every reload so the project
-     *  right-click submenu can list them synchronously. */
-    @Volatile private var agentsCache: List<Triple<String, String, String?>> = emptyList()
-
-    override fun rootLabel() = "terminals"
-
-    override fun reload(): List<DefaultMutableTreeNode> {
-        // Refresh agent cache for the right-click submenu (cheap; ignore failures).
-        ForgeClient.get().request("/api/agents").let { ar ->
-            if (ar.ok && ar.data?.isJsonObject == true) {
-                agentsCache = ar.data.asJsonObject.getAsJsonArray("agents")?.toList()?.mapNotNull { el ->
-                    val o = el.asJsonObject
-                    if (o.get("enabled")?.asBoolean == false) return@mapNotNull null
-                    val id = o.get("id")?.asString ?: return@mapNotNull null
-                    val name = o.get("name")?.asString ?: id
-                    Triple(id, name, o.get("cliType")?.asString)
-                }.orEmpty()
-            }
-        }
-
-        val r = ForgeClient.get().request("/api/projects")
-        if (r.status == 401 || r.status == 403) return listOf(DefaultMutableTreeNode(TreeNodeData.Hint("🔑 Tools → Forge: Login")))
-        if (!r.ok || r.data == null || !r.data.isJsonArray) {
-            return listOf(DefaultMutableTreeNode(TreeNodeData.Hint("⚠ ${r.error ?: "Not connected"}")))
-        }
-        val arr = r.data.asJsonArray
-        if (arr.size() == 0) return listOf(DefaultMutableTreeNode(TreeNodeData.Hint("No projects yet")))
-
-        return arr.toList()
-            .sortedBy { it.asJsonObject.get("name")?.asString ?: "" }
-            .mapNotNull { el ->
-                val p = el.asJsonObject
-                val name = p.get("name")?.asString ?: return@mapNotNull null
-                val path = p.get("path")?.asString ?: return@mapNotNull null
-                val node = DefaultMutableTreeNode(TreeNodeData.LocalProject("📁 $name", path, name))
-
-                val bs = ForgeClient.get().request("/api/project-sessions?projectPath=${URLEncoder.encode(path, "UTF-8")}")
-                val boundId = bs.data?.asJsonObject?.get("fixedSessionId")?.takeUnless { it.isJsonNull }?.asString
-
-                val ss = ForgeClient.get().request("/api/claude-sessions/${URLEncoder.encode(name, "UTF-8")}")
-                val sessions = ss.data?.takeIf { it.isJsonArray }?.asJsonArray?.toList() ?: emptyList()
-
-                sessions.take(10).forEach { sEl ->
-                    val s = sEl.asJsonObject
-                    val sid = s.get("sessionId")?.asString ?: return@forEach
-                    val mtime = s.get("modified")?.asString ?: ""
-                    val isBound = sid == boundId
-                    val mark = if (isBound) "★" else "·"
-                    val pretty = mtime.take(19).replace('T', ' ')
-                    node.add(DefaultMutableTreeNode(
-                        TreeNodeData.ClaudeSession("$mark ${sid.take(8)}  $pretty", path, name, sid, isBound),
-                    ))
-                }
-                node.add(DefaultMutableTreeNode(TreeNodeData.NewSession("➕ New session…", path, name)))
-                node
-            }
-    }
-
-    override fun onDoubleClick(data: TreeNodeData, node: DefaultMutableTreeNode) {
-        when (data) {
-            is TreeNodeData.ClaudeSession -> resumeClaudeSession(data)
-            is TreeNodeData.NewSession    -> promptAgentAndLaunch(data.projectPath, data.projectName, resumeSessionId = null)
-            is TreeNodeData.LocalProject  -> promptAgentAndLaunch(data.projectPath, data.projectName, resumeSessionId = null)
-            else -> {}
-        }
-    }
-
-    override fun contextActions(data: TreeNodeData, node: DefaultMutableTreeNode): List<AnAction> = when (data) {
-        is TreeNodeData.LocalProject -> buildList {
-            add(buildOpenWithGroup(data.projectPath, data.projectName, resumeSessionId = null, label = "Open With (fresh)"))
-            add(act("New Session… (pick agent)", AllIcons.General.Add) { promptAgentAndLaunch(data.projectPath, data.projectName, resumeSessionId = null) })
-            add(act("Plain Terminal Here", AllIcons.Debugger.Console) { openPlainTerminal(data.projectPath, data.projectName) })
-        }
-        is TreeNodeData.ClaudeSession -> buildList {
-            add(act("Resume (claude)", AllIcons.Actions.Execute) { resumeClaudeSession(data) })
-            add(buildOpenWithGroup(data.projectPath, data.projectName, resumeSessionId = data.sessionId, label = "Resume With…"))
-            if (!data.isBound) add(act("Pin as Default Session", AllIcons.Nodes.Favorite) { bindSession(data) })
-        }
-        is TreeNodeData.NewSession -> listOf(
-            buildOpenWithGroup(data.projectPath, data.projectName, resumeSessionId = null, label = "Open With (fresh)"),
-            act("New Session… (pick agent)", AllIcons.General.Add) { promptAgentAndLaunch(data.projectPath, data.projectName, resumeSessionId = null) },
-        )
-        else -> emptyList()
-    }
-
-    /** Submenu listing each cached agent — clicking one launches with the given resume mode. */
-    private fun buildOpenWithGroup(projectPath: String, projectName: String, resumeSessionId: String?, label: String): DefaultActionGroup {
-        val group = DefaultActionGroup(label, true)
-        group.isPopup = true
-        val ags = agentsCache
-        if (ags.isEmpty()) {
-            group.add(act("(loading agents — try again)", null) {})
-        } else {
-            for ((id, name, type) in ags) {
-                val item = if (type != null) "$name  ($type)" else name
-                group.add(act(item, null) { launchAgent(projectPath, projectName, id, name, resumeSessionId) })
-            }
-        }
-        return group
-    }
-
-    /** Resume a specific claude session — picks the first claude-type agent automatically. */
-    private fun resumeClaudeSession(s: TreeNodeData.ClaudeSession) {
-        runBg(project, "Resuming ${s.sessionId.take(8)}") {
-            val ar = ForgeClient.get().request("/api/agents")
-            val agents = ar.data?.asJsonObject?.getAsJsonArray("agents")?.toList()?.map { it.asJsonObject } ?: emptyList()
-            val claude = agents.firstOrNull {
-                val t = it.get("type")?.asString ?: it.get("cliType")?.asString
-                t == "claude-code"
-            } ?: agents.firstOrNull { it.get("id")?.asString?.startsWith("claude") == true }
-            if (claude == null) {
-                ApplicationManager.getApplication().invokeLater {
-                    notify(project, "Forge: no claude agent configured — open New Session… to pick another agent.", com.intellij.notification.NotificationType.WARNING)
-                }
-                return@runBg
-            }
-            launchAgent(s.projectPath, s.projectName,
-                agentId = claude.get("id").asString,
-                agentName = claude.get("name")?.asString ?: "claude",
-                resumeSessionId = s.sessionId)
-        }
-    }
-
-    /** Show an agent picker, then launch with the given resume mode. */
-    private fun promptAgentAndLaunch(projectPath: String, projectName: String, resumeSessionId: String?) {
-        runBg(project, "Loading agents") {
-            val ar = ForgeClient.get().request("/api/agents")
-            if (!ar.ok || ar.data == null || !ar.data.isJsonObject) {
-                ApplicationManager.getApplication().invokeLater {
-                    notify(project, "Forge: failed to load agents — ${ar.error ?: "unknown"}", com.intellij.notification.NotificationType.ERROR)
-                }
-                return@runBg
-            }
-            val agents = ar.data.asJsonObject.getAsJsonArray("agents")?.toList()?.mapNotNull { el ->
-                val o = el.asJsonObject
-                if (o.get("enabled")?.asBoolean == false) return@mapNotNull null
-                val id = o.get("id")?.asString ?: return@mapNotNull null
-                val name = o.get("name")?.asString ?: id
-                Triple(id, name, o.get("cliType")?.asString)
-            }.orEmpty()
-            if (agents.isEmpty()) {
-                ApplicationManager.getApplication().invokeLater {
-                    notify(project, "Forge: no enabled agents — configure one in the Forge web UI.", com.intellij.notification.NotificationType.WARNING)
-                }
-                return@runBg
-            }
-            ApplicationManager.getApplication().invokeLater {
-                val labels = agents.map { (_, name, type) -> if (type != null) "$name  ($type)" else name }.toTypedArray()
-                val choice = Messages.showEditableChooseDialog(
-                    "Choose an agent to launch in $projectName",
-                    if (resumeSessionId != null) "Forge: Resume With Agent" else "Forge: New Session",
-                    null, labels, labels[0], null,
-                ) ?: return@invokeLater
-                val idx = labels.indexOf(choice).let { if (it < 0) agents.indexOfFirst { (_, n, _) -> n == choice } else it }
-                if (idx < 0) return@invokeLater
-                val (agentId, agentName, _) = agents[idx]
-                launchAgent(projectPath, projectName, agentId, agentName, resumeSessionId)
-            }
-        }
-    }
-
-    /** Resolve the agent's CLI command + env, build an argv, and spawn it directly
-     *  as the pty process — no intermediate shell, so the user sees the agent's UI
-     *  immediately with no leftover prompt fragments. */
-    private fun launchAgent(projectPath: String, projectName: String, agentId: String, agentName: String, resumeSessionId: String?) {
-        runBg(project, "Launching $agentName") {
-            val rr = ForgeClient.get().request("/api/agents?resolve=${URLEncoder.encode(agentId, "UTF-8")}")
-            val resolved = rr.data?.asJsonObject
-            if (!rr.ok || resolved == null) {
-                ApplicationManager.getApplication().invokeLater {
-                    notify(project, "Forge: cannot resolve $agentName — ${rr.error ?: "unknown"}", com.intellij.notification.NotificationType.ERROR)
-                }
-                return@runBg
-            }
-            val cliCmd = resolved.get("cliCmd")?.asString ?: agentId
-            val supportsSession = resolved.get("supportsSession")?.asBoolean == true
-            val cliType = resolved.get("cliType")?.asString
-            // For claude, the API returns `-c` which is `--continue` (zero-arg) — passing a
-            // session id after `-c` makes claude treat the id as initial prompt text and
-            // resume the *most recent* session instead. Force `--resume` for specific-session
-            // launches; this matches what forge's web UI does (see WebTerminal.tsx).
-            val resumeFlag = if (cliType == "claude-code" && !resumeSessionId.isNullOrBlank()) {
-                "--resume"
-            } else {
-                resolved.get("resumeFlag")?.asString ?: "--resume"
-            }
-            val envObj = resolved.getAsJsonObject("env")
-            val envMap = mutableMapOf<String, String>()
-            envObj?.entrySet()?.forEach { (k, v) -> if (!v.isJsonNull) envMap[k] = v.asString }
-
-            // The resolve endpoint returns `model` separately from `env`. For claude this
-            // becomes `--model <name>`; without it the agent silently falls back to claude's
-            // default (opus), so a "sonnet" profile would appear to do nothing.
-            val model = resolved.get("model")?.takeUnless { it.isJsonNull }?.asString
-            val modelFlag = if (cliType == "claude-code" && !model.isNullOrBlank()) {
-                " --model " + shellQuote(model)
-            } else ""
-
-            val cmdLine = buildString {
-                append(cliCmd)
-                if (supportsSession && !resumeSessionId.isNullOrBlank()) {
-                    append(' ').append(resumeFlag).append(' ').append(shellQuote(resumeSessionId))
-                }
-                append(modelFlag)
-            }
-            // Use the user's login shell so .zprofile/.bash_profile gets sourced — IDEA's
-            // inherited PATH usually misses /opt/homebrew/bin, ~/.claude/local, etc. where
-            // CLI agents actually live. `exec` makes the shell hand off the pty to the agent
-            // so when the agent quits the tab closes; if exec fails (cmd not in PATH) we
-            // fall through to a diagnostic so the error stays visible.
-            val userShell = System.getenv("SHELL")?.takeIf { it.isNotBlank() } ?: "/bin/zsh"
-            val script = """
-                exec $cmdLine
-                echo
-                echo "[forge: failed to launch — '$cliCmd' not found in PATH]"
-                echo "[forge: PATH=${'$'}PATH]"
-                echo
-                echo "(this terminal will close in 30s)"
-                sleep 30
-            """.trimIndent()
-            val shellCmd = listOf(userShell, "-l", "-c", script)
-
-            ApplicationManager.getApplication().invokeLater {
-                spawnInTerminalTab(projectPath, "forge: $projectName ($agentName)", shellCmd, envMap)
-            }
-        }
-    }
-
-    /** Spawn `shellCmd` as the pty's primary process by intercepting
-     *  [LocalTerminalDirectRunner.configureStartupOptions]. */
-    private fun spawnInTerminalTab(workingDir: String, tabName: String, shellCmd: List<String>, extraEnv: Map<String, String>) {
-        val runner = object : LocalTerminalDirectRunner(project) {
-            // Skip RC-file injection / command markers — our pty process isn't a shell.
-            override fun enableShellIntegration(): Boolean = false
-
-            override fun configureStartupOptions(baseOptions: ShellStartupOptions): ShellStartupOptions {
-                val mergedEnv = HashMap<String, String>().apply {
-                    baseOptions.envVariables?.let { putAll(it) }
-                    putAll(extraEnv)
-                    putIfAbsent("TERM", "xterm-256color")
-                }
-                return baseOptions.builder()
-                    .shellCommand(shellCmd)
-                    .workingDirectory(baseOptions.workingDirectory ?: workingDir)
-                    .envVariables(mergedEnv)
-                    .build()
-            }
-
-            override fun getDefaultTabTitle(): String = tabName
-        }
-        val state = TerminalTabState().apply {
-            myTabName = tabName
-            myWorkingDirectory = workingDir
-        }
-        TerminalToolWindowManager.getInstance(project).createNewSession(runner, state)
-    }
-
-    private fun openPlainTerminal(projectPath: String, projectName: String) {
-        TerminalToolWindowManager.getInstance(project)
-            .createShellWidget(projectPath, "forge: $projectName", false, true)
-    }
-
-    private fun bindSession(s: TreeNodeData.ClaudeSession) {
-        runApi(project, "Pin ${s.sessionId.take(8)}", {
-            ForgeClient.get().request(
-                "/api/project-sessions",
-                method = "POST",
-                body = mapOf("projectPath" to s.projectPath, "fixedSessionId" to s.sessionId),
-            )
-        }) { refresh() }
-    }
-
-    private fun shellQuote(s: String): String = "'" + s.replace("'", "'\\''") + "'"
-
-    private fun act(name: String, icon: javax.swing.Icon?, run: () -> Unit) = object : AnAction(name, null, icon) {
-        override fun actionPerformed(e: AnActionEvent) = run()
-    }
-}

package/intellij-plugin/src/main/kotlin/com/aion0/forge/ui/toolwindow/TreeNodeData.kt

@@ -1,33 +0,0 @@
-package com.aion0.forge.ui.toolwindow
-
-/** Typed payloads attached to DefaultMutableTreeNode.userObject so click /
- *  right-click handlers can branch on what was clicked. The `label` is what
- *  ends up rendered (we just call .toString()). */
-sealed class TreeNodeData(val label: String) {
-    override fun toString(): String = label
-
-    // ── Workspaces tab ─────────────────────────────────────
-    class Workspace(label: String, val workspaceId: String, val projectName: String, val daemonActive: Boolean) : TreeNodeData(label)
-    class Smith(label: String, val workspaceId: String, val agentId: String, val agentLabel: String, val taskStatus: String, val paused: Boolean, val tmuxSession: String?) : TreeNodeData(label)
-    // ── Terminals tab ──────────────────────────────────────
-    /** A forge project (from /api/projects). Expand → list of sessions; right-click → new terminal. */
-    class LocalProject(label: String, val projectPath: String, val projectName: String) : TreeNodeData(label)
-    /** A claude session belonging to a project. Double-click → resume in IDE terminal. */
-    class ClaudeSession(label: String, val projectPath: String, val projectName: String, val sessionId: String, val isBound: Boolean) : TreeNodeData(label)
-    /** "+ New session…" leaf shown under each project. */
-    class NewSession(label: String, val projectPath: String, val projectName: String) : TreeNodeData(label)
-
-    // ── Pipelines tab ──────────────────────────────────────
-    class PipelineProject(label: String, val projectPath: String, val projectName: String) : TreeNodeData(label)
-    class PipelineBinding(label: String, val projectPath: String, val projectName: String, val workflowName: String, val enabled: Boolean) : TreeNodeData(label)
-    class PipelineRun(label: String, val pipelineId: String, val workflowName: String, val status: String) : TreeNodeData(label)
-    class PipelineNode(label: String, val pipelineId: String, val nodeName: String, val status: String, val error: String?, val taskId: String?) : TreeNodeData(label)
-
-    // ── Docs tab ───────────────────────────────────────────
-    class DocRoot(label: String, val rootIdx: Int, val rootPath: String, val rootName: String) : TreeNodeData(label)
-    class DocDir(label: String, val rootIdx: Int, val rootPath: String, val relPath: String) : TreeNodeData(label)
-    class DocFile(label: String, val rootIdx: Int, val rootPath: String, val relPath: String, val fileType: String?) : TreeNodeData(label)
-
-    // ── Misc ───────────────────────────────────────────────
-    class Hint(label: String) : TreeNodeData(label)
-}