@inkeep/create-agents 0.0.0-dev-20250915202938 → 0.0.0-dev-20250916184039

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

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

package/dist/__tests__/utils.test.js

@@ -0,0 +1,237 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import fs from 'fs-extra';
+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');
+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.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(['weather-graph', 'chatbot', 'data-analysis']);
+        vi.mocked(cloneTemplate).mockResolvedValue(undefined);
+        // Mock util.promisify to return a mock exec function
+        const mockExecAsync = vi.fn().mockResolvedValue({ stdout: '', stderr: '' });
+        const util = require('util');
+        util.promisify = vi.fn(() => mockExecAsync);
+        // Mock child_process.spawn
+        const childProcess = require('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 weather-graph 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 weather-graph 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');
+            // Should not call getAvailableTemplates since no template validation needed
+            expect(getAvailableTemplates).not.toHaveBeenCalled();
+        });
+        it('should create project with weather-graph as project ID', async () => {
+            await createAgents({
+                dirName: 'test-dir',
+                openAiKey: 'test-openai-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"'));
+        });
+    });
+    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/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(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']);
+            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(['weather-graph', '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('weather-graph');
+            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/create-agents-template', expect.any(String));
+            // Should NOT validate templates
+            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 () => {
+            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/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"'));
+        });
+    });
+    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-cookbook/templates/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'
+            });
+            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"'));
+        });
+        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/custom');
+        });
+    });
+});
+// Helper to setup default mocks
+function setupDefaultMocks() {
+    vi.mocked(p.spinner).mockReturnValue(mockSpinner);
+    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(cloneTemplate).mockResolvedValue(undefined);
+}

package/dist/index.js

@@ -6,9 +6,10 @@ program
     .description('Create an Inkeep Agent Framework directory')
     .version('0.1.0')
     .argument('[directory-name]', 'Name of the directory')
-    .option('--project-id <project-id>', 'Project ID')
+    .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')
     .parse();
 async function main() {
     const options = program.opts();
@@ -18,7 +19,8 @@ async function main() {
             dirName: directoryName,
             openAiKey: options.openaiKey,
             anthropicKey: options.anthropicKey,
-            projectId: options.projectId,
+            customProjectId: options.customProjectId,
+            template: options.template,
         });
     }
     catch (error) {

package/dist/templates.d.ts

@@ -0,0 +1,2 @@
+export declare function cloneTemplate(templatePath: string, targetPath: string): Promise<void>;
+export declare function getAvailableTemplates(): Promise<string[]>;

package/dist/templates.js

@@ -0,0 +1,22 @@
+import fs from 'fs-extra';
+import degit from 'degit';
+//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 });
+    const templatePathSuffix = templatePath.replace('https://github.com/', '');
+    const emitter = degit(templatePathSuffix);
+    try {
+        await emitter.clone(targetPath);
+    }
+    catch (error) {
+        process.exit(1);
+    }
+}
+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 contents = await response.json();
+    return contents
+        .filter((item) => item.type === 'dir')
+        .map((item) => item.name);
+}

package/dist/utils.d.ts

@@ -32,9 +32,11 @@ export declare const defaultAnthropicModelConfigurations: {
     };
 };
 export declare const createAgents: (args?: {
-    projectId?: string;
     dirName?: string;
+    templateName?: string;
     openAiKey?: string;
     anthropicKey?: string;
+    template?: string;
+    customProjectId?: string;
 }) => Promise<void>;
 export declare function createCommand(dirName?: string, options?: any): Promise<void>;

package/dist/utils.js

@@ -4,6 +4,7 @@ import fs from 'fs-extra';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import path from 'path';
+import { cloneTemplate, getAvailableTemplates } from './templates.js';
 const execAsync = promisify(exec);
 export const defaultDualModelConfigurations = {
     base: {
@@ -39,10 +40,35 @@ export const defaultAnthropicModelConfigurations = {
     },
 };
 export const createAgents = async (args = {}) => {
-    let { projectId, dirName, openAiKey, anthropicKey } = args;
+    let { dirName, openAiKey, anthropicKey, template, customProjectId } = args;
     const tenantId = 'default';
     const manageApiPort = '3002';
     const runApiPort = '3003';
+    let projectId;
+    let templateName;
+    // Determine project ID and template based on user input
+    if (customProjectId) {
+        // User provided custom project ID - use it as-is, no template needed
+        projectId = customProjectId;
+        templateName = ''; // No template will be cloned
+    }
+    else if (template) {
+        // User provided template - validate it exists and use template name as project ID
+        const availableTemplates = await getAvailableTemplates();
+        if (!availableTemplates.includes(template)) {
+            p.cancel(`${color.red('✗')} Template "${template}" not found\n\n` +
+                `${color.yellow('Available templates:')}\n` +
+                `  • ${availableTemplates.join('\n  • ')}\n`);
+            process.exit(0);
+        }
+        projectId = template;
+        templateName = template;
+    }
+    else {
+        // No template or custom project ID provided - use defaults
+        projectId = 'weather-graph';
+        templateName = 'weather-graph';
+    }
     p.intro(color.inverse(' Create Agents Directory '));
     // Prompt for directory name if not provided
     if (!dirName) {
@@ -63,25 +89,12 @@ export const createAgents = async (args = {}) => {
         }
         dirName = dirResponse;
     }
-    // Prompt for project ID
-    if (!projectId) {
-        const projectIdResponse = await p.text({
-            message: 'Enter your project ID:',
-            placeholder: '(default)',
-            defaultValue: 'default',
-        });
-        if (p.isCancel(projectIdResponse)) {
-            p.cancel('Operation cancelled');
-            process.exit(0);
-        }
-        projectId = projectIdResponse;
-    }
+    // Project ID is already determined above based on template/customProjectId logic
     // 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?',
             options: [
-                { value: 'both', label: 'Both Anthropic and OpenAI (recommended)' },
                 { value: 'anthropic', label: 'Anthropic only' },
                 { value: 'openai', label: 'OpenAI only' },
             ],
@@ -91,7 +104,7 @@ export const createAgents = async (args = {}) => {
             process.exit(0);
         }
         // Prompt for keys based on selection
-        if (providerChoice === 'anthropic' || providerChoice === 'both') {
+        if (providerChoice === 'anthropic') {
             const anthropicKeyResponse = await p.text({
                 message: 'Enter your Anthropic API key:',
                 placeholder: 'sk-ant-...',
@@ -108,7 +121,7 @@ export const createAgents = async (args = {}) => {
             }
             anthropicKey = anthropicKeyResponse;
         }
-        if (providerChoice === 'openai' || providerChoice === 'both') {
+        if (providerChoice === 'openai') {
             const openAiKeyResponse = await p.text({
                 message: 'Enter your OpenAI API key:',
                 placeholder: 'sk-...',
@@ -166,6 +179,8 @@ export const createAgents = async (args = {}) => {
     const s = p.spinner();
     s.start('Creating directory structure...');
     try {
+        const agentsTemplateRepo = 'https://github.com/inkeep/create-agents-template';
+        const projectTemplateRepo = templateName ? `https://github.com/inkeep/agents-cookbook/templates/${templateName}` : null;
         const directoryPath = path.resolve(process.cwd(), dirName);
         // Check if directory already exists
         if (await fs.pathExists(directoryPath)) {
@@ -180,8 +195,10 @@ export const createAgents = async (args = {}) => {
             s.start('Cleaning existing directory...');
             await fs.emptyDir(directoryPath);
         }
-        // Create the project directory
-        await fs.ensureDir(directoryPath);
+        // Clone the template repository
+        s.message('Building template...');
+        await cloneTemplate(agentsTemplateRepo, directoryPath);
+        // Change to the project directory
         process.chdir(directoryPath);
         const config = {
             dirName,
@@ -192,25 +209,30 @@ export const createAgents = async (args = {}) => {
             manageApiPort: manageApiPort || '3002',
             runApiPort: runApiPort || '3003',
             modelSettings: defaultModelSettings,
+            customProject: customProjectId ? true : false,
         };
-        // Create workspace structure
-        s.message('Setting up workspace structure...');
-        await createWorkspaceStructure(projectId);
-        // Setup package configurations
-        s.message('Creating package configurations...');
-        await setupPackageConfigurations(dirName);
+        // Create workspace structure for project-specific files
+        s.message('Setting up project structure...');
+        await createWorkspaceStructure();
         // Create environment files
         s.message('Setting up environment files...');
         await createEnvironmentFiles(config);
+        // Create project template folder (only if template is specified)
+        if (projectTemplateRepo) {
+            s.message('Creating project template folder...');
+            const templateTargetPath = `src/${projectId}`;
+            await cloneTemplate(projectTemplateRepo, templateTargetPath);
+        }
+        else {
+            s.message('Creating empty project folder...');
+            await fs.ensureDir(`src/${projectId}`);
+        }
+        // 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);
-        // Create documentation
-        s.message('Creating documentation...');
-        await createDocumentation(config);
-        // Create turbo config
-        s.message('Setting up Turbo...');
-        await createTurboConfig();
         // Install dependencies
         s.message('Installing dependencies (this may take a while)...');
         await installDependencies();
@@ -218,8 +240,9 @@ export const createAgents = async (args = {}) => {
         s.message('Setting up database...');
         await setupDatabase();
         // Setup project in database
-        s.message('Setting up project in database...');
-        await setupProjectInDatabase();
+        s.message('Pushing project...');
+        await setupProjectInDatabase(config);
+        s.message('Project setup complete!');
         s.stop();
         // Success message with next steps
         p.note(`${color.green('✓')} Project created at: ${color.cyan(directoryPath)}\n\n` +
@@ -236,7 +259,7 @@ export const createAgents = async (args = {}) => {
             `  • Manage UI: Available with management API\n` +
             `\n${color.yellow('Configuration:')}\n` +
             `  • Edit .env for environment variables\n` +
-            `  • Edit src/${projectId}/weather.graph.ts for agent definitions\n` +
+            `  • Edit files in src/${projectId}/ for agent definitions\n` +
             `  • Use 'inkeep push' to deploy agents to the platform\n` +
             `  • Use 'inkeep chat' to test your agents locally\n`, 'Ready to go!');
     }
@@ -246,138 +269,9 @@ export const createAgents = async (args = {}) => {
         process.exit(1);
     }
 };
-async function createWorkspaceStructure(projectId) {
+async function createWorkspaceStructure() {
     // Create the workspace directory structure
-    await fs.ensureDir(`src/${projectId}`);
-    await fs.ensureDir('apps/manage-api/src');
-    await fs.ensureDir('apps/run-api/src');
-    await fs.ensureDir('apps/shared');
-    await fs.ensureDir('scripts');
-}
-async function setupPackageConfigurations(dirName) {
-    // Root package.json (workspace root)
-    const rootPackageJson = {
-        name: dirName,
-        version: '0.1.0',
-        description: 'An Inkeep Agent Framework directory',
-        private: true,
-        type: 'module',
-        scripts: {
-            dev: 'turbo dev',
-            'db:push': 'drizzle-kit push',
-            setup: 'node scripts/setup.js',
-            'dev:setup': 'node scripts/dev-setup.js',
-            start: 'pnpm dev:setup'
-        },
-        dependencies: {},
-        devDependencies: {
-            '@biomejs/biome': '^1.8.0',
-            '@inkeep/agents-cli': '^0.1.1',
-            'drizzle-kit': '^0.31.4',
-            tsx: '^4.19.0',
-            turbo: '^2.5.5',
-            "concurrently": '^8.2.0',
-            'wait-on': '^8.0.0',
-        },
-        engines: {
-            node: '>=22.x',
-        },
-        packageManager: 'pnpm@10.10.0',
-        pnpm: {
-            onlyBuiltDependencies: [
-                'keytar'
-            ]
-        },
-    };
-    await fs.writeJson('package.json', rootPackageJson, { spaces: 2 });
-    // Create pnpm-workspace.yaml for pnpm workspaces
-    const pnpmWorkspace = `packages:
-  - "apps/*"
-`;
-    await fs.writeFile('pnpm-workspace.yaml', pnpmWorkspace);
-    // Add shared dependencies to root package.json
-    rootPackageJson.dependencies = {
-        '@inkeep/agents-core': '^0.1.0',
-        '@inkeep/agents-sdk': '^0.1.0',
-        dotenv: '^16.0.0',
-        zod: '^4.1.5',
-    };
-    await fs.writeJson('package.json', rootPackageJson, { spaces: 2 });
-    // Manage API package
-    const manageApiPackageJson = {
-        name: `@${dirName}/manage-api`,
-        version: '0.1.0',
-        description: 'Manage API for agents',
-        type: 'module',
-        scripts: {
-            build: 'tsc',
-            dev: 'tsx watch src/index.ts',
-            start: 'node dist/index.js',
-        },
-        dependencies: {
-            '@inkeep/agents-manage-api': '^0.1.1',
-            '@inkeep/agents-core': '^0.1.0',
-            '@hono/node-server': '^1.14.3',
-        },
-        devDependencies: {
-            '@types/node': '^20.12.0',
-            tsx: '^4.19.0',
-            typescript: '^5.4.0',
-        },
-        engines: {
-            node: '>=22.x',
-        },
-    };
-    await fs.writeJson('apps/manage-api/package.json', manageApiPackageJson, { spaces: 2 });
-    // Run API package
-    const runApiPackageJson = {
-        name: `@${dirName}/run-api`,
-        version: '0.1.0',
-        description: 'Run API for agents',
-        type: 'module',
-        scripts: {
-            dev: 'tsx watch src/index.ts',
-            start: 'node dist/index.js',
-        },
-        dependencies: {
-            '@inkeep/agents-run-api': '^0.1.1',
-            '@inkeep/agents-core': '^0.1.0',
-            '@hono/node-server': '^1.14.3',
-        },
-        devDependencies: {
-            '@types/node': '^20.12.0',
-            tsx: '^4.19.0',
-            typescript: '^5.4.0',
-        },
-        engines: {
-            node: '>=22.x',
-        },
-    };
-    await fs.writeJson('apps/run-api/package.json', runApiPackageJson, { spaces: 2 });
-    // TypeScript configs for API services
-    const apiTsConfig = {
-        compilerOptions: {
-            target: 'ES2022',
-            module: 'ESNext',
-            moduleResolution: 'bundler',
-            strict: true,
-            esModuleInterop: true,
-            skipLibCheck: true,
-            forceConsistentCasingInFileNames: true,
-            declaration: true,
-            outDir: './dist',
-            rootDir: '..',
-            allowImportingTsExtensions: false,
-            resolveJsonModule: true,
-            isolatedModules: true,
-            noEmit: false,
-        },
-        include: ['src/**/*', '../shared/**/*'],
-        exclude: ['node_modules', 'dist', '**/*.test.ts'],
-    };
-    await fs.writeJson('apps/manage-api/tsconfig.json', apiTsConfig, { spaces: 2 });
-    await fs.writeJson('apps/run-api/tsconfig.json', apiTsConfig, { spaces: 2 });
-    // No tsconfig needed for UI since we're using the packaged version
+    await fs.ensureDir(`src`);
 }
 async function createEnvironmentFiles(config) {
     // Root .env file
@@ -390,25 +284,11 @@ DB_FILE_NAME=file:./local.db
 # AI Provider Keys  
 ANTHROPIC_API_KEY=${config.anthropicKey || 'your-anthropic-key-here'}
 OPENAI_API_KEY=${config.openAiKey || 'your-openai-key-here'}
-
-# Logging
-LOG_LEVEL=debug
-
-# Service Ports
-MANAGE_API_PORT=${config.manageApiPort}
-RUN_API_PORT=${config.runApiPort}
-
-# UI Configuration (for dashboard)
-
 `;
     await fs.writeFile('.env', envContent);
     // Create .env.example
     const envExample = envContent.replace(/=.+$/gm, '=');
     await fs.writeFile('.env.example', envExample);
-    // Create setup script
-    await createSetupScript(config);
-    // Create dev-setup script
-    await createDevSetupScript(config);
     // Create .env files for each API service
     const runApiEnvContent = `# Environment
 ENVIRONMENT=development
@@ -432,287 +312,8 @@ AGENTS_MANAGE_API_URL=http://localhost:${config.manageApiPort}
 `;
     await fs.writeFile('apps/manage-api/.env', manageApiEnvContent);
     await fs.writeFile('apps/run-api/.env', runApiEnvContent);
-    // Create .gitignore
-    const gitignore = `# Dependencies
-node_modules/
-.pnpm-store/
-
-# Environment variables
-.env
-.env.local
-.env.development.local
-.env.test.local
-.env.production.local
-
-# Build outputs
-dist/
-build/
-.next/
-.turbo/
-
-# Logs
-*.log
-logs/
-
-# Database
-*.db
-*.sqlite
-*.sqlite3
-
-# IDE
-.vscode/
-.idea/
-*.swp
-*.swo
-
-# OS
-.DS_Store
-Thumbs.db
-
-# Coverage
-coverage/
-.nyc_output/
-
-# Temporary files
-*.tmp
-*.temp
-.cache/
-
-# Runtime data
-pids/
-*.pid
-*.seed
-*.pid.lock
-`;
-    await fs.writeFile('.gitignore', gitignore);
-    // Create biome.json
-    const biomeConfig = {
-        linter: {
-            enabled: true,
-            rules: {
-                recommended: true,
-            },
-        },
-        formatter: {
-            enabled: true,
-            indentStyle: 'space',
-            indentWidth: 2,
-        },
-        organizeImports: {
-            enabled: true,
-        },
-        javascript: {
-            formatter: {
-                semicolons: 'always',
-                quoteStyle: 'single',
-            },
-        },
-    };
-    await fs.writeJson('biome.json', biomeConfig, { spaces: 2 });
-}
-async function createSetupScript(config) {
-    const setupScriptContent = `#!/usr/bin/env node
-
-import { createDatabaseClient, createProject, getProject } from '@inkeep/agents-core';
-import dotenv from 'dotenv';
-
-// Load environment variables
-dotenv.config();
-
-const dbUrl = process.env.DB_FILE_NAME || 'file:local.db';
-const tenantId = '${config.tenantId}';
-const projectId = '${config.projectId}';
-const projectName = '${config.projectId}';
-const projectDescription = 'Generated Inkeep Agents project';
-
-async function setupProject() {
-  console.log('🚀 Setting up your Inkeep Agents project...');
-  
-  try {
-    const dbClient = createDatabaseClient({ url: dbUrl });
-    
-    // Check if project already exists
-    console.log('📋 Checking if project already exists...');
-    try {
-      const existingProject = await getProject(dbClient)({ 
-        id: projectId, 
-        tenantId: tenantId 
-      });
-      
-      if (existingProject) {
-        console.log('✅ Project already exists in database:', existingProject.name);
-        console.log('🎯 Project ID:', projectId);
-        console.log('🏢 Tenant ID:', tenantId);
-        return;
-      }
-    } catch (error) {
-      // Project doesn't exist, continue with creation
-    }
-    
-    // Create the project in the database
-    console.log('📦 Creating project in database...');
-    await createProject(dbClient)({
-      id: projectId,
-      tenantId: tenantId,
-      name: projectName,
-      description: projectDescription,
-      models: ${JSON.stringify(config.modelSettings, null, 2)},
-    });
-    
-    console.log('✅ Project created successfully!');
-    console.log('🎯 Project ID:', projectId);
-    console.log('🏢 Tenant ID:', tenantId);
-    console.log('');
-    console.log('🎉 Setup complete! Your development servers are running.');
-    console.log('');
-    console.log('📋 Available URLs:');
-    console.log('   - Management UI: http://localhost:${config.manageApiPort}');
-    console.log('   - Runtime API:   http://localhost:${config.runApiPort}');
-    console.log('');
-    console.log('🚀 Ready to build agents!');
-    
-  } catch (error) {
-    console.error('❌ Failed to setup project:', error);
-    process.exit(1);
-  }
-}
-
-setupProject();
-`;
-    await fs.writeFile('scripts/setup.js', setupScriptContent);
-    // Make the script executable
-    await fs.chmod('scripts/setup.js', 0o755);
-}
-async function createDevSetupScript(config) {
-    const devSetupScriptContent = `#!/usr/bin/env node
-
-import { spawn } from 'child_process';
-import { promisify } from 'util';
-import { exec } from 'child_process';
-
-const execAsync = promisify(exec);
-
-async function devSetup() {
-  console.log('🚀 Starting Inkeep Agents development environment...');
-  console.log('');
-  
-  try {
-    // Start development servers in background
-    console.log('📡 Starting development servers...');
-    const devProcess = spawn('pnpm', ['dev'], {
-      stdio: ['pipe', 'pipe', 'pipe'],
-      detached: false
-    });
-    
-    // Give servers time to start
-    console.log('⏳ Waiting for servers to start...');
-    await new Promise(resolve => setTimeout(resolve, 5000));
-    
-    console.log('');
-    console.log('📦 Servers are ready! Setting up project in database...');
-    
-    // Run the setup script
-    await execAsync('pnpm setup');
-    
-    console.log('');
-    console.log('🎉 Development environment is ready!');
-    console.log('');
-    console.log('📋 Available URLs:');
-    console.log(\`   - Management UI: http://localhost:${config.manageApiPort}\`);
-    console.log(\`   - Runtime API:   http://localhost:${config.runApiPort}\`);
-    console.log('');
-    console.log('✨ The servers will continue running. Press Ctrl+C to stop.');
-    
-    // Keep the script running so servers don't terminate
-    process.on('SIGINT', () => {
-      console.log('\\n👋 Shutting down development servers...');
-      devProcess.kill();
-      process.exit(0);
-    });
-    
-    // Wait for the dev process to finish or be killed
-    devProcess.on('close', (code) => {
-      console.log(\`Development servers stopped with code \${code}\`);
-      process.exit(code);
-    });
-    
-  } catch (error) {
-    console.error('❌ Failed to start development environment:', error.message);
-    process.exit(1);
-  }
-}
-
-devSetup();
-`;
-    await fs.writeFile('scripts/dev-setup.js', devSetupScriptContent);
-    await fs.chmod('scripts/dev-setup.js', 0o755);
 }
 async function createServiceFiles(config) {
-    const agentsGraph = `import { agent, agentGraph, mcpTool } from '@inkeep/agents-sdk';
-
-// MCP Tools
-const forecastWeatherTool = mcpTool({
-  id: 'fUI2riwrBVJ6MepT8rjx0',
-  name: 'Forecast weather',
-  serverUrl: 'https://weather-forecast-mcp.vercel.app/mcp',
-});
-
-const geocodeAddressTool = mcpTool({
-  id: 'fdxgfv9HL7SXlfynPx8hf',
-  name: 'Geocode address',
-  serverUrl: 'https://geocoder-mcp.vercel.app/mcp',
-});
-
-// Agents
-const weatherAssistant = agent({
-  id: 'weather-assistant',
-  name: 'Weather assistant',
-  description: 'Responsible for routing between the geocoder agent and weather forecast agent',
-  prompt:
-    'You are a helpful assistant. When the user asks about the weather in a given location, first ask the geocoder agent for the coordinates, and then pass those coordinates to the weather forecast agent to get the weather forecast',
-  canDelegateTo: () => [weatherForecaster, geocoderAgent],
-});
-
-const weatherForecaster = agent({
-  id: 'weather-forecaster',
-  name: 'Weather forecaster',
-  description:
-    'This agent is responsible for taking in coordinates and returning the forecast for the weather at that location',
-  prompt:
-    'You are a helpful assistant responsible for taking in coordinates and returning the forecast for that location using your forecasting tool',
-  canUse: () => [forecastWeatherTool],
-});
-
-const geocoderAgent = agent({
-  id: 'geocoder-agent',
-  name: 'Geocoder agent',
-  description: 'Responsible for converting location or address into coordinates',
-  prompt:
-    'You are a helpful assistant responsible for converting location or address into coordinates using your geocode tool',
-  canUse: () => [geocodeAddressTool],
-});
-
-// Agent Graph
-export const weatherGraph = agentGraph({
-  id: 'weather-graph',
-  name: 'Weather graph',
-  defaultAgent: weatherAssistant,
-  agents: () => [weatherAssistant, weatherForecaster, geocoderAgent],
-});`;
-    await fs.writeFile(`src/${config.projectId}/weather.graph.ts`, agentsGraph);
-    // Inkeep config (if using CLI)
-    const inkeepConfig = `import { defineConfig } from '@inkeep/agents-cli/config';
-
-const config = defineConfig({
-  tenantId: "${config.tenantId}",
-  projectId: "${config.projectId}",
-  agentsManageApiUrl: \`http://localhost:\${process.env.MANAGE_API_PORT || '3002'}\`,
-  agentsRunApiUrl: \`http://localhost:\${process.env.RUN_API_PORT || '3003'}\`,
-  modelSettings: ${JSON.stringify(config.modelSettings, null, 2)},
-});
-    
-export default config;`;
-    await fs.writeFile(`src/${config.projectId}/inkeep.config.ts`, inkeepConfig);
     // Create .env file for the project directory (for inkeep CLI commands)
     const projectEnvContent = `# Environment
 ENVIRONMENT=development
@@ -721,306 +322,61 @@ ENVIRONMENT=development
 DB_FILE_NAME=file:../../local.db
 `;
     await fs.writeFile(`src/${config.projectId}/.env`, projectEnvContent);
-    // Shared credential stores
-    const credentialStoresFile = `import {
-  InMemoryCredentialStore,
-  createNangoCredentialStore,
-  createKeyChainStore,
-} from '@inkeep/agents-core';
-
-// Shared credential stores configuration for all services
-export const credentialStores = [
-  new InMemoryCredentialStore('memory-default'),
-  ...(process.env.NANGO_SECRET_KEY
-    ? [
-        createNangoCredentialStore('nango-default', {
-          apiUrl: process.env.NANGO_HOST || 'https://api.nango.dev',
-          secretKey: process.env.NANGO_SECRET_KEY,
-        }),
-      ]
-    : []),
-  createKeyChainStore('keychain-default'),
-];
-`;
-    await fs.writeFile('apps/shared/credential-stores.ts', credentialStoresFile);
-    // Manage API
-    const manageApiIndex = `import { serve } from '@hono/node-server';
-import { createManagementApp } from '@inkeep/agents-manage-api';
-import { getLogger } from '@inkeep/agents-core';
-import { credentialStores } from '../../shared/credential-stores.js';
-
-const logger = getLogger('management-api');
-
-// Create the Hono app
-const app = createManagementApp({
-  serverConfig: {
-    port: Number(process.env.MANAGE_API_PORT) || 3002,
-    serverOptions: {
-      requestTimeout: 60000,
-      keepAliveTimeout: 60000,
-      keepAlive: true,
-    },
-  },
-  credentialStores,
-});
-
-const port = Number(process.env.MANAGE_API_PORT) || 3002;
-
-// Start the server using @hono/node-server
-serve(
-  {
-    fetch: app.fetch,
-    port,
-  },
-  (info) => {
-    logger.info({}, \`📝 Management API running on http://localhost:\${info.port}\`);
-    logger.info({}, \`📝 OpenAPI documentation available at http://localhost:\${info.port}/openapi.json\`);
-  }
-);`;
-    await fs.writeFile('apps/manage-api/src/index.ts', manageApiIndex);
-    // Run API
-    const runApiIndex = `import { serve } from '@hono/node-server';
-import { createExecutionApp } from '@inkeep/agents-run-api';
-import { credentialStores } from '../../shared/credential-stores.js';
-import { getLogger } from '@inkeep/agents-core';
-
-const logger = getLogger('execution-api');
-
-
-// Create the Hono app
-const app = createExecutionApp({
-  serverConfig: {
-    port: Number(process.env.RUN_API_PORT) || 3003,
-    serverOptions: {
-      requestTimeout: 120000,
-      keepAliveTimeout: 60000,
-      keepAlive: true,
-    },
-  },
-  credentialStores,
-});
-
-const port = Number(process.env.RUN_API_PORT) || 3003;
-
-// Start the server using @hono/node-server
-serve(
-  {
-    fetch: app.fetch,
-    port,
-  },
-  (info) => {
-    logger.info({}, \`📝 Run API running on http://localhost:\${info.port}\`);
-    logger.info({}, \`📝 OpenAPI documentation available at http://localhost:\${info.port}/openapi.json\`);
-  }
-);`;
-    await fs.writeFile('apps/run-api/src/index.ts', runApiIndex);
-    // Database configuration
-    const drizzleConfig = `import { defineConfig } from 'drizzle-kit';
-
-export default defineConfig({
-  schema: 'node_modules/@inkeep/agents-core/dist/db/schema.js',
-  dialect: 'sqlite',
-  dbCredentials: {
-    url: process.env.DB_FILE_NAME || 'file:./local.db'
-  },
-});`;
-    await fs.writeFile('drizzle.config.ts', drizzleConfig);
-}
-async function createTurboConfig() {
-    const turboConfig = {
-        $schema: 'https://turbo.build/schema.json',
-        ui: 'tui',
-        globalDependencies: ['**/.env', '**/.env.local', '**/.env.*'],
-        globalEnv: [
-            'NODE_ENV',
-            'CI',
-            'ANTHROPIC_API_KEY',
-            'OPENAI_API_KEY',
-            'ENVIRONMENT',
-            'DB_FILE_NAME',
-            'MANAGE_API_PORT',
-            'RUN_API_PORT',
-            'LOG_LEVEL',
-            'NANGO_SECRET_KEY',
-        ],
-        tasks: {
-            build: {
-                dependsOn: ['^build'],
-                inputs: ['$TURBO_DEFAULT$', '.env*'],
-                outputs: ['dist/**', 'build/**', '.next/**', '!.next/cache/**'],
-            },
-            dev: {
-                cache: false,
-                persistent: true,
-            },
-            start: {
-                dependsOn: ['build'],
-                cache: false,
-            },
-            'db:push': {
-                cache: false,
-                inputs: ['drizzle.config.ts', 'src/data/db/schema.ts'],
-            },
-        },
-    };
-    await fs.writeJson('turbo.json', turboConfig, { spaces: 2 });
 }
-async function createDocumentation(config) {
-    const readme = `# ${config.dirName}
-
-An Inkeep Agent Framework project with multi-service architecture.
-
-## Architecture
-
-This project follows a workspace structure with the following services:
-
-- **Agents Manage API** (Port 3002): Agent configuration and managemen
-  - Handles entity management and configuration endpoints.
-- **Agents Run API** (Port 3003): Agent execution and chat processing  
-  - Handles agent communication. You can interact with your agents either over MCP from an MCP client or through our React UI components library
-- **Agents Manage UI** (Port 3000): Web interface available via \`inkeep dev\`
-  - The agent framework visual builder. From the builder you can create, manage and visualize all your graphs.
-
-## Quick Start
-1. **Install the Inkeep CLI:**
-   \`\`\`bash
-   pnpm install -g @inkeep/agents-cli
-   \`\`\`
-
-1. **Start services:**
-   \`\`\`bash
-   # Start Agents Manage API and Agents Run API
-   pnpm dev
-   
-   # Start the Dashboard
-   inkeep dev
-   \`\`\`
-
-3. **Deploy your first agent graph:**
-   \`\`\`bash
-   # Navigate to your project's graph directory
-   cd src/${config.projectId}/
-   
-   # Push the weather graph to create it
-   inkeep push weather.graph.ts
-   \`\`\`
-  - Follow the prompts to create the project and graph
-  - Click on the \"View graph in UI:\" link to see the graph in the management dashboard
-
-## Project Structure
-
-\`\`\`
-${config.dirName}/
-├── src/
-│   ├── /${config.projectId}              # Agent configurations
-├── apps/
-│   ├── manage-api/          # Agents Manage API service
-│   ├── run-api/             # Agents Run API service
-│   └── shared/              # Shared code between API services
-│       └── credential-stores.ts  # Shared credential store configuration
-├── turbo.json               # Turbo configuration
-├── pnpm-workspace.yaml      # pnpm workspace configuration
-└── package.json             # Root package configuration
-\`\`\`
-
-## Configuration
-
-### Environment Variables
-
-Environment variables are defined in the following places:
-
-- \`apps/manage-api/.env\`: Agents Manage API environment variables
-- \`apps/run-api/.env\`: Agents Run API environment variables
-- \`src/${config.projectId}/.env\`: Inkeep CLI environment variables
-- \`.env\`: Root environment variables 
-
-To change the API keys used by your agents modify \`apps/run-api/.env\`. You are required to define at least one LLM provider key.
-
-\`\`\`bash
-# AI Provider Keys
-ANTHROPIC_API_KEY=your-anthropic-key-here
-OPENAI_API_KEY=your-openai-key-here
-\`\`\`
-
-
-
-### Agent Configuration
-
-Your graphs are defined in \`src/${config.projectId}/weather.graph.ts\`. The default setup includes:
-
-- **Weather Graph**: A graph that can forecast the weather in a given location.
-
-Your inkeep configuration is defined in \`src/${config.projectId}/inkeep.config.ts\`. The inkeep configuration is used to configure defaults for the inkeep CLI. The configuration includes:
-
-- \`tenantId\`: The tenant ID
-- \`projectId\`: The project ID
-- \`agentsManageApiUrl\`: The Manage API URL
-- \`agentsRunApiUrl\`: The Run API URL
-
-
-## Development
-
-### Updating Your Agents
-
-1. Edit \`src/${config.projectId}/weather.graph.ts\`
-2. Push the graph to the platform to update: \`inkeep pus weather.graph.ts\` 
-
-### API Documentation
-
-Once services are running, view the OpenAPI documentation:
-
-- Manage API: http://localhost:${config.manageApiPort}/docs
-- Run API: http://localhost:${config.runApiPort}/docs
-
-## Learn More
-
-- [Inkeep Documentation](https://docs.inkeep.com)
-
-## Troubleshooting
-
-## Inkeep CLI commands
-
-- Ensure you are runnning commands from \`cd src/${config.projectId}\`.
-- Validate the \`inkeep.config.ts\` file has the correct api urls.
-- Validate that the \`.env\` file in \`src/${config.projectId}\` has the correct \`DB_FILE_NAME\`.
-
-### Services won't start
-
-1. Ensure all dependencies are installed: \`pnpm install\`
-2. Check that ports 3000-3003 are available
-
-### Agents won't respond
+async function createInkeepConfig(config) {
+    const inkeepConfig = `import { defineConfig } from '@inkeep/agents-cli/config';
 
-1. Ensure that the Agents Run API is running and includes a valid Anthropic or OpenAI API key in its .env file
-`;
-    await fs.writeFile('README.md', readme);
+  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);
+    if (config.customProject) {
+        const customIndexContent = `import { project } from '@inkeep/agents-sdk';
+
+export const myProject = project({
+  id: "${config.projectId}",
+  name: "${config.projectId}",
+  description: "",
+  graphs: () => [],
+});`;
+        await fs.writeFile(`src/${config.projectId}/index.ts`, customIndexContent);
+    }
 }
 async function installDependencies() {
     await execAsync('pnpm install');
 }
-async function setupProjectInDatabase() {
-    const s = p.spinner();
-    s.start('🚀 Starting development servers and setting up database...');
+async function setupProjectInDatabase(config) {
+    // Start development servers in background
+    const { spawn } = await import('child_process');
+    const devProcess = spawn('pnpm', ['dev:apis'], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        detached: true, // Detach so we can kill the process group
+        cwd: process.cwd(),
+    });
+    // Give servers time to start
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+    // Run inkeep push
     try {
-        // Start development servers in background
-        const { spawn } = await import('child_process');
-        const devProcess = spawn('pnpm', ['dev'], {
-            stdio: ['pipe', 'pipe', 'pipe'],
-            detached: true, // Detach so we can kill the process group
-            cwd: process.cwd()
-        });
-        // Give servers time to start
-        await new Promise(resolve => setTimeout(resolve, 5000));
-        s.message('📦 Servers ready! Creating project in database...');
-        // Run the database setup
-        await execAsync('node scripts/setup.js');
+        // Suppress all output
+        const { stdout, stderr } = await execAsync(`pnpm inkeep push --project src/${config.projectId}`);
+    }
+    catch (error) {
+        //Continue despite error - user can setup project manually
+    }
+    finally {
         // Kill the dev servers and their child processes
         if (devProcess.pid) {
             try {
                 // Kill the entire process group
                 process.kill(-devProcess.pid, 'SIGTERM');
                 // Wait a moment for graceful shutdown
-                await new Promise(resolve => setTimeout(resolve, 1000));
+                await new Promise((resolve) => setTimeout(resolve, 1000));
                 // Force kill if still running
                 try {
                     process.kill(-devProcess.pid, 'SIGKILL');
@@ -1034,18 +390,13 @@ async function setupProjectInDatabase() {
                 console.log('Note: Dev servers may still be running in background');
             }
         }
-        s.stop('✅ Project successfully created and configured in database!');
-    }
-    catch (error) {
-        s.stop('❌ Failed to setup project in database');
-        console.error('Setup error:', error);
-        // Continue anyway - user can run setup manually
     }
 }
 async function setupDatabase() {
     try {
         // Run drizzle-kit push to create database file and apply schema
         await execAsync('pnpm db:push');
+        await new Promise((resolve) => setTimeout(resolve, 1000));
     }
     catch (error) {
         throw new Error(`Failed to setup database: ${error instanceof Error ? error.message : 'Unknown error'}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/create-agents",
-  "version": "0.0.0-dev-20250915202938",
+  "version": "0.0.0-dev-20250916184039",
   "description": "Create an Inkeep Agent Framework project",
   "type": "module",
   "bin": {
@@ -30,10 +30,12 @@
   "dependencies": {
     "@clack/prompts": "^0.11.0",
     "commander": "^12.0.0",
+    "degit": "^2.8.4",
     "fs-extra": "^11.0.0",
     "picocolors": "^1.0.0"
   },
   "devDependencies": {
+    "@types/degit": "^2.8.6",
     "@types/fs-extra": "^11.0.0",
     "@types/node": "^20.12.0",
     "tsx": "^4.7.0",