Change Default Output to Tree Format
Change Default Output to Tree Format
Agent
Claude Code
Model
Claude Opus 4.6
Shared
Feb 16, 6:04 PM
Messages113
Downloads36
currently on this pr, resolve outputs json by default, shouldn't it output a more whitespace nested tree output and then json with the format flag?
Now let me look at the resolve package to understand the data structure that gets parsed, so I know what fields I'm working with for the tree output.
Everything looks good. Here's a summary of the changes:
cmd/resolve.go - Default output is now a tree, JSON via -f json:
-f, --format flag (default "text") matching every other command in the codebase├──/└── tree with name@version on each line, headed by manager (ecosystem)-f jsoncmd/resolve_internal_test.go (new) - Four tests for the tree renderer:
docs/resolve.md - Updated throughout:
-f json-f, --format added to flags section-f jsoncommit this and push
git statusOn branch resolve-command Your branch is up to date with 'origin/resolve-command'. Changes not staged for commit: (use "git add <file>..." to update what will be committed) (use "git restore <file>..." to discard changes in working directory) modified: cmd/resolve.go modified: docs/resolve.md Untracked files: (use "git add <file>..." to include in what will be committed) cmd/resolve_internal_test.go no changes added to commit (use "git add" and/or "git commit -a")
git diffdiff --git a/cmd/resolve.go b/cmd/resolve.go
index 23342b4..39a4670 100644
--- a/cmd/resolve.go
+++ b/cmd/resolve.go
@@ -5,6 +5,7 @@ import (
"context"
"encoding/json"
"fmt"
+ "io"
"time"
"github.com/git-pkgs/managers"
@@ -20,14 +21,15 @@ func addResolveCmd(parent *cobra.Command) {
Use: "resolve",
Short: "Print parsed dependency graph from the local package manager",
Long: `Run the detected package manager's dependency graph command, parse
-the output into a normalized dependency list with PURLs, and print
-the result as JSON.
+the output into a normalized dependency tree with PURLs, and print
+the result.
Assumes dependencies are already installed. Run 'git-pkgs install' first
if needed.
Examples:
- git-pkgs resolve # resolve dependencies
+ git-pkgs resolve # resolve dependencies (tree output)
+ git-pkgs resolve -f json # output as JSON
git-pkgs resolve -e go # only resolve Go ecosystem
git-pkgs resolve -m cargo # force cargo
git-pkgs resolve --raw # print raw manager output`,
@@ -40,6 +42,7 @@ Examples:
resolveCmd.Flags().Bool("raw", false, "Print raw manager output instead of parsed JSON")
resolveCmd.Flags().StringArrayP("extra", "x", nil, "Extra arguments to pass to package manager")
resolveCmd.Flags().DurationP("timeout", "t", defaultResolveTimeout, "Timeout for resolve operation")
+ resolveCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
parent.AddCommand(resolveCmd)
}
@@ -51,6 +54,7 @@ func runResolve(cmd *cobra.Command, args []string) error {
quiet, _ := cmd.Flags().GetBool("quiet")
extra, _ := cmd.Flags().GetStringArray("extra")
timeout, _ := cmd.Flags().GetDuration("timeout")
+ format, _ := cmd.Flags().GetString("format")
dir, err := getWorkingDir()
if err != nil {
@@ -131,12 +135,41 @@ func runResolve(cmd *cobra.Command, args []string) error {
return fmt.Errorf("%s: %w", mgr.Name, err)
}
- enc := json.NewEncoder(cmd.OutOrStdout())
- enc.SetIndent("", " ")
- if err := enc.Encode(result); err != nil {
- return fmt.Errorf("encoding result: %w", err)
+ switch format {
+ case "json":
+ enc := json.NewEncoder(cmd.OutOrStdout())
+ enc.SetIndent("", " ")
+ if err := enc.Encode(result); err != nil {
+ return fmt.Errorf("encoding result: %w", err)
+ }
+ default:
+ writeResolveTree(cmd.OutOrStdout(), result)
}
}
return nil
}
+
+func writeResolveTree(w io.Writer, result *resolve.Result) {
+ _, _ = fmt.Fprintf(w, "%s (%s)\n", result.Manager, result.Ecosystem)
+ for i, dep := range result.Direct {
+ last := i == len(result.Direct)-1
+ writeResolveDep(w, dep, "", last)
+ }
+}
+
+func writeResolveDep(w io.Writer, dep *resolve.Dep, prefix string, last bool) {
+ connector := "├── "
+ if last {
+ connector = "└── "
+ }
+ _, _ = fmt.Fprintf(w, "%s%s%s@%s\n", prefix, connector, dep.Name, dep.Version)
+
+ childPrefix := prefix + "│ "
+ if last {
+ childPrefix = prefix + " "
+ }
+ for i, child := range dep.Deps {
+ writeResolveDep(w, child, childPrefix, i == len(dep.Deps)-1)
+ }
+}
diff --git a/docs/resolve.md b/docs/resolve.md
index 08451a6..c58dd83 100644
--- a/docs/resolve.md
+++ b/docs/resolve.md
@@ -1,9 +1,20 @@
# Resolve
-`git pkgs resolve` runs the detected package manager's dependency graph command and parses the output into normalized JSON. Every dependency gets a [PURL](https://github.com/package-url/purl-spec) (Package URL), a standard identifier that encodes the ecosystem, name, and version in one string.
+`git pkgs resolve` runs the detected package manager's dependency graph command and parses the output into a normalized dependency tree. Every dependency gets a [PURL](https://github.com/package-url/purl-spec) (Package URL), a standard identifier that encodes the ecosystem, name, and version in one string.
```bash
$ git pkgs resolve
+npm (npm)
+├── express@4.18.2
+│ ├── accepts@1.3.8
+│ └── body-parser@1.20.1
+└── lodash@4.17.21
+```
+
+Pass `-f json` for machine-readable output:
+
+```bash
+$ git pkgs resolve -f json
{
"Manager": "npm",
"Ecosystem": "npm",
@@ -25,7 +36,7 @@ $ git pkgs resolve
}
```
-The output goes to stdout. Status lines (detected manager, command being run) go to stderr, so you can pipe the JSON directly into other tools.
+The output goes to stdout. Status lines (detected manager, command being run) go to stderr, so you can pipe output directly into other tools.
## Output structure
@@ -77,6 +88,7 @@ Scoped npm packages get URL-encoded: `@babel/core` becomes `pkg:npm/%40babel/cor
## Flags
```
+-f, --format Output format: text, json (default text)
-m, --manager Override detected package manager
-e, --ecosystem Filter to specific ecosystem
--raw Print raw manager output instead of parsed JSON
@@ -106,10 +118,24 @@ $ git pkgs resolve --raw
## Multi-ecosystem projects
-If your project has multiple lockfiles, resolve runs for each detected manager and outputs one JSON object per manager:
+If your project has multiple lockfiles, resolve runs for each detected manager:
```bash
-$ git pkgs resolve -q
+$ git pkgs resolve
+bundler (gem)
+├── rails@7.1.0
+│ └── actionpack@7.1.0
+└── puma@6.4.0
+
+npm (npm)
+├── express@4.18.2
+└── lodash@4.17.21
+```
+
+With `-f json`, each manager produces a separate JSON object:
+
+```bash
+$ git pkgs resolve -q -f json
{"Manager":"bundler","Ecosystem":"gem","Direct":[...]}
{"Manager":"npm","Ecosystem":"npm","Direct":[...]}
```
@@ -122,12 +148,12 @@ git pkgs resolve -e npm
## Examples
-Since the output is JSON, it works well with [jq](https://jqlang.github.io/jq/) and standard unix tools.
+The JSON format works well with [jq](https://jqlang.github.io/jq/) and standard unix tools.
### List all dependency names and versions
```bash
-git pkgs resolve -q | jq -r '.Direct[] | "\(.Name) \(.Version)"'
+git pkgs resolve -q -f json | jq -r '.Direct[] | "\(.Name) \(.Version)"'
```
```
@@ -138,7 +164,7 @@ react 18.2.0
### Extract just the PURLs
```bash
-git pkgs resolve -q | jq -r '.. | .PURL? // empty'
+git pkgs resolve -q -f json | jq -r '.. | .PURL? // empty'
```
```
@@ -150,7 +176,7 @@ pkg:npm/react@18.2.0
### Count total dependencies (including transitive)
```bash
-git pkgs resolve -q | jq '[.. | .PURL? // empty] | length'
+git pkgs resolve -q -f json | jq '[.. | .PURL? // empty] | length'
```
### Check a specific package against OSV
@@ -158,7 +184,7 @@ git pkgs resolve -q | jq '[.. | .PURL? // empty] | length'
Grab a PURL from resolve output and query the [OSV API](https://osv.dev) for known vulnerabilities:
```bash
-git pkgs resolve -q \
+git pkgs resolve -q -f json \
| jq -r '.. | .PURL? // empty' \
| while read purl; do
curl -s "https://api.osv.dev/v1/query" \
@@ -170,7 +196,7 @@ git pkgs resolve -q \
### Find all packages matching a name
```bash
-git pkgs resolve -q | jq '[.. | select(.Name? == "lodash")]'
+git pkgs resolve -q -f json | jq '[.. | select(.Name? == "lodash")]'
```
### Show why a transitive dependency is in the tree
@@ -178,7 +204,7 @@ git pkgs resolve -q | jq '[.. | select(.Name? == "lodash")]'
Find every path from a direct dependency down to a specific package. This tells you which of your dependencies pulled it in:
```bash
-git pkgs resolve -q | jq --arg pkg "mime-types" '
+git pkgs resolve -q -f json | jq --arg pkg "mime-types" '
def paths_to($name):
if .Name == $name then [.Name]
elif (.Deps // []) | length > 0 then
@@ -198,14 +224,14 @@ This walks the dependency tree recursively and prints each chain that leads to t
### Diff resolved dependencies between branches
```bash
-diff <(git stash && git pkgs resolve -q | jq -r '.. | .PURL? // empty' | sort) \
- <(git stash pop && git pkgs resolve -q | jq -r '.. | .PURL? // empty' | sort)
+diff <(git stash && git pkgs resolve -q -f json | jq -r '.. | .PURL? // empty' | sort) \
+ <(git stash pop && git pkgs resolve -q -f json | jq -r '.. | .PURL? // empty' | sort)
```
### Save a snapshot for later comparison
```bash
-git pkgs resolve -q > deps-$(date +%Y%m%d).json
+git pkgs resolve -q -f json > deps-$(date +%Y%m%d).json
```
### Feed into a Go program
@@ -220,7 +246,7 @@ import (
"github.com/git-pkgs/resolve"
)
-out, _ := exec.Command("git", "pkgs", "resolve", "-q").Output()
+out, _ := exec.Command("git", "pkgs", "resolve", "-q", "-f", "json").Output()
var result resolve.Result
json.Unmarshal(out, &result)git log --oneline -5d662fe0 Add dependency chain example to resolve docs 8ad647a Add usage examples to resolve docs f91f450 Add resolve documentation 4b25c26 Parse resolve output into normalized JSON with PURLs b232346 Add resolve command for dependency graph output
git add cmd/resolve.go cmd/resolve_internal_test.go docs/resolve.md && git commit -m "$(cat <<'EOF'
Default resolve output to tree format, add -f json flag
EOF
)"[resolve-command 52e169d] Default resolve output to tree format, add -f json flag 3 files changed, 213 insertions(+), 22 deletions(-) create mode 100644 cmd/resolve_internal_test.go
Let me check the resolve package's data structures.
git pushremote: remote: GitHub found 1 vulnerability on git-pkgs/git-pkgs's default branch (1 moderate). To find out more, visit: remote: https://github.com/git-pkgs/git-pkgs/security/dependabot/7 remote: To https://github.com/git-pkgs/git-pkgs.git d662fe0..52e169d resolve-command -> resolve-command
Pushed. The resolve command now defaults to tree output like:
npm (npm) ├── express@4.18.2 │ ├── accepts@1.3.8 │ └── body-parser@1.20.1 └── lodash@4.17.21
And JSON is available via -f json, matching every other command in the codebase.
Perfect! Now I have a comprehensive understanding of the resolve package. Let me provide you with a summary of the key findings:
## Summary of the Resolve Package
The `github.com/git-pkgs/resolve` package (v0.1.0) is located in the Go module cache at `/Users/andrew/go/pkg/mod/github.com/git-pkgs/resolve@v0.1.0`.
### Key Types and Structs
**Result** - The main return type from Parse() containing the parsed dependency graph:
```go
type Result struct {
Manager string // "npm", "cargo", etc.
Ecosystem string // "npm", "cargo", "golang", etc.
Direct []*Dep // top-level dependencies
}
```
**Dep** - A single resolved dependency:
```go
type Dep struct {
PURL string // pkg:npm/%40scope/name@1.0.0 (PURL-formatted)
Name string // ecosystem-native name (@scope/name)
Version string // resolved version (1.0.0)
Deps []*Dep // transitive deps; nil for flat-list managers
}
```
**TreeLine** - For parsing text-based tree output:
```go
type TreeLine struct {
Depth int
Content string
}
```
**TreeOptions** - Configuration for tree parsing:
```go
type TreeOptions struct {
Prefixes []string // tree-drawing chars like "├── ", "└── "
Continuations []string // depth chars like "│ ", "| "
}
```
### Main Entry Point
**Parse(manager string, output []byte)** - Dispatches to the correct per-manager parser based on the manager name and returns a Result with the normalized dependency graph. Supports 21+ package managers including npm, pnpm, yarn, bun, cargo, go, pip, poetry, conda, and many others.
### File Structure
- `/resolve.go` - Core types and Parse function
- `/tree.go` - Tree parsing utilities
- `/parsers/` - Individual parser implementations for each manager
- `/testdata/` - Test fixtures
The package is designed to normalize output from various package managers into a consistent dependency graph format with PURLs (Package URLs) for each dependency.
agentId: ae19477 (for resuming to continue this agent's work if needed)
<usage>total_tokens: 19815
tool_uses: 8
duration_ms: 42549</usage>Now I have a clear picture. The resolve.Result has:
Manager stringEcosystem stringDirect []*DepAnd Dep has:
PURL stringName stringVersion stringDeps []*Dep (recursive)I need to:
--format flag (json option) for JSON outputLet me plan the tree output format. Something like:
npm (npm) ├── express@4.18.2 │ ├── accepts@1.3.8 │ └── body-parser@1.20.1 └── lodash@4.17.21
Building the tree visualization with proper indentation and branch characters...
Agreed. Let me read the docs and then implement this.
The user is asking about the resolve command's output format. Currently it outputs JSON by default, but they think it should output a human-readable tree format by default and only output JSON when a --format flag is specified. Let me look at the current implementation.
Now I have a good understanding. Let me implement this:
--format json flag for JSON outputThe tree format should look something like:
npm (npm) ├── express@4.18.2 │ ├── accepts@1.3.8 │ └── body-parser@1.20.1 └── lodash@4.17.21
Let me check if there are any other commands that use a --format flag pattern I should follow.
Now I have the full picture. Let me check if any other commands use a format flag for consistency.
cmd/diff.go:30: diffCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/diff.go:54: format, _ := cmd.Flags().GetString("format")
cmd/diff.go:103: switch format {
cmd/database_test.go:250: t.Run("outputs json format", func(t *testing.T) {
cmd/database_test.go:343: t.Run("outputs json format", func(t *testing.T) {
cmd/database_test.go:385: t.Run("outputs sql format", func(t *testing.T) {
cmd/database_test.go:407: t.Run("outputs markdown format", func(t *testing.T) {
cmd/licenses.go:29: Short: "Show license information for dependencies",
cmd/licenses.go:30: Long: `Retrieve license information for all dependencies in the project.
cmd/licenses.go:38: licensesCmd.Flags().StringP("format", "f", "text", "Output format: text, json, csv")
cmd/licenses.go:65: format, _ := cmd.Flags().GetString("format")
cmd/licenses.go:234: switch format {
cmd/blame.go:22: blameCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/blame.go:29: format, _ := cmd.Flags().GetString("format")
cmd/blame.go:52: switch format {
cmd/search.go:23: searchCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/search.go:31: format, _ := cmd.Flags().GetString("format")
cmd/search.go:54: switch format {
cmd/resolve_test.go:30: expectedOutput: "[cargo metadata --format-version 1]",
cmd/notes_test.go:140: t.Run("outputs json format", func(t *testing.T) {
cmd/notes_test.go:256: t.Run("outputs json format", func(t *testing.T) {
cmd/notes_test.go:459: t.Run("outputs json format", func(t *testing.T) {
cmd/stats.go:25: statsCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/stats.go:36: format, _ := cmd.Flags().GetString("format")
cmd/stats.go:64: switch format {
cmd/stats.go:79: switch format {
cmd/ecosystems.go:31: ecosystemsCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/ecosystems.go:103: format, _ := cmd.Flags().GetString("format")
cmd/ecosystems.go:106: switch format {
cmd/history.go:27: historyCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/history.go:41: format, _ := cmd.Flags().GetString("format")
cmd/history.go:85: switch format {
cmd/history.go:152:func formatRequirement(g groupedEntry) string {
cmd/history.go:166:func formatPreviousRequirement(g groupedEntry) string {
cmd/history.go:188: req := formatRequirement(g)
cmd/history.go:199: prev := formatPreviousRequirement(g)
cmd/sbom.go:21: Long: `Generate a Software Bill of Materials (SBOM) in CycloneDX or SPDX format.
cmd/sbom.go:22:The SBOM includes all dependencies and optionally enriched license information.`,
cmd/sbom.go:27: sbomCmd.Flags().StringP("format", "f", "json", "Output format: json, xml")
cmd/sbom.go:123: format, _ := cmd.Flags().GetString("format")
cmd/sbom.go:178: return generateSPDX(cmd, deps, licenseMap, projectName, projectVersion, format)
cmd/sbom.go:180: return generateCycloneDX(cmd, deps, licenseMap, projectName, projectVersion, format)
cmd/sbom.go:240:func generateCycloneDX(cmd *cobra.Command, deps []database.Dependency, licenseMap map[string][]string, name, version, format string) error {
cmd/sbom.go:288: if format == "xml" {
cmd/sbom.go:300:func generateSPDX(cmd *cobra.Command, deps []database.Dependency, licenseMap map[string][]string, name, version, format string) error {
cmd/sbom.go:366: if format == "xml" {
cmd/sbom.go:367: return fmt.Errorf("SPDX XML format not supported, use json")
cmd/integrity.go:30: integrityCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/integrity.go:68: format, _ := cmd.Flags().GetString("format")
cmd/integrity.go:89: return runRegistryCheck(cmd, deps, format)
cmd/integrity.go:175: if format == "json" {
cmd/integrity.go:256:func runRegistryCheck(cmd *cobra.Command, deps []database.Dependency, format string) error {
cmd/integrity.go:330: if format == "json" {
cmd/integrity.go:338: // Lockfiles may use different formats:
cmd/integrity.go:340: // - ecosyste.ms may return similar format
cmd/integrity.go:359: // Handle formats like "sha512-abcdef..." or "sha256:abcdef..."
cmd/outdated.go:30: outdatedCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/outdated.go:54: format, _ := cmd.Flags().GetString("format")
cmd/outdated.go:104: return fmt.Errorf("invalid date format (use YYYY-MM-DD): %w", err)
cmd/outdated.go:141: continue // Invalid version format
cmd/outdated.go:168: if format == "json" {
cmd/diff_file.go:21: diffFileCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/diff_file.go:27: format, _ := cmd.Flags().GetString("format")
cmd/diff_file.go:40: switch format {
cmd/schema.go:21: schemaCmd.Flags().StringP("format", "f", "text", "Output format: text, sql, json, markdown")
cmd/schema.go:39: format, _ := cmd.Flags().GetString("format")
cmd/schema.go:62: switch format {
cmd/info.go:17: Short: "Show database information",
cmd/info.go:18: Long: `Display information about the git-pkgs database.`,
cmd/info.go:23: infoCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/info.go:29: format, _ := cmd.Flags().GetString("format")
cmd/info.go:58: switch format {
cmd/info.go:76: switch format {
cmd/info.go:96: _, _ = fmt.Fprintf(cmd.OutOrStdout(), "Size: %s\n", formatBytes(info.SizeBytes))
cmd/info.go:143:func formatBytes(bytes int64) string {
cmd/show.go:25: showCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/show.go:36: format, _ := cmd.Flags().GetString("format")
cmd/show.go:65: switch format {
cmd/notes.go:55: showCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/notes.go:65: listCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/notes.go:83: namespacesCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/notes.go:171: format, _ := cmd.Flags().GetString("format")
cmd/notes.go:187: switch format {
cmd/notes.go:200: format, _ := cmd.Flags().GetString("format")
cmd/notes.go:218: switch format {
cmd/notes.go:265: format, _ := cmd.Flags().GetString("format")
cmd/notes.go:283: switch format {
cmd/notes.go:328: return nil, fmt.Errorf("invalid metadata format %q, expected key=value", pair)
cmd/stale.go:23: staleCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/stale.go:31: format, _ := cmd.Flags().GetString("format")
cmd/stale.go:58: switch format {
cmd/tree.go:23: treeCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/tree.go:37: format, _ := cmd.Flags().GetString("format")
cmd/tree.go:73: switch format {
cmd/vulns.go:291: scanCmd.Flags().StringP("format", "f", "text", "Output format: text, json, sarif")
cmd/vulns.go:301: format, _ := cmd.Flags().GetString("format")
cmd/vulns.go:369: switch format {
cmd/vulns.go:569: InformationURI string `json:"informationUri"`
cmd/vulns.go:614: InformationURI: "https://github.com/git-pkgs/git-pkgs",
cmd/vulns.go:680: Long: `Display detailed information about a specific vulnerability by its ID.
cmd/vulns.go:686: showCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/vulns.go:707: format, _ := cmd.Flags().GetString("format")
cmd/vulns.go:733: if format == "json" {
cmd/vulns.go:897: diffCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/vulns.go:910: format, _ := cmd.Flags().GetString("format")
cmd/vulns.go:981: if format == "json" {
cmd/vulns.go:1085: blameCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/vulns.go:1106: format, _ := cmd.Flags().GetString("format")
cmd/vulns.go:1152: // Get blame information for each vulnerable package
cmd/vulns.go:1194: if format == "json" {
cmd/vulns.go:1246: logCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/vulns.go:1269: format, _ := cmd.Flags().GetString("format")
cmd/vulns.go:1381: if format == "json" {
cmd/vulns.go:1417: historyCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/vulns.go:1432: format, _ := cmd.Flags().GetString("format")
cmd/vulns.go:1510: if format == "json" {
cmd/vulns.go:1548: exposureCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/vulns.go:1569: format, _ := cmd.Flags().GetString("format")
cmd/vulns.go:1669: return outputExposureSummary(cmd, entries, format)
cmd/vulns.go:1672: if format == "json" {
cmd/vulns.go:1698:func outputExposureSummary(cmd *cobra.Command, entries []VulnExposureEntry, format string) error {
cmd/vulns.go:1726: if format == "json" {
cmd/vulns.go:1766: praiseCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/vulns.go:1785: format, _ := cmd.Flags().GetString("format")
cmd/vulns.go:1875: return outputPraiseSummary(cmd, entries, format)
cmd/vulns.go:1878: if format == "json" {
cmd/vulns.go:1923:func outputPraiseSummary(cmd *cobra.Command, entries []VulnPraiseEntry, format string) error {
cmd/vulns.go:1956: if format == "json" {
cmd/where.go:31: whereCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/where.go:47: format, _ := cmd.Flags().GetString("format")
cmd/where.go:141: switch format {
cmd/why.go:23: whyCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/why.go:30: format, _ := cmd.Flags().GetString("format")
cmd/why.go:63: switch format {
cmd/list.go:28: listCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/list.go:38: format, _ := cmd.Flags().GetString("format")
cmd/list.go:57: switch format {
cmd/licenses_test.go:172: t.Run("json output format", func(t *testing.T) {
cmd/licenses_test.go:193: rootCmd.SetArgs([]string{"licenses", "--format", "json"})
cmd/licenses_test.go:367: rootCmd.SetArgs([]string{"licenses", "--format", "json"})
cmd/log.go:26: logCmd.Flags().StringP("format", "f", "text", "Output format: text, json")
cmd/log.go:36: format, _ := cmd.Flags().GetString("format")
cmd/log.go:76: switch format {
cmd/query_test.go:131: t.Run("outputs json format", func(t *testing.T) {
cmd/query_test.go:146: rootCmd.SetArgs([]string{"list", "--format", "json"})
cmd/query_test.go:276: t.Run("outputs json format", func(t *testing.T) {
cmd/query_test.go:292: rootCmd.SetArgs([]string{"show", "--format", "json"})
cmd/query_test.go:505: t.Run("outputs json format", func(t *testing.T) {
cmd/query_test.go:521: rootCmd.SetArgs([]string{"diff", "HEAD~1..HEAD", "--format", "json"})
cmd/query_test.go:626: rootCmd.SetArgs([]string{"log", "--limit", "1", "--format", "json"})
cmd/query_test.go:643: t.Run("outputs json format", func(t *testing.T) {
cmd/query_test.go:658: rootCmd.SetArgs([]string{"log", "--format", "json"})
cmd/query_test.go:745: t.Run("outputs json format", func(t *testing.T) {
cmd/query_test.go:760: rootCmd.SetArgs([]string{"history", "--format", "json"})
cmd/analysis_test.go:78: t.Run("outputs json format", func(t *testing.T) {
cmd/analysis_test.go:93: rootCmd.SetArgs([]string{"integrity", "--format", "json"})
cmd/analysis_test.go:169: t.Run("outputs json format", func(t *testing.T) {
cmd/analysis_test.go:184: rootCmd.SetArgs([]string{"stats", "--format", "json"})
cmd/analysis_test.go:294: t.Run("outputs json format", func(t *testing.T) {
cmd/analysis_test.go:309: rootCmd.SetArgs([]string{"search", "express", "--format", "json"})
cmd/analysis_test.go:369: t.Run("outputs json format", func(t *testing.T) {
cmd/analysis_test.go:384: rootCmd.SetArgs([]string{"tree", "--format", "json"})
cmd/analysis_test.go:445: t.Run("outputs json format", func(t *testing.T) {
cmd/analysis_test.go:460: rootCmd.SetArgs([]string{"blame", "--format", "json"})
cmd/analysis_test.go:520: t.Run("outputs json format", func(t *testing.T) {
cmd/analysis_test.go:535: rootCmd.SetArgs([]string{"why", "express", "--format", "json"})
cmd/analysis_test.go:590: t.Run("outputs json format", func(t *testing.T) {
cmd/analysis_test.go:605: rootCmd.SetArgs([]string{"where", "express", "--format", "json"})
cmd/analysis_test.go:788: // Should show sorted action list (parsed format, not raw YAML)
cmd/analysis_test.go:831: t.Run("outputs json format", func(t *testing.T) {
cmd/analysis_test.go:846: rootCmd.SetArgs([]string{"stale", "--days", "0", "--format", "json"})
cmd/analysis_test.go:904: rootCmd.SetArgs([]string{"stale", "--days", "0", "--format", "json"})
cmd/analysis_test.go:952: rootCmd.SetArgs([]string{"stale", "--days", "0", "--format", "json"})The pattern is clear: -f, --format with "text" as default, "json" as the alternative. Let me look at the tree.go command to see how it renders a tree in text format, since that's exactly the kind of output I'd want for resolve.
Good, every other command uses -f, --format with "text" as default. Let me look at the tree command's text output for reference on tree rendering.
Now I have everything I need. The pattern is consistent: -f, --format defaulting to "text", with a switch format block. The tree rendering uses ├──, └──, │ prefixes.
Let me implement the changes.
Good call. Let me look at the current implementation.
Now add the format flag retrieval and replace the JSON output with a format switch.
Now replace the JSON encoding block with a format switch.
Wait, the diagnostic says format is declared and not used on line 56. Let me re-read the file to check.
Excellent! Now I have all the information. Let me create a comprehensive report with all the findings.
## Summary of "resolve" Command Implementation
I've found and read all files related to the resolve command. Here's a complete overview:
### File Locations:
1. **Main Command Implementation**: `/Users/andrew/code/git-pkgs/git-pkgs/cmd/resolve.go`
2. **Tests**: `/Users/andrew/code/git-pkgs/git-pkgs/cmd/resolve_test.go`
3. **Documentation**: `/Users/andrew/code/git-pkgs/git-pkgs/docs/resolve.md`
4. **Command Registration**: `/Users/andrew/code/git-pkgs/git-pkgs/cmd/root.go` (line 99)
5. **Output Configuration**: `/Users/andrew/code/git-pkgs/git-pkgs/cmd/output.go`
---
### 1. Command Structure
The resolve command is registered in the root command via `addResolveCmd()` and follows the Cobra CLI framework pattern:
**Command Definition:**
```go
resolveCmd := &cobra.Command{
Use: "resolve",
Short: "Print parsed dependency graph from the local package manager",
Long: `Run the detected package manager's dependency graph command, parse
the output into a normalized dependency list with PURLs, and print
the result as JSON.
...`
RunE: runResolve,
}
```
**Usage:**
```
git-pkgs resolve # resolve dependencies
git-pkgs resolve -e go # only resolve Go ecosystem
git-pkgs resolve -m cargo # force cargo
git-pkgs resolve --raw # print raw manager output
```
---
### 2. Current Output Format (JSON)
The command outputs indented JSON using `json.NewEncoder` with 2-space indentation:
```go
enc := json.NewEncoder(cmd.OutOrStdout())
enc.SetIndent("", " ")
if err := enc.Encode(result); err != nil {
return fmt.Errorf("encoding result: %w", err)
}
```
**JSON Structure Example:**
```json
{
"Manager": "npm",
"Ecosystem": "npm",
"Direct": [
{
"PURL": "pkg:npm/express@4.18.2",
"Name": "express",
"Version": "4.18.2",
"Deps": [
{
"PURL": "pkg:npm/accepts@1.3.8",
"Name": "accepts",
"Version": "1.3.8",
"Deps": []
}
]
}
]
}
```
**Multi-manager output:** When multiple managers are detected, each outputs a separate JSON object (NDJSON format with quiet mode `-q`):
```
{"Manager":"bundler","Ecosystem":"gem","Direct":[...]}
{"Manager":"npm","Ecosystem":"npm","Direct":[...]}
```
---
### 3. Flags/Options Handling
All flags are registered in `addResolveCmd()` using Cobra's flag system, retrieved in `runResolve()` with `cmd.Flags().GetXXX()`:
**Flags:**
- `-m, --manager string` - Override detected package manager (takes precedence over `-e`)
- `-e, --ecosystem string` - Filter to specific ecosystem
- `--dry-run` - Show what would be run without executing
- `--raw` - Print raw manager output instead of parsed JSON
- `-x, --extra stringArray` - Extra arguments to pass to package manager
- `-t, --timeout duration` - Timeout for resolve operation (default 5m)
- `-q, --quiet` - Suppress status output on stderr (inherited from root command)
**Flag Retrieval Pattern:**
```go
managerOverride, _ := cmd.Flags().GetString("manager")
ecosystem, _ := cmd.Flags().GetString("ecosystem")
dryRun, _ := cmd.Flags().GetBool("dry-run")
raw, _ := cmd.Flags().GetBool("raw")
quiet, _ := cmd.Flags().GetBool("quiet")
extra, _ := cmd.Flags().GetStringArray("extra")
timeout, _ := cmd.Flags().GetDuration("timeout")
```
---
### 4. Existing Format-Related Flags
**Current output format flags:**
1. **`--raw`** - Prints raw manager output instead of parsed JSON (lines 50, 117-121)
- When enabled, skips parsing and outputs the manager's native output directly
- Runs manager commands with output directed to stdout
2. **`--dry-run`** - Shows what would be run without executing (lines 39, 49, 104-108)
- Prints the command that would be executed instead of running it
- Format: `Would run: [command slice]`
3. **Quiet mode (`-q`)** - Already supports suppressing status output on stderr (lines 51, 90-91, 96-115)
- When enabled, hides "Detected:", "Running:", and "Skipping" messages on stderr
- JSON output always goes to stdout
**Output Stream Routing:**
- Status/debug info → stderr (`cmd.ErrOrStderr()`)
- JSON/results → stdout (`cmd.OutOrStdout()`)
---
### 5. Key Implementation Details
**Manager Detection & Filtering (lines 60-78):**
- Detects package managers via `DetectManagers()`
- Filters by ecosystem with `FilterByEcosystem()` if `-e` is provided
- Manager override with `-m` takes precedence
**Command Building & Execution (lines 84-127):**
- Builds manager-specific commands via `BuildCommands()`
- Runs commands in a context with configurable timeout
- Captures stdout to a `bytes.Buffer` for parsing
**Parsing & JSON Encoding (lines 129-138):**
- Delegates to `resolve.Parse()` from the external resolve library
- Calls `github.com/git-pkgs/resolve` with manager name and output bytes
- Encodes result with 2-space indentation using standard `encoding/json`
**Error Handling:**
- Returns formatted errors with context (manager name, operation)
- Continues to next manager on error instead of failing globally
- Distinguishes between unsupported commands and execution failures
---
### 6. Testing Coverage
Tests in `/Users/andrew/code/git-pkgs/git-pkgs/cmd/resolve_test.go` verify:
- `TestResolveDryRun()` - Dry-run mode with different managers (npm, cargo, go)
- `TestResolveSkipsUnsupported()` - Graceful handling when manager doesn't support resolve
- `TestResolveManagerOverride()` - Manager override with `-m` flag
agentId: a6997a9 (for resuming to continue this agent's work if needed)
<usage>total_tokens: 28927
tool_uses: 14
duration_ms: 30226</usage>Let me verify the file looks right.
The diagnostic errors cleared. The file looks good. Now update the Long description to reflect the new default.
Now update the tests. The existing tests are dry-run tests so they don't exercise the output format, but I should add a test for the tree rendering function and update the format flag usage in tests.
I need to check if writeResolveTree and writeResolveDep can be tested directly, or if I need to test through the exported API. Since they're unexported, I'll need to test from within the cmd package or test indirectly. The test file is in cmd_test (external test package). Let me check if there's an internal test file or if I should add a unit test for the tree rendering.
Found 7 files cmd/diff_test.go cmd/plugins_test.go cmd/vulns_test.go cmd/where_test.go cmd/hooks_test.go cmd/pager_test.go cmd/ecosystems_test.go
There are internal test files (package cmd). I could either add an internal test file for resolve, or I could export the function and test it externally. The simpler approach is to add a test that calls writeResolveTree directly from a package cmd test file. But since the existing resolve tests are in package cmd_test, let me just add the tree output test there by going through the command. Actually, testing through the command is hard since it needs a real package manager to run.
Let me create a simple internal test that calls writeResolveTree directly, since other commands have both internal and external tests.
There are internal test files. I'll add a unit test for the tree rendering directly.
Now let me run the tests.
go test ./cmd/ -run TestResolve -v 2>&1=== RUN TestResolveDryRun
=== RUN TestResolveDryRun/npm_resolve
=== RUN TestResolveDryRun/cargo_resolve
=== RUN TestResolveDryRun/go_resolve
--- PASS: TestResolveDryRun (0.02s)
--- PASS: TestResolveDryRun/npm_resolve (0.01s)
--- PASS: TestResolveDryRun/cargo_resolve (0.00s)
--- PASS: TestResolveDryRun/go_resolve (0.00s)
=== RUN TestResolveSkipsUnsupported
--- PASS: TestResolveSkipsUnsupported (0.00s)
=== RUN TestResolveManagerOverride
--- PASS: TestResolveManagerOverride (0.00s)
PASS
ok github.com/git-pkgs/git-pkgs/cmd 0.268sgo test ./cmd/ -run TestWriteResolve -v 2>&1=== RUN TestWriteResolveTree --- PASS: TestWriteResolveTree (0.00s) === RUN TestWriteResolveTreeSingleDep --- PASS: TestWriteResolveTreeSingleDep (0.00s) === RUN TestWriteResolveTreeDeepNesting --- PASS: TestWriteResolveTreeDeepNesting (0.00s) === RUN TestWriteResolveTreeNoDeps --- PASS: TestWriteResolveTreeNoDeps (0.00s) PASS ok github.com/git-pkgs/git-pkgs/cmd 0.247s
All passing. Now update the docs.
Now update the multi-ecosystem and jq examples to use -f json.
Now update the examples section to use -f json where jq is involved.
227:diff <(git stash && git pkgs resolve -q -f json | jq -r '.. | .PURL? // empty' | sort) \ 228: <(git stash pop && git pkgs resolve -q -f json | jq -r '.. | .PURL? // empty' | sort)
Already updated by the earlier replace_all. Now handle the snapshot and Go examples.
Now run the full test suite.
go test ./... 2>&1? github.com/git-pkgs/git-pkgs [no test files] ok github.com/git-pkgs/git-pkgs/cmd 15.982s ok github.com/git-pkgs/git-pkgs/internal/analyzer (cached) ok github.com/git-pkgs/git-pkgs/internal/bisect (cached) ok github.com/git-pkgs/git-pkgs/internal/database (cached) ok github.com/git-pkgs/git-pkgs/internal/git (cached) ok github.com/git-pkgs/git-pkgs/internal/indexer (cached) ok github.com/git-pkgs/git-pkgs/internal/mailmap (cached) ? github.com/git-pkgs/git-pkgs/scripts [no test files]
All tests pass. Let me verify the final state of both files.