jsonfile = "$item/segment_summary_2026-04-19.json"

        jsonfile = "$item/segment_summary_2026-05-07.json"

guru callers ./pkg/path/funcname

callgraph

pi -e pi-gondolin.ts

pi -e pi-gondolin.ts
guru callers ./pkg/path/funcname
### Callgraph Commands                                                            
                                                                                
 1. Full project-internal callgraph (best for understanding code flow):         
                                                                                
 ```bash                                                                        
   callgraph -algo rta skraak 2>/dev/null | awk -F'\t' '$1 ~ /^skraak/ && $3 ~ /^skraak/' | grep -v '\$' | sed 's/--static-[0-9]*:[0-9]*-->/  →/; s/--dynamic-[0-9]*:[0-9]*-->/  →/' | sort -u                                                                    
 ```                                                                            
                                                                                
 2. Cross-package calls only (who calls across package boundaries):             
                                                                                
 ```bash                                                                        
   callgraph -algo rta skraak 2>/dev/null | awk -F'\t' '$1 ~ /^skraak/ && $3 ~ /^skraak/' | grep -v '\$' | awk -F'\t' '{split($1,a,"."); split($3,b,"."); if(a[1]!=b[1]) print}' | sed 's/--static-[0-9]*:[0-9]*-->/  →/; s/--dynamic-[0-9]*:[0-9]*-->/  →/' | sort -u                                                                      
 ```                                                                            
                                                                                
 3. Trace a specific function — "what does CallsClip call?":                    
                                                                                
 ```bash                                                                        
   callgraph -algo rta skraak 2>/dev/null | grep 'tools.CallsClip\t' | grep -v '\$'                                                                           
 ```                                                                            
                                                                                
 4. Who calls a specific function — "who uses GenerateSpectrogram?":            
                                                                                
 ```bash                                                                        
   callgraph -algo rta skraak 2>/dev/null | grep 'GenerateSpectrogram' | grep -v '\$' | grep -v 'GenerateSpectrogram\t.*→.*GenerateSpectrogram'              
 ```                                                                            
                                                                                
 5. Dynamic (interface/virtual) calls only — find where interfaces dispatch:    
                                                                                
 ```bash                                                                        
   callgraph -algo rta skraak 2>/dev/null | grep 'dynamic' | grep '^skraak'     
 ```                                                                            

	"strings"

// TestPackageDependencies enforces the project's package dependency rules
// defined in CLAUDE.md. Packages may only import packages below them:
//
//	cmd    → tools, tui, utils, db
//	tools  → utils, db
//	tui    → tools, utils
//	utils  → (nothing — leaf package)
//	db     → utils
func TestPackageDependencies(t *testing.T) {
	rules := map[string]map[string]bool{
		"skraak/cmd":   {"skraak/tools": true, "skraak/tui": true, "skraak/utils": true, "skraak/db": true},
		"skraak/tools": {"skraak/utils": true, "skraak/db": true},
		"skraak/tui":   {"skraak/tools": true, "skraak/utils": true},
		"skraak/utils": {}, // leaf package — no skraak imports allowed
		"skraak/db":    {"skraak/utils": true},
	}
	for pkg, allowed := range rules {
		imports := getInternalImports(t, pkg)
		for _, imp := range imports {
			if !allowed[imp] {
				t.Errorf("%s imports %s — not allowed by dependency rules", pkg, imp)
			}
		}
	}
}
// TestNoDirectDBImportInUtils checks that no file in utils/ imports skraak/db.
// Fast source-level check using go/packages.
func TestNoDirectDBImportInUtils(t *testing.T) {
	importPaths := getInternalImports(t, "skraak/utils")
	for _, imp := range importPaths {
		if imp == "skraak/db" {
			t.Error("utils/ imports skraak/db — forbidden (utils is the leaf package)")
		}
	}
}
// getInternalImports returns the skraak-internal imports for a package using `go list`.
func getInternalImports(t *testing.T, pkg string) []string {
	t.Helper()
	out, err := exec.Command("go", "list", "-f", "{{range .Imports}}{{.}}\n{{end}}", pkg).Output()
	if err != nil {
		t.Fatalf("go list %s: %v", pkg, err)
	}
	var internal []string
	for line := range strings.SplitSeq(string(out), "\n") {
		line = strings.TrimSpace(line)
		if strings.HasPrefix(line, "skraak/") || line == "skraak" {
			internal = append(internal, line)
		}
	}
	return internal
}

If called by `cmd/`, it goes in `tools/`. If called by `tools/`, it goes in `utils/`. 

- **`utils/`** - Reusable helpers (no MCP types, no `*Input`/`*Output` structs, no `db` import)

- **`utils/`** - Reusable helpers (no MCP types, no `*Input`/`*Output` structs, no `db` import)

    - depguard

    depguard:
      rules:
        # Package dependency rules — see CLAUDE.md "Package Organization"
        # Packages may only import packages below them in the list:
        #   cmd → tools, tui, utils, db
        #   tools → utils, db
        #   tui → tools, utils
        #   db → utils
        #   utils → (nothing — leaf package)
        utils:
          files:
            - "**/utils/*.go"
          deny:
            - pkg: "skraak/cmd"
              desc: "utils is the leaf package"
            - pkg: "skraak/tools"
              desc: "utils is the leaf package"
            - pkg: "skraak/tui"
              desc: "utils is the leaf package"
            - pkg: "skraak/db"
              desc: "utils is the leaf package"
        db:
          files:
            - "**/db/*.go"
          deny:
            - pkg: "skraak/cmd"
              desc: "db may only import utils"
            - pkg: "skraak/tools"
              desc: "db may only import utils"
            - pkg: "skraak/tui"
              desc: "db may only import utils"
        tui:
          files:
            - "**/tui/*.go"
          deny:
            - pkg: "skraak/cmd"
              desc: "tui must not import cmd"
            - pkg: "skraak/db"
              desc: "tui must not import db"
        tools:
          files:
            - "**/tools/*.go"
          deny:
            - pkg: "skraak/cmd"
              desc: "tools must not import cmd"
            - pkg: "skraak/tui"
              desc: "tools must not import tui"