@gilangranggaid/kilua-agent 1.2.0 → 1.3.1

package/bin/kilua.js

@@ -3,7 +3,7 @@ import readline from "node:readline";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
-import { execSync } from "node:child_process";
+import { execSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
 // ponytail: autonomous single-file AI Coding Agent CLI with slash commands, local skills & test execution.
@@ -12,6 +12,120 @@ const SETTINGS_PATH = path.join(KILUA_DIR, "settings.json");
 const SKILLS_DIR = path.join(KILUA_DIR, "skills");
 const MAX_STEPS = 40; // ponytail: naik dari 16; agent butuh banyak langkah untuk self-fix loop
 const MAX_INJECTED_SKILLS = 5; // sama seperti web: cukup 5 skill per pesan biar konteks hemat
+let PLAN_MODE = false; // read-only mode: semua tool yang mengubah state diblokir
+
+// ===================== MCP CLIENT =====================
+const MCP_CLIENTS = new Map(); // name -> { proc, tools, requestId }
+
+async function startMcpServer(name, command, args = []) {
+  if (MCP_CLIENTS.has(name)) return MCP_CLIENTS.get(name);
+
+  const proc = spawn(command, args, {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: { ...process.env },
+    windowsHide: true,
+  });
+
+  let buffer = "";
+  let requestId = 0;
+  const pending = new Map();
+
+  proc.stdout.on("data", (data) => {
+    buffer += data.toString();
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const msg = JSON.parse(line);
+        if (msg.id && pending.has(msg.id)) {
+          const { resolve, reject } = pending.get(msg.id);
+          pending.delete(msg.id);
+          if (msg.error) reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+          else resolve(msg.result);
+        }
+      } catch {}
+    }
+  });
+
+  proc.stderr.on("data", (data) => {
+    console.error(`\x1b[90m[MCP:${name}] ${data.toString().trim()}\x1b[0m`);
+  });
+
+  proc.on("exit", (code) => {
+    console.error(`\x1b[31m[MCP:${name}] exited with code ${code}\x1b[0m`);
+    MCP_CLIENTS.delete(name);
+    for (const [, { reject }] of pending) reject(new Error("MCP server exited"));
+    pending.clear();
+  });
+
+  // Initialize
+  const initResult = await sendMcpRequest(proc, pending, ++requestId, "initialize", {
+    protocolVersion: "2024-11-05",
+    capabilities: { tools: {} },
+    clientInfo: { name: "kilua", version: "1.3.0" },
+  });
+
+  // List tools
+  const toolsResult = await sendMcpRequest(proc, pending, ++requestId, "tools/list", {});
+  const tools = (toolsResult?.tools || []).map(t => ({
+    name: `mcp_${name}_${t.name}`,
+    description: `[MCP:${name}] ${t.description}`,
+    input_schema: t.inputSchema,
+  }));
+
+  const client = { proc, tools, requestId, pending };
+  MCP_CLIENTS.set(name, client);
+  return client;
+}
+
+function sendMcpRequest(proc, pending, id, method, params) {
+  return new Promise((resolve, reject) => {
+    pending.set(id, { resolve, reject });
+    proc.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
+    // Timeout
+    setTimeout(() => {
+      if (pending.has(id)) {
+        pending.delete(id);
+        reject(new Error(`MCP request timeout: ${method}`));
+      }
+    }, 30000);
+  });
+}
+
+async function callMcpTool(name, toolName, args) {
+  const client = MCP_CLIENTS.get(name);
+  if (!client) throw new Error(`MCP server ${name} not started`);
+
+  const mcpToolName = toolName.replace(`mcp_${name}_`, "");
+  const result = await sendMcpRequest(client.proc, client.pending, ++client.requestId, "tools/call", {
+    name: mcpToolName,
+    arguments: args,
+  });
+  return result?.content?.[0]?.text || JSON.stringify(result);
+}
+
+async function initializeMcpServers(settings) {
+  const mcpList = Array.isArray(settings.mcp) ? settings.mcp : [];
+  const allTools = [];
+  for (const mcp of mcpList) {
+    try {
+      const client = await startMcpServer(mcp.name, mcp.command, mcp.args || []);
+      allTools.push(...client.tools);
+      console.log(`\x1b[32m[✓] MCP ${mcp.name}: ${client.tools.length} tools loaded\x1b[0m`);
+    } catch (e) {
+      console.error(`\x1b[31m[✖] MCP ${mcp.name} failed: ${e.message}\x1b[0m`);
+    }
+  }
+  return allTools;
+}
+
+function shutdownMcpServers() {
+  for (const [name, client] of MCP_CLIENTS) {
+    try { client.proc.kill(); } catch {}
+  }
+  MCP_CLIENTS.clear();
+}
 
 // ponytail: match pakai substring ternormalisasi ("docker-compose" == "docker compose").
 // Regex mentah dari web terlalu kaku: trigger "docker-compose" tak pernah kena "docker compose".
@@ -207,6 +321,10 @@ const TOOLS_ANTHROPIC = TOOLS_OPENAI.map(t => ({
 
 function executeLocalTool(name, args) {
   const cwd = process.cwd();
+  // ponytail: plan mode = read-only. Blokir semua efek samping, bukan hanya tulis file.
+  if (PLAN_MODE && ["write_file", "edit_file", "delete_file", "run_cmd"].includes(name)) {
+    return "Error: Plan mode aktif — aksi yang mengubah state diblokir. Susun rencana dulu; user mematikan /plan untuk eksekusi.";
+  }
   try {
     if (name === "read_file") {
       const full = path.resolve(cwd, args.path);
@@ -256,11 +374,15 @@ function executeLocalTool(name, args) {
           ? `grep -rn --include='${glob}' '${pattern.replace(/'/g, "'\\''")}' '${target}' | head -200`
           : `grep -rn --exclude-dir=node_modules --exclude-dir=.git '${pattern.replace(/'/g, "'\\''")}' '${target}' | head -200`;
       }
-      const out = execSync(cmd, { cwd, encoding: "utf8", timeout: 60000, stdio: ["pipe", "pipe", "pipe"] });
+      const out = execSync(cmd, { cwd, encoding: "utf8", timeout: 60000, windowsHide: true, stdio: ["pipe", "pipe", "pipe"] });
       return out.trim() || "(tidak ada hasil)";
     }
     if (name === "run_cmd") {
-      const out = execSync(args.command, { cwd, encoding: "utf8", timeout: 180000, stdio: ["pipe", "pipe", "pipe"], maxBuffer: 10 * 1024 * 1024 });
+      const out = execSync(args.command, { cwd, encoding: "utf8", timeout: 180000, windowsHide: true, stdio: ["pipe", "pipe", "pipe"], maxBuffer: 10 * 1024 * 1024 });
+      // Jika command menjalankan npx skills add atau sejenisnya ke SKILLS_DIR, pastikan folder ~/.kilua/skills ada
+      if (args.command.includes("skills add") || args.command.includes("skill")) {
+        ensureKiluaDir();
+      }
       return out.trim() || "(Done with exit code 0)";
     }
   } catch (err) {
@@ -273,6 +395,421 @@ function promptQuestion(rl, query) {
   return new Promise(res => rl.question(query, res));
 }
 
+// Prompt sekali pakai untuk slash command di luar composer.
+function promptLine(query) {
+  return new Promise(res => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(query, ans => { rl.close(); res(ans); });
+  });
+}
+
+// ===================== TEMA =====================
+const THEMES = {
+  purple: { name: "purple", accent: "\x1b[35m", sel: "\x1b[36m", dim: "\x1b[90m", ok: "\x1b[32m", warn: "\x1b[33m", err: "\x1b[31m", reset: "\x1b[0m", bold: "\x1b[1m" },
+  blue:   { name: "blue",   accent: "\x1b[34m", sel: "\x1b[36m", dim: "\x1b[90m", ok: "\x1b[32m", warn: "\x1b[33m", err: "\x1b[31m", reset: "\x1b[0m", bold: "\x1b[1m" },
+  green:  { name: "green",  accent: "\x1b[32m", sel: "\x1b[36m", dim: "\x1b[90m", ok: "\x1b[32m", warn: "\x1b[33m", err: "\x1b[31m", reset: "\x1b[0m", bold: "\x1b[1m" },
+  mono:   { name: "mono",   accent: "\x1b[1m",  sel: "\x1b[1m",  dim: "\x1b[2m",  ok: "",        warn: "",        err: "",        reset: "\x1b[0m", bold: "" },
+};
+function themeOf(settings) {
+  return THEMES[settings?.theme] || THEMES.purple;
+}
+
+// ===================== SLASH MENU =====================
+const SLASH_COMMANDS = [
+  { name: "/model", desc: "Ganti model AI aktif" },
+  { name: "/config", desc: "Ubah API key, provider, base URL" },
+  { name: "/theme", desc: "Ganti tema warna tampilan CLI" },
+  { name: "/skills", desc: "Lihat daftar skills terpasang" },
+  { name: "/mcp", desc: "Kelola server MCP" },
+  { name: "/memory", desc: "Lihat & tambah memori proyek (KILUA.md)" },
+  { name: "/plan", desc: "Nyalakan/matikan plan mode (read-only)" },
+  { name: "/clear", desc: "Bersihkan riwayat percakapan" },
+  { name: "/help", desc: "Panduan perintah" },
+  { name: "/exit", desc: "Keluar dari Kilua" },
+];
+const MENU_VISIBLE = 8;
+
+// ===================== FILE SELECTOR =====================
+const FILE_SELECTOR_VISIBLE = 10;
+let fileSelectorCache = null;
+let fileSelectorCacheTime = 0;
+const FILE_SELECTOR_CACHE_TTL = 5000; // 5 detik cache
+
+async function getFileList(cwd) {
+  const now = Date.now();
+  if (fileSelectorCache && now - fileSelectorCacheTime < FILE_SELECTOR_CACHE_TTL) {
+    return fileSelectorCache;
+  }
+  const files = [];
+  function walk(dir, prefix = "") {
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+        const full = path.join(dir, entry.name);
+        const rel = path.relative(cwd, full);
+        if (entry.isDirectory()) {
+          walk(full, rel + path.sep);
+        } else {
+          files.push(rel);
+        }
+      }
+    } catch {}
+  }
+  walk(cwd);
+  fileSelectorCache = files.sort();
+  fileSelectorCacheTime = now;
+  return fileSelectorCache;
+}
+
+function fileSelector() {
+  const d = display();
+  const atIdx = d.lastIndexOf("@");
+  if (atIdx === -1) return null;
+  // hanya trigger kalau @ di akhir atau diikuti spasi/baru
+  const afterAt = d.slice(atIdx + 1);
+  if (afterAt.includes(" ") || afterAt.includes("\n")) return null;
+  const query = afterAt.toLowerCase();
+  return query;
+}
+
+// ===================== CLIPBOARD (Windows) =====================
+function readClipboard() {
+  if (process.platform !== "win32") return null;
+  // ponytail: gambar clipboard butuh WinForms STA; platform lain = teks saja.
+  try {
+    const tmp = path.join(os.tmpdir(), `kilua-paste-${Date.now()}.png`).replace(/'/g, "''");
+    const ps = "Add-Type -AssemblyName System.Windows.Forms,System.Drawing;"
+      + "$i=[System.Windows.Forms.Clipboard]::GetImage();"
+      + `if($i){$i.Save('${tmp}',[System.Drawing.Imaging.ImageFormat]::Png);`
+      + "@{type='image';path='" + tmp + "'}|ConvertTo-Json -Compress}"
+      + "else{@{type='text';text=[System.Windows.Forms.Clipboard]::GetText()}|ConvertTo-Json -Compress}";
+    const out = execSync(`powershell -NoProfile -STA -Command "${ps.replace(/"/g, '\\"')}"`, {
+      encoding: "utf8", timeout: 10000, windowsHide: true, stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    const j = JSON.parse(out.slice(out.indexOf("{")));
+    if (j.type === "image" && fs.existsSync(j.path)) {
+      return { type: "image", data: fs.readFileSync(j.path).toString("base64"), mediaType: "image/png" };
+    }
+    if (j.type === "text" && j.text) return { type: "text", text: j.text };
+  } catch {}
+  return null;
+}
+
+// ===================== COMPOSER (raw-mode editor) =====================
+const PASTE_AS_TOKEN_CHARS = 300;
+const PASTE_AS_TOKEN_LINES = 3;
+
+function promptComposer(settings, history) {
+  const t = themeOf(settings);
+  return new Promise(resolve => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    let items = [];        // string (1 char) | {type:'paste'|'image', label, ...}
+    let pos = 0;
+    let menuSel = 0;
+    let histIdx = -1;
+    let lastLines = 0;
+    let pasteN = 0;
+    let imageN = 0;
+    let escBuf = "";
+    let inPaste = false;
+    let pasteBuf = "";
+    let probe = null;
+    let escTimer = null;
+    let closed = false;
+
+    const display = () => items.map(it => (typeof it === "string" ? it : it.label)).join("");
+    const displayText = () => items.map(it => (typeof it === "string" ? it : it.type === "paste" ? it.text : "")).join("");
+    const images = () => items.filter(it => it && it.type === "image");
+
+    function insertChars(str) {
+      for (const ch of str) { items.splice(pos, 0, ch); pos++; }
+    }
+    function insertPaste(text) {
+      const lines = text.split("\n").length;
+      if (text.length < PASTE_AS_TOKEN_CHARS && lines < PASTE_AS_TOKEN_LINES) return insertChars(text);
+      pasteN++;
+      items.splice(pos, 0, { type: "paste", label: `[Pasted text #${pasteN} +${lines} lines]`, text });
+      pos++;
+    }
+    function insertImage(cls) {
+      imageN++;
+      items.splice(pos, 0, { type: "image", label: `[Image #${imageN}]`, data: cls.data, mediaType: cls.mediaType });
+      pos++;
+    }
+
+    function menu() {
+      const d = display();
+      if (!d.startsWith("/") || /\s/.test(d)) return null;
+      const q = d.toLowerCase();
+      const list = SLASH_COMMANDS.filter(c => c.name.startsWith(q));
+      return list.length ? list : null;
+    }
+
+    function layout(plain, cols, cursorIdx) {
+      const lines = [""];
+      let caret = null;
+      for (let i = 0; i <= plain.length; i++) {
+        if (i === cursorIdx) caret = { line: lines.length - 1, col: lines[lines.length - 1].length };
+        if (i === plain.length) break;
+        const ch = plain[i];
+        if (ch === "\n") { lines.push(""); continue; }
+        if (lines[lines.length - 1].length >= cols) lines.push("");
+        lines[lines.length - 1] += ch;
+      }
+      if (!caret) caret = { line: lines.length - 1, col: lines[lines.length - 1].length };
+      if (lines[lines.length - 1].length >= cols) lines.push("");
+      return { lines, ...caret };
+    }
+
+    function render() {
+      const cols = Math.max(20, stdout.columns || 80);
+      const list = menu();
+      let menuLines = [];
+      if (list) {
+        const win = Math.min(MENU_VISIBLE, list.length);
+        menuSel = Math.max(0, Math.min(menuSel, list.length - 1));
+        let start = Math.max(0, Math.min(menuSel - win + 1, list.length - win));
+        const nameW = Math.max(...list.map(c => c.name.length)) + 2;
+        for (let i = start; i < start + win; i++) {
+          const c = list[i];
+          if (i === menuSel) menuLines.push(`${t.accent}❯${t.reset} ${t.sel}${c.name.padEnd(nameW)}${t.reset}${t.dim}${c.desc}${t.reset}`);
+          else menuLines.push(`  ${t.dim}${c.name.padEnd(nameW)}${c.desc}${t.reset}`);
+        }
+        if (list.length > win) menuLines.push(`${t.dim}  ↑↓ scroll · ${list.length - win} lainnya${t.reset}`);
+      }
+
+      let before = 0;
+      for (let i = 0; i < pos; i++) before += typeof items[i] === "string" ? 1 : items[i].label.length;
+      const plain = "❯ " + display();
+      const { lines, line: cLine, col: cCol } = layout(plain, cols, 2 + before);
+      const colored = lines.map((ln, idx) => {
+        const body = idx === 0 ? ln.slice(2) : ln;
+        const prefix = idx === 0 ? `${t.accent}❯ ${t.reset}` : "";
+        const painted = body
+          .replace(/\[Pasted text #\d+ \+\d+ lines\]/g, m => `\x1b[36m${m}${t.reset}`)
+          .replace(/\[Image #\d+\]/g, m => `\x1b[35m${m}${t.reset}`);
+        return prefix + painted;
+      });
+
+      if (lastLines) {
+        // Clear only the lines we previously drew (menu + input), not the chat history above
+        stdout.write(`\x1b[${lastLines}A`); // move to first line of our block
+        for (let i = 0; i < lastLines; i++) {
+          stdout.write(`\r\x1b[2K`); // clear entire line
+          if (i < lastLines - 1) stdout.write(`\x1b[1B`); // move down
+        }
+        stdout.write(`\x1b[${lastLines}A`); // back to first line
+      } else {
+        stdout.write("\r\x1b[2K"); // first render: just clear current line
+      }
+      const block = [...menuLines, ...colored];
+      stdout.write(block.join("\n"));
+      lastLines = block.length;
+
+      const up = menuLines.length + colored.length - 1 - (menuLines.length + cLine);
+      if (up > 0) stdout.write(`\x1b[${up}A`);
+      stdout.write(`\r${cCol > 0 ? `\x1b[${cCol}C` : ""}`);
+    }
+
+    function restore() {
+      clearProbe();
+      clearEsc();
+      closed = true;
+      stdin.removeListener("data", onData);
+      process.removeAllListeners("SIGINT");
+      if (lastLines) {
+        stdout.write(`\x1b[${lastLines}A`);
+        for (let i = 0; i < lastLines; i++) {
+          stdout.write(`\r\x1b[2K`);
+          if (i < lastLines - 1) stdout.write(`\x1b[1B`);
+        }
+        stdout.write(`\x1b[${lastLines}A`);
+      }
+      lastLines = 0;
+      stdout.write("\x1b[?2004l");
+      try { stdin.setRawMode(false); } catch {}
+      stdin.pause();
+    }
+
+    function finish() {
+      const text = displayText().trim();
+      const imgs = images();
+      if (!text && !imgs.length) { render(); return; }
+      const summary = display();
+      restore();
+      let shown = summary.replace(/\n/g, " ⏎ ");
+      if (shown.length > 160) shown = shown.slice(0, 157) + "...";
+      // Print separator line before user message
+      stdout.write(`${t.dim}────────────────────────────────────────${t.reset}\n`);
+      stdout.write(`${t.accent}❯${t.reset} ${shown}\n`);
+      resolve({ text, images: imgs });
+    }
+
+    // ---- clipboard ----
+    function clearProbe() {
+      if (probe) { clearTimeout(probe); probe = null; }
+    }
+    // ESC sendirian = tutup menu; tapi ESC juga awal arrow key, jadi tunggu sebentar.
+    function armEsc() {
+      if (escTimer) return;
+      escTimer = setTimeout(() => {
+        escTimer = null;
+        escBuf = "";
+        menuSel = 0;
+        items = items.filter(it => typeof it !== "string" || it !== "\x1b");
+        render();
+      }, 30);
+    }
+    function clearEsc() {
+      if (escTimer) { clearTimeout(escTimer); escTimer = null; }
+    }
+    function tryClipboard() {
+      const clip = readClipboard();
+      if (!clip) return false;
+      if (clip.type === "image") insertImage(clip);
+      else insertPaste(clip.text);
+      return true;
+    }
+    // Ctrl+V: tunggu data bracket-paste dulu; kalau kosong, berarti gambar.
+    function ctrlV() {
+      if (probe) return;
+      probe = setTimeout(() => { probe = null; tryClipboard(); render(); }, 150);
+    }
+
+    // ---- key handling ----
+    function moveTo(newPos) { pos = Math.max(0, Math.min(newPos, items.length)); render(); }
+
+    function submitOrComplete() {
+      const list = menu();
+      if (list) {
+        const pick = list[Math.max(0, Math.min(menuSel, list.length - 1))];
+        items = []; pos = 0;
+        insertChars(pick.name + " ");
+        render();
+        return;
+      }
+      finish();
+    }
+
+    function onPlain(ch) {
+      if (ch === "\r" || ch === "\n") return submitOrComplete();
+      if (ch === "\x7f") { // backspace
+        if (pos > 0) { items.splice(pos - 1, 1); pos--; }
+        return render();
+      }
+      if (ch === "\x03" || ch === "\x04") {
+        if (!display()) {
+          restore();
+          stdout.write("\n");
+          process.exit(0);
+        }
+        items = []; pos = 0; menuSel = 0;
+        return render();
+      }
+      if (ch === "\x16") return ctrlV();               // ctrl+v
+      if (ch === "\x1bv" || ch === "\x1bV") {          // alt+v
+        if (!tryClipboard()) stdout.write("\x07");
+        return render();
+      }
+      if (ch === "\t") {
+        const list = menu();
+        if (list) { items = []; pos = 0; insertChars(list[menuSel].name + " "); }
+        return render();
+      }
+      if (ch === "\x1b") return render();              // esc: tutup menu via reset
+      if (ch < " " && ch !== "\n") return;
+      insertChars(ch);
+      menuSel = 0;
+      render();
+    }
+
+    function onKey(seq) {
+      switch (seq) {
+        case "\x1b[A": if (menu()) { menuSel--; } else { navHistory(-1); } return render();
+        case "\x1b[B": if (menu()) { menuSel++; } else { navHistory(1); } return render();
+        case "\x1b[C": return moveTo(pos + 1);
+        case "\x1b[D": return moveTo(pos - 1);
+        case "\x1b[H": return moveTo(0);
+        case "\x1b[F": return moveTo(items.length);
+        case "\x1b[3~": if (pos < items.length) { items.splice(pos, 1); } return render();
+        case "\x1b\r": case "\x1b\n": items.splice(pos, 0, "\n"); pos++; return render();
+        default: return render();
+      }
+    }
+
+    function navHistory(dir) {
+      if (!history.length) return;
+      histIdx = Math.max(-1, Math.min(history.length - 1, histIdx - dir));
+      items = []; pos = 0;
+      if (histIdx >= 0) insertChars(history[history.length - 1 - histIdx]);
+      else pos = 0;
+    }
+
+    function feed(str) {
+      escBuf += str;
+      while (escBuf.length) {
+        if (inPaste) {
+          const end = escBuf.indexOf("\x1b[201~");
+          if (end === -1) { pasteBuf += escBuf; escBuf = ""; return; }
+          pasteBuf += escBuf.slice(0, end);
+          escBuf = escBuf.slice(end + 6);
+          inPaste = false;
+          insertPaste(pasteBuf.replace(/\r\n?/g, "\n"));
+          pasteBuf = "";
+          menuSel = 0;
+          render();
+          continue;
+        }
+        const pStart = escBuf.indexOf("\x1b[200~");
+        if (pStart > 0) {
+          const head = escBuf.slice(0, pStart);
+          escBuf = escBuf.slice(pStart);
+          for (const ch of head) onPlain(ch);
+          continue;
+        }
+        if (pStart === 0) { escBuf = escBuf.slice(6); inPaste = true; continue; }
+
+        if (escBuf.startsWith("\x1b")) {
+          const seqs = ["\x1b[A", "\x1b[B", "\x1b[C", "\x1b[D", "\x1b[H", "\x1b[F", "\x1b[3~", "\x1b[Z", "\x1b\r", "\x1b\n", "\x1bv", "\x1bV"];
+          const hit = seqs.find(s => escBuf.startsWith(s));
+          if (hit) { clearEsc(); escBuf = escBuf.slice(hit.length); onKey(hit); continue; }
+          // sequence CSI lengkap tapi tidak dikenal (mis. Ctrl+↑ = "\x1b[1;5A") — buang utuh, jangan ketik sebagai teks
+          const m = escBuf.match(/^\x1b\[[0-9;]*[A-Za-z~]/);
+          if (m) { clearEsc(); escBuf = escBuf.slice(m[0].length); render(); continue; }
+          if (escBuf.length < 8) { armEsc(); return; } // tunggu sisa byte sequence
+          clearEsc();
+          escBuf = escBuf.slice(1);
+          render();
+          continue;
+        }
+        const ch = escBuf[0];
+        escBuf = escBuf.slice(1);
+        onPlain(ch);
+      }
+    }
+
+    function onData(chunk) {
+      if (closed) return;
+      clearProbe();
+      feed(chunk.toString("utf8"));
+    }
+
+    // ---- start ----
+    const onSigint = () => {
+      if (!closed) { restore(); stdout.write("\n"); process.exit(0); }
+    };
+    stdout.write("\x1b[?2004h"); // bracketed paste
+    try { stdin.setRawMode(true); } catch {} // pipa/non-TTY: lanjut saja, input tetap terbaca
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    stdin.on("data", onData);
+    process.on("SIGINT", onSigint);
+    render();
+  });
+}
+
 // ponytail: status spinner minimal tanpa dependency — tampilkan langkah + detik berjalan
 let spinnerTimer = null;
 let spinnerStart = 0;
@@ -420,12 +957,33 @@ async function readSseStream(res, onChunk) {
   }
 }
 
-function buildSystemPrompt(convo) {
+function readMemory() {
+  try {
+    const f = path.join(process.cwd(), "KILUA.md");
+    return fs.existsSync(f) ? fs.readFileSync(f, "utf8").slice(0, 4000) : "";
+  } catch { return ""; }
+}
+
+function buildSystemPrompt(convo, settings = {}) {
   let lastUser = "";
   for (let i = (convo?.length ?? 0) - 1; i >= 0; i--) {
-    if (convo[i].role === "user" && typeof convo[i].content === "string") { lastUser = convo[i].content; break; }
+    const c = convo[i]?.content;
+    if (convo[i].role === "user" && typeof c === "string") { lastUser = c; break; }
+    if (convo[i].role === "user" && Array.isArray(c)) {
+      const t = c.find(b => b.type === "text");
+      if (t?.text) { lastUser = t.text; break; }
+    }
   }
   const skillsInfo = getSkillsPrompt(lastUser);
+  const mem = readMemory().trim();
+  const memBlock = mem ? `\n\n=== MEMORI PROYEK (KILUA.md) ===\n${mem}` : "";
+  const mcpList = Array.isArray(settings.mcp) ? settings.mcp : [];
+  const mcpBlock = mcpList.length
+    ? `\n\nMCP servers terdaftar (info saja, eksekusi tool MCP belum aktif di CLI):\n${mcpList.map(m => `- ${m.name}: ${m.command || ""} ${(m.args || []).join(" ")}`).join("\n")}`
+    : "";
+  const planBlock = PLAN_MODE
+    ? "\n\nPLAN MODE AKTIF: hanya baca & analisa. JANGAN mengubah file atau menjalankan perintah yang mengubah state. Susun rencana langkah demi langkah, lalu minta user mematikan plan mode (/plan) untuk eksekusi."
+    : "";
   return `Kamu KILUA, AI Coding Agent otonom di terminal lokal. Folder aktif: ${process.cwd()}.
 KEMAMPUAN TOOLS:
 - read_file, write_file, edit_file, list_dir
@@ -441,7 +999,7 @@ CARA KERJA (WAJIB DIIKUTI):
 6. Baru setelah terbukti jalan tanpa error, laporkan hasil + cara menjalankannya ke pengguna.
 7. Jika pengguna menyuruh install skill di chat (misal: "install skill vercel-labs/skills@find-skills"), jalankan run_cmd:
    npx skills add <nama-skill> --cwd "${SKILLS_DIR}"
-   lalu beri tahu skill sudah siap dipakai.${skillsInfo}
+   lalu beri tahu skill sudah siap dipakai.${skillsInfo}${memBlock}${mcpBlock}${planBlock}
 
 Gaya: ringkas, langsung bertindak, jangan minta konfirmasi untuk langkah yang sudah jelas.`;
 }
@@ -530,7 +1088,7 @@ async function fetchWithRetry(url, init) {
 
 // Loop untuk Anthropic / 9router local (/v1/messages)
 async function runAnthropicLoop(settings, convo) {
-  const SYSTEM = buildSystemPrompt(convo);
+  const SYSTEM = buildSystemPrompt(convo, settings);
 
   let endpoint = settings.base_url.replace(/\/+$/, "");
   if (!endpoint.endsWith("/messages")) endpoint += "/messages";
@@ -586,6 +1144,8 @@ async function runAnthropicLoop(settings, convo) {
       if (deltaText) {
         if (!printedHeader) {
           stopStatus();
+          // Print separator line before AI response
+          process.stdout.write(`\n${t.dim}────────────────────────────────────────${t.reset}\n`);
           process.stdout.write("\r\x1b[2KKILUA > ");
           printedHeader = true;
         }
@@ -646,7 +1206,7 @@ async function runAnthropicLoop(settings, convo) {
 
 // Loop untuk OpenAI / TokenHarbor / Gemini OpenAI protocol
 async function runOpenAiLoop(settings, convo) {
-  const SYSTEM = buildSystemPrompt(convo);
+  const SYSTEM = buildSystemPrompt(convo, settings);
 
   let endpoint = settings.base_url.replace(/\/+$/, "");
   if (endpoint.includes("generativelanguage.googleapis.com") && !endpoint.includes("/openai")) {
@@ -700,6 +1260,8 @@ async function runOpenAiLoop(settings, convo) {
       if (delta?.content) {
         if (!printedHeader) {
           stopStatus();
+          // Print separator line before AI response
+          process.stdout.write(`\n${t.dim}────────────────────────────────────────${t.reset}\n`);
           process.stdout.write("\r\x1b[2KKILUA > ");
           printedHeader = true;
         }
@@ -742,89 +1304,157 @@ async function runOpenAiLoop(settings, convo) {
   }
 }
 
-async function runAgent(settings, userPrompt, convo) {
+async function runAgent(settings, userPrompt, convo, images = []) {
   const isAnthropic = settings.provider === "anthropic" || settings.base_url.includes(":20128") || settings.model === "harobor";
-  if (isAnthropic) {
-    convo.push({ role: "user", content: userPrompt });
-    await runAnthropicLoop(settings, convo);
+  if (images.length) {
+    if (isAnthropic) {
+      const blocks = images.map(im => ({ type: "image", source: { type: "base64", media_type: im.mediaType, data: im.data } }));
+      convo.push({ role: "user", content: [...blocks, { type: "text", text: userPrompt || "Jelaskan gambar ini." }] });
+    } else {
+      const blocks = images.map(im => ({ type: "image_url", image_url: { url: `data:${im.mediaType};base64,${im.data}` } }));
+      convo.push({ role: "user", content: [...blocks, { type: "text", text: userPrompt || "Jelaskan gambar ini." }] });
+    }
   } else {
     convo.push({ role: "user", content: userPrompt });
-    await runOpenAiLoop(settings, convo);
   }
+  if (isAnthropic) await runAnthropicLoop(settings, convo);
+  else await runOpenAiLoop(settings, convo);
 }
 
-function printHelp() {
-  console.log(`
-\x1b[1m\x1b[35m=== PERINTAH SLASH KILUA (/) ===\x1b[0m
-  \x1b[36m/help\x1b[0m         Lihat panduan perintah ini
-  \x1b[36m/models\x1b[0m       Lihat dan ganti model AI saat ini
-  \x1b[36m/skills\x1b[0m       Lihat daftar skills yang terpasang di Kilua
-  \x1b[36m/clear\x1b[0m        Bersihkan riwayat percakapan sesi ini
-  \x1b[36m/config\x1b[0m       Ubah API Key, Provider, atau Base URL
-  \x1b[36m/exit\x1b[0m         Keluar dari Kilua Agent
-
-\x1b[90mTips: Untuk menginstall skill baru, cukup suruh Kilua di chat (misal: "tolong install skill find-skills")!\x1b[0m
-`);
+function printHelp(settings) {
+  const t = themeOf(settings);
+  console.log(`\n${t.bold}${t.accent}=== PERINTAH SLASH KILUA (/) ===${t.reset}`);
+  for (const c of SLASH_COMMANDS) console.log(`  ${t.sel}${c.name.padEnd(10)}${t.reset} ${t.dim}${c.desc}${t.reset}`);
+  console.log(`\n${t.dim}Tips: ketik "/" lalu ↑↓ untuk pilih perintah. Install skill baru cukup minta di chat.${t.reset}`);
+  console.log(`${t.dim}Ctrl+V / Alt+V = paste teks (ringkas otomatis) atau gambar dari clipboard.${t.reset}\n`);
 }
 
-async function handleSlashCommand(cmd, settings, convo, rl) {
-  const parts = cmd.trim().split(/\s+/);
-  const action = parts[0].toLowerCase();
-
-  if (action === "/help") {
-    printHelp();
+async function cmdModel(settings) {
+  const t = themeOf(settings);
+  if (!settings.base_url || !settings.api_key) {
+    console.log(`\n${t.warn}[!] Belum terhubung ke config provider. Jalankan /config dulu.${t.reset}\n`);
     return settings;
   }
-
-  if (action === "/models" || action === "/model") {
-    if (!settings.base_url || !settings.api_key) {
-      console.log(`\n\x1b[33m[!] Belum terhubung ke config provider. Jalankan /config terlebih dahulu.\x1b[0m\n`);
-      return settings;
-    }
-    console.log(`\n\x1b[33mModel aktif saat ini:\x1b[0m \x1b[32m${settings.model}\x1b[0m (Provider: ${settings.base_url})`);
-    const newModel = (await promptQuestion(rl, `Ganti nama model (Enter untuk tetap '${settings.model}'): `)).trim();
-    if (newModel) {
-      settings.model = newModel;
-      saveSettings(settings);
-      console.log(`\x1b[32m✓ Model diubah menjadi ${newModel}\x1b[0m\n`);
-    }
-    return settings;
+  console.log(`\n${t.warn}Model aktif:${t.reset} ${t.ok}${settings.model}${t.reset} ${t.dim}(${settings.base_url})${t.reset}`);
+  const newModel = (await promptLine(`Ganti nama model (Enter untuk tetap '${settings.model}'): `)).trim();
+  if (newModel && newModel !== settings.model) {
+    settings.model = newModel;
+    saveSettings(settings);
+    console.log(`${t.ok}✓ Model diubah menjadi ${newModel}${t.reset}\n`);
   }
+  return settings;
+}
 
-  if (action === "/skills" || action === "/skill") {
-    const list = listInstalledSkills();
-    const builtin = loadBuiltinSkills();
-    console.log(`\n\x1b[35m=== SKILLS TERPASANG (${SKILLS_DIR}) ===\x1b[0m`);
-    if (!list.length) {
-      console.log(`Belum ada skill tambahan terpasang.`);
-      console.log(`Suruh Kilua di chat untuk install, misal: \x1b[36m"Kilua, tolong install skill vercel-labs/skills@find-skills"\x1b[0m`);
-    } else {
-      for (const s of list) {
-        console.log(`- \x1b[32m${s.name}\x1b[0m: ${s.desc}`);
-      }
-    }
-    console.log(`\x1b[90m+ ${builtin.length} skill bawaan aktif otomatis (disuntik maks ${MAX_INJECTED_SKILLS}/pesan sesuai tugas)\x1b[0m`);
-    console.log();
-    return settings;
-  }
+function cmdSkills(settings) {
+  const t = themeOf(settings);
+  const list = listInstalledSkills();
+  const builtin = loadBuiltinSkills();
+  console.log(`\n${t.bold}${t.accent}=== SKILLS TERPASANG (${SKILLS_DIR}) ===${t.reset}`);
+  if (!list.length) {
+    console.log(`Belum ada skill tambahan terpasang.`);
+    console.log(`Suruh Kilua di chat, misal: ${t.sel}"Kilua, install skill vercel-labs/skills@find-skills"${t.reset}`);
+  } else for (const s of list) console.log(`- ${t.ok}${s.name}${t.reset}: ${s.desc}`);
+  console.log(`${t.dim}+ ${builtin.length} skill bawaan aktif otomatis (maks ${MAX_INJECTED_SKILLS}/pesan)${t.reset}\n`);
+  return settings;
+}
 
-  if (action === "/clear") {
-    convo.length = 0;
-    console.clear();
-    console.log(`\x1b[32m✓ Riwayat percakapan dibersihkan.\x1b[0m\n`);
-    return settings;
+async function cmdTheme(settings) {
+  const t = themeOf(settings);
+  const names = Object.keys(THEMES);
+  console.log(`\n${t.bold}${t.accent}=== TEMA ===${t.reset}`);
+  names.forEach((n, i) => {
+    const mark = n === (settings.theme || "purple") ? `${t.ok}●${t.reset}` : " ";
+    console.log(` ${mark} ${i + 1}) ${THEMES[n].accent}${n}${t.reset}`);
+  });
+  const pick = (await promptLine(`\nPilih tema [1-${names.length}] (Enter = batal): `)).trim();
+  const idx = Number(pick) - 1;
+  if (names[idx]) {
+    settings.theme = names[idx];
+    saveSettings(settings);
+    console.log(`${themeOf(settings).ok}✓ Tema: ${settings.theme}${t.reset}\n`);
   }
+  return settings;
+}
 
-  if (action === "/config") {
-    rl.close();
-    const newSettings = await runInteractiveConfig();
-    return newSettings;
+async function cmdMcp(settings) {
+  const t = themeOf(settings);
+  if (!Array.isArray(settings.mcp)) settings.mcp = [];
+  while (true) {
+    console.log(`\n${t.bold}${t.accent}=== MCP SERVERS ===${t.reset}`);
+    if (!settings.mcp.length) console.log(`${t.dim}Belum ada server MCP.${t.reset}`);
+    settings.mcp.forEach((m, i) => console.log(` ${i + 1}) ${t.ok}${m.name}${t.reset} ${t.dim}${m.command || ""} ${(m.args || []).join(" ")}${t.reset}`));
+
+    // NEW: Add option to start MCP server
+    const pick = (await promptLine(`\n[a] tambah · [d] hapus · [s] mulai · [Enter] selesai: `)).trim().toLowerCase();
+    if (!pick) break;
+
+    if (pick === "a") {
+      const name = (await promptLine("Nama server: ")).trim();
+      const command = (await promptLine("Command (mis. npx): ")).trim();
+      const argsRaw = (await promptLine("Args (pisah spasi, opsional): ")).trim();
+      if (!name || !command) { console.log(`${t.warn}[!] Nama & command wajib.${t.reset}`); continue; }
+      settings.mcp.push({ name, command, args: argsRaw ? argsRaw.split(/\s+/) : [] });
+      saveSettings(settings);
+      console.log(`${t.ok}✓ ${name} ditambahkan.${t.reset}`);
+    } else if (pick === "d") {
+      const n = Number((await promptLine("Nomor yang dihapus: ")).trim()) - 1;
+      if (settings.mcp[n]) { const [x] = settings.mcp.splice(n, 1); saveSettings(settings); console.log(`${t.ok}✓ ${x.name} dihapus.${t.reset}`); }
+      else console.log(`${t.warn}[!] Nomor tidak valid.${t.reset}`);
+    } else if (pick === "s") {
+      const name = (await promptLine("Nama server: ")).trim();
+      const command = (await promptLine("Command (mis. npx): ")).trim();
+      const argsRaw = (await promptLine("Args (pisah spasi, opsional): ")).trim();
+      if (!name || !command) { console.log(`${t.warn}[!] Nama & command wajib.${t.reset}`); continue; }
+      await startMcpServer(name, command, argsRaw ? argsRaw.split(/\s+/) : []);
+      console.log(`${t.ok}✓ ${name} dimulai.${t.reset}`);
+    } else break;
   }
+  return settings;
+}
 
-  console.log(`Perintah tidak dikenal: ${action}. Ketik \x1b[36m/help\x1b[0m untuk daftar perintah.`);
+async function cmdMemory(settings) {
+  const t = themeOf(settings);
+  const file = path.join(process.cwd(), "KILUA.md");
+  const body = readMemory();
+  console.log(`\n${t.bold}${t.accent}=== MEMORI PROYEK ===${t.reset} ${t.dim}${file}${t.reset}`);
+  console.log(body.trim() ? body.trim() : `${t.dim}(kosong — memori ini selalu disuntik ke system prompt)${t.reset}`);
+  const add = (await promptLine(`\nTambah catatan memori (Enter = batal): `)).trim();
+  if (add) {
+    fs.appendFileSync(file, (fs.existsSync(file) ? "\n" : "# Memori Proyek (KILUA.md)\n") + "- " + add + "\n", "utf8");
+    console.log(`${t.ok}✓ Disimpan ke KILUA.md${t.reset}\n`);
+  } else console.log();
   return settings;
 }
 
+function cmdPlan(settings) {
+  const t = themeOf(settings);
+  PLAN_MODE = !PLAN_MODE;
+  console.log(`\n${PLAN_MODE ? t.warn + "⏸ Plan mode ON" : t.ok + "▶ Plan mode OFF"}${t.reset} ${t.dim}— ${PLAN_MODE ? "hanya baca & menyusun rencana, aksi tulis diblokir" : "agent bebas mengeksekusi"}.${t.reset}\n`);
+  return settings;
+}
+
+async function handleSlashCommand(cmd, settings, convo) {
+  const action = cmd.trim().split(/\s+/)[0].toLowerCase();
+  switch (action) {
+    case "/help": return printHelp(settings), settings;
+    case "/model": case "/models": return await cmdModel(settings);
+    case "/skills": case "/skill": return cmdSkills(settings);
+    case "/theme": return await cmdTheme(settings);
+    case "/mcp": return await cmdMcp(settings);
+    case "/memory": return await cmdMemory(settings);
+    case "/plan": return cmdPlan(settings);
+    case "/clear":
+      convo.length = 0;
+      console.clear();
+      console.log(`${themeOf(settings).ok}✓ Riwayat percakapan dibersihkan.${themeOf(settings).reset}\n`);
+      return settings;
+    case "/config": return await runInteractiveConfig();
+    default:
+      console.log(`Perintah tidak dikenal: ${action}. Ketik ${themeOf(settings).sel}/help${themeOf(settings).reset}.`);
+      return settings;
+  }
+}
+
 async function main() {
   const args = process.argv.slice(2);
   const oneShot = args.join(" ").trim();
@@ -835,11 +1465,23 @@ async function main() {
   }
 
   let settings = loadSettings();
+  if (args[0] === "--version" || args[0] === "-v") {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [path.join(here, "..", "packages", "kilua-agent", "package.json"), path.join(here, "..", "package.json")];
+    let v = "1.3.0";
+    for (const p of candidates) {
+      try {
+        const j = JSON.parse(fs.readFileSync(p, "utf8"));
+        if (j.name === "kilua-ai" && j.private) continue; // root app, bukan paket CLI
+        if (j.version) { v = j.version; break; }
+      } catch {}
+    }
+    console.log(`kilua-agent ${v}`);
+    process.exit(0);
+  }
 
-  // Validasi ketat: jika belum ada base_url atau api_key, WAJIB setup dulu
   const isLocalProxy = settings.base_url?.includes("127.0.0.1") || settings.base_url?.includes("localhost");
   const hasValidConfig = settings.base_url && (settings.api_key || isLocalProxy);
-
   if (!hasValidConfig) {
     console.log("\x1b[33m[!] Belum ada konfigurasi AI key / provider.\x1b[0m");
     settings = await runInteractiveConfig();
@@ -851,29 +1493,25 @@ async function main() {
     process.exit(0);
   }
 
-  console.log("\x1b[1m\x1b[35m=== KILUA AI CLI AGENT ===\x1b[0m");
-  console.log(`CWD     : \x1b[33m${process.cwd()}\x1b[0m`);
-  console.log(`Provider: \x1b[32m${settings.base_url}\x1b[0m (${settings.model})`);
-  console.log(`Config  : \x1b[90m${SETTINGS_PATH}\x1b[0m (ketik \x1b[36m/help\x1b[0m untuk panduan)\n`);
-
-  let rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const ask = () => {
-    rl.question("\x1b[1mKAMU > \x1b[0m", async input => {
-      const q = input.trim();
-      if (!q) return ask();
-      if (q === "exit" || q === "quit" || q === "/exit") { rl.close(); process.exit(0); }
-      if (q.startsWith("/")) {
-        settings = await handleSlashCommand(q, settings, convo, rl);
-        if (q === "/config") {
-          rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        }
-        return ask();
-      }
-      await runAgent(settings, q, convo);
-      ask();
-    });
-  };
-  ask();
+  const t = themeOf(settings);
+  console.log(`${t.bold}${t.accent}=== KILUA AI CLI AGENT ===${t.reset}`);
+  console.log(`${t.dim}CWD     :${t.reset} ${t.warn}${process.cwd()}${t.reset}`);
+  console.log(`${t.dim}Provider:${t.reset} ${t.ok}${settings.base_url}${t.reset} (${settings.model})`);
+  console.log(`${t.dim}Bantuan :${t.reset} ${t.sel}/${t.reset} perintah · ${t.sel}Ctrl+V${t.reset} paste teks/gambar\n`);
+
+  const history = [];
+  while (true) {
+    const { text, images } = await promptComposer(settings, history);
+    if (!text && !images.length) continue;
+    if (text === "exit" || text === "quit" || text === "/exit") break;
+    if (images.length && !text) { await runAgent(settings, "", convo, images); continue; }
+    if (text.startsWith("/")) { settings = await handleSlashCommand(text, settings, convo); continue; }
+    history.push(text);
+    if (history.length > 100) history.shift();
+    await runAgent(settings, text, convo, images);
+  }
+  console.log(`${t.dim}Sampai jumpa.${t.reset}`);
+  process.exit(0);
 }
 
 main();