feat: add project id

Author: pedronauck

.cursor/mcp.json

@@ -0,0 +1,13 @@
+{
+  "mcpServers": {
+    "gograph": {
+      "command": "/Users/pedronauck/Dev/ai/gograph/bin/gograph",
+      "args": ["serve-mcp"],
+      "env": {
+        "NEO4J_URI": "bolt://localhost:7687",
+        "NEO4J_USERNAME": "neo4j",
+        "NEO4J_PASSWORD": "password"
+      }
+    }
+  }
+}

MCP_SETUP.md

@@ -0,0 +1,139 @@
+# GoGraph MCP Server Setup for Cursor
+
+This guide explains how to set up the GoGraph MCP (Model Context Protocol) server to work with Cursor IDE.
+
+## Prerequisites
+
+1. **Neo4j Database**: Ensure Neo4j is running on `bolt://localhost:7687`
+2. **Built GoGraph Binary**: Run `make build` to create the `bin/gograph` executable
+
+## Setup Instructions
+
+### 1. Build GoGraph
+
+```bash
+make build
+```
+
+### 2. Configure Cursor MCP Settings
+
+1. Open Cursor IDE
+2. Go to **Settings** (Cmd/Ctrl + ,)
+3. Search for "mcp" or navigate to **Extensions** → **Model Context Protocol**
+4. Add the following configuration to your MCP settings:
+
+```json
+{
+  "mcpServers": {
+    "gograph": {
+      "command": "/Users/pedronauck/Dev/ai/gograph/bin/gograph",
+      "args": ["serve-mcp"],
+      "env": {
+        "NEO4J_URI": "bolt://localhost:7687",
+        "NEO4J_USERNAME": "neo4j",
+        "NEO4J_PASSWORD": "password"
+      }
+    }
+  }
+}
+```
+
+**Important**: Update the paths and credentials:
+- Replace `/Users/pedronauck/Dev/ai/gograph/bin/gograph` with the absolute path to your built binary
+- Update Neo4j credentials if different from defaults
+
+### 3. Alternative Configuration File
+
+You can also create a separate MCP configuration file:
+
+1. Create `~/.cursor/mcp_settings.json` with the configuration above
+2. Or use the provided `cursor-mcp-config.json` as a template
+
+### 4. Restart Cursor
+
+After adding the configuration, restart Cursor IDE for the changes to take effect.
+
+## Available Tools
+
+Once configured, Cursor will have access to 17 GoGraph tools:
+
+### 📊 Analysis Tools
+- `analyze_project` - Analyze a Go project and build its dependency graph
+- `query_dependencies` - Query dependencies of a package or file
+
+### 🧭 Navigation Tools  
+- `find_implementations` - Find all implementations of an interface
+- `trace_call_chain` - Trace call chains between functions
+- `detect_circular_deps` - Detect circular dependencies in the project
+- `get_function_info` - Get detailed information about a function
+- `list_packages` - List all packages in the project
+- `get_package_structure` - Get detailed structure of a package
+
+### 🔍 Query Tools
+- `execute_cypher` - Execute a Cypher query against the graph database
+- `natural_language_query` - Convert natural language to Cypher and execute
+
+### ✅ Verification Tools
+- `verify_code_exists` - Verify if a code element exists in the project
+- `get_code_context` - Get context around a code element for LLM understanding
+- `validate_import_path` - Validate and resolve an import path
+
+### 🎯 Pattern Tools
+- `detect_code_patterns` - Detect common code patterns and anti-patterns
+- `get_naming_conventions` - Analyze naming conventions used in the project
+
+### 🧪 Test Tools
+- `find_tests_for_code` - Find tests for a specific code element
+- `check_test_coverage` - Check test coverage for packages or files
+
+## Usage Examples
+
+Once configured, you can use natural language in Cursor to interact with your Go codebase:
+
+- *"Analyze this project and show me the main packages"*
+- *"Find all implementations of the ServiceAdapter interface"*
+- *"Show me the call chain from main() to database operations"*
+- *"What functions call the HandleRequest method?"*
+- *"Detect any circular dependencies in this codebase"*
+- *"Find tests for the ParseProject function"*
+
+## Troubleshooting
+
+### MCP Server Not Starting
+1. Verify Neo4j is running: `docker ps` or check your local Neo4j instance
+2. Check the binary path is correct and executable: `ls -la /path/to/bin/gograph`
+3. Test the server manually: `./bin/gograph serve-mcp --help`
+
+### Connection Issues
+1. Verify Neo4j credentials in the configuration
+2. Check Neo4j is accessible: `nc -zv localhost 7687`
+3. Review Cursor's MCP logs in the developer console
+
+### Tools Not Available
+1. Restart Cursor after configuration changes
+2. Check MCP configuration syntax is valid JSON
+3. Verify the `command` path points to the built binary
+
+## Manual Testing
+
+Test the MCP server manually:
+
+```bash
+# Test tools list
+echo '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' | ./bin/gograph serve-mcp
+
+# Test project analysis (replace with your project path)
+echo '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"analyze_project","arguments":{"project_path":".","project_id":"test-project"}}}' | ./bin/gograph serve-mcp
+```
+
+## Next Steps
+
+Once set up, GoGraph will enhance Cursor's understanding of your Go codebase by providing:
+- Accurate code navigation and search
+- Dependency analysis and visualization  
+- Interface implementation discovery
+- Call chain tracing
+- Anti-pattern detection
+- Test coverage analysis
+
+The integration enables Cursor to provide more accurate suggestions and better understand your codebase structure.

Makefile

@@ -93,9 +93,9 @@ ifeq ($(CI),true)
 	done
 else
 	@command -v docker-compose >/dev/null 2>&1 || { echo >&2 "docker-compose is required but not installed. Aborting."; exit 1; }
-	@docker-compose -f docker-compose.test.yml up -d
+	@docker-compose -f docker-compose.yml up -d
 	@echo "Waiting for Neo4j to be ready..."
-	@docker-compose -f docker-compose.test.yml exec -T neo4j-test wget -q --spider --tries=30 --waitretry=2 http://localhost:7474 || true
+	@docker-compose -f docker-compose.yml exec -T neo4j-test wget -q --spider --tries=30 --waitretry=2 http://localhost:7474 || true
 endif
 	@echo "Test dependencies ready"
 
@@ -105,7 +105,7 @@ test-down:
 ifeq ($(CI),true)
 	@echo "CI environment detected - skipping docker-compose down"
 else
-	@docker-compose -f docker-compose.test.yml down
+	@docker-compose -f docker-compose.yml down
 endif
 
 # Clean test dependencies (including volumes)
@@ -114,15 +114,15 @@ test-clean:
 ifeq ($(CI),true)
 	@echo "CI environment detected - skipping docker-compose cleanup"
 else
-	@docker-compose -f docker-compose.test.yml down -v
+	@docker-compose -f docker-compose.yml down -v
 endif
 
 # Show test logs
 test-logs:
 ifeq ($(CI),true)
 	@echo "CI environment detected - use GitHub Actions logs"
 else
-	@docker-compose -f docker-compose.test.yml logs -f
+	@docker-compose -f docker-compose.yml logs -f
 endif
 
 # -----------------------------------------------------------------------------

bin/gograph

@@ -11,11 +11,11 @@ import (
 	"github.com/compozy/gograph/engine/graph"
 	"github.com/compozy/gograph/engine/infra"
 	"github.com/compozy/gograph/engine/parser"
+	"github.com/compozy/gograph/pkg/config"
 	"github.com/compozy/gograph/pkg/errors"
 	"github.com/compozy/gograph/pkg/logger"
 	"github.com/compozy/gograph/pkg/progress"
 	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
 )
 
 var analyzeCmd = &cobra.Command{
@@ -58,74 +58,72 @@ The resulting graph allows you to:
 
 		// Wrap the entire command execution with panic recovery
 		return errors.WithRecover("analyze_command", func() error {
+			// Load configuration
+			cfg, err := config.Load("")
+			if err != nil {
+				return fmt.Errorf("failed to load config: %w", err)
+			}
+
+			// Get project ID from config or override flag
+			projectID := core.ID(cfg.Project.ID)
+			if projectIDFlag, err := cmd.Flags().GetString("project-id"); err == nil && projectIDFlag != "" {
+				projectID = core.ID(projectIDFlag)
+			}
+
 			// Check for --no-progress flag
 			noProgress, err := cmd.Flags().GetBool("no-progress")
 			if err != nil {
 				return fmt.Errorf("failed to get no-progress flag: %w", err)
 			}
 
-			// Initialize parser configuration from Viper
+			// Initialize parser configuration from config
 			parserConfig := &parser.Config{
-				IgnoreDirs:     viper.GetStringSlice("parser.ignore_dirs"),
-				IgnoreFiles:    viper.GetStringSlice("parser.ignore_files"),
-				IncludeTests:   viper.GetBool("parser.include_tests"),
-				IncludeVendor:  viper.GetBool("parser.include_vendor"),
-				MaxConcurrency: viper.GetInt("parser.max_concurrency"),
+				IgnoreDirs:     cfg.Analysis.IgnoreDirs,
+				IgnoreFiles:    cfg.Analysis.IgnoreFiles,
+				IncludeTests:   cfg.Analysis.IncludeTests,
+				IncludeVendor:  cfg.Analysis.IncludeVendor,
+				MaxConcurrency: cfg.Analysis.MaxConcurrency,
 			}
 
-			// Initialize analyzer configuration from Viper
+			// Initialize analyzer configuration with defaults
 			analyzerConfig := analyzer.DefaultAnalyzerConfig()
-			if maxDepth := viper.GetInt("analyzer.max_dependency_depth"); maxDepth > 0 {
-				analyzerConfig.MaxDependencyDepth = maxDepth
-			}
-			if ignoreTest := viper.GetBool("analyzer.ignore_test_files"); ignoreTest {
-				analyzerConfig.IgnoreTestFiles = ignoreTest
-			}
-			if ignoreVendor := viper.GetBool("analyzer.ignore_vendor"); ignoreVendor {
-				analyzerConfig.IgnoreVendor = ignoreVendor
-			}
-			if includeMetrics := viper.GetBool("analyzer.include_metrics"); includeMetrics {
-				analyzerConfig.IncludeMetrics = includeMetrics
-			}
-			if workers := viper.GetInt("analyzer.parallel_workers"); workers > 0 {
-				analyzerConfig.ParallelWorkers = workers
-			}
 
-			// Initialize Neo4j configuration from Viper with fallback to defaults
-			neo4jURI := viper.GetString("neo4j.uri")
+			// Initialize Neo4j configuration from config with fallback to defaults
+			neo4jURI := cfg.Neo4j.URI
 			if neo4jURI == "" {
-				neo4jURI = DefaultNeo4jURI // Default only if not set via env vars
+				neo4jURI = DefaultNeo4jURI
 			}
-			neo4jUsername := viper.GetString("neo4j.username")
+			neo4jUsername := cfg.Neo4j.Username
 			if neo4jUsername == "" {
-				neo4jUsername = DefaultNeo4jUsername // Default only if not set via env vars
+				neo4jUsername = DefaultNeo4jUsername
 			}
-			neo4jPassword := viper.GetString("neo4j.password")
+			neo4jPassword := cfg.Neo4j.Password
 			if neo4jPassword == "" {
-				neo4jPassword = DefaultNeo4jPassword // Default only if not set via env vars
+				neo4jPassword = DefaultNeo4jPassword
 			}
 
 			neo4jConfig := &infra.Neo4jConfig{
 				URI:        neo4jURI,
 				Username:   neo4jUsername,
 				Password:   neo4jPassword,
-				Database:   viper.GetString("neo4j.database"),
+				Database:   cfg.Neo4j.Database,
 				MaxRetries: 3,
 				BatchSize:  1000,
 			}
 
 			// Start the analysis
 			if noProgress {
-				return runAnalysisWithoutProgress(projectPath, parserConfig, analyzerConfig, neo4jConfig)
+				return runAnalysisWithoutProgress(projectPath, projectID, parserConfig, analyzerConfig, neo4jConfig)
 			}
 
-			return runAnalysisWithProgress(projectPath, parserConfig, analyzerConfig, neo4jConfig)
+			return runAnalysisWithProgress(projectPath, projectID, parserConfig, analyzerConfig, neo4jConfig)
 		})
 	},
 }
 
 func runAnalysisWithoutProgress(
 	projectPath string,
+	projectID core.ID,
 	parserConfig *parser.Config,
 	analyzerConfig *analyzer.Config,
 	neo4jConfig *infra.Neo4jConfig,
@@ -151,7 +149,6 @@ func runAnalysisWithoutProgress(
 	// -----
 	logger.Info("analyzing project structure")
 	analyzerService := analyzer.NewAnalyzer(analyzerConfig)
-	projectID := core.NewID()
 	analysisInput := &analyzer.AnalysisInput{
 		ProjectID: projectID.String(),
 		Files:     parseResult.Files,
@@ -203,6 +200,7 @@ func runAnalysisWithoutProgress(
 
 func runAnalysisWithProgress(
 	projectPath string,
+	projectID core.ID,
 	parserConfig *parser.Config,
 	analyzerConfig *analyzer.Config,
 	neo4jConfig *infra.Neo4jConfig,
@@ -213,7 +211,6 @@ func runAnalysisWithProgress(
 	var parseResult *parser.ParseResult
 	var report *analyzer.AnalysisReport
 	var graphResult *core.AnalysisResult
-	var projectID core.ID
 
 	// -----
 	// Parsing Phase
@@ -233,7 +230,6 @@ func runAnalysisWithProgress(
 	// -----
 	err = progress.WithProgress("Analyzing code structure", func() error {
 		analyzerService := analyzer.NewAnalyzer(analyzerConfig)
-		projectID = core.NewID()
 		analysisInput := &analyzer.AnalysisInput{
 			ProjectID: projectID.String(),
 			Files:     parseResult.Files,
@@ -298,7 +294,8 @@ func InitAnalyzeCommand() {
 	initAnalyzeOnce.Do(func() {
 		rootCmd.AddCommand(analyzeCmd)
 
-		// Add progress flag
+		// Add flags
 		analyzeCmd.Flags().Bool("no-progress", false, "Disable progress indicators")
+		analyzeCmd.Flags().String("project-id", "", "Override project ID from config file")
 	})
 }