@traisetech/autopilot 0.1.3 → 0.1.6

package/CHANGELOG.md

@@ -15,3 +15,53 @@
 - Per-repo config and ignore rules
 
 Built by Praise Masunga (PraiseTechzw).
+# Changelog
+
+All notable changes to this project will be documented in this file.
+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.
+- Additional configuration and commit logic unit tests.
+
+### Changed
+- Standardized command exports across all CLI commands.
+- Improved error messages for misconfigured or invalid commands.
+- Strengthened release hygiene and stability guarantees.
+
+### Developer Experience
+- Added `prepublishOnly` guard to prevent accidental publishing of failing builds.
+- Improved Windows compatibility during testing and CLI execution.
+
+---
+
+## [0.1.3] – 2026-01-31
+
+### Added
+- Initial public release of Autopilot CLI.
+- Intelligent Git automation with smart commit messages.
+- Background watcher with debouncing and safety rails.
+- Branch protection and remote-ahead detection.
+- `doctor` command for environment diagnostics.
+- Per-project configuration via `.autopilotrc.json`.
+
+---
+
+## [0.1.0] – Initial Development
+- Core architecture and foundational CLI commands.

package/README.md

@@ -1,210 +1,2 @@
-# 🚀 Autopilot CLI
 
-<div align="center">
-
-![Autopilot Logo](https://img.shields.io/badge/Autopilot-CLI-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/autopilot-cli?style=flat-square&color=success)](https://www.npmjs.com/package/autopilot-cli)
-[![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/autopilot-cli?style=flat-square&color=blue)](https://www.npmjs.com/package/autopilot-cli)
-[![GitHub Stars](https://img.shields.io/github/stars/PraiseTechzw/autopilot-cli?style=flat-square&color=gold)](https://github.com/PraiseTechzw/autopilot-cli/stargazers)
-[![Build Status](https://img.shields.io/github/actions/workflow/status/PraiseTechzw/autopilot-cli/ci.yml?style=flat-square)](https://github.com/PraiseTechzw/autopilot-cli/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) • [Quick Start](#-quick-start) • [Configuration](#-configuration) • [Commands](#-commands) • [Safety](#-safety-features)
-
-</div>
-
----
-
-## 📖 Table of Contents
-
-- [Why Autopilot?](#-why-autopilot)
-- [Features](#-features)
-- [Quick Start](#-quick-start)
-- [Installation](#-installation)
-- [Commands](#-commands)
-- [Configuration](#-configuration)
-- [Safety Features](#-safety-features)
-- [Troubleshooting](#-troubleshooting)
-- [Contributing](#-contributing)
-- [License](#-license)
-
----
-
-## 🎯 Why Autopilot?
-
-<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.
-
----
-
-## 🚀 Quick Start
-
-### Installation
-
-```bash
-# Install globally via npm
-npm install -g autopilot-cli
-```
-
-### Usage
-
-```bash
-# 1. Initialize in your project
-cd my-project
-autopilot init
-
-# 2. Start the background watcher
-autopilot start
-
-# 3. Check status
-autopilot status
-
-# 4. Stop when done
-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.
-
-```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 with ❤️ by <a href="https://github.com/PraiseTechzw">Praise Masunga (PraiseTechzw)</a></b>
-</div>
+<!-- Autopilot test run: 2026-02-01 -->

package/bin/autopilot.js

@@ -1,12 +1,32 @@
 #!/usr/bin/env node
 
 const { Command } = require('commander');
-const { initRepo } = require('../src/commands/init');
-const { startWatcher } = require('../src/commands/start');
-const { stopWatcher } = require('../src/commands/stop');
-const { statusWatcher } = require('../src/commands/status');
-const { doctor } = require('../src/commands/doctor');
+const initRepo = require('../src/commands/init');
+const startWatcher = require('../src/commands/start');
+const stopWatcher = require('../src/commands/stop');
+const statusWatcher = require('../src/commands/status');
+const doctor = require('../src/commands/doctor');
 const pkg = require('../package.json');
+const logger = require('../src/utils/logger');
+
+// Validate command handlers
+const commands = {
+  init: initRepo,
+  start: startWatcher,
+  stop: stopWatcher,
+  status: statusWatcher,
+  doctor: doctor
+};
+
+// Runtime assertion to prevent wiring errors
+Object.entries(commands).forEach(([name, handler]) => {
+  if (typeof handler !== 'function') {
+    console.error(`\n❌ FATAL ERROR: Command handler for '${name}' is not a function.`);
+    console.error(`Received: ${typeof handler}`);
+    console.error('Please report this issue to the maintainer.\n');
+    process.exit(1);
+  }
+});
 
 const program = new Command();
 

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.3",
+  "version": "0.1.6",
   "publishConfig": {
     "access": "public"
   },
@@ -32,12 +32,11 @@
   "main": "src/index.js",
   "scripts": {
     "dev": "node bin/autopilot.js",
-    "lint": "echo \"No lint configured\"",
     "test": "node --test",
-    "verify": "node bin/autopilot.js doctor",
-    "release:patch": "npm test && echo \"⚠️  Ensure CHANGELOG.md is updated\" && npm version patch && git push --follow-tags",
-    "release:minor": "npm test && echo \"⚠️  Ensure CHANGELOG.md is updated\" && npm version minor && git push --follow-tags",
-    "release:major": "npm test && echo \"⚠️  Ensure CHANGELOG.md is updated\" && npm version major && git push --follow-tags"
+    "lint": "node -c bin/autopilot.js && node -c src/index.js",
+    "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\""
   },
   "engines": {
     "node": ">=18.0.0"

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:');
@@ -89,4 +126,4 @@ async function initRepo() {
   }
 }
 
-module.exports = { initRepo };
+module.exports = initRepo;

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/config/loader.js

@@ -1,47 +1,47 @@
-const fs = require('fs-extra');
-const path = require('path');
-const logger = require('../utils/logger');
-const defaults = require('./defaults');
-const { getConfigPath } = require('../utils/paths');
-
-const loadConfig = async (repoPath) => {
-  const configPath = getConfigPath(repoPath);
-  try {
-    if (await fs.pathExists(configPath)) {
-      const config = await fs.readJson(configPath);
-      logger.debug(`Loaded config from ${configPath}`);
-      return { ...defaults, ...config };
-    }
-  } catch (error) {
-    logger.warn(`Error loading config: ${error.message}`);
-  }
-  return defaults;
-};
-
-const saveConfig = async (repoPath, config) => {
-  const configPath = getConfigPath(repoPath);
-  try {
-    await fs.writeJson(configPath, config, { spaces: 2 });
-    logger.success(`Config saved to ${configPath}`);
-  } catch (error) {
-    logger.error(`Failed to save config: ${error.message}`);
-  }
-};
-
-const createDefaultConfig = async (repoPath) => {
-  const configPath = getConfigPath(repoPath);
-  try {
-    if (!(await fs.pathExists(configPath))) {
-      await fs.writeJson(configPath, defaults, { spaces: 2 });
-      logger.success(`Created default config at ${configPath}`);
-    }
-  } catch (error) {
-    logger.error(`Failed to create config: ${error.message}`);
-  }
-};
-
-module.exports = {
-  loadConfig,
-  saveConfig,
-  createDefaultConfig,
-};
+const fs = require('fs-extra');
+const path = require('path');
+const logger = require('../utils/logger');
+const { DEFAULT_CONFIG } = require('./defaults');
+const { getConfigPath } = require('../utils/paths');
+
+const loadConfig = async (repoPath) => {
+  const configPath = getConfigPath(repoPath);
+  try {
+    if (await fs.pathExists(configPath)) {
+      const config = await fs.readJson(configPath);
+      logger.debug(`Loaded config from ${configPath}`);
+      return { ...DEFAULT_CONFIG, ...config };
+    }
+  } catch (error) {
+    logger.warn(`Error loading config: ${error.message}`);
+  }
+  return { ...DEFAULT_CONFIG };
+};
+
+const saveConfig = async (repoPath, config) => {
+  const configPath = getConfigPath(repoPath);
+  try {
+    await fs.writeJson(configPath, config, { spaces: 2 });
+    logger.success(`Config saved to ${configPath}`);
+  } catch (error) {
+    logger.error(`Failed to save config: ${error.message}`);
+  }
+};
+
+const createDefaultConfig = async (repoPath) => {
+  const configPath = getConfigPath(repoPath);
+  try {
+    if (!(await fs.pathExists(configPath))) {
+      await fs.writeJson(configPath, DEFAULT_CONFIG, { spaces: 2 });
+      logger.success(`Created default config at ${configPath}`);
+    }
+  } catch (error) {
+    logger.error(`Failed to create config: ${error.message}`);
+  }
+};
+
+module.exports = {
+  loadConfig,
+  saveConfig,
+  createDefaultConfig,
+};

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: {
@@ -91,9 +100,18 @@ class Watcher {
       logger.success(`Autopilot is watching ${this.repoPath}`);
       logger.info(`Logs: ${this.logFilePath}`);
       
+      // Test Mode Support
+      if (process.env.AUTOPILOT_TEST_MODE) {
+        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);
+        }, 8000);
+      }
+      
     } catch (error) {
       logger.error(`Failed to start watcher: ${error.message}`);
-      this.logVerbose(`Start error: ${error.stack}`);
       await this.stop();
     }
   }
@@ -127,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();
   }
 
@@ -144,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
    */
@@ -157,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;

package/src/utils/logger.js

@@ -12,6 +12,16 @@ const logger = {
     console.log(`ℹ️  ${message}`);
   },
 
+  /**
+   * Log debug message (only visible if DEBUG env var is set)
+   * @param {string} message - Message to log
+   */
+  debug: (message) => {
+    if (process.env.DEBUG) {
+      console.log(`🔍 ${message}`);
+    }
+  },
+
   /**
    * Log success message
    * @param {string} message - Message to log