cleanup: go module changes

README.md

@@ -4,18 +4,16 @@ Rollup aggregates the contents of text-based files and webpages into a markdown
 
 ## Features
 
-- File type filtering for targeted content aggregation
+- File type filtering
-- Ignore patterns for excluding specific files or directories
+- Ignore patterns for excluding files
-- Support for code-generated file detection and exclusion
+- Support for code-generated file detection
-- Advanced web scraping functionality with depth control
+- Advanced web scraping functionality
-- Verbose logging option for detailed operation insights
+- Verbose logging option for detailed output
-- Exclusionary CSS selectors for precise web content extraction
+- Exclusionary CSS selectors for web scraping
-- Support for multiple URLs in web scraping operations
+- Support for multiple URLs in web scraping
 - Configurable output format for web scraping (single file or separate files)
-- Flexible configuration file support (YAML)
+- Configuration file support (YAML)
-- Automatic generation of default configuration file
+- Generation of default configuration file
-- Custom output file naming
-- Rate limiting for web scraping to respect server resources
 
 ## Installation
 
@@ -66,36 +64,24 @@ Rollup can be configured using a YAML file. By default, it looks for `rollup.yml
 Example `rollup.yml`:
 
 ```yaml
-file_extensions:
+file_types:
   - go
   - md
-ignore_paths:
+ignore:
   - node_modules/**
   - vendor/**
   - .git/**
-code_generated_paths:
+code_generated:
   - **/generated/**
-sites:
+scrape:
-  - base_url: https://example.com
+  urls:
-    css_locator: .content
+    - url: https://example.com
-    exclude_selectors:
+      css_locator: .content
-      - .ads
+      exclude_selectors:
-      - .navigation
+        - .ads
-    max_depth: 2
+        - .navigation
-    allowed_paths:
+      output_alias: example
-      - /blog
+  output_type: single
-      - /docs
-    exclude_paths:
-      - /admin
-    output_alias: example
-    path_overrides:
-      - path: /special-page
-        css_locator: .special-content
-        exclude_selectors:
-          - .special-ads
-output_type: single
-requests_per_second: 1.0
-burst_limit: 3
 ```
 
 ## Examples
@@ -125,22 +111,10 @@ burst_limit: 3
    ```
 
 5. Web scraping with separate output files:
-
    ```bash
    rollup web --urls=https://example.com,https://another-example.com --output=separate
    ```
 
-6. Rollup files with specific types and ignore patterns:
-
-   ```bash
-   rollup files --types=go,md --ignore=vendor/**,*_test.go
-   ```
-
-7. Web scraping with depth and CSS selector:
-   ```bash
-   rollup web --urls=https://example.com --depth=2 --css=.main-content
-   ```
-
 ## Contributing
 
 Contributions are welcome! Please feel free to submit a Pull Request.

cmd/files.go

@@ -8,11 +8,8 @@ import (
 	"time"
 
 	"github.com/spf13/cobra"
-	"github.com/tnypxl/rollup/internal/config"
 )
 
-var cfg *config.Config
-
 var (
 	path            string
 	fileTypes       string
@@ -27,7 +24,7 @@ var filesCmd = &cobra.Command{
 in a given project, current path or a custom path, to a single timestamped markdown file
 whose name is <project-directory-name>-rollup-<timestamp>.md.`,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		return runRollup(cfg)
+		return runRollup()
 	},
 }
 
@@ -90,38 +87,30 @@ func isIgnored(filePath string, patterns []string) bool {
 				return true
 			}
 		} else {
-			// Check if the pattern matches the full path or any part of it
+			matched, err := filepath.Match(pattern, filepath.Base(filePath))
-			if matched, _ := filepath.Match(pattern, filePath); matched {
+			if err == nil && matched {
 				return true
 			}
-			pathParts := strings.Split(filePath, string(os.PathSeparator))
-			for i := range pathParts {
-				partialPath := filepath.Join(pathParts[:i+1]...)
-				if matched, _ := filepath.Match(pattern, partialPath); matched {
-					return true
-				}
-			}
 		}
 	}
 	return false
 }
 
-func runRollup(cfg *config.Config) error {
+func runRollup() error {
 	// Use config if available, otherwise use command-line flags
-	var types []string
+	var types, codeGenList, ignoreList []string
-	var codeGenList, ignoreList []string
+	if cfg != nil && len(cfg.FileTypes) > 0 {
-	if cfg != nil && len(cfg.FileExtensions) > 0 {
+		types = cfg.FileTypes
-		types = cfg.FileExtensions
 	} else {
 		types = strings.Split(fileTypes, ",")
 	}
-	if cfg != nil && len(cfg.CodeGeneratedPaths) > 0 {
+	if cfg != nil && len(cfg.CodeGenerated) > 0 {
-		codeGenList = cfg.CodeGeneratedPaths
+		codeGenList = cfg.CodeGenerated
 	} else {
 		codeGenList = strings.Split(codeGenPatterns, ",")
 	}
-	if cfg != nil && len(cfg.IgnorePaths) > 0 {
+	if cfg != nil && cfg.Ignore != nil && len(cfg.Ignore) > 0 {
-		ignoreList = cfg.IgnorePaths
+		ignoreList = cfg.Ignore
 	} else {
 		ignoreList = strings.Split(ignorePatterns, ",")
 	}
@@ -146,11 +135,6 @@ func runRollup(cfg *config.Config) error {
 	}
 	defer outputFile.Close()
 
-	startTime := time.Now()
-	showProgress := false
-	progressTicker := time.NewTicker(500 * time.Millisecond)
-	defer progressTicker.Stop()
-
 	// Walk through the directory
 	err = filepath.Walk(absPath, func(path string, info os.FileInfo, err error) error {
 		if err != nil {
@@ -166,25 +150,16 @@ func runRollup(cfg *config.Config) error {
 
 		// Check if the file should be ignored
 		if isIgnored(relPath, ignoreList) {
-			if verbose {
-				fmt.Printf("Ignoring file: %s\n", relPath)
-			}
 			return nil
 		}
 
 		ext := filepath.Ext(path)
 		for _, t := range types {
 			if ext == "."+t {
-				// Verbose logging for processed file
-				if verbose {
-					size := humanReadableSize(info.Size())
-					fmt.Printf("Processing file: %s (%s)\n", relPath, size)
-				}
-
 				// Read file contents
 				content, err := os.ReadFile(path)
 				if err != nil {
-					fmt.Printf("Error reading file %s: %v\n", path, err)
+					fmt.Printf("Error reading file %s: %v", path, err)
 					return nil
 				}
 
@@ -200,43 +175,12 @@ func runRollup(cfg *config.Config) error {
 				break
 			}
 		}
-
-		if !showProgress && time.Since(startTime) > 5*time.Second {
-			showProgress = true
-			fmt.Print("This is taking a while (hold tight) ")
-		}
-
-		select {
-		case <-progressTicker.C:
-			if showProgress {
-				fmt.Print(".")
-			}
-		default:
-		}
-
 		return nil
 	})
 	if err != nil {
 		return fmt.Errorf("error walking through directory: %v", err)
 	}
 
-	if showProgress {
+	fmt.Printf("Rollup complete. Output file: %s", outputFileName)
-		fmt.Println() // Print a newline after the progress dots
-	}
-
-	fmt.Printf("Rollup complete. Output file: %s\n", outputFileName)
 	return nil
 }
-
-func humanReadableSize(size int64) string {
-	const unit = 1024
-	if size < unit {
-		return fmt.Sprintf("%d B", size)
-	}
-	div, exp := int64(unit), 0
-	for n := size / unit; n >= unit; n /= unit {
-		div *= unit
-		exp++
-	}
-	return fmt.Sprintf("%.1f %cB", float64(size)/float64(div), "KMGTPE"[exp])
-}

cmd/files_test.go

@@ -21,9 +21,6 @@ func TestMatchGlob(t *testing.T) {
 		{"**/*.go", "dir/subdir/file.go", true},
 		{"dir/*.go", "dir/file.go", true},
 		{"dir/*.go", "otherdir/file.go", false},
-		{"**/test_*.go", "internal/test_helper.go", true},
-		{"docs/**/*.md", "docs/api/endpoints.md", true},
-		{"docs/**/*.md", "src/docs/readme.md", false},
 	}
 
 	for _, test := range tests {
@@ -35,7 +32,7 @@ func TestMatchGlob(t *testing.T) {
 }
 
 func TestIsCodeGenerated(t *testing.T) {
-	patterns := []string{"generated_*.go", "**/auto_*.go", "**/*_gen.go"}
+	patterns := []string{"generated_*.go", "**/auto_*.go"}
 	tests := []struct {
 		path     string
 		expected bool
@@ -44,8 +41,6 @@ func TestIsCodeGenerated(t *testing.T) {
 		{"normal_file.go", false},
 		{"subdir/auto_file.go", true},
 		{"subdir/normal_file.go", false},
-		{"pkg/models_gen.go", true},
-		{"pkg/handler.go", false},
 	}
 
 	for _, test := range tests {
@@ -57,7 +52,7 @@ func TestIsCodeGenerated(t *testing.T) {
 }
 
 func TestIsIgnored(t *testing.T) {
-	patterns := []string{"*.tmp", "**/*.log", ".git/**", "vendor/**"}
+	patterns := []string{"*.tmp", "**/*.log"}
 	tests := []struct {
 		path     string
 		expected bool
@@ -66,10 +61,6 @@ func TestIsIgnored(t *testing.T) {
 		{"file.go", false},
 		{"subdir/file.log", true},
 		{"subdir/file.txt", false},
-		{".git/config", true},
-		{"src/.git/config", false},
-		{"vendor/package/file.go", true},
-		{"internal/vendor/file.go", false},
 	}
 
 	for _, test := range tests {
@@ -90,56 +81,49 @@ func TestRunRollup(t *testing.T) {
 
 	// Create some test files
 	files := map[string]string{
-		"file1.go":             "package main\n\nfunc main() {}\n",
+		"file1.go":          "package main\n\nfunc main() {}\n",
-		"file2.txt":            "This is a text file.\n",
+		"file2.txt":         "This is a text file.\n",
-		"subdir/file3.go":      "package subdir\n\nfunc Func() {}\n",
+		"subdir/file3.go":   "package subdir\n\nfunc Func() {}\n",
-		"subdir/file4.json":    "{\"key\": \"value\"}\n",
+		"subdir/file4.json": "{\"key\": \"value\"}\n",
-		"generated_model.go":   "// Code generated DO NOT EDIT.\n\npackage model\n",
-		"docs/api/readme.md":   "# API Documentation\n",
-		".git/config":          "[core]\n\trepositoryformatversion = 0\n",
-		"vendor/lib/helper.go": "package lib\n\nfunc Helper() {}\n",
 	}
 
 	for name, content := range files {
 		path := filepath.Join(tempDir, name)
-		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		err := os.MkdirAll(filepath.Dir(path), 0755)
+		if err != nil {
 			t.Fatalf("Failed to create directory: %v", err)
 		}
-		if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+		err = os.WriteFile(path, []byte(content), 0644)
+		if err != nil {
 			t.Fatalf("Failed to write file: %v", err)
 		}
 	}
 
 	// Set up test configuration
 	cfg = &config.Config{
-		FileExtensions:     []string{"go", "txt", "md"},
+		FileTypes:     []string{"go", "txt"},
-		IgnorePaths:        []string{"*.json", ".git/**", "vendor/**"},
+		Ignore:        []string{"*.json"},
-		CodeGeneratedPaths: []string{"generated_*.go"},
+		CodeGenerated: []string{},
 	}
-
+	path = tempDir
-	// Change working directory to the temp directory
-	originalWd, _ := os.Getwd()
-	os.Chdir(tempDir)
-	defer os.Chdir(originalWd)
 
 	// Run the rollup
-	if err := runRollup(cfg); err != nil {
+	err = runRollup()
+	if err != nil {
 		t.Fatalf("runRollup() failed: %v", err)
 	}
 
 	// Check if the output file was created
-	outputFiles, err := filepath.Glob("*.rollup.md")
+	outputFiles, err := filepath.Glob(filepath.Join(tempDir, "*.rollup.md"))
 	if err != nil {
-		t.Fatalf("Error globbing for output file: %v", err)
+		t.Fatalf("Failed to glob output files: %v", err)
 	}
-	if len(outputFiles) == 0 {
+	if len(outputFiles) != 1 {
-		allFiles, _ := filepath.Glob("*")
+		t.Fatalf("Expected 1 output file, got %d", len(outputFiles))
-		t.Fatalf("No rollup.md file found. Files in directory: %v", allFiles)
 	}
-	outputFile := outputFiles[0]
 
 	// Read the content of the output file
-	content, err := os.ReadFile(outputFile)
+	content, err := os.ReadFile(outputFiles[0])
 	if err != nil {
 		t.Fatalf("Failed to read output file: %v", err)
 	}
@@ -149,8 +133,6 @@ func TestRunRollup(t *testing.T) {
 		"# File: file1.go",
 		"# File: file2.txt",
 		"# File: subdir/file3.go",
-		"# File: docs/api/readme.md",
-		"# File: generated_model.go (Code-generated, Read-only)",
 	}
 	for _, expected := range expectedContent {
 		if !strings.Contains(string(content), expected) {
@@ -158,15 +140,8 @@ func TestRunRollup(t *testing.T) {
 		}
 	}
 
-	// Check if the ignored files are not included
+	// Check if the ignored file is not included
-	ignoredContent := []string{
+	if strings.Contains(string(content), "file4.json") {
-		"file4.json",
+		t.Errorf("Output file contains ignored file: file4.json")
-		".git/config",
-		"vendor/lib/helper.go",
-	}
-	for _, ignored := range ignoredContent {
-		if strings.Contains(string(content), ignored) {
-			t.Errorf("Output file contains ignored file: %s", ignored)
-		}
 	}
 }

cmd/generate.go

@@ -38,23 +38,23 @@ func runGenerate(cmd *cobra.Command, args []string) error {
 	}
 
 	cfg := config.Config{
-		FileExtensions: make([]string, 0, len(fileTypes)),
+		FileTypes: make([]string, 0, len(fileTypes)),
-		IgnorePaths:    []string{"node_modules/**", "vendor/**", ".git/**"},
+		Ignore:    []string{"node_modules/**", "vendor/**", ".git/**"},
 	}
 
 	for ext := range fileTypes {
-		cfg.FileExtensions = append(cfg.FileExtensions, ext)
+		cfg.FileTypes = append(cfg.FileTypes, ext)
 	}
 
 	// Sort file types for consistency
-	sort.Strings(cfg.FileExtensions)
+	sort.Strings(cfg.FileTypes)
 
 	yamlData, err := yaml.Marshal(&cfg)
 	if err != nil {
 		return fmt.Errorf("error marshaling config: %v", err)
 	}
 
-	outputPath := "rollup.yml"
+	outputPath := config.DefaultConfigPath()
 	err = os.WriteFile(outputPath, yamlData, 0644)
 	if err != nil {
 		return fmt.Errorf("error writing config file: %v", err)

cmd/root.go

@@ -7,6 +7,7 @@ import (
 
 var (
 	configFile string
+	cfg        *config.Config
 	verbose    bool
 )
 
@@ -18,10 +19,10 @@ Use subcommands to perform specific operations.`,
 }
 
 func Execute(conf *config.Config) error {
-	if conf == nil {
+	cfg = conf
-		conf = &config.Config{} // Use an empty config if none is provided
+	if cfg == nil {
+		cfg = &config.Config{} // Use an empty config if none is provided
 	}
-	cfg = conf // Set the cfg variable in cmd/files.go
 	return rootCmd.Execute()
 }
 

cmd/web.go

@@ -2,7 +2,7 @@ package cmd
 
 import (
 	"fmt"
-	"io"
+	"io/ioutil"
 	"log"
 	"net/url"
 	"os"
@@ -18,6 +18,7 @@ import (
 var (
 	urls             []string
 	outputType       string
+	depth            int
 	includeSelector  string
 	excludeSelectors []string
 )
@@ -33,119 +34,104 @@ var webCmd = &cobra.Command{
 
 func init() {
 	webCmd.Flags().StringSliceVarP(&urls, "urls", "u", []string{}, "URLs of the webpages to scrape (comma-separated)")
-	webCmd.Flags().StringVarP(&outputType, "output", "o", "", "Output type: 'single' for one file, 'separate' for multiple files")
+	webCmd.Flags().StringVarP(&outputType, "output", "o", "single", "Output type: 'single' for one file, 'separate' for multiple files")
+	webCmd.Flags().IntVarP(&depth, "depth", "d", 0, "Depth of link traversal (default: 0, only scrape the given URLs)")
 	webCmd.Flags().StringVar(&includeSelector, "css", "", "CSS selector to extract specific content")
 	webCmd.Flags().StringSliceVar(&excludeSelectors, "exclude", []string{}, "CSS selectors to exclude from the extracted content (comma-separated)")
 }
 
 func runWeb(cmd *cobra.Command, args []string) error {
-	scraper.SetupLogger(verbose)
+    scraper.SetupLogger(verbose)
-	logger := log.New(os.Stdout, "WEB: ", log.LstdFlags)
+    logger := log.New(os.Stdout, "WEB: ", log.LstdFlags)
-	if !verbose {
+    if !verbose {
-		logger.SetOutput(io.Discard)
+        logger.SetOutput(ioutil.Discard)
-	}
+    }
-	logger.Printf("Starting web scraping process with verbose mode: %v", verbose)
+    logger.Printf("Starting web scraping process with verbose mode: %v", verbose)
-	scraperConfig.Verbose = verbose
+    scraperConfig.Verbose = verbose
 
-	var siteConfigs []scraper.SiteConfig
+    var siteConfigs []scraper.SiteConfig
-	if len(cfg.Sites) > 0 {
+    if len(cfg.Scrape.Sites) > 0 {
-		logger.Printf("Using configuration from rollup.yml for %d sites", len(cfg.Sites))
+        logger.Printf("Using configuration from rollup.yml for %d sites", len(cfg.Scrape.Sites))
-		siteConfigs = make([]scraper.SiteConfig, len(cfg.Sites))
+        siteConfigs = make([]scraper.SiteConfig, len(cfg.Scrape.Sites))
-		for i, site := range cfg.Sites {
+        for i, site := range cfg.Scrape.Sites {
-			siteConfigs[i] = scraper.SiteConfig{
+            siteConfigs[i] = scraper.SiteConfig{
-				BaseURL:          site.BaseURL,
+                BaseURL:          site.BaseURL,
-				CSSLocator:       site.CSSLocator,
+                CSSLocator:       site.CSSLocator,
-				ExcludeSelectors: site.ExcludeSelectors,
+                ExcludeSelectors: site.ExcludeSelectors,
-				AllowedPaths:     site.AllowedPaths,
+                MaxDepth:         site.MaxDepth,
-				ExcludePaths:     site.ExcludePaths,
+                AllowedPaths:     site.AllowedPaths,
-				PathOverrides:    convertPathOverrides(site.PathOverrides),
+                ExcludePaths:     site.ExcludePaths,
-			}
+                OutputAlias:      site.OutputAlias,
-			logger.Printf("Site %d configuration: BaseURL=%s, CSSLocator=%s, AllowedPaths=%v",
+                PathOverrides:    convertPathOverrides(site.PathOverrides),
-				i+1, site.BaseURL, site.CSSLocator, site.AllowedPaths)
+            }
-		}
+            logger.Printf("Site %d configuration: BaseURL=%s, CSSLocator=%s, MaxDepth=%d, AllowedPaths=%v", 
-	} else {
+                       i+1, site.BaseURL, site.CSSLocator, site.MaxDepth, site.AllowedPaths)
-		logger.Printf("No sites defined in rollup.yml, falling back to URL-based configuration")
+        }
-		siteConfigs = make([]scraper.SiteConfig, len(urls))
+    } else {
-		for i, u := range urls {
+        logger.Printf("No sites defined in rollup.yml, falling back to URL-based configuration")
-			siteConfigs[i] = scraper.SiteConfig{
+        siteConfigs = make([]scraper.SiteConfig, len(urls))
-				BaseURL:          u,
+        for i, u := range urls {
-				CSSLocator:       includeSelector,
+            siteConfigs[i] = scraper.SiteConfig{
-				ExcludeSelectors: excludeSelectors,
+                BaseURL:          u,
-			}
+                CSSLocator:       includeSelector,
-			logger.Printf("URL %d configuration: BaseURL=%s, CSSLocator=%s",
+                ExcludeSelectors: excludeSelectors,
-				i+1, u, includeSelector)
+                MaxDepth:         depth,
-		}
+            }
-	}
+            logger.Printf("URL %d configuration: BaseURL=%s, CSSLocator=%s, MaxDepth=%d", 
+                       i+1, u, includeSelector, depth)
+        }
+    }
 
-	if len(siteConfigs) == 0 {
+    if len(siteConfigs) == 0 {
-		logger.Println("Error: No sites or URLs provided")
+        logger.Println("Error: No sites or URLs provided")
-		return fmt.Errorf("no sites or URLs provided. Use --urls flag with comma-separated URLs or set 'scrape.sites' in the rollup.yml file")
+        return fmt.Errorf("no sites or URLs provided. Use --urls flag with comma-separated URLs or set 'scrape.sites' in the rollup.yml file")
-	}
+    }
 
-	// Set default values for rate limiting
+    // Set default values for rate limiting
-	defaultRequestsPerSecond := 1.0
+    defaultRequestsPerSecond := 1.0
-	defaultBurstLimit := 3
+    defaultBurstLimit := 3
 
-	// Use default values if not set in the configuration
+    // Use default values if not set in the configuration
-	requestsPerSecond := defaultRequestsPerSecond
+    requestsPerSecond := cfg.Scrape.RequestsPerSecond
-	if cfg.RequestsPerSecond != nil {
+    if requestsPerSecond == 0 {
-		requestsPerSecond = *cfg.RequestsPerSecond
+        requestsPerSecond = defaultRequestsPerSecond
-	}
+    }
-	burstLimit := defaultBurstLimit
+    burstLimit := cfg.Scrape.BurstLimit
-	if cfg.BurstLimit != nil {
+    if burstLimit == 0 {
-		burstLimit = *cfg.BurstLimit
+        burstLimit = defaultBurstLimit
-	}
+    }
 
-	scraperConfig := scraper.Config{
+    scraperConfig := scraper.Config{
-		Sites:      siteConfigs,
+        Sites:      siteConfigs,
-		OutputType: outputType,
+        OutputType: outputType,
-		Verbose:    verbose,
+        Verbose:    verbose,
-		Scrape: scraper.ScrapeConfig{
+        Scrape: scraper.ScrapeConfig{
-			RequestsPerSecond: requestsPerSecond,
+            RequestsPerSecond: requestsPerSecond,
-			BurstLimit:        burstLimit,
+            BurstLimit:        burstLimit,
-		},
+        },
-	}
+    }
-	logger.Printf("Scraper configuration: OutputType=%s, RequestsPerSecond=%f, BurstLimit=%d",
+    logger.Printf("Scraper configuration: OutputType=%s, RequestsPerSecond=%f, BurstLimit=%d", 
-		outputType, requestsPerSecond, burstLimit)
+               outputType, requestsPerSecond, burstLimit)
 
-	logger.Println("Starting scraping process")
+    logger.Println("Starting scraping process")
-	startTime := time.Now()
+    scrapedContent, err := scraper.ScrapeSites(scraperConfig)
-	progressTicker := time.NewTicker(time.Second)
+    if err != nil {
-	defer progressTicker.Stop()
+        logger.Printf("Error occurred during scraping: %v", err)
+        return fmt.Errorf("error scraping content: %v", err)
+    }
+    logger.Printf("Scraping completed. Total content scraped: %d", len(scrapedContent))
 
-	done := make(chan bool)
+    if outputType == "single" {
-	messagePrinted := false
+        logger.Println("Writing content to a single file")
-	go func() {
+        return writeSingleFile(scrapedContent)
-		for {
+    } else {
-			select {
+        logger.Println("Writing content to multiple files")
-			case <-progressTicker.C:
+        return writeMultipleFiles(scrapedContent)
-				if time.Since(startTime) > 5*time.Second && !messagePrinted {
+    }
-					fmt.Print("This is taking a while (hold tight) ")
-					messagePrinted = true
-				} else if messagePrinted {
-					fmt.Print(".")
-				}
-			case <-done:
-				return
-			}
-		}
-	}()
-
-	err := scraper.ScrapeSites(scraperConfig)
-	done <- true
-	fmt.Println() // New line after progress indicator
-
-	if err != nil {
-		logger.Printf("Error occurred during scraping: %v", err)
-		return fmt.Errorf("error scraping content: %v", err)
-	}
-	logger.Println("Scraping completed")
-
-	return nil
 }
 
 func writeSingleFile(content map[string]string) error {
-	outputFile := generateDefaultFilename()
+	outputFile := generateDefaultFilename(urls)
 	file, err := os.Create(outputFile)
 	if err != nil {
 		return fmt.Errorf("error creating output file: %v", err)
@@ -153,7 +139,7 @@ func writeSingleFile(content map[string]string) error {
 	defer file.Close()
 
 	for url, c := range content {
-		_, err = fmt.Fprintf(file, "# ::: Content from %s\n\n%s\n\n---\n\n", url, c)
+		_, err = file.WriteString(fmt.Sprintf("# Content from %s\n\n%s\n\n---\n\n", url, c))
 		if err != nil {
 			return fmt.Errorf("error writing content to file: %v", err)
 		}
@@ -175,7 +161,7 @@ func writeMultipleFiles(content map[string]string) error {
 			return fmt.Errorf("error creating output file %s: %v", filename, err)
 		}
 
-		_, err = file.WriteString(fmt.Sprintf("# ::: Content from %s\n\n%s\n", url, c))
+		_, err = file.WriteString(fmt.Sprintf("# Content from %s\n\n%s\n", url, c))
 		if err != nil {
 			file.Close()
 			return fmt.Errorf("error writing content to file %s: %v", filename, err)
@@ -188,23 +174,49 @@ func writeMultipleFiles(content map[string]string) error {
 	return nil
 }
 
-func generateDefaultFilename() string {
+func generateDefaultFilename(urls []string) string {
 	timestamp := time.Now().Format("20060102-150405")
 	return fmt.Sprintf("web-%s.rollup.md", timestamp)
 }
 
-func scrapeURL(urlStr string) (string, error) {
+func scrapeRecursively(urlStr string, depth int) (string, error) {
+	visited := make(map[string]bool)
+	return scrapeURL(urlStr, depth, visited)
+}
+
+func scrapeURL(urlStr string, depth int, visited map[string]bool) (string, error) {
+	if depth < 0 || visited[urlStr] {
+		return "", nil
+	}
+
+	visited[urlStr] = true
+
 	content, err := testExtractAndConvertContent(urlStr)
 	if err != nil {
 		return "", err
 	}
 
+	if depth > 0 {
+		links, err := testExtractLinks(urlStr)
+		if err != nil {
+			return content, fmt.Errorf("error extracting links: %v", err)
+		}
+
+		for _, link := range links {
+			subContent, err := scrapeURL(link, depth-1, visited)
+			if err != nil {
+				fmt.Printf("Warning: Error scraping %s: %v\n", link, err)
+				continue
+			}
+			content += "\n\n---\n\n" + subContent
+		}
+	}
+
 	return content, nil
 }
 
-var (
+var testExtractAndConvertContent = extractAndConvertContent
-	testExtractAndConvertContent = extractAndConvertContent
+var testExtractLinks = scraper.ExtractLinks
-)
 
 func extractAndConvertContent(urlStr string) (string, error) {
 	content, err := scraper.FetchWebpageContent(urlStr)
@@ -228,7 +240,7 @@ func extractAndConvertContent(urlStr string) (string, error) {
 	if err != nil {
 		return "", fmt.Errorf("error parsing URL: %v", err)
 	}
-	header := fmt.Sprintf("# ::: Content from %s\n\n", parsedURL.String())
+	header := fmt.Sprintf("# Content from %s\n\n", parsedURL.String())
 
 	return header + markdown + "\n\n", nil
 }
@@ -249,11 +261,11 @@ func getFilenameFromContent(content, urlStr string) (string, error) {
 	if err != nil {
 		return "", fmt.Errorf("invalid URL: %v", err)
 	}
-
+	
 	if parsedURL.Host == "" {
 		return "", fmt.Errorf("invalid URL: missing host")
 	}
-
+	
 	filename := parsedURL.Host
 	if parsedURL.Path != "" && parsedURL.Path != "/" {
 		filename += strings.TrimSuffix(parsedURL.Path, "/")

cmd/web_test.go

@@ -2,7 +2,7 @@ package cmd
 
 import (
 	"testing"
-
+	"strings"
 	"github.com/tnypxl/rollup/internal/config"
 )
 
@@ -67,9 +67,9 @@ func TestSanitizeFilename(t *testing.T) {
 
 func TestGetFilenameFromContent(t *testing.T) {
 	tests := []struct {
-		content   string
+		content  string
-		url       string
+		url      string
-		expected  string
+		expected string
 		expectErr bool
 	}{
 		{"<title>Test Page</title>", "http://example.com", "Test_Page.rollup.md", false},
@@ -102,3 +102,53 @@ func TestGetFilenameFromContent(t *testing.T) {
 func mockExtractAndConvertContent(urlStr string) (string, error) {
 	return "Mocked content for " + urlStr, nil
 }
+
+func mockExtractLinks(urlStr string) ([]string, error) {
+	return []string{"http://example.com/link1", "http://example.com/link2"}, nil
+}
+
+func TestScrapeURL(t *testing.T) {
+	// Store the original functions
+	originalExtractAndConvertContent := testExtractAndConvertContent
+	originalExtractLinks := testExtractLinks
+
+	// Define mock functions
+	testExtractAndConvertContent = func(urlStr string) (string, error) {
+		return "Mocked content for " + urlStr, nil
+	}
+	testExtractLinks = func(urlStr string) ([]string, error) {
+		return []string{"http://example.com/link1", "http://example.com/link2"}, nil
+	}
+
+	// Defer the restoration of original functions
+	defer func() {
+		testExtractAndConvertContent = originalExtractAndConvertContent
+		testExtractLinks = originalExtractLinks
+	}()
+
+	tests := []struct {
+		url           string
+		depth         int
+		expectedCalls int
+	}{
+		{"http://example.com", 0, 1},
+		{"http://example.com", 1, 3},
+		{"http://example.com", 2, 3}, // Same as depth 1 because our mock only returns 2 links
+	}
+
+	for _, test := range tests {
+		visited := make(map[string]bool)
+		content, err := scrapeURL(test.url, test.depth, visited)
+		if err != nil {
+			t.Errorf("scrapeURL(%q, %d) returned error: %v", test.url, test.depth, err)
+			continue
+		}
+		if len(visited) != test.expectedCalls {
+			t.Errorf("scrapeURL(%q, %d) made %d calls, expected %d", test.url, test.depth, len(visited), test.expectedCalls)
+		}
+		expectedContent := "Mocked content for " + test.url
+		if !strings.Contains(content, expectedContent) {
+			t.Errorf("scrapeURL(%q, %d) content doesn't contain %q", test.url, test.depth, expectedContent)
+		}
+	}
+}

docs/CHANGELOG.md

@@ -1,21 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [0.0.3] - 2024-09-22
-
-### Added
-- Implemented web scraping functionality using Playwright
-- Added support for CSS selectors to extract specific content
-- Introduced rate limiting for web requests
-- Created configuration options for scraping settings
-
-### Changed
-- Improved error handling and logging throughout the application
-- Enhanced URL parsing and validation
-
-### Fixed
-- Resolved issues with concurrent scraping operations

internal/config/config.go

@@ -7,64 +7,35 @@ import (
 	"gopkg.in/yaml.v2"
 )
 
-// Config represents the configuration for the rollup tool
 type Config struct {
-	// FileExtensions is a list of file extensions to include in the rollup
+	FileTypes     []string     `yaml:"file_types"`
-	FileExtensions []string `yaml:"file_extensions"`
+	Ignore        []string     `yaml:"ignore"`
-
+	CodeGenerated []string     `yaml:"code_generated"`
-	// IgnorePaths is a list of glob patterns for paths to ignore
+	Scrape        ScrapeConfig `yaml:"scrape"`
-	IgnorePaths []string `yaml:"ignore_paths"`
+}
-
+
-	// CodeGeneratedPaths is a list of glob patterns for code-generated files
+type ScrapeConfig struct {
-	CodeGeneratedPaths []string `yaml:"code_generated_paths"`
+    Sites             []SiteConfig `yaml:"sites"`
-
+    OutputType        string       `yaml:"output_type"`
-	// Sites is a list of site configurations for web scraping
+    RequestsPerSecond float64      `yaml:"requests_per_second"`
-	Sites []SiteConfig `yaml:"sites"`
+    BurstLimit        int          `yaml:"burst_limit"`
-
-	// OutputType specifies how the output should be generated
-	OutputType string `yaml:"output_type"`
-
-	// RequestsPerSecond limits the rate of web requests
-	RequestsPerSecond *float64 `yaml:"requests_per_second,omitempty"`
-
-	// BurstLimit sets the maximum burst size for rate limiting
-	BurstLimit *int `yaml:"burst_limit,omitempty"`
 }
 
-// SiteConfig contains configuration for scraping a single site
 type SiteConfig struct {
-	// BaseURL is the starting point for scraping this site
+    BaseURL          string            `yaml:"base_url"`
-	BaseURL string `yaml:"base_url"`
+    CSSLocator       string            `yaml:"css_locator"`
-
+    ExcludeSelectors []string          `yaml:"exclude_selectors"`
-	// CSSLocator is used to extract specific content
+    MaxDepth         int               `yaml:"max_depth"`
-	CSSLocator string `yaml:"css_locator"`
+    AllowedPaths     []string          `yaml:"allowed_paths"`
-
+    ExcludePaths     []string          `yaml:"exclude_paths"`
-	// ExcludeSelectors lists CSS selectors for content to exclude
+    OutputAlias      string            `yaml:"output_alias"`
-	ExcludeSelectors []string `yaml:"exclude_selectors"`
+    PathOverrides    []PathOverride    `yaml:"path_overrides"`
-
-	// AllowedPaths lists paths that are allowed to be scraped
-	AllowedPaths []string `yaml:"allowed_paths"`
-
-	// ExcludePaths lists paths that should not be scraped
-	ExcludePaths []string `yaml:"exclude_paths"`
-
-	// FileNamePrefix provides the base name for output files
-	FileNamePrefix string `yaml:"file_name_prefix"`
-
-	// PathOverrides allows for path-specific configurations
-	PathOverrides []PathOverride `yaml:"path_overrides"`
 }
 
-// PathOverride allows for path-specific configurations
 type PathOverride struct {
-	// Path is the URL path this override applies to
+    Path             string   `yaml:"path"`
-	Path string `yaml:"path"`
+    CSSLocator       string   `yaml:"css_locator"`
-
+    ExcludeSelectors []string `yaml:"exclude_selectors"`
-	// CSSLocator overrides the site-wide CSS locator for this path
-	CSSLocator string `yaml:"css_locator"`
-
-	// ExcludeSelectors overrides the site-wide exclude selectors for this path
-	ExcludeSelectors []string `yaml:"exclude_selectors"`
 }
 
 func Load(configPath string) (*Config, error) {
@@ -79,28 +50,15 @@ func Load(configPath string) (*Config, error) {
 		return nil, fmt.Errorf("error parsing config file: %v", err)
 	}
 
-	if err := config.Validate(); err != nil {
-		return nil, fmt.Errorf("invalid configuration: %v", err)
-	}
-
 	return &config, nil
 }
 
-// Validate checks the configuration for any invalid values
+func DefaultConfigPath() string {
-func (c *Config) Validate() error {
+	return "rollup.yml"
-	if c.RequestsPerSecond != nil && *c.RequestsPerSecond <= 0 {
-		return fmt.Errorf("requests_per_second must be positive")
-	}
-
-	if c.BurstLimit != nil && *c.BurstLimit <= 0 {
-		return fmt.Errorf("burst_limit must be positive")
-	}
-
-	for _, site := range c.Sites {
-		if site.BaseURL == "" {
-			return fmt.Errorf("base_url must be specified for each site")
-		}
-	}
-
-	return nil
 }
+
+func FileExists(filename string) bool {
+	_, err := os.Stat(filename)
+	return err == nil
+}
+

internal/config/config_test.go

@@ -9,33 +9,34 @@ import (
 func TestLoad(t *testing.T) {
 	// Create a temporary config file
 	content := []byte(`
-file_extensions:
+file_types:
-  - .go
+  - go
-  - .md
+  - md
-ignore_paths:
+ignore:
   - "*.tmp"
   - "**/*.log"
-code_generated_paths:
+code_generated:
   - "generated_*.go"
-sites:
+scrape:
-  - base_url: "https://example.com"
+  sites:
-    css_locator: "main"
+    - base_url: "https://example.com"
-    exclude_selectors:
+      css_locator: "main"
-      - ".ads"
+      exclude_selectors:
-    max_depth: 2
+        - ".ads"
-    allowed_paths:
+      max_depth: 2
-      - "/blog"
+      allowed_paths:
-    exclude_paths:
+        - "/blog"
-      - "/admin"
+      exclude_paths:
-      file_name_prefix: "example"
+        - "/admin"
-    path_overrides:
+      output_alias: "example"
-      - path: "/special"
+      path_overrides:
-        css_locator: ".special-content"
+        - path: "/special"
-        exclude_selectors:
+          css_locator: ".special-content"
-          - ".sidebar"
+          exclude_selectors:
-output_type: "single"
+            - ".sidebar"
-requests_per_second: 1.0
+  output_type: "single"
-burst_limit: 5
+  requests_per_second: 1.0
+  burst_limit: 5
 `)
 
 	tmpfile, err := os.CreateTemp("", "config*.yml")
@@ -44,10 +45,10 @@ burst_limit: 5
 	}
 	defer os.Remove(tmpfile.Name())
 
-	if _, err = tmpfile.Write(content); err != nil {
+	if _, err := tmpfile.Write(content); err != nil {
 		t.Fatalf("Failed to write to temp file: %v", err)
 	}
-	if err = tmpfile.Close(); err != nil {
+	if err := tmpfile.Close(); err != nil {
 		t.Fatalf("Failed to close temp file: %v", err)
 	}
 
@@ -58,32 +59,33 @@ burst_limit: 5
 	}
 
 	// Check if the loaded config matches the expected values
-	rps := 1.0
-	bl := 5
 	expectedConfig := &Config{
-		FileExtensions:     []string{".go", ".md"},
+		FileTypes:     []string{"go", "md"},
-		IgnorePaths:        []string{"*.tmp", "**/*.log"},
+		Ignore:        []string{"*.tmp", "**/*.log"},
-		CodeGeneratedPaths: []string{"generated_*.go"},
+		CodeGenerated: []string{"generated_*.go"},
-		Sites: []SiteConfig{
+		Scrape: ScrapeConfig{
-			{
+			Sites: []SiteConfig{
-				BaseURL:          "https://example.com",
+				{
-				CSSLocator:       "main",
+					BaseURL:          "https://example.com",
-				ExcludeSelectors: []string{".ads"},
+					CSSLocator:       "main",
-				AllowedPaths:     []string{"/blog"},
+					ExcludeSelectors: []string{".ads"},
-				ExcludePaths:     []string{"/admin"},
+					MaxDepth:         2,
-				FileNamePrefix:   "example",
+					AllowedPaths:     []string{"/blog"},
-				PathOverrides: []PathOverride{
+					ExcludePaths:     []string{"/admin"},
-					{
+					OutputAlias:      "example",
-						Path:             "/special",
+					PathOverrides: []PathOverride{
-						CSSLocator:       ".special-content",
+						{
-						ExcludeSelectors: []string{".sidebar"},
+							Path:             "/special",
+							CSSLocator:       ".special-content",
+							ExcludeSelectors: []string{".sidebar"},
+						},
 					},
 				},
 			},
+			OutputType:        "single",
+			RequestsPerSecond: 1.0,
+			BurstLimit:        5,
 		},
-		OutputType:        "single",
-		RequestsPerSecond: &rps,
-		BurstLimit:        &bl,
 	}
 
 	if !reflect.DeepEqual(config, expectedConfig) {
@@ -91,67 +93,28 @@ burst_limit: 5
 	}
 }
 
-func TestValidate(t *testing.T) {
+func TestDefaultConfigPath(t *testing.T) {
-	tests := []struct {
+	expected := "rollup.yml"
-		name    string
+	result := DefaultConfigPath()
-		config  Config
+	if result != expected {
-		wantErr bool
+		t.Errorf("DefaultConfigPath() = %q, want %q", result, expected)
-	}{
+	}
-		{
+}
-			name: "Valid config",
+
-			config: Config{
+func TestFileExists(t *testing.T) {
-				FileExtensions: []string{".go"},
+	// Test with an existing file
-				Sites: []SiteConfig{
+	tmpfile, err := os.CreateTemp("", "testfile")
-					{BaseURL: "https://example.com"},
+	if err != nil {
-				},
+		t.Fatalf("Failed to create temp file: %v", err)
-			},
+	}
-			wantErr: false,
+	defer os.Remove(tmpfile.Name())
-		},
+
-		{
+	if !FileExists(tmpfile.Name()) {
-			name:    "No file extensions",
+		t.Errorf("FileExists(%q) = false, want true", tmpfile.Name())
-			config:  Config{},
+	}
-			wantErr: true,
+
-		},
+	// Test with a non-existing file
-		{
+	if FileExists("non_existing_file.txt") {
-			name: "Invalid requests per second",
+		t.Errorf("FileExists(\"non_existing_file.txt\") = true, want false")
-			config: Config{
-				FileExtensions:    []string{".go"},
-				RequestsPerSecond: func() *float64 { f := -1.0; return &f }(),
-			},
-			wantErr: true,
-		},
-		{
-			name: "Invalid burst limit",
-			config: Config{
-				FileExtensions: []string{".go"},
-				BurstLimit:     func() *int { i := -1; return &i }(),
-			},
-			wantErr: true,
-		},
-		{
-			name: "Site without base URL",
-			config: Config{
-				FileExtensions: []string{".go"},
-				Sites:          []SiteConfig{{}},
-			},
-			wantErr: true,
-		},
-		{
-			name: "Negative max depth",
-			config: Config{
-				FileExtensions: []string{".go"},
-				Sites:          []SiteConfig{{BaseURL: "https://example.com"}},
-			},
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := tt.config.Validate()
-			if (err != nil) != tt.wantErr {
-				t.Errorf("Validate() error = %v, wantErr %v", err, tt.wantErr)
-			}
-		})
 	}
 }

internal/scraper/scraper.go

@@ -1,22 +1,21 @@
 package scraper
 
 import (
-	"context"
 	"fmt"
-	"io"
+	"io/ioutil"
 	"log"
 	"math/rand"
 	"net/url"
 	"os"
-	"path/filepath"
 	"regexp"
 	"strings"
-	"sync"
 	"time"
+	"sync"
+	"context"
 
-	md "github.com/JohannesKaufmann/html-to-markdown"
 	"github.com/PuerkitoBio/goquery"
 	"github.com/playwright-community/playwright-go"
+	md "github.com/JohannesKaufmann/html-to-markdown"
 	"golang.org/x/time/rate"
 )
 
@@ -46,9 +45,10 @@ type SiteConfig struct {
 	BaseURL          string
 	CSSLocator       string
 	ExcludeSelectors []string
+	MaxDepth         int
 	AllowedPaths     []string
 	ExcludePaths     []string
-	FileNamePrefix   string
+	OutputAlias      string
 	PathOverrides    []PathOverride
 }
 
@@ -59,164 +59,209 @@ type PathOverride struct {
 	ExcludeSelectors []string
 }
 
-func ScrapeSites(config Config) error {
+func ScrapeSites(config Config) (map[string]string, error) {
-	logger.Println("Starting ScrapeSites function - Verbose mode is active")
+    logger.Println("Starting ScrapeSites function - Verbose mode is active")
-	results := make(chan struct {
+    results := make(chan struct {
-		url     string
+        url     string
-		content string
+        content string
-		site    SiteConfig // Add site config to track which site the content came from
+        err     error
-		err     error
+    })
-	})
 
-	limiter := rate.NewLimiter(rate.Limit(config.Scrape.RequestsPerSecond), config.Scrape.BurstLimit)
+    limiter := rate.NewLimiter(rate.Limit(config.Scrape.RequestsPerSecond), config.Scrape.BurstLimit)
-	logger.Printf("Rate limiter configured with %f requests per second and burst limit of %d\n",
+    logger.Printf("Rate limiter configured with %f requests per second and burst limit of %d\n", config.Scrape.RequestsPerSecond, config.Scrape.BurstLimit)
-		config.Scrape.RequestsPerSecond, config.Scrape.BurstLimit)
 
-	var wg sync.WaitGroup
+    var wg sync.WaitGroup
-	totalURLs := 0
+    totalURLs := 0
-	for _, site := range config.Sites {
+    for _, site := range config.Sites {
-		logger.Printf("Processing site: %s\n", site.BaseURL)
+        logger.Printf("Processing site: %s\n", site.BaseURL)
-		wg.Add(1)
+        wg.Add(1)
-		go func(site SiteConfig) {
+        go func(site SiteConfig) {
-			defer wg.Done()
+            defer wg.Done()
-			for _, path := range site.AllowedPaths {
+            for _, path := range site.AllowedPaths {
-				fullURL := site.BaseURL + path
+                fullURL := site.BaseURL + path
-				totalURLs++
+                totalURLs++
-				logger.Printf("Queueing URL for scraping: %s\n", fullURL)
+                logger.Printf("Queueing URL for scraping: %s\n", fullURL)
-				scrapeSingleURL(fullURL, site, results, limiter)
+                scrapeSingleURL(fullURL, site, config, results, limiter)
-			}
+            }
-		}(site)
+        }(site)
-	}
+    }
 
-	go func() {
+    go func() {
-		wg.Wait()
+        wg.Wait()
-		close(results)
+        close(results)
-		logger.Println("All goroutines completed, results channel closed")
+        logger.Println("All goroutines completed, results channel closed")
-	}()
+    }()
 
-	// Use a map that includes site configuration
+    scrapedContent := make(map[string]string)
-	scrapedContent := make(map[string]struct {
+    for result := range results {
-		content string
+        if result.err != nil {
-		site    SiteConfig
+            logger.Printf("Error scraping %s: %v\n", result.url, result.err)
-	})
+            continue
+        }
+        logger.Printf("Successfully scraped content from %s (length: %d)\n", result.url, len(result.content))
+        scrapedContent[result.url] = result.content
+    }
 
-	for result := range results {
+    logger.Printf("Total URLs processed: %d\n", totalURLs)
-		if result.err != nil {
+    logger.Printf("Successfully scraped content from %d URLs\n", len(scrapedContent))
-			logger.Printf("Error scraping %s: %v\n", result.url, result.err)
-			continue
-		}
-		logger.Printf("Successfully scraped content from %s (length: %d)\n",
-			result.url, len(result.content))
-		scrapedContent[result.url] = struct {
-			content string
-			site    SiteConfig
-		}{
-			content: result.content,
-			site:    result.site,
-		}
-	}
 
-	logger.Printf("Total URLs processed: %d\n", totalURLs)
+    return scrapedContent, nil
-	logger.Printf("Successfully scraped content from %d URLs\n", len(scrapedContent))
-
-	return SaveToFiles(scrapedContent, config)
 }
 
-func scrapeSingleURL(url string, site SiteConfig, results chan<- struct {
+func scrapeSingleURL(url string, site SiteConfig, config Config, results chan<- struct {
-	url     string
+    url     string
-	content string
+    content string
-	site    SiteConfig
+    err     error
-	err     error
 }, limiter *rate.Limiter) {
-	logger.Printf("Starting to scrape URL: %s\n", url)
+    logger.Printf("Starting to scrape URL: %s\n", url)
 
-	err := limiter.Wait(context.Background())
+    // Wait for rate limiter before making the request
-	if err != nil {
+    err := limiter.Wait(context.Background())
-		results <- struct {
+    if err != nil {
-			url     string
+        logger.Printf("Rate limiter error for %s: %v\n", url, err)
-			content string
+        results <- struct {
-			site    SiteConfig
+            url     string
-			err     error
+            content string
-		}{url, "", site, fmt.Errorf("rate limiter error: %v", err)}
+            err     error
-		return
+        }{url, "", fmt.Errorf("rate limiter error: %v", err)}
-	}
+        return
+    }
 
-	cssLocator, excludeSelectors := getOverrides(url, site)
+    cssLocator, excludeSelectors := getOverrides(url, site)
-	content, err := scrapeURL(url, cssLocator, excludeSelectors)
+    logger.Printf("Using CSS locator for %s: %s\n", url, cssLocator)
-	if err != nil {
+    logger.Printf("Exclude selectors for %s: %v\n", url, excludeSelectors)
-		results <- struct {
-			url     string
-			content string
-			site    SiteConfig
-			err     error
-		}{url, "", site, err}
-		return
-	}
 
-	results <- struct {
+    content, err := scrapeURL(url, cssLocator, excludeSelectors)
-		url     string
+    if err != nil {
-		content string
+        logger.Printf("Error scraping %s: %v\n", url, err)
-		site    SiteConfig
+        results <- struct {
-		err     error
+            url     string
-	}{url, content, site, nil}
+            content string
+            err     error
+        }{url, "", err}
+        return
+    }
+
+    if content == "" {
+        logger.Printf("Warning: Empty content scraped from %s\n", url)
+    } else {
+        logger.Printf("Successfully scraped content from %s (length: %d)\n", url, len(content))
+    }
+
+    results <- struct {
+        url     string
+        content string
+        err     error
+    }{url, content, nil}
+}
+
+func scrapeSite(site SiteConfig, config Config, results chan<- struct {
+    url     string
+    content string
+    err     error
+}, limiter *rate.Limiter) {
+    visited := make(map[string]bool)
+    queue := []string{site.BaseURL}
+
+    for len(queue) > 0 {
+        url := queue[0]
+        queue = queue[1:]
+
+        if visited[url] {
+            continue
+        }
+        visited[url] = true
+
+        if !isAllowedURL(url, site) {
+            continue
+        }
+
+        // Wait for rate limiter before making the request
+        err := limiter.Wait(context.Background())
+        if err != nil {
+            results <- struct {
+                url     string
+                content string
+                err     error
+            }{url, "", fmt.Errorf("rate limiter error: %v", err)}
+            continue
+        }
+
+        cssLocator, excludeSelectors := getOverrides(url, site)
+        content, err := scrapeURL(url, cssLocator, excludeSelectors)
+        results <- struct {
+            url     string
+            content string
+            err     error
+        }{url, content, err}
+
+        if len(visited) < site.MaxDepth {
+            links, _ := ExtractLinks(url)
+            for _, link := range links {
+                if !visited[link] && isAllowedURL(link, site) {
+                    queue = append(queue, link)
+                }
+            }
+        }
+    }
 }
 
 func isAllowedURL(urlStr string, site SiteConfig) bool {
-	parsedURL, err := url.Parse(urlStr)
+    parsedURL, err := url.Parse(urlStr)
-	if err != nil {
+    if err != nil {
-		return false
+        return false
-	}
+    }
 
-	baseURL, _ := url.Parse(site.BaseURL)
+    baseURL, _ := url.Parse(site.BaseURL)
-	if parsedURL.Host != baseURL.Host {
+    if parsedURL.Host != baseURL.Host {
-		return false
+        return false
-	}
+    }
 
-	path := parsedURL.Path
+    path := parsedURL.Path
-	for _, allowedPath := range site.AllowedPaths {
+    for _, allowedPath := range site.AllowedPaths {
-		if strings.HasPrefix(path, allowedPath) {
+        if strings.HasPrefix(path, allowedPath) {
-			for _, excludePath := range site.ExcludePaths {
+            for _, excludePath := range site.ExcludePaths {
-				if strings.HasPrefix(path, excludePath) {
+                if strings.HasPrefix(path, excludePath) {
-					return false
+                    return false
-				}
+                }
-			}
+            }
-			return true
+            return true
-		}
+        }
-	}
+    }
 
-	return false
+    return false
 }
 
 func getOverrides(urlStr string, site SiteConfig) (string, []string) {
-	parsedURL, _ := url.Parse(urlStr)
+    parsedURL, _ := url.Parse(urlStr)
-	path := parsedURL.Path
+    path := parsedURL.Path
 
-	for _, override := range site.PathOverrides {
+    for _, override := range site.PathOverrides {
-		if strings.HasPrefix(path, override.Path) {
+        if strings.HasPrefix(path, override.Path) {
-			if override.CSSLocator != "" {
+            if override.CSSLocator != "" {
-				return override.CSSLocator, override.ExcludeSelectors
+                return override.CSSLocator, override.ExcludeSelectors
-			}
+            }
-			return site.CSSLocator, override.ExcludeSelectors
+            return site.CSSLocator, override.ExcludeSelectors
-		}
+        }
-	}
+    }
 
-	return site.CSSLocator, site.ExcludeSelectors
+    return site.CSSLocator, site.ExcludeSelectors
 }
 
 func scrapeURL(url, cssLocator string, excludeSelectors []string) (string, error) {
-	content, err := FetchWebpageContent(url)
+    content, err := FetchWebpageContent(url)
-	if err != nil {
+    if err != nil {
-		return "", err
+        return "", err
-	}
+    }
 
-	if cssLocator != "" {
+    if cssLocator != "" {
-		content, err = ExtractContentWithCSS(content, cssLocator, excludeSelectors)
+        content, err = ExtractContentWithCSS(content, cssLocator, excludeSelectors)
-		if err != nil {
+        if err != nil {
-			return "", err
+            return "", err
-		}
+        }
-	}
+    }
 
-	return ProcessHTMLContent(content, Config{})
+    return ProcessHTMLContent(content, Config{})
 }
 
 func getFilenameFromContent(content, url string) string {
@@ -233,14 +278,9 @@ func getFilenameFromContent(content, url string) string {
 }
 
 func sanitizeFilename(name string) string {
-	// Replace all non-alphanumeric characters with dashes
+	// Remove any character that isn't alphanumeric, dash, or underscore
-	reg := regexp.MustCompile("[^a-zA-Z0-9]+")
+	reg, _ := regexp.Compile("[^a-zA-Z0-9-_]+")
-	name = reg.ReplaceAllString(name, "-")
+	return reg.ReplaceAllString(name, "_")
-	// Remove any leading or trailing dashes
-	name = strings.Trim(name, "-")
-	// Collapse multiple consecutive dashes into one
-	reg = regexp.MustCompile("-+")
-	return reg.ReplaceAllString(name, "-")
 }
 
 // URLConfig holds configuration for a single URL
@@ -248,7 +288,7 @@ type URLConfig struct {
 	URL              string
 	CSSLocator       string
 	ExcludeSelectors []string
-	FileNamePrefix   string
+	OutputAlias      string
 }
 
 // SetupLogger initializes the logger based on the verbose flag
@@ -256,7 +296,7 @@ func SetupLogger(verbose bool) {
 	if verbose {
 		logger = log.New(os.Stdout, "SCRAPER: ", log.LstdFlags)
 	} else {
-		logger = log.New(io.Discard, "", 0)
+		logger = log.New(ioutil.Discard, "", 0)
 	}
 }
 
@@ -276,7 +316,7 @@ func InitPlaywright() error {
 		return fmt.Errorf("could not start Playwright: %v", err)
 	}
 
-	userAgent := "Mozilla/5.0 (Linux; Android 15; Pixel 9 Build/AP3A.241105.008) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.106 Mobile Safari/537.36 OPX/2.5"
+	userAgent := "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
 
 	browser, err = pw.Chromium.Launch(playwright.BrowserTypeLaunchOptions{
 		Args: []string{fmt.Sprintf("--user-agent=%s", userAgent)},
@@ -299,129 +339,6 @@ func ClosePlaywright() {
 	}
 }
 
-// InitBrowser initializes the browser
-func InitBrowser() error {
-	return InitPlaywright()
-}
-
-// CloseBrowser closes the browser
-func CloseBrowser() {
-	ClosePlaywright()
-}
-
-// SaveToFiles writes the scraped content to files based on output type
-func SaveToFiles(content map[string]struct {
-	content string
-	site    SiteConfig
-}, config Config) error {
-	if config.OutputType == "" {
-		config.OutputType = "separate" // default to separate files if not specified
-	}
-
-	switch config.OutputType {
-	case "single":
-		if err := os.MkdirAll("output", 0755); err != nil {
-			return fmt.Errorf("failed to create output directory: %v", err)
-		}
-		var combined strings.Builder
-		for url, data := range content {
-			combined.WriteString(fmt.Sprintf("## %s\n\n", url))
-			combined.WriteString(data.content)
-			combined.WriteString("\n\n")
-		}
-		return os.WriteFile(filepath.Join("output", "combined.md"), []byte(combined.String()), 0644)
-
-	case "separate":
-		if err := os.MkdirAll("output", 0755); err != nil {
-			return fmt.Errorf("failed to create output directory: %v", err)
-		}
-
-		// Group content by site and path
-		contentBySitePath := make(map[string]map[string]string)
-		for urlStr, data := range content {
-			parsedURL, err := url.Parse(urlStr)
-			if err != nil {
-				logger.Printf("Warning: Could not parse URL %s: %v", urlStr, err)
-				continue
-			}
-
-			// Find matching allowed path for this URL
-			var matchingPath string
-			for _, path := range data.site.AllowedPaths {
-				if strings.HasPrefix(parsedURL.Path, path) {
-					matchingPath = path
-					break
-				}
-			}
-			if matchingPath == "" {
-				logger.Printf("Warning: No matching allowed path for URL %s", urlStr)
-				continue
-			}
-
-			siteKey := fmt.Sprintf("%s-%s", data.site.BaseURL, data.site.FileNamePrefix)
-			if contentBySitePath[siteKey] == nil {
-				contentBySitePath[siteKey] = make(map[string]string)
-			}
-
-			// Combine all content for the same path
-			if existing, exists := contentBySitePath[siteKey][matchingPath]; exists {
-				contentBySitePath[siteKey][matchingPath] = existing + "\n\n" + data.content
-			} else {
-				contentBySitePath[siteKey][matchingPath] = data.content
-			}
-		}
-
-		// Write files for each site and path
-		for siteKey, pathContent := range contentBySitePath {
-			for path, content := range pathContent {
-				parts := strings.SplitN(siteKey, "-", 2) // Split only on first hyphen
-				prefix := parts[1]                       // Get the FileNamePrefix part
-				if prefix == "" {
-					prefix = "doc" // default prefix if none specified
-				}
-
-				normalizedPath := NormalizePathForFilename(path)
-				if normalizedPath == "" {
-					normalizedPath = "index"
-				}
-
-				filename := filepath.Join("output", fmt.Sprintf("%s-%s.md",
-					prefix, normalizedPath))
-
-				// Ensure we don't have empty files
-				if strings.TrimSpace(content) == "" {
-					logger.Printf("Skipping empty content for path %s", path)
-					continue
-				}
-
-				if err := os.WriteFile(filename, []byte(content), 0644); err != nil {
-					return fmt.Errorf("failed to write file %s: %v", filename, err)
-				}
-				logger.Printf("Wrote content to %s", filename)
-			}
-		}
-		return nil
-
-	default:
-		return fmt.Errorf("unsupported output type: %s", config.OutputType)
-	}
-}
-
-// NormalizePathForFilename converts a URL path into a valid filename component
-func NormalizePathForFilename(urlPath string) string {
-	// Remove leading/trailing slashes
-	path := strings.Trim(urlPath, "/")
-	// Replace all non-alphanumeric characters with dashes
-	reg := regexp.MustCompile("[^a-zA-Z0-9]+")
-	path = reg.ReplaceAllString(path, "-")
-	// Remove any leading or trailing dashes
-	path = strings.Trim(path, "-")
-	// Collapse multiple consecutive dashes into one
-	reg = regexp.MustCompile("-+")
-	path = reg.ReplaceAllString(path, "-")
-	return path
-}
-
 // FetchWebpageContent retrieves the content of a webpage using Playwright
 func FetchWebpageContent(urlStr string) (string, error) {
 	logger.Printf("Fetching webpage content for URL: %s\n", urlStr)
@@ -460,9 +377,7 @@ func FetchWebpageContent(urlStr string) (string, error) {
 	}
 
 	logger.Println("Waiting for body element")
-
+	_, err = page.WaitForSelector("body", playwright.PageWaitForSelectorOptions{
-	bodyElement := page.Locator("body")
-	err = bodyElement.WaitFor(playwright.LocatorWaitForOptions{
 		State: playwright.WaitForSelectorStateVisible,
 	})
 	if err != nil {
@@ -479,7 +394,7 @@ func FetchWebpageContent(urlStr string) (string, error) {
 
 	if content == "" {
 		logger.Println(" content is empty, falling back to body content")
-		content, err = bodyElement.InnerHTML()
+		content, err = page.InnerHTML("body")
 		if err != nil {
 			logger.Printf("Error getting body content: %v\n", err)
 			return "", fmt.Errorf("could not get body content: %v", err)
@@ -532,8 +447,6 @@ func scrollPage(page playwright.Page) error {
 		() => {
 			window.scrollTo(0, document.body.scrollHeight);
 			return document.body.scrollHeight;
-			// wait for 500 ms
-			new Promise(resolve => setTimeout(resolve, 500));
 		}
 	`
 
@@ -565,8 +478,7 @@ func scrollPage(page playwright.Page) error {
 
 		previousHeight = currentHeight
 
-		// Wait for a while before scrolling again
+		page.WaitForTimeout(500)
-
 	}
 
 	logger.Println("Scrolling back to top")
@@ -580,6 +492,39 @@ func scrollPage(page playwright.Page) error {
 	return nil
 }
 
+// ExtractLinks extracts all links from the given URL
+func ExtractLinks(urlStr string) ([]string, error) {
+	logger.Printf("Extracting links from URL: %s\n", urlStr)
+
+	page, err := browser.NewPage()
+	if err != nil {
+		return nil, fmt.Errorf("could not create page: %v", err)
+	}
+	defer page.Close()
+
+	if _, err = page.Goto(urlStr, playwright.PageGotoOptions{
+		WaitUntil: playwright.WaitUntilStateNetworkidle,
+	}); err != nil {
+		return nil, fmt.Errorf("could not go to page: %v", err)
+	}
+
+	links, err := page.Evaluate(`() => {
+		const anchors = document.querySelectorAll('a');
+		return Array.from(anchors).map(a => a.href);
+	}`)
+	if err != nil {
+		return nil, fmt.Errorf("could not extract links: %v", err)
+	}
+
+	var result []string
+	for _, link := range links.([]interface{}) {
+		result = append(result, link.(string))
+	}
+
+	logger.Printf("Extracted %d links\n", len(result))
+	return result, nil
+}
+
 // ExtractContentWithCSS extracts content from HTML using a CSS selector
 func ExtractContentWithCSS(content, includeSelector string, excludeSelectors []string) (string, error) {
 	logger.Printf("Extracting content with CSS selector: %s\n", includeSelector)
@@ -607,23 +552,6 @@ func ExtractContentWithCSS(content, includeSelector string, excludeSelectors []s
 		return "", fmt.Errorf("error extracting content with CSS selector: %v", err)
 	}
 
-	// Trim leading and trailing whitespace
-	selectedContent = strings.TrimSpace(selectedContent)
-
-	// Normalize newlines
-	selectedContent = strings.ReplaceAll(selectedContent, "\r\n", "\n")
-	selectedContent = strings.ReplaceAll(selectedContent, "\r", "\n")
-
-	// Remove indentation while preserving structure
-	lines := strings.Split(selectedContent, "\n")
-	for i, line := range lines {
-		lines[i] = strings.TrimSpace(line)
-	}
-	selectedContent = strings.Join(lines, "\n")
-
-	// Remove any leading or trailing newlines
-	selectedContent = strings.Trim(selectedContent, "\n")
-
 	logger.Printf("Extracted content length: %d\n", len(selectedContent))
 	return selectedContent, nil
 }

internal/scraper/scraper_test.go

@@ -1,13 +1,10 @@
 package scraper
 
 import (
-	"io"
-	"log"
-	// "net/http"
-	// "net/http/httptest"
-	"reflect"
-	"strings"
 	"testing"
+	"net/http"
+	"net/http/httptest"
+	"strings"
 )
 
 func TestIsAllowedURL(t *testing.T) {
@@ -51,9 +48,9 @@ func TestGetOverrides(t *testing.T) {
 	}
 
 	tests := []struct {
-		url              string
+		url               string
-		expectedLocator  string
+		expectedLocator   string
-		expectedExcludes []string
+		expectedExcludes  []string
 	}{
 		{"https://example.com/normal", "main", []string{".ads"}},
 		{"https://example.com/special", ".special-content", []string{".sidebar"}},
@@ -72,9 +69,6 @@ func TestGetOverrides(t *testing.T) {
 }
 
 func TestExtractContentWithCSS(t *testing.T) {
-	// Initialize logger for testing
-	logger = log.New(io.Discard, "", 0)
-
 	html := `
 		<html>
 			<body>
@@ -143,39 +137,33 @@ This is a **test** paragraph.
 	}
 }
 
-// func TestExtractLinks(t *testing.T) {
+func TestExtractLinks(t *testing.T) {
-// 	// Initialize Playwright before running the test
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-// 	if err := InitPlaywright(); err != nil {
+		w.Header().Set("Content-Type", "text/html")
-// 		t.Fatalf("Failed to initialize Playwright: %v", err)
+		w.Write([]byte(`
-// 	}
+			<html>
-// 	defer ClosePlaywright()
+				<body>
+					<a href="https://example.com/page1">Page 1</a>
+					<a href="https://example.com/page2">Page 2</a>
+					<a href="https://othersite.com">Other Site</a>
+				</body>
+			</html>
+		`))
+	}))
+	defer server.Close()
 
-// 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+	links, err := ExtractLinks(server.URL)
-// 		w.Header().Set("Content-Type", "text/html")
+	if err != nil {
-// 		w.Write([]byte(`
+		t.Fatalf("ExtractLinks() returned error: %v", err)
-// 			<html>
+	}
-// 				<body>
-// 					<a href="https://example.com/page1">Page 1</a>
-// 					<a href="https://example.com/page2">Page 2</a>
-// 					<a href="https://othersite.com">Other Site</a>
-// 				</body>
-// 			</html>
-// 		`))
-// 	}))
-// 	defer server.Close()
 
-// 	links, err := ExtractLinks(server.URL)
+	expectedLinks := []string{
-// 	if err != nil {
+		"https://example.com/page1",
-// 		t.Fatalf("ExtractLinks() returned error: %v", err)
+		"https://example.com/page2",
-// 	}
+		"https://othersite.com",
+	}
 
-// 	expectedLinks := []string{
+	if !reflect.DeepEqual(links, expectedLinks) {
-// 		"https://example.com/page1",
+		t.Errorf("ExtractLinks() = %v, want %v", links, expectedLinks)
-// 		"https://example.com/page2",
+	}
-// 		"https://othersite.com",
+}
-// 	}
-
-// 	if !reflect.DeepEqual(links, expectedLinks) {
-// 		t.Errorf("ExtractLinks() = %v, want %v", links, expectedLinks)
-// 	}
-// }

main.go

@@ -20,7 +20,7 @@ func main() {
 	var err error
 
 	if !isHelpCommand {
-		configPath := "rollup.yml"
+		configPath := config.DefaultConfigPath()
 		cfg, err = config.Load(configPath)
 		if err != nil {
 			log.Printf("Warning: Failed to load configuration: %v", err)