feat(query): add --from/--to/--range scan-bounding for large repos

Bounds the git log scan so huge histories (e.g. Linux kernel, ~1.5M commits) aren't walked in full. --from/--to accept any git date; --range takes a ref range (e.g. main...feature) which also serves per-PR stats. Flags work before or after the positional arg.

LiveReview Pre-Commit Check: skipped (iter:1, coverage:0%)

Author: iconicvenom

cmd/app.go

@@ -390,11 +390,18 @@ EXAMPLES
 
    # Save and reuse your own query
    lrc query --add "SELECT date, subject FROM review_log WHERE action='skipped'" --name skipped
-   lrc query skipped --json`,
+   lrc query skipped --json
+
+   # Bound the scan on huge repos (Linux kernel = ~1.5M commits)
+   lrc query stats --from "2024-01-01" --to "2024-12-31"
+   lrc query stats --range main...feature   # just this PR's commits`,
 				Flags: []cli.Flag{
 					&cli.BoolFlag{Name: "json", Usage: "output machine-readable JSON"},
 					&cli.StringFlag{Name: "add", Usage: "save the given SQL as an alias (requires --name)"},
 					&cli.StringFlag{Name: "name", Usage: "alias name to save with --add"},
+					&cli.StringFlag{Name: "from", Usage: "only scan commits since this git date (e.g. 2024-01-01, '2 weeks ago') — bounds large repos"},
+					&cli.StringFlag{Name: "to", Usage: "only scan commits until this git date"},
+					&cli.StringFlag{Name: "range", Usage: "only scan a ref range, e.g. main...feature (per-PR stats)"},
 				},
 				Action: h.RunQuery,
 				Subcommands: []*cli.Command{

internal/reviewquery/command.go

@@ -22,18 +22,13 @@ func RunQuery(c *cli.Context) error {
 		return nil
 	}
 
-	// urfave/cli stops parsing flags at the first positional arg, so support a
-	// trailing --json too (e.g. `lrc query stats --json`).
+	// Seed from flags placed BEFORE the positional arg (cli parses those).
 	jsonOut := c.Bool("json")
-	positionals := make([]string, 0, c.NArg())
-	for _, a := range c.Args().Slice() {
-		switch a {
-		case "--json", "-json", "-j":
-			jsonOut = true
-		default:
-			positionals = append(positionals, a)
-		}
-	}
+	filter := Filter{From: c.String("from"), To: c.String("to"), Range: c.String("range")}
+
+	// urfave/cli stops parsing flags at the first positional arg, so also scan
+	// the remaining args for trailing flags (e.g. `lrc query stats --from 2024-01-01`).
+	positionals := parseTrailingFlags(c.Args().Slice(), &jsonOut, &filter)
 
 	arg := "stats" // default alias
 	if len(positionals) > 0 && strings.TrimSpace(positionals[0]) != "" {
@@ -49,7 +44,7 @@ func RunQuery(c *cli.Context) error {
 		sqlText = strings.Join(positionals, " ")
 	}
 
-	res, err := Run(Filter{}, sqlText)
+	res, err := Run(filter, sqlText)
 	if err != nil {
 		return err
 	}
@@ -66,6 +61,50 @@ func RunQuery(c *cli.Context) error {
 	return nil
 }
 
+// parseTrailingFlags pulls flags out of args that cli left unparsed (anything
+// after the first positional). Supports `--flag value` and `--flag=value`.
+// Returns the remaining positional args; sets jsonOut/filter via pointers.
+func parseTrailingFlags(args []string, jsonOut *bool, filter *Filter) []string {
+	positionals := make([]string, 0, len(args))
+	for i := 0; i < len(args); i++ {
+		a := args[i]
+		// flag=value form
+		switch {
+		case a == "--json" || a == "-j":
+			*jsonOut = true
+			continue
+		case strings.HasPrefix(a, "--from="):
+			filter.From = strings.TrimPrefix(a, "--from=")
+			continue
+		case strings.HasPrefix(a, "--to="):
+			filter.To = strings.TrimPrefix(a, "--to=")
+			continue
+		case strings.HasPrefix(a, "--range="):
+			filter.Range = strings.TrimPrefix(a, "--range=")
+			continue
+		}
+		// flag value form (consume next arg)
+		if i+1 < len(args) {
+			switch a {
+			case "--from":
+				filter.From = args[i+1]
+				i++
+				continue
+			case "--to":
+				filter.To = args[i+1]
+				i++
+				continue
+			case "--range":
+				filter.Range = args[i+1]
+				i++
+				continue
+			}
+		}
+		positionals = append(positionals, a)
+	}
+	return positionals
+}
+
 // RunQueryList prints every alias and its source.
 func RunQueryList(c *cli.Context) error {
 	aliases, err := ListAliases()

internal/reviewquery/command_test.go

@@ -0,0 +1,36 @@
+package reviewquery
+
+import "testing"
+
+func TestParseTrailingFlags(t *testing.T) {
+	cases := []struct {
+		name    string
+		args    []string
+		wantPos []string
+		from    string
+		to      string
+		rng     string
+		json    bool
+	}{
+		{"none", []string{"stats"}, []string{"stats"}, "", "", "", false},
+		{"trailing json", []string{"stats", "--json"}, []string{"stats"}, "", "", "", true},
+		{"from value", []string{"stats", "--from", "2024-01-01"}, []string{"stats"}, "2024-01-01", "", "", false},
+		{"from equals", []string{"stats", "--from=2024-01-01"}, []string{"stats"}, "2024-01-01", "", "", false},
+		{"range+json", []string{"q", "--range", "main...dev", "--json"}, []string{"q"}, "", "", "main...dev", true},
+		{"to", []string{"stats", "--to=2025-12-31"}, []string{"stats"}, "", "2025-12-31", "", false},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			jsonOut := false
+			f := Filter{}
+			pos := parseTrailingFlags(tc.args, &jsonOut, &f)
+			if len(pos) != len(tc.wantPos) || (len(pos) > 0 && pos[0] != tc.wantPos[0]) {
+				t.Errorf("positionals = %v; want %v", pos, tc.wantPos)
+			}
+			if f.From != tc.from || f.To != tc.to || f.Range != tc.rng || jsonOut != tc.json {
+				t.Errorf("got from=%q to=%q range=%q json=%v; want from=%q to=%q range=%q json=%v",
+					f.From, f.To, f.Range, jsonOut, tc.from, tc.to, tc.rng, tc.json)
+			}
+		})
+	}
+}

internal/reviewquery/extract.go

@@ -97,11 +97,11 @@ func Extract(f Filter) ([]ReviewRecord, error) {
 	if f.Author != "" {
 		args = append(args, "--author="+f.Author)
 	}
-	if !f.Since.IsZero() {
-		args = append(args, "--since="+f.Since.Format(time.RFC3339))
+	if f.From != "" {
+		args = append(args, "--since="+f.From)
 	}
-	if !f.Until.IsZero() {
-		args = append(args, "--until="+f.Until.Format(time.RFC3339))
+	if f.To != "" {
+		args = append(args, "--until="+f.To)
 	}
 	if f.Range != "" {
 		args = append(args, f.Range)

internal/reviewquery/model.go

@@ -21,15 +21,17 @@ type ReviewRecord struct {
 	CoveragePct int       // coverage percent (0 if absent)
 }
 
-// Filter narrows which commits are extracted. Phase 1 uses Range/Since; the
-// rest are wired in Phase 2.
+// Filter narrows (and bounds) which commits are scanned. From/To/Range bound the
+// git log so huge repos (e.g. the Linux kernel, ~1.5M commits) don't get walked
+// in full. From/To are passed straight to git, so they accept any git date
+// (e.g. "2024-01-01", "2 weeks ago").
 type Filter struct {
-	Range      string    // e.g. "main...feature" (PR diff); empty = full history
-	Since      time.Time // zero = no lower bound
-	Until      time.Time // zero = no upper bound
-	Author     string    // substring match on author/email
-	PathPrefix string    // limit to commits touching this path
-	Action     string    // limit to one action
+	Range      string // e.g. "main...feature" (PR diff); empty = full history
+	From       string // git --since bound (lower); empty = no lower bound
+	To         string // git --until bound (upper); empty = no upper bound
+	Author     string // substring match on author/email
+	PathPrefix string // limit to commits touching this path
+	Action     string // limit to one action
 }
 
 // Alias is a saved, named SQL query stored in ~/.lrc/queries.toml.