@gilangranggaid/kilua-agent 0.0.0-stage → 1.0.1

package/README.md

@@ -1,3 +1,29 @@
-# Temporary Holding Version
+# KILUA AI Agent CLI
 
-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.
+Autonomous AI Coding Agent di terminal & VS Code kamu (seperti Claude Code).
+
+## Fitur
+- 🔍 Membaca & menelusuri file di project lokal.
+- ✏️ Mengedit dan membuat file kode secara otomatis.
+- ⚡ Mengeksekusi perintah shell lokal (`git`, `npm`, script).
+- 🧠 Mendukung TokenHarbor, 9router, Gemini, dan OpenAI-compatible provider.
+
+## Cara Menggunakan
+
+### Tanpa Install (NPX):
+```bash
+npx @gilangranggaid/kilua-agent
+```
+
+### Install Global:
+```bash
+npm install -g @gilangranggaid/kilua-agent
+kilua
+```
+
+### Konfigurasi API Key & Model:
+Cukup jalankan, Kilua akan menanyakan API Key & Provider secara interaktif dan menyimpannya di `~/.kilua/settings.json`.
+Atau ketik kapan saja:
+```bash
+kilua config
+```

package/bin/kilua.mjs

@@ -0,0 +1,353 @@
+#!/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 both OpenAI & Anthropic (9router) protocols.
+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 / Claude Code Proxy (Port 20128)");
+  console.log("2) TokenHarbor / OpenAI Compatible");
+  console.log("3) Custom Provider\n");
+
+  const choice = (await promptQuestion(rl, "Pilihan [1/2/3] (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) + "..." : "kosongkan jika sama"}): `)).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 === "2") {
+    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 };
+  } else {
+    const provider = (await promptQuestion(rl, "Tipe API [openai/anthropic] (openai): ")).trim() || "openai";
+    const baseUrl = (await promptQuestion(rl, "Base URL: ")).trim();
+    const key = (await promptQuestion(rl, "API Key: ")).trim();
+    const model = (await promptQuestion(rl, "Model: ")).trim();
+    settings = { provider, api_key: key, base_url: baseUrl.replace(/\/+$/, ""), model };
+  }
+
+  saveSettings(settings);
+  rl.close();
+  console.log("\x1b[32m✓ Saved to " + SETTINGS_PATH + "\x1b[0m\n");
+  return settings;
+}
+
+// Loop untuk Anthropic / 9router protocol (/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.`;
+
+  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(`${settings.base_url}/messages`, {
+        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,
+          system: SYSTEM,
+          messages: convo,
+          tools: TOOLS_ANTHROPIC
+        })
+      });
+    } catch (e) {
+      console.error("\n[!] Connection error:", e.message);
+      return;
+    }
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      console.error(`\n[!] Error (${res.status}):`, err.error?.message || err.message || res.statusText);
+      return;
+    }
+
+    const data = await res.json();
+    const blocks = data.content || [];
+    const textBlock = blocks.find(b => b.type === "text");
+    if (textBlock?.text) {
+      process.stdout.write(`\r\x1b[2KKILUA > ${textBlock.text}\n`);
+    }
+
+    convo.push({ role: "assistant", content: blocks });
+
+    const toolUseBlocks = blocks.filter(b => b.type === "tool_use");
+    if (!toolUseBlocks.length) break;
+
+    const toolResultContent = [];
+    for (const tu of toolUseBlocks) {
+      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 });
+  }
+  console.log();
+}
+
+// Loop untuk OpenAI / TokenHarbor protocol (/v1/chat/completions)
+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.`;
+
+  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(`${settings.base_url}/chat/completions`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${settings.api_key}` },
+        body: JSON.stringify({ model: settings.model, 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 err = await res.json().catch(() => ({}));
+      console.error(`\n[!] Error (${res.status}):`, err.error?.message || err.message || res.statusText);
+      return;
+    }
+
+    const data = await res.json();
+    const message = data.choices?.[0]?.message;
+    if (!message) break;
+    convo.push(message);
+
+    if (message.content) process.stdout.write(`\r\x1b[2KKILUA > ${message.content}\n`);
+
+    const toolCalls = message.tool_calls || [];
+    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 });
+    }
+  }
+  console.log();
+}
+
+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}) [${settings.provider || "openai"}]`);
+  console.log(`Config  : \x1b[90m${SETTINGS_PATH}\x1b[0m (ketik 'config' untuk ganti)\n`);
+
+  const 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();
+        return ask();
+      }
+      await runAgent(settings, q, convo);
+      ask();
+    });
+  };
+  ask();
+}
+
+main();

package/package.json

@@ -1,6 +1,27 @@
 {
   "name": "@gilangranggaid/kilua-agent",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "Autonomous AI Coding Agent for your terminal and VS Code",
+  "type": "module",
+  "main": "bin/kilua.mjs",
+  "bin": {
+    "kilua": "./bin/kilua.mjs",
+    "kilua-agent": "./bin/kilua.mjs"
+  },
+  "files": [
+    "bin",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "coding-assistant",
+    "terminal",
+    "vscode"
+  ],
+  "author": "Gilang Rangga ID",
+  "license": "MIT"
+}