I really enjoy goda! It's been very helpful on debugging. Now I want to use it as part of our CI to build and test the application when the relevant packages have changed.

Our CI is air gapped and all the packages vendored, but when I call goda list, I see it's trying to fetch the packages from the internet.

Is there a way to enable vendored package in goda?

I am attempting to use goda to produce the same form of output as go mod graph, for use in an application that parses the latter. goda graph -type edges comes close, save for the lack of version suffixes. There does not appear to be a format string argument that will provide this.

It would be helpful for version information to at least be available (as a label-formatting directive) when generating dependency output.

I don't find the clusters chosen by goda -cluster map to concepts in Go. I think clustering based on repository and module membership provides a more useful visualization. Here's a rough draft of some changes to make goda -cluster work that way. Is this something you would consider adding to goda if it was polished up a bit more?

Thanks for the great tool.

I did run across a null pointer dereference error when attempting to create a graph with the -cluster command, as described by someone else in #62

I noticed that when LoadNode() is called, it sets an error if the repo cannot be loaded. If the error is set, it means the repo is not set, so anything attempting to access the node repo is then crashing. Rather than checking for nil values in specific places, I opted to no longer process that node at all.

I have very often wanted to run a command to see why a dependency is required. This could be similar to go mod why, although that command is lacking a bit of functionality.

Essentially, given an import tree of

.
 ├  a
   ├ b
   ├ c
 ├ d
   ├  c 
 ├  c 

I would like a command like: goda why . c I would expect:

$ goda why . c
. -> a -> c
. -> d -> c
. -> c

From this, I can see all of the places I need to clean up usages of c if I want to drop the dependency.

I have done this exact thing before using a bunch of ad-hoc goda commands, resulting in out binary sizes being cut in half, so I think it would be pretty useful. It feels like all of the information is there, but not presentable in this way. Its also possible I just haven't found the right expressions to represent this.

Alternatives:

• Modify graph/tree in some way to allow filtering out packages not in the path of c. For example, the above tree would be filtered to:

.
 ├  a
   ├ c
 ├ d
   ├  c 
 ├  c 

Here the tree is pretty much the same, but in our real repo the tree is 12k lines so its not usable for this use case. The same with the graph - its too big to read without filtering

From the list of subcommands, nm is the one which could have a more intuitive name. Depending on future developments I would recommend binary or memory as a replacement.

I'm not sure what other details I can provide that would be helpful since the repo is private but happy to provide whatever additional details I can.

$ goda graph -cluster -short "github.com/me/app:all" | dot -Tsvg -o graph.svg

panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x18 pc=0x1408ce1]

goroutine 1 [running]:
github.com/loov/goda/internal/pkgtree.(*Tree).NodeRepo(...)
	/Users/me/go/pkg/mod/github.com/loov/[email protected]/internal/pkgtree/tree.go:75
github.com/loov/goda/internal/pkgtree.From(0xc000076000, 0xb061, 0x5c0, 0xee)
	/Users/me/go/pkg/mod/github.com/loov/[email protected]/internal/pkgtree/tree.go:26 +0x121
github.com/loov/goda/internal/graph.(*Dot).WriteClusters(0xc000154980, 0xc000076000, 0x0, 0x0)
	/Users/me/go/pkg/mod/github.com/loov/[email protected]/internal/graph/dot.go:131 +0x76
github.com/loov/goda/internal/graph.(*Dot).Write(0xc000154980, 0xc000076000, 0xc0008d2270, 0x1)
	/Users/me/go/pkg/mod/github.com/loov/[email protected]/internal/graph/dot.go:106 +0x3b
github.com/loov/goda/internal/graph.(*Command).Execute(0xc000154640, 0x157f370, 0xc00011a000, 0xc00012e660, 0x0, 0x0, 0x0, 0x0)
	/Users/me/go/pkg/mod/github.com/loov/[email protected]/internal/graph/cmd.go:136 +0x339
github.com/google/subcommands.(*Commander).Execute(0xc000130200, 0x157f370, 0xc00011a000, 0x0, 0x0, 0x0, 0xffffffff)
	/Users/me/go/pkg/mod/github.com/google/[email protected]/subcommands.go:209 +0x347
main.main()
	/Users/me/go/pkg/mod/github.com/loov/[email protected]/main.go:38 +0x39d

Currently it seems build tags are not respected. I would like files like // +build !bloat to be ignored, since they will not end up in my final binaries anyways. Specifically with graph, but likely others apply as well

Currently to include test packages, you can use test=1(something) but that's awkward to type, not that easy to remember and requires shell quotes.

I find myself needing this qualifier a lot, because test code is a large part of any repository and a big part of refactoring calculations.

How about using a :test qualifier instead?

So, for example, ./...:test would include all the test code in ./....

./...:test:all would include all dependencies of all packages and tests below ..

This change:

• removes :root, this is the default behavior
• removes :noroot, and replaces it with :deps
• adds :all, to get the previous behavior

When using the expression syntax, the first usage is often to target all the roots and the dependenices... however most reduction need to use :root. Effectively making the expressions longer than they need to be.

For a comparison:

X - golang.org/x/tools/...:root - github.com/xyz/...:root

After this change:

X:all - golang.org/x/tools/... - github.com/xyz/...

Arguably, the second one is easier to read and understand.

CC @rogpeppe

Feature Request We run our own internal GoDoc. Being able to point at that instead of pkg.go.dev would make this package usable in our GoDoc.

What's currently happening Clicking a node yields documentation for pkg.go.dev which only serves public packages

What you want to happen Be able to override the pkg.go.dev URL.

Currently the code loads all the std library packages, which takes a bunch of time. It's only used to remove std library packages from the output.

https://github.com/loov/goda/blob/v0.5.3/internal/pkgset/std.go#L13

Instead of loading the std packages separately, write a func that detects based on packages.Package whether it's a std library package or not.

When I run goda cut, I see a lot of test package results like this:

github.com/influxdata/idpe/client/v2 [github.com/influxdata/idpe/client/v2.test]                                                                            in:0     pkgs:1   size:45.6KB    loc:1499
github.com/influxdata/idpe/client/v2.test                                                                                                                   in:0     pkgs:1   size:2.9KB     loc:58
github.com/influxdata/idpe/client/v2_test [github.com/influxdata/idpe/client/v2.test]                                                                       in:0     pkgs:1   size:6.0KB     loc:234
github.com/influxdata/idpe/client/v2                                                                                                                        in:24    pkgs:1   size:21.3KB    loc:706

There's actually only one package there, but it's appearing multiple times in the results (because of the external test shenanigans).

It's probably not helpful to include these entries in the cut results because it's unlikely we're going to consider removing tests.

In fact, these results are kinda confusing all round unless you're familiar with the way that test packages are dealt with. I know these package need to be a part of the package sets internally, but I wonder if there might be a way to hide them from user view, at least most of the time?

During output it would be nice to collapse some particular nodes into a single node.

For example, these could be collapsed:

1. modules
2. */internal/*
3. golang.org/x/tools/*
4. everything except the project module (or multiple modules)

This sounds like pkggraph needs collapsing and uncollapsing capabilities so that the code can be written as:

goda graph -m .
goda graph -collapse "*/internal/*" .
goda graph -collapse "golang.org/x/tools/*" .

# combining all together
goda graph -m -uncollapse github.com/loov/goda -collapse "*/internal/*" .