Merge pull request #5 from twentyTwo/feature/pause_timer_on_inactivity

twentyTwo · web-flow · commit aa9104b178d8 · 2025-04-13T12:33:29.000+06:00
Add pause feature
diff --git a/README.md b/README.md
@@ -13,8 +13,9 @@ Simple Coding Time Tracker is a powerful extension for Visual Studio Code that h
 - **Tooltip on Status Bar**: Shows the total coding time weekly, monthly, and all time basis.
 - **Detailed Summaries**: View comprehensive reports of your coding activity. You can search your total time on a particular day or project.
 - **Data Persistence**: Safely stores your time data for long-term analysis.
-- **Configurable Save Interval**: Customize how often your coding time data is saved (default: 5 seconds). Adjust this in VS Code settings to balance between data accuracy and system performance.
-
+- **Configurable Settings**: 
+  - Save Interval: Customize how often your coding time data is saved (default: 5 seconds)
+  - Inactivity Timeout: Set how long to wait before stopping the timer when no activity is detected (default: 5 minutes)
 
 ## Screenshots
 ### Status Bar
@@ -39,7 +40,6 @@ There are total 3 commands in the command palette available for this extension.
 
 ![All Command Palette Commands](./images/commands.png)
 
-
 ## Installation
 
 1. Open Visual Studio Code
@@ -51,37 +51,36 @@ There are total 3 commands in the command palette available for this extension.
 
 Once installed, the extension will automatically start tracking your coding time. You can view your current session time in the status bar at the bottom of the VSCode window.
 
-To access detailed summaries and reports, use the command palette (Ctrl+Shift+P or Cmd+Shift+P on macOS) and search for "Time Tracker" to see available commands.
+To access detailed summaries and reports, use the command palette (Ctrl+Shift+P or Cmd+Shift+P on macOS) and search for "SCTT" to see available commands.
 
-### Configuring Save Interval
-You can customize how often the extension saves your coding time data:
-1. Open VS Code Settings (Ctrl+, or Cmd+, on macOS)
-2. Search for "Simple Coding Time Tracker"
-3. Find the "Save Interval" setting
-4. Enter your preferred interval in seconds (default is 5 seconds)
-   - Lower values (e.g., 5-10 seconds) provide more frequent updates but may impact performance
-   - Higher values (e.g., 30-60 seconds) are more efficient but update less frequently
+### Configuration Options
 
-## Control Panel Commands
+You can customize the extension's behavior through VS Code settings:
 
-The Simple Coding Time Tracker extension offers a range of commands accessible through the Command Palette, designed to streamline your coding time tracking experience. Here are the primary commands available:
-
-To access these commands, open the Command Palette (Ctrl+Shift+P or Cmd+Shift+P on macOS).
+1. Open VS Code Settings (Ctrl+, or Cmd+, on macOS)
+2. Search for "Simple Coding Time Tracker"
+3. Available settings:
+   - **Save Interval**: How often to save your coding time data (in seconds)
+     - Default: 5 seconds
+     - Lower values provide more frequent updates but may impact performance
+     - Higher values are more efficient but update less frequently
+   - **Inactivity Timeout**: How long to wait before stopping the timer when no activity is detected (in minutes)
+     - Default: 5 minutes
+     - Lower values will stop tracking sooner when you're not actively coding
+     - Higher values will continue tracking for longer during breaks
 
-- **Show Summary**: 
-  - Command Title: `SCTT: Show Coding Time Summary`
-  - This command displays a comprehensive summary of your coding activity, including the total time invested in projects and a daily breakdown.
+### Available Commands
 
-- **Reset Timer for Today**: 
-  - Command Title: `SCTT: Reset Coding Timer for Today`
-  - This command resets the coding time tracker for the current day, allowing you to start anew without any previous data influencing your current session.
+The extension provides the following commands through the Command Palette:
 
-- **Reset All Timers**: 
-  - Command Title: `SCTT: Reset All Coding Timers`
-  - This command resets all coding time trackers. It includes a confirmation prompt to prevent unintended resets, ensuring you have full control over your data.
+- **Show Summary** (`SCTT: Show Coding Time Summary`): 
+  Displays a comprehensive summary of your coding activity, including total time invested in projects and a daily breakdown.
 
-By using these commands, you can effectively manage your coding sessions and maintain precise records of your work.
+- **Reset Timer for Today** (`SCTT: Reset Coding Timer for Today`): 
+  Resets the coding time tracker for the current day, allowing you to start anew.
 
+- **Reset All Timers** (`SCTT: Reset All Coding Timers`): 
+  Resets all coding time trackers with a confirmation prompt to prevent unintended resets.
 
 ## Changelog
 
diff --git a/package.json b/package.json
@@ -24,6 +24,11 @@
           "type": "number",
           "default": 5,
           "description": "Interval in seconds to save the current coding session"
+        },
+        "simpleCodingTimeTracker.inactivityTimeout": {
+          "type": "number",
+          "default": 300,
+          "description": "Time in seconds of inactivity before tracking stops (default: 300 seconds = 5 minutes)"
         }
       }
     },
diff --git a/src/extension.ts b/src/extension.ts
@@ -10,6 +10,13 @@ export function activate(context: vscode.ExtensionContext) {
     const statusBar = new StatusBar(timeTracker);
     const summaryView = new SummaryViewProvider(context, database, timeTracker);
 
+    // Register cursor tracking
+    context.subscriptions.push(
+        vscode.window.onDidChangeTextEditorSelection(() => {
+            timeTracker.updateCursorActivity();
+        })
+    );
+
     // Register the existing command
     let disposable = vscode.commands.registerCommand('simpleCodingTimeTracker.showSummary', () => {
         summaryView.show();
diff --git a/src/statusBar.ts b/src/statusBar.ts
@@ -20,8 +20,9 @@ export class StatusBar implements vscode.Disposable {
 
     private updateStatusBar() {
         const todayTotal = this.timeTracker.getTodayTotal();
-        this.statusBarItem.text = `💻 ${this.formatTime(todayTotal)}`;
-        this.statusBarItem.tooltip = this.getTooltipText();
+        const isActive = this.timeTracker.isActive();
+        this.statusBarItem.text = `${isActive ? '💻' : '⏸️'} ${this.formatTime(todayTotal)}`;
+        this.statusBarItem.tooltip = this.getTooltipText(isActive);
     }
 
     private formatTime(minutes: number): string {
@@ -31,12 +32,12 @@ export class StatusBar implements vscode.Disposable {
         return `${hours.toString().padStart(2, '0')}:${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
     }
 
-    private getTooltipText(): string {
+    private getTooltipText(isActive: boolean): string {
         const weeklyTotal = this.timeTracker.getWeeklyTotal();
         const monthlyTotal = this.timeTracker.getMonthlyTotal();
         const allTimeTotal = this.timeTracker.getAllTimeTotal();
 
-        return `Total Coding Time:
+        return `${isActive ? 'Active' : 'Paused'} - Total Coding Time:
 This week: ${formatTime(weeklyTotal)}
 This month: ${formatTime(monthlyTotal)}
 All Time: ${formatTime(allTimeTotal)}
diff --git a/src/timeTracker.ts b/src/timeTracker.ts
@@ -9,12 +9,99 @@ export class TimeTracker implements vscode.Disposable {
     private updateInterval: NodeJS.Timeout | null = null;
     private saveInterval: NodeJS.Timeout | null = null;
     private saveIntervalSeconds: number;
+    private lastCursorActivity: number = Date.now();
+    private cursorInactivityTimeout: NodeJS.Timeout | null = null;
+    private inactivityTimeoutSeconds: number;
 
     constructor(database: Database) {
         this.database = database;
-        this.saveIntervalSeconds = vscode.workspace
-            .getConfiguration('simpleCodingTimeTracker')
-            .get('saveInterval', 5);
+        const config = vscode.workspace.getConfiguration('simpleCodingTimeTracker');
+        this.saveIntervalSeconds = config.get('saveInterval', 5);
+        this.inactivityTimeoutSeconds = config.get('inactivityTimeout', 300); // Default 5 minutes in seconds
+
+        // Track cursor movements
+        vscode.window.onDidChangeTextEditorSelection(() => {
+            this.updateCursorActivity();
+        });
+
+        // Track text changes
+        vscode.workspace.onDidChangeTextDocument(() => {
+            this.updateCursorActivity();
+        });
+
+        // Track active editor changes
+        vscode.window.onDidChangeActiveTextEditor(() => {
+            this.updateCursorActivity();
+        });
+
+        // Track hover events
+        vscode.languages.registerHoverProvider({ scheme: '*' }, {
+            provideHover: () => {
+                this.updateCursorActivity();
+                return null;
+            }
+        });
+
+        // Track type definition requests (triggered by mouse movement over symbols)
+        vscode.languages.registerTypeDefinitionProvider({ scheme: '*' }, {
+            provideTypeDefinition: () => {
+                this.updateCursorActivity();
+                return null;
+            }
+        });
+
+        // Track signature help requests (triggered by hovering over function calls)
+        vscode.languages.registerSignatureHelpProvider({ scheme: '*' }, {
+            provideSignatureHelp: () => {
+                this.updateCursorActivity();
+                return null;
+            }
+        }, '(', ',');
+
+        // Track when VS Code window gains focus
+        vscode.window.onDidChangeWindowState((e) => {
+            if (e.focused) {
+                this.updateCursorActivity();
+            }
+        });
+    }
+
+    private setupCursorTracking() {
+        if (this.cursorInactivityTimeout) {
+            clearTimeout(this.cursorInactivityTimeout);
+        }
+
+        const currentTime = Date.now();
+        const timeSinceLastActivity = currentTime - this.lastCursorActivity;
+
+        // Only setup new timeout if we haven't exceeded the inactivity threshold
+        if (timeSinceLastActivity < this.inactivityTimeoutSeconds * 1000) {
+            // Set up cursor activity tracking
+            this.cursorInactivityTimeout = setTimeout(() => {
+                const now = Date.now();
+                const inactivityDuration = now - this.lastCursorActivity;
+                
+                // Only stop tracking if we've truly been inactive
+                if (this.isTracking && inactivityDuration >= this.inactivityTimeoutSeconds * 1000) {
+                    this.stopTracking();
+                    this.saveCurrentSession();
+                }
+            }, this.inactivityTimeoutSeconds * 1000); // Convert seconds to milliseconds
+        }
+
+        this.lastCursorActivity = currentTime;
+    }
+
+    public updateCursorActivity() {
+        if (!this.isTracking) {
+            this.startTracking();
+        }
+
+        // Update the last activity timestamp
+        this.lastCursorActivity = Date.now();
+
+        // Reset and setup the inactivity timer
+        this.setupCursorTracking();
     }
 
     startTracking() {
@@ -24,6 +111,7 @@ export class TimeTracker implements vscode.Disposable {
             this.currentProject = this.getCurrentProject();
             this.updateInterval = setInterval(() => this.updateCurrentSession(), 1000);
             this.saveInterval = setInterval(() => this.saveCurrentSession(), this.saveIntervalSeconds * 1000); // Convert seconds to milliseconds
+            this.setupCursorTracking();
         }
     }
 
@@ -38,6 +126,10 @@ export class TimeTracker implements vscode.Disposable {
                 clearInterval(this.saveInterval);
                 this.saveInterval = null;
             }
+            if (this.cursorInactivityTimeout) {
+                clearTimeout(this.cursorInactivityTimeout);
+                this.cursorInactivityTimeout = null;
+            }
             this.saveCurrentSession();
         }
     }
@@ -67,10 +159,14 @@ export class TimeTracker implements vscode.Disposable {
             .filter((entry: TimeEntry) => entry.date === today)
             .reduce((sum: number, entry: TimeEntry) => sum + entry.timeSpent, 0);
         
-        // Add the current session time if tracking is active
+        // Add the current session time if tracking is active and we haven't exceeded inactivity threshold
         if (this.isTracking) {
-            const currentSessionTime = (Date.now() - this.startTime) / 60000;
-            return todayTotal + currentSessionTime;
+            const timeSinceLastActivity = Date.now() - this.lastCursorActivity;
+            // Only include current session if we're still within the activity window
+            if (timeSinceLastActivity < this.inactivityTimeoutSeconds * 1000) {
+                const currentSessionTime = (Date.now() - this.startTime) / 60000;
+                return todayTotal + currentSessionTime;
+            }
         }
         
         return todayTotal;
@@ -84,10 +180,13 @@ export class TimeTracker implements vscode.Disposable {
             .filter((entry: TimeEntry) => entry.date === today && entry.project === currentProject)
             .reduce((sum: number, entry: TimeEntry) => sum + entry.timeSpent, 0);
         
-        // Add the current session time if tracking is active
+        // Add the current session time if tracking is active and within activity window
         if (this.isTracking && this.currentProject === currentProject) {
-            const currentSessionTime = (Date.now() - this.startTime) / 60000;
-            return currentProjectTime + currentSessionTime;
+            const timeSinceLastActivity = Date.now() - this.lastCursorActivity;
+            if (timeSinceLastActivity < this.inactivityTimeoutSeconds * 1000) {
+                const currentSessionTime = (Date.now() - this.startTime) / 60000;
+                return currentProjectTime + currentSessionTime;
+            }
         }
         
         return currentProjectTime;
@@ -109,10 +208,13 @@ export class TimeTracker implements vscode.Disposable {
         const total = this.database.getEntries()
             .reduce((sum: number, entry: TimeEntry) => sum + entry.timeSpent, 0);
 
-        // Add current session if tracking is active
+        // Add current session if tracking is active and within activity window
         if (this.isTracking) {
-            const currentSessionTime = (Date.now() - this.startTime) / 60000;
-            return total + currentSessionTime;
+            const timeSinceLastActivity = Date.now() - this.lastCursorActivity;
+            if (timeSinceLastActivity < this.inactivityTimeoutSeconds * 1000) {
+                const currentSessionTime = (Date.now() - this.startTime) / 60000;
+                return total + currentSessionTime;
+            }
         }
 
         return total;
@@ -129,10 +231,13 @@ export class TimeTracker implements vscode.Disposable {
 
         const total = filteredEntries.reduce((sum, entry) => sum + entry.timeSpent, 0);
 
-        // Add current session if tracking is active
+        // Add current session if tracking is active and within activity window
         if (this.isTracking) {
-            const currentSessionTime = (Date.now() - this.startTime) / 60000;
-            return total + currentSessionTime;
+            const timeSinceLastActivity = Date.now() - this.lastCursorActivity;
+            if (timeSinceLastActivity < this.inactivityTimeoutSeconds * 1000) {
+                const currentSessionTime = (Date.now() - this.startTime) / 60000;
+                return total + currentSessionTime;
+            }
         }
 
         return total;
@@ -159,4 +264,8 @@ export class TimeTracker implements vscode.Disposable {
         this.startTime = 0;
         this.database.resetAllTime();
     }
+
+    isActive(): boolean {
+        return this.isTracking;
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,11 @@`
`24`	`24`	`"type": "number",`
`25`	`25`	`"default": 5,`
`26`	`26`	`"description": "Interval in seconds to save the current coding session"`
	`27`	`+ },`
	`28`	`+ "simpleCodingTimeTracker.inactivityTimeout": {`
	`29`	`+ "type": "number",`
	`30`	`+ "default": 300,`
	`31`	`+ "description": "Time in seconds of inactivity before tracking stops (default: 300 seconds = 5 minutes)"`
`27`	`32`	`}`
`28`	`33`	`}`
`29`	`34`	`},`