@inkeep/create-agents 0.0.0-chat-to-edit-20251119071712

package/dist/__tests__/e2e/utils.js

@@ -0,0 +1,217 @@
+import os from 'node:os';
+import path, { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execa } from 'execa';
+import fs from 'fs-extra';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+ * Run the create-agents CLI with the given arguments
+ */
+export async function runCreateAgentsCLI(args, cwd, timeout = 300000 // 5 minutes default for full flow
+) {
+    const cliPath = path.join(__dirname, '../../../src/index.ts');
+    try {
+        // Run using tsx to execute TypeScript directly
+        const result = await execa('tsx', [cliPath, ...args], {
+            cwd,
+            timeout,
+            env: { ...process.env, FORCE_COLOR: '0' }, // Disable colors for easier assertion
+            all: true, // Capture combined stdout + stderr in order
+        });
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            exitCode: result.exitCode,
+        };
+    }
+    catch (error) {
+        // execa throws on non-zero exit codes, capture the error info
+        return {
+            stdout: error.stdout || '',
+            stderr: error.stderr || '',
+            exitCode: error.exitCode || 1,
+        };
+    }
+}
+/**
+ * Run a command in the created project directory
+ */
+export async function runCommand(command, args, cwd, timeout = 120000 // 2 minutes default
+) {
+    try {
+        const result = await execa(command, args, {
+            cwd,
+            timeout,
+            env: { ...process.env, FORCE_COLOR: '0' },
+            shell: true,
+        });
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            exitCode: result.exitCode,
+        };
+    }
+    catch (error) {
+        return {
+            stdout: error.stdout || '',
+            stderr: error.stderr || '',
+            exitCode: error.exitCode || 1,
+        };
+    }
+}
+/**
+ * Create a temporary directory for testing
+ */
+export async function createTempDir(prefix = 'create-agents-e2e-') {
+    return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+/**
+ * Clean up a test directory with retries
+ */
+export async function cleanupDir(dir) {
+    if (!(await fs.pathExists(dir))) {
+        return;
+    }
+    try {
+        // Try multiple times with delays (common in CI)
+        for (let i = 0; i < 3; i++) {
+            try {
+                await fs.remove(dir);
+                return;
+            }
+            catch (error) {
+                if (i === 2)
+                    throw error; // Last attempt, throw the error
+                await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait 1s before retry
+            }
+        }
+    }
+    catch (error) {
+        // If still failing, try force removal
+        if (error.code === 'ENOTEMPTY' || error.code === 'EBUSY') {
+            await execa('rm', ['-rf', dir], { shell: true }).catch(() => {
+                console.warn(`Failed to clean up ${dir}`);
+            });
+        }
+    }
+}
+/**
+ * Verify that a file exists and optionally check its contents
+ */
+export async function verifyFile(filePath, expectedContents) {
+    const exists = await fs.pathExists(filePath);
+    if (!exists) {
+        throw new Error(`Expected file to exist: ${filePath}`);
+    }
+    if (expectedContents) {
+        const content = await fs.readFile(filePath, 'utf-8');
+        for (const expected of expectedContents) {
+            if (typeof expected === 'string') {
+                if (!content.includes(expected)) {
+                    throw new Error(`Expected file ${filePath} to contain: ${expected}`);
+                }
+            }
+            else {
+                if (!expected.test(content)) {
+                    throw new Error(`Expected file ${filePath} to match pattern: ${expected}`);
+                }
+            }
+        }
+    }
+}
+/**
+ * Verify that a directory has the expected structure
+ */
+export async function verifyDirectoryStructure(baseDir, expectedPaths) {
+    for (const expectedPath of expectedPaths) {
+        const fullPath = path.join(baseDir, expectedPath);
+        const exists = await fs.pathExists(fullPath);
+        if (!exists) {
+            throw new Error(`Expected path to exist: ${fullPath}`);
+        }
+    }
+}
+/**
+ * Link local monorepo packages to the created project
+ * This replaces published @inkeep packages with local versions for testing
+ */
+export async function linkLocalPackages(projectDir, monorepoRoot) {
+    const packageJsonPaths = [
+        path.join(projectDir, 'package.json'),
+        path.join(projectDir, 'apps/manage-api/package.json'),
+        path.join(projectDir, 'apps/run-api/package.json'),
+    ];
+    const packageJsons = {};
+    for (const packageJsonPath of packageJsonPaths) {
+        packageJsons[packageJsonPath] = await fs.readJson(packageJsonPath);
+    }
+    // Define local @inkeep packages to link
+    const inkeepPackages = {
+        '@inkeep/agents-sdk': `link:${path.join(monorepoRoot, 'packages/agents-sdk')}`,
+        '@inkeep/agents-core': `link:${path.join(monorepoRoot, 'packages/agents-core')}`,
+        '@inkeep/agents-manage-api': `link:${path.join(monorepoRoot, 'agents-manage-api')}`,
+        '@inkeep/agents-run-api': `link:${path.join(monorepoRoot, 'agents-run-api')}`,
+        '@inkeep/agents-cli': `link:${path.join(monorepoRoot, 'agents-cli')}`,
+    };
+    // Replace package versions with local links
+    for (const [pkg, linkPath] of Object.entries(inkeepPackages)) {
+        for (const packageJsonPath of packageJsonPaths) {
+            if (packageJsons[packageJsonPath].dependencies?.[pkg]) {
+                packageJsons[packageJsonPath].dependencies[pkg] = linkPath;
+            }
+            if (packageJsons[packageJsonPath].devDependencies?.[pkg]) {
+                packageJsons[packageJsonPath].devDependencies[pkg] = linkPath;
+            }
+        }
+    }
+    // Write updated package.json
+    for (const packageJsonPath of packageJsonPaths) {
+        await fs.writeJson(packageJsonPath, packageJsons[packageJsonPath], { spaces: 2 });
+    }
+    // Reinstall to create the symlinks
+    await execa('pnpm', ['install', '--no-frozen-lockfile'], {
+        cwd: projectDir,
+        env: { ...process.env, FORCE_COLOR: '0' },
+    });
+}
+/**
+ * Wait for a server to be ready by polling a health endpoint
+ */
+export async function waitForServerReady(url, timeout) {
+    const start = Date.now();
+    let lastError = null;
+    let attempts = 0;
+    console.log(`Waiting for server at ${url}...`);
+    while (Date.now() - start < timeout) {
+        attempts++;
+        try {
+            const response = await fetch(url, {
+                signal: AbortSignal.timeout(5000), // 5 second timeout per request
+            });
+            if (response.ok) {
+                console.log(`✓ Server ready at ${url} after ${attempts} attempts (${Date.now() - start}ms)`);
+                return;
+            }
+            lastError = new Error(`HTTP ${response.status}: ${response.statusText}`);
+            // Log status every 10 attempts in CI
+            if (process.env.CI && attempts % 10 === 0) {
+                console.log(`Still waiting for ${url}... (attempt ${attempts}, ${Math.floor((Date.now() - start) / 1000)}s elapsed)`);
+            }
+        }
+        catch (error) {
+            // Server not ready yet or connection refused
+            lastError = error instanceof Error ? error : new Error(String(error));
+            // Log connection errors periodically in CI
+            if (process.env.CI && attempts % 15 === 0) {
+                console.log(`Connection attempt ${attempts} failed: ${lastError.message}`);
+            }
+        }
+        // Wait before next attempt (exponential backoff up to 5s)
+        const waitTime = Math.min(1000 + attempts * 100, 5000);
+        await new Promise((resolve) => setTimeout(resolve, waitTime));
+    }
+    // Timeout reached - provide detailed error
+    const elapsed = Date.now() - start;
+    const errorDetails = lastError ? `: ${lastError.message}` : '';
+    throw new Error(`Server not ready at ${url} after ${elapsed}ms (${attempts} attempts)${errorDetails}`);
+}

package/dist/__tests__/templates.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/templates.test.js

@@ -0,0 +1,283 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { cloneTemplate, replaceContentInFiles, replaceObjectProperties, } from '../templates';
+// Mock dependencies
+vi.mock('fs-extra');
+vi.mock('degit', () => ({
+    default: vi.fn(() => ({
+        clone: vi.fn().mockResolvedValue(undefined),
+    })),
+}));
+describe('Template Content Replacement', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Setup default fs-extra mocks
+        vi.mocked(fs.pathExists).mockResolvedValue(true);
+        vi.mocked(fs.readFile).mockResolvedValue('');
+        vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+        vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+    });
+    describe('replaceObjectProperties', () => {
+        it('should replace a simple object property', async () => {
+            const content = `export const myProject = project({
+  id: 'test-project',
+  models: {
+    base: {
+      model: 'gpt-4o-mini',
+    },
+  },
+});`;
+            const replacement = {
+                base: {
+                    model: 'anthropic/claude-3-5-haiku-20241022',
+                },
+                summarizer: {
+                    model: 'anthropic/claude-3-5-haiku-20241022',
+                },
+            };
+            const result = await replaceObjectProperties(content, { models: replacement });
+            expect(result).toContain("'model': 'anthropic/claude-3-5-haiku-20241022'");
+            expect(result).toContain("'summarizer'");
+            expect(result).not.toContain('gpt-4o-mini');
+        });
+        it('should handle nested objects correctly', async () => {
+            const content = `export const config = {
+  models: {
+    base: {
+      model: 'old-model',
+      temperature: 0.5,
+    },
+    structured: {
+      model: 'old-structured',
+    }
+  },
+  other: 'value'
+};`;
+            const replacement = {
+                base: {
+                    model: 'new-model',
+                    temperature: 0.8,
+                },
+                structured: {
+                    model: 'new-structured',
+                },
+            };
+            const result = await replaceObjectProperties(content, { models: replacement });
+            expect(result).toContain("'model': 'new-model'");
+            expect(result).toContain("'model': 'new-structured'");
+            expect(result).toContain("'temperature': 0.8");
+            expect(result).toContain("other: 'value'");
+            expect(result).not.toContain('old-model');
+        });
+        it('should preserve code structure and formatting', async () => {
+            const content = `const project = {
+  id: 'test',
+  models: {
+    base: { model: 'old' }
+  },
+  description: 'test project'
+};`;
+            const replacement = { base: { model: 'new' } };
+            const result = await replaceObjectProperties(content, { models: replacement });
+            expect(result).toContain("id: 'test'");
+            expect(result).toContain("description: 'test project'");
+            expect(result).toContain("'model': 'new'");
+        });
+        it('should handle multiple property replacements', async () => {
+            const content = `export const config = {
+  models: { base: { model: 'old1' } },
+  tools: { search: { enabled: false } },
+  data: 'keep this'
+};`;
+            const replacements = {
+                models: { base: { model: 'new1' } },
+                tools: { search: { enabled: true }, newTool: { type: 'api' } },
+            };
+            const result = await replaceObjectProperties(content, replacements);
+            expect(result).toContain("'model': 'new1'");
+            expect(result).toContain("'enabled': true");
+            expect(result).toContain("'newTool'");
+            expect(result).toContain("data: 'keep this'");
+        });
+    });
+    describe('replaceContentInFiles', () => {
+        it('should process multiple files with replacements', async () => {
+            const replacements = [
+                {
+                    filePath: 'index.ts',
+                    replacements: {
+                        models: { base: { model: 'new-model' } },
+                    },
+                },
+                {
+                    filePath: 'config.ts',
+                    replacements: {
+                        settings: { debug: true },
+                    },
+                },
+            ];
+            const indexContent = `export const project = { models: { base: { model: 'old' } } };`;
+            const configContent = `export const config = { settings: { debug: false } };`;
+            vi.mocked(fs.readFile)
+                .mockResolvedValueOnce(indexContent)
+                .mockResolvedValueOnce(configContent);
+            await replaceContentInFiles('/target/path', replacements);
+            expect(fs.readFile).toHaveBeenCalledTimes(2);
+            expect(fs.readFile).toHaveBeenCalledWith(path.join('/target/path', 'index.ts'), 'utf-8');
+            expect(fs.readFile).toHaveBeenCalledWith(path.join('/target/path', 'config.ts'), 'utf-8');
+            expect(fs.writeFile).toHaveBeenCalledTimes(2);
+            // Verify the content contains the replacements
+            const writeCalls = vi.mocked(fs.writeFile).mock.calls;
+            expect(writeCalls[0][1]).toContain("'model': 'new-model'");
+            expect(writeCalls[1][1]).toContain("'debug': true");
+        });
+        it('should warn and skip non-existent files', async () => {
+            const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+            vi.mocked(fs.pathExists).mockResolvedValue(false);
+            const replacements = [
+                {
+                    filePath: 'non-existent.ts',
+                    replacements: { test: 'value' },
+                },
+            ];
+            await replaceContentInFiles('/target/path', replacements);
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('non-existent.ts'));
+            expect(fs.readFile).not.toHaveBeenCalled();
+            expect(fs.writeFile).not.toHaveBeenCalled();
+            consoleSpy.mockRestore();
+        });
+    });
+    describe('cloneTemplate with replacements', () => {
+        it('should clone template and apply replacements', async () => {
+            const degit = await import('degit');
+            const mockEmitter = { clone: vi.fn().mockResolvedValue(undefined) };
+            vi.mocked(degit.default).mockReturnValue(mockEmitter);
+            const replacements = [
+                {
+                    filePath: 'index.ts',
+                    replacements: {
+                        models: { base: { model: 'new-model' } },
+                    },
+                },
+            ];
+            const fileContent = `export const project = { models: { base: { model: 'old' } } };`;
+            vi.mocked(fs.readFile).mockResolvedValue(fileContent);
+            await cloneTemplate('https://github.com/test/repo', '/target/path', replacements);
+            expect(mockEmitter.clone).toHaveBeenCalledWith('/target/path');
+            expect(fs.readFile).toHaveBeenCalledWith(path.join('/target/path', 'index.ts'), 'utf-8');
+            expect(fs.writeFile).toHaveBeenCalledWith(path.join('/target/path', 'index.ts'), expect.stringContaining("'model': 'new-model'"), 'utf-8');
+        });
+        it('should clone template without replacements when none provided', async () => {
+            const degit = await import('degit');
+            const mockEmitter = { clone: vi.fn().mockResolvedValue(undefined) };
+            vi.mocked(degit.default).mockReturnValue(mockEmitter);
+            await cloneTemplate('https://github.com/test/repo', '/target/path');
+            expect(mockEmitter.clone).toHaveBeenCalledWith('/target/path');
+            expect(fs.readFile).not.toHaveBeenCalled();
+            expect(fs.writeFile).not.toHaveBeenCalled();
+        });
+        it('should handle clone errors gracefully', async () => {
+            const degit = await import('degit');
+            const mockEmitter = { clone: vi.fn().mockRejectedValue(new Error('Clone failed')) };
+            vi.mocked(degit.default).mockReturnValue(mockEmitter);
+            const processExitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {
+                throw new Error('process.exit called');
+            });
+            await expect(cloneTemplate('https://github.com/test/repo', '/target/path')).rejects.toThrow('process.exit called');
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+            processExitSpy.mockRestore();
+        });
+    });
+    describe('Integration tests', () => {
+        it('should handle real-world TypeScript project structure', async () => {
+            const projectContent = `import { project } from '@inkeep/agents-sdk';
+import { weatherAgent } from './agent/weather-agent';
+
+export const myProject = project({
+  id: 'weather-project',
+  name: 'Weather Project',
+  description: 'Weather project template',
+  agent: () => [weatherAgent],
+  models: {
+    base: {
+      model: 'gpt-4o-mini',
+    },
+    structuredOutput: {
+      model: 'gpt-4o-mini',
+    },
+    summarizer: {
+      model: 'gpt-4o-mini',
+    }
+  },
+});`;
+            const newModels = {
+                base: {
+                    model: 'anthropic/claude-3-5-haiku-20241022',
+                },
+                structuredOutput: {
+                    model: 'anthropic/claude-3-5-haiku-20241022',
+                },
+                summarizer: {
+                    model: 'anthropic/claude-3-5-haiku-20241022',
+                },
+            };
+            const result = await replaceObjectProperties(projectContent, { models: newModels });
+            // Should preserve imports and structure
+            expect(result).toContain("import { project } from '@inkeep/agents-sdk'");
+            expect(result).toContain("import { weatherAgent } from './agent/weather-agent'");
+            expect(result).toContain("id: 'weather-project'");
+            expect(result).toContain("name: 'Weather Project'");
+            expect(result).toContain('agent: () => [weatherAgent]');
+            // Should replace all model configurations
+            expect(result).toContain('anthropic/claude-3-5-haiku-20241022');
+            expect(result).not.toContain('gpt-4o-mini');
+            // Should maintain proper structure
+            expect(result).toContain("'base': {");
+            expect(result).toContain("'structuredOutput': {");
+            expect(result).toContain("'summarizer': {");
+        });
+        it('should handle edge cases in TypeScript syntax', async () => {
+            const content = `export const config = {
+  models: {
+    base: { model: "double-quotes" },
+    other: { 
+      model: 'single-quotes',
+      nested: { value: true }
+    },
+  },
+  // Comment here
+  data: 'preserve me'
+};`;
+            const replacement = {
+                base: { model: 'new-base' },
+                other: { model: 'new-other', nested: { value: false } },
+            };
+            const result = await replaceObjectProperties(content, { models: replacement });
+            expect(result).toContain("'model': 'new-base'");
+            expect(result).toContain("'model': 'new-other'");
+            expect(result).toContain("'value': false");
+            expect(result).toContain('// Comment here');
+            expect(result).toContain("data: 'preserve me'");
+        });
+        it('should inject models property when it does not exist', async () => {
+            const content = `export const myProject = project({
+  id: 'test-project',
+  name: 'Test Project',
+  description: 'A test project without models',
+  agent: () => [],
+});`;
+            const replacement = {
+                base: { model: 'anthropic/claude-3-5-haiku-20241022' },
+                structuredOutput: { model: 'anthropic/claude-3-5-haiku-20241022' },
+            };
+            const result = await replaceObjectProperties(content, { models: replacement });
+            expect(result).toContain('models:');
+            expect(result).toContain("'base': {");
+            expect(result).toContain("'model': 'anthropic/claude-3-5-haiku-20241022'");
+            expect(result).toContain("'structuredOutput': {");
+            expect(result).toContain("id: 'test-project'");
+            expect(result).toContain('agent: () => []');
+        });
+    });
+});

package/dist/__tests__/utils.test.d.ts

@@ -0,0 +1 @@
+export {};