.claude/settings.json

@@ -2,11 +2,11 @@
   "hooks": {
     "PostToolUse": [
       {
-        "matcher": "Edit|Write|MultiEdit",
+        "matcher": "Edit|Write",
         "hooks": [
           {
             "type": "command",
-            "command": "jq -r '.tool_input.file_path // empty' | { read -r f; case \"$f\" in *.go) gofumpt -w \"$f\" ;; esac; } 2>/dev/null || true"
+            "command": "jq -r '.tool_input.file_path // empty' | xargs -I{} gofumpt -w {}"
           }
         ]
       }

CLAUDE.md

@@ -1,5 +0,0 @@
-# CLAUDE.md
-
-## Build & test
-- All Go commands need `GOFLAGS=-mod=vendor` (deps are vendored, including the `jesseduffield/gocui` fork and the Docker SDK).
-- Unit tests: `GOFLAGS=-mod=vendor go test ./...`

pkg/commands/docker.go

@@ -154,25 +154,9 @@ func NewDockerCommand(log *logrus.Entry, osCommand *OSCommand, tr *i18n.Translat
 		log.Warn(err.Error())
 	}
 
-	// When the user passes -p outside of a compose directory, treat it as the
-	// local project so the project/services panels still appear and filtering
-	// is applied. Inside a compose dir, LocalProjectName is derived from
-	// container labels later in RefreshContainersAndServices.
-	if !dockerCommand.InDockerComposeProject && config.ProjectName != "" {
-		dockerCommand.LocalProjectName = config.ProjectName
-	}
-
 	return dockerCommand, nil
 }
 
-// IsProjectScoped reports whether lazydocker should be scoped to a single
-// compose project — either because we're inside a compose directory or
-// because the user passed -p. When false, the project/services panels are
-// hidden and all containers are shown in a flat list.
-func (c *DockerCommand) IsProjectScoped() bool {
-	return c.InDockerComposeProject || c.Config.ProjectName != ""
-}
-
 func (c *DockerCommand) setDockerComposeCommand(config *config.AppConfig) {
 	if config.UserConfig.CommandTemplates.DockerCompose != "docker compose" {
 		return

pkg/commands/docker_test.go

@@ -5,7 +5,6 @@ import (
 	"testing"
 
 	"github.com/docker/docker/client"
-	"github.com/jesseduffield/lazydocker/pkg/config"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -62,30 +61,3 @@ func TestNewDockerClientVersionNegotiation(t *testing.T) {
 			"client version should not be locked to DOCKER_API_VERSION env var")
 	})
 }
-
-// TestIsProjectScoped covers the predicate that drives whether the
-// project/services panels appear and whether the containers panel filters by
-// project. The "outside compose dir + -p" case is the regression we fixed
-// after PR #776 silently disabled it.
-func TestIsProjectScoped(t *testing.T) {
-	cases := []struct {
-		name                   string
-		inDockerComposeProject bool
-		projectName            string
-		want                   bool
-	}{
-		{"inside compose dir, no -p", true, "", true},
-		{"inside compose dir, with -p", true, "myproject", true},
-		{"outside compose dir, no -p", false, "", false},
-		{"outside compose dir, with -p", false, "myproject", true},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			c := &DockerCommand{
-				InDockerComposeProject: tc.inDockerComposeProject,
-				Config:                 &config.AppConfig{ProjectName: tc.projectName},
-			}
-			assert.Equal(t, tc.want, c.IsProjectScoped())
-		})
-	}
-}

pkg/gui/arrangement.go

@@ -176,30 +176,23 @@ func (gui *Gui) sidePanelChildren(width int, height int) []*boxlayout.Box {
 		}
 
 		// The project panel is compact (Size: 3) when not focused, but expands
-		// when focused to show the list of projects. This only applies when the
+		// when focused to show the list of projects.
-		// project panel is actually visible (i.e. we are inside a compose project).
+		projectBox := &boxlayout.Box{
-		if len(sideWindowNames) > 0 && sideWindowNames[0] == "project" {
+			Window: sideWindowNames[0],
-			projectBox := &boxlayout.Box{
+			Size:   3,
+		}
+		if currentWindow == sideWindowNames[0] {
+			projectBox = &boxlayout.Box{
 				Window: sideWindowNames[0],
-				Size:   3,
+				Weight: 2,
 			}
-			if currentWindow == sideWindowNames[0] {
-				projectBox = &boxlayout.Box{
-					Window: sideWindowNames[0],
-					Weight: 2,
-				}
-			}
-
-			return append([]*boxlayout.Box{
-				projectBox,
-			}, lo.Map(sideWindowNames[1:], func(window string, _ int) *boxlayout.Box {
-				return accordionBox(&boxlayout.Box{Window: window, Weight: 1})
-			})...)
 		}
 
-		return lo.Map(sideWindowNames, func(window string, _ int) *boxlayout.Box {
+		return append([]*boxlayout.Box{
+			projectBox,
+		}, lo.Map(sideWindowNames[1:], func(window string, _ int) *boxlayout.Box {
 			return accordionBox(&boxlayout.Box{Window: window, Weight: 1})
-		})
+		})...)
 	} else {
 		squashedHeight := 1
 		if height >= 21 {

pkg/gui/containers_panel.go

@@ -83,35 +83,25 @@ func (gui *Gui) getContainersPanel() *panels.SideListPanel[*commands.Container]
 			return sortContainers(a, b, gui.Config.UserConfig.Gui.LegacySortContainers)
 		},
 		Filter: func(container *commands.Container) bool {
+			// Note that this is O(N*M) time complexity where N is the number of services
+			// and M is the number of containers. We expect N to be small but M may be large,
+			// so we will need to keep an eye on this.
+			if !gui.Config.UserConfig.Gui.ShowAllContainers && !isStandaloneContainer(container) {
+				return false
+			}
+
 			if !gui.State.ShowExitedContainers && container.Container.State == "exited" {
 				return false
 			}
 
-			// When project-scoped, apply project and standalone filtering.
+			// Filter by selected project. Containers with no project (truly
-			// Otherwise all containers are shown in a flat list regardless
+			// standalone, not from any compose project) are always shown.
-			// of which compose project they belong to.
+			selectedProject := gui.getSelectedProjectName()
-			if gui.DockerCommand.IsProjectScoped() {
+			if selectedProject == "" {
-				// This check must be inside the IsProjectScoped guard: when
+				selectedProject = gui.DockerCommand.LocalProjectName
-				// not project-scoped, services are still derived from container
+			}
-				// labels, so compose-managed containers from other projects
+			if selectedProject != "" && container.ProjectName != "" && container.ProjectName != selectedProject {
-				// would be incorrectly hidden.
+				return false
-				//
-				// Note that this is O(N*M) time complexity where N is the number of services
-				// and M is the number of containers. We expect N to be small but M may be large,
-				// so we will need to keep an eye on this.
-				if !gui.Config.UserConfig.Gui.ShowAllContainers && !isStandaloneContainer(container) {
-					return false
-				}
-
-				// Filter by selected project. Containers with no project (truly
-				// standalone, not from any compose project) are always shown.
-				selectedProject := gui.getSelectedProjectName()
-				if selectedProject == "" {
-					selectedProject = gui.DockerCommand.LocalProjectName
-				}
-				if selectedProject != "" && container.ProjectName != "" && container.ProjectName != selectedProject {
-					return false
-				}
 			}
 
 			return true

pkg/gui/gui.go

@@ -459,7 +459,7 @@ func (gui *Gui) ShouldRefresh(key string) bool {
 }
 
 func (gui *Gui) initiallyFocusedViewName() string {
-	if gui.DockerCommand.IsProjectScoped() {
+	if gui.DockerCommand.InDockerComposeProject {
 		return "services"
 	}
 	return "containers"

pkg/gui/project_panel.go

@@ -58,9 +58,6 @@ func (gui *Gui) getProjectPanel() *panels.SideListPanel[*commands.Project] {
 			// containers to show only those belonging to the selected project.
 			return gui.renderContainersAndServices()
 		},
-		Hide: func() bool {
-			return !gui.DockerCommand.IsProjectScoped()
-		},
 	}
 }
 
@@ -94,19 +91,18 @@ func (gui *Gui) refreshProject() error {
 }
 
 // getDiscoveredProjects returns all docker compose projects by examining container labels.
-// The local project (from docker-compose.yml in the current directory, or from -p) is
+// The local project (from docker-compose.yml in the current directory) is included if
-// included even when it has no running containers, so the user always sees the project
+// it has running containers or if InDockerComposeProject is true.
-// they explicitly scoped to.
 func (gui *Gui) getDiscoveredProjects() []*commands.Project {
 	containers := gui.Panels.Containers.List.GetAllItems()
 	projectNames := gui.DockerCommand.GetProjectNames(containers)
 
-	// If we're scoped to a project but it has no running containers, still
+	// If we're in a docker compose project but it has no running containers,
-	// include it. We don't fall back to the directory name here to avoid
+	// still include it. We don't fall back to the directory name here to avoid
 	// briefly flashing the wrong project name on startup.
 	localName := gui.DockerCommand.LocalProjectName
 
-	if gui.DockerCommand.IsProjectScoped() && localName != "" {
+	if gui.DockerCommand.InDockerComposeProject && localName != "" {
 		found := false
 		for _, name := range projectNames {
 			if name == localName {
@@ -191,11 +187,6 @@ func (gui *Gui) renderAllLogs(project *commands.Project) tasks.TaskFunc {
 }
 
 func (gui *Gui) renderDockerComposeConfig(project *commands.Project) tasks.TaskFunc {
-	if !gui.DockerCommand.InDockerComposeProject {
-		return gui.NewSimpleRenderStringTask(func() string {
-			return "Compose config is only available when launched from a docker-compose project directory"
-		})
-	}
 	if project != nil && project.Name != gui.DockerCommand.LocalProjectName {
 		return gui.NewSimpleRenderStringTask(func() string {
 			return "Compose config is not available for non-local projects"

pkg/gui/services_panel.go

@@ -90,7 +90,8 @@ func (gui *Gui) getServicesPanel() *panels.SideListPanel[*commands.Service] {
 			return presentation.GetServiceDisplayStrings(&gui.Config.UserConfig.Gui, service)
 		},
 		Hide: func() bool {
-			return !gui.DockerCommand.IsProjectScoped()
+			// Show services panel if there are any compose projects (local or discovered)
+			return !gui.DockerCommand.InDockerComposeProject && len(gui.Panels.Services.List.GetAllItems()) == 0
 		},
 	}
 }

pkg/gui/views.go

@@ -130,7 +130,7 @@ func (gui *Gui) createAllViews() error {
 
 	gui.Views.Containers.Highlight = true
 	gui.Views.Containers.SelBgColor = selectedLineBgColor
-	if gui.Config.UserConfig.Gui.ShowAllContainers || !gui.DockerCommand.IsProjectScoped() {
+	if gui.Config.UserConfig.Gui.ShowAllContainers || !gui.DockerCommand.InDockerComposeProject {
 		gui.Views.Containers.Title = gui.Tr.ContainersTitle
 	} else {
 		gui.Views.Containers.Title = gui.Tr.StandaloneContainersTitle