Refactor monolithic code into maintainable Go modules with improved test coverage

- Split 1066-line main.go into focused domain files (article.go, audio.go, openai.go, text.go)
- Move interfaces to consumer side following Go conventions
- Replace functions with many parameters using parameter structs
- Create separate podcast/types.go package to prevent circular dependencies
- Generate mocks using moq for all interfaces
- Increase test coverage from 14.6% to 23.8%
- Add comprehensive tests for OpenAI service, text processing, and article fetching
- Update linter configuration for better code quality

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: umputun

.golangci.yml

@@ -1,89 +1,84 @@
-linters-settings:
-  govet:
-    shadow: true
-  golint:
-    min-confidence: 0.6
-  gocyclo:
-    min-complexity: 15
-  maligned:
-    suggest-new: true
-  dupl:
-    threshold: 100
-  goconst:
-    min-len: 2
-    min-occurrences: 2
-  misspell:
-    locale: US
-  lll:
-    line-length: 140
-  gocritic:
-    enabled-tags:
-      - performance
-      - style
-      - experimental
-    disabled-checks:
-      - wrapperFunc
-      - hugeParam
-      - rangeValCopy
-
+version: "2"
+run:
+  concurrency: 4
 linters:
-  disable-all: true
+  default: none
   enable:
-    - revive
-    - govet
-    - unconvert
-    - gosec
-    - misspell
-    - unused
-    - typecheck
-    - ineffassign
-    - stylecheck
     - gochecknoinits
     - gocritic
+    - gosec
+    - govet
+    - ineffassign
+    - misspell
     - nakedret
-    - gosimple
     - prealloc
-
-  fast: false
-
-
-run:
-  #  modules-download-mode: vendor
-
-  concurrency: 4
-
-issues:
-  exclude-dirs:
-    - vendor
-  exclude-rules:
-    - text: "should have a package comment, unless it's in another file for this package"
-      linters:
-        - golint
-    - text: "exitAfterDefer:"
-      linters:
-        - gocritic
-    - text: "whyNoLint: include an explanation for nolint directive"
-      linters:
-        - gocritic
-    - text: "go.mongodb.org/mongo-driver/bson/primitive.E"
-      linters:
-        - govet
-    - text: "weak cryptographic primitive"
-      linters:
-        - gosec
-    - text: "at least one file in a package should have a package comment"
-      linters:
-        - stylecheck
-    - text: "package-comments: should have a package comment"
-      linters:
-        - revive
-    - text: 'Deferring unsafe method "Close" on type "io.ReadCloser"'
-      linters:
-        - gosec
-    - linters:
-        - unparam
-        - unused
-        - revive
-      path: _test\.go$
-      text: "unused-parameter"
-  exclude-use-default: false
+    - revive
+    - staticcheck
+    - unconvert
+    - unused
+  settings:
+    dupl:
+      threshold: 100
+    goconst:
+      min-len: 2
+      min-occurrences: 2
+    gocritic:
+      disabled-checks:
+        - wrapperFunc
+        - hugeParam
+        - rangeValCopy
+      enabled-tags:
+        - performance
+        - style
+        - experimental
+    gocyclo:
+      min-complexity: 15
+    lll:
+      line-length: 140
+    misspell:
+      locale: US
+  exclusions:
+    generated: lax
+    rules:
+      - linters:
+          - revive
+        text: should have a package comment, unless it's in another file for this package
+      - linters:
+          - gocritic
+        text: 'exitAfterDefer:'
+      - linters:
+          - gocritic
+        text: 'whyNoLint: include an explanation for nolint directive'
+      - linters:
+          - govet
+        text: go.mongodb.org/mongo-driver/bson/primitive.E
+      - linters:
+          - gosec
+        text: weak cryptographic primitive
+      - linters:
+          - staticcheck
+        text: at least one file in a package should have a package comment
+      - linters:
+          - revive
+        text: 'package-comments: should have a package comment'
+      - linters:
+          - gosec
+        text: Deferring unsafe method "Close" on type "io.ReadCloser"
+      - linters:
+          - revive
+          - unparam
+          - unused
+        path: _test\.go$
+        text: unused-parameter
+    paths:
+      - vendor
+      - third_party$
+      - builtin$
+      - examples$
+formatters:
+  exclusions:
+    generated: lax
+    paths:
+      - third_party$
+      - builtin$
+      - examples$

article.go

@@ -0,0 +1,81 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/PuerkitoBio/goquery"
+)
+
+// HTTPArticleFetcher implements article fetching using HTTP
+type HTTPArticleFetcher struct {
+	client *http.Client
+}
+
+// NewHTTPArticleFetcher creates a new HTTP article fetcher
+func NewHTTPArticleFetcher(client *http.Client) *HTTPArticleFetcher {
+	if client == nil {
+		client = http.DefaultClient
+	}
+	return &HTTPArticleFetcher{client: client}
+}
+
+// Fetch downloads and extracts text from the given URL
+func (f *HTTPArticleFetcher) Fetch(url string) (content, title string, err error) {
+	// #nosec G107 -- URL is provided by command-line flag
+	resp, err := f.client.Get(url)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to fetch URL: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return "", "", fmt.Errorf("failed to fetch article: status code %d", resp.StatusCode)
+	}
+
+	// parse the HTML
+	doc, err := goquery.NewDocumentFromReader(resp.Body)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to parse HTML: %w", err)
+	}
+
+	// extract title
+	title = doc.Find("title").Text()
+
+	// extract article content
+	content = f.extractContent(doc)
+
+	// limit article length for API calls
+	const maxContentLength = 8000
+	if len(content) > maxContentLength {
+		content = content[:maxContentLength] + "..."
+	}
+
+	return content, title, nil
+}
+
+// extractContent extracts the main text content from the HTML document
+func (f *HTTPArticleFetcher) extractContent(doc *goquery.Document) string {
+	var articleText strings.Builder
+
+	// first try to find article content in common containers
+	article := doc.Find("article, .article, .post, .content, main")
+	if article.Length() > 0 {
+		article.Find("p").Each(func(_ int, s *goquery.Selection) {
+			articleText.WriteString(s.Text())
+			articleText.WriteString("\n\n")
+		})
+	} else {
+		// fallback to all paragraphs
+		doc.Find("p").Each(func(_ int, s *goquery.Selection) {
+			// skip very short paragraphs which are likely not article content
+			if len(s.Text()) > 50 {
+				articleText.WriteString(s.Text())
+				articleText.WriteString("\n\n")
+			}
+		})
+	}
+
+	return strings.TrimSpace(articleText.String())
+}

article_test.go

@@ -0,0 +1,140 @@
+package main
+
+import (
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestHTTPArticleFetcher_Fetch(t *testing.T) {
+	tests := []struct {
+		name            string
+		html            string
+		statusCode      int
+		expectedTitle   string
+		expectedContent string
+		expectError     bool
+	}{
+		{
+			name: "successful fetch with article tag",
+			html: `<html>
+				<head><title>Test Article</title></head>
+				<body>
+					<article>
+						<p>This is the first paragraph of the article.</p>
+						<p>This is the second paragraph with more content.</p>
+					</article>
+				</body>
+			</html>`,
+			statusCode:      http.StatusOK,
+			expectedTitle:   "Test Article",
+			expectedContent: "This is the first paragraph of the article.\n\nThis is the second paragraph with more content.",
+			expectError:     false,
+		},
+		{
+			name: "successful fetch with class content",
+			html: `<html>
+				<head><title>Another Article</title></head>
+				<body>
+					<div class="content">
+						<p>Content paragraph one.</p>
+						<p>Content paragraph two with enough text to be included.</p>
+					</div>
+				</body>
+			</html>`,
+			statusCode:      http.StatusOK,
+			expectedTitle:   "Another Article",
+			expectedContent: "Content paragraph one.\n\nContent paragraph two with enough text to be included.",
+			expectError:     false,
+		},
+		{
+			name: "fallback to all paragraphs",
+			html: `<html>
+				<head><title>Simple Page</title></head>
+				<body>
+					<p>Short.</p>
+					<p>This is a longer paragraph that should be included in the content extraction.</p>
+					<p>Another long paragraph with sufficient content to pass the length filter.</p>
+				</body>
+			</html>`,
+			statusCode:      http.StatusOK,
+			expectedTitle:   "Simple Page",
+			expectedContent: "This is a longer paragraph that should be included in the content extraction.\n\nAnother long paragraph with sufficient content to pass the length filter.",
+			expectError:     false,
+		},
+		{
+			name:            "error status code",
+			html:            "<html><body>Not Found</body></html>",
+			statusCode:      http.StatusNotFound,
+			expectedTitle:   "",
+			expectedContent: "",
+			expectError:     true,
+		},
+		{
+			name: "content length limit",
+			html: `<html>
+				<head><title>Long Article</title></head>
+				<body>
+					<article>
+						<p>` + strings.Repeat("A", 9000) + `</p>
+					</article>
+				</body>
+			</html>`,
+			statusCode:      http.StatusOK,
+			expectedTitle:   "Long Article",
+			expectedContent: strings.Repeat("A", 8000) + "...",
+			expectError:     false,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			// create test server
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(tc.statusCode)
+				_, _ = w.Write([]byte(tc.html))
+			}))
+			defer server.Close()
+
+			// create fetcher
+			fetcher := NewHTTPArticleFetcher(server.Client())
+
+			// fetch article
+			content, title, err := fetcher.Fetch(server.URL)
+
+			if tc.expectError {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tc.expectedTitle, title)
+				assert.Equal(t, tc.expectedContent, strings.TrimSpace(content))
+			}
+		})
+	}
+}
+
+func TestHTTPArticleFetcher_FetchWithNetworkError(t *testing.T) {
+	// create fetcher with custom client that always fails
+	client := &http.Client{
+		Transport: &failingTransport{},
+	}
+	fetcher := NewHTTPArticleFetcher(client)
+
+	content, title, err := fetcher.Fetch("http://example.com")
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "failed to fetch URL")
+	assert.Empty(t, content)
+	assert.Empty(t, title)
+}
+
+// failingTransport is a custom transport that always returns an error
+type failingTransport struct{}
+
+func (f *failingTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	return nil, io.ErrUnexpectedEOF
+}