@agentuity/cli 3.0.0-alpha.7 → 3.0.0-beta.0

package/src/cmd/repl/index.ts

@@ -1,477 +0,0 @@
-import { createCommand } from '../../types';
-import { createRepl, type ReplCommand } from '../../repl';
-import { z } from 'zod';
-import { getCommand } from '../../command-prefix';
-
-export const command = createCommand({
-	name: 'repl',
-	hidden: true,
-	description: 'interactive REPL for testing',
-	tags: ['slow'],
-	idempotent: false,
-	examples: [{ command: getCommand('repl'), description: 'Run repl command' }],
-
-	async handler() {
-		// Define test commands
-		const commands: ReplCommand[] = [
-			{
-				name: 'keyvalue',
-				aliases: ['kv'],
-				description: 'Echo back the arguments',
-				schema: {
-					args: z.tuple([z.string().min(1)]).rest(z.string()),
-					argNames: ['action'],
-				},
-				handler: (ctx) => {
-					ctx.write(ctx.parsed.args.join(' '));
-				},
-			},
-			{
-				name: 'echoall',
-				description: 'Echo all arguments with separators',
-				handler: (ctx) => {
-					if (ctx.parsed.args.length === 0) {
-						ctx.error('Usage: echoall <args...>');
-						return;
-					}
-					ctx.write(ctx.parsed.args.map((arg, i) => `[${i + 1}] ${arg}`).join('\n'));
-				},
-			},
-			{
-				name: 'echofile',
-				description: 'Echo as if writing to a file',
-				handler: (ctx) => {
-					if (ctx.parsed.args.length === 0) {
-						ctx.error('Usage: echofile <content>');
-						return;
-					}
-					ctx.success(`Would write to file: ${ctx.parsed.args.join(' ')}`);
-				},
-			},
-			{
-				name: 'upper',
-				description: 'Convert text to uppercase',
-				aliases: ['up'],
-				handler: (ctx) => {
-					if (ctx.parsed.args.length === 0) {
-						ctx.error('Usage: upper <text>');
-						return;
-					}
-					ctx.success(ctx.parsed.args.join(' ').toUpperCase());
-				},
-			},
-			{
-				name: 'lower',
-				description: 'Convert text to lowercase',
-				aliases: ['down'],
-				handler: (ctx) => {
-					if (ctx.parsed.args.length === 0) {
-						ctx.error('Usage: lower <text>');
-						return;
-					}
-					ctx.success(ctx.parsed.args.join(' ').toLowerCase());
-				},
-			},
-			{
-				name: 'count',
-				description: 'Count from 1 to N (with optional delay)',
-				schema: {
-					args: z.tuple([z.coerce.number().int().positive().default(5)]),
-					argNames: ['number'],
-					options: z.object({
-						delay: z.coerce.number().int().positive().default(100).optional(),
-					}),
-				},
-				handler: async function* (ctx) {
-					const count = parseInt(ctx.parsed.args[0] || '5', 10);
-					const delay = parseInt(ctx.parsed.options.delay as string, 10) || 100;
-
-					for (let i = 1; i <= count; i++) {
-						yield `${i}`;
-						if (i < count) {
-							yield ', ';
-						}
-						await new Promise((resolve) => setTimeout(resolve, delay));
-					}
-				},
-			},
-			{
-				name: 'longoutput',
-				description: 'Generate long output to test paging',
-				aliases: ['long'],
-				handler: (ctx) => {
-					const lines = parseInt(ctx.parsed.args[0] || '50', 10);
-					for (let i = 1; i <= lines; i++) {
-						ctx.write(
-							`Line ${i}: This is a test line to demonstrate output paging in the REPL`
-						);
-					}
-				},
-			},
-			{
-				name: 'download',
-				description: 'Simulate a download with progress updates',
-				schema: {
-					args: z.tuple([z.coerce.number().int().positive().default(5)]),
-					argNames: ['chunks'],
-				},
-				handler: async (ctx) => {
-					const chunks = parseInt(ctx.parsed.args[0] || '5', 10);
-
-					for (let i = 1; i <= chunks; i++) {
-						// Check if aborted
-						if (ctx.signal.aborted) {
-							return; // Just return, abort will be detected
-						}
-
-						ctx.setProgress(`Downloading chunk ${i}/${chunks}`);
-
-						// Use signal with setTimeout for proper abort handling
-						await new Promise((resolve) => {
-							const timeout = setTimeout(resolve, 500);
-							ctx.signal.addEventListener(
-								'abort',
-								() => {
-									clearTimeout(timeout);
-									resolve(undefined); // Resolve to exit cleanly
-								},
-								{ once: true }
-							);
-						});
-					}
-
-					if (ctx.signal.aborted) return;
-
-					ctx.setProgress('Processing downloaded data');
-					await new Promise((resolve) => {
-						const timeout = setTimeout(resolve, 1000);
-						ctx.signal.addEventListener(
-							'abort',
-							() => {
-								clearTimeout(timeout);
-								resolve(undefined);
-							},
-							{ once: true }
-						);
-					});
-
-					if (!ctx.signal.aborted) {
-						ctx.success(`Downloaded ${chunks} chunks successfully!`);
-					}
-				},
-			},
-			{
-				name: 'greet',
-				description: 'Greet a person with optional title',
-				schema: {
-					args: z.tuple([z.string().min(1)]),
-					argNames: ['name'],
-					options: z.object({
-						title: z.string().optional(),
-						loud: z.boolean().optional(),
-					}),
-				},
-				handler: (ctx) => {
-					const name = ctx.parsed.args[0];
-					const title = ctx.parsed.options.title || '';
-					const greeting = title ? `Hello, ${title} ${name}!` : `Hello, ${name}!`;
-
-					if (ctx.parsed.options.loud) {
-						ctx.success(greeting.toUpperCase());
-					} else {
-						ctx.success(greeting);
-					}
-				},
-			},
-			{
-				name: 'options',
-				description: 'Show all parsed options for debugging',
-				handler: (ctx) => {
-					ctx.info('Parsed command:');
-					ctx.json(ctx.parsed);
-				},
-			},
-			{
-				name: 'json',
-				description: 'Display JSON data in colorized format',
-				schema: {
-					args: z.tuple([z.string().optional()]),
-					argNames: ['data'],
-				},
-				handler: (ctx) => {
-					const input = ctx.parsed.args.join(' ').trim();
-
-					if (!input) {
-						// Show example JSON
-						ctx.json({
-							users: [
-								{ id: 1, name: 'Alice', active: true, tags: ['admin', 'user'] },
-								{ id: 2, name: 'Bob', active: false, tags: ['user'] },
-							],
-							metadata: {
-								total: 2,
-								timestamp: new Date().toISOString(),
-							},
-						});
-						return;
-					}
-
-					// Try to parse input as JSON
-					try {
-						const parsed = JSON.parse(input);
-						ctx.json(parsed);
-					} catch {
-						ctx.error('Invalid JSON input');
-					}
-				},
-			},
-			{
-				name: 'kv',
-				description: 'Key-value store commands',
-				subcommands: [
-					{
-						name: 'set',
-						description: 'Set a key-value pair',
-						schema: {
-							args: z.tuple([z.string().min(1), z.string()]),
-							argNames: ['key', 'value'],
-						},
-						handler: (ctx) => {
-							const [key, value] = ctx.parsed.args;
-							ctx.success(`Set ${key} = ${value}`);
-						},
-					},
-					{
-						name: 'get',
-						description: 'Get a value by key',
-						schema: {
-							args: z.tuple([z.string().min(1)]),
-							argNames: ['key'],
-						},
-						handler: (ctx) => {
-							const key = ctx.parsed.args[0];
-							ctx.write(`Value for ${key}: (example value)`);
-						},
-					},
-					{
-						name: 'del',
-						description: 'Delete a key',
-						aliases: ['delete', 'rm'],
-						schema: {
-							args: z.tuple([z.string().min(1)]),
-							argNames: ['key'],
-						},
-						handler: (ctx) => {
-							const key = ctx.parsed.args[0];
-							ctx.success(`Deleted ${key}`);
-						},
-					},
-				],
-			},
-			{
-				name: 'vector',
-				description: 'Vector store commands',
-				subcommands: [
-					{
-						name: 'set',
-						description: 'Store a vector',
-						schema: {
-							args: z.tuple([z.string().min(1), z.string()]),
-							argNames: ['id', 'vector'],
-						},
-						handler: (ctx) => {
-							const [id, _vector] = ctx.parsed.args;
-							ctx.success(`Stored vector ${id}`);
-						},
-					},
-					{
-						name: 'get',
-						description: 'Retrieve a vector by ID',
-						schema: {
-							args: z.tuple([z.string().min(1)]),
-							argNames: ['id'],
-						},
-						handler: (ctx) => {
-							const id = ctx.parsed.args[0];
-							ctx.write(`Vector for ${id}: [0.1, 0.2, 0.3, ...]`);
-						},
-					},
-				],
-			},
-			{
-				name: 'sql',
-				description: 'Execute a mock SQL query and display results',
-				schema: {
-					args: z.tuple([z.string().min(1)]).rest(z.string()),
-					argNames: ['query'],
-				},
-				handler: (ctx) => {
-					const query = ctx.parsed.args.join(' ').trim();
-
-					if (!query) {
-						ctx.error('Usage: sql <query>');
-						return;
-					}
-
-					// Simulate different query results based on query pattern
-					const queryLower = query.toLowerCase();
-
-					if (queryLower.includes('select') && queryLower.includes('users')) {
-						// Mock user table
-						ctx.table(
-							[
-								{ name: 'id', alignment: 'right' },
-								{ name: 'name', alignment: 'left' },
-								{ name: 'email', alignment: 'left' },
-								{ name: 'active', alignment: 'center' },
-								{ name: 'created_at', alignment: 'left' },
-							],
-							[
-								{
-									id: 1,
-									name: 'Alice Johnson',
-									email: 'alice@example.com',
-									active: 'Yes',
-									created_at: '2024-01-15 10:30:00',
-								},
-								{
-									id: 2,
-									name: 'Bob Smith',
-									email: 'bob@example.com',
-									active: 'Yes',
-									created_at: '2024-02-20 14:15:00',
-								},
-								{
-									id: 3,
-									name: 'Carol Williams',
-									email: 'carol@example.com',
-									active: 'No',
-									created_at: '2024-03-10 09:00:00',
-								},
-							]
-						);
-						ctx.info('3 rows returned');
-					} else if (queryLower.includes('select') && queryLower.includes('products')) {
-						// Mock product table
-						ctx.table(
-							[
-								{ name: 'id', alignment: 'right' },
-								{ name: 'name', alignment: 'left' },
-								{ name: 'price', alignment: 'right' },
-								{ name: 'stock', alignment: 'right' },
-								{ name: 'category', alignment: 'left' },
-							],
-							[
-								{
-									id: 101,
-									name: 'Laptop Pro',
-									price: '$1299.99',
-									stock: 45,
-									category: 'Electronics',
-								},
-								{
-									id: 102,
-									name: 'Wireless Mouse',
-									price: '$29.99',
-									stock: 120,
-									category: 'Accessories',
-								},
-								{
-									id: 103,
-									name: 'USB-C Cable',
-									price: '$12.99',
-									stock: 200,
-									category: 'Accessories',
-								},
-								{
-									id: 104,
-									name: 'Monitor 27"',
-									price: '$349.99',
-									stock: 30,
-									category: 'Electronics',
-								},
-							]
-						);
-						ctx.info('4 rows returned');
-					} else if (queryLower.includes('select') && queryLower.includes('orders')) {
-						// Mock orders table
-						ctx.table(
-							[
-								{ name: 'order_id', alignment: 'right' },
-								{ name: 'user_id', alignment: 'right' },
-								{ name: 'total', alignment: 'right' },
-								{ name: 'status', alignment: 'left' },
-								{ name: 'order_date', alignment: 'left' },
-							],
-							[
-								{
-									order_id: 1001,
-									user_id: 1,
-									total: '$1329.98',
-									status: 'Shipped',
-									order_date: '2024-11-01',
-								},
-								{
-									order_id: 1002,
-									user_id: 2,
-									total: '$42.98',
-									status: 'Processing',
-									order_date: '2024-11-15',
-								},
-								{
-									order_id: 1003,
-									user_id: 1,
-									total: '$349.99',
-									status: 'Delivered',
-									order_date: '2024-11-10',
-								},
-							]
-						);
-						ctx.info('3 rows returned');
-					} else if (
-						queryLower.includes('insert') ||
-						queryLower.includes('update') ||
-						queryLower.includes('delete')
-					) {
-						// Mock mutation result
-						const affected = Math.floor(Math.random() * 5) + 1;
-						ctx.success(`Query OK, ${affected} row(s) affected`);
-					} else {
-						// Generic SELECT result
-						ctx.table(
-							[
-								{ name: 'column1', alignment: 'left' },
-								{ name: 'column2', alignment: 'left' },
-								{ name: 'column3', alignment: 'left' },
-							],
-							[
-								{
-									column1: 'value1',
-									column2: 'value2',
-									column3: 'value3',
-								},
-								{
-									column1: 'data1',
-									column2: 'data2',
-									column3: 'data3',
-								},
-							]
-						);
-						ctx.info('2 rows returned');
-					}
-				},
-			},
-		];
-
-		// Start the REPL
-		await createRepl({
-			name: 'test',
-			prompt: '> ',
-			welcome: 'Welcome to the Agentuity REPL! Type "help" or / for available commands.',
-			exitMessage: 'Goodbye!',
-			commands,
-		});
-	},
-});
-
-export default command;

package/src/cmd/setup/index.ts

@@ -1,93 +0,0 @@
-import { z } from 'zod';
-import { createCommand } from '../../types';
-import { hasLoggedInBefore } from '../../auth';
-import { showBanner } from '../../banner';
-import * as tui from '../../tui';
-import { getCommand } from '../../command-prefix';
-import { getAgentPromptMarkdown } from '../../onboarding/agentPrompt';
-
-const validateToken = /[\d]{7,}\.[\w-_.]{22}/;
-
-export const command = createCommand({
-	name: 'setup',
-	description: 'Display first-run setup information (internal use)',
-	hidden: true,
-	skipUpgradeCheck: true,
-	skipSkill: true,
-	tags: ['read-only', 'fast'],
-	schema: {
-		options: z.object({
-			nonInteractive: z.boolean().optional().describe('Run in non-interactive mode'),
-			setupToken: z.string().optional().describe('Use a one-time use setup token'),
-		}),
-	},
-
-	async handler(ctx) {
-		const { opts } = ctx;
-		const _nonInteractive = opts.nonInteractive ?? false;
-
-		// validate the one time setup token if provided
-		if (opts?.setupToken && opts.setupToken !== '-' && validateToken.test(opts.setupToken)) {
-			const [hours] = opts.setupToken.split('.');
-			const tokenInterval = Number(hours);
-			if (!Number.isNaN(tokenInterval)) {
-				const now = Math.round(Date.now() / (60_000 * 5));
-				if (tokenInterval === now || tokenInterval === now - 1) {
-					const ok = await tui.spinner({
-						message: 'Validating your identity',
-						clearOnSuccess: true,
-						callback: async () => {
-							// Re-run the CLI with 'login' instead of 'setup'
-							// Only replace the first occurrence of 'setup' to avoid replacing user data
-							const argv = process.argv;
-							const setupIndex = argv.indexOf('setup');
-							const cmd =
-								setupIndex >= 0
-									? [...argv.slice(0, setupIndex), 'login', ...argv.slice(setupIndex + 1)]
-									: argv;
-							const r = Bun.spawn({
-								cmd: cmd.concat('--json'),
-								stdout: 'pipe',
-								stderr: 'inherit',
-							});
-							await r.exited;
-							try {
-								const res = JSON.parse(await r.stdout.text()) as { success: boolean };
-								return res.success;
-							} catch {
-								/* fall through */
-							}
-							return false;
-						},
-					});
-					if (ok) {
-						process.stdout.write(getAgentPromptMarkdown());
-						return;
-					}
-				}
-			}
-		}
-
-		tui.newline();
-		showBanner();
-		tui.newline();
-
-		if (!(await hasLoggedInBefore())) {
-			tui.output(`${tui.muted('To get started, run:')}`);
-			tui.newline();
-			tui.output(
-				`${tui.colorPrimary(getCommand('login'))}        ${tui.muted('Login to an existing account (or signup)')}`
-			);
-			tui.output(
-				`${tui.colorPrimary(getCommand('create'))}       ${tui.muted('Create a project')}`
-			);
-			tui.output(
-				`${tui.colorPrimary(getCommand('help'))}         ${tui.muted('List commands and options')}`
-			);
-		} else {
-			tui.success('Welcome back! 🙌');
-		}
-
-		return undefined;
-	},
-});

package/src/cmd/support/index.ts

@@ -1,11 +0,0 @@
-import { createCommand } from '../../types';
-import logs from './logs';
-import report from './report';
-import system from './system';
-
-export const command = createCommand({
-	name: 'support',
-	description: 'Create support tickets and report issues',
-	skipInternalLogging: true,
-	subcommands: [logs, report, system],
-});

package/src/cmd/support/logs/index.ts

@@ -1,9 +0,0 @@
-import { createCommand } from '../../../types';
-import show from './show';
-import path from './path';
-
-export default createCommand({
-	name: 'logs',
-	description: 'View and manage CLI execution logs',
-	subcommands: [show, path],
-});

package/src/cmd/support/logs/path.ts

@@ -1,56 +0,0 @@
-import { createSubcommand } from '../../../types';
-import { z } from 'zod';
-import { getLatestLogSession, getLogsDirPath } from '../../../internal-logger';
-import * as tui from '../../../tui';
-
-const argsSchema = z.object({});
-
-const optionsSchema = z.object({
-	logs: z.boolean().optional().default(false).describe('Show path to logs directory instead of session'),
-});
-
-export default createSubcommand({
-	name: 'path',
-	description: 'Show the path to the most recent log session',
-	schema: {
-		args: argsSchema,
-		options: optionsSchema,
-	},
-	handler: async (ctx) => {
-		const { opts } = ctx;
-		const isJsonMode = ctx.options.json;
-
-		if (opts.logs) {
-			// Show the logs directory path
-			const logsDir = getLogsDirPath();
-			if (isJsonMode) {
-				console.log(JSON.stringify({ logsDir }));
-			} else {
-				console.log(logsDir);
-			}
-			return;
-		}
-
-		const sessionDir = getLatestLogSession();
-		if (!sessionDir) {
-			if (isJsonMode) {
-				console.log(
-					JSON.stringify({
-						error: 'No logs found',
-						logsDir: getLogsDirPath(),
-					})
-				);
-			} else {
-				tui.warning('No CLI logs found');
-				tui.info(`Logs directory: ${tui.muted(getLogsDirPath())}`);
-			}
-			return;
-		}
-
-		if (isJsonMode) {
-			console.log(JSON.stringify({ sessionDir }));
-		} else {
-			console.log(sessionDir);
-		}
-	},
-});