@inkeep/create-agents 0.8.0 → 0.8.2

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 { weatherGraph } from './graphs/weather-graph';
+
+export const myProject = project({
+  id: 'weather-project',
+  name: 'Weather Project',
+  description: 'Weather project template',
+  graphs: () => [weatherGraph],
+  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 { weatherGraph } from './graphs/weather-graph'");
+            expect(result).toContain("id: 'weather-project'");
+            expect(result).toContain("name: 'Weather Project'");
+            expect(result).toContain('graphs: () => [weatherGraph]');
+            // 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',
+  graphs: () => [],
+});`;
+            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('graphs: () => []');
+        });
+    });
+});

package/dist/__tests__/utils.test.js

@@ -81,7 +81,14 @@ describe('createAgents - Template and Project ID Logic', () => {
             // 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/template-projects/weather-project', 'src/weather-project');
+            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents-cookbook/template-projects/weather-project', 'src/weather-project', expect.arrayContaining([
+                expect.objectContaining({
+                    filePath: 'index.ts',
+                    replacements: expect.objectContaining({
+                        models: expect.any(Object)
+                    })
+                })
+            ]));
             // Should not call getAvailableTemplates since no template validation needed
             expect(getAvailableTemplates).not.toHaveBeenCalled();
         });
@@ -91,8 +98,10 @@ describe('createAgents - Template and Project ID Logic', () => {
                 openAiKey: 'test-openai-key',
                 anthropicKey: 'test-anthropic-key',
             });
-            // Check that inkeep.config.ts is created with correct project ID
-            expect(fs.writeFile).toHaveBeenCalledWith('src/weather-project/inkeep.config.ts', expect.stringContaining('projectId: "weather-project"'));
+            // Check that .env file is created
+            expect(fs.writeFile).toHaveBeenCalledWith('.env', expect.stringContaining('ENVIRONMENT=development'));
+            // Check that inkeep.config.ts is created in src directory
+            expect(fs.writeFile).toHaveBeenCalledWith('src/inkeep.config.ts', expect.stringContaining('tenantId: "default"'));
         });
     });
     describe('Template provided', () => {
@@ -108,8 +117,18 @@ describe('createAgents - Template and Project ID Logic', () => {
             // 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/template-projects/chatbot', 'src/chatbot');
-            expect(fs.writeFile).toHaveBeenCalledWith('src/chatbot/inkeep.config.ts', expect.stringContaining('projectId: "chatbot"'));
+            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents-cookbook/template-projects/chatbot', 'src/chatbot', expect.arrayContaining([
+                expect.objectContaining({
+                    filePath: 'index.ts',
+                    replacements: expect.objectContaining({
+                        models: expect.any(Object)
+                    })
+                })
+            ]));
+            // Check that .env file is created
+            expect(fs.writeFile).toHaveBeenCalledWith('.env', expect.stringContaining('ENVIRONMENT=development'));
+            // Check that inkeep.config.ts is created in src directory (not in project subdirectory)
+            expect(fs.writeFile).toHaveBeenCalledWith('src/inkeep.config.ts', expect.stringContaining('tenantId: "default"'));
         });
         it('should exit with error when template does not exist', async () => {
             vi.mocked(getAvailableTemplates).mockResolvedValue(['weather-project', 'chatbot']);
@@ -153,7 +172,12 @@ describe('createAgents - Template and Project ID Logic', () => {
             expect(getAvailableTemplates).not.toHaveBeenCalled();
             // Should create empty project directory
             expect(fs.ensureDir).toHaveBeenCalledWith('src/my-custom-project');
-            expect(fs.writeFile).toHaveBeenCalledWith('src/my-custom-project/inkeep.config.ts', expect.stringContaining('projectId: "my-custom-project"'));
+            // Check that .env file is created
+            expect(fs.writeFile).toHaveBeenCalledWith('.env', expect.stringContaining('ENVIRONMENT=development'));
+            // Check that inkeep.config.ts is created in src directory
+            expect(fs.writeFile).toHaveBeenCalledWith('src/inkeep.config.ts', expect.stringContaining('tenantId: "default"'));
+            // Check that custom project index.ts is created
+            expect(fs.writeFile).toHaveBeenCalledWith('src/my-custom-project/index.ts', expect.stringContaining('id: "my-custom-project"'));
         });
         it('should prioritize custom project ID over template if both are provided', async () => {
             await createAgents({
@@ -168,8 +192,12 @@ describe('createAgents - Template and Project ID Logic', () => {
             expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/create-agents-template', expect.any(String));
             expect(getAvailableTemplates).not.toHaveBeenCalled();
             expect(fs.ensureDir).toHaveBeenCalledWith('src/my-custom-project');
-            // Config should use custom project ID
-            expect(fs.writeFile).toHaveBeenCalledWith('src/my-custom-project/inkeep.config.ts', expect.stringContaining('projectId: "my-custom-project"'));
+            // Check that .env file is created
+            expect(fs.writeFile).toHaveBeenCalledWith('.env', expect.stringContaining('ENVIRONMENT=development'));
+            // Check that inkeep.config.ts is created in src directory
+            expect(fs.writeFile).toHaveBeenCalledWith('src/inkeep.config.ts', expect.stringContaining('tenantId: "default"'));
+            // Check that custom project index.ts is created
+            expect(fs.writeFile).toHaveBeenCalledWith('src/my-custom-project/index.ts', expect.stringContaining('id: "my-custom-project"'));
         });
     });
     describe('Edge cases and validation', () => {
@@ -185,7 +213,14 @@ describe('createAgents - Template and Project ID Logic', () => {
                 anthropicKey: 'test-key',
             });
             expect(cloneTemplate).toHaveBeenCalledTimes(2);
-            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents-cookbook/template-projects/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', expect.arrayContaining([
+                expect.objectContaining({
+                    filePath: 'index.ts',
+                    replacements: expect.objectContaining({
+                        models: expect.any(Object)
+                    })
+                })
+            ]));
         });
         it('should handle custom project IDs with special characters', async () => {
             await createAgents({
@@ -195,7 +230,12 @@ describe('createAgents - Template and Project ID Logic', () => {
                 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"'));
+            // Check that .env file is created
+            expect(fs.writeFile).toHaveBeenCalledWith('.env', expect.stringContaining('ENVIRONMENT=development'));
+            // Check that inkeep.config.ts is created in src directory
+            expect(fs.writeFile).toHaveBeenCalledWith('src/inkeep.config.ts', expect.stringContaining('tenantId: "default"'));
+            // Check that custom project index.ts is created
+            expect(fs.writeFile).toHaveBeenCalledWith('src/my_project-123/index.ts', expect.stringContaining('id: "my_project-123"'));
         });
         it('should create correct folder structure for all scenarios', async () => {
             // Test default

package/dist/templates.d.ts

@@ -1,2 +1,16 @@
-export declare function cloneTemplate(templatePath: string, targetPath: string): Promise<void>;
+export interface ContentReplacement {
+    /** Relative file path within the cloned template */
+    filePath: string;
+    /** Object property replacements - key is the property path, value is the replacement content */
+    replacements: Record<string, any>;
+}
+export declare function cloneTemplate(templatePath: string, targetPath: string, replacements?: ContentReplacement[]): Promise<void>;
+/**
+ * Replace content in cloned template files
+ */
+export declare function replaceContentInFiles(targetPath: string, replacements: ContentReplacement[]): Promise<void>;
+/**
+ * Replace object properties in TypeScript code content
+ */
+export declare function replaceObjectProperties(content: string, replacements: Record<string, any>): Promise<string>;
 export declare function getAvailableTemplates(): Promise<string[]>;

package/dist/templates.js

@@ -1,17 +1,242 @@
+import path from 'node:path';
 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) {
+export async function cloneTemplate(templatePath, targetPath, replacements) {
     await fs.mkdir(targetPath, { recursive: true });
     const templatePathSuffix = templatePath.replace('https://github.com/', '');
     const emitter = degit(templatePathSuffix);
     try {
         await emitter.clone(targetPath);
+        // Apply content replacements if provided
+        if (replacements && replacements.length > 0) {
+            await replaceContentInFiles(targetPath, replacements);
+        }
     }
     catch (_error) {
         process.exit(1);
     }
 }
+/**
+ * Replace content in cloned template files
+ */
+export async function replaceContentInFiles(targetPath, replacements) {
+    for (const replacement of replacements) {
+        const filePath = path.join(targetPath, replacement.filePath);
+        // Check if file exists
+        if (!(await fs.pathExists(filePath))) {
+            console.warn(`Warning: File ${filePath} not found, skipping replacements`);
+            continue;
+        }
+        // Read the file content
+        const content = await fs.readFile(filePath, 'utf-8');
+        // Apply replacements
+        const updatedContent = await replaceObjectProperties(content, replacement.replacements);
+        // Write back to file
+        await fs.writeFile(filePath, updatedContent, 'utf-8');
+    }
+}
+/**
+ * Replace object properties in TypeScript code content
+ */
+export async function replaceObjectProperties(content, replacements) {
+    let updatedContent = content;
+    for (const [propertyPath, replacement] of Object.entries(replacements)) {
+        updatedContent = replaceObjectProperty(updatedContent, propertyPath, replacement);
+    }
+    return updatedContent;
+}
+/**
+ * Replace a specific object property in TypeScript code
+ * This implementation uses line-by-line parsing for better accuracy
+ * If the property doesn't exist, it will be added to the object
+ */
+function replaceObjectProperty(content, propertyPath, replacement) {
+    // Check if this is a single-line object format first (object all on one line)
+    const singleLineMatch = content.match(new RegExp(`^(.+{[^{}]*${propertyPath}\\s*:\\s*{[^{}]*}[^{}]*}.*)$`, 'm'));
+    if (singleLineMatch) {
+        // For single-line objects, handle replacement inline
+        const singleLinePattern = new RegExp(`((^|\\s|{)${propertyPath}\\s*:\\s*)({[^}]*})`);
+        return content.replace(singleLinePattern, `$1${JSON.stringify(replacement).replace(/"/g, "'").replace(/:/g, ': ').replace(/,/g, ', ')}`);
+    }
+    // Convert replacement to formatted JSON string with proper indentation
+    const replacementStr = JSON.stringify(replacement, null, 2).replace(/"/g, "'"); // Use single quotes for consistency with TS
+    const lines = content.split('\n');
+    const result = [];
+    let inTargetProperty = false;
+    let braceCount = 0;
+    let targetPropertyIndent = '';
+    let foundProperty = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmedLine = line.trim();
+        // Skip if we're currently inside the target property
+        if (inTargetProperty) {
+            // Count braces to track nesting
+            for (const char of line) {
+                if (char === '{')
+                    braceCount++;
+                if (char === '}')
+                    braceCount--;
+            }
+            // When braceCount reaches 0, we've found the end of the property
+            if (braceCount <= 0) {
+                // Check if there's a trailing comma on this line or the original property line
+                const hasTrailingComma = line.includes(',') ||
+                    (i + 1 < lines.length &&
+                        lines[i + 1].trim().startsWith('}') === false &&
+                        lines[i + 1].trim() !== '');
+                // Add the replacement with proper indentation
+                const indentedReplacement = replacementStr
+                    .split('\n')
+                    .map((replacementLine, index) => {
+                    if (index === 0) {
+                        return `${targetPropertyIndent}${propertyPath}: ${replacementLine}`;
+                    }
+                    return `${targetPropertyIndent}${replacementLine}`;
+                })
+                    .join('\n');
+                result.push(`${indentedReplacement}${hasTrailingComma ? ',' : ''}`);
+                inTargetProperty = false;
+                foundProperty = true;
+                continue;
+            }
+            // Skip all lines while inside the target property
+            continue;
+        }
+        // Check if this line contains the target property at the right level
+        const propertyPattern = new RegExp(`(^|\\s+)${propertyPath}\\s*:`);
+        if (trimmedLine.startsWith(`${propertyPath}:`) || propertyPattern.test(line)) {
+            inTargetProperty = true;
+            braceCount = 0;
+            // For single-line objects, use base indentation plus 2 spaces for properties
+            if (line.includes(' = { ')) {
+                // Single-line format: use base indentation
+                targetPropertyIndent = `${line.match(/^\s*/)?.[0] || ''}  `;
+            }
+            else {
+                // Multi-line format: calculate from property position
+                const propertyMatch = line.match(new RegExp(`(.*?)(^|\\s+)${propertyPath}\\s*:`));
+                targetPropertyIndent = propertyMatch ? propertyMatch[1] : line.match(/^\s*/)?.[0] || '';
+            }
+            // Count braces in the current line
+            for (const char of line) {
+                if (char === '{')
+                    braceCount++;
+                if (char === '}')
+                    braceCount--;
+            }
+            // If the property definition is on a single line (braceCount = 0)
+            if (braceCount <= 0) {
+                const hasTrailingComma = line.includes(',');
+                const indentedReplacement = replacementStr
+                    .split('\n')
+                    .map((replacementLine, index) => {
+                    if (index === 0) {
+                        return `${targetPropertyIndent}${propertyPath}: ${replacementLine}`;
+                    }
+                    return `${targetPropertyIndent}${replacementLine}`;
+                })
+                    .join('\n');
+                result.push(`${indentedReplacement}${hasTrailingComma ? ',' : ''}`);
+                inTargetProperty = false;
+                foundProperty = true;
+                continue;
+            }
+            // Continue to next iteration to process multi-line property
+            continue;
+        }
+        // If we're not in the target property, keep the line as-is
+        result.push(line);
+    }
+    // If property wasn't found, try to inject it into the object
+    if (!foundProperty) {
+        return injectPropertyIntoObject(result.join('\n'), propertyPath, replacement);
+    }
+    return result.join('\n');
+}
+/**
+ * Inject a new property into a TypeScript object when the property doesn't exist
+ */
+function injectPropertyIntoObject(content, propertyPath, replacement) {
+    const replacementStr = JSON.stringify(replacement, null, 2).replace(/"/g, "'"); // Use single quotes for consistency with TS
+    const lines = content.split('\n');
+    const result = [];
+    // Find the main object definition (looking for patterns like project({...})
+    let foundObjectStart = false;
+    let objectDepth = 0;
+    let insertionPoint = -1;
+    let baseIndent = '';
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmedLine = line.trim();
+        // Look for object patterns like "project({", "= {", etc.
+        if (!foundObjectStart &&
+            (trimmedLine.includes('({') || trimmedLine.endsWith(' = {') || line.includes(' = { '))) {
+            foundObjectStart = true;
+            baseIndent = line.match(/^\s*/)?.[0] || '';
+            objectDepth = 0;
+            // Count braces on this line
+            for (const char of line) {
+                if (char === '{')
+                    objectDepth++;
+                if (char === '}')
+                    objectDepth--;
+            }
+        }
+        else if (foundObjectStart) {
+            // Track brace depth
+            for (const char of line) {
+                if (char === '{')
+                    objectDepth++;
+                if (char === '}')
+                    objectDepth--;
+            }
+            // If we're at the end of the main object, this is our insertion point
+            if (objectDepth === 0 && trimmedLine.startsWith('}')) {
+                insertionPoint = i;
+                break;
+            }
+        }
+    }
+    // If we found an insertion point, add the property
+    if (insertionPoint !== -1) {
+        const propertyIndent = `${baseIndent}  `; // Add 2 spaces for property indent
+        // Check if we need a comma before our property
+        let needsCommaPrefix = false;
+        if (insertionPoint > 0) {
+            const prevLine = lines[insertionPoint - 1].trim();
+            needsCommaPrefix = prevLine !== '' && !prevLine.endsWith(',') && !prevLine.startsWith('}');
+        }
+        // Format the property to inject
+        const indentedReplacement = replacementStr
+            .split('\n')
+            .map((replacementLine, index) => {
+            if (index === 0) {
+                return `${propertyIndent}${propertyPath}: ${replacementLine}`;
+            }
+            return `${propertyIndent}${replacementLine}`;
+        })
+            .join('\n');
+        // Insert the property before the closing brace
+        for (let i = 0; i < lines.length; i++) {
+            if (i === insertionPoint) {
+                result.push(indentedReplacement);
+            }
+            // Add comma to previous line if needed and we're at the right position
+            if (i === insertionPoint - 1 && needsCommaPrefix) {
+                result.push(`${lines[i]},`);
+            }
+            else {
+                result.push(lines[i]);
+            }
+        }
+        return result.join('\n');
+    }
+    // If we couldn't find a suitable injection point, warn and return original
+    console.warn(`Could not inject property "${propertyPath}" - no suitable object found in content`);
+    return content;
+}
 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/template-projects');

package/dist/utils.js

@@ -1,9 +1,9 @@
-import * as p from '@clack/prompts';
 import { exec } from 'node:child_process';
-import fs from 'fs-extra';
 import path from 'node:path';
-import color from 'picocolors';
 import { promisify } from 'node:util';
+import * as p from '@clack/prompts';
+import fs from 'fs-extra';
+import color from 'picocolors';
 import { cloneTemplate, getAvailableTemplates } from './templates.js';
 const execAsync = promisify(exec);
 export const defaultGoogleModelConfigurations = {
@@ -215,7 +215,16 @@ export const createAgents = async (args = {}) => {
         if (projectTemplateRepo) {
             s.message('Creating project template folder...');
             const templateTargetPath = `src/${projectId}`;
-            await cloneTemplate(projectTemplateRepo, templateTargetPath);
+            // Prepare content replacements for model settings
+            const contentReplacements = [
+                {
+                    filePath: 'index.ts',
+                    replacements: {
+                        models: defaultModelSettings,
+                    },
+                },
+            ];
+            await cloneTemplate(projectTemplateRepo, templateTargetPath, contentReplacements);
         }
         else {
             s.message('Creating empty project folder...');
@@ -299,14 +308,12 @@ async function createInkeepConfig(config) {
 
   const config = defineConfig({
     tenantId: "${config.tenantId}",
-    projectId: "${config.projectId}",
     agentsManageApiUrl: 'http://localhost:3002',
     agentsRunApiUrl: 'http://localhost:3003',
-    modelSettings: ${JSON.stringify(config.modelSettings, null, 2)},
   });
       
   export default config;`;
-    await fs.writeFile(`src/${config.projectId}/inkeep.config.ts`, inkeepConfig);
+    await fs.writeFile(`src/inkeep.config.ts`, inkeepConfig);
     if (config.customProject) {
         const customIndexContent = `import { project } from '@inkeep/agents-sdk';
 
@@ -315,6 +322,7 @@ export const myProject = project({
   name: "${config.projectId}",
   description: "",
   graphs: () => [],
+  models: ${JSON.stringify(config.modelSettings, null, 2)},
 });`;
         await fs.writeFile(`src/${config.projectId}/index.ts`, customIndexContent);
     }

package/package.json

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