gitview 0.1.0__tar.gz → 0.1.2__tar.gz

{gitview-0.1.0/gitview.egg-info → gitview-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitview
-Version: 0.1.0
+Version: 0.1.2
 Summary: Git history analyzer with LLM-powered narrative generation
 Home-page: https://github.com/carstenbund/gitview
 Author: GitView Contributors

{gitview-0.1.0 → gitview-0.1.2}/gitview/__init__.py

@@ -1,3 +1,3 @@
 """GitView - Git history analyzer with LLM-powered narrative generation."""
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"

gitview-0.1.2/gitview/cli.py

@@ -0,0 +1,665 @@
+"""Command-line interface for GitView."""
+
+import os
+import sys
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+
+from .extractor import GitHistoryExtractor
+from .chunker import HistoryChunker
+from .summarizer import PhaseSummarizer
+from .storyteller import StoryTeller
+from .writer import OutputWriter
+
+console = Console()
+
+
+@click.group()
+@click.version_option(version="0.1.0")
+def cli():
+    """GitView - Git history analyzer with LLM-powered narrative generation.
+
+    \b
+    Extract, chunk, and use LLMs to generate compelling narratives from your
+    git repository's history.
+
+    \b
+    Quick Start:
+      # Using Anthropic Claude (default)
+      export ANTHROPIC_API_KEY="your-key"
+      gitview analyze
+
+      # Using OpenAI GPT
+      export OPENAI_API_KEY="your-key"
+      gitview analyze --backend openai
+
+      # Using local Ollama (no API key needed)
+      gitview analyze --backend ollama --model llama3
+
+    \b
+    See 'gitview analyze --help' for detailed LLM configuration options.
+    """
+    pass
+
+
+ANALYZE_HELP = """Analyze git repository and generate narrative history.
+
+\b
+This command runs the full pipeline:
+  1. Extract git history with detailed metadata
+  2. Chunk commits into meaningful phases/epochs
+  3. Summarize each phase using LLM
+  4. Generate global narrative stories
+  5. Write markdown reports and JSON data
+
+\b
+LLM BACKEND CONFIGURATION:
+
+GitView supports three LLM backends:
+
+\b
+1. Anthropic Claude (default, requires API key):
+   export ANTHROPIC_API_KEY="your-key"
+   gitview analyze
+
+   Or: gitview analyze --backend anthropic --api-key "your-key"
+
+   Default model: claude-sonnet-4-5-20250929
+   Other models: claude-3-opus-20240229, claude-3-haiku-20240307
+
+\b
+2. OpenAI GPT (requires API key):
+   export OPENAI_API_KEY="your-key"
+   gitview analyze --backend openai
+
+   Default model: gpt-4
+   Other models: gpt-4-turbo-preview, gpt-3.5-turbo
+
+\b
+3. Ollama (local, FREE, no API key needed):
+   # Start Ollama server first: ollama serve
+   # Pull a model: ollama pull llama3
+   gitview analyze --backend ollama --model llama3
+
+   Popular models: llama3, mistral, codellama, mixtral
+   Default URL: http://localhost:11434
+
+\b
+Backend auto-detection:
+  If no --backend is specified, GitView checks environment variables:
+  - If ANTHROPIC_API_KEY is set → uses Anthropic
+  - If OPENAI_API_KEY is set → uses OpenAI
+  - Otherwise → uses Ollama (local)
+
+\b
+EXAMPLES:
+
+  # Analyze current directory with Claude (auto-detected)
+  export ANTHROPIC_API_KEY="sk-ant-..."
+  gitview analyze
+
+  # Use OpenAI GPT-4 with custom model
+  gitview analyze --backend openai --model gpt-4-turbo-preview
+
+  # Use local Ollama (no API costs!)
+  gitview analyze --backend ollama --model llama3
+
+  # Analyze specific repository
+  gitview analyze --repo /path/to/repo --output ./analysis
+
+  # Quick analysis without LLM (just extract and chunk)
+  gitview analyze --skip-llm
+
+  # Analyze last 100 commits only
+  gitview analyze --max-commits 100
+
+  # Adaptive chunking (default, splits on significant changes)
+  gitview analyze --strategy adaptive
+
+  # Fixed-size chunks (50 commits per phase)
+  gitview analyze --strategy fixed --chunk-size 50
+
+  # Use custom Ollama server
+  gitview analyze --backend ollama --ollama-url http://192.168.1.100:11434
+
+\b
+INCREMENTAL ANALYSIS (Cost-Efficient Ongoing Monitoring):
+
+  For managers analyzing multiple projects on an ongoing basis, incremental
+  analysis dramatically reduces costs by reusing previous LLM summaries.
+
+  # Initial full analysis
+  gitview analyze --output reports/myproject
+
+  # Later: incremental update (only analyzes new commits)
+  gitview analyze --output reports/myproject --incremental
+
+  # Manual incremental from specific commit
+  gitview analyze --since-commit abc123def
+
+  # Incremental from date
+  gitview analyze --since-date 2025-11-01
+
+  How it works:
+  - Detects previous analysis in output directory
+  - Extracts only commits since last run
+  - Reuses existing phase summaries (no LLM calls!)
+  - Only summarizes new/modified phases
+  - Updates JSON with new metadata
+
+  Benefits:
+  - Massive API cost savings for ongoing monitoring
+  - Much faster analysis (only processes new commits)
+  - Perfect for CI/CD integration or periodic reviews
+"""
+
+
+@cli.command(help=ANALYZE_HELP)
+@click.option('--repo', '-r', default=".",
+              help="Path to git repository (default: current directory)")
+@click.option('--output', '-o', default="output",
+              help="Output directory for reports and data")
+@click.option('--strategy', '-s', type=click.Choice(['fixed', 'time', 'adaptive']),
+              default='adaptive',
+              help="Chunking strategy: 'adaptive' (default, splits on significant changes), "
+                   "'fixed' (N commits per phase), 'time' (by time period)")
+@click.option('--chunk-size', type=int, default=50,
+              help="Commits per chunk when using 'fixed' strategy")
+@click.option('--max-commits', type=int,
+              help="Maximum commits to analyze (default: all commits)")
+@click.option('--branch', default='HEAD',
+              help="Branch to analyze (default: HEAD/current branch)")
+@click.option('--backend', '-b', type=click.Choice(['anthropic', 'openai', 'ollama']),
+              help="LLM backend: 'anthropic' (Claude), 'openai' (GPT), 'ollama' (local). "
+                   "Auto-detected from env vars if not specified.")
+@click.option('--model', '-m',
+              help="Model identifier. Defaults: claude-sonnet-4-5-20250929 (Anthropic), "
+                   "gpt-4 (OpenAI), llama3 (Ollama)")
+@click.option('--api-key',
+              help="API key for Anthropic/OpenAI. Defaults to ANTHROPIC_API_KEY or "
+                   "OPENAI_API_KEY environment variable")
+@click.option('--ollama-url', default='http://localhost:11434',
+              help="Ollama server URL (only for --backend ollama)")
+@click.option('--repo-name',
+              help="Repository name for output (default: directory name)")
+@click.option('--skip-llm', is_flag=True,
+              help="Skip LLM summarization - only extract and chunk history "
+                   "(useful for quick analysis without API costs)")
+@click.option('--incremental', is_flag=True,
+              help="Incremental analysis: only process commits since last run. "
+                   "Automatically detects previous analysis in output directory")
+@click.option('--since-commit',
+              help="Extract commits since this commit hash (for manual incremental analysis)")
+@click.option('--since-date',
+              help="Extract commits since this date (ISO format: YYYY-MM-DD)")
+def analyze(repo, output, strategy, chunk_size, max_commits, branch, backend,
+           model, api_key, ollama_url, repo_name, skip_llm, incremental,
+           since_commit, since_date):
+    """Analyze git repository and generate narrative history.
+
+    This is the main command that runs the full pipeline:
+    1. Extract git history
+    2. Chunk into meaningful phases
+    3. Summarize each phase with LLM
+    4. Generate global narrative
+    5. Write output files
+    """
+    console.print("\n[bold blue]GitView - Repository History Analyzer[/bold blue]\n")
+
+    # Validate repository
+    repo_path = Path(repo).resolve()
+    if not (repo_path / '.git').exists():
+        console.print(f"[red]Error: {repo_path} is not a git repository[/red]")
+        sys.exit(1)
+
+    # Get repo name if not provided
+    if not repo_name:
+        repo_name = repo_path.name
+
+    console.print(f"[cyan]Repository:[/cyan] {repo_path}")
+    console.print(f"[cyan]Output:[/cyan] {output}")
+    console.print(f"[cyan]Strategy:[/cyan] {strategy}")
+
+    if not skip_llm:
+        # Determine backend for display
+        from .backends import LLMRouter
+        router = LLMRouter(backend=backend, model=model, api_key=api_key, ollama_url=ollama_url)
+        console.print(f"[cyan]Backend:[/cyan] {router.backend_type.value}")
+        console.print(f"[cyan]Model:[/cyan] {router.model}\n")
+    else:
+        console.print("[yellow]Skipping LLM summarization[/yellow]\n")
+
+    try:
+        # Check for incremental analysis
+        previous_analysis = None
+        existing_phases = []
+        starting_loc = 0
+
+        if incremental or since_commit or since_date:
+            # Load previous analysis
+            previous_analysis = OutputWriter.load_previous_analysis(output)
+
+            if incremental and not previous_analysis:
+                console.print("[yellow]Warning: --incremental specified but no previous analysis found.[/yellow]")
+                console.print("[yellow]Running full analysis instead...[/yellow]\n")
+                incremental = False
+            elif previous_analysis:
+                metadata = previous_analysis.get('metadata', {})
+                last_hash = metadata.get('last_commit_hash')
+                last_date = metadata.get('last_commit_date')
+
+                if incremental:
+                    since_commit = last_hash
+                    console.print(f"[cyan]Incremental mode:[/cyan] Analyzing commits since {last_hash[:8]}")
+                    console.print(f"[cyan]Last analysis:[/cyan] {metadata.get('generated_at', 'unknown')}\n")
+
+                # Load existing phases
+                from .chunker import Phase
+                existing_phases = [Phase.from_dict(p) for p in previous_analysis.get('phases', [])]
+
+                if existing_phases and existing_phases[-1].commits:
+                    starting_loc = existing_phases[-1].commits[-1].loc_total
+
+        # Step 1: Extract git history
+        console.print("[bold]Step 1: Extracting git history...[/bold]")
+        extractor = GitHistoryExtractor(str(repo_path))
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console
+        ) as progress:
+            task = progress.add_task("Extracting commits...", total=None)
+
+            # Use incremental extraction if requested
+            if since_commit or since_date:
+                records = extractor.extract_incremental(
+                    since_commit=since_commit,
+                    since_date=since_date,
+                    branch=branch
+                )
+                # Adjust LOC to continue from previous analysis
+                if starting_loc > 0:
+                    extractor._calculate_cumulative_loc(records, starting_loc)
+            else:
+                records = extractor.extract_history(max_commits=max_commits, branch=branch)
+
+            progress.update(task, completed=True)
+
+        if since_commit or since_date:
+            console.print(f"[green]Extracted {len(records)} new commits[/green]\n")
+
+            # Exit early if no new commits
+            if len(records) == 0:
+                console.print("[yellow]No new commits found since last analysis.[/yellow]")
+                console.print("[green]Repository is up to date![/green]\n")
+                return
+        else:
+            console.print(f"[green]Extracted {len(records)} commits[/green]\n")
+
+        # Save raw history
+        history_file = Path(output) / "repo_history.jsonl"
+        extractor.save_to_jsonl(records, str(history_file))
+
+        # Step 2: Chunk into phases
+        console.print("[bold]Step 2: Chunking into phases...[/bold]")
+        chunker = HistoryChunker(strategy)
+
+        kwargs = {}
+        if strategy == 'fixed':
+            kwargs['chunk_size'] = chunk_size
+
+        # Handle incremental phase management
+        if existing_phases and len(records) > 0:
+            # Incremental mode: merge new commits with existing phases
+            merge_threshold = 10  # commits - merge if fewer, create new phase if more
+
+            if len(records) < merge_threshold:
+                # Append new commits to last phase
+                console.print(f"[yellow]Merging {len(records)} new commits into last phase...[/yellow]")
+                last_phase = existing_phases[-1]
+                last_phase.commits.extend(records)
+
+                # Recalculate phase stats
+                from .chunker import Phase
+                last_phase.commit_count = len(last_phase.commits)
+                last_phase.end_date = records[-1].timestamp
+                last_phase.total_insertions = sum(c.insertions for c in last_phase.commits)
+                last_phase.total_deletions = sum(c.deletions for c in last_phase.commits)
+                last_phase.loc_end = records[-1].loc_total
+                last_phase.loc_delta = last_phase.loc_end - last_phase.loc_start
+                if last_phase.loc_start > 0:
+                    last_phase.loc_delta_percent = (last_phase.loc_delta / last_phase.loc_start) * 100
+
+                # Clear summary so it will be regenerated
+                last_phase.summary = None
+
+                phases = existing_phases
+                console.print(f"[green]Updated last phase (now {last_phase.commit_count} commits)[/green]\n")
+            else:
+                # Create new phases for new commits
+                new_phases = chunker.chunk(records, **kwargs)
+
+                # Renumber new phases to continue from existing
+                for phase in new_phases:
+                    phase.phase_number = len(existing_phases) + phase.phase_number
+
+                phases = existing_phases + new_phases
+                console.print(f"[green]Created {len(new_phases)} new phases (total: {len(phases)})[/green]\n")
+        else:
+            # Full analysis: chunk normally
+            phases = chunker.chunk(records, **kwargs)
+            console.print(f"[green]Created {len(phases)} phases[/green]\n")
+
+        # Display phase overview
+        _display_phase_overview(phases)
+
+        # Save phases
+        phases_dir = Path(output) / "phases"
+        chunker.save_phases(phases, str(phases_dir))
+
+        if skip_llm:
+            console.print("\n[yellow]Skipping LLM summarization. Writing basic timeline...[/yellow]")
+            timeline_file = Path(output) / "timeline.md"
+            OutputWriter.write_simple_timeline(phases, str(timeline_file))
+            console.print(f"[green]Wrote timeline to {timeline_file}[/green]\n")
+            return
+
+        # Step 3: Summarize phases with LLM
+        console.print("[bold]Step 3: Summarizing phases with LLM...[/bold]")
+        summarizer = PhaseSummarizer(
+            backend=backend,
+            model=model,
+            api_key=api_key,
+            ollama_url=ollama_url
+        )
+
+        # Identify phases that need summarization (no summary)
+        phases_to_summarize = [p for p in phases if p.summary is None]
+
+        if previous_analysis and len(phases_to_summarize) < len(phases):
+            console.print(f"[cyan]Incremental mode: {len(phases_to_summarize)} phases need summarization "
+                         f"({len(phases) - len(phases_to_summarize)} already summarized)[/cyan]")
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console
+        ) as progress:
+            task = progress.add_task("Summarizing phases...", total=len(phases_to_summarize))
+
+            # Build previous summaries from all phases (including existing ones)
+            previous_summaries = []
+            for i, phase in enumerate(phases):
+                progress.update(task, description=f"Processing phase {i+1}/{len(phases)}...")
+
+                if phase.summary is None:
+                    # Need to summarize this phase
+                    context = summarizer._build_context(previous_summaries)
+                    summary = summarizer.summarize_phase(phase, context)
+                    phase.summary = summary
+                    progress.update(task, advance=1)
+
+                previous_summaries.append({
+                    'phase_number': phase.phase_number,
+                    'summary': phase.summary,
+                    'loc_delta': phase.loc_delta,
+                })
+
+                summarizer._save_phase_with_summary(phase, str(phases_dir))
+
+        if len(phases_to_summarize) > 0:
+            console.print(f"[green]Summarized {len(phases_to_summarize)} phase(s)[/green]\n")
+        else:
+            console.print(f"[green]All phases already summarized[/green]\n")
+
+        # Step 4: Generate global story
+        console.print("[bold]Step 4: Generating global narrative...[/bold]")
+        storyteller = StoryTeller(
+            backend=backend,
+            model=model,
+            api_key=api_key,
+            ollama_url=ollama_url
+        )
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console
+        ) as progress:
+            task = progress.add_task("Generating story...", total=None)
+            stories = storyteller.generate_global_story(phases, repo_name)
+            progress.update(task, completed=True)
+
+        console.print(f"[green]Generated global narrative[/green]\n")
+
+        # Step 5: Write output
+        console.print("[bold]Step 5: Writing output files...[/bold]")
+        output_path = Path(output)
+
+        # Write markdown report
+        markdown_path = output_path / "history_story.md"
+        OutputWriter.write_markdown(stories, phases, str(markdown_path), repo_name)
+        console.print(f"[green]Wrote {markdown_path}[/green]")
+
+        # Write JSON data with metadata for incremental analysis
+        json_path = output_path / "history_data.json"
+        OutputWriter.write_json(stories, phases, str(json_path), repo_path=str(repo_path))
+        console.print(f"[green]Wrote {json_path}[/green]")
+
+        # Write timeline
+        timeline_path = output_path / "timeline.md"
+        OutputWriter.write_simple_timeline(phases, str(timeline_path))
+        console.print(f"[green]Wrote {timeline_path}[/green]\n")
+
+        # Success summary
+        console.print("[bold green]Analysis complete![/bold green]\n")
+        console.print(f"Analyzed {len(records)} commits across {len(phases)} phases")
+        console.print(f"Output written to: {output_path.resolve()}\n")
+
+    except Exception as e:
+        console.print(f"\n[red]Error: {e}[/red]")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+EXTRACT_HELP = """Extract git history to JSONL file (no LLM needed).
+
+\b
+This command extracts detailed metadata from git commits without using an LLM.
+Useful for:
+  - Quick history extraction
+  - Pre-processing for later analysis
+  - Exploring repository metrics
+
+\b
+Extracted data includes:
+  - Commit metadata (hash, author, date, message)
+  - Lines of code changes (insertions/deletions)
+  - Language breakdown per commit
+  - README evolution
+  - Comment density analysis
+  - Detection of large changes and refactors
+
+\b
+EXAMPLES:
+
+  # Extract full history to default location
+  gitview extract
+
+  # Extract to custom file
+  gitview extract --output my_history.jsonl
+
+  # Extract only last 100 commits
+  gitview extract --max-commits 100
+
+  # Extract from specific branch
+  gitview extract --branch develop
+
+  # Extract from different repository
+  gitview extract --repo /path/to/repo --output repo_data.jsonl
+"""
+
+
+@cli.command(help=EXTRACT_HELP)
+@click.option('--repo', '-r', default=".",
+              help="Path to git repository (default: current directory)")
+@click.option('--output', '-o', default="output/repo_history.jsonl",
+              help="Output JSONL file path")
+@click.option('--max-commits', type=int,
+              help="Maximum commits to extract (default: all commits)")
+@click.option('--branch', default='HEAD',
+              help="Branch to extract from (default: HEAD/current branch)")
+def extract(repo, output, max_commits, branch):
+    console.print("\n[bold blue]Extracting Git History[/bold blue]\n")
+
+    repo_path = Path(repo).resolve()
+    if not (repo_path / '.git').exists():
+        console.print(f"[red]Error: {repo_path} is not a git repository[/red]")
+        sys.exit(1)
+
+    try:
+        extractor = GitHistoryExtractor(str(repo_path))
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console
+        ) as progress:
+            task = progress.add_task("Extracting commits...", total=None)
+            records = extractor.extract_history(max_commits=max_commits, branch=branch)
+            progress.update(task, completed=True)
+
+        extractor.save_to_jsonl(records, output)
+
+        console.print(f"\n[green]Extracted {len(records)} commits to {output}[/green]\n")
+
+    except Exception as e:
+        console.print(f"\n[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
+CHUNK_HELP = """Chunk extracted history into meaningful phases (no LLM needed).
+
+\b
+Takes a JSONL file from 'gitview extract' and splits it into phases/epochs
+based on the chosen strategy. No LLM or API key required.
+
+\b
+CHUNKING STRATEGIES:
+
+1. Adaptive (recommended):
+   Automatically splits when significant changes occur:
+   - LOC changes by >30%
+   - Large deletions or additions (>1000 lines)
+   - README rewrites
+   - Major refactorings
+
+2. Fixed:
+   Split into fixed-size chunks (e.g., 50 commits per phase)
+
+3. Time:
+   Split by time periods (week, month, quarter, year)
+
+\b
+EXAMPLES:
+
+  # Chunk with adaptive strategy (recommended)
+  gitview chunk repo_history.jsonl
+
+  # Chunk with fixed size (25 commits per phase)
+  gitview chunk repo_history.jsonl --strategy fixed --chunk-size 25
+
+  # Save phases to custom directory
+  gitview chunk repo_history.jsonl --output ./my_phases
+
+  # First extract, then chunk separately
+  gitview extract --output data.jsonl
+  gitview chunk data.jsonl --output phases/
+"""
+
+
+@cli.command(help=CHUNK_HELP)
+@click.argument('history_file', type=click.Path(exists=True))
+@click.option('--output', '-o', default="output/phases",
+              help="Output directory for phase JSON files")
+@click.option('--strategy', '-s', type=click.Choice(['fixed', 'time', 'adaptive']),
+              default='adaptive',
+              help="Chunking strategy: 'adaptive' (default), 'fixed', 'time'")
+@click.option('--chunk-size', type=int, default=50,
+              help="Commits per chunk when using 'fixed' strategy")
+def chunk(history_file, output, strategy, chunk_size):
+    console.print("\n[bold blue]Chunking History into Phases[/bold blue]\n")
+
+    try:
+        # Load history
+        from .extractor import GitHistoryExtractor
+        records = GitHistoryExtractor.load_from_jsonl(history_file)
+
+        console.print(f"[cyan]Loaded {len(records)} commits[/cyan]")
+        console.print(f"[cyan]Strategy: {strategy}[/cyan]\n")
+
+        # Chunk
+        chunker = HistoryChunker(strategy)
+        kwargs = {}
+        if strategy == 'fixed':
+            kwargs['chunk_size'] = chunk_size
+
+        phases = chunker.chunk(records, **kwargs)
+
+        console.print(f"[green]Created {len(phases)} phases[/green]\n")
+        _display_phase_overview(phases)
+
+        # Save
+        chunker.save_phases(phases, output)
+        console.print(f"\n[green]Saved phases to {output}[/green]\n")
+
+    except Exception as e:
+        console.print(f"\n[red]Error: {e}[/red]")
+        sys.exit(1)
+
+
+def _display_phase_overview(phases):
+    """Display phase overview table."""
+    table = Table(title="Phase Overview")
+
+    table.add_column("Phase", style="cyan", justify="right")
+    table.add_column("Period", style="magenta")
+    table.add_column("Commits", justify="right")
+    table.add_column("LOC Δ", justify="right")
+    table.add_column("Events", style="yellow")
+
+    for phase in phases:
+        events = []
+        if phase.has_large_deletion:
+            events.append("x")
+        if phase.has_large_addition:
+            events.append("+")
+        if phase.has_refactor:
+            events.append(">>")
+        if phase.readme_changed:
+            events.append(">")
+
+        table.add_row(
+            str(phase.phase_number),
+            f"{phase.start_date[:10]} to {phase.end_date[:10]}",
+            str(phase.commit_count),
+            f"{phase.loc_delta:+,d}",
+            " ".join(events)
+        )
+
+    console.print(table)
+
+
+def main():
+    """Main entry point."""
+    cli()
+
+
+if __name__ == '__main__':
+    main()

{gitview-0.1.0 → gitview-0.1.2}/gitview/extractor.py

@@ -136,7 +136,74 @@ class GitHistoryExtractor:
         commits.reverse()
 
         # Calculate cumulative LOC
-        total_loc = 0
+        return self._calculate_cumulative_loc(commits)
+
+    def extract_incremental(self, since_commit: str = None, since_date: str = None,
+                           branch: str = "HEAD") -> List[CommitRecord]:
+        """Extract only new commits since a specific commit or date.
+
+        Args:
+            since_commit: Commit hash to start from (exclusive)
+            since_date: ISO date string to start from (exclusive)
+            branch: Branch to extract from (default: HEAD)
+
+        Returns:
+            List of CommitRecord objects for new commits, sorted chronologically (oldest first)
+        """
+        commits = []
+
+        # Build revision range
+        if since_commit:
+            # Extract commits from since_commit..HEAD (exclusive of since_commit)
+            revision = f"{since_commit}..{branch}"
+        elif since_date:
+            # Extract commits after the given date
+            commit_iterator = self.repo.iter_commits(
+                branch,
+                since=since_date
+            )
+            for commit in commit_iterator:
+                try:
+                    record = self._extract_commit_record(commit)
+                    commits.append(record)
+                except Exception as e:
+                    print(f"Warning: Failed to extract commit {commit.hexsha[:8]}: {e}")
+                    continue
+
+            # Sort chronologically and calculate LOC
+            commits.reverse()
+            return self._calculate_cumulative_loc(commits)
+        else:
+            raise ValueError("Must provide either since_commit or since_date")
+
+        # Extract commits in the range
+        commit_iterator = self.repo.iter_commits(revision)
+
+        for commit in commit_iterator:
+            try:
+                record = self._extract_commit_record(commit)
+                commits.append(record)
+            except Exception as e:
+                print(f"Warning: Failed to extract commit {commit.hexsha[:8]}: {e}")
+                continue
+
+        # Sort chronologically (oldest first)
+        commits.reverse()
+
+        return commits
+
+    def _calculate_cumulative_loc(self, commits: List[CommitRecord],
+                                  starting_loc: int = 0) -> List[CommitRecord]:
+        """Calculate cumulative LOC for a list of commits.
+
+        Args:
+            commits: List of CommitRecord objects
+            starting_loc: Starting LOC count (for incremental analysis)
+
+        Returns:
+            Same list with loc_total updated
+        """
+        total_loc = starting_loc
         for record in commits:
             total_loc += (record.loc_added - record.loc_deleted)
             record.loc_total = max(0, total_loc)
@@ -218,11 +285,11 @@ class GitHistoryExtractor:
         if not commit.parents:
             # Initial commit
             try:
-                diff_index = commit.diff(git.NULL_TREE)
+                diff_index = commit.diff(git.NULL_TREE, create_patch=True)
             except:
                 return stats
         else:
-            diff_index = commit.parents[0].diff(commit)
+            diff_index = commit.parents[0].diff(commit, create_patch=True)
 
         for diff in diff_index:
             try:
@@ -239,8 +306,9 @@ class GitHistoryExtractor:
                 # Get line changes
                 if diff.diff:
                     diff_text = diff.diff.decode('utf-8', errors='ignore')
-                    insertions = len([l for l in diff_text.split('\n') if l.startswith('+')])
-                    deletions = len([l for l in diff_text.split('\n') if l.startswith('-')])
+                    # Exclude diff headers (---, +++) from line counts
+                    insertions = len([l for l in diff_text.split('\n') if l.startswith('+') and not l.startswith('+++')])
+                    deletions = len([l for l in diff_text.split('\n') if l.startswith('-') and not l.startswith('---')])
 
                     stats['insertions'] += insertions
                     stats['deletions'] += deletions
@@ -312,9 +380,9 @@ class GitHistoryExtractor:
 
         try:
             if not commit.parents:
-                diff_index = commit.diff(git.NULL_TREE)
+                diff_index = commit.diff(git.NULL_TREE, create_patch=True)
             else:
-                diff_index = commit.parents[0].diff(commit)
+                diff_index = commit.parents[0].diff(commit, create_patch=True)
 
             for diff in diff_index:
                 if not diff.b_blob:

{gitview-0.1.0 → gitview-0.1.2}/gitview/writer.py

@@ -11,6 +11,27 @@ from .chunker import Phase
 class OutputWriter:
     """Write git history stories to various formats."""
 
+    @staticmethod
+    def load_previous_analysis(output_path: str) -> Dict[str, Any]:
+        """
+        Load previous analysis from JSON file.
+
+        Args:
+            output_path: Path to output directory containing history_data.json
+
+        Returns:
+            Dict with previous analysis data, or None if not found
+        """
+        json_file = Path(output_path) / "history_data.json"
+        if not json_file.exists():
+            return None
+
+        try:
+            with open(json_file, 'r') as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return None
+
     @staticmethod
     def write_markdown(stories: Dict[str, str], phases: List[Phase],
                       output_path: str, repo_name: str = "Repository"):
@@ -90,13 +111,13 @@ class OutputWriter:
                 # Events
                 events = []
                 if phase.has_large_deletion:
-                    events.append("🗑️ Large Deletion")
+                    events.append("Large Deletion")
                 if phase.has_large_addition:
-                    events.append("➕ Large Addition")
+                    events.append("Large Addition")
                 if phase.has_refactor:
-                    events.append("♻️ Refactoring")
+                    events.append("Refactoring")
                 if phase.readme_changed:
-                    events.append("📝 README Changed")
+                    events.append("README Changed")
 
                 if events:
                     f.write(f"**Events:** {' | '.join(events)}\n\n")
@@ -164,20 +185,39 @@ class OutputWriter:
             f.write("\n")
 
     @staticmethod
-    def write_json(stories: Dict[str, str], phases: List[Phase], output_path: str):
+    def write_json(stories: Dict[str, str], phases: List[Phase], output_path: str,
+                   repo_path: str = None):
         """
-        Write complete data to JSON file.
+        Write complete data to JSON file with metadata for incremental analysis.
 
         Args:
             stories: Dict of story sections
             phases: List of Phase objects
             output_path: Path to output JSON file
+            repo_path: Path to git repository (for metadata)
         """
         output_file = Path(output_path)
         output_file.parent.mkdir(parents=True, exist_ok=True)
 
-        data = {
+        # Calculate metadata from phases
+        metadata = {
             'generated_at': datetime.now().isoformat(),
+            'total_commits_analyzed': sum(p.commit_count for p in phases),
+        }
+
+        # Add last commit info if phases exist
+        if phases:
+            last_phase = phases[-1]
+            if last_phase.commits:
+                last_commit = last_phase.commits[-1]
+                metadata['last_commit_hash'] = last_commit.commit_hash
+                metadata['last_commit_date'] = last_commit.timestamp
+
+        if repo_path:
+            metadata['repository_path'] = str(Path(repo_path).resolve())
+
+        data = {
+            'metadata': metadata,
             'total_phases': len(phases),
             'total_commits': sum(p.commit_count for p in phases),
             'stories': stories,

{gitview-0.1.0 → gitview-0.1.2/gitview.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitview
-Version: 0.1.0
+Version: 0.1.2
 Summary: Git history analyzer with LLM-powered narrative generation
 Home-page: https://github.com/carstenbund/gitview
 Author: GitView Contributors

{gitview-0.1.0 → gitview-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gitview"
-version = "0.1.0"
+version = "0.1.2"
 description = "Git history analyzer with LLM-powered narrative generation"
 readme = "README.md"
 requires-python = ">=3.8"

{gitview-0.1.0 → gitview-0.1.2}/setup.py

@@ -13,7 +13,7 @@ with open("requirements.txt", "r", encoding="utf-8") as fh:
 
 setup(
     name="gitview",
-    version="0.1.0",
+    version="0.1.1",
     author="GitView Contributors",
     author_email="",  # Add if publishing
     description="Git history analyzer with LLM-powered narrative generation",

gitview-0.1.0/gitview/cli.py

@@ -1,332 +0,0 @@
-"""Command-line interface for GitView."""
-
-import os
-import sys
-from pathlib import Path
-
-import click
-from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, TextColumn
-from rich.table import Table
-
-from .extractor import GitHistoryExtractor
-from .chunker import HistoryChunker
-from .summarizer import PhaseSummarizer
-from .storyteller import StoryTeller
-from .writer import OutputWriter
-
-console = Console()
-
-
-@click.group()
-@click.version_option(version="0.1.0")
-def cli():
-    """GitView - Git history analyzer with LLM-powered narrative generation.
-
-    Extract, analyze, and generate compelling narratives from your git repository's history.
-    """
-    pass
-
-
-@cli.command()
-@click.option('--repo', '-r', default=".", help="Path to git repository")
-@click.option('--output', '-o', default="output", help="Output directory")
-@click.option('--strategy', '-s', type=click.Choice(['fixed', 'time', 'adaptive']),
-              default='adaptive', help="Chunking strategy")
-@click.option('--chunk-size', type=int, default=50,
-              help="Chunk size for fixed strategy")
-@click.option('--max-commits', type=int, help="Maximum commits to analyze")
-@click.option('--branch', default='HEAD', help="Branch to analyze")
-@click.option('--backend', '-b', type=click.Choice(['anthropic', 'openai', 'ollama']),
-              help="LLM backend (auto-detected from environment if not specified)")
-@click.option('--model', '-m', help="Model identifier (uses backend defaults if not specified)")
-@click.option('--api-key', help="API key for the backend (defaults to env var)")
-@click.option('--ollama-url', default='http://localhost:11434', help="Ollama API URL")
-@click.option('--repo-name', help="Repository name for output")
-@click.option('--skip-llm', is_flag=True, help="Skip LLM summarization (extract and chunk only)")
-def analyze(repo, output, strategy, chunk_size, max_commits, branch, backend,
-           model, api_key, ollama_url, repo_name, skip_llm):
-    """Analyze git repository and generate narrative history.
-
-    This is the main command that runs the full pipeline:
-    1. Extract git history
-    2. Chunk into meaningful phases
-    3. Summarize each phase with LLM
-    4. Generate global narrative
-    5. Write output files
-    """
-    console.print("\n[bold blue]GitView - Repository History Analyzer[/bold blue]\n")
-
-    # Validate repository
-    repo_path = Path(repo).resolve()
-    if not (repo_path / '.git').exists():
-        console.print(f"[red]Error: {repo_path} is not a git repository[/red]")
-        sys.exit(1)
-
-    # Get repo name if not provided
-    if not repo_name:
-        repo_name = repo_path.name
-
-    console.print(f"[cyan]Repository:[/cyan] {repo_path}")
-    console.print(f"[cyan]Output:[/cyan] {output}")
-    console.print(f"[cyan]Strategy:[/cyan] {strategy}")
-
-    if not skip_llm:
-        # Determine backend for display
-        from .backends import LLMRouter
-        router = LLMRouter(backend=backend, model=model, api_key=api_key, ollama_url=ollama_url)
-        console.print(f"[cyan]Backend:[/cyan] {router.backend_type.value}")
-        console.print(f"[cyan]Model:[/cyan] {router.model}\n")
-    else:
-        console.print("[yellow]Skipping LLM summarization[/yellow]\n")
-
-    try:
-        # Step 1: Extract git history
-        console.print("[bold]Step 1: Extracting git history...[/bold]")
-        extractor = GitHistoryExtractor(str(repo_path))
-
-        with Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            console=console
-        ) as progress:
-            task = progress.add_task("Extracting commits...", total=None)
-            records = extractor.extract_history(max_commits=max_commits, branch=branch)
-            progress.update(task, completed=True)
-
-        console.print(f"[green]✓ Extracted {len(records)} commits[/green]\n")
-
-        # Save raw history
-        history_file = Path(output) / "repo_history.jsonl"
-        extractor.save_to_jsonl(records, str(history_file))
-
-        # Step 2: Chunk into phases
-        console.print("[bold]Step 2: Chunking into phases...[/bold]")
-        chunker = HistoryChunker(strategy)
-
-        kwargs = {}
-        if strategy == 'fixed':
-            kwargs['chunk_size'] = chunk_size
-
-        phases = chunker.chunk(records, **kwargs)
-        console.print(f"[green]✓ Created {len(phases)} phases[/green]\n")
-
-        # Display phase overview
-        _display_phase_overview(phases)
-
-        # Save phases
-        phases_dir = Path(output) / "phases"
-        chunker.save_phases(phases, str(phases_dir))
-
-        if skip_llm:
-            console.print("\n[yellow]Skipping LLM summarization. Writing basic timeline...[/yellow]")
-            timeline_file = Path(output) / "timeline.md"
-            OutputWriter.write_simple_timeline(phases, str(timeline_file))
-            console.print(f"[green]✓ Wrote timeline to {timeline_file}[/green]\n")
-            return
-
-        # Step 3: Summarize phases with LLM
-        console.print("[bold]Step 3: Summarizing phases with LLM...[/bold]")
-        summarizer = PhaseSummarizer(
-            backend=backend,
-            model=model,
-            api_key=api_key,
-            ollama_url=ollama_url
-        )
-
-        with Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            console=console
-        ) as progress:
-            task = progress.add_task("Summarizing phases...", total=len(phases))
-
-            previous_summaries = []
-            for i, phase in enumerate(phases):
-                progress.update(task, description=f"Summarizing phase {i+1}/{len(phases)}...")
-
-                context = summarizer._build_context(previous_summaries)
-                summary = summarizer.summarize_phase(phase, context)
-                phase.summary = summary
-
-                previous_summaries.append({
-                    'phase_number': phase.phase_number,
-                    'summary': summary,
-                    'loc_delta': phase.loc_delta,
-                })
-
-                summarizer._save_phase_with_summary(phase, str(phases_dir))
-                progress.update(task, advance=1)
-
-        console.print(f"[green]✓ Summarized all phases[/green]\n")
-
-        # Step 4: Generate global story
-        console.print("[bold]Step 4: Generating global narrative...[/bold]")
-        storyteller = StoryTeller(
-            backend=backend,
-            model=model,
-            api_key=api_key,
-            ollama_url=ollama_url
-        )
-
-        with Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            console=console
-        ) as progress:
-            task = progress.add_task("Generating story...", total=None)
-            stories = storyteller.generate_global_story(phases, repo_name)
-            progress.update(task, completed=True)
-
-        console.print(f"[green]✓ Generated global narrative[/green]\n")
-
-        # Step 5: Write output
-        console.print("[bold]Step 5: Writing output files...[/bold]")
-        output_path = Path(output)
-
-        # Write markdown report
-        markdown_path = output_path / "history_story.md"
-        OutputWriter.write_markdown(stories, phases, str(markdown_path), repo_name)
-        console.print(f"[green]✓ Wrote {markdown_path}[/green]")
-
-        # Write JSON data
-        json_path = output_path / "history_data.json"
-        OutputWriter.write_json(stories, phases, str(json_path))
-        console.print(f"[green]✓ Wrote {json_path}[/green]")
-
-        # Write timeline
-        timeline_path = output_path / "timeline.md"
-        OutputWriter.write_simple_timeline(phases, str(timeline_path))
-        console.print(f"[green]✓ Wrote {timeline_path}[/green]\n")
-
-        # Success summary
-        console.print("[bold green]✓ Analysis complete![/bold green]\n")
-        console.print(f"📊 Analyzed {len(records)} commits across {len(phases)} phases")
-        console.print(f"📝 Output written to: {output_path.resolve()}\n")
-
-    except Exception as e:
-        console.print(f"\n[red]Error: {e}[/red]")
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-
-
-@cli.command()
-@click.option('--repo', '-r', default=".", help="Path to git repository")
-@click.option('--output', '-o', default="output/repo_history.jsonl",
-              help="Output JSONL file")
-@click.option('--max-commits', type=int, help="Maximum commits to extract")
-@click.option('--branch', default='HEAD', help="Branch to extract from")
-def extract(repo, output, max_commits, branch):
-    """Extract git history to JSONL file.
-
-    This command only extracts the git history without chunking or summarization.
-    """
-    console.print("\n[bold blue]Extracting Git History[/bold blue]\n")
-
-    repo_path = Path(repo).resolve()
-    if not (repo_path / '.git').exists():
-        console.print(f"[red]Error: {repo_path} is not a git repository[/red]")
-        sys.exit(1)
-
-    try:
-        extractor = GitHistoryExtractor(str(repo_path))
-
-        with Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            console=console
-        ) as progress:
-            task = progress.add_task("Extracting commits...", total=None)
-            records = extractor.extract_history(max_commits=max_commits, branch=branch)
-            progress.update(task, completed=True)
-
-        extractor.save_to_jsonl(records, output)
-
-        console.print(f"\n[green]✓ Extracted {len(records)} commits to {output}[/green]\n")
-
-    except Exception as e:
-        console.print(f"\n[red]Error: {e}[/red]")
-        sys.exit(1)
-
-
-@cli.command()
-@click.argument('history_file', type=click.Path(exists=True))
-@click.option('--output', '-o', default="output/phases", help="Output directory for phases")
-@click.option('--strategy', '-s', type=click.Choice(['fixed', 'time', 'adaptive']),
-              default='adaptive', help="Chunking strategy")
-@click.option('--chunk-size', type=int, default=50, help="Chunk size for fixed strategy")
-def chunk(history_file, output, strategy, chunk_size):
-    """Chunk extracted history into phases.
-
-    Takes a JSONL file from the extract command and chunks it into phases.
-    """
-    console.print("\n[bold blue]Chunking History into Phases[/bold blue]\n")
-
-    try:
-        # Load history
-        from .extractor import GitHistoryExtractor
-        records = GitHistoryExtractor.load_from_jsonl(history_file)
-
-        console.print(f"[cyan]Loaded {len(records)} commits[/cyan]")
-        console.print(f"[cyan]Strategy: {strategy}[/cyan]\n")
-
-        # Chunk
-        chunker = HistoryChunker(strategy)
-        kwargs = {}
-        if strategy == 'fixed':
-            kwargs['chunk_size'] = chunk_size
-
-        phases = chunker.chunk(records, **kwargs)
-
-        console.print(f"[green]✓ Created {len(phases)} phases[/green]\n")
-        _display_phase_overview(phases)
-
-        # Save
-        chunker.save_phases(phases, output)
-        console.print(f"\n[green]✓ Saved phases to {output}[/green]\n")
-
-    except Exception as e:
-        console.print(f"\n[red]Error: {e}[/red]")
-        sys.exit(1)
-
-
-def _display_phase_overview(phases):
-    """Display phase overview table."""
-    table = Table(title="Phase Overview")
-
-    table.add_column("Phase", style="cyan", justify="right")
-    table.add_column("Period", style="magenta")
-    table.add_column("Commits", justify="right")
-    table.add_column("LOC Δ", justify="right")
-    table.add_column("Events", style="yellow")
-
-    for phase in phases:
-        events = []
-        if phase.has_large_deletion:
-            events.append("🗑️")
-        if phase.has_large_addition:
-            events.append("➕")
-        if phase.has_refactor:
-            events.append("♻️")
-        if phase.readme_changed:
-            events.append("📝")
-
-        table.add_row(
-            str(phase.phase_number),
-            f"{phase.start_date[:10]} to {phase.end_date[:10]}",
-            str(phase.commit_count),
-            f"{phase.loc_delta:+,d}",
-            " ".join(events)
-        )
-
-    console.print(table)
-
-
-def main():
-    """Main entry point."""
-    cli()
-
-
-if __name__ == '__main__':
-    main()