@better-openclaw/core 1.0.0

package/src/services/registry.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, it } from "vitest";
+import {
+	getAllServices,
+	getServiceById,
+	getServicesByCategory,
+	getServicesByTag,
+} from "../services/registry.js";
+
+describe("service registry", () => {
+	it("has at least 60 services registered", () => {
+		const services = getAllServices();
+		expect(services.length).toBeGreaterThanOrEqual(60);
+	});
+
+	it("finds redis by ID", () => {
+		const redis = getServiceById("redis");
+		expect(redis).toBeDefined();
+		expect(redis!.id).toBe("redis");
+		expect(redis!.name).toBe("Redis");
+	});
+
+	it("returns undefined for unknown ID", () => {
+		const result = getServiceById("nonexistent");
+		expect(result).toBeUndefined();
+	});
+
+	it("finds tailscale and it is mandatory", () => {
+		const tailscale = getServiceById("tailscale");
+		expect(tailscale).toBeDefined();
+		expect(tailscale!.id).toBe("tailscale");
+		expect(tailscale!.mandatory).toBe(true);
+	});
+
+	it("finds coolify, dokploy, livekit, and La Suite Meet services by ID", () => {
+		expect(getServiceById("coolify")).toBeDefined();
+		expect(getServiceById("dokploy")).toBeDefined();
+		expect(getServiceById("livekit")).toBeDefined();
+		expect(getServiceById("lasuite-meet-backend")).toBeDefined();
+		expect(getServiceById("lasuite-meet-frontend")).toBeDefined();
+		expect(getServiceById("lasuite-meet-agents")).toBeDefined();
+	});
+
+	it("filters by category", () => {
+		const databases = getServicesByCategory("database");
+		const ids = databases.map((s) => s.id);
+		expect(ids).toContain("redis");
+		expect(databases.length).toBeGreaterThanOrEqual(1);
+	});
+
+	it("filters by tag", () => {
+		const cacheServices = getServicesByTag("cache");
+		const ids = cacheServices.map((s) => s.id);
+		expect(ids).toContain("redis");
+		expect(cacheServices.length).toBeGreaterThanOrEqual(1);
+	});
+
+	it("all service IDs are unique", () => {
+		const services = getAllServices();
+		const ids = services.map((s) => s.id);
+		const uniqueIds = new Set(ids);
+		expect(uniqueIds.size).toBe(ids.length);
+	});
+
+	it("no two services have the same exposed host port", () => {
+		const services = getAllServices();
+		const portMap = new Map<number, string[]>();
+
+		for (const svc of services) {
+			for (const port of svc.ports) {
+				if (!port.exposed) continue;
+				const existing = portMap.get(port.host) ?? [];
+				existing.push(svc.id);
+				portMap.set(port.host, existing);
+			}
+		}
+
+		// Informational: log any shared ports but don't hard-fail,
+		// since users may not enable all services simultaneously.
+		const conflicts: string[] = [];
+		for (const [port, serviceIds] of portMap) {
+			if (serviceIds.length > 1) {
+				conflicts.push(`Port ${port} shared by: ${serviceIds.join(", ")}`);
+			}
+		}
+
+		// This is informational — warn if there are conflicts but still pass.
+		// If you want to enforce unique ports, change the next line to:
+		//   expect(conflicts).toHaveLength(0);
+		if (conflicts.length > 0) {
+			console.warn(
+				`[informational] ${conflicts.length} port overlap(s) detected:\n  ${conflicts.join("\n  ")}`,
+			);
+		}
+
+		// At minimum, verify we checked something
+		expect(portMap.size).toBeGreaterThan(0);
+	});
+});

package/src/services/registry.ts

@@ -0,0 +1,37 @@
+import type { ServiceCategory, ServiceDefinition } from "../types.js";
+import { allServiceDefinitions } from "./definitions/index.js";
+
+// Build the registry map and validate no duplicates
+const registryMap = new Map<string, ServiceDefinition>();
+
+for (const def of allServiceDefinitions) {
+	if (registryMap.has(def.id)) {
+		throw new Error(
+			`Duplicate service definition ID: "${def.id}". Each service must have a unique ID.`,
+		);
+	}
+	registryMap.set(def.id, def);
+}
+
+/** Readonly map of all registered services indexed by ID */
+export const serviceRegistry: ReadonlyMap<string, ServiceDefinition> = registryMap;
+
+/** Look up a service by its unique ID */
+export function getServiceById(id: string): ServiceDefinition | undefined {
+	return registryMap.get(id);
+}
+
+/** Get all services in a given category */
+export function getServicesByCategory(category: ServiceCategory): ServiceDefinition[] {
+	return allServiceDefinitions.filter((s) => s.category === category);
+}
+
+/** Get all registered services */
+export function getAllServices(): ServiceDefinition[] {
+	return [...allServiceDefinitions];
+}
+
+/** Get services matching a specific tag */
+export function getServicesByTag(tag: string): ServiceDefinition[] {
+	return allServiceDefinitions.filter((s) => s.tags.includes(tag));
+}

package/src/skills/registry.ts

@@ -0,0 +1,126 @@
+import type { SkillPack } from "../types.js";
+
+const skillPacks: SkillPack[] = [
+	{
+		id: "video-creator",
+		name: "Video Creator",
+		description:
+			"Create and process videos programmatically with FFmpeg, Remotion, and MinIO storage",
+		requiredServices: ["ffmpeg", "remotion", "minio"],
+		skills: ["ffmpeg-process", "remotion-render", "minio-storage"],
+		icon: "🎬",
+		tags: ["video", "media", "rendering"],
+	},
+	{
+		id: "research-agent",
+		name: "Research Agent",
+		description: "Research the web, store findings in vector memory, and scrape full pages",
+		requiredServices: ["qdrant", "searxng", "browserless"],
+		skills: ["qdrant-memory", "searxng-search", "browserless-browse"],
+		icon: "🔬",
+		tags: ["research", "rag", "web-scraping"],
+	},
+	{
+		id: "social-media",
+		name: "Social Media",
+		description:
+			"Process and manage social media content with video tools, caching, and asset storage",
+		requiredServices: ["ffmpeg", "redis", "minio"],
+		skills: ["ffmpeg-process", "redis-cache", "minio-storage"],
+		icon: "📱",
+		tags: ["social", "content", "scheduling"],
+	},
+	{
+		id: "dev-ops",
+		name: "DevOps",
+		description: "Monitor services, automate workflows, and manage infrastructure alerts",
+		requiredServices: ["n8n", "redis", "uptime-kuma", "grafana", "prometheus"],
+		skills: ["n8n-trigger", "redis-cache"],
+		icon: "⚙️",
+		tags: ["devops", "monitoring", "automation"],
+	},
+	{
+		id: "knowledge-base",
+		name: "Knowledge Base",
+		description:
+			"Index documents with vector search and full-text search for comprehensive retrieval",
+		requiredServices: ["qdrant", "postgresql", "meilisearch"],
+		skills: ["qdrant-memory"],
+		icon: "📚",
+		tags: ["knowledge", "search", "indexing"],
+	},
+	{
+		id: "local-ai",
+		name: "Local AI",
+		description: "Run local LLM inference and speech-to-text transcription without external APIs",
+		requiredServices: ["ollama", "whisper"],
+		skills: ["ollama-local-llm", "whisper-transcribe"],
+		icon: "🤖",
+		tags: ["local-llm", "transcription", "offline"],
+	},
+	{
+		id: "content-creator",
+		name: "Content Creator",
+		description:
+			"Full social media content pipeline with scheduling, media processing, analytics, and storage",
+		requiredServices: ["postiz", "ffmpeg", "minio", "redis", "postgresql"],
+		skills: ["ffmpeg-process", "minio-storage", "redis-cache"],
+		icon: "📱",
+		tags: ["social-media", "content", "scheduling", "analytics"],
+	},
+	{
+		id: "ai-playground",
+		name: "AI Playground",
+		description:
+			"Full AI experimentation stack with chat UIs, LLM gateway, local models, and document chat",
+		requiredServices: ["ollama", "open-webui", "litellm"],
+		skills: ["ollama-local-llm"],
+		icon: "🧪",
+		tags: ["ai", "llm", "playground", "experimentation"],
+	},
+	{
+		id: "coding-team",
+		name: "Coding Team",
+		description:
+			"AI-powered development environment with coding agents, Git hosting, and browser IDE",
+		requiredServices: ["claude-code", "gitea", "code-server"],
+		skills: [],
+		icon: "💻",
+		tags: ["coding", "development", "ide", "git"],
+	},
+	{
+		id: "knowledge-hub",
+		name: "Knowledge Hub",
+		description:
+			"Enterprise knowledge management with wiki, document processing, analytics, and vector search",
+		requiredServices: ["outline", "paperless-ngx", "qdrant", "postgresql", "redis"],
+		skills: ["qdrant-memory"],
+		icon: "📚",
+		tags: ["knowledge", "wiki", "documents", "search"],
+	},
+];
+
+const packMap = new Map<string, SkillPack>();
+for (const pack of skillPacks) {
+	if (packMap.has(pack.id)) {
+		throw new Error(`Duplicate skill pack ID: "${pack.id}"`);
+	}
+	packMap.set(pack.id, pack);
+}
+
+export const skillPackRegistry: ReadonlyMap<string, SkillPack> = packMap;
+
+export function getSkillPackById(id: string): SkillPack | undefined {
+	return packMap.get(id);
+}
+
+export function getAllSkillPacks(): SkillPack[] {
+	return [...skillPacks];
+}
+
+/** Get skill packs whose required services are all present in the given service list */
+export function getCompatibleSkillPacks(availableServiceIds: string[]): SkillPack[] {
+	return skillPacks.filter((pack) =>
+		pack.requiredServices.every((req) => availableServiceIds.includes(req)),
+	);
+}

package/src/types.ts

@@ -0,0 +1,123 @@
+import type { z } from "zod";
+import type {
+	AddedDependencySchema,
+	ApiErrorSchema,
+	ComposeOptionsSchema,
+	DeploymentTargetSchema,
+	DeploymentTypeSchema,
+	DeploySchema,
+	EnvVariableSchema,
+	ErrorSchema,
+	GenerationInputSchema,
+	HealthCheckSchema,
+	MaturitySchema,
+	NativePlatformSchema,
+	NativeRecipeSchema,
+	OutputFormatSchema,
+	PlatformSchema,
+	PortMappingSchema,
+	PresetSchema,
+	ProxyTypeSchema,
+	ResolvedServiceSchema,
+	ResolverOutputSchema,
+	ResourceLimitsSchema,
+	RestartPolicySchema,
+	ServiceCategorySchema,
+	ServiceDefinitionSchema,
+	SkillBindingSchema,
+	SkillPackSchema,
+	ValidateRequestSchema,
+	ValidateResponseSchema,
+	VolumeMappingSchema,
+	WarningSchema,
+} from "./schema.js";
+
+// ─── Inferred Types ─────────────────────────────────────────────────────────
+
+export type ServiceCategory = z.infer<typeof ServiceCategorySchema>;
+export type Maturity = z.infer<typeof MaturitySchema>;
+export type Platform = z.infer<typeof PlatformSchema>;
+export type RestartPolicy = z.infer<typeof RestartPolicySchema>;
+export type ProxyType = z.infer<typeof ProxyTypeSchema>;
+export type DeploymentTarget = z.infer<typeof DeploymentTargetSchema>;
+export type DeploymentType = z.infer<typeof DeploymentTypeSchema>;
+export type NativePlatform = z.infer<typeof NativePlatformSchema>;
+export type NativeRecipe = z.infer<typeof NativeRecipeSchema>;
+export type OutputFormat = z.infer<typeof OutputFormatSchema>;
+
+export type PortMapping = z.infer<typeof PortMappingSchema>;
+export type VolumeMapping = z.infer<typeof VolumeMappingSchema>;
+export type EnvVariable = z.infer<typeof EnvVariableSchema>;
+export type HealthCheck = z.infer<typeof HealthCheckSchema>;
+export type ResourceLimits = z.infer<typeof ResourceLimitsSchema>;
+export type Deploy = z.infer<typeof DeploySchema>;
+export type SkillBinding = z.infer<typeof SkillBindingSchema>;
+
+export type ServiceDefinition = z.infer<typeof ServiceDefinitionSchema>;
+export type SkillPack = z.infer<typeof SkillPackSchema>;
+export type Preset = z.infer<typeof PresetSchema>;
+
+export type GenerationInput = z.infer<typeof GenerationInputSchema>;
+export type ComposeOptions = z.infer<typeof ComposeOptionsSchema>;
+export type ResolvedService = z.infer<typeof ResolvedServiceSchema>;
+export type AddedDependency = z.infer<typeof AddedDependencySchema>;
+export type Warning = z.infer<typeof WarningSchema>;
+export type ResolverError = z.infer<typeof ErrorSchema>;
+export type ResolverOutput = z.infer<typeof ResolverOutputSchema>;
+
+export type ValidateRequest = z.infer<typeof ValidateRequestSchema>;
+export type ValidateResponse = z.infer<typeof ValidateResponseSchema>;
+export type ApiError = z.infer<typeof ApiErrorSchema>;
+
+// ─── Additional Types ───────────────────────────────────────────────────────
+
+export interface ResolverInput {
+	services: string[];
+	skillPacks: string[];
+	proxy?: ProxyType;
+	gpu?: boolean;
+	platform?: Platform;
+	monitoring?: boolean;
+}
+
+export interface GeneratedFiles {
+	[path: string]: string;
+}
+
+export interface GenerationMetadata {
+	serviceCount: number;
+	skillCount: number;
+	estimatedMemoryMB: number;
+	generatedAt: string;
+}
+
+export interface GenerationResult {
+	files: GeneratedFiles;
+	metadata: GenerationMetadata;
+}
+
+export interface CategoryInfo {
+	id: ServiceCategory;
+	name: string;
+	icon: string;
+}
+
+export const SERVICE_CATEGORIES: CategoryInfo[] = [
+	{ id: "coding-agent", name: "AI Coding Agents", icon: "💻" },
+	{ id: "ai-platform", name: "AI Platforms & Chat UIs", icon: "🧪" },
+	{ id: "ai", name: "AI / Local Models", icon: "🤖" },
+	{ id: "automation", name: "Automation & Workflows", icon: "🔄" },
+	{ id: "vector-db", name: "Vector Databases", icon: "🧠" },
+	{ id: "media", name: "Media & Video", icon: "🎬" },
+	{ id: "social-media", name: "Social Media", icon: "📱" },
+	{ id: "analytics", name: "Analytics", icon: "📊" },
+	{ id: "knowledge", name: "Knowledge & Documents", icon: "📚" },
+	{ id: "storage", name: "Object Storage", icon: "💾" },
+	{ id: "database", name: "Databases & Caching", icon: "🗄️" },
+	{ id: "dev-tools", name: "Developer Tools", icon: "🛠️" },
+	{ id: "proxy", name: "Reverse Proxy", icon: "🌐" },
+	{ id: "monitoring", name: "Monitoring", icon: "📡" },
+	{ id: "browser", name: "Browser Automation", icon: "🌐" },
+	{ id: "search", name: "Search", icon: "🔍" },
+	{ id: "communication", name: "Notifications", icon: "🔔" },
+];

package/src/validator.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import { compose } from "./composer.js";
+import { resolve } from "./resolver.js";
+import type { ComposeOptions } from "./types.js";
+import { validate } from "./validator.js";
+
+const defaultComposeOptions: ComposeOptions = {
+	projectName: "test-project",
+	proxy: "none",
+	gpu: false,
+	platform: "linux/amd64",
+	deployment: "local",
+	openclawVersion: "latest",
+};
+
+describe("validate", () => {
+	it("validates a valid minimal stack", () => {
+		const resolved = resolve({ services: ["redis"], skillPacks: [] });
+		const yaml = compose(resolved, defaultComposeOptions);
+		const result = validate(resolved, yaml);
+
+		expect(result.valid).toBe(true);
+		expect(result.errors).toHaveLength(0);
+	});
+
+	it("detects invalid YAML", () => {
+		const resolved = resolve({ services: ["redis"], skillPacks: [] });
+		const brokenYaml =
+			"services:\n  redis:\n    image: redis\n  bad_indent:\n- broken\n::: invalid";
+
+		const result = validate(resolved, brokenYaml);
+
+		const yamlErrors = result.errors.filter((e) => e.type === "yaml_invalid");
+		expect(yamlErrors.length).toBeGreaterThanOrEqual(1);
+	});
+
+	it("detects invalid domain", () => {
+		const resolved = resolve({ services: ["redis"], skillPacks: [] });
+		const yaml = compose(resolved, defaultComposeOptions);
+		const result = validate(resolved, yaml, { domain: "not-a-domain" });
+
+		const domainErrors = result.errors.filter((e) => e.type === "invalid_domain");
+		expect(domainErrors.length).toBeGreaterThanOrEqual(1);
+	});
+
+	it("accepts valid domain", () => {
+		const resolved = resolve({ services: ["redis"], skillPacks: [] });
+		const yaml = compose(resolved, defaultComposeOptions);
+		const result = validate(resolved, yaml, { domain: "example.com" });
+
+		const domainErrors = result.errors.filter((e) => e.type === "invalid_domain");
+		expect(domainErrors).toHaveLength(0);
+	});
+
+	it("validates full stack without errors", () => {
+		const resolved = resolve({
+			services: ["redis", "qdrant", "n8n", "minio", "browserless", "searxng"],
+			skillPacks: [],
+		});
+		const yaml = compose(resolved, defaultComposeOptions);
+		const result = validate(resolved, yaml);
+
+		expect(result.valid).toBe(true);
+		expect(result.errors).toHaveLength(0);
+	});
+});

package/src/validator.ts

@@ -0,0 +1,166 @@
+import { parse } from "yaml";
+import type { ResolverError, ResolverOutput, Warning } from "./types.js";
+
+export interface ValidationResult {
+	valid: boolean;
+	errors: ResolverError[];
+	warnings: Warning[];
+}
+
+/**
+ * Validates a complete generated stack before writing files.
+ * Checks for port conflicts, volume uniqueness, env completeness,
+ * dependency ordering, YAML validity, and more.
+ */
+export function validate(
+	resolved: ResolverOutput,
+	composedYaml: string,
+	options: { domain?: string; generateSecrets?: boolean } = {},
+): ValidationResult {
+	const errors: ResolverError[] = [];
+	const warnings: Warning[] = [];
+
+	checkPortConflicts(resolved, errors);
+	checkVolumeUniqueness(resolved, errors);
+	checkEnvCompleteness(resolved, errors, warnings, options.generateSecrets ?? true);
+	checkNetworkConsistency(resolved, warnings);
+	checkDependencyDAG(resolved, errors);
+	checkYamlValidity(composedYaml, errors);
+
+	if (options.domain) {
+		checkDomainFormat(options.domain, errors);
+	}
+
+	return {
+		valid: errors.length === 0,
+		errors,
+		warnings,
+	};
+}
+
+function checkPortConflicts(resolved: ResolverOutput, errors: ResolverError[]): void {
+	const hostPorts = new Map<number, string>();
+	for (const svc of resolved.services) {
+		for (const port of svc.definition.ports) {
+			if (!port.exposed) continue;
+			const existing = hostPorts.get(port.host);
+			if (existing) {
+				errors.push({
+					type: "port_conflict",
+					message: `Port ${port.host} is used by both "${existing}" and "${svc.definition.name}"`,
+				});
+			} else {
+				hostPorts.set(port.host, svc.definition.name);
+			}
+		}
+	}
+}
+
+function checkVolumeUniqueness(resolved: ResolverOutput, errors: ResolverError[]): void {
+	const volumeNames = new Map<string, string>();
+	for (const svc of resolved.services) {
+		for (const vol of svc.definition.volumes) {
+			const existing = volumeNames.get(vol.name);
+			if (existing && existing !== svc.definition.id) {
+				errors.push({
+					type: "volume_conflict",
+					message: `Volume name "${vol.name}" is used by both "${existing}" and "${svc.definition.id}"`,
+				});
+			} else {
+				volumeNames.set(vol.name, svc.definition.id);
+			}
+		}
+	}
+}
+
+function checkEnvCompleteness(
+	resolved: ResolverOutput,
+	errors: ResolverError[],
+	warnings: Warning[],
+	generateSecrets: boolean,
+): void {
+	for (const svc of resolved.services) {
+		for (const envVar of svc.definition.environment) {
+			if (envVar.required && !envVar.defaultValue && !envVar.secret) {
+				errors.push({
+					type: "missing_env",
+					message: `Required environment variable "${envVar.key}" for "${svc.definition.name}" has no default value`,
+				});
+			}
+			if (envVar.secret && !generateSecrets && !envVar.defaultValue) {
+				warnings.push({
+					type: "secret_needed",
+					message: `Secret "${envVar.key}" for "${svc.definition.name}" needs to be configured manually`,
+				});
+			}
+		}
+	}
+}
+
+function checkNetworkConsistency(resolved: ResolverOutput, warnings: Warning[]): void {
+	for (const svc of resolved.services) {
+		if (!svc.definition.networks.includes("openclaw-network")) {
+			warnings.push({
+				type: "network",
+				message: `Service "${svc.definition.name}" is not on openclaw-network — it may not be reachable from OpenClaw`,
+			});
+		}
+	}
+}
+
+function checkDependencyDAG(resolved: ResolverOutput, errors: ResolverError[]): void {
+	const ids = new Set(resolved.services.map((s) => s.definition.id));
+	const visited = new Set<string>();
+	const inStack = new Set<string>();
+
+	const adjList = new Map<string, string[]>();
+	for (const svc of resolved.services) {
+		const deps = [...svc.definition.requires, ...svc.definition.dependsOn].filter((d) =>
+			ids.has(d),
+		);
+		adjList.set(svc.definition.id, deps);
+	}
+
+	function hasCycle(node: string): boolean {
+		if (inStack.has(node)) return true;
+		if (visited.has(node)) return false;
+		visited.add(node);
+		inStack.add(node);
+		for (const dep of adjList.get(node) ?? []) {
+			if (hasCycle(dep)) return true;
+		}
+		inStack.delete(node);
+		return false;
+	}
+
+	for (const id of ids) {
+		if (hasCycle(id)) {
+			errors.push({
+				type: "cycle",
+				message: `Circular dependency detected involving "${id}"`,
+			});
+			break;
+		}
+	}
+}
+
+function checkYamlValidity(yaml: string, errors: ResolverError[]): void {
+	try {
+		parse(yaml);
+	} catch (e) {
+		errors.push({
+			type: "yaml_invalid",
+			message: `Generated YAML is not valid: ${e instanceof Error ? e.message : String(e)}`,
+		});
+	}
+}
+
+function checkDomainFormat(domain: string, errors: ResolverError[]): void {
+	const domainRegex = /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
+	if (!domainRegex.test(domain)) {
+		errors.push({
+			type: "invalid_domain",
+			message: `"${domain}" is not a valid domain name`,
+		});
+	}
+}

package/src/version-manager.ts

@@ -0,0 +1,65 @@
+import { getServiceById } from "./services/registry.js";
+import type { ResolverOutput, ServiceDefinition, Warning } from "./types.js";
+
+/** Get the pinned image tag for a service */
+export function getImageTag(serviceId: string): string | undefined {
+	const svc = getServiceById(serviceId);
+	return svc?.imageTag;
+}
+
+/** Get the full image reference (image:tag) for a service */
+export function getImageReference(serviceId: string): string | undefined {
+	const svc = getServiceById(serviceId);
+	if (!svc) return undefined;
+	return `${svc.image}:${svc.imageTag}`;
+}
+
+/** Pin all service image tags in a resolved output (returns a copy) */
+export function pinImageTags(resolved: ResolverOutput): ResolverOutput {
+	return {
+		...resolved,
+		services: resolved.services.map((s) => ({
+			...s,
+			definition: { ...s.definition },
+		})),
+	};
+}
+
+/** Check for known compatibility issues between services */
+export function checkCompatibility(services: ServiceDefinition[]): Warning[] {
+	const warnings: Warning[] = [];
+	const ids = new Set(services.map((s) => s.id));
+
+	// Redis + Valkey conflict (should already be caught by resolver, but double-check)
+	if (ids.has("redis") && ids.has("valkey")) {
+		warnings.push({
+			type: "compatibility",
+			message: "Redis and Valkey cannot coexist. Choose one.",
+		});
+	}
+	// Caddy + Traefik conflict
+	if (ids.has("caddy") && ids.has("traefik")) {
+		warnings.push({
+			type: "compatibility",
+			message: "Caddy and Traefik cannot coexist. Choose one reverse proxy.",
+		});
+	}
+	// Multiple vector DBs warning
+	const vectorDbs = ["qdrant", "chromadb", "weaviate"].filter((id) => ids.has(id));
+	if (vectorDbs.length > 1) {
+		warnings.push({
+			type: "compatibility",
+			message: `Multiple vector databases selected (${vectorDbs.join(", ")}). Consider using just one to reduce resource usage.`,
+		});
+	}
+	// GPU services without GPU
+	const gpuServices = services.filter((s) => s.gpuRequired);
+	if (gpuServices.length > 0) {
+		warnings.push({
+			type: "compatibility",
+			message: `Services requiring GPU: ${gpuServices.map((s) => s.name).join(", ")}. Ensure NVIDIA Container Toolkit is installed.`,
+		});
+	}
+
+	return warnings;
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}