dexto 1.1.2 → 1.1.4

package/dist/cli/commands/create-app.js

@@ -0,0 +1,135 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import { executeWithTimeout } from '../utils/execute.js';
+import * as p from '@clack/prompts';
+import { getPackageManager, getPackageManagerInstallCommand, addScriptsToPackageJson, } from '../utils/package-mgmt.js';
+import { logger } from '@dexto/core';
+/**
+ * Creates basic scaffolding for a Dexto project
+ * sets up git and gitignore, and sets up initial dependencies
+ * Does not add scripts to package.json or create tsconfig.json which require the directory name
+ * @param name - The name of the project
+ * @returns The absolute path to the created project directory
+ */
+export async function createDextoProject(name) {
+    // Basic regex: must start with a letter, contain only letters, numbers, hyphens or underscores
+    const nameRegex = /^[a-zA-Z][a-zA-Z0-9-_]*$/;
+    let projectName;
+    if (name) {
+        // Validate provided project name
+        if (!nameRegex.test(name)) {
+            console.log(chalk.red('Invalid project name. Must start with a letter and contain only letters, numbers, hyphens or underscores.'));
+            process.exit(1);
+        }
+        projectName = name;
+    }
+    else {
+        let input;
+        do {
+            input = await p.text({
+                message: 'What do you want to name your Dexto project?',
+                placeholder: 'my-dexto-project',
+                defaultValue: 'my-dexto-project',
+            });
+            if (p.isCancel(input)) {
+                p.cancel('Project creation cancelled');
+                process.exit(0);
+            }
+            if (!nameRegex.test(input)) {
+                console.log(chalk.red('Invalid project name. Must start with a letter and contain only letters, numbers, hyphens or underscores.'));
+            }
+        } while (!nameRegex.test(input));
+        projectName = input;
+    }
+    const spinner = p.spinner();
+    const projectPath = path.resolve(process.cwd(), projectName);
+    spinner.start(`Creating dexto project in ${projectPath}...`);
+    try {
+        await fs.mkdir(projectPath);
+    }
+    catch (error) {
+        // if the directory already exists, end the process
+        if (error instanceof Error && 'code' in error && error.code === 'EEXIST') {
+            spinner.stop(`Directory "${projectName}" already exists. Please choose a different name or delete the existing directory.`);
+            process.exit(1);
+        }
+        else {
+            // If it's not an EEXIST error, rethrow it to be caught by the outer catch
+            spinner.stop(`Failed to create project: ${error}`);
+            throw error;
+        }
+    }
+    // Move to the new project directory
+    process.chdir(projectPath);
+    // initialize package.json
+    await executeWithTimeout('npm', ['init', '-y'], { cwd: projectPath });
+    // initialize git repository
+    await executeWithTimeout('git', ['init'], { cwd: projectPath });
+    // add .gitignore
+    await fs.writeFile('.gitignore', 'node_modules\n.env\ndist\n.dexto\n*.log');
+    // update package.json module type
+    const packageJson = JSON.parse(await fs.readFile('package.json', 'utf8'));
+    packageJson.type = 'module';
+    await fs.writeFile('package.json', JSON.stringify(packageJson, null, 2));
+    spinner.stop('Project files created successfully!');
+    spinner.start('Installing dependencies...');
+    const packageManager = getPackageManager();
+    const installCommand = getPackageManagerInstallCommand(packageManager);
+    // install yaml and dotenv
+    await executeWithTimeout(packageManager, [installCommand, 'yaml', 'dotenv'], {
+        cwd: projectPath,
+    });
+    // install typescript
+    await executeWithTimeout(packageManager, [installCommand, 'typescript', 'tsx', 'ts-node', '@types/node', '--save-dev'], { cwd: projectPath });
+    spinner.stop('Dependencies installed!');
+    return projectPath;
+}
+/**
+ * Adds the dexto scripts to the package.json. Assumes the package.json already exists and is accessible
+ * @param directory - The directory of the project
+ */
+export async function addDextoScriptsToPackageJson(directory, projectPath) {
+    logger.debug(`Adding dexto scripts to package.json in ${projectPath}`);
+    await addScriptsToPackageJson({
+        build: 'tsc',
+        start: `node dist/${path.join('dexto', 'dexto-example.js')}`,
+        dev: `node --loader ts-node/esm ${path.join(directory, 'dexto', 'dexto-example.ts')}`,
+    });
+    logger.debug(`Successfully added dexto scripts to package.json in ${projectPath}`);
+}
+/** Creates a tsconfig.json file in the project directory */
+export async function createTsconfigJson(projectPath, directory) {
+    // setup tsconfig.json
+    logger.debug(`Creating tsconfig.json in ${projectPath}`);
+    const tsconfig = {
+        compilerOptions: {
+            target: 'ES2022',
+            module: 'ESNext',
+            moduleResolution: 'node',
+            strict: true,
+            esModuleInterop: true,
+            forceConsistentCasingInFileNames: true,
+            skipLibCheck: true,
+            outDir: 'dist',
+            rootDir: directory,
+        },
+        include: [`${directory}/**/*.ts`],
+        exclude: ['node_modules', 'dist', '.dexto'],
+    };
+    await fs.writeJSON(path.join(projectPath, 'tsconfig.json'), tsconfig, { spaces: 4 });
+    logger.debug(`Successfully created tsconfig.json in ${projectPath}`);
+}
+/** Adds notes for users to get started with their new initialized Dexto project */
+export async function postCreateDexto(projectPath, directory) {
+    const nextSteps = [
+        `1. Go to the project directory: ${chalk.cyan(`cd ${projectPath}`)}`,
+        `2. Run the example: ${chalk.cyan(`npm run dev`)}`,
+        `3. Add/update your API key(s) in ${chalk.cyan('.env')}`,
+        `4. Check out the agent configuration file ${chalk.cyan(path.join(directory, 'dexto', 'agents', 'default-agent.yml'))}`,
+        `5. Try out different LLMs and MCP servers in the default-agent.yml file`,
+        `6. Run dexto in your project directory to start the interactive CLI with default-agent.yml file`,
+        `7. Read more about Dexto: ${chalk.cyan('https://docs.dexto.ai')}`,
+    ].join('\n');
+    p.note(nextSteps, chalk.yellow('Next steps:'));
+}

package/dist/cli/commands/index.d.ts

@@ -0,0 +1,8 @@
+export { createDextoProject, createTsconfigJson, addDextoScriptsToPackageJson, postCreateDexto, } from './create-app.js';
+export { getUserInputToInitDextoApp, initDexto, postInitDexto } from './init-app.js';
+export { handleSetupCommand, type CLISetupOptions, type CLISetupOptionsInput } from './setup.js';
+export { handleInstallCommand, type InstallCommandOptions } from './install.js';
+export { handleUninstallCommand, type UninstallCommandOptions } from './uninstall.js';
+export { handleListAgentsCommand, type ListAgentsCommandOptions, type ListAgentsCommandOptionsInput, } from './list-agents.js';
+export { handleWhichCommand, type WhichCommandOptions } from './which.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/index.ts"],"names":[],"mappings":"AAGA,OAAO,EACH,kBAAkB,EAClB,kBAAkB,EAClB,4BAA4B,EAC5B,eAAe,GAClB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,0BAA0B,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAErF,OAAO,EAAE,kBAAkB,EAAE,KAAK,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACjG,OAAO,EAAE,oBAAoB,EAAE,KAAK,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAChF,OAAO,EAAE,sBAAsB,EAAE,KAAK,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACtF,OAAO,EACH,uBAAuB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,6BAA6B,GACrC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,MAAM,YAAY,CAAC"}

package/dist/cli/commands/index.js

@@ -0,0 +1,9 @@
+// packages/cli/src/cli/commands/index.ts
+// Project setup commands
+export { createDextoProject, createTsconfigJson, addDextoScriptsToPackageJson, postCreateDexto, } from './create-app.js';
+export { getUserInputToInitDextoApp, initDexto, postInitDexto } from './init-app.js';
+export { handleSetupCommand } from './setup.js';
+export { handleInstallCommand } from './install.js';
+export { handleUninstallCommand } from './uninstall.js';
+export { handleListAgentsCommand, } from './list-agents.js';
+export { handleWhichCommand } from './which.js';

package/dist/cli/commands/init-app.d.ts

@@ -0,0 +1,45 @@
+import { type LLMProvider } from '@dexto/core';
+/**
+ * Get user preferences needed to initialize a Dexto app
+ * @returns The user preferences
+ */
+export declare function getUserInputToInitDextoApp(): Promise<{
+    llmProvider: LLMProvider;
+    llmApiKey: string;
+    directory: string;
+    createExampleFile: boolean;
+}>;
+/**
+ * Initializes an existing project with Dexto in the given directory.
+ * @param directory - The directory to initialize the Dexto project in
+ * @param llmProvider - The LLM provider to use
+ * @param llmApiKey - The API key for the LLM provider
+ * @returns The path to the created Dexto project
+ */
+export declare function initDexto(directory: string, createExampleFile?: boolean, llmProvider?: LLMProvider, llmApiKey?: string): Promise<void>;
+/** Adds notes for users to get started with their new initialized Dexto project */
+export declare function postInitDexto(directory: string): Promise<void>;
+/**
+ * Creates the dexto directories (dexto, dexto/agents) in the given directory.
+ * @param directory - The directory to create the dexto directories in
+ * @returns The path to the created dexto directory
+ */
+export declare function createDextoDirectories(directory: string): Promise<{
+    ok: true;
+    dirPath: string;
+} | {
+    ok: false;
+}>;
+/**
+ * Creates a dexto config file in the given directory. Pulls the config file from the installed Dexto package.
+ * @param directory - The directory to create the config file in
+ * @returns The path to the created config file
+ */
+export declare function createDextoConfigFile(directory: string): Promise<string>;
+/**
+ * Creates an example file in the given directory showing how to use Dexto in code. This file has example code to get you started.
+ * @param directory - The directory to create the example index file in
+ * @returns The path to the created example index file
+ */
+export declare function createDextoExampleFile(directory: string): Promise<string>;
+//# sourceMappingURL=init-app.d.ts.map

package/dist/cli/commands/init-app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-app.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/init-app.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,WAAW,EAAU,MAAM,aAAa,CAAC;AAWvD;;;GAGG;AACH,wBAAsB,0BAA0B,IAAI,OAAO,CAAC;IACxD,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,OAAO,CAAC;CAC9B,CAAC,CA2ED;AAED;;;;;;GAMG;AACH,wBAAsB,SAAS,CAC3B,SAAS,EAAE,MAAM,EACjB,iBAAiB,UAAO,EACxB,WAAW,CAAC,EAAE,WAAW,EACzB,SAAS,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC,CAyGf;AAED,mFAAmF;AACnF,wBAAsB,aAAa,CAAC,SAAS,EAAE,MAAM,iBASpD;AACD;;;;GAIG;AACH,wBAAsB,sBAAsB,CACxC,SAAS,EAAE,MAAM,GAClB,OAAO,CAAC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAA;CAAE,CAAC,CAaxD;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAmC9E;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA4F/E"}

package/dist/cli/commands/init-app.js

@@ -0,0 +1,323 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import fs from 'node:fs/promises';
+import fsExtra from 'fs-extra';
+import path from 'node:path';
+import { getPackageManager, getPackageManagerInstallCommand } from '../utils/package-mgmt.js';
+import { executeWithTimeout } from '../utils/execute.js';
+import { createRequire } from 'module';
+import { logger } from '@dexto/core';
+import { updateDextoConfigFile } from '../utils/project-utils.js';
+import { saveProviderApiKey } from '@dexto/core';
+import { getProviderDisplayName, isValidApiKeyFormat, PROVIDER_OPTIONS, } from '../utils/provider-setup.js';
+const require = createRequire(import.meta.url);
+/**
+ * Get user preferences needed to initialize a Dexto app
+ * @returns The user preferences
+ */
+export async function getUserInputToInitDextoApp() {
+    const answers = await p.group({
+        llmProvider: () => p.select({
+            message: 'Choose your AI provider',
+            options: PROVIDER_OPTIONS,
+        }),
+        llmApiKey: async ({ results }) => {
+            const llmProvider = results.llmProvider;
+            const selection = await p.select({
+                message: `Enter your API key for ${getProviderDisplayName(llmProvider)}?`,
+                options: [
+                    { value: 'enter', label: 'Enter', hint: 'recommended' },
+                    { value: 'skip', label: 'Skip', hint: '' },
+                ],
+                initialValue: 'enter',
+            });
+            if (p.isCancel(selection)) {
+                p.cancel('Dexto initialization cancelled');
+                process.exit(0);
+            }
+            if (selection === 'enter') {
+                const apiKey = await p.password({
+                    message: `Enter your ${getProviderDisplayName(llmProvider)} API key`,
+                    mask: '*',
+                    validate: (value) => {
+                        if (!value || value.trim().length === 0) {
+                            return 'API key is required';
+                        }
+                        if (!isValidApiKeyFormat(value.trim(), llmProvider)) {
+                            return `Invalid ${getProviderDisplayName(llmProvider)} API key format`;
+                        }
+                        return undefined;
+                    },
+                });
+                if (p.isCancel(apiKey)) {
+                    p.cancel('Dexto initialization cancelled');
+                    process.exit(0);
+                }
+                return apiKey;
+            }
+            return '';
+        },
+        directory: () => p.text({
+            message: 'Enter the directory to add the dexto files in',
+            placeholder: 'src/',
+            defaultValue: 'src/',
+        }),
+        createExampleFile: () => p.confirm({
+            message: 'Create a dexto example file? [Recommended]',
+            initialValue: true,
+        }),
+    }, {
+        onCancel: () => {
+            p.cancel('Dexto initialization cancelled');
+            process.exit(0);
+        },
+    });
+    // Type assertion to bypass the possible 'Symbol' type returned by p.group which is handled in onCancel
+    return answers;
+}
+/**
+ * Initializes an existing project with Dexto in the given directory.
+ * @param directory - The directory to initialize the Dexto project in
+ * @param llmProvider - The LLM provider to use
+ * @param llmApiKey - The API key for the LLM provider
+ * @returns The path to the created Dexto project
+ */
+export async function initDexto(directory, createExampleFile = true, llmProvider, llmApiKey) {
+    const spinner = p.spinner();
+    try {
+        // install dexto
+        const packageManager = getPackageManager();
+        const installCommand = getPackageManagerInstallCommand(packageManager);
+        spinner.start('Installing Dexto...');
+        const label = 'latest';
+        logger.debug(`Installing Dexto using ${packageManager} with install command: ${installCommand} and label: ${label}`);
+        try {
+            await executeWithTimeout(packageManager, [installCommand, `@dexto/core@${label}`], {
+                cwd: process.cwd(),
+            });
+        }
+        catch (installError) {
+            // Handle pnpm workspace root add error specifically
+            console.error(`Install error: ${installError instanceof Error ? installError.message : String(installError)}`);
+            if (packageManager === 'pnpm' &&
+                installError instanceof Error &&
+                /\bERR_PNPM_ADDING_TO_ROOT\b/.test(installError.message)) {
+                spinner.stop(chalk.red('Error: Cannot install in pnpm workspace root'));
+                p.note('You are initializing dexto in a pnpm workspace root. Go to a specific workspace package and run "pnpm add @dexto/core" there.', chalk.yellow('Workspace Error'));
+                process.exit(1);
+            }
+            throw installError; // Re-throw other errors
+        }
+        spinner.stop('Dexto installed successfully!');
+        spinner.start('Creating Dexto files...');
+        // create dexto directories (dexto, dexto/agents)
+        const result = await createDextoDirectories(directory);
+        if (!result.ok) {
+            spinner.stop(chalk.inverse(`Dexto already initialized in ${path.join(directory, 'dexto')}. Would you like to overwrite it?`));
+            const overwrite = await p.confirm({
+                message: 'Overwrite Dexto?',
+                initialValue: false,
+            });
+            if (p.isCancel(overwrite) || !overwrite) {
+                p.cancel('Dexto initialization cancelled');
+                process.exit(1);
+            }
+        }
+        // create dexto config file
+        logger.debug('Creating dexto config file...');
+        const dextoDir = path.join(directory, 'dexto');
+        const agentsDir = path.join(dextoDir, 'agents');
+        let configPath;
+        try {
+            configPath = await createDextoConfigFile(agentsDir);
+            logger.debug(`Dexto config file created at ${configPath}`);
+        }
+        catch (configError) {
+            spinner.stop(chalk.red('Failed to create agent config file'));
+            logger.error(`Config creation error: ${configError}`);
+            throw new Error(`Failed to create default-agent.yml: ${configError instanceof Error ? configError.message : String(configError)}`);
+        }
+        // update dexto config file based on llmProvider
+        if (llmProvider) {
+            logger.debug(`Updating dexto config file based on llmProvider: ${llmProvider}`);
+            await updateDextoConfigFile(configPath, llmProvider);
+            logger.debug(`Dexto config file updated with llmProvider: ${llmProvider}`);
+        }
+        // create dexto example file if requested
+        if (createExampleFile) {
+            logger.debug('Creating dexto example file...');
+            await createDextoExampleFile(dextoDir);
+            logger.debug('Dexto example file created successfully!');
+        }
+        // add/update .env file (only if user provided a key)
+        spinner.start('Saving API key to .env file...');
+        logger.debug(`Saving API key: provider=${llmProvider ?? 'none'}, hasApiKey=${Boolean(llmApiKey)}`);
+        if (llmProvider && llmApiKey) {
+            await saveProviderApiKey(llmProvider, llmApiKey, process.cwd());
+        }
+        spinner.stop('Saved .env updates');
+    }
+    catch (err) {
+        spinner.stop(chalk.inverse(`An error occurred initializing Dexto project - ${err}`));
+        logger.debug(`Error: ${err}`);
+        process.exit(1);
+    }
+}
+/** Adds notes for users to get started with their new initialized Dexto project */
+export async function postInitDexto(directory) {
+    const nextSteps = [
+        `1. Run the example: ${chalk.cyan(`node --loader ts-node/esm ${path.join(directory, 'dexto', 'dexto-example.ts')}`)}`,
+        `2. Add/update your API key(s) in ${chalk.cyan('.env')}`,
+        `3. Check out the agent configuration file ${chalk.cyan(path.join(directory, 'dexto', 'agents', 'default-agent.yml'))}`,
+        `4. Try out different LLMs and MCP servers in the default-agent.yml file`,
+        `5. Read more about Dexto: ${chalk.cyan('https://github.com/truffle-ai/dexto')}`,
+    ].join('\n');
+    p.note(nextSteps, chalk.yellow('Next steps:'));
+}
+/**
+ * Creates the dexto directories (dexto, dexto/agents) in the given directory.
+ * @param directory - The directory to create the dexto directories in
+ * @returns The path to the created dexto directory
+ */
+export async function createDextoDirectories(directory) {
+    const dirPath = path.join(directory, 'dexto');
+    const agentsPath = path.join(directory, 'dexto', 'agents');
+    try {
+        await fs.access(dirPath);
+        return { ok: false };
+    }
+    catch {
+        // fsExtra.ensureDir creates directories recursively if they don't exist
+        await fsExtra.ensureDir(dirPath);
+        await fsExtra.ensureDir(agentsPath);
+        return { ok: true, dirPath };
+    }
+}
+/**
+ * Creates a dexto config file in the given directory. Pulls the config file from the installed Dexto package.
+ * @param directory - The directory to create the config file in
+ * @returns The path to the created config file
+ */
+export async function createDextoConfigFile(directory) {
+    // Ensure the directory exists
+    await fsExtra.ensureDir(directory);
+    try {
+        // Locate the Dexto package installation directory
+        const pkgJsonPath = require.resolve('dexto/package.json');
+        const pkgDir = path.dirname(pkgJsonPath);
+        logger.debug(`Package directory: ${pkgDir}`);
+        // Build path to the configuration template for create-app (with auto-approve toolConfirmation)
+        const templateConfigSrc = path.join(pkgDir, 'dist', 'agents', 'agent-template.yml');
+        logger.debug(`Looking for template at: ${templateConfigSrc}`);
+        // Check if template exists - fail if not found
+        const templateExists = await fsExtra.pathExists(templateConfigSrc);
+        if (!templateExists) {
+            throw new Error(`Template file not found at: ${templateConfigSrc}. This indicates a build issue - the template should be included in the package.`);
+        }
+        // Path to the destination config file
+        const destConfigPath = path.join(directory, 'default-agent.yml');
+        logger.debug(`Copying template to: ${destConfigPath}`);
+        // Copy the config file from the Dexto package
+        await fsExtra.copy(templateConfigSrc, destConfigPath);
+        logger.debug(`Successfully created config file at: ${destConfigPath}`);
+        return destConfigPath;
+    }
+    catch (error) {
+        logger.error(`Failed to create Dexto config file: ${error}`);
+        throw error;
+    }
+}
+/**
+ * Creates an example file in the given directory showing how to use Dexto in code. This file has example code to get you started.
+ * @param directory - The directory to create the example index file in
+ * @returns The path to the created example index file
+ */
+export async function createDextoExampleFile(directory) {
+    // Extract the base directory from the given path (e.g., "src" from "src/dexto")
+    const baseDir = path.dirname(directory);
+    const configPath = `./${path.posix.join(baseDir, 'dexto/agents/default-agent.yml')}`;
+    const indexTsLines = [
+        "import 'dotenv/config';",
+        "import { DextoAgent, loadAgentConfig } from '@dexto/core';",
+        '',
+        "console.log('🚀 Starting Dexto Basic Example\\n');",
+        '',
+        'try {',
+        '  // Load the agent configuration',
+        `  const config = await loadAgentConfig('${configPath}');`,
+        '',
+        '  // Create a new DextoAgent instance',
+        '  const agent = new DextoAgent(config);',
+        '',
+        '  // Start the agent (connects to MCP servers)',
+        "  console.log('🔗 Connecting to MCP servers...');",
+        '  await agent.start();',
+        "  console.log('✅ Agent started successfully!\\n');",
+        '',
+        '  // Example 1: Simple task',
+        "  console.log('📋 Example 1: Simple information request');",
+        "  const request1 = 'What tools do you have available?';",
+        "  console.log('Request:', request1);",
+        '  const response1 = await agent.run(request1);',
+        "  console.log('Response:', response1);",
+        "  console.log('\\n——————\\n');",
+        '',
+        '  // Example 2: File operation',
+        "  console.log('📄 Example 2: File creation');",
+        '  const request2 = \'Create a file called test-output.txt with the content "Hello from Dexto!"\';',
+        "  console.log('Request:', request2);",
+        '  const response2 = await agent.run(request2);',
+        "  console.log('Response:', response2);",
+        "  console.log('\\n——————\\n');",
+        '',
+        '  // Example 3: Multi-step conversation',
+        "  console.log('🗣️ Example 3: Multi-step conversation');",
+        '  const request3a = \'Create a simple HTML file called demo.html with a heading that says "Dexto Demo"\';',
+        "  console.log('Request 3a:', request3a);",
+        '  const response3a = await agent.run(request3a);',
+        "  console.log('Response:', response3a);",
+        "  console.log('\\n\\n');",
+        "  const request3b = 'Now add a paragraph to that HTML file explaining what Dexto is';",
+        "  console.log('Request 3b:', request3b);",
+        '  const response3b = await agent.run(request3b);',
+        "  console.log('Response:', response3b);",
+        "  console.log('\\n——————\\n');",
+        '',
+        '  // Reset conversation (clear context)',
+        "  console.log('🔄 Resetting conversation context...');",
+        '  await agent.resetConversation();',
+        "  console.log('🔄 Conversation context reset');",
+        "  console.log('\\n——————\\n');",
+        '',
+        '  // Example 4: Complex task',
+        "  console.log('🏗️ Example 4: Complex multi-tool task');",
+        '  const request4 = ',
+        "    'Create a simple webpage about AI agents with HTML, CSS, and JavaScript. ' +",
+        "    'The page should have a title, some content about what AI agents are, ' +",
+        "    'and a button that shows an alert when clicked.';",
+        "  console.log('Request:', request4);",
+        '  const response4 = await agent.run(request4);',
+        "  console.log('Response:', response4);",
+        "  console.log('\\n——————\\n');",
+        '',
+        '  // Stop the agent (disconnect from MCP servers)',
+        "  console.log('\\n🛑 Stopping agent...');",
+        '  await agent.stop();',
+        "  console.log('✅ Agent stopped successfully!');",
+        '',
+        '} catch (error) {',
+        "  console.error('❌ Error:', error);",
+        '}',
+        '',
+        "console.log('\\n📖 Read Dexto documentation to understand more about using Dexto: https://docs.dexto.ai');",
+    ];
+    const indexTsContent = indexTsLines.join('\n');
+    const outputPath = path.join(directory, 'dexto-example.ts');
+    // Log the generated file content and paths for debugging
+    logger.debug(`Creating example file with config path: ${configPath}`);
+    logger.debug(`Base directory: ${baseDir}, Output path: ${outputPath}`);
+    logger.debug(`Generated file content:\n${indexTsContent}`);
+    // Ensure the directory exists before writing the file
+    await fs.writeFile(outputPath, indexTsContent);
+    return outputPath;
+}

package/dist/cli/commands/install.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+declare const InstallCommandSchema: z.ZodObject<{
+    agents: z.ZodArray<z.ZodString, "many">;
+    all: z.ZodDefault<z.ZodBoolean>;
+    injectPreferences: z.ZodDefault<z.ZodBoolean>;
+    force: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    agents: string[];
+    force: boolean;
+    all: boolean;
+    injectPreferences: boolean;
+}, {
+    agents: string[];
+    force?: boolean | undefined;
+    all?: boolean | undefined;
+    injectPreferences?: boolean | undefined;
+}>;
+export type InstallCommandOptions = z.output<typeof InstallCommandSchema>;
+export declare function handleInstallCommand(agents: string[], options: Partial<InstallCommandOptions>): Promise<void>;
+export {};
+//# sourceMappingURL=install.d.ts.map

package/dist/cli/commands/install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/install.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;EAOb,CAAC;AAEd,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAuC1E,wBAAsB,oBAAoB,CACtC,MAAM,EAAE,MAAM,EAAE,EAChB,OAAO,EAAE,OAAO,CAAC,qBAAqB,CAAC,GACxC,OAAO,CAAC,IAAI,CAAC,CAoEf"}

package/dist/cli/commands/install.js

@@ -0,0 +1,103 @@
+// packages/cli/src/cli/commands/install.ts
+import { existsSync } from 'fs';
+import path from 'path';
+import { z } from 'zod';
+import { getAgentRegistry, getDextoGlobalPath } from '@dexto/core';
+// Zod schema for install command validation
+const InstallCommandSchema = z
+    .object({
+    agents: z.array(z.string().min(1, 'Agent name cannot be empty')),
+    all: z.boolean().default(false),
+    injectPreferences: z.boolean().default(true),
+    force: z.boolean().default(false),
+})
+    .strict();
+/**
+ * Validate install command arguments with registry-aware validation
+ */
+function validateInstallCommand(agents, options) {
+    const registry = getAgentRegistry();
+    // Basic structure validation
+    const validated = InstallCommandSchema.parse({
+        ...options,
+        agents,
+    });
+    // Business logic validation
+    const availableAgents = registry.getAvailableAgents();
+    if (!validated.all && validated.agents.length === 0) {
+        throw new Error(`No agents specified. Use agent names or --all flag.  Available agents: ${Object.keys(availableAgents).join(', ')}`);
+    }
+    if (!validated.all) {
+        // Validate all specified agents exist in registry
+        const invalidAgents = validated.agents.filter((agent) => !registry.hasAgent(agent));
+        if (invalidAgents.length > 0) {
+            throw new Error(`Unknown agents: ${invalidAgents.join(', ')}. ` +
+                `Available agents: ${Object.keys(availableAgents).join(', ')}`);
+        }
+    }
+    return validated;
+}
+export async function handleInstallCommand(agents, options) {
+    // Validate command with Zod
+    const validated = validateInstallCommand(agents, options);
+    const registry = getAgentRegistry();
+    // Determine which agents to install
+    let agentsToInstall;
+    if (validated.all) {
+        agentsToInstall = Object.keys(registry.getAvailableAgents());
+        console.log(`📋 Installing all ${agentsToInstall.length} available agents...`);
+    }
+    else {
+        agentsToInstall = validated.agents;
+    }
+    console.log(`🚀 Installing ${agentsToInstall.length} agents...`);
+    let successCount = 0;
+    let errorCount = 0;
+    const errors = [];
+    // Install each agent
+    for (const agentName of agentsToInstall) {
+        try {
+            console.log(`\n📦 Installing ${agentName}...`);
+            // Check if already installed (unless --force)
+            const globalAgentsDir = getDextoGlobalPath('agents');
+            const installedPath = path.join(globalAgentsDir, agentName);
+            if (existsSync(installedPath) && !validated.force) {
+                console.log(`⏭️  ${agentName} already installed (use --force to reinstall)`);
+                successCount++;
+                continue;
+            }
+            await registry.installAgent(agentName, validated.injectPreferences);
+            successCount++;
+            console.log(`✅ ${agentName} installed successfully`);
+        }
+        catch (error) {
+            errorCount++;
+            const errorMsg = `Failed to install ${agentName}: ${error instanceof Error ? error.message : String(error)}`;
+            errors.push(errorMsg);
+            console.error(`❌ ${errorMsg}`);
+        }
+    }
+    // For single agent operations, throw error if it failed
+    if (agentsToInstall.length === 1) {
+        if (errorCount > 0) {
+            throw new Error(errors[0]);
+        }
+        return;
+    }
+    // Show summary if more than 1 agent installed
+    console.log(`\n📊 Installation Summary:`);
+    console.log(`✅ Successfully installed: ${successCount}`);
+    if (errorCount > 0) {
+        console.log(`❌ Failed to install: ${errorCount}`);
+        errors.forEach((error) => console.log(`   • ${error}`));
+    }
+    if (errorCount > 0 && successCount === 0) {
+        throw new Error('All installations failed');
+    }
+    else if (errorCount > 0) {
+        console.log(`⚠️  Some installations failed, but ${successCount} succeeded.`);
+    }
+    else {
+        console.log(`🎉 All agents installed successfully!`);
+    }
+}