refactor(ci): resolve service aliases instead of filtering

Better approach: resolve service aliases to their canonical service names
instead of filtering them out. This preserves change information while
ensuring we build the correct images.

Changes:
- Replace filterServiceAliases() with buildServiceAliasMapping()
- Add resolveServiceAliases() to map alias names to canonical names
- Apply resolution after detecting changed services
- Duplicates are automatically removed during resolution

Example workflow:
1. Changes detected in: ['historian', 'historian-secondary']
2. Alias mapping: historian-secondary → historian
3. Resolved to build: ['historian']
4. Build workflow uses canonical service name 'historian'
5. Image ghcr.io/groupsky/homy/historian works for both services

Benefits:
- Don't lose track of changes in alias-specific configuration
- Correctly identify which image needs to be built
- Maintain relationship between aliases and canonical services
- More maintainable and explicit than filtering

Author: groupsky

.github/scripts/detect-changes/src/index.ts

@@ -13,7 +13,7 @@ import { Command } from 'commander';
 import { writeFileSync, readFileSync, existsSync } from 'fs';
 import * as path from 'path';
 import { discoverBaseImages, buildDirectoryToGhcrMapping } from './lib/base-images.js';
-import { discoverServicesFromCompose, filterGhcrServices, filterServiceAliases } from './lib/services.js';
+import { discoverServicesFromCompose, filterGhcrServices, buildServiceAliasMapping, resolveServiceAliases } from './lib/services.js';
 import { buildReverseDependencyMap, detectAffectedServices } from './lib/dependency-graph.js';
 import { detectChangedBaseImages, detectChangedServices, isTestOnlyChange } from './lib/change-detection.js';
 import { hasHealthcheck, extractFinalStageBase } from './lib/dockerfile-parser.js';
@@ -175,17 +175,24 @@ async function detectChanges(options: CliOptions): Promise<DetectionResult> {
 
   console.error('Step 3: Discovering services from docker-compose...');
   const allServices = discoverServicesFromCompose(options.composeFile, options.envFile);
-  const ghcrServices = filterGhcrServices(allServices);
-  const services = filterServiceAliases(ghcrServices);
-  console.error(`Found ${services.length} buildable services (${ghcrServices.length} GHCR, ${allServices.length} total)`);
+  const services = filterGhcrServices(allServices);
+  console.error(`Found ${services.length} GHCR services (${allServices.length} total)`);
+
+  console.error('Step 3.5: Building service alias mapping...');
+  const serviceAliasMapping = buildServiceAliasMapping(services);
+  const aliasCount = Array.from(serviceAliasMapping.entries()).filter(
+    ([alias, canonical]) => alias !== canonical
+  ).length;
+  console.error(`Found ${aliasCount} service aliases`);
 
   console.error('Step 4: Detecting changed base images...');
   const changedBaseImages = detectChangedBaseImages(options.baseRef, baseImages);
   console.error(`Changed base images: ${changedBaseImages.length}`);
 
   console.error('Step 5: Detecting changed services...');
-  const changedServices = detectChangedServices(options.baseRef, services);
-  console.error(`Changed services: ${changedServices.length}`);
+  const changedServicesRaw = detectChangedServices(options.baseRef, services);
+  const changedServices = resolveServiceAliases(changedServicesRaw, serviceAliasMapping);
+  console.error(`Changed services (raw): ${changedServicesRaw.length}, resolved: ${changedServices.length}`);
 
   console.error('Step 6: Building reverse dependency map...');
   const reverseDeps = buildReverseDependencyMap(services, options.dockerDir, baseImageMapping);

.github/scripts/detect-changes/src/lib/services.ts

@@ -197,37 +197,36 @@ export function filterGhcrServices(services: Service[]): Service[] {
 }
 
 /**
- * Filters out service aliases that share the same image with another service.
+ * Builds a mapping from service names (including aliases) to their canonical service names.
  *
  * Service aliases are docker-compose services that use the same Docker image as another
- * service but with different runtime configuration (environment variables, volumes, etc.).
- * These should not be built separately since they share the same image.
+ * service but with different runtime configuration. They should resolve to the canonical
+ * service name for build purposes.
  *
- * A service is considered an alias if:
- * 1. Its image name doesn't match its service name
- * 2. Another service exists whose service name matches the image name
+ * A canonical service is one where the service name matches the image name.
+ * An alias is any other service using that same image.
  *
- * @param services Array of services to filter
- * @returns Filtered array with service aliases removed
+ * @param services Array of all services
+ * @returns Map from service name to canonical service name
  *
  * @example
  * ```typescript
  * const services = [
  *   { service_name: 'historian', image: 'ghcr.io/groupsky/homy/historian:latest', ... },
  *   { service_name: 'historian-secondary', image: 'ghcr.io/groupsky/homy/historian:latest', ... }
  * ];
- * const filtered = filterServiceAliases(services);
- * console.log(filtered.length); // 1 (only historian, historian-secondary is filtered out)
+ * const mapping = buildServiceAliasMapping(services);
+ * console.log(mapping.get('historian')); // 'historian'
+ * console.log(mapping.get('historian-secondary')); // 'historian'
  * ```
  */
-export function filterServiceAliases(services: Service[]): Service[] {
-  // Build a map of image names to service names for canonical services
-  // A canonical service is one where the service name matches the image name
+export function buildServiceAliasMapping(services: Service[]): Map<string, string> {
+  // First pass: find canonical services (service name matches image name)
   const imageToCanonicalService = new Map<string, string>();
 
   for (const service of services) {
     if (!service.image) {
-      // Services without images (local builds) are always canonical
+      // Services without images (local builds) map to themselves
       imageToCanonicalService.set(service.service_name, service.service_name);
       continue;
     }
@@ -243,26 +242,69 @@ export function filterServiceAliases(services: Service[]): Service[] {
     }
   }
 
-  // Filter out service aliases
-  return services.filter((service) => {
-    // Services without image field are always kept (local builds)
+  // Second pass: build alias mapping
+  const aliasMapping = new Map<string, string>();
+
+  for (const service of services) {
     if (!service.image) {
-      return true;
+      // Local builds map to themselves
+      aliasMapping.set(service.service_name, service.service_name);
+      continue;
     }
 
-    // Check if this service's image has a canonical service
+    // Look up canonical service for this image
     const canonicalService = imageToCanonicalService.get(service.image);
 
-    // Keep service if:
-    // 1. No canonical service exists (orphan image), OR
-    // 2. This IS the canonical service
-    if (!canonicalService || canonicalService === service.service_name) {
-      return true;
+    if (canonicalService) {
+      // Map to canonical service
+      aliasMapping.set(service.service_name, canonicalService);
+    } else {
+      // No canonical service found - map to itself (orphan image)
+      aliasMapping.set(service.service_name, service.service_name);
     }
+  }
 
-    // This is a service alias - filter it out
-    return false;
-  });
+  return aliasMapping;
+}
+
+/**
+ * Resolves a list of service names to their canonical names, removing duplicates.
+ *
+ * Service aliases are resolved to their canonical service names based on the
+ * alias mapping. Duplicates are removed to ensure each canonical service appears
+ * only once in the result.
+ *
+ * @param serviceNames Array of service names (may include aliases)
+ * @param aliasMapping Map from service name to canonical service name
+ * @returns Array of unique canonical service names, sorted
+ *
+ * @example
+ * ```typescript
+ * const aliasMapping = new Map([
+ *   ['historian', 'historian'],
+ *   ['historian-secondary', 'historian'],
+ * ]);
+ * const resolved = resolveServiceAliases(['historian', 'historian-secondary'], aliasMapping);
+ * console.log(resolved); // ['historian']
+ * ```
+ */
+export function resolveServiceAliases(
+  serviceNames: string[],
+  aliasMapping: Map<string, string>
+): string[] {
+  const canonicalServices = new Set<string>();
+
+  for (const serviceName of serviceNames) {
+    const canonical = aliasMapping.get(serviceName);
+    if (canonical) {
+      canonicalServices.add(canonical);
+    } else {
+      // No mapping found - use service name as-is
+      canonicalServices.add(serviceName);
+    }
+  }
+
+  return Array.from(canonicalServices).sort();
 }
 
 /**