chore: modernize workflows, security scanning, and linting configuration (#50)

* build: update Go 1.25, CI workflows, and build tooling

- Upgrade to Go 1.25
- Add benchmark targets to Makefile
- Implement parallel gosec execution
- Lock tool versions for reproducibility
- Add shellcheck directives to scripts
- Update CI workflows with improved caching

* refactor: migrate from golangci-lint to revive

- Replace golangci-lint with revive for linting
- Configure comprehensive revive rules
- Fix all EditorConfig violations
- Add yamllint and yamlfmt support
- Remove deprecated .golangci.yml

* refactor: rename utils to shared and deduplicate code

- Rename utils package to shared
- Add shared constants package
- Deduplicate constants across packages
- Address CodeRabbit review feedback

* fix: resolve SonarQube issues and add safety guards

- Fix all 73 SonarQube OPEN issues
- Add nil guards for resourceMonitor, backpressure, metricsCollector
- Implement io.Closer for headerFileReader
- Propagate errors from processing helpers
- Add metrics and templates packages
- Improve error handling across codebase

* test: improve test infrastructure and coverage

- Add benchmarks for cli, fileproc, metrics
- Improve test coverage for cli, fileproc, config
- Refactor tests with helper functions
- Add shared test constants
- Fix test function naming conventions
- Reduce cognitive complexity in benchmark tests

* docs: update documentation and configuration examples

- Update CLAUDE.md with current project state
- Refresh README with new features
- Add usage and configuration examples
- Add SonarQube project configuration
- Consolidate config.example.yaml

* fix: resolve shellcheck warnings in scripts

- Use ./*.go instead of *.go to prevent dash-prefixed filenames
  from being interpreted as options (SC2035)
- Remove unreachable return statement after exit (SC2317)
- Remove obsolete gibidiutils/ directory reference

* chore(deps): upgrade go dependencies

* chore(lint): megalinter fixes

* fix: improve test coverage and fix file descriptor leaks

- Add defer r.Close() to fix pipe file descriptor leaks in benchmark tests
- Refactor TestProcessorConfigureFileTypes with helper functions and assertions
- Refactor TestProcessorLogFinalStats with output capture and keyword verification
- Use shared constants instead of literal strings (TestFilePNG, FormatMarkdown, etc.)
- Reduce cognitive complexity by extracting helper functions

* fix: align test comments with function names

Remove underscores from test comments to match actual function names:
- benchmark/benchmark_test.go (2 fixes)
- fileproc/filetypes_config_test.go (4 fixes)
- fileproc/filetypes_registry_test.go (6 fixes)
- fileproc/processor_test.go (6 fixes)
- fileproc/resource_monitor_types_test.go (4 fixes)
- fileproc/writer_test.go (3 fixes)

* fix: various test improvements and bug fixes

- Remove duplicate maxCacheSize check in filetypes_registry_test.go
- Shorten long comment in processor_test.go to stay under 120 chars
- Remove flaky time.Sleep in collector_test.go, use >= 0 assertion
- Close pipe reader in benchmark_test.go to fix file descriptor leak
- Use ContinueOnError in flags_test.go to match ResetFlags behavior
- Add nil check for p.ui in processor_workers.go before UpdateProgress
- Fix resource_monitor_validation_test.go by setting hardMemoryLimitBytes directly

* chore(yaml): add missing document start markers

Add --- document start to YAML files to satisfy yamllint:
- .github/workflows/codeql.yml
- .github/workflows/build-test-publish.yml
- .github/workflows/security.yml
- .github/actions/setup/action.yml

* fix: guard nil resourceMonitor and fix test deadlock

- Guard resourceMonitor before CreateFileProcessingContext call
- Add ui.UpdateProgress on emergency stop and path error returns
- Fix potential deadlock in TestProcessFile using wg.Go with defer close

main_test.go

@@ -2,12 +2,15 @@ package main
 
 import (
 	"context"
+	"flag"
 	"fmt"
 	"os"
+	"path/filepath"
+	"strings"
 	"testing"
 	"time"
 
-	"github.com/ivuorinen/gibidify/config"
+	"github.com/ivuorinen/gibidify/cli"
 	"github.com/ivuorinen/gibidify/testutil"
 )
 
@@ -15,22 +18,25 @@ const (
 	testFileCount = 1000
 )
 
-// TestMain configures test-time flags for packages.
-func TestMain(m *testing.M) {
-	// Inform packages that we're running under tests so they can adjust noisy logging.
-	// The config package will suppress the specific info-level message about missing config
-	// while still allowing tests to enable debug/info level logging when needed.
-	config.SetRunningInTest(true)
-	os.Exit(m.Run())
+// resetFlagState resets the global flag state to allow multiple test runs.
+func resetFlagState() {
+	// Reset both the flag.CommandLine and cli global state for clean testing
+	cli.ResetFlags()
+	flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
 }
 
 // TestIntegrationFullCLI simulates a full run of the CLI application using adaptive concurrency.
 func TestIntegrationFullCLI(t *testing.T) {
+	// Suppress logs for cleaner test output
+	restore := testutil.SuppressAllOutput(t)
+	defer restore()
+
+	resetFlagState()
 	srcDir := setupTestFiles(t)
 	outFilePath := setupOutputFile(t)
 	setupCLIArgs(srcDir, outFilePath)
 
-	// Run the application with the test context.
+	// Run the application with a background context.
 	ctx := t.Context()
 	if runErr := run(ctx); runErr != nil {
 		t.Fatalf("Run failed: %v", runErr)
@@ -70,7 +76,7 @@ func setupCLIArgs(srcDir, outFilePath string) {
 // verifyOutput checks that the output file contains expected content.
 func verifyOutput(t *testing.T, outFilePath string) {
 	t.Helper()
-	data, err := os.ReadFile(outFilePath) // #nosec G304 - test file path is controlled
+	data, err := os.ReadFile(outFilePath)
 	if err != nil {
 		t.Fatalf("Failed to read output file: %v", err)
 	}
@@ -80,6 +86,11 @@ func verifyOutput(t *testing.T, outFilePath string) {
 
 // TestIntegrationCancellation verifies that the application correctly cancels processing when the context times out.
 func TestIntegrationCancellation(t *testing.T) {
+	// Suppress logs for cleaner test output
+	restore := testutil.SuppressAllOutput(t)
+	defer restore()
+
+	resetFlagState()
 	// Create a temporary source directory with many files to simulate a long-running process.
 	srcDir := t.TempDir()
 
@@ -101,10 +112,10 @@ func TestIntegrationCancellation(t *testing.T) {
 	// Set up CLI arguments.
 	testutil.SetupCLIArgs(srcDir, outFilePath, "PREFIX", "SUFFIX", 2)
 
-	// Create a context with a very short timeout to force cancellation.
+	// Create a context with a short timeout to force cancellation.
 	ctx, cancel := context.WithTimeout(
 		t.Context(),
-		1*time.Millisecond,
+		5*time.Millisecond,
 	)
 	defer cancel()
 
@@ -114,3 +125,86 @@ func TestIntegrationCancellation(t *testing.T) {
 		t.Error("Expected Run to fail due to cancellation, but it succeeded")
 	}
 }
+
+// BenchmarkRun benchmarks the run() function performance.
+func BenchmarkRun(b *testing.B) {
+	// Save original args and flags
+	oldArgs := os.Args
+	defer func() { os.Args = oldArgs }()
+
+	ctx := context.Background()
+
+	for b.Loop() {
+		// Create fresh directories for each iteration
+		srcDir := b.TempDir()
+		outDir := b.TempDir()
+
+		// Create benchmark files
+		files := map[string]string{
+			"bench1.go":  "package main\n// Benchmark file 1",
+			"bench2.txt": "Benchmark content file 2",
+			"bench3.md":  "# Benchmark markdown file",
+		}
+
+		for name, content := range files {
+			filePath := filepath.Join(srcDir, name)
+			if err := os.WriteFile(filePath, []byte(content), 0o600); err != nil {
+				b.Fatalf("Failed to create benchmark file %s: %v", name, err)
+			}
+		}
+
+		outFilePath := filepath.Join(outDir, "output.md")
+
+		// Reset flags for each iteration
+		cli.ResetFlags()
+		flag.CommandLine = flag.NewFlagSet("bench", flag.ContinueOnError)
+
+		os.Args = []string{"gibidify", "-source", srcDir, "-destination", outFilePath, "-no-ui"}
+
+		if err := run(ctx); err != nil {
+			b.Fatalf("run() failed in benchmark: %v", err)
+		}
+	}
+}
+
+// BenchmarkRunLargeFiles benchmarks the run() function with larger files.
+func BenchmarkRunLargeFiles(b *testing.B) {
+	// Save original args
+	oldArgs := os.Args
+	defer func() { os.Args = oldArgs }()
+
+	largeContent := strings.Repeat("This is a large file for benchmarking purposes.\n", 1000)
+	ctx := context.Background()
+
+	for b.Loop() {
+		// Create fresh directories for each iteration
+		srcDir := b.TempDir()
+		outDir := b.TempDir()
+
+		// Create large benchmark files
+		files := map[string]string{
+			"large1.go":  "package main\n" + largeContent,
+			"large2.txt": largeContent,
+			"large3.md":  "# Large File\n" + largeContent,
+		}
+
+		for name, content := range files {
+			filePath := filepath.Join(srcDir, name)
+			if err := os.WriteFile(filePath, []byte(content), 0o600); err != nil {
+				b.Fatalf("Failed to create large benchmark file %s: %v", name, err)
+			}
+		}
+
+		outFilePath := filepath.Join(outDir, "output.md")
+
+		// Reset flags for each iteration
+		cli.ResetFlags()
+		flag.CommandLine = flag.NewFlagSet("bench", flag.ContinueOnError)
+
+		os.Args = []string{"gibidify", "-source", srcDir, "-destination", outFilePath, "-no-ui"}
+
+		if err := run(ctx); err != nil {
+			b.Fatalf("run() failed in large files benchmark: %v", err)
+		}
+	}
+}