@aion0/forge 0.5.44 → 0.5.46

package/intellij-plugin/src/main/kotlin/com/aion0/forge/settings/ForgeConfigurable.kt

@@ -1,81 +0,0 @@
-package com.aion0.forge.settings
-
-import com.aion0.forge.connection.ConnectionManager
-import com.aion0.forge.connection.ForgeConnection
-import com.intellij.openapi.options.Configurable
-import com.intellij.ui.ToolbarDecorator
-import com.intellij.ui.table.JBTable
-import javax.swing.JComponent
-import javax.swing.JPanel
-import javax.swing.JTextField
-import javax.swing.table.DefaultTableModel
-
-/** "Tools → Forge" preferences pane: edit the list of connections and pick the
- *  active one. Tokens are stored separately in PasswordSafe (cleared via the
- *  Forge: Logout action). */
-class ForgeConfigurable : Configurable {
-    private lateinit var rootPanel: JPanel
-    private lateinit var activeNameField: JTextField
-    private lateinit var tableModel: DefaultTableModel
-    private lateinit var table: JBTable
-
-    override fun getDisplayName(): String = "Forge"
-
-    override fun createComponent(): JComponent {
-        tableModel = object : DefaultTableModel(arrayOf("Name", "Server URL", "Terminal URL"), 0) {
-            override fun isCellEditable(row: Int, col: Int) = true
-        }
-        table = JBTable(tableModel)
-
-        for (c in ConnectionManager.get().list()) {
-            tableModel.addRow(arrayOf(c.name, c.serverUrl, c.terminalUrl))
-        }
-
-        val tableWithToolbar = ToolbarDecorator.createDecorator(table)
-            .setAddAction { tableModel.addRow(arrayOf("New", "http://localhost:8403", "ws://localhost:8404")) }
-            .setRemoveAction {
-                val sel = table.selectedRow
-                if (sel >= 0 && tableModel.rowCount > 1) tableModel.removeRow(sel)
-            }
-            .createPanel()
-
-        activeNameField = JTextField(ConnectionManager.get().active().name)
-
-        rootPanel = JPanel().apply {
-            layout = javax.swing.BoxLayout(this, javax.swing.BoxLayout.Y_AXIS)
-            add(javax.swing.JLabel("Active connection name:"))
-            add(activeNameField)
-            add(javax.swing.Box.createVerticalStrut(8))
-            add(javax.swing.JLabel("Saved connections:"))
-            add(tableWithToolbar)
-        }
-        return rootPanel
-    }
-
-    override fun isModified(): Boolean {
-        val current = collectFromTable()
-        return current != ConnectionManager.get().list() ||
-            activeNameField.text != ConnectionManager.get().active().name
-    }
-
-    override fun apply() {
-        val list = collectFromTable()
-        ConnectionManager.get().replaceAll(list, activeNameField.text.trim())
-    }
-
-    override fun reset() {
-        tableModel.rowCount = 0
-        for (c in ConnectionManager.get().list()) {
-            tableModel.addRow(arrayOf(c.name, c.serverUrl, c.terminalUrl))
-        }
-        activeNameField.text = ConnectionManager.get().active().name
-    }
-
-    private fun collectFromTable(): List<ForgeConnection> = (0 until tableModel.rowCount).map { i ->
-        ForgeConnection(
-            name = (tableModel.getValueAt(i, 0) ?: "").toString().trim(),
-            serverUrl = (tableModel.getValueAt(i, 1) ?: "").toString().trim(),
-            terminalUrl = (tableModel.getValueAt(i, 2) ?: "").toString().trim(),
-        )
-    }.filter { it.name.isNotEmpty() }
-}

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

@@ -1,99 +0,0 @@
-package com.aion0.forge.ui.toolwindow
-
-import com.aion0.forge.api.ForgeClient
-import com.google.gson.JsonElement
-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.vfs.LocalFileSystem
-import org.jetbrains.plugins.terminal.TerminalView
-import java.io.File
-import javax.swing.tree.DefaultMutableTreeNode
-
-class DocsView(project: Project) : ForgeTreeView(project) {
-
-    override fun rootLabel() = "docs"
-
-    override fun reload(): List<DefaultMutableTreeNode> {
-        val r = ForgeClient.get().request("/api/docs")
-        if (r.status == 401 || r.status == 403) return listOf(DefaultMutableTreeNode(TreeNodeData.Hint("🔑 Tools → Forge: Login")))
-        if (!r.ok || r.data == null || !r.data.isJsonObject) {
-            return listOf(DefaultMutableTreeNode(TreeNodeData.Hint("⚠ ${r.error ?: "Not connected"}")))
-        }
-        val roots = r.data.asJsonObject.getAsJsonArray("roots") ?: return listOf(DefaultMutableTreeNode(TreeNodeData.Hint("No doc roots — add one in forge Settings → Doc Roots")))
-        val rootPaths = r.data.asJsonObject.getAsJsonArray("rootPaths")
-        if (roots.size() == 0) return listOf(DefaultMutableTreeNode(TreeNodeData.Hint("No doc roots")))
-
-        return (0 until roots.size()).map { i ->
-            val rootName = roots[i].asString
-            val rootPath = rootPaths?.get(i)?.asString ?: rootName
-            val node = DefaultMutableTreeNode(TreeNodeData.DocRoot("📚 $rootName", i, rootPath, rootName))
-            val sub = ForgeClient.get().request("/api/docs?root=$i")
-            sub.data?.asJsonObject?.getAsJsonArray("tree")?.forEach { addChildNode(node, it, i, rootPath) }
-            node
-        }
-    }
-
-    private fun addChildNode(parent: DefaultMutableTreeNode, el: JsonElement, rootIdx: Int, rootPath: String) {
-        val obj = el.asJsonObject
-        val name = obj.get("name")?.asString ?: "?"
-        val type = obj.get("type")?.asString ?: "file"
-        val relPath = obj.get("path")?.asString ?: name
-        val fileType = obj.get("fileType")?.asString
-        val emoji = when {
-            type == "dir"        -> "📁"
-            fileType == "md"     -> "📄"
-            fileType == "image"  -> "🖼"
-            else                 -> "📑"
-        }
-        val data = if (type == "dir") TreeNodeData.DocDir("$emoji $name", rootIdx, rootPath, relPath)
-                   else               TreeNodeData.DocFile("$emoji $name", rootIdx, rootPath, relPath, fileType)
-        val node = DefaultMutableTreeNode(data)
-        if (type == "dir") obj.getAsJsonArray("children")?.forEach { addChildNode(node, it, rootIdx, rootPath) }
-        parent.add(node)
-    }
-
-    override fun onDoubleClick(data: TreeNodeData, node: DefaultMutableTreeNode) {
-        when (data) {
-            is TreeNodeData.DocFile -> openFile(data)
-            else -> {}
-        }
-    }
-
-    override fun contextActions(data: TreeNodeData, node: DefaultMutableTreeNode): List<AnAction> = when (data) {
-        is TreeNodeData.DocRoot -> listOf(
-            act("Open Terminal Here", AllIcons.Debugger.Console) { openTerminalAt(data.rootPath) },
-        )
-        is TreeNodeData.DocDir -> listOf(
-            act("Open Terminal Here", AllIcons.Debugger.Console) { openTerminalAt("${data.rootPath}/${data.relPath}") },
-        )
-        is TreeNodeData.DocFile -> listOf(
-            act("Open", AllIcons.Actions.Edit) { openFile(data) },
-        )
-        else -> emptyList()
-    }
-
-    /** Open the file via the local filesystem (forge is local-by-default —
-     *  remote forges would need an HTTP-backed VFS, deferred). */
-    private fun openFile(f: TreeNodeData.DocFile) {
-        val abs = File(f.rootPath, f.relPath)
-        if (!abs.isFile) {
-            notify(project, "Forge: file not found locally — ${abs.absolutePath} (remote forge support TBD)", com.intellij.notification.NotificationType.WARNING)
-            return
-        }
-        val vf = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(abs) ?: return
-        FileEditorManager.getInstance(project).openFile(vf, true)
-    }
-
-    private fun openTerminalAt(absDir: String) {
-        val terminalView = TerminalView.getInstance(project)
-        val widget = terminalView.createLocalShellWidget(absDir, "forge: ${File(absDir).name}")
-        widget.executeCommand("claude --dangerously-skip-permissions")
-    }
-
-    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/ForgeStatusBarWidgetFactory.kt

@@ -1,94 +0,0 @@
-package com.aion0.forge.ui.toolwindow
-
-import com.aion0.forge.api.ForgeClient
-import com.aion0.forge.auth.Auth
-import com.aion0.forge.connection.ConnectionListener
-import com.aion0.forge.connection.ConnectionManager
-import com.aion0.forge.connection.ForgeConnection
-import com.intellij.openapi.actionSystem.ActionManager
-import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.wm.StatusBar
-import com.intellij.openapi.wm.StatusBarWidget
-import com.intellij.openapi.wm.StatusBarWidgetFactory
-import com.intellij.util.Alarm
-import java.awt.event.MouseEvent
-import javax.swing.Timer
-
-class ForgeStatusBarWidgetFactory : StatusBarWidgetFactory {
-    override fun getId(): String = "com.aion0.forge.statusbar"
-    override fun getDisplayName(): String = "Forge"
-    override fun isAvailable(project: Project): Boolean = true
-    override fun createWidget(project: Project): StatusBarWidget = ForgeStatusBarWidget(project)
-    override fun disposeWidget(widget: StatusBarWidget) {}
-    override fun canBeEnabledOn(statusBar: StatusBar): Boolean = true
-}
-
-class ForgeStatusBarWidget(private val project: Project) : StatusBarWidget,
-    StatusBarWidget.TextPresentation {
-
-    private var statusBar: StatusBar? = null
-    // `this` is a Disposable (StatusBarWidget extends Disposable). The Alarm
-    // requires a parent Disposable for non-Swing threads — registering with
-    // ourselves means the Alarm is auto-disposed when the widget goes away.
-    private val alarm: Alarm by lazy { Alarm(Alarm.ThreadToUse.POOLED_THREAD, this) }
-    private var lastText: String = "Forge: …"
-    private var lastTooltip: String = "Forge"
-    private var pollTimer: Timer? = null
-
-    override fun ID(): String = "com.aion0.forge.statusbar"
-    override fun getPresentation(): StatusBarWidget.WidgetPresentation = this
-
-    override fun install(statusBar: StatusBar) {
-        this.statusBar = statusBar
-        // Refresh on connection change.
-        ApplicationManager.getApplication().messageBus.connect()
-            .subscribe(ConnectionListener.TOPIC, object : ConnectionListener {
-                override fun onConnectionChanged(active: ForgeConnection) = scheduleRefresh()
-            })
-        scheduleRefresh()
-        // Periodic poll so connectivity changes (server up/down) reflect.
-        pollTimer = Timer(5_000) { scheduleRefresh() }.apply { start() }
-    }
-
-    override fun dispose() {
-        pollTimer?.stop()
-        pollTimer = null
-        // alarm is disposed automatically (we passed `this` as parent).
-    }
-
-    override fun getText(): String = lastText
-    override fun getTooltipText(): String = lastTooltip
-    override fun getAlignment(): Float = 0f
-
-    override fun getClickConsumer(): com.intellij.util.Consumer<MouseEvent>? =
-        com.intellij.util.Consumer { _ ->
-            // Click → run "Switch Connection" action.
-            val action = ActionManager.getInstance().getAction("com.aion0.forge.action.SwitchConnectionAction")
-            ActionManager.getInstance().tryToExecute(action, null, null, "Forge", true)
-        }
-
-    private fun scheduleRefresh() {
-        alarm.cancelAllRequests()
-        alarm.addRequest({
-            val conn = ConnectionManager.get().active()
-            val reachable = ForgeClient.get().ping()
-            val token = Auth.get().getToken(conn.name)
-            val text = when {
-                !reachable     -> "Forge ⊘ ${conn.name}"
-                token.isNullOrBlank() -> "Forge ⚠ ${conn.name}"
-                else           -> "Forge ⚡ ${conn.name}"
-            }
-            val tooltip = when {
-                !reachable     -> "${conn.name} — server unreachable (${conn.serverUrl})"
-                token.isNullOrBlank() -> "${conn.name} — login required"
-                else           -> "${conn.name} — connected (${conn.serverUrl})"
-            }
-            ApplicationManager.getApplication().invokeLater {
-                lastText = text
-                lastTooltip = tooltip
-                statusBar?.updateWidget(ID())
-            }
-        }, 100)
-    }
-}

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

@@ -1,27 +0,0 @@
-package com.aion0.forge.ui.toolwindow
-
-import com.intellij.openapi.project.DumbAware
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.util.Disposer
-import com.intellij.openapi.wm.ToolWindow
-import com.intellij.openapi.wm.ToolWindowFactory
-import com.intellij.ui.content.Content
-import com.intellij.ui.content.ContentFactory
-
-class ForgeToolWindowFactory : ToolWindowFactory, DumbAware {
-    override fun createToolWindowContent(project: Project, toolWindow: ToolWindow) {
-        val cf = ContentFactory.getInstance()
-        addView(toolWindow, cf, "Workspaces", WorkspacesView(project))
-        addView(toolWindow, cf, "Terminals",  TerminalsView(project))
-        addView(toolWindow, cf, "Pipelines",  PipelinesView(project))
-        addView(toolWindow, cf, "Docs",       DocsView(project))
-    }
-
-    private fun addView(tw: ToolWindow, cf: ContentFactory, name: String, view: ForgeTreeView) {
-        val content: Content = cf.createContent(view.component(), name, false)
-        // Tie the view's lifecycle to the tab content so background polling
-        // stops when the user closes the tool window.
-        Disposer.register(content, view)
-        tw.contentManager.addContent(content)
-    }
-}

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

@@ -1,176 +0,0 @@
-package com.aion0.forge.ui.toolwindow
-
-import com.aion0.forge.connection.ConnectionListener
-import com.aion0.forge.connection.ForgeConnection
-import com.intellij.openapi.Disposable
-import com.intellij.openapi.actionSystem.ActionManager
-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.util.Disposer
-import com.intellij.ui.PopupHandler
-import com.intellij.ui.ScrollPaneFactory
-import com.intellij.ui.treeStructure.Tree
-import com.intellij.util.Alarm
-import java.awt.BorderLayout
-import java.awt.event.MouseAdapter
-import java.awt.event.MouseEvent
-import javax.swing.JPanel
-import javax.swing.tree.DefaultMutableTreeNode
-import javax.swing.tree.DefaultTreeModel
-import javax.swing.tree.TreePath
-
-/**
- * Common boilerplate for the four Forge tool-window tabs.
- *
- *   - Tree component wrapped in a scroll pane
- *   - Toolbar with a refresh button
- *   - Auto-refresh every 5 s
- *   - Refresh on active-connection change
- *
- * Subclasses override [reload] to populate the [root] node and [refreshUi].
- */
-abstract class ForgeTreeView(protected val project: Project) : Disposable {
-    protected val root: DefaultMutableTreeNode = DefaultMutableTreeNode(rootLabel())
-    protected val treeModel = DefaultTreeModel(root)
-    protected val tree = Tree(treeModel).apply {
-        isRootVisible = false
-        showsRootHandles = true
-    }
-    private val alarm = Alarm(Alarm.ThreadToUse.POOLED_THREAD, this)
-
-    /** Build the panel — wrap toolbar + tree in a JPanel. */
-    fun component(): JPanel {
-        val panel = JPanel(BorderLayout())
-        // Toolbar
-        val actions = DefaultActionGroup().apply {
-            add(RefreshAction())
-            toolbarActions(this)
-        }
-        val toolbar = ActionManager.getInstance().createActionToolbar("ForgeView", actions, true)
-        toolbar.targetComponent = tree
-        panel.add(toolbar.component, BorderLayout.NORTH)
-        // Tree
-        panel.add(ScrollPaneFactory.createScrollPane(tree), BorderLayout.CENTER)
-        // Click + right-click handlers — subclasses override.
-        tree.addMouseListener(object : MouseAdapter() {
-            override fun mouseClicked(e: MouseEvent) {
-                if (e.clickCount == 2 && !e.isPopupTrigger) {
-                    val path = tree.getPathForLocation(e.x, e.y) ?: return
-                    val node = path.lastPathComponent as? DefaultMutableTreeNode ?: return
-                    val data = node.userObject as? TreeNodeData ?: return
-                    onDoubleClick(data, node)
-                }
-            }
-        })
-        PopupHandler.installPopupMenu(tree, object : DefaultActionGroup() {
-            override fun getChildren(e: AnActionEvent?): Array<AnAction> {
-                val node = selectedNode() ?: return emptyArray()
-                val data = node.userObject as? TreeNodeData ?: return emptyArray()
-                return contextActions(data, node).toTypedArray()
-            }
-        }, "ForgeViewPopup")
-
-        // Listen for connection changes → reload.
-        ApplicationManager.getApplication().messageBus.connect(this)
-            .subscribe(ConnectionListener.TOPIC, object : ConnectionListener {
-                override fun onConnectionChanged(active: ForgeConnection) = scheduleReload()
-            })
-
-        scheduleReload()
-        // Periodic 5s refresh.
-        startPolling()
-        return panel
-    }
-
-    private fun startPolling() {
-        // Tail-recursive scheduling so we always wait 5s after each completion.
-        if (!Disposer.isDisposed(this)) {
-            alarm.addRequest({
-                doReloadAsync()
-                startPolling()
-            }, 5_000)
-        }
-    }
-
-    private fun scheduleReload() {
-        alarm.cancelAllRequests()
-        alarm.addRequest({ doReloadAsync() }, 50)
-    }
-
-    private fun doReloadAsync() {
-        val newChildren = runCatching { reload() }.getOrElse {
-            listOf(DefaultMutableTreeNode("⚠ ${it.message ?: "error"}"))
-        }
-        ApplicationManager.getApplication().invokeLater {
-            // Snapshot the userObject-string path of every expanded node so we can
-            // re-expand them after the tree is rebuilt — otherwise the 5s poll
-            // collapses anything the user opened (Docs subfolders, Pipeline runs, …).
-            val expanded = collectExpandedPaths()
-            root.removeAllChildren()
-            for (n in newChildren) root.add(n)
-            treeModel.reload(root)
-            reExpand(expanded)
-            // Continue polling unless we've been disposed.
-            if (Disposer.isDisposed(this)) alarm.cancelAllRequests()
-        }
-    }
-
-    /** Path identity of every expanded node, keyed by the chain of userObject
-     *  toStrings from root → leaf (root itself excluded). */
-    private fun collectExpandedPaths(): Set<List<String>> {
-        val out = mutableSetOf<List<String>>()
-        val descendants = tree.getExpandedDescendants(TreePath(root.path)) ?: return out
-        while (descendants.hasMoreElements()) {
-            val tp = descendants.nextElement()
-            val parts = tp.path
-            if (parts.size <= 1) continue
-            out.add((1 until parts.size).map { (parts[it] as DefaultMutableTreeNode).userObject?.toString().orEmpty() })
-        }
-        return out
-    }
-
-    private fun reExpand(expanded: Set<List<String>>) {
-        if (expanded.isEmpty()) return
-        fun visit(node: DefaultMutableTreeNode, prefix: List<String>) {
-            for (i in 0 until node.childCount) {
-                val child = node.getChildAt(i) as DefaultMutableTreeNode
-                val key = prefix + (child.userObject?.toString().orEmpty())
-                if (key in expanded) tree.expandPath(TreePath(child.path))
-                visit(child, key)
-            }
-        }
-        visit(root, emptyList())
-    }
-
-    /** Build the children of the synthetic root (top-level rows the user sees). */
-    protected abstract fun reload(): List<DefaultMutableTreeNode>
-
-    /** Override to add view-specific buttons to the toolbar (after Refresh). */
-    protected open fun toolbarActions(group: DefaultActionGroup) {}
-
-    /** Override to handle a left double-click on a typed tree node. */
-    protected open fun onDoubleClick(data: TreeNodeData, node: DefaultMutableTreeNode) {}
-
-    /** Override to add right-click menu items for a typed tree node. */
-    protected open fun contextActions(data: TreeNodeData, node: DefaultMutableTreeNode): List<AnAction> = emptyList()
-
-    /** Label for the hidden synthetic root — never shown but useful as a key. */
-    protected open fun rootLabel(): String = "ROOT"
-
-    /** Trigger a refresh from subclasses (e.g. after running an action). */
-    fun refresh() = scheduleReload()
-
-    protected fun selectedNode(): DefaultMutableTreeNode? =
-        tree.lastSelectedPathComponent as? DefaultMutableTreeNode
-
-    override fun dispose() {
-        alarm.cancelAllRequests()
-    }
-
-    private inner class RefreshAction : AnAction("Refresh", "Refresh from Forge", com.intellij.icons.AllIcons.Actions.Refresh) {
-        override fun actionPerformed(e: AnActionEvent) = scheduleReload()
-    }
-}

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

@@ -1,48 +0,0 @@
-package com.aion0.forge.ui.toolwindow
-
-import com.aion0.forge.api.ApiResult
-import com.aion0.forge.api.ForgeClient
-import com.intellij.notification.NotificationGroupManager
-import com.intellij.notification.NotificationType
-import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.progress.ProgressIndicator
-import com.intellij.openapi.progress.ProgressManager
-import com.intellij.openapi.progress.Task
-import com.intellij.openapi.project.Project
-
-internal fun notify(project: Project?, message: String, type: NotificationType = NotificationType.INFORMATION) {
-    NotificationGroupManager.getInstance().getNotificationGroup("Forge")
-        .createNotification(message, type)
-        .notify(project)
-}
-
-internal fun runBg(project: Project?, title: String, work: () -> Unit) {
-    ProgressManager.getInstance().run(object : Task.Backgroundable(project, title, false) {
-        override fun run(indicator: ProgressIndicator) { work() }
-    })
-}
-
-/** Convenience: run an API call on a bg thread, then show a success/failure
- *  notification on EDT, then call onSuccess (used to trigger view refreshes). */
-internal fun runApi(project: Project?, title: String, call: () -> ApiResult, onSuccess: () -> Unit = {}) {
-    runBg(project, title) {
-        val res = call()
-        ApplicationManager.getApplication().invokeLater {
-            if (res.ok) {
-                notify(project, "Forge: $title — ok")
-                onSuccess()
-            } else {
-                notify(project, "Forge: $title failed — ${res.error}", NotificationType.ERROR)
-            }
-        }
-    }
-}
-
-/** WS action against the workspace daemon: POST /api/workspace/<id>/agents
- *  with `{action, agentId, ...}`. */
-internal fun wsAction(workspaceId: String, action: String, body: Map<String, Any> = emptyMap()): ApiResult =
-    ForgeClient.get().request(
-        "/api/workspace/$workspaceId/agents",
-        method = "POST",
-        body = mapOf("action" to action) + body,
-    )