refactor(pipeline): replace heading-level chunking with greedy token-based chunker

- Drop --chunk-level and auto-detect logic; chunk by flatten+greedy merge
- Improve verbose chunk preview with token count + head/tail snippet
- Interactive mode uses minimum heading level
- Add DocumentTree.get_chunks_at_level() and tests

Author: SOV710

src/doc2anki/cli.py

@@ -257,11 +257,6 @@ def generate_cmd(
         "--extra-tags",
         help="Additional tags (comma-separated)",
     ),
-    chunk_level: Optional[int] = typer.Option(
-        None,
-        "--chunk-level",
-        help="Heading level to chunk at (1-6, default: auto)",
-    ),
     include_parent_chain: bool = typer.Option(
         True,
         "--include-parent-chain/--no-parent-chain",
@@ -287,7 +282,7 @@ def generate_cmd(
     """Generate Anki cards from documents."""
     # Import parser here to avoid circular imports and speed up CLI startup
     from .parser import build_document_tree
-    from .pipeline import process_pipeline, auto_detect_level
+    from .pipeline import process_pipeline
 
     # Validate input path
     if not input_path.exists():
@@ -341,23 +336,19 @@ def generate_cmd(
             for key, value in tree.metadata.raw_data.items():
                 console.print(f"  - {key}: {value}")
 
-        # Determine chunk level
-        actual_level = chunk_level
-        if actual_level is None:
-            actual_level = auto_detect_level(tree, max_tokens)
-
         if verbose:
             console.print(f"[blue]Document tree:[/blue] {tree}")
-            console.print(f"[blue]Chunk level:[/blue] {actual_level}")
 
         # Interactive classification if requested
         classified_nodes = None
         if interactive:
             from .pipeline import run_interactive_session
 
+            # Use minimum heading level for interactive mode
+            interactive_level = tree.min_level if tree.min_level > 0 else 2
             classified_nodes = run_interactive_session(
                 tree=tree,
-                level=actual_level,
+                level=interactive_level,
                 console=console,
                 filename=str(file_path.name),
             )
@@ -370,7 +361,6 @@ def generate_cmd(
         try:
             chunk_contexts = process_pipeline(
                 tree=tree,
-                chunk_level=actual_level,
                 max_tokens=max_tokens,
                 include_parent_chain=include_parent_chain,
                 classified_nodes=classified_nodes,
@@ -380,12 +370,22 @@ def generate_cmd(
             return
 
         if verbose:
+            from .parser import count_tokens
+
             console.print(f"[blue]Chunks:[/blue] {len(chunk_contexts)}")
             for i, ctx in enumerate(chunk_contexts):
-                preview = ctx.chunk_content[:100].replace("\n", " ")
+                tokens = count_tokens(ctx.chunk_content)
                 chain_str = " > ".join(ctx.parent_chain) if ctx.parent_chain else "(root)"
-                console.print(f"  [{i+1}] {chain_str}")
-                console.print(f"      {preview}...")
+
+                # Show beginning and ending of content
+                content = ctx.chunk_content.replace("\n", " ")
+                if len(content) > 80:
+                    preview = f"{content[:40]}...{content[-30:]}"
+                else:
+                    preview = content
+
+                console.print(f"  [{i+1}] {chain_str} (tokens: {tokens})")
+                console.print(f"      {preview}")
 
         if dry_run:
             console.print(f"\n[green]Dry run complete for {file_path}[/green]")

src/doc2anki/parser/tree.py

@@ -146,5 +146,40 @@ def iter_all_nodes(self) -> Iterator[HeadingNode]:
             yield child
             yield from child.iter_descendants()
 
+    def get_chunks_at_level(self, level: int) -> tuple[HeadingNode, ...]:
+        """
+        获取在指定 level 切分的 chunks。
+
+        对于每个分支：
+        - 如果有 level N 的子节点：返回这些 level N 节点
+        - 如果深度不足：返回该分支的叶子节点
+
+        这确保没有内容被丢弃。
+
+        Args:
+            level: 目标切分层级
+
+        Returns:
+            Tuple of HeadingNode objects to be used as chunks
+        """
+        result: list[HeadingNode] = []
+
+        def collect(node: HeadingNode) -> None:
+            if node.level >= level:
+                # 到达或超过目标 level，作为 chunk
+                result.append(node)
+            elif not node.children:
+                # 叶子节点且 level < target，作为 chunk（深度不足）
+                result.append(node)
+            else:
+                # 有子节点且 level < target，继续递归
+                for child in node.children:
+                    collect(child)
+
+        for child in self.children:
+            collect(child)
+
+        return tuple(result)
+
     def __repr__(self) -> str:
         return f"DocumentTree(children={len(self.children)}, levels={set(self.get_all_levels())})"

src/doc2anki/pipeline/__init__.py

@@ -3,13 +3,12 @@
 from .classifier import ChunkType, ClassifiedNode
 from .context import ChunkWithContext
 from .interactive import run_interactive_session
-from .processor import auto_detect_level, process_pipeline
+from .processor import process_pipeline
 
 __all__ = [
     "ChunkType",
     "ClassifiedNode",
     "ChunkWithContext",
-    "auto_detect_level",
     "process_pipeline",
     "run_interactive_session",
 ]