feat(create): skip secret and generated files during scaffold copy

Author: anav5704

cmd/create.go

@@ -15,6 +15,12 @@ import (
 	"github.com/spf13/cobra"
 )
 
+var skippedTemplateDirs = map[string]struct{}{
+	".git":         {},
+	".hackctl":     {},
+	"node_modules": {},
+}
+
 var (
 	createTemplate string
 )
@@ -56,12 +62,6 @@ var createCmd = &cobra.Command{
 			}
 			completeStep(stepID)
 
-			stepID = addStep("Updating ignore rules")
-			if err := ensureGitignoreEntry(targetPath, ".hackctl/"); err != nil {
-				return errors.New("could not update .gitignore")
-			}
-			completeStep(stepID)
-
 			installTargets, err := dependencyInstallTargets(targetPath)
 			if err != nil {
 				return err
@@ -282,39 +282,6 @@ func installDependencies(target dependencyTarget) error {
 	return nil
 }
 
-func ensureGitignoreEntry(projectPath string, entry string) error {
-	gitignorePath := filepath.Join(projectPath, ".gitignore")
-	body, err := os.ReadFile(gitignorePath)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return os.WriteFile(gitignorePath, []byte(entry+"\n"), 0o644)
-		}
-		return err
-	}
-
-	content := string(body)
-	if hasGitignoreEntry(content, entry) {
-		return nil
-	}
-
-	if !strings.HasSuffix(content, "\n") {
-		content += "\n"
-	}
-	content += entry + "\n"
-
-	return os.WriteFile(gitignorePath, []byte(content), 0o644)
-}
-
-func hasGitignoreEntry(content string, entry string) bool {
-	for _, line := range strings.Split(content, "\n") {
-		if strings.TrimSpace(line) == entry {
-			return true
-		}
-	}
-
-	return false
-}
-
 func copyDirectory(src string, dst string) error {
 	if err := os.MkdirAll(dst, 0o755); err != nil {
 		return err
@@ -334,8 +301,11 @@ func copyDirectory(src string, dst string) error {
 			return nil
 		}
 
-		if d.IsDir() && d.Name() == ".git" {
-			return filepath.SkipDir
+		if shouldSkipTemplateEntry(d) {
+			if d.IsDir() {
+				return filepath.SkipDir
+			}
+			return nil
 		}
 
 		targetPath := filepath.Join(dst, relPath)
@@ -368,3 +338,29 @@ func copyDirectory(src string, dst string) error {
 		return nil
 	})
 }
+
+func shouldSkipTemplateEntry(entry os.DirEntry) bool {
+	name := strings.ToLower(strings.TrimSpace(entry.Name()))
+	if name == "" {
+		return false
+	}
+
+	if entry.IsDir() {
+		_, shouldSkip := skippedTemplateDirs[name]
+		return shouldSkip
+	}
+
+	if name == ".ds_store" || name == "thumbs.db" {
+		return true
+	}
+
+	if strings.HasPrefix(name, ".env") {
+		return !isExampleEnvFile(name)
+	}
+
+	return false
+}
+
+func isExampleEnvFile(name string) bool {
+	return strings.HasSuffix(name, ".env.example") || strings.HasSuffix(name, ".env.sample")
+}

cmd/create_test.go

@@ -9,46 +9,48 @@ import (
 	"github.com/hackctl/hackctl/cli/internal/config"
 )
 
-func TestEnsureGitignoreEntryCreatesFile(t *testing.T) {
-	dir := t.TempDir()
+func TestCopyDirectorySkipsSecretsAndGeneratedFiles(t *testing.T) {
+	sourceDir := t.TempDir()
+	destinationDir := t.TempDir()
 
-	if err := ensureGitignoreEntry(dir, ".hackctl/"); err != nil {
-		t.Fatalf("unexpected error: %v", err)
+	if err := os.WriteFile(filepath.Join(sourceDir, ".env"), []byte("SECRET=1\n"), 0o644); err != nil {
+		t.Fatalf("could not write .env: %v", err)
 	}
-
-	body, err := os.ReadFile(filepath.Join(dir, ".gitignore"))
-	if err != nil {
-		t.Fatalf("could not read .gitignore: %v", err)
+	if err := os.WriteFile(filepath.Join(sourceDir, ".env.example"), []byte("SECRET=\n"), 0o644); err != nil {
+		t.Fatalf("could not write .env.example: %v", err)
 	}
-
-	if string(body) != ".hackctl/\n" {
-		t.Fatalf("unexpected .gitignore content: %q", string(body))
+	if err := os.WriteFile(filepath.Join(sourceDir, ".DS_Store"), []byte("junk"), 0o644); err != nil {
+		t.Fatalf("could not write .DS_Store: %v", err)
+	}
+	if err := os.MkdirAll(filepath.Join(sourceDir, "frontend", "node_modules"), 0o755); err != nil {
+		t.Fatalf("could not create node_modules: %v", err)
+	}
+	if err := os.WriteFile(filepath.Join(sourceDir, "frontend", "node_modules", "pkg.txt"), []byte("x"), 0o644); err != nil {
+		t.Fatalf("could not write node_modules file: %v", err)
+	}
+	if err := os.WriteFile(filepath.Join(sourceDir, "frontend", "app.js"), []byte("console.log('ok')\n"), 0o644); err != nil {
+		t.Fatalf("could not write app file: %v", err)
 	}
-}
-
-func TestEnsureGitignoreEntryAppendsWithoutDuplicates(t *testing.T) {
-	dir := t.TempDir()
-	gitignorePath := filepath.Join(dir, ".gitignore")
 
-	if err := os.WriteFile(gitignorePath, []byte("backend/.env\n"), 0o644); err != nil {
-		t.Fatalf("could not write seed .gitignore: %v", err)
+	if err := copyDirectory(sourceDir, destinationDir); err != nil {
+		t.Fatalf("copyDirectory failed: %v", err)
 	}
 
-	if err := ensureGitignoreEntry(dir, ".hackctl/"); err != nil {
-		t.Fatalf("unexpected error on first write: %v", err)
+	if _, err := os.Stat(filepath.Join(destinationDir, ".env")); err == nil {
+		t.Fatalf("expected .env to be excluded")
 	}
-	if err := ensureGitignoreEntry(dir, ".hackctl/"); err != nil {
-		t.Fatalf("unexpected error on second write: %v", err)
+	if _, err := os.Stat(filepath.Join(destinationDir, ".DS_Store")); err == nil {
+		t.Fatalf("expected .DS_Store to be excluded")
 	}
-
-	body, err := os.ReadFile(gitignorePath)
-	if err != nil {
-		t.Fatalf("could not read .gitignore: %v", err)
+	if _, err := os.Stat(filepath.Join(destinationDir, "frontend", "node_modules")); err == nil {
+		t.Fatalf("expected node_modules to be excluded")
 	}
 
-	expected := "backend/.env\n.hackctl/\n"
-	if string(body) != expected {
-		t.Fatalf("unexpected .gitignore content: %q", string(body))
+	if _, err := os.Stat(filepath.Join(destinationDir, ".env.example")); err != nil {
+		t.Fatalf("expected .env.example to be copied: %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(destinationDir, "frontend", "app.js")); err != nil {
+		t.Fatalf("expected app file to be copied: %v", err)
 	}
 }