@gilangranggaid/kilua-agent 1.0.4 → 1.0.5

package/bin/kilua.js

@@ -0,0 +1,479 @@
+#!/usr/bin/env node
+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";
+
+// ponytail: single-file agent CLI supporting real-time streaming for 9router, Anthropic & OpenAI proxies.
+const KILUA_DIR = path.join(os.homedir(), ".kilua");
+const SETTINGS_PATH = path.join(KILUA_DIR, "settings.json");
+const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
+
+function ensureKiluaDir() {
+  if (!fs.existsSync(KILUA_DIR)) fs.mkdirSync(KILUA_DIR, { recursive: true });
+}
+
+function loadSettings() {
+  ensureKiluaDir();
+  try { return JSON.parse(fs.readFileSync(SETTINGS_PATH, "utf8")); } catch { return {}; }
+}
+
+function saveSettings(settings) {
+  ensureKiluaDir();
+  fs.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf8");
+}
+
+function readClaudeSettings() {
+  try {
+    const raw = JSON.parse(fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf8"));
+    const env = raw.env || {};
+    if (env.ANTHROPIC_BASE_URL || env.ANTHROPIC_AUTH_TOKEN) {
+      return {
+        base_url: env.ANTHROPIC_BASE_URL || "http://127.0.0.1:20128/v1",
+        api_key: env.ANTHROPIC_AUTH_TOKEN || "",
+        model: env.ANTHROPIC_DEFAULT_OPUS_MODEL || env.ANTHROPIC_DEFAULT_SONNET_MODEL || "harobor",
+        provider: "anthropic"
+      };
+    }
+  } catch {}
+  return null;
+}
+
+const TOOLS_OPENAI = [
+  {
+    type: "function",
+    function: {
+      name: "read_file",
+      description: "Membaca isi file lokal.",
+      parameters: { type: "object", properties: { path: { type: "string" } }, required: ["path"] }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "write_file",
+      description: "Menulis atau membuat file lokal.",
+      parameters: { type: "object", properties: { path: { type: "string" }, content: { type: "string" } }, required: ["path", "content"] }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "edit_file",
+      description: "Mengganti teks persis di file lokal.",
+      parameters: { type: "object", properties: { path: { type: "string" }, old_string: { type: "string" }, new_string: { type: "string" } }, required: ["path", "old_string", "new_string"] }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "list_dir",
+      description: "Melihat daftar file di folder.",
+      parameters: { type: "object", properties: { path: { type: "string" } } }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "run_cmd",
+      description: "Menjalankan perintah terminal lokal.",
+      parameters: { type: "object", properties: { command: { type: "string" } }, required: ["command"] }
+    }
+  }
+];
+
+const TOOLS_ANTHROPIC = TOOLS_OPENAI.map(t => ({
+  name: t.function.name,
+  description: t.function.description,
+  input_schema: t.function.parameters
+}));
+
+function executeLocalTool(name, args) {
+  const cwd = process.cwd();
+  try {
+    if (name === "read_file") {
+      const full = path.resolve(cwd, args.path);
+      return fs.existsSync(full) ? fs.readFileSync(full, "utf8").slice(0, 40000) : `Error: ${args.path} not found.`;
+    }
+    if (name === "write_file") {
+      const full = path.resolve(cwd, args.path);
+      fs.mkdirSync(path.dirname(full), { recursive: true });
+      fs.writeFileSync(full, args.content, "utf8");
+      return `✓ Written: ${args.path}`;
+    }
+    if (name === "edit_file") {
+      const full = path.resolve(cwd, args.path);
+      if (!fs.existsSync(full)) return `Error: ${args.path} not found.`;
+      const src = fs.readFileSync(full, "utf8");
+      if (!src.includes(args.old_string)) return `Error: old_string not matched in ${args.path}.`;
+      fs.writeFileSync(full, src.replace(args.old_string, args.new_string), "utf8");
+      return `✓ Edited: ${args.path}`;
+    }
+    if (name === "list_dir") {
+      const target = path.resolve(cwd, args.path || ".");
+      return fs.readdirSync(target, { withFileTypes: true }).map(it => `${it.isDirectory() ? "[DIR]" : "[FILE]"} ${it.name}`).join("\n");
+    }
+    if (name === "run_cmd") {
+      const out = execSync(args.command, { cwd, encoding: "utf8", timeout: 60000, stdio: ["pipe", "pipe", "pipe"] });
+      return out.trim() || "(Done)";
+    }
+  } catch (err) {
+    return `Error: ${err.stderr || err.message}`;
+  }
+  return `Error: Unknown tool ${name}`;
+}
+
+function promptQuestion(rl, query) {
+  return new Promise(res => rl.question(query, res));
+}
+
+async function runInteractiveConfig() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const claudeCfg = readClaudeSettings();
+
+  console.log("\x1b[35m=== KILUA CONFIG ===\x1b[0m\nPath: " + SETTINGS_PATH);
+  console.log("1) 9Router Local / Claude Code Proxy (Port 20128)");
+  console.log("2) TokenHarbor / 9Router / OpenRouter (OpenAI-compatible)");
+  console.log("3) Google Gemini (AI Studio Key)\n");
+
+  const choice = (await promptQuestion(rl, "Pilihan [1/2/3] (default 1): ")).trim() || "1";
+  let settings = {};
+
+  if (choice === "1") {
+    const defaultUrl = claudeCfg?.base_url || "http://127.0.0.1:20128/v1";
+    const defaultKey = claudeCfg?.api_key || "";
+    const defaultModel = claudeCfg?.model || "harobor";
+
+    const baseUrl = (await promptQuestion(rl, `Base URL (${defaultUrl}): `)).trim() || defaultUrl;
+    const key = (await promptQuestion(rl, `API Key/Token (${defaultKey ? defaultKey.slice(0, 10) + "..." : "masukkan token"}): `)).trim() || defaultKey;
+    const model = (await promptQuestion(rl, `Model (${defaultModel}): `)).trim() || defaultModel;
+
+    settings = {
+      provider: "anthropic",
+      base_url: baseUrl.replace(/\/+$/, ""),
+      api_key: key,
+      model
+    };
+  } else if (choice === "3") {
+    const key = (await promptQuestion(rl, "Masukkan GEMINI_API_KEY: ")).trim();
+    const model = (await promptQuestion(rl, "Nama Model (gemini-2.5-flash): ")).trim() || "gemini-2.5-flash";
+    settings = {
+      provider: "openai",
+      base_url: "https://generativelanguage.googleapis.com/v1beta/openai",
+      api_key: key,
+      model
+    };
+  } else {
+    console.log("Contoh Base URL: https://tokenharbor.ai/v1");
+    const baseUrl = (await promptQuestion(rl, "Base URL (https://tokenharbor.ai/v1): ")).trim() || "https://tokenharbor.ai/v1";
+    const key = (await promptQuestion(rl, "API Key: ")).trim();
+    const model = (await promptQuestion(rl, "Model (deepseek-v4.1-flash:free): ")).trim() || "deepseek-v4.1-flash:free";
+    settings = {
+      provider: "openai",
+      api_key: key,
+      base_url: baseUrl.replace(/\/+$/, ""),
+      model
+    };
+  }
+
+  saveSettings(settings);
+  rl.close();
+  console.log("\x1b[32m✓ Pengaturan disimpan di " + SETTINGS_PATH + "\x1b[0m\n");
+  return settings;
+}
+
+// Stream reader universal untuk SSE (Anthropic & 9router)
+async function readSseStream(res, onChunk) {
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const rawLine of lines) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("event:") || line.startsWith(":")) continue;
+      if (line.startsWith("data:")) {
+        const jsonStr = line.slice(5).trim();
+        if (!jsonStr || jsonStr === "[DONE]") continue;
+        try {
+          const parsed = JSON.parse(jsonStr);
+          onChunk(parsed);
+        } catch {}
+      }
+    }
+  }
+
+  if (buffer.trim().startsWith("data:")) {
+    try {
+      const parsed = JSON.parse(buffer.trim().slice(5).trim());
+      onChunk(parsed);
+    } catch {}
+  }
+}
+
+// Loop untuk Anthropic / 9router local (/v1/messages)
+async function runAnthropicLoop(settings, convo) {
+  const SYSTEM = `Kamu KILUA, AI Coding Agent di terminal lokal. Folder: ${process.cwd()}. Gunakan tools (read_file, write_file, edit_file, list_dir, run_cmd) untuk inspeksi dan eksekusi tugas coding mandiri. Respon ringkas to the point.`;
+
+  let endpoint = settings.base_url.replace(/\/+$/, "");
+  if (!endpoint.endsWith("/messages")) endpoint += "/messages";
+
+  for (let step = 0; step < 12; step++) {
+    process.stdout.write("\r\x1b[2K\x1b[35m[KILUA Berpikir...]\x1b[0m ");
+    let res;
+    try {
+      res = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": settings.api_key,
+          Authorization: `Bearer ${settings.api_key}`,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: settings.model,
+          max_tokens: 4096,
+          stream: true,
+          system: SYSTEM,
+          messages: convo,
+          tools: TOOLS_ANTHROPIC
+        })
+      });
+    } catch (e) {
+      console.error("\n[!] Connection error:", e.message);
+      return;
+    }
+
+    if (!res.ok) {
+      const errText = await res.text().catch(() => "");
+      console.error(`\n[!] Error (${res.status}):`, errText.slice(0, 200));
+      return;
+    }
+
+    let printedHeader = false;
+    let fullText = "";
+    const toolBlocks = [];
+
+    await readSseStream(res, (evt) => {
+      // 1. Text deltas
+      let deltaText = "";
+      if (typeof evt.delta?.text === "string") deltaText = evt.delta.text;
+      else if (typeof evt.delta?.content === "string") deltaText = evt.delta.content;
+      else if (evt.choices?.[0]?.delta?.content) deltaText = evt.choices[0].delta.content;
+      else if (evt.content_block?.text) deltaText = evt.content_block.text;
+
+      if (deltaText) {
+        if (!printedHeader) {
+          process.stdout.write("\r\x1b[2KKILUA > ");
+          printedHeader = true;
+        }
+        process.stdout.write(deltaText);
+        fullText += deltaText;
+      }
+
+      // 2. Tool deltas
+      if (evt.type === "content_block_start" && evt.content_block?.type === "tool_use") {
+        toolBlocks[evt.index] = { ...evt.content_block, _raw_json: "" };
+      } else if (evt.delta?.type === "input_json_delta") {
+        const idx = evt.index;
+        if (toolBlocks[idx]) {
+          toolBlocks[idx]._raw_json = (toolBlocks[idx]._raw_json || "") + (evt.delta.partial_json || "");
+        }
+      } else if (evt.type === "content_block_stop") {
+        const idx = evt.index;
+        if (toolBlocks[idx]?._raw_json) {
+          try { toolBlocks[idx].input = JSON.parse(toolBlocks[idx]._raw_json); } catch {}
+          delete toolBlocks[idx]._raw_json;
+        }
+      }
+    });
+
+    if (printedHeader) console.log();
+    else process.stdout.write("\r\x1b[2K");
+
+    const activeTools = toolBlocks.filter(Boolean);
+    const assistantBlocks = [];
+    if (fullText) assistantBlocks.push({ type: "text", text: fullText });
+    for (const tb of activeTools) assistantBlocks.push(tb);
+
+    convo.push({ role: "assistant", content: assistantBlocks.length ? assistantBlocks : fullText });
+
+    if (!activeTools.length) break;
+
+    const toolResultContent = [];
+    for (const tu of activeTools) {
+      const name = tu.name;
+      const args = tu.input || {};
+      console.log(`\x1b[36m⚡ Tool: ${name}\x1b[0m(${JSON.stringify(args)})`);
+      const output = executeLocalTool(name, args);
+      console.log(`\x1b[90m↳ ${output.slice(0, 140).replace(/\n/g, " ")}${output.length > 140 ? "..." : ""}\x1b[0m`);
+      toolResultContent.push({
+        type: "tool_result",
+        tool_use_id: tu.id,
+        content: output
+      });
+    }
+    convo.push({ role: "user", content: toolResultContent });
+  }
+}
+
+// Loop untuk OpenAI / TokenHarbor / Gemini OpenAI protocol
+async function runOpenAiLoop(settings, convo) {
+  const SYSTEM = `Kamu KILUA, AI Coding Agent di terminal lokal. Folder: ${process.cwd()}. Gunakan tools (read_file, write_file, edit_file, list_dir, run_cmd) untuk inspeksi dan eksekusi tugas coding mandiri. Respon ringkas to the point.`;
+
+  let endpoint = settings.base_url.replace(/\/+$/, "");
+  if (endpoint.includes("generativelanguage.googleapis.com") && !endpoint.includes("/openai")) {
+    endpoint += "/openai";
+  }
+  if (!endpoint.endsWith("/chat/completions")) {
+    endpoint += "/chat/completions";
+  }
+
+  for (let step = 0; step < 12; step++) {
+    process.stdout.write("\r\x1b[2K\x1b[35m[KILUA Berpikir...]\x1b[0m ");
+    let res;
+    try {
+      res = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${settings.api_key}`,
+          "x-goog-api-key": settings.api_key
+        },
+        body: JSON.stringify({
+          model: settings.model,
+          stream: true,
+          messages: [{ role: "system", content: SYSTEM }, ...convo],
+          tools: TOOLS_OPENAI,
+          tool_choice: "auto"
+        })
+      });
+    } catch (e) {
+      console.error("\n[!] Connection error:", e.message);
+      return;
+    }
+
+    if (!res.ok) {
+      const errText = await res.text().catch(() => "");
+      console.error(`\n[!] Error (${res.status}):`, errText.slice(0, 200));
+      return;
+    }
+
+    let printedHeader = false;
+    let fullText = "";
+    const toolCallsMap = {};
+
+    await readSseStream(res, (evt) => {
+      const choice = evt.choices?.[0];
+      const delta = choice?.delta;
+      if (delta?.content) {
+        if (!printedHeader) {
+          process.stdout.write("\r\x1b[2KKILUA > ");
+          printedHeader = true;
+        }
+        process.stdout.write(delta.content);
+        fullText += delta.content;
+      }
+      if (delta?.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const idx = tc.index ?? 0;
+          if (!toolCallsMap[idx]) toolCallsMap[idx] = { id: tc.id, function: { name: tc.function?.name || "", arguments: "" } };
+          if (tc.function?.name) toolCallsMap[idx].function.name = tc.function.name;
+          if (tc.function?.arguments) toolCallsMap[idx].function.arguments += tc.function.arguments;
+        }
+      }
+    });
+
+    if (printedHeader) console.log();
+    else process.stdout.write("\r\x1b[2K");
+
+    const toolCalls = Object.values(toolCallsMap);
+    convo.push({ role: "assistant", content: fullText, tool_calls: toolCalls.length ? toolCalls : undefined });
+
+    if (!toolCalls.length) break;
+
+    for (const tc of toolCalls) {
+      const name = tc.function.name;
+      let args = {};
+      try { args = JSON.parse(tc.function.arguments || "{}"); } catch {}
+      console.log(`\x1b[36m⚡ Tool: ${name}\x1b[0m(${JSON.stringify(args)})`);
+      const output = executeLocalTool(name, args);
+      console.log(`\x1b[90m↳ ${output.slice(0, 140).replace(/\n/g, " ")}${output.length > 140 ? "..." : ""}\x1b[0m`);
+      convo.push({ role: "tool", tool_call_id: tc.id, name, content: output });
+    }
+  }
+}
+
+async function runAgent(settings, userPrompt, convo) {
+  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);
+  } else {
+    convo.push({ role: "user", content: userPrompt });
+    await runOpenAiLoop(settings, convo);
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const oneShot = args.join(" ").trim();
+
+  if (args[0] === "config" || args[0] === "setup") {
+    await runInteractiveConfig();
+    process.exit(0);
+  }
+
+  let settings = loadSettings();
+
+  // Auto-import dari Claude Code jika settings kilua belum ada
+  if (!settings.api_key) {
+    const claudeCfg = readClaudeSettings();
+    if (claudeCfg) {
+      settings = claudeCfg;
+      saveSettings(settings);
+    } else {
+      console.log("\x1b[33m[!] Belum ada konfigurasi AI key.\x1b[0m");
+      settings = await runInteractiveConfig();
+    }
+  }
+
+  const convo = [];
+  if (oneShot) {
+    await runAgent(settings, oneShot, convo);
+    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 'config' untuk ganti)\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") { rl.close(); process.exit(0); }
+      if (q === "config" || q === "/config") {
+        rl.close();
+        await runInteractiveConfig();
+        settings = loadSettings();
+        rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        return ask();
+      }
+      await runAgent(settings, q, convo);
+      ask();
+    });
+  };
+  ask();
+}
+
+main();

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@gilangranggaid/kilua-agent",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Autonomous AI Coding Agent for your terminal and VS Code",
   "type": "module",
-  "main": "bin/kilua.mjs",
+  "main": "bin/kilua.js",
   "bin": {
-    "kilua": "./bin/kilua.mjs",
-    "kilua-agent": "./bin/kilua.mjs"
+    "kilua": "./bin/kilua.js",
+    "kilua-agent": "./bin/kilua.js"
   },
   "files": [
     "bin",