@iqai/adk-cli 0.1.1 → 0.2.1

package/dist/index.mjs

@@ -8,7 +8,7 @@ import { program } from "commander";
 // package.json
 var package_default = {
   name: "@iqai/adk-cli",
-  version: "0.1.1",
+  version: "0.2.1",
   description: "CLI tool for creating, running, and testing ADK agents",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -143,21 +143,7 @@ async function detectAvailablePackageManagers() {
 }
 async function createProject(projectName, options) {
   console.clear();
-  console.log(
-    chalk.magentaBright(dedent`
-    ╔══════════════════════════════════════════════════════╗
-    ║                                                      ║
-    ║     █████╗ ██████╗ ██╗  ██╗    ████████╗███████╗     ║
-    ║    ██╔══██╗██╔══██╗██║ ██╔╝    ╚══██╔══╝██╔════╝     ║
-    ║    ███████║██║  ██║█████╔╝        ██║   ███████╗     ║
-    ║    ██╔══██║██║  ██║██╔═██╗        ██║   ╚════██║     ║
-    ║    ██║  ██║██████╔╝██║  ██╗       ██║   ███████║     ║
-    ║    ╚═╝  ╚═╝╚═════╝ ╚═╝  ╚═╝       ╚═╝   ╚══════╝     ║
-    ║                                                      ║
-    ╚══════════════════════════════════════════════════════╝
-  `)
-  );
-  intro(chalk.bgMagenta.bold(" \u2728 Let's build something amazing! "));
+  intro(chalk.magentaBright("\u{1F9E0} Create new ADK-TS project"));
   let finalProjectName = projectName;
   if (!finalProjectName) {
     const response = await text({
@@ -305,7 +291,59 @@ import { existsSync as existsSync3 } from "fs";
 import { resolve } from "path";
 import chalk2 from "chalk";
 
-// src/server.ts
+// src/server/index.ts
+import { serve } from "@hono/node-server";
+import { InMemorySessionService } from "@iqai/adk";
+import { Hono } from "hono";
+
+// 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 } = await c.req.json();
+    const response = await agentManager.sendMessageToAgent(agentPath, message);
+    const messageResponse = { response };
+    return c.json(messageResponse);
+  });
+}
+
+// src/server/services.ts
 import {
   existsSync as existsSync2,
   mkdirSync,
@@ -316,91 +354,14 @@ import {
 } from "fs";
 import { dirname, join as join2, relative } from "path";
 import { pathToFileURL } from "url";
-import { serve } from "@hono/node-server";
-import { AgentBuilder, InMemorySessionService } from "@iqai/adk";
-import { Hono } from "hono";
-import { cors } from "hono/cors";
-var ADKServer = class {
-  agents = /* @__PURE__ */ new Map();
-  loadedAgents = /* @__PURE__ */ new Map();
-  sessionService;
-  app;
-  server;
-  agentsDir;
-  port;
-  host;
-  quiet;
-  constructor(agentsDir, port = 8042, host = "localhost", quiet = false) {
-    this.agentsDir = agentsDir;
-    this.port = port;
-    this.host = host;
+import { AgentBuilder } from "@iqai/adk";
+var AgentScanner = class {
+  constructor(quiet = false) {
     this.quiet = quiet;
-    this.sessionService = new InMemorySessionService();
-    this.app = new Hono();
-    this.setupRoutes();
-    this.scanAgents();
   }
-  setupRoutes() {
-    this.app.use("/*", cors());
-    this.app.get("/health", (c) => c.json({ status: "ok" }));
-    this.app.get("/api/agents", (c) => {
-      const agentsList = Array.from(this.agents.values()).map((agent) => ({
-        path: agent.absolutePath,
-        name: agent.name,
-        directory: agent.absolutePath,
-        relativePath: agent.relativePath
-      }));
-      return c.json({ agents: agentsList });
-    });
-    this.app.post("/api/agents/refresh", (c) => {
-      this.scanAgents();
-      const agentsList = Array.from(this.agents.values()).map((agent) => ({
-        path: agent.absolutePath,
-        name: agent.name,
-        directory: agent.absolutePath,
-        relativePath: agent.relativePath
-      }));
-      return c.json({ agents: agentsList });
-    });
-    this.app.get("/api/agents/:id/messages", async (c) => {
-      const agentPath = decodeURIComponent(c.req.param("id"));
-      const loadedAgent = this.loadedAgents.get(agentPath);
-      if (!loadedAgent) {
-        return c.json({ messages: [] });
-      }
-      try {
-        const session = await this.sessionService.getSession(
-          loadedAgent.appName,
-          loadedAgent.userId,
-          loadedAgent.sessionId
-        );
-        if (!session || !session.events) {
-          return c.json({ messages: [] });
-        }
-        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 c.json({ messages });
-      } catch (error) {
-        console.error("Error fetching messages:", error);
-        return c.json({ messages: [] });
-      }
-    });
-    this.app.post("/api/agents/:id/message", async (c) => {
-      const agentPath = decodeURIComponent(c.req.param("id"));
-      const { message } = await c.req.json();
-      const response = await this.sendMessageToAgent(agentPath, message);
-      return c.json({ response });
-    });
-  }
-  scanAgents() {
-    this.agents.clear();
-    const scanDir = !this.agentsDir || !existsSync2(this.agentsDir) ? process.cwd() : this.agentsDir;
+  scanAgents(agentsDir, loadedAgents) {
+    const agents = /* @__PURE__ */ new Map();
+    const scanDir = !agentsDir || !existsSync2(agentsDir) ? process.cwd() : agentsDir;
     const shouldSkipDirectory = (dirName) => {
       const skipDirs = [
         "node_modules",
@@ -427,7 +388,7 @@ var ADKServer = class {
           }
         } else if (item === "agent.ts" || item === "agent.js") {
           const relativePath = relative(scanDir, dir);
-          const loadedAgent = this.loadedAgents.get(relativePath);
+          const loadedAgent = loadedAgents.get(relativePath);
           let agentName = relativePath.split("/").pop() || "unknown";
           if (loadedAgent?.agent?.name) {
             agentName = loadedAgent.agent.name;
@@ -438,7 +399,7 @@ var ADKServer = class {
             } catch {
             }
           }
-          this.agents.set(relativePath, {
+          agents.set(relativePath, {
             relativePath,
             name: agentName,
             absolutePath: dir,
@@ -449,9 +410,225 @@ var ADKServer = class {
     };
     scanDirectory(scanDir);
     if (!this.quiet) {
-      console.log(`\u2705 Agent scan complete. Found ${this.agents.size} agents.`);
+      console.log(`\u2705 Agent scan complete. Found ${agents.size} agents.`);
+    }
+    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;
+  }
+  /**
+   * 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)) {
+          if (!this.quiet) {
+            console.log(
+              `\u2139\uFE0F Ignoring primitive 'agent' export in ${filePath}; scanning module for factory...`
+            );
+          }
+        } else {
+          if (!this.quiet) {
+            console.log(`\u2705 TS agent imported via esbuild: ${filePath}`);
+          }
+          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 envPath = join2(projectRoot, ".env");
+    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");
+              process.env[key.trim()] = value.trim();
+            }
+          }
+        }
+      } catch (error) {
+        console.warn(
+          `\u26A0\uFE0F Warning: Could not load .env 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);
+  }
+  agents = /* @__PURE__ */ new Map();
+  loadedAgents = /* @__PURE__ */ new Map();
+  scanner;
+  loader;
+  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) {
@@ -470,70 +647,31 @@ var ADKServer = class {
           `No agent.js or agent.ts file found in ${agent.absolutePath}`
         );
       }
-      let projectRoot = dirname(agentFilePath);
-      while (projectRoot !== "/" && projectRoot !== dirname(projectRoot)) {
-        if (existsSync2(join2(projectRoot, "package.json")) || existsSync2(join2(projectRoot, ".env"))) {
-          break;
-        }
-        projectRoot = dirname(projectRoot);
-      }
-      const envPath = join2(projectRoot, ".env");
-      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");
-                process.env[key.trim()] = value.trim();
-              }
-            }
-          }
-        } catch (error) {
-          console.warn(
-            `\u26A0\uFE0F Warning: Could not load .env file: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
+      this.loader.loadEnvironmentVariables(agentFilePath);
       const agentFileUrl = pathToFileURL(agentFilePath).href;
-      const agentModule = agentFilePath.endsWith(".ts") ? await this.importTypeScriptFile(agentFilePath) : await import(agentFileUrl);
-      if (!agentModule.agent) {
-        throw new Error(`No 'agent' export found in ${agentFilePath}`);
-      }
-      if (!agentModule.agent || typeof agentModule.agent !== "object" || !agentModule.agent.name) {
+      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.`
         );
       }
-      if (!agentModule.agent.model || !agentModule.agent.instruction) {
-      }
-      const agentBuilder = AgentBuilder.create(agentModule.agent.name).withModel(agentModule.agent.model).withDescription(agentModule.agent.description || "").withInstruction(agentModule.agent.instruction || "").withSessionService(this.sessionService, {
+      const agentBuilder = AgentBuilder.create(exportedAgent.name).withAgent(exportedAgent).withSessionService(this.sessionService, {
         userId: `user_${agentPath}`,
         appName: "adk-server"
       });
-      if (agentModule.agent.tools && Array.isArray(agentModule.agent.tools) && agentModule.agent.tools.length > 0) {
-        agentBuilder.withTools(...agentModule.agent.tools);
-        if (!this.quiet) {
-          const toolNames = agentModule.agent.tools.map((t) => t?.name || "<unnamed>").join(", ");
-          console.log(
-            `\u{1F9E9} Registered tools for agent "${agentModule.agent.name}": [${toolNames}]`
-          );
-        }
-      }
       const { runner, session } = await agentBuilder.build();
       const loadedAgent = {
-        agent: agentModule.agent,
+        agent: exportedAgent,
         runner,
         sessionId: session.id,
         userId: `user_${agentPath}`,
         appName: "adk-server"
       };
       this.loadedAgents.set(agentPath, loadedAgent);
-      agent.instance = agentModule.agent;
-      agent.name = agentModule.agent.name;
+      agent.instance = exportedAgent;
+      agent.name = exportedAgent.name;
     } catch (error) {
       console.error(`\u274C Failed to load agent "${agent.name}":`, error);
       throw new Error(
@@ -568,78 +706,65 @@ var ADKServer = class {
       throw new Error(`Failed to send message to agent: ${errorMessage}`);
     }
   }
-  /**
-   * Import a TypeScript file by compiling it on-demand
-   */
-  async importTypeScriptFile(filePath) {
-    let projectRoot = dirname(filePath);
-    while (projectRoot !== "/" && projectRoot !== dirname(projectRoot)) {
-      if (existsSync2(join2(projectRoot, "package.json")) || existsSync2(join2(projectRoot, ".env"))) {
-        break;
-      }
-      projectRoot = dirname(projectRoot);
+  stopAllAgents() {
+    for (const [agentPath] of this.loadedAgents.entries()) {
+      this.stopAgent(agentPath);
     }
+  }
+};
+var SessionManager = class {
+  constructor(sessionService) {
+    this.sessionService = sessionService;
+  }
+  async getSessionMessages(loadedAgent) {
     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) {
-        if (!this.quiet) {
-          console.log(`\u2705 TS agent imported via esbuild: ${filePath}`);
-        }
-        return { agent: agentExport };
-      }
-    } catch (e) {
-      throw new Error(
-        `Failed to import TS agent via esbuild: ${e instanceof Error ? e.message : String(e)}`
+      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) {
+      console.error("Error fetching messages:", error);
+      return [];
     }
-    throw new Error("No 'agent' export found in TypeScript module");
+  }
+};
+
+// src/server/index.ts
+var ADKServer = class {
+  agentManager;
+  sessionManager;
+  sessionService;
+  app;
+  server;
+  config;
+  constructor(agentsDir, port = 8042, host = "localhost", quiet = false) {
+    this.config = { agentsDir, port, host, quiet };
+    this.sessionService = new InMemorySessionService();
+    this.agentManager = new AgentManager(this.sessionService, quiet);
+    this.sessionManager = new SessionManager(this.sessionService);
+    this.app = new Hono();
+    setupRoutes(this.app, this.agentManager, this.sessionManager, agentsDir);
+    this.agentManager.scanAgents(agentsDir);
   }
   async start() {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve2) => {
       this.server = serve({
         fetch: this.app.fetch,
-        port: this.port,
-        hostname: this.host
+        port: this.config.port,
+        hostname: this.config.host
       });
       setTimeout(() => {
         resolve2();
@@ -648,9 +773,7 @@ var ADKServer = class {
   }
   async stop() {
     return new Promise((resolve2) => {
-      for (const [agentPath] of this.loadedAgents) {
-        this.stopAgent(agentPath);
-      }
+      this.agentManager.stopAllAgents();
       if (this.server) {
         this.server.close();
       }
@@ -658,19 +781,7 @@ var ADKServer = class {
     });
   }
   getPort() {
-    return this.port;
-  }
-  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;
-    }
+    return this.config.port;
   }
 };
 
@@ -963,8 +1074,7 @@ async function webCommand(options = {}) {
 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)",
-  "simple-agent"
+  "Template to use (simple-agent, discord-bot, telegram-bot, hono-server, mcp-starter)"
 ).action(async (projectName, options) => {
   try {
     await createProject(projectName, options);