@iqai/adk-cli 0.2.9 → 0.3.0

package/dist/index.mjs

@@ -1,1223 +0,0 @@
-#!/usr/bin/env node
-
-
-// src/index.ts
-import chalk6 from "chalk";
-import { program } from "commander";
-
-// package.json
-var package_default = {
-  name: "@iqai/adk-cli",
-  version: "0.2.9",
-  description: "CLI tool for creating, running, and testing ADK agents",
-  main: "dist/index.js",
-  types: "dist/index.d.ts",
-  bin: {
-    adk: "./dist/index.mjs"
-  },
-  scripts: {
-    build: "tsup",
-    dev: "tsup --watch",
-    test: "vitest run",
-    "test:watch": "vitest"
-  },
-  repository: {
-    type: "git",
-    url: "https://github.com/IQAIcom/adk-ts.git",
-    directory: "packages/adk-cli"
-  },
-  keywords: [
-    "ai",
-    "llm",
-    "agent",
-    "cli",
-    "adk",
-    "typescript"
-  ],
-  author: "IQAI",
-  license: "MIT",
-  dependencies: {
-    "@clack/prompts": "^0.11.0",
-    "@hono/node-server": "^1.18.1",
-    "@iqai/adk": "workspace:*",
-    chalk: "^5.4.1",
-    commander: "^12.1.0",
-    dedent: "^1.6.0",
-    giget: "^2.0.0",
-    hono: "^4.6.13",
-    marked: "^14.1.3",
-    "marked-terminal": "^7.2.1",
-    esbuild: "^0.23.0"
-  },
-  devDependencies: {
-    "@iqai/tsconfig": "workspace:*",
-    "@types/marked-terminal": "^6.1.1",
-    "@types/node": "^20.17.30",
-    tsup: "^8.4.0",
-    typescript: "^5.3.2",
-    vitest: "^3.1.3"
-  },
-  packageManager: "pnpm@9.0.0",
-  engines: {
-    node: ">=22.0"
-  },
-  files: [
-    "dist",
-    "!**/*.test.*",
-    "!**/*.json",
-    "CHANGELOG.md",
-    "LICENSE",
-    "README.md"
-  ],
-  publishConfig: {
-    access: "public"
-  }
-};
-
-// src/commands/new.ts
-import { existsSync } from "fs";
-import { join } from "path";
-import { confirm, intro, outro, select, spinner, text } from "@clack/prompts";
-import chalk from "chalk";
-import dedent from "dedent";
-import { downloadTemplate } from "giget";
-var templates = [
-  {
-    value: "simple-agent",
-    label: "\u{1F916} Simple Agent",
-    hint: "Basic agent with chat capabilities",
-    source: "github:IQAIcom/adk-ts/apps/starter-templates/simple-agent"
-  },
-  {
-    value: "discord-bot",
-    label: "\u{1F3AE} Discord Bot",
-    hint: "Agent integrated with Discord",
-    source: "github:IQAIcom/adk-ts/apps/starter-templates/discord-bot"
-  },
-  {
-    value: "telegram-bot",
-    label: "\u{1F4F1} Telegram Bot",
-    hint: "Agent integrated with Telegram",
-    source: "github:IQAIcom/adk-ts/apps/starter-templates/telegram-bot"
-  },
-  {
-    value: "hono-server",
-    label: "\u{1F680} Hono Server",
-    hint: "Web server with agent endpoints",
-    source: "github:IQAIcom/adk-ts/apps/starter-templates/hono-server"
-  },
-  {
-    value: "shade-agent",
-    label: "\u{1F313} Near Shade Agent",
-    hint: "Starter that uses Near Shade Agent",
-    source: "github:IQAIcom/adk-ts/apps/starter-templates/shade-agent"
-  },
-  {
-    value: "mcp-starter",
-    label: "\u{1F50C} MCP Integration",
-    hint: "Model Context Protocol server",
-    source: "github:IQAIcom/adk-ts/apps/starter-templates/mcp-starter"
-  }
-];
-var packageManagers = [
-  { name: "npm", command: "npm", args: ["install"], label: "\u{1F4E6} npm" },
-  { name: "pnpm", command: "pnpm", args: ["install"], label: "\u26A1 pnpm" },
-  { name: "yarn", command: "yarn", args: ["install"], label: "\u{1F9F6} yarn" },
-  { name: "bun", command: "bun", args: ["install"], label: "\u{1F35E} bun" }
-];
-async function detectAvailablePackageManagers() {
-  const { spawn } = await import("child_process");
-  const available = [];
-  for (const pm of packageManagers) {
-    try {
-      await new Promise((resolve2, reject) => {
-        const child = spawn(pm.command, ["--version"], {
-          stdio: "pipe"
-        });
-        child.on("close", (code) => {
-          if (code === 0) {
-            available.push(pm);
-          }
-          resolve2();
-        });
-        child.on("error", () => resolve2());
-      });
-    } catch {
-    }
-  }
-  return available.length > 0 ? available : [packageManagers[0]];
-}
-async function createProject(projectName, options) {
-  console.clear();
-  intro(chalk.magentaBright("\u{1F9E0} Create new ADK-TS project"));
-  let finalProjectName = projectName;
-  if (!finalProjectName) {
-    const response = await text({
-      message: "What is your project name?",
-      placeholder: "my-adk-project",
-      validate: (value) => {
-        if (!value) return "Project name is required";
-        if (value.includes(" ")) return "Project name cannot contain spaces";
-        if (existsSync(value)) return `Directory "${value}" already exists`;
-        return void 0;
-      }
-    });
-    if (typeof response === "symbol") {
-      outro("Operation cancelled");
-      process.exit(0);
-    }
-    finalProjectName = response;
-  }
-  let selectedTemplate = options?.template;
-  if (!selectedTemplate || !templates.find((t) => t.value === selectedTemplate)) {
-    const framework = await select({
-      message: "Which template would you like to use?",
-      options: templates.map((t) => ({
-        value: t.value,
-        label: t.label,
-        hint: t.hint
-      }))
-    });
-    if (typeof framework === "symbol") {
-      outro("Operation cancelled");
-      process.exit(0);
-    }
-    selectedTemplate = framework;
-  }
-  const template = templates.find((t) => t.value === selectedTemplate);
-  if (!template) {
-    outro("Invalid template selected");
-    process.exit(1);
-  }
-  if (existsSync(finalProjectName)) {
-    outro(chalk.red(`Directory "${finalProjectName}" already exists`));
-    process.exit(1);
-  }
-  const s = spinner();
-  s.start("Downloading template...");
-  try {
-    await downloadTemplate(template.source, {
-      dir: finalProjectName,
-      registry: "gh"
-    });
-    s.stop("Template downloaded!");
-  } catch (error) {
-    s.stop("Failed to download template");
-    outro(chalk.red(`Error: ${error}`));
-    process.exit(1);
-  }
-  const availablePackageManagers = await detectAvailablePackageManagers();
-  let selectedPackageManager;
-  if (availablePackageManagers.length === 1) {
-    selectedPackageManager = availablePackageManagers[0];
-  } else {
-    const packageManagerChoice = await select({
-      message: "Which package manager would you like to use?",
-      options: availablePackageManagers.map((pm) => ({
-        value: pm.name,
-        label: pm.label
-      }))
-    });
-    if (typeof packageManagerChoice === "symbol") {
-      outro("Operation cancelled");
-      process.exit(0);
-    }
-    selectedPackageManager = availablePackageManagers.find(
-      (pm) => pm.name === packageManagerChoice
-    );
-  }
-  const shouldInstall = await confirm({
-    message: "Install dependencies?",
-    initialValue: true
-  });
-  if (typeof shouldInstall === "symbol") {
-    outro("Operation cancelled");
-    process.exit(0);
-  }
-  if (shouldInstall) {
-    const s2 = spinner();
-    s2.start(`Installing dependencies with ${selectedPackageManager.name}...`);
-    const { spawn } = await import("child_process");
-    const projectPath = join(process.cwd(), finalProjectName);
-    try {
-      await new Promise((resolve2, reject) => {
-        const child = spawn(
-          selectedPackageManager.command,
-          selectedPackageManager.args,
-          {
-            cwd: projectPath,
-            stdio: "pipe"
-          }
-        );
-        child.on("close", (code) => {
-          if (code === 0) {
-            resolve2();
-          } else {
-            reject(new Error(`Package installation failed with code ${code}`));
-          }
-        });
-        child.on("error", reject);
-      });
-      s2.stop("Dependencies installed!");
-    } catch (error) {
-      s2.stop("Failed to install dependencies");
-      console.log(
-        chalk.yellow("\nYou can install dependencies manually by running:")
-      );
-      console.log(
-        chalk.cyan(
-          `cd ${finalProjectName} && ${selectedPackageManager.command} ${selectedPackageManager.args.join(" ")}`
-        )
-      );
-    }
-  }
-  outro(
-    chalk.green(dedent`
-      🎉 Project created successfully!
-
-      Next steps:
-      ${chalk.cyan(`cd ${finalProjectName}`)}
-      ${shouldInstall ? "" : chalk.cyan(`${selectedPackageManager.command} ${selectedPackageManager.args.join(" ")}`)}
-      ${chalk.cyan("npm run dev")} or ${chalk.cyan("yarn dev")} or ${chalk.cyan("pnpm dev")}
-
-      Happy coding! 🚀
-    `)
-  );
-}
-
-// src/commands/run.ts
-import * as p from "@clack/prompts";
-import { log, spinner as spinner2 } from "@clack/prompts";
-import chalk4 from "chalk";
-import { marked } from "marked";
-import { markedTerminal } from "marked-terminal";
-
-// src/commands/serve.ts
-import { existsSync as existsSync3 } from "fs";
-import { resolve } from "path";
-import chalk3 from "chalk";
-
-// src/server/index.ts
-import { serve } from "@hono/node-server";
-import { InMemorySessionService } from "@iqai/adk";
-import { Hono } from "hono";
-
-// src/server/logger.ts
-import chalk2 from "chalk";
-var Logger = class {
-  name;
-  quiet;
-  debugEnabled;
-  constructor({ name, quiet = false }) {
-    this.name = name;
-    this.quiet = quiet;
-    this.debugEnabled = process.env.NODE_ENV === "development" || process.env.ADK_DEBUG === "true";
-  }
-  time() {
-    return (/* @__PURE__ */ new Date()).toLocaleTimeString();
-  }
-  prefix(icon, message) {
-    return `${this.time()} ${icon} [${this.name}] ${message}`;
-  }
-  debug(message, ...args) {
-    if (!this.debugEnabled || this.quiet) return;
-    console.debug(chalk2.blue(this.prefix("\u{1F41B}", message)), ...args);
-  }
-  info(message, ...args) {
-    if (this.quiet) return;
-    console.info(chalk2.cyan(this.prefix("\u2139\uFE0F", message)), ...args);
-  }
-  warn(message, ...args) {
-    if (this.quiet) return;
-    console.warn(chalk2.yellow(this.prefix("\u{1F6A7}", message)), ...args);
-  }
-  error(message, ...args) {
-    if (this.quiet) return;
-    console.error(chalk2.red(this.prefix("\u274C", message)), ...args);
-  }
-};
-
-// src/server/routes.ts
-import { cors } from "hono/cors";
-function setupRoutes(app, agentManager, sessionManager, agentsDir) {
-  app.use("/*", cors());
-  app.get("/health", (c) => c.json({ status: "ok" }));
-  app.get("/api/agents", (c) => {
-    const agentsList = Array.from(
-      agentManager.getAgents().values()
-    ).map((agent) => ({
-      path: agent.absolutePath,
-      name: agent.name,
-      directory: agent.absolutePath,
-      relativePath: agent.relativePath
-    }));
-    return c.json({ agents: agentsList });
-  });
-  app.post("/api/agents/refresh", (c) => {
-    agentManager.scanAgents(agentsDir);
-    const agentsList = Array.from(
-      agentManager.getAgents().values()
-    ).map((agent) => ({
-      path: agent.absolutePath,
-      name: agent.name,
-      directory: agent.absolutePath,
-      relativePath: agent.relativePath
-    }));
-    return c.json({ agents: agentsList });
-  });
-  app.get("/api/agents/:id/messages", async (c) => {
-    const agentPath = decodeURIComponent(c.req.param("id"));
-    const loadedAgent = agentManager.getLoadedAgents().get(agentPath);
-    if (!loadedAgent) {
-      return c.json({ messages: [] });
-    }
-    const messages = await sessionManager.getSessionMessages(loadedAgent);
-    const response = { messages };
-    return c.json(response);
-  });
-  app.post("/api/agents/:id/message", async (c) => {
-    const agentPath = decodeURIComponent(c.req.param("id"));
-    const { message, attachments } = await c.req.json();
-    const response = await agentManager.sendMessageToAgent(
-      agentPath,
-      message,
-      attachments
-    );
-    const messageResponse = { response };
-    return c.json(messageResponse);
-  });
-}
-
-// src/server/services.ts
-import {
-  existsSync as existsSync2,
-  mkdirSync,
-  readFileSync,
-  readdirSync,
-  statSync,
-  unlinkSync
-} from "fs";
-import { dirname, join as join2, relative } from "path";
-import { pathToFileURL } from "url";
-import { AgentBuilder } from "@iqai/adk";
-var AgentScanner = class {
-  constructor(quiet = false) {
-    this.quiet = quiet;
-    this.logger = new Logger({ name: "session-manager", quiet: this.quiet });
-  }
-  logger;
-  async getSessionMessages(loadedAgent) {
-  }
-  scanAgents(agentsDir, loadedAgents) {
-    const agents = /* @__PURE__ */ new Map();
-    const scanDir = !agentsDir || !existsSync2(agentsDir) ? process.cwd() : agentsDir;
-    const shouldSkipDirectory = (dirName) => {
-      const skipDirs = [
-        "node_modules",
-        ".git",
-        ".next",
-        "dist",
-        "build",
-        ".turbo",
-        "coverage",
-        ".vscode",
-        ".idea"
-      ];
-      return skipDirs.includes(dirName);
-    };
-    const scanDirectory = (dir) => {
-      const items = readdirSync(dir);
-      for (const item of items) {
-        const fullPath = join2(dir, item);
-        const stat = statSync(fullPath);
-        if (stat.isDirectory()) {
-          if (!shouldSkipDirectory(item)) {
-            scanDirectory(fullPath);
-          }
-        } else if (item === "agent.ts" || item === "agent.js") {
-          const relativePath = relative(scanDir, dir);
-          const loadedAgent = loadedAgents.get(relativePath);
-          let agentName = relativePath.split("/").pop() || "unknown";
-          if (loadedAgent?.agent?.name) {
-            agentName = loadedAgent.agent.name;
-          } else {
-            try {
-              const agentFilePath = join2(dir, item);
-              agentName = this.extractAgentNameFromFile(agentFilePath) || agentName;
-            } catch {
-            }
-          }
-          agents.set(relativePath, {
-            relativePath,
-            name: agentName,
-            absolutePath: dir,
-            instance: loadedAgent?.agent
-          });
-        }
-      }
-    };
-    scanDirectory(scanDir);
-    this.logger.info(`Agent scan complete. Found ${agents.size} agents. \u2728`);
-    return agents;
-  }
-  extractAgentNameFromFile(filePath) {
-    try {
-      const content = readFileSync(filePath, "utf-8");
-      const nameMatch = content.match(/name\s*:\s*["']([^"']+)["']/);
-      if (nameMatch?.[1]) {
-        return nameMatch[1];
-      }
-      return null;
-    } catch {
-      return null;
-    }
-  }
-};
-var AgentLoader = class {
-  constructor(quiet = false) {
-    this.quiet = quiet;
-    this.logger = new Logger({ name: "agent-loader", quiet: this.quiet });
-  }
-  logger;
-  /**
-   * Import a TypeScript file by compiling it on-demand
-   */
-  async importTypeScriptFile(filePath) {
-    const startDir = dirname(filePath);
-    let projectRoot = startDir;
-    while (projectRoot !== "/" && projectRoot !== dirname(projectRoot)) {
-      if (existsSync2(join2(projectRoot, "package.json")) || existsSync2(join2(projectRoot, ".env"))) {
-        break;
-      }
-      projectRoot = dirname(projectRoot);
-    }
-    if (projectRoot === "/") {
-      projectRoot = startDir;
-    }
-    try {
-      const { build } = await import("esbuild");
-      const cacheDir = join2(projectRoot, ".adk-cache");
-      if (!existsSync2(cacheDir)) {
-        mkdirSync(cacheDir, { recursive: true });
-      }
-      const outFile = join2(cacheDir, `agent-${Date.now()}.mjs`);
-      const plugin = {
-        name: "externalize-bare-imports",
-        setup(build2) {
-          build2.onResolve({ filter: /.*/ }, (args) => {
-            if (args.path.startsWith(".") || args.path.startsWith("/") || args.path.startsWith("..")) {
-              return;
-            }
-            return { path: args.path, external: true };
-          });
-        }
-      };
-      const tsconfigPath = join2(projectRoot, "tsconfig.json");
-      await build({
-        entryPoints: [filePath],
-        outfile: outFile,
-        bundle: true,
-        format: "esm",
-        platform: "node",
-        target: ["node22"],
-        sourcemap: false,
-        logLevel: "silent",
-        plugins: [plugin],
-        absWorkingDir: projectRoot,
-        // Use tsconfig if present for path aliases
-        ...existsSync2(tsconfigPath) ? { tsconfig: tsconfigPath } : {}
-      });
-      const mod = await import(`${pathToFileURL(outFile).href}?t=${Date.now()}`);
-      let agentExport = mod?.agent;
-      if (!agentExport && mod?.default) {
-        agentExport = mod.default.agent ?? mod.default;
-      }
-      try {
-        unlinkSync(outFile);
-      } catch {
-      }
-      if (agentExport) {
-        const isPrimitive = (v) => v == null || ["string", "number", "boolean"].includes(typeof v);
-        if (isPrimitive(agentExport)) {
-          this.logger.info(
-            `Ignoring primitive 'agent' export in ${filePath}; scanning module for factory...`
-          );
-        } else {
-          this.logger.info(`TS agent imported via esbuild: ${filePath} \u2705`);
-          return { agent: agentExport };
-        }
-      }
-      return mod;
-    } catch (e) {
-      throw new Error(
-        `Failed to import TS agent via esbuild: ${e instanceof Error ? e.message : String(e)}`
-      );
-    }
-  }
-  loadEnvironmentVariables(agentFilePath) {
-    let projectRoot = dirname(agentFilePath);
-    while (projectRoot !== "/" && projectRoot !== dirname(projectRoot)) {
-      if (existsSync2(join2(projectRoot, "package.json")) || existsSync2(join2(projectRoot, ".env"))) {
-        break;
-      }
-      projectRoot = dirname(projectRoot);
-    }
-    const envFiles = [
-      ".env.local",
-      ".env.development.local",
-      ".env.production.local",
-      ".env.development",
-      ".env.production",
-      ".env"
-    ];
-    for (const envFile of envFiles) {
-      const envPath = join2(projectRoot, envFile);
-      if (existsSync2(envPath)) {
-        try {
-          const envContent = readFileSync(envPath, "utf8");
-          const envLines = envContent.split("\n");
-          for (const line of envLines) {
-            const trimmedLine = line.trim();
-            if (trimmedLine && !trimmedLine.startsWith("#")) {
-              const [key, ...valueParts] = trimmedLine.split("=");
-              if (key && valueParts.length > 0) {
-                const value = valueParts.join("=").replace(/^"(.*)"$/, "$1");
-                if (!process.env[key.trim()]) {
-                  process.env[key.trim()] = value.trim();
-                }
-              }
-            }
-          }
-        } catch (error) {
-          this.logger.warn(
-            `Warning: Could not load ${envFile} file: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-    }
-  }
-  // Minimal resolution logic for agent exports: supports
-  // 1) export const agent = new LlmAgent(...)
-  // 2) export function agent() { return new LlmAgent(...) }
-  // 3) export async function agent() { return new LlmAgent(...) }
-  // 4) default export (object or function) returning or containing .agent
-  async resolveAgentExport(mod) {
-    let candidate = mod?.agent ?? mod?.default?.agent ?? mod?.default ?? mod;
-    const isLikelyAgentInstance = (obj) => obj && typeof obj === "object" && typeof obj.name === "string";
-    const isPrimitive = (v) => v == null || ["string", "number", "boolean"].includes(typeof v);
-    const invokeMaybe = async (fn) => {
-      let out = fn();
-      if (out && typeof out === "object" && "then" in out) {
-        out = await out;
-      }
-      return out;
-    };
-    if (!isLikelyAgentInstance(candidate) && isPrimitive(candidate) || !isLikelyAgentInstance(candidate) && candidate && candidate === mod) {
-      candidate = mod;
-      for (const [key, value] of Object.entries(mod)) {
-        if (key === "default") continue;
-        const keyLower = key.toLowerCase();
-        if (isPrimitive(value)) continue;
-        if (isLikelyAgentInstance(value)) {
-          candidate = value;
-          break;
-        }
-        if (value && typeof value === "object" && value.agent && isLikelyAgentInstance(value.agent)) {
-          candidate = value.agent;
-          break;
-        }
-        if (typeof value === "function" && (/(agent|build|create)/i.test(keyLower) || value.name && /(agent|build|create)/i.test(value.name.toLowerCase()))) {
-          try {
-            const maybe = await invokeMaybe(value);
-            if (isLikelyAgentInstance(maybe)) {
-              candidate = maybe;
-              break;
-            }
-            if (maybe && typeof maybe === "object" && maybe.agent && isLikelyAgentInstance(maybe.agent)) {
-              candidate = maybe.agent;
-              break;
-            }
-          } catch (e) {
-          }
-        }
-      }
-    }
-    if (typeof candidate === "function") {
-      try {
-        candidate = await invokeMaybe(candidate);
-      } catch (e) {
-        throw new Error(
-          `Failed executing exported agent function: ${e instanceof Error ? e.message : String(e)}`
-        );
-      }
-    }
-    if (candidate && typeof candidate === "object" && candidate.agent && isLikelyAgentInstance(candidate.agent)) {
-      candidate = candidate.agent;
-    }
-    if (candidate?.agent && isLikelyAgentInstance(candidate.agent)) {
-      candidate = candidate.agent;
-    }
-    if (!candidate || !isLikelyAgentInstance(candidate)) {
-      throw new Error(
-        "No agent export resolved (expected variable, function, or function returning an agent)"
-      );
-    }
-    return { agent: candidate };
-  }
-};
-var AgentManager = class {
-  constructor(sessionService, quiet = false) {
-    this.sessionService = sessionService;
-    this.quiet = quiet;
-    this.scanner = new AgentScanner(quiet);
-    this.loader = new AgentLoader(quiet);
-    this.logger = new Logger({ name: "agent-manager", quiet: this.quiet });
-  }
-  agents = /* @__PURE__ */ new Map();
-  loadedAgents = /* @__PURE__ */ new Map();
-  scanner;
-  loader;
-  logger;
-  getAgents() {
-    return this.agents;
-  }
-  getLoadedAgents() {
-    return this.loadedAgents;
-  }
-  scanAgents(agentsDir) {
-    this.agents = this.scanner.scanAgents(agentsDir, this.loadedAgents);
-  }
-  async startAgent(agentPath) {
-    const agent = this.agents.get(agentPath);
-    if (!agent) {
-      throw new Error(`Agent not found: ${agentPath}`);
-    }
-    if (this.loadedAgents.has(agentPath)) {
-      return;
-    }
-    try {
-      let agentFilePath = join2(agent.absolutePath, "agent.js");
-      if (!existsSync2(agentFilePath)) {
-        agentFilePath = join2(agent.absolutePath, "agent.ts");
-      }
-      if (!existsSync2(agentFilePath)) {
-        throw new Error(
-          `No agent.js or agent.ts file found in ${agent.absolutePath}`
-        );
-      }
-      this.loader.loadEnvironmentVariables(agentFilePath);
-      const agentFileUrl = pathToFileURL(agentFilePath).href;
-      const agentModule = agentFilePath.endsWith(".ts") ? await this.loader.importTypeScriptFile(agentFilePath) : await import(agentFileUrl);
-      const resolved = await this.loader.resolveAgentExport(agentModule);
-      const exportedAgent = resolved.agent;
-      if (!exportedAgent?.name) {
-        throw new Error(
-          `Invalid agent export in ${agentFilePath}. Expected an LlmAgent instance with a name property.`
-        );
-      }
-      const agentBuilder = AgentBuilder.create(exportedAgent.name).withAgent(exportedAgent).withSessionService(this.sessionService, {
-        userId: `user_${agentPath}`,
-        appName: "adk-server"
-      });
-      const { runner, session } = await agentBuilder.build();
-      const loadedAgent = {
-        agent: exportedAgent,
-        runner,
-        sessionId: session.id,
-        userId: `user_${agentPath}`,
-        appName: "adk-server"
-      };
-      this.loadedAgents.set(agentPath, loadedAgent);
-      agent.instance = exportedAgent;
-      agent.name = exportedAgent.name;
-    } catch (error) {
-      const agentName = agent?.name ?? agentPath;
-      this.logger.error(
-        `Failed to load agent "${agentName}": ${error instanceof Error ? error.message : String(error)}`
-      );
-      throw new Error(
-        `Failed to load agent: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  async stopAgent(agentPath) {
-    this.loadedAgents.delete(agentPath);
-    const agent = this.agents.get(agentPath);
-    if (agent) {
-      agent.instance = void 0;
-    }
-  }
-  async sendMessageToAgent(agentPath, message, attachments) {
-    if (!this.loadedAgents.has(agentPath)) {
-      await this.startAgent(agentPath);
-    }
-    const loadedAgent = this.loadedAgents.get(agentPath);
-    if (!loadedAgent) {
-      throw new Error("Agent failed to start");
-    }
-    try {
-      if (attachments && attachments.length > 0) {
-        const request = {
-          parts: [
-            { text: message },
-            ...attachments.map((file) => ({
-              inlineData: {
-                mimeType: file.mimeType,
-                data: file.data
-              }
-            }))
-          ]
-        };
-        const response2 = await loadedAgent.runner.ask(request);
-        return response2;
-      }
-      const response = await loadedAgent.runner.ask(message);
-      return response;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      this.logger.error(
-        `Error sending message to agent ${agentPath}: ${errorMessage}`
-      );
-      throw new Error(`Failed to send message to agent: ${errorMessage}`);
-    }
-  }
-  stopAllAgents() {
-    for (const [agentPath] of this.loadedAgents.entries()) {
-      this.stopAgent(agentPath);
-    }
-  }
-};
-var SessionManager = class {
-  constructor(sessionService, quiet = false) {
-    this.sessionService = sessionService;
-    this.quiet = quiet;
-    this.logger = new Logger({ name: "session-manager", quiet: this.quiet });
-  }
-  logger;
-  async getSessionMessages(loadedAgent) {
-    try {
-      const session = await this.sessionService.getSession(
-        loadedAgent.appName,
-        loadedAgent.userId,
-        loadedAgent.sessionId
-      );
-      if (!session || !session.events) {
-        return [];
-      }
-      const messages = session.events.map((event, index) => ({
-        id: index + 1,
-        type: event.author === "user" ? "user" : "assistant",
-        content: event.content?.parts?.map(
-          (part) => typeof part === "object" && "text" in part ? part.text : ""
-        ).join("") || "",
-        timestamp: new Date(event.timestamp || Date.now()).toISOString()
-      }));
-      return messages;
-    } catch (error) {
-      this.logger.error(
-        "Error fetching messages:",
-        error instanceof Error ? error.message : String(error)
-      );
-      return [];
-    }
-  }
-};
-
-// src/server/index.ts
-var ADKServer = class {
-  agentManager;
-  sessionManager;
-  sessionService;
-  app;
-  server;
-  config;
-  logger;
-  constructor(agentsDir, port = 8042, host = "localhost", quiet = false) {
-    this.config = { agentsDir, port, host, quiet };
-    this.logger = new Logger({ name: "adk-server", quiet });
-    this.sessionService = new InMemorySessionService();
-    this.agentManager = new AgentManager(this.sessionService, quiet);
-    this.sessionManager = new SessionManager(this.sessionService, quiet);
-    this.app = new Hono();
-    setupRoutes(this.app, this.agentManager, this.sessionManager, agentsDir);
-    this.logger.info(`Starting agent scan in ${agentsDir} \u2728`);
-    this.agentManager.scanAgents(agentsDir);
-  }
-  async start() {
-    return new Promise((resolve2) => {
-      this.server = serve({
-        fetch: this.app.fetch,
-        port: this.config.port,
-        hostname: this.config.host
-      });
-      setTimeout(() => {
-        this.logger.info(
-          `Server listening on http://${this.config.host}:${this.config.port} \u{1F680}`
-        );
-        resolve2();
-      }, 100);
-    });
-  }
-  async stop() {
-    return new Promise((resolve2) => {
-      this.logger.info("Stopping server and all agents... \u{1F6D1}");
-      this.agentManager.stopAllAgents();
-      if (this.server) {
-        this.server.close();
-      }
-      this.logger.info("Server stopped");
-      resolve2();
-    });
-  }
-  getPort() {
-    return this.config.port;
-  }
-};
-
-// src/commands/serve.ts
-async function serveCommand(options = {}) {
-  const port = options.port || 8042;
-  const host = options.host || "localhost";
-  const agentsDir = resolve(options.dir || ".");
-  if (!existsSync3(agentsDir)) {
-    console.error(chalk3.red(`\u274C Directory not found: ${agentsDir}`));
-    process.exit(1);
-  }
-  if (!options.quiet) {
-    console.log(chalk3.blue(`\u{1F680} ADK Server starting on http://${host}:${port}`));
-  }
-  const server = new ADKServer(agentsDir, port, host, options.quiet);
-  try {
-    await server.start();
-    if (!options.quiet) {
-      console.log(chalk3.green("\u2705 Server ready"));
-    }
-    const cleanup = async () => {
-      if (!options.quiet) {
-        console.log(chalk3.yellow("\n\u{1F6D1} Stopping server..."));
-      }
-      await server.stop();
-      process.exit(0);
-    };
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
-    return server;
-  } catch (error) {
-    console.error(chalk3.red("\u274C Failed to start ADK server:"), error);
-    process.exit(1);
-  }
-}
-
-// src/commands/run.ts
-marked.use(markedTerminal());
-async function renderMarkdown(text3) {
-  try {
-    const result = await marked(text3);
-    return typeof result === "string" ? result : text3;
-  } catch (error) {
-    return text3;
-  }
-}
-var AgentChatClient = class {
-  apiUrl;
-  selectedAgent = null;
-  constructor(apiUrl) {
-    this.apiUrl = apiUrl;
-  }
-  async connect() {
-    try {
-      const response = await fetch(`${this.apiUrl}/health`);
-      if (!response.ok) {
-        throw new Error("Connection failed");
-      }
-    } catch (error) {
-      throw new Error("\u274C Connection failed");
-    }
-  }
-  async fetchAgents() {
-    try {
-      const response = await fetch(`${this.apiUrl}/api/agents`);
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-      }
-      const data = await response.json();
-      if (Array.isArray(data)) {
-        return data;
-      }
-      if (data && Array.isArray(data.agents)) {
-        return data.agents;
-      }
-      throw new Error(`Unexpected response format: ${JSON.stringify(data)}`);
-    } catch (error) {
-      throw new Error(
-        `Failed to fetch agents: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  async selectAgent() {
-    const agents = await this.fetchAgents();
-    if (agents.length === 0) {
-      throw new Error("No agents found in the current directory");
-    }
-    if (agents.length === 1) {
-      return agents[0];
-    }
-    const selectedAgent = await p.select({
-      message: "Choose an agent to chat with:",
-      options: agents.map((agent) => ({
-        label: agent.name,
-        value: agent,
-        hint: agent.relativePath
-      }))
-    });
-    if (p.isCancel(selectedAgent)) {
-      p.cancel("Operation cancelled");
-      process.exit(0);
-    }
-    return selectedAgent;
-  }
-  // No-op: agents are auto-loaded on message; keeping method removed
-  async sendMessage(message) {
-    if (!this.selectedAgent) {
-      throw new Error("No agent selected");
-    }
-    const s = spinner2();
-    s.start("\u{1F916} Thinking...");
-    try {
-      const response = await fetch(
-        `${this.apiUrl}/api/agents/${encodeURIComponent(this.selectedAgent.relativePath)}/message`,
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({ message })
-        }
-      );
-      if (!response.ok) {
-        const errorText = await response.text();
-        s.stop("\u274C Failed to send message");
-        throw new Error(`Failed to send message: ${errorText}`);
-      }
-      const result = await response.json();
-      s.stop("\u{1F916} Assistant:");
-      if (result.response) {
-        const formattedResponse = await renderMarkdown(result.response);
-        log.message(formattedResponse.trim());
-      }
-    } catch (error) {
-      log.error("Failed to send message");
-    }
-  }
-  async startChat() {
-    if (!this.selectedAgent) {
-      throw new Error("Agent not selected");
-    }
-    while (true) {
-      try {
-        const message = await p.text({
-          message: "\u{1F4AC} Message:",
-          placeholder: "Type your message here..."
-        });
-        if (p.isCancel(message)) {
-          break;
-        }
-        if (message.trim()) {
-          await this.sendMessage(message.trim());
-        }
-      } catch (error) {
-        console.error(chalk4.red("Error in chat:"), error);
-        break;
-      }
-    }
-  }
-  disconnect() {
-  }
-  setSelectedAgent(agent) {
-    this.selectedAgent = agent;
-  }
-};
-async function runAgent(agentPath, options = {}) {
-  const envVerbose = process.env.ADK_VERBOSE;
-  const isVerbose = options.verbose ?? (envVerbose === "1" || envVerbose === "true");
-  if (options.server) {
-    const apiPort = 8042;
-    const host = options.host || "localhost";
-    console.log(chalk4.blue("\u{1F680} Starting ADK Server..."));
-    const serveOptions = {
-      port: apiPort,
-      dir: process.cwd(),
-      host,
-      quiet: !isVerbose
-    };
-    try {
-      const server = await serveCommand(serveOptions);
-      console.log(chalk4.cyan("Press Ctrl+C to stop the server"));
-      process.on("SIGINT", async () => {
-        console.log(chalk4.yellow("\n\u{1F6D1} Stopping server..."));
-        await server.stop();
-        process.exit(0);
-      });
-      return new Promise(() => {
-      });
-    } catch (error) {
-      console.error(chalk4.red("\u274C Failed to start server"));
-      process.exit(1);
-    }
-  }
-  const apiUrl = `http://${options.host || "localhost"}:8042`;
-  p.intro("\u{1F916} ADK Agent Chat");
-  try {
-    const healthResponse = await fetch(`${apiUrl}/health`).catch(() => null);
-    if (!healthResponse || !healthResponse.ok) {
-      const serverSpinner = spinner2();
-      serverSpinner.start("\u{1F680} Starting server...");
-      const serveOptions = {
-        port: 8042,
-        // Use new default port
-        dir: process.cwd(),
-        host: options.host || "localhost",
-        quiet: !isVerbose
-      };
-      await serveCommand(serveOptions);
-      await new Promise((resolve2) => setTimeout(resolve2, 1e3));
-      serverSpinner.stop("\u2705 Server ready");
-    }
-    const client = new AgentChatClient(apiUrl);
-    await client.connect();
-    const agentSpinner = spinner2();
-    agentSpinner.start("\u{1F50D} Scanning for agents...");
-    const agents = await client.fetchAgents();
-    let selectedAgent;
-    if (agents.length === 0) {
-      agentSpinner.stop("\u274C No agents found");
-      p.cancel("No agents found in the current directory");
-      process.exit(1);
-    } else if (agents.length === 1) {
-      selectedAgent = agents[0];
-      agentSpinner.stop(`\u{1F916} Found agent: ${selectedAgent.name}`);
-    } else {
-      agentSpinner.stop(`\u{1F916} Found ${agents.length} agents`);
-      const choice = await p.select({
-        message: "Choose an agent to chat with:",
-        options: agents.map((agent) => ({
-          label: agent.name,
-          value: agent,
-          hint: agent.relativePath
-        }))
-      });
-      if (p.isCancel(choice)) {
-        p.cancel("Operation cancelled");
-        process.exit(0);
-      }
-      selectedAgent = choice;
-    }
-    client.setSelectedAgent(selectedAgent);
-    await client.startChat();
-    client.disconnect();
-    p.outro("Chat ended");
-  } catch (error) {
-    p.cancel(
-      `Error: ${error instanceof Error ? error.message : String(error)}`
-    );
-    process.exit(1);
-  }
-}
-
-// src/commands/web.ts
-import chalk5 from "chalk";
-async function webCommand(options = {}) {
-  const apiPort = options.port || 8042;
-  const webPort = options.webPort || 3e3;
-  const host = options.host || "localhost";
-  const useLocal = options.local || false;
-  const webUrl = options.webUrl || "https://adk-web.iqai.com";
-  console.log(chalk5.blue("\u{1F310} Starting ADK Web Interface..."));
-  const serveOptions = {
-    port: apiPort,
-    dir: options.dir,
-    host,
-    quiet: true
-  };
-  await serveCommand(serveOptions);
-  let webAppUrl;
-  if (useLocal) {
-    if (apiPort === 8042) {
-      webAppUrl = `http://${host}:${webPort}`;
-    } else {
-      webAppUrl = `http://${host}:${webPort}?port=${apiPort}`;
-    }
-  } else {
-    if (apiPort === 8042) {
-      webAppUrl = webUrl;
-    } else {
-      webAppUrl = `${webUrl}?port=${apiPort}`;
-    }
-  }
-  console.log(chalk5.cyan(`\u{1F517} Open this URL in your browser: ${webAppUrl}`));
-  console.log(chalk5.gray(`   API Server: http://${host}:${apiPort}`));
-  console.log(chalk5.cyan("Press Ctrl+C to stop the API server"));
-}
-
-// src/index.ts
-program.name("adk").description(package_default.description).version(package_default.version);
-program.command("new").description("Create a new ADK project").argument("[project-name]", "Name of the project to create").option(
-  "-t, --template <template>",
-  "Template to use (simple-agent, discord-bot, telegram-bot, hono-server, mcp-starter)"
-).action(async (projectName, options) => {
-  try {
-    await createProject(projectName, options);
-  } catch (error) {
-    console.error(chalk6.red("Error creating project:"), error);
-    process.exit(1);
-  }
-});
-program.command("run").description("Start an interactive chat with an agent").argument(
-  "[agent-path]",
-  "Path to specific agent (optional - will show selector if multiple agents found)"
-).option("-s, --server", "Start ADK server only (without chat interface)").option(
-  "-h, --host <host>",
-  "Host for server (when using --server)",
-  "localhost"
-).action(async (agentPath, options) => {
-  try {
-    await runAgent(agentPath, options);
-  } catch (error) {
-    console.error(chalk6.red("Error running agent:"), error);
-    process.exit(1);
-  }
-});
-program.command("web").description("Start a web interface for testing agents").option("-p, --port <port>", "Port for API server", "8042").option("--web-port <port>", "Port for web app (when using --local)", "3000").option("-h, --host <host>", "Host for servers", "localhost").option(
-  "-d, --dir <directory>",
-  "Directory to scan for agents (default: current directory)",
-  "."
-).option(
-  "--local",
-  "Run local web app instead of opening production URL",
-  false
-).option(
-  "--web-url <url>",
-  "URL of the web application (used when not --local)",
-  "https://adk-web.iqai.com"
-).action(async (options) => {
-  try {
-    await webCommand(options);
-  } catch (error) {
-    console.error(chalk6.red("Error starting web UI:"), error);
-    process.exit(1);
-  }
-});
-program.command("serve").description("Start an API server for agent management").option("-p, --port <port>", "Port for the server", "8042").option("-h, --host <host>", "Host for the server", "localhost").option(
-  "-d, --dir <directory>",
-  "Directory to scan for agents (default: current directory)",
-  "."
-).action(async (options) => {
-  try {
-    await serveCommand(options);
-  } catch (error) {
-    console.error(chalk6.red("Error starting server:"), error);
-    process.exit(1);
-  }
-});
-program.parse();
-//# sourceMappingURL=index.mjs.map