create-adk-agent 0.0.1

package/src/generators/init/files/src/index.ts.template

@@ -0,0 +1,61 @@
+import 'dotenv/config';
+<% if (hasBasic) { %>import { rootAgent as basicAgent } from './agents/basic/agent.js';
+<% } %><% if (hasMultiTool) { %>import { rootAgent as multiToolAgent } from './agents/multi-tool/agent.js';
+<% } %><% if (hasTeam) { %>import { rootAgent as teamAgent } from './agents/team/root-agent.js';
+<% } %><% if (hasStreaming) { %>import { rootAgent as streamingAgent } from './agents/streaming/agent.js';
+<% } %><% if (hasWorkflow) { %>import { rootAgent as workflowAgent } from './agents/workflow/agent.js';
+<% } %>
+// Validate required environment variables based on model
+const modelProvider = '<%= modelProvider %>';
+const model = '<%= model %>';
+
+if (modelProvider === 'gemini' && !process.env.GEMINI_API_KEY) {
+  console.error('❌ GEMINI_API_KEY is required for Gemini models.');
+  console.error('Get your API key from: https://aistudio.google.com/apikey');
+  console.error('Add it to your .env file: GEMINI_API_KEY=your_key_here');
+  process.exit(1);
+}
+
+if (modelProvider === 'openai' && !process.env.OPENAI_API_KEY) {
+  console.error('❌ OPENAI_API_KEY is required for OpenAI models.');
+  console.error('Get your API key from: https://platform.openai.com/api-keys');
+  console.error('Add it to your .env file: OPENAI_API_KEY=your_key_here');
+  process.exit(1);
+}
+
+if (modelProvider === 'anthropic' && !process.env.ANTHROPIC_API_KEY) {
+  console.error('❌ ANTHROPIC_API_KEY is required for Anthropic models.');
+  console.error('Get your API key from: https://console.anthropic.com/settings/keys');
+  console.error('Add it to your .env file: ANTHROPIC_API_KEY=your_key_here');
+  process.exit(1);
+}
+
+console.log('✅ Environment configured successfully');
+console.log(`📦 Model Provider: ${modelProvider}`);
+console.log(`🤖 Model: ${model}`);
+console.log('');
+console.log('Available agents:');
+<% if (hasBasic) { %>console.log('  - basicAgent: Basic agent with time tool');
+<% } %><% if (hasMultiTool) { %>console.log('  - multiToolAgent: Agent with multiple tools');
+<% } %><% if (hasTeam) { %>console.log('  - teamAgent: Multi-agent team coordination');
+<% } %><% if (hasStreaming) { %>console.log('  - streamingAgent: Streaming responses with Live API');
+<% } %><% if (hasWorkflow) { %>console.log('  - workflowAgent: Workflow patterns (sequential/loop/parallel)');
+<% } %>console.log('');
+console.log('Run agents with ADK DevTools:');
+console.log('  npm run adk:web   - Web UI for all agents');
+console.log('  npm run adk:run   - CLI runner');
+
+// Export agents for ADK DevTools
+<% if (hasBasic) { %>export { basicAgent };
+<% } %><% if (hasMultiTool) { %>export { multiToolAgent };
+<% } %><% if (hasTeam) { %>export { teamAgent };
+<% } %><% if (hasStreaming) { %>export { streamingAgent };
+<% } %><% if (hasWorkflow) { %>export { workflowAgent };
+<% } %>
+// Default export for convenience
+<% if (hasMultiTool) { %>export default multiToolAgent;
+<% } else if (hasBasic) { %>export default basicAgent;
+<% } else if (hasTeam) { %>export default teamAgent;
+<% } else if (hasStreaming) { %>export default streamingAgent;
+<% } else if (hasWorkflow) { %>export default workflowAgent;
+<% } %>

package/src/generators/init/files/tests/agents.test.ts.template

@@ -0,0 +1,80 @@
+<% if (hasBasic) { %>import { rootAgent as basicAgent } from '../src/agents/basic/agent.js';
+
+describe('Basic Agent', () => {
+  it('should initialize with correct configuration', () => {
+    expect(basicAgent.name).toBe('hello_time_agent');
+    expect(basicAgent.tools).toHaveLength(1);
+    expect(basicAgent.tools[0].name).toBe('get_current_time');
+  });
+
+  it('should have correct description', () => {
+    expect(basicAgent.description).toContain('time');
+  });
+});
+<% } %>
+<% if (hasMultiTool) { %>import { rootAgent as multiToolAgent } from '../src/agents/multi-tool/agent.js';
+
+describe('Multi-Tool Agent', () => {
+  it('should initialize with correct configuration', () => {
+    expect(multiToolAgent.name).toBe('multi_tool_agent');
+    expect(multiToolAgent.tools).toHaveLength(3);
+  });
+
+  it('should have time, weather, and calculate tools', () => {
+    const toolNames = multiToolAgent.tools.map((tool) => tool.name);
+    expect(toolNames).toContain('get_current_time');
+    expect(toolNames).toContain('get_weather');
+    expect(toolNames).toContain('calculate');
+  });
+});
+<% } %>
+<% if (hasTeam) { %>import { rootAgent as teamAgent } from '../src/agents/team/root-agent.js';
+import { greetingAgent } from '../src/agents/team/greeting-agent.js';
+import { farewellAgent } from '../src/agents/team/farewell-agent.js';
+
+describe('Team Agents', () => {
+  it('root agent should coordinate sub-agents', () => {
+    expect(teamAgent.name).toBe('team_root_agent');
+    expect(teamAgent.agents).toHaveLength(2);
+  });
+
+  it('greeting agent should have say_hello tool', () => {
+    expect(greetingAgent.name).toBe('greeting_agent');
+    expect(greetingAgent.tools).toHaveLength(1);
+    expect(greetingAgent.tools[0].name).toBe('say_hello');
+  });
+
+  it('farewell agent should have say_goodbye tool', () => {
+    expect(farewellAgent.name).toBe('farewell_agent');
+    expect(farewellAgent.tools).toHaveLength(1);
+    expect(farewellAgent.tools[0].name).toBe('say_goodbye');
+  });
+});
+<% } %>
+<% if (hasStreaming) { %>import { rootAgent as streamingAgent } from '../src/agents/streaming/agent.js';
+
+describe('Streaming Agent', () => {
+  it('should initialize with correct configuration', () => {
+    expect(streamingAgent.name).toBe('streaming_agent');
+    expect(streamingAgent.tools).toHaveLength(1);
+  });
+
+  it('should have process_data tool', () => {
+    expect(streamingAgent.tools[0].name).toBe('process_data');
+  });
+});
+<% } %>
+<% if (hasWorkflow) { %>import { rootAgent as workflowAgent } from '../src/agents/workflow/agent.js';
+
+describe('Workflow Agent', () => {
+  it('should initialize with correct configuration', () => {
+    expect(workflowAgent.name).toBe('workflow_agent');
+    expect(workflowAgent.tools).toHaveLength(3);
+  });
+
+  it('should have workflow tools in correct order', () => {
+    const toolNames = workflowAgent.tools.map((tool) => tool.name);
+    expect(toolNames).toEqual(['validate_input', 'transform_data', 'save_result']);
+  });
+});
+<% } %>

package/src/generators/init/files/tsconfig.json.template

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "verbatimModuleSyntax": false,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}

package/src/generators/init/schema.json

@@ -0,0 +1,124 @@
+{
+    "$schema": "http://json-schema.org/schema",
+    "$id": "CreateAdkAgent",
+    "title": "Create ADK Agent",
+    "type": "object",
+    "properties": {
+        "name": {
+            "type": "string",
+            "description": "The name of the agent project",
+            "$default": {
+                "$source": "argv",
+                "index": 0
+            },
+            "x-prompt": "What is the name of your agent project?"
+        },
+        "directory": {
+            "type": "string",
+            "description": "Directory where the project will be created",
+            "default": ""
+        },
+        "description": {
+            "type": "string",
+            "description": "Project description",
+            "default": "My ADK Agent"
+        },
+        "templates": {
+            "type": "array",
+            "description": "Agent templates to include",
+            "items": {
+                "type": "string",
+                "enum": [
+                    "basic",
+                    "multi-tool",
+                    "team",
+                    "streaming",
+                    "workflow"
+                ]
+            },
+            "default": [
+                "multi-tool"
+            ],
+            "x-prompt": {
+                "message": "Select agent templates to include:",
+                "type": "list",
+                "multiselect": true,
+                "items": [
+                    {
+                        "value": "basic",
+                        "label": "Basic Agent (getCurrentTime - from docs quickstart)"
+                    },
+                    {
+                        "value": "multi-tool",
+                        "label": "Multi-tool Agent (weather + time - from docs quickstart)"
+                    },
+                    {
+                        "value": "team",
+                        "label": "Agent Team (greeting + farewell + weather delegation)"
+                    },
+                    {
+                        "value": "streaming",
+                        "label": "Streaming Agent (Live API voice/text)"
+                    },
+                    {
+                        "value": "workflow",
+                        "label": "Workflow Agent (Sequential/Loop/Parallel)"
+                    }
+                ]
+            }
+        },
+        "modelProvider": {
+            "type": "string",
+            "description": "LLM model provider",
+            "enum": [
+                "gemini",
+                "openai",
+                "anthropic",
+                "custom"
+            ],
+            "default": "gemini",
+            "x-prompt": {
+                "message": "Select your preferred model provider:",
+                "type": "list",
+                "items": [
+                    {
+                        "value": "gemini",
+                        "label": "Google Gemini (Google AI Studio or Vertex AI)"
+                    },
+                    {
+                        "value": "openai",
+                        "label": "OpenAI (GPT models via LiteLLM)"
+                    },
+                    {
+                        "value": "anthropic",
+                        "label": "Anthropic (Claude models via LiteLLM)"
+                    },
+                    {
+                        "value": "custom",
+                        "label": "Other/Custom (Manual configuration)"
+                    }
+                ]
+            }
+        },
+        "model": {
+            "type": "string",
+            "description": "Specific model to use",
+            "default": "gemini-3.0-flash"
+        },
+        "installDependencies": {
+            "type": "boolean",
+            "description": "Install dependencies after generation",
+            "default": true,
+            "x-prompt": "Install dependencies now?"
+        },
+        "initGit": {
+            "type": "boolean",
+            "description": "Initialize git repository",
+            "default": true,
+            "x-prompt": "Initialize git repository?"
+        }
+    },
+    "required": [
+        "name"
+    ]
+}