olblak · Aug 28, 2026 · Aug 26, 2026 · Aug 26, 2026 · Aug 27, 2026 · Aug 28, 2026
diff --git a/pkg/core/config/main.go b/pkg/core/config/main.go
@@ -304,6 +304,9 @@ func New(option Option, pipelineIDFilters []string, pipelineLabels map[string]st
 
 	var templatedManifestContent []byte
 	var rawManifestContent []byte
+	// manifestFragments tracks which file each line of rawManifestContent comes
+	// from, so that a templating error can be reported against that file.
+	var manifestFragments []manifestFragment
 
 	for _, partialFile := range option.PartialFiles {
 		partialContent, err := readFile(partialFile)
@@ -319,6 +322,7 @@ func New(option Option, pipelineIDFilters []string, pipelineLabels map[string]st
 		}
 
 		logrus.Debugf("Partial content detected from: %q", partialFile)
+		manifestFragments, partialContent = appendFragment(manifestFragments, partialFile, partialContent)
 		rawManifestContent = append(rawManifestContent, partialContent...)
 	}
 
@@ -329,6 +333,7 @@ func New(option Option, pipelineIDFilters []string, pipelineLabels map[string]st
 		return nil, err
 	}
 
+	manifestFragments, rawManifestFileContent = appendFragment(manifestFragments, option.ManifestFile, rawManifestFileContent)
 	rawManifestContent = append(rawManifestContent, rawManifestFileContent...)
 
 	specs := []Spec{}
@@ -365,6 +370,7 @@ func New(option Option, pipelineIDFilters []string, pipelineLabels map[string]st
 			ValuesFiles:  option.ValuesFiles,
 			ValuesInline: option.ValuesInline,
 			SecretsFiles: option.SecretsFiles,
+			Fragments:    manifestFragments,
 			fs:           fs,
 		}
 
@@ -374,7 +380,6 @@ func New(option Option, pipelineIDFilters []string, pipelineLabels map[string]st
 			templatedManifestContent, err = t.NewStringTemplate(rawManifestContent)
 		}
 		if err != nil {
-			logrus.Errorf("Error while templating %q:\n---\n%s\n---\n\t%s\n", option.ManifestFile, string(rawManifestContent), err.Error())
 			return nil, err
 		}
 
@@ -508,7 +513,6 @@ func New(option Option, pipelineIDFilters []string, pipelineLabels map[string]st
 
 // isMatchingLabel checks if a spec labels match filter labels
 func isMatchingLabel(specLabels map[string]string, filterLabels map[string]string) bool {
-
 	if len(filterLabels) == 0 {
 		return true
 	}

diff --git a/pkg/core/config/template.go b/pkg/core/config/template.go
@@ -35,35 +35,64 @@ type Template struct {
 	Values map[string]interface{} `yaml:"-,inline"`
 	// Secrets contains key/value extracted from a sops file
 	Secrets map[string]interface{} `yaml:"-,inline"`
+	// Fragments describes which file each line of the content handed to
+	// NewStringTemplate comes from, so that templating errors can be reported
+	// against the file the user wrote rather than against the concatenation of
+	// every partial and the manifest.
+	Fragments []manifestFragment
 	// fs is a file system abstraction used to read files
 	fs fs.FS
 }
 
+// templateName returns the name given to the golang template, which text/template
+// uses to prefix the location of parse and execution errors.
+func (t *Template) templateName() string {
+	if t.CfgFile == "" {
+		return "cfg"
+	}
+
+	return t.CfgFile
+}
+
 // NewStringTemplate parses a golang template then return an updatecli configuration as a struct
 func (t *Template) NewStringTemplate(content []byte) ([]byte, error) {
 	templateValues, err := t.readAllValues()
 	if err != nil {
 		return []byte{}, err
 	}
 
-	tmpl, err := template.New("cfg").
+	tmpl, err := template.New(t.templateName()).
 		Funcs(sprig.FuncMap()).
 		Funcs(helmFuncMap()).      // add helm funcMap
 		Funcs(updatecliFuncMap()). // add custom funcMap last so that it takes precedence
 		Parse(string(content))
 	if err != nil {
-		return []byte{}, err
+		return []byte{}, t.locateError(err, content)
 	}
 
 	b := bytes.Buffer{}
 
 	if err := tmpl.Execute(&b, templateValues); err != nil {
-		return []byte{}, err
+		return []byte{}, t.locateError(err, content)
 	}
 
 	return b.Bytes(), nil
 }
 
+// locateError points a templating error at the file and line it came from, and
+// appends an excerpt of the offending lines. It returns the error unchanged when
+// the location cannot be resolved.
+func (t *Template) locateError(err error, content []byte) error {
+	location, located := locateTemplateError(err, t.templateName(), t.Fragments)
+
+	excerpt := renderExcerpt(content, location, excerptContextLines)
+	if excerpt == "" {
+		return located
+	}
+
+	return fmt.Errorf("%w\n\n%s", located, strings.TrimRight(excerpt, "\n"))
+}
+
 // NewCueTemplate parses a Cue template then return an updatecli configuration as a struct
 func (t *Template) NewCueTemplate(content []byte) (cue.Value, error) {
 	ctx := cuecontext.New()

diff --git a/pkg/core/config/template_test.go b/pkg/core/config/template_test.go
@@ -24,6 +24,8 @@ type TestTemplateData struct {
 	ExpectedManifest string
 	// ExpectError is used to check if the test should return an error
 	ExpectError bool
+	// ExpectedError, when set, must be contained in the returned error
+	ExpectedError string
 }
 
 var (
@@ -61,6 +63,9 @@ var (
       hello {{ .value }
       `,
 			ExpectError: true,
+			// The template is named after the manifest it came from, so that the
+			// error points at a file the user can open.
+			ExpectedError: `manifest.yaml:2: unexpected "}" in operand`,
 		},
 
 		{
@@ -80,17 +85,25 @@ func TestTemplates(t *testing.T) {
 	for _, testTemplate := range testTemplates {
 		t.Run(fmt.Sprintf("test template %s", testTemplate.ID), func(t *testing.T) {
 
+			manifest := dedent.Dedent(testTemplate.ManifestTemplate)
+			fragments, _ := appendFragment(nil, "manifest.yaml", []byte(manifest))
+
 			template := Template{
+				CfgFile:     "manifest.yaml",
+				Fragments:   fragments,
 				ValuesFiles: []string{"values1.yml", "values2.yml"},
 				fs: fstest.MapFS{
 					"values1.yml": {Data: []byte(testTemplate.Values1)},
 					"values2.yml": {Data: []byte(testTemplate.Values2)},
 				},
 			}
 			expected := dedent.Dedent(testTemplate.ExpectedManifest)
-			rendered, err := template.NewStringTemplate([]byte(dedent.Dedent(testTemplate.ManifestTemplate)))
+			rendered, err := template.NewStringTemplate([]byte(manifest))
 			if testTemplate.ExpectError {
 				require.Error(t, err)
+				if testTemplate.ExpectedError != "" {
+					require.Contains(t, err.Error(), testTemplate.ExpectedError)
+				}
 				return
 			}
 			require.NoError(t, err)

diff --git a/pkg/core/config/templateerror.go b/pkg/core/config/templateerror.go
@@ -0,0 +1,171 @@
+package config
+
+import (
+	"bytes"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// excerptContextLines is the number of lines displayed before and after the line
+// a templating error points at.
+const excerptContextLines = 3
+
+// manifestFragment locates one file's contribution inside the concatenated
+// content handed to the templating engine.
+type manifestFragment struct {
+	file string
+	// firstLine is the 1-based line number of this fragment's first line within
+	// the concatenation.
+	firstLine int
+	lineCount int
+}
+
+// lastLine returns the 1-based line number of this fragment's last line within
+// the concatenation.
+func (f manifestFragment) lastLine() int {
+	return f.firstLine + f.lineCount - 1
+}
+
+// appendFragment records where content lands inside the concatenation described
+// by fragments, and returns both the updated fragment list and the content to
+// append.
+//
+// The content is normalized to end with a newline: without it the last line of a
+// fragment glues onto the first line of the next one, which both corrupts the
+// resulting manifest and makes line numbers impossible to attribute.
+func appendFragment(fragments []manifestFragment, file string, content []byte) ([]manifestFragment, []byte) {
+	if len(content) > 0 && !bytes.HasSuffix(content, []byte("\n")) {
+		content = append(content, '\n')
+	}
+
+	firstLine := 1
+	if len(fragments) > 0 {
+		previous := fragments[len(fragments)-1]
+		firstLine = previous.firstLine + previous.lineCount
+	}
+
+	return append(fragments, manifestFragment{
+		file:      file,
+		firstLine: firstLine,
+		lineCount: bytes.Count(content, []byte("\n")),
+	}), content
+}
+
+// templateLocation is a templating error resolved back to the file it came from.
+type templateLocation struct {
+	fragment manifestFragment
+	// line is the 1-based line number within the fragment's own file.
+	line int
+	// concatLine is the 1-based line number within the concatenated content.
+	concatLine int
+}
+
+// templateError is a templating error whose location has been resolved back to
+// the file and line the user actually wrote.
+type templateError struct {
+	msg string
+	err error
+}
+
+func (e *templateError) Error() string { return e.msg }
+func (e *templateError) Unwrap() error { return e.err }
+
+// resolveFragment returns the fragment owning the given line of the
+// concatenation, or nil when no fragment covers it.
+func resolveFragment(fragments []manifestFragment, concatLine int) *templateLocation {
+	for _, fragment := range fragments {
+		if concatLine >= fragment.firstLine && concatLine <= fragment.lastLine() {
+			return &templateLocation{
+				fragment:   fragment,
+				line:       concatLine - fragment.firstLine + 1,
+				concatLine: concatLine,
+			}
+		}
+	}
+
+	return nil
+}
+
+// locateTemplateError rewrites the "template: <name>:<line>[:<column>]" prefix
+// that text/template puts on parse and execution errors so that it points at the
+// file the line actually came from, rather than at an offset into the
+// concatenation of every partial and the manifest.
+//
+// The error is returned untouched, with a nil location, when it carries no such
+// prefix or when no fragment covers the reported line.
+func locateTemplateError(err error, name string, fragments []manifestFragment) (*templateLocation, error) {
+	if err == nil {
+		return nil, nil
+	}
+
+	// The name is quoted so that a Windows path, or any other name containing a
+	// colon, cannot swallow the line number.
+	prefix := regexp.MustCompile(`^template: ` + regexp.QuoteMeta(name) + `:(\d+)(?::(\d+))?: `)
+
+	message := err.Error()
+	match := prefix.FindStringSubmatch(message)
+	if match == nil {
+		return nil, err
+	}
+
+	concatLine, convErr := strconv.Atoi(match[1])
+	if convErr != nil {
+		return nil, err
+	}
+
+	location := resolveFragment(fragments, concatLine)
+	if location == nil {
+		return nil, err
+	}
+
+	position := fmt.Sprintf("%s:%d", location.fragment.file, location.line)
+	if match[2] != "" {
+		position += ":" + match[2]
+	}
+
+	return location, &templateError{
+		msg: fmt.Sprintf("%s: %s", position, strings.TrimPrefix(message, match[0])),
+		err: err,
+	}
+}
+
+// renderExcerpt returns the lines of content surrounding location, with the
+// offending line marked. Line numbers are those of the file the line came from,
+// so that they match what the user sees in their editor, and the excerpt never
+// spills into a neighboring fragment.
+func renderExcerpt(content []byte, location *templateLocation, contextLines int) string {
+	if location == nil {
+		return ""
+	}
+
+	lines := strings.Split(string(content), "\n")
+	// Content ending with a newline yields a trailing empty element which is not
+	// a line of its own.
+	if len(lines) > 0 && lines[len(lines)-1] == "" {
+		lines = lines[:len(lines)-1]
+	}
+
+	first := max(location.concatLine-contextLines, location.fragment.firstLine)
+	last := min(location.concatLine+contextLines, location.fragment.lastLine())
+	last = min(last, len(lines))
+
+	if first > last {
+		return ""
+	}
+
+	// Width of the widest line number displayed, so that the gutter stays aligned.
+	width := len(strconv.Itoa(location.line + last - location.concatLine))
+
+	excerpt := strings.Builder{}
+	for i := first; i <= last; i++ {
+		marker := "  "
+		if i == location.concatLine {
+			marker = "> "
+		}
+		fmt.Fprintf(&excerpt, "%s%*d | %s\n", marker, width, location.line+i-location.concatLine, lines[i-1])
+	}
+
+	return excerpt.String()
+}