openxgen 0.3.0

package/dist/index.js

@@ -0,0 +1,2161 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config/store.ts
+var store_exports = {};
+__export(store_exports, {
+  addProvider: () => addProvider,
+  clearAuth: () => clearAuth,
+  getAccessToken: () => getAccessToken,
+  getAuth: () => getAuth,
+  getConfig: () => getConfig,
+  getDefaultProvider: () => getDefaultProvider,
+  getProviders: () => getProviders,
+  getProvidersStore: () => getProvidersStore,
+  getRefreshToken: () => getRefreshToken,
+  getServer: () => getServer,
+  removeProvider: () => removeProvider,
+  requireAuth: () => requireAuth,
+  requireServer: () => requireServer,
+  setAuth: () => setAuth,
+  setConfig: () => setConfig,
+  setDefaultProvider: () => setDefaultProvider,
+  setServer: () => setServer
+});
+import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function ensureDir() {
+  if (!existsSync(XGEN_DIR)) {
+    mkdirSync(XGEN_DIR, { recursive: true, mode: 448 });
+  }
+}
+function readJson(filePath, fallback) {
+  try {
+    if (!existsSync(filePath)) return fallback;
+    const data = readFileSync(filePath, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return fallback;
+  }
+}
+function writeJson(filePath, data, secure = false) {
+  ensureDir();
+  writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+  if (secure) {
+    chmodSync(filePath, 384);
+  }
+}
+function getConfig() {
+  return { ...DEFAULT_CONFIG, ...readJson(CONFIG_FILE, {}) };
+}
+function setConfig(partial) {
+  const current = getConfig();
+  writeJson(CONFIG_FILE, { ...current, ...partial });
+}
+function getServer() {
+  return getConfig().server;
+}
+function setServer(url) {
+  const normalized = url.replace(/\/+$/, "");
+  setConfig({ server: normalized });
+}
+function getAuth() {
+  const auth = readJson(AUTH_FILE, null);
+  if (!auth || !auth.accessToken) return null;
+  return auth;
+}
+function setAuth(auth) {
+  writeJson(AUTH_FILE, auth, true);
+}
+function clearAuth() {
+  writeJson(AUTH_FILE, {}, true);
+}
+function getAccessToken() {
+  return getAuth()?.accessToken ?? null;
+}
+function getRefreshToken() {
+  return getAuth()?.refreshToken ?? null;
+}
+function getProvidersStore() {
+  return { ...DEFAULT_PROVIDERS, ...readJson(PROVIDERS_FILE, DEFAULT_PROVIDERS) };
+}
+function getProviders() {
+  return getProvidersStore().providers;
+}
+function addProvider(provider) {
+  const store = getProvidersStore();
+  store.providers = store.providers.filter((p) => p.id !== provider.id);
+  store.providers.push(provider);
+  if (!store.defaultId) store.defaultId = provider.id;
+  writeJson(PROVIDERS_FILE, store, true);
+}
+function removeProvider(id) {
+  const store = getProvidersStore();
+  const before = store.providers.length;
+  store.providers = store.providers.filter((p) => p.id !== id);
+  if (store.defaultId === id) {
+    store.defaultId = store.providers[0]?.id ?? null;
+  }
+  writeJson(PROVIDERS_FILE, store, true);
+  return store.providers.length < before;
+}
+function getDefaultProvider() {
+  const store = getProvidersStore();
+  if (!store.defaultId) return store.providers[0] ?? null;
+  return store.providers.find((p) => p.id === store.defaultId) ?? null;
+}
+function setDefaultProvider(id) {
+  const store = getProvidersStore();
+  const exists = store.providers.some((p) => p.id === id);
+  if (!exists) return false;
+  store.defaultId = id;
+  writeJson(PROVIDERS_FILE, store, true);
+  return true;
+}
+function requireServer() {
+  const server = getServer();
+  if (!server) {
+    console.error("\uC11C\uBC84\uAC00 \uC124\uC815\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694:");
+    console.error("  xgen config set-server <url>");
+    process.exit(1);
+  }
+  return server;
+}
+function requireAuth() {
+  const auth = getAuth();
+  if (!auth) {
+    console.error("\uB85C\uADF8\uC778\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694:");
+    console.error("  xgen login");
+    process.exit(1);
+  }
+  return auth;
+}
+var XGEN_DIR, CONFIG_FILE, AUTH_FILE, PROVIDERS_FILE, DEFAULT_CONFIG, DEFAULT_PROVIDERS;
+var init_store = __esm({
+  "src/config/store.ts"() {
+    "use strict";
+    XGEN_DIR = join(homedir(), ".xgen");
+    CONFIG_FILE = join(XGEN_DIR, "config.json");
+    AUTH_FILE = join(XGEN_DIR, "auth.json");
+    PROVIDERS_FILE = join(XGEN_DIR, "providers.json");
+    DEFAULT_CONFIG = {
+      server: null,
+      defaultWorkflow: null,
+      theme: "default",
+      streamLogs: false
+    };
+    DEFAULT_PROVIDERS = { providers: [], defaultId: null };
+  }
+});
+
+// src/api/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  apiLogin: () => apiLogin,
+  apiRefresh: () => apiRefresh,
+  apiValidate: () => apiValidate
+});
+import axios2 from "axios";
+import { createHash } from "crypto";
+async function apiLogin(email, password) {
+  const server = getServer();
+  if (!server) throw new Error("\uC11C\uBC84\uAC00 \uC124\uC815\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4");
+  const hashedPassword = createHash("sha256").update(password).digest("hex");
+  const res = await axios2.post(`${server}/api/auth/login`, {
+    email,
+    password: hashedPassword
+  });
+  return res.data;
+}
+async function apiValidate(accessToken) {
+  const server = getServer();
+  if (!server) throw new Error("\uC11C\uBC84\uAC00 \uC124\uC815\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4");
+  const res = await axios2.get(`${server}/api/auth/validate`, {
+    headers: { Authorization: `Bearer ${accessToken}` }
+  });
+  return res.data;
+}
+async function apiRefresh(refreshToken) {
+  const server = getServer();
+  if (!server) throw new Error("\uC11C\uBC84\uAC00 \uC124\uC815\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4");
+  const res = await axios2.post(`${server}/api/auth/refresh`, {
+    refresh_token: refreshToken
+  });
+  return res.data;
+}
+var init_auth = __esm({
+  "src/api/auth.ts"() {
+    "use strict";
+    init_store();
+  }
+});
+
+// src/index.ts
+import { Command } from "commander";
+import chalk14 from "chalk";
+
+// src/commands/config.ts
+init_store();
+import chalk2 from "chalk";
+
+// src/api/client.ts
+init_store();
+import axios from "axios";
+var client = null;
+function getClient() {
+  if (client) return client;
+  const server = getServer();
+  if (!server) {
+    throw new Error("\uC11C\uBC84\uAC00 \uC124\uC815\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. xgen config set-server <url>");
+  }
+  client = axios.create({
+    baseURL: server,
+    timeout: 12e4,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  client.interceptors.request.use((config) => {
+    const token = getAccessToken();
+    if (token && config.headers) {
+      config.headers.Authorization = `Bearer ${token}`;
+    }
+    return config;
+  });
+  client.interceptors.response.use(
+    (response) => response,
+    async (error) => {
+      const originalRequest = error.config;
+      if (error.response?.status === 401 && !originalRequest._retry && getRefreshToken()) {
+        originalRequest._retry = true;
+        try {
+          const refreshToken = getRefreshToken();
+          const server2 = getServer();
+          const res = await axios.post(`${server2}/api/auth/refresh`, {
+            refresh_token: refreshToken
+          });
+          if (res.data.success && res.data.access_token) {
+            const auth = getAuth();
+            setAuth({
+              ...auth,
+              accessToken: res.data.access_token
+            });
+            originalRequest.headers.Authorization = `Bearer ${res.data.access_token}`;
+            return client(originalRequest);
+          }
+        } catch {
+          clearAuth();
+          console.error("\n\uC138\uC158\uC774 \uB9CC\uB8CC\uB418\uC5C8\uC2B5\uB2C8\uB2E4. \uB2E4\uC2DC \uB85C\uADF8\uC778\uD558\uC138\uC694: xgen login");
+          process.exit(1);
+        }
+      }
+      return Promise.reject(error);
+    }
+  );
+  return client;
+}
+function resetClient() {
+  client = null;
+}
+
+// src/utils/format.ts
+import chalk from "chalk";
+function printHeader(text) {
+  const line = "\u2500".repeat(Math.max(text.length + 4, 40));
+  console.log(chalk.cyan(line));
+  console.log(chalk.cyan.bold(`  ${text}`));
+  console.log(chalk.cyan(line));
+}
+function printSuccess(text) {
+  console.log(chalk.green(`\u2713 ${text}`));
+}
+function printError(text) {
+  console.error(chalk.red(`\u2717 ${text}`));
+}
+function printInfo(text) {
+  console.log(chalk.blue(`\u2139 ${text}`));
+}
+function printKeyValue(key, value) {
+  console.log(`  ${chalk.gray(key + ":")} ${value ?? chalk.dim("(\uC5C6\uC74C)")}`);
+}
+function printTable(headers, rows) {
+  const widths = headers.map((h, i) => {
+    const colMax = rows.reduce((max, row) => Math.max(max, (row[i] ?? "").length), 0);
+    return Math.max(h.length, colMax);
+  });
+  const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join("  ");
+  console.log(chalk.bold(headerLine));
+  console.log(chalk.gray("\u2500".repeat(headerLine.length)));
+  for (const row of rows) {
+    const line = row.map((cell, i) => (cell ?? "").padEnd(widths[i])).join("  ");
+    console.log(line);
+  }
+}
+function truncate(text, maxLen = 50) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen - 3) + "...";
+}
+function formatDate(dateStr) {
+  if (!dateStr) return "-";
+  try {
+    const d = new Date(dateStr);
+    return d.toLocaleDateString("ko-KR") + " " + d.toLocaleTimeString("ko-KR", { hour: "2-digit", minute: "2-digit" });
+  } catch {
+    return dateStr;
+  }
+}
+
+// src/commands/config.ts
+function registerConfigCommand(program2) {
+  const config = program2.command("config").description("XGEN CLI \uC124\uC815 \uAD00\uB9AC");
+  config.command("set-server <url>").description("XGEN \uC11C\uBC84 URL \uC124\uC815").action((url) => {
+    if (!url.startsWith("http://") && !url.startsWith("https://")) {
+      printError("URL\uC740 http:// \uB610\uB294 https://\uB85C \uC2DC\uC791\uD574\uC57C \uD569\uB2C8\uB2E4");
+      process.exit(1);
+    }
+    setServer(url);
+    resetClient();
+    printSuccess(`\uC11C\uBC84 \uC124\uC815 \uC644\uB8CC: ${chalk2.underline(url)}`);
+  });
+  config.command("get-server").description("\uD604\uC7AC \uC124\uC815\uB41C \uC11C\uBC84 URL \uD655\uC778").action(() => {
+    const server = getServer();
+    if (server) {
+      console.log(server);
+    } else {
+      printError("\uC11C\uBC84\uAC00 \uC124\uC815\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4");
+      console.log("  \uC124\uC815: xgen config set-server <url>");
+    }
+  });
+  config.command("list").description("\uC804\uCCB4 \uC124\uC815 \uD655\uC778").action(() => {
+    const cfg = getConfig();
+    console.log(chalk2.bold("\nXGEN CLI \uC124\uC815"));
+    console.log(chalk2.gray("\u2500".repeat(40)));
+    printKeyValue("\uC11C\uBC84", cfg.server);
+    printKeyValue("\uAE30\uBCF8 \uC6CC\uD06C\uD50C\uB85C\uC6B0", cfg.defaultWorkflow);
+    printKeyValue("\uD14C\uB9C8", cfg.theme);
+    printKeyValue("\uC2A4\uD2B8\uB9BC \uB85C\uADF8", String(cfg.streamLogs));
+    console.log();
+  });
+  config.command("set <key> <value>").description("\uC124\uC815 \uAC12 \uBCC0\uACBD").action((key, value) => {
+    const allowedKeys = ["defaultWorkflow", "theme", "streamLogs"];
+    if (!allowedKeys.includes(key)) {
+      printError(`\uC54C \uC218 \uC5C6\uB294 \uC124\uC815 \uD0A4: ${key}`);
+      console.log(`  \uC0AC\uC6A9 \uAC00\uB2A5: ${allowedKeys.join(", ")}`);
+      process.exit(1);
+    }
+    const parsed = key === "streamLogs" ? value === "true" : value;
+    setConfig({ [key]: parsed });
+    printSuccess(`${key} = ${value}`);
+  });
+}
+
+// src/commands/login.ts
+init_auth();
+init_store();
+import chalk3 from "chalk";
+import { createInterface } from "readline";
+function prompt(question, hidden = false) {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    if (hidden) {
+      process.stdout.write(question);
+      const stdin = process.stdin;
+      const wasRaw = stdin.isRaw;
+      if (stdin.isTTY) stdin.setRawMode(true);
+      let password = "";
+      const onData = (ch) => {
+        const c = ch.toString("utf8");
+        if (c === "\n" || c === "\r" || c === "") {
+          if (stdin.isTTY) stdin.setRawMode(wasRaw ?? false);
+          stdin.removeListener("data", onData);
+          process.stdout.write("\n");
+          rl.close();
+          resolve(password);
+        } else if (c === "") {
+          process.exit(0);
+        } else if (c === "\x7F" || c === "\b") {
+          if (password.length > 0) {
+            password = password.slice(0, -1);
+            process.stdout.write("\b \b");
+          }
+        } else {
+          password += c;
+          process.stdout.write("*");
+        }
+      };
+      stdin.on("data", onData);
+    } else {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    }
+  });
+}
+function registerLoginCommand(program2) {
+  program2.command("login").description("XGEN \uC11C\uBC84\uC5D0 \uB85C\uADF8\uC778").option("-e, --email <email>", "\uC774\uBA54\uC77C").option("-p, --password <password>", "\uBE44\uBC00\uBC88\uD638").action(async (opts) => {
+    const server = requireServer();
+    printHeader("XGEN Login");
+    console.log(chalk3.gray(`\uC11C\uBC84: ${server}
+`));
+    let email = opts.email;
+    let password = opts.password;
+    if (!email) {
+      email = await prompt(chalk3.white("\uC774\uBA54\uC77C: "));
+    }
+    if (!password) {
+      password = await prompt(chalk3.white("\uBE44\uBC00\uBC88\uD638: "), true);
+    }
+    if (!email || !password) {
+      printError("\uC774\uBA54\uC77C\uACFC \uBE44\uBC00\uBC88\uD638\uB97C \uBAA8\uB450 \uC785\uB825\uD558\uC138\uC694");
+      process.exit(1);
+    }
+    try {
+      const result = await apiLogin(email, password);
+      if (result.success && result.access_token) {
+        setAuth({
+          accessToken: result.access_token,
+          refreshToken: result.refresh_token ?? "",
+          userId: result.user_id ?? "",
+          username: result.username ?? "",
+          isAdmin: false,
+          expiresAt: null
+        });
+        console.log();
+        printSuccess(`\uB85C\uADF8\uC778 \uC131\uACF5! ${chalk3.bold(result.username ?? email)}`);
+      } else {
+        printError(result.message || "\uB85C\uADF8\uC778 \uC2E4\uD328");
+        process.exit(1);
+      }
+    } catch (err) {
+      const msg = err?.response?.data?.message ?? err?.response?.data?.detail ?? err.message;
+      printError(`\uB85C\uADF8\uC778 \uC2E4\uD328: ${msg}`);
+      process.exit(1);
+    }
+  });
+  program2.command("logout").description("\uB85C\uADF8\uC544\uC6C3").action(async () => {
+    const { clearAuth: clearAuth2 } = await Promise.resolve().then(() => (init_store(), store_exports));
+    clearAuth2();
+    printSuccess("\uB85C\uADF8\uC544\uC6C3 \uC644\uB8CC");
+  });
+  program2.command("whoami").description("\uD604\uC7AC \uB85C\uADF8\uC778\uB41C \uC0AC\uC6A9\uC790 \uC815\uBCF4").action(async () => {
+    const auth = getAuth();
+    if (!auth) {
+      printError("\uB85C\uADF8\uC778\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. xgen login \uC2E4\uD589\uD558\uC138\uC694");
+      process.exit(1);
+    }
+    const server = requireServer();
+    console.log(chalk3.bold("\n\uD604\uC7AC \uC0AC\uC6A9\uC790"));
+    console.log(chalk3.gray("\u2500".repeat(30)));
+    console.log(`  ${chalk3.gray("\uC11C\uBC84:")} ${server}`);
+    console.log(`  ${chalk3.gray("\uC0AC\uC6A9\uC790:")} ${chalk3.bold(auth.username)}`);
+    console.log(`  ${chalk3.gray("User ID:")} ${auth.userId}`);
+    try {
+      const { apiValidate: apiValidate2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+      const result = await apiValidate2(auth.accessToken);
+      if (result.valid) {
+        console.log(`  ${chalk3.gray("\uC0C1\uD0DC:")} ${chalk3.green("\uD65C\uC131")}`);
+        if (result.is_admin) {
+          console.log(`  ${chalk3.gray("\uAD8C\uD55C:")} ${chalk3.yellow("\uAD00\uB9AC\uC790")}`);
+        }
+        if (result.user_type) {
+          console.log(`  ${chalk3.gray("\uC720\uD615:")} ${result.user_type}`);
+        }
+      } else {
+        console.log(`  ${chalk3.gray("\uC0C1\uD0DC:")} ${chalk3.red("\uD1A0\uD070 \uB9CC\uB8CC")}`);
+      }
+    } catch {
+      console.log(`  ${chalk3.gray("\uC0C1\uD0DC:")} ${chalk3.yellow("\uAC80\uC99D \uBD88\uAC00 (\uC11C\uBC84 \uC5F0\uACB0 \uC2E4\uD328)")}`);
+    }
+    console.log();
+  });
+}
+
+// src/commands/workflow/list.ts
+init_store();
+import chalk4 from "chalk";
+
+// src/api/workflow.ts
+async function listWorkflows(userId) {
+  const client2 = getClient();
+  const params = {};
+  if (userId) params.user_id = userId;
+  const res = await client2.get("/api/workflow/list", { params });
+  return res.data.workflows ?? res.data;
+}
+async function getWorkflowDetail(workflowId) {
+  const client2 = getClient();
+  const res = await client2.get(`/api/workflow/load/${workflowId}`);
+  return res.data;
+}
+async function getWorkflowListDetail() {
+  const client2 = getClient();
+  const res = await client2.get("/api/workflow/list/detail");
+  return res.data;
+}
+async function executeWorkflowStream(request) {
+  const client2 = getClient();
+  const res = await client2.post("/api/workflow/execute/based_id/stream", request, {
+    responseType: "stream",
+    headers: {
+      Accept: "text/event-stream"
+    }
+  });
+  return res.data;
+}
+async function getIOLogs(workflowId, limit = 20) {
+  const client2 = getClient();
+  const params = { limit };
+  if (workflowId) params.workflow_id = workflowId;
+  const res = await client2.get("/api/workflow/io_logs", { params });
+  return res.data;
+}
+
+// src/commands/workflow/list.ts
+async function workflowList(opts) {
+  requireAuth();
+  try {
+    if (opts.detail) {
+      const workflows = await getWorkflowListDetail();
+      if (!workflows || workflows.length === 0) {
+        console.log(chalk4.yellow("\n\uC6CC\uD06C\uD50C\uB85C\uC6B0\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.\n"));
+        return;
+      }
+      printHeader(`\uC6CC\uD06C\uD50C\uB85C\uC6B0 \uBAA9\uB85D (${workflows.length}\uAC1C)`);
+      console.log();
+      printTable(
+        ["#", "ID", "\uC774\uB984", "\uBC30\uD3EC", "\uC5C5\uB370\uC774\uD2B8"],
+        workflows.map((w, i) => [
+          String(i + 1),
+          (w.workflow_id ?? w.id ?? "-").slice(0, 12),
+          truncate(w.workflow_name ?? "-", 30),
+          w.deploy_status === "deployed" ? chalk4.green("\uBC30\uD3EC\uB428") : chalk4.gray("\uBBF8\uBC30\uD3EC"),
+          formatDate(w.updated_at)
+        ])
+      );
+    } else {
+      const workflows = await listWorkflows();
+      if (!workflows || workflows.length === 0) {
+        console.log(chalk4.yellow("\n\uC6CC\uD06C\uD50C\uB85C\uC6B0\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.\n"));
+        return;
+      }
+      printHeader(`\uC6CC\uD06C\uD50C\uB85C\uC6B0 \uBAA9\uB85D (${workflows.length}\uAC1C)`);
+      console.log();
+      printTable(
+        ["#", "ID", "\uC774\uB984"],
+        workflows.map((w, i) => [
+          String(i + 1),
+          (w.workflow_id ?? w.id ?? "-").slice(0, 12),
+          w.workflow_name ?? "-"
+        ])
+      );
+    }
+    console.log();
+  } catch (err) {
+    const msg = err.message;
+    printError(`\uC6CC\uD06C\uD50C\uB85C\uC6B0 \uBAA9\uB85D \uC870\uD68C \uC2E4\uD328: ${msg}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/workflow/info.ts
+init_store();
+import chalk5 from "chalk";
+async function workflowInfo(workflowId) {
+  requireAuth();
+  try {
+    const detail = await getWorkflowDetail(workflowId);
+    printHeader(`\uC6CC\uD06C\uD50C\uB85C\uC6B0: ${detail.workflow_name ?? workflowId}`);
+    console.log();
+    printKeyValue("ID", detail.id);
+    printKeyValue("\uC774\uB984", detail.workflow_name);
+    printKeyValue("\uC124\uBA85", detail.description ?? "(\uC5C6\uC74C)");
+    if (detail.nodes && Array.isArray(detail.nodes)) {
+      console.log();
+      console.log(chalk5.bold("  \uB178\uB4DC \uAD6C\uC131:"));
+      for (const node of detail.nodes) {
+        const label = node.data?.label ?? node.id;
+        const type = node.data?.type ?? "unknown";
+        console.log(`    ${chalk5.cyan("\u2022")} ${label} ${chalk5.gray(`(${type})`)}`);
+      }
+    }
+    if (detail.parameters && Object.keys(detail.parameters).length > 0) {
+      console.log();
+      console.log(chalk5.bold("  \uD30C\uB77C\uBBF8\uD130:"));
+      for (const [key, val] of Object.entries(detail.parameters)) {
+        console.log(`    ${chalk5.gray(key)}: ${JSON.stringify(val)}`);
+      }
+    }
+    console.log();
+  } catch (err) {
+    const msg = err.message;
+    printError(`\uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC870\uD68C \uC2E4\uD328: ${msg}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/workflow/run.ts
+init_store();
+import chalk7 from "chalk";
+import { randomUUID } from "crypto";
+
+// src/utils/sse.ts
+async function parseSSEStream(stream, onEvent, onDone, onError) {
+  let buffer = "";
+  return new Promise((resolve, reject) => {
+    stream.on("data", (chunk) => {
+      buffer += chunk.toString();
+      const parts = buffer.split("\n\n");
+      buffer = parts.pop() ?? "";
+      for (const part of parts) {
+        const lines = part.split("\n");
+        let data = "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            data += line.slice(6);
+          } else if (line.startsWith("data:")) {
+            data += line.slice(5);
+          }
+        }
+        if (!data) continue;
+        try {
+          const event = JSON.parse(data);
+          onEvent(event);
+        } catch {
+          onEvent({ type: "token", content: data });
+        }
+      }
+    });
+    stream.on("end", () => {
+      if (buffer.trim()) {
+        const lines = buffer.split("\n");
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            try {
+              const event = JSON.parse(line.slice(6));
+              onEvent(event);
+            } catch {
+              onEvent({ type: "token", content: line.slice(6) });
+            }
+          }
+        }
+      }
+      onDone?.();
+      resolve();
+    });
+    stream.on("error", (err) => {
+      onError?.(err);
+      reject(err);
+    });
+  });
+}
+
+// src/utils/markdown.ts
+import chalk6 from "chalk";
+var CODE_BLOCK_RE = /```(\w*)\n([\s\S]*?)```/g;
+var INLINE_CODE_RE = /`([^`]+)`/g;
+var BOLD_RE = /\*\*(.+?)\*\*/g;
+var HEADING_RE = /^(#{1,3})\s+(.+)$/gm;
+var LIST_RE = /^(\s*)[-*]\s+(.+)$/gm;
+var LINK_RE = /\[([^\]]+)\]\(([^)]+)\)/g;
+function renderMarkdown(text) {
+  let result = text;
+  result = result.replace(CODE_BLOCK_RE, (_match, lang, code) => {
+    const trimmed = code.trimEnd();
+    const header = lang ? chalk6.gray(`  \u2500\u2500 ${lang} \u2500\u2500`) : chalk6.gray("  \u2500\u2500 code \u2500\u2500");
+    const lines = trimmed.split("\n").map((l) => chalk6.white(`  ${l}`)).join("\n");
+    return `
+${header}
+${lines}
+${chalk6.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}
+`;
+  });
+  result = result.replace(INLINE_CODE_RE, (_m, code) => chalk6.cyan(`\`${code}\``));
+  result = result.replace(BOLD_RE, (_m, text2) => chalk6.bold(text2));
+  result = result.replace(HEADING_RE, (_m, hashes, text2) => {
+    if (hashes.length === 1) return chalk6.bold.underline(text2);
+    if (hashes.length === 2) return chalk6.bold(text2);
+    return chalk6.bold.dim(text2);
+  });
+  result = result.replace(LIST_RE, (_m, indent, text2) => `${indent}${chalk6.cyan("\u2022")} ${text2}`);
+  result = result.replace(LINK_RE, (_m, label, url) => `${chalk6.blue.underline(label)} ${chalk6.gray(`(${url})`)}`);
+  return result;
+}
+
+// src/commands/workflow/run.ts
+async function workflowRun(workflowId, input, opts) {
+  const auth = requireAuth();
+  let workflowName = workflowId;
+  try {
+    const detail = await getWorkflowDetail(workflowId);
+    workflowName = detail.workflow_name ?? workflowId;
+  } catch {
+  }
+  if (!input) {
+    if (opts.interactive || !process.stdin.isTTY) {
+      const { createInterface: createInterface7 } = await import("readline");
+      const rl = createInterface7({ input: process.stdin, output: process.stdout });
+      input = await new Promise((resolve) => {
+        rl.question(chalk7.cyan("\uC785\uB825> "), (answer) => {
+          rl.close();
+          resolve(answer.trim());
+        });
+      });
+    } else {
+      printError("\uC785\uB825\uAC12\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. \uC0AC\uC6A9\uBC95:");
+      console.log('  xgen workflow run <id> "\uC785\uB825 \uD14D\uC2A4\uFFFD\uFFFD\uFFFD"');
+      console.log("  xgen workflow run -i <id>");
+      process.exit(1);
+    }
+  }
+  if (!input) {
+    printError("\uC785\uB825\uAC12\uC774 \uBE44\uC5B4\uC788\uC2B5\uB2C8\uB2E4");
+    process.exit(1);
+  }
+  const interactionId = `cli_${randomUUID().slice(0, 8)}`;
+  printHeader(`\uC2E4\uD589: ${workflowName}`);
+  printInfo(`\uC785\uB825: ${input}`);
+  console.log();
+  try {
+    const stream = await executeWorkflowStream({
+      workflow_id: workflowId,
+      workflow_name: workflowName,
+      input_data: input,
+      interaction_id: interactionId
+    });
+    let hasOutput = false;
+    let fullResponse = "";
+    await parseSSEStream(
+      stream,
+      (event) => {
+        switch (event.type) {
+          case "token":
+            if (event.content) {
+              if (!hasOutput) {
+                hasOutput = true;
+                console.log();
+              }
+              process.stdout.write(event.content);
+              fullResponse += event.content;
+            }
+            break;
+          case "log":
+            if (opts.logs && event.content) {
+              process.stderr.write(chalk7.gray(`[LOG] ${event.content}
+`));
+            }
+            break;
+          case "node_status":
+            if (opts.logs) {
+              const nodeName = event.node_name ?? event.node_id ?? "?";
+              const status = event.status ?? "?";
+              process.stderr.write(
+                chalk7.gray(`[\uB178\uB4DC] ${nodeName}: ${status}
+`)
+              );
+            }
+            break;
+          case "tool":
+            if (opts.logs) {
+              process.stderr.write(chalk7.gray(`[\uB3C4\uAD6C] ${JSON.stringify(event.data)}
+`));
+            }
+            break;
+          case "complete":
+            break;
+          case "error":
+            console.log();
+            printError(event.error ?? event.content ?? "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958");
+            break;
+          default:
+            if (event.content) {
+              if (!hasOutput) {
+                process.stdout.write(chalk7.green("\uC751\uB2F5: "));
+                hasOutput = true;
+              }
+              process.stdout.write(event.content);
+            }
+        }
+      },
+      () => {
+        if (hasOutput) {
+          console.log();
+          if (fullResponse.includes("```") || fullResponse.includes("**")) {
+            console.log(chalk7.gray("\u2500".repeat(40)));
+            console.log(renderMarkdown(fullResponse));
+          }
+        }
+        console.log();
+        console.log(chalk7.gray(`\uC138\uC158: ${interactionId}`));
+      },
+      (err) => {
+        console.log();
+        printError(`\uC2A4\uD2B8\uB9AC\uBC0D \uC624\uB958: ${err.message}`);
+      }
+    );
+  } catch (err) {
+    const msg = err?.response?.data?.detail ?? err.message;
+    printError(`\uC2E4\uD589 \uC2E4\uD328: ${msg}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/workflow/history.ts
+init_store();
+import chalk8 from "chalk";
+async function workflowHistory(workflowId, opts = {}) {
+  requireAuth();
+  const limit = opts.limit ?? 20;
+  try {
+    const logs = await getIOLogs(workflowId, limit);
+    if (!logs || logs.length === 0) {
+      console.log(chalk8.yellow("\n\uC2E4\uD589 \uC774\uB825\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.\n"));
+      return;
+    }
+    printHeader(`\uC2E4\uD589 \uC774\uB825 (\uCD5C\uADFC ${logs.length}\uAC74)`);
+    console.log();
+    for (const log of logs) {
+      console.log(
+        `  ${chalk8.gray(formatDate(log.created_at))} ${chalk8.cyan(log.interaction_id)}`
+      );
+      console.log(`    ${chalk8.white("\uC785\uB825:")} ${truncate(log.input_data, 60)}`);
+      console.log(
+        `    ${chalk8.green("\uCD9C\uB825:")} ${truncate(log.output_data, 60)}`
+      );
+      if (log.execution_time) {
+        console.log(
+          `    ${chalk8.gray("\uC2DC\uAC04:")} ${(log.execution_time / 1e3).toFixed(1)}s`
+        );
+      }
+      console.log();
+    }
+  } catch (err) {
+    const msg = err.message;
+    printError(`\uC774\uB825 \uC870\uD68C \uC2E4\uD328: ${msg}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/workflow/index.ts
+function registerWorkflowCommand(program2) {
+  const wf = program2.command("workflow").alias("wf").description("\uC6CC\uD06C\uD50C\uB85C\uC6B0 \uAD00\uB9AC \uBC0F \uC2E4\uD589");
+  wf.command("list").alias("ls").description("\uC6CC\uD06C\uD50C\uB85C\uC6B0 \uBAA9\uB85D \uC870\uD68C").option("-d, --detail", "\uC0C1\uC138 \uC815\uBCF4 \uD3EC\uD568").action((opts) => workflowList(opts));
+  wf.command("info <workflow-id>").description("\uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC0C1\uC138 \uC815\uBCF4").action((id) => workflowInfo(id));
+  wf.command("run <workflow-id> [input]").description("\uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC2E4\uD589").option("-i, --interactive", "\uC778\uD130\uB799\uD2F0\uBE0C \uBAA8\uB4DC (\uC785\uB825 \uD504\uB86C\uD504\uD2B8)").option("-l, --logs", "\uB514\uBC84\uADF8 \uB85C\uADF8 \uD45C\uC2DC").action((id, input, opts) => workflowRun(id, input, opts));
+  wf.command("history [workflow-id]").description("\uC2E4\uD589 \uC774\uB825 \uC870\uD68C").option("-n, --limit <number>", "\uC870\uD68C \uAC74\uC218", "20").action((id, opts) => workflowHistory(id, { limit: parseInt(opts.limit) }));
+}
+
+// src/commands/chat.ts
+init_store();
+import chalk9 from "chalk";
+import { createInterface as createInterface2 } from "readline";
+import { randomUUID as randomUUID2 } from "crypto";
+var CHAT_BANNER = `
+${chalk9.cyan("\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E")}
+${chalk9.cyan("\u2502")} ${chalk9.white.bold("XGEN")} ${chalk9.gray("\u2014 \uC6CC\uD06C\uD50C\uB85C\uC6B0 AI \uD130\uBBF8\uB110")}          ${chalk9.cyan("\u2502")}
+${chalk9.cyan("\u2502")} ${chalk9.gray("/help \uB3C4\uC6C0\uB9D0  /workflows \uC804\uD658  /exit")} ${chalk9.cyan("\u2502")}
+${chalk9.cyan("\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F")}`;
+function printHelp() {
+  console.log(`
+${chalk9.bold("\uC2AC\uB798\uC2DC \uCEE4\uB9E8\uB4DC")}
+  ${chalk9.cyan("/workflows")}    \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uBAA9\uB85D \uBCF4\uAE30 & \uC804\uD658
+  ${chalk9.cyan("/switch")}       \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uBC88\uD638\uB85C \uC804\uD658 (\uC608: /switch 3)
+  ${chalk9.cyan("/history")}      \uD604\uC7AC \uC138\uC158 \uB300\uD654 \uC774\uB825
+  ${chalk9.cyan("/clear")}        \uD654\uBA74 \uC9C0\uC6B0\uAE30
+  ${chalk9.cyan("/info")}         \uD604\uC7AC \uC5F0\uACB0 \uC815\uBCF4
+  ${chalk9.cyan("/help")}         \uC774 \uB3C4\uC6C0\uB9D0
+  ${chalk9.cyan("/exit")}         \uC885\uB8CC (Ctrl+C\uB3C4 \uAC00\uB2A5)
+`);
+}
+async function promptLine(rl, promptStr) {
+  return new Promise((resolve) => {
+    rl.question(promptStr, (answer) => resolve(answer));
+  });
+}
+async function chat(workflowId) {
+  const auth = requireAuth();
+  const server = getServer();
+  let workflows = [];
+  try {
+    workflows = await listWorkflows();
+  } catch {
+    printError("\uC6CC\uD06C\uD50C\uB85C\uC6B0 \uBAA9\uB85D\uC744 \uBD88\uB7EC\uC62C \uC218 \uC5C6\uC2B5\uB2C8\uB2E4");
+    process.exit(1);
+  }
+  if (workflows.length === 0) {
+    printError("\uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uC6CC\uD06C\uD50C\uB85C\uC6B0\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4");
+    process.exit(1);
+  }
+  let current;
+  if (workflowId) {
+    const found = workflows.find((w) => w.id === workflowId || w.workflow_name === workflowId);
+    current = found ?? { id: workflowId, workflow_name: workflowId };
+  } else {
+    console.log(CHAT_BANNER);
+    console.log(chalk9.gray(`  \uC11C\uBC84: ${server}  |  \uC0AC\uC6A9\uC790: ${auth.username}
+`));
+    console.log(chalk9.bold("  \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC120\uD0DD:\n"));
+    workflows.forEach((w, i) => {
+      console.log(`  ${chalk9.cyan(String(i + 1).padStart(3))}  ${w.workflow_name}`);
+    });
+    console.log();
+    const rl2 = createInterface2({ input: process.stdin, output: process.stdout });
+    const answer = await promptLine(rl2, chalk9.cyan("  \uBC88\uD638> "));
+    rl2.close();
+    const idx = parseInt(answer.trim()) - 1;
+    if (isNaN(idx) || idx < 0 || idx >= workflows.length) {
+      current = workflows[0];
+    } else {
+      current = workflows[idx];
+    }
+  }
+  const sessionId = randomUUID2().slice(0, 8);
+  let turnCount = 0;
+  const history = [];
+  console.log();
+  console.log(chalk9.cyan("\u2500".repeat(42)));
+  console.log(chalk9.white.bold(`  ${current.workflow_name}`));
+  console.log(chalk9.cyan("\u2500".repeat(42)));
+  console.log(chalk9.gray("  \uBA54\uC2DC\uC9C0\uB97C \uC785\uB825\uD558\uC138\uC694. /help \uB85C \uB3C4\uC6C0\uB9D0.\n"));
+  const rl = createInterface2({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const getPrompt = () => chalk9.cyan("\u276F ");
+  const processInput = async (line) => {
+    const input = line.trim();
+    if (!input) return;
+    if (input.startsWith("/")) {
+      const [cmd, ...args] = input.slice(1).split(" ");
+      switch (cmd.toLowerCase()) {
+        case "exit":
+        case "quit":
+        case "q":
+          console.log(chalk9.gray("\n  \uC885\uB8CC\uD569\uB2C8\uB2E4.\n"));
+          rl.close();
+          process.exit(0);
+          break;
+        case "help":
+        case "h":
+          printHelp();
+          break;
+        case "clear":
+        case "cls":
+          console.clear();
+          console.log(chalk9.white.bold(`  ${current.workflow_name}`));
+          console.log(chalk9.cyan("\u2500".repeat(42)));
+          break;
+        case "workflows":
+        case "wf":
+          console.log();
+          workflows.forEach((w, i) => {
+            const marker = w.id === current.id ? chalk9.green("\u25B8") : " ";
+            console.log(`  ${marker} ${chalk9.cyan(String(i + 1).padStart(2))}  ${w.workflow_name}`);
+          });
+          console.log(chalk9.gray("\n  /switch <\uBC88\uD638> \uB85C \uC804\uD658\n"));
+          break;
+        case "switch":
+        case "sw": {
+          const num = parseInt(args[0]);
+          if (isNaN(num) || num < 1 || num > workflows.length) {
+            console.log(chalk9.yellow(`  1~${workflows.length} \uC0AC\uC774 \uBC88\uD638\uB97C \uC785\uB825\uD558\uC138\uC694`));
+          } else {
+            current = workflows[num - 1];
+            turnCount = 0;
+            history.length = 0;
+            console.log(chalk9.green(`
+  \uC804\uD658: ${current.workflow_name}
+`));
+          }
+          break;
+        }
+        case "history":
+        case "hist":
+          if (history.length === 0) {
+            console.log(chalk9.gray("  \uB300\uD654 \uC774\uB825\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.\n"));
+          } else {
+            console.log();
+            for (const h of history) {
+              const label = h.role === "user" ? chalk9.cyan("\uB098") : chalk9.green("AI");
+              const text = h.content.length > 80 ? h.content.slice(0, 80) + "..." : h.content;
+              console.log(`  ${label}: ${text}`);
+            }
+            console.log();
+          }
+          break;
+        case "info":
+          console.log(`
+  ${chalk9.gray("\uC11C\uBC84:")}     ${server}
+  ${chalk9.gray("\uC0AC\uC6A9\uC790:")}   ${auth.username}
+  ${chalk9.gray("\uC6CC\uD06C\uD50C\uB85C\uC6B0:")} ${current.workflow_name}
+  ${chalk9.gray("\uC138\uC158:")}     ${sessionId}
+  ${chalk9.gray("\uD134:")}       ${turnCount}
+`);
+          break;
+        default:
+          console.log(chalk9.yellow(`  \uC54C \uC218 \uC5C6\uB294 \uCEE4\uB9E8\uB4DC: /${cmd}. /help \uCC38\uACE0`));
+      }
+      rl.prompt();
+      return;
+    }
+    turnCount++;
+    const interactionId = `${sessionId}_t${turnCount}`;
+    history.push({ role: "user", content: input });
+    process.stdout.write(chalk9.gray("  thinking..."));
+    try {
+      const stream = await executeWorkflowStream({
+        workflow_id: current.id,
+        workflow_name: current.workflow_name,
+        input_data: input,
+        interaction_id: interactionId
+      });
+      process.stdout.write("\r" + " ".repeat(20) + "\r");
+      let fullResponse = "";
+      let hasOutput = false;
+      await parseSSEStream(
+        stream,
+        (event) => {
+          if ((event.type === "token" || !event.type) && event.content) {
+            if (!hasOutput) {
+              hasOutput = true;
+              console.log();
+            }
+            process.stdout.write(event.content);
+            fullResponse += event.content;
+          } else if (event.type === "error") {
+            process.stdout.write("\r" + " ".repeat(20) + "\r");
+            printError(event.error ?? event.content ?? "\uC624\uB958");
+          }
+        },
+        () => {
+          if (hasOutput) {
+            console.log();
+            console.log();
+          }
+          if (fullResponse) {
+            history.push({ role: "assistant", content: fullResponse });
+          }
+        },
+        (err) => {
+          process.stdout.write("\r" + " ".repeat(20) + "\r");
+          printError(`\uC2A4\uD2B8\uB9AC\uBC0D \uC624\uB958: ${err.message}`);
+        }
+      );
+    } catch (err) {
+      process.stdout.write("\r" + " ".repeat(20) + "\r");
+      const msg = err?.response?.data?.detail ?? err.message;
+      printError(`\uC2E4\uD589 \uC2E4\uD328: ${msg}`);
+    }
+    rl.prompt();
+  };
+  rl.setPrompt(getPrompt());
+  rl.prompt();
+  rl.on("line", (line) => {
+    processInput(line).then(() => {
+    });
+  });
+  rl.on("close", () => {
+    console.log(chalk9.gray("\n  \uC885\uB8CC\uD569\uB2C8\uB2E4.\n"));
+    process.exit(0);
+  });
+  process.on("SIGINT", () => {
+    console.log(chalk9.gray("\n  \uC885\uB8CC\uD569\uB2C8\uB2E4.\n"));
+    process.exit(0);
+  });
+}
+function registerChatCommand(program2) {
+  program2.command("chat [workflow-id]").description("\uC778\uD130\uB799\uD2F0\uBE0C \uB300\uD654 \uBAA8\uB4DC").action((workflowId) => chat(workflowId));
+}
+
+// src/commands/provider.ts
+init_store();
+import chalk10 from "chalk";
+import { createInterface as createInterface3 } from "readline";
+function prompt2(question) {
+  return new Promise((resolve) => {
+    const rl = createInterface3({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+var PROVIDER_PRESETS = {
+  openai: { defaultModel: "gpt-4o-mini" },
+  gemini: { baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai", defaultModel: "gemini-2.0-flash" },
+  ollama: { baseUrl: "http://localhost:11434/v1", defaultModel: "llama3.1" },
+  anthropic: { baseUrl: "https://api.anthropic.com/v1", defaultModel: "claude-sonnet-4-20250514" },
+  custom: { defaultModel: "gpt-4o-mini" }
+};
+function registerProviderCommand(program2) {
+  const prov = program2.command("provider").description("AI \uD504\uB85C\uBC14\uC774\uB354 \uAD00\uB9AC");
+  prov.command("add").description("\uD504\uB85C\uBC14\uC774\uB354 \uCD94\uAC00 (\uB300\uD654\uD615)").action(async () => {
+    printHeader("\uD504\uB85C\uBC14\uC774\uB354 \uCD94\uAC00");
+    console.log();
+    const types = Object.keys(PROVIDER_PRESETS);
+    console.log(chalk10.gray("\uC9C0\uC6D0 \uD0C0\uC785:"), types.join(", "));
+    const type = await prompt2(chalk10.white("\uD0C0\uC785: "));
+    if (!types.includes(type)) {
+      printError(`\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD0C0\uC785: ${type}`);
+      process.exit(1);
+    }
+    const preset = PROVIDER_PRESETS[type];
+    const name = await prompt2(chalk10.white("\uC774\uB984 (\uD45C\uC2DC\uC6A9): ")) || type;
+    const id = name.toLowerCase().replace(/[^a-z0-9]/g, "-");
+    let baseUrl = preset.baseUrl;
+    if (type === "custom" || type === "ollama") {
+      const input = await prompt2(chalk10.white(`Base URL [${preset.baseUrl ?? ""}]: `));
+      if (input) baseUrl = input;
+    }
+    let apiKey = "";
+    if (type !== "ollama") {
+      apiKey = await prompt2(chalk10.white("API Key: "));
+      if (!apiKey) {
+        printError("API Key\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4");
+        process.exit(1);
+      }
+    }
+    const model = await prompt2(chalk10.white(`\uBAA8\uB378 [${preset.defaultModel}]: `)) || preset.defaultModel;
+    const provider = { id, name, type, baseUrl, apiKey, model };
+    addProvider(provider);
+    console.log();
+    printSuccess(`\uD504\uB85C\uBC14\uC774\uB354 \uCD94\uAC00 \uC644\uB8CC: ${chalk10.bold(name)} (${model})`);
+  });
+  prov.command("list").alias("ls").description("\uD504\uB85C\uBC14\uC774\uB354 \uBAA9\uB85D").action(() => {
+    const providers = getProviders();
+    const defaultP = getDefaultProvider();
+    if (providers.length === 0) {
+      console.log(chalk10.yellow("\n\uD504\uB85C\uBC14\uC774\uB354\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. xgen provider add \uB85C \uCD94\uAC00\uD558\uC138\uC694.\n"));
+      return;
+    }
+    printHeader(`\uD504\uB85C\uBC14\uC774\uB354 (${providers.length}\uAC1C)`);
+    console.log();
+    printTable(
+      ["", "ID", "\uC774\uB984", "\uD0C0\uC785", "\uBAA8\uB378"],
+      providers.map((p) => [
+        p.id === defaultP?.id ? chalk10.green("\u25CF") : " ",
+        p.id,
+        p.name,
+        p.type,
+        p.model
+      ])
+    );
+    console.log();
+  });
+  prov.command("remove <id>").description("\uD504\uB85C\uBC14\uC774\uB354 \uC81C\uAC70").action((id) => {
+    if (removeProvider(id)) {
+      printSuccess(`\uD504\uB85C\uBC14\uC774\uB354 \uC81C\uAC70: ${id}`);
+    } else {
+      printError(`\uD504\uB85C\uBC14\uC774\uB354\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${id}`);
+    }
+  });
+  prov.command("use <id>").description("\uAE30\uBCF8 \uD504\uB85C\uBC14\uC774\uB354 \uC124\uC815").action((id) => {
+    if (setDefaultProvider(id)) {
+      printSuccess(`\uAE30\uBCF8 \uD504\uB85C\uBC14\uC774\uB354: ${id}`);
+    } else {
+      printError(`\uD504\uB85C\uBC14\uC774\uB354\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${id}`);
+    }
+  });
+}
+
+// src/commands/agent.ts
+init_store();
+import chalk11 from "chalk";
+import { createInterface as createInterface5 } from "readline";
+
+// src/agent/llm.ts
+import OpenAI from "openai";
+function createLLMClient(provider) {
+  const opts = {
+    apiKey: provider.apiKey || "ollama"
+  };
+  if (provider.baseUrl) {
+    opts.baseURL = provider.baseUrl;
+  }
+  return new OpenAI(opts);
+}
+async function streamChat(client2, model, messages, tools2, onDelta) {
+  const params = {
+    model,
+    messages,
+    stream: true
+  };
+  if (tools2 && tools2.length > 0) {
+    params.tools = tools2;
+  }
+  const stream = await client2.chat.completions.create(params);
+  let content = "";
+  const toolCallMap = /* @__PURE__ */ new Map();
+  for await (const chunk of stream) {
+    const delta = chunk.choices[0]?.delta;
+    if (!delta) continue;
+    if (delta.content) {
+      content += delta.content;
+      onDelta?.(delta.content);
+    }
+    if (delta.tool_calls) {
+      for (const tc of delta.tool_calls) {
+        const idx = tc.index;
+        if (!toolCallMap.has(idx)) {
+          toolCallMap.set(idx, { id: tc.id ?? "", name: tc.function?.name ?? "", arguments: "" });
+        }
+        const entry = toolCallMap.get(idx);
+        if (tc.id) entry.id = tc.id;
+        if (tc.function?.name) entry.name = tc.function.name;
+        if (tc.function?.arguments) entry.arguments += tc.function.arguments;
+      }
+    }
+  }
+  return {
+    content,
+    toolCalls: [...toolCallMap.values()]
+  };
+}
+
+// src/agent/tools/file-read.ts
+var file_read_exports = {};
+__export(file_read_exports, {
+  definition: () => definition,
+  execute: () => execute
+});
+import { readFileSync as readFileSync2 } from "fs";
+var definition = {
+  type: "function",
+  function: {
+    name: "file_read",
+    description: "\uD30C\uC77C \uB0B4\uC6A9\uC744 \uC77D\uC2B5\uB2C8\uB2E4. \uC904 \uBC88\uD638\uAC00 \uD3EC\uD568\uB429\uB2C8\uB2E4.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "\uD30C\uC77C \uACBD\uB85C" },
+        start_line: { type: "number", description: "\uC2DC\uC791 \uC904 \uBC88\uD638 (\uC120\uD0DD)" },
+        end_line: { type: "number", description: "\uB05D \uC904 \uBC88\uD638 (\uC120\uD0DD)" }
+      },
+      required: ["path"]
+    }
+  }
+};
+async function execute(args) {
+  const path = args.path;
+  const startLine = args.start_line || 1;
+  const endLine = args.end_line;
+  try {
+    const content = readFileSync2(path, "utf-8");
+    const lines = content.split("\n");
+    const sliced = lines.slice(startLine - 1, endLine ?? lines.length);
+    return sliced.map((line, i) => `${startLine + i}	${line}`).join("\n");
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
+}
+
+// src/agent/tools/file-write.ts
+var file_write_exports = {};
+__export(file_write_exports, {
+  definition: () => definition2,
+  execute: () => execute2
+});
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname } from "path";
+var definition2 = {
+  type: "function",
+  function: {
+    name: "file_write",
+    description: "\uD30C\uC77C\uC744 \uC0DD\uC131\uD558\uAC70\uB098 \uB36E\uC5B4\uC501\uB2C8\uB2E4.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "\uD30C\uC77C \uACBD\uB85C" },
+        content: { type: "string", description: "\uD30C\uC77C \uB0B4\uC6A9" }
+      },
+      required: ["path", "content"]
+    }
+  }
+};
+async function execute2(args) {
+  const path = args.path;
+  const content = args.content;
+  try {
+    mkdirSync2(dirname(path), { recursive: true });
+    writeFileSync2(path, content, "utf-8");
+    return `\uD30C\uC77C \uC791\uC131 \uC644\uB8CC: ${path}`;
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
+}
+
+// src/agent/tools/file-edit.ts
+var file_edit_exports = {};
+__export(file_edit_exports, {
+  definition: () => definition3,
+  execute: () => execute3
+});
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+var definition3 = {
+  type: "function",
+  function: {
+    name: "file_edit",
+    description: "\uD30C\uC77C\uC5D0\uC11C \uD2B9\uC815 \uD14D\uC2A4\uD2B8\uB97C \uCC3E\uC544 \uAD50\uCCB4\uD569\uB2C8\uB2E4.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "\uD30C\uC77C \uACBD\uB85C" },
+        old_text: { type: "string", description: "\uAD50\uCCB4\uD560 \uAE30\uC874 \uD14D\uC2A4\uD2B8" },
+        new_text: { type: "string", description: "\uC0C8 \uD14D\uC2A4\uD2B8" }
+      },
+      required: ["path", "old_text", "new_text"]
+    }
+  }
+};
+async function execute3(args) {
+  const path = args.path;
+  const oldText = args.old_text;
+  const newText = args.new_text;
+  try {
+    const content = readFileSync3(path, "utf-8");
+    if (!content.includes(oldText)) {
+      return `Error: \uD14D\uC2A4\uD2B8\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4`;
+    }
+    const updated = content.replace(oldText, newText);
+    writeFileSync3(path, updated, "utf-8");
+    return `\uD30C\uC77C \uC218\uC815 \uC644\uB8CC: ${path}`;
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
+}
+
+// src/agent/tools/bash.ts
+var bash_exports = {};
+__export(bash_exports, {
+  definition: () => definition4,
+  execute: () => execute4
+});
+import { execSync } from "child_process";
+var definition4 = {
+  type: "function",
+  function: {
+    name: "bash",
+    description: "\uC178 \uBA85\uB839\uC5B4\uB97C \uC2E4\uD589\uD569\uB2C8\uB2E4. stdout + stderr\uB97C \uBC18\uD658\uD569\uB2C8\uB2E4.",
+    parameters: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "\uC2E4\uD589\uD560 \uBA85\uB839\uC5B4" }
+      },
+      required: ["command"]
+    }
+  }
+};
+async function execute4(args) {
+  const command = args.command;
+  try {
+    const output = execSync(command, {
+      encoding: "utf-8",
+      timeout: 3e4,
+      maxBuffer: 1024 * 1024,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return output || "(no output)";
+  } catch (err) {
+    const e = err;
+    return (e.stdout || "") + (e.stderr || "") || `Error: ${e.message}`;
+  }
+}
+
+// src/agent/tools/grep.ts
+var grep_exports = {};
+__export(grep_exports, {
+  definition: () => definition5,
+  execute: () => execute5
+});
+import { execSync as execSync2 } from "child_process";
+var definition5 = {
+  type: "function",
+  function: {
+    name: "grep",
+    description: "\uD30C\uC77C\uC5D0\uC11C \uD328\uD134\uC744 \uAC80\uC0C9\uD569\uB2C8\uB2E4 (\uC7AC\uADC0, \uC904 \uBC88\uD638 \uD3EC\uD568).",
+    parameters: {
+      type: "object",
+      properties: {
+        pattern: { type: "string", description: "\uAC80\uC0C9 \uD328\uD134 (\uC815\uADDC\uC2DD)" },
+        path: { type: "string", description: "\uAC80\uC0C9 \uB514\uB809\uD1A0\uB9AC \uB610\uB294 \uD30C\uC77C (\uAE30\uBCF8: .)" },
+        glob: { type: "string", description: "\uD30C\uC77C \uD544\uD130 (\uC608: *.ts)" }
+      },
+      required: ["pattern"]
+    }
+  }
+};
+async function execute5(args) {
+  const pattern = args.pattern;
+  const path = args.path || ".";
+  const glob = args.glob;
+  try {
+    let cmd = `grep -rn --color=never "${pattern.replace(/"/g, '\\"')}" "${path}"`;
+    if (glob) cmd += ` --include="${glob}"`;
+    cmd += " | head -50";
+    const output = execSync2(cmd, {
+      encoding: "utf-8",
+      timeout: 1e4,
+      maxBuffer: 512 * 1024,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return output || "\uC77C\uCE58\uD558\uB294 \uACB0\uACFC \uC5C6\uC74C";
+  } catch {
+    return "\uC77C\uCE58\uD558\uB294 \uACB0\uACFC \uC5C6\uC74C";
+  }
+}
+
+// src/agent/tools/list-files.ts
+var list_files_exports = {};
+__export(list_files_exports, {
+  definition: () => definition6,
+  execute: () => execute6
+});
+import { execSync as execSync3 } from "child_process";
+var definition6 = {
+  type: "function",
+  function: {
+    name: "list_files",
+    description: "\uB514\uB809\uD1A0\uB9AC\uC758 \uD30C\uC77C/\uD3F4\uB354 \uBAA9\uB85D\uC744 \uBC18\uD658\uD569\uB2C8\uB2E4. glob \uD328\uD134 \uC9C0\uC6D0.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "\uB514\uB809\uD1A0\uB9AC \uACBD\uB85C (\uAE30\uBCF8: .)" },
+        pattern: { type: "string", description: "glob \uD328\uD134 (\uC608: **/*.ts)" }
+      }
+    }
+  }
+};
+async function execute6(args) {
+  const path = args.path || ".";
+  const pattern = args.pattern;
+  try {
+    let cmd;
+    if (pattern) {
+      cmd = `find "${path}" -name "${pattern}" -type f | head -100`;
+    } else {
+      cmd = `ls -la "${path}"`;
+    }
+    const output = execSync3(cmd, {
+      encoding: "utf-8",
+      timeout: 1e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return output || "(empty)";
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
+}
+
+// src/agent/tools/sandbox.ts
+var sandbox_exports = {};
+__export(sandbox_exports, {
+  definition: () => definition7,
+  execute: () => execute7
+});
+import { execSync as execSync4 } from "child_process";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4, existsSync as existsSync2, rmSync } from "fs";
+import { join as join2 } from "path";
+import { tmpdir } from "os";
+var SANDBOX_DIR = join2(tmpdir(), "xgen-sandbox");
+function ensureSandbox() {
+  if (!existsSync2(SANDBOX_DIR)) {
+    mkdirSync3(SANDBOX_DIR, { recursive: true });
+  }
+  return SANDBOX_DIR;
+}
+var definition7 = {
+  type: "function",
+  function: {
+    name: "sandbox_run",
+    description: "\uACA9\uB9AC\uB41C \uC0CC\uB4DC\uBC15\uC2A4\uC5D0\uC11C \uCF54\uB4DC\uB97C \uC2E4\uD589\uD569\uB2C8\uB2E4. Node.js \uB610\uB294 Python \uCF54\uB4DC\uB97C \uC548\uC804\uD558\uAC8C \uC2E4\uD589\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4. npm \uD328\uD0A4\uC9C0 \uC124\uCE58\uB3C4 \uAC00\uB2A5\uD569\uB2C8\uB2E4.",
+    parameters: {
+      type: "object",
+      properties: {
+        language: {
+          type: "string",
+          enum: ["javascript", "typescript", "python"],
+          description: "\uC2E4\uD589\uD560 \uC5B8\uC5B4"
+        },
+        code: { type: "string", description: "\uC2E4\uD589\uD560 \uCF54\uB4DC" },
+        packages: {
+          type: "array",
+          items: { type: "string" },
+          description: "\uC124\uCE58\uD560 \uD328\uD0A4\uC9C0 (npm \uB610\uB294 pip)"
+        }
+      },
+      required: ["language", "code"]
+    }
+  }
+};
+async function execute7(args) {
+  const language = args.language;
+  const code = args.code;
+  const packages = args.packages ?? [];
+  const dir = ensureSandbox();
+  const runId = `run_${Date.now()}`;
+  const runDir = join2(dir, runId);
+  mkdirSync3(runDir, { recursive: true });
+  try {
+    if (packages.length > 0) {
+      if (language === "python") {
+        const pkgList = packages.join(" ");
+        execSync4(`pip install ${pkgList}`, {
+          cwd: runDir,
+          encoding: "utf-8",
+          timeout: 6e4,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      } else {
+        execSync4("npm init -y", { cwd: runDir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+        const pkgList = packages.join(" ");
+        execSync4(`npm install ${pkgList}`, {
+          cwd: runDir,
+          encoding: "utf-8",
+          timeout: 6e4,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      }
+    }
+    let cmd;
+    let filename;
+    if (language === "python") {
+      filename = "script.py";
+      writeFileSync4(join2(runDir, filename), code, "utf-8");
+      cmd = `python3 ${filename}`;
+    } else if (language === "typescript") {
+      filename = "script.ts";
+      writeFileSync4(join2(runDir, filename), code, "utf-8");
+      cmd = `npx tsx ${filename}`;
+    } else {
+      filename = "script.mjs";
+      writeFileSync4(join2(runDir, filename), code, "utf-8");
+      cmd = `node ${filename}`;
+    }
+    const output = execSync4(cmd, {
+      cwd: runDir,
+      encoding: "utf-8",
+      timeout: 3e4,
+      maxBuffer: 1024 * 1024,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return output || "(no output)";
+  } catch (err) {
+    const e = err;
+    return (e.stdout || "") + (e.stderr || "") || `Error: ${e.message}`;
+  } finally {
+    try {
+      rmSync(runDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+
+// src/agent/tools/index.ts
+var tools = [file_read_exports, file_write_exports, file_edit_exports, bash_exports, grep_exports, list_files_exports, sandbox_exports];
+var toolMap = /* @__PURE__ */ new Map();
+for (const t of tools) {
+  toolMap.set(t.definition.function.name, t);
+}
+function getAllToolDefs() {
+  return tools.map((t) => t.definition);
+}
+async function executeTool(name, args) {
+  const tool = toolMap.get(name);
+  if (!tool) return `Unknown tool: ${name}`;
+  return tool.execute(args);
+}
+function getToolNames() {
+  return tools.map((t) => t.definition.function.name);
+}
+
+// src/mcp/client.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
+import { join as join3 } from "path";
+import { createInterface as createInterface4 } from "readline";
+var McpClient = class {
+  process = null;
+  requestId = 0;
+  pending = /* @__PURE__ */ new Map();
+  serverName;
+  config;
+  tools = [];
+  constructor(serverName, config) {
+    this.serverName = serverName;
+    this.config = config;
+  }
+  async start() {
+    this.process = spawn(this.config.command, this.config.args ?? [], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...this.config.env }
+    });
+    const rl = createInterface4({ input: this.process.stdout });
+    rl.on("line", (line) => {
+      try {
+        const msg = JSON.parse(line);
+        if (msg.id !== void 0 && this.pending.has(msg.id)) {
+          const p = this.pending.get(msg.id);
+          this.pending.delete(msg.id);
+          if (msg.error) {
+            p.reject(new Error(msg.error.message));
+          } else {
+            p.resolve(msg.result);
+          }
+        }
+      } catch {
+      }
+    });
+    this.process.on("error", (err) => {
+      console.error(`MCP [${this.serverName}] \uD504\uB85C\uC138\uC2A4 \uC624\uB958:`, err.message);
+    });
+    await this.send("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "open-xgen", version: "0.3.0" }
+    });
+    await this.send("notifications/initialized", {});
+  }
+  send(method, params) {
+    return new Promise((resolve, reject) => {
+      const id = ++this.requestId;
+      const request = { jsonrpc: "2.0", id, method, params };
+      this.pending.set(id, { resolve, reject });
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`MCP \uC694\uCCAD \uD0C0\uC784\uC544\uC6C3: ${method}`));
+      }, 15e3);
+      this.pending.set(id, {
+        resolve: (v) => {
+          clearTimeout(timeout);
+          resolve(v);
+        },
+        reject: (e) => {
+          clearTimeout(timeout);
+          reject(e);
+        }
+      });
+      this.process?.stdin?.write(JSON.stringify(request) + "\n");
+    });
+  }
+  async listTools() {
+    const result = await this.send("tools/list", {});
+    this.tools = result.tools ?? [];
+    return this.tools;
+  }
+  async callTool(name, args) {
+    const result = await this.send("tools/call", { name, arguments: args });
+    return result.content?.map((c) => c.text ?? "").join("\n") ?? "";
+  }
+  getOpenAITools() {
+    return this.tools.map((t) => ({
+      type: "function",
+      function: {
+        name: `mcp_${this.serverName}_${t.name}`,
+        description: `[MCP:${this.serverName}] ${t.description ?? t.name}`,
+        parameters: t.inputSchema ?? { type: "object", properties: {} }
+      }
+    }));
+  }
+  stop() {
+    this.process?.kill();
+    this.process = null;
+  }
+};
+function loadMcpConfig(dir) {
+  const searchPaths = [
+    dir ? join3(dir, ".mcp.json") : null,
+    join3(process.cwd(), ".mcp.json"),
+    join3(process.env.HOME ?? "", ".mcp.json")
+  ].filter(Boolean);
+  for (const p of searchPaths) {
+    if (existsSync3(p)) {
+      try {
+        return JSON.parse(readFileSync4(p, "utf-8"));
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+var McpManager = class {
+  clients = /* @__PURE__ */ new Map();
+  async startAll(config) {
+    for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+      if (serverConfig.type !== "stdio") continue;
+      try {
+        const client2 = new McpClient(name, serverConfig);
+        await client2.start();
+        await client2.listTools();
+        this.clients.set(name, client2);
+      } catch (err) {
+        console.error(`MCP [${name}] \uC2DC\uC791 \uC2E4\uD328:`, err.message);
+      }
+    }
+  }
+  getAllTools() {
+    const tools2 = [];
+    for (const client2 of this.clients.values()) {
+      tools2.push(...client2.getOpenAITools());
+    }
+    return tools2;
+  }
+  async callTool(fullName, args) {
+    const parts = fullName.split("_");
+    if (parts.length < 3 || parts[0] !== "mcp") return `Unknown MCP tool: ${fullName}`;
+    const serverName = parts[1];
+    const toolName = parts.slice(2).join("_");
+    const client2 = this.clients.get(serverName);
+    if (!client2) return `MCP \uC11C\uBC84\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${serverName}`;
+    return client2.callTool(toolName, args);
+  }
+  isMcpTool(name) {
+    return name.startsWith("mcp_");
+  }
+  stopAll() {
+    for (const client2 of this.clients.values()) {
+      client2.stop();
+    }
+    this.clients.clear();
+  }
+  get serverCount() {
+    return this.clients.size;
+  }
+  getServerNames() {
+    return [...this.clients.keys()];
+  }
+};
+
+// src/commands/agent.ts
+var SYSTEM_PROMPT = `You are OPEN XGEN Agent, an AI coding assistant running in the user's terminal.
+You have access to tools for reading/writing files, executing commands, searching code, and running sandboxed code.
+You can also use MCP (Model Context Protocol) tools if available.
+Always respond in the same language as the user.
+When using tools, be concise about what you're doing.
+For file edits, show what you changed briefly.
+For sandbox_run, you can install npm/pip packages and run isolated code.`;
+var mcpManager = null;
+async function agentRepl() {
+  const provider = getDefaultProvider();
+  if (!provider) {
+    printError("\uD504\uB85C\uBC14\uC774\uB354\uAC00 \uC124\uC815\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.");
+    console.log(`  ${chalk11.cyan("xgen provider add")}  \uD504\uB85C\uBC14\uC774\uB354 \uCD94\uAC00`);
+    process.exit(1);
+  }
+  const client2 = createLLMClient(provider);
+  const builtinTools = getAllToolDefs();
+  const allTools = [...builtinTools];
+  const allToolNames = [...getToolNames()];
+  const mcpConfig = loadMcpConfig();
+  if (mcpConfig && Object.keys(mcpConfig.mcpServers).length > 0) {
+    mcpManager = new McpManager();
+    try {
+      await mcpManager.startAll(mcpConfig);
+      if (mcpManager.serverCount > 0) {
+        const mcpTools = mcpManager.getAllTools();
+        allTools.push(...mcpTools);
+        allToolNames.push(...mcpTools.map((t) => t.function.name));
+      }
+    } catch {
+    }
+  }
+  const messages = [{ role: "system", content: SYSTEM_PROMPT }];
+  console.log(chalk11.cyan.bold("\n  OPEN XGEN Agent"));
+  console.log(chalk11.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk11.gray(`  \uD504\uB85C\uBC14\uC774\uB354: ${provider.name} (${provider.model})`));
+  console.log(chalk11.gray(`  \uB3C4\uAD6C: ${getToolNames().join(", ")}`));
+  if (mcpManager && mcpManager.serverCount > 0) {
+    console.log(chalk11.gray(`  MCP: ${mcpManager.getServerNames().join(", ")} (${mcpManager.getAllTools().length}\uAC1C \uB3C4\uAD6C)`));
+  }
+  console.log(chalk11.gray(`  \uC885\uB8CC: exit | Ctrl+C`));
+  console.log();
+  const rl = createInterface5({ input: process.stdin, output: process.stdout });
+  const ask = () => new Promise((resolve) => rl.question(chalk11.green("\u276F "), (a) => resolve(a.trim())));
+  process.on("SIGINT", () => {
+    console.log(chalk11.gray("\n\uC885\uB8CC\uD569\uB2C8\uB2E4."));
+    mcpManager?.stopAll();
+    rl.close();
+    process.exit(0);
+  });
+  while (true) {
+    const input = await ask();
+    if (!input) continue;
+    if (input === "exit" || input === "/exit") {
+      console.log(chalk11.gray("\uC885\uB8CC\uD569\uB2C8\uB2E4."));
+      mcpManager?.stopAll();
+      rl.close();
+      break;
+    }
+    if (input === "/clear") {
+      messages.length = 1;
+      console.log(chalk11.gray("\uB300\uD654 \uCD08\uAE30\uD654\uB428.\n"));
+      continue;
+    }
+    if (input === "/tools") {
+      console.log(chalk11.bold("\n\uB0B4\uC7A5 \uB3C4\uAD6C:"), getToolNames().join(", "));
+      if (mcpManager && mcpManager.serverCount > 0) {
+        console.log(chalk11.bold("MCP \uB3C4\uAD6C:"), mcpManager.getAllTools().map((t) => t.function.name).join(", "));
+      }
+      console.log();
+      continue;
+    }
+    if (input === "/provider") {
+      console.log(chalk11.gray(`\uD604\uC7AC: ${provider.name} (${provider.model})
+`));
+      continue;
+    }
+    if (input === "/mcp") {
+      if (mcpManager && mcpManager.serverCount > 0) {
+        console.log(chalk11.bold("\nMCP \uC11C\uBC84:"), mcpManager.getServerNames().join(", "));
+        console.log(chalk11.gray("\uB3C4\uAD6C:"), mcpManager.getAllTools().map((t) => t.function.name).join(", "));
+      } else {
+        console.log(chalk11.gray("MCP \uC11C\uBC84 \uC5C6\uC74C. .mcp.json\uC744 \uD504\uB85C\uC81D\uD2B8 \uB8E8\uD2B8\uC5D0 \uCD94\uAC00\uD558\uC138\uC694."));
+      }
+      console.log();
+      continue;
+    }
+    messages.push({ role: "user", content: input });
+    try {
+      await runAgentLoop(client2, provider.model, messages, allTools);
+    } catch (err) {
+      console.log(chalk11.red(`
+\uC624\uB958: ${err.message}
+`));
+    }
+  }
+}
+async function runAgentLoop(client2, model, messages, tools2) {
+  const MAX_ITERATIONS = 20;
+  for (let i = 0; i < MAX_ITERATIONS; i++) {
+    const result = await streamChat(client2, model, messages, tools2, (delta) => {
+      process.stdout.write(delta);
+    });
+    if (result.content) {
+      process.stdout.write("\n\n");
+    }
+    if (result.toolCalls.length === 0) {
+      if (result.content) {
+        messages.push({ role: "assistant", content: result.content });
+      }
+      return;
+    }
+    messages.push({
+      role: "assistant",
+      content: result.content || null,
+      tool_calls: result.toolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: { name: tc.name, arguments: tc.arguments }
+      }))
+    });
+    for (const tc of result.toolCalls) {
+      let args;
+      try {
+        args = JSON.parse(tc.arguments);
+      } catch {
+        args = {};
+      }
+      console.log(chalk11.gray(`  \u2699 ${tc.name}(`), chalk11.dim(summarizeArgs(args)), chalk11.gray(")"));
+      let toolResult;
+      if (mcpManager?.isMcpTool(tc.name)) {
+        toolResult = await mcpManager.callTool(tc.name, args);
+      } else {
+        toolResult = await executeTool(tc.name, args);
+      }
+      const truncated = toolResult.length > 4e3 ? toolResult.slice(0, 4e3) + "\n...(truncated)" : toolResult;
+      messages.push({
+        role: "tool",
+        tool_call_id: tc.id,
+        content: truncated
+      });
+    }
+  }
+  console.log(chalk11.yellow("\n\uCD5C\uB300 \uBC18\uBCF5 \uD69F\uC218\uC5D0 \uB3C4\uB2EC\uD588\uC2B5\uB2C8\uB2E4.\n"));
+}
+function summarizeArgs(args) {
+  const parts = [];
+  for (const [k, v] of Object.entries(args)) {
+    const s = String(v);
+    parts.push(`${k}: ${s.length > 40 ? s.slice(0, 40) + "..." : s}`);
+  }
+  return parts.join(", ");
+}
+function registerAgentCommand(program2) {
+  program2.command("agent").description("OPEN XGEN AI \uCF54\uB529 \uC5D0\uC774\uC804\uD2B8").action(async () => {
+    await agentRepl();
+  });
+}
+
+// src/commands/doc.ts
+init_store();
+import chalk12 from "chalk";
+
+// src/api/document.ts
+import { createReadStream, statSync } from "fs";
+import { basename } from "path";
+async function listDocuments(collectionId) {
+  const client2 = getClient();
+  const params = {};
+  if (collectionId) params.collection_id = collectionId;
+  const res = await client2.get("/api/documents/list", { params });
+  return res.data.documents ?? res.data ?? [];
+}
+async function uploadDocument(filePath, collectionId, name) {
+  const client2 = getClient();
+  const stat = statSync(filePath);
+  const fileName = name || basename(filePath);
+  const FormData = (await import("buffer")).Blob ? globalThis.FormData : null;
+  if (!FormData) throw new Error("FormData not available");
+  const form = new FormData();
+  const fileBlob = new Blob([createReadStream(filePath)]);
+  form.append("file", fileBlob, fileName);
+  if (collectionId) form.append("collection_id", collectionId);
+  const res = await client2.post("/api/documents/upload", form, {
+    headers: { "Content-Type": "multipart/form-data" },
+    maxBodyLength: stat.size + 1024 * 1024
+  });
+  return res.data;
+}
+async function getDocumentInfo(docId) {
+  const client2 = getClient();
+  const res = await client2.get(`/api/documents/${docId}`);
+  return res.data;
+}
+
+// src/commands/doc.ts
+function registerDocCommand(program2) {
+  const doc = program2.command("doc").description("\uBB38\uC11C \uAD00\uB9AC");
+  doc.command("list").alias("ls").description("\uBB38\uC11C \uBAA9\uB85D \uC870\uD68C").option("-c, --collection <id>", "\uCEEC\uB809\uC158 ID").action(async (opts) => {
+    requireAuth();
+    try {
+      const docs = await listDocuments(opts.collection);
+      if (!docs.length) {
+        console.log(chalk12.yellow("\n\uBB38\uC11C\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.\n"));
+        return;
+      }
+      printHeader(`\uBB38\uC11C \uBAA9\uB85D (${docs.length}\uAC1C)`);
+      console.log();
+      printTable(
+        ["#", "ID", "\uD30C\uC77C\uBA85", "\uD0C0\uC785", "\uC0C1\uD0DC", "\uC0DD\uC131\uC77C"],
+        docs.map((d, i) => [
+          String(i + 1),
+          (d.document_id ?? d.id ?? "-").toString().slice(0, 10),
+          d.file_name ?? d.name ?? "-",
+          d.file_type ?? "-",
+          d.status ?? "-",
+          formatDate(d.created_at)
+        ])
+      );
+      console.log();
+    } catch (err) {
+      printError(`\uBB38\uC11C \uBAA9\uB85D \uC870\uD68C \uC2E4\uD328: ${err.message}`);
+    }
+  });
+  doc.command("upload <file>").description("\uBB38\uC11C \uC5C5\uB85C\uB4DC").option("-c, --collection <id>", "\uCEEC\uB809\uC158 ID").option("-n, --name <name>", "\uD30C\uC77C\uBA85").action(async (file, opts) => {
+    requireAuth();
+    try {
+      console.log(chalk12.gray(`\uC5C5\uB85C\uB4DC \uC911: ${file}`));
+      const result = await uploadDocument(file, opts.collection, opts.name);
+      console.log(chalk12.green("\u2713 \uC5C5\uB85C\uB4DC \uC644\uB8CC"));
+      console.log(chalk12.gray(JSON.stringify(result, null, 2)));
+    } catch (err) {
+      printError(`\uC5C5\uB85C\uB4DC \uC2E4\uD328: ${err.message}`);
+    }
+  });
+  doc.command("info <id>").description("\uBB38\uC11C \uC0C1\uC138 \uC815\uBCF4").action(async (id) => {
+    requireAuth();
+    try {
+      const d = await getDocumentInfo(id);
+      printHeader("\uBB38\uC11C \uC815\uBCF4");
+      console.log(chalk12.gray(JSON.stringify(d, null, 2)));
+    } catch (err) {
+      printError(`\uC870\uD68C \uC2E4\uD328: ${err.message}`);
+    }
+  });
+}
+
+// src/commands/ontology.ts
+init_store();
+import chalk13 from "chalk";
+import { createInterface as createInterface6 } from "readline";
+
+// src/api/ontology.ts
+async function queryGraphRAG(query, graphId, opts) {
+  const client2 = getClient();
+  const res = await client2.post("/api/graph-rag", {
+    query,
+    graph_id: graphId,
+    use_scs: opts?.scs ?? true
+  });
+  return res.data;
+}
+async function queryGraphRAGMultiTurn(query, sessionId, graphId, opts) {
+  const client2 = getClient();
+  const res = await client2.post("/api/graph-rag/multi-turn", {
+    query,
+    session_id: sessionId,
+    graph_id: graphId,
+    max_turns: opts?.maxTurns ?? 5
+  });
+  return res.data;
+}
+async function getGraphStats(graphId) {
+  const client2 = getClient();
+  const res = await client2.get(`/api/graph/${graphId}/stats`);
+  return res.data;
+}
+
+// src/commands/ontology.ts
+import { randomUUID as randomUUID3 } from "crypto";
+function registerOntologyCommand(program2) {
+  const ont = program2.command("ontology").alias("ont").description("\uC628\uD1A8\uB85C\uC9C0 GraphRAG \uC9C8\uC758");
+  ont.command("query <question>").alias("q").description("GraphRAG \uC6D0\uC0F7 \uC9C8\uC758").option("-g, --graph <id>", "\uADF8\uB798\uD504 ID").option("--no-scs", "SCS \uCEE8\uD14D\uC2A4\uD2B8 \uBE44\uD65C\uC131\uD654").action(async (question, opts) => {
+    requireAuth();
+    try {
+      console.log(chalk13.gray("\n\uC9C8\uC758 \uC911...\n"));
+      const result = await queryGraphRAG(question, opts.graph, { scs: opts.scs });
+      if (result.answer) {
+        console.log(chalk13.bold("\uB2F5\uBCC0:"));
+        console.log(result.answer);
+      }
+      if (result.sources?.length) {
+        console.log(chalk13.bold("\n\uCD9C\uCC98:"));
+        result.sources.forEach((s) => console.log(chalk13.gray(`  - ${s}`)));
+      }
+      if (result.triples_used?.length) {
+        console.log(chalk13.bold("\n\uC0AC\uC6A9\uB41C \uD2B8\uB9AC\uD50C:"));
+        result.triples_used.forEach((t) => console.log(chalk13.dim(`  ${t}`)));
+      }
+      console.log();
+    } catch (err) {
+      printError(`\uC9C8\uC758 \uC2E4\uD328: ${err.message}`);
+    }
+  });
+  ont.command("chat").description("\uBA40\uD2F0\uD134 GraphRAG \uB300\uD654").option("-g, --graph <id>", "\uADF8\uB798\uD504 ID").action(async (opts) => {
+    requireAuth();
+    const sessionId = randomUUID3();
+    printHeader("Ontology Chat");
+    console.log(chalk13.gray("\uBA40\uD2F0\uD134 GraphRAG \uB300\uD654. exit\uB85C \uC885\uB8CC.\n"));
+    const rl = createInterface6({ input: process.stdin, output: process.stdout });
+    const ask = () => new Promise((resolve) => rl.question(chalk13.green("\u276F "), (a) => resolve(a.trim())));
+    while (true) {
+      const input = await ask();
+      if (!input) continue;
+      if (input === "exit") {
+        rl.close();
+        break;
+      }
+      try {
+        const result = await queryGraphRAGMultiTurn(input, sessionId, opts.graph);
+        if (result.answer) console.log(`
+${result.answer}
+`);
+      } catch (err) {
+        console.log(chalk13.red(`\uC624\uB958: ${err.message}
+`));
+      }
+    }
+  });
+  ont.command("stats <graph-id>").description("\uADF8\uB798\uD504 \uD1B5\uACC4").action(async (graphId) => {
+    requireAuth();
+    try {
+      const stats = await getGraphStats(graphId);
+      printHeader("\uADF8\uB798\uD504 \uD1B5\uACC4");
+      console.log(chalk13.gray(JSON.stringify(stats, null, 2)));
+      console.log();
+    } catch (err) {
+      printError(`\uD1B5\uACC4 \uC870\uD68C \uC2E4\uD328: ${err.message}`);
+    }
+  });
+}
+
+// src/index.ts
+init_store();
+var VERSION = "0.3.0";
+var LOGO = chalk14.cyan(`
+   \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588\u2588\u2588 \u2588\u2588\u2588    \u2588\u2588
+  \u2588\u2588    \u2588\u2588 \u2588\u2588   \u2588\u2588 \u2588\u2588      \u2588\u2588\u2588\u2588   \u2588\u2588
+  \u2588\u2588    \u2588\u2588 \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588   \u2588\u2588 \u2588\u2588  \u2588\u2588
+  \u2588\u2588    \u2588\u2588 \u2588\u2588      \u2588\u2588      \u2588\u2588  \u2588\u2588 \u2588\u2588
+   \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588      \u2588\u2588\u2588\u2588\u2588\u2588\u2588 \u2588\u2588   \u2588\u2588\u2588\u2588
+`) + chalk14.white.bold(`
+  \u2588\u2588   \u2588\u2588  \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588\u2588\u2588 \u2588\u2588\u2588    \u2588\u2588
+   \u2588\u2588 \u2588\u2588  \u2588\u2588       \u2588\u2588      \u2588\u2588\u2588\u2588   \u2588\u2588
+    \u2588\u2588\u2588   \u2588\u2588   \u2588\u2588\u2588 \u2588\u2588\u2588\u2588\u2588   \u2588\u2588 \u2588\u2588  \u2588\u2588
+   \u2588\u2588 \u2588\u2588  \u2588\u2588    \u2588\u2588 \u2588\u2588      \u2588\u2588  \u2588\u2588 \u2588\u2588
+  \u2588\u2588   \u2588\u2588  \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588\u2588\u2588 \u2588\u2588   \u2588\u2588\u2588\u2588
+`) + chalk14.gray(`                              v${VERSION}
+`);
+var BANNER = LOGO;
+var program = new Command();
+program.name("xgen").description("OPEN XGEN \u2014 AI Coding Agent + XGEN Platform CLI").version(VERSION).addHelpText("before", BANNER).addHelpText(
+  "after",
+  `
+${chalk14.bold("\uC2DC\uC791\uD558\uAE30:")}
+  ${chalk14.cyan("xgen provider add")}               AI \uD504\uB85C\uBC14\uC774\uB354 \uC124\uC815
+  ${chalk14.cyan("xgen agent")}                      AI \uCF54\uB529 \uC5D0\uC774\uC804\uD2B8
+  ${chalk14.cyan("xgen config set-server")} <url>    XGEN \uC11C\uBC84 \uC5F0\uACB0
+  ${chalk14.cyan("xgen login")}                      \uC11C\uBC84 \uB85C\uADF8\uC778
+
+${chalk14.bold("AI \uC5D0\uC774\uC804\uD2B8:")}
+  ${chalk14.cyan("xgen agent")}                      \uCF54\uB529 \uC5D0\uC774\uC804\uD2B8 (\uD30C\uC77C, \uD130\uBBF8\uB110, \uAC80\uC0C9)
+  ${chalk14.cyan("xgen provider ls")}                \uD504\uB85C\uBC14\uC774\uB354 \uBAA9\uB85D
+  ${chalk14.cyan("xgen provider add")}               \uD504\uB85C\uBC14\uC774\uB354 \uCD94\uAC00
+
+${chalk14.bold("XGEN \uD50C\uB7AB\uD3FC:")}
+  ${chalk14.cyan("xgen chat")}                       \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uB300\uD654
+  ${chalk14.cyan("xgen wf ls")}                      \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uBAA9\uB85D
+  ${chalk14.cyan("xgen wf run")} <id> "\uC9C8\uBB38"         \uC6CC\uD06C\uD50C\uB85C\uC6B0 \uC2E4\uD589
+  ${chalk14.cyan("xgen doc ls")}                     \uBB38\uC11C \uBAA9\uB85D
+  ${chalk14.cyan("xgen ont query")} "\uC9C8\uBB38"           \uC628\uD1A8\uB85C\uC9C0 \uC9C8\uC758
+`
+);
+registerConfigCommand(program);
+registerLoginCommand(program);
+registerWorkflowCommand(program);
+registerChatCommand(program);
+registerProviderCommand(program);
+registerAgentCommand(program);
+registerDocCommand(program);
+registerOntologyCommand(program);
+if (process.argv.length <= 2) {
+  const auth = getAuth();
+  const server = getServer();
+  const provider = getDefaultProvider();
+  if (provider) {
+    agentRepl().catch((err) => {
+      console.error(chalk14.red(`\uC624\uB958: ${err.message}`));
+      process.exit(1);
+    });
+  } else if (auth && server) {
+    chat().catch((err) => {
+      console.error(chalk14.red(`\uC624\uB958: ${err.message}`));
+      process.exit(1);
+    });
+  } else {
+    console.log(BANNER);
+    console.log(chalk14.yellow("  \uC124\uC815\uC774 \uD544\uC694\uD569\uB2C8\uB2E4.\n"));
+    console.log(chalk14.bold("  AI \uC5D0\uC774\uC804\uD2B8:"));
+    console.log(`    ${chalk14.cyan("xgen provider add")}    \uD504\uB85C\uBC14\uC774\uB354 \uCD94\uAC00
+`);
+    console.log(chalk14.bold("  XGEN \uD50C\uB7AB\uD3FC:"));
+    console.log(`    ${chalk14.cyan("xgen config set-server")} <url>  \uC11C\uBC84 \uC124\uC815`);
+    console.log(`    ${chalk14.cyan("xgen login")}                   \uB85C\uADF8\uC778
+`);
+  }
+} else {
+  program.parse();
+}
+//# sourceMappingURL=index.js.map