@traisetech/autopilot 0.1.3

package/src/core/git.js

@@ -0,0 +1,154 @@
+/**
+ * Git helper module - Clean, testable Git operations
+ * Built by Praise Masunga (PraiseTechzw)
+ */
+
+const { execa } = require('execa');
+
+/**
+ * Get current branch name
+ * @param {string} root - Repository root path
+ * @returns {Promise<string|null>} Branch name or null on error
+ */
+async function getBranch(root) {
+  try {
+    const { stdout } = await execa('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: root });
+    return stdout.trim();
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Check if repository has uncommitted changes
+ * @param {string} root - Repository root path
+ * @returns {Promise<boolean>} True if there are changes
+ */
+async function hasChanges(root) {
+  try {
+    const { stdout } = await execa('git', ['status', '--porcelain'], { cwd: root });
+    return stdout.trim().length > 0;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Get porcelain status - parsed list of changed files
+ * @param {string} root - Repository root path
+ * @returns {Promise<{ok: boolean, files: string[], raw: string}>} Status object
+ */
+async function getPorcelainStatus(root) {
+  try {
+    const { stdout } = await execa('git', ['status', '--porcelain'], { cwd: root });
+    const raw = stdout.trim();
+    
+    if (!raw) {
+      return { ok: true, files: [], raw: '' };
+    }
+
+    const files = raw
+      .split(/\r?\n/)
+      .map(line => line.slice(3).trim()); // Remove status prefix (XY + space)
+
+    return { ok: true, files, raw };
+  } catch (error) {
+    return { ok: false, files: [], raw: error.message };
+  }
+}
+
+/**
+ * Stage all changes (git add -A)
+ * @param {string} root - Repository root path
+ * @returns {Promise<{ok: boolean, stdout: string, stderr: string}>} Result object
+ */
+async function addAll(root) {
+  try {
+    const { stdout, stderr } = await execa('git', ['add', '-A'], { cwd: root });
+    return { ok: true, stdout, stderr };
+  } catch (error) {
+    return { ok: false, stdout: '', stderr: error.message };
+  }
+}
+
+/**
+ * Commit staged changes
+ * @param {string} root - Repository root path
+ * @param {string} message - Commit message
+ * @returns {Promise<{ok: boolean, stdout: string, stderr: string}>} Result object
+ */
+async function commit(root, message) {
+  try {
+    const { stdout, stderr } = await execa('git', ['commit', '-m', message], { cwd: root });
+    return { ok: true, stdout, stderr };
+  } catch (error) {
+    return { ok: false, stdout: '', stderr: error.message };
+  }
+}
+
+/**
+ * Fetch updates from remote
+ * @param {string} root - Repository root path
+ * @returns {Promise<{ok: boolean, stdout: string, stderr: string}>} Result object
+ */
+async function fetch(root) {
+  try {
+    const { stdout, stderr } = await execa('git', ['fetch'], { cwd: root });
+    return { ok: true, stdout, stderr };
+  } catch (error) {
+    return { ok: false, stdout: '', stderr: error.message };
+  }
+}
+
+/**
+ * Check if remote is ahead/behind
+ * @param {string} root - Repository root path
+ * @returns {Promise<{ok: boolean, ahead: boolean, behind: boolean, raw: string}>} Status object
+ */
+async function isRemoteAhead(root) {
+  try {
+    const branch = await getBranch(root);
+    if (!branch) return { ok: false, ahead: false, behind: false, raw: 'No branch' };
+
+    // Ensure we have latest info
+    await fetch(root);
+
+    const { stdout } = await execa('git', ['rev-list', '--left-right', '--count', `${branch}...origin/${branch}`], { cwd: root });
+    const [aheadCount, behindCount] = stdout.trim().split(/\s+/).map(Number);
+    
+    return {
+      ok: true,
+      ahead: aheadCount > 0,
+      behind: behindCount > 0,
+      raw: stdout.trim()
+    };
+  } catch (error) {
+    return { ok: false, ahead: false, behind: false, raw: error.message };
+  }
+}
+
+/**
+ * Push changes to remote
+ * @param {string} root - Repository root path
+ * @param {string} branch - Branch to push
+ * @returns {Promise<{ok: boolean, stdout: string, stderr: string}>} Result object
+ */
+async function push(root, branch) {
+  try {
+    const { stdout, stderr } = await execa('git', ['push', 'origin', branch], { cwd: root });
+    return { ok: true, stdout, stderr };
+  } catch (error) {
+    return { ok: false, stdout: '', stderr: error.message };
+  }
+}
+
+module.exports = {
+  getBranch,
+  hasChanges,
+  getPorcelainStatus,
+  addAll,
+  commit,
+  fetch,
+  isRemoteAhead,
+  push,
+};

package/src/core/safety.js

@@ -0,0 +1,38 @@
+const logger = require('../utils/logger');
+
+const validateConfig = (config) => {
+  const errors = [];
+
+  if (!config) {
+    errors.push('Configuration is missing');
+    return errors;
+  }
+
+  if (config.commitMessage && typeof config.commitMessage !== 'string') {
+    errors.push('commitMessage must be a string');
+  }
+
+  if (config.autoPush && typeof config.autoPush !== 'boolean') {
+    errors.push('autoPush must be a boolean');
+  }
+
+  if (config.ignore && !Array.isArray(config.ignore)) {
+    errors.push('ignore must be an array');
+  }
+
+  return errors;
+};
+
+const validateBeforeCommit = async (repoPath) => {
+  const errors = [];
+
+  // Add safety checks before committing
+  // For example, check for large files, sensitive files, etc.
+
+  return errors;
+};
+
+module.exports = {
+  validateConfig,
+  validateBeforeCommit,
+};

package/src/core/watcher.js

@@ -0,0 +1,309 @@
+/**
+ * Autopilot Watcher Engine
+ * Built by Praise Masunga (PraiseTechzw)
+ */
+
+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');
+
+class Watcher {
+  constructor(repoPath) {
+    this.repoPath = repoPath;
+    this.config = null;
+    this.watcher = null;
+    this.isWatching = false;
+    this.isProcessing = false;
+    this.debounceTimer = null;
+    this.lastCommitAt = 0;
+    this.logFilePath = path.join(repoPath, 'autopilot.log');
+    this.ignorePatterns = [];
+  }
+
+  /**
+   * Initialize and start the watcher
+   */
+  async start() {
+    try {
+      if (this.isWatching) {
+        logger.warn('Watcher is already running');
+        return;
+      }
+
+      // Initialize environment
+      await fs.ensureFile(this.logFilePath);
+      await savePid(this.repoPath);
+      
+      this.logVerbose('Starting Autopilot watcher...');
+      
+      // Load configuration
+      await this.reloadConfig();
+      await this.reloadIgnore();
+
+      // Initial safety check
+      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
+      ];
+
+      // Start Chokidar
+      this.watcher = chokidar.watch(this.repoPath, {
+        ignored: finalIgnored,
+        ignoreInitial: true,
+        persistent: true,
+        awaitWriteFinish: {
+          stabilityThreshold: 1000,
+          pollInterval: 100,
+        }
+      });
+
+      this.watcher
+        .on('add', (path) => this.onFsEvent('add', path))
+        .on('change', (path) => this.onFsEvent('change', path))
+        .on('unlink', (path) => this.onFsEvent('unlink', path))
+        .on('error', (error) => this.handleError(error));
+
+      // Handle process signals
+      registerProcessHandlers(async () => {
+        await this.stop();
+      });
+
+      this.isWatching = true;
+      logger.success(`Autopilot is watching ${this.repoPath}`);
+      logger.info(`Logs: ${this.logFilePath}`);
+      
+    } catch (error) {
+      logger.error(`Failed to start watcher: ${error.message}`);
+      this.logVerbose(`Start error: ${error.stack}`);
+      await this.stop();
+    }
+  }
+
+  /**
+   * Stop the watcher
+   */
+  async stop() {
+    try {
+      if (this.debounceTimer) {
+        clearTimeout(this.debounceTimer);
+        this.debounceTimer = null;
+      }
+
+      if (this.watcher) {
+        await this.watcher.close();
+        this.watcher = null;
+      }
+
+      await removePid(this.repoPath);
+      this.isWatching = false;
+      logger.info('Watcher stopped');
+    } catch (error) {
+      logger.error(`Error stopping watcher: ${error.message}`);
+    }
+  }
+
+  /**
+   * Handle filesystem events
+   */
+  onFsEvent(type, filePath) {
+    if (this.isProcessing) return;
+    
+    // Double check ignore (safety net)
+    if (filePath.includes('.git') || filePath.endsWith('autopilot.log')) return;
+
+    this.logVerbose(`File event: ${type} ${filePath}`);
+    this.scheduleProcess();
+  }
+
+  /**
+   * Schedule processing with debounce
+   */
+  scheduleProcess() {
+    const debounceMs = (this.config?.debounceSeconds || 5) * 1000;
+    
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+
+    this.debounceTimer = setTimeout(() => {
+      this.processChanges();
+    }, debounceMs);
+  }
+
+  /**
+   * Main processing loop
+   */
+  async processChanges() {
+    if (this.isProcessing) return;
+    this.isProcessing = true;
+
+    try {
+      // 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');
+        return;
+      }
+
+      // 2. Safety: Branch check
+      const branch = await git.getBranch(this.repoPath);
+      if (this.config?.blockedBranches?.includes(branch)) {
+        logger.warn(`Current branch '${branch}' is blocked. Skipping.`);
+        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: Custom checks
+      if (this.config?.requireChecks) {
+        const checksPassed = await this.runChecks();
+        if (!checksPassed) {
+          logger.warn('Checks failed. Skipping commit.');
+          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`);
+      
+      // Add all
+      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}`);
+      }
+
+    } 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/index.js

@@ -0,0 +1,50 @@
+const { Command } = require('commander');
+const { initRepo } = require('./commands/init');
+const { startWatcher } = require('./commands/start');
+const { stopWatcher } = require('./commands/stop');
+const { statusWatcher } = require('./commands/status');
+const { doctor } = require('./commands/doctor');
+const pkg = require('../package.json');
+
+function run() {
+  const program = new Command();
+
+  program
+    .name('autopilot')
+    .description('Git automation with safety rails')
+    .version(pkg.version, '-v, --version', 'Show version');
+
+  program
+    .command('init')
+    .description('Initialize autopilot configuration in repository')
+    .action(initRepo);
+
+  program
+    .command('start')
+    .description('Start autopilot watcher in foreground')
+    .action(startWatcher);
+
+  program
+    .command('stop')
+    .description('Stop the running autopilot watcher')
+    .action(stopWatcher);
+
+  program
+    .command('status')
+    .description('Show autopilot watcher status')
+    .action(statusWatcher);
+
+  program
+    .command('doctor')
+    .description('Diagnose and validate autopilot setup')
+    .action(doctor);
+
+  program
+    .addHelpText('after', '\nBuilt by Praise Masunga (PraiseTechzw)')
+    .addHelpCommand(true, 'Show help for command')
+    .showHelpAfterError('(add --help for command information)');
+
+  program.parse(process.argv);
+}
+
+module.exports = { run };

package/src/utils/banner.js

@@ -0,0 +1,6 @@
+const pkg = require('../../package.json');
+
+module.exports = () => {
+  console.log(`\n🚀 Autopilot CLI v${pkg.version}`);
+  console.log(`   Built by Praise Masunga (PraiseTechzw)\n`);
+};

package/src/utils/logger.js

@@ -0,0 +1,49 @@
+/**
+ * Simple logger utility for consistent CLI output
+ * Built by Praise Masunga (PraiseTechzw)
+ */
+
+const logger = {
+  /**
+   * Log informational message
+   * @param {string} message - Message to log
+   */
+  info: (message) => {
+    console.log(`ℹ️  ${message}`);
+  },
+
+  /**
+   * Log success message
+   * @param {string} message - Message to log
+   */
+  success: (message) => {
+    console.log(`✅ ${message}`);
+  },
+
+  /**
+   * Log warning message
+   * @param {string} message - Message to log
+   */
+  warn: (message) => {
+    console.warn(`⚠️  ${message}`);
+  },
+
+  /**
+   * Log error message
+   * @param {string} message - Message to log
+   */
+  error: (message) => {
+    console.error(`❌ ${message}`);
+  },
+
+  /**
+   * Log section header
+   * @param {string} title - Section title
+   */
+  section: (title) => {
+    console.log(`\n${title}`);
+    console.log('─'.repeat(50));
+  },
+};
+
+module.exports = logger;

package/src/utils/paths.js

@@ -0,0 +1,59 @@
+/**
+ * Path utilities for Autopilot
+ * Built by Praise Masunga (PraiseTechzw)
+ */
+
+const path = require('path');
+const os = require('os');
+const fs = require('fs-extra');
+
+/**
+ * Get path to config file in repository
+ * @param {string} repoPath - Repository path
+ * @returns {string} Config file path
+ */
+const getConfigPath = (repoPath) => {
+  return path.join(repoPath, '.autopilotrc.json');
+};
+
+/**
+ * Get path to ignore file in repository
+ * @param {string} repoPath - Repository path
+ * @returns {string} Ignore file path
+ */
+const getIgnorePath = (repoPath) => {
+  return path.join(repoPath, '.autopilotignore');
+};
+
+/**
+ * Get path to .git directory
+ * @param {string} repoPath - Repository path
+ * @returns {string} .git directory path
+ */
+const getGitPath = (repoPath) => {
+  return path.join(repoPath, '.git');
+};
+
+/**
+ * Get global config directory
+ * @returns {string} Config directory path
+ */
+const getConfigDir = () => {
+  return path.join(os.homedir(), '.autopilot');
+};
+
+/**
+ * Ensure config directory exists
+ * @returns {Promise<void>}
+ */
+const ensureConfigDir = async () => {
+  await fs.ensureDir(getConfigDir());
+};
+
+module.exports = {
+  getConfigPath,
+  getIgnorePath,
+  getGitPath,
+  getConfigDir,
+  ensureConfigDir,
+};