@traisetech/autopilot 0.1.4 → 0.1.6

package/CHANGELOG.md

@@ -25,11 +25,16 @@ This project follows Semantic Versioning (https://semver.org).
 ## [0.1.4] – 2026-02-01
 
 ### Fixed
+- **Windows Compatibility**: Fixed critical issue where absolute paths on Windows caused ignore rules to fail.
+- **Watcher Noise**: Fixed infinite commit loops caused by `.vscode/time-analytics.json` and self-logging.
 - Fixed a critical CLI crash where `autopilot start` failed due to miswired Commander action handlers.
 - Improved command registration to ensure all CLI commands are correctly bound and validated at runtime.
 - Prevented undefined command handlers from causing runtime exceptions.
 
 ### Added
+- **Release Gates**: Added `npm run verify` and `prepublishOnly` hooks to prevent broken releases.
+- **Integration Tests**: Added full end-to-end test suite using `node:test`.
+- **Smart Init**: `autopilot init` now automatically adds `autopilot.log` to `.gitignore`.
 - Pre-publish verification pipeline to block publishing broken builds.
 - CLI smoke tests to ensure core commands (`init`, `start`, `status`, `doctor`) do not crash.
 - Test-only dry-run mode for watcher to allow safe automated testing.

package/README.md

@@ -1,227 +1,2 @@
-# 🚀 Autopilot
 
-<div align="center">
-
-![Autopilot Logo](https://img.shields.io/badge/Autopilot-blue?style=for-the-badge&logo=git&logoColor=white)
-
-**Intelligent Git automation that commits and pushes your code, so you can focus on building.**
-
-[![npm version](https://img.shields.io/npm/v/@traisetech/autopilot?style=flat-square&color=success)](https://www.npmjs.com/package/@traisetech/autopilot)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
-[![Node Version](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen?style=flat-square)](https://nodejs.org)
-[![Downloads](https://img.shields.io/npm/dm/@traisetech/autopilot?style=flat-square&color=blue)](https://www.npmjs.com/package/@traisetech/autopilot)
-[![GitHub Stars](https://img.shields.io/github/stars/PraiseTechzw/autopilot?style=flat-square&color=gold)](https://github.com/PraiseTechzw/autopilot/stargazers)
-[![Build Status](https://img.shields.io/github/actions/workflow/status/PraiseTechzw/autopilot/ci.yml?style=flat-square)](https://github.com/PraiseTechzw/autopilot/actions)
-[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
-
-**Built by [Praise Masunga](https://github.com/PraiseTechzw) (PraiseTechzw)**
-
-[Features](#-features) • [Installation](#-installation) • [Quick Start](#-quick-start) • [Configuration](#-configuration) • [Commands](#-commands)
-
-</div>
-
----
-
-## 📖 Table of Contents
-
-- [Why Autopilot?](#-why-autopilot)
-- [Features](#-features)
-- [Installation](#-installation)
-- [Quick Start](#-quick-start)
-- [Commands](#-commands)
-- [Configuration](#-configuration)
-- [Safety Features](#-safety-features)
-- [Troubleshooting](#-troubleshooting)
-- [Contributing](#-contributing)
-- [License](#-license)
-
----
-
-## 🎯 Why Autopilot?
-
-Autopilot is designed for developers who want to stay in the flow. It solves manual Git workflow fatigue by handling the repetitive cycle of staging, committing, and pushing changes, allowing you to focus entirely on writing code.
-
-<table>
-<tr>
-<td width="50%">
-
-### ❌ Before Autopilot
-
-```bash
-# Every. Single. Time.
-git add .
-git commit -m "update stuff"
-git push
-
-# Repeat 50+ times a day...
-# Lose focus on coding
-# Forget to commit
-# Inconsistent messages
-```
-
-</td>
-<td width="50%">
-
-### ✅ With Autopilot
-
-```bash
-# One time setup
-autopilot init
-autopilot start
-
-# That's it! 
-# Focus on coding
-# Auto-commits with smart messages
-# Never lose work again
-```
-
-</td>
-</tr>
-</table>
-
----
-
-## ✨ Features
-
-- **🧠 Smart Commits**: Generates professional conventional commit messages automatically.
-- **⚡ Watcher Engine**: Real-time file monitoring with smart debouncing using `chokidar`.
-- **🛡️ Safety First**: Blocks commits on protected branches and checks remote status.
-- **🔄 Automated Flow**: Fetches, stages, commits, and pushes (optional) automatically.
-- **⚙️ Zero Config**: Works out of the box, but fully configurable via `.autopilotrc.json`.
-- **🩺 Self-Healing**: Includes a `doctor` command to diagnose and fix issues.
-
----
-
-## ⬇️ Installation
-
-Install Autopilot globally using npm:
-
-```bash
-npm install -g @traisetech/autopilot
-```
-
----
-
-## 🚀 Quick Start
-
-### 1. Initialize
-Navigate to your Git repository and initialize Autopilot:
-
-```bash
-cd my-project
-autopilot init
-```
-
-### 2. Start Watching
-Start the background daemon to begin monitoring your files:
-
-```bash
-autopilot start
-```
-
-### 3. Check Status
-Verify that Autopilot is running:
-
-```bash
-autopilot status
-```
-
-### 4. Stop
-When you're done for the day:
-
-```bash
-autopilot stop
-```
-
----
-
-## 💻 Commands
-
-| Command | Description |
-|---------|-------------|
-| `autopilot init` | Initializes configuration and ignore files in the current directory. |
-| `autopilot start` | Starts the background watcher daemon. |
-| `autopilot stop` | Stops the running watcher daemon. |
-| `autopilot status` | Shows the current status of the watcher process. |
-| `autopilot doctor` | Runs diagnostics to verify environment and configuration. |
-| `autopilot --help` | Displays help information. |
-
----
-
-## ⚙️ Configuration
-
-Autopilot uses a `.autopilotrc.json` file for configuration. It is created automatically when you run `autopilot init`.
-
-```json
-{
-  "minInterval": 30,
-  "autoPush": true,
-  "blockedBranches": ["main", "production"],
-  "requireChecks": false,
-  "ignore": [
-    "*.log",
-    "temp/",
-    "dist/",
-    "node_modules"
-  ]
-}
-```
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `minInterval` | `number` | `30` | Minimum seconds between commits. |
-| `autoPush` | `boolean` | `true` | Whether to push changes automatically after commit. |
-| `blockedBranches` | `array` | `[]` | List of branches to disable auto-commit on. |
-| `requireChecks` | `boolean` | `false` | Run custom checks before committing. |
-| `ignore` | `array` | `[]` | Additional glob patterns to ignore. |
-
----
-
-## 🛡️ Safety Features
-
-Autopilot includes several safety mechanisms to prevent accidents:
-
-1.  **Branch Protection**: Will not run on branches listed in `blockedBranches`.
-2.  **Remote Sync**: Checks if local branch is behind remote before acting.
-3.  **Debouncing**: Waits for file changes to settle before committing.
-4.  **PID Management**: Ensures only one instance runs per repository.
-
----
-
-## 🔧 Troubleshooting
-
-If you encounter issues, run the doctor command:
-
-```bash
-autopilot doctor
-```
-
-This will check for:
-- Git repository status
-- Configuration validity
-- Node.js version
-- Permissions
-
----
-
-## 🤝 Contributing
-
-Contributions are welcome! Please feel free to submit a Pull Request.
-
-1.  Fork the repository
-2.  Create your feature branch (`git checkout -b feature/AmazingFeature`)
-3.  Commit your changes (`git commit -m 'Add some AmazingFeature'`)
-4.  Push to the branch (`git push origin feature/AmazingFeature`)
-5.  Open a Pull Request
-
----
-
-## 📜 License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
-
----
-
-<div align="center">
-  <b>Built by <a href="https://github.com/PraiseTechzw">Praise Masunga (PraiseTechzw)</a></b>
-</div>
+<!-- Autopilot test run: 2026-02-01 -->

package/docs/TROUBLESHOOTING.md

@@ -1,40 +1,21 @@
-# Troubleshooting
-
-**Built by Praise Masunga (PraiseTechzw)**
-
----
-
-## Autopilot won’t start
-
-- Ensure you are inside a git repository
-- Run `autopilot doctor`
-- Remove stale PID if needed: delete `.autopilot.pid`
-
----
-
-## It won’t commit
-
-Common reasons:
-- You are on a blocked branch (`blockBranches`)
-- Remote is ahead (pull first)
-- `requireChecks` is enabled and a check failed
-- No changes detected by git
-
----
-
-## It won’t push
-
-- Verify `autoPush` is true
-- Check your `origin` remote and authentication
-- Ensure you have access to the remote
-
----
-
-## Logs
-
-- `autopilot.log` is created in the repo root
-- `autopilot status` shows the last log line
-
----
-
-**Built by Praise Masunga (PraiseTechzw)**
+# TROUBLESHOOTING
+
+## Common Issues
+
+### Watcher Loop / High CPU Usage (Windows)
+If Autopilot seems to be constantly triggering or consuming high CPU on Windows, it is likely due to "noisy" files that change frequently but should be ignored.
+
+**Common Culprits:**
+- `.vscode/time-analytics.json`: Some VS Code extensions write to this file constantly.
+- `autopilot.log`: If the watcher logs to a file that it is also watching, it creates a feedback loop.
+
+**Solution:**
+Autopilot v0.1.4+ includes enhanced Windows path handling to automatically ignore these files. If you still see issues:
+1. Ensure `.vscode/` and `*.log` are in your `.autopilotignore` file.
+2. Run `autopilot doctor` to verify your configuration.
+
+### "git.status is not a function"
+This was a known issue in older versions. Please upgrade to the latest version.
+
+### Permissions Errors
+Ensure you have write access to the repository and that no other process has locked the files (common on Windows with anti-virus software).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@traisetech/autopilot",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "publishConfig": {
     "access": "public"
   },
@@ -34,7 +34,7 @@
     "dev": "node bin/autopilot.js",
     "test": "node --test",
     "lint": "node -c bin/autopilot.js && node -c src/index.js",
-    "verify": "npm run test && npm run lint && node bin/autopilot.js --help",
+    "verify": "node bin/autopilot.js --help && npm run test && node bin/autopilot.js doctor",
     "prepublishOnly": "npm run verify",
     "release:patch": "npm run verify && npm version patch && git push --follow-tags && echo \"\n🚀 Ready to publish! Run: npm publish --access public\""
   },

package/src/commands/init.js

@@ -4,6 +4,7 @@
  */
 
 const fs = require('fs-extra');
+const path = require('path');
 const logger = require('../utils/logger');
 const { getConfigPath, getIgnorePath, getGitPath } = require('../utils/paths');
 const { DEFAULT_CONFIG, DEFAULT_IGNORE_PATTERNS } = require('../config/defaults');
@@ -54,6 +55,41 @@ async function createConfigFile(repoPath) {
   return true;
 }
 
+/**
+ * Update .gitignore with Autopilot specific files
+ * @param {string} repoPath 
+ */
+async function updateGitIgnore(repoPath) {
+  const gitIgnorePath = path.join(repoPath, '.gitignore');
+  const toIgnore = ['autopilot.log', '.autopilot.pid'];
+  let content = '';
+  
+  try {
+    if (await fs.pathExists(gitIgnorePath)) {
+      content = await fs.readFile(gitIgnorePath, 'utf-8');
+    }
+    
+    const lines = content.split('\n').map(l => l.trim());
+    const newLines = [];
+    let added = false;
+
+    for (const item of toIgnore) {
+      if (!lines.includes(item)) {
+        newLines.push(item);
+        added = true;
+      }
+    }
+
+    if (added) {
+      const newContent = content + (content && !content.endsWith('\n') ? '\n' : '') + newLines.join('\n') + '\n';
+      await fs.writeFile(gitIgnorePath, newContent);
+      logger.success('Updated .gitignore');
+    }
+  } catch (error) {
+    logger.warn(`Could not update .gitignore: ${error.message}`);
+  }
+}
+
 /**
  * Initialize Autopilot in current repository
  */
@@ -76,6 +112,7 @@ async function initRepo() {
     // Create files
     await createIgnoreFile(repoPath);
     await createConfigFile(repoPath);
+    await updateGitIgnore(repoPath);
 
     logger.section('✨ Initialization Complete');
     logger.info('Next steps:');

package/src/config/defaults.js

@@ -22,6 +22,8 @@ const DEFAULT_IGNORE_PATTERNS = [
   '.env.*',
   'coverage/',
   '*.log',
+  'autopilot.log',
+  '.autopilot.pid',
   '.DS_Store',
   '.git/',
   '.idea/',

package/src/config/ignore.js

@@ -1,37 +1,136 @@
-const fs = require('fs-extra');
-const path = require('path');
-const logger = require('../utils/logger');
-
-const readIgnoreFile = async (repoPath) => {
-  const ignorePath = path.join(repoPath, '.autopilot-ignore');
-  try {
-    if (await fs.pathExists(ignorePath)) {
-      const content = await fs.readFile(ignorePath, 'utf-8');
-      return content
-        .split('\n')
-        .map((line) => line.trim())
-        .filter((line) => line && !line.startsWith('#'));
-    }
-  } catch (error) {
-    logger.debug(`Error reading ignore file: ${error.message}`);
-  }
-  return [];
-};
-
-const createIgnoreFile = async (repoPath, patterns = []) => {
-  const ignorePath = path.join(repoPath, '.autopilot-ignore');
-  try {
-    const content =
-      `# Autopilot Ignore File\n# Add patterns to exclude from autopilot watching\n\n` +
-      patterns.join('\n');
-    await fs.writeFile(ignorePath, content);
-    logger.success('Created .autopilot-ignore file');
-  } catch (error) {
-    logger.error(`Failed to create ignore file: ${error.message}`);
-  }
-};
-
-module.exports = {
-  readIgnoreFile,
-  createIgnoreFile,
-};
+const fs = require('fs-extra');
+const path = require('path');
+const logger = require('../utils/logger');
+const { getIgnorePath } = require('../utils/paths');
+
+/**
+ * Standardize path to use forward slashes
+ * @param {string} p - Path to normalize
+ * @returns {string} Normalized path
+ */
+const normalizePath = (p) => p.split(path.sep).join('/');
+
+/**
+ * Read ignore file patterns
+ * @param {string} repoPath 
+ * @returns {Promise<string[]>} Array of ignore patterns
+ */
+const readIgnoreFile = async (repoPath) => {
+  const ignorePath = getIgnorePath(repoPath);
+  try {
+    if (await fs.pathExists(ignorePath)) {
+      const content = await fs.readFile(ignorePath, 'utf-8');
+      return content
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('#'));
+    }
+  } catch (error) {
+    logger.debug(`Error reading ignore file: ${error.message}`);
+  }
+  return [];
+};
+
+/**
+ * Create ignore file
+ */
+const createIgnoreFile = async (repoPath, patterns = []) => {
+  const ignorePath = getIgnorePath(repoPath);
+  try {
+    const content =
+      `# Autopilot Ignore File\n# Add patterns to exclude from autopilot watching\n\n` +
+      patterns.join('\n');
+    await fs.writeFile(ignorePath, content);
+    logger.success('Created .autopilotignore file');
+  } catch (error) {
+    logger.error(`Failed to create ignore file: ${error.message}`);
+  }
+};
+
+/**
+ * Create a filter function for Chokidar
+ * @param {string} repoPath - Root of the repository
+ * @param {string[]} userPatterns - Custom ignore patterns
+ * @returns {function} Filter function (path => boolean)
+ */
+const createIgnoredFilter = (repoPath, userPatterns = []) => {
+  const normalizedRepoPath = normalizePath(repoPath);
+
+  // Always ignore these critical paths to prevent loops and noise
+  const criticalIgnores = [
+    '.git',
+    'node_modules',
+    '.vscode',
+    '.idea',
+    'dist',
+    'build',
+    'coverage',
+    '.next'
+  ];
+
+  const criticalFiles = [
+    'autopilot.log',
+    '.autopilot.pid',
+    '.DS_Store'
+  ];
+
+  return (absolutePath) => {
+    // 1. Normalize paths
+    const normalizedAbs = normalizePath(absolutePath);
+    
+    // 2. Get relative path
+    let relativePath = normalizedAbs;
+    if (normalizedAbs.startsWith(normalizedRepoPath)) {
+      relativePath = normalizedAbs.slice(normalizedRepoPath.length);
+      if (relativePath.startsWith('/')) {
+        relativePath = relativePath.slice(1);
+      }
+    }
+
+    // Handle root path case
+    if (!relativePath) return false;
+
+    // 3. Check critical directory prefixes
+    // We check if any path segment matches a critical ignore
+    const parts = relativePath.split('/');
+    for (const part of parts) {
+      if (criticalIgnores.includes(part)) return true;
+    }
+
+    // 4. Check file extensions and exact matches
+    if (relativePath.endsWith('.log')) return true;
+    if (criticalFiles.some(f => relativePath.endsWith(f))) return true;
+
+    // 5. Check user patterns (simple prefix/suffix matching for now)
+    // For robust glob support without adding dependencies, we rely on basic checks
+    // Most users use simple dir/ or *.ext patterns
+    for (const pattern of userPatterns) {
+      // Remove leading/trailing slashes for comparison
+      const cleanPattern = pattern.replace(/^\/+|\/+$/g, '');
+      
+      // Directory match (e.g., "temp/")
+      if (pattern.endsWith('/') && (relativePath === cleanPattern || relativePath.startsWith(cleanPattern + '/'))) {
+        return true;
+      }
+      
+      // Extension match (e.g., "*.tmp")
+      if (pattern.startsWith('*.') && relativePath.endsWith(pattern.slice(1))) {
+        return true;
+      }
+
+      // Exact match
+      if (relativePath === cleanPattern) {
+        return true;
+      }
+    }
+
+    return false;
+  };
+};
+
+module.exports = {
+  readIgnoreFile,
+  createIgnoreFile,
+  createIgnoredFilter,
+  normalizePath
+};

package/src/core/watcher.js

@@ -6,13 +6,12 @@
 const fs = require('fs-extra');
 const path = require('path');
 const chokidar = require('chokidar');
-const { execa } = require('execa');
 const logger = require('../utils/logger');
 const git = require('./git');
 const { generateCommitMessage } = require('./commit');
-const { getIgnorePath } = require('../utils/paths');
 const { savePid, removePid, registerProcessHandlers } = require('../utils/process');
 const { loadConfig } = require('../config/loader');
+const { readIgnoreFile, createIgnoredFilter, normalizePath } = require('../config/ignore');
 
 class Watcher {
   constructor(repoPath) {
@@ -27,6 +26,23 @@ class Watcher {
     this.ignorePatterns = [];
   }
 
+  logVerbose(message) {
+    // Helper to log debug messages to file/stdout if needed
+    // For now, we use logger.debug which writes to stdout if DEBUG is set
+    // We also want to ensure we don't create a loop by logging to the file we watch
+    // But since we ignore autopilot.log, it should be fine.
+    logger.debug(message);
+    // TODO: Append to log file if configured
+  }
+
+  async reloadConfig() {
+    this.config = await loadConfig(this.repoPath);
+  }
+
+  async reloadIgnore() {
+    this.ignorePatterns = await readIgnoreFile(this.repoPath);
+  }
+
   /**
    * Initialize and start the watcher
    */
@@ -41,7 +57,7 @@ class Watcher {
       await fs.ensureFile(this.logFilePath);
       await savePid(this.repoPath);
       
-      this.logVerbose('Starting Autopilot watcher...');
+      logger.info('Starting Autopilot watcher...');
       
       // Load configuration
       await this.reloadConfig();
@@ -51,23 +67,16 @@ class Watcher {
       const currentBranch = await git.getBranch(this.repoPath);
       if (currentBranch && this.config.blockedBranches?.includes(currentBranch)) {
         logger.error(`Branch '${currentBranch}' is blocked in config. Stopping.`);
-        this.logVerbose(`Blocked branch detected: ${currentBranch}`);
         await this.stop();
         return;
       }
 
-      // Combine defaults + loaded patterns
-      const finalIgnored = [
-        ...this.ignorePatterns,
-        /(^|[\/\\])\.git([\/\\]|$)/, // Regex for .git folder
-        '**/autopilot.log',
-        '**/.autopilot.pid',
-        'node_modules' // Sensible default
-      ];
+      // Create robust ignore filter
+      const ignoredFilter = createIgnoredFilter(this.repoPath, this.ignorePatterns);
 
-      // Start Chokidar
+      // Start Chokidar with function-based ignore
       this.watcher = chokidar.watch(this.repoPath, {
-        ignored: finalIgnored,
+        ignored: ignoredFilter,
         ignoreInitial: true,
         persistent: true,
         awaitWriteFinish: {
@@ -93,17 +102,16 @@ class Watcher {
       
       // Test Mode Support
       if (process.env.AUTOPILOT_TEST_MODE) {
-        logger.warn('TEST MODE: Running in dry-run mode for 3 seconds...');
+        logger.warn('TEST MODE: Running in dry-run mode for 8 seconds...');
         setTimeout(async () => {
           logger.info('TEST MODE: Auto-stopping watcher...');
           await this.stop();
           process.exit(0);
-        }, 3000);
+        }, 8000);
       }
       
     } catch (error) {
       logger.error(`Failed to start watcher: ${error.message}`);
-      this.logVerbose(`Start error: ${error.stack}`);
       await this.stop();
     }
   }
@@ -137,10 +145,15 @@ class Watcher {
   onFsEvent(type, filePath) {
     if (this.isProcessing) return;
     
-    // Double check ignore (safety net)
-    if (filePath.includes('.git') || filePath.endsWith('autopilot.log')) return;
+    // Normalize path relative to repo for logging and checks
+    const relativePath = normalizePath(path.relative(this.repoPath, filePath));
+    
+    // Double check ignore (safety net) - although chokidar should catch most
+    if (relativePath.includes('.git/') || relativePath.endsWith('autopilot.log') || relativePath.includes('.vscode/')) {
+        return;
+    }
 
-    this.logVerbose(`File event: ${type} ${filePath}`);
+    this.logVerbose(`File event: ${type} ${relativePath}`);
     this.scheduleProcess();
   }
 
@@ -154,11 +167,22 @@ class Watcher {
       clearTimeout(this.debounceTimer);
     }
 
+    logger.debug('Debounce fired. Waiting...');
+    
     this.debounceTimer = setTimeout(() => {
       this.processChanges();
     }, debounceMs);
   }
 
+  handleError(error) {
+    logger.error(`Watcher error: ${error.message}`);
+  }
+
+  async runChecks() {
+    // Placeholder for custom checks
+    return true;
+  }
+
   /**
    * Main processing loop
    */
@@ -167,153 +191,84 @@ class Watcher {
     this.isProcessing = true;
 
     try {
+      logger.debug('Checking git status...');
+
       // 1. Min interval check
       const now = Date.now();
-      const minInterval = (this.config?.minIntervalSeconds || 30) * 1000;
-      if (now - this.lastCommitAt < minInterval) {
-        this.logVerbose('Skipping: Minimum interval not met');
+      const minInterval = (this.config?.minSecondsBetweenCommits || 180) * 1000;
+      if (this.lastCommitAt > 0 && now - this.lastCommitAt < minInterval) {
+        logger.debug(`Skip commit: Minimum interval not met (${Math.round((minInterval - (now - this.lastCommitAt))/1000)}s remaining)`);
+        return;
+      }
+
+      // 2. Check if dirty
+      const statusObj = await git.getPorcelainStatus(this.repoPath);
+      const isDirty = statusObj.ok && statusObj.files.length > 0;
+      logger.debug(`Git dirty: ${isDirty}`);
+
+      if (!isDirty) {
         return;
       }
 
-      // 2. Safety: Branch check
+      // 3. Safety: Branch check
       const branch = await git.getBranch(this.repoPath);
       if (this.config?.blockedBranches?.includes(branch)) {
-        logger.warn(`Current branch '${branch}' is blocked. Skipping.`);
+        logger.warn(`Skip commit: Branch '${branch}' is blocked`);
         return;
       }
 
-      // 3. Safety: Remote check (fetch -> behind?)
-      this.logVerbose('Checking remote status...');
-      const remoteStatus = await git.isRemoteAhead(this.repoPath);
-      if (remoteStatus.behind) {
-        logger.warn('Local branch is behind remote. Please pull changes.');
-        this.logVerbose('Behind remote. Pausing auto-commit.');
-        return;
+      // 4. Safety: Remote check (fetch -> behind?)
+      logger.debug('Checking remote status...');
+      // Note: isRemoteAhead might need network, timeout safely?
+      try {
+          const remoteStatus = await git.isRemoteAhead(this.repoPath);
+          if (remoteStatus.behind) {
+            logger.warn('Skip commit: Local branch is behind remote. Please pull changes.');
+            return;
+          }
+      } catch (e) {
+          logger.debug(`Remote check failed (offline?): ${e.message}`);
       }
 
-      // 4. Safety: Custom checks
+      // 5. Safety: Custom checks
       if (this.config?.requireChecks) {
         const checksPassed = await this.runChecks();
         if (!checksPassed) {
-          logger.warn('Checks failed. Skipping commit.');
+          logger.warn('Skip commit: Checks failed');
           return;
         }
       }
 
-      // 5. Flow: Status -> Add -> Commit -> Push
-      const status = await git.getPorcelainStatus(this.repoPath);
-      if (!status.ok || status.files.length === 0) {
-        this.logVerbose('No changes to commit');
-        return;
-      }
-
-      this.logVerbose(`Detecting ${status.files.length} changed files`);
+      // 6. Commit
+      logger.info('Committing changes...');
       
-      // Add all
+      // Add all changes
       await git.addAll(this.repoPath);
       
       // Generate message
-      const message = generateCommitMessage(status.files);
-      this.logVerbose(`Generated message: ${message}`);
-      
-      // Commit
-      const commitResult = await git.commit(this.repoPath, message);
-      if (commitResult.ok) {
-        logger.success(`Committed: ${message}`);
-        this.lastCommitAt = Date.now();
-
-        // Push if enabled
-        if (this.config?.autoPush) {
-          logger.info('Pushing to remote...');
-          const pushResult = await git.push(this.repoPath, branch);
-          if (pushResult.ok) {
-            logger.success('Pushed successfully');
-          } else {
-            logger.error(`Push failed: ${pushResult.stderr}`);
-            this.logVerbose(`Push error: ${pushResult.stderr}`);
-          }
-        }
-      } else {
-        logger.error(`Commit failed: ${commitResult.stderr}`);
-        this.logVerbose(`Commit error: ${commitResult.stderr}`);
+      const changedFiles = statusObj.files;
+      const message = this.config?.commitMessageMode === 'simple' 
+        ? 'chore: auto-commit changes'
+        : generateCommitMessage(changedFiles);
+
+      await git.commit(this.repoPath, message);
+      this.lastCommitAt = Date.now();
+      logger.success('Commit done');
+
+      // 7. Auto-push
+      if (this.config?.autoPush) {
+        logger.info('Pushing to remote...');
+        await git.push(this.repoPath);
+        logger.success('Push complete');
       }
 
     } catch (error) {
       logger.error(`Process error: ${error.message}`);
-      this.logVerbose(`Process exception: ${error.stack}`);
     } finally {
       this.isProcessing = false;
       this.debounceTimer = null;
     }
   }
-
-  /**
-   * Run user-defined checks
-   */
-  async runChecks() {
-    const checks = this.config?.checks || [];
-    if (checks.length === 0) return true;
-
-    this.logVerbose(`Running checks: ${checks.join(', ')}`);
-
-    for (const cmd of checks) {
-      try {
-        logger.info(`Running check: ${cmd}`);
-        await execa(cmd, { cwd: this.repoPath, shell: true });
-      } catch (error) {
-        logger.error(`Check failed: ${cmd}`);
-        this.logVerbose(`Check output: ${error.message}`);
-        return false;
-      }
-    }
-    return true;
-  }
-
-  /**
-   * Reload configuration
-   */
-  async reloadConfig() {
-    this.config = await loadConfig(this.repoPath);
-    this.logVerbose('Config reloaded');
-  }
-
-  /**
-   * Reload ignore patterns
-   */
-  async reloadIgnore() {
-    const ignorePath = getIgnorePath(this.repoPath);
-    this.ignorePatterns = []; 
-    
-    if (await fs.pathExists(ignorePath)) {
-      try {
-        const content = await fs.readFile(ignorePath, 'utf-8');
-        const lines = content.split('\n')
-          .map(l => l.trim())
-          .filter(l => l && !l.startsWith('#'));
-        
-        this.ignorePatterns.push(...lines);
-        this.logVerbose(`Loaded ${lines.length} ignore patterns`);
-      } catch (error) {
-        logger.warn(`Failed to load ignore file: ${error.message}`);
-      }
-    }
-    
-    // Also load ignore patterns from config json if they exist
-    if (this.config?.ignore && Array.isArray(this.config.ignore)) {
-       this.ignorePatterns.push(...this.config.ignore);
-    }
-  }
-
-  handleError(error) {
-    logger.error(`Watcher error: ${error.message}`);
-    this.logVerbose(`Watcher error: ${error.stack}`);
-  }
-
-  logVerbose(message) {
-    const timestamp = new Date().toISOString();
-    const logLine = `[${timestamp}] ${message}\n`;
-    fs.appendFile(this.logFilePath, logLine).catch(() => {});
-  }
 }
 
 module.exports = Watcher;