multacd 1.0.0__py3-none-any.whl

core/codebase.py

@@ -0,0 +1,318 @@
+"""Codebase awareness — scan project biar agent langsung ngerti konteks.
+
+    from core.codebase import scan_project, project_label
+
+    ctx = scan_project(".")   # → string ProjectContext buat system prompt
+
+Aturan scan (PLAN Phase 2 Section 5):
+- SELALU: struktur folder (depth 3), file kunci root, entry point, git info.
+- SKIP: file planning (PLAN*.md, ROADMAP.md, soul.md), dependency folder
+  (.venv, node_modules), compiled (__pycache__, *.pyc), .git, secrets
+  (.env), folder plan/ + roadmap/, pola di .gitignore.
+- Gagal scan (I/O, git hilang) → fallback, tidak crash.
+
+Test cepat:
+    python -m core.codebase
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+TREE_DEPTH = 3
+MAX_TREE_ENTRIES = 200
+MAX_FILE_CHARS = 1500
+
+# File kunci yang dibaca isinya (kalau ada di root).
+KEY_FILES = (
+    "README.md",
+    ".env.example",
+    "requirements.txt",
+    "pyproject.toml",
+    "setup.py",
+    "setup.cfg",
+    "Makefile",
+    "docker-compose.yml",
+)
+
+# File planning/bawaan — isi tidak relevan buat konteks kode.
+SKIP_FILES = frozenset({"soul.md"})
+
+SKIP_DIRS = frozenset({
+    ".git", ".venv", "node_modules", "__pycache__", ".pytest_cache",
+    ".idea", ".vscode", "dist", "build", "htmlcov",
+    "plan", "roadmap",
+})
+
+SECRET_SUFFIXES = (".key", ".pem")
+
+ENTRY_CANDIDATES = ("main.py", "app.py", "run.py", "index.py")
+
+
+def _is_planning_file(name: str) -> bool:
+    upper = name.upper()
+    return (upper in ("PLAN.MD", "ROADMAP.MD")
+            or upper.startswith(("PLAN-", "PLAN_", "ROADMAP-", "ROADMAP_")))
+
+
+def detect_project_type(root: Path | str) -> str:
+    """Tebak jenis project dari file signature di root."""
+    root = Path(root)
+    if any((root / f).is_file()
+           for f in ("requirements.txt", "pyproject.toml", "setup.py", "setup.cfg")):
+        return "Python"
+    if (root / "package.json").is_file():
+        return "Node.js"
+    if (root / "go.mod").is_file():
+        return "Go"
+    if (root / "Cargo.toml").is_file():
+        return "Rust"
+    if (root / "pom.xml").is_file() or list(root.glob("build.gradle*")):
+        return "Java"
+    return "Generic"
+
+
+def _gitignore_names(root: Path) -> set[str]:
+    """Parse .gitignore seperlunya: ambil pola nama sederhana."""
+    names: set[str] = set()
+    try:
+        text = (root / ".gitignore").read_text(encoding="utf-8")
+    except OSError:
+        return names
+    for line in text.splitlines():
+        line = line.strip()
+        if not line or line.startswith(("#", "!")):
+            continue
+        line = line.strip("/").split("/")[0]
+        if line and "*" not in line:
+            names.add(line)
+    return names
+
+
+def build_file_tree(root: Path | str, depth: int = TREE_DEPTH) -> str:
+    """Render struktur folder sebagai string tree (depth terbatas)."""
+    root = Path(root)
+    ignored = _gitignore_names(root)
+    lines: list[str] = []
+    count = 0
+    truncated = False
+
+    def skip_dir(d: Path) -> bool:
+        return d.name in SKIP_DIRS or d.name in ignored or d.name.startswith(".")
+
+    def skip_file(f: Path) -> bool:
+        n = f.name
+        return (
+            n in SKIP_FILES or _is_planning_file(n) or n in ignored
+            or n.startswith(".") or n.endswith(".pyc")
+            or n == ".env" or n.endswith(SECRET_SUFFIXES)
+        )
+
+    def walk(dir_path: Path, prefix: str, level: int) -> None:
+        nonlocal count, truncated
+        if level > depth or truncated:
+            return
+        try:
+            entries = sorted(dir_path.iterdir(),
+                             key=lambda p: (p.is_file(), p.name.lower()))
+        except OSError:
+            return
+        for p in entries:
+            if count >= MAX_TREE_ENTRIES:
+                truncated = True
+                return
+            if p.is_dir():
+                if skip_dir(p):
+                    continue
+                lines.append(f"{prefix}{p.name}/")
+                count += 1
+                walk(p, prefix + "  ", level + 1)
+            else:
+                if skip_file(p):
+                    continue
+                lines.append(f"{prefix}{p.name}")
+                count += 1
+
+    if not root.is_dir():
+        return "(folder tidak ditemukan)"
+    walk(root, "", 1)
+    if truncated:
+        lines.append(f"… (dipotong, >{MAX_TREE_ENTRIES} entri)")
+    return "\n".join(lines) if lines else "(folder kosong)"
+
+
+def get_key_files(root: Path | str) -> dict[str, str]:
+    """Baca file kunci root. File hilang → skip; isi dipotong MAX_FILE_CHARS."""
+    root = Path(root)
+    out: dict[str, str] = {}
+    for name in KEY_FILES:
+        try:
+            text = (root / name).read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            continue
+        if len(text) > MAX_FILE_CHARS:
+            text = text[:MAX_FILE_CHARS] + "\n…(dipotong)"
+        out[name] = text
+    return out
+
+
+def get_entry_points(root: Path | str) -> list[str]:
+    root = Path(root)
+    return [c for c in ENTRY_CANDIDATES if (root / c).is_file()]
+
+
+def get_git_summary(root: Path | str) -> dict[str, object]:
+    """Ringkasan git via subprocess. Bukan repo → {"is_repo": False}."""
+    root = Path(root)
+    try:
+        branch = subprocess.run(
+            ["git", "-C", str(root), "branch", "--show-current"],
+            capture_output=True, text=True, timeout=5)
+        if branch.returncode != 0:
+            return {"is_repo": False}
+        status = subprocess.run(
+            ["git", "-C", str(root), "status", "--porcelain"],
+            capture_output=True, text=True, timeout=5)
+    except (OSError, subprocess.SubprocessError):
+        return {"is_repo": False}
+    modified = untracked = 0
+    if status.returncode == 0:
+        for line in status.stdout.splitlines():
+            if line.startswith("??"):
+                untracked += 1
+            elif line.strip():
+                modified += 1
+    return {
+        "is_repo": True,
+        "branch": branch.stdout.strip() or "(detached)",
+        "modified": modified,
+        "untracked": untracked,
+    }
+
+
+def _parse_dependencies(key_files: dict[str, str]) -> str:
+    req = key_files.get("requirements.txt", "")
+    names: list[str] = []
+    for line in req.splitlines():
+        line = line.strip()
+        if not line or line.startswith(("#", "-")):
+            continue
+        for sep in ("==", ">=", "<=", "~=", "!=", ">", "<", ";", "["):
+            line = line.split(sep)[0]
+        line = line.strip()
+        if line:
+            names.append(line)
+    if names:
+        shown = ", ".join(names[:12])
+        return shown + ("…" if len(names) > 12 else "")
+    if "pyproject.toml" in key_files:
+        return "(lihat pyproject.toml)"
+    if "package.json" in key_files:
+        return "(lihat package.json)"
+    return "-"
+
+
+def scan_project(root: Path | str = ".") -> str:
+    """Scan project → string ProjectContext (tidak pernah raise)."""
+    try:
+        return _scan_project(Path(root).expanduser())
+    except Exception as e:
+        return f"Project: (scan gagal: {type(e).__name__}: {e})"
+
+
+def _scan_project(root: Path) -> str:
+    name = root.resolve().name
+    ptype = detect_project_type(root)
+    key_files = get_key_files(root)
+    tree = build_file_tree(root)
+    entries = get_entry_points(root)
+    git = get_git_summary(root)
+
+    readme = key_files.get("README.md", "").replace("\n", " ").strip()
+    readme = (readme[:500] + "…") if len(readme) > 500 else (readme or "-")
+
+    if git.get("is_repo"):
+        git_line = (f"branch '{git['branch']}', "
+                    f"{git['modified']} modified, {git['untracked']} untracked")
+    else:
+        git_line = "bukan git repo"
+
+    return (
+        f"Project: {name}\n"
+        f"Type: {ptype}\n"
+        f"Entry point: {', '.join(entries) if entries else '-'}\n"
+        f"Dependencies: {_parse_dependencies(key_files)}\n"
+        f"Structure:\n{tree}\n"
+        f"Git: {git_line}\n"
+        f"README: {readme}"
+    )
+
+
+def project_label(root: Path | str = ".") -> str:
+    """Label satu baris buat status/welcome: `nama · Tipe · branch +M ~U`."""
+    root = Path(root)
+    git = get_git_summary(root)
+    if git.get("is_repo"):
+        return (f"{root.resolve().name} · {detect_project_type(root)} · "
+                f"{git['branch']} +{git['modified']} ~{git['untracked']}")
+    return f"{root.resolve().name} · {detect_project_type(root)}"
+
+
+if __name__ == "__main__":
+    import tempfile
+
+    tmp = Path(tempfile.mkdtemp(prefix="multacd-codebase-"))
+    (tmp / "README.md").write_text("# Demo\nProject contoh untuk test.\n" * 5)
+    (tmp / "requirements.txt").write_text("textual>=8\nlitellm==1.100.0\n# komen\n")
+    (tmp / "main.py").write_text("print('hi')\n")
+    (tmp / "PLAN.md").write_text("planning, harus di-skip")
+    (tmp / "soul.md").write_text("kepribadian, harus di-skip")
+    (tmp / ".env").write_text("SECRET=xxx")
+    (tmp / ".venv").mkdir()
+    (tmp / ".venv" / "x.py").write_text("dep, harus di-skip")
+    (tmp / "__pycache__").mkdir()
+    (tmp / "__pycache__" / "a.pyc").write_bytes(b"\x00")
+    (tmp / "plan").mkdir()
+    (tmp / "sub").mkdir()
+    (tmp / "sub" / "deep.py").write_text("x=1\n")
+
+    # 1. Deteksi Python + entry point
+    assert detect_project_type(tmp) == "Python", detect_project_type(tmp)
+    assert get_entry_points(tmp) == ["main.py"]
+    assert detect_project_type(tempfile.mkdtemp()) == "Generic"
+
+    # 2. Tree skip yang harus di-skip, tampilkan yang relevan
+    tree = build_file_tree(tmp)
+    for bad in ("PLAN.md", "soul.md", ".env", ".venv", "__pycache__", "plan", ".pyc"):
+        assert bad not in tree, (bad, tree)
+    for good in ("main.py", "README.md", "requirements.txt", "sub/", "deep.py"):
+        assert good in tree, (good, tree)
+
+    # 3. Key files: baca yang perlu, potong yang panjang
+    keys = get_key_files(tmp)
+    assert set(keys) == {"README.md", "requirements.txt"}, set(keys)
+
+    # 4. Bukan git repo → fallback sopan
+    assert get_git_summary(tmp) == {"is_repo": False}
+
+    # 5. scan_project lengkap + format sesuai spec
+    ctx = scan_project(tmp)
+    for needle in ("Project: ", "Type: Python", "Entry point: main.py",
+                   "textual, litellm", "Structure:", "Git: bukan git repo",
+                   "README: # Demo"):
+        assert needle in ctx, (needle, ctx[:300])
+    assert "SECRET" not in ctx and "planning" not in ctx
+
+    # 6. Folder hilang / aneh → tidak crash
+    assert "tidak ditemukan" in build_file_tree(tmp / "nope")
+    assert scan_project(tmp / "nope").startswith("Project: nope")
+    assert "scan gagal" not in scan_project(tmp / "nope")
+
+    # 7. Repo asli multacd ke-scan beneran
+    real = Path(__file__).resolve().parent.parent
+    ctx = scan_project(real)
+    assert "Type: Python" in ctx and "agent_loop.py" in ctx, ctx[:500]
+    assert "soul.md" not in ctx.split("Structure:")[1].split("Git:")[0]
+
+    print("✅ codebase self-test OK (7 skenario)")

core/config.py

@@ -0,0 +1,340 @@
+"""Config system (BYOK) — baca & validasi ~/.multacd/config.yaml.
+
+Jalankan langsung untuk test cepat:
+    python -m core.config
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+from typing import Literal
+
+import yaml
+from pydantic import BaseModel, Field, ValidationError, field_validator
+
+# Hormati MULTACD_HOME (isolation test) — konsisten dengan memory/store.py
+# dan tools/agent/skill.py. Dievaluasi saat import; test set env sebelum subprocess.
+CONFIG_DIR = Path(os.environ.get("MULTACD_HOME", str(Path.home()))) / ".multacd"
+DEFAULT_CONFIG_PATH = CONFIG_DIR / "config.yaml"
+ENV_CONFIG_OVERRIDE = "MULTACD_CONFIG"
+
+EXAMPLE_CONFIG = """\
+# ~/.multacd/config.yaml — contoh config lengkap multacd (BYOK)
+
+# ── Model (wajib diisi) ──────────────────────────────
+model: "anthropic/claude-sonnet-4-6"
+api_key: "sk-ant-xxxx"
+
+# Contoh provider lain (uncomment salah satu):
+#
+# OpenAI
+# model: "openai/gpt-4o"
+# api_key: "sk-xxxx"
+#
+# Google Gemini
+# model: "gemini/gemini-2.0-flash"
+# api_key: "AIzaxxxx"
+#
+# Groq (cepat & murah)
+# model: "groq/llama-3.3-70b-versatile"
+# api_key: "gsk_xxxx"
+#
+# Ollama (lokal, gratis)
+# model: "ollama/llama3.2"
+# api_base: "http://localhost:11434"
+# api_key: "none"
+#
+# Custom OpenAI-compatible endpoint
+# model: "openai/nama-model"
+# api_base: "https://endpoint-kamu.com/v1"
+# api_key: "key-kamu"
+
+# ── Agent Settings ───────────────────────────────────
+max_tokens: 8096
+temperature: 0.3
+max_tool_iterations: 20      # batas loop per task, hindari infinite loop
+
+# ── Permission Settings ──────────────────────────────
+auto_approve_reads: true     # semua tool READ → langsung jalan
+ask_before_write: true       # semua tool WRITE → konfirmasi dulu
+ask_before_bash: true        # bash → konfirmasi dulu
+ask_before_web: true         # web_fetch → konfirmasi dulu
+
+# ── Display Settings ─────────────────────────────────
+theme: "dark"                # dark | light | catppuccin-mocha | catppuccin-latte
+                             # | catppuccin-frappe | catppuccin-macchiato
+                             # (dark/light = alias mocha/latte)
+show_tool_calls: true        # tampilkan nama tool yang dijalankan
+show_thinking: false         # tampilkan reasoning LLM (verbose mode)
+icon_style: "auto"           # auto | nerdfonts | unicode | ascii
+
+# ── Search Provider (BYOK, Phase 3) ────────────────────
+search_provider: "tavily"    # tavily | exa | brave | serpapi | duckduckgo
+search_api_key: "tvly-xxxx"  # tidak perlu untuk duckduckgo (gratis, tidak resmi)
+
+# ── Research Settings (Phase 3) ────────────────────────
+search_results_per_query: 5     # hasil per query saat search
+research_quick_queries: 3       # jumlah query untuk quick research
+research_quick_max_sources: 5   # max sumber yang dibaca quick research
+research_deep_rounds: 5         # max round untuk deep research
+research_deep_queries_per_round: 4  # query per round di deep research
+research_deep_max_sources: 20   # max total sumber deep research
+research_scrape_timeout: 15     # timeout scraping per URL (detik)
+research_snippet_fallback: true # pakai snippet kalau scraping gagal
+
+# ── Telegram Bot (Phase 4, opsional) ───────────────────
+# Diisi via setup wizard atau manual. Kosong = bot nonaktif.
+# telegram:
+#   bot_token: "123456:AAF..."  # dari @BotFather
+#   admin_id: 123456789         # Telegram user ID kamu
+#   admin_username: "usernamekamu"
+#   allowed_users: [987654321]
+
+# ── Scheduler (Phase 4, opsional) ──────────────────────
+# schedules:
+#   - name: "daily_briefing"
+#     cron: "0 7 * * *"
+#     action: "briefing"
+#     channel: "telegram"
+
+# ── Daily Briefing (Phase 4, opsional) ─────────────────
+# briefing:
+#   todo: true
+#   git_status: true
+#   news: true
+#   news_topics: ["artificial intelligence"]
+#   news_sources: 3
+"""
+
+
+class TelegramConfig(BaseModel):
+    """Kredensial bot + whitelist (Phase 4). Default kosong = nonaktif."""
+
+    bot_token: str = ""
+    admin_id: int = 0
+    admin_username: str = ""
+    allowed_users: list[int] = Field(default_factory=list)
+
+
+class ScheduleConfig(BaseModel):
+    """Satu jadwal cron (Phase 4). channel: telegram (saat ini satu-satunya)."""
+
+    name: str = Field(min_length=1)
+    cron: str = Field(min_length=1)
+    action: Literal["briefing", "research"] = "briefing"
+    topic: str = ""
+    channel: str = "telegram"
+
+
+class BriefingConfig(BaseModel):
+    """Konten daily briefing (Phase 4)."""
+
+    todo: bool = True
+    news: bool = True
+    git_status: bool = True
+    weather: bool = False  # Phase 5 (butuh API cuaca)
+    news_topics: list[str] = Field(
+        default_factory=lambda: ["artificial intelligence",
+                                 "software engineering"])
+    news_sources: int = Field(default=3, gt=0)
+
+
+class Config(BaseModel):
+    """Config utama multacd. Field flat 1:1 dengan contoh config.yaml."""
+
+    # ── Model (wajib) ──
+    model: str = Field(min_length=1)
+    api_key: str = Field(min_length=1)
+    api_base: str | None = None
+
+    # ── Agent settings ──
+    max_tokens: int = Field(default=8096, gt=0)
+    temperature: float = Field(default=0.3, ge=0.0, le=2.0)
+    max_tool_iterations: int = Field(default=20, gt=0)
+
+    # ── Permission settings ──
+    auto_approve_reads: bool = True
+    ask_before_write: bool = True
+    ask_before_bash: bool = True
+    ask_before_web: bool = True
+
+    # ── Display settings ──
+    theme: Literal["dark", "light", "catppuccin-mocha", "catppuccin-latte",
+                   "catppuccin-frappe", "catppuccin-macchiato"] = "dark"
+    show_tool_calls: bool = True
+    show_thinking: bool = False
+    icon_style: Literal["auto", "nerdfonts", "unicode", "ascii"] = "auto"
+
+    # ── Search provider (BYOK, Phase 3) ──
+    search_provider: Literal["tavily", "exa", "brave", "serpapi", "duckduckgo"] = "tavily"
+    search_api_key: str = ""
+
+    # ── Research settings (Phase 3) ──
+    search_results_per_query: int = Field(default=5, gt=0)
+    research_quick_queries: int = Field(default=3, gt=0)
+    research_quick_max_sources: int = Field(default=5, gt=0)
+    research_deep_rounds: int = Field(default=5, gt=0, le=10)
+    research_deep_queries_per_round: int = Field(default=4, gt=0)
+    research_deep_max_sources: int = Field(default=20, gt=0)
+    research_scrape_timeout: int = Field(default=15, gt=0)
+    research_snippet_fallback: bool = True
+
+    # ── Personal agent (Phase 4, opsional) ──
+    telegram: TelegramConfig = Field(default_factory=TelegramConfig)
+    schedules: list[ScheduleConfig] = Field(default_factory=list)
+    briefing: BriefingConfig = Field(default_factory=BriefingConfig)
+
+    @field_validator("search_provider", mode="before")
+    @classmethod
+    def _norm_provider(cls, v: object) -> object:
+        # "Tavily", " TAVILY " → "tavily" (maafkan kapital/spasi user).
+        return v.lower().strip() if isinstance(v, str) else v
+
+    @field_validator("theme", mode="before")
+    @classmethod
+    def _norm_theme(cls, v: object) -> object:
+        # "Dark", " MOCHA " → canonical ("dark", "mocha" bukan nama penuh
+        # tetap ditolak pydantic dengan pesan jelas — cuma maafkan case).
+        return v.lower().strip() if isinstance(v, str) else v
+
+
+class ConfigError(Exception):
+    """Error config yang friendly — pesannya bisa langsung ditampilkan ke user."""
+
+
+# ── Active config sesi (Bug 3) ───────────────────────────────────────────
+# Tool research (quick/deep_research, web_search, query_generator) tidak
+# menerima config dari LLM — mereka membaca dari sini. MultacdApp memasang
+# config-nya saat init, jadi `--config PATH` dan `/model X` tetap dihormati.
+# None → fallback load_config() seperti dulu (pemakaian standalone/CLI).
+_active_config: Config | None = None
+
+
+def set_active_config(cfg: Config | None) -> None:
+    """Pasang/cabut (None) config aktif sesi. Dipanggil MultacdApp saat init."""
+    global _active_config
+    _active_config = cfg
+
+
+def get_active_config() -> Config | None:
+    """Config sesi yang sedang jalan, atau None kalau tidak ada."""
+    return _active_config
+
+
+def resolve_config_path(explicit: Path | str | None = None) -> Path:
+    """Urutan prioritas: argumen eksplisit > $MULTACD_CONFIG > ~/.multacd/config.yaml."""
+    if explicit is not None:
+        return Path(explicit).expanduser()
+    env = os.environ.get(ENV_CONFIG_OVERRIDE)
+    if env:
+        return Path(env).expanduser()
+    return DEFAULT_CONFIG_PATH
+
+
+def _setup_message(path: Path) -> str:
+    return (
+        "⚡ multacd — config belum ditemukan.\n"
+        "\n"
+        f"File yang dicari: {path}\n"
+        "\n"
+        "Cara setup (sekali saja):\n"
+        f"  1. Buat foldernya : mkdir -p {path.parent}\n"
+        f"  2. Simpan contoh di bawah ini sebagai: {path}\n"
+        "  3. Isi `model` dan `api_key` sesuai provider kamu (BYOK)\n"
+        "  4. Jalankan lagi: python main.py\n"
+        "\n"
+        "────── contoh config ──────\n"
+        f"{EXAMPLE_CONFIG}"
+        "───────────────────────────\n"
+    )
+
+
+def load_config(explicit_path: Path | str | None = None) -> Config:
+    """Baca & validasi config. Exit(1) dengan pesan jelas kalau ada masalah."""
+    path = resolve_config_path(explicit_path)
+
+    # Buat folder ~/.multacd/ kalau belum ada (aman dipanggil berulang).
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+    except OSError as e:
+        print(f"❌ Gagal membuat folder config {path.parent}: {e}", file=sys.stderr)
+        raise SystemExit(1) from e
+
+    if not path.is_file():
+        print(_setup_message(path))
+        raise SystemExit(1)
+
+    try:
+        raw = yaml.safe_load(path.read_text(encoding="utf-8"))
+    except yaml.YAMLError as e:
+        print(f"❌ config.yaml bukan YAML valid: {path}\n   Detail: {e}", file=sys.stderr)
+        raise SystemExit(1) from e
+    except OSError as e:
+        print(f"❌ Gagal membaca config {path}: {e}", file=sys.stderr)
+        raise SystemExit(1) from e
+
+    if not isinstance(raw, dict) or not raw:
+        print(
+            f"❌ config.yaml kosong atau tidak berbentuk key: value: {path}\n"
+            "   Isi dengan contoh config (jalankan tanpa config untuk melihatnya).",
+            file=sys.stderr,
+        )
+        raise SystemExit(1)
+
+    try:
+        cfg = Config(**raw)
+    except ValidationError as e:
+        print(f"❌ config.yaml tidak valid: {path}", file=sys.stderr)
+        for err in e.errors():
+            field = ".".join(str(p) for p in err["loc"])
+            print(f"   • {field}: {err['msg']}", file=sys.stderr)
+        print("   Lihat contoh field yang benar di pesan setup.", file=sys.stderr)
+        raise SystemExit(1) from e
+
+    if not cfg.model.strip():
+        print("❌ Field `model` wajib diisi (contoh: anthropic/claude-sonnet-4-6).", file=sys.stderr)
+        raise SystemExit(1)
+    if not cfg.api_key.strip():
+        print("❌ Field `api_key` wajib diisi (BYOK — pakai key provider kamu).", file=sys.stderr)
+        raise SystemExit(1)
+
+    return cfg
+
+
+def _mask_key(key: str) -> str:
+    if len(key) <= 6:
+        return "***"
+    return f"{key[:4]}***{key[-2:]}"
+
+
+if __name__ == "__main__":
+    cfg = load_config()
+
+    # Active config (Bug 3): set/get/clear simetris.
+    set_active_config(cfg)
+    assert get_active_config() is cfg
+    set_active_config(None)
+    assert get_active_config() is None
+
+    # Phase 4: nested default + parse dari dict.
+    assert cfg.telegram.bot_token == "" and cfg.schedules == []
+    assert cfg.briefing.news_sources == 3
+    legacy = Config(model="m", api_key="k")  # yaml lama tanpa phase4
+    assert legacy.telegram.admin_id == 0 and legacy.briefing.todo
+    full = Config(model="m", api_key="k", telegram={
+        "bot_token": "t", "admin_id": 1, "admin_username": "u",
+        "allowed_users": [2]},
+        schedules=[{"name": "j", "cron": "0 7 * * *",
+                     "action": "briefing"}])
+    assert full.telegram.admin_id == 1 and full.schedules[0].cron == "0 7 * * *"
+
+    print("✅ Config loaded OK")
+    print(f"   model               : {cfg.model}")
+    print(f"   api_key             : {_mask_key(cfg.api_key)}")
+    print(f"   api_base            : {cfg.api_base or '(default provider)'}")
+    print(f"   max_tokens          : {cfg.max_tokens}")
+    print(f"   temperature         : {cfg.temperature}")
+    print(f"   max_tool_iterations : {cfg.max_tool_iterations}")
+    print(f"   theme               : {cfg.theme}")