@agentuity/cli 0.0.43 → 0.0.44

package/src/cmd/bundle/fix-duplicate-exports.test.ts

@@ -0,0 +1,387 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { join } from 'node:path';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { fixDuplicateExportsInDirectory } from './fix-duplicate-exports';
+
+describe('fix-duplicate-exports', () => {
+	let tempDir: string;
+
+	beforeEach(async () => {
+		tempDir = await mkdtemp(join(tmpdir(), 'fix-duplicate-exports-test-'));
+	});
+
+	afterEach(async () => {
+		await rm(tempDir, { recursive: true, force: true });
+	});
+
+	describe('export alias syntax preservation', () => {
+		test('preserves "qux as baz" when removing duplicate foo', async () => {
+			// This is the critical bug case from the feedback
+			const code = `export { foo };
+export { qux as baz, foo };`;
+
+			const expected = `export { foo };
+export { qux as baz };`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(expected);
+		});
+
+		test('preserves "foo as bar" when it is not duplicate', async () => {
+			const code = `export { foo as bar };
+export { baz };`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			// Should not change - no duplicates
+			expect(result).toBe(code);
+		});
+
+		test('handles multiple aliases in same export statement', async () => {
+			const code = `export { foo as bar, baz as qux };
+export { bar, simple };`;
+
+			// "bar" is duplicate (exported in both statements)
+			const expected = `export { foo as bar, baz as qux };
+export { simple };`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(expected);
+		});
+
+		test('preserves alias when removing from middle of export list', async () => {
+			const code = `export { alpha, beta };
+export { alpha, gamma as delta, epsilon };`;
+
+			const expected = `export { alpha, beta };
+export { gamma as delta, epsilon };`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(expected);
+		});
+
+		test('handles exported name being the duplicate (alias target)', async () => {
+			const code = `export { foo as bar };
+export { bar };`;
+
+			// "bar" from first export and "bar" from second export are DIFFERENT
+			// First one exports the identifier "foo" with the name "bar"
+			// Second one exports the identifier "bar" with the name "bar"
+			// These are duplicates from export name perspective
+			const expected = `export { foo as bar };
+`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(expected);
+		});
+	});
+
+	describe('duplicate removal', () => {
+		test('removes entire duplicate export statement', async () => {
+			const code = `export { foo, bar };
+export { foo, bar };`;
+
+			const expected = `export { foo, bar };
+`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(expected);
+		});
+
+		test('removes only duplicate names from partial duplicate', async () => {
+			const code = `export { foo, bar };
+export { foo, baz };`;
+
+			const expected = `export { foo, bar };
+export { baz };`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(expected);
+		});
+
+		test('handles three-way duplicates', async () => {
+			const code = `export { foo };
+export { bar };
+export { foo };`;
+
+			const expected = `export { foo };
+export { bar };
+`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(expected);
+		});
+
+		test('preserves non-duplicate exports', async () => {
+			const code = `export { foo };
+export { bar };
+export { baz };`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			// Should not change - no duplicates
+			expect(result).toBe(code);
+		});
+	});
+
+	describe('__INVALID__REF__ removal', () => {
+		test('removes __INVALID__REF__ at start with comma', async () => {
+			const code = `export { __INVALID__REF__, foo, bar };`;
+			const expected = `export { foo, bar };`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(expected);
+		});
+
+		test('removes __INVALID__REF__ at end with comma', async () => {
+			const code = `export { foo, bar, __INVALID__REF__ };`;
+			const expected = `export { foo, bar };`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(expected);
+		});
+
+		test('removes __INVALID__REF__ in middle', async () => {
+			const code = `export { foo, __INVALID__REF__, bar };`;
+			const expected = `export { foo, bar };`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(expected);
+		});
+
+		test('removes __INVALID__REF__ from imports', async () => {
+			const code = `import { __INVALID__REF__, foo } from 'bar';
+export { foo };`;
+
+			const expected = `import { foo } from 'bar';
+export { foo };`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(expected);
+		});
+	});
+
+	describe('complex scenarios', () => {
+		test('handles combination of aliases and duplicates', async () => {
+			const code = `export { foo as exportedFoo, bar };
+export { baz as exportedBaz };
+export { bar, qux };`;
+
+			const expected = `export { foo as exportedFoo, bar };
+export { baz as exportedBaz };
+export { qux };`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(expected);
+		});
+
+		test('handles whitespace variations', async () => {
+			const code = `export { foo };
+  export { bar as baz  , foo };`;
+
+			const expected = `export { foo };
+export { bar as baz };`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(expected);
+		});
+
+		test('does not modify non-matching export patterns', async () => {
+			const code = `export default function foo() {}
+export const bar = 1;
+export { baz };
+export * from './other';`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			// Should only process export { ... } statements
+			expect(result).toBe(code);
+		});
+
+		test('handles multiple files in directory', async () => {
+			const file1 = join(tempDir, 'file1.js');
+			const file2 = join(tempDir, 'file2.js');
+
+			await Bun.write(file1, `export { foo };\nexport { foo };`);
+			await Bun.write(file2, `export { qux as baz };\nexport { baz };`);
+
+			await fixDuplicateExportsInDirectory(tempDir, false);
+
+			const result1 = await Bun.file(file1).text();
+			const result2 = await Bun.file(file2).text();
+
+			expect(result1).toBe(`export { foo };
+`);
+			expect(result2).toBe(`export { qux as baz };
+`);
+		});
+	});
+
+	describe('patch order edge cases', () => {
+		test('handles partial duplicate followed by full duplicate', async () => {
+			// This tests the scenario where modification shifts indices for subsequent removal
+			const code = `export { foo };
+export { foo, bar };
+export { foo };`;
+
+			// Expected: first foo kept, second becomes just bar, third removed
+			const expected = `export { foo };
+export { bar };
+`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(expected);
+		});
+
+		test('handles multiple partial duplicates with full duplicate at end', async () => {
+			const code = `export { foo };
+export { foo, bar };
+export { foo, baz };
+export { foo };`;
+
+			// First foo kept, second becomes bar only, third becomes baz only, fourth removed
+			const expected = `export { foo };
+export { bar };
+export { baz };
+`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(expected);
+		});
+
+		test('handles full duplicate followed by partial duplicate', async () => {
+			const code = `export { foo, bar };
+export { foo, bar };
+export { bar, baz };`;
+
+			// First kept, second removed (full dup - leaves blank line), third becomes just baz
+			const expected = `export { foo, bar };
+
+export { baz };`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(expected);
+		});
+	});
+
+	describe('edge cases', () => {
+		test('handles empty file', async () => {
+			const code = '';
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(code);
+		});
+
+		test('handles file with no exports', async () => {
+			const code = `const foo = 1;\nconst bar = 2;`;
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(code);
+		});
+
+		test('handles single export with alias', async () => {
+			const code = `export { foo as bar };`;
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(code);
+		});
+
+		test('handles export with semicolon vs without', async () => {
+			const code = `export { foo }
+export { foo };`;
+
+			const expected = `export { foo }
+`;
+
+			const testFile = join(tempDir, 'test.js');
+			await Bun.write(testFile, code);
+			await fixDuplicateExportsInDirectory(tempDir, false);
+			const result = await Bun.file(testFile).text();
+
+			expect(result).toBe(expected);
+		});
+	});
+});

package/src/cmd/bundle/fix-duplicate-exports.ts

@@ -0,0 +1,204 @@
+import path from 'node:path';
+
+export async function fixDuplicateExportsInDirectory(dir: string, verbose = false) {
+	if (verbose) {
+		console.log(`Scanning for .js files in: ${dir}`);
+	}
+
+	const jsFiles = await getAllJsFiles(dir);
+	if (verbose) {
+		console.log(`Found ${jsFiles.length} .js files`);
+	}
+
+	if (jsFiles.length === 0) {
+		if (verbose) {
+			console.log('No .js files found');
+		}
+		return;
+	}
+
+	// Process all files in parallel
+	const results = await Promise.all(
+		jsFiles.map(async (filePath) => {
+			try {
+				const wasFixed = await fixDuplicateExportsInFile(filePath, verbose);
+				return { filePath, wasFixed, error: null };
+			} catch (error) {
+				return { filePath, wasFixed: false, error };
+			}
+		})
+	);
+
+	// Report results
+	const fixed = results.filter((r) => r.wasFixed);
+	const errors = results.filter((r) => r.error);
+
+	if (verbose) {
+		console.log(`\nResults:`);
+		console.log(`- Total files: ${jsFiles.length}`);
+		console.log(`- Files fixed: ${fixed.length}`);
+		console.log(`- Errors: ${errors.length}`);
+
+		if (fixed.length > 0) {
+			console.log('\nFixed files:');
+			fixed.forEach(({ filePath }) => {
+				console.log(`  - ${filePath}`);
+			});
+		}
+
+		if (errors.length > 0) {
+			console.log('\nErrors:');
+			errors.forEach(({ filePath, error }) => {
+				console.log(`  - ${filePath}: ${error}`);
+			});
+		}
+	}
+}
+
+async function fixDuplicateExportsInFile(filePath: string, verbose = false): Promise<boolean> {
+	const originalCode = await Bun.file(filePath).text();
+
+	// Only fix __INVALID__REF__ - remove it from imports and exports
+	let code = originalCode;
+
+	// Pattern 1: __INVALID__REF__ at start with comma after: "__INVALID__REF__, foo" -> "foo"
+	code = code.replace(/\b__INVALID__REF__\s*,\s*/g, '');
+
+	// Pattern 2: __INVALID__REF__ at end with comma before: "foo, __INVALID__REF__" -> "foo"
+	code = code.replace(/,\s*__INVALID__REF__\b/g, '');
+
+	// Pattern 3: __INVALID__REF__ alone (shouldn't happen but handle it)
+	code = code.replace(/\b__INVALID__REF__\b/g, '');
+
+	// Remove duplicate export statements
+	// Find all export { ... } statements (allow leading whitespace)
+	const exportPattern = /^\s*export\s*\{([^}]+)\}\s*;?\s*$/gm;
+	const exports: Array<{
+		match: string;
+		names: Set<string>;
+		nameToSyntax: Map<string, string>;
+		start: number;
+		end: number;
+	}> = [];
+	let match;
+
+	while ((match = exportPattern.exec(code)) !== null) {
+		const nameToSyntax = new Map<string, string>();
+		const names: string[] = [];
+
+		match[1].split(',').forEach((n) => {
+			const fullSyntax = n.trim();
+			const parts = fullSyntax.split(/\s+as\s+/);
+			const exportedName = parts.length > 1 ? parts[1].trim() : parts[0].trim();
+			if (exportedName) {
+				names.push(exportedName);
+				nameToSyntax.set(exportedName, fullSyntax);
+			}
+		});
+
+		exports.push({
+			match: match[0],
+			names: new Set(names),
+			nameToSyntax,
+			start: match.index,
+			end: match.index + match[0].length,
+		});
+	}
+
+	// Track which names we've seen and which export statements to remove/modify
+	const seenNames = new Set<string>();
+	const indicesToRemove: number[] = [];
+	const modificationsNeeded = new Map<number, Set<string>>(); // index -> names to keep
+
+	for (let i = 0; i < exports.length; i++) {
+		const exp = exports[i];
+		const duplicateNames = [...exp.names].filter((name) => seenNames.has(name));
+		const newNames = [...exp.names].filter((name) => !seenNames.has(name));
+		const allDuplicates = duplicateNames.length === exp.names.size;
+
+		if (verbose && duplicateNames.length > 0) {
+			console.log(`  Duplicate exports found in statement ${i}: ${duplicateNames.join(', ')}`);
+		}
+
+		if (allDuplicates && exp.names.size > 0) {
+			// This entire export statement is a duplicate - remove it
+			indicesToRemove.push(i);
+			if (verbose) {
+				console.log(`    -> Will remove entire statement`);
+			}
+		} else if (duplicateNames.length > 0) {
+			// Partial duplicates - need to remove just the duplicate names
+			modificationsNeeded.set(i, new Set(newNames));
+			if (verbose) {
+				console.log(`    -> Will keep only: ${newNames.join(', ')}`);
+			}
+			// Mark the new names as seen
+			newNames.forEach((name) => seenNames.add(name));
+		} else {
+			// No duplicates - mark these names as seen
+			exp.names.forEach((name) => seenNames.add(name));
+		}
+	}
+
+	// Build patches for modifications and removals, then apply from end to preserve indices
+	const patches: Array<{ start: number; end: number; replacement: string }> = [];
+
+	// Partial duplicates: replace the export statement with only the kept names
+	for (const [i, namesToKeep] of modificationsNeeded.entries()) {
+		const exp = exports[i];
+		const syntaxToKeep = [...namesToKeep].map((name) => exp.nameToSyntax.get(name)!);
+		const newExport = `export { ${syntaxToKeep.join(', ')} };`;
+		patches.push({ start: exp.start, end: exp.end, replacement: newExport });
+	}
+
+	// Full duplicates: remove the entire export statement
+	for (const idx of indicesToRemove) {
+		const exp = exports[idx];
+		patches.push({ start: exp.start, end: exp.end, replacement: '' });
+	}
+
+	// Apply all patches from right to left so earlier indices remain valid
+	patches.sort((a, b) => b.start - a.start);
+	for (const { start, end, replacement } of patches) {
+		code = code.slice(0, start) + replacement + code.slice(end);
+	}
+	// Nothing changed
+	if (code === originalCode) {
+		return false;
+	}
+
+	// Write the fixed content back to the file
+	await Bun.write(filePath, code);
+
+	if (verbose) {
+		console.log(`\n🔧 Fixed exports in: ${filePath}`);
+	}
+
+	return true;
+}
+
+async function getAllJsFiles(dir: string): Promise<string[]> {
+	const glob = new Bun.Glob('**/*.js');
+	const files = await Array.fromAsync(glob.scan({ cwd: dir }));
+	return files.map((file) => path.join(dir, file));
+}
+
+async function main() {
+	const dir = process.argv[2];
+	if (!dir) {
+		console.error('Usage: bun fix-duplicate-exports.ts <directory>');
+		process.exit(1);
+	}
+
+	const { existsSync } = await import('node:fs');
+	if (!existsSync(dir)) {
+		console.error(`Error: Directory does not exist: ${dir}`);
+		process.exit(1);
+	}
+
+	await fixDuplicateExportsInDirectory(dir, true);
+}
+
+if (import.meta.main) {
+	await main();
+}

package/src/cmd/bundle/index.ts

@@ -1,37 +1,37 @@
 import { createCommand } from '../../types';
 import { z } from 'zod';
-import { resolve } from 'node:path';
 import { bundle } from './bundler';
+import * as tui from '../../tui';
 
 export const command = createCommand({
 	name: 'bundle',
 	description: 'Bundle Agentuity application for deployment',
 	aliases: ['build'],
+	optional: { project: true },
 	schema: {
 		options: z.object({
-			dir: z.string().optional().describe('Root directory of the project'),
 			dev: z.boolean().optional().describe('Enable development mode'),
 		}),
 	},
 
 	async handler(ctx) {
-		const { logger, opts } = ctx;
-		const rootDir = resolve(opts.dir || process.cwd());
+		const { opts, projectDir, project } = ctx;
 
 		try {
-			logger.info(`Bundling project at: ${rootDir}`);
+			tui.info(`Bundling project at: ${projectDir}`);
 
 			await bundle({
-				rootDir,
+				rootDir: projectDir,
 				dev: opts.dev || false,
+				project,
 			});
 
-			logger.info('✓ Bundle complete');
+			tui.success('Bundle complete');
 		} catch (error) {
 			if (error instanceof Error) {
-				logger.fatal(`Bundle failed: ${error.message}`);
+				tui.fatal(`Bundle failed: ${error.message}`);
 			} else {
-				logger.fatal('Bundle failed');
+				tui.fatal('Bundle failed');
 			}
 		}
 	},

package/src/cmd/bundle/patch/aisdk.ts

@@ -121,7 +121,7 @@ function createVercelAIProviderPatch(
 				before: generateEnvGuard(
 					envkey,
 					generateVercelAIProvider(provider, envkey),
-					`console.log("User provided API Key set for ${provider}. Switch to Agentuity AI Gateway for better logs, metrics and billing.");`
+					`if (!process.env.AGENTUITY_SDK_KEY) console.log("User provided ${provider} api key set. Use the Agentuity AI Gateway more features.");`
 				),
 			},
 		},