multacd 1.0.0__py3-none-any.whl

briefing/__init__.py

@@ -0,0 +1,6 @@
+"""Briefing package — daily briefing generator (Phase 4).
+
+Step 1: privacy filter. Step 7: sources + generator.
+"""
+
+from __future__ import annotations

briefing/generator.py

@@ -0,0 +1,125 @@
+"""Briefing generator — kumpul → filter privasi → narasi LLM → gabung.
+
+cepat:
+    python -m briefing.generator
+"""
+
+from __future__ import annotations
+
+import datetime
+from typing import Any
+
+from briefing.privacy import PrivacyFilter
+from briefing.sources.git_source import get_git_status
+from briefing.sources.news_source import get_news_sync
+from briefing.sources.todo_source import get_todos
+
+_HARI = ["Senin", "Selasa", "Rabu", "Kamis", "Jumat", "Sabtu", "Minggu"]
+_BULAN = ["", "Jan", "Feb", "Mar", "Apr", "Mei", "Jun",
+          "Jul", "Agu", "Sep", "Okt", "Nov", "Des"]
+
+NARRATIVE_PROMPT = (
+    "Buat briefing pagi yang ringkas dan informatif dari data berikut. "
+    "Bahasa: Indonesia santai tapi informatif. "
+    "Format: teks biasa untuk Telegram (tanpa markdown, tanpa header #). "
+    "Fokus pada yang actionable.\n\nDATA:\n{data}")
+
+
+def _today_str(today: datetime.date | None = None) -> str:
+    today = today or datetime.date.today()
+    return (f"{_HARI[today.weekday()]}, {today.day} "
+            f"{_BULAN[today.month]} {today.year}")
+
+
+def _collect_raw(cfg: Any, research_fn: Any = None,
+                 todo_extra: Any = None, projects: Any = None) -> str:
+    """Kumpulkan data mentah semua section yang aktif di config."""
+    b = cfg.briefing
+    blocks: list[str] = []
+    if b.todo:
+        todos = get_todos(todo_extra)
+        blocks.append("TODO:\n" + ("\n".join(f"- {t}" for t in todos)
+                                  if todos else "(tidak ada todo pending)"))
+    if b.git_status:
+        statuses = get_git_status(projects)
+        blocks.append("GIT:\n" + ("\n".join(statuses)
+                                  if statuses else "(tidak ada project)"))
+    if b.news:
+        topics = list(b.news_topics or [])
+        if topics:
+            news = get_news_sync(topics, research_fn, b.news_sources)
+            lines = [f"[{t}] {news.get(t, '-')}" for t in topics]
+            blocks.append("BERITA:\n" + "\n".join(lines))
+    return "\n\n".join(blocks)
+
+
+async def _narrate(llm: Any, clean: str) -> str:
+    done = await llm.complete(
+        [{"role": "user",
+          "content": NARRATIVE_PROMPT.format(data=clean[:12000])}])
+    return (done.text or "").strip() or "(LLM tidak memberi narasi)"
+
+
+def generate_briefing(config: Any = None, llm: Any = None,
+                      research_fn: Any = None,
+                      todo_extra: Any = None, projects: Any = None,
+                      today: datetime.date | None = None) -> str:
+    """Generate teks briefing lengkap (sync — aman dari job thread)."""
+    from tools.research.quick_research import _run_coro
+
+    if config is None:
+        from core.config import get_active_config, load_config
+        config = get_active_config() or load_config()
+    if llm is None:
+        from core.llm_client import setup_client
+        llm = setup_client(config)
+
+    raw = _collect_raw(config, research_fn, todo_extra, projects)
+    clean, private = PrivacyFilter().filter(raw)
+    narrative = (_run_coro(_narrate(llm, clean)) if clean.strip()
+                 else "(tidak ada data briefing hari ini)")
+    parts = [f"Briefing Pagi — {_today_str(today)}", "", narrative]
+    if private:
+        parts += ["", "─────", "PRIVATE (tidak dikirim ke AI):",
+                  *("- " + item for item in private)]
+    return "\n".join(parts).strip()
+
+
+if __name__ == "__main__":
+    import os
+    import tempfile
+    from pathlib import Path
+    from types import SimpleNamespace
+
+    from core.llm_client import StreamDone
+
+    seen_prompts: list[str] = []
+
+    class _FakeLLM:
+        async def complete(self, messages: list) -> StreamDone:
+            seen_prompts.append(messages[0]["content"])
+            return StreamDone("Ringkasan: 2 todo, git bersih.", [])
+
+    async def _fake_news(topic: str) -> str:
+        return f"kabar {topic}: baik"
+
+    with tempfile.TemporaryDirectory() as d:
+        os.environ["MULTACD_HOME"] = d
+        todo = Path(d) / "todo.md"
+        todo.write_text("- Fix bug\n- [private] Password db: s3cr3t\n",
+                        encoding="utf-8")
+        cfg = SimpleNamespace(briefing=SimpleNamespace(
+            todo=True, news=True, git_status=False, news_topics=["AI"],
+            news_sources=3))
+        out = generate_briefing(config=cfg, llm=_FakeLLM(),
+                                research_fn=_fake_news,
+                                todo_extra=[todo],
+                                today=datetime.date(2026, 9, 11))
+        assert "Briefing Pagi — Jumat, 11 Sep 2026" in out
+        assert "Ringkasan" in out and "Fix bug" not in out.split("PRIVATE")[0]
+        assert "s3cr3t" in out.split("PRIVATE")[1]  # private ada di akhir
+        assert "s3cr3t" not in seen_prompts[0]  # TIDAK bocor ke LLM
+        assert "kabar AI" in seen_prompts[0]  # berita masuk LLM
+        del os.environ["MULTACD_HOME"]
+
+    print("✅ generator self-test OK (narrate + privacy no-leak)")

briefing/privacy.py

@@ -0,0 +1,112 @@
+"""Privacy filter — pisahkan item sensitif sebelum data dikirim ke LLM.
+
+Kontrak (PLAN Phase 4 §5):
+    filter(content) -> (clean_content, private_items)
+    - Baris bertag [private] (semua format, case-insensitive) → private.
+    - Baris auto-sensitif (password, api key, token panjang) → private.
+    - clean_content aman dikirim ke LLM; private_items diproses lokal.
+
+Test cepat:
+    python -m briefing.privacy
+"""
+
+from __future__ import annotations
+
+import re
+
+# Tag eksplisit: [private], # private:, >>private: (case-insensitive).
+PRIVATE_PATTERNS = [
+    r"\[private\]",
+    r"#\s*private\s*:",
+    r">>\s*private\s*:",
+]
+
+# Auto-detect: pola password/secret/kunci + token panjang mirip API key.
+AUTO_SENSITIVE_PATTERNS = [
+    r"password[:\s=]",
+    r"passwd[:\s=]",
+    r"secret[:\s=]",
+    r"api.?key[:\s=]",
+    r"\b(?:sk|tvly|exa|brv|tavily)[-_][A-Za-z0-9_\-]{8,}",
+    r"\b[A-Za-z0-9_\-]{20,}\b",
+    r"\b\d{4}[-\s]?\d{4}[-\s]?\d{2,}\b",
+]
+
+_TAG_RE = re.compile("|".join(f"(?:{p})" for p in PRIVATE_PATTERNS),
+                     re.IGNORECASE)
+_AUTO_RES = [re.compile(p, re.IGNORECASE)
+             for p in AUTO_SENSITIVE_PATTERNS]
+
+
+def _clean_item(line: str) -> str:
+    """Buang tag [private] + marker list, sisakan isi mentah."""
+    item = _TAG_RE.sub("", line).strip()
+    return re.sub(r"^[\-\*>\s]+", "", item).strip()
+
+
+class PrivacyFilter:
+    """Filter stateless — satu instance bisa dipakai ulang."""
+
+    def is_sensitive_line(self, line: str) -> bool:
+        """True kalau baris bertag private atau cocok pola sensitif."""
+        if not line or not line.strip():
+            return False
+        if _TAG_RE.search(line):
+            return True
+        return any(r.search(line) for r in _AUTO_RES)
+
+    def filter(self, content: str) -> tuple[str, list[str]]:
+        """Pisahkan konten. Return (bersih_untuk_LLM, item_private)."""
+        if not content:
+            return "", []
+        clean_lines: list[str] = []
+        private_items: list[str] = []
+        for line in content.splitlines():
+            if self.is_sensitive_line(line):
+                item = _clean_item(line)
+                private_items.append(item or line.strip())
+            else:
+                clean_lines.append(line)
+        return "\n".join(clean_lines), private_items
+
+
+if __name__ == "__main__":
+    f = PrivacyFilter()
+
+    # 1. Semua format tag eksplisit (case-insensitive).
+    for tag in ("[private] Password db: x", "[PRIVATE] No rek: 1",
+                "- # private: antar obat", ">>private: token abc",
+                ">>PRIVATE: rahasia", "# PRIVATE: pin"):
+        assert f.is_sensitive_line(tag), tag
+        clean, priv = f.filter(tag)
+        assert clean.strip() == "" and len(priv) == 1, tag
+        assert _TAG_RE.search(tag) and not _TAG_RE.search(priv[0]), tag
+
+    # 2. Baris biasa lolos, kosong diabaikan.
+    assert not f.is_sensitive_line("Beli susu besok")
+    assert not f.is_sensitive_line("")
+    assert not f.is_sensitive_line("   ")
+
+    # 3. Auto-detect tanpa tag: password + key panjang.
+    assert f.is_sensitive_line("db password: hunter2")
+    assert f.is_sensitive_line("api_key=tvly-abc123XYZ")
+    assert f.is_sensitive_line("token sk-ant-abcd1234efgh")
+    assert f.is_sensitive_line("kartu 1234-5678-9012")
+
+    # 4. Campuran: bersih tidak bocor, private lengkap.
+    mixed = "\n".join([
+        "- Beli susu besok",
+        "[private] Password database: xxxxx",
+        "- Meeting klien jam 3",
+        "api_key = sk-1234567890abcdefghij",
+    ])
+    clean, priv = f.filter(mixed)
+    assert "Beli susu" in clean and "Meeting" in clean
+    assert "xxxxx" not in clean and "sk-1234" not in clean
+    assert len(priv) == 2 and "Password database" in priv[0]
+
+    # 5. Kosong & tanpa private.
+    assert f.filter("") == ("", [])
+    assert f.filter("a\nb") == ("a\nb", [])
+
+    print("✅ privacy self-test OK (tag + auto-detect + no-leak)")

briefing/sources/__init__.py

@@ -0,0 +1,3 @@
+"""Briefing sources package — todo/git/news (diisi Step 7)."""
+
+from __future__ import annotations

briefing/sources/git_source.py

@@ -0,0 +1,77 @@
+"""Git source — ringkasan status project (PLAN Phase 4 Step 7).
+
+Default [cwd] + path eksplisit yang mengandung .git. Via git CLI langsung
+(sync, tanpa dependensi tools.git).
+
+Test cepat:
+    python -m briefing.sources.git_source
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+
+def get_projects(extra: list[str | Path] | None = None) -> list[Path]:
+    """Project = cwd + path eksplisit bervolume .git (unik, yang ada saja)."""
+    seen: list[Path] = []
+    for raw in [Path.cwd(), *(Path(p) for p in (extra or []))]:
+        try:
+            p = raw.resolve()
+        except OSError:
+            continue
+        if (p / ".git").is_dir() and p not in seen:
+            seen.append(p)
+    return seen
+
+
+def _git(args: list[str], cwd: Path, timeout: int = 10) -> str | None:
+    try:
+        proc = subprocess.run(
+            ["git", *args], cwd=cwd, capture_output=True, text=True,
+            timeout=timeout)
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if proc.returncode != 0:
+        return None
+    return proc.stdout.strip()
+
+
+def git_summary(path: str | Path) -> str:
+    """Satu baris ringkas: 'nama (branch): N berubah, commit terakhir ...'."""
+    p = Path(path)
+    branch = _git(["branch", "--show-current"], p) or "?"
+    porcelain = _git(["status", "--porcelain"], p)
+    changed = len(porcelain.splitlines()) if porcelain else 0
+    last = _git(["log", "-1", "--format=%h %s (%ar)"], p) or "belum ada commit"
+    return (f"{p.name} ({branch}): {changed} file berubah, "
+            f"terakhir {last}")
+
+
+def get_git_status(extra: list[str | Path] | None = None) -> list[str]:
+    """Ringkasan semua project yang ketemu."""
+    return [git_summary(p) for p in get_projects(extra)]
+
+
+if __name__ == "__main__":
+    import tempfile
+
+    with tempfile.TemporaryDirectory() as d:
+        repo = Path(d) / "demo"
+        repo.mkdir()
+        assert repo.resolve() not in get_projects(extra=[repo])  # bukan git
+        subprocess.run(["git", "init", "-q"], cwd=repo, check=True)
+        subprocess.run(["git", "config", "user.email", "t@t.id"],
+                       cwd=repo, check=True)
+        subprocess.run(["git", "config", "user.name", "t"], cwd=repo,
+                       check=True)
+        (repo / "a.txt").write_text("hi", encoding="utf-8")
+        subprocess.run(["git", "add", "."], cwd=repo, check=True)
+        subprocess.run(["git", "commit", "-qm", "awal"], cwd=repo, check=True)
+        (repo / "b.txt").write_text("baru", encoding="utf-8")
+        assert repo.resolve() in get_projects(extra=[repo])
+        s = git_summary(repo)
+        assert "demo" in s and "1 file berubah" in s and "awal" in s, s
+
+    print("✅ git_source self-test OK (detect + summary)")

briefing/sources/news_source.py

@@ -0,0 +1,76 @@
+"""News source — riset berita per topik, paralel (PLAN Phase 4 Step 7).
+
+research_fn(topic) -> str di-inject biar test tanpa network.
+Default: orchestrator quick_research (active config → setup_client).
+
+Test cepat:
+    python -m briefing.sources.news_source
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+ResearchFn = Callable[[str], Awaitable[str]]
+
+
+async def _default_research(topic: str, max_sources: int = 3) -> str:
+    from core.config import get_active_config, load_config
+    from core.llm_client import setup_client
+    from core.research.orchestrator import quick_research as _qr
+
+    config = get_active_config() or load_config()
+    llm = setup_client(config)
+    res = await _qr(f"latest news about {topic}", config=config, llm=llm)
+    answer = (res.answer or "").strip()
+    shown = (res.sources[:max_sources]
+             if max_sources > 0 and len(res.sources) > max_sources
+             else res.sources)
+    if shown:
+        names = ", ".join(getattr(s, "title", "?") or "?" for s in shown)
+        answer += f" ({len(shown)} sumber: {names})"
+    return answer or "(tidak ada berita ditemukan)"
+
+
+async def get_news(topics: list[str],
+                   research_fn: ResearchFn | None = None,
+                   max_sources: int = 3) -> dict[str, str]:
+    """Riset semua topik paralel. Gagal satu → pesan, bukan raise."""
+    async def _one(topic: str) -> tuple[str, str]:
+        try:
+            if research_fn is not None:
+                return topic, await research_fn(topic)
+            return topic, await _default_research(topic, max_sources)
+        except Exception as e:
+            return topic, f"(gagal riset: {e})"
+
+    results = await asyncio.gather(*[_one(t) for t in topics])
+    return dict(results)
+
+
+def get_news_sync(topics: list[str], research_fn: Any = None,
+                  max_sources: int = 3) -> dict[str, str]:
+    """Wrapper sync (dipakai generator yang jalan di job thread)."""
+    from tools.research.quick_research import _run_coro
+    return _run_coro(get_news(topics, research_fn, max_sources))
+
+
+if __name__ == "__main__":
+    async def _fake(topic: str) -> str:
+        if topic == "rusak":
+            raise RuntimeError("jaringan putus")
+        return f"berita {topic}: model baru rilis"
+
+    async def _go() -> None:
+        out = await get_news(["AI", "rusak"], _fake)
+        assert out["AI"] == "berita AI: model baru rilis"
+        assert "gagal riset" in out["rusak"]
+        assert await get_news([], _fake) == {}
+
+    asyncio.run(_go())
+    out = get_news_sync(["AI"], _fake)
+    assert out == {"AI": "berita AI: model baru rilis"}, out
+
+    print("✅ news_source self-test OK (paralel + gagal-satu)")

briefing/sources/todo_source.py

@@ -0,0 +1,69 @@
+"""Todo source — baca item belum selesai (PLAN Phase 4 Step 7).
+
+Cari: ./todo.md, ./TODO.md, ~/.multacd/todo.md (hormati MULTACD_HOME).
+Format: '- [ ] x' / '- x' / '* x' / '1. x'. Selesai ([x]/[X]) di-skip.
+
+Test cepat:
+    python -m briefing.sources.todo_source
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+
+_DONE_RE = re.compile(r"^\s*[-*]\s*\[[xX]\]\s*")
+_ITEM_RE = re.compile(r"^\s*(?:[-*]\s*(?:\[[ ]\]\s*)?|\d+[.)]\s*)(.+?)\s*$")
+
+
+def find_todo_files(extra: list[str | Path] | None = None) -> list[Path]:
+    """Kembalikan path todo yang ada (tidak raise kalau kosong)."""
+    candidates = [Path("todo.md"), Path("TODO.md"),
+                  Path(os.environ.get("MULTACD_HOME", str(Path.home())))
+                  / ".multacd" / "todo.md"]
+    if extra:
+        candidates.extend(Path(p) for p in extra)
+    return [p for p in candidates if p.is_file()]
+
+
+def parse_todo_file(path: str | Path) -> list[str]:
+    """Parse item belum selesai dari satu file."""
+    items: list[str] = []
+    try:
+        lines = Path(path).read_text(encoding="utf-8").splitlines()
+    except OSError:
+        return []
+    for line in lines:
+        if not line.strip() or _DONE_RE.match(line):
+            continue
+        m = _ITEM_RE.match(line)
+        if m and m.group(1).strip():
+            items.append(m.group(1).strip())
+    return items
+
+
+def get_todos(extra: list[str | Path] | None = None) -> list[str]:
+    """Semua todo pending dari semua file yang ketemu."""
+    out: list[str] = []
+    for path in find_todo_files(extra):
+        out.extend(parse_todo_file(path))
+    return out
+
+
+if __name__ == "__main__":
+    import tempfile
+
+    with tempfile.TemporaryDirectory() as d:
+        os.environ["MULTACD_HOME"] = d
+        assert get_todos() == []  # tidak ada file → kosong, bukan error
+        f = Path(d) / "todo.md"
+        f.write_text("# Hari ini\n- [ ] Fix bug agent\n- [x] Sudah ini\n"
+                     "- Beli susu\n1. Review PR\n", encoding="utf-8")
+        items = get_todos(extra=[f])
+        assert "Fix bug agent" in items and "Beli susu" in items
+        assert "Review PR" in items
+        assert not any("Sudah ini" in i for i in items)
+        del os.environ["MULTACD_HOME"]
+
+    print("✅ todo_source self-test OK (parse + skip-done)")