@chispear/vibekit 0.1.1 → 0.3.0

package/README.md

@@ -61,11 +61,41 @@ vibekit status
 | Perintah | Fungsi |
 |---|---|
 | `vibekit init` | Buat `~/.vibekit/config.json` dari template (tidak menimpa yang sudah ada) |
-| `vibekit ask "<pertanyaan>" [--file <path>]... [--dir <path>]...` | Tanya sekali; lampirkan file/folder sebagai konteks terseleksi. Ringkasan hemat token ditulis ke stderr, jawaban bersih di stdout, ditutup baris info model + token terpakai |
-| `vibekit chat` | Percakapan interaktif; riwayat dipangkas otomatis (maks ±4.000 token, giliran tertua dibuang); `/keluar` untuk berhenti |
+| `vibekit ask "<pertanyaan>" [--file <path>]... [--dir <path>]...` | Satu pertanyaan yang boleh berakhir dengan aksi; lampirkan file/folder sebagai konteks terseleksi. Ringkasan hemat token ditulis ke stderr, jawaban bersih di stdout, ditutup baris info model + token terpakai |
+| `vibekit chat` | Percakapan interaktif yang juga bisa bertindak di tengah obrolan; riwayat dipangkas otomatis dan sadar-tool (maks ±4.000 token, hanya pada batas giliran utuh); `/keluar` untuk berhenti |
+| `vibekit do "<tugas>"` | Mode agent sekali jalan: model mengerjakan tugas nyata dengan tool file/perintah di folder saat ini (lihat bagian Mode Agent di bawah) |
 | `vibekit status` | Tabel per penyedia: model, status (aktif / cooldown s.d. jam / anggaran tercapai), token terpakai hari ini |
 | `vibekit --help` / `--version` | Bantuan / versi |
 
+## Mode Agent — `ask`, `chat`, dan `do`
+
+Selain menjawab pertanyaan, VibeKit bisa **bertindak** di folder proyek Anda. Sejak v0.3.0 kemampuan agent ini menyatu ke semua perintah — pertanyaan biasa dijawab teks seperti biasa, sedangkan permintaan membuat file atau menjalankan perintah dikerjakan lewat tool dengan pagar keamanan yang sama:
+
+- **`vibekit ask`** — satu pertanyaan yang boleh berakhir dengan aksi: `vibekit ask "buatkan file halo.txt berisi sapaan"`.
+- **`vibekit chat`** — ngobrol yang bisa bertindak di tengah percakapan: minta dibuatkan file di giliran mana pun, model memakai tool lalu melanjutkan obrolan dengan riwayat yang utuh (termasuk rangkaian tool-nya).
+- **`vibekit do`** — mode tugas sekali jalan: jejak langkah dicetak, ditutup ringkasan akhir, dan kode keluar mencerminkan berhasil/tidaknya tugas:
+
+```bash
+vibekit do "buatkan file halo.txt berisi sapaan, lalu tampilkan daftar file di sini"
+```
+
+Model bekerja langkah demi langkah lewat tool calling (API OpenAI-compatible yang sama, failover router yang sama), sampai ia membalas teks akhir. Ada **5 tool**:
+
+| Tool | Fungsi | Konfirmasi? |
+|---|---|---|
+| `daftar_file` | Daftar isi folder | Tidak (baca-saja) |
+| `baca_file` | Baca isi file teks | Tidak (baca-saja) |
+| `tulis_file` | Buat/timpa file (folder induk dibuat bila perlu) | **Ya, satu per satu** |
+| `edit_file` | Ganti kemunculan pertama `teksLama` → `teksBaru` dalam file | **Ya, satu per satu** |
+| `jalankan_perintah` | Jalankan perintah shell (timeout 60 detik, keluaran ditangkap) | **Ya, satu per satu** |
+
+**Model keamanan:**
+
+- **Hanya folder kerja (cwd).** Semua path di-resolve terhadap folder tempat perintah dijalankan; path yang keluar dari folder itu (mis. `../`) ditolak eksekutor, bahkan bila pengguna menyetujui.
+- **Konfirmasi per aksi.** Setiap aksi yang mengubah file atau menjalankan perintah menampilkan deskripsi aksinya (path + pratinjau konten untuk tulis, potongan teks lama→baru untuk edit, perintah lengkap untuk shell) dan hanya berjalan bila Anda menjawab `y`/`ya` — selain itu dianggap menolak, dan penolakan itu dilaporkan ke model agar ia menyesuaikan rencana.
+- **Batas 12 langkah** per giliran/tugas, dan hasil tiap tool dipangkas (±4.000 karakter) sebelum dikirim balik ke model demi hemat token.
+- **Riwayat chat yang aman untuk tool.** Pemangkasan riwayat chat hanya terjadi pada batas giliran utuh (satu pesan pengguna + seluruh rangkaian tool-nya), sehingga tidak pernah ada pesan hasil tool yang yatim atau panggilan tool yang kehilangan hasilnya.
+
 ## Cara Failover Bekerja
 
 1. Sebelum memanggil, router memeriksa state lokal (`~/.vibekit/state.json`): penyedia yang masih **cooldown** atau sudah mencapai **anggaran harian** dilewati tanpa dipanggil.
@@ -93,7 +123,7 @@ Keputusan repo: `dist/` masuk `.gitignore` dan dibangun saat publish (`prepublis
 
 ## Status Nama di npm
 
-Package ini terbit di npm sebagai **`@chispear/vibekit`** (v0.1.0, 25 Oktober 2026) karena nama tak-scoped `vibekit` sudah dipakai proyek lain. Nama perintah CLI tetap `vibekit`.
+Package ini terbit di npm sebagai **`@chispear/vibekit`** (v0.1.0, 25 Oktober 2026; v0.2.0 menambahkan mode agent `vibekit do`; v0.3.0 menggabungkan kemampuan agent itu ke `ask` dan `chat`) karena nama tak-scoped `vibekit` sudah dipakai proyek lain. Nama perintah CLI tetap `vibekit`.
 
 ## Lisensi
 

package/dist/agent.js

@@ -0,0 +1,453 @@
+import { exec } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { tanyaRouter } from "./router.js";
+import { hitungToken } from "./token.js";
+/** Hasil tool dipangkas sampai ±karakter ini sebelum dikirim balik ke model (hemat token). */
+const BATAS_HASIL_TOOL = 4000;
+/** Batas waktu jalankan_perintah. */
+const TIMEOUT_PERINTAH_MS = 60_000;
+/** Batas langkah agent bawaan. */
+export const MAKS_LANGKAH_BAWAAN = 12;
+const SKEMA_PATH = {
+    type: "string",
+    description: "Path relatif terhadap folder kerja (cwd). Tidak boleh keluar dari folder kerja.",
+};
+/** Definisi 5 tool mode agent (format function calling OpenAI, skema ketat). */
+export const DEFINISI_TOOL = [
+    {
+        type: "function",
+        function: {
+            name: "daftar_file",
+            description: "Daftar isi sebuah folder di dalam folder kerja. Baca-saja, tanpa konfirmasi.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { ...SKEMA_PATH, description: "Path folder relatif; kosong atau '.' berarti folder kerja itu sendiri." },
+                },
+                required: [],
+                additionalProperties: false,
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "baca_file",
+            description: "Baca isi sebuah file teks di dalam folder kerja. Baca-saja, tanpa konfirmasi.",
+            parameters: {
+                type: "object",
+                properties: { path: SKEMA_PATH },
+                required: ["path"],
+                additionalProperties: false,
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "tulis_file",
+            description: "Buat file baru atau timpa file yang ada dengan konten yang diberikan (folder induk dibuat bila perlu). Selalu meminta konfirmasi pengguna.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: SKEMA_PATH,
+                    konten: { type: "string", description: "Seluruh isi file yang akan ditulis." },
+                },
+                required: ["path", "konten"],
+                additionalProperties: false,
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "edit_file",
+            description: "Ganti kemunculan PERTAMA teksLama dengan teksBaru di dalam file. Error bila teksLama tidak ditemukan. Selalu meminta konfirmasi pengguna.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: SKEMA_PATH,
+                    teksLama: { type: "string", description: "Teks persis yang dicari (harus muncul minimal sekali)." },
+                    teksBaru: { type: "string", description: "Teks pengganti." },
+                },
+                required: ["path", "teksLama", "teksBaru"],
+                additionalProperties: false,
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "jalankan_perintah",
+            description: "Jalankan sebuah perintah shell di folder kerja (timeout 60 detik) dan kembalikan stdout+stderr. Selalu meminta konfirmasi pengguna.",
+            parameters: {
+                type: "object",
+                properties: {
+                    perintah: { type: "string", description: "Perintah shell lengkap yang akan dijalankan di folder kerja." },
+                },
+                required: ["perintah"],
+                additionalProperties: false,
+            },
+        },
+    },
+];
+const SYSTEM_PROMPT_AGENT = [
+    "Kamu adalah agent pelaksana tugas VibeKit yang bekerja di dalam SATU folder kerja pengguna.",
+    "Kerjakan tugas langkah demi langkah memakai tool yang tersedia: daftar_file, baca_file, tulis_file, edit_file, jalankan_perintah.",
+    "Semua path bersifat relatif terhadap folder kerja; jangan pernah mencoba mengakses apa pun di luar folder itu.",
+    "Aksi tulis_file, edit_file, dan jalankan_perintah selalu meminta persetujuan pengguna dulu; bila pengguna menolak, jangan memaksa dan jangan mengulang aksi yang sama — sesuaikan rencana atau akhiri tugas.",
+    "Jangan mengarang isi file: gunakan daftar_file/baca_file dulu bila perlu mengetahui isi folder/file.",
+    "Bila tugas selesai (atau tidak bisa dilanjutkan), balas TANPA memanggil tool, berisi ringkasan akhir yang singkat dalam poin-poin penting: apa yang dilakukan dan hasilnya.",
+].join(" ");
+/**
+ * System prompt gabungan untuk `ask` dan `chat` (sejak v0.3.0): model adalah
+ * lawan bicara yang menjawab pertanyaan biasa langsung sebagai teks, tetapi
+ * juga bisa bertindak memakai tool yang sama seperti mode agent bila diminta.
+ */
+export const SYSTEM_PROMPT_GABUNGAN = [
+    "Kamu adalah lawan bicara VibeKit yang bekerja di dalam SATU folder kerja pengguna.",
+    "Jawab pertanyaan biasa langsung sebagai teks, singkat dan hanya poin-poin penting.",
+    "Bila pengguna meminta dibuatkan/diubah file atau menjalankan perintah, gunakan tool yang tersedia: daftar_file, baca_file, tulis_file, edit_file, jalankan_perintah.",
+    "Semua path bersifat relatif terhadap folder kerja; jangan pernah mencoba mengakses apa pun di luar folder itu.",
+    "Aksi tulis_file, edit_file, dan jalankan_perintah selalu meminta persetujuan pengguna dulu; bila pengguna menolak, jangan memaksa dan jangan mengulang aksi yang sama.",
+    "Jangan mengarang isi file: gunakan daftar_file/baca_file dulu bila perlu mengetahui isi folder/file.",
+    "Setelah bertindak, tutup giliran dengan balasan teks (tanpa tool) berisi ringkasan singkat: apa yang dilakukan dan hasilnya.",
+].join(" ");
+/**
+ * Resolve path masukan terhadap cwd. Mengembalikan null bila hasil resolve
+ * keluar dari cwd (path traversal) — kunci keamanan mode agent.
+ */
+function resolusiAman(cwd, masukan) {
+    const dasar = path.resolve(cwd);
+    const tujuan = path.resolve(dasar, masukan);
+    if (tujuan === dasar)
+        return tujuan;
+    return tujuan.startsWith(dasar + path.sep) ? tujuan : null;
+}
+function pathRelatif(cwd, tujuan) {
+    const rel = path.relative(path.resolve(cwd), tujuan);
+    return rel === "" ? "." : rel;
+}
+function potong(teks, maks) {
+    return teks.length > maks ? teks.slice(0, maks) + "…" : teks;
+}
+/** Pangkas hasil tool sampai ±BATAS_HASIL_TOOL karakter sebelum dikirim ke model. */
+function potongHasilTool(teks) {
+    if (teks.length <= BATAS_HASIL_TOOL)
+        return teks;
+    return teks.slice(0, BATAS_HASIL_TOOL) + `\n…(hasil dipotong demi hemat token; total ${teks.length} karakter)`;
+}
+/** Ringkasan argumen satu baris untuk jejak langkah yang dicetak CLI. */
+function argumenRingkas(nama, arg) {
+    switch (nama) {
+        case "jalankan_perintah":
+            return potong(String(arg.perintah ?? ""), 80);
+        case "tulis_file":
+        case "edit_file":
+        case "baca_file":
+        case "daftar_file":
+            return String(arg.path ?? ".");
+        default:
+            return potong(JSON.stringify(arg), 80);
+    }
+}
+/**
+ * Jalankan satu panggilan tool. Selalu mengembalikan teks hasil untuk model
+ * (tidak pernah throw): keberhasilan diawali "OK:", kegagalan "ERROR:",
+ * penolakan pengguna "DITOLAK:".
+ */
+export async function eksekusiTool(panggilan, konteks) {
+    const nama = panggilan.function.name;
+    let arg;
+    try {
+        arg = JSON.parse(panggilan.function.arguments || "{}");
+    }
+    catch {
+        return `ERROR: argumen untuk tool ${nama} bukan JSON yang valid.`;
+    }
+    const { cwd, konfirmasi } = konteks;
+    const ambilPath = (mentah) => {
+        const masukan = typeof mentah === "string" && mentah.trim() !== "" ? mentah : ".";
+        const tujuan = resolusiAman(cwd, masukan);
+        if (!tujuan) {
+            return { error: `ERROR: path "${masukan}" berada di luar folder kerja — akses ditolak demi keamanan.` };
+        }
+        return { tujuan, rel: pathRelatif(cwd, tujuan) };
+    };
+    try {
+        switch (nama) {
+            case "daftar_file": {
+                const p = ambilPath(arg.path);
+                if ("error" in p)
+                    return p.error;
+                const entri = await fs.readdir(p.tujuan, { withFileTypes: true });
+                if (entri.length === 0)
+                    return `OK: folder ${p.rel} kosong.`;
+                const baris = entri
+                    .sort((a, b) => a.name.localeCompare(b.name))
+                    .map((e) => (e.isDirectory() ? `${e.name}/` : e.name));
+                return `OK: isi folder ${p.rel}:\n${baris.join("\n")}`;
+            }
+            case "baca_file": {
+                const p = ambilPath(arg.path);
+                if ("error" in p)
+                    return p.error;
+                const isi = await fs.readFile(p.tujuan, "utf8");
+                return `OK: isi file ${p.rel}:\n${isi}`;
+            }
+            case "tulis_file": {
+                const p = ambilPath(arg.path);
+                if ("error" in p)
+                    return p.error;
+                const konten = typeof arg.konten === "string" ? arg.konten : "";
+                const deskripsi = `tulis_file → ${p.rel} (${konten.length} karakter)\n` +
+                    `Pratinjau konten:\n${potong(konten, 300)}`;
+                if (!(await konfirmasi(deskripsi))) {
+                    return `DITOLAK: pengguna menolak aksi tulis_file ke ${p.rel}. File tidak ditulis. Jangan mengulang aksi yang sama; sesuaikan rencana atau akhiri dengan ringkasan.`;
+                }
+                await fs.mkdir(path.dirname(p.tujuan), { recursive: true });
+                await fs.writeFile(p.tujuan, konten, "utf8");
+                return `OK: file ${p.rel} ditulis (${konten.length} karakter).`;
+            }
+            case "edit_file": {
+                const p = ambilPath(arg.path);
+                if ("error" in p)
+                    return p.error;
+                const teksLama = typeof arg.teksLama === "string" ? arg.teksLama : "";
+                const teksBaru = typeof arg.teksBaru === "string" ? arg.teksBaru : "";
+                const isi = await fs.readFile(p.tujuan, "utf8");
+                const idx = isi.indexOf(teksLama);
+                if (idx < 0) {
+                    return `ERROR: teksLama tidak ditemukan di ${p.rel}; tidak ada yang diubah. Baca file lagi dan salin teks persisnya.`;
+                }
+                const deskripsi = `edit_file → ${p.rel}\n` +
+                    `Teks lama: ${potong(teksLama, 150)}\n` +
+                    `Teks baru: ${potong(teksBaru, 150)}`;
+                if (!(await konfirmasi(deskripsi))) {
+                    return `DITOLAK: pengguna menolak aksi edit_file di ${p.rel}. File tidak diubah. Jangan mengulang aksi yang sama; sesuaikan rencana atau akhiri dengan ringkasan.`;
+                }
+                const baru = isi.slice(0, idx) + teksBaru + isi.slice(idx + teksLama.length);
+                await fs.writeFile(p.tujuan, baru, "utf8");
+                return `OK: ${p.rel} diubah (kemunculan pertama teksLama diganti teksBaru).`;
+            }
+            case "jalankan_perintah": {
+                const perintah = typeof arg.perintah === "string" ? arg.perintah.trim() : "";
+                if (!perintah)
+                    return "ERROR: argumen perintah kosong.";
+                const deskripsi = `jalankan_perintah → ${perintah}`;
+                if (!(await konfirmasi(deskripsi))) {
+                    return `DITOLAK: pengguna menolak menjalankan perintah "${perintah}". Perintah tidak dijalankan. Jangan mengulang aksi yang sama; sesuaikan rencana atau akhiri dengan ringkasan.`;
+                }
+                const hasil = await new Promise((resolve) => {
+                    exec(perintah, { cwd: path.resolve(cwd), timeout: TIMEOUT_PERINTAH_MS, maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
+                        if (err) {
+                            const e = err;
+                            resolve({
+                                kode: typeof e.code === "number" ? e.code : null,
+                                stdout: String(stdout ?? ""),
+                                stderr: String(stderr ?? ""),
+                                timeout: e.killed === true,
+                            });
+                        }
+                        else {
+                            resolve({ kode: 0, stdout: String(stdout), stderr: String(stderr), timeout: false });
+                        }
+                    });
+                });
+                const bagian = [`kode keluar: ${hasil.kode ?? "?"}${hasil.timeout ? " (timeout 60 detik, perintah dihentikan)" : ""}`];
+                if (hasil.stdout.trim())
+                    bagian.push(`stdout:\n${hasil.stdout.trimEnd()}`);
+                if (hasil.stderr.trim())
+                    bagian.push(`stderr:\n${hasil.stderr.trimEnd()}`);
+                return (hasil.kode === 0 ? "OK: " : "ERROR: ") + bagian.join("\n");
+            }
+            default:
+                return `ERROR: tool tidak dikenal: ${nama}. Tool yang tersedia: daftar_file, baca_file, tulis_file, edit_file, jalankan_perintah.`;
+        }
+    }
+    catch (e) {
+        return `ERROR: ${e.message}`;
+    }
+}
+/**
+ * Inti loop agent untuk SATU giliran: panggil router (dengan tools) → jalankan
+ * tool_calls yang diminta model lewat eksekutor aman → kirim hasil tool balik
+ * → ulangi sampai model membalas teks tanpa tool_calls atau langkah habis.
+ * Dipakai bersama oleh `do` (lewat jalankanAgent), `ask`, dan `chat`.
+ *
+ * Catatan kegagalan: bila router gagal di tengah giliran, `messages` mungkin
+ * sudah memuat rangkaian parsial (assistant tool_calls + hasil tool tanpa teks
+ * akhir). Pemanggil yang menyimpan riwayat (chat) sebaiknya menggulung balik
+ * giliran itu; pemanggil sekali jalan (ask/do) bisa mengabaikannya.
+ */
+export async function jalankanGiliran(opsi) {
+    const maksLangkah = opsi.maksLangkah ?? MAKS_LANGKAH_BAWAAN;
+    const messages = opsi.messages;
+    const catatan = [];
+    let totalToken = 0;
+    let semuaUsage = true;
+    let providerTerakhir = null;
+    const sumber = () => (semuaUsage ? "usage" : "estimasi");
+    let langkah = 0;
+    while (langkah < maksLangkah) {
+        langkah++;
+        const hasil = await tanyaRouter({
+            config: opsi.config,
+            messages,
+            lokasiState: opsi.lokasiState,
+            fetchImpl: opsi.fetchImpl,
+            tools: DEFINISI_TOOL,
+        });
+        catatan.push(...hasil.catatan);
+        if (!hasil.ok) {
+            return {
+                ok: false,
+                jawabanAkhir: "",
+                providerTerakhir,
+                totalToken,
+                tokenSumber: sumber(),
+                jumlahLangkah: langkah,
+                catatan,
+                pesanGagal: hasil.pesan,
+            };
+        }
+        totalToken += hasil.tokenTerpakai;
+        if (hasil.tokenSumber !== "usage")
+            semuaUsage = false;
+        providerTerakhir = hasil.provider;
+        const panggilan = hasil.toolCalls ?? [];
+        if (panggilan.length === 0) {
+            // Balasan teks murni = jawaban akhir giliran; simpan ke riwayat agar utuh.
+            messages.push({ role: "assistant", content: hasil.jawaban });
+            return {
+                ok: true,
+                jawabanAkhir: hasil.jawaban,
+                providerTerakhir,
+                totalToken,
+                tokenSumber: sumber(),
+                jumlahLangkah: langkah,
+                catatan,
+            };
+        }
+        if (hasil.pesanMentah && typeof hasil.pesanMentah === "object") {
+            // Teruskan pesan assistant persis seperti yang dikirim penyedia. Gemini 3
+            // menyisipkan thought_signature di dalam tool_calls (extra_content) dan
+            // menolak permintaan berikutnya dengan HTTP 400 bila tanda tangan itu
+            // hilang dari riwayat — jadi pesan mentah tidak boleh dibangun ulang.
+            messages.push(hasil.pesanMentah);
+        }
+        else {
+            messages.push({
+                role: "assistant",
+                content: hasil.jawaban ? hasil.jawaban : null,
+                tool_calls: panggilan,
+            });
+        }
+        for (const p of panggilan) {
+            let argRingkas = "";
+            try {
+                argRingkas = argumenRingkas(p.function.name, JSON.parse(p.function.arguments || "{}"));
+            }
+            catch {
+                argRingkas = "";
+            }
+            opsi.jejak?.(`langkah ${langkah}: ${p.function.name}${argRingkas ? ` (${argRingkas})` : ""}`);
+            const hasilTool = await eksekusiTool(p, { cwd: opsi.cwd, konfirmasi: opsi.konfirmasi });
+            opsi.jejak?.(`  → ${potong(hasilTool.split("\n")[0], 120)}`);
+            messages.push({
+                role: "tool",
+                tool_call_id: p.id,
+                name: p.function.name,
+                content: potongHasilTool(hasilTool),
+            });
+        }
+    }
+    return {
+        ok: false,
+        jawabanAkhir: "",
+        providerTerakhir,
+        totalToken,
+        tokenSumber: sumber(),
+        jumlahLangkah: langkah,
+        catatan,
+        batasTercapai: true,
+    };
+}
+/** Perkiraan token satu pesan: konten teks ditambah argumen tool_calls (bila ada). */
+function tokenPesan(m) {
+    let teks = m.content ?? "";
+    if (m.tool_calls && m.tool_calls.length > 0)
+        teks += "\n" + JSON.stringify(m.tool_calls);
+    return hitungToken(teks);
+}
+/**
+ * Pangkas riwayat percakapan secara SADAR-TOOL: pemotongan hanya terjadi pada
+ * batas giliran utuh. Satu giliran = satu pesan "user" beserta seluruh
+ * rangkaian sesudahnya sampai sebelum "user" berikutnya (assistant tool_calls,
+ * hasil-hasil tool, assistant teks akhir). Fungsi ini TIDAK PERNAH menyisakan
+ * pesan "tool" yatim atau assistant tool_calls tanpa hasil tool-nya.
+ *
+ * Awalan pesan "system" (bila ada) selalu dipertahankan karena bukan bagian
+ * giliran mana pun. Giliran terakhir selalu dipertahankan utuh, jadi hasil
+ * boleh tetap melebihi maksToken bila satu giliran terakhir saja sudah
+ * sebesar itu. Tidak mengubah array masukan; mengembalikan array baru.
+ */
+export function pangkasRiwayatAman(messages, maksToken) {
+    let awal = 0;
+    while (awal < messages.length && messages[awal].role === "system")
+        awal++;
+    const awalan = messages.slice(0, awal);
+    const sisa = messages.slice(awal);
+    // Kelompokkan sisa menjadi giliran-giliran: grup baru dimulai di setiap
+    // pesan "user"; pesan sebelum "user" pertama membentuk grupnya sendiri.
+    const grup = [];
+    for (const m of sisa) {
+        if (m.role === "user" || grup.length === 0)
+            grup.push([m]);
+        else
+            grup[grup.length - 1].push(m);
+    }
+    const tokenGrup = (g) => g.reduce((s, m) => s + tokenPesan(m), 0);
+    let total = awalan.reduce((s, m) => s + tokenPesan(m), 0) + grup.reduce((s, g) => s + tokenGrup(g), 0);
+    // Buang giliran tertua secara utuh sampai muat; giliran terakhir tak dibuang.
+    while (total > maksToken && grup.length > 1) {
+        total -= tokenGrup(grup.shift());
+    }
+    return [...awalan, ...grup.flat()];
+}
+/**
+ * Mode tugas sekali jalan (`vibekit do`): satu giliran agent dengan system
+ * prompt pelaksana tugas, dibangun di atas jalankanGiliran. Perilaku dan
+ * bentuk HasilAgent sama seperti sebelum refaktor v0.3.0.
+ */
+export async function jalankanAgent(opsi) {
+    const maksLangkah = opsi.maksLangkah ?? MAKS_LANGKAH_BAWAAN;
+    const messages = [
+        { role: "system", content: SYSTEM_PROMPT_AGENT },
+        { role: "user", content: opsi.tugas },
+    ];
+    const hasil = await jalankanGiliran({
+        config: opsi.config,
+        messages,
+        lokasiState: opsi.lokasiState,
+        cwd: opsi.cwd,
+        konfirmasi: opsi.konfirmasi,
+        fetchImpl: opsi.fetchImpl,
+        maksLangkah: opsi.maksLangkah,
+        jejak: opsi.jejak,
+    });
+    if (hasil.pesanGagal !== undefined) {
+        return { ok: false, ringkasan: hasil.pesanGagal, jumlahLangkah: hasil.jumlahLangkah, catatan: hasil.catatan };
+    }
+    if (hasil.batasTercapai) {
+        return {
+            ok: false,
+            ringkasan: `Batas langkah tercapai (${maksLangkah} langkah) sebelum tugas selesai. ` +
+                "Jalankan lagi perintah yang sama untuk melanjutkan, atau persempit tugasnya.",
+            jumlahLangkah: hasil.jumlahLangkah,
+            catatan: hasil.catatan,
+        };
+    }
+    return { ok: true, ringkasan: hasil.jawabanAkhir, jumlahLangkah: hasil.jumlahLangkah, catatan: hasil.catatan };
+}

package/dist/banner.js

@@ -0,0 +1,36 @@
+// Banner CHISPEAR hijau besar — ditampilkan saat `vibekit init` pertama kali
+// (momen "berhasil terpasang & diatur" yang pasti terlihat pengguna, karena
+// keluaran skrip postinstall npm tidak selalu ditampilkan npm).
+// CATATAN: scripts/banner.js adalah salinan mandiri dari seni ini untuk
+// postinstall — jaga keduanya tetap sinkron.
+const GLIF = {
+    C: [" █████ ", "██   ██", "██     ", "██     ", "██   ██", " █████ "],
+    H: ["██   ██", "██   ██", "███████", "██   ██", "██   ██", "██   ██"],
+    I: ["███", " █ ", " █ ", " █ ", " █ ", "███"],
+    S: ["███████", "██     ", "██████ ", "     ██", "     ██", "██████ "],
+    P: ["██████ ", "██   ██", "██████ ", "██     ", "██     ", "██     "],
+    E: ["███████", "██     ", "█████  ", "█████  ", "██     ", "███████"],
+    A: [" █████ ", "██   ██", "███████", "██   ██", "██   ██", "██   ██"],
+    R: ["██████ ", "██   ██", "██████ ", "██  ██ ", "██   ██", "██   ██"],
+};
+/** Teks banner CHISPEAR (hijau terang bila NO_COLOR tidak diset). */
+export function teksBanner() {
+    const baris = ["", "", "", "", "", ""];
+    for (const huruf of "CHISPEAR") {
+        const g = GLIF[huruf];
+        if (!g)
+            continue;
+        for (let i = 0; i < 6; i++)
+            baris[i] += (baris[i] ? "  " : "") + g[i];
+    }
+    const pakaiWarna = !process.env.NO_COLOR;
+    const HIJAU = pakaiWarna ? "\x1b[1;92m" : "";
+    const RESET = pakaiWarna ? "\x1b[0m" : "";
+    return [
+        "",
+        ...baris.map((b) => HIJAU + b + RESET),
+        "",
+        HIJAU + "  VibeKit CLI terpasang — router AI hemat tokenmu siap dipakai." + RESET,
+        "",
+    ].join("\n");
+}

package/dist/cli.js

@@ -1,19 +1,21 @@
 #!/usr/bin/env node
 import readline from "node:readline";
 import { buatConfigGlobal, globalConfigPath, muatConfig, statePath, } from "./config.js";
+import { jalankanAgent, jalankanGiliran, pangkasRiwayatAman, SYSTEM_PROMPT_GABUNGAN, } from "./agent.js";
+import { teksBanner } from "./banner.js";
 import { bangunKonteks } from "./context.js";
-import { tanyaRouter } from "./router.js";
 import { formatJam, muatState, sedangCooldown, statePenyedia, } from "./state.js";
-import { formatAngka, hitungToken } from "./token.js";
-const VERSI = "0.1.0";
+import { formatAngka } from "./token.js";
+const VERSI = "0.3.0";
 const BATAS_TOKEN_RIWAYAT = 4000;
 function bantuan() {
     console.log(`VibeKit CLI v${VERSI} — router AI hemat token dengan failover otomatis
 
 Penggunaan:
   vibekit init                          Buat ~/.vibekit/config.json dari template
-  vibekit ask "<pertanyaan>" [opsi]     Tanya sekali lewat router
-  vibekit chat                          Percakapan interaktif (perintah /keluar untuk berhenti)
+  vibekit ask "<pertanyaan>" [opsi]     Tanya sekali (bisa bertindak: membuat file & menjalankan perintah dengan persetujuanmu)
+  vibekit chat                          Percakapan interaktif yang juga bisa bertindak (perintah /keluar untuk berhenti)
+  vibekit do "<tugas>"                  Mode agent sekali jalan: kerjakan tugas dengan tool file/perintah di folder ini
   vibekit status                        Status & pemakaian token tiap penyedia hari ini
   vibekit --help                        Tampilkan bantuan ini
   vibekit --version                     Tampilkan versi
@@ -22,6 +24,18 @@ Opsi ask:
   --file <path>    Lampirkan file sebagai konteks (boleh diulang)
   --dir <path>     Lampirkan isi folder sebagai konteks (boleh diulang)
 
+Kemampuan agent (ask, chat, do):
+  Sejak v0.3.0 ketiga perintah itu bisa bertindak, bukan hanya menjawab:
+  bila kamu meminta dibuatkan/diubah file atau menjalankan perintah, model
+  memakai tool di folder tempat perintah dijalankan. Tool baca (daftar_file,
+  baca_file) berjalan langsung; tool yang mengubah sesuatu (tulis_file,
+  edit_file, jalankan_perintah) selalu meminta persetujuanmu satu per satu
+  — jawaban selain y/ya berarti ditolak. Batas 12 langkah per giliran.
+  Perbedaannya: ask = satu pertanyaan yang boleh berakhir dengan aksi,
+  chat = percakapan yang bisa bertindak di tengah obrolan,
+  do = mode tugas sekali jalan dengan jejak langkah & ringkasan akhir.
+  Contoh: vibekit do "buatkan file halo.txt berisi sapaan, lalu tampilkan daftar file di sini"
+
 Cara kerja singkat:
   Penyedia dicoba sesuai urutan di konfigurasi. Bila kuota penyedia terdeteksi
   habis, permintaan otomatis diulang ke penyedia berikutnya. Setiap jawaban
@@ -32,6 +46,7 @@ Cara kerja singkat:
 function perintahInit() {
     const dibuat = buatConfigGlobal();
     if (dibuat) {
+        console.log(teksBanner());
         console.log(`Konfigurasi dibuat: ${globalConfigPath()}`);
         console.log("Isi kolom \"apiKey\" untuk tiap penyedia yang ingin dipakai (atau pakai sintaks \"env:NAMA_VAR\").");
         console.log("Urutan penyedia = prioritas: yang pertama adalah bawaan, berikutnya cadangan failover.");
@@ -75,18 +90,46 @@ function uraiArgAsk(args) {
         return { error: "Pertanyaan kosong. Contoh: vibekit ask \"apa itu API?\"" };
     return { pertanyaan, files, dirs };
 }
-function tampilkanHasil(hasil) {
-    if (hasil.ok) {
-        console.log(hasil.jawaban);
-        const sumber = hasil.tokenSumber === "usage" ? "dari usage API" : "estimasi";
-        console.log(`\n— dijawab oleh ${hasil.provider.nama} (${hasil.provider.model}) • ${formatAngka(hasil.tokenTerpakai)} token (${sumber})`);
-        for (const c of hasil.catatan) {
-            console.error(`[vibekit] dilewati ${c.nama}: ${c.alasan}`);
-        }
-        return 0;
-    }
-    console.error(hasil.pesan);
-    return 1;
+function buatPembacaBaris() {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const antrian = [];
+    const penunggu = [];
+    let berakhir = false;
+    rl.on("line", (baris) => {
+        const p = penunggu.shift();
+        if (p)
+            p(baris);
+        else
+            antrian.push(baris);
+    });
+    rl.on("close", () => {
+        berakhir = true;
+        while (penunggu.length > 0)
+            penunggu.shift()(null);
+    });
+    return {
+        tanya: (prompt) => {
+            process.stdout.write(prompt);
+            const siap = antrian.shift();
+            if (siap !== undefined)
+                return Promise.resolve(siap);
+            if (berakhir)
+                return Promise.resolve(null);
+            return new Promise((resolve) => penunggu.push(resolve));
+        },
+        tutup: () => rl.close(),
+    };
+}
+/** Pembuat callback konfirmasi bersama untuk do/ask/chat di atas satu PembacaBaris. */
+function buatKonfirmasi(pembaca) {
+    return async (deskripsi) => {
+        console.log(`\n[vibekit] Usulan aksi:\n${deskripsi}`);
+        const jawaban = await pembaca.tanya("Jalankan? (y/N) ");
+        if (jawaban === null)
+            return false; // EOF: tolak demi keamanan
+        const j = jawaban.trim().toLowerCase();
+        return j === "y" || j === "ya";
+    };
 }
 async function perintahAsk(args) {
     const urai = uraiArgAsk(args);
@@ -116,12 +159,45 @@ async function perintahAsk(args) {
         for (const d of konteks.dilewati)
             console.error(`[vibekit] konteks dilewati: ${d}`);
     }
-    const hasil = await tanyaRouter({
-        config,
-        messages: [{ role: "user", content: isiUser }],
-        lokasiState: statePath(),
-    });
-    return tampilkanHasil(hasil);
+    // Sejak v0.3.0 ask menjalankan SATU giliran agent: pertanyaan biasa dijawab
+    // teks langsung, permintaan membuat file/perintah dijalankan lewat tool
+    // dengan konfirmasi — pagar keamanan yang sama seperti `do`.
+    const messages = [
+        { role: "system", content: SYSTEM_PROMPT_GABUNGAN },
+        { role: "user", content: isiUser },
+    ];
+    const pembaca = buatPembacaBaris();
+    try {
+        const hasil = await jalankanGiliran({
+            config,
+            messages,
+            lokasiState: statePath(),
+            cwd: process.cwd(),
+            konfirmasi: buatKonfirmasi(pembaca),
+            jejak: (pesan) => console.error(`[vibekit] ${pesan}`),
+        });
+        if (!hasil.ok) {
+            if (hasil.batasTercapai) {
+                console.error(`[vibekit] Batas langkah tercapai (${hasil.jumlahLangkah} langkah) sebelum pertanyaan ini selesai dikerjakan. Persempit permintaanmu, atau gunakan vibekit do untuk mode tugas.`);
+            }
+            else {
+                console.error(hasil.pesanGagal ?? "[vibekit] Semua penyedia gagal atau sedang tidak tersedia.");
+            }
+            return 1;
+        }
+        console.log(hasil.jawabanAkhir);
+        if (hasil.providerTerakhir) {
+            const sumber = hasil.tokenSumber === "usage" ? "dari usage API" : "estimasi";
+            console.log(`\n— dijawab oleh ${hasil.providerTerakhir.nama} (${hasil.providerTerakhir.model}) • ${formatAngka(hasil.totalToken)} token (${sumber})`);
+        }
+        for (const c of hasil.catatan) {
+            console.error(`[vibekit] dilewati ${c.nama}: ${c.alasan}`);
+        }
+        return 0;
+    }
+    finally {
+        pembaca.tutup();
+    }
 }
 async function perintahChat() {
     let config;
@@ -133,54 +209,99 @@ async function perintahChat() {
         return 2;
     }
     console.log("VibeKit chat — ketik pertanyaan, /keluar untuk berhenti.");
-    const riwayat = [];
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: "kamu> " });
-    let rlDitutup = false;
-    rl.on("close", () => {
-        rlDitutup = true;
-    });
-    const promptAman = () => {
-        if (!rlDitutup) {
-            try {
-                rl.prompt();
+    console.log("Chat ini juga bisa bertindak: minta saja dibuatkan file atau menjalankan perintah — setiap aksi meminta persetujuanmu dulu.");
+    const riwayat = [{ role: "system", content: SYSTEM_PROMPT_GABUNGAN }];
+    const pembaca = buatPembacaBaris();
+    const konfirmasi = buatKonfirmasi(pembaca);
+    try {
+        for (;;) {
+            const barisMentah = await pembaca.tanya("kamu> ");
+            if (barisMentah === null)
+                break; // stdin berakhir (EOF)
+            const baris = barisMentah.trim();
+            if (baris === "/keluar" || baris === "/exit")
+                break;
+            if (!baris)
+                continue;
+            riwayat.push({ role: "user", content: baris });
+            // Pangkas SADAR-TOOL: hanya pada batas giliran utuh, tidak pernah
+            // menyisakan pesan tool yatim atau tool_calls tanpa hasilnya.
+            const terpotong = pangkasRiwayatAman(riwayat, BATAS_TOKEN_RIWAYAT);
+            riwayat.splice(0, riwayat.length, ...terpotong);
+            const hasil = await jalankanGiliran({
+                config,
+                messages: riwayat,
+                lokasiState: statePath(),
+                cwd: process.cwd(),
+                konfirmasi,
+                jejak: (pesan) => console.error(`[vibekit] ${pesan}`),
+            });
+            if (hasil.ok) {
+                console.log(`\nvibekit (${hasil.providerTerakhir?.nama ?? "?"})> ${hasil.jawabanAkhir}\n`);
             }
-            catch {
-                /* readline sudah tertutup (EOF) — abaikan */
+            else {
+                // Giliran gagal/batas tercapai: gulung balik SELURUH giliran ini
+                // (pesan user + rangkaian parsialnya) agar riwayat tetap bersih.
+                let idxUser = -1;
+                for (let i = riwayat.length - 1; i >= 0; i--) {
+                    if (riwayat[i].role === "user") {
+                        idxUser = i;
+                        break;
+                    }
+                }
+                if (idxUser >= 0)
+                    riwayat.length = idxUser;
+                const pesan = hasil.batasTercapai
+                    ? `Batas langkah tercapai (${hasil.jumlahLangkah} langkah) pada giliran ini; giliran dibatalkan. Persempit permintaanmu.`
+                    : (hasil.pesanGagal ?? "Semua penyedia gagal atau sedang tidak tersedia.");
+                console.error(`\n${pesan}\n`);
             }
         }
-    };
-    promptAman();
-    for await (const barisMentah of rl) {
-        const baris = barisMentah.trim();
-        if (baris === "/keluar" || baris === "/exit")
-            break;
-        if (!baris) {
-            promptAman();
-            continue;
-        }
-        riwayat.push({ role: "user", content: baris });
-        // Jaga riwayat: buang giliran tertua sampai total token riwayat masuk akal.
-        while (riwayat.length > 2 &&
-            hitungToken(riwayat.map((m) => m.content).join("\n")) > BATAS_TOKEN_RIWAYAT) {
-            riwayat.splice(0, 2);
-        }
-        const hasil = await tanyaRouter({
+    }
+    finally {
+        pembaca.tutup();
+    }
+    return 0;
+}
+async function perintahDo(args) {
+    const tugas = args.join(" ").trim();
+    if (!tugas) {
+        console.error("[vibekit] Tugas kosong. Contoh: vibekit do \"buatkan file halo.txt berisi sapaan\"");
+        return 2;
+    }
+    let config;
+    try {
+        config = muatConfig().config;
+    }
+    catch (e) {
+        console.error(`[vibekit] ${e.message}`);
+        return 2;
+    }
+    const cwd = process.cwd();
+    console.log(`VibeKit agent — folder kerja: ${cwd}`);
+    console.log(`Tugas: ${tugas}`);
+    console.log("Tool baca berjalan langsung; tulis/edit file dan jalankan perintah meminta persetujuanmu satu per satu.\n");
+    const pembaca = buatPembacaBaris();
+    const konfirmasi = buatKonfirmasi(pembaca);
+    try {
+        const hasil = await jalankanAgent({
             config,
-            messages: [...riwayat],
+            tugas,
             lokasiState: statePath(),
+            cwd,
+            konfirmasi,
+            jejak: (pesan) => console.error(`[vibekit] ${pesan}`),
         });
-        if (hasil.ok) {
-            riwayat.push({ role: "assistant", content: hasil.jawaban });
-            console.log(`\nvibekit (${hasil.provider.nama})> ${hasil.jawaban}\n`);
-        }
-        else {
-            riwayat.pop(); // pertanyaan yang gagal tidak disimpan sebagai giliran selesai
-            console.error(`\n${hasil.pesan}\n`);
+        for (const c of hasil.catatan) {
+            console.error(`[vibekit] dilewati ${c.nama}: ${c.alasan}`);
         }
-        promptAman();
+        console.log(`\n— ringkasan agent (${hasil.jumlahLangkah} langkah) —`);
+        console.log(hasil.ringkasan);
+        return hasil.ok ? 0 : 1;
+    }
+    finally {
+        pembaca.tutup();
     }
-    rl.close();
-    return 0;
 }
 function perintahStatus() {
     let config;
@@ -220,6 +341,8 @@ async function utama() {
             return perintahAsk(sisa);
         case "chat":
             return perintahChat();
+        case "do":
+            return perintahDo(sisa);
         case "status":
             return perintahStatus();
         case "--version":

package/dist/router.js

@@ -38,7 +38,7 @@ export async function tanyaRouter(opsi) {
     const catatan = [];
     const system = { role: "system", content: systemPromptHemat(opsi.config.gaya) };
     const semuaPesan = [system, ...opsi.messages];
-    const tokenPromptEstimasi = hitungToken(semuaPesan.map((m) => m.content).join("\n"));
+    const tokenPromptEstimasi = hitungToken(semuaPesan.map((m) => m.content ?? "").join("\n"));
     for (const provider of opsi.config.providers) {
         const entri = statePenyedia(state, provider.nama, sekarang);
         if (sedangCooldown(entri, sekarang)) {
@@ -85,6 +85,7 @@ export async function tanyaRouter(opsi) {
             model: provider.model,
             messages: semuaPesan,
             max_tokens: opsi.config.gaya.maksTokenJawaban,
+            ...(opsi.tools && opsi.tools.length > 0 ? { tools: opsi.tools } : {}),
             ...(provider.extraBody ?? {}),
         };
         let respons;
@@ -162,8 +163,23 @@ export async function tanyaRouter(opsi) {
             catatan.push({ nama: provider.nama, model: provider.model, status: "gagal", alasan });
             continue;
         }
-        const jawaban = data?.choices?.[0]?.message?.content ?? "";
-        if (!jawaban) {
+        const pesanMentah = data?.choices?.[0]?.message;
+        const jawaban = pesanMentah?.content ?? "";
+        const toolCallsMentah = pesanMentah?.tool_calls;
+        const toolCalls = Array.isArray(toolCallsMentah)
+            ? toolCallsMentah
+                .filter((t) => !!t && typeof t === "object" && typeof t.function?.name === "string")
+                .map((t, i) => ({
+                id: typeof t.id === "string" && t.id ? t.id : `panggilan-${i + 1}`,
+                type: "function",
+                function: {
+                    name: t.function.name,
+                    arguments: typeof t.function.arguments === "string" ? t.function.arguments : JSON.stringify(t.function.arguments ?? {}),
+                },
+            }))
+            : [];
+        // Respons berisi tool_calls sah walau content kosong (mode agent).
+        if (!jawaban && toolCalls.length === 0) {
             const alasan = "respons tidak berisi jawaban (choices kosong)";
             entri.alasanTerakhir = alasan;
             simpanState(opsi.lokasiState, state);
@@ -182,13 +198,23 @@ export async function tanyaRouter(opsi) {
             tokenSumber = "usage";
         }
         else {
-            tokenTerpakai = tokenPromptEstimasi + hitungToken(jawaban);
+            // Estimasi juga menghitung argumen tool_calls (bagian dari keluaran model).
+            const teksTool = toolCalls.map((t) => `${t.function.name} ${t.function.arguments}`).join("\n");
+            tokenTerpakai = tokenPromptEstimasi + hitungToken(jawaban) + (teksTool ? hitungToken(teksTool) : 0);
             tokenSumber = "estimasi";
         }
         entri.totalToken += tokenTerpakai;
         entri.alasanTerakhir = null;
         simpanState(opsi.lokasiState, state);
-        return { ok: true, jawaban, provider, tokenTerpakai, tokenSumber, catatan };
+        return {
+            ok: true,
+            jawaban,
+            ...(toolCalls.length > 0 ? { toolCalls, pesanMentah } : {}),
+            provider,
+            tokenTerpakai,
+            tokenSumber,
+            catatan,
+        };
     }
     const baris = catatan.map((c) => {
         const lagi = c.tersediaLagi ? ` — bisa dicoba lagi ${c.tersediaLagi}` : "";

package/package.json

@@ -15,6 +15,7 @@
   },
   "files": [
     "dist",
+    "scripts",
     "README.md",
     "examples"
   ],
@@ -23,12 +24,13 @@
   "name": "@chispear/vibekit",
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "postinstall": "node scripts/banner.js",
     "prepublishOnly": "npm run build",
     "start": "node dist/cli.js",
     "test": "npm run build && node --test test/*.test.mjs"
   },
   "type": "module",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "publishConfig": {
     "access": "public"
   }

package/scripts/banner.js

@@ -0,0 +1,34 @@
+// Banner CHISPEAR — tampil otomatis setelah package berhasil terpasang
+// (npm postinstall). Tanpa dependensi; hormati NO_COLOR.
+// Salinan mandiri dari seni di src/banner.ts (skrip ini tidak boleh bergantung
+// pada dist/ karena postinstall juga berjalan sebelum build di repo clone) —
+// jaga keduanya tetap sinkron.
+const GLIF = {
+  C: [" █████ ", "██   ██", "██     ", "██     ", "██   ██", " █████ "],
+  H: ["██   ██", "██   ██", "███████", "██   ██", "██   ██", "██   ██"],
+  I: ["███", " █ ", " █ ", " █ ", " █ ", "███"],
+  S: ["███████", "██     ", "██████ ", "     ██", "     ██", "██████ "],
+  P: ["██████ ", "██   ██", "██████ ", "██     ", "██     ", "██     "],
+  E: ["███████", "██     ", "█████  ", "█████  ", "██     ", "███████"],
+  A: [" █████ ", "██   ██", "███████", "██   ██", "██   ██", "██   ██"],
+  R: ["██████ ", "██   ██", "██████ ", "██  ██ ", "██   ██", "██   ██"],
+};
+
+const kata = "CHISPEAR";
+const baris = ["", "", "", "", "", ""];
+for (const huruf of kata) {
+  const g = GLIF[huruf];
+  if (!g) continue;
+  for (let i = 0; i < 6; i++) baris[i] += (baris[i] ? "  " : "") + g[i];
+}
+
+const pakaiWarna = !process.env.NO_COLOR;
+const HIJAU = pakaiWarna ? "\x1b[1;92m" : "";
+const RESET = pakaiWarna ? "\x1b[0m" : "";
+
+console.log("");
+for (const b of baris) console.log(HIJAU + b + RESET);
+console.log("");
+console.log(HIJAU + "  VibeKit CLI terpasang — router AI hemat tokenmu siap dipakai." + RESET);
+console.log("  Mulai dengan: vibekit init   •   Bantuan: vibekit --help");
+console.log("");