create-asaje-go-vue 0.3.0 → 0.3.2

package/README.md

@@ -8,6 +8,7 @@ CLI package for scaffolding and running the Asaje Go + Vue boilerplate.
 
 | Command | Purpose |
 | --- | --- |
+| `asaje sync-project-config [directory]` | Scan the project, detect managed services, and rewrite `asaje.config.json` / `asaje.railway.json` |
 | `asaje setup-railway [directory]` | Provision infrastructure, create missing Railway services, wire variables, and deploy |
 | `asaje update-railway [directory]` | Reconcile an existing Railway project after changing `asaje.config.json` |
 | `asaje sync-railway-env [directory]` | Reapply Railway variables without reprovisioning infra |
@@ -66,6 +67,13 @@ npx -p create-asaje-go-vue@latest asaje update ./my-app --yes
 npx -p create-asaje-go-vue@latest asaje update ./my-app --include admin/src/stores/session.ts,admin/src/services/http/session.ts
 ```
 
+### Scan the project and regenerate local config manifests
+
+```bash
+npx -p create-asaje-go-vue@latest asaje sync-project-config ./my-app --dry-run
+npx -p create-asaje-go-vue@latest asaje sync-project-config ./my-app --yes
+```
+
 ### Provision Railway resources
 
 ```bash
@@ -74,6 +82,15 @@ npx -p create-asaje-go-vue@latest asaje setup-railway ./my-app --dry-run
 npx -p create-asaje-go-vue@latest asaje update-railway ./my-app --yes
 ```
 
+By default this manages four Railway app services:
+
+- `api`
+- `worker`
+- `realtime-gateway`
+- `admin`
+
+The default `worker` service reuses `api/Dockerfile` and starts with `API_COMMAND=worker`.
+
 ### Sync Railway app variables
 
 ```bash
@@ -119,6 +136,7 @@ npx -p create-asaje-go-vue@latest asaje diff-railway-config ./my-app --file ./sn
 
 ```bash
 npx -p create-asaje-go-vue@latest asaje deploy-railway ./my-app
+npx -p create-asaje-go-vue@latest asaje deploy-railway ./my-app --service worker
 npx -p create-asaje-go-vue@latest asaje deploy-railway ./my-app --service api
 npx -p create-asaje-go-vue@latest asaje deploy-railway ./my-app --services api,admin --dry-run
 ```
@@ -171,6 +189,15 @@ npx -p create-asaje-go-vue@latest asaje destroy-railway ./my-app --scope project
 - supports `--dry-run` to preview which files would be updated
 - updates `asaje.config.json` with the template repository and branch used for the update
 
+## What `asaje sync-project-config` does
+
+- scans the project tree for service-local `Dockerfile` files
+- infers Railway managed services from the detected directories
+- preserves existing service metadata when possible, while updating directories and Dockerfile paths from the scan
+- rewrites `asaje.config.json` with the merged `railway.services` list
+- rewrites `asaje.railway.json` so local service names line up with the current managed service list
+- supports `--dry-run` to preview the rewrite without changing local files
+
 ## What `asaje setup-railway` does
 
 - validates the target project structure
@@ -178,9 +205,9 @@ npx -p create-asaje-go-vue@latest asaje destroy-railway ./my-app --scope project
 - reads the linked Railway project context
 - provisions PostgreSQL, RabbitMQ, and S3-compatible object storage on Railway
 - creates missing Railway app services for the configured app service list
-- defaults to `api`, `realtime-gateway`, and `admin` when no custom Railway service config is present
+- defaults to `api`, `worker`, `realtime-gateway`, and `admin` when no custom Railway service config is present
 - applies Railway variables from `asaje.config.json` when configured
-- keeps the legacy automatic variable wiring for `api`, `realtime-gateway`, and `admin` unless `railway.variablesMode` is set to `replace`
+- keeps the legacy automatic variable wiring for `api`, `worker`, `realtime-gateway`, and `admin` unless `railway.variablesMode` is set to `replace`
 - triggers the first Railway deployment for each app service using the service-local `Dockerfile` and `railway.json`
 - generates missing app secrets such as `JWT_SECRET` and `SWAGGER_PASSWORD`, while reusing existing Railway values when present
 - supports `--dry-run` to preview provisioning and variable changes without applying them
@@ -201,7 +228,7 @@ npx -p create-asaje-go-vue@latest asaje destroy-railway ./my-app --scope project
 - reads the linked Railway project context
 - discovers existing Railway app and infra services
 - syncs configured Railway variables without provisioning infra resources
-- keeps the legacy automatic variable wiring for `api`, `realtime-gateway`, and `admin` unless `railway.variablesMode` is set to `replace`
+- keeps the legacy automatic variable wiring for `api`, `worker`, `realtime-gateway`, and `admin` unless `railway.variablesMode` is set to `replace`
 - supports `--diff` to show what would be added or changed compared with the current Railway variables
 - supports `--dry-run` to preview variable changes without applying them
 
@@ -246,7 +273,7 @@ npx -p create-asaje-go-vue@latest asaje destroy-railway ./my-app --scope project
 - reads the linked Railway project context
 - discovers the existing Railway app services from the linked project or `asaje.railway.json`
 - triggers fresh Railway builds/deployments for the configured app service list from the current local source tree
-- defaults to `api`, `realtime-gateway`, and `admin` when no custom Railway service config is present
+- defaults to `api`, `worker`, `realtime-gateway`, and `admin` when no custom Railway service config is present
 - supports `--service` and `--services` to redeploy only selected app services
 - supports `--dry-run` to preview which services would be redeployed
 
@@ -268,6 +295,13 @@ If the `railway` block is omitted, the CLI keeps the default built-in services a
         "directory": "api",
         "dockerfile": "api/Dockerfile"
       },
+      {
+        "key": "worker",
+        "directory": "api",
+        "baseName": "worker",
+        "aliases": ["worker", "api-worker"],
+        "dockerfile": "api/Dockerfile"
+      },
       {
         "key": "admin",
         "directory": "admin",
@@ -280,12 +314,6 @@ If the `railway` block is omitted, the CLI keeps the default built-in services a
         "aliases": ["realtime-gateway"],
         "dockerfile": "realtime-gateway/Dockerfile"
       },
-      {
-        "key": "worker",
-        "directory": "worker-api",
-        "baseName": "worker",
-        "dockerfile": "worker-api/Dockerfile"
-      },
       {
         "key": "marketing",
         "directory": "marketing",
@@ -386,7 +414,8 @@ Notes:
 - the service directory should contain the `Dockerfile` Railway will build from
 - custom services are provisioned and deployed by `setup-railway` and `deploy-railway`
 - `sync-railway-env` can now apply declarative variables to any managed service key, including custom services
-- with `variablesMode: "merge"`, the core services `api`, `realtime-gateway`, and `admin` still receive the legacy generated defaults unless you override them
+- with `variablesMode: "merge"`, the core services `api`, `worker`, `realtime-gateway`, and `admin` still receive the legacy generated defaults unless you override them
+- the default `worker` service reuses the `api` image and starts with `API_COMMAND=worker`
 - with `variablesMode: "replace"`, only the variables declared in `asaje.config.json` are applied
 - after changing the Railway config, run `asaje update-railway ./my-app --yes` to reconcile the linked Railway project with the new configuration
 - you can target a custom service with `asaje deploy-railway ./my-app --service worker`

package/bin/create-asaje-go-vue.js

@@ -34,6 +34,12 @@ const DEFAULT_RAILWAY_APP_SERVICE_SPECS = [
     directory: "api",
     key: "api",
   },
+  {
+    aliases: ["worker", "api-worker"],
+    baseName: "worker",
+    directory: "api",
+    key: "worker",
+  },
   {
     aliases: ["admin", "frontend", "web"],
     baseName: "admin",
@@ -104,6 +110,12 @@ async function main() {
       return;
     }
 
+    if (invocation.command === "sync-project-config") {
+      await runSyncProjectConfig(invocation.argv);
+      outro(pc.green("Project config sync complete."));
+      return;
+    }
+
     if (invocation.command === "setup-railway") {
       await runSetupRailway(invocation.argv);
       outro(pc.green("Railway setup complete."));
@@ -202,6 +214,10 @@ function resolveInvocation(argv) {
       return { argv: rawArgs.slice(1), command: "update", title: "asaje update" };
     }
 
+    if (firstArg === "sync-project-config") {
+      return { argv: rawArgs.slice(1), command: "sync-project-config", title: "asaje sync-project-config" };
+    }
+
     if (firstArg === "setup-railway") {
       return { argv: rawArgs.slice(1), command: "setup-railway", title: "asaje setup-railway" };
     }
@@ -261,6 +277,10 @@ function resolveInvocation(argv) {
     return { argv: rawArgs.slice(1), command: "update", title: "create-asaje-go-vue" };
   }
 
+  if (firstArg === "sync-project-config") {
+    return { argv: rawArgs.slice(1), command: "sync-project-config", title: "create-asaje-go-vue" };
+  }
+
   if (firstArg === "setup-railway") {
     return { argv: rawArgs.slice(1), command: "setup-railway", title: "create-asaje-go-vue" };
   }
@@ -308,6 +328,7 @@ function printHelp() {
   console.log(`- ${pc.bold("asaje doctor [directory]")} check environment and project readiness`);
   console.log(`- ${pc.bold("asaje publish")} run npm publish checklist for the CLI package`);
   console.log(`- ${pc.bold("asaje update [directory]")} update managed boilerplate files from the template`);
+  console.log(`- ${pc.bold("asaje sync-project-config [directory]")} scan the project and rewrite Asaje config manifests`);
   console.log(`- ${pc.bold("asaje setup-railway [directory]")} provision Railway infrastructure for a project`);
   console.log(`- ${pc.bold("asaje update-railway [directory]")} reconcile Railway resources/services/vars from current config`);
   console.log(`- ${pc.bold("asaje sync-railway-env [directory]")} sync Railway app variables without provisioning`);
@@ -324,6 +345,7 @@ function printHelp() {
   console.log(`- ${pc.bold("asaje doctor ..")}`);
   console.log(`- ${pc.bold("asaje publish")}`);
   console.log(`- ${pc.bold("asaje update .. --dry-run")}`);
+  console.log(`- ${pc.bold("asaje sync-project-config .. --dry-run")}`);
   console.log(`- ${pc.bold("asaje setup-railway ..")}`);
   console.log(`- ${pc.bold("asaje update-railway ..")}`);
   console.log(`- ${pc.bold("asaje sync-railway-env ..")}`);
@@ -1207,6 +1229,34 @@ async function runUpdate(argv) {
   }
 }
 
+async function runSyncProjectConfig(argv) {
+  const args = await collectSyncProjectConfigAnswers(parseSyncProjectConfigArgs(argv));
+  const projectDir = path.resolve(process.cwd(), args.directory);
+
+  await ensureProjectStructure(projectDir);
+
+  const projectConfig = await loadProjectConfig(projectDir);
+  const manifest = await readRailwayManifest(projectDir);
+  const scanSummary = await scanProjectForManagedRailwayServices(projectDir);
+  const nextProjectConfig = buildSyncedProjectConfig(projectDir, projectConfig, scanSummary.serviceSpecs);
+  const nextManifest = buildSyncedRailwayManifest(manifest, nextProjectConfig, scanSummary.serviceSpecs);
+
+  if (!args.dryRun) {
+    await writeProjectConfigFile(projectDir, nextProjectConfig);
+    await writeRailwayManifest(projectDir, nextManifest);
+  }
+
+  printSyncProjectConfigSummary({
+    dryRun: args.dryRun,
+    manifest,
+    nextManifest,
+    nextProjectConfig,
+    previousProjectConfig: projectConfig,
+    projectDir,
+    scanSummary,
+  });
+}
+
 async function runSetupRailway(argv) {
   const args = parseSetupRailwayArgs(argv);
   const answers = await collectSetupRailwayAnswers(args);
@@ -1910,6 +1960,34 @@ function parseImportRailwayConfigArgs(argv) {
   return options;
 }
 
+function parseSyncProjectConfigArgs(argv) {
+  const options = {
+    directory: ".",
+    dryRun: false,
+    yes: false,
+  };
+  const positionals = [];
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+
+    if (arg === "--yes" || arg === "-y") {
+      options.yes = true;
+      continue;
+    }
+
+    if (arg === "--dry-run") {
+      options.dryRun = true;
+      continue;
+    }
+
+    positionals.push(arg);
+  }
+
+  options.directory = positionals[0] || options.directory;
+  return options;
+}
+
 function parseDiffRailwayConfigArgs(argv) {
   const options = {
     compareEnvironment: undefined,
@@ -2235,6 +2313,25 @@ async function collectImportRailwayConfigAnswers(args) {
   return args;
 }
 
+async function collectSyncProjectConfigAnswers(args) {
+  if (args.yes || args.dryRun) {
+    return args;
+  }
+
+  const confirmed = await prompt(
+    confirm({
+      initialValue: true,
+      message: `Scan ${args.directory} and rewrite asaje.config.json / ${RAILWAY_MANIFEST_FILENAME}?`,
+    }),
+  );
+
+  if (!confirmed) {
+    throw new Error("Project config sync cancelled.");
+  }
+
+  return args;
+}
+
 async function collectDestroyRailwayAnswers(args) {
   if (args.yes) {
     return args;
@@ -2979,6 +3076,7 @@ async function resolveRailwayVariablePlan(config) {
     admin: findRailwayServiceByKey(config.services, config.appServiceSpecs, config.manifest, "admin"),
     api: findRailwayServiceByKey(config.services, config.appServiceSpecs, config.manifest, "api"),
     realtime: findRailwayServiceByKey(config.services, config.appServiceSpecs, config.manifest, "realtime"),
+    worker: findRailwayServiceByKey(config.services, config.appServiceSpecs, config.manifest, "worker"),
   };
 
   const serviceRegistry = {
@@ -2988,6 +3086,7 @@ async function resolveRailwayVariablePlan(config) {
     postgres: infra.postgres ? { name: infra.postgres.name, variables: {} } : null,
     rabbitmq: infra.rabbitmq ? { name: infra.rabbitmq.name, variables: {} } : null,
     realtime: appServices.realtime ? { name: appServices.realtime.name, variables: {} } : null,
+    worker: appServices.worker ? { name: appServices.worker.name, variables: {} } : null,
   };
 
   for (const spec of config.appServiceSpecs) {
@@ -3018,6 +3117,9 @@ async function resolveRailwayVariablePlan(config) {
   if (!appServices.admin) {
     notices.push("admin service not found, skipping admin variable wiring");
   }
+  if (!appServices.worker) {
+    notices.push("worker service not found, skipping worker variable wiring");
+  }
   if (!infra.postgres) {
     notices.push("postgres resource not found, DATABASE_URL wiring will be skipped");
   }
@@ -3079,6 +3181,26 @@ async function resolveRailwayVariablePlan(config) {
     mergeRailwayServiceVariables(serviceRegistry.admin, variables);
   }
 
+  if (variablesMode !== "replace" && appServices.worker) {
+    const existingApiVariables = appServices.api?.name
+      ? await loadRailwayServiceVariables(config.projectDir, config.railwayContext.environmentRef, appServices.api.name)
+      : {};
+    const variables = {};
+    const sharedSecrets = buildRailwaySharedSecrets(localEnv, existingApiVariables);
+    Object.assign(variables, sharedSecrets.api);
+    variables.API_COMMAND = "worker";
+    if (infra.postgres?.name) {
+      variables.DATABASE_URL = railwayReference(infra.postgres.name, "DATABASE_URL");
+    }
+    if (infra.rabbitmq?.name) {
+      variables.RABBITMQ_URL = buildRabbitMqUrlReference(infra.rabbitmq.name);
+    }
+    if (infra.objectStorage?.name) {
+      Object.assign(variables, buildObjectStorageVariables(infra.objectStorage.name));
+    }
+    mergeRailwayServiceVariables(serviceRegistry.worker, variables);
+  }
+
   if (declaredVariables.hasDeclaredVariables) {
     if (Object.keys(declaredVariables.sharedVariables).length > 0) {
       for (const entry of Object.values(serviceRegistry)) {
@@ -3818,6 +3940,7 @@ function printRailwaySetupSummary(config) {
   if (config.railwayContext.environmentName || config.railwayContext.environmentId) {
     console.log(`- Environment: ${pc.bold(config.railwayContext.environmentName || config.railwayContext.environmentId)}`);
   }
+  console.log(`- Managed services: ${pc.bold("api, worker, realtime-gateway, admin")}`);
   console.log(`- Bucket: ${pc.bold(config.bucket)}`);
 
   console.log(pc.bold("\nResources"));
@@ -3878,6 +4001,7 @@ function printRailwayDeploySummary(config) {
   if (config.railwayContext.environmentName || config.railwayContext.environmentId) {
     console.log(`- Environment: ${pc.bold(config.railwayContext.environmentName || config.railwayContext.environmentId)}`);
   }
+  console.log(`- Default managed services: ${pc.bold("api, worker, realtime-gateway, admin")}`);
   console.log(`- Services: ${pc.bold(config.selectedServices.join(", "))}`);
 
   console.log(pc.bold("\nDeployments"));
@@ -4149,6 +4273,227 @@ async function ensureRailwayAppServiceTargets(projectDir, appServiceSpecs) {
   }
 }
 
+async function scanProjectForManagedRailwayServices(projectDir) {
+  const dockerfiles = [];
+  await collectDockerfiles(projectDir, "", dockerfiles);
+
+  const scannedSpecs = dockerfiles
+    .map((dockerfilePath) => buildScannedRailwayServiceSpec(projectDir, dockerfilePath))
+    .filter(Boolean)
+    .sort((left, right) => left.directory.localeCompare(right.directory));
+
+  const serviceSpecs = synthesizeDerivedRailwayServices(scannedSpecs);
+
+  return {
+    dockerfiles,
+    serviceSpecs,
+  };
+}
+
+function synthesizeDerivedRailwayServices(serviceSpecs) {
+  const nextSpecs = [...serviceSpecs];
+  const hasAPI = serviceSpecs.some((spec) => spec.key === "api" && spec.directory === "api");
+  const hasWorker = serviceSpecs.some((spec) => spec.key === "worker");
+  if (hasAPI && !hasWorker) {
+    nextSpecs.push({
+      aliases: ["worker", "api-worker"],
+      baseName: "worker",
+      directory: "api",
+      dockerfile: "api/Dockerfile",
+      key: "worker",
+      seedImage: "alpine:3.22",
+      serviceName: null,
+    });
+  }
+
+  return nextSpecs.sort((left, right) => `${left.directory}:${left.key}`.localeCompare(`${right.directory}:${right.key}`));
+}
+
+async function collectDockerfiles(projectDir, relativeDir, results) {
+  const absoluteDir = path.join(projectDir, relativeDir);
+  const entries = await fs.readdir(absoluteDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const nextRelativePath = relativeDir ? path.posix.join(relativeDir, entry.name) : entry.name;
+    if (entry.isDirectory()) {
+      if (shouldSkipProjectScanDirectory(entry.name, nextRelativePath)) {
+        continue;
+      }
+
+      await collectDockerfiles(projectDir, nextRelativePath, results);
+      continue;
+    }
+
+    if (entry.isFile() && entry.name === "Dockerfile") {
+      results.push(nextRelativePath);
+    }
+  }
+}
+
+function shouldSkipProjectScanDirectory(name, relativePath) {
+  const normalized = String(name || "").trim();
+  if (!normalized) {
+    return false;
+  }
+
+  if ([".git", ".turbo", ".next", ".nuxt", "node_modules", "dist", "build", "coverage", "tmp", "vendor"].includes(normalized)) {
+    return true;
+  }
+
+  if (relativePath === "cli") {
+    return true;
+  }
+
+  return normalized.startsWith(".") && normalized !== ".well-known";
+}
+
+function buildScannedRailwayServiceSpec(projectDir, dockerfilePath) {
+  const directory = path.posix.dirname(dockerfilePath);
+  if (!directory || directory === ".") {
+    return null;
+  }
+
+  const inferred = inferRailwayServiceIdentity(directory);
+  return {
+    aliases: inferred.aliases,
+    baseName: inferred.baseName,
+    directory,
+    dockerfile: dockerfilePath,
+    key: inferred.key,
+    seedImage: inferred.key === "admin" ? "nginx:1.29-alpine" : "alpine:3.22",
+    serviceName: null,
+  };
+}
+
+function inferRailwayServiceIdentity(directory) {
+  const normalizedDirectory = directory.replace(/\/+$/g, "");
+  const directoryName = path.posix.basename(normalizedDirectory);
+  const normalizedName = normalizeRailwayServiceName(directoryName);
+
+  if (["api", "backend", "server"].includes(normalizedName)) {
+    return { aliases: ["api", "backend", "server"], baseName: "api", key: "api" };
+  }
+  if (["admin", "frontend", "web"].includes(normalizedName)) {
+    return { aliases: ["admin", "frontend", "web"], baseName: "admin", key: "admin" };
+  }
+  if (["realtime", "realtime-gateway"].includes(normalizedName)) {
+    return { aliases: ["realtime-gateway", "realtime"], baseName: "realtime-gateway", key: "realtime" };
+  }
+
+  const slug = slugify(directoryName);
+  return { aliases: [slug], baseName: slug, key: slug };
+}
+
+function buildSyncedProjectConfig(projectDir, projectConfig, scannedServiceSpecs) {
+  const nextConfig = {
+    ...(projectConfig || {}),
+    projectName: projectConfig?.projectName || path.basename(projectDir),
+    projectSlug: projectConfig?.projectSlug || slugify(path.basename(projectDir)),
+  };
+
+  const previousServices = resolveRailwayAppServiceSpecs(projectConfig);
+  const mergedServices = mergeScannedRailwayServices(previousServices, scannedServiceSpecs);
+
+  nextConfig.railway = {
+    ...(getRailwayConfig(projectConfig) || {}),
+    services: mergedServices.map((service) => ({
+      baseName: service.baseName,
+      directory: service.directory,
+      ...(service.dockerfile ? { dockerfile: service.dockerfile } : {}),
+      key: service.key,
+      ...(service.aliases?.length > 0 ? { aliases: service.aliases } : {}),
+      ...(service.serviceName ? { serviceName: service.serviceName } : {}),
+      ...(service.seedImage ? { seedImage: service.seedImage } : {}),
+    })),
+  };
+
+  return nextConfig;
+}
+
+function mergeScannedRailwayServices(previousServices, scannedServiceSpecs) {
+  const previousByKey = new Map(previousServices.map((service) => [service.key, service]));
+  const previousByDirectory = new Map(previousServices.map((service) => [service.directory, service]));
+
+  return scannedServiceSpecs.map((scanned) => {
+    const previous = previousByKey.get(scanned.key) || previousByDirectory.get(scanned.directory);
+    return {
+      aliases: uniqueStrings([...(previous?.aliases || []), ...scanned.aliases]),
+      baseName: previous?.baseName || scanned.baseName,
+      directory: scanned.directory,
+      dockerfile: scanned.dockerfile,
+      key: previous?.key || scanned.key,
+      seedImage: previous?.seedImage || scanned.seedImage,
+      serviceName: previous?.serviceName || null,
+    };
+  });
+}
+
+function buildSyncedRailwayManifest(manifest, nextProjectConfig, scannedServiceSpecs) {
+  const nextManifest = {
+    ...(manifest || {}),
+    appServices: {},
+    projectSlug: nextProjectConfig.projectSlug || manifest?.projectSlug || null,
+    updatedAt: new Date().toISOString(),
+  };
+
+  const previousAppServices = manifest?.appServices || {};
+  const existingSpecs = resolveRailwayAppServiceSpecs(nextProjectConfig);
+  for (const spec of existingSpecs) {
+    const previousEntry =
+      previousAppServices[spec.key] ||
+      findRailwayManifestAppServiceByName(previousAppServices, resolveRailwayServiceName(spec, nextManifest.projectSlug));
+
+    nextManifest.appServices[spec.key] = {
+      serviceId: previousEntry?.serviceId || null,
+      serviceName: previousEntry?.serviceName || resolveRailwayServiceName(spec, nextManifest.projectSlug),
+    };
+  }
+
+  return nextManifest;
+}
+
+function findRailwayManifestAppServiceByName(appServices, serviceName) {
+  return Object.values(appServices || {}).find(
+    (entry) => normalizeRailwayServiceName(entry?.serviceName) === normalizeRailwayServiceName(serviceName),
+  ) || null;
+}
+
+async function writeProjectConfigFile(projectDir, projectConfig) {
+  const configPath = path.join(projectDir, "asaje.config.json");
+  await fs.writeJson(configPath, projectConfig, { spaces: 2 });
+}
+
+function printSyncProjectConfigSummary(config) {
+  const previousServices = new Map(resolveRailwayAppServiceSpecs(config.previousProjectConfig).map((service) => [service.key, service]));
+  const nextServices = config.nextProjectConfig.railway?.services || [];
+
+  console.log(pc.bold("\nProject config sync"));
+  console.log(`- Directory: ${pc.bold(config.projectDir)}`);
+  console.log(`- Dockerfiles found: ${pc.bold(String(config.scanSummary.dockerfiles.length))}`);
+
+  console.log(pc.bold("\nRailway services"));
+  if (nextServices.length === 0) {
+    console.log("- No managed Railway services detected");
+  } else {
+    for (const service of nextServices) {
+      const previous = previousServices.get(service.key);
+      const status = !previous ? "new" : previous.directory !== service.directory || previous.dockerfile !== service.dockerfile ? "updated" : "unchanged";
+      console.log(`- ${pc.bold(service.key)}: ${status} (${service.directory})`);
+    }
+  }
+
+  console.log(pc.bold("\nFiles"));
+  console.log(`- ${config.dryRun ? "would write" : "wrote"} ${pc.bold("asaje.config.json")}`);
+  console.log(`- ${config.dryRun ? "would write" : "wrote"} ${pc.bold(RAILWAY_MANIFEST_FILENAME)}`);
+  if (config.dryRun) {
+    console.log("- Dry run only, local files were not modified");
+  }
+}
+
+function uniqueStrings(values) {
+  return [...new Set((values || []).map((value) => String(value || "").trim()).filter(Boolean))];
+}
+
 function resolveProjectSlug(projectDir, projectConfig) {
   return slugify(projectConfig?.projectSlug || projectConfig?.projectName || path.basename(projectDir) || "asaje-app");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "create-asaje-go-vue",
-	"version": "0.3.0",
+	"version": "0.3.2",
 	"description": "CLI to scaffold, configure, and run the Asaje Go + Vue boilerplate",
 	"type": "module",
 	"bin": {
@@ -11,6 +11,7 @@
 		"create": "node ./bin/create-asaje-go-vue.js",
 		"start": "node ./bin/asaje.js start .",
 		"doctor": "node ./bin/asaje.js doctor ..",
+		"sync-project-config": "node ./bin/asaje.js sync-project-config .. --dry-run",
 		"setup-railway": "node ./bin/asaje.js setup-railway .. --yes",
 		"update-railway": "node ./bin/asaje.js update-railway .. --yes",
 		"sync-railway-env": "node ./bin/asaje.js sync-railway-env .. --yes",