Tracking git branch checked out?

[elliot-nelson]

I just found this project today and have been playing with it, and it might be perfect for me.

The one thing I find missing is: my eventual goal is to be able to take collapsed log files for a day and produce a report (possibly fed through local AI) that can give me a summary of the way I spent my day... without any kind of intentional clocking in-out (no pomodoro stuff).

I think for this I need more than just window titles. "Terminal" and "VSCode" do happen to have their folder opened in the title (and in the case of VSCode, the file as well), which is a good start: but I really need what git branch is checked out in that folder as well.

What I'm hoping is: raw logs minute-by-minute throughout the day, recording window titles, but also if a window title seems to have a folder in it, and that folder contains a .git folder, what branch was checked out during that minute.

Does such a feature exist, or if not, what component should it live in? (I'm potentially interested in contributing it if it would fit into the architecture and the project is still alive.)

[elliot-nelson]

I'm going to add here that another thing incredibly useful would be to tie Copilot conversations to the logs somehow.

Logs in ~/Library/Application Support/Code/User/workspaceStorage/*/chatSessions/*.json, each of which have timestamp properties, could be used to tie to approximate minute.

(Again, exactly how this would happen -- is a different Watcher watching it, or is it part of some existing Watcher, that's what I could use advice on.)

[BelKed]

https://superuser.com/questions/105499/change-terminal-title-in-mac-os-x
https://superuser.com/questions/1612990/how-to-set-terminal-tab-title-to-show-the-current-git-branch-using-zsh

Combining these two questions should allow you to display your current Git branch in the Terminal title, which will then be recorded by ActivityWatch :)

[petrroll]

You could create your own watcher that is somehow configured which folders to watch and reports which branches are current there.

Shouldn't be much work.

A bit harder would be making the finding which folders to watch automatic.

An easier avenue might be extending the VScode watcher. There's link to it from docs about other watchers.

[Lopesnextgen]

Hey Elliot,

Most of what you want already fits ActivityWatch’s architecture

The key distinction is that ActivityWatch does not need to save a complete snapshot every minute. Watchers send heartbeats when context changes, and ActivityWatch stores the resulting time intervals. That produces a much smaller timeline that can still be expanded into minute-level reporting later.

Git branch tracking in VS Code

The official aw-watcher-vscode already supports sending:

• project name
• current file
• programming language
• current Git branch

This belongs in the editor watcher, not in aw-watcher-window.

Parsing directories from window titles would be fragile because:

• title formats change between applications
• paths may be abbreviated or absent
• multi-root workspaces complicate repository selection
• the branch can change without the window title changing
• reading arbitrary directories creates privacy and performance concerns

The VS Code extension can use VS Code’s integrated Git API, which gives it a much more reliable understanding of the active repository.

There has been an issue where the Marketplace version did not include the branch functionality even though it had already been merged into the repository. I would check the raw VS Code watcher events in ActivityWatch’s Timeline and confirm whether they contain a branch field.

Relevant links:

• https://github.com/ActivityWatch/aw-watcher-vscode
• Send Git branch name. aw-watcher-vscode#26
• Git branch name from VSCode is not sent aw-watcher-vscode#41

Terminal activity is a different problem

For terminal work, I would use a separate terminal or shell watcher.

A shell integration could emit an event whenever a prompt or command starts, containing metadata such as:

• current working directory
• Git repository root
• current branch
• command duration
• shell session identifier
• terminal application

That is more reliable than trying to infer the working directory from the terminal window title.

I would make command capture optional. Commands frequently contain tokens, passwords, internal URLs, customer names, and other sensitive information. Repository and branch metadata are usually enough for a daily activity report.

Copilot conversations should probably be a separate importer

If the source is persisted JSON under VS Code’s workspaceStorage, I would initially model this as an importer rather than add it to the regular VS Code watcher.

The importer could:

• scan new or modified chat-session files
• parse their timestamps
• avoid importing the same message twice
• associate sessions with a workspace or repository
• create events in a dedicated bucket
• optionally store message counts or summaries

I would avoid storing complete prompts and responses by default. Copilot conversations can contain source code, credentials, proprietary information, and copied production data.

A safer event might contain:

• session ID
• workspace or repository
• timestamp
• number of user/assistant turns
• model or provider, when available
• a locally generated and redacted summary

Reading workspaceStorage is also an implementation-dependent integration. Microsoft may change that internal format or location. A documented VS Code API would be preferable if one becomes available.

Where correlation should happen

I would keep the architecture separated:

• watchers collect factual source-specific events
• ActivityWatch stores those events in separate buckets
• queries correlate overlapping events
• a reporting layer produces the daily narrative

For example, a report generator could combine:

• active window: VS Code
• editor project: ActivityWatch
• Git branch: feature/daily-summary
• terminal working directory: the same repository
• Copilot session: three messages during that interval
• browser activity: related documentation
• AFK status: active

That derived timeline could then be sent to a local model to generate a summary without changing the original events.

Suggested component ownership

• VS Code file/project/branch: aw-watcher-vscode
• terminal directory/repository/branch: separate terminal watcher
• Copilot persisted conversations: separate importer or opt-in watcher
• cross-source timeline: custom ActivityWatch query
• daily AI report: separate local reporting tool

This keeps each watcher small and prevents the generic window watcher from becoming responsible for understanding Git, terminals, editors, and AI tools.

So yes, the project’s architecture is a good fit for this. Git branch support already exists for VS Code; the most valuable contributions would likely be reliable terminal context collection and a privacy-conscious importer/reporting pipeline for AI conversations.