kiosapi 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PT Mura Teras Kreatif
+
+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

@@ -0,0 +1,65 @@
+# @kiosapi/cli
+
+CLI Kiosapi.id berbahasa Indonesia — bangun aplikasimu memakai API key Kiosapi.
+
+## Sesi interaktif (seperti Claude Code)
+
+Jalankan `kiosapi` tanpa argumen → login (sekali) → masuk sesi. Ketik **tugas langsung** ke agen;
+perintah meta diawali **`/`** (jadi `/isi` ≠ "isi kode di file ini"):
+
+```text
+$ kiosapi
+buat › bikin file hello.js yang mencetak "Halo Dunia", lalu jalankan
+buat › /mode rencana      # ganti mode (rencana | edit | buat)
+rencana › /saldo          # perintah meta: /model /otomatis /bersih /pakai /isi /bantuan /keluar
+```
+
+Riwayat percakapan menyatuh antar giliran. Default mode `buat` (otonom, minta izin sebelum tulis/
+jalankan; `/otomatis` untuk melewati). Subperintah satu-kali di bawah tetap ada untuk skrip/CI.
+
+## Subperintah
+
+(inti tipis, tanpa dependensi eksternal — hanya Node ≥20 built-ins):
+
+```bash
+kiosapi masuk                 # simpan API key (kios_live_…)
+kiosapi periksa               # cek konektivitas + setelan
+kiosapi model --cari coding   # daftar model
+kiosapi tanya "halo"          # tanya sekali (streaming)
+kiosapi ngobrol               # mode percakapan (REPL)
+kiosapi setel model <id>      # atur model default
+```
+
+Pipe stdin: `cat error.log | kiosapi tanya "jelaskan error ini"`.
+
+**Agen built-in** (butuh model yang mendukung tool calling, mis. `anthropic/claude-sonnet-4-6`):
+
+```bash
+kiosapi rencana "telusuri kode & susun rencana"   # read-only
+kiosapi edit "ganti judul jadi Halo Dunia"         # tulis/edit file (konfirmasi)
+kiosapi buat "bikin REST API Express + tes"        # agen otonom (tulis + jalankan)
+kiosapi tim "bikin endpoint /health + tes"          # multi-agen: perencana→pengkode→peninjau
+# Opsi: -m <model>, --otomatis (lewati konfirmasi). Tool dibatasi ke direktori kerja;
+# .env & .kiosapiignore dilindungi.
+```
+
+**Multimodal:**
+
+```bash
+kiosapi gambar "kucing astronot" -o kucing.png   # buat gambar → file
+kiosapi video "ombak pantai senja" --detik 6      # buat video (async) → .mp4
+kiosapi lihat foto.png "apa isinya?"              # tanya model vision soal gambar
+```
+Agen `edit`/`buat` juga punya tool `buat_gambar` untuk membuat aset.
+
+**Sambung ke agen lain** (OpenAI-compatible, vendor-netral):
+
+```bash
+kiosapi sambung aider -- --model openai/deepseek/deepseek-v3   # luncurkan aider via Kiosapi
+kiosapi sambung opencode
+kiosapi sambung cursor        # tampilkan cara setel editor
+eval "$(kiosapi sambung env)" # export OPENAI_* untuk tool apa pun
+```
+
+Konfigurasi disimpan di `~/.kiosapi/config.json` (key dapat dioverride lewat `KIOSAPI_API_KEY`).
+Lihat rencana lengkap di `docs/cli-plan.md`.

package/dist/agent/run.js

@@ -0,0 +1,131 @@
+import { writeFileSync } from 'node:fs';
+import { chatComplete, generateImage, resolveMediaModel, } from '../api.js';
+import { cyan, dim, green, prompt, rupiah, thinking, yellow } from '../ui.js';
+import { systemPrompt, toolsForMode } from './schemas.js';
+import { bacaFile, cari, daftarFile, editFile, jalankan, tulisFile } from './tools.js';
+const MAX_STEPS = 25;
+/** Ask y/t before a destructive action (unless --otomatis). */
+async function allow(otomatis, question) {
+    if (otomatis)
+        return true;
+    const ans = (await prompt(`${yellow('? ')}${question} (y/t) `)).trim().toLowerCase();
+    return ans === 'y' || ans === 'ya';
+}
+/** Execute one tool call (with permission gating for destructive tools). */
+async function runTool(call, otomatis) {
+    let args = {};
+    try {
+        args = JSON.parse(call.function.arguments || '{}');
+    }
+    catch {
+        return { output: 'Error: argumen bukan JSON valid.' };
+    }
+    const str = (k) => (typeof args[k] === 'string' ? args[k] : '');
+    try {
+        switch (call.function.name) {
+            case 'baca_file':
+                console.log(dim(`  baca ${str('path')}`));
+                return { output: bacaFile(str('path')) };
+            case 'daftar_file':
+                console.log(dim(`  daftar ${str('path') || '.'}`));
+                return { output: daftarFile(str('path') || '.') };
+            case 'cari':
+                console.log(dim(`  cari "${str('pola')}"`));
+                return { output: cari(str('pola'), str('ext') || undefined) };
+            case 'tulis_file': {
+                const p = str('path');
+                const isi = str('konten');
+                console.log(`  ${cyan('tulis')} ${p} ${dim(`(${isi.length} char)`)}`);
+                if (!(await allow(otomatis, `Tulis file ${p}?`)))
+                    return { output: 'Ditolak oleh pengguna.' };
+                return { output: tulisFile(p, isi) };
+            }
+            case 'edit_file': {
+                const p = str('path');
+                console.log(`  ${cyan('edit')} ${p}`);
+                if (!(await allow(otomatis, `Edit file ${p}?`)))
+                    return { output: 'Ditolak oleh pengguna.' };
+                return { output: editFile(p, str('cari'), str('ganti')) };
+            }
+            case 'jalankan': {
+                const cmd = str('perintah');
+                console.log(`  ${cyan('jalankan')}: ${cmd}`);
+                if (!(await allow(otomatis, 'Jalankan perintah ini?'))) {
+                    return { output: 'Ditolak oleh pengguna.' };
+                }
+                return { output: jalankan(cmd) };
+            }
+            case 'buat_gambar': {
+                const p = str('path');
+                console.log(`  ${cyan('buat_gambar')} ${p} ${dim(`"${str('prompt').slice(0, 50)}"`)}`);
+                if (!(await allow(otomatis, `Buat gambar ${p}? (berbayar)`))) {
+                    return { output: 'Ditolak oleh pengguna.' };
+                }
+                const model = await resolveMediaModel(undefined, 'image');
+                const img = await generateImage(model, str('prompt'));
+                writeFileSync(p, Buffer.from(img.b64, 'base64'));
+                return { output: `OK: ${p} dibuat (${rupiah(img.cost)}).` };
+            }
+            case 'selesai':
+                return { output: str('ringkasan') || 'selesai', done: true };
+            default:
+                return { output: `Error: tool tidak dikenal "${call.function.name}".` };
+        }
+    }
+    catch (err) {
+        return { output: `Error: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
+/** Start a fresh session (system prompt seeded from the mode). */
+export function newSession(model, mode, otomatis) {
+    return { model, mode, otomatis, messages: [{ role: 'system', content: systemPrompt(mode) }] };
+}
+/** Reset the conversation, keeping the current mode/model/otomatis. */
+export function resetSession(s) {
+    s.messages = [{ role: 'system', content: systemPrompt(s.mode) }];
+}
+/**
+ * Process one user turn: run the tool-use loop, appending to the session's history. Returns the
+ * agent's final text (last answer or the `selesai` summary) — useful for chaining agents in a team.
+ */
+export async function runTurn(s, userText) {
+    s.messages.push({ role: 'user', content: userText });
+    const tools = toolsForMode(s.mode);
+    let lastText = '';
+    for (let step = 0; step < MAX_STEPS; step++) {
+        const stop = thinking();
+        let reply;
+        try {
+            reply = await chatComplete(s.model, s.messages, tools);
+        }
+        finally {
+            stop();
+        }
+        s.messages.push({ role: 'assistant', content: reply.content, tool_calls: reply.tool_calls });
+        if (reply.content) {
+            console.log(reply.content);
+            lastText = reply.content;
+        }
+        const calls = reply.tool_calls ?? [];
+        if (calls.length === 0) {
+            if (step === 0) {
+                console.log(dim('(Model tidak memakai tool — pastikan model mendukung function calling, mis. /model anthropic/claude-sonnet-4-6.)'));
+            }
+            return lastText; // final text answer
+        }
+        for (const call of calls) {
+            const result = await runTool(call, s.otomatis);
+            s.messages.push({ role: 'tool', content: result.output, tool_call_id: call.id });
+            if (result.done) {
+                console.log(green(`\n✓ Selesai: ${result.output}`));
+                return result.output;
+            }
+        }
+    }
+    console.log(yellow(`\nBerhenti setelah ${MAX_STEPS} langkah. Lanjutkan dengan perintah berikutnya.`));
+    return lastText;
+}
+/** One-shot: run a single task in a mode (used by the `rencana`/`edit`/`buat` subcommands). */
+export async function runAgent(task, mode, opts) {
+    await runTurn(newSession(opts.model, mode, opts.otomatis), task);
+}

package/dist/agent/schemas.js

@@ -0,0 +1,147 @@
+/** Tool catalog (OpenAI function-calling schemas), described in Indonesian. */
+const TOOLS = {
+    baca_file: {
+        type: 'function',
+        function: {
+            name: 'baca_file',
+            description: 'Baca isi sebuah file (path relatif ke direktori kerja).',
+            parameters: {
+                type: 'object',
+                properties: { path: { type: 'string', description: 'Path file' } },
+                required: ['path'],
+            },
+        },
+    },
+    daftar_file: {
+        type: 'function',
+        function: {
+            name: 'daftar_file',
+            description: 'Daftar isi sebuah folder.',
+            parameters: {
+                type: 'object',
+                properties: { path: { type: 'string', description: 'Path folder (default ".")' } },
+            },
+        },
+    },
+    cari: {
+        type: 'function',
+        function: {
+            name: 'cari',
+            description: 'Cari teks di dalam file-file pada direktori kerja.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    pola: { type: 'string', description: 'Teks yang dicari' },
+                    ext: {
+                        type: 'string',
+                        description: 'Batasi ke ekstensi tertentu, mis. ".ts" (opsional)',
+                    },
+                },
+                required: ['pola'],
+            },
+        },
+    },
+    tulis_file: {
+        type: 'function',
+        function: {
+            name: 'tulis_file',
+            description: 'Buat atau timpa file dengan konten penuh.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string' },
+                    konten: { type: 'string', description: 'Isi file lengkap' },
+                },
+                required: ['path', 'konten'],
+            },
+        },
+    },
+    edit_file: {
+        type: 'function',
+        function: {
+            name: 'edit_file',
+            description: 'Ganti satu potongan teks yang UNIK di sebuah file.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string' },
+                    cari: { type: 'string', description: 'Teks lama (harus unik di file)' },
+                    ganti: { type: 'string', description: 'Teks baru' },
+                },
+                required: ['path', 'cari', 'ganti'],
+            },
+        },
+    },
+    jalankan: {
+        type: 'function',
+        function: {
+            name: 'jalankan',
+            description: 'Jalankan satu perintah shell di direktori kerja.',
+            parameters: {
+                type: 'object',
+                properties: { perintah: { type: 'string' } },
+                required: ['perintah'],
+            },
+        },
+    },
+    buat_gambar: {
+        type: 'function',
+        function: {
+            name: 'buat_gambar',
+            description: 'Buat gambar AI dari prompt dan simpan ke file (berbayar).',
+            parameters: {
+                type: 'object',
+                properties: {
+                    prompt: { type: 'string' },
+                    path: { type: 'string', description: 'Nama file output, mis. assets/logo.png' },
+                },
+                required: ['prompt', 'path'],
+            },
+        },
+    },
+    selesai: {
+        type: 'function',
+        function: {
+            name: 'selesai',
+            description: 'Tandai tugas selesai dengan ringkasan singkat.',
+            parameters: {
+                type: 'object',
+                properties: { ringkasan: { type: 'string' } },
+                required: ['ringkasan'],
+            },
+        },
+    },
+};
+const READ_TOOLS = ['baca_file', 'daftar_file', 'cari'];
+const WRITE_TOOLS = ['tulis_file', 'edit_file'];
+const MODE_TOOLS = {
+    rencana: [...READ_TOOLS, 'selesai'],
+    edit: [...READ_TOOLS, ...WRITE_TOOLS, 'buat_gambar', 'selesai'],
+    buat: [...READ_TOOLS, ...WRITE_TOOLS, 'jalankan', 'buat_gambar', 'selesai'],
+};
+/** The tool specs available in a given mode. */
+export function toolsForMode(mode) {
+    return MODE_TOOLS[mode].map((name) => {
+        const spec = TOOLS[name];
+        if (!spec)
+            throw new Error(`tool tidak ada: ${name}`);
+        return spec;
+    });
+}
+const MODE_BRIEF = {
+    rencana: 'MODE RENCANA (read-only): telusuri kode dan susun rencana langkah. JANGAN mengubah apa pun.',
+    edit: 'MODE EDIT: lakukan perubahan kode yang diminta dengan tulis_file/edit_file. Jangan jalankan perintah shell.',
+    buat: 'MODE AGEN: bangun/ubah proyek secara otonom. Boleh menulis file dan menjalankan perintah.',
+};
+/** System prompt (Indonesian) that frames the agent's role, mode, and workflow. */
+export function systemPrompt(mode) {
+    return `Kamu adalah asisten coding Kiosapi yang bekerja di terminal developer Indonesia.
+${MODE_BRIEF[mode]}
+
+Direktori kerja: ${process.cwd()}
+Aturan:
+- Bekerja langkah demi langkah: pakai tool untuk membaca sebelum mengubah.
+- Path selalu relatif ke direktori kerja; akses ke luar ditolak.
+- Buat perubahan kecil dan jelas. Setelah tugas beres, panggil tool "selesai" dengan ringkasan.
+- Jawab dan jelaskan dalam Bahasa Indonesia.`;
+}

package/dist/agent/team.js

@@ -0,0 +1,35 @@
+import { bold, dim, green } from '../ui.js';
+import { newSession, runTurn } from './run.js';
+const ROLES = {
+    perencana: {
+        title: '① Perencana',
+        mode: 'rencana',
+        brief: 'Peranmu: PERENCANA. Telusuri kode seperlunya, lalu susun rencana langkah yang jelas & ringkas. JANGAN menulis kode.',
+    },
+    pengkode: {
+        title: '② Pengkode',
+        mode: 'buat',
+        brief: 'Peranmu: PENGKODE. Implementasikan tugas mengikuti rencana. Buat perubahan kecil & jelas, lalu panggil selesai.',
+    },
+    peninjau: {
+        title: '③ Peninjau',
+        mode: 'rencana',
+        brief: 'Peranmu: PENINJAU. Baca file yang relevan dan tinjau hasil implementasi: sebutkan masalah/risiko & saran perbaikan singkat.',
+    },
+};
+/** Run one role as a sub-agent and return its final text. */
+async function runRole(role, task, opts) {
+    console.log(`\n${bold(role.title)}`);
+    const s = newSession(opts.model, role.mode, opts.otomatis);
+    s.messages.push({ role: 'system', content: role.brief });
+    return runTurn(s, task);
+}
+/** Orchestrate the perencana → pengkode → peninjau pipeline for a task. */
+export async function runTeam(task, opts) {
+    console.log(bold('👥 Tim agen: perencana → pengkode → peninjau'));
+    console.log(dim(`Model: ${opts.model}`));
+    const plan = await runRole(ROLES.perencana, task, opts);
+    await runRole(ROLES.pengkode, `Tugas: ${task}\n\nRencana:\n${plan || '(tidak ada rencana eksplisit)'}`, opts);
+    await runRole(ROLES.peninjau, `Tinjau hasil implementasi untuk tugas: ${task}`, opts);
+    console.log(green('\n✓ Tim selesai.'));
+}

package/dist/agent/tools.js

@@ -0,0 +1,149 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+/**
+ * Local tools the agent can run, all confined to the current working directory and screened by an
+ * ignore list (secrets, VCS, deps, build output). These are the only ways the agent touches the
+ * machine; permission gating for the destructive ones lives in run.ts.
+ */
+const ROOT = process.cwd();
+const MAX_READ = 100_000; // cap a single file read (chars)
+const MAX_MATCHES = 80; // cap search results
+const MAX_OUTPUT = 20_000; // cap captured command output (chars)
+const DEFAULT_IGNORE = ['.git', 'node_modules', '.kiosapi', 'dist', '.next', '.turbo', '.venv'];
+function ignorePatterns() {
+    const list = [...DEFAULT_IGNORE];
+    const f = join(ROOT, '.kiosapiignore');
+    if (existsSync(f)) {
+        for (const line of readFileSync(f, 'utf8').split('\n')) {
+            const t = line.trim();
+            if (t && !t.startsWith('#'))
+                list.push(t);
+        }
+    }
+    return list;
+}
+/** A path is protected if any segment matches an ignore pattern, or it's a dotenv-style secret. */
+function isProtected(rel, patterns) {
+    const segments = rel.split(/[\\/]/);
+    if (segments.some((s) => s === '.env' || s.startsWith('.env.')))
+        return true;
+    return patterns.some((p) => segments.includes(p) || rel === p || rel.startsWith(`${p}/`));
+}
+/** Resolve a user/model-supplied path, rejecting anything outside the working directory or protected. */
+function safePath(p) {
+    const abs = resolve(ROOT, p);
+    const rel = relative(ROOT, abs);
+    if (rel.startsWith('..') || isAbsolute(rel)) {
+        throw new Error(`akses di luar direktori kerja ditolak: ${p}`);
+    }
+    if (rel !== '' && isProtected(rel, ignorePatterns())) {
+        throw new Error(`path dilindungi/diabaikan: ${p}`);
+    }
+    return { abs, rel: rel || '.' };
+}
+/** baca_file — read a text file. */
+export function bacaFile(path) {
+    const { abs } = safePath(path);
+    if (!existsSync(abs))
+        return `Error: file tidak ada: ${path}`;
+    const text = readFileSync(abs, 'utf8');
+    return text.length > MAX_READ
+        ? `${text.slice(0, MAX_READ)}\n…[dipotong, ${text.length} char total]`
+        : text;
+}
+/** daftar_file — list a directory (ignored entries hidden). */
+export function daftarFile(path) {
+    const { abs, rel } = safePath(path || '.');
+    if (!existsSync(abs))
+        return `Error: folder tidak ada: ${path}`;
+    const patterns = ignorePatterns();
+    const entries = readdirSync(abs)
+        .filter((name) => !isProtected(rel === '.' ? name : `${rel}/${name}`, patterns))
+        .sort()
+        .map((name) => {
+        const dir = statSync(join(abs, name)).isDirectory();
+        return dir ? `${name}/` : name;
+    });
+    return entries.length > 0 ? entries.join('\n') : '(kosong)';
+}
+/** cari — grep file contents under the working dir (case-insensitive). */
+export function cari(pola, ext) {
+    if (!pola)
+        return 'Error: pola pencarian kosong.';
+    const patterns = ignorePatterns();
+    const needle = pola.toLowerCase();
+    const hits = [];
+    const walk = (dir) => {
+        if (hits.length >= MAX_MATCHES)
+            return;
+        for (const name of readdirSync(dir)) {
+            const abs = join(dir, name);
+            const rel = relative(ROOT, abs);
+            if (isProtected(rel, patterns))
+                continue;
+            const st = statSync(abs);
+            if (st.isDirectory()) {
+                walk(abs);
+            }
+            else if (!ext || name.endsWith(ext)) {
+                if (st.size > 2_000_000)
+                    continue; // skip very large/binary files
+                const lines = readFileSync(abs, 'utf8').split('\n');
+                for (let i = 0; i < lines.length; i++) {
+                    const line = lines[i] ?? '';
+                    if (line.toLowerCase().includes(needle)) {
+                        hits.push(`${rel}:${i + 1}: ${line.trim().slice(0, 200)}`);
+                        if (hits.length >= MAX_MATCHES)
+                            return;
+                    }
+                }
+            }
+        }
+    };
+    try {
+        walk(ROOT);
+    }
+    catch {
+        // unreadable entry — ignore
+    }
+    return hits.length > 0 ? hits.join('\n') : `(tidak ada hasil untuk "${pola}")`;
+}
+/** tulis_file — create/overwrite a file (parent dirs created). */
+export function tulisFile(path, konten) {
+    const { abs } = safePath(path);
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, konten);
+    return `OK: ${path} ditulis (${konten.length} char).`;
+}
+/** edit_file — replace an exact substring (must occur exactly once). */
+export function editFile(path, cari, ganti) {
+    const { abs } = safePath(path);
+    if (!existsSync(abs))
+        return `Error: file tidak ada: ${path}`;
+    if (!cari)
+        return 'Error: teks "cari" kosong.';
+    const text = readFileSync(abs, 'utf8');
+    const count = text.split(cari).length - 1;
+    if (count === 0)
+        return `Error: teks "cari" tidak ditemukan di ${path}.`;
+    if (count > 1)
+        return `Error: teks "cari" muncul ${count}× di ${path} (harus unik). Perbesar konteks.`;
+    writeFileSync(abs, text.replace(cari, ganti));
+    return `OK: ${path} diedit.`;
+}
+/** jalankan — run a shell command in the working dir, returning combined output (capped). */
+export function jalankan(perintah) {
+    if (!perintah.trim())
+        return 'Error: perintah kosong.';
+    const res = spawnSync(perintah, {
+        cwd: ROOT,
+        shell: true,
+        encoding: 'utf8',
+        timeout: 120_000,
+        maxBuffer: 10 * 1024 * 1024,
+    });
+    const out = `${res.stdout ?? ''}${res.stderr ?? ''}`.trim();
+    const capped = out.length > MAX_OUTPUT ? `${out.slice(0, MAX_OUTPUT)}\n…[dipotong]` : out;
+    return `exit=${res.status ?? 'null'}\n${capped || '(tanpa output)'}`;
+}