@agentuity/cli 2.0.11 → 3.0.0-alpha.1

package/src/cmd/build/adapters/types.ts

@@ -0,0 +1,93 @@
+/**
+ * Build adapter types.
+ *
+ * Adapters know how to build a specific framework and package the result.
+ * They receive a DetectedFramework and produce a BuildResult.
+ */
+
+import type { DetectedFramework, PackageJsonData } from '../detect/types';
+import type { Logger, DeployOptions } from '../../../types';
+import type { BuildReportCollector } from '../../../build-report';
+
+/**
+ * Result of a successful build.
+ */
+export interface BuildResult {
+	/** Absolute path to the build output directory */
+	outputDir: string;
+
+	/** The start command to run the application */
+	startCommand?: string;
+
+	/** Server entrypoint file (relative to outputDir) */
+	serverEntry?: string;
+
+	/** Static/CDN assets directory (absolute path), for CDN upload enumeration */
+	staticDir?: string;
+
+	/** Port the app listens on */
+	port?: number;
+
+	/** Build duration in milliseconds */
+	duration: number;
+
+	/** Human-readable build log lines */
+	logs: string[];
+}
+
+/**
+ * Options passed to a build adapter.
+ */
+export interface BuildAdapterOptions {
+	/** Absolute path to the project root */
+	projectDir: string;
+
+	/** Detected framework info */
+	framework: DetectedFramework;
+
+	/** Parsed package.json */
+	packageJson: PackageJsonData;
+
+	/** Absolute path to write build output */
+	outputDir: string;
+
+	/** Logger instance */
+	logger: Logger;
+
+	/** Build report collector for structured error reporting */
+	collector?: BuildReportCollector;
+
+	/** Development mode (less minification, inline sourcemaps) */
+	dev?: boolean;
+
+	/** Project ID (for Agentuity metadata) */
+	projectId?: string;
+
+	/** Org ID (for Agentuity metadata) */
+	orgId?: string;
+
+	/** Region (for Agentuity metadata) */
+	region?: string;
+
+	/** Deployment ID (for Agentuity metadata) */
+	deploymentId?: string;
+
+	/** Deployment options from CLI (git info, trigger, etc.) */
+	deploymentOptions?: DeployOptions;
+
+	/** Deployment config from agentuity.json (resources, mode, dependencies, domains) */
+	deploymentConfig?: Record<string, unknown>;
+}
+
+/**
+ * A build adapter that knows how to build a specific framework.
+ */
+export interface BuildAdapter {
+	/** Framework this adapter handles */
+	name: string;
+
+	/**
+	 * Run the build for this framework.
+	 */
+	build(options: BuildAdapterOptions): Promise<BuildResult>;
+}

package/src/cmd/build/detect/engine.ts

@@ -0,0 +1,111 @@
+/**
+ * Framework detection engine.
+ *
+ * Evaluates detector rules from the framework database against a real project
+ * directory. Handles three rule types:
+ * - matchPackage: check if package exists in dependencies/devDependencies
+ * - path: check if a file exists at the given path
+ * - path + matchContent: check if a file exists AND its content matches a regex
+ *
+ * The `every` array requires ALL rules to match.
+ * The `some` array requires at least ONE rule to match.
+ * If both are present, both conditions must be satisfied.
+ */
+
+import { join } from 'node:path';
+import type { DetectorRule, FrameworkDefinition } from './frameworks';
+import type { PackageJsonData } from './types';
+
+/**
+ * Check if a single detector rule matches the project.
+ */
+async function matchRule(
+	rule: DetectorRule,
+	projectDir: string,
+	pkg: PackageJsonData
+): Promise<boolean> {
+	// Package match: check dependencies and devDependencies
+	if (rule.matchPackage) {
+		const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+		return rule.matchPackage in allDeps;
+	}
+
+	// File path match (with optional content matching)
+	if (rule.path) {
+		const filePath = join(projectDir, rule.path);
+		const file = Bun.file(filePath);
+		if (!(await file.exists())) return false;
+
+		// If matchContent is specified, check file content against regex
+		if (rule.matchContent) {
+			try {
+				const content = await file.text();
+				return new RegExp(rule.matchContent).test(content);
+			} catch {
+				return false;
+			}
+		}
+
+		// File exists, no content check needed
+		return true;
+	}
+
+	return false;
+}
+
+/**
+ * Check if a framework definition matches the project.
+ */
+async function matchFramework(
+	fw: FrameworkDefinition,
+	projectDir: string,
+	pkg: PackageJsonData
+): Promise<boolean> {
+	const { detectors } = fw;
+	if (!detectors) return false;
+
+	// Check 'every' rules: ALL must match
+	if (detectors.every && detectors.every.length > 0) {
+		for (const rule of detectors.every) {
+			if (!(await matchRule(rule, projectDir, pkg))) {
+				return false;
+			}
+		}
+	}
+
+	// Check 'some' rules: at least ONE must match
+	if (detectors.some && detectors.some.length > 0) {
+		let anyMatch = false;
+		for (const rule of detectors.some) {
+			if (await matchRule(rule, projectDir, pkg)) {
+				anyMatch = true;
+				break;
+			}
+		}
+		if (!anyMatch) return false;
+	}
+
+	// If we have 'every' rules and they all matched (and 'some' either matched or wasn't present), pass
+	// If we only have 'some' rules and one matched, pass
+	return true;
+}
+
+/**
+ * Run detection against the framework database.
+ * Returns the first matching framework definition, or null.
+ *
+ * The framework list is evaluated in order — more specific frameworks
+ * should be listed before generic ones.
+ */
+export async function detectFromDatabase(
+	projectDir: string,
+	pkg: PackageJsonData,
+	frameworkList: FrameworkDefinition[]
+): Promise<FrameworkDefinition | null> {
+	for (const fw of frameworkList) {
+		if (await matchFramework(fw, projectDir, pkg)) {
+			return fw;
+		}
+	}
+	return null;
+}

package/src/cmd/build/detect/frameworks.ts

@@ -0,0 +1,335 @@
+/**
+ * Framework detection database.
+ *
+ * Package detection rules (which npm packages and config files identify each
+ * framework) were informed by the @vercel/frameworks package (Apache-2.0,
+ * Copyright 2017 Vercel Inc, github.com/vercel/vercel/tree/main/packages/frameworks).
+ *
+ * All Vercel-specific properties (logos, CDN URLs, runtime config, routing
+ * rules, deploy targets) have been stripped. Only generic framework facts
+ * remain: package names, config filenames, default build commands, and output
+ * directories as documented by each framework's own docs.
+ *
+ * Framework entries are ordered by specificity — more specific frameworks
+ * (e.g., SvelteKit) should be listed before generic ones (e.g., Vite).
+ */
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface DetectorRule {
+	/** Match a package in dependencies or devDependencies */
+	matchPackage?: string;
+	/** Match a file path (relative to project root) */
+	path?: string;
+	/** Regex pattern to match against file content (requires `path`) */
+	matchContent?: string;
+}
+
+export interface FrameworkDefinition {
+	/** Human-readable name */
+	name: string;
+	/** Unique slug identifier */
+	slug: string;
+	/** Default build command (null = no build step) */
+	buildCommand: string | null;
+	/** Default output directory for static assets */
+	outputDirectory: string | null;
+	/**
+	 * Static/CDN asset directory, relative to the project root.
+	 *
+	 * Points to the directory containing files suitable for CDN upload
+	 * (JS bundles, CSS, images, fonts, etc.) after the build runs.
+	 *
+	 * - `null` means the entire outputDirectory IS the static output
+	 *   (pure static-site generators, SPAs) — resolved to outputDirectory.
+	 * - A string path (e.g., `.next/static`, `.output/public`) is resolved
+	 *   relative to the project root, since some frameworks put static
+	 *   assets outside their main output directory.
+	 * - `undefined` (omitted) means no known static asset directory.
+	 */
+	staticDir?: string | null;
+	/** Environment variable prefix for browser-inlined values */
+	envPrefix?: string;
+	/**
+	 * Detection rules.
+	 * - `every`: ALL must match for the framework to be detected.
+	 * - `some`: at least ONE must match (in addition to all `every` rules).
+	 */
+	detectors: {
+		every?: DetectorRule[];
+		some?: DetectorRule[];
+	};
+}
+
+// ─── Framework Database ──────────────────────────────────────────────────────
+
+/**
+ * JS/TS framework definitions for detection.
+ *
+ * Order matters — first match wins. More specific frameworks come first,
+ * generic catch-alls (Vite, Parcel) come last.
+ */
+export const frameworkDefinitions: FrameworkDefinition[] = [
+	// ── Meta-frameworks (most specific, check first) ──
+
+	{
+		name: 'Next.js',
+		slug: 'nextjs',
+		buildCommand: 'next build',
+		outputDirectory: null, // Dynamic — reads from next.config
+		staticDir: '.next/static', // Relative to project root (adapter handles standalone copy)
+		envPrefix: 'NEXT_PUBLIC_',
+		detectors: {
+			every: [{ matchPackage: 'next' }],
+		},
+	},
+	{
+		name: 'Nuxt',
+		slug: 'nuxt',
+		buildCommand: 'nuxt build',
+		outputDirectory: 'dist',
+		staticDir: '.output/public', // Nitro output; static assets served from here
+		envPrefix: 'NUXT_ENV_',
+		detectors: {
+			some: [
+				{ matchPackage: 'nuxt' },
+				{ matchPackage: 'nuxt3' },
+				{ matchPackage: 'nuxt-edge' },
+				{ matchPackage: 'nuxt-nightly' },
+			],
+		},
+	},
+	{
+		name: 'Remix',
+		slug: 'remix',
+		buildCommand: 'remix build',
+		outputDirectory: 'public',
+		staticDir: 'public/build', // Built browser bundles
+		detectors: {
+			some: [
+				{ matchPackage: '@remix-run/dev' },
+				{ path: 'remix.config.js' },
+				{ path: 'remix.config.mjs' },
+			],
+		},
+	},
+	{
+		name: 'React Router',
+		slug: 'react-router',
+		buildCommand: 'react-router build',
+		outputDirectory: 'build',
+		staticDir: 'build/client', // Client-side assets
+		detectors: {
+			some: [
+				{ path: 'react-router.config.js' },
+				{ path: 'react-router.config.ts' },
+				{ path: 'vite.config.js', matchContent: '@react-router/dev/vite' },
+				{ path: 'vite.config.ts', matchContent: '@react-router/dev/vite' },
+			],
+		},
+	},
+	{
+		name: 'SvelteKit',
+		slug: 'sveltekit',
+		buildCommand: 'vite build',
+		outputDirectory: 'public',
+		staticDir: 'build/client', // adapter-node client assets
+		detectors: {
+			every: [
+				{
+					path: 'package.json',
+					matchContent: '"(dev)?(d|D)ependencies":\\s*{[^}]*"@sveltejs\\/kit":\\s*".+?"[^}]*}',
+				},
+			],
+		},
+	},
+	{
+		name: 'Astro',
+		slug: 'astro',
+		buildCommand: 'astro build',
+		outputDirectory: 'dist',
+		staticDir: null, // Entire dist/ is static (SSG default); dist/client/ for SSR
+		envPrefix: 'PUBLIC_',
+		detectors: {
+			every: [{ matchPackage: 'astro' }],
+		},
+	},
+	{
+		name: 'SolidStart',
+		slug: 'solidstart',
+		buildCommand: 'vinxi build',
+		outputDirectory: '.output',
+		staticDir: '.output/public', // Nitro-based static assets
+		envPrefix: 'VITE_',
+		detectors: {
+			every: [{ matchPackage: 'solid-js' }, { matchPackage: '@solidjs/start' }],
+		},
+	},
+	{
+		name: 'TanStack Start',
+		slug: 'tanstack-start',
+		buildCommand: 'vite build',
+		outputDirectory: 'dist',
+		staticDir: '.output/public', // Nitro-based; similar to Nuxt/SolidStart
+		detectors: {
+			every: [{ matchPackage: '@tanstack/router-plugin' }, { matchPackage: 'nitro' }],
+		},
+	},
+	{
+		name: 'RedwoodJS',
+		slug: 'redwoodjs',
+		buildCommand: 'yarn rw build',
+		outputDirectory: null, // Dynamic — depends on target
+		staticDir: 'web/dist', // Redwood web-side build output
+		envPrefix: 'REDWOOD_ENV_',
+		detectors: {
+			every: [{ matchPackage: '@redwoodjs/core' }],
+		},
+	},
+
+	// ── Static site generators ──
+
+	{
+		name: 'Gatsby.js',
+		slug: 'gatsby',
+		buildCommand: 'gatsby build',
+		outputDirectory: 'public',
+		staticDir: null, // Entire public/ is static output
+		envPrefix: 'GATSBY_',
+		detectors: {
+			every: [{ matchPackage: 'gatsby' }],
+		},
+	},
+	{
+		name: 'Eleventy',
+		slug: 'eleventy',
+		buildCommand: 'npx @11ty/eleventy',
+		outputDirectory: '_site',
+		staticDir: null, // Entire _site/ is static output
+		detectors: {
+			every: [{ matchPackage: '@11ty/eleventy' }],
+		},
+	},
+	{
+		name: 'VitePress',
+		slug: 'vitepress',
+		buildCommand: 'vitepress build docs',
+		outputDirectory: 'docs/.vitepress/dist',
+		staticDir: null, // Entire output is static
+		detectors: {
+			every: [{ matchPackage: 'vitepress' }],
+		},
+	},
+	{
+		name: 'VuePress',
+		slug: 'vuepress',
+		buildCommand: 'vuepress build src',
+		outputDirectory: 'src/.vuepress/dist',
+		staticDir: null, // Entire output is static
+		detectors: {
+			every: [{ matchPackage: 'vuepress' }],
+		},
+	},
+	{
+		name: 'Docusaurus',
+		slug: 'docusaurus',
+		buildCommand: 'docusaurus build',
+		outputDirectory: 'build',
+		staticDir: null, // Entire build/ is static output
+		detectors: {
+			some: [{ matchPackage: '@docusaurus/core' }],
+		},
+	},
+	{
+		name: 'Hexo',
+		slug: 'hexo',
+		buildCommand: 'hexo generate',
+		outputDirectory: 'public',
+		staticDir: null, // Entire public/ is static output
+		detectors: {
+			every: [{ matchPackage: 'hexo' }],
+		},
+	},
+
+	// ── UI frameworks (with CLI build) ──
+
+	{
+		name: 'Angular',
+		slug: 'angular',
+		buildCommand: 'ng build',
+		outputDirectory: 'dist',
+		staticDir: null, // Entire dist/ is static output (browser subfolder in v17+)
+		detectors: {
+			every: [{ matchPackage: '@angular/cli' }],
+		},
+	},
+	{
+		name: 'Vue.js',
+		slug: 'vue',
+		buildCommand: 'vue-cli-service build',
+		outputDirectory: 'dist',
+		staticDir: null, // Entire dist/ is static output
+		envPrefix: 'VUE_APP_',
+		detectors: {
+			every: [{ matchPackage: '@vue/cli-service' }],
+		},
+	},
+	{
+		name: 'Create React App',
+		slug: 'create-react-app',
+		buildCommand: 'react-scripts build',
+		outputDirectory: 'build',
+		staticDir: null, // Entire build/ is static output
+		envPrefix: 'REACT_APP_',
+		detectors: {
+			some: [{ matchPackage: 'react-scripts' }, { matchPackage: 'react-dev-utils' }],
+		},
+	},
+	{
+		name: 'Preact',
+		slug: 'preact',
+		buildCommand: 'preact build',
+		outputDirectory: 'build',
+		staticDir: null, // Entire build/ is static output
+		detectors: {
+			every: [{ matchPackage: 'preact-cli' }],
+		},
+	},
+
+	// ── Server frameworks (no default build step) ──
+
+	{
+		name: 'Nitro',
+		slug: 'nitro',
+		buildCommand: 'nitro build',
+		outputDirectory: 'dist',
+		staticDir: '.output/public', // Nitro static assets
+		detectors: {
+			some: [{ matchPackage: 'nitropack' }, { matchPackage: 'nitro' }],
+		},
+	},
+
+	// ── Generic bundlers (least specific, check last) ──
+
+	{
+		name: 'Vite',
+		slug: 'vite',
+		buildCommand: 'vite build',
+		outputDirectory: 'dist',
+		staticDir: null, // Entire dist/ is static output
+		envPrefix: 'VITE_',
+		detectors: {
+			every: [{ matchPackage: 'vite' }],
+		},
+	},
+	{
+		name: 'Parcel',
+		slug: 'parcel',
+		buildCommand: 'parcel build',
+		outputDirectory: 'dist',
+		staticDir: null, // Entire dist/ is static output
+		detectors: {
+			every: [{ matchPackage: 'parcel' }],
+		},
+	},
+];

package/src/cmd/build/detect/generic.ts

@@ -0,0 +1,71 @@
+/**
+ * Generic JS/TS project detector (fallback).
+ *
+ * This is the catch-all detector for projects that don't match any specific
+ * framework. It looks for:
+ * 1. A package.json with a "build" script
+ * 2. A "start" script or "main" field for the start command
+ *
+ * If neither is found, detection fails — we can't build what we don't understand.
+ */
+
+import { join } from 'node:path';
+import type { FrameworkDetector, DetectedFramework } from './types';
+import { detectPackageManager } from './util';
+
+export const genericDetector: FrameworkDetector = {
+	name: 'generic',
+	priority: 100, // Lowest priority — true fallback
+
+	async detect(projectDir, pkg): Promise<DetectedFramework | null> {
+		// Must have a package.json with something we can work with
+		if (!pkg.scripts?.build && !pkg.scripts?.start && !pkg.main) {
+			return null;
+		}
+
+		const pm = await detectPackageManager(projectDir);
+
+		// Determine build command
+		const buildCommand = pkg.scripts?.build ?? null;
+		if (!buildCommand) {
+			// No build script — might be a runtime-only project
+			// We'll still try if there's a start command
+		}
+
+		// Determine start command
+		let startCommand: string | undefined;
+		let serverEntry: string | undefined;
+
+		if (pkg.scripts?.start) {
+			startCommand = pkg.scripts.start;
+		} else if (pkg.main) {
+			// Check if main entry exists
+			const mainFile = Bun.file(join(projectDir, pkg.main));
+			if (await mainFile.exists()) {
+				const runtime = pm === 'bun' ? 'bun' : 'node';
+				startCommand = `${runtime} ${pkg.main}`;
+				serverEntry = pkg.main;
+			}
+		}
+
+		// If no build and no start, we can't do anything
+		if (!buildCommand && !startCommand) {
+			return null;
+		}
+
+		// Detect runtime from engines field or package manager
+		const runtime = pkg.engines?.bun ? 'bun' : pm === 'bun' ? 'bun' : 'node';
+
+		return {
+			name: 'generic',
+			runtime,
+			packageManager: pm,
+			buildCommand: buildCommand ?? 'echo "No build step"',
+			buildOutput: '.', // Generic — build output could be anywhere
+			startCommand,
+			serverEntry,
+			port: 3000,
+			confidence: 'low',
+		};
+	},
+};