stella-coder 5.2.0 → 5.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stella-coder",
-  "version": "5.2.0",
+  "version": "5.2.1",
   "private": false,
   "description": "Stella Coder 5.0 — AI coding agent with Telegram bot, huge context, TDD, Git ecosystem, presentations, computer control, smart home, Office automation, and antivirus",
   "main": "stella-cli/index.mjs",
@@ -36,6 +36,7 @@
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "gsap": "^3.15.0",
+    "jsdom": "^29.1.1",
     "lucide-react": "^1.16.0",
     "next": "16.2.6",
     "react": "^19",

package/stella-cli/browser-control.mjs

@@ -0,0 +1,274 @@
+import { execSync, spawn } from "child_process"
+import { writeFileSync, existsSync, mkdirSync } from "fs"
+import { join } from "path"
+import { homedir } from "os"
+import http from "http"
+
+const STELLA_DIR = join(homedir(), ".stella")
+const BROWSER_DIR = join(STELLA_DIR, "browser")
+const PROFILES_DIR = join(BROWSER_DIR, "profiles")
+
+function ensureDir() {
+  if (!existsSync(BROWSER_DIR)) mkdirSync(BROWSER_DIR, { recursive: true })
+  if (!existsSync(PROFILES_DIR)) mkdirSync(PROFILES_DIR, { recursive: true })
+}
+
+function httpGet(url) {
+  return new Promise((resolve, reject) => {
+    http.get(url, (res) => {
+      let data = ""
+      res.on("data", (chunk) => data += chunk)
+      res.on("end", () => {
+        try { resolve(JSON.parse(data)) } catch { resolve(data) }
+      })
+    }).on("error", reject)
+  })
+}
+
+export class ChromeBrowser {
+  constructor() {
+    ensureDir()
+    this.ws = null
+    this.pageId = null
+    this.debugPort = 9222
+    this.proc = null
+    this.msgId = 0
+    this.callbacks = new Map()
+  }
+
+  async launch(headless = false) {
+    const chromePaths = [
+      "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+      "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+      join(homedir(), "AppData\\Local\\Google\\Chrome\\Application\\chrome.exe"),
+      "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe",
+      "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
+    ]
+
+    let chromePath = null
+    for (const p of chromePaths) {
+      if (existsSync(p)) { chromePath = p; break }
+    }
+
+    if (!chromePath) {
+      return { success: false, error: "Chrome/Edge not found" }
+    }
+
+    const args = [
+      `--remote-debugging-port=${this.debugPort}`,
+      "--no-first-run",
+      "--no-default-browser-check",
+      headless ? "--headless=new" : "",
+      `--user-data-dir=${join(PROFILES_DIR, "default")}`,
+      "about:blank",
+    ].filter(Boolean)
+
+    this.proc = spawn(chromePath, args, { detached: true, stdio: "ignore" })
+    this.proc.unref()
+
+    await new Promise(r => setTimeout(r, 2000))
+
+    try {
+      const tabs = await httpGet(`http://127.0.0.1:${this.debugPort}/json`)
+      if (tabs && tabs.length > 0) {
+        this.pageId = tabs[0].id
+        return { success: true, port: this.debugPort, pid: this.proc.pid }
+      }
+    } catch (e) {
+      return { success: false, error: `Chrome launched but DevTools not ready: ${e.message}` }
+    }
+
+    return { success: true, port: this.debugPort }
+  }
+
+  async connect() {
+    try {
+      const tabs = await httpGet(`http://127.0.0.1:${this.debugPort}/json`)
+      if (!tabs || tabs.length === 0) {
+        return { success: false, error: "No tabs found. Launch Chrome first." }
+      }
+
+      const wsUrl = tabs[0].webSocketDebuggerUrl
+      if (!wsUrl) {
+        return { success: false, error: "WebSocket URL not available" }
+      }
+
+      return new Promise((resolve) => {
+        this.ws = new WebSocket(wsUrl)
+        this.ws.onopen = () => {
+          this.pageId = tabs[0].id
+          resolve({ success: true, title: tabs[0].title })
+        }
+        this.ws.onmessage = (event) => {
+          const msg = JSON.parse(typeof event.data === "string" ? event.data : event.data.toString())
+          if (msg.id && this.callbacks.has(msg.id)) {
+            this.callbacks.get(msg.id)(msg)
+            this.callbacks.delete(msg.id)
+          }
+        }
+        this.ws.onerror = (err) => {
+          resolve({ success: false, error: err.message || "WebSocket error" })
+        }
+      })
+    } catch (e) {
+      return { success: false, error: e.message }
+    }
+  }
+
+  async sendCommand(method, params = {}) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      const conn = await this.connect()
+      if (!conn.success) return { success: false, error: conn.error }
+    }
+
+    const id = ++this.msgId
+    return new Promise((resolve) => {
+      this.callbacks.set(id, (msg) => {
+        if (msg.error) {
+          resolve({ success: false, error: msg.error.message })
+        } else {
+          resolve({ success: true, result: msg.result })
+        }
+      })
+      this.ws.send(JSON.stringify({ id, method, params }))
+      setTimeout(() => {
+        if (this.callbacks.has(id)) {
+          this.callbacks.delete(id)
+          resolve({ success: false, error: "Command timeout" })
+        }
+      }, 30000)
+    })
+  }
+
+  async navigate(url) {
+    const result = await this.sendCommand("Page.navigate", { url })
+    if (result.success) await new Promise(r => setTimeout(r, 2000))
+    return result
+  }
+
+  async getPageContent() {
+    const result = await this.sendCommand("Runtime.evaluate", {
+      expression: "document.documentElement.outerHTML",
+      returnByValue: true,
+    })
+    return result.success ? { success: true, html: result.result?.value || "" } : result
+  }
+
+  async getText() {
+    const result = await this.sendCommand("Runtime.evaluate", {
+      expression: "document.body.innerText",
+      returnByValue: true,
+    })
+    return result.success ? { success: true, text: result.result?.value || "" } : result
+  }
+
+  async getTitle() {
+    const result = await this.sendCommand("Runtime.evaluate", {
+      expression: "document.title",
+      returnByValue: true,
+    })
+    return result.success ? { success: true, title: result.result?.value || "" } : result
+  }
+
+  async screenshot(path) {
+    const result = await this.sendCommand("Page.captureScreenshot", { format: "png" })
+    if (result.success && result.result?.data) {
+      const imgPath = path || join(BROWSER_DIR, `screenshot_${Date.now()}.png`)
+      writeFileSync(imgPath, Buffer.from(result.result.data, "base64"))
+      return { success: true, path: imgPath }
+    }
+    return result
+  }
+
+  async evaluate(expression) {
+    return await this.sendCommand("Runtime.evaluate", {
+      expression,
+      returnByValue: true,
+      awaitPromise: true,
+    })
+  }
+
+  async click(selector) {
+    const posResult = await this.sendCommand("Runtime.evaluate", {
+      expression: `(() => { const el = document.querySelector('${selector.replace(/'/g, "\\'")}'); if (!el) return null; const r = el.getBoundingClientRect(); return { x: r.x + r.width/2, y: r.y + r.height/2 }; })()`,
+      returnByValue: true,
+    })
+
+    if (!posResult.success || !posResult.result?.value) {
+      return { success: false, error: `Element not found: ${selector}` }
+    }
+
+    const { x, y } = posResult.result.value
+    await this.sendCommand("Input.dispatchMouseEvent", { type: "mousePressed", x, y, button: "left", clickCount: 1 })
+    await this.sendCommand("Input.dispatchMouseEvent", { type: "mouseReleased", x, y, button: "left", clickCount: 1 })
+    return { success: true, x, y }
+  }
+
+  async type(selector, text) {
+    await this.sendCommand("Runtime.evaluate", {
+      expression: `document.querySelector('${selector.replace(/'/g, "\\'")}')?.focus()`,
+    })
+    for (const char of text) {
+      await this.sendCommand("Input.dispatchKeyEvent", { type: "keyDown", text: char, key: char })
+      await this.sendCommand("Input.dispatchKeyEvent", { type: "keyUp", key: char })
+    }
+    return { success: true }
+  }
+
+  async scroll(deltaX = 0, deltaY = 300) {
+    await this.sendCommand("Input.dispatchMouseEvent", { type: "mouseWheel", x: 400, y: 400, deltaX, deltaY })
+    return { success: true }
+  }
+
+  async pressKey(key) {
+    const keys = {
+      enter: { key: "Enter", code: "Enter", windowsVirtualKeyCode: 13 },
+      tab: { key: "Tab", code: "Tab", windowsVirtualKeyCode: 9 },
+      escape: { key: "Escape", code: "Escape", windowsVirtualKeyCode: 27 },
+      backspace: { key: "Backspace", code: "Backspace", windowsVirtualKeyCode: 8 },
+      space: { key: " ", code: "Space", windowsVirtualKeyCode: 32 },
+      arrowup: { key: "ArrowUp", code: "ArrowUp", windowsVirtualKeyCode: 38 },
+      arrowdown: { key: "ArrowDown", code: "ArrowDown", windowsVirtualKeyCode: 40 },
+    }
+    const k = keys[key.toLowerCase()] || { key, code: `Key${key.toUpperCase()}` }
+    await this.sendCommand("Input.dispatchKeyEvent", { type: "keyDown", ...k })
+    await this.sendCommand("Input.dispatchKeyEvent", { type: "keyUp", ...k })
+    return { success: true }
+  }
+
+  async fillForm(fields) {
+    const results = []
+    for (const { selector, value } of fields) {
+      results.push({ selector, ...(await this.type(selector, value)) })
+    }
+    return { success: true, results }
+  }
+
+  async getLinks() {
+    const result = await this.sendCommand("Runtime.evaluate", {
+      expression: `Array.from(document.querySelectorAll('a[href]')).map(a => ({ text: a.innerText.trim().slice(0, 100), href: a.href })).filter(a => a.text).slice(0, 50)`,
+      returnByValue: true,
+    })
+    return result.success ? { success: true, links: result.result?.value || [] } : result
+  }
+
+  async getForms() {
+    const result = await this.sendCommand("Runtime.evaluate", {
+      expression: `Array.from(document.querySelectorAll('form')).map(f => ({ action: f.action, method: f.method, inputs: Array.from(f.querySelectorAll('input,textarea,select')).map(i => ({ name: i.name, type: i.type, placeholder: i.placeholder })) }))`,
+      returnByValue: true,
+    })
+    return result.success ? { success: true, forms: result.result?.value || [] } : result
+  }
+
+  close() {
+    if (this.ws) this.ws.close()
+    if (this.proc) this.proc.kill()
+    return { success: true }
+  }
+
+  static async listTabs(port = 9222) {
+    try { return await httpGet(`http://127.0.0.1:${port}/json`) } catch { return [] }
+  }
+}
+
+export default ChromeBrowser

package/stella-cli/git-api.mjs

@@ -0,0 +1,407 @@
+import { execSync } from "child_process"
+import { readFileSync, existsSync } from "fs"
+import { join } from "path"
+import http from "http"
+import https from "https"
+
+function apiRequest(url, options = {}) {
+  return new Promise((resolve, reject) => {
+    const mod = url.startsWith("https") ? https : http
+    const urlObj = new URL(url)
+    const headers = {
+      "Accept": "application/vnd.github+json",
+      ...options.headers,
+    }
+    if (options.token) headers["Authorization"] = `Bearer ${options.token}`
+
+    const reqOptions = {
+      hostname: urlObj.hostname,
+      port: urlObj.port,
+      path: urlObj.pathname + urlObj.search,
+      method: options.method || "GET",
+      headers,
+    }
+
+    const req = mod.request(reqOptions, (res) => {
+      let data = ""
+      res.on("data", (chunk) => data += chunk)
+      res.on("end", () => {
+        try { resolve({ status: res.statusCode, data: JSON.parse(data) }) }
+        catch { resolve({ status: res.statusCode, data }) }
+      })
+    })
+    req.on("error", reject)
+    if (options.body) req.write(JSON.stringify(options.body))
+    req.end()
+  })
+}
+
+function getGitRemote() {
+  try {
+    const remote = execSync("git remote get-url origin", { encoding: "utf-8" }).trim()
+    // Parse owner/repo from URL
+    const match = remote.match(/github\.com[/:]([^/]+)\/([^/.]+)/)
+    if (match) return { provider: "github", owner: match[1], repo: match[2] }
+    const glMatch = remote.match(/gitlab\.com[/:]([^/]+)\/([^/.]+)/)
+    if (glMatch) return { provider: "gitlab", owner: glMatch[1], repo: glMatch[2] }
+    return { provider: "unknown", remote }
+  } catch {
+    return null
+  }
+}
+
+function getToken(provider) {
+  // Try environment variables
+  if (provider === "github") return process.env.GITHUB_TOKEN || process.env.GH_TOKEN
+  if (provider === "gitlab") return process.env.GITLAB_TOKEN || process.env.GL_TOKEN
+
+  // Try git credential
+  try {
+    const config = execSync("git config --get credential.helper", { encoding: "utf-8" }).trim()
+    if (config.includes("store")) {
+      const credPath = join(process.env.USERPROFILE || process.env.HOME || "", ".git-credentials")
+      if (existsSync(credPath)) {
+        const creds = readFileSync(credPath, "utf-8")
+        const match = creds.match(/https:\/\/[^:]+:([^@]+)@github\.com/)
+        if (match) return match[1]
+      }
+    }
+  } catch {}
+
+  return null
+}
+
+export class GitAPI {
+  constructor() {
+    this.info = getGitRemote()
+    this.token = this.info ? getToken(this.info.provider) : null
+  }
+
+  isConfigured() {
+    return this.info && this.info.provider !== "unknown"
+  }
+
+  hasToken() {
+    return !!this.token
+  }
+
+  // ===== ISSUES =====
+  async listIssues(state = "open", perPage = 20) {
+    if (!this.isConfigured()) return { success: false, error: "No GitHub/GitLab remote configured" }
+    const { provider, owner, repo } = this.info
+    const token = this.token
+
+    if (provider === "github") {
+      const url = `https://api.github.com/repos/${owner}/${repo}/issues?state=${state}&per_page=${perPage}`
+      const res = await apiRequest(url, { token: this.token })
+      return { success: true, issues: Array.isArray(res.data) ? res.data : [] }
+    }
+
+    if (provider === "gitlab") {
+      const encoded = encodeURIComponent(`${owner}/${repo}`)
+      const url = `https://gitlab.com/api/v4/projects/${encoded}/issues?state=${state}`
+      const res = await apiRequest(url, { token: this.token })
+      return { success: true, issues: Array.isArray(res.data) ? res.data : [] }
+    }
+
+    return { success: false, error: "Unknown provider" }
+  }
+
+  async createIssue(title, body, labels = []) {
+    if (!this.isConfigured()) return { success: false, error: "No git remote configured" }
+
+    const { provider, owner, repo } = this.info
+
+    if (provider === "github") {
+      const url = `https://api.github.com/repos/${owner}/${repo}/issues`
+      const res = await apiRequest(url, {
+        method: "POST",
+        token: this.token,
+        body: { title, body, labels },
+      })
+      return { success: res.status === 201, data: res.data, url: res.data?.html_url }
+    }
+
+    if (provider === "gitlab") {
+      const encoded = encodeURIComponent(`${owner}/${repo}`)
+      const url = `https://gitlab.com/api/v4/projects/${encoded}/issues`
+      const res = await apiRequest(url, {
+        method: "POST",
+        token: this.token,
+        body: { title, description: body, labels: labels.join(",") },
+      })
+      return { success: res.status === 201, data: res.data, url: res.data?.web_url }
+    }
+
+    return { success: false, error: "Unknown provider" }
+  }
+
+  async closeIssue(issueNumber) {
+    if (!this.isConfigured()) return { success: false, error: "No git remote configured" }
+
+    const { provider, owner, repo } = this.info
+
+    if (provider === "github") {
+      const url = `https://api.github.com/repos/${owner}/${repo}/issues/${issueNumber}`
+      const res = await apiRequest(url, {
+        method: "PATCH",
+        token: this.token,
+        body: { state: "closed" },
+      })
+      return { success: res.status === 200, data: res.data }
+    }
+
+    if (provider === "gitlab") {
+      const encoded = encodeURIComponent(`${owner}/${repo}`)
+      const url = `https://gitlab.com/api/v4/projects/${encoded}/issues/${issueNumber}`
+      const res = await apiRequest(url, {
+        method: "PUT",
+        token: this.token,
+        body: { state_event: "close" },
+      })
+      return { success: res.status === 200, data: res.data }
+    }
+
+    return { success: false, error: "Unknown provider" }
+  }
+
+  // ===== PULL REQUESTS / MERGE REQUESTS =====
+  async listPRs(state = "open") {
+    if (!this.isConfigured()) return { success: false, error: "No git remote configured" }
+
+    const { provider, owner, repo } = this.info
+
+    if (provider === "github") {
+      const url = `https://api.github.com/repos/${owner}/${repo}/pulls?state=${state}`
+      const res = await apiRequest(url, { token: this.token })
+      return { success: true, prs: Array.isArray(res.data) ? res.data : [] }
+    }
+
+    if (provider === "gitlab") {
+      const encoded = encodeURIComponent(`${owner}/${repo}`)
+      const stateMap = { open: "opened", closed: "closed", merged: "merged" }
+      const url = `https://gitlab.com/api/v4/projects/${encoded}/merge_requests?state=${stateMap[state] || state}`
+      const res = await apiRequest(url, { token: this.token })
+      return { success: true, prs: Array.isArray(res.data) ? res.data : [] }
+    }
+
+    return { success: false, error: "Unknown provider" }
+  }
+
+  async createPR(title, body, head = "main", base = "main") {
+    if (!this.isConfigured()) return { success: false, error: "No git remote configured" }
+
+    const { provider, owner, repo } = this.info
+
+    if (provider === "github") {
+      const url = `https://api.github.com/repos/${owner}/${repo}/pulls`
+      const res = await apiRequest(url, {
+        method: "POST",
+        token: this.token,
+        body: { title, body, head, base },
+      })
+      return { success: res.status === 201, data: res.data, url: res.data?.html_url }
+    }
+
+    if (provider === "gitlab") {
+      const encoded = encodeURIComponent(`${owner}/${repo}`)
+      const url = `https://gitlab.com/api/v4/projects/${encoded}/merge_requests`
+      const res = await apiRequest(url, {
+        method: "POST",
+        token: this.token,
+        body: { title, description: body, source_branch: head, target_branch: base },
+      })
+      return { success: res.status === 201, data: res.data, url: res.data?.web_url }
+    }
+
+    return { success: false, error: "Unknown provider" }
+  }
+
+  async reviewPR(prNumber, event, body) {
+    if (!this.isConfigured()) return { success: false, error: "No git remote configured" }
+
+    const { provider, owner, repo } = this.info
+
+    if (provider === "github") {
+      const url = `https://api.github.com/repos/${owner}/${repo}/pulls/${prNumber}/reviews`
+      const res = await apiRequest(url, {
+        method: "POST",
+        token: this.token,
+        body: { event, body },
+      })
+      return { success: res.status === 200 || res.status === 201, data: res.data }
+    }
+
+    if (provider === "gitlab") {
+      const encoded = encodeURIComponent(`${owner}/${repo}`)
+      const url = `https://gitlab.com/api/v4/projects/${encoded}/merge_requests/${prNumber}/approvals`
+      const res = await apiRequest(url, {
+        method: "POST",
+        token: this.token,
+      })
+      return { success: res.status === 201, data: res.data }
+    }
+
+    return { success: false, error: "Unknown provider" }
+  }
+
+  async mergePR(prNumber) {
+    if (!this.isConfigured()) return { success: false, error: "No git remote configured" }
+
+    const { provider, owner, repo } = this.info
+
+    if (provider === "github") {
+      const url = `https://api.github.com/repos/${owner}/${repo}/pulls/${prNumber}/merge`
+      const res = await apiRequest(url, {
+        method: "PUT",
+        token: this.token,
+        body: { merge_method: "squash" },
+      })
+      return { success: res.status === 200, data: res.data }
+    }
+
+    if (provider === "gitlab") {
+      const encoded = encodeURIComponent(`${owner}/${repo}`)
+      const url = `https://gitlab.com/api/v4/projects/${encoded}/merge_requests/${prNumber}/merge`
+      const res = await apiRequest(url, {
+        method: "PUT",
+        token: this.token,
+      })
+      return { success: res.status === 200, data: res.data }
+    }
+
+    return { success: false, error: "Unknown provider" }
+  }
+
+  // ===== CODE REVIEW =====
+  async getPRFiles(prNumber) {
+    if (!this.isConfigured()) return { success: false, error: "No git remote configured" }
+
+    const { provider, owner, repo } = this.info
+
+    if (provider === "github") {
+      const url = `https://api.github.com/repos/${owner}/${repo}/pulls/${prNumber}/files`
+      const res = await apiRequest(url, { token: this.token })
+      return { success: true, files: Array.isArray(res.data) ? res.data : [] }
+    }
+
+    if (provider === "gitlab") {
+      const encoded = encodeURIComponent(`${owner}/${repo}`)
+      const url = `https://gitlab.com/api/v4/projects/${encoded}/merge_requests/${prNumber}/changes`
+      const res = await apiRequest(url, { token: this.token })
+      return { success: true, files: res.data?.changes || [] }
+    }
+
+    return { success: false, error: "Unknown provider" }
+  }
+
+  async addComment(prNumber, body, filePath, position) {
+    if (!this.isConfigured()) return { success: false, error: "No git remote configured" }
+
+    const { provider, owner, repo } = this.info
+
+    if (provider === "github" && filePath && position) {
+      // Get latest commit SHA
+      const prUrl = `https://api.github.com/repos/${owner}/${repo}/pulls/${prNumber}`
+      const prRes = await apiRequest(prUrl, { token: this.token })
+      const commitId = prRes.data?.head?.sha
+
+      if (commitId) {
+        const url = `https://api.github.com/repos/${owner}/${repo}/pulls/${prNumber}/comments`
+        const res = await apiRequest(url, {
+          method: "POST",
+          token: this.token,
+          body: { body, path: filePath, position, commit_id: commitId },
+        })
+        return { success: res.status === 201, data: res.data }
+      }
+    }
+
+    // Fallback: general comment
+    return await this.reviewPR(prNumber, "COMMENT", body)
+  }
+
+  // ===== REPOS =====
+  async getRepoInfo() {
+    if (!this.isConfigured()) return { success: false, error: "No git remote configured" }
+
+    const { provider, owner, repo } = this.info
+
+    if (provider === "github") {
+      const url = `https://api.github.com/repos/${owner}/${repo}`
+      const res = await apiRequest(url, { token: this.token })
+      return { success: true, repo: res.data }
+    }
+
+    if (provider === "gitlab") {
+      const encoded = encodeURIComponent(`${owner}/${repo}`)
+      const url = `https://gitlab.com/api/v4/projects/${encoded}`
+      const res = await apiRequest(url, { token: this.token })
+      return { success: true, repo: res.data }
+    }
+
+    return { success: false, error: "Unknown provider" }
+  }
+
+  async listBranches() {
+    if (!this.isConfigured()) return { success: false, error: "No git remote configured" }
+
+    const { provider, owner, repo } = this.info
+
+    if (provider === "github") {
+      const url = `https://api.github.com/repos/${owner}/${repo}/branches`
+      const res = await apiRequest(url, { token: this.token })
+      return { success: true, branches: Array.isArray(res.data) ? res.data.map(b => b.name) : [] }
+    }
+
+    if (provider === "gitlab") {
+      const encoded = encodeURIComponent(`${owner}/${repo}`)
+      const url = `https://gitlab.com/api/v4/projects/${encoded}/repository/branches`
+      const res = await apiRequest(url, { token: this.token })
+      return { success: true, branches: Array.isArray(res.data) ? res.data.map(b => b.name) : [] }
+    }
+
+    return { success: false, error: "Unknown provider" }
+  }
+
+  async listReleases() {
+    if (!this.isConfigured()) return { success: false, error: "No git remote configured" }
+
+    const { provider, owner, repo } = this.info
+
+    if (provider === "github") {
+      const url = `https://api.github.com/repos/${owner}/${repo}/releases`
+      const res = await apiRequest(url, { token: this.token })
+      return { success: true, releases: Array.isArray(res.data) ? res.data : [] }
+    }
+
+    if (provider === "gitlab") {
+      const encoded = encodeURIComponent(`${owner}/${repo}`)
+      const url = `https://gitlab.com/api/v4/projects/${encoded}/releases`
+      const res = await apiRequest(url, { token: this.token })
+      return { success: true, releases: Array.isArray(res.data) ? res.data : [] }
+    }
+
+    return { success: false, error: "Unknown provider" }
+  }
+
+  async createRelease(tag, name, body) {
+    if (!this.isConfigured()) return { success: false, error: "No git remote configured" }
+
+    const { provider, owner, repo } = this.info
+
+    if (provider === "github") {
+      const url = `https://api.github.com/repos/${owner}/${repo}/releases`
+      const res = await apiRequest(url, {
+        method: "POST",
+        token: this.token,
+        body: { tag_name: tag, name, body },
+      })
+      return { success: res.status === 201, data: res.data, url: res.data?.html_url }
+    }
+
+    return { success: false, error: "Release creation only supported on GitHub" }
+  }
+}
+
+export default GitAPI