minor updates

Author: sammcj

README.md

@@ -4,6 +4,8 @@ Ingest is a command-line tool designed to parse directories of plain text files,
 
 It's intended use case is for preparing content to be provided to AI/LLMs.
 
+![ingest screenshot](screenshot.png)
+
 ## Features
 
 - Traverse directory structures and generate a tree view
@@ -86,7 +88,8 @@ ingest -o output.md /path/to/project
 - `--print-default-excludes`: Print the default exclude patterns
 - `--print-default-template`: Print the default template
 - `--report`: Print the largest parsed files
-- `-v, --version`: Print the version number (WIP - still trying to get this to work nicely)
+- `--verbose`: Print verbose output
+- `-V, --version`: Print the version number (WIP - still trying to get this to work nicely)
 
 ## Configuration
 

main.go

@@ -36,22 +36,18 @@ var (
 	printDefaultExcludes bool
 	printDefaultTemplate bool
 	report               bool
+	verbose              bool
 	Version              string // This will be set by the linker at build time
 )
 
 func main() {
 	rootCmd := &cobra.Command{
-		Use:   "ingest [path]",
+		Use:   "ingest [flags] [path]",
 		Short: "Generate a markdown LLM prompt from a codebase directory",
 		Long:  `ingest is a command-line tool to generate an LLM prompt from a codebase directory.`,
 		RunE:  run,
 	}
 
-	// if run with no arguments, assume the current directory
-	if len(os.Args) == 1 {
-		os.Args = append(os.Args, ".")
-	}
-
 	rootCmd.Flags().StringSliceP("include", "i", nil, "Patterns to include")
 	rootCmd.Flags().StringSliceP("exclude", "e", nil, "Patterns to exclude")
 	rootCmd.Flags().BoolVar(&includePriority, "include-priority", false, "Include files in case of conflict between include and exclude patterns")
@@ -71,16 +67,23 @@ func main() {
 	rootCmd.Flags().StringVar(&patternExclude, "pattern-exclude", "", "Path to a specific .glob file for exclude patterns")
 	rootCmd.Flags().BoolVar(&printDefaultExcludes, "print-default-excludes", false, "Print the default exclude patterns")
 	rootCmd.Flags().BoolVar(&printDefaultTemplate, "print-default-template", false, "Print the default template")
-	rootCmd.Flags().BoolP("version", "v", false, "Print the version number")
+	rootCmd.Flags().BoolP("version", "V", false, "Print the version number")
 	rootCmd.Flags().BoolVar(&report, "report", false, "Report the top 5 largest files included in the output")
+	rootCmd.Flags().BoolVarP(&verbose, "verbose", "v", false, "Enable verbose output")
+
+	rootCmd.ParseFlags(os.Args[1:])
+
+	// if run with no arguments, assume the current directory
+	if len(rootCmd.Flags().Args()) == 0 {
+		rootCmd.SetArgs([]string{"."})
+	}
 
 	if err := rootCmd.Execute(); err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}
 }
 
-
 func run(cmd *cobra.Command, args []string) error {
 	if version, _ := cmd.Flags().GetBool("version"); version {
 		fmt.Printf("ingest version %s\n", Version)
@@ -120,6 +123,15 @@ func run(cmd *cobra.Command, args []string) error {
 	spinner := utils.SetupSpinner("Traversing directory and building tree...")
 	defer spinner.Finish()
 
+	// If verbose, print active excludes
+	if verbose {
+		activeExcludes, err := filesystem.ReadExcludePatterns(patternExclude)
+		if err != nil {
+			return fmt.Errorf("failed to read exclude patterns: %w", err)
+		}
+		printExcludePatterns(activeExcludes)
+	}
+
 	// Traverse directory with parallel processing
 	tree, files, err := filesystem.WalkDirectory(absPath, includePatterns, excludePatterns, patternExclude, includePriority, lineNumber, relativePaths, excludeFromTree, noCodeblock)
 	if err != nil {
@@ -184,7 +196,7 @@ func run(cmd *cobra.Command, args []string) error {
 	}
 
 	// Handle output
-	if err := handleOutput(rendered, tokens, encoding, noClipboard, output, jsonOutput, report, files); err != nil {
+	if err := handleOutput(rendered, tokens, encoding, noClipboard, output, jsonOutput, report || verbose, files); err != nil {
 		return fmt.Errorf("failed to handle output: %w", err)
 	}
 
@@ -196,16 +208,17 @@ func reportLargestFiles(files []filesystem.FileInfo) {
 		return len(files[i].Code) > len(files[j].Code)
 	})
 
-	fmt.Println("\nTop 5 largest files:")
+	fmt.Println("\nTop 5 largest files (by estimated token count):")
 	for i, file := range files[:min(5, len(files))] {
-		fmt.Printf("%d. %s (%d bytes)\n", i+1, file.Path, len(file.Code))
+		tokenCount := token.CountTokens(file.Code, encoding)
+		fmt.Printf("%d. %s (%s tokens)\n", i+1, file.Path, utils.FormatNumber(tokenCount))
 	}
 }
 
 func handleOutput(rendered string, countTokens bool, encoding string, noClipboard bool, output string, jsonOutput bool, report bool, files []filesystem.FileInfo) error {
 	if countTokens {
 		tokenCount := token.CountTokens(rendered, encoding)
-		utils.PrintColouredMessage("i", fmt.Sprintf("%d Tokens (Approximate)", tokenCount), color.FgYellow)
+		utils.PrintColouredMessage("i", fmt.Sprintf("%s Tokens (Approximate)", utils.FormatNumber(tokenCount)), color.FgYellow)
 	}
 
 	if report {
@@ -248,3 +261,54 @@ func handleOutput(rendered string, countTokens bool, encoding string, noClipboar
 
 	return nil
 }
+
+
+func printExcludePatterns(patterns []string) {
+	utils.PrintColouredMessage("i", "Active exclude patterns:", color.FgCyan)
+
+	// Define colours for syntax highlighting
+	starColour := color.New(color.FgYellow).SprintFunc()
+	slashColour := color.New(color.FgGreen).SprintFunc()
+	dotColour := color.New(color.FgBlue).SprintFunc()
+
+	// Calculate the maximum width of patterns for alignment
+	maxWidth := 0
+	for _, pattern := range patterns {
+		if len(pattern) > maxWidth {
+			maxWidth = len(pattern)
+		}
+	}
+
+	// Print patterns in a horizontal list
+	lineWidth := 0
+
+	// get the width of the terminal
+	w := utils.GetTerminalWidth()
+
+	for i, pattern := range patterns {
+		highlighted := pattern
+		highlighted = strings.ReplaceAll(highlighted, "*", starColour("*"))
+		highlighted = strings.ReplaceAll(highlighted, "/", slashColour("/"))
+		highlighted = strings.ReplaceAll(highlighted, ".", dotColour("."))
+
+		// Add padding to align patterns
+		padding := strings.Repeat(" ", maxWidth - len(pattern) + 2)
+
+		if lineWidth + len(pattern) + 2 > w && i > 0 {
+			fmt.Println()
+			lineWidth = 0
+		}
+
+		if lineWidth == 0 {
+			fmt.Print("  ")
+		}
+
+		fmt.Print(highlighted + padding)
+		lineWidth += len(pattern) + len(padding)
+
+		if i < len(patterns)-1 {
+			fmt.Print("| ")
+			lineWidth += 2
+		}
+	}
+}

screenshot.png

@@ -4,13 +4,23 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strconv"
+	"syscall"
+	"unsafe"
 
 	"github.com/atotto/clipboard"
 	"github.com/fatih/color"
 	"github.com/mitchellh/go-homedir"
 	"github.com/schollz/progressbar/v3"
 )
 
+type termSize struct {
+	Row    uint16
+	Col    uint16
+	Xpixel uint16
+	Ypixel uint16
+}
+
 func CopyToClipboard(rendered string) error {
 	err := clipboard.WriteAll(rendered)
 	if err != nil {
@@ -55,9 +65,9 @@ func Label(path string) string {
 
 func PrintColouredMessage(symbol string, message string, messageColor color.Attribute) {
 	white := color.New(color.FgWhite, color.Bold).SprintFunc()
-	coloredMessage := color.New(messageColor).SprintFunc()
+	colouredMessage := color.New(messageColor).SprintFunc()
 
-	fmt.Printf("%s%s%s %s\n", white("["), white(symbol), white("]"), coloredMessage(message))
+	fmt.Printf("%s%s%s %s\n", white("["), white(symbol), white("]"), colouredMessage(message))
 }
 
 func EnsureConfigDirectories() error {
@@ -90,3 +100,35 @@ func EnsureConfigDirectories() error {
 
 	return nil
 }
+
+func FormatNumber(n int) string {
+	in := strconv.Itoa(n)
+	out := make([]byte, len(in)+(len(in)-2+int(in[0]/'0'))/3)
+	if in[0] == '-' {
+		in, out[0] = in[1:], '-'
+	}
+
+	for i, j, k := len(in)-1, len(out)-1, 0; ; i, j = i-1, j-1 {
+		out[j] = in[i]
+		if i == 0 {
+			return string(out)
+		}
+		if k++; k == 3 {
+			j, k = j-1, 0
+			out[j] = ','
+		}
+	}
+}
+
+func GetTerminalWidth() int {
+	ws := &termSize{}
+	retCode, _, _ := syscall.Syscall(syscall.SYS_IOCTL,
+			uintptr(syscall.Stdin),
+			uintptr(syscall.TIOCGWINSZ),
+			uintptr(unsafe.Pointer(ws)))
+
+	if int(retCode) == -1 {
+			return 100
+	}
+	return int(ws.Col)
+}