@traisetech/autopilot 0.1.3

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@traisetech/autopilot",
+  "version": "0.1.3",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bin",
+    "src",
+    "docs",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "description": "An intelligent CLI tool that automatically commits and pushes your code so you can focus on building.",
+  "keywords": [
+    "git",
+    "automation",
+    "autocommit",
+    "autopush",
+    "developer-tools",
+    "cli",
+    "productivity",
+    "git-workflow"
+  ],
+  "author": "Praise Masunga (PraiseTechzw)",
+  "license": "MIT",
+  "type": "commonjs",
+  "bin": {
+    "autopilot": "bin/autopilot.js"
+  },
+  "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"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/PraiseTechzw/autopilot-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/PraiseTechzw/autopilot-cli/issues"
+  },
+  "homepage": "https://github.com/PraiseTechzw/autopilot-cli#readme",
+  "dependencies": {
+    "chokidar": "^5.0.0",
+    "commander": "^14.0.3",
+    "execa": "^9.6.1",
+    "fs-extra": "^11.3.3"
+  }
+}

package/src/commands/doctor.js

@@ -0,0 +1,121 @@
+/**
+ * Command: doctor
+ * Diagnoses potential issues with the repository and environment
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const process = require('process');
+const { execa } = require('execa');
+const logger = require('../utils/logger');
+const git = require('../core/git');
+
+const doctor = async () => {
+  const repoPath = process.cwd();
+  let issues = 0;
+  
+  logger.section('Autopilot Doctor');
+  logger.info('Diagnosing environment...');
+
+  // 1. Check Git installation
+  try {
+    const { stdout } = await execa('git', ['--version']);
+    logger.success(`Git installed: ${stdout.trim()}`);
+  } catch (error) {
+    logger.error('Git is not installed or not in PATH.');
+    issues++;
+  }
+
+  // 2. Check valid repository
+  try {
+    const { stdout } = await execa('git', ['rev-parse', '--is-inside-work-tree'], { cwd: repoPath });
+    if (stdout.trim() === 'true') {
+      logger.success('Valid Git repository detected');
+    } else {
+      logger.error('Not inside a Git repository.');
+      issues++;
+      return; // Stop further checks if not a repo
+    }
+  } catch (error) {
+    logger.error('Not inside a Git repository.');
+    issues++;
+    return;
+  }
+
+  // 3. Check remote origin
+  try {
+    const { stdout } = await execa('git', ['remote', 'get-url', 'origin'], { cwd: repoPath });
+    const remoteUrl = stdout.trim();
+    logger.success(`Remote 'origin' found: ${remoteUrl}`);
+
+    // Check remote type
+    if (remoteUrl.startsWith('http')) {
+      logger.warn('Remote uses HTTPS. Ensure credential helper is configured for non-interactive push.');
+    } else if (remoteUrl.startsWith('git@') || remoteUrl.startsWith('ssh://')) {
+      logger.success('Remote uses SSH (recommended).');
+    } else {
+      logger.info('Remote uses unknown protocol.');
+    }
+  } catch (error) {
+    logger.warn('No remote \'origin\' configured. Auto-push will fail.');
+    issues++;
+  }
+
+  // 4. Check branch name
+  const branch = await git.getBranch(repoPath);
+  if (branch) {
+    logger.info(`Current branch: ${branch}`);
+    if (branch === 'main' || branch === 'master') {
+      logger.warn('You are on the main/master branch. It is recommended to work on feature branches.');
+      issues++;
+    }
+  } else {
+    logger.error('Could not detect current branch.');
+    issues++;
+  }
+
+  // 5. Check .env in .gitignore
+  const envPath = path.join(repoPath, '.env');
+  if (await fs.pathExists(envPath)) {
+    try {
+      // Check if ignored by git
+      await execa('git', ['check-ignore', '.env'], { cwd: repoPath });
+      logger.success('.env is properly ignored.');
+    } catch (error) {
+      // Exit code 1 means not ignored
+      logger.warn('SECURITY WARNING: .env file exists but is NOT ignored by git!');
+      logger.info('Add .env to your .gitignore file immediately.');
+      issues++;
+    }
+  }
+
+  // 6. Check remote status (ahead/behind)
+  try {
+    const remoteStatus = await git.isRemoteAhead(repoPath);
+    if (remoteStatus.ok) {
+      if (remoteStatus.behind) {
+        logger.warn('Your branch is behind remote. You should pull changes before starting autopilot.');
+        issues++;
+      } else if (remoteStatus.ahead) {
+        logger.info('Your branch is ahead of remote. Autopilot will push these changes.');
+      } else {
+        logger.success('Branch is up to date with remote.');
+      }
+    } else {
+       // Could be no upstream configured, which is fine for local-only initially
+       logger.info('Could not check remote status (upstream might not be set).');
+    }
+  } catch (error) {
+    logger.info('Skipping remote status check.');
+  }
+
+  // Summary
+  console.log(''); // newline
+  if (issues === 0) {
+    logger.success('Diagnosis complete. No issues found. You are ready to fly! ✈️');
+  } else {
+    logger.warn(`Diagnosis complete. Found ${issues} potential issue(s).`);
+  }
+};
+
+module.exports = doctor;

package/src/commands/init.js

@@ -0,0 +1,92 @@
+/**
+ * Autopilot init command - Initialize repository configuration
+ * Built by Praise Masunga (PraiseTechzw)
+ */
+
+const fs = require('fs-extra');
+const logger = require('../utils/logger');
+const { getConfigPath, getIgnorePath, getGitPath } = require('../utils/paths');
+const { DEFAULT_CONFIG, DEFAULT_IGNORE_PATTERNS } = require('../config/defaults');
+
+/**
+ * Verify current directory is a git repository
+ * @param {string} repoPath - Path to check
+ * @returns {boolean} True if git repo
+ */
+function isGitRepo(repoPath) {
+  const gitPath = getGitPath(repoPath);
+  return fs.existsSync(gitPath);
+}
+
+/**
+ * Create .autopilotignore file with safe defaults
+ * @param {string} repoPath - Repository path
+ * @returns {Promise<boolean>} True if created, false if already exists
+ */
+async function createIgnoreFile(repoPath) {
+  const ignorePath = getIgnorePath(repoPath);
+  
+  if (fs.existsSync(ignorePath)) {
+    logger.info('.autopilotignore already exists');
+    return false;
+  }
+
+  await fs.writeFile(ignorePath, DEFAULT_IGNORE_PATTERNS, 'utf8');
+  logger.success('Created .autopilotignore');
+  return true;
+}
+
+/**
+ * Create .autopilotrc.json file with default configuration
+ * @param {string} repoPath - Repository path
+ * @returns {Promise<boolean>} True if created, false if already exists
+ */
+async function createConfigFile(repoPath) {
+  const configPath = getConfigPath(repoPath);
+  
+  if (fs.existsSync(configPath)) {
+    logger.info('.autopilotrc.json already exists');
+    return false;
+  }
+
+  await fs.writeJson(configPath, DEFAULT_CONFIG, { spaces: 2 });
+  logger.success('Created .autopilotrc.json');
+  return true;
+}
+
+/**
+ * Initialize Autopilot in current repository
+ */
+async function initRepo() {
+  try {
+    const repoPath = process.cwd();
+
+    logger.section('🚀 Autopilot Init');
+    logger.info('Built by Praise Masunga (PraiseTechzw)');
+    logger.info('Initializing git automation...');
+
+    // Verify git repository
+    if (!isGitRepo(repoPath)) {
+      logger.error('Not a git repository. Please run this inside a git repo.');
+      process.exit(1);
+    }
+
+    logger.success('Git repository detected');
+
+    // Create files
+    await createIgnoreFile(repoPath);
+    await createConfigFile(repoPath);
+
+    logger.section('✨ Initialization Complete');
+    logger.info('Next steps:');
+    logger.info('  1. Review .autopilotrc.json to customize settings');
+    logger.info('  2. Review .autopilotignore to adjust ignore patterns');
+    logger.info('  3. Run "autopilot start" to begin watching');
+    
+  } catch (error) {
+    logger.error(`Initialization failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { initRepo };

package/src/commands/start.js

@@ -0,0 +1,41 @@
+/**
+ * Command: start
+ * Starts the Autopilot watcher in the foreground
+ */
+
+const process = require('process');
+const logger = require('../utils/logger');
+const Watcher = require('../core/watcher');
+const { getRunningPid } = require('../utils/process');
+
+const start = async (options) => {
+  const repoPath = process.cwd();
+
+  try {
+    // Check if already running
+    const runningPid = await getRunningPid(repoPath);
+    if (runningPid) {
+      logger.warn(`Autopilot is already running (PID: ${runningPid})`);
+      logger.info('Run "autopilot stop" to stop the current instance.');
+      return;
+    }
+
+    // Initialize watcher
+    const watcher = new Watcher(repoPath);
+
+    logger.section('Starting Autopilot');
+    logger.info('Press Ctrl+C to stop, or run "autopilot stop" in another terminal.');
+    
+    // Start watching
+    await watcher.start();
+
+    // Keep process alive is handled by chokidar being persistent
+    // The watcher handles process signals for cleanup
+
+  } catch (error) {
+    logger.error(`Failed to start autopilot: ${error.message}`);
+    process.exit(1);
+  }
+};
+
+module.exports = start;

package/src/commands/status.js

@@ -0,0 +1,56 @@
+/**
+ * Command: status
+ * Checks the status of the Autopilot watcher
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const process = require('process');
+const logger = require('../utils/logger');
+const { getRunningPid } = require('../utils/process');
+
+const status = async () => {
+  const repoPath = process.cwd();
+
+  try {
+    const pid = await getRunningPid(repoPath);
+
+    logger.section('Autopilot Status');
+
+    if (pid) {
+      logger.success(`Status: Running`);
+      logger.info(`PID: ${pid}`);
+    } else {
+      logger.warn('Status: Not Running');
+    }
+
+    // Show recent logs if available
+    const logPath = path.join(repoPath, 'autopilot.log');
+    if (await fs.pathExists(logPath)) {
+      logger.section('Recent Logs');
+      try {
+        const logs = await fs.readFile(logPath, 'utf-8');
+        const lines = logs.trim().split('\n');
+        const lastLines = lines.slice(-5); // Show last 5 lines
+        
+        if (lastLines.length > 0) {
+          lastLines.forEach(line => console.log(line));
+        } else {
+          console.log('(Log file is empty)');
+        }
+        
+        logger.info(`\nFull log: ${logPath}`);
+      } catch (error) {
+        logger.error(`Could not read log file: ${error.message}`);
+      }
+    } else {
+      logger.info('No log file found.');
+    }
+
+  } catch (error) {
+    logger.error(`Error checking status: ${error.message}`);
+    process.exit(1);
+  }
+};
+
+module.exports = status;

package/src/commands/stop.js

@@ -0,0 +1,50 @@
+/**
+ * Command: stop
+ * Stops the running Autopilot instance
+ */
+
+const process = require('process');
+const logger = require('../utils/logger');
+const { getRunningPid, removePid } = require('../utils/process');
+
+const stop = async () => {
+  const repoPath = process.cwd();
+
+  try {
+    const pid = await getRunningPid(repoPath);
+
+    if (!pid) {
+      logger.info('Autopilot is not running.');
+      // Clean up stale PID file just in case
+      await removePid(repoPath);
+      return;
+    }
+
+    logger.info(`Stopping Autopilot (PID: ${pid})...`);
+
+    try {
+      // Send SIGTERM to the process
+      process.kill(pid, 'SIGTERM');
+      
+      logger.success('Autopilot stopped successfully.');
+      
+      // Cleanup PID file
+      await removePid(repoPath);
+      
+    } catch (error) {
+      if (error.code === 'ESRCH') {
+        logger.warn('Process not found (stale PID file). Cleaning up...');
+        await removePid(repoPath);
+        logger.success('Cleaned up stale lock file.');
+      } else {
+        logger.error(`Failed to stop process: ${error.message}`);
+      }
+    }
+
+  } catch (error) {
+    logger.error(`Error stopping autopilot: ${error.message}`);
+    process.exit(1);
+  }
+};
+
+module.exports = stop;

package/src/config/defaults.js

@@ -0,0 +1,34 @@
+/**
+ * Default configuration values for Autopilot
+ * Built by Praise Masunga (PraiseTechzw)
+ */
+
+const DEFAULT_CONFIG = {
+  debounceSeconds: 20,
+  minSecondsBetweenCommits: 180,
+  autoPush: true,
+  blockBranches: ['main', 'master'],
+  requireChecks: false,
+  checks: [],
+  commitMessageMode: 'smart', // smart | simple
+};
+
+const DEFAULT_IGNORE_PATTERNS = [
+  'node_modules/',
+  'dist/',
+  'build/',
+  '.next/',
+  '.env',
+  '.env.*',
+  'coverage/',
+  '*.log',
+  '.DS_Store',
+  '.git/',
+  '.idea/',
+  '.vscode/'
+].join('\n');
+
+module.exports = {
+  DEFAULT_CONFIG,
+  DEFAULT_IGNORE_PATTERNS,
+};

package/src/config/ignore.js

@@ -0,0 +1,37 @@
+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,
+};

package/src/config/loader.js

@@ -0,0 +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,
+};

package/src/core/commit.js

@@ -0,0 +1,116 @@
+/**
+ * Smart commit message generator
+ */
+
+/**
+ * Generate a conventional commit message based on changed files
+ * @param {string[]} files - Array of changed file paths
+ * @returns {string} Conventional commit message
+ */
+function generateCommitMessage(files) {
+  if (!files || files.length === 0) {
+    return 'chore: update changes';
+  }
+
+  const categories = {
+    fix: false,
+    feat: false,
+    docs: false,
+    test: false,
+    chore: false,     // Generic chore (unknown files)
+    config: false,    // Specific config files
+  };
+
+  for (const file of files) {
+    const lowerFile = file.toLowerCase();
+    const normalized = lowerFile.replace(/\\/g, '/');
+    let matched = false;
+
+    // Fix detection (highest priority)
+    if (
+      normalized.includes('/fix/') ||
+      normalized.includes('fix-') ||
+      normalized.includes('-fix') ||
+      normalized.includes('bugfix') ||
+      normalized.includes('hotfix') ||
+      normalized.includes('error') ||
+      normalized.includes('exception') ||
+      normalized.endsWith('error.js') ||
+      normalized.endsWith('error.ts')
+    ) {
+      categories.fix = true;
+      matched = true;
+    }
+
+    // Docs detection
+    if (normalized.endsWith('.md') || normalized.endsWith('.txt')) {
+      categories.docs = true;
+      matched = true;
+    }
+
+    // Test detection
+    if (
+      normalized.includes('.test.') ||
+      normalized.includes('.spec.') ||
+      normalized.includes('__tests__')
+    ) {
+      categories.test = true;
+      matched = true;
+    }
+
+    // Feat detection - src/ changes that aren't tests
+    if (
+      (normalized.startsWith('src/') || normalized.includes('/src/')) &&
+      !categories.test // Ensure we don't count tests as features if they happen to be in src
+    ) {
+      categories.feat = true;
+      matched = true;
+    }
+
+    // Config files detection
+    if (
+      normalized === 'package.json' ||
+      normalized.endsWith('.yml') ||
+      normalized.endsWith('.yaml') ||
+      normalized.endsWith('.json') ||
+      normalized.endsWith('.config.js') ||
+      normalized.endsWith('.config.ts') ||
+      normalized.includes('.github/') ||
+      normalized.includes('.gitignore') ||
+      normalized.includes('.editorconfig')
+    ) {
+      categories.config = true;
+      matched = true;
+    }
+
+    // Default to chore for other files
+    if (!matched) {
+      categories.chore = true;
+    }
+  }
+
+  // Priority order: fix > feat > docs > test > chore
+  if (categories.fix) {
+    return 'fix: resolve issues';
+  }
+  if (categories.feat) {
+    return 'feat: add new features';
+  }
+  if (categories.docs) {
+    return 'docs: update documentation';
+  }
+  if (categories.test) {
+    return 'test: update tests';
+  }
+  // "chore" category splits into explicit config vs generic changes
+  if (categories.config) {
+    return 'chore: update configuration';
+  }
+  if (categories.chore) {
+    return 'chore: update changes';
+  }
+
+  return 'chore: update changes';
+}
+
+module.exports = { generateCommitMessage };