@inkeep/create-agents 0.2.1 → 0.3.0

package/dist/__tests__/utils.test.js

@@ -1,8 +1,8 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as p from '@clack/prompts';
 import fs from 'fs-extra';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { cloneTemplate, getAvailableTemplates } from '../templates';
 import { createAgents } from '../utils';
-import { getAvailableTemplates, cloneTemplate } from '../templates';
-import * as p from '@clack/prompts';
 // Mock all dependencies
 vi.mock('fs-extra');
 vi.mock('../templates');
@@ -48,7 +48,11 @@ describe('createAgents - Template and Project ID Logic', () => {
         vi.mocked(fs.mkdir).mockResolvedValue(undefined);
         vi.mocked(fs.remove).mockResolvedValue(undefined);
         // Mock templates
-        vi.mocked(getAvailableTemplates).mockResolvedValue(['weather-graph', 'chatbot', 'data-analysis']);
+        vi.mocked(getAvailableTemplates).mockResolvedValue([
+            'weather-project',
+            'chatbot',
+            'data-analysis',
+        ]);
         vi.mocked(cloneTemplate).mockResolvedValue(undefined);
         // Mock util.promisify to return a mock exec function
         const mockExecAsync = vi.fn().mockResolvedValue({ stdout: '', stderr: '' });
@@ -68,29 +72,27 @@ describe('createAgents - Template and Project ID Logic', () => {
         processChdirSpy.mockRestore();
     });
     describe('Default behavior (no template or customProjectId)', () => {
-        it('should use weather-graph as default template and project ID', async () => {
+        it('should use weather-project as default template and project ID', async () => {
             await createAgents({
                 dirName: 'test-dir',
                 openAiKey: 'test-openai-key',
-                anthropicKey: 'test-anthropic-key'
+                anthropicKey: 'test-anthropic-key',
             });
-            // Should clone base template and weather-graph template
+            // Should clone base template and weather-project template
             expect(cloneTemplate).toHaveBeenCalledTimes(2);
             expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/create-agents-template', expect.any(String));
-            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents-cookbook/templates/weather-graph', 'src/weather-graph');
+            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents-cookbook/template-projects/weather-project', 'src/weather-project');
             // Should not call getAvailableTemplates since no template validation needed
             expect(getAvailableTemplates).not.toHaveBeenCalled();
         });
-        it('should create project with weather-graph as project ID', async () => {
+        it('should create project with weather-project as project ID', async () => {
             await createAgents({
                 dirName: 'test-dir',
                 openAiKey: 'test-openai-key',
-                anthropicKey: 'test-anthropic-key'
+                anthropicKey: 'test-anthropic-key',
             });
-            // Check that .env file is created with correct project ID path
-            expect(fs.writeFile).toHaveBeenCalledWith('src/weather-graph/.env', expect.any(String));
             // Check that inkeep.config.ts is created with correct project ID
-            expect(fs.writeFile).toHaveBeenCalledWith('src/weather-graph/inkeep.config.ts', expect.stringContaining('projectId: "weather-graph"'));
+            expect(fs.writeFile).toHaveBeenCalledWith('src/weather-project/inkeep.config.ts', expect.stringContaining('projectId: "weather-project"'));
         });
     });
     describe('Template provided', () => {
@@ -99,37 +101,39 @@ describe('createAgents - Template and Project ID Logic', () => {
                 dirName: 'test-dir',
                 template: 'chatbot',
                 openAiKey: 'test-openai-key',
-                anthropicKey: 'test-anthropic-key'
+                anthropicKey: 'test-anthropic-key',
             });
             // Should validate template exists
             expect(getAvailableTemplates).toHaveBeenCalled();
             // Should clone base template and the specified template
             expect(cloneTemplate).toHaveBeenCalledTimes(2);
             expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/create-agents-template', expect.any(String));
-            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents-cookbook/templates/chatbot', 'src/chatbot');
-            // Should create config files with template name as project ID
-            expect(fs.writeFile).toHaveBeenCalledWith('src/chatbot/.env', expect.any(String));
+            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents-cookbook/template-projects/chatbot', 'src/chatbot');
             expect(fs.writeFile).toHaveBeenCalledWith('src/chatbot/inkeep.config.ts', expect.stringContaining('projectId: "chatbot"'));
         });
         it('should exit with error when template does not exist', async () => {
-            vi.mocked(getAvailableTemplates).mockResolvedValue(['weather-graph', 'chatbot']);
+            vi.mocked(getAvailableTemplates).mockResolvedValue(['weather-project', 'chatbot']);
             await expect(createAgents({
                 dirName: 'test-dir',
                 template: 'non-existent-template',
-                openAiKey: 'test-openai-key'
+                openAiKey: 'test-openai-key',
             })).rejects.toThrow('process.exit called');
             expect(p.cancel).toHaveBeenCalledWith(expect.stringContaining('Template "non-existent-template" not found'));
             expect(processExitSpy).toHaveBeenCalledWith(0);
         });
         it('should show available templates when invalid template is provided', async () => {
-            vi.mocked(getAvailableTemplates).mockResolvedValue(['weather-graph', 'chatbot', 'data-analysis']);
+            vi.mocked(getAvailableTemplates).mockResolvedValue([
+                'weather-project',
+                'chatbot',
+                'data-analysis',
+            ]);
             await expect(createAgents({
                 dirName: 'test-dir',
                 template: 'invalid',
-                openAiKey: 'test-openai-key'
+                openAiKey: 'test-openai-key',
             })).rejects.toThrow('process.exit called');
             const cancelCall = vi.mocked(p.cancel).mock.calls[0][0];
-            expect(cancelCall).toContain('weather-graph');
+            expect(cancelCall).toContain('weather-project');
             expect(cancelCall).toContain('chatbot');
             expect(cancelCall).toContain('data-analysis');
         });
@@ -140,7 +144,7 @@ describe('createAgents - Template and Project ID Logic', () => {
                 dirName: 'test-dir',
                 customProjectId: 'my-custom-project',
                 openAiKey: 'test-openai-key',
-                anthropicKey: 'test-anthropic-key'
+                anthropicKey: 'test-anthropic-key',
             });
             // Should clone base template but NOT project template
             expect(cloneTemplate).toHaveBeenCalledTimes(1);
@@ -149,8 +153,6 @@ describe('createAgents - Template and Project ID Logic', () => {
             expect(getAvailableTemplates).not.toHaveBeenCalled();
             // Should create empty project directory
             expect(fs.ensureDir).toHaveBeenCalledWith('src/my-custom-project');
-            // Should create config files with custom project ID
-            expect(fs.writeFile).toHaveBeenCalledWith('src/my-custom-project/.env', expect.any(String));
             expect(fs.writeFile).toHaveBeenCalledWith('src/my-custom-project/inkeep.config.ts', expect.stringContaining('projectId: "my-custom-project"'));
         });
         it('should prioritize custom project ID over template if both are provided', async () => {
@@ -159,7 +161,7 @@ describe('createAgents - Template and Project ID Logic', () => {
                 template: 'chatbot',
                 customProjectId: 'my-custom-project',
                 openAiKey: 'test-openai-key',
-                anthropicKey: 'test-anthropic-key'
+                anthropicKey: 'test-anthropic-key',
             });
             // Should only clone base template, not project template
             expect(cloneTemplate).toHaveBeenCalledTimes(1);
@@ -172,22 +174,25 @@ describe('createAgents - Template and Project ID Logic', () => {
     });
     describe('Edge cases and validation', () => {
         it('should handle template names with hyphens correctly', async () => {
-            vi.mocked(getAvailableTemplates).mockResolvedValue(['my-complex-template', 'another-template']);
+            vi.mocked(getAvailableTemplates).mockResolvedValue([
+                'my-complex-template',
+                'another-template',
+            ]);
             await createAgents({
                 dirName: 'test-dir',
                 template: 'my-complex-template',
                 openAiKey: 'test-key',
-                anthropicKey: 'test-key'
+                anthropicKey: 'test-key',
             });
             expect(cloneTemplate).toHaveBeenCalledTimes(2);
-            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents-cookbook/templates/my-complex-template', 'src/my-complex-template');
+            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents-cookbook/template-projects/my-complex-template', 'src/my-complex-template');
         });
         it('should handle custom project IDs with special characters', async () => {
             await createAgents({
                 dirName: 'test-dir',
                 customProjectId: 'my_project-123',
                 openAiKey: 'test-key',
-                anthropicKey: 'test-key'
+                anthropicKey: 'test-key',
             });
             expect(fs.ensureDir).toHaveBeenCalledWith('src/my_project-123');
             expect(fs.writeFile).toHaveBeenCalledWith('src/my_project-123/inkeep.config.ts', expect.stringContaining('projectId: "my_project-123"'));
@@ -197,7 +202,7 @@ describe('createAgents - Template and Project ID Logic', () => {
             await createAgents({
                 dirName: 'dir1',
                 openAiKey: 'key',
-                anthropicKey: 'key'
+                anthropicKey: 'key',
             });
             expect(fs.ensureDir).toHaveBeenCalledWith('src');
             // Reset mocks
@@ -208,7 +213,7 @@ describe('createAgents - Template and Project ID Logic', () => {
                 dirName: 'dir2',
                 template: 'chatbot',
                 openAiKey: 'key',
-                anthropicKey: 'key'
+                anthropicKey: 'key',
             });
             expect(fs.ensureDir).toHaveBeenCalledWith('src');
             // Reset mocks
@@ -219,7 +224,7 @@ describe('createAgents - Template and Project ID Logic', () => {
                 dirName: 'dir3',
                 customProjectId: 'custom',
                 openAiKey: 'key',
-                anthropicKey: 'key'
+                anthropicKey: 'key',
             });
             expect(fs.ensureDir).toHaveBeenCalledWith('src');
             expect(fs.ensureDir).toHaveBeenCalledWith('src/custom');
@@ -232,6 +237,10 @@ function setupDefaultMocks() {
     vi.mocked(fs.pathExists).mockResolvedValue(false);
     vi.mocked(fs.ensureDir).mockResolvedValue(undefined);
     vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-    vi.mocked(getAvailableTemplates).mockResolvedValue(['weather-graph', 'chatbot', 'data-analysis']);
+    vi.mocked(getAvailableTemplates).mockResolvedValue([
+        'weather-project',
+        'chatbot',
+        'data-analysis',
+    ]);
     vi.mocked(cloneTemplate).mockResolvedValue(undefined);
 }

package/dist/templates.js

@@ -1,5 +1,5 @@
-import fs from 'fs-extra';
 import degit from 'degit';
+import fs from 'fs-extra';
 //Duplicating function here so we dont have to add a dependency on the agents-cli package
 export async function cloneTemplate(templatePath, targetPath) {
     await fs.mkdir(targetPath, { recursive: true });
@@ -14,9 +14,7 @@ export async function cloneTemplate(templatePath, targetPath) {
 }
 export async function getAvailableTemplates() {
     // Fetch the list of templates from your repo
-    const response = await fetch('https://api.github.com/repos/inkeep/agents-cookbook/contents/templates');
+    const response = await fetch('https://api.github.com/repos/inkeep/agents-cookbook/contents/template-projects');
     const contents = await response.json();
-    return contents
-        .filter((item) => item.type === 'dir')
-        .map((item) => item.name);
+    return contents.filter((item) => item.type === 'dir').map((item) => item.name);
 }

package/dist/utils.js

@@ -66,8 +66,8 @@ export const createAgents = async (args = {}) => {
     }
     else {
         // No template or custom project ID provided - use defaults
-        projectId = 'weather-graph';
-        templateName = 'weather-graph';
+        projectId = 'weather-project';
+        templateName = 'weather-project';
     }
     p.intro(color.inverse(' Create Agents Directory '));
     // Prompt for directory name if not provided
@@ -93,11 +93,11 @@ export const createAgents = async (args = {}) => {
     // If keys aren't provided via CLI args, prompt for provider selection and keys
     if (!anthropicKey && !openAiKey) {
         const providerChoice = await p.select({
-            message: 'Which AI provider(s) would you like to use?',
+            message: 'Which AI provider would you like to use?',
             options: [
-                { value: 'anthropic', label: 'Anthropic only' },
-                { value: 'openai', label: 'OpenAI only' },
-                { value: 'google', label: 'Google only' },
+                { value: 'anthropic', label: 'Anthropic' },
+                { value: 'openai', label: 'OpenAI' },
+                { value: 'google', label: 'Google' },
             ],
         });
         if (p.isCancel(providerChoice)) {
@@ -172,7 +172,7 @@ export const createAgents = async (args = {}) => {
     try {
         const agentsTemplateRepo = 'https://github.com/inkeep/create-agents-template';
         const projectTemplateRepo = templateName
-            ? `https://github.com/inkeep/agents-cookbook/templates/${templateName}`
+            ? `https://github.com/inkeep/agents-cookbook/template-projects/${templateName}`
             : null;
         const directoryPath = path.resolve(process.cwd(), dirName);
         // Check if directory already exists
@@ -199,6 +199,7 @@ export const createAgents = async (args = {}) => {
             projectId,
             openAiKey,
             anthropicKey,
+            googleKey,
             manageApiPort: manageApiPort || '3002',
             runApiPort: runApiPort || '3003',
             modelSettings: defaultModelSettings,
@@ -223,9 +224,6 @@ export const createAgents = async (args = {}) => {
         // create or overwrite inkeep.config.ts
         s.message('Creating inkeep.config.ts...');
         await createInkeepConfig(config);
-        // Create service files
-        s.message('Creating service files...');
-        await createServiceFiles(config);
         // Install dependencies
         s.message('Installing dependencies (this may take a while)...');
         await installDependencies();
@@ -272,51 +270,29 @@ async function createEnvironmentFiles(config) {
 ENVIRONMENT=development
 
 # Database
-DB_FILE_NAME=file:./local.db
+DB_FILE_NAME=file:${process.cwd()}/local.db
 
 # AI Provider Keys  
 ANTHROPIC_API_KEY=${config.anthropicKey || 'your-anthropic-key-here'}
 OPENAI_API_KEY=${config.openAiKey || 'your-openai-key-here'}
 GOOGLE_GENERATIVE_AI_API_KEY=${config.googleKey || 'your-google-key-here'}
-`;
-    await fs.writeFile('.env', envContent);
-    // Create .env.example
-    const envExample = envContent.replace(/=.+$/gm, '=');
-    await fs.writeFile('.env.example', envExample);
-    // Create .env files for each API service
-    const runApiEnvContent = `# Environment
-ENVIRONMENT=development
 
-# Database (relative path from API directory)
-DB_FILE_NAME=file:../../local.db
+# Inkeep API URLs
+INKEEP_AGENTS_MANAGE_API_URL="http://localhost:3002"
+INKEEP_AGENTS_RUN_API_URL="http://localhost:3003"
 
-# AI Provider Keys  
-ANTHROPIC_API_KEY=${config.anthropicKey || 'your-anthropic-key-here'}
-OPENAI_API_KEY=${config.openAiKey || 'your-openai-key-here'}
-GOOGLE_GENERATIVE_AI_API_KEY=${config.googleKey || 'your-google-key-here'}
+# SigNoz Configuration
+SIGNOZ_URL=your-signoz-url-here
+SIGNOZ_API_KEY=your-signoz-api-key-here
 
-AGENTS_RUN_API_URL=http://localhost:${config.runApiPort}
-`;
-    const manageApiEnvContent = `# Environment
-ENVIRONMENT=development
-
-# Database (relative path from API directory)
-DB_FILE_NAME=file:../../local.db
+# OTEL Configuration
+OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://ingest.us.signoz.cloud:443/v1/traces
+OTEL_EXPORTER_OTLP_TRACES_HEADERS="signoz-ingestion-key=<your-ingestion-key>"
 
-AGENTS_MANAGE_API_URL=http://localhost:${config.manageApiPort}
+# Nango Configuration
+NANGO_SECRET_KEY=
 `;
-    await fs.writeFile('apps/manage-api/.env', manageApiEnvContent);
-    await fs.writeFile('apps/run-api/.env', runApiEnvContent);
-}
-async function createServiceFiles(config) {
-    // Create .env file for the project directory (for inkeep CLI commands)
-    const projectEnvContent = `# Environment
-ENVIRONMENT=development
-
-# Database (relative path from project directory)
-DB_FILE_NAME=file:../../local.db
-`;
-    await fs.writeFile(`src/${config.projectId}/.env`, projectEnvContent);
+    await fs.writeFile('.env', envContent);
 }
 async function createInkeepConfig(config) {
     const inkeepConfig = `import { defineConfig } from '@inkeep/agents-cli/config';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/create-agents",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Create an Inkeep Agent Framework project",
   "type": "module",
   "bin": {