Finishing v1 of GitScope !! :)

This session, I tightened the project for public viewing and basic use. The documentation now matches the implemented behavior, the app was checked against the design document, and the project version was moved to 1.0.0 for the planned v1.0 release line.

What Changed

• Updated the TUI to follow DESIGN.md more closely.
• Placed the app inside a single framed terminal-style window.
• Removed the default Textual footer so the custom status bar owns the bottom edge.
• Styled the title bar, refs sidebar, commit table, selection state, graph gutter, diff pane, diff overview strip, and status hints with the documented color palette.
• Kept the UI read-only: ref selection changes the viewed log only and never checks out a branch.
• Updated README status, key bindings, bounded-loading notes, and known v1 limitations.
• Marked the readiness pass complete in the roadmap.
• Updated package and CLI version strings from 0.1.0 to 1.0.0.

Release Preparation

The intended public release target is GitHub Release v1.0, with Windows and Linux builds to be published later.

No release artifacts were built in this pass. No GitHub release was created. No push was performed.

Known v1 Limits

• Line-level diffs only; no word-level intraline highlighting.
• No config files, custom themes, or plugin system.
• No remote operations and no network calls.
• No mutating git operations.

Verification

• py -m pytest passed with 31 tests.
• py -m pip install . installed the project from source.
• gitscope --version reported the package version.
• A Textual smoke check in the local repository populated the refs, history table, selected commit, diff pane, status bar, and exported screenshot.
• Source scans confirmed subprocess use remains isolated to the backend and no network libraries or mutating git command shapes were added.

Releases:

1. https://github.com/DevaanshPathak/gitscope/releases/tag/v1.0
2. https://pypi.org/project/devaansh-gitscope/1.0.0/

Handling repos with large commit histories

This session focused on making gitscope stay responsive when opened in repositories with larger commit histories. The app now loads commit history incrementally instead of assuming the entire log can be fetched at startup.

What Changed

• Added bounded commit loading with an initial page size.
• Requested one extra commit per page so the UI can tell whether more history is available.
• Added a manual “load more” action for extending the visible history.
• Added automatic loading near the end of the currently loaded rows during keyboard navigation.
• Added status bar feedback for loading, more-history, and end-of-history states.
• Kept current branch/HEAD and all-branches views on the same paginated backend path.
• Preserved selected-commit behavior as new pages are appended.

Why It Matters

Before this work, a very large repository could force the app to ask git for too much history up front. The updated behavior keeps startup bounded by the first page of commits, then loads additional pages only when the user asks for or navigates into them.

That keeps gitscope aligned with its core goal: a fast local read-only history viewer, not a heavyweight repository indexer.

Testing

Added and expanded tests around:

• initial log loading staying bounded by page size
• manual page loading appending rows
• load-more stopping cleanly at the end of history
• navigation near the loaded boundary requesting another page
• all-branches loading using the same pagination window

Read-Only Review

The UI still does not call git directly. It asks the backend for paged commit data, selected-commit diffs, refs, and HEAD information only.

No checkout, staging, committing, branch mutation, remote operation, or network behavior was added.

Verification

• py -m pytest passed with 31 tests.
• Source installation continued to work.
• The app could be mounted against the local gitscope repository with populated refs, log rows, selected commit, diff output, and status text.

Updates on the build!!

This session, I connected the earlier git data, diff parsing, and graph layout work to the Textual interface. gitscope now opens as a coordinated read-only history viewer instead of a static shell.

What Changed

• Replaced the placeholder app screen with a real Textual layout.
• Added a refs sidebar for HEAD, local branches, tags, and an all-branches view.
• Added a commit table with graph, SHA, author, date, and subject columns.
• Rendered the branch graph gutter from the pure graph layout module.
• Added a diff pane that updates when the selected commit changes.
• Added a compact diff overview strip beside the diff pane.
• Added a status bar showing repo path, HEAD, selected ref, selected commit, loaded count, and key hints.
• Added shared reactive state for the selected commit, so the log selection drives the diff pane cleanly.
• Added key bindings for refresh, all branches, HEAD, load more, j/k movement, help, and quit.

Read-Only Behavior

The UI only asks the backend for repository data. It does not shell out to git directly and does not expose checkout, staging, committing, rebasing, pushing, pulling, fetching, branch creation, or any other mutating operation.

Selecting a branch or tag changes the viewed log data only. It does not change the checked-out branch.

Testing

Added headless Textual tests with a fake backend to verify:

• the refs sidebar, commit table, diff pane, and status bar mount correctly
• the selected commit updates the diff pane
• moving the selection changes the displayed diff
• selecting a ref reloads log data without mutating git state
• the all-branches action uses the all-branches backend path

Verification

• py -m pytest passed with 26 tests.
• py -m pip install . completed successfully.
• gitscope --version returned gitscope 0.1.0.
• A headless app smoke check against the real gitscope repository loaded the commit log and selected the current commit.
• Source scans confirmed subprocess access remains outside the UI.

Notes

The next devlog will cover large-repository behavior and release-readiness work.

Got basic stuff working!!

This session, I added the core non-UI logic behind gitscope: a read-only git data layer, a line-level diff parser, and a pure branch graph layout engine. The goal was to make the app capable of reading repository history while keeping git access, parsing, and graph computation testable outside the terminal UI.

Git Data Layer

Added a GitBackend abstraction around the local git binary. It is the only place application code should shell out to git.

The backend can now:

• Discover the current repository root.
• Validate that a path is inside a git work tree.
• Report the repository path.
• Read current HEAD details: full SHA, short SHA, and current branch.
• List HEAD, local branches, and tags.
• Load commit pages for HEAD or a specific ref.
• Load commit pages across local branches.
• Load the patch for a selected commit.

The backend deliberately stays read-only. It does not expose staging, committing, checkout, reset, merge, rebase, push, pull, fetch, clone, or branch mutation.

Data Models

Added typed records for the main data flowing through the app:

• Commit
• GitRef
• HeadInfo
• DiffLine
• GraphRow
• GraphCell
• GraphConnection

These keep git output, parsed diffs, and graph layout results explicit instead of passing around loosely structured dictionaries or strings.

Diff Parsing

Added a pure parse_diff() function for line-level git diff output.

It classifies:

• file headers
• metadata lines
• hunk headers
• added lines
• removed lines
• context lines
• no-newline markers

It also tracks old and new line numbers inside hunks so the UI can render a readable diff view later.

Graph Layout

Added a pure layout_graph() function that takes newest-first commits and parent SHAs, then returns lane and connector metadata for each row.

It handles:

• empty history
• root commits
• linear history
• merge commits
• multiple active lanes
• detached-style history

The graph logic is independent of Textual. It returns data that a terminal UI can render, but it does not depend on terminal widgets or screen state.

Testing

Added tests for:

• backend command construction
• backend parsing
• unsafe refs and SHAs
• unsupported git command shapes
• non-work-tree validation
• a real temporary git repository with commits, a branch, a tag, logs, refs, and diffs
• diff classification and line numbering
• empty diffs
• root, linear, merge, multi-lane, and detached-style graph histories
• graph collision checks

Verification

• py -m pytest passed with 22 tests.
• py -m pip install . completed successfully.
• gitscope --version returned gitscope 0.1.0.
• Source scans confirmed parser/layout/model modules do not depend on Textual, subprocess, or direct git commands.

Notes

• Git access intentionally uses the installed git CLI rather than libgit2 bindings or direct object parsing.
• The graph layout is a first practical implementation intended to be refined once it is exercised by the live UI.
• Wiring this logic into the Textual interface is covered by the next devlog.

Established the project baseline for gitscope and completed the first foundation milestone. The repository now has planning documents, design guidance, installable Python package metadata, a starter Textual app shell, a console entry point, and an initial test layout.

Completed

• Added project planning docs: README.md, PRD.md, AGENTS.md, and roadmap.md.
• Added DESIGN.md and banner.png as the visual reference for the TUI.
• Updated README.md to show the banner image.
• Added pyproject.toml with Python package metadata, Textual dependency, console script, and pytest configuration.
• Added the initial src/gitscope package with __init__.py, __main__.py, cli.py, and app.py.
• Added a Milestone 1 Textual shell with the major design zones: title bar, refs sidebar, commit table, diff pane, status bar, and footer.
• Added initial tests in tests/test_foundation.py.
• Updated AGENTS.md to make following DESIGN.md compulsory for all TUI work.

Verification

• py -m pip install . completed successfully.
• gitscope --version returned gitscope 0.1.0.
• py -m pytest passed with 3 tests.
• A headless Textual mount smoke check completed successfully.

Notes

• The current implementation is intentionally limited to Milestone 1 foundation work.
• Git backend, graph layout, diff parsing, real refs, and live commit loading remain future milestone work.
• On this machine, python resolves to an MSYS Python without pip, so verification used the working Windows launcher command py.