fix: Load configuration before running rollup

CLAUDE.md

@@ -1,53 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Build and Run Commands
-
-```bash
-# Build the binary
-go build -o rollup .
-
-# Run directly
-go run main.go [command]
-
-# Run tests
-go test ./...
-
-# Run a single test
-go test -run TestName ./path/to/package
-```
-
-## Project Overview
-
-Rollup is a Go CLI tool that aggregates text-based files and webpages into markdown files. It has three main commands:
-- `files` - Rolls up local files into a single markdown file
-- `web` - Scrapes webpages and converts to markdown using Playwright
-- `generate` - Creates a default rollup.yml config file
-
-## Architecture
-
-**Entry Point**: `main.go` initializes Playwright browser and loads config before executing commands via Cobra.
-
-**Command Layer** (`cmd/`):
-- `root.go` - Cobra root command with global flags (--config, --verbose)
-- `files.go` - File aggregation with glob pattern matching for ignore/codegen detection
-- `web.go` - Web scraping orchestration, converts config site definitions to scraper configs
-- `generate.go` - Scans directory for text file types and generates rollup.yml
-
-**Internal Packages**:
-- `internal/config` - YAML config loading and validation. Defines `Config`, `SiteConfig`, `PathOverride` structs
-- `internal/scraper` - Playwright-based web scraping with rate limiting, HTML-to-markdown conversion via goquery and html-to-markdown library
-
-**Key Dependencies**:
-- `spf13/cobra` - CLI framework
-- `playwright-go` - Browser automation for web scraping
-- `PuerkitoBio/goquery` - HTML parsing and CSS selector extraction
-- `JohannesKaufmann/html-to-markdown` - HTML to markdown conversion
-
-## Configuration
-
-The tool reads from `rollup.yml` by default. Key config fields:
-- `file_extensions` - File types to include in rollup
-- `ignore_paths` / `code_generated_paths` - Glob patterns for exclusion
-- `sites` - Web scraping targets with CSS selectors, path filtering, rate limiting

README.md

@@ -1,225 +1,145 @@
 # Rollup
 
-Rollup aggregates the contents of text-based files and webpages into markdown files.
+Rollup aggregates the contents of text-based files and webpages into a markdown file.
 
 ## Features
 
-- **File aggregation**: Combine multiple source files into a single markdown document
+- File type filtering for targeted content aggregation
-- **File type filtering**: Include only specific file extensions
+- Ignore patterns for excluding specific files or directories
-- **Ignore patterns**: Exclude files/directories using glob patterns
+- Support for code-generated file detection and exclusion
-- **Code-generated file detection**: Mark auto-generated files as read-only in output
+- Advanced web scraping functionality with depth control
-- **Web scraping**: Scrape webpage content using Playwright browser automation
+- Verbose logging option for detailed operation insights
-- **HTML to Markdown conversion**: Automatically converts scraped HTML to clean markdown
+- Exclusionary CSS selectors for precise web content extraction
-- **CSS selectors**: Extract specific content sections or exclude unwanted elements
+- Support for multiple URLs in web scraping operations
-- **Path-based overrides**: Configure different selectors for specific URL paths
+- Configurable output format for web scraping (single file or separate files)
-- **Rate limiting**: Configurable requests per second and burst limits for web scraping
+- Flexible configuration file support (YAML)
-- **Output modes**: Single combined file or separate files per source
+- Automatic generation of default configuration file
-- **Verbose logging**: Detailed operation insights for debugging
+- Custom output file naming
-- **YAML configuration**: Flexible configuration file support
+- Rate limiting for web scraping to respect server resources
 
 ## Installation
 
-Ensure you have Go 1.21+ installed, then run:
+To install Rollup, make sure you have Go installed on your system, then run:
 
 ```bash
-go install github.com/tnypxl/rollup@latest
+go get github.com/tnypxl/rollup
-```
-
-Or build from source:
-
-```bash
-git clone https://github.com/tnypxl/rollup.git
-cd rollup
-go build -o rollup .
 ```
 
 ## Usage
 
+Basic usage:
+
 ```bash
 rollup [command] [flags]
 ```
 
 ### Commands
 
-| Command | Description |
+- `rollup files`: Rollup files into a single Markdown file
-|---------|-------------|
+- `rollup web`: Scrape main content from webpages and convert to Markdown
-| `files` | Aggregate local files into a single markdown file |
+- `rollup generate`: Generate a rollup.yml config file
-| `web` | Scrape webpages and convert to markdown |
-| `generate` | Generate a default rollup.yml config file |
 
 ### Flags for `files` command
 
-| Flag | Short | Default | Description |
+- `--path, -p`: Path to the project directory (default: current directory)
-|------|-------|---------|-------------|
+- `--types, -t`: Comma-separated list of file extensions to include (default: .go,.md,.txt)
-| `--path` | `-p` | `.` | Path to the project directory |
+- `--codegen, -g`: Comma-separated list of glob patterns for code-generated files
-| `--types` | `-t` | `go,md,txt` | Comma-separated list of file extensions (without dots) |
+- `--ignore, -i`: Comma-separated list of glob patterns for files to ignore
-| `--codegen` | `-g` | | Glob patterns for code-generated files |
-| `--ignore` | `-i` | | Glob patterns for files to ignore |
 
 ### Flags for `web` command
 
-| Flag | Short | Description |
+- `--urls, -u`: URLs of the webpages to scrape (comma-separated)
-|------|-------|-------------|
+- `--output, -o`: Output type: 'single' for one file, 'separate' for multiple files (default: single)
-| `--urls` | `-u` | URLs of webpages to scrape (comma-separated) |
+- `--depth, -d`: Depth of link traversal (default: 0, only scrape the given URLs)
-| `--output` | `-o` | Output type: `single` or `separate` |
+- `--css`: CSS selector to extract specific content
-| `--css` | | CSS selector to extract specific content |
+- `--exclude`: CSS selectors to exclude from the extracted content (comma-separated)
-| `--exclude` | | CSS selectors to exclude (comma-separated) |
 
 ### Global flags
 
-| Flag | Short | Description |
+- `--config, -f`: Path to the configuration file (default: rollup.yml in the current directory)
-|------|-------|-------------|
+- `--verbose, -v`: Enable verbose logging
-| `--config` | `-f` | Path to config file (default: `rollup.yml`) |
-| `--verbose` | `-v` | Enable verbose logging |
 
 ## Configuration
 
-Rollup reads from `rollup.yml` by default. Use `--config` to specify a different file.
+Rollup can be configured using a YAML file. By default, it looks for `rollup.yml` in the current directory. You can specify a different configuration file using the `--config` flag.
 
-### Configuration Options
+Example `rollup.yml`:
 
 ```yaml
-# File extensions to include (without leading dots)
 file_extensions:
   - go
   - md
-  - js
-
-# Glob patterns for paths to ignore
 ignore_paths:
   - node_modules/**
   - vendor/**
   - .git/**
-
-# Glob patterns for code-generated files (marked as read-only in output)
 code_generated_paths:
-  - "**/*.pb.go"
+  - **/generated/**
-  - "**/generated/**"
-
-# Web scraping site configurations
 sites:
   - base_url: https://example.com
-    css_locator: .main-content
+    css_locator: .content
     exclude_selectors:
       - .ads
       - .navigation
-      - footer
+    max_depth: 2
     allowed_paths:
-      - /docs
       - /blog
+      - /docs
     exclude_paths:
       - /admin
-    file_name_prefix: example-docs
+    output_alias: example
     path_overrides:
       - path: /special-page
         css_locator: .special-content
         exclude_selectors:
           - .special-ads
-
-# Output type for web scraping: 'single' or 'separate'
 output_type: single
-
-# Rate limiting for web requests
 requests_per_second: 1.0
 burst_limit: 3
 ```
 
-### Configuration Reference
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `file_extensions` | list | File extensions to include in file rollup |
-| `ignore_paths` | list | Glob patterns for files/directories to skip |
-| `code_generated_paths` | list | Glob patterns for auto-generated files |
-| `sites` | list | Web scraping target configurations |
-| `output_type` | string | `single` (one file) or `separate` (multiple files) |
-| `requests_per_second` | float | Rate limit for web requests (default: 1.0) |
-| `burst_limit` | int | Maximum burst size for rate limiting (default: 3) |
-
-#### Site Configuration
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `base_url` | string | Starting URL for scraping (required) |
-| `css_locator` | string | CSS selector for content extraction |
-| `exclude_selectors` | list | CSS selectors for content to exclude |
-| `allowed_paths` | list | URL paths allowed for scraping |
-| `exclude_paths` | list | URL paths to skip |
-| `file_name_prefix` | string | Prefix for output file names |
-| `path_overrides` | list | Path-specific selector overrides |
-
 ## Examples
 
-### File Aggregation
+1. Rollup files with default configuration:
 
-```bash
+   ```bash
-# Rollup files using config file
+   rollup files
-rollup files
+   ```
 
-# Specify file types and ignore patterns
+2. Web scraping with multiple URLs:
-rollup files --types=go,js,ts --ignore="vendor/**,*_test.go"
 
-# Rollup a specific directory
+   ```bash
-rollup files --path=/path/to/project
+   rollup web --urls=https://example.com,https://another-example.com
-```
+   ```
 
-### Web Scraping
+3. Generate a default configuration file:
 
-```bash
+   ```bash
-# Scrape URLs from command line
+   rollup generate
-rollup web --urls=https://example.com/docs
+   ```
 
-# Scrape multiple URLs
+4. Use a custom configuration file:
-rollup web --urls=https://example.com,https://another.com
 
-# Extract specific content with CSS selector
+   ```bash
-rollup web --urls=https://example.com --css=".article-content"
+   rollup files --config=my-config.yml
+   ```
 
-# Exclude elements from scraped content
+5. Web scraping with separate output files:
-rollup web --urls=https://example.com --css=".content" --exclude=".ads,.sidebar"
 
-# Output to separate files
+   ```bash
-rollup web --urls=https://example.com --output=separate
+   rollup web --urls=https://example.com,https://another-example.com --output=separate
-```
+   ```
 
-### Configuration Generation
+6. Rollup files with specific types and ignore patterns:
 
-```bash
+   ```bash
-# Generate rollup.yml based on files in current directory
+   rollup files --types=go,md --ignore=vendor/**,*_test.go
-rollup generate
+   ```
-```
 
-### Using Custom Config
+7. Web scraping with depth and CSS selector:
-
+   ```bash
-```bash
+   rollup web --urls=https://example.com --depth=2 --css=.main-content
-rollup files --config=my-config.yml
+   ```
-rollup web --config=my-config.yml
-```
-
-## Output
-
-### File Rollup Output
-
-The `files` command generates a markdown file named `<project-name>-<timestamp>.rollup.md` containing all matched files:
-
-```markdown
-# File: src/main.go
-
-​```go
-package main
-// ... file contents
-​```
-
-# File: docs/README.md (Code-generated, Read-only)
-
-​```md
-// ... file contents
-​```
-```
-
-### Web Rollup Output
-
-The `web` command generates markdown files from scraped content, with filenames based on the page title or URL.
 
 ## Contributing
 

cmd/files.go

@@ -26,6 +26,14 @@ var filesCmd = &cobra.Command{
 	Long: `The files subcommand writes the contents of all files (with target custom file types provided)
 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.`,
+	PreRunE: func(cmd *cobra.Command, args []string) error {
+		var err error
+		cfg, err = config.Load("rollup.yml") // Assuming the config file is named rollup.yml
+		if err != nil {
+			return fmt.Errorf("failed to load configuration: %v", err)
+		}
+		return nil
+	},
 	RunE: func(cmd *cobra.Command, args []string) error {
 		return runRollup(cfg)
 	},
@@ -33,7 +41,7 @@ whose name is <project-directory-name>-rollup-<timestamp>.md.`,
 
 func init() {
 	filesCmd.Flags().StringVarP(&path, "path", "p", ".", "Path to the project directory")
-	filesCmd.Flags().StringVarP(&fileTypes, "types", "t", "go,md,txt", "Comma-separated list of file extensions to include (without leading dot)")
+	filesCmd.Flags().StringVarP(&fileTypes, "types", "t", ".go,.md,.txt", "Comma-separated list of file extensions to include")
 	filesCmd.Flags().StringVarP(&codeGenPatterns, "codegen", "g", "", "Comma-separated list of glob patterns for code-generated files")
 	filesCmd.Flags().StringVarP(&ignorePatterns, "ignore", "i", "", "Comma-separated list of glob patterns for files to ignore")
 }

cmd/root.go

@@ -1,10 +1,8 @@
 package cmd
 
 import (
-	"log"
-
 	"github.com/spf13/cobra"
-	"github.com/tnypxl/rollup/internal/config"
+	config "github.com/tnypxl/rollup/internal/config"
 )
 
 var (
@@ -17,31 +15,13 @@ var rootCmd = &cobra.Command{
 	Short: "Rollup is a tool for combining and processing files",
 	Long: `Rollup is a versatile tool that can combine and process files in various ways.
 Use subcommands to perform specific operations.`,
-	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
-		// Skip config loading for generate and help commands
-		if cmd.Name() == "generate" || cmd.Name() == "help" {
-			return nil
-		}
-
-		// Determine config path
-		configPath := configFile
-		if configPath == "" {
-			configPath = "rollup.yml"
-		}
-
-		// Load configuration
-		var err error
-		cfg, err = config.Load(configPath)
-		if err != nil {
-			log.Printf("Warning: Failed to load configuration from %s: %v", configPath, err)
-			cfg = &config.Config{} // Use empty config if loading fails
-		}
-
-		return nil
-	},
 }
 
-func Execute() error {
+func Execute(conf *config.Config) error {
+	if conf == nil {
+		conf = &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

@@ -28,26 +28,12 @@ var webCmd = &cobra.Command{
 	Use:   "web",
 	Short: "Scrape main content from webpages and convert to Markdown",
 	Long:  `Scrape the main content from one or more webpages, ignoring navigational elements, ads, and other UI aspects. Convert the content to a well-structured Markdown file.`,
-	PreRunE: func(cmd *cobra.Command, args []string) error {
+	RunE:  runWeb,
-		// Setup logger before initializing Playwright
-		scraper.SetupLogger(verbose)
-		// Initialize Playwright for web scraping
-		if err := scraper.InitPlaywright(); err != nil {
-			return fmt.Errorf("failed to initialize Playwright: %w", err)
-		}
-		return nil
-	},
-	RunE: runWeb,
-	PostRunE: func(cmd *cobra.Command, args []string) error {
-		// Clean up Playwright resources
-		scraper.ClosePlaywright()
-		return nil
-	},
 }
 
 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().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)")
 }
@@ -72,6 +58,7 @@ func runWeb(cmd *cobra.Command, args []string) error {
 				ExcludeSelectors: site.ExcludeSelectors,
 				AllowedPaths:     site.AllowedPaths,
 				ExcludePaths:     site.ExcludePaths,
+				OutputAlias:      site.OutputAlias,
 				PathOverrides:    convertPathOverrides(site.PathOverrides),
 			}
 			logger.Printf("Site %d configuration: BaseURL=%s, CSSLocator=%s, AllowedPaths=%v",
@@ -85,7 +72,6 @@ func runWeb(cmd *cobra.Command, args []string) error {
 				BaseURL:          u,
 				CSSLocator:       includeSelector,
 				ExcludeSelectors: excludeSelectors,
-				AllowedPaths:     []string{""},
 			}
 			logger.Printf("URL %d configuration: BaseURL=%s, CSSLocator=%s",
 				i+1, u, includeSelector)
@@ -146,7 +132,7 @@ func runWeb(cmd *cobra.Command, args []string) error {
 		}
 	}()
 
-	err := scraper.ScrapeSites(scraperConfig)
+	scrapedContent, err := scraper.ScrapeSites(scraperConfig)
 	done <- true
 	fmt.Println() // New line after progress indicator
 
@@ -154,11 +140,106 @@ func runWeb(cmd *cobra.Command, args []string) error {
 		logger.Printf("Error occurred during scraping: %v", err)
 		return fmt.Errorf("error scraping content: %v", err)
 	}
-	logger.Println("Scraping completed")
+	logger.Printf("Scraping completed. Total content scraped: %d", len(scrapedContent))
+
+	if outputType == "single" {
+		logger.Println("Writing content to a single file")
+		return writeSingleFile(scrapedContent)
+	} else {
+		logger.Println("Writing content to multiple files")
+		return writeMultipleFiles(scrapedContent)
+	}
+}
+
+func writeSingleFile(content map[string]string) error {
+	outputFile := generateDefaultFilename()
+	file, err := os.Create(outputFile)
+	if err != nil {
+		return fmt.Errorf("error creating output file: %v", err)
+	}
+	defer file.Close()
+
+	for url, c := range content {
+		_, err = fmt.Fprintf(file, "# ::: 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)
+		}
+	}
+
+	fmt.Printf("Content has been extracted from %d URL(s) and saved to %s\n", len(content), outputFile)
+	return nil
+}
+
+func writeMultipleFiles(content map[string]string) error {
+	for url, c := range content {
+		filename, err := getFilenameFromContent(c, url)
+		if err != nil {
+			return fmt.Errorf("error generating filename for %s: %v", url, err)
+		}
+
+		file, err := os.Create(filename)
+		if err != nil {
+			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))
+		if err != nil {
+			file.Close()
+			return fmt.Errorf("error writing content to file %s: %v", filename, err)
+		}
+
+		file.Close()
+		fmt.Printf("Content from %s has been saved to %s\n", url, filename)
+	}
 
 	return nil
 }
 
+func generateDefaultFilename() string {
+	timestamp := time.Now().Format("20060102-150405")
+	return fmt.Sprintf("web-%s.rollup.md", timestamp)
+}
+
+func scrapeURL(urlStr string) (string, error) {
+	content, err := testExtractAndConvertContent(urlStr)
+	if err != nil {
+		return "", err
+	}
+
+	return content, nil
+}
+
+var (
+	testExtractAndConvertContent = extractAndConvertContent
+)
+
+func extractAndConvertContent(urlStr string) (string, error) {
+	content, err := scraper.FetchWebpageContent(urlStr)
+	if err != nil {
+		return "", fmt.Errorf("error fetching webpage content: %v", err)
+	}
+
+	if includeSelector != "" {
+		content, err = scraper.ExtractContentWithCSS(content, includeSelector, excludeSelectors)
+		if err != nil {
+			return "", fmt.Errorf("error extracting content with CSS: %v", err)
+		}
+	}
+
+	markdown, err := scraper.ProcessHTMLContent(content, scraper.Config{})
+	if err != nil {
+		return "", fmt.Errorf("error processing HTML content: %v", err)
+	}
+
+	parsedURL, err := url.Parse(urlStr)
+	if err != nil {
+		return "", fmt.Errorf("error parsing URL: %v", err)
+	}
+	header := fmt.Sprintf("# ::: Content from %s\n\n", parsedURL.String())
+
+	return header + markdown + "\n\n", nil
+}
+
 func getFilenameFromContent(content, urlStr string) (string, error) {
 	// Try to extract title from content
 	titleStart := strings.Index(content, "<title>")

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},
@@ -97,3 +97,58 @@ func TestGetFilenameFromContent(t *testing.T) {
 		}
 	}
 }
+
+// Mock functions for testing
+func mockExtractAndConvertContent(urlStr string) (string, error) {
+	return "Mocked content for " + urlStr, nil
+}
+
+func mockExtractLinks() ([]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)
+		}
+	}
+}

internal/config/config.go

@@ -48,8 +48,8 @@ type SiteConfig struct {
 	// ExcludePaths lists paths that should not be scraped
 	ExcludePaths []string `yaml:"exclude_paths"`
 
-	// FileNamePrefix provides the base name for output files
+	// OutputAlias provides an alternative name for output files
-	FileNamePrefix string `yaml:"file_name_prefix"`
+	OutputAlias string `yaml:"output_alias"`
 
 	// PathOverrides allows for path-specific configurations
 	PathOverrides []PathOverride `yaml:"path_overrides"`
@@ -88,14 +88,6 @@ func Load(configPath string) (*Config, error) {
 
 // Validate checks the configuration for any invalid values
 func (c *Config) Validate() error {
-	if len(c.FileExtensions) == 0 && len(c.Sites) == 0 {
-		return fmt.Errorf("file_extensions or sites must be specified")
-	}
-
-	if c.OutputType != "" && c.OutputType != "single" && c.OutputType != "separate" {
-		return fmt.Errorf("output_type must be 'single' or 'separate'")
-	}
-
 	if c.RequestsPerSecond != nil && *c.RequestsPerSecond <= 0 {
 		return fmt.Errorf("requests_per_second must be positive")
 	}

internal/config/config_test.go

@@ -10,8 +10,8 @@ func TestLoad(t *testing.T) {
 	// Create a temporary config file
 	content := []byte(`
 file_extensions:
-  - go
+  - .go
-  - md
+  - .md
 ignore_paths:
   - "*.tmp"
   - "**/*.log"
@@ -27,7 +27,7 @@ sites:
       - "/blog"
     exclude_paths:
       - "/admin"
-    file_name_prefix: "example"
+    output_alias: "example"
     path_overrides:
       - path: "/special"
         css_locator: ".special-content"
@@ -61,7 +61,7 @@ burst_limit: 5
 	rps := 1.0
 	bl := 5
 	expectedConfig := &Config{
-		FileExtensions:     []string{"go", "md"},
+		FileExtensions:     []string{".go", ".md"},
 		IgnorePaths:        []string{"*.tmp", "**/*.log"},
 		CodeGeneratedPaths: []string{"generated_*.go"},
 		Sites: []SiteConfig{
@@ -69,9 +69,10 @@ burst_limit: 5
 				BaseURL:          "https://example.com",
 				CSSLocator:       "main",
 				ExcludeSelectors: []string{".ads"},
+				MaxDepth:         2,
 				AllowedPaths:     []string{"/blog"},
 				ExcludePaths:     []string{"/admin"},
-				FileNamePrefix:   "example",
+				OutputAlias:      "example",
 				PathOverrides: []PathOverride{
 					{
 						Path:             "/special",
@@ -100,9 +101,9 @@ func TestValidate(t *testing.T) {
 		{
 			name: "Valid config",
 			config: Config{
-				FileExtensions: []string{"go"},
+				FileExtensions: []string{".go"},
 				Sites: []SiteConfig{
-					{BaseURL: "https://example.com"},
+					{BaseURL: "https://example.com", MaxDepth: 2},
 				},
 			},
 			wantErr: false,
@@ -115,7 +116,7 @@ func TestValidate(t *testing.T) {
 		{
 			name: "Invalid requests per second",
 			config: Config{
-				FileExtensions:    []string{"go"},
+				FileExtensions:    []string{".go"},
 				RequestsPerSecond: func() *float64 { f := -1.0; return &f }(),
 			},
 			wantErr: true,
@@ -123,7 +124,7 @@ func TestValidate(t *testing.T) {
 		{
 			name: "Invalid burst limit",
 			config: Config{
-				FileExtensions: []string{"go"},
+				FileExtensions: []string{".go"},
 				BurstLimit:     func() *int { i := -1; return &i }(),
 			},
 			wantErr: true,
@@ -131,32 +132,16 @@ func TestValidate(t *testing.T) {
 		{
 			name: "Site without base URL",
 			config: Config{
-				FileExtensions: []string{"go"},
+				FileExtensions: []string{".go"},
 				Sites:          []SiteConfig{{}},
 			},
 			wantErr: true,
 		},
 		{
-			name: "Valid output type single",
+			name: "Negative max depth",
 			config: Config{
-				FileExtensions: []string{"go"},
+				FileExtensions: []string{".go"},
-				OutputType:     "single",
+				Sites:          []SiteConfig{{BaseURL: "https://example.com", MaxDepth: -1}},
-			},
-			wantErr: false,
-		},
-		{
-			name: "Valid output type separate",
-			config: Config{
-				FileExtensions: []string{"go"},
-				OutputType:     "separate",
-			},
-			wantErr: false,
-		},
-		{
-			name: "Invalid output type",
-			config: Config{
-				FileExtensions: []string{"go"},
-				OutputType:     "invalid",
 			},
 			wantErr: true,
 		},

internal/scraper/scraper.go

@@ -8,7 +8,6 @@ import (
 	"math/rand"
 	"net/url"
 	"os"
-	"path/filepath"
 	"regexp"
 	"strings"
 	"sync"
@@ -48,7 +47,7 @@ type SiteConfig struct {
 	ExcludeSelectors []string
 	AllowedPaths     []string
 	ExcludePaths     []string
-	FileNamePrefix   string
+	OutputAlias      string
 	PathOverrides    []PathOverride
 }
 
@@ -59,24 +58,19 @@ 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")
 	results := make(chan struct {
 		url     string
 		content string
-		site    SiteConfig // Add site config to track which site the content came from
 		err     error
 	})
 
 	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
 	totalURLs := 0
-	for _, site := range config.Sites {
-		totalURLs += len(site.AllowedPaths)
-	}
 	for _, site := range config.Sites {
 		logger.Printf("Processing site: %s\n", site.BaseURL)
 		wg.Add(1)
@@ -84,6 +78,7 @@ func ScrapeSites(config Config) error {
 			defer wg.Done()
 			for _, path := range site.AllowedPaths {
 				fullURL := site.BaseURL + path
+				totalURLs++
 				logger.Printf("Queueing URL for scraping: %s\n", fullURL)
 				scrapeSingleURL(fullURL, site, results, limiter)
 			}
@@ -96,73 +91,71 @@ func ScrapeSites(config Config) error {
 		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 {
-		content string
-		site    SiteConfig
-	})
-
 	for result := range results {
 		if result.err != nil {
 			logger.Printf("Error scraping %s: %v\n", result.url, result.err)
 			continue
 		}
-		logger.Printf("Successfully scraped content from %s (length: %d)\n",
+		logger.Printf("Successfully scraped content from %s (length: %d)\n", result.url, len(result.content))
-			result.url, len(result.content))
+		scrapedContent[result.url] = result.content
-		scrapedContent[result.url] = struct {
-			content string
-			site    SiteConfig
-		}{
-			content: result.content,
-			site:    result.site,
-		}
 	}
 
 	logger.Printf("Total URLs processed: %d\n", totalURLs)
 	logger.Printf("Successfully scraped content from %d URLs\n", len(scrapedContent))
 
-	return SaveToFiles(scrapedContent, config)
+	return scrapedContent, nil
 }
 
 func scrapeSingleURL(url string, site SiteConfig, results chan<- struct {
 	url     string
 	content string
-	site    SiteConfig
 	err     error
-}, limiter *rate.Limiter) {
+}, limiter *rate.Limiter,
+) {
 	logger.Printf("Starting to scrape URL: %s\n", url)
 
+	// Wait for rate limiter before making the request
 	err := limiter.Wait(context.Background())
 	if err != nil {
+		logger.Printf("Rate limiter error for %s: %v\n", url, err)
 		results <- struct {
 			url     string
 			content string
-			site    SiteConfig
 			err     error
-		}{url, "", site, fmt.Errorf("rate limiter error: %v", err)}
+		}{url, "", fmt.Errorf("rate limiter error: %v", err)}
 		return
 	}
 
 	cssLocator, excludeSelectors := getOverrides(url, site)
+	logger.Printf("Using CSS locator for %s: %s\n", url, cssLocator)
+	logger.Printf("Exclude selectors for %s: %v\n", url, excludeSelectors)
+
 	content, err := scrapeURL(url, cssLocator, excludeSelectors)
 	if err != nil {
+		logger.Printf("Error scraping %s: %v\n", url, err)
 		results <- struct {
 			url     string
 			content string
-			site    SiteConfig
 			err     error
-		}{url, "", site, err}
+		}{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
-		site    SiteConfig
 		err     error
-	}{url, content, site, nil}
+	}{url, content, nil}
 }
 
+
 func isAllowedURL(urlStr string, site SiteConfig) bool {
 	parsedURL, err := url.Parse(urlStr)
 	if err != nil {
@@ -235,14 +228,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
@@ -250,7 +238,7 @@ type URLConfig struct {
 	URL              string
 	CSSLocator       string
 	ExcludeSelectors []string
-	FileNamePrefix   string
+	OutputAlias      string
 }
 
 // SetupLogger initializes the logger based on the verbose flag
@@ -278,7 +266,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)},
@@ -311,119 +299,6 @@ 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)
@@ -462,7 +337,7 @@ func FetchWebpageContent(urlStr string) (string, error) {
 	}
 
 	logger.Println("Waiting for body element")
-
+	
 	bodyElement := page.Locator("body")
 	err = bodyElement.WaitFor(playwright.LocatorWaitForOptions{
 		State: playwright.WaitForSelectorStateVisible,
@@ -534,6 +409,8 @@ 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 +442,9 @@ func scrollPage(page playwright.Page) error {
 
 		previousHeight = currentHeight
 
-		// Wait for content to load before scrolling again
+		// Wait for a while before scrolling again
-		time.Sleep(100 * time.Millisecond)
+		
+		
 	}
 
 	logger.Println("Scrolling back to top")
@@ -580,6 +458,7 @@ func scrollPage(page playwright.Page) error {
 	return 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)

internal/scraper/scraper_test.go

@@ -3,8 +3,8 @@ package scraper
 import (
 	"io"
 	"log"
-	// "net/http"
+	"net/http"
-	// "net/http/httptest"
+	"net/http/httptest"
 	"reflect"
 	"strings"
 	"testing"
@@ -143,39 +143,39 @@ This is a **test** paragraph.
 	}
 }
 
-// func TestExtractLinks(t *testing.T) {
+func TestExtractLinks(t *testing.T) {
-// 	// Initialize Playwright before running the test
+	// Initialize Playwright before running the test
-// 	if err := InitPlaywright(); err != nil {
+	if err := InitPlaywright(); err != nil {
-// 		t.Fatalf("Failed to initialize Playwright: %v", err)
+		t.Fatalf("Failed to initialize Playwright: %v", err)
-// 	}
+	}
-// 	defer ClosePlaywright()
+	defer ClosePlaywright()
 
-// 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-// 		w.Header().Set("Content-Type", "text/html")
+		w.Header().Set("Content-Type", "text/html")
-// 		w.Write([]byte(`
+		w.Write([]byte(`
-// 			<html>
+			<html>
-// 				<body>
+				<body>
-// 					<a href="https://example.com/page1">Page 1</a>
+					<a href="https://example.com/page1">Page 1</a>
-// 					<a href="https://example.com/page2">Page 2</a>
+					<a href="https://example.com/page2">Page 2</a>
-// 					<a href="https://othersite.com">Other Site</a>
+					<a href="https://othersite.com">Other Site</a>
-// 				</body>
+				</body>
-// 			</html>
+			</html>
-// 		`))
+		`))
-// 	}))
+	}))
-// 	defer server.Close()
+	defer server.Close()
 
-// 	links, err := ExtractLinks(server.URL)
+	links, err := ExtractLinks(server.URL)
-// 	if err != nil {
+	if err != nil {
-// 		t.Fatalf("ExtractLinks() returned error: %v", err)
+		t.Fatalf("ExtractLinks() returned error: %v", err)
-// 	}
+	}
 
-// 	expectedLinks := []string{
+	expectedLinks := []string{
-// 		"https://example.com/page1",
+		"https://example.com/page1",
-// 		"https://example.com/page2",
+		"https://example.com/page2",
-// 		"https://othersite.com",
+		"https://othersite.com",
-// 	}
+	}
 
-// 	if !reflect.DeepEqual(links, expectedLinks) {
+	if !reflect.DeepEqual(links, expectedLinks) {
-// 		t.Errorf("ExtractLinks() = %v, want %v", links, expectedLinks)
+		t.Errorf("ExtractLinks() = %v, want %v", links, expectedLinks)
-// 	}
+	}
-// }
+}

main.go

@@ -2,13 +2,42 @@ package main
 
 import (
 	"fmt"
+	"log"
 	"os"
 
 	"github.com/tnypxl/rollup/cmd"
+	"github.com/tnypxl/rollup/internal/config"
+	"github.com/tnypxl/rollup/internal/scraper"
 )
 
+var cfg *config.Config
+
 func main() {
-	if err := cmd.Execute(); err != nil {
+	// Check if the command is "help"
+	isHelpCommand := len(os.Args) > 1 && (os.Args[1] == "help" || os.Args[1] == "--help" || os.Args[1] == "-h")
+
+	var cfg *config.Config
+	var err error
+
+	if !isHelpCommand {
+		configPath := "rollup.yml"
+		cfg, err = config.Load(configPath)
+		if err != nil {
+			log.Printf("Warning: Failed to load configuration: %v", err)
+			// Continue execution without a config file
+		}
+
+		// Initialize the scraper logger with default verbosity (false)
+		scraper.SetupLogger(false)
+
+		err = scraper.InitPlaywright()
+		if err != nil {
+			log.Fatalf("Failed to initialize Playwright: %v", err)
+		}
+		defer scraper.ClosePlaywright()
+	}
+
+	if err := cmd.Execute(cfg); err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}