feat: add --skip flag for CLI log pagination

Add skip parameter to engine LogParams, CLI (--skip N), and MCP
(skip: N) so users can page through log results without needing
continuation tokens. Composes naturally with --max-count:

  aifr log --oneline --max-count 20
  aifr log --oneline --max-count 20 --skip 20

Update text/oneline continuation messages to suggest --skip as
an alternative to continuation tokens, since CLI users have no
way to pass tokens back.

https://claude.ai/code/session_016QBk2VFvP92AXspnSePeLz

Author: claude

cmd/aifr/cmd_log.go

@@ -11,6 +11,7 @@ import (
 
 var (
 	logMaxCount int
+	logSkip     int
 	logOneline  bool
 	logDivider  string
 	logVerbose  bool
@@ -68,6 +69,7 @@ details (when they differ from the author) in JSON output.`,
 
 		resp, err := eng.Log(repoName, ref, engine.LogParams{
 			MaxCount: logMaxCount,
+			Skip:     logSkip,
 			Verbose:  logVerbose,
 		})
 		if err != nil {
@@ -81,6 +83,7 @@ details (when they differ from the author) in JSON output.`,
 
 func init() {
 	logCmd.Flags().IntVar(&logMaxCount, "max-count", 20, "maximum commits to show")
+	logCmd.Flags().IntVar(&logSkip, "skip", 0, "skip this many commits before showing results")
 	logCmd.Flags().BoolVar(&logOneline, "oneline", false, "compact one-line-per-commit output")
 	logCmd.Flags().StringVar(&logDivider, "divider", "plain", "divider format for text output: plain, xml")
 	logCmd.Flags().BoolVar(&logVerbose, "verbose", false, "include tree hash, parent hashes, committer details")

internal/engine/gitops.go

@@ -272,6 +272,7 @@ func (e *Engine) Refs(repoName string, branches, tags, remotes bool) (*protocol.
 // LogParams controls git log queries.
 type LogParams struct {
 	MaxCount  int    // 0 = default (20)
+	Skip      int    // skip this many commits before collecting entries
 	StartHash string // start from this commit's parent (for pagination)
 	Verbose   bool   // include tree hash, parent hashes, committer details
 }
@@ -322,6 +323,19 @@ func (e *Engine) Log(repoName, ref string, params LogParams) (*protocol.LogRespo
 		}
 	}
 
+	// Skip commits if requested.
+	for skipped := 0; skipped < params.Skip && current != nil; skipped++ {
+		if current.NumParents() == 0 {
+			current = nil
+			break
+		}
+		current, err = current.Parent(0)
+		if err != nil {
+			current = nil
+			break
+		}
+	}
+
 	resp := &protocol.LogResponse{
 		Repo: repoName,
 		Ref:  ref,

internal/engine/pagination_test.go

@@ -318,6 +318,60 @@ func TestLogCompleteField(t *testing.T) {
 	}
 }
 
+func TestLogSkip(t *testing.T) {
+	dir := t.TempDir()
+	initTestGitRepo(t, dir, 5)
+	eng := newTestEngine(t, dir)
+
+	// Get all commits to know the expected order.
+	all, err := eng.Log(dir, "HEAD", LogParams{MaxCount: 100})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(all.Entries) != 5 {
+		t.Fatalf("expected 5 commits, got %d", len(all.Entries))
+	}
+
+	// Skip 2, get 2 — should start at the 3rd commit.
+	resp, err := eng.Log(dir, "HEAD", LogParams{MaxCount: 2, Skip: 2})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(resp.Entries) != 2 {
+		t.Fatalf("expected 2 entries, got %d", len(resp.Entries))
+	}
+	if resp.Entries[0].Hash != all.Entries[2].Hash {
+		t.Errorf("first entry after skip=2: got %s, want %s",
+			resp.Entries[0].Hash[:12], all.Entries[2].Hash[:12])
+	}
+	if resp.Entries[1].Hash != all.Entries[3].Hash {
+		t.Errorf("second entry after skip=2: got %s, want %s",
+			resp.Entries[1].Hash[:12], all.Entries[3].Hash[:12])
+	}
+
+	// Skip past all commits — should return empty.
+	resp2, err := eng.Log(dir, "HEAD", LogParams{MaxCount: 10, Skip: 100})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(resp2.Entries) != 0 {
+		t.Errorf("expected 0 entries after skipping past all, got %d", len(resp2.Entries))
+	}
+	if !resp2.Complete {
+		t.Error("expected Complete=true when no entries returned")
+	}
+
+	// Skip 0 — same as no skip.
+	resp3, err := eng.Log(dir, "HEAD", LogParams{MaxCount: 2, Skip: 0})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if resp3.Entries[0].Hash != all.Entries[0].Hash {
+		t.Errorf("skip=0 first entry: got %s, want %s",
+			resp3.Entries[0].Hash[:12], all.Entries[0].Hash[:12])
+	}
+}
+
 // initTestGitRepo creates a bare-minimum git repo with N commits using go-git.
 func initTestGitRepo(t *testing.T, dir string, numCommits int) {
 	t.Helper()

internal/mcpserver/tools.go

@@ -197,6 +197,7 @@ Use verbose=true in json mode for tree_hash, parent_hashes, and committer detail
 				"repo":         map[string]any{"type": "string", "description": "Named repo, filesystem path, or empty for auto-detect from cwd"},
 				"ref":          map[string]any{"type": "string", "description": "Git ref (default HEAD)"},
 				"max_count":    map[string]any{"type": "integer", "description": "Max commits (default 20)", "default": 20},
+				"skip":         map[string]any{"type": "integer", "description": "Skip this many commits before collecting results", "default": 0},
 				"continuation": map[string]any{"type": "string", "description": "Continuation token from previous log"},
 				"format":       map[string]any{"type": "string", "enum": []string{"json", "text", "oneline"}, "description": "Output format (default: json)", "default": "json"},
 				"divider":      map[string]any{"type": "string", "enum": []string{"plain", "xml"}, "description": "Divider format for text output (default: plain)", "default": "plain"},
@@ -534,6 +535,7 @@ func (s *Server) handleLog(_ context.Context, req *mcp.CallToolRequest) (*mcp.Ca
 		Repo         string `json:"repo"`
 		Ref          string `json:"ref"`
 		MaxCount     int    `json:"max_count"`
+		Skip         int    `json:"skip"`
 		Continuation string `json:"continuation"`
 		Format       string `json:"format"`
 		Divider      string `json:"divider"`
@@ -544,7 +546,7 @@ func (s *Server) handleLog(_ context.Context, req *mcp.CallToolRequest) (*mcp.Ca
 	}
 	args.Format = resolveMCPFormat(args.Format)
 
-	params := engine.LogParams{MaxCount: args.MaxCount, Verbose: args.Verbose}
+	params := engine.LogParams{MaxCount: args.MaxCount, Skip: args.Skip, Verbose: args.Verbose}
 	if args.Continuation != "" {
 		tok, err := s.decodeContinuation(args.Continuation, "log")
 		if err != nil {

internal/output/text.go

@@ -244,7 +244,7 @@ func WriteLogText(w io.Writer, resp *protocol.LogResponse) {
 	}
 
 	if !resp.Complete && resp.Continuation != "" {
-		fmt.Fprintf(w, "\n... %d commits shown, more available with continuation token\n", resp.Total)
+		fmt.Fprintf(w, "\n... %d commits shown, more available (use --skip %d or continuation token)\n", resp.Total, resp.Total)
 	}
 }
 
@@ -271,7 +271,7 @@ func WriteLogOneline(w io.Writer, resp *protocol.LogResponse) {
 		fmt.Fprintf(w, "%s %s\n", hash, subject)
 	}
 	if !resp.Complete && resp.Continuation != "" {
-		fmt.Fprintf(w, "... %d commits shown, more available with continuation token\n", resp.Total)
+		fmt.Fprintf(w, "... %d commits shown, more available (use --skip %d or continuation token)\n", resp.Total, resp.Total)
 	}
 }
 

internal/output/text_test.go

@@ -865,6 +865,9 @@ func TestWriteLogText(t *testing.T) {
 		if !strings.Contains(got, "1 commits shown") {
 			t.Errorf("expected continuation message, got %q", got)
 		}
+		if !strings.Contains(got, "--skip 1") {
+			t.Errorf("expected --skip hint in continuation message, got %q", got)
+		}
 	})
 }