@chispear/vibekit 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Emil Kusmayadi (Chispear)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,98 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# VibeKit CLI
+
+**Router AI hemat token untuk terminal Anda.** Daftarkan banyak penyedia model AI (GPT/OpenAI, Gemini, DeepSeek, OpenRouter, bahkan model lokal Ollama) dalam satu file konfigurasi — VibeKit memakai penyedia pertama sebagai bawaan, dan **otomatis pindah ke penyedia berikutnya bila kuota terdeteksi habis**. Setiap jawaban diatur ringkas poin-poin penting dan dibatasi tokennya, konteks dipilih & dipangkas sebelum dikirim, dan pemakaian token dicatat per hari per penyedia.
+
+> **Token-savvy AI router for your terminal.** Register multiple AI providers in one config file — VibeKit uses the first as default and **fails over automatically when a quota runs out**, keeps answers brief and to the point, trims attached context, and tracks daily per-provider token usage.
+
+## Kenapa VibeKit?
+
+- **Failover otomatis** — kuota GPT habis di tengah hari? Permintaan yang sama diulang transparan ke Gemini, lalu DeepSeek. Anda tidak perlu ganti alat atau ganti konfigurasi.
+- **Irit token by design** — system prompt "poin-penting", batas `max_tokens`, lampiran konteks yang diseleksi (file biner & raksasa dilewati, komentar dipangkas, ada laporan hemat token), dan riwayat chat yang dipangkas otomatis.
+- **Anggaran harian per penyedia** — pasang batas token harian; penyedia yang mencapai batas dilewati *sebelum* menabrak kuota beneran.
+- **Satu format untuk semua** — semua penyedia dipanggil lewat API OpenAI-compatible (`/chat/completions`). Penyedia apa pun yang kompatibel bisa ditambahkan hanya lewat konfigurasi.
+- **Lokal & privat** — API key tersimpan di komputer Anda (`~/.vibekit/config.json`), tidak ada server perantara.
+
+## Instalasi
+
+```bash
+npm install -g vibekit      # npm
+pnpm add -g vibekit         # pnpm
+npx vibekit ask "halo"      # tanpa install, langsung coba
+```
+
+Butuh Node.js >= 18.
+
+## Mulai Cepat
+
+```bash
+vibekit init
+```
+
+Perintah ini membuat `~/.vibekit/config.json`:
+
+```json
+{
+  "providers": [
+    { "nama": "gpt",      "baseUrl": "https://api.openai.com/v1",                              "apiKey": "", "model": "gpt-4o-mini",     "anggaranHarian": 500000, "jedaCooldownMenit": 15 },
+    { "nama": "gemini",   "baseUrl": "https://generativelanguage.googleapis.com/v1beta/openai/", "apiKey": "", "model": "gemini-2.5-flash", "jedaCooldownMenit": 15 },
+    { "nama": "deepseek", "baseUrl": "https://api.deepseek.com/v1",                            "apiKey": "", "model": "deepseek-chat",    "jedaCooldownMenit": 15 }
+  ],
+  "gaya": { "jawaban": "poin-penting", "maksTokenJawaban": 800 }
+}
+```
+
+Isi `apiKey` tiap penyedia (atau gunakan sintaks `"env:NAMA_VAR"` untuk membaca dari variabel lingkungan). **Urutan array = prioritas**: `gpt` dipakai duluan; bila kuotanya habis, lanjut `gemini`, lalu `deepseek`. Tambah penyedia lain (OpenRouter, Ollama lokal) cukup dengan menambah entri — lihat `examples/vibekit.config.json`.
+
+Konfigurasi per proyek: file `./vibekit.config.json` di folder proyek **menimpa** konfigurasi global, jadi tiap proyek bisa punya susunan penyedia sendiri.
+
+Lalu:
+
+```bash
+vibekit ask "jelaskan apa itu REST API"
+vibekit ask "tinjau kode ini" --file src/app.ts --dir src/
+vibekit chat
+vibekit status
+```
+
+## Perintah
+
+| 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 status` | Tabel per penyedia: model, status (aktif / cooldown s.d. jam / anggaran tercapai), token terpakai hari ini |
+| `vibekit --help` / `--version` | Bantuan / versi |
+
+## 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.
+2. Saat memanggil, permintaan berisi system prompt hemat sesuai `gaya.jawaban` dan `max_tokens` = `gaya.maksTokenJawaban`. Objek `extraBody` per penyedia (bila ada) digabung ke body — berguna untuk kenop khas model, mis. menekan penalaran.
+3. Bila respons menandakan kuota habis — HTTP **429/402** atau pola error `insufficient_quota` / `RESOURCE_EXHAUSTED` / saldo — penyedia ditandai **cooldown sampai akhir hari lokal** dan permintaan yang sama diulangi ke penyedia berikutnya. Rate-limit singkat (429 tanpa pola kuota) → cooldown `jedaCooldownMenit` (bawaan 15 menit).
+4. Error lain (401 kunci salah, 400, jaringan) **tidak** dianggap kuota habis: dicatat apa adanya dan router tetap mencoba penyedia berikutnya.
+5. Token terpakai dicatat dari field `usage` respons (atau estimasi tokenizer bila tidak ada). Bila semua penyedia gagal/habis, Anda menerima ringkasan status tiap penyedia dan jam paling awal untuk mencoba lagi.
+
+## Penghematan Token
+
+- **System prompt ringkas** — gaya `poin-penting` memerintahkan model menjawab hanya poin penting tanpa basa-basi; tersedia juga `normal` dan `detail`.
+- **Batas jawaban keras** — `maksTokenJawaban` menjadi `max_tokens` di setiap permintaan.
+- **Konteks terseleksi** — `--file/--dir` melewati file biner & file > 256 KB, memangkas baris komentar penuh dan baris kosong berlebih, dan membatasi total konteks (±16.000 token) dengan memotong berkas terbesar. Selisih token mentah vs terseleksi selalu ditampilkan.
+- **Anggaran & pencatatan** — pemakaian per penyedia per hari terlihat di `vibekit status`, sehingga boros selalu kelihatan.
+
+## Pengembangan
+
+```bash
+npm install
+npm test        # build + uji node:test melawan server tiruan lokal (tanpa API key asli)
+npm run build   # tsc → dist/
+```
+
+Keputusan repo: `dist/` masuk `.gitignore` dan dibangun saat publish (`prepublishOnly`), jadi repo tetap bersih; `vibekit.config.json` dan `.vibekit/` juga di-ignore karena dapat berisi API key.
+
+## Status Nama di npm
+
+Nama paket **`vibekit` di npm sudah terpakai** oleh proyek lain (per Oktober 2026). Sebelum publish, nama perlu diganti — mis. scoped package `@username/vibekit` atau nama turunan — keputusan ada pada pemilik repo. Nama perintah CLI tetap `vibekit`.
+
+## Lisensi
+
+MIT

package/dist/cli.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+import readline from "node:readline";
+import { buatConfigGlobal, globalConfigPath, muatConfig, statePath, } from "./config.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";
+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 status                        Status & pemakaian token tiap penyedia hari ini
+  vibekit --help                        Tampilkan bantuan ini
+  vibekit --version                     Tampilkan versi
+
+Opsi ask:
+  --file <path>    Lampirkan file sebagai konteks (boleh diulang)
+  --dir <path>     Lampirkan isi folder sebagai konteks (boleh diulang)
+
+Cara kerja singkat:
+  Penyedia dicoba sesuai urutan di konfigurasi. Bila kuota penyedia terdeteksi
+  habis, permintaan otomatis diulang ke penyedia berikutnya. Setiap jawaban
+  diatur ringkas (poin-poin penting) dan dibatasi tokennya agar hemat.
+  Konfigurasi proyek ./vibekit.config.json menimpa konfigurasi global.
+`);
+}
+function perintahInit() {
+    const dibuat = buatConfigGlobal();
+    if (dibuat) {
+        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.");
+    }
+    else {
+        console.log(`Konfigurasi sudah ada di ${globalConfigPath()} — tidak ditimpa.`);
+        console.log("Edit file itu langsung bila ingin mengubah penyedia, model, atau anggaran.");
+    }
+    return 0;
+}
+function uraiArgAsk(args) {
+    const files = [];
+    const dirs = [];
+    const sisa = [];
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--file") {
+            const v = args[++i];
+            if (!v)
+                return { error: "Opsi --file membutuhkan path file." };
+            files.push(v);
+        }
+        else if (a === "--dir") {
+            const v = args[++i];
+            if (!v)
+                return { error: "Opsi --dir membutuhkan path folder." };
+            dirs.push(v);
+        }
+        else if (a.startsWith("--file=")) {
+            files.push(a.slice("--file=".length));
+        }
+        else if (a.startsWith("--dir=")) {
+            dirs.push(a.slice("--dir=".length));
+        }
+        else {
+            sisa.push(a);
+        }
+    }
+    const pertanyaan = sisa.join(" ").trim();
+    if (!pertanyaan)
+        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;
+}
+async function perintahAsk(args) {
+    const urai = uraiArgAsk(args);
+    if ("error" in urai) {
+        console.error(`[vibekit] ${urai.error}`);
+        return 2;
+    }
+    let config;
+    try {
+        config = muatConfig().config;
+    }
+    catch (e) {
+        console.error(`[vibekit] ${e.message}`);
+        return 2;
+    }
+    let isiUser = urai.pertanyaan;
+    const target = [...urai.files, ...urai.dirs];
+    if (target.length > 0) {
+        const konteks = bangunKonteks(target);
+        if (konteks.jumlahFile > 0) {
+            const hemat = konteks.tokenMentah > 0
+                ? Math.max(0, Math.round((1 - konteks.tokenTerseleksi / konteks.tokenMentah) * 100))
+                : 0;
+            console.error(`[vibekit] konteks: ${konteks.jumlahFile} file • token mentah ${formatAngka(konteks.tokenMentah)} → terseleksi ${formatAngka(konteks.tokenTerseleksi)} (hemat ${hemat}%)`);
+            isiUser = `Konteks proyek:\n\n${konteks.teks}\n\nPertanyaan: ${urai.pertanyaan}`;
+        }
+        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);
+}
+async function perintahChat() {
+    let config;
+    try {
+        config = muatConfig().config;
+    }
+    catch (e) {
+        console.error(`[vibekit] ${e.message}`);
+        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();
+            }
+            catch {
+                /* readline sudah tertutup (EOF) — abaikan */
+            }
+        }
+    };
+    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({
+            config,
+            messages: [...riwayat],
+            lokasiState: statePath(),
+        });
+        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`);
+        }
+        promptAman();
+    }
+    rl.close();
+    return 0;
+}
+function perintahStatus() {
+    let config;
+    try {
+        config = muatConfig().config;
+    }
+    catch (e) {
+        console.error(`[vibekit] ${e.message}`);
+        return 2;
+    }
+    const state = muatState(statePath());
+    const sekarang = new Date();
+    const baris = [["Penyedia", "Model", "Status", "Token hari ini"]];
+    for (const p of config.providers) {
+        const entri = statePenyedia(state, p.nama, sekarang);
+        let status = "aktif";
+        if (sedangCooldown(entri, sekarang) && entri.cooldownUntil) {
+            status = `cooldown s.d. ${formatJam(entri.cooldownUntil)}`;
+        }
+        else if (typeof p.anggaranHarian === "number" && entri.totalToken >= p.anggaranHarian) {
+            status = "anggaran harian tercapai";
+        }
+        baris.push([p.nama, p.model, status, formatAngka(entri.totalToken)]);
+    }
+    const lebar = baris[0].map((_, i) => Math.max(...baris.map((b) => b[i].length)));
+    for (const b of baris) {
+        console.log(b.map((sel, i) => sel.padEnd(lebar[i])).join("  "));
+    }
+    return 0;
+}
+async function utama() {
+    const [perintah, ...sisa] = process.argv.slice(2);
+    switch (perintah) {
+        case "init":
+            return perintahInit();
+        case "ask":
+            return perintahAsk(sisa);
+        case "chat":
+            return perintahChat();
+        case "status":
+            return perintahStatus();
+        case "--version":
+        case "-v":
+            console.log(VERSI);
+            return 0;
+        case "--help":
+        case "-h":
+        case "help":
+        case undefined:
+            bantuan();
+            return 0;
+        default:
+            console.error(`[vibekit] Perintah tidak dikenal: ${perintah}\n`);
+            bantuan();
+            return 2;
+    }
+}
+utama()
+    .then((kode) => {
+    process.exitCode = kode;
+})
+    .catch((e) => {
+    console.error(`[vibekit] Kesalahan tak terduga: ${e.message}`);
+    process.exitCode = 1;
+});

package/dist/config.js

@@ -0,0 +1,110 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function configDir() {
+    return path.join(os.homedir(), ".vibekit");
+}
+export function globalConfigPath() {
+    return path.join(configDir(), "config.json");
+}
+export function statePath() {
+    return path.join(configDir(), "state.json");
+}
+export function projectConfigPath(cwd = process.cwd()) {
+    return path.join(cwd, "vibekit.config.json");
+}
+const BASE_URL_BAWAAN = {
+    gpt: "https://api.openai.com/v1",
+    openai: "https://api.openai.com/v1",
+    gemini: "https://generativelanguage.googleapis.com/v1beta/openai/",
+    google: "https://generativelanguage.googleapis.com/v1beta/openai/",
+    deepseek: "https://api.deepseek.com/v1",
+};
+export const TEMPLATE_CONFIG = {
+    providers: [
+        {
+            nama: "gpt",
+            baseUrl: "https://api.openai.com/v1",
+            apiKey: "",
+            model: "gpt-4o-mini",
+            anggaranHarian: 500000,
+            jedaCooldownMenit: 15,
+        },
+        {
+            nama: "gemini",
+            baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai/",
+            apiKey: "",
+            model: "gemini-2.5-flash",
+            jedaCooldownMenit: 15,
+        },
+        {
+            nama: "deepseek",
+            baseUrl: "https://api.deepseek.com/v1",
+            apiKey: "",
+            model: "deepseek-chat",
+            jedaCooldownMenit: 15,
+        },
+    ],
+    gaya: { jawaban: "poin-penting", maksTokenJawaban: 800 },
+};
+/** Buat ~/.vibekit/config.json dari template. Kembalikan false bila sudah ada (tidak ditimpa). */
+export function buatConfigGlobal() {
+    const target = globalConfigPath();
+    if (fs.existsSync(target))
+        return false;
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, JSON.stringify(TEMPLATE_CONFIG, null, 2) + "\n", "utf8");
+    return true;
+}
+function normalisasiProvider(p) {
+    const nama = String(p.nama);
+    return {
+        nama,
+        baseUrl: p.baseUrl ?? BASE_URL_BAWAAN[nama.toLowerCase()] ?? "",
+        apiKey: p.apiKey ?? "",
+        model: p.model ?? "",
+        anggaranHarian: typeof p.anggaranHarian === "number" ? p.anggaranHarian : undefined,
+        jedaCooldownMenit: typeof p.jedaCooldownMenit === "number" ? p.jedaCooldownMenit : undefined,
+        extraBody: p.extraBody,
+    };
+}
+/**
+ * Muat konfigurasi: file proyek ./vibekit.config.json menimpa global ~/.vibekit/config.json.
+ * Lempar Error dengan pesan Bahasa Indonesia bila tidak ada konfigurasi / tidak valid.
+ */
+export function muatConfig(cwd = process.cwd()) {
+    const proyek = projectConfigPath(cwd);
+    const global = globalConfigPath();
+    const sumber = fs.existsSync(proyek) ? proyek : fs.existsSync(global) ? global : null;
+    if (!sumber) {
+        throw new Error("Konfigurasi tidak ditemukan. Jalankan `vibekit init` untuk membuat ~/.vibekit/config.json, " +
+            "atau buat file vibekit.config.json di folder proyek ini.");
+    }
+    let mentah;
+    try {
+        mentah = JSON.parse(fs.readFileSync(sumber, "utf8"));
+    }
+    catch (e) {
+        throw new Error(`Konfigurasi di ${sumber} bukan JSON yang valid: ${e.message}`);
+    }
+    const obj = mentah;
+    if (!obj || !Array.isArray(obj.providers) || obj.providers.length === 0) {
+        throw new Error(`Konfigurasi di ${sumber} harus berisi array "providers" yang tidak kosong.`);
+    }
+    const config = {
+        providers: obj.providers.map((p) => normalisasiProvider(p)),
+        gaya: {
+            jawaban: obj.gaya?.jawaban ?? "poin-penting",
+            maksTokenJawaban: typeof obj.gaya?.maksTokenJawaban === "number" ? obj.gaya.maksTokenJawaban : 800,
+        },
+    };
+    return { config, sumber };
+}
+/** Selesaikan nilai apiKey: sintaks "env:NAMA_VAR" dibaca dari variabel lingkungan. */
+export function selesaikanApiKey(apiKey) {
+    if (apiKey.startsWith("env:")) {
+        const namaVar = apiKey.slice(4).trim();
+        return process.env[namaVar] ?? "";
+    }
+    return apiKey;
+}

package/dist/context.js

@@ -0,0 +1,115 @@
+import fs from "node:fs";
+import path from "node:path";
+import { hitungToken } from "./token.js";
+const EKSTENSI_BINER = new Set([
+    ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".bmp", ".tiff",
+    ".exe", ".dll", ".so", ".dylib", ".bin", ".o", ".class",
+    ".zip", ".tar", ".gz", ".rar", ".7z",
+    ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx",
+    ".mp3", ".mp4", ".wav", ".mov", ".avi", ".mkv",
+    ".woff", ".woff2", ".ttf", ".eot", ".wasm",
+]);
+const DIR_LEWATI = new Set(["node_modules", ".git", "dist", ".vibekit", ".next", "coverage"]);
+const UKURAN_MAKS_FILE = 256 * 1024; // 256 KB — di atas ini dianggap raksasa, dilewati
+const CAP_TOKEN_KONTEKS = 16_000;
+function terlihatBiner(lokasi, buffer) {
+    if (EKSTENSI_BINER.has(path.extname(lokasi).toLowerCase()))
+        return true;
+    const sampel = buffer.subarray(0, 4096);
+    return sampel.includes(0);
+}
+/** Pangkas ringan: buang baris komentar penuh & rapatkan baris kosong berlebih. */
+export function pangkasTeks(teks) {
+    const baris = teks.split("\n");
+    const hasil = [];
+    let kosongBeruntun = 0;
+    for (const mentah of baris) {
+        const barisRapi = mentah.replace(/\s+$/, "");
+        const trim = barisRapi.trim();
+        const komentarPenuh = (trim.startsWith("//") && !trim.startsWith("///")) ||
+            (trim.startsWith("#") && !trim.startsWith("#!") && trim.length > 1) ||
+            (trim.startsWith("/*") && trim.endsWith("*/") && trim.length > 3) ||
+            trim === "/*" || trim === "*/" || (trim.startsWith("* ") && trim.length > 2);
+        if (komentarPenuh)
+            continue;
+        if (trim === "") {
+            kosongBeruntun++;
+            if (kosongBeruntun > 1)
+                continue;
+        }
+        else {
+            kosongBeruntun = 0;
+        }
+        hasil.push(barisRapi);
+    }
+    return hasil.join("\n").trim();
+}
+function kumpulkanFile(targets) {
+    const file = [];
+    const dilewati = [];
+    const kunjungi = (lokasi) => {
+        let stat;
+        try {
+            stat = fs.statSync(lokasi);
+        }
+        catch {
+            dilewati.push(`${lokasi} (tidak ditemukan)`);
+            return;
+        }
+        if (stat.isDirectory()) {
+            const nama = path.basename(lokasi);
+            if (DIR_LEWATI.has(nama)) {
+                dilewati.push(`${lokasi} (folder dilewati)`);
+                return;
+            }
+            for (const entri of fs.readdirSync(lokasi).sort())
+                kunjungi(path.join(lokasi, entri));
+        }
+        else if (stat.isFile()) {
+            file.push(lokasi);
+        }
+    };
+    for (const t of targets)
+        kunjungi(t);
+    return { file, dilewati };
+}
+/** Bangun teks konteks dari daftar file/folder, dengan seleksi & pemangkasan hemat token. */
+export function bangunKonteks(targets, capToken = CAP_TOKEN_KONTEKS) {
+    const { file, dilewati } = kumpulkanFile(targets);
+    const berkas = [];
+    for (const lokasi of file) {
+        const stat = fs.statSync(lokasi);
+        if (stat.size > UKURAN_MAKS_FILE) {
+            dilewati.push(`${lokasi} (terlalu besar: ${Math.round(stat.size / 1024)} KB)`);
+            continue;
+        }
+        const buffer = fs.readFileSync(lokasi);
+        if (terlihatBiner(lokasi, buffer)) {
+            dilewati.push(`${lokasi} (biner)`);
+            continue;
+        }
+        const mentah = buffer.toString("utf8");
+        const bersih = pangkasTeks(mentah);
+        berkas.push({ lokasi, mentah, bersih, tokenMentah: hitungToken(mentah), tokenBersih: hitungToken(bersih) });
+    }
+    let tokenMentah = berkas.reduce((a, b) => a + b.tokenMentah, 0);
+    let tokenTerseleksi = berkas.reduce((a, b) => a + b.tokenBersih, 0);
+    // Bila masih melewati cap: potong isi berkas terbesar berulang kali sampai muat.
+    let pengaman = 0;
+    while (tokenTerseleksi > capToken && berkas.length > 0 && pengaman++ < 200) {
+        berkas.sort((a, b) => b.tokenBersih - a.tokenBersih);
+        const terbesar = berkas[0];
+        if (terbesar.tokenBersih <= 40)
+            break;
+        const potong = Math.floor(terbesar.bersih.length / 2);
+        terbesar.bersih = terbesar.bersih.slice(0, potong) + "\n…[dipotong demi anggaran token]";
+        terbesar.tokenBersih = hitungToken(terbesar.bersih);
+        tokenTerseleksi = berkas.reduce((a, b) => a + b.tokenBersih, 0);
+    }
+    const teks = berkas
+        .map((b) => `### File: ${b.lokasi}\n\`\`\`\n${b.bersih}\n\`\`\``)
+        .join("\n\n");
+    tokenMentah = berkas.reduce((a, b) => a + b.tokenMentah, 0);
+    tokenTerseleksi = berkas.reduce((a, b) => a + b.tokenBersih, 0);
+    return { teks, jumlahFile: berkas.length, tokenMentah, tokenTerseleksi, dilewati };
+}

package/dist/prompt.js

@@ -0,0 +1,25 @@
+/** System prompt hemat token sesuai gaya jawaban pada konfigurasi. */
+export function systemPromptHemat(gaya) {
+    switch ((gaya.jawaban || "poin-penting").toLowerCase()) {
+        case "detail":
+            return [
+                "Jawablah dengan jelas dan terstruktur.",
+                "Hindari basa-basi, pembuka yang bertele-tele, dan pengulangan pertanyaan.",
+                "Bila jawaban panjang diperlukan, gunakan subjudul atau poin agar mudah dipindai.",
+            ].join(" ");
+        case "normal":
+            return [
+                "Jawablah secara ringkas dan langsung ke inti.",
+                "Tanpa basa-basi, tanpa mengulang pertanyaan, tanpa penjelasan yang tidak diminta.",
+            ].join(" ");
+        case "poin-penting":
+        default:
+            return [
+                "Jawablah SANGAT ringkas, hanya poin-poin penting, dalam format poin (bullet list) bila cocok.",
+                "DILARANG: basa-basi, pembuka/penutup sopan-santun, mengulang atau parafrase pertanyaan,",
+                "menjelaskan hal yang tidak ditanyakan, dan kalimat pengisi.",
+                "Satu poin = satu ide, sesingkat mungkin sambil tetap akurat dan lengkap pada intinya.",
+                "Untuk kode: berikan kodenya saja ditambah penjelasan maksimal satu baris bila perlu.",
+            ].join(" ");
+    }
+}

package/dist/router.js

@@ -0,0 +1,180 @@
+import { selesaikanApiKey } from "./config.js";
+import { systemPromptHemat } from "./prompt.js";
+import { akhirHariIni, formatJam, muatState, sedangCooldown, simpanState, statePenyedia, } from "./state.js";
+import { formatAngka, hitungToken } from "./token.js";
+const POLA_KUOTA = /insufficient_quota|resource_exhausted|quota exceeded|exceeded your quota|kuota|insufficient balance|balance is too low|credit balance|billing/i;
+/** Klasifikasikan kegagalan HTTP: kuota habis, rate-limit singkat, atau error lain. */
+export function klasifikasiError(status, bodyTeks) {
+    const potongan = bodyTeks.replace(/\s+/g, " ").slice(0, 200);
+    if (status === 402 || POLA_KUOTA.test(bodyTeks)) {
+        return { jenis: "kuota", ringkas: `kuota/saldo habis (HTTP ${status}) ${potongan}`.trim() };
+    }
+    if (status === 429) {
+        return { jenis: "rate-limit", ringkas: `terkena rate-limit (HTTP 429) ${potongan}`.trim() };
+    }
+    return { jenis: "lainnya", ringkas: `HTTP ${status} ${potongan}`.trim() };
+}
+/**
+ * Mesin router: coba penyedia sesuai urutan prioritas konfigurasi.
+ * - Penyedia yang cooldown / anggaran hariannya tercapai dilewati tanpa dipanggil.
+ * - Kuota habis (429/402/pola kuota) → cooldown sampai akhir hari lokal, lalu permintaan
+ *   yang sama diulangi ke penyedia berikutnya secara transparan.
+ * - Rate-limit singkat → cooldown jedaCooldownMenit (bawaan 15).
+ * - Error lain (401, 400, jaringan) tidak dianggap kuota habis; dicatat dan lanjut ke berikutnya.
+ */
+export async function tanyaRouter(opsi) {
+    const fetchImpl = opsi.fetchImpl ?? fetch;
+    const sekarang = opsi.sekarang ?? new Date();
+    const timeoutMs = opsi.timeoutMs ?? 90_000;
+    const state = muatState(opsi.lokasiState);
+    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"));
+    for (const provider of opsi.config.providers) {
+        const entri = statePenyedia(state, provider.nama, sekarang);
+        if (sedangCooldown(entri, sekarang)) {
+            catatan.push({
+                nama: provider.nama,
+                model: provider.model,
+                status: "cooldown",
+                alasan: entri.alasanTerakhir ?? "sedang istirahat (cooldown)",
+                tersediaLagi: entri.cooldownUntil ? formatJam(entri.cooldownUntil) : undefined,
+            });
+            continue;
+        }
+        if (typeof provider.anggaranHarian === "number" && entri.totalToken >= provider.anggaranHarian) {
+            catatan.push({
+                nama: provider.nama,
+                model: provider.model,
+                status: "anggaran-tercapai",
+                alasan: `anggaran harian tercapai (${formatAngka(entri.totalToken)} / ${formatAngka(provider.anggaranHarian)} token)`,
+                tersediaLagi: "besok (reset harian)",
+            });
+            continue;
+        }
+        const apiKey = selesaikanApiKey(provider.apiKey ?? "");
+        if (!apiKey) {
+            catatan.push({
+                nama: provider.nama,
+                model: provider.model,
+                status: "tanpa-kunci",
+                alasan: "API key belum diisi di konfigurasi",
+            });
+            continue;
+        }
+        if (!provider.baseUrl) {
+            catatan.push({
+                nama: provider.nama,
+                model: provider.model,
+                status: "konfigurasi-salah",
+                alasan: "baseUrl kosong dan tidak ada bawaan untuk nama penyedia ini",
+            });
+            continue;
+        }
+        const url = provider.baseUrl.replace(/\/+$/, "") + "/chat/completions";
+        const body = {
+            model: provider.model,
+            messages: semuaPesan,
+            max_tokens: opsi.config.gaya.maksTokenJawaban,
+            ...(provider.extraBody ?? {}),
+        };
+        let respons;
+        try {
+            const kontroler = new AbortController();
+            const pengatur = setTimeout(() => kontroler.abort(), timeoutMs);
+            try {
+                respons = await fetchImpl(url, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${apiKey}`,
+                    },
+                    body: JSON.stringify(body),
+                    signal: kontroler.signal,
+                });
+            }
+            finally {
+                clearTimeout(pengatur);
+            }
+        }
+        catch (e) {
+            const alasan = `gagal jaringan: ${e.message}`;
+            entri.alasanTerakhir = alasan;
+            simpanState(opsi.lokasiState, state);
+            catatan.push({ nama: provider.nama, model: provider.model, status: "gagal", alasan });
+            continue;
+        }
+        const teks = await respons.text();
+        if (!respons.ok) {
+            const { jenis, ringkas } = klasifikasiError(respons.status, teks);
+            entri.alasanTerakhir = ringkas;
+            if (jenis === "kuota") {
+                entri.cooldownUntil = akhirHariIni(sekarang).toISOString();
+            }
+            else if (jenis === "rate-limit") {
+                const menit = provider.jedaCooldownMenit ?? 15;
+                entri.cooldownUntil = new Date(sekarang.getTime() + menit * 60_000).toISOString();
+            }
+            simpanState(opsi.lokasiState, state);
+            catatan.push({
+                nama: provider.nama,
+                model: provider.model,
+                status: jenis === "lainnya" ? "gagal" : "cooldown",
+                alasan: ringkas,
+                tersediaLagi: entri.cooldownUntil ? formatJam(entri.cooldownUntil) : undefined,
+            });
+            continue;
+        }
+        let data;
+        try {
+            data = JSON.parse(teks);
+        }
+        catch {
+            const alasan = "respons bukan JSON yang valid";
+            entri.alasanTerakhir = alasan;
+            simpanState(opsi.lokasiState, state);
+            catatan.push({ nama: provider.nama, model: provider.model, status: "gagal", alasan });
+            continue;
+        }
+        const jawaban = data?.choices?.[0]?.message?.content ?? "";
+        if (!jawaban) {
+            const alasan = "respons tidak berisi jawaban (choices kosong)";
+            entri.alasanTerakhir = alasan;
+            simpanState(opsi.lokasiState, state);
+            catatan.push({ nama: provider.nama, model: provider.model, status: "gagal", alasan });
+            continue;
+        }
+        let tokenTerpakai;
+        let tokenSumber;
+        const usage = data?.usage;
+        if (usage && typeof usage.total_tokens === "number") {
+            tokenTerpakai = usage.total_tokens;
+            tokenSumber = "usage";
+        }
+        else if (usage && typeof usage.prompt_tokens === "number" && typeof usage.completion_tokens === "number") {
+            tokenTerpakai = usage.prompt_tokens + usage.completion_tokens;
+            tokenSumber = "usage";
+        }
+        else {
+            tokenTerpakai = tokenPromptEstimasi + hitungToken(jawaban);
+            tokenSumber = "estimasi";
+        }
+        entri.totalToken += tokenTerpakai;
+        entri.alasanTerakhir = null;
+        simpanState(opsi.lokasiState, state);
+        return { ok: true, jawaban, provider, tokenTerpakai, tokenSumber, catatan };
+    }
+    const baris = catatan.map((c) => {
+        const lagi = c.tersediaLagi ? ` — bisa dicoba lagi ${c.tersediaLagi}` : "";
+        return `  • ${c.nama} (${c.model}): ${c.status} — ${c.alasan}${lagi}`;
+    });
+    const palingAwal = catatan
+        .filter((c) => c.tersediaLagi && c.status === "cooldown")
+        .map((c) => c.tersediaLagi)
+        .sort()[0];
+    const pesan = "Semua penyedia gagal atau sedang tidak tersedia:\n" +
+        baris.join("\n") +
+        (palingAwal ? `\nPenyedia paling awal bisa dicoba lagi sekitar pukul ${palingAwal}.` : "");
+    return { ok: false, pesan, catatan };
+}

package/dist/state.js

@@ -0,0 +1,58 @@
+import fs from "node:fs";
+import path from "node:path";
+/** Tanggal lokal pengguna dalam format YYYY-MM-DD. */
+export function tanggalLokal(d = new Date()) {
+    const y = d.getFullYear();
+    const m = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return `${y}-${m}-${day}`;
+}
+/** Timestamp akhir hari lokal (23:59:59.999) — cooldown untuk kuota habis. */
+export function akhirHariIni(d = new Date()) {
+    const akhir = new Date(d);
+    akhir.setHours(23, 59, 59, 999);
+    return akhir;
+}
+export function muatState(lokasi) {
+    try {
+        if (fs.existsSync(lokasi)) {
+            const mentah = JSON.parse(fs.readFileSync(lokasi, "utf8"));
+            if (mentah && typeof mentah === "object" && mentah.providers)
+                return mentah;
+        }
+    }
+    catch {
+        /* state rusak → mulai dari kosong */
+    }
+    return { providers: {} };
+}
+export function simpanState(lokasi, state) {
+    fs.mkdirSync(path.dirname(lokasi), { recursive: true });
+    const sementara = lokasi + ".tmp";
+    fs.writeFileSync(sementara, JSON.stringify(state, null, 2) + "\n", "utf8");
+    fs.renameSync(sementara, lokasi);
+}
+/**
+ * Ambil state penyedia untuk hari ini. Bila entri berasal dari hari lain,
+ * hitungan token direset (cooldown akhir-hari otomatis kedaluwarsa).
+ */
+export function statePenyedia(state, nama, sekarang = new Date()) {
+    const hariIni = tanggalLokal(sekarang);
+    let entri = state.providers[nama];
+    if (!entri || entri.tanggal !== hariIni) {
+        entri = { tanggal: hariIni, totalToken: 0, cooldownUntil: null, alasanTerakhir: null };
+        state.providers[nama] = entri;
+    }
+    return entri;
+}
+export function sedangCooldown(entri, sekarang = new Date()) {
+    if (!entri.cooldownUntil)
+        return false;
+    return new Date(entri.cooldownUntil).getTime() > sekarang.getTime();
+}
+export function formatJam(iso) {
+    const d = new Date(iso);
+    const hh = String(d.getHours()).padStart(2, "0");
+    const mm = String(d.getMinutes()).padStart(2, "0");
+    return `${hh}:${mm}`;
+}

package/dist/token.js

@@ -0,0 +1,16 @@
+import { encode } from "gpt-tokenizer";
+/** Hitung token teks (estimasi, encoding cl100k_base — cukup akurat untuk OpenAI & estimasi umum). */
+export function hitungToken(teks) {
+    if (!teks)
+        return 0;
+    try {
+        return encode(teks).length;
+    }
+    catch {
+        // Cadangan kasar bila tokenizer gagal: ~4 karakter per token.
+        return Math.ceil(teks.length / 4);
+    }
+}
+export function formatAngka(n) {
+    return n.toLocaleString("id-ID");
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/examples/vibekit.config.json

@@ -0,0 +1 @@
+{"gaya":{"jawaban":"poin-penting","maksTokenJawaban":800},"providers":[{"anggaranHarian":500000,"apiKey":"","baseUrl":"https://api.openai.com/v1","jedaCooldownMenit":15,"model":"gpt-4o-mini","nama":"gpt"},{"apiKey":"env:GEMINI_API_KEY","baseUrl":"https://generativelanguage.googleapis.com/v1beta/openai/","jedaCooldownMenit":15,"model":"gemini-2.5-flash","nama":"gemini"},{"apiKey":"env:DEEPSEEK_API_KEY","baseUrl":"https://api.deepseek.com/v1","extraBody":{},"jedaCooldownMenit":15,"model":"deepseek-chat","nama":"deepseek"},{"apiKey":"env:OPENROUTER_API_KEY","baseUrl":"https://openrouter.ai/api/v1","model":"openai/gpt-4o-mini","nama":"openrouter"},{"apiKey":"ollama","baseUrl":"http://localhost:11434/v1","model":"llama3.1","nama":"ollama-lokal"}]}

package/package.json

@@ -1,6 +1,35 @@
-{
-  "name": "@chispear/vibekit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "bin": {
+    "vibekit": "dist/cli.js"
+  },
+  "dependencies": {
+    "gpt-tokenizer": "^2.5.0"
+  },
+  "description": "VibeKit CLI — router AI hemat token: banyak penyedia model dalam satu konfigurasi, failover otomatis saat kuota habis, jawaban ringkas poin-poin penting.",
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "examples"
+  ],
+  "license": "MIT",
+  "main": "dist/cli.js",
+  "name": "@chispear/vibekit",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/cli.js",
+    "test": "npm run build && node --test test/*.test.mjs"
+  },
+  "type": "module",
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public"
+  }
+}