address review: cross-file negation test, stat fallback test, error wrap, docs

- Add TestNewMatcher_CrossFileNegationCannotOverride to codify that
  .gitignore negation cannot un-ignore .azdxignore matches (W1/New 2)
- Add TestGetFileChanges_DeleteIgnoredDirFallback to test the os.Stat
  failure re-check with isDir=true for dir-only patterns (W4/New 3)
- Wrap filepath.Abs() error with context in NewMatcher (New 4)
- Add Long description to watch cobra command documenting .azdxignore
  usage with example (New 1)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: jongio

cli/azd/extensions/microsoft.azd.extensions/internal/cmd/watch.go

@@ -30,6 +30,19 @@ func newWatchCommand() *cobra.Command {
 	watchCmd := &cobra.Command{
 		Use:   "watch",
 		Short: "Watches the azd extension project for file changes and rebuilds it.",
+		Long: `Watches the azd extension project for file changes and rebuilds it.
+
+Place a .azdxignore file in your project root to exclude paths from triggering
+rebuilds. It uses standard gitignore syntax (https://git-scm.com/docs/gitignore).
+Patterns from .gitignore are also respected. Both files are additive — a path is
+ignored if it matches either file.
+
+Example .azdxignore:
+  dist/
+  build/
+  *.tmp
+  coverage/
+  !.vscode/launch.json`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			internal.WriteCommandHeader(
 				"Watch and azd extension (azd x watch)",

cli/azd/pkg/ignore/ignore.go

@@ -6,6 +6,7 @@ package ignore
 import (
 	"bytes"
 	"errors"
+	"fmt"
 	"io/fs"
 	"os"
 	"path/filepath"
@@ -38,7 +39,7 @@ type Matcher struct {
 func NewMatcher(root string) (*Matcher, error) {
 	absRoot, err := filepath.Abs(root)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("resolving root path: %w", err)
 	}
 
 	m := &Matcher{root: absRoot}

cli/azd/pkg/ignore/ignore_test.go

@@ -239,3 +239,26 @@ func TestNewMatcher_BlankAndWhitespaceLines(t *testing.T) {
 	require.True(t, m.IsIgnored("temp", true))
 	require.False(t, m.IsIgnored("main.go", false))
 }
+
+func TestNewMatcher_CrossFileNegationCannotOverride(t *testing.T) {
+	dir := t.TempDir()
+
+	// .azdxignore ignores all .log files.
+	writeFile(t, dir, AzdxIgnoreFile, "*.log\n")
+	// .gitignore tries to un-ignore important.log via negation.
+	writeFile(t, dir, GitIgnoreFile, "!important.log\n")
+
+	m, err := NewMatcher(dir)
+	require.NoError(t, err)
+
+	// important.log is STILL ignored — .gitignore negation cannot override
+	// .azdxignore matches because each file is parsed independently (union semantics).
+	require.True(t, m.IsIgnored("important.log", false),
+		".gitignore negation must not un-ignore paths matched by .azdxignore")
+
+	// Regular .log files are also ignored.
+	require.True(t, m.IsIgnored("debug.log", false))
+
+	// Non-log files are unaffected.
+	require.False(t, m.IsIgnored("main.go", false))
+}

cli/azd/pkg/watch/watch_test.go

@@ -354,3 +354,53 @@ func TestGetFileChanges_RenameFile(t *testing.T) {
 		return false
 	}, 2*time.Second, 50*time.Millisecond, "expected new.txt after rename")
 }
+
+func TestGetFileChanges_DeleteIgnoredDirFallback(t *testing.T) {
+	// Tests the os.Stat failure fallback: when a directory matching a dir-only
+	// ignore pattern (trailing /) is deleted, os.Stat fails and isDir defaults
+	// to false. The watcher re-checks with isDir=true so that the Remove event
+	// is still filtered by the directory-only pattern.
+	dir := t.TempDir()
+	t.Chdir(dir)
+
+	// .azdxignore uses a dir-only pattern (trailing slash).
+	err := os.WriteFile(filepath.Join(dir, ".azdxignore"), []byte("tmpout/\n"), 0600)
+	require.NoError(t, err)
+
+	// Pre-create the directory so watchRecursive skips it (ignored).
+	err = os.MkdirAll(filepath.Join(dir, "tmpout"), 0700)
+	require.NoError(t, err)
+
+	ctx, cancel := context.WithCancel(t.Context())
+	defer cancel()
+
+	watcher, err := NewWatcher(ctx)
+	require.NoError(t, err)
+
+	// Delete the ignored directory — the parent watcher fires a Remove event.
+	// os.Stat will fail (path gone), so isDir defaults to false.
+	// Without the fallback re-check (isDir=true), this would leak through
+	// as a file deletion since "tmpout/" only matches directories.
+	err = os.RemoveAll(filepath.Join(dir, "tmpout"))
+	require.NoError(t, err)
+
+	// Write a tracked file as a positive signal.
+	err = os.WriteFile(filepath.Join(dir, "tracked.go"), []byte("package main"), 0600)
+	require.NoError(t, err)
+
+	// Verify tracked file appears and no tmpout path leaks through.
+	require.Eventually(t, func() bool {
+		changes := watcher.GetFileChanges()
+		foundTracked := false
+		for _, c := range changes {
+			if filepath.Base(c.Path) == "tmpout" {
+				return false // ignored dir leaked through — fail fast
+			}
+			if filepath.Base(c.Path) == "tracked.go" && c.ChangeType == FileCreated {
+				foundTracked = true
+			}
+		}
+		return foundTracked
+	}, 2*time.Second, 50*time.Millisecond,
+		"expected tracked.go created without tmpout directory delete leaking through")
+}