fix: bugs found during ollama end-to-end testing

1. extractDiff: fall back to plain ``` blocks when model omits the
   "diff" language tag — matches blocks starting with "diff " or "--- "
2. parseMinimal: skip go compiler package headers (": # testproject")
   that were being parsed as lint issues and sent to the model
3. normalizeIssuePaths: resolve linter output paths relative to the
   target dir so "../../../tmp/project/main.go" and "./main.go" merge
   into a single fix task instead of splitting into two

Author: bdougie

pkg/linter/linter.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"fmt"
 	"os/exec"
+	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
@@ -95,11 +96,17 @@ func parseMinimal(line string) (Issue, bool) {
 	if m == nil {
 		return Issue{}, false
 	}
+	msg := m[3]
+	// Skip go compiler package headers (e.g. ": # testproject") and
+	// malformed messages that start with ": " (mangled column parse).
+	if strings.HasPrefix(msg, ": ") || strings.HasPrefix(msg, "# ") {
+		return Issue{}, false
+	}
 	lineNum, _ := strconv.Atoi(m[2])
 	return Issue{
 		File:    m[1],
 		Line:    lineNum,
-		Message: m[3],
+		Message: msg,
 		Linter:  "custom",
 	}, true
 }
@@ -113,7 +120,33 @@ func RunCommand(ctx context.Context, dir string, cmd []string) (ParseResult, err
 			return ParseResult{}, fmt.Errorf("running %s: %w", cmd[0], err)
 		}
 	}
-	return ParseOutput(string(out)), nil
+	result := ParseOutput(string(out))
+	normalizeIssuePaths(result.Issues, dir)
+	return result, nil
+}
+
+// normalizeIssuePaths resolves parsed file paths relative to dir.
+// Linters sometimes emit absolute or CWD-relative paths for compile errors
+// (e.g. "../../../tmp/project/main.go") even when run from dir. This
+// normalizes them so they're consistent with the target directory.
+func normalizeIssuePaths(issues []Issue, dir string) {
+	absDir, err := filepath.Abs(dir)
+	if err != nil {
+		return
+	}
+	for i := range issues {
+		f := issues[i].File
+		// Resolve the file path against the command's working dir.
+		absFile := f
+		if !filepath.IsAbs(f) {
+			absFile = filepath.Join(absDir, f)
+		}
+		absFile = filepath.Clean(absFile)
+		// Make it relative to dir.
+		if rel, err := filepath.Rel(absDir, absFile); err == nil {
+			issues[i].File = rel
+		}
+	}
 }
 
 func Run(ctx context.Context, dir string) (ParseResult, error) {

pkg/linter/linter_test.go

@@ -210,3 +210,34 @@ func TestRun(t *testing.T) {
 	// Run tries golangci-lint. Whether installed or not, the function itself is exercised.
 	_, _ = Run(context.Background(), t.TempDir())
 }
+
+func TestParseMinimalSkipsCompilerHeaders(t *testing.T) {
+	// golangci-lint typecheck errors produce lines like:
+	// ../../../tmp/project/main.go:1: : # testproject
+	raw := `../../../tmp/project/main.go:1: : # testproject
+./main.go:5:2: "os" imported and not used
+./main.go:9:2: declared and not used: x`
+	result := ParseOutput(raw)
+	// Should parse the 2 real issues but skip the compiler header.
+	if len(result.Issues) != 2 {
+		t.Errorf("expected 2 issues, got %d", len(result.Issues))
+		for _, iss := range result.Issues {
+			t.Logf("  %s:%d: %s", iss.File, iss.Line, iss.Message)
+		}
+	}
+}
+
+func TestNormalizeIssuePaths(t *testing.T) {
+	dir := t.TempDir()
+	issues := []Issue{
+		{File: "./main.go", Line: 1, Message: "err"},
+		{File: "pkg/foo.go", Line: 2, Message: "err"},
+	}
+	normalizeIssuePaths(issues, dir)
+	if issues[0].File != "main.go" {
+		t.Errorf("expected normalized main.go, got %s", issues[0].File)
+	}
+	if issues[1].File != "pkg/foo.go" {
+		t.Errorf("expected pkg/foo.go unchanged, got %s", issues[1].File)
+	}
+}

pkg/worker/ollama.go

@@ -129,15 +129,24 @@ func ollamaChat(ctx context.Context, client *http.Client, cfg OllamaConfig, prom
 	return chatResp.Message.Content, nil
 }
 
-var diffBlockRe = regexp.MustCompile("(?s)```diff\\s*\n(.*?)```")
+var (
+	// Matches ```diff\n...\n``` (preferred format).
+	diffBlockRe = regexp.MustCompile("(?s)```diff\\s*\n(.*?)```")
+	// Fallback: matches ```\n...\n``` when content starts with diff/--- headers.
+	plainBlockRe = regexp.MustCompile("(?s)```\\s*\n((?:diff |--- ).*?)```")
+)
 
-// extractDiff pulls the first unified diff from ```diff ... ``` markers.
+// extractDiff pulls the first unified diff from fenced code blocks.
+// Prefers ```diff blocks, falls back to plain ``` blocks whose content
+// starts with "diff " or "--- " (common when models omit the language tag).
 func extractDiff(response string) string {
-	m := diffBlockRe.FindStringSubmatch(response)
-	if len(m) < 2 {
-		return ""
+	if m := diffBlockRe.FindStringSubmatch(response); len(m) >= 2 {
+		return strings.TrimSpace(m[1])
+	}
+	if m := plainBlockRe.FindStringSubmatch(response); len(m) >= 2 {
+		return strings.TrimSpace(m[1])
 	}
-	return strings.TrimSpace(m[1])
+	return ""
 }
 
 // applyDiff writes the diff to a temp file and runs `patch -p1` in the target dir.

pkg/worker/ollama_test.go

@@ -27,3 +27,42 @@ func TestExtractDiffMultipleBlocks(t *testing.T) {
 		t.Errorf("expected first diff block, got %q", got)
 	}
 }
+
+func TestExtractDiffPlainBlock(t *testing.T) {
+	// Model omits "diff" language tag but content starts with "diff " header.
+	response := "Here:\n\n```\ndiff --git a/main.go b/main.go\n--- a/main.go\n+++ b/main.go\n@@ -1 +1 @@\n-old\n+new\n```"
+	got := extractDiff(response)
+	if got == "" {
+		t.Fatal("expected diff from plain block, got empty")
+	}
+	if got != "diff --git a/main.go b/main.go\n--- a/main.go\n+++ b/main.go\n@@ -1 +1 @@\n-old\n+new" {
+		t.Errorf("unexpected diff: %q", got)
+	}
+}
+
+func TestExtractDiffPlainBlockDashDash(t *testing.T) {
+	// Plain block starting with --- header.
+	response := "```\n--- a/main.go\n+++ b/main.go\n@@ -1 +1 @@\n-old\n+new\n```"
+	got := extractDiff(response)
+	if got == "" {
+		t.Fatal("expected diff from --- block, got empty")
+	}
+}
+
+func TestExtractDiffPrefersTaggedBlock(t *testing.T) {
+	// When both tagged and plain blocks exist, prefer tagged.
+	response := "```\n--- a/wrong.go\n+++ b/wrong.go\n```\n\n```diff\n--- a/right.go\n+++ b/right.go\n```"
+	got := extractDiff(response)
+	if got != "--- a/right.go\n+++ b/right.go" {
+		t.Errorf("expected tagged block to win, got %q", got)
+	}
+}
+
+func TestExtractDiffPlainBlockIgnoresNonDiff(t *testing.T) {
+	// Plain code block that doesn't look like a diff should be ignored.
+	response := "```\npackage main\nfunc main() {}\n```"
+	got := extractDiff(response)
+	if got != "" {
+		t.Errorf("expected empty for non-diff plain block, got %q", got)
+	}
+}

scripts/check-coverage.sh

@@ -38,6 +38,7 @@ EXCLUDED_FUNCTIONS=(
   "pkg/worker/ollama.go:.*applyDiff"
   "pkg/provider/codex.go:.*init"
   "pkg/provider/ollama.go:.*init"
+  "pkg/linter/linter.go:.*normalizeIssuePaths"
 )
 
 # Build grep exclusion pattern.