feat: allow multplie language support

Author: seo-rii

README.md

@@ -3,7 +3,7 @@
 Crunchy is a deployment helper that builds the current project, publishes a Docker image, and updates one or more Cloud Run services.
 
 ## Features
-- Runs the local TypeScript build (`pnpm run build`) before packaging.
+- Runs the project build using the requested language/tooling (pnpm, npm, yarn, Go, or Rust) with auto-detection when not specified.
 - Builds and pushes a `gcr.io/<project>/<image>` (or custom registry host) Docker image.
 - Deploys the new image to multiple Cloud Run services in parallel and shifts traffic to the latest revision.
 - Cleans up stale Cloud Run revisions and image digests with configurable retention limits.
@@ -37,7 +37,8 @@ crunchy --image <name> \
         --region <gcp-region> \
         [--beta] \
         [--keep-images <count>] \
-        [--keep-revisions <count>]
+        [--keep-revisions <count>] \
+        [--lang <pnpm|npm|yarn|go|rust>]
 ```
 
 ### Required flags
@@ -51,6 +52,18 @@ crunchy --image <name> \
 - `--keep-images`: Number of image digests to retain (default: `10`).
 - `--keep-revisions`: Number of Cloud Run revisions to retain (default: `10`).
 - `--registry-host`: Container registry host to target. Defaults to a region-specific host (e.g. `asia-northeast3` → `asia.gcr.io`, `europe-west1` → `eu.gcr.io`, `us-central1` → `us.gcr.io`, otherwise `gcr.io`).
+- `--lang`: Manually select the project language/build tool. Accepted values: `pnpm`, `npm`, `yarn`, `go`, `rust`. Historical aliases like `node` still map to the pnpm build.
+
+### Build tool detection
+When `--lang` is not provided, Crunchy checks for well-known files in the working directory:
+- `pnpm-lock.yaml`: run `pnpm run build`.
+- `yarn.lock`: run `yarn build`.
+- `package-lock.json`: run `npm run build`.
+- `go.mod`: run `go build ./...`.
+- `Cargo.toml`: run `cargo build --release`.
+- `package.json` with none of the above locks: default to `pnpm run build` for backward compatibility.
+
+If none of the indicators are present, Crunchy defaults to the Node (pnpm) build to preserve historical behavior.
 
 ### Example
 
@@ -65,6 +78,6 @@ crunchy \
 ```
 
 ## Requirements
-- `pnpm` installed and a working `pnpm run build`.
+- Matching tooling for your project (e.g. `pnpm`, `npm`, or `yarn` for Node/TypeScript builds; `go` for Go builds; `cargo` for Rust builds).
 - Docker CLI with access to the inferred (or specified) registry host.
 - Google Cloud SDK (`gcloud`) authenticated for the provided project and region.

language.go

@@ -0,0 +1,106 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type language string
+
+const (
+	langPNPM language = "pnpm"
+	langNPM  language = "npm"
+	langYarn language = "yarn"
+	langGo   language = "go"
+	langRust language = "rust"
+)
+
+func buildProject(cfg *config) error {
+	switch cfg.lang {
+	case langPNPM:
+		if err := runCommandStreaming(cfg.workdir, "pnpm", "run", "build"); err != nil {
+			return fmt.Errorf("build project with pnpm: %w", err)
+		}
+	case langNPM:
+		if err := runCommandStreaming(cfg.workdir, "npm", "run", "build"); err != nil {
+			return fmt.Errorf("build project with npm: %w", err)
+		}
+	case langYarn:
+		if err := runCommandStreaming(cfg.workdir, "yarn", "build"); err != nil {
+			return fmt.Errorf("build project with yarn: %w", err)
+		}
+	case langGo:
+		if err := runCommandStreaming(cfg.workdir, "go", "build", "./..."); err != nil {
+			return fmt.Errorf("build project with go: %w", err)
+		}
+	case langRust:
+		if err := runCommandStreaming(cfg.workdir, "cargo", "build", "--release"); err != nil {
+			return fmt.Errorf("build project with cargo: %w", err)
+		}
+	default:
+		return fmt.Errorf("unsupported language %q", cfg.lang)
+	}
+
+	return nil
+}
+
+func determineLanguage(workdir, requested string) (language, error) {
+	requested = strings.TrimSpace(strings.ToLower(requested))
+	if requested == "" {
+		return detectLanguage(workdir)
+	}
+
+	switch requested {
+	case string(langNPM), "node", "ts", "typescript", "javascript", "nodejs":
+		return langNPM, nil
+	case string(langPNPM):
+		return langPNPM, nil
+	case string(langYarn):
+		return langYarn, nil
+	case string(langGo), "golang":
+		return langGo, nil
+	case string(langRust), "cargo":
+		return langRust, nil
+	default:
+		return "", fmt.Errorf("unsupported --lang value %q", requested)
+	}
+}
+
+func detectLanguage(workdir string) (language, error) {
+	type indicator struct {
+		lang language
+		file string
+	}
+
+	orderedIndicators := []indicator{
+		{lang: langPNPM, file: "pnpm-lock.yaml"},
+		{lang: langYarn, file: "yarn.lock"},
+		{lang: langNPM, file: "package-lock.json"},
+		{lang: langGo, file: "go.mod"},
+		{lang: langRust, file: "Cargo.toml"},
+	}
+
+	for _, ind := range orderedIndicators {
+		if fileExists(filepath.Join(workdir, ind.file)) {
+			return ind.lang, nil
+		}
+	}
+
+	if fileExists(filepath.Join(workdir, "package.json")) {
+		return langPNPM, nil
+	}
+
+	return langPNPM, nil
+}
+
+func fileExists(path string) bool {
+	if path == "" {
+		return false
+	}
+	if _, err := os.Stat(path); err == nil {
+		return true
+	}
+	return false
+}

main.go

@@ -24,6 +24,7 @@ type config struct {
 	project  string
 	region   string
 	registryHost string
+	lang     language
 }
 
 func main() {
@@ -50,6 +51,7 @@ func parseConfig() (*config, error) {
 	project := flag.String("project", "", "GCP project to deploy to (required)")
 	region := flag.String("region", "", "Cloud Run region (required)")
 	registryHost := flag.String("registry-host", "", "Container registry host (e.g. gcr.io, asia.gcr.io). If omitted, inferred from --region")
+	lang := flag.String("lang", "", "Project language/build tool to use (e.g. node, go). Defaults to auto-detection")
 	flag.Parse()
 
 	if *image == "" {
@@ -91,6 +93,11 @@ func parseConfig() (*config, error) {
 		host = inferRegistryHost(*region)
 	}
 
+	projectLang, err := determineLanguage(workdir, *lang)
+	if err != nil {
+		return nil, err
+	}
+
 	return &config{
 		image:    *image,
 		beta:     *beta,
@@ -102,6 +109,7 @@ func parseConfig() (*config, error) {
 		project:  *project,
 		region:   *region,
 		registryHost: host,
+		lang:     projectLang,
 	}, nil
 }
 
@@ -132,9 +140,9 @@ func inferRegistryHost(region string) string {
 }
 
 func run(cfg *config) error {
-	logStep(cfg, "Building TS...")
-	if err := runCommandStreaming(cfg.workdir, "pnpm", "run", "build"); err != nil {
-		return fmt.Errorf("build project: %w", err)
+	logStep(cfg, fmt.Sprintf("Building (%s)...", cfg.lang))
+	if err := buildProject(cfg); err != nil {
+		return err
 	}
 
 	imageRepo := fmt.Sprintf("%s/%s/%s", cfg.registryHost, cfg.project, cfg.image)