feat: improve analyze command

Author: pedronauck

cmd/gograph/commands/analyze.go

@@ -3,6 +3,7 @@ package commands
 import (
 	"context"
 	"fmt"
+	"os"
 	"sync"
 	"time"
 
@@ -15,6 +16,7 @@ import (
 	"github.com/compozy/gograph/pkg/errors"
 	"github.com/compozy/gograph/pkg/logger"
 	"github.com/compozy/gograph/pkg/progress"
+	"github.com/mattn/go-isatty"
 	"github.com/spf13/cobra"
 )
 
@@ -116,6 +118,14 @@ The resulting graph allows you to:
 				return runAnalysisWithoutProgress(projectPath, projectID, parserConfig, analyzerConfig, neo4jConfig)
 			}
 
+			// Check if we're in TTY mode and suppress logging if so
+			isTTY := isatty.IsTerminal(os.Stdout.Fd()) || isatty.IsCygwinTerminal(os.Stdout.Fd())
+			if isTTY {
+				// Suppress all logging output to avoid conflicts with TUI
+				logger.Disable()
+				defer logger.Enable() // Re-enable after completion
+			}
+
 			return runAnalysisWithProgress(projectPath, projectID, parserConfig, analyzerConfig, neo4jConfig)
 		})
 	},
@@ -206,89 +216,156 @@ func runAnalysisWithProgress(
 	neo4jConfig *infra.Neo4jConfig,
 ) error {
 	ctx := context.Background()
-	startTime := time.Now()
 
-	var parseResult *parser.ParseResult
-	var report *analyzer.AnalysisReport
-	var graphResult *core.AnalysisResult
+	// Initialize adaptive progress
+	progressIndicator := progress.NewAdaptiveProgress(os.Stdout)
+	phases := []progress.PhaseInfo{
+		{Name: "Parsing", Description: "Scanning and parsing Go source files", Weight: 0.3},
+		{Name: "Analysis", Description: "Analyzing code structure and relationships", Weight: 0.3},
+		{Name: "Graph Building", Description: "Building graph representation", Weight: 0.2},
+		{Name: "Storage", Description: "Storing results in Neo4j", Weight: 0.2},
+	}
+	progressIndicator.SetPhases(phases)
+	progressIndicator.Start(fmt.Sprintf("Analyzing project: %s", projectPath))
 
-	// -----
-	// Parsing Phase
-	// -----
-	err := progress.WithProgress("Parsing project files", func() error {
-		parserService := parser.NewService(parserConfig)
-		var err error
-		parseResult, err = parserService.ParseProject(ctx, projectPath, parserConfig)
-		return err
-	})
+	// Parse project
+	parseResult, err := runParsingPhase(ctx, projectPath, parserConfig, progressIndicator)
 	if err != nil {
-		return fmt.Errorf("failed to parse project: %w", err)
+		return err
 	}
 
-	// -----
-	// Analysis Phase
-	// -----
-	err = progress.WithProgress("Analyzing code structure", func() error {
-		analyzerService := analyzer.NewAnalyzer(analyzerConfig)
-		analysisInput := &analyzer.AnalysisInput{
-			ProjectID: projectID.String(),
-			Files:     parseResult.Files,
-		}
-		var err error
-		report, err = analyzerService.AnalyzeProject(ctx, analysisInput)
-		return err
-	})
+	// Analyze project
+	report, err := runAnalysisPhase(ctx, projectID, parseResult, analyzerConfig, progressIndicator)
 	if err != nil {
-		return fmt.Errorf("failed to analyze project: %w", err)
+		return err
 	}
 
-	// -----
-	// Graph Building Phase
-	// -----
-	err = progress.WithProgress("Building graph representation", func() error {
-		builder := graph.NewBuilder(nil) // Use default config
-		var err error
-		graphResult, err = builder.BuildFromAnalysis(ctx, projectID, parseResult, report)
-		return err
-	})
+	// Build graph
+	graphResult, err := runGraphBuildingPhase(ctx, projectID, parseResult, report, progressIndicator)
 	if err != nil {
-		return fmt.Errorf("failed to build graph: %w", err)
+		return err
 	}
 
-	// -----
-	// Storage Phase
-	// -----
-	err = progress.WithProgressSteps("Storing in Neo4j", func(update func(string), _ func(int, int)) error {
-		update("Connecting to database")
-		repo, err := infra.NewNeo4jRepository(neo4jConfig)
-		if err != nil {
-			return fmt.Errorf("failed to create Neo4j repository: %w", err)
-		}
-		defer repo.Close()
-
-		update("Storing nodes and relationships")
-		return repo.StoreAnalysis(ctx, graphResult)
-	})
+	// Store results
+	err = runStoragePhase(ctx, graphResult, neo4jConfig, progressIndicator)
 	if err != nil {
-		return fmt.Errorf("failed to store analysis: %w", err)
+		return err
 	}
 
-	duration := time.Since(startTime)
+	// Success with detailed statistics
+	successMsg := "Analysis completed successfully!"
+
+	// Create detailed statistics
+	stats := progress.AnalysisStats{
+		Files:         len(parseResult.Files),
+		Nodes:         len(graphResult.Nodes),
+		Relationships: len(graphResult.Relationships),
+		Interfaces:    len(report.InterfaceImplementations),
+		CallChains:    len(report.CallChains),
+		ProjectID:     projectID.String(),
+	}
 
-	// Final summary
-	logger.Info("✓ Analysis completed successfully")
-	logger.Info("Summary:",
-		"files", len(parseResult.Files),
-		"nodes", len(graphResult.Nodes),
-		"relationships", len(graphResult.Relationships),
-		"duration", duration.Round(time.Millisecond),
-		"project_id", projectID)
+	progressIndicator.SuccessWithStats(successMsg, stats)
 
 	return nil
 }
 
 var initAnalyzeOnce sync.Once
 
+func runParsingPhase(
+	ctx context.Context,
+	projectPath string,
+	parserConfig *parser.Config,
+	progressIndicator *progress.AdaptiveProgress,
+) (*parser.ParseResult, error) {
+	progressIndicator.UpdatePhase("Parsing")
+	progressIndicator.UpdateProgress(0.0, "Initializing parser")
+
+	parserService := parser.NewService(parserConfig)
+	progressIndicator.UpdateProgress(0.1, "Scanning project files")
+
+	parseResult, err := parserService.ParseProject(ctx, projectPath, parserConfig)
+	if err != nil {
+		progressIndicator.Error(fmt.Errorf("failed to parse project: %w", err))
+		return nil, fmt.Errorf("failed to parse project: %w", err)
+	}
+	progressIndicator.UpdateProgress(0.25, fmt.Sprintf("Parsed %d files", len(parseResult.Files)))
+	return parseResult, nil
+}
+
+func runAnalysisPhase(
+	ctx context.Context,
+	projectID core.ID,
+	parseResult *parser.ParseResult,
+	analyzerConfig *analyzer.Config,
+	progressIndicator *progress.AdaptiveProgress,
+) (*analyzer.AnalysisReport, error) {
+	progressIndicator.UpdatePhase("Analysis")
+	progressIndicator.UpdateProgress(0.3, "Initializing analyzer")
+
+	analyzerService := analyzer.NewAnalyzer(analyzerConfig)
+	analysisInput := &analyzer.AnalysisInput{
+		ProjectID: projectID.String(),
+		Files:     parseResult.Files,
+	}
+	progressIndicator.UpdateProgress(0.4, "Analyzing structure and dependencies")
+
+	report, err := analyzerService.AnalyzeProject(ctx, analysisInput)
+	if err != nil {
+		progressIndicator.Error(fmt.Errorf("failed to analyze project: %w", err))
+		return nil, fmt.Errorf("failed to analyze project: %w", err)
+	}
+	progressIndicator.UpdateProgress(0.55, fmt.Sprintf("Found %d interfaces, %d call chains",
+		len(report.InterfaceImplementations), len(report.CallChains)))
+	return report, nil
+}
+
+func runGraphBuildingPhase(
+	ctx context.Context,
+	projectID core.ID,
+	parseResult *parser.ParseResult,
+	report *analyzer.AnalysisReport,
+	progressIndicator *progress.AdaptiveProgress,
+) (*core.AnalysisResult, error) {
+	progressIndicator.UpdatePhase("Graph Building")
+	progressIndicator.UpdateProgress(0.6, "Building graph nodes and relationships")
+
+	builder := graph.NewBuilder(nil) // Use default config
+	graphResult, err := builder.BuildFromAnalysis(ctx, projectID, parseResult, report)
+	if err != nil {
+		progressIndicator.Error(fmt.Errorf("failed to build graph: %w", err))
+		return nil, fmt.Errorf("failed to build graph: %w", err)
+	}
+	progressIndicator.UpdateProgress(0.75, fmt.Sprintf("Built %d nodes, %d relationships",
+		len(graphResult.Nodes), len(graphResult.Relationships)))
+	return graphResult, nil
+}
+
+func runStoragePhase(
+	ctx context.Context,
+	graphResult *core.AnalysisResult,
+	neo4jConfig *infra.Neo4jConfig,
+	progressIndicator *progress.AdaptiveProgress,
+) error {
+	progressIndicator.UpdatePhase("Storage")
+	progressIndicator.UpdateProgress(0.8, "Connecting to Neo4j database")
+
+	repo, err := infra.NewNeo4jRepository(neo4jConfig)
+	if err != nil {
+		progressIndicator.Error(fmt.Errorf("failed to create Neo4j repository: %w", err))
+		return fmt.Errorf("failed to create Neo4j repository: %w", err)
+	}
+	defer repo.Close()
+
+	progressIndicator.UpdateProgress(0.9, "Storing nodes and relationships")
+	err = repo.StoreAnalysis(ctx, graphResult)
+	if err != nil {
+		progressIndicator.Error(fmt.Errorf("failed to store analysis: %w", err))
+		return fmt.Errorf("failed to store analysis: %w", err)
+	}
+	return nil
+}
+
 // InitAnalyzeCommand registers the analyze command
 func InitAnalyzeCommand() {
 	initAnalyzeOnce.Do(func() {

go.mod

@@ -7,11 +7,12 @@ toolchain go1.24.4
 require (
 	github.com/avast/retry-go/v4 v4.6.1
 	github.com/charmbracelet/bubbles v0.21.0
-	github.com/charmbracelet/bubbletea v1.3.4
+	github.com/charmbracelet/bubbletea v1.3.5
 	github.com/charmbracelet/lipgloss v1.1.0
 	github.com/charmbracelet/log v0.3.1
 	github.com/google/uuid v1.6.0
 	github.com/mark3labs/mcp-go v0.32.0
+	github.com/mattn/go-isatty v0.0.20
 	github.com/neo4j/neo4j-go-driver/v5 v5.28.1
 	github.com/sashabaranov/go-openai v1.40.3
 	github.com/spf13/cobra v1.9.1
@@ -24,6 +25,7 @@ require (
 require (
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
 	github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc // indirect
+	github.com/charmbracelet/harmonica v0.2.0 // indirect
 	github.com/charmbracelet/x/ansi v0.8.0 // indirect
 	github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd // indirect
 	github.com/charmbracelet/x/term v0.2.1 // indirect
@@ -35,7 +37,6 @@ require (
 	github.com/google/go-cmp v0.7.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-localereader v0.0.1 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect

go.sum

@@ -6,8 +6,12 @@ github.com/charmbracelet/bubbles v0.21.0 h1:9TdC97SdRVg/1aaXNVWfFH3nnLAwOXr8Fn6u
 github.com/charmbracelet/bubbles v0.21.0/go.mod h1:HF+v6QUR4HkEpz62dx7ym2xc71/KBHg+zKwJtMw+qtg=
 github.com/charmbracelet/bubbletea v1.3.4 h1:kCg7B+jSCFPLYRA52SDZjr51kG/fMUEoPoZrkaDHyoI=
 github.com/charmbracelet/bubbletea v1.3.4/go.mod h1:dtcUCyCGEX3g9tosuYiut3MXgY/Jsv9nKVdibKKRRXo=
+github.com/charmbracelet/bubbletea v1.3.5 h1:JAMNLTbqMOhSwoELIr0qyP4VidFq72/6E9j7HHmRKQc=
+github.com/charmbracelet/bubbletea v1.3.5/go.mod h1:TkCnmH+aBd4LrXhXcqrKiYwRs7qyQx5rBgH5fVY3v54=
 github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc h1:4pZI35227imm7yK2bGPcfpFEmuY1gc2YSTShr4iJBfs=
 github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc/go.mod h1:X4/0JoqgTIPSFcRA/P6INZzIuyqdFY5rm8tb41s9okk=
+github.com/charmbracelet/harmonica v0.2.0 h1:8NxJWRWg/bzKqqEaaeFNipOu77YR5t8aSwG4pgaUBiQ=
+github.com/charmbracelet/harmonica v0.2.0/go.mod h1:KSri/1RMQOZLbw7AHqgcBycp8pgJnQMYYT8QZRqZ1Ao=
 github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY=
 github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30=
 github.com/charmbracelet/log v0.3.1 h1:TjuY4OBNbxmHWSwO3tosgqs5I3biyY8sQPny/eCMTYw=

pkg/config/config.go

@@ -76,8 +76,23 @@ func Load(configPath string) (*Config, error) {
 	cfg := DefaultConfig()
 
 	if configPath == "" {
-		// Look for config file in current directory
-		configPath = filepath.Join(".", defaultConfigFileName+"."+defaultConfigType)
+		// Look for config file in current directory - try both formats
+		possiblePaths := []string{
+			filepath.Join(".", "gograph.yaml"),                              // New format
+			filepath.Join(".", defaultConfigFileName+"."+defaultConfigType), // Legacy format (.gograph.yaml)
+		}
+
+		configPath = ""
+		for _, path := range possiblePaths {
+			if _, err := os.Stat(path); err == nil {
+				configPath = path
+				break
+			}
+		}
+
+		if configPath == "" {
+			return cfg, nil // Return default config if no config file found
+		}
 	}
 
 	// Check if config file exists

pkg/logger/logger.go

@@ -1,6 +1,7 @@
 package logger
 
 import (
+	"io"
 	"os"
 	"sync"
 
@@ -80,3 +81,15 @@ func With(keyvals ...any) *log.Logger {
 	ensureInitialized()
 	return logger.With(keyvals...)
 }
+
+// Disable completely disables logging output
+func Disable() {
+	ensureInitialized()
+	logger.SetOutput(io.Discard)
+}
+
+// Enable re-enables logging output to stderr
+func Enable() {
+	ensureInitialized()
+	logger.SetOutput(os.Stderr)
+}