rakit-cli 2.0.1__py3-none-any.whl

rakit_cli/mcp_server.py

@@ -0,0 +1,325 @@
+"""Server MCP `stdio` JSON-RPC 2.0 ringan untuk asisten AI editor lokal (ADR-002)."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+from rakit_cli.config import (
+    WorkspaceConfig,
+    get_effective_api_token,
+    load_workspace_config,
+    save_workspace_config,
+    write_active_task_prompt,
+)
+from rakit_cli.security import redact_sensitive_text
+from rakit_cli.tasks_parser import parse_tasks_markdown
+
+MCP_TOOLS_CATALOG: list[dict[str, Any]] = [
+    {
+        "name": "rakit_status",
+        "description": "Membaca ikatan proyek aktif dan progres TASKS.md di folder kerja notebook.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "workspace_path": {
+                    "type": "string",
+                    "description": "Jalur folder proyek aktif (opsional)",
+                }
+            },
+        },
+    },
+    {
+        "name": "rakit_claim_ticket",
+        "description": (
+            "Mengikat kunci tiket aktif pada workspace lokal untuk dikerjakan asisten AI."
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "ticket_key": {"type": "string"},
+                "workspace_path": {
+                    "type": "string",
+                    "description": "Jalur folder proyek aktif (opsional)",
+                },
+            },
+            "required": ["ticket_key"],
+        },
+    },
+    {
+        "name": "rakit_sync_progress",
+        "description": "Menyusun muatan progres sub-tugas TASKS.md yang tersanitasi dari rahasia.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "summary": {"type": "string"},
+                "workspace_path": {
+                    "type": "string",
+                    "description": "Jalur folder proyek aktif (opsional)",
+                },
+            },
+        },
+    },
+    {
+        "name": "rakit_ask_human",
+        "description": (
+            "Menyiapkan pertanyaan klarifikasi ask_human untuk dikirim ke HP pengembang."
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "question": {"type": "string"},
+                "workspace_path": {
+                    "type": "string",
+                    "description": "Jalur folder proyek aktif (opsional)",
+                },
+            },
+            "required": ["question"],
+        },
+    },
+]
+
+
+def find_workspace_root(start_dir: Path | None = None) -> Path:
+    """
+    TUJUAN: Menemukan folder workspace yang memuat berkas `.rakit/workspace.json`.
+
+    ALUR:
+      1. Memeriksa environment variable `RAKIT_WORKSPACE` bila disetel.
+      2. Melakukan traversal ke direktori induk (parent traversal) dari `start_dir`.
+      3. Bila tidak ditemukan, kembali ke `start_dir` atau direktori aktif.
+    """
+    import os
+
+    env_root = os.environ.get("RAKIT_WORKSPACE", "").strip()
+    if env_root:
+        candidate = Path(env_root).resolve()
+        if (candidate / ".rakit" / "workspace.json").exists():
+            return candidate
+
+    cur = (start_dir or Path.cwd()).resolve()
+    for candidate in [cur, *cur.parents]:
+        if (candidate / ".rakit" / "workspace.json").exists():
+            return candidate
+    return cur
+
+
+def handle_jsonrpc_message(
+    request: dict[str, Any],
+    *,
+    workspace_root: Path,
+) -> dict[str, Any] | None:
+    """
+    TUJUAN: Menangani satu pesan JSON-RPC 2.0 MCP (`initialize`, `tools/list`, `tools/call`).
+
+    ALUR:
+      1. Mengabaikan notifikasi satu arah yang tidak memiliki `id`.
+      2. Mengembalikan katalog 4 perkakas pada `tools/list`.
+      3. Mengeksekusi logika workspace lokal pada `tools/call` dengan penyensoran rahasia.
+
+    DIPANGGIL DARI: Loop `stdio` di `main()` dan pengujian unit MCP
+    DEPENDENSI: config, security, tasks_parser
+    """
+    method = str(request.get("method") or "")
+    request_id = request.get("id")
+    if request_id is None:
+        return None
+
+    if method == "initialize":
+        return {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "result": {
+                "protocolVersion": "2024-11-05",
+                "serverInfo": {"name": "rakit-mcp", "version": "2.0.0"},
+                "capabilities": {"tools": {}},
+            },
+        }
+
+    if method == "tools/list":
+        return {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "result": {"tools": MCP_TOOLS_CATALOG},
+        }
+
+    if method == "tools/call":
+        params = request.get("params") or {}
+        tool_name = str(params.get("name") or "")
+        arguments = params.get("arguments") or {}
+        result_payload = _execute_mcp_tool(
+            tool_name=tool_name,
+            arguments=arguments,
+            workspace_root=workspace_root,
+        )
+        return {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "result": {
+                "content": [
+                    {
+                        "type": "text",
+                        "text": json.dumps(result_payload, ensure_ascii=False),
+                    }
+                ]
+            },
+        }
+
+    return {
+        "jsonrpc": "2.0",
+        "id": request_id,
+        "error": {"code": -32601, "message": f"Method tidak dikenali: {method}"},
+    }
+
+
+def _execute_mcp_tool(
+    *,
+    tool_name: str,
+    arguments: dict[str, Any],
+    workspace_root: Path,
+) -> dict[str, Any]:
+    """Menjalankan salah satu dari 4 perkakas MCP lokal."""
+    target_root = workspace_root
+    arg_ws = arguments.get("workspace_path")
+    if isinstance(arg_ws, str) and arg_ws.strip():
+        target_root = Path(arg_ws).resolve()
+    else:
+        target_root = find_workspace_root(workspace_root)
+
+    cfg = load_workspace_config(target_root)
+    if cfg is None:
+        return {"ok": False, "code": "WORKSPACE_NOT_INITIALIZED"}
+
+    tasks_path = target_root / "TASKS.md"
+    tasks_summary = (
+        parse_tasks_markdown(tasks_path.read_text(encoding="utf-8"))
+        if tasks_path.exists()
+        else parse_tasks_markdown("")
+    )
+
+    if tool_name == "rakit_status":
+        return {
+            "ok": True,
+            "project_slug": cfg.project_slug,
+            "active_ticket_key": cfg.active_ticket_key,
+            "tasks_completed": tasks_summary.completed_count,
+            "tasks_total": tasks_summary.total_count,
+            "next_open_task": tasks_summary.next_open_task,
+        }
+
+    if tool_name == "rakit_claim_ticket":
+        ticket_key = str(arguments.get("ticket_key") or "").strip()
+        if not ticket_key:
+            return {"ok": False, "code": "TICKET_KEY_REQUIRED"}
+        updated = WorkspaceConfig(
+            project_slug=cfg.project_slug,
+            api_base_url=cfg.api_base_url,
+            machine_label=cfg.machine_label,
+            root_fingerprint=cfg.root_fingerprint,
+            active_ticket_key=ticket_key,
+            api_token=cfg.api_token,
+            secret_blocklist=cfg.secret_blocklist,
+        )
+        save_workspace_config(target_root, updated)
+
+        server_status = "saved_locally_offline"
+        auth_hint = ""
+        token = get_effective_api_token(cfg)
+        if cfg.api_base_url:
+            try:
+                import urllib.error
+                import urllib.request
+
+                claim_url = f"{cfg.api_base_url}/tickets/{ticket_key}/claim/"
+                claim_body = json.dumps(
+                    {
+                        "holder_id": cfg.machine_label or "mcp-agent",
+                        "holder_kind": "NOTEBOOK_CLI",
+                        "ttl_minutes": 30,
+                        "project_slug": cfg.project_slug,
+                    }
+                ).encode("utf-8")
+                headers = {"Content-Type": "application/json"}
+                if token:
+                    headers["Authorization"] = f"Token {token}"
+                req = urllib.request.Request(
+                    claim_url, data=claim_body, headers=headers, method="POST"
+                )
+                with urllib.request.urlopen(req, timeout=4) as resp:
+                    if resp.status in {200, 201}:
+                        server_status = "claimed_on_server"
+                        raw_claim = json.loads(resp.read().decode("utf-8"))
+                        ticket_obj = (raw_claim.get("data") or {}).get("ticket") or {}
+                        if ticket_obj:
+                            write_active_task_prompt(target_root, ticket_obj)
+            except urllib.error.HTTPError as err:
+                if err.code in {401, 403}:
+                    server_status = "unauthorized_401"
+                    auth_hint = (
+                        "Token API RAKIT belum disetel atau tidak valid. "
+                        "Salin token dari Web Console: http://localhost:8000/accounts/profile/ "
+                        "lalu simpan dengan: rakit token <TOKEN>"
+                    )
+                else:
+                    server_status = f"http_{err.code}"
+            except Exception as e:
+                server_status = f"offline_fallback: {e}"
+
+        res: dict[str, Any] = {
+            "ok": True,
+            "active_ticket_key": ticket_key,
+            "server_claim_status": server_status,
+        }
+        if auth_hint:
+            res["auth_hint"] = auth_hint
+        return res
+
+    if tool_name == "rakit_sync_progress":
+        raw_summary = str(arguments.get("summary") or tasks_summary.next_open_task)
+        return {
+            "ok": True,
+            "active_ticket_key": cfg.active_ticket_key,
+            "tasks_completed": tasks_summary.completed_count,
+            "tasks_total": tasks_summary.total_count,
+            "summary": redact_sensitive_text(raw_summary),
+        }
+
+    if tool_name == "rakit_ask_human":
+        question = redact_sensitive_text(str(arguments.get("question") or "").strip())
+        if not question:
+            return {"ok": False, "code": "QUESTION_REQUIRED"}
+        return {
+            "ok": True,
+            "active_ticket_key": cfg.active_ticket_key,
+            "paused_status": "NEEDS_HUMAN",
+            "question": question,
+        }
+
+    return {"ok": False, "code": "UNKNOWN_TOOL"}
+
+
+def main() -> int:
+    """Menjalankan loop pembacaan baris JSON-RPC 2.0 melalui `sys.stdin` dan `sys.stdout`."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="RAKIT MCP stdio server")
+    parser.add_argument("--workspace", "-w", type=Path, default=None, help="Jalur workspace")
+    args, _ = parser.parse_known_args()
+
+    workspace_root = find_workspace_root(args.workspace.resolve() if args.workspace else None)
+    for raw_line in sys.stdin:
+        stripped = raw_line.strip()
+        if not stripped:
+            continue
+        request_obj = json.loads(stripped)
+        response_obj = handle_jsonrpc_message(request_obj, workspace_root=workspace_root)
+        if response_obj is not None:
+            sys.stdout.write(json.dumps(response_obj, ensure_ascii=False) + "\n")
+            sys.stdout.flush()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

rakit_cli/security.py

@@ -0,0 +1,90 @@
+"""Saringan keamanan pemindaian lokal & penyensoran rahasia sebelum dikirim ke server RAKIT."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path, PurePosixPath
+
+BLOCKED_DIRECTORY_NAMES: frozenset[str] = frozenset(
+    {
+        ".git",
+        ".venv",
+        "venv",
+        "node_modules",
+        "__pycache__",
+        ".pytest_cache",
+        ".dart_tool",
+        "build",
+        "secrets",
+        ".secrets",
+        ".rakit",
+    }
+)
+
+BLOCKED_SUFFIXES: tuple[str, ...] = (
+    ".pem",
+    ".key",
+    ".p12",
+    ".pfx",
+    ".keystore",
+    ".jks",
+    ".sqlite3",
+)
+
+BLOCKED_FILE_PREFIXES: tuple[str, ...] = (
+    "id_rsa",
+    "id_ed25519",
+    "id_ecdsa",
+)
+
+_SECRET_PATTERNS: tuple[re.Pattern[str], ...] = (
+    re.compile(
+        r"(?i)(token|api[_-]?key|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-\.]{8,}['\"]?"
+    ),
+    re.compile(r"gh[pousr]_[A-Za-z0-9_]{20,}"),
+    re.compile(r"sk-[A-Za-z0-9_\-]{20,}"),
+)
+
+
+def is_safe_workspace_path(relative_path: str | Path) -> bool:
+    """
+    TUJUAN: Memastikan berkas lokal aman dipindai tanpa menyentuh `.env` atau kunci privat (NFR-05).
+
+    ALUR:
+      1. Menolak segmen direktori terlarang / berawalan titik (`.git`, `.venv`, dll.).
+      2. Menolak berkas dot/tersembunyi (`.gitignore`, `.coverage`, `.python-version`, `.env*`).
+      3. Menolak sertifikat/kunci privat (`*.pem`, `*.key`, `id_rsa*`).
+
+    DIPANGGIL DARI: Pemindai pohon direktori `rakit scan`
+    DEPENDENSI: pathlib
+    """
+    posix_path = PurePosixPath(str(relative_path).replace("\\", "/"))
+    for part in posix_path.parts[:-1]:
+        if part.startswith(".") or part in BLOCKED_DIRECTORY_NAMES:
+            return False
+
+    filename = posix_path.name
+    lower_name = filename.lower()
+    if lower_name.startswith(".") or lower_name in BLOCKED_DIRECTORY_NAMES:
+        return False
+
+    if lower_name.endswith(BLOCKED_SUFFIXES):
+        return False
+
+    if lower_name.startswith(BLOCKED_FILE_PREFIXES):
+        return False
+
+    return True
+
+
+def redact_sensitive_text(raw_text: str) -> str:
+    """
+    TUJUAN: Menyensor pola token, password, dan kunci API dari ringkasan teks sebelum dikirim.
+
+    DIPANGGIL DARI: `rakit sync` dan perkakas MCP `rakit_ask_human`
+    DEPENDENSI: re
+    """
+    sanitized = raw_text
+    for pattern in _SECRET_PATTERNS:
+        sanitized = pattern.sub("[REDACTED_SECRET]", sanitized)
+    return sanitized

rakit_cli/skill_installer.py

@@ -0,0 +1,218 @@
+"""Modul pemasang & pengelola AI Skill RAKIT v2.0 untuk asisten coding."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+_FALLBACK_SKILL_CONTENT = """---
+name: rakit
+description: >-
+  Skill orkestrator alur kerja AI & pengembang untuk ekosistem RAKIT v2.0.
+  Membimbing siklus hidup pengembangan dari ide (PRD, User Story, ADR, DB Design, Prototipe),
+  interaksi tiket backlog via MCP/CLI, hingga quality gates.
+---
+
+# RAKIT v2.0 AI Assistant Skill
+Skill ini memandu AI mengeksekusi tiket backlog dan quality gates RAKIT v2.0 secara riil.
+"""
+
+MODULAR_COMPANION_SKILLS: dict[str, str] = {
+    "rakit-status": """---
+name: rakit-status
+description: Membaca status koneksi proyek RAKIT, kunci tiket aktif, dan progres TASKS.md.
+---
+
+# /rakit-status — Status Proyek & Progres
+1. Panggil MCP `rakit_status` atau jalankan `rakit status`.
+2. Sajikan laporan status proyek, tiket aktif, progres TASKS.md, dan tugas terbuka berikutnya.
+""",
+    "rakit-claim-ticket": """---
+name: rakit-claim-ticket
+description: Mengklaim tiket aktif dari backlog ke workspace lokal & buat .rakit/PROMPT.md.
+---
+
+# /rakit-claim-ticket — Klaim Tiket Aktif
+1. Panggil MCP `rakit_claim_ticket` dengan ticket_key atau jalankan `rakit start <KEY>`.
+2. Baca `.rakit/PROMPT.md` untuk memahami allowed_paths dan kriteria GWT.
+3. Mulai pengerjaan TDD secara nyata di repositori!
+""",
+    "rakit-sync-progress": """---
+name: rakit-sync-progress
+description: Menyaring rahasia & sinkronkan progres to-do TASKS.md ke Web Console RAKIT.
+---
+
+# /rakit-sync-progress — Sinkronisasi Progres
+1. Pastikan to-do selesai di `TASKS.md` sudah bertanda `[x]`.
+2. Panggil MCP `rakit_sync_progress` atau jalankan `rakit sync --note "<CATATAN>"`.
+3. Tampilkan konfirmasi progres dan persentase terbaru.
+""",
+    "rakit-ask-human": """---
+name: rakit-ask-human
+description: Eskalasi blocker/keraguan bisnis ke Web Console & HP pengembang (NEEDS_HUMAN).
+---
+
+# /rakit-ask-human — Eskalasi Blocker ke Pengembang
+1. Rumuskan pertanyaan ringkas tanpa data rahasia/token.
+2. Panggil tool MCP `rakit_ask_human` dengan argumen pertanyaan.
+3. Status tiket berubah menjadi `NEEDS_HUMAN` di Web Console & HP pengembang.
+4. Tunggu respon manusia sebelum melanjutkan kode.
+""",
+    "rakit-new-task": """---
+name: rakit-new-task
+description: Formulasi tiket baru berformat GWT, tentukan allowed_paths, & daftar ke backlog.
+---
+
+# /rakit-new-task — Buat Tiket Baru
+1. Tentukan sejak awal bersama pengguna:
+   - **Kategori Alur** (mis. `Manajemen Aset`, `Auth & Login`, `Inti Sistem`),
+   - **Story Points** (mis. `3` atau `5`), **Allowed Paths**, **Given-When-Then**, dan **Cakupan**.
+2. Tambahkan butir `- [ ]` terstruktur ke `TASKS.md` dengan format metadata berikut
+   agar langsung terbaca oleh `rakit scan --persist`:
+   - `- **Kategori:** <Kategori Alur>`
+   - `- **Story Points:** <angka>`
+   - `- **Allowed Paths:** <daftar folder/berkas dipisah koma>`
+   - `- **Given-When-Then (GWT):**` (`- **Given:**`, `- **When:**`, `- **Then:**`)
+   - `- **Cakupan:** <rincian poin pekerjaan & unit test>`
+3. Jalankan `rakit scan --persist` untuk mendaftarkan tiket lengkap ke BACKLOG Web Console.
+""",
+    "rakit-prd": """---
+name: rakit-prd
+description: Menyusun dokumen Product Requirement Document di docs/prd/<fitur>.md (G1 Gate).
+---
+
+# /rakit-prd — Penyusunan PRD
+1. Buat dokumen PRD di `docs/prd/<nama_fitur>.md`.
+2. Susun Problem Statement, Goals, Non-Goals, FR (GWT), Security, dan allowed_paths.
+3. Periksa kelengkapan Gerbang G1 (Spec Gate).
+""",
+    "rakit-user-story": """---
+name: rakit-user-story
+description: Memecah PRD menjadi User Stories berformat GWT dan estimasi Story Points.
+---
+
+# /rakit-user-story — Pecah User Story
+1. Baca PRD dan buat berkas `docs/prd/user-stories/<fitur>.md`.
+2. Format: As a... I want to... So that..., Acceptance Criteria GWT, estimasi.
+3. Daftarkan checklist sub-tugas ke `TASKS.md`.
+""",
+    "rakit-adr": """---
+name: rakit-adr
+description: Membuat Architectural Decision Record di docs/adr/ format Michael Nygard.
+---
+
+# /rakit-adr — Architectural Decision Record
+1. Cari nomor urut ADR berikutnya di `docs/adr/`.
+2. Tulis berkas `docs/adr/ADR-XXX-<judul>.md`.
+3. Cantumkan Status, Konteks, Keputusan, Konsekuensi, dan Compliance.
+""",
+    "rakit-db-design": """---
+name: rakit-db-design
+description: Merancang skema database relasional, ERD mermaid, tenant isolation, & migrasi.
+---
+
+# /rakit-db-design — Desain Database Relasional
+1. Rancang entitas, relasi, UUID/BigInt PK, FK cascade, dan composite index.
+2. Terapkan multi-tenant (`tenant_id`), audit trail, dan soft-delete.
+3. Buat diagram Mermaid ERD dan deklarasi model Django lengkap.
+""",
+    "rakit-proto": """---
+name: rakit-proto
+description: Merancang prototipe antarmuka UI (Dasa UI v2, Cotton, HTMX, Flutter Pastel).
+---
+
+# /rakit-proto — Prototipe Antarmuka
+1. Desain komponen UI menggunakan sistem desain yang berlaku:
+   - Web: Dasa UI v2 + Django-Cotton + HTMX parsial.
+   - Mobile: Flutter M3 Pastel (`useMaterial3: true`, RakitSemanticColors).
+2. Dilarang memakai inline CSS liar atau warna hex hardcoded.
+""",
+    "rakit-verify": """---
+name: rakit-verify
+description: Audit mutu lokal (linter, pytest, coverage, TASKS.md) menuju Gerbang G2 (QA).
+---
+
+# /rakit-verify — Verifikasi Mutu Gerbang G2
+1. Pastikan to-do terkait di `TASKS.md` sudah `[x]`.
+2. Jalankan linter (mis. `uv run ruff check .`) dan unit test (`uv run pytest`)
+   sesuai konfigurasi `verification` di `rakit.yaml`.
+3. Jalankan `rakit verify`.
+4. Panggil `rakit_sync_progress` untuk melaporkan kesiapan tiket ke QA.
+""",
+    "rakit-uat": """---
+name: rakit-uat
+description: Menyusun dokumen UAT Acceptance Test Plan dan skenario Playwright E2E.
+---
+
+# /rakit-uat — User Acceptance Test (UAT)
+1. Buat dokumen skenario acceptance di `docs/uat/<fitur>.md`.
+2. Tulis skenario E2E pada direktori proyek target sesuai `e2e_dir` di `rakit.yaml`
+   (mis. `tests/e2e/test_<fitur>.py` atau `e2e/<fitur>.spec.ts`).
+3. Pastikan bukti uji/video H.264 `.mp4` (jika tersedia) dikirim ke API RAKIT.
+""",
+    "rakit-release": """---
+name: rakit-release
+description: Checklist Gerbang G3 (Rilis Produksi), bump SemVer, CHANGELOG, & artefak.
+---
+
+# /rakit-release — Gerbang G3 & Rilis Produksi
+1. Periksa kelulusan seluruh tiket dan audit keamanan.
+2. Naikkan versi SemVer di `pyproject.toml` dan `pubspec.yaml`.
+3. Perbarui `CHANGELOG.md` dan verifikasi artefak rilis.
+""",
+}
+
+
+def get_rakit_skill_content() -> str:
+    """Mengembalikan konten Markdown lengkap dari berkas SKILL.md RAKIT v2.0."""
+    template_path = Path(__file__).parent / "templates" / "SKILL.md"
+    if template_path.exists():
+        return template_path.read_text(encoding="utf-8")
+    return _FALLBACK_SKILL_CONTENT.strip() + "\n"
+
+
+def install_skill(
+    destination_dir: Path,
+    *,
+    force: bool = False,
+) -> tuple[Path, str]:
+    """
+    TUJUAN: Memasang berkas SKILL.md ke folder target beserta skill pendamping.
+
+    PARAMETER:
+      - destination_dir: Folder tujuan (misal .agents/skills/rakit)
+      - force: Bila True, timpa berkas jika sudah ada.
+
+    KEMBALIAN:
+      Tuple (jalur_berkas_skill, status: 'created' | 'updated' | 'existing_preserved')
+    """
+    destination_dir.mkdir(parents=True, exist_ok=True)
+    skill_file = destination_dir / "SKILL.md"
+
+    content = get_rakit_skill_content()
+    is_update = skill_file.exists()
+    status = "existing_preserved"
+    if not skill_file.exists() or force:
+        skill_file.write_text(content, encoding="utf-8")
+        status = "updated" if is_update else "created"
+
+    # Jika destination_dir bernama 'rakit', otomatis pasang skill pendamping di folder induknya
+    if destination_dir.name == "rakit":
+        base_skills_dir = destination_dir.parent
+        for skill_name, skill_text in MODULAR_COMPANION_SKILLS.items():
+            child_dir = base_skills_dir / skill_name
+            child_dir.mkdir(parents=True, exist_ok=True)
+            child_file = child_dir / "SKILL.md"
+            if not child_file.exists() or force:
+                child_file.write_text(skill_text.strip() + "\n", encoding="utf-8")
+
+    return skill_file, status
+
+
+def get_default_workspace_skill_dir(workspace_root: Path) -> Path:
+    """Mengembalikan jalur standar direktori skill workspace lokal (.agents/skills/rakit)."""
+    return workspace_root / ".agents" / "skills" / "rakit"
+
+
+def get_default_global_skill_dir() -> Path:
+    """Mengembalikan jalur standar direktori skill global pengguna (~/.agents/skills/rakit)."""
+    return Path.home() / ".agents" / "skills" / "rakit"

rakit_cli/tasks_parser.py

@@ -0,0 +1,59 @@
+"""Pengurai berkas `TASKS.md` untuk menghitung progres sub-tugas secara deterministik."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+_CHECKBOX_PATTERN = re.compile(r"^\s*-\s*\[(?P<mark>[ xX])\]\s+(?P<label>.+?)\s*$")
+
+
+@dataclass(frozen=True)
+class TasksProgressSummary:
+    """
+    TUJUAN: Menyimpan ringkasan tugas selesai, total tugas, persentase, dan item terbuka berikutnya.
+
+    DIPANGGIL DARI: `rakit sync`, `rakit scan`, dan perkakas MCP `rakit_status`
+    DEPENDENSI: dataclasses
+    """
+
+    completed_count: int
+    total_count: int
+    progress_pct: int
+    next_open_task: str
+
+
+def parse_tasks_markdown(markdown_text: str) -> TasksProgressSummary:
+    """
+    TUJUAN: Menghitung kotak centang `- [x]` dan `- [ ]` dari isi berkas `TASKS.md`.
+
+    ALUR:
+      1. Memindai baris demi baris memakai ekspresi reguler kotak centang Markdown.
+      2. Mencatat butir `- [ ]` pertama sebagai `next_open_task` (milestone aktif).
+
+    DIPANGGIL DARI: CLI `rakit` dan server MCP `rakit-mcp`
+    DEPENDENSI: re
+    """
+    completed = 0
+    total = 0
+    next_open = ""
+
+    for line in markdown_text.splitlines():
+        match = _CHECKBOX_PATTERN.match(line)
+        if match is None:
+            continue
+        total += 1
+        mark = match.group("mark")
+        label = match.group("label").strip()
+        if mark.lower() == "x":
+            completed += 1
+        elif not next_open:
+            next_open = label
+
+    pct = int((completed / total) * 100) if total > 0 else 0
+    return TasksProgressSummary(
+        completed_count=completed,
+        total_count=total,
+        progress_pct=min(pct, 100),
+        next_open_task=next_open,
+    )