feat: Dispatch Hover and Definition to values handlers by FileType

Extend the Hover and Definition switch to route FileTypeValues
through the new values handlers.

- hoverValues builds markdown popups for variables and dependency
  references (newValuesVariableHoverResponse / newValuesDependencyHoverResponse).
- definitionValues resolves dependency references to the matching
  terragrunt.hcl via ResolveValuesDependencyPath.
- Rewrite TestState_Hover_ValuesFile to assert real popups and add
  TestState_Definition_ValuesFile covering dependency navigation.

Author: diofeher

internal/tg/state.go

@@ -131,7 +131,9 @@ func (s *State) Hover(l logger.Logger, id int, docURI protocol.DocumentURI, posi
 		return s.hoverUnit(l, id, st, position)
 	case store.FileTypeStack:
 		return s.hoverStack(l, id, st, position)
-	case store.FileTypeUnknown, store.FileTypeValues:
+	case store.FileTypeValues:
+		return s.hoverValues(l, id, st, position)
+	case store.FileTypeUnknown:
 		return newEmptyHoverResponse(id)
 	}
 
@@ -267,6 +269,53 @@ func newStackBlockHoverResponse(id int, stackName string) lsp.HoverResponse {
 	}
 }
 
+func (s *State) hoverValues(l logger.Logger, id int, st store.Store, position protocol.Position) lsp.HoverResponse {
+	target, context := hover.GetValuesHoverTargetWithContext(l, st, position)
+
+	l.Debug(
+		"Values hover with context",
+		"target", target,
+		"context", context,
+	)
+
+	if target == "" {
+		return newEmptyHoverResponse(id)
+	}
+
+	switch context {
+	case hover.HoverContextValuesVariable:
+		return newValuesVariableHoverResponse(id, target)
+	case hover.HoverContextValuesDependency:
+		return newValuesDependencyHoverResponse(id, target)
+	}
+
+	return newEmptyHoverResponse(id)
+}
+
+func newValuesVariableHoverResponse(id int, variable string) lsp.HoverResponse {
+	return lsp.HoverResponse{
+		Response: lsp.Response{RPC: lsp.RPCVersion, ID: &id},
+		Result: lsp.HoverResult{
+			Contents: protocol.MarkupContent{
+				Kind:  protocol.Markdown,
+				Value: "**Variable: `" + variable + "`**\n\nThis appears to be a variable defined in the values block.\n\nValues files are used to define dynamic input values for units in Terragrunt stacks.",
+			},
+		},
+	}
+}
+
+func newValuesDependencyHoverResponse(id int, dependency string) lsp.HoverResponse {
+	return lsp.HoverResponse{
+		Response: lsp.Response{RPC: lsp.RPCVersion, ID: &id},
+		Result: lsp.HoverResult{
+			Contents: protocol.MarkupContent{
+				Kind:  protocol.Markdown,
+				Value: "**Dependency: `" + dependency + "`**\n\nThis is a reference to a dependency unit defined elsewhere in your Terragrunt configuration.\n\nThe dependency must be declared before it can be referenced in a values file.",
+			},
+		},
+	}
+}
+
 func newEmptyHoverResponse(id int) lsp.HoverResponse {
 	return lsp.HoverResponse{
 		Response: lsp.Response{
@@ -294,7 +343,9 @@ func (s *State) Definition(l logger.Logger, id int, docURI protocol.DocumentURI,
 		return s.definitionUnit(l, id, st, docURI, position)
 	case store.FileTypeStack:
 		return s.definitionStack(l, id, st, docURI, position)
-	case store.FileTypeUnknown, store.FileTypeValues:
+	case store.FileTypeValues:
+		return s.definitionValues(l, id, st, docURI, position)
+	case store.FileTypeUnknown:
 		return newEmptyDefinitionResponse(id, docURI, position)
 	}
 
@@ -488,6 +539,32 @@ func (s *State) definitionStack(l logger.Logger, id int, st store.Store, docURI
 	return newEmptyDefinitionResponse(id, docURI, position)
 }
 
+func (s *State) definitionValues(l logger.Logger, id int, st store.Store, docURI protocol.DocumentURI, position protocol.Position) lsp.DefinitionResponse {
+	target, context := definition.GetValuesDefinitionTargetWithContext(l, st, position)
+
+	l.Debug(
+		"Values definition discovered",
+		"target", target,
+		"context", context,
+	)
+
+	if target == "" {
+		return newEmptyDefinitionResponse(id, docURI, position)
+	}
+
+	//nolint:gocritic
+	switch context {
+	case definition.DefinitionContextValuesDependency:
+		if resolved, ok := definition.ResolveValuesDependencyPath(target, docURI.Filename()); ok {
+			return newStackDefinitionResponse(id, resolved)
+		}
+
+		l.Debug("Could not resolve values dependency path", "dependency", target)
+	}
+
+	return newEmptyDefinitionResponse(id, docURI, position)
+}
+
 func newStackDefinitionResponse(id int, resolved string) lsp.DefinitionResponse {
 	return lsp.DefinitionResponse{
 		Response: lsp.Response{RPC: lsp.RPCVersion, ID: &id},

internal/tg/state_test.go

@@ -670,17 +670,93 @@ func TestState_Hover_StackFile(t *testing.T) {
 func TestState_Hover_ValuesFile(t *testing.T) {
 	t.Parallel()
 
+	tc := []struct {
+		name           string
+		document       string
+		expectFragment string
+		position       protocol.Position
+		expectNonEmpty bool
+	}{
+		{
+			name:           "plain variable",
+			document:       `some_var = "hello"`,
+			position:       protocol.Position{Line: 0, Character: 2},
+			expectNonEmpty: true,
+			expectFragment: "Variable",
+		},
+		{
+			name:           "dependency reference",
+			document:       `vpc_id = dependency.vpc.outputs.id`,
+			position:       protocol.Position{Line: 0, Character: 22},
+			expectNonEmpty: true,
+			expectFragment: "Dependency",
+		},
+	}
+
+	for _, tt := range tc {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			tmpDir := t.TempDir()
+			valuesPath := filepath.Join(tmpDir, "terragrunt.values.hcl")
+			valuesURI := uri.File(valuesPath)
+
+			state := tg.NewState()
+			l := testutils.NewTestLogger(t)
+
+			_ = state.OpenDocument(t.Context(), l, valuesURI, tt.document)
+
+			hover := state.Hover(l, 1, valuesURI, tt.position)
+
+			if tt.expectNonEmpty {
+				assert.NotEmpty(t, hover.Result.Contents.Value)
+				assert.Contains(t, hover.Result.Contents.Value, tt.expectFragment)
+			} else {
+				assert.Empty(t, hover.Result.Contents.Value)
+			}
+		})
+	}
+}
+
+func TestState_Definition_ValuesFile(t *testing.T) {
+	t.Parallel()
+
+	// Seed a fake dependency unit directory structure:
+	// tmp/
+	//   values/terragrunt.values.hcl (the file under test)
+	//   vpc/terragrunt.hcl          (the dependency)
 	tmpDir := t.TempDir()
-	valuesPath := filepath.Join(tmpDir, "terragrunt.values.hcl")
+	valuesDir := filepath.Join(tmpDir, "values")
+	require.NoError(t, os.MkdirAll(valuesDir, 0o755))
+	depDir := filepath.Join(tmpDir, "vpc")
+	require.NoError(t, os.MkdirAll(depDir, 0o755))
+	depFile := filepath.Join(depDir, "terragrunt.hcl")
+	require.NoError(t, os.WriteFile(depFile, []byte(""), 0o644))
+
+	valuesPath := filepath.Join(valuesDir, "terragrunt.values.hcl")
 	valuesURI := uri.File(valuesPath)
 
 	state := tg.NewState()
 	l := testutils.NewTestLogger(t)
 
-	_ = state.OpenDocument(t.Context(), l, valuesURI, `some_var = "hello"`)
+	_ = state.OpenDocument(t.Context(), l, valuesURI, `vpc_id = dependency.vpc.outputs.id`)
 
-	hover := state.Hover(l, 1, valuesURI, protocol.Position{Line: 0, Character: 0})
-	assert.Empty(t, hover.Result.Contents.Value)
+	t.Run("dependency reference jumps to terragrunt.hcl", func(t *testing.T) {
+		t.Parallel()
+
+		pos := protocol.Position{Line: 0, Character: 22}
+		def := state.Definition(l, 1, valuesURI, pos)
+		assert.Equal(t, uri.File(depFile), def.Result.URI)
+	})
+
+	t.Run("plain variable returns empty definition", func(t *testing.T) {
+		t.Parallel()
+
+		pos := protocol.Position{Line: 0, Character: 2}
+		def := state.Definition(l, 1, valuesURI, pos)
+		assert.Equal(t, valuesURI, def.Result.URI)
+		assert.Equal(t, pos, def.Result.Range.Start)
+	})
 }
 
 func TestState_Definition_StackFile(t *testing.T) {