rakit-cli 2.0.1__tar.gz

rakit_cli-2.0.1/.gitignore

@@ -0,0 +1,59 @@
+# Python / uv / Django
+celerybeat-schedule*
+*.bak
+*.dat
+*.dir
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+.venv/
+venv/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+htmlcov/
+db.sqlite3
+db.sqlite3-journal
+staticfiles/
+media/
+
+# Secrets & Environment
+.env
+.env.*
+!.env.example
+*.pem
+*.key
+*.jks
+secrets/
+
+# Flutter / Dart
+mobile/.dart_tool/
+mobile/.packages
+mobile/build/
+mobile/.flutter-plugins
+mobile/.flutter-plugins-dependencies
+mobile/coverage/
+
+# Node / Playwright Runners
+node_modules/
+runners/node_modules/
+runners/artifacts/
+runners/playwright-report/
+runners/test-results/
+runners/.auth/
+
+# OS / Editor
+.DS_Store
+Thumbs.db
+.idea/
+
+# Local RAKIT CLI workspace binding cache
+.rakit/
+
+# Binary APK rilis mobile (disajikan dari backend/media, bukan dari git)
+mobile/dist/*.apk
+mobile/android/key.properties
+*.jks
+*.keystore

rakit_cli-2.0.1/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.5
+Name: rakit-cli
+Version: 2.0.1
+Summary: Pendamping folder notebook lokal & server MCP stdio untuk RAKIT v2.0
+Project-URL: Homepage, https://github.com/radianapp/rakit
+Project-URL: Documentation, https://github.com/radianapp/rakit
+Project-URL: Repository, https://github.com/radianapp/rakit
+Author-email: RAKIT Team <rakitsbs@gmail.com>
+License: MIT
+Keywords: agentic,ai,developer-tools,mcp,orchestration,workflow
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# rakit-cli
+
+[![PyPI version](https://img.shields.io/pypi/v/rakit-cli.svg)](https://pypi.org/project/rakit-cli/)
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**rakit-cli** adalah pendamping baris perintah (CLI) dan server MCP (Model Context Protocol) berbasis `stdio` untuk ekosistem **RAKIT v2.0 (Radian Agentic Kit & Interactive Tracking)**.
+
+Alat ini digunakan oleh pengembang perangkat lunak dan asisten agen AI (seperti Cursor, Claude Code, Windsurf, Copilot, atau Antigravity) untuk mengikat folder notebook lokal ke peladen RAKIT, menyinkronkan progres tiket, dan menjalankan gerbang verifikasi kualitas.
+
+---
+
+## Fitur Utama
+
+- 🔒 **SecretFilter Bawaan**: Mencegah kebocoran berkas sensitif (`.env*`, `*.pem`, `*.key`, token, dan kredensial) secara lokal sebelum dikirim ke server.
+- 📦 **Zero Runtime Dependencies**: Murni menggunakan pustaka bawaan Python 3.12+ (*standard library*), sangat ringan dan cepat dipasang.
+- 🤖 **Server MCP Stdio (`rakit-mcp`)**: Menyediakan perkakas `rakit_status`, `rakit_claim_ticket`, `rakit_sync_progress`, dan `rakit_ask_human` langsung ke agen AI di editor Anda.
+- ⚡ **Offline-First Synchronization**: Perubahan status dan progres tiket dicatat di buffer lokal saat koneksi internet terputus dan disinkronkan otomatis saat kembali online.
+- 🛡️ **Verifikasi Otomatis**: Integrasi linter dan test suite lokal (`rakit verify`) sebelum mengajukan tiket ke gerbang QA/UAT.
+
+---
+
+## Instalasi
+
+### Menggunakan `pip` (Standar)
+```bash
+pip install rakit-cli
+```
+
+### Menggunakan `pipx` (Direkomendasikan untuk CLI Terisolasi)
+```bash
+pipx install rakit-cli
+```
+
+### Menggunakan `uv tool`
+```bash
+uv tool install rakit-cli
+```
+
+---
+
+## Panduan Penggunaan Singkat
+
+### 1. Inisialisasi Proyek Lokal
+Arahkan terminal ke direktori proyek lokal Anda, lalu hubungkan ke server RAKIT:
+
+```bash
+cd /jalur/ke/folder/proyek-anda
+rakit init --project siaga --api-url http://localhost:8000/api/v1 --token <TOKEN_API_ANDA>
+```
+
+> **Tip Token API:** Dapatkan token autentikasi Anda dari Web Console RAKIT di menu **Profil & Token API** (`http://localhost:8000/accounts/profile/`).
+
+### 2. Memindai Struktur Proyek (Smart Scan)
+```bash
+rakit scan
+```
+
+### 3. Mengklaim Tiket Kerja
+```bash
+rakit start TIKET-101
+```
+
+### 4. Menjalankan Verifikasi Kualitas
+```bash
+rakit verify
+```
+
+### 5. Mengaktifkan Server MCP untuk AI
+Tambahkan konfigurasi berikut ke berkas MCP editor Anda (`claude_desktop_config.json` atau settings Cursor/VS Code):
+
+```json
+{
+  "mcpServers": {
+    "rakit-dev": {
+      "command": "rakit-mcp",
+      "args": ["--workspace", "/jalur/ke/folder/proyek-anda"]
+    }
+  }
+}
+```
+
+---
+
+## Lisensi
+
+Didistribusikan di bawah lisensi MIT. Lihat berkas `LICENSE` untuk rincian lengkap.
+

rakit_cli-2.0.1/README.md

@@ -0,0 +1,88 @@
+# rakit-cli
+
+[![PyPI version](https://img.shields.io/pypi/v/rakit-cli.svg)](https://pypi.org/project/rakit-cli/)
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**rakit-cli** adalah pendamping baris perintah (CLI) dan server MCP (Model Context Protocol) berbasis `stdio` untuk ekosistem **RAKIT v2.0 (Radian Agentic Kit & Interactive Tracking)**.
+
+Alat ini digunakan oleh pengembang perangkat lunak dan asisten agen AI (seperti Cursor, Claude Code, Windsurf, Copilot, atau Antigravity) untuk mengikat folder notebook lokal ke peladen RAKIT, menyinkronkan progres tiket, dan menjalankan gerbang verifikasi kualitas.
+
+---
+
+## Fitur Utama
+
+- 🔒 **SecretFilter Bawaan**: Mencegah kebocoran berkas sensitif (`.env*`, `*.pem`, `*.key`, token, dan kredensial) secara lokal sebelum dikirim ke server.
+- 📦 **Zero Runtime Dependencies**: Murni menggunakan pustaka bawaan Python 3.12+ (*standard library*), sangat ringan dan cepat dipasang.
+- 🤖 **Server MCP Stdio (`rakit-mcp`)**: Menyediakan perkakas `rakit_status`, `rakit_claim_ticket`, `rakit_sync_progress`, dan `rakit_ask_human` langsung ke agen AI di editor Anda.
+- ⚡ **Offline-First Synchronization**: Perubahan status dan progres tiket dicatat di buffer lokal saat koneksi internet terputus dan disinkronkan otomatis saat kembali online.
+- 🛡️ **Verifikasi Otomatis**: Integrasi linter dan test suite lokal (`rakit verify`) sebelum mengajukan tiket ke gerbang QA/UAT.
+
+---
+
+## Instalasi
+
+### Menggunakan `pip` (Standar)
+```bash
+pip install rakit-cli
+```
+
+### Menggunakan `pipx` (Direkomendasikan untuk CLI Terisolasi)
+```bash
+pipx install rakit-cli
+```
+
+### Menggunakan `uv tool`
+```bash
+uv tool install rakit-cli
+```
+
+---
+
+## Panduan Penggunaan Singkat
+
+### 1. Inisialisasi Proyek Lokal
+Arahkan terminal ke direktori proyek lokal Anda, lalu hubungkan ke server RAKIT:
+
+```bash
+cd /jalur/ke/folder/proyek-anda
+rakit init --project siaga --api-url http://localhost:8000/api/v1 --token <TOKEN_API_ANDA>
+```
+
+> **Tip Token API:** Dapatkan token autentikasi Anda dari Web Console RAKIT di menu **Profil & Token API** (`http://localhost:8000/accounts/profile/`).
+
+### 2. Memindai Struktur Proyek (Smart Scan)
+```bash
+rakit scan
+```
+
+### 3. Mengklaim Tiket Kerja
+```bash
+rakit start TIKET-101
+```
+
+### 4. Menjalankan Verifikasi Kualitas
+```bash
+rakit verify
+```
+
+### 5. Mengaktifkan Server MCP untuk AI
+Tambahkan konfigurasi berikut ke berkas MCP editor Anda (`claude_desktop_config.json` atau settings Cursor/VS Code):
+
+```json
+{
+  "mcpServers": {
+    "rakit-dev": {
+      "command": "rakit-mcp",
+      "args": ["--workspace", "/jalur/ke/folder/proyek-anda"]
+    }
+  }
+}
+```
+
+---
+
+## Lisensi
+
+Didistribusikan di bawah lisensi MIT. Lihat berkas `LICENSE` untuk rincian lengkap.
+

rakit_cli-2.0.1/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "rakit-cli"
+version = "2.0.1"
+description = "Pendamping folder notebook lokal & server MCP stdio untuk RAKIT v2.0"
+readme = "README.md"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+authors = [
+    { name = "RAKIT Team", email = "rakitsbs@gmail.com" }
+]
+keywords = ["agentic", "ai", "mcp", "workflow", "developer-tools", "orchestration"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Build Tools",
+    "Topic :: Software Development :: Quality Assurance",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/radianapp/rakit"
+Documentation = "https://github.com/radianapp/rakit"
+Repository = "https://github.com/radianapp/rakit"
+
+[project.scripts]
+rakit = "rakit_cli.main:main"
+rakit-mcp = "rakit_cli.mcp_server:main"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.0",
+    "pytest-cov>=7.0.0",
+    "ruff>=0.15.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/rakit_cli"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--cov=rakit_cli --cov-report=term-missing"
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP"]

rakit_cli-2.0.1/src/rakit_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Paket pendamping folder notebook lokal (`rakit`) dan server MCP `stdio` (`rakit-mcp`)."""
+
+__version__ = "2.0.1"

rakit_cli-2.0.1/src/rakit_cli/branding.py

@@ -0,0 +1,21 @@
+"""Banner dan identitas visual terminal (ASCII/Unicode Logo) untuk `rakit-cli` & `rakit-mcp`."""
+
+from __future__ import annotations
+
+RAKIT_CLI_VERSION = "2.0.1"
+
+RAKIT_ASCII_LOGO = r"""
+  ____      _    _  _____ _____       ____   ___
+ |  _ \    / \  | |/ /_ _|_   _| __ _|___ \ / _ \
+ | |_) |  / _ \ | ' / | |  | |   \ \ / / __) | | | |
+ |  _ <  / ___ \| . \ | |  | |    \ V / / __/| |_| |
+ |_| \_\/_/   \_\_|\_\___| |_|     \_/ |_____|\___/
+  [G1: Spec Gate] ---> [G2: E2E Video UAT] ---> [G3: Human Merge]
+""".strip("\n")
+
+RAKIT_COMPACT_BADGE = "◆ RAKIT v2.0 · Autonomous SDLC & Hybrid Workspace Engine"
+
+
+def render_cli_banner() -> str:
+    """Mengembalikan banner teks logo RAKIT v2.0 untuk layar bantuan CLI (`rakit banner`)."""
+    return f"{RAKIT_ASCII_LOGO}\n  {RAKIT_COMPACT_BADGE}\n"

rakit_cli-2.0.1/src/rakit_cli/config.py

@@ -0,0 +1,267 @@
+"""Pengelolaan berkas konfigurasi workspace lokal `.rakit/workspace.json` bebas rahasia."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import socket
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+DEFAULT_SECRET_BLOCKLIST: tuple[str, ...] = (
+    ".env",
+    ".env.*",
+    "*.pem",
+    "*.key",
+    "*.p12",
+    "*.pfx",
+    "id_rsa*",
+    "id_ed25519*",
+    "secrets/**",
+    "credentials.json",
+)
+
+
+@dataclass(frozen=True)
+class WorkspaceConfig:
+    """
+    TUJUAN: Menyimpan identitas proyek, server RAKIT, sidik jari folder,
+    token API lokal, dan daftar blokir rahasia.
+
+    KEPUTUSAN TEKNIS: Token autentikasi disimpan di `.rakit/workspace.json` yang secara otomatis
+    masuk ke `.rakit/.gitignore` agar tidak pernah ter-commit ke repositori Git.
+    DIPANGGIL DARI: `rakit init`, `rakit status`, `rakit token`, dan server MCP `stdio`
+    DEPENDENSI: pathlib, hashlib, json
+    """
+
+    project_slug: str
+    api_base_url: str
+    machine_label: str
+    root_fingerprint: str
+    active_ticket_key: str = ""
+    api_token: str = ""
+    secret_blocklist: tuple[str, ...] = DEFAULT_SECRET_BLOCKLIST
+
+
+def compute_workspace_fingerprint(workspace_root: Path) -> str:
+    """Menghasilkan hash SHA-256 satu arah dari jalur absolut folder kerja notebook."""
+    normalized = str(workspace_root.resolve()).lower().encode("utf-8")
+    return hashlib.sha256(normalized).hexdigest()
+
+
+def load_workspace_config(workspace_root: Path) -> WorkspaceConfig | None:
+    """Membaca `.rakit/workspace.json` bila sudah diinisialisasi."""
+    config_file = workspace_root / ".rakit" / "workspace.json"
+    if not config_file.exists():
+        return None
+    raw_data = json.loads(config_file.read_text(encoding="utf-8"))
+    raw_blocklist = raw_data.get("secret_blocklist")
+    resolved_blocklist = (
+        tuple(str(item) for item in raw_blocklist)
+        if isinstance(raw_blocklist, list) and raw_blocklist
+        else DEFAULT_SECRET_BLOCKLIST
+    )
+    return WorkspaceConfig(
+        project_slug=str(raw_data["project_slug"]),
+        api_base_url=str(raw_data["api_base_url"]),
+        machine_label=str(raw_data.get("machine_label") or socket.gethostname()),
+        root_fingerprint=str(raw_data["root_fingerprint"]),
+        active_ticket_key=str(raw_data.get("active_ticket_key") or ""),
+        api_token=str(raw_data.get("api_token") or ""),
+        secret_blocklist=resolved_blocklist,
+    )
+
+
+def save_workspace_config(workspace_root: Path, config: WorkspaceConfig) -> Path:
+    """Menyimpan `.rakit/workspace.json` dan memastikan `.rakit/.gitignore` dibuat."""
+    rakit_dir = workspace_root / ".rakit"
+    rakit_dir.mkdir(parents=True, exist_ok=True)
+
+    gitignore_file = rakit_dir / ".gitignore"
+    if not gitignore_file.exists():
+        gitignore_file.write_text(
+            "workspace.json\n*.token\ncache/\noffline_queue.json\n", encoding="utf-8"
+        )
+    else:
+        existing_gi = gitignore_file.read_text(encoding="utf-8")
+        if "workspace.json" not in existing_gi:
+            gitignore_file.write_text("workspace.json\n" + existing_gi, encoding="utf-8")
+
+    config_file = rakit_dir / "workspace.json"
+    payload = asdict(config)
+    payload["secret_blocklist"] = list(config.secret_blocklist)
+    config_file.write_text(
+        json.dumps(payload, indent=2, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+    return config_file
+
+
+def get_effective_api_token(config: WorkspaceConfig | None) -> str:
+    """
+    Mengambil token API aktif dengan urutan prioritas:
+      1. Environment variable `RAKIT_API_TOKEN`
+      2. `api_token` tersimpan di `.rakit/workspace.json`
+    """
+    import os
+
+    env_token = os.environ.get("RAKIT_API_TOKEN", "").strip()
+    if env_token:
+        return env_token
+    if config and config.api_token:
+        return config.api_token.strip()
+    return ""
+
+
+def enqueue_offline_sync_event(workspace_root: Path, event_payload: dict[str, Any]) -> Path:
+    """
+    TUJUAN: Mencatat progres TASKS.md ke antrean luring `.rakit/offline_queue.json` (US-011).
+
+    ALUR:
+      1. Membaca daftar event yang belum terkirim di `.rakit/offline_queue.json`.
+      2. Bila `idempotency_key` belum ada di antrean, menambahkan event baru.
+      3. Menyimpan kembali berkas antrean luring.
+
+    DIPANGGIL DARI: `rakit sync` dan perkakas MCP `rakit_sync_progress`
+    DEPENDENSI: json, pathlib
+    """
+    rakit_dir = workspace_root / ".rakit"
+    rakit_dir.mkdir(parents=True, exist_ok=True)
+    queue_file = rakit_dir / "offline_queue.json"
+
+    existing_items: list[dict[str, Any]] = []
+    if queue_file.exists():
+        loaded = json.loads(queue_file.read_text(encoding="utf-8"))
+        if isinstance(loaded, list):
+            existing_items = loaded
+
+    idem_key = str(event_payload.get("idempotency_key") or "")
+    if not idem_key or all(item.get("idempotency_key") != idem_key for item in existing_items):
+        existing_items.append(event_payload)
+
+    queue_file.write_text(
+        json.dumps(existing_items, indent=2, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+    return queue_file
+
+
+def write_active_task_prompt(
+    workspace_root: Path,
+    ticket_data: dict[str, Any],
+) -> Path:
+    """
+    Menulis berkas `.rakit/PROMPT.md` yang memuat konteks instruksi kerja aktif
+    sehingga agen AI lokal dapat langsung mengeksekusi dengan perintah
+    'Lanjutkan pekerjaan dari RAKIT'.
+    """
+    rakit_dir = workspace_root / ".rakit"
+    rakit_dir.mkdir(parents=True, exist_ok=True)
+    prompt_file = rakit_dir / "PROMPT.md"
+
+    key = str(ticket_data.get("key") or "UNKNOWN")
+    title = str(ticket_data.get("title") or "Tugas Aktif")
+    kind = str(ticket_data.get("kind") or "WORK_ITEM")
+    category = str(ticket_data.get("category") or "").strip()
+    category_md = f"- **Kategori Alur / Event**: `{category}`\n" if category else ""
+    desc = str(ticket_data.get("description") or "Tidak ada deskripsi spesifik.")
+    allowed_list = ticket_data.get("allowed_paths") or []
+    allowed = ", ".join(allowed_list) if allowed_list else "Semua jalur modul proyek"
+    forbidden_list = ticket_data.get("forbidden_paths") or []
+    forbidden = ", ".join(forbidden_list) if forbidden_list else "Tidak ada"
+
+    ac_items = ticket_data.get("acceptance_criteria") or []
+    ac_lines: list[str] = []
+    if isinstance(ac_items, list) and ac_items:
+        for idx, ac in enumerate(ac_items, 1):
+            if isinstance(ac, dict):
+                given = ac.get("given", "-")
+                when = ac.get("when", "-")
+                then = ac.get("then", "-")
+                ac_lines.append(
+                    f"{idx}. **Given**: {given}\n   **When**: {when}\n   **Then**: {then}"
+                )
+            else:
+                ac_lines.append(f"{idx}. {ac}")
+    ac_formatted = (
+        "\n\n".join(ac_lines) if ac_lines else "- Mengikuti spesifikasi arsitektur standar modul."
+    )
+
+    content = (
+        f"# 📋 TUGAS AKTIF RAKIT: [{key}] {title}\n\n"
+        f"Kamu sedang mengerjakan tiket aktif dari orkestrator **RAKIT v2.0**.\n\n"
+        f"## 1. Identitas & Kontrak Tiket\n"
+        f"- **Kunci Tiket**: `{key}`\n"
+        f"- **Jenis**: `{kind}`\n"
+        f"{category_md}"
+        f"- **Pagar Direktori Diizinkan (`allowed_paths`)**: `{allowed}`\n"
+        f"- **Direktori Terlarang (`forbidden_paths`)**: `{forbidden}`\n\n"
+        f"## 2. Deskripsi Pekerjaan\n"
+        f"{desc}\n\n"
+        f"## 3. Kriteria Penerimaan (Acceptance Criteria / GWT)\n"
+        f"{ac_formatted}\n\n"
+        f"## 4. Instruksi Eksekusi untuk AI\n"
+        f"1. Periksa kode dan modul terkait di folder proyek ini sesuai `allowed_paths`.\n"
+        f"2. Tulis kode implementasi dan unit test pendukung hingga semua kriteria di atas "
+        f"terpenuhi dan tes lulus hijau.\n"
+        f"3. Selama pengerjaan, laporkan progresmu secara berkala ke Web Console RAKIT:\n"
+        f'   `rakit sync --note "Deskripsi progres milestone aktif"`\n'
+        f"4. Bila kamu ragu atau butuh input arsitektur, panggil tool MCP `rakit_ask_human` "
+        f"atau laporkan via `rakit sync`.\n"
+        f"5. Setelah kode selesai dan semua pengujian lulus, jalankan:\n"
+        f"   `rakit verify`\n"
+        f"   untuk mengajukan tiket ke tahap QA & UAT Review (Gerbang G2).\n\n"
+        f"> **PENTING**: Kerjakan perubahan kode secara nyata di repositori ini. "
+        f"Dilarang hanya mensimulasikan hasil di chat!\n"
+    )
+    prompt_file.write_text(content, encoding="utf-8")
+    return prompt_file
+
+
+def fetch_and_write_prompt(
+    workspace_root: Path,
+    cfg: WorkspaceConfig,
+    ticket_key: str | None = None,
+) -> Path | None:
+    """
+    TUJUAN: Mengambil data tiket dari peladen RAKIT dan menulis .rakit/PROMPT.md.
+
+    DIPANGGIL DARI: `rakit prompt`, `rakit sync` (bila belum ada), dan `rakit start`.
+    """
+    key = (ticket_key or "").strip() or (cfg.active_ticket_key or "").strip()
+    if not key:
+        return None
+
+    token = get_effective_api_token(cfg)
+    ticket_obj: dict[str, Any] = {
+        "key": key,
+        "title": f"Tugas aktif {key}",
+        "kind": "FEATURE",
+        "description": "Dikerjakan dari lingkungan lokal.",
+        "allowed_paths": [],
+        "forbidden_paths": [],
+        "acceptance_criteria": [],
+    }
+
+    if cfg.api_base_url:
+        try:
+            import urllib.request
+
+            url = f"{cfg.api_base_url}/tickets/{key}/?project_slug={cfg.project_slug}"
+            headers = {"Content-Type": "application/json"}
+            if token:
+                headers["Authorization"] = f"Token {token}"
+            req = urllib.request.Request(url, headers=headers, method="GET")
+            with urllib.request.urlopen(req, timeout=4) as resp:
+                if resp.status == 200:
+                    raw_data = json.loads(resp.read().decode("utf-8"))
+                    payload = raw_data.get("data") or {}
+                    if "ticket" in payload and isinstance(payload["ticket"], dict):
+                        ticket_obj = payload["ticket"]
+                    elif "key" in payload:
+                        ticket_obj = payload
+        except Exception:
+            pass
+
+    return write_active_task_prompt(workspace_root, ticket_obj)