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

package/dist/__tests__/utils.test.js

@@ -0,0 +1,333 @@
+import * as p from '@clack/prompts';
+import fs from 'fs-extra';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { cloneTemplate, cloneTemplateLocal, getAvailableTemplates } from '../templates';
+import { createAgents } from '../utils';
+// Mock all dependencies
+vi.mock('fs-extra');
+vi.mock('../templates');
+vi.mock('@clack/prompts');
+vi.mock('child_process');
+vi.mock('util');
+// Setup default mocks
+const mockSpinner = {
+    start: vi.fn().mockReturnThis(),
+    stop: vi.fn().mockReturnThis(),
+    message: vi.fn().mockReturnThis(),
+};
+describe('createAgents - Template and Project ID Logic', () => {
+    let processExitSpy;
+    let processChdirSpy;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Mock process methods
+        processExitSpy = vi.spyOn(process, 'exit').mockImplementation((code) => {
+            // Only throw for exit(0) which is expected behavior in some tests
+            // Let exit(1) pass so we can see the actual error
+            if (code === 0) {
+                throw new Error('process.exit called');
+            }
+            // Don't actually exit for exit(1) in tests
+            return undefined;
+        });
+        processChdirSpy = vi.spyOn(process, 'chdir').mockImplementation(() => { });
+        // Setup default mocks for @clack/prompts
+        vi.mocked(p.intro).mockImplementation(() => { });
+        vi.mocked(p.outro).mockImplementation(() => { });
+        vi.mocked(p.cancel).mockImplementation(() => { });
+        vi.mocked(p.note).mockImplementation(() => { });
+        vi.mocked(p.text).mockResolvedValue('test-dir');
+        vi.mocked(p.password).mockResolvedValue('test-api-key');
+        vi.mocked(p.select).mockResolvedValue('dual');
+        vi.mocked(p.confirm).mockResolvedValue(false);
+        vi.mocked(p.spinner).mockReturnValue(mockSpinner);
+        vi.mocked(p.isCancel).mockReturnValue(false);
+        // Mock fs-extra
+        vi.mocked(fs.pathExists).mockResolvedValue(false);
+        vi.mocked(fs.ensureDir).mockResolvedValue(undefined);
+        vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+        vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+        vi.mocked(fs.remove).mockResolvedValue(undefined);
+        // Mock templates
+        vi.mocked(getAvailableTemplates).mockResolvedValue([
+            'event-planner',
+            'chatbot',
+            'data-analysis',
+        ]);
+        vi.mocked(cloneTemplate).mockResolvedValue(undefined);
+        vi.mocked(cloneTemplateLocal).mockResolvedValue(undefined);
+        // Mock util.promisify to return a mock exec function
+        const mockExecAsync = vi.fn().mockResolvedValue({ stdout: '', stderr: '' });
+        const util = require('node:util');
+        util.promisify = vi.fn(() => mockExecAsync);
+        // Mock child_process.spawn
+        const childProcess = require('node:child_process');
+        childProcess.spawn = vi.fn(() => ({
+            pid: 12345,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            on: vi.fn(),
+            kill: vi.fn(),
+        }));
+    });
+    afterEach(() => {
+        processExitSpy.mockRestore();
+        processChdirSpy.mockRestore();
+    });
+    describe('Default behavior (no template or customProjectId)', () => {
+        it('should use activies-planner as default template and project ID', async () => {
+            await createAgents({
+                dirName: 'test-dir',
+                openAiKey: 'test-openai-key',
+                anthropicKey: 'test-anthropic-key',
+            });
+            // Should clone base template and activities-planner template
+            expect(cloneTemplate).toHaveBeenCalledTimes(2);
+            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents/create-agents-template', expect.any(String), undefined);
+            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents/agents-cookbook/template-projects/activities-planner', 'src/projects/activities-planner', 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();
+        });
+        it('should create project with event-planner as project ID', async () => {
+            await createAgents({
+                dirName: 'test-dir',
+                openAiKey: 'test-openai-key',
+                anthropicKey: 'test-anthropic-key',
+            });
+            // 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', () => {
+        it('should use template name as project ID when template is provided', async () => {
+            await createAgents({
+                dirName: 'test-dir',
+                template: 'chatbot',
+                openAiKey: 'test-openai-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/agents/create-agents-template', expect.any(String), undefined);
+            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents/agents-cookbook/template-projects/chatbot', 'src/projects/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(['event-planner', 'chatbot']);
+            await expect(createAgents({
+                dirName: 'test-dir',
+                template: 'non-existent-template',
+                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([
+                'event-planner',
+                'chatbot',
+                'data-analysis',
+            ]);
+            await expect(createAgents({
+                dirName: 'test-dir',
+                template: 'invalid',
+                openAiKey: 'test-openai-key',
+            })).rejects.toThrow('process.exit called');
+            const cancelCall = vi.mocked(p.cancel).mock.calls[0][0];
+            expect(cancelCall).toContain('event-planner');
+            expect(cancelCall).toContain('chatbot');
+            expect(cancelCall).toContain('data-analysis');
+        });
+    });
+    describe('Custom Project ID provided', () => {
+        it('should use custom project ID and not clone any template', async () => {
+            await createAgents({
+                dirName: 'test-dir',
+                customProjectId: 'my-custom-project',
+                openAiKey: 'test-openai-key',
+                anthropicKey: 'test-anthropic-key',
+            });
+            // Should clone base template but NOT project template
+            expect(cloneTemplate).toHaveBeenCalledTimes(1);
+            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents/create-agents-template', expect.any(String), undefined);
+            // Should NOT validate templates
+            expect(getAvailableTemplates).not.toHaveBeenCalled();
+            // Should create empty project directory
+            expect(fs.ensureDir).toHaveBeenCalledWith('src/projects/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/projects/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({
+                dirName: 'test-dir',
+                template: 'chatbot',
+                customProjectId: 'my-custom-project',
+                openAiKey: 'test-openai-key',
+                anthropicKey: 'test-anthropic-key',
+            });
+            // Should only clone base template, not project template
+            expect(cloneTemplate).toHaveBeenCalledTimes(1);
+            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents/create-agents-template', expect.any(String), undefined);
+            expect(getAvailableTemplates).not.toHaveBeenCalled();
+            expect(fs.ensureDir).toHaveBeenCalledWith('src/projects/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/projects/my-custom-project/index.ts', expect.stringContaining('id: "my-custom-project"'));
+        });
+    });
+    describe('Edge cases and validation', () => {
+        it('should handle template names with hyphens correctly', async () => {
+            vi.mocked(getAvailableTemplates).mockResolvedValue([
+                'my-complex-template',
+                'another-template',
+            ]);
+            await createAgents({
+                dirName: 'test-dir',
+                template: 'my-complex-template',
+                openAiKey: 'test-key',
+                anthropicKey: 'test-key',
+            });
+            expect(cloneTemplate).toHaveBeenCalledTimes(2);
+            expect(cloneTemplate).toHaveBeenCalledWith('https://github.com/inkeep/agents/agents-cookbook/template-projects/my-complex-template', 'src/projects/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({
+                dirName: 'test-dir',
+                customProjectId: 'my_project-123',
+                openAiKey: 'test-key',
+                anthropicKey: 'test-key',
+            });
+            expect(fs.ensureDir).toHaveBeenCalledWith('src/projects/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/projects/my_project-123/index.ts', expect.stringContaining('id: "my_project-123"'));
+        });
+        it('should create correct folder structure for all scenarios', async () => {
+            // Test default
+            await createAgents({
+                dirName: 'dir1',
+                openAiKey: 'key',
+                anthropicKey: 'key',
+            });
+            expect(fs.ensureDir).toHaveBeenCalledWith('src');
+            // Reset mocks
+            vi.clearAllMocks();
+            setupDefaultMocks();
+            // Test with template
+            await createAgents({
+                dirName: 'dir2',
+                template: 'chatbot',
+                openAiKey: 'key',
+                anthropicKey: 'key',
+            });
+            expect(fs.ensureDir).toHaveBeenCalledWith('src');
+            // Reset mocks
+            vi.clearAllMocks();
+            setupDefaultMocks();
+            // Test with custom ID
+            await createAgents({
+                dirName: 'dir3',
+                customProjectId: 'custom',
+                openAiKey: 'key',
+                anthropicKey: 'key',
+            });
+            expect(fs.ensureDir).toHaveBeenCalledWith('src');
+            expect(fs.ensureDir).toHaveBeenCalledWith('src/projects/custom');
+        });
+    });
+    describe('Security - Password input for API keys', () => {
+        it('should use password input instead of text input for API keys', async () => {
+            // Mock the select to return 'anthropic' to trigger the API key prompt
+            vi.mocked(p.select).mockResolvedValueOnce('anthropic');
+            vi.mocked(p.password).mockResolvedValueOnce('test-anthropic-key');
+            await createAgents({
+                dirName: 'test-dir',
+            });
+            // Verify that p.password was called for the API key
+            expect(p.password).toHaveBeenCalledWith(expect.objectContaining({
+                message: 'Enter your Anthropic API key:',
+                validate: expect.any(Function),
+            }));
+            // Verify that p.text was NOT called for API keys (only for directory name)
+            const textCalls = vi.mocked(p.text).mock.calls;
+            const apiKeyCalls = textCalls.filter((call) => call[0] &&
+                typeof call[0] === 'object' &&
+                'message' in call[0] &&
+                (call[0].message.includes('API key') ||
+                    call[0].message.includes('Anthropic') ||
+                    call[0].message.includes('OpenAI') ||
+                    call[0].message.includes('Google')));
+            expect(apiKeyCalls).toHaveLength(0);
+        });
+        it('should use password input for OpenAI keys', async () => {
+            vi.mocked(p.select).mockResolvedValueOnce('openai');
+            vi.mocked(p.password).mockResolvedValueOnce('test-openai-key');
+            await createAgents({
+                dirName: 'test-dir',
+            });
+            expect(p.password).toHaveBeenCalledWith(expect.objectContaining({
+                message: 'Enter your OpenAI API key:',
+                validate: expect.any(Function),
+            }));
+        });
+        it('should use password input for Google keys', async () => {
+            vi.mocked(p.select).mockResolvedValueOnce('google');
+            vi.mocked(p.password).mockResolvedValueOnce('test-google-key');
+            await createAgents({
+                dirName: 'test-dir',
+            });
+            expect(p.password).toHaveBeenCalledWith(expect.objectContaining({
+                message: 'Enter your Google API key:',
+                validate: expect.any(Function),
+            }));
+        });
+    });
+});
+// Helper to setup default mocks
+function setupDefaultMocks() {
+    vi.mocked(p.spinner).mockReturnValue(mockSpinner);
+    vi.mocked(p.password).mockResolvedValue('test-api-key');
+    vi.mocked(fs.pathExists).mockResolvedValue(false);
+    vi.mocked(fs.ensureDir).mockResolvedValue(undefined);
+    vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+    vi.mocked(getAvailableTemplates).mockResolvedValue(['event-planner', 'chatbot', 'data-analysis']);
+    vi.mocked(cloneTemplate).mockResolvedValue(undefined);
+    vi.mocked(cloneTemplateLocal).mockResolvedValue(undefined);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import { createAgents } from './utils.js';
+program
+    .name('create-agents')
+    .description('Create an Inkeep Agent Framework directory')
+    .version('0.1.0')
+    .argument('[directory-name]', 'Name of the directory')
+    .option('--template <template>', 'Template to use')
+    .option('--openai-key <openai-key>', 'OpenAI API key')
+    .option('--anthropic-key <anthropic-key>', 'Anthropic API key')
+    .option('--custom-project-id <custom-project-id>', 'Custom project id for experienced users who want an empty project directory')
+    .option('--disable-git', 'Disable git initialization')
+    .option('--local-agents-prefix <local-agents-prefix>', 'Local prefix for create-agents-template')
+    .option('--local-templates-prefix <local-templates-prefix>', 'Local prefix for project templates')
+    .parse();
+async function main() {
+    const options = program.opts();
+    const directoryName = program.args[0];
+    try {
+        await createAgents({
+            dirName: directoryName,
+            openAiKey: options.openaiKey,
+            anthropicKey: options.anthropicKey,
+            customProjectId: options.customProjectId,
+            template: options.template,
+            disableGit: options.disableGit,
+            localAgentsPrefix: options.localAgentsPrefix,
+            localTemplatesPrefix: options.localTemplatesPrefix,
+        });
+    }
+    catch (error) {
+        console.error('Failed to create directory:', error);
+        process.exit(1);
+    }
+}
+main().catch((error) => {
+    console.error('An unexpected error occurred:', error);
+    process.exit(1);
+});

package/dist/templates.d.ts

@@ -0,0 +1,17 @@
+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>;
+export declare function cloneTemplateLocal(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(localPrefix?: string): Promise<string[]>;

package/dist/templates.js

@@ -0,0 +1,266 @@
+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, 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);
+    }
+}
+export async function cloneTemplateLocal(templatePath, targetPath, replacements) {
+    await fs.mkdir(targetPath, { recursive: true });
+    try {
+        await fs.copy(templatePath, targetPath, {
+            overwrite: true,
+            errorOnExist: false,
+        });
+        if (replacements && replacements.length > 0) {
+            await replaceContentInFiles(targetPath, replacements);
+        }
+    }
+    catch (error) {
+        console.error(`Failed to clone template from ${templatePath}:`, 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(localPrefix) {
+    if (localPrefix && localPrefix.length > 0) {
+        const fullTemplatePath = path.join(localPrefix, 'template-projects');
+        const response = await fs.readdir(fullTemplatePath);
+        return response.filter((item) => fs.stat(path.join(fullTemplatePath, item)).then((stat) => stat.isDirectory()));
+    }
+    // Fetch the list of templates from your repo
+    const response = await fetch(`https://api.github.com/repos/inkeep/agents/contents/agents-cookbook/template-projects`);
+    const contents = await response.json();
+    return contents.filter((item) => item.type === 'dir').map((item) => item.name);
+}