diary-docs 0.1.0__py3-none-any.whl

diary/cli.py

@@ -0,0 +1,999 @@
+import argparse
+import os
+import re
+import sys
+from pathlib import Path
+
+from rich.console import Console
+from rich.text import Text
+from InquirerPy import inquirer
+
+from diary.indexer.indexer import run_index
+from diary.indexer.reporter import generate_report
+from diary.sync.engine import run_sync, SyncConfig
+from diary.sync.protocol import serialize_report
+from diary.templates import CATALOG_TEMPLATE, MKDOCS_TEMPLATE, aimb_wrap_body
+
+console = Console()
+
+BANNER = r"""
+╔════════════════════════════════════════╗
+║                                        ║
+║ ██████╗ ██╗ █████╗ ██████╗ ██╗   ██╗   ║
+║ ██╔══██╗██║██╔══██╗██╔══██╗╚██╗ ██╔╝   ║
+║ ██║  ██║██║███████║██████╔╝ ╚████╔╝    ║
+║ ██║  ██║██║██╔══██║██╔══██╗  ╚██╔╝     ║
+║ ██████╔╝██║██║  ██║██║  ██║   ██║      ║
+║ ╚═════╝ ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝      ║
+║                                        ║
+╚════════════════════════════════════════╝
+"""
+
+
+SYNC_CONTENT = """\
+---
+description: Synchronize documentation AIMB blocks with detected code changes using the DIARY sync protocol
+---
+
+# /diary-sync
+
+Sinkronisasi dokumentasi dengan perubahan kode yang terdeteksi. Agent ini membaca output dari `diary sync --dry-run`, memproses perubahan satu per satu, dan menulis ulang konten AIMB block yang kedaluwarsa.
+
+## Prerequisites
+
+- `diary sync` CLI command harus sudah terinstall
+- Workspace harus dalam keadaan **clean git state** (no uncommitted changes selain yang dimaksud)
+- Dokumentasi harus sudah memiliki struktur AIMB blocks
+- **Semua perubahan kode harus sudah di-commit ke git** — diary sync membandingkan file saat ini dengan git history untuk mendeteksi perubahan. File yang untracked (`??` di git status) tidak akan terdeteksi sebagai perubahan. Commit dulu sebelum menjalankan sync.
+
+## SyncReport JSON Protocol
+
+Perintah `diary sync --dry-run` menghasilkan JSON dengan skema berikut:
+
+```json
+{
+  "branch": "feature/my-branch",
+  "timestamp": "2026-06-26T10:30:00+07:00",
+  "changes": [
+    {
+      "file_path": "src/services/auth.py",
+      "change_type": "modified",
+      "affected_docs": ["docs/techdocs/architecture.md"],
+      "confidence": 0.95
+    }
+  ],
+  "conflicts": [
+    {
+      "file_path": "docs/techdocs/architecture.md",
+      "block_id": "arch-auth-flow",
+      "old_hash": "abc123def456",
+      "current_hash": "789ghi012jkl",
+      "diff_preview": "@@ -10,6 +10,8 @@\\n ..."
+    }
+  ],
+  "stats": {
+    "files_scanned": 42,
+    "docs_updated": 0,
+    "conflicts": 1,
+    "duration_ms": 1523
+  }
+}
+```
+
+### Field Reference
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `branch` | string | Nama branch saat ini |
+| `timestamp` | string | ISO-8601 timestamp kapan sync dijalankan |
+| `changes[]` | array | Daftar perubahan kode yang terdeteksi |
+| `changes[].file_path` | string | Path file yang berubah (relative ke workspace) |
+| `changes[].change_type` | string | `"modified"`, `"added"`, atau `"deleted"` |
+| `changes[].affected_docs` | array | Path dokumentasi yang terpengaruh |
+| `changes[].confidence` | float | 0.0 – 1.0, seberapa yakin detektor |
+| `conflicts[]` | array | Daftar konflik AIMB block |
+| `conflicts[].file_path` | string | File dokumentasi yang konflik |
+| `conflicts[].block_id` | string | ID AIMB block yang bermasalah |
+| `conflicts[].old_hash` | string | Hash tersimpan terakhir |
+| `conflicts[].current_hash` | string | Hash saat ini di file |
+| `conflicts[].diff_preview` | string | Unified diff antara old dan current |
+| `stats.files_scanned` | int | Total file yang di-scan |
+| `stats.docs_updated` | int | Dokumentasi yang sudah di-update (0 saat dry-run) |
+| `stats.conflicts` | int | Jumlah konflik |
+| `stats.duration_ms` | int | Durasi scan dalam milidetik |
+
+## AIMB Blocks vs Manual Blocks
+
+### AIMB Block (AI-Managed Block)
+
+DIARY markdown files mungkin memiliki blok yang dikelola secara otomatis:
+
+```html
+<!-- ai-managed id="arch-overview" hash="a1b2c3d4" updated="2026-06-01" -->
+Ini adalah konten yang dihasilkan oleh AI agent.
+Setiap kali ada perubahan kode yang relevan, konten ini akan diperbarui.
+<!-- /ai-managed -->
+```
+
+Ciri-ciri:
+- Diawali dengan `<!-- ai-managed id="..." hash="..." updated="..." -->`
+- Diakhiri dengan `<!-- /ai-managed -->`
+- **Hash** adalah SHA-256 dari konten block. Digunakan untuk deteksi konflik.
+- **updated** adalah tanggal terakhir block ini diubah.
+- Agent BOLEH mengubah konten block ini.
+
+### Manual Block
+
+```html
+<!-- manual -->
+Ini adalah konten yang ditulis manual oleh user.
+Agent TIDAK BOLEH mengubah konten ini tanpa persetujuan eksplisit.
+<!-- /manual -->
+```
+
+Ciri-ciri:
+- Diawali dengan `<!-- manual -->`
+- Diakhiri dengan `<!-- /manual -->`
+- Agent TIDAK BOLEH mengubah konten di dalamnya.
+- Jika ada perubahan di luar AIMB block, itu dianggap manual edit.
+
+### Non-Block Content
+
+Konten markdown biasa (tanpa tag `<!-- ai-managed -->` atau `<!-- manual -->`) dianggap sebagai konten user yang tidak boleh disentuh oleh agent.
+
+## Workflow
+
+Agent WAJIB menjalankan langkah-langkah berikut secara berurutan:
+
+### Step 1: Verify Git State & Dry-Run Analysis
+
+**PENTING**: Sebelum menjalankan diary sync, pastikan semua perubahan kode sudah di-commit ke git.
+
+Periksa status git terlebih dahulu:
+
+```bash
+git status --short
+```
+
+Jika ada file dengan status `??` (untracked) atau `M` (modified) yang merupakan bagian dari fitur baru, **commit terlebih dahulu**:
+
+```bash
+git add <files>
+git commit -m "feat: deskripsi perubahan"
+```
+
+File yang tidak di-commit **tidak akan terdeteksi** oleh diary sync karena tidak ada git history untuk dibandingkan.
+
+Setelah git state clean, jalankan perintah berikut untuk mendapatkan analisis perubahan:
+
+```bash
+python -m diary sync --dry-run
+```
+
+Perintah ini mengembalikan JSON (SyncReport). Simpan output untuk referensi.
+
+**Jika command tidak ditemukan**, hentikan dan beri tahu user bahwa `diary sync` belum terinstall.
+
+### Step 2: Parse & Understand Change Scope
+
+Parsing output JSON dan pahami scope perubahan:
+
+1. **Periksa `conflicts[]`** — jika ada konflik, catat untuk step 4.
+2. **Periksa `changes[]`** — setiap entry adalah file kode yang berubah.
+3. **Perhatikan `confidence`**:
+   - `confidence >= 0.8`: perubahan jelas, aman diproses.
+   - `confidence < 0.8`: perubahan kurang jelas, tanya user sebelum memproses.
+4. **Perhatikan `affected_docs`** — ini adalah file dokumentasi yang perlu diperbarui.
+
+### Step 3: Process Each Change (High Confidence, No Conflict)
+
+Untuk setiap perubahan dengan `confidence >= 0.8` dan tanpa konflik:
+
+1. **Baca file dokumentasi yang terpengaruh** — gunakan path dari `affected_docs`.
+2. **Baca file kode yang berubah** — pahami perubahan apa yang terjadi.
+3. **Identifikasi AIMB block yang relevan** — cari `<!-- ai-managed id="..." ... -->` di file dokumentasi.
+4. **Generate konten baru**:
+   - Analisis perubahan kode: apa yang berubah, fungsi baru, parameter baru, behavior baru.
+   - Gunakan kemampuan AI untuk menghasilkan konten dokumentasi profesional.
+   - Ikuti DIARY documentation style (formal, terstruktur, Bahasa Indonesia + English terms).
+   - Konten harus akurat mencerminkan state kode yang baru.
+5. **Tulis konten baru** menggunakan fungsi `apply_replace()` logic dari merge module:
+   - Temukan AIMB block dengan ID yang sesuai.
+   - Ganti konten di antara open dan close tag.
+   - Hash dan tanggal akan diperbarui secara otomatis oleh `apply_replace()`.
+
+Jika sebuah file dokumentasi memiliki beberapa AIMB block, hanya update block yang relevan dengan perubahan kode tersebut.
+
+**PENTING**: Jangan mengubah konten di luar AIMB block. Jangan menyentuh manual blocks.
+
+### Step 4: Handle Conflicts (DO NOT Auto-Resolve)
+
+Jika ada `conflicts[]` di SyncReport:
+
+1. **Print conflict summary** dalam format yang mudah dibaca:
+
+   ```
+   ⚠️  Merge Conflicts Detected
+   
+   1. docs/techdocs/architecture.md — block "arch-auth-flow"
+      - Stored hash: abc123def456
+      - Current hash: 789ghi012jkl
+      - Status: Manual edit detected
+      
+      Diff Preview:
+      ```diff
+      @@ -10,6 +10,8 @@
+       ...
+      ```
+   ```
+
+2. **JANGAN auto-resolve**. Tanyakan ke user:
+   - "Apakah ingin menyimpan versi yang ada di file (manual edit) atau menimpa dengan konten baru?"
+   - Atau minta user untuk merge manual.
+
+3. Jika user memutuskan, lakukan sesuai keputusan user. Jika user menyuruh timpa:
+   - Baca file dokumentasi.
+   - Gunakan `apply_replace()` untuk block yang konflik.
+   - Catat bahwa konflik di-resolve secara paksa.
+
+### Step 5: Finalize Sync
+
+Setelah semua perubahan ditulis, jalankan:
+
+```bash
+python -m diary sync --force
+```
+
+Perintah ini akan:
+- Menghitung ulang hash untuk semua AIMB block.
+- Menyimpan hash baru ke database index.
+- Menampilkan ringkasan final.
+
+### Step 6: Report Summary
+
+Buat ringkasan dalam format berikut:
+
+```
+✅ Diary Sync Completed
+
+Files processed: 3
+  - src/services/auth.py → docs/techdocs/architecture.md (AIMB: arch-overview, arch-flow)
+  - src/models/user.py → docs/techdocs/api-contracts.md (AIMB: user-model)
+  - src/config/settings.py → docs/product/user-guide.md (AIMB: config-reference)
+
+Conflicts: 1
+  - docs/techdocs/architecture.md — block "arch-auth-flow": ⚠️ Manual review needed
+
+Stats:
+  - Total files scanned: 42
+  - Duration: 1523 ms
+```
+
+## Example: Full Session
+
+Berikut contoh sesi lengkap:
+
+### User Request
+"Update dokumentasi setelah aku nambahin fitur rate limiting di middleware."
+
+### Agent Execution
+
+**Step 1 — Dry-Run:**
+```bash
+$ python -m diary sync --dry-run
+
+{
+  "branch": "feature/rate-limit",
+  "timestamp": "2026-06-26T14:30:00+07:00",
+  "changes": [
+    {
+      "file_path": "src/middleware/ratelimit.py",
+      "change_type": "added",
+      "affected_docs": ["docs/techdocs/architecture.md"],
+      "confidence": 0.95
+    }
+  ],
+  "conflicts": [],
+  "stats": { "files_scanned": 45, "docs_updated": 0, "conflicts": 0, "duration_ms": 1234 }
+}
+```
+
+**Step 2 — Parse:** Tidak ada konflik. Satu perubahan baru di middleware dengan confidence tinggi. File terdampak: `docs/techdocs/architecture.md`.
+
+**Step 3 — Process:**
+- Baca `docs/techdocs/architecture.md` → temukan AIMB block `id="arch-middleware"`.
+- Baca `src/middleware/ratelimit.py` → pahami fitur rate limiting baru.
+- Generate konten baru untuk block `arch-middleware` yang menjelaskan arsitektur rate limiting.
+- Panggil `apply_replace()` untuk menulis konten baru.
+
+**Step 4 — Skip** (tidak ada konflik).
+
+**Step 5 — Finalize:**
+```bash
+python -m diary sync --force
+```
+
+**Step 6 — Report:**
+```
+✅ Diary Sync Completed
+
+Files processed: 1
+  - src/middleware/ratelimit.py → docs/techdocs/architecture.md (AIMB: arch-middleware)
+
+Conflicts: 0
+
+Stats:
+  - Total files scanned: 45
+  - Duration: 891 ms
+```
+
+## Error Handling
+
+| Scenario | Action |
+|----------|--------|
+| `diary sync --dry-run` gagal | Print error, minta user cek instalasi `diary` |
+| Tidak ada perubahan | Laporkan "No changes detected. Documentation is up to date." |
+| Semua perubahan low confidence | Tanya user apakah tetap diproses |
+| Konflik + perubahan | Proses perubahan dulu, lalu tanya user soal konflik |
+| `diary sync --force` gagal | Print stderr, minta user cek file lock atau write permission |
+| File AIMB block tidak ditemukan | Cek apakah file masih ada. Jika sudah dihapus, skip. |
+"""
+
+
+SKILL_CONTENT = """\
+---
+description: Generate DIARY documentation content by analyzing the workspace codebase
+---
+
+# {heading}
+
+Analyze the current workspace codebase and generate enterprise-grade documentation content for the DIARY structure.
+
+## Target Audience
+
+Documentation must be usable by:
+- Business Analyst
+- System Analyst
+- Software Engineer
+- QA Engineer
+- DevOps Engineer
+- Project Manager
+- Stakeholder bisnis
+
+## Documentation Style Guide
+
+- Gunakan bahasa yang formal, jelas, dan profesional.
+- Fokus pada kejelasan dibanding kompleksitas.
+- Gunakan heading yang terstruktur.
+- Gunakan tabel untuk informasi terstruktur.
+- Berikan asumsi jika ada informasi yang tidak tersedia.
+- Hindari penjelasan yang bertele-tele.
+- Gunakan istilah yang konsisten di seluruh dokumen.
+
+## Analysis Structure
+
+Selalu analisis sistem dari sudut pandang:
+
+1. **Business View** — Proses bisnis, flow, stakeholders
+2. **Functional View** — Fitur, use case, requirement fungsional
+3. **Application View** — Arsitektur aplikasi, komponen, module
+4. **Integration View** — Integrasi dengan sistem eksternal, API
+5. **Data View** — Model data, ERD, relasi
+6. **Security View** — Autentikasi, otorisasi, keamanan data
+7. **Deployment View** — Infrastruktur, CI/CD, environment
+
+## Mermaid Diagram Rules
+
+Diagram harus profesional dan mudah dibaca:
+- Gunakan `flowchart TD` (Top-Down) sebagai default
+- Hindari edge crossing
+- Gunakan `subgraph` untuk grouping
+- Maksimal 8-10 node per group
+- Pisahkan layer dengan jelas menggunakan subgraph
+- Jika diagram terlalu besar, pecah menjadi beberapa diagram
+- Prioritaskan readability daripada kelengkapan
+- Gunakan style yang konsisten: `style SubName fill:#4A90D9,color:#fff`
+- Berikan label yang jelas pada setiap node dan edge
+
+Contoh format diagram yang benar:
+```mermaid
+flowchart TD
+    subgraph "Presentation Layer"
+        UI[Web App]
+    end
+    subgraph "Application Layer"
+        API[API Gateway]
+        SVC[Service]
+    end
+    subgraph "Data Layer"
+        DB[(Database)]
+    end
+    UI --> API
+    API --> SVC
+    SVC --> DB
+```
+
+## Instructions
+
+You are a documentation generator. Your task is to analyze the workspace codebase and produce
+high-quality enterprise-grade documentation following DIARY guidelines.
+
+IMPORTANT!!!
+You MUST execute every step in order.
+Do NOT skip any step.
+
+### Step 1: Read Existing Docs Structure
+
+Read all files in the `docs/` folder to understand the current template structure.
+Each file has front matter with a title and a placeholder heading.
+
+### Step 2: Read from Knowledge Index (REPLACES manual codebase scan)
+
+Instead of manually scanning the codebase, use the pre-built index:
+
+1. **Ensure index exists**: Run `diary index` if not already run
+   ```bash
+   python -m diary index
+   ```
+
+2. **Read the knowledge database**: Query `docs/.index/knowledge.db` at the workspace root for:
+   - **Technology stack**: Search `files` table for config files (package.json, pyproject.toml, etc.)
+   - **Symbols/types**: Query `symbols` table grouped by `type` and `file_id`
+   - **Available modules**: Query `symbols` where `parent IS NULL` grouped by `file_id`
+   - **API endpoints**: Not directly indexed — still search for route definitions in source files
+   - **Database schemas**: Not directly indexed — check for ORM models and migrations
+   - **Documentation coverage**: Query `relations` table for doc-to-symbol links
+
+   Example queries:
+   ```sql
+   -- Get all files by language
+   SELECT language, COUNT(*) as count FROM files GROUP BY language ORDER BY count DESC;
+
+   -- Get all top-level symbols (classes, interfaces)
+   SELECT name, type, fqn FROM symbols WHERE parent IS NULL;
+
+   -- Get undocumented symbols
+   SELECT s.name, s.type, f.rel_path FROM symbols s
+   JOIN files f ON s.file_id = f.id
+   WHERE s.id NOT IN (SELECT symbol_id FROM relations);
+   ```
+
+3. **Fall back to manual scan** for:
+   - API routes (Express routes, Flask blueprints, etc.)
+   - Business process details not captured by symbol extraction
+   - Configuration values and environment variables
+
+### Step 3: Ask Clarifying Questions (IMPORTANT)
+
+**SEBELUM menulis dokumentasi, WAJIB mengumpulkan informasi yang ambigu atau tidak tersedia di codebase.**
+
+Gunakan tool `{tool_name}` untuk bertanya kepada user. Kumpulkan informasi berikut:
+
+**Business Context:**
+- Apa nama lengkap proyek dan deskripsi resmi?
+- Siapa target pengguna utama (end-user, admin, developer)?
+- Apa business process utama yang dijalankan sistem ini?
+- Apa trigger/awal mula dari setiap business flow?
+
+**Functional Requirements:**
+- Fitur utama apa saja yang belum terlihat dari kode?
+- Apa use case yang belum terdokumentasi?
+- Apa edge case atau special scenario yang perlu dicatat?
+
+**Non-Functional Requirements:**
+- Apa target SLA untuk uptime dan response time?
+- Apa requirement untuk scalability (expected user count, data volume)?
+- Apa requirement untuk security compliance (SOC2, GDPR, dll)?
+
+**Integration:**
+- Sistem eksternal apa saja yang terintegrasi?
+- Apa protocol yang digunakan (REST, gRPC, Message Queue)?
+- Apa flow integrasi antar sistem?
+
+**Deployment:**
+- Berapa environment yang digunakan (dev, staging, production)?
+- Apa infrastruktur yang digunakan (cloud provider, on-premise)?
+- Apa CI/CD pipeline yang digunakan?
+
+**Risks:**
+- Apa known technical risks yang perlu didokumentasikan?
+- Apa dependencies kritis yang perlu dihighlight?
+
+**PENTING:**
+- Jika informasi TIDAK tersedia di codebase dan user TIDAK memberikan jawaban,
+  gunakan placeholder `[ASSUMED: ...]` dan catat asumsi di dokumentasi.
+- Jika user menjawab, gunakan jawaban tersebut sebagai sumber utama.
+- Jangan berhalusinasi — lebih baik bertanya daripada menebak.
+
+### Step 4: Generate Content for Each DIARY File
+
+For each documentation file, generate appropriate content based on the codebase analysis.
+
+#### docs/index.md
+
+Update with:
+- Project name and description (from package.json description, pyproject.toml, or README)
+- Brief overview of what the project does
+- Link to objectives and key documentation sections
+
+#### docs/objectives.md
+
+Generate project objectives based on what the code does:
+- Primary objective (what problem does this project solve?)
+- Key goals (performance, scalability, usability, etc.)
+- Target users/audience
+- Success metrics if identifiable
+
+#### docs/structure/index.md
+
+Update with project-specific writing guidelines:
+- Link to DIARY documentation standards
+- Reference to the project's documentation conventions
+
+#### docs/techdocs/index.md (Technical Documentation Overview)
+
+Update with:
+- Brief description of the technical documentation section
+- Tech stack summary (language, framework, database)
+- List of available technical docs with links
+- Kontak tim (placeholder names)
+
+#### docs/techdocs/architecture.md
+
+Generate architecture overview following the 7 analysis views:
+
+**System Overview:**
+- What the application does, its purpose
+- Target users and use cases
+
+**Tech Stack:**
+| Komponen | Teknologi | Versi | Keterangan |
+|----------|-----------|-------|------------|
+| Frontend | ... | ... | ... |
+| Backend | ... | ... | ... |
+| Database | ... | ... | ... |
+
+**Project Structure:**
+- Directory tree with explanations
+
+**Architecture Diagram:**
+- Mermaid flowchart TD with subgraph grouping
+- Show Presentation, Application, Integration, and Data layers
+- Max 8-10 nodes per subgraph
+- Use consistent styling
+
+**Data Flow:**
+- Sequence diagram for key business processes
+
+**Integration Points:**
+- List all external system integrations
+- Protocol, direction, purpose
+
+**Security Architecture:**
+- Authentication mechanism
+- Authorization model
+- Data protection measures
+
+#### docs/techdocs/api-contracts.md
+
+If API routes/endpoints are found, for EACH endpoint document:
+
+| Field | Description |
+|-------|-------------|
+| Purpose | What this endpoint does |
+| Endpoint | URL path |
+| Method | GET/POST/PUT/DELETE |
+| Request Structure | Headers, body, params |
+| Response Structure | Success and error responses |
+| Validation Rules | Input validation requirements |
+| Error Handling | Error codes and messages |
+| Security | Auth requirements, rate limiting |
+
+Provide request/response examples with JSON payloads.
+Include error code reference table.
+
+If no API found, note that this is a non-API project and document any public interfaces.
+
+#### docs/techdocs/deployment.md
+
+Generate deployment flow documentation:
+- Deployment environments (development, staging, production)
+- CI/CD pipeline overview (if .gitlab-ci.yml or similar found)
+- Deployment steps
+- Environment variables required
+- Rollback procedures
+
+#### docs/techdocs/adr.md
+
+Generate Architecture Decision Record:
+- ADR format with status, context, decision, consequences
+- Add initial ADR entries for major architectural choices found in code
+
+#### docs/techdocs/development-guide.md
+
+Generate development guide:
+- **Prerequisites**: Required tools and versions (from dependency files)
+- **Setup instructions**: Step-by-step local development setup
+- **Project structure**: Explanation of key directories and files
+- **Coding standards**: Based on existing code patterns (linting config, formatting, etc.)
+- **Testing**: How to run tests (from package.json scripts, Makefile, etc.)
+
+#### docs/product/index.md (Product Documentation Overview)
+
+Update with:
+- Product description (what the product does for users)
+- Key features list
+- Target audience
+- Current version info
+
+#### docs/product/user-guide.md
+
+Generate user guide with use case format:
+
+For each major use case:
+| Field | Description |
+|-------|-------------|
+| Use Case Name | Name of the use case |
+| Objective | What the user achieves |
+| Actor | Who performs this |
+| Preconditions | What must be true before |
+| Main Flow | Step-by-step process |
+| Alternative Flow | Other ways to accomplish |
+| Error Flow | What happens on error |
+| Post Conditions | What is true after |
+
+Include business flow diagrams (Mermaid sequence diagrams).
+
+#### docs/product/modules.md
+
+List all modules/components found in the codebase:
+| Module | Purpose | Key Files | Dependencies |
+|--------|---------|-----------|--------------|
+| ... | ... | ... | ... |
+
+Include module relationship diagram if complex.
+
+#### docs/ops-governance/index.md (Ops & Governance Overview)
+
+Update with:
+| Parameter | Target SLA | Keterangan |
+|-----------|-----------|------------|
+| Uptime | 99.5% per bulan | ... |
+| Response Time | < 500ms (P95) | ... |
+| RTO | < 4 jam | ... |
+| RPO | < 1 jam | ... |
+
+- Maintenance schedule
+- Escalation contacts
+
+#### docs/ops-governance/runbooks.md
+
+Generate operational runbooks for each common scenario:
+- Incident response procedures
+- Monitoring and alerting setup
+- Backup/restore procedures
+- Scaling procedures
+- Health check procedures
+
+Include severity level table:
+| Severity | Definisi | Response Time | Resolusi Target |
+|----------|----------|---------------|-----------------|
+| Critical | ... | ... | ... |
+| High | ... | ... | ... |
+| Medium | ... | ... | ... |
+| Low | ... | ... | ... |
+
+#### docs/ops-governance/security.md
+
+Generate security documentation covering:
+| Aspect | Implementation |
+|--------|---------------|
+| Authentication | JWT/OAuth/etc. |
+| Authorization | RBAC/etc. |
+| Data Protection | Encryption at rest/transit |
+| Audit Trail | Logging mechanism |
+| Rate Limiting | Configuration |
+| API Security | CORS, CSP, etc. |
+
+Include security checklist and compliance considerations.
+
+#### docs/knowledge-base/index.md (Knowledge Base Overview)
+
+Update with:
+- Purpose of the knowledge base
+- How to contribute
+- Categories of information available
+
+#### docs/knowledge-base/faq.md
+
+Generate common questions based on code patterns:
+- How to set up the project?
+- How to run tests?
+- How to deploy?
+- Common error messages and solutions
+- Configuration options
+
+#### docs/knowledge-base/troubleshooting.md
+
+Generate troubleshooting guide:
+- Common issues and their solutions
+- Error message reference
+- Debug steps
+- Log analysis guide
+
+### Step 4: Apply DIARY Guidelines
+
+ALL generated content MUST follow these rules:
+
+1. **Language**: Use **Bahasa Indonesia** as the primary language for prose
+2. **Technical terms**: Keep in English without translation: `deployment`, `pipeline`,
+   `endpoint`, `payload`, `commit`, `merge request`, `branch`, `container`, `middleware`,
+   `repository`, `service`, `database`, `cache`, `queue`, etc.
+3. **Markdown format**:
+   - One H1 per file as the page title
+   - Hierarchical headings (H1 > H2 > H3)
+   - Front matter with `title` field
+   - Code blocks with language identifiers
+   - Tables for structured data
+   - Mermaid diagrams for architecture/flow visualization
+4. **Admonitions**: Use for important notes:
+   ```markdown
+   !!! note "Catatan"
+       Informasi tambahan.
+
+   !!! warning "Perhatian"
+       Peringatan penting.
+
+   !!! tip "Tips"
+       Saran berguna.
+   ```
+5. **Do NOT** include sensitive information (passwords, API keys, internal IPs)
+6. **Use placeholders** like `YOUR_API_KEY_HERE` for sensitive values
+7. **Diagrams**: Follow Mermaid rules above — professional, readable, grouped with subgraph
+
+### Step 5: Non-Functional Requirements
+
+Selalu identifikasi dan dokumentasikan:
+- **Availability** — Uptime target, redundancy
+- **Reliability** — Error rates, retry mechanisms
+- **Scalability** — Horizontal/vertical scaling considerations
+- **Performance** — Response time targets, throughput
+- **Maintainability** — Code quality, documentation coverage
+- **Observability** — Logging, monitoring, alerting
+- **Disaster Recovery** — Backup, restore, failover
+
+### Step 6: Risk Assessment
+
+Dokumentasikan risiko yang ditemukan:
+| Risk Type | Description | Impact | Mitigation |
+|-----------|-------------|--------|------------|
+| Technical | ... | ... | ... |
+| Business | ... | ... | ... |
+| Operational | ... | ... | ... |
+
+### Step 7: Write the Files
+
+After generating all content, write each file to the appropriate path in `docs/`.
+Preserve existing front matter titles but update the content.
+
+### Step 8: Generate Deliverables
+
+Pastikan dokumentasi yang dihasilkan mencakup:
+1. Executive Summary
+2. Business Flow
+3. Use Cases
+4. Functional Requirements
+5. Non Functional Requirements
+6. Architecture Diagram
+7. Integration Diagram
+8. Data Model
+9. API Specification
+10. Security Consideration
+11. Deployment Architecture
+12. Risks & Assumptions
+
+Output harus menyerupai dokumentasi proyek enterprise yang siap masuk Confluence,
+Git Repository, atau Technical Design Document.
+
+Report a summary of all files updated when complete.
+"""
+
+
+def generate_skill_content(is_opencode: bool = False) -> str:
+    """Return the skill file content for diary-generate-content."""
+    heading = "diary-generate-content" if is_opencode else "/diary-generate-content"
+    tool_name = "question" if is_opencode else "AskUserQuestion"
+    return SKILL_CONTENT.format(heading=heading, tool_name=tool_name)
+
+
+def create_structure(project_name: str, base_path: Path, force: bool = False) -> None:
+    """Create the DIARY documentation folder structure with all template files."""
+    docs = base_path / "docs"
+    folders = {
+        docs: {
+            "index": (project_name, project_name),
+            "files": [("objectives.md", "objectives", "Tujuan")],
+        },
+        docs / "structure": {
+            "index": ("structure", "Panduan Umum Menulis Docs"),
+            "files": [],
+        },
+        docs / "techdocs": {
+            "index": ("techdocs", "Technical Documentation - Overview"),
+            "files": [
+                ("architecture.md", "architecture", "Arsitektur Sistem"),
+                ("api-contracts.md", "api-contracts", "API Contracts"),
+                ("deployment.md", "deployment", "Deployment Flow"),
+                ("adr.md", "adr", "Architecture Decision Record"),
+                ("development-guide.md", "development-guide", "Development Guide"),
+            ],
+        },
+        docs / "product": {
+            "index": ("product", "Product Documentation - Overview"),
+            "files": [
+                ("user-guide.md", "user-guide", "User Guide"),
+                ("modules.md", "modules", "Modules"),
+            ],
+        },
+        docs / "ops-governance": {
+            "index": ("ops-governance", "Ops & Governance - Overview"),
+            "files": [
+                ("runbooks.md", "runbooks", "Runbooks"),
+                ("security.md", "security", "Security Compliance"),
+            ],
+        },
+        docs / "knowledge-base": {
+            "index": ("knowledge-base", "Knowledge Base - Overview"),
+            "files": [
+                ("faq.md", "faq", "FAQ"),
+                ("troubleshooting.md", "troubleshooting", "Troubleshooting"),
+            ],
+        },
+    }
+    for folder, config in folders.items():
+        folder.mkdir(parents=True, exist_ok=True)
+        index_title, index_heading = config["index"]
+        index = folder / "index.md"
+        if force or not index.exists():
+            content = aimb_wrap_body(f"---\ntitle: {index_title}\n---\n\n# {index_heading}\n", "index.md")
+            index.write_text(content, encoding="utf-8")
+        for filename, title, heading in config["files"]:
+            f = folder / filename
+            if force or not f.exists():
+                content = aimb_wrap_body(f"---\ntitle: {title}\n---\n\n# {heading}\n", filename)
+                f.write_text(content, encoding="utf-8")
+
+
+def main():
+    try:
+        banner = Text(BANNER, style="bold orange1")
+        console.print(banner)
+    except (UnicodeEncodeError, UnicodeError):
+        pass  # Some terminals (e.g. Windows cp1252) cannot render Unicode box-drawing characters
+
+    parser = argparse.ArgumentParser(prog="diary-docs", description="DIARY documentation scaffolder")
+    parser.add_argument("--version", action="version", version="%(prog)s 0.1.0")
+
+    subparsers = parser.add_subparsers(dest="command")
+    init_parser = subparsers.add_parser("init", help="Initialize a new DIARY documentation project")
+    init_parser.add_argument("-f", "--force", action="store_true", help="Overwrite existing files")
+
+    index_parser = subparsers.add_parser("index", help="Index workspace for knowledge retrieval")
+    index_parser.add_argument("--report", "-r", action="store_true", help="Generate coverage report after indexing")
+    index_parser.add_argument("--db-path", type=str, help="Custom database path (default: docs/.index/knowledge.db)")
+
+    sync_parser = subparsers.add_parser("sync", help="Sync documentation with code changes")
+    sync_parser.add_argument("--dry-run", "-n", action="store_true", help="Preview changes without applying")
+    sync_parser.add_argument("--branch", "-b", type=str, default="", help="Override branch detection")
+    sync_parser.add_argument("--force", "-f", action="store_true", help="Skip conflict warnings")
+    sync_parser.add_argument("--output", "-o", type=str, help="Write JSON report to file")
+
+    try:
+        args = parser.parse_args()
+    except SystemExit as e:
+        sys.exit(e.code)
+
+    if args.command is None:
+        parser.print_help()
+        sys.exit(1)
+
+    if args.command == "init":
+        try:
+            name = input("Project name: ").strip()
+        except KeyboardInterrupt:
+            print()
+            sys.exit(0)
+
+        if not name:
+            print("Error: Project name cannot be empty", file=sys.stderr)
+            sys.exit(1)
+
+        if not os.access(Path.cwd(), os.W_OK):
+            print("Error: No write permission in current directory", file=sys.stderr)
+            sys.exit(1)
+
+        try:
+            create_structure(name, Path.cwd(), force=args.force)
+
+            mkdocs_path = Path.cwd() / "mkdocs.yml"
+            if args.force or not mkdocs_path.exists():
+                mkdocs_path.write_text(
+                    MKDOCS_TEMPLATE.format(project_name=name), encoding="utf-8"
+                )
+
+            catalog_path = Path.cwd() / "catalog-info.yaml"
+            if args.force or not catalog_path.exists():
+                catalog_path.write_text(
+                    CATALOG_TEMPLATE.format(project_name=name, project_title=name.title()),
+                    encoding="utf-8",
+                )
+
+            try:
+                if sys.stdin.isatty():
+                    choice = inquirer.select(
+                        message="Skill structure?",
+                        choices=["Claude Code", "OpenCode"],
+                        default="Claude Code",
+                    ).execute()
+                else:
+                    choice = "Claude Code"
+                choice = "1" if choice == "Claude Code" else "2"
+            except (EOFError, KeyboardInterrupt, SystemExit):
+                print()
+                choice = "1"
+
+            if choice == "1":
+                skill_dir = Path.cwd() / ".claude" / "commands"
+            elif choice == "2":
+                skill_dir = Path.cwd() / ".opencode" / "commands"
+            else:
+                print("Error: Invalid choice. Use 1 for Claude Code or 2 for OpenCode.", file=sys.stderr)
+                sys.exit(1)
+
+            skill_dir.mkdir(parents=True, exist_ok=True)
+            skill_file = skill_dir / "diary-generate-content.md"
+            skill_file.write_text(
+                generate_skill_content(is_opencode=(choice == "2")),
+                encoding="utf-8",
+            )
+            sync_file = skill_dir / "diary-sync.md"
+            sync_file.write_text(SYNC_CONTENT, encoding="utf-8")
+
+            print(f"DIARY structure created for '{name}'")
+        except Exception as e:
+            print(f"Error: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    if args.command == "index":
+        db_path = Path(args.db_path) if args.db_path else None
+        db = run_index(Path.cwd(), db_path=db_path)
+        if args.report:
+            generate_report(db, Path.cwd())
+        db.close()
+        sys.exit(0)
+
+    if args.command == "sync":
+        config = SyncConfig(
+            workspace_path=Path.cwd(),
+            branch_override=args.branch,
+            dry_run=args.dry_run,
+            force=args.force,
+        )
+        result = run_sync(config)
+
+        if result.errors:
+            for err in result.errors:
+                print(err, file=sys.stderr)
+
+        if result.report is not None:
+            json_output = serialize_report(result.report)
+            if args.output:
+                try:
+                    Path(args.output).write_text(json_output, encoding="utf-8")
+                except OSError as e:
+                    print(f"Error: Cannot write to {args.output}: {e}", file=sys.stderr)
+                    sys.exit(1)
+            else:
+                print(json_output)
+
+        sys.exit(0 if result.success else 1)