Merge pull request #27 from Priyans-hu/feat/modernize-go-patterns

Modernize Go patterns: stdlib strings, context.Context, slog

Author: Priyans-hu

CLAUDE.md

@@ -4,9 +4,11 @@ import (
 	"archive/tar"
 	"archive/zip"
 	"compress/gzip"
+	"context"
 	"encoding/json"
 	"fmt"
 	"io"
+	"log/slog"
 	"net/http"
 	"os"
 	"os/signal"
@@ -49,6 +51,21 @@ Argus scans your codebase and generates optimized context files
 for AI coding assistants (Claude Code, Cursor, Copilot, etc.).
 
 No more manually writing CLAUDE.md or .cursorrules - Argus sees everything.`,
+	PersistentPreRun: func(cmd *cobra.Command, args []string) {
+		setupLogging()
+	},
+}
+
+// setupLogging configures slog based on verbose flag
+func setupLogging() {
+	level := slog.LevelInfo
+	if verbose {
+		level = slog.LevelDebug
+	}
+	handler := slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{
+		Level: level,
+	})
+	slog.SetDefault(slog.New(handler))
 }
 
 var initCmd = &cobra.Command{
@@ -229,14 +246,26 @@ func runScan(cmd *cobra.Command, args []string) error {
 		fmt.Println("   Using parallel detector execution...")
 	}
 
+	// Create context with cancellation support
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	// Handle interrupt signals for graceful cancellation
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
+	go func() {
+		<-sigChan
+		cancel()
+	}()
+
 	// Run analysis (parallel or sequential)
 	var analysis *types.Analysis
 	if parallel {
 		pa := analyzer.NewParallelAnalyzer(absPath, nil)
-		analysis, err = pa.Analyze()
+		analysis, err = pa.Analyze(ctx)
 	} else {
 		a := analyzer.NewAnalyzer(absPath, nil)
-		analysis, err = a.Analyze()
+		analysis, err = a.Analyze(ctx)
 	}
 	if err != nil {
 		return fmt.Errorf("analysis failed: %w", err)
@@ -300,14 +329,26 @@ func runSync(cmd *cobra.Command, args []string) error {
 		fmt.Println("   Using parallel detector execution...")
 	}
 
+	// Create context with cancellation support
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	// Handle interrupt signals for graceful cancellation
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
+	go func() {
+		<-sigChan
+		cancel()
+	}()
+
 	// Run analysis (parallel or sequential)
 	var analysis *types.Analysis
 	if parallel {
 		pa := analyzer.NewParallelAnalyzer(absPath, nil)
-		analysis, err = pa.Analyze()
+		analysis, err = pa.Analyze(ctx)
 	} else {
 		a := analyzer.NewAnalyzer(absPath, nil)
-		analysis, err = a.Analyze()
+		analysis, err = a.Analyze(ctx)
 	}
 	if err != nil {
 		return fmt.Errorf("analysis failed: %w", err)
@@ -537,12 +578,16 @@ func runWatch(cmd *cobra.Command, args []string) error {
 	fmt.Println("   Press Ctrl+C to stop")
 	fmt.Println()
 
+	// Create context with cancellation for watch mode
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
 	// Create incremental analyzer
 	incAnalyzer := analyzer.NewIncrementalAnalyzer(absPath)
 
 	// Do initial full generation
 	fmt.Println("🔍 Running initial full analysis...")
-	if err := regenerateWithAnalyzer(absPath, cfg, incAnalyzer, "", true); err != nil {
+	if err := regenerateWithAnalyzer(ctx, absPath, cfg, incAnalyzer, "", true); err != nil {
 		fmt.Printf("⚠️  Initial generation failed: %v\n", err)
 	}
 
@@ -582,7 +627,7 @@ func runWatch(cmd *cobra.Command, args []string) error {
 
 			changedFile := lastChangedFile // Capture for closure
 			debounceTimer = time.AfterFunc(debounceDelay, func() {
-				if err := regenerateWithAnalyzer(absPath, cfg, incAnalyzer, changedFile, false); err != nil {
+				if err := regenerateWithAnalyzer(ctx, absPath, cfg, incAnalyzer, changedFile, false); err != nil {
 					fmt.Printf("⚠️  Regeneration failed: %v\n", err)
 				}
 			})
@@ -600,7 +645,7 @@ func runWatch(cmd *cobra.Command, args []string) error {
 	}
 }
 
-func regenerateWithAnalyzer(absPath string, cfg *config.Config, incAnalyzer *analyzer.IncrementalAnalyzer, changedFile string, isInitial bool) error {
+func regenerateWithAnalyzer(ctx context.Context, absPath string, cfg *config.Config, incAnalyzer *analyzer.IncrementalAnalyzer, changedFile string, isInitial bool) error {
 	var analysis *types.Analysis
 	var impacts []string
 	var err error
@@ -609,11 +654,11 @@ func regenerateWithAnalyzer(absPath string, cfg *config.Config, incAnalyzer *ana
 
 	if isInitial || changedFile == "" {
 		// Full analysis for initial run
-		analysis, err = incAnalyzer.AnalyzeFull()
+		analysis, err = incAnalyzer.AnalyzeFull(ctx)
 		impacts = []string{analyzer.ImpactAll}
 	} else {
 		// Incremental analysis for file changes
-		analysis, impacts, err = incAnalyzer.AnalyzeIncremental(changedFile)
+		analysis, impacts, err = incAnalyzer.AnalyzeIncremental(ctx, changedFile)
 	}
 
 	if err != nil {

cmd/argus/main.go

@@ -1,10 +1,13 @@
 package analyzer
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
+	"log/slog"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"github.com/Priyans-hu/argus/internal/detector"
 	"github.com/Priyans-hu/argus/pkg/types"
@@ -25,7 +28,16 @@ func NewAnalyzer(rootPath string, config *types.Config) *Analyzer {
 }
 
 // Analyze performs the full codebase analysis
-func (a *Analyzer) Analyze() (*types.Analysis, error) {
+func (a *Analyzer) Analyze(ctx context.Context) (*types.Analysis, error) {
+	// Check for cancellation
+	select {
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	default:
+	}
+
+	slog.Debug("starting analysis", "rootPath", a.rootPath)
+
 	// Get absolute path
 	absPath, err := filepath.Abs(a.rootPath)
 	if err != nil {
@@ -37,11 +49,13 @@ func (a *Analyzer) Analyze() (*types.Analysis, error) {
 
 	// Walk the file tree
 	walker := NewWalker(absPath)
-	files, err := walker.Walk()
+	files, err := walker.Walk(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("failed to walk directory: %w", err)
 	}
 
+	slog.Debug("file walk complete", "fileCount", len(files))
+
 	// Initialize analysis
 	analysis := &types.Analysis{
 		ProjectName: projectName,
@@ -203,10 +217,10 @@ func (a *Analyzer) detectDependencies(rootPath string) []types.Dependency {
 	// Try go.mod (simplified)
 	modPath := filepath.Join(rootPath, "go.mod")
 	if data, err := os.ReadFile(modPath); err == nil {
-		lines := splitLines(string(data))
+		lines := strings.Split(string(data), "\n")
 		inRequire := false
 		for _, line := range lines {
-			line = trimSpace(line)
+			line = strings.TrimSpace(line)
 			if line == "require (" {
 				inRequire = true
 				continue
@@ -217,11 +231,11 @@ func (a *Analyzer) detectDependencies(rootPath string) []types.Dependency {
 			}
 			if inRequire && line != "" {
 				// Skip indirect dependencies
-				if contains(line, "// indirect") {
+				if strings.Contains(line, "// indirect") {
 					continue
 				}
 
-				parts := splitFields(line)
+				parts := strings.Fields(line)
 				if len(parts) >= 2 {
 					pkgName := parts[0]
 
@@ -246,83 +260,20 @@ func (a *Analyzer) detectDependencies(rootPath string) []types.Dependency {
 // isInternalPackage checks if a package path is internal/vendor
 func isInternalPackage(pkg string) bool {
 	// Skip internal subpackages
-	if contains(pkg, "/internal/") {
+	if strings.Contains(pkg, "/internal/") {
 		return true
 	}
 	// Skip service-specific subpackages (AWS SDK pattern)
-	if contains(pkg, "/service/internal/") {
+	if strings.Contains(pkg, "/service/internal/") {
 		return true
 	}
 	// Skip feature subpackages
-	if contains(pkg, "/feature/") {
+	if strings.Contains(pkg, "/feature/") {
 		return true
 	}
 	return false
 }
 
-// contains checks if s contains substr (simple implementation)
-func contains(s, substr string) bool {
-	return len(s) >= len(substr) && findSubstring(s, substr) >= 0
-}
-
-func findSubstring(s, substr string) int {
-	for i := 0; i <= len(s)-len(substr); i++ {
-		if s[i:i+len(substr)] == substr {
-			return i
-		}
-	}
-	return -1
-}
-
-// Helper functions to avoid importing strings package multiple times
-func splitLines(s string) []string {
-	var lines []string
-	start := 0
-	for i := 0; i < len(s); i++ {
-		if s[i] == '\n' {
-			lines = append(lines, s[start:i])
-			start = i + 1
-		}
-	}
-	if start < len(s) {
-		lines = append(lines, s[start:])
-	}
-	return lines
-}
-
-func trimSpace(s string) string {
-	start := 0
-	end := len(s)
-	for start < end && (s[start] == ' ' || s[start] == '\t' || s[start] == '\r') {
-		start++
-	}
-	for end > start && (s[end-1] == ' ' || s[end-1] == '\t' || s[end-1] == '\r') {
-		end--
-	}
-	return s[start:end]
-}
-
-func splitFields(s string) []string {
-	var fields []string
-	start := -1
-	for i, c := range s {
-		if c == ' ' || c == '\t' {
-			if start >= 0 {
-				fields = append(fields, s[start:i])
-				start = -1
-			}
-		} else {
-			if start < 0 {
-				start = i
-			}
-		}
-	}
-	if start >= 0 {
-		fields = append(fields, s[start:])
-	}
-	return fields
-}
-
 // detectPyProjectCommands extracts commands from pyproject.toml
 func detectPyProjectCommands(info *detector.PyProjectInfo) []types.Command {
 	var commands []types.Command

internal/analyzer/analyzer.go

@@ -1,6 +1,7 @@
 package analyzer
 
 import (
+	"context"
 	"path/filepath"
 	"strings"
 	"sync"
@@ -43,9 +44,9 @@ func NewIncrementalAnalyzer(rootPath string) *IncrementalAnalyzer {
 }
 
 // AnalyzeFull performs a full analysis and caches the result
-func (ia *IncrementalAnalyzer) AnalyzeFull() (*types.Analysis, error) {
+func (ia *IncrementalAnalyzer) AnalyzeFull(ctx context.Context) (*types.Analysis, error) {
 	a := NewAnalyzer(ia.rootPath, nil)
-	analysis, err := a.Analyze()
+	analysis, err := a.Analyze(ctx)
 	if err != nil {
 		return nil, err
 	}
@@ -59,12 +60,12 @@ func (ia *IncrementalAnalyzer) AnalyzeFull() (*types.Analysis, error) {
 }
 
 // AnalyzeIncremental performs incremental analysis based on changed file
-func (ia *IncrementalAnalyzer) AnalyzeIncremental(changedFile string) (*types.Analysis, []string, error) {
+func (ia *IncrementalAnalyzer) AnalyzeIncremental(ctx context.Context, changedFile string) (*types.Analysis, []string, error) {
 	// If no cache, do full analysis
 	ia.cacheMu.RLock()
 	if ia.cache == nil {
 		ia.cacheMu.RUnlock()
-		analysis, err := ia.AnalyzeFull()
+		analysis, err := ia.AnalyzeFull(ctx)
 		return analysis, []string{ImpactAll}, err
 	}
 	ia.cacheMu.RUnlock()
@@ -75,13 +76,13 @@ func (ia *IncrementalAnalyzer) AnalyzeIncremental(changedFile string) (*types.An
 	// If all impacts, do full analysis
 	for _, impact := range impacts {
 		if impact == ImpactAll {
-			analysis, err := ia.AnalyzeFull()
+			analysis, err := ia.AnalyzeFull(ctx)
 			return analysis, impacts, err
 		}
 	}
 
 	// Get fresh file list
-	files, err := ia.walker.Walk()
+	files, err := ia.walker.Walk(ctx)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -95,7 +96,7 @@ func (ia *IncrementalAnalyzer) AnalyzeIncremental(changedFile string) (*types.An
 	for _, impact := range impacts {
 		if err := ia.runDetector(impact, files, analysis); err != nil {
 			// On error, fall back to full analysis
-			fullAnalysis, fullErr := ia.AnalyzeFull()
+			fullAnalysis, fullErr := ia.AnalyzeFull(ctx)
 			return fullAnalysis, []string{ImpactAll}, fullErr
 		}
 	}