rakit-cli 2.0.1__py3-none-any.whl

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/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/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)