@genflowai/opencode-autosetup 2.0.0 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genflowai/opencode-autosetup",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "Auto setup GenFlowAI provider for OpenCode",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   },
   "files": [
     "setup-opencode.js",
+    "models-metadata.json",
     "README.md"
   ],
   "scripts": {

package/setup-opencode.js

@@ -3,7 +3,8 @@ import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { join, dirname } from "node:path";
 import { homedir } from "node:os";
 import { spawn } from "node:child_process";
 
@@ -13,6 +14,169 @@ const MODELS_URL = `${BASE_URL}/models`;
 const CONFIG_DIR = process.env.OPENCODE_CONFIG_DIR || join(homedir(), ".config", "opencode");
 const CONFIG_PATH = join(CONFIG_DIR, "opencode.json");
 
+// ── Model metadata ────────────────────────────────────────────────────────────
+let modelDb = {};
+
+async function loadModelMetadata() {
+  try {
+    const bundledPath = join(dirname(fileURLToPath(import.meta.url)), "models-metadata.json");
+    const bundled = await readFile(bundledPath, "utf8");
+    modelDb = JSON.parse(bundled);
+  } catch {
+    modelDb = {};
+  }
+}
+
+function getModelInfo(id) {
+  const info = modelDb[id];
+  if (!info) return createDefaultModelInfo(id);
+
+  if (info.limit && info.modalities) {
+    return info;
+  }
+
+  if (info.contextInput && info.contextOutput) {
+    const input = info.capability === "multimodal"
+      ? ["text", "image", "video"]
+      : info.capability === "vision"
+        ? ["text", "image"]
+        : ["text"];
+
+    return {
+      limit: {
+        context: info.contextInput,
+        input: info.contextInput,
+        output: info.contextOutput
+      },
+      modalities: {
+        input,
+        output: ["text"]
+      }
+    };
+  }
+
+  return null;
+}
+
+function createDefaultModelInfo(id) {
+  const name = id.toLowerCase();
+  const input = name.includes("kimi")
+    ? ["text", "image", "video"]
+    : name.includes("gpt") || name.includes("claude") || name.includes("gemini")
+      ? ["text", "image"]
+      : ["text"];
+
+  return {
+    limit: {
+      context: 192000,
+      input: 192000,
+      output: 16000
+    },
+    modalities: {
+      input,
+      output: ["text"]
+    }
+  };
+}
+
+const CAPABILITY_LABEL = {
+  text: "Text",
+  vision: "Vision",
+  multimodal: "Multi"
+};
+
+function getCapability(info) {
+  const input = info?.modalities?.input ?? [];
+  if (input.includes("video")) return "multimodal";
+  if (input.includes("image")) return "vision";
+  return "text";
+}
+
+function formatTokens(n) {
+  if (n >= 1000000) return `${(n / 1000000).toFixed(n % 1000000 === 0 ? 0 : 1)}M`;
+  if (n >= 1000) return `${(n / 1000).toFixed(n % 1000 === 0 ? 0 : 1)}K`;
+  return String(n);
+}
+
+// ── ANSI helpers ──────────────────────────────────────────────────────────────
+const ESC = "\x1B[";
+const RESET = `${ESC}0m`;
+const BOLD = `${ESC}1m`;
+const DIM = `${ESC}2m`;
+const CYAN = `${ESC}36m`;
+const GREEN = `${ESC}32m`;
+const YELLOW = `${ESC}33m`;
+const RED = `${ESC}31m`;
+const MAGENTA = `${ESC}35m`;
+const BLUE = `${ESC}34m`;
+
+const SUPPORTS_ANSI = output.isTTY && !/^(dumb|msys|cygwin)/i.test(process.env.TERM ?? "");
+
+function c(code, text) {
+  return SUPPORTS_ANSI ? `${code}${text}${RESET}` : text;
+}
+
+function box(lines) {
+  const maxLen = Math.max(...lines.map((l) => stripAnsi(l).length));
+  const top = `${ESC}36m${"╭" + "─".repeat(maxLen + 2) + "╮"}${RESET}`;
+  const bot = `${ESC}36m${"╰" + "─".repeat(maxLen + 2) + "╯"}${RESET}`;
+  const rows = lines.map((l) => {
+    const pad = maxLen - stripAnsi(l).length;
+    return `${ESC}36m│${RESET} ${l}${" ".repeat(pad)} ${ESC}36m│${RESET}`;
+  });
+  return [top, ...rows, bot].join("\n");
+}
+
+function stripAnsi(str) {
+  return str.replace(/\x1B\[[0-9;]*m/g, "");
+}
+
+function printBanner() {
+  const banner = [
+    c(CYAN + BOLD, "   ╔══════════════════════════════════╗"),
+    c(CYAN + BOLD, "   ║     GenFlow × OpenCode Setup     ║"),
+    c(CYAN + BOLD, "   ╚══════════════════════════════════╝"),
+  ].join("\n");
+  console.log(`\n${banner}\n`);
+}
+
+function printStep(label) {
+  console.log(c(CYAN + BOLD, "  ▸ ") + c(BOLD, label));
+}
+
+function printOk(msg) {
+  console.log(c(GREEN, "    ✔ ") + msg);
+}
+
+function printWarn(msg) {
+  console.log(c(YELLOW, "    ⚠ ") + msg);
+}
+
+function printErr(msg) {
+  console.log(c(RED, "    ✖ ") + msg);
+}
+
+function printSpinner(label) {
+  const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  let i = 0;
+  const id = setInterval(() => {
+    const f = SUPPORTS_ANSI ? frames[i % frames.length] : ".";
+    process.stdout.write(`\r${c(CYAN, `    ${f}`)} ${label}`);
+    i++;
+  }, 80);
+  return {
+    stop: (msg) => {
+      clearInterval(id);
+      process.stdout.write(`\r${c(GREEN, "    ✔")} ${label}${msg ? ` — ${msg}` : ""}\n`);
+    },
+    fail: (msg) => {
+      clearInterval(id);
+      process.stdout.write(`\r${c(RED, "    ✖")} ${label}${msg ? ` — ${msg}` : ""}\n`);
+    },
+  };
+}
+
+// ── Arg helpers ────────────────────────────────────────────────────────────────
 function getArgValue(name) {
   const index = process.argv.indexOf(name);
   return index === -1 ? "" : process.argv[index + 1] ?? "";
@@ -22,6 +186,7 @@ function hasArg(name) {
   return process.argv.includes(name);
 }
 
+// ── Process helpers ────────────────────────────────────────────────────────────
 function run(command, args) {
   return new Promise((resolve, reject) => {
     const child = spawnProcess(command, args, "inherit");
@@ -61,28 +226,35 @@ function opencodeCommand() {
   return process.platform === "win32" ? "opencode.cmd" : "opencode";
 }
 
+// ── Setup steps ────────────────────────────────────────────────────────────────
 async function ensureOpenCodeInstalled() {
   if (hasArg("--skip-opencode-install")) {
-    console.log("Skip cek/install OpenCode.");
+    printWarn("Skip cek/install OpenCode.");
     return;
   }
 
+  printStep("Cek OpenCode...");
   const installed = await runQuiet(opencodeCommand(), ["--version"]);
 
   if (installed) {
-    console.log("OpenCode sudah terinstall.");
+    printOk("OpenCode sudah terinstall.");
     return;
   }
 
-  console.log("OpenCode belum terinstall. Menginstall via npm...");
-  await run(npmCommand(), ["install", "-g", "opencode-ai@latest"]);
-
-  const installedAfterInstall = await runQuiet(opencodeCommand(), ["--version"]);
-  if (!installedAfterInstall) {
-    throw new Error("OpenCode sudah diinstall, tapi command `opencode` belum tersedia di PATH. Restart terminal lalu coba lagi.");
+  printWarn("OpenCode belum terinstall.");
+  const spin = printSpinner("Menginstall OpenCode via npm");
+  try {
+    await run(npmCommand(), ["install", "-g", "opencode-ai@latest"]);
+    const installedAfterInstall = await runQuiet(opencodeCommand(), ["--version"]);
+    if (!installedAfterInstall) {
+      spin.fail("Gagal");
+      throw new Error("OpenCode sudah diinstall, tapi command `opencode` belum tersedia di PATH. Restart terminal lalu coba lagi.");
+    }
+    spin.stop("Berhasil");
+  } catch (err) {
+    spin.fail(err.message);
+    throw err;
   }
-
-  console.log("OpenCode berhasil terinstall.");
 }
 
 function stripJsonComments(value) {
@@ -102,17 +274,23 @@ async function readExistingConfig() {
 
 async function fetchAvailableModels() {
   try {
+    const spin = printSpinner("Mengambil daftar model");
     const response = await fetch(MODELS_URL);
 
     if (!response.ok) {
+      spin.fail(`HTTP ${response.status}`);
       return [];
     }
 
     const payload = await response.json();
-    return Array.isArray(payload.data)
+    const models = Array.isArray(payload.data)
       ? payload.data.map((model) => model.id).filter((model) => typeof model === "string")
       : [];
-  } catch {
+
+    spin.stop(`${c(BOLD, models.length)} model ditemukan`);
+    return models;
+  } catch (err) {
+    printWarn(`Gagal mengambil model: ${err.message}`);
     return [];
   }
 }
@@ -121,25 +299,47 @@ function getLatestModel(models) {
   return models[0] ?? "gpt-5.5";
 }
 
-function buildModelsConfig(models) {
-  return Object.fromEntries(models.map((model) => [model, { name: model }]));
+function buildModelsConfig(models, overrides = {}) {
+  return Object.fromEntries(
+    models.map((id) => {
+      const info = overrides[id] ?? getModelInfo(id);
+      const entry = { name: id };
+      if (info) {
+        entry.limit = info.limit;
+        entry.modalities = info.modalities;
+      }
+      return [id, entry];
+    })
+  );
 }
 
-function printModelHint(models) {
+function printModelList(models) {
   if (models.length === 0) {
-    console.log(`Daftar model: ${MODELS_URL}`);
+    printWarn(`Daftar model: ${MODELS_URL}`);
     return;
   }
 
-  console.log("Model tersedia contoh:");
-  for (const model of models.slice(0, 12)) {
-    console.log(`- ${model}`);
+  const shown = models.slice(0, 10);
+  for (const id of shown) {
+    const info = getModelInfo(id);
+    if (info) {
+      const capability = getCapability(info);
+      const cap = CAPABILITY_LABEL[capability] ?? "Text";
+      const ctx = `${formatTokens(info.limit.input)}/${formatTokens(info.limit.output)}`;
+      const capColor = capability === "multimodal" ? MAGENTA : capability === "vision" ? CYAN : DIM;
+      console.log(c(DIM, `      • ${id}  `) + c(capColor, `[${cap}]`) + c(DIM, ` ${ctx}`));
+    } else {
+      console.log(c(DIM, `      • ${id}`));
+    }
+  }
+  if (models.length > shown.length) {
+    console.log(c(DIM, `      ... dan ${models.length - shown.length} model lainnya`));
   }
-  console.log(`Total model: ${models.length}. Lihat lengkap: https://genflowai.co/models`);
 }
 
-function buildConfig(existingConfig, apiKey, model, availableModels) {
+function buildConfig(existingConfig, apiKey, model, availableModels, customLimitsForSelected = null) {
   const models = availableModels.length > 0 ? availableModels : [model];
+  const overrides = customLimitsForSelected ? { [model]: customLimitsForSelected } : {};
 
   return {
     ...existingConfig,
@@ -156,56 +356,180 @@ function buildConfig(existingConfig, apiKey, model, availableModels) {
         },
         models: {
           ...(existingConfig.provider?.[PROVIDER_ID]?.models ?? {}),
-          ...buildModelsConfig(models)
+          ...buildModelsConfig(models, overrides)
         }
       }
     }
   };
 }
 
+// ── Mode selection ─────────────────────────────────────────────────────────────
+async function pickMode(rl) {
+  if (hasArg("--quick")) return "quick";
+  if (hasArg("--advanced")) return "advanced";
+  if (!input.isTTY) return "quick";
+
+  printStep("Mode Setup");
+  console.log(c(DIM, "      ") + c(BOLD + GREEN, "1) Quick") + c(DIM, "    — pakai default, auto pilih model terbaru"));
+  console.log(c(DIM, "      ") + c(BOLD + MAGENTA, "2) Advanced") + c(DIM, " — custom model, context, input/output limit"));
+
+  const answer = (await rl.question(c(CYAN, "    Pilih [1/2] (default 1): "))).trim();
+  return answer === "2" || answer.toLowerCase() === "advanced" ? "advanced" : "quick";
+}
+
+function parseTokens(str, fallback) {
+  const v = String(str).trim().toLowerCase();
+  if (!v) return fallback;
+  const m = v.match(/^(\d+(?:\.\d+)?)\s*([km]?)$/);
+  if (!m) return fallback;
+  const n = parseFloat(m[1]);
+  const mult = m[2] === "m" ? 1_000_000 : m[2] === "k" ? 1_000 : 1;
+  return Math.round(n * mult);
+}
+
+async function pickModelInteractive(rl, models) {
+  console.log(c(DIM, "    Daftar model:"));
+  models.forEach((id, i) => {
+    const info = getModelInfo(id);
+    const capability = getCapability(info);
+    const cap = CAPABILITY_LABEL[capability] ?? "Text";
+    const capColor = capability === "multimodal" ? MAGENTA : capability === "vision" ? CYAN : DIM;
+    const ctx = `${formatTokens(info.limit.input)}/${formatTokens(info.limit.output)}`;
+    const idx = String(i + 1).padStart(2, " ");
+    console.log(c(DIM, `      ${idx}) ${id}  `) + c(capColor, `[${cap}]`) + c(DIM, ` ${ctx}`));
+  });
+
+  while (true) {
+    const ans = (await rl.question(c(CYAN, `    Pilih nomor / nama model [1]: `))).trim();
+    if (!ans) return models[0];
+    const num = parseInt(ans, 10);
+    if (Number.isFinite(num) && num >= 1 && num <= models.length) return models[num - 1];
+    if (models.includes(ans)) return ans;
+    printWarn(`Input "${ans}" tidak valid.`);
+  }
+}
+
+async function customizeLimits(rl, info) {
+  console.log(c(DIM, `    Default: context ${info.limit.context}, input ${info.limit.input}, output ${info.limit.output}`));
+  const ctxIn = (await rl.question(c(CYAN, `    Context window [${info.limit.context}] (contoh: 200k, 1m): `))).trim();
+  const inIn = (await rl.question(c(CYAN, `    Max input  [${info.limit.input}]: `))).trim();
+  const outIn = (await rl.question(c(CYAN, `    Max output [${info.limit.output}]: `))).trim();
+
+  const modalitiesIn = (await rl.question(c(CYAN, `    Modalities input [${info.modalities.input.join(",")}] (text,image,video,audio): `))).trim();
+  const inputModalities = modalitiesIn
+    ? modalitiesIn.split(",").map((m) => m.trim()).filter(Boolean)
+    : info.modalities.input;
+
+  return {
+    limit: {
+      context: parseTokens(ctxIn, info.limit.context),
+      input: parseTokens(inIn, info.limit.input),
+      output: parseTokens(outIn, info.limit.output)
+    },
+    modalities: {
+      input: inputModalities,
+      output: info.modalities.output
+    }
+  };
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────────
 async function main() {
+  printBanner();
+
   const rl = createInterface({ input, output });
 
   try {
     await ensureOpenCodeInstalled();
 
-    const apiKey = (getArgValue("--api-key") || process.env.GENFLOW_API_KEY || await rl.question("Masukkan GenFlow API key: ")).trim();
+    const mode = await pickMode(rl);
+    printOk(`Mode: ${c(BOLD, mode === "quick" ? "Quick" : "Advanced")}`);
+
+    printStep("API Key");
+    const apiKey = (getArgValue("--api-key") || process.env.GENFLOW_API_KEY || await rl.question(c(CYAN, "    Masukkan GenFlow API key: "))).trim();
 
     if (!apiKey) {
+      printErr("API key wajib diisi.");
       throw new Error("API key wajib diisi.");
     }
+    printOk("API key diterima.");
 
+    printStep("Model");
+    await loadModelMetadata();
     const availableModels = await fetchAvailableModels();
-    printModelHint(availableModels);
 
     const modelArg = getArgValue("--model").trim();
-    const model = modelArg || getLatestModel(availableModels);
-
-    if (!modelArg) {
-      console.log(`Model otomatis: ${model}`);
+    let model;
+
+    if (modelArg) {
+      model = modelArg;
+      printOk(`Model dipilih: ${c(BOLD, model)}`);
+    } else if (mode === "advanced" && availableModels.length > 0 && input.isTTY) {
+      model = await pickModelInteractive(rl, availableModels);
+      printOk(`Model dipilih: ${c(BOLD, model)}`);
+    } else {
+      printModelList(availableModels);
+      model = getLatestModel(availableModels);
+      printOk(`Model otomatis: ${c(BOLD, model)}`);
     }
 
     if (availableModels.length > 0 && !availableModels.includes(model)) {
+      printErr(`Model "${model}" tidak ditemukan.`);
       throw new Error(`Model "${model}" tidak ditemukan di ${MODELS_URL}. Cek https://genflowai.co/models`);
     }
 
+    let customLimitsOverride = null;
+    if (mode === "advanced" && input.isTTY) {
+      const wantCustom = (await rl.question(c(CYAN, "    Custom context/input/output limits? [y/N]: "))).trim().toLowerCase();
+      if (wantCustom === "y" || wantCustom === "yes") {
+        customLimitsOverride = await customizeLimits(rl, getModelInfo(model));
+        printOk("Custom limits diset.");
+      }
+    }
+
+    printStep("Config");
     const existingConfig = await readExistingConfig();
-    const nextConfig = buildConfig(existingConfig, apiKey, model, availableModels);
+    const nextConfig = buildConfig(existingConfig, apiKey, model, availableModels, customLimitsOverride);
 
     await mkdir(CONFIG_DIR, { recursive: true });
     await writeFile(CONFIG_PATH, `${JSON.stringify(nextConfig, null, 2)}\n`, "utf8");
+    printOk("Config ditulis.");
+
+    console.log();
+    const modelInfo = customLimitsOverride ?? getModelInfo(model);
+    const summaryLines = [
+      c(GREEN + BOLD, " Setup Selesai! "),
+      "",
+      c(BOLD, "  Mode     ") + c(DIM, "→ ") + c(mode === "quick" ? GREEN : MAGENTA, mode),
+      c(BOLD, "  Provider ") + c(DIM, "→ ") + c(MAGENTA, PROVIDER_ID),
+      c(BOLD, "  Model    ") + c(DIM, "→ ") + c(MAGENTA, `${PROVIDER_ID}/${model}`),
+    ];
+
+    if (modelInfo) {
+      const capability = getCapability(modelInfo);
+      const cap = CAPABILITY_LABEL[capability] ?? "Text";
+      const capColor = capability === "multimodal" ? MAGENTA : capability === "vision" ? CYAN : DIM;
+      summaryLines.push(
+        c(BOLD, "  Type     ") + c(DIM, "→ ") + c(capColor, cap),
+        c(BOLD, "  Context  ") + c(DIM, "→ ") + c(BOLD, `${formatTokens(modelInfo.limit.input)} input / ${formatTokens(modelInfo.limit.output)} output`),
+      );
+    }
+
+    summaryLines.push(
+      c(BOLD, "  Config   ") + c(DIM, "→ ") + c(BLUE, CONFIG_PATH),
+      c(BOLD, "  Total    ") + c(DIM, "→ ") + c(BOLD, `${availableModels.length || 1} model ditambahkan`),
+      "",
+      c(DIM, "  Jalankan: ") + c(GREEN + BOLD, "opencode"),
+    );
 
-    console.log(`\nSelesai. Config opencode ditulis ke: ${CONFIG_PATH}`);
-    console.log(`Provider: ${PROVIDER_ID}`);
-    console.log(`Model: ${PROVIDER_ID}/${model}`);
-    console.log(`Total model ditambahkan: ${availableModels.length || 1}`);
-    console.log("Jalankan: opencode");
+    console.log(box(summaryLines));
+    console.log();
   } finally {
     rl.close();
   }
 }
 
 main().catch((error) => {
-  console.error(`Gagal setup opencode: ${error.message}`);
+  console.error(`\n${c(RED + BOLD, "✖ Gagal:")} ${error.message}\n`);
   process.exitCode = 1;
 });