@agentuity/cli 0.0.100 → 0.0.102

package/src/cmd/build/vite/metadata-generator.ts

@@ -25,6 +25,7 @@ interface AssetInfo {
 	kind: string;
 	contentType: string;
 	size: number;
+	contentEncoding?: string;
 }
 
 function getContentType(filename: string): string {
@@ -65,6 +66,59 @@ function getContentType(filename: string): string {
 	}
 }
 
+/**
+ * Determine if an asset should be compressed with gzip.
+ * The result is included in asset metadata so the API can generate
+ * presigned URLs with matching Content-Encoding.
+ */
+function shouldCompressAsset(asset: {
+	filename: string;
+	contentType: string;
+	kind: string;
+}): boolean {
+	const ct = asset.contentType.toLowerCase();
+	const filename = asset.filename.toLowerCase();
+
+	if (ct.startsWith('image/') && ct !== 'image/svg+xml') {
+		return false;
+	}
+	if (ct.startsWith('video/') || ct.startsWith('audio/')) {
+		return false;
+	}
+	if (ct === 'font/woff' || ct === 'font/woff2') {
+		return false;
+	}
+	if (/\.(zip|gz|tgz|tar|bz2|br)$/.test(filename)) {
+		return false;
+	}
+
+	if (
+		ct.startsWith('text/') ||
+		ct === 'application/javascript' ||
+		ct === 'application/json' ||
+		ct === 'application/xml' ||
+		ct === 'application/xhtml+xml' ||
+		ct === 'image/svg+xml'
+	) {
+		return true;
+	}
+
+	if (ct === 'font/ttf' || ct === 'application/vnd.ms-fontobject') {
+		return true;
+	}
+
+	if (
+		asset.kind === 'entry-point' ||
+		asset.kind === 'script' ||
+		asset.kind === 'stylesheet' ||
+		asset.kind === 'sourcemap'
+	) {
+		return true;
+	}
+
+	return false;
+}
+
 function getAssetKind(filename: string, isEntry: boolean = false): string {
 	const ext = filename.split('.').pop()?.toLowerCase();
 
@@ -220,12 +274,18 @@ export async function generateMetadata(options: MetadataGeneratorOptions): Promi
 			}
 
 			seenAssets.add(assetPath);
-			assets.push({
+			const kind = getAssetKind(relativePath, isEntry);
+			const contentType = getContentType(relativePath);
+			const assetInfo: AssetInfo = {
 				filename: assetPath,
-				kind: getAssetKind(relativePath, isEntry),
-				contentType: getContentType(relativePath),
+				kind,
+				contentType,
 				size: stats.size,
-			});
+			};
+			if (shouldCompressAsset(assetInfo)) {
+				assetInfo.contentEncoding = 'gzip';
+			}
+			assets.push(assetInfo);
 		}
 	};
 
@@ -328,12 +388,17 @@ export async function generateMetadata(options: MetadataGeneratorOptions): Promi
 						const assetPath = `public/${relativePath}`;
 						if (!seenAssets.has(assetPath)) {
 							seenAssets.add(assetPath);
-							assets.push({
+							const contentType = getContentType(entry.name);
+							const assetInfo: AssetInfo = {
 								filename: assetPath,
 								kind: 'static',
-								contentType: getContentType(entry.name),
+								contentType,
 								size: stats.size,
-							});
+							};
+							if (shouldCompressAsset(assetInfo)) {
+								assetInfo.contentEncoding = 'gzip';
+							}
+							assets.push(assetInfo);
 						}
 					}
 				}
@@ -548,6 +613,176 @@ async function getGitInfo(
 	}
 }
 
+/**
+ * Generate AGENTS.md content for AI coding agents
+ */
+function generateAgentsMd(metadata: BuildMetadata): string {
+	const lines: string[] = [];
+
+	lines.push('# Compiled Agentuity Application');
+	lines.push('');
+	lines.push(
+		'This directory contains compiled and bundled source code from an Agentuity application.'
+	);
+	lines.push('');
+
+	// Add source repository info if available
+	if (metadata.deployment?.git?.repo) {
+		lines.push('## Source Repository');
+		lines.push('');
+		lines.push(`**Repository:** ${metadata.deployment.git.repo}`);
+
+		if (metadata.deployment.git.branch) {
+			lines.push(`**Branch:** ${metadata.deployment.git.branch}`);
+		}
+
+		if (metadata.deployment.git.commit) {
+			const shortCommit = metadata.deployment.git.commit.substring(0, 7);
+			const commitUrl = metadata.deployment.git.repo.endsWith('.git')
+				? metadata.deployment.git.repo.slice(0, -4)
+				: metadata.deployment.git.repo;
+			lines.push(
+				`**Commit:** [\`${shortCommit}\`](${commitUrl}/commit/${metadata.deployment.git.commit})`
+			);
+		}
+
+		if (metadata.deployment.git.message) {
+			lines.push(`**Message:** ${metadata.deployment.git.message}`);
+		}
+
+		lines.push('');
+	}
+
+	// Add build info
+	lines.push('## Build Information');
+	lines.push('');
+	if (metadata.project?.name) {
+		lines.push(
+			`**Project:** ${metadata.project.name}${metadata.project.version ? ` v${metadata.project.version}` : ''}`
+		);
+	}
+	if (metadata.project?.id) {
+		lines.push(`**Project ID:** ${metadata.project.id}`);
+	}
+	if (metadata.project?.orgId) {
+		lines.push(`**Org ID:** ${metadata.project.orgId}`);
+	}
+	if (metadata.deployment.id) {
+		lines.push(`**Deployment ID:** ${metadata.deployment.id}`);
+	}
+	if (metadata.deployment?.build) {
+		lines.push(
+			`**Built with:** Agentuity CLI v${metadata.deployment.build.agentuity}, Bun v${metadata.deployment.build.bun}`
+		);
+		lines.push(
+			`**Platform:** ${metadata.deployment.build.platform}-${metadata.deployment.build.arch}`
+		);
+	}
+	if (metadata.deployment?.date) {
+		lines.push(`**Build date:** ${metadata.deployment.date}`);
+	}
+	lines.push('');
+
+	// Add structure overview
+	lines.push('## Structure');
+	lines.push('');
+	lines.push('```');
+	lines.push('.agentuity/');
+	lines.push('├── app.js                     # Bundled server application');
+	lines.push('├── agentuity.metadata.json    # Build metadata and schemas');
+	if (metadata.assets?.some((a) => a.filename.startsWith('client/'))) {
+		lines.push('├── client/                # Frontend assets (fallback, CDN by default)');
+	}
+	if (metadata.assets?.some((a) => a.filename.startsWith('public/'))) {
+		lines.push('├── public/                # Static assets');
+	}
+	lines.push('└── AGENTS.md                  # This file');
+	lines.push('```');
+	lines.push('');
+
+	// Add agent/route details
+	if (metadata.agents && metadata.agents.length > 0) {
+		lines.push('## Agents');
+		lines.push('');
+		lines.push(`This application defines ${metadata.agents.length} agent(s):`);
+		lines.push('');
+		for (const agent of metadata.agents) {
+			lines.push(`- **${agent.name}** (ID: \`${agent.id}\`)`);
+		}
+		lines.push('');
+	}
+
+	if (metadata.routes && metadata.routes.length > 0) {
+		lines.push('## Routes');
+		lines.push('');
+		lines.push(`This application defines ${metadata.routes.length} route(s):`);
+		lines.push('');
+		for (const route of metadata.routes) {
+			lines.push(`- \`${route.method.toUpperCase()} ${route.path}\` (${route.type})`);
+		}
+		lines.push('');
+	}
+
+	// Add runtime environment info
+	lines.push('## Runtime Environment');
+	lines.push('');
+	lines.push('When deployed, this application runs in a managed runtime environment with:');
+	lines.push('');
+	lines.push('**User & Permissions:**');
+	lines.push('- User: `agentuity` (UID: 1022, GID: 1777)');
+	lines.push('- Home directory: `/home/agentuity`');
+	lines.push('- Working directory: `/home/agentuity/app` (application code deployed here)');
+	lines.push('- Logs directory: `/home/agentuity/logs`');
+	lines.push('- Temp directory: `/home/agentuity/tmp`');
+	lines.push('');
+	lines.push('**Pre-installed Tools:**');
+	lines.push('- **Runtimes:** Node.js 24, Bun 1.x');
+	lines.push('- **AI Tools:** Amp, Opencode AI, Claude Code');
+	lines.push('- **Version Control:** git, GitHub CLI (gh)');
+	lines.push('- **Browser Automation:** Chromium, ChromeDriver, Xvfb (headless display)');
+	lines.push('- **Media Processing:** ffmpeg');
+	lines.push('- **Network Tools:** curl, wget, netcat, dnsutils');
+	lines.push('- **Other:** openssh-client, openssh-sftp-server, strace, unzip, fuse');
+	lines.push('');
+	lines.push('**Environment Variables:**');
+	lines.push('- `AGENTUITY_DATA_DIR=/home/agentuity/data` - Persistent data storage');
+	lines.push('- `AGENTUITY_LOG_DIR=/home/agentuity/logs` - Application logs');
+	lines.push('- `CHROME_BIN=/usr/bin/chromium` - Chromium browser path');
+	lines.push('- `DISPLAY=:99` - X11 display for headless browser');
+	lines.push(
+		'- `PATH` includes `/home/agentuity/.local/bin` and `/home/agentuity/.agentuity/bin`'
+	);
+	lines.push('');
+	lines.push('**Ports:**');
+	lines.push(
+		'- `3000: This default port that the project is running. Use PORT environment if not available'
+	);
+	lines.push('');
+
+	// Add note about metadata
+	lines.push('## For AI Coding Agents');
+	lines.push('');
+	lines.push(
+		'This is production-ready compiled code. For development and source code modifications:'
+	);
+	lines.push('');
+	if (metadata.deployment?.git?.repo) {
+		lines.push(`1. Clone the source repository: ${metadata.deployment.git.repo}`);
+		lines.push('2. Make changes to source files in `src/`');
+		lines.push('3. Run `agentuity build` to rebuild this bundle');
+	} else {
+		lines.push('1. Locate the original source repository');
+		lines.push('2. Make changes to source files in `src/`');
+		lines.push('3. Run `agentuity build` to rebuild this bundle');
+	}
+	lines.push('');
+	lines.push(
+		'See `agentuity.metadata.json` for detailed information about agents, routes, and schemas.'
+	);
+
+	return lines.join('\n');
+}
+
 /**
  * Write agentuity.metadata.json to .agentuity directory
  */
@@ -569,6 +804,15 @@ export function writeMetadataFile(
 
 	writeFileSync(metadataPath, metadataContent, 'utf-8');
 	logger.trace('Wrote agentuity.metadata.json');
+
+	// Write AGENTS.md for AI coding agents
+	if (!dev) {
+		const agentMdPath = join(agentuityDir, 'AGENTS.md');
+		const agentMdContent = generateAgentsMd(metadata);
+
+		writeFileSync(agentMdPath, agentMdContent, 'utf-8');
+		logger.trace('Wrote AGENTS.md');
+	}
 }
 
 /**

package/src/cmd/build/vite/prompt-generator.ts

@@ -0,0 +1,169 @@
+/**
+ * Prompt Generator
+ *
+ * Generates AGENTS.md prompt files in .agents/agentuity/sdk/[type]/ directories.
+ * Also creates reference files in src/[type]/AGENTS.md (write-once, only if missing).
+ *
+ * Uses hash tracking to detect template changes in .agents/ folder.
+ * Reference files in src/ are never overwritten once created.
+ *
+ * Only runs in dev mode.
+ */
+
+import { join, dirname } from 'node:path';
+import { mkdir } from 'node:fs/promises';
+import type { Logger } from '../../../types';
+import { needsUpdate } from '../../ai/prompt/version';
+import {
+	generateLLMPrompt as generateAgentPrompt,
+	getPromptContent as getAgentContent,
+} from '../../ai/prompt/agent';
+import {
+	generateLLMPrompt as generateApiPrompt,
+	getPromptContent as getApiContent,
+} from '../../ai/prompt/api';
+import {
+	generateLLMPrompt as generateWebPrompt,
+	getPromptContent as getWebContent,
+} from '../../ai/prompt/web';
+
+interface PromptConfig {
+	name: string;
+	srcFolder: string;
+	generate: () => string;
+	getContent: () => string;
+}
+
+const PROMPTS: PromptConfig[] = [
+	{
+		name: 'agent',
+		srcFolder: 'agent',
+		generate: generateAgentPrompt,
+		getContent: getAgentContent,
+	},
+	{
+		name: 'api',
+		srcFolder: 'api',
+		generate: generateApiPrompt,
+		getContent: getApiContent,
+	},
+	{
+		name: 'web',
+		srcFolder: 'web',
+		generate: generateWebPrompt,
+		getContent: getWebContent,
+	},
+];
+
+/**
+ * Generate the reference file content that points to .agents/
+ */
+function generateReferenceContent(name: string): string {
+	return `See [.agents/agentuity/sdk/${name}/AGENTS.md](../../.agents/agentuity/sdk/${name}/AGENTS.md) for Agentuity ${name} development guidelines.
+`;
+}
+
+/**
+ * Generate or update prompt files.
+ *
+ * - .agents/agentuity/sdk/[type]/AGENTS.md: Full content, updated when hash differs
+ * - src/[type]/AGENTS.md: Reference file, only created if missing
+ *
+ * @param srcDir - The src/ directory path
+ * @param logger - Logger for output
+ */
+export async function generatePromptFiles(srcDir: string, logger: Logger): Promise<void> {
+	const projectRoot = dirname(srcDir);
+
+	for (const prompt of PROMPTS) {
+		await generatePromptFile(projectRoot, srcDir, prompt, logger);
+	}
+}
+
+async function generatePromptFile(
+	projectRoot: string,
+	srcDir: string,
+	config: PromptConfig,
+	logger: Logger
+): Promise<void> {
+	const srcFolderPath = join(srcDir, config.srcFolder);
+
+	// Check if the src folder exists (e.g., src/agent/)
+	try {
+		const stat = await Bun.$`test -d ${srcFolderPath}`.nothrow();
+		if (stat.exitCode !== 0) {
+			logger.trace(`Skipping ${config.name} prompt - src/${config.srcFolder}/ does not exist`);
+			return;
+		}
+	} catch {
+		logger.trace(`Skipping ${config.name} prompt - src/${config.srcFolder}/ does not exist`);
+		return;
+	}
+
+	// Generate files
+	await generateAgentsFile(projectRoot, config, logger);
+	await generateReferenceFile(srcFolderPath, config, logger);
+}
+
+/**
+ * Generate/update the .agents/agentuity/sdk/[type]/AGENTS.md file.
+ * Overwrites if hash differs from source template.
+ */
+async function generateAgentsFile(
+	projectRoot: string,
+	config: PromptConfig,
+	logger: Logger
+): Promise<void> {
+	const agentsDir = join(projectRoot, '.agents', 'agentuity', 'sdk', config.name);
+	const filePath = join(agentsDir, 'AGENTS.md');
+
+	const file = Bun.file(filePath);
+	const fileExists = await file.exists();
+
+	if (!fileExists) {
+		// File doesn't exist - create it
+		await mkdir(agentsDir, { recursive: true });
+		const content = config.generate();
+		await Bun.write(filePath, content);
+		logger.debug(`Generated .agents/agentuity/sdk/${config.name}/AGENTS.md`);
+		return;
+	}
+
+	// File exists - check if it needs to be updated
+	const existingContent = await file.text();
+	const sourceContent = config.getContent();
+
+	if (needsUpdate(existingContent, sourceContent)) {
+		const content = config.generate();
+		await Bun.write(filePath, content);
+		logger.debug(`Updated .agents/agentuity/sdk/${config.name}/AGENTS.md`);
+		return;
+	}
+
+	logger.trace(`Skipping ${config.name} prompt - already up to date`);
+}
+
+/**
+ * Generate the src/[type]/AGENTS.md reference file.
+ * Only creates if missing (write-once).
+ */
+async function generateReferenceFile(
+	srcFolderPath: string,
+	config: PromptConfig,
+	logger: Logger
+): Promise<void> {
+	const filePath = join(srcFolderPath, 'AGENTS.md');
+
+	const file = Bun.file(filePath);
+	const fileExists = await file.exists();
+
+	if (fileExists) {
+		logger.trace(`Skipping src/${config.srcFolder}/AGENTS.md - already exists`);
+		return;
+	}
+
+	// Create the reference file
+	const content = generateReferenceContent(config.name);
+	await Bun.write(filePath, content);
+	logger.debug(`Generated src/${config.srcFolder}/AGENTS.md (reference)`);
+}