maiass 5.10.6 → 5.12.2

package/lib/bootstrap.js

@@ -583,9 +583,9 @@ MAIASS_STAGINGBRANCH=${config.branches.staging}
 #MAIASS_BITBUCKET_WORKSPACE=
 #MAIASS_BITBUCKET_REPO_SLUG=
 
-# Pull Request Configuration
-#MAIASS_STAGING_PULLREQUESTS=on
-#MAIASS_MAIN_PULLREQUESTS=on
+# Pull Request Configuration — when 'on', open PR URL instead of direct merge.
+# Also auto-engaged if a direct push to develop is rejected (e.g. branch protection).
+#MAIASS_DEVELOP_PULLREQUESTS=off
 
 # Logging Configuration
 #MAIASS_LOGGING=true

package/lib/config-command.js

@@ -69,7 +69,7 @@ function displayConfig(config, options = {}) {
     'AI Integration': ['MAIASS_AI_MODE', 'MAIASS_AI_TOKEN', 'MAIASS_AI_MODEL', 'MAIASS_AI_TEMPERATURE', 'MAIASS_AI_HOST', 'MAIASS_AI_MAX_CHARACTERS', 'MAIASS_AI_COMMIT_MESSAGE_STYLE'],
     'Git Branches': ['MAIASS_DEVELOPBRANCH', 'MAIASS_STAGINGBRANCH', 'MAIASS_MAINBRANCH'],
     'Repository Settings': ['MAIASS_REPO_TYPE', 'MAIASS_GITHUB_OWNER', 'MAIASS_GITHUB_REPO', 'MAIASS_BITBUCKET_WORKSPACE', 'MAIASS_BITBUCKET_REPO_SLUG'],
-    'Pull Requests': ['MAIASS_STAGING_PULLREQUESTS', 'MAIASS_MAIN_PULLREQUESTS'],
+    'Pull Requests': ['MAIASS_DEVELOP_PULLREQUESTS'],
     'Version Management': ['MAIASS_VERSION_PATH', 'MAIASS_VERSION_PRIMARY_FILE', 'MAIASS_VERSION_PRIMARY_TYPE', 'MAIASS_VERSION_PRIMARY_LINE_START', 'MAIASS_VERSION_SECONDARY_FILES'],
     'Changelog': ['MAIASS_CHANGELOG_PATH', 'MAIASS_CHANGELOG_NAME', 'MAIASS_CHANGELOG_INTERNAL_NAME']
   };

package/lib/config-manager.js

@@ -115,7 +115,7 @@ export function writeConfig(configPath, config, options = {}) {
       'AI': ['MAIASS_AI_MODE', 'MAIASS_AI_TOKEN', 'MAIASS_AI_MODEL', 'MAIASS_AI_TEMPERATURE', 'MAIASS_AI_ENDPOINT', 'MAIASS_AI_MAX_CHARACTERS', 'MAIASS_AI_COMMIT_MESSAGE_STYLE'],
       'Branches': ['MAIASS_DEVELOPBRANCH', 'MAIASS_STAGINGBRANCH', 'MAIASS_MAINBRANCH'],
       'Repository': ['MAIASS_REPO_TYPE', 'MAIASS_GITHUB_OWNER', 'MAIASS_GITHUB_REPO', 'MAIASS_BITBUCKET_WORKSPACE', 'MAIASS_BITBUCKET_REPO_SLUG'],
-      'Pull Requests': ['MAIASS_STAGING_PULLREQUESTS', 'MAIASS_MAIN_PULLREQUESTS'],
+      'Pull Requests': ['MAIASS_DEVELOP_PULLREQUESTS'],
       'Versioning': ['MAIASS_VERSION_PATH', 'MAIASS_VERSION_PRIMARY_FILE', 'MAIASS_VERSION_PRIMARY_TYPE', 'MAIASS_VERSION_PRIMARY_LINE_START', 'MAIASS_VERSION_SECONDARY_FILES'],
       'Changelog': ['MAIASS_CHANGELOG_PATH', 'MAIASS_CHANGELOG_NAME', 'MAIASS_CHANGELOG_INTERNAL_NAME'],
       'Other': []

package/lib/maiass-pipeline.js

@@ -16,6 +16,7 @@ import { getSingleCharInput, getLineInput } from './input-utils.js';
 import { updateChangelog as updateChangelogNew } from './changelog.js';
 import { displayHeader } from './header.js';
 import { checkForUpdates } from './update-check.js';
+import { createPullRequest } from './pull-request.js';
 import { execSync } from 'child_process';
 import path from 'path';
 import fs from 'fs';
@@ -317,9 +318,34 @@ async function handleMergeToDevelop(branchInfo, commitResult, options = {}) {
     return { success: true, simplified: true };
   }
 
+  // autoMerge (-a): skip prompts and proceed with merge. If direct merge is
+  // blocked, fall back to opening a PR in the browser (auto mode = "do whatever
+  // is needed without asking").
+  const autoMerge = process.env.MAIASS_AUTO_MERGE_TO_DEVELOP === 'true';
+
+  // PR flow: if MAIASS_DEVELOP_PULLREQUESTS=on, push source and open a PR URL
+  // instead of doing a direct merge. The pipeline ends here — the user merges
+  // the PR on the platform, then re-runs maiass on develop for the version bump.
+  if (process.env.MAIASS_DEVELOP_PULLREQUESTS === 'on') {
+    log.blue(SYMBOLS.INFO, `MAIASS_DEVELOP_PULLREQUESTS=on — opening PR instead of direct merge`);
+    const prResult = createPullRequest({
+      source: currentBranch,
+      target: developBranch,
+      title: `Merge ${currentBranch} into ${developBranch}`
+    });
+    if (!prResult.success) {
+      log.error(SYMBOLS.CROSS, `Failed to create pull request: ${prResult.error}`);
+      return { success: false, error: prResult.error };
+    }
+    log.success(SYMBOLS.CHECKMARK, `Pull request opened in browser`);
+    log.blue(SYMBOLS.INFO, `${prResult.url}`);
+    log.blue(SYMBOLS.INFO, `After merging the PR, re-run maiass on ${developBranch} to bump the version.`);
+    return { success: true, pullRequest: true, url: prResult.url };
+  }
+
   // Determine tagging strategy for this version bump
   const taggingDecision = shouldTagRelease(versionBump, tag);
-  
+
   // Prompt user for merge (and tagging if needed)
   if (!force) {
     log.blue(SYMBOLS.INFO, `Ready to merge changes to ${developBranch} branch`);
@@ -401,14 +427,58 @@ async function handleMergeToDevelop(branchInfo, commitResult, options = {}) {
   }
   
   log.success(SYMBOLS.CHECKMARK, `Successfully merged ${currentBranch} into ${developBranch}`);
-  
+
+  // Detect blocked direct push (e.g. branch protection requires PR).
+  // Run a dry-run push — if it fails, the eventual push will fail too. Only do
+  // this when the remote actually exists; otherwise there's nothing to dry-run.
+  if (remoteExists()) {
+    const dryRun = executeGitCommand(`git push --dry-run origin ${developBranch}`, true);
+    if (!dryRun.success) {
+      log.warning(SYMBOLS.WARNING, `Direct push to ${developBranch} appears blocked (likely branch protection)`);
+
+      // Decide whether to fall back to PR flow:
+      // - autoMerge (-am): yes, automatically — that's exactly what -am promises
+      // - interactive: prompt the user
+      let useFallback = autoMerge;
+      if (!autoMerge) {
+        const reply = await getSingleCharInput(`Open a pull request instead? [Y/n] `);
+        useFallback = reply !== 'n';
+      } else {
+        log.info(SYMBOLS.INFO, '-am mode — falling back to PR flow');
+      }
+
+      if (useFallback) {
+        // Roll back the local merge so the working copy is back to clean develop,
+        // then return to the original branch so we push the right ref for the PR
+        executeGitCommand(`git reset --hard HEAD~1`);
+        await switchToBranch(originalBranch || currentBranch);
+
+        const prResult = createPullRequest({
+          source: currentBranch,
+          target: developBranch,
+          title: `Merge ${currentBranch} into ${developBranch}`
+        });
+        if (!prResult.success) {
+          log.error(SYMBOLS.CROSS, `Failed to create pull request: ${prResult.error}`);
+          return { success: false, error: prResult.error };
+        }
+        log.success(SYMBOLS.CHECKMARK, `Pull request opened in browser`);
+        log.blue(SYMBOLS.INFO, `${prResult.url}`);
+        log.blue(SYMBOLS.INFO, `After merging the PR, re-run maiass on ${developBranch} to bump the version.`);
+        return { success: true, pullRequest: true, url: prResult.url };
+      }
+      // User declined PR fallback — continue and let the later push fail with a clear error
+      log.warning(SYMBOLS.WARNING, `Continuing with direct merge — push may fail at version bump stage`);
+    }
+  }
+
   // Log the merge to devlog.sh (equivalent to logthis in maiass.sh)
   logMerge(currentBranch, developBranch, originalGitInfo, 'Merged');
-  
-  return { 
-    success: true, 
-    merged: true, 
-    taggingDecision: taggingDecision 
+
+  return {
+    success: true,
+    merged: true,
+    taggingDecision: taggingDecision
   };
 }
 
@@ -458,12 +528,19 @@ async function handleVersionManagement(branchInfo, mergeResult, options = {}) {
 
   logger.header(SYMBOLS.INFO, 'Version Management Phase');
 
-  // Must be on develop branch for version management — check before reading version files
+  // Must be on develop branch for version management — check before reading version files.
+  // If the user explicitly asked for a bump (passed major/minor/patch), this is an error.
+  // Otherwise it's a graceful skip — they may have run maiass on a feature branch without
+  // intending a version bump, or the merge was deferred to a PR.
   const currentBranch = getCurrentBranch();
   if (currentBranch !== developBranch) {
-    console.error(colors.Red(`${SYMBOLS.CROSS} Version management must be done on ${developBranch} branch`));
-    console.error(colors.Red(`${SYMBOLS.CROSS} Current branch: ${currentBranch}`));
-    return { success: false, error: `Not on ${developBranch} branch` };
+    if (versionBumpExplicit) {
+      console.error(colors.Red(`${SYMBOLS.CROSS} Version management must be done on ${developBranch} branch`));
+      console.error(colors.Red(`${SYMBOLS.CROSS} Current branch: ${currentBranch}`));
+      return { success: false, error: `Not on ${developBranch} branch` };
+    }
+    log.blue(SYMBOLS.INFO, `Skipping version management — on ${currentBranch}, not ${developBranch}`);
+    return { success: true, skipped: true, reason: 'not on develop' };
   }
 
   // Pull latest develop from remote before reading version files.
@@ -710,6 +787,19 @@ async function handleReleaseBranchWorkflow(newVersion, versionInfo, developBranc
     }
 
     logger.success(SYMBOLS.CHECKMARK, `Release workflow completed: ${versionInfo.current} → ${newVersion}`);
+
+    // Return to the user's original branch unless they started on develop or
+    // a release branch. Mirrors handleSimpleVersionBump so the user isn't left
+    // stranded on develop after a release runs from a feature branch.
+    const originalBranch = originalGitInfo?.currentBranch;
+    if (originalBranch && originalBranch !== developBranch && !originalBranch.startsWith('release/')) {
+      logger.info(SYMBOLS.INFO, `Returning to original branch: ${originalBranch}`);
+      const switched = await switchToBranch(originalBranch);
+      if (!switched) {
+        logger.warning(SYMBOLS.WARNING, `Failed to switch back to ${originalBranch}`);
+      }
+    }
+
     return {
       success: true,
       version: newVersion,
@@ -825,6 +915,15 @@ export async function runMaiassPipeline(options = {}) {
       logger.info(SYMBOLS.INFO, 'Thank you for using MAIASS!');
       return { success: true, cancelled: true, phase: 'merge-cancelled' };
     }
+
+    // If PR flow was used, the merge will happen on the platform — stop the
+    // pipeline here. Version management will run on the next maiass invocation
+    // after the user merges the PR.
+    if (mergeResult.pullRequest) {
+      console.log();
+      logger.info(SYMBOLS.INFO, 'Thank you for using MAIASS!');
+      return { success: true, pullRequest: true, url: mergeResult.url };
+    }
     
     console.log('');
     

package/lib/maiass-variables.js

@@ -6,8 +6,14 @@ import path from 'path';
 export const MAIASS_VARIABLES = {
   // Core system variables
   'MAIASS_DEBUG': { default: 'false', description: 'Enable debug mode' },
-  'MAIASS_AUTOPUSH_COMMITS': { default: 'false', description: 'Automatically push commits' },
   'MAIASS_BRAND': { default: 'MAIASS', description: 'Brand name for display' },
+
+  // Auto-yes flags — set by -a (all four) or -ac (first three only).
+  // Setting any of these in .env.maiass makes that prompt auto-approve permanently.
+  'MAIASS_AUTO_STAGE_UNSTAGED': { default: 'false', description: 'Auto-stage unstaged changes during commit phase' },
+  'MAIASS_AUTO_PUSH_COMMITS': { default: 'false', description: 'Auto-push commits to origin' },
+  'MAIASS_AUTO_APPROVE_AI_SUGGESTIONS': { default: 'false', description: 'Auto-approve AI commit message suggestions' },
+  'MAIASS_AUTO_MERGE_TO_DEVELOP': { default: 'false', description: 'Auto-merge feature branch into develop without prompting' },
   'MAIASS_VERBOSITY': { default: 'brief', description: 'Verbosity level (brief/normal/verbose)' },
   'MAIASS_LOGGING': { default: 'false', description: 'Enable logging to file' },
   'MAIASS_LOG_FILE': { default: 'maiass.log', description: 'Log file name' },
@@ -46,9 +52,9 @@ export const MAIASS_VARIABLES = {
   // Release configuration
   'MAIASS_AUTO_TAG_RELEASES': { default: 'true', description: 'Automatically tag releases without prompting' },
 
-  // Pull request configuration
-  'MAIASS_STAGING_PULLREQUESTS': { default: 'on', description: 'Enable staging pull requests' },
-  'MAIASS_MAIN_PULLREQUESTS': { default: 'on', description: 'Enable main branch pull requests' },
+  // Pull request configuration — when 'on', push source and open PR URL instead of direct merge.
+  // Also auto-engaged when a direct push to develop is rejected (e.g. branch protection).
+  'MAIASS_DEVELOP_PULLREQUESTS': { default: 'off', description: 'Open PR for merges into develop instead of direct merge' },
 
   // Repository provider configuration
   'MAIASS_BITBUCKET_WORKSPACE': { default: '', description: 'Bitbucket workspace name' },

package/lib/pull-request.js

@@ -0,0 +1,140 @@
+import { execSync, spawn } from 'child_process';
+import { detectRepoProvider } from './repo-provider.js';
+
+/**
+ * Build a provider-specific URL that opens the PR creation form pre-filled
+ * with source/target branches and a title.
+ *
+ * @param {Object} args
+ * @param {string} args.provider - 'github' | 'bitbucket' | 'gitlab'
+ * @param {string} args.owner - Repo owner / workspace
+ * @param {string} args.repo - Repo name / slug
+ * @param {string} args.source - Source branch (the changes)
+ * @param {string} args.target - Target branch (where they're merging into)
+ * @param {string} [args.title] - Optional PR title
+ * @returns {string|null} The URL, or null if provider unsupported
+ */
+export function buildPullRequestUrl({ provider, owner, repo, source, target, title = '' }) {
+  const encodedTitle = encodeURIComponent(title);
+
+  if (provider === 'github') {
+    // GitHub's quick_pull form: /compare/target...source?quick_pull=1&title=...
+    const base = `https://github.com/${owner}/${repo}/compare/${target}...${source}?quick_pull=1`;
+    return title ? `${base}&title=${encodedTitle}` : base;
+  }
+
+  if (provider === 'bitbucket') {
+    // Bitbucket: /pull-requests/new?source=...&dest=...&title=...
+    const base = `https://bitbucket.org/${owner}/${repo}/pull-requests/new?source=${source}&dest=${target}`;
+    return title ? `${base}&title=${encodedTitle}` : base;
+  }
+
+  if (provider === 'gitlab') {
+    // GitLab: /-/merge_requests/new?merge_request[source_branch]=...&...
+    const params = new URLSearchParams({
+      'merge_request[source_branch]': source,
+      'merge_request[target_branch]': target
+    });
+    if (title) params.set('merge_request[title]', title);
+    return `https://gitlab.com/${owner}/${repo}/-/merge_requests/new?${params.toString()}`;
+  }
+
+  return null;
+}
+
+/**
+ * Open a URL in the user's default browser using the platform-native command.
+ * Uses spawn so it doesn't block, and detaches so the parent can exit cleanly.
+ *
+ * @param {string} url
+ * @returns {boolean} True if the open command was launched
+ */
+export function openInBrowser(url) {
+  const platform = process.platform;
+  let cmd, args;
+
+  if (platform === 'darwin') {
+    cmd = 'open';
+    args = [url];
+  } else if (platform === 'win32') {
+    cmd = 'cmd';
+    args = ['/c', 'start', '""', url];
+  } else {
+    // Linux + others: xdg-open is the standard
+    cmd = 'xdg-open';
+    args = [url];
+  }
+
+  try {
+    const child = spawn(cmd, args, { detached: true, stdio: 'ignore' });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Push a branch to origin, setting upstream if needed.
+ * Used before opening the PR URL so the source branch exists on the remote.
+ */
+function pushBranchToOrigin(branch) {
+  try {
+    execSync(`git push --set-upstream origin ${branch}`, { stdio: ['pipe', 'pipe', 'pipe'] });
+    return { success: true };
+  } catch (error) {
+    // Fall back to a plain push if upstream is already set
+    try {
+      execSync(`git push origin ${branch}`, { stdio: ['pipe', 'pipe', 'pipe'] });
+      return { success: true };
+    } catch (innerError) {
+      return { success: false, error: innerError.message };
+    }
+  }
+}
+
+/**
+ * Push the source branch and open a PR-creation URL in the browser.
+ * Mirrors the bashmaiass `perform_merge_operation` PR path.
+ *
+ * @param {Object} args
+ * @param {string} args.source - Source branch
+ * @param {string} args.target - Target branch
+ * @param {string} [args.title] - Optional PR title
+ * @param {Object} [deps] - Injectable dependencies for testing
+ * @param {Function} [deps.detect] - Provider detection function (defaults to detectRepoProvider)
+ * @param {Function} [deps.push] - Branch push function (defaults to pushBranchToOrigin)
+ * @param {Function} [deps.open] - Browser open function (defaults to openInBrowser)
+ * @returns {{success: boolean, url?: string, error?: string}}
+ */
+export function createPullRequest({ source, target, title }, deps = {}) {
+  const detect = deps.detect || detectRepoProvider;
+  const push   = deps.push   || pushBranchToOrigin;
+  const open   = deps.open   || openInBrowser;
+
+  const repoInfo = detect();
+  if (!repoInfo) {
+    return { success: false, error: 'Could not detect repository provider from git remote' };
+  }
+
+  const url = buildPullRequestUrl({
+    provider: repoInfo.provider,
+    owner: repoInfo.owner,
+    repo: repoInfo.repo,
+    source,
+    target,
+    title
+  });
+  if (!url) {
+    return { success: false, error: `Unsupported provider: ${repoInfo.provider}` };
+  }
+
+  // Push source branch so the PR has commits to compare against
+  const pushResult = push(source);
+  if (!pushResult.success) {
+    return { success: false, error: `Failed to push ${source}: ${pushResult.error}` };
+  }
+
+  open(url);
+  return { success: true, url };
+}

package/lib/repo-provider.js

@@ -0,0 +1,98 @@
+import { execSync } from 'child_process';
+
+/**
+ * Parse a git remote URL and extract provider, owner, and repo.
+ * Supports common GitHub, Bitbucket, and GitLab URL formats:
+ *
+ *   https://github.com/owner/repo.git
+ *   git@github.com:owner/repo.git
+ *   https://bitbucket.org/workspace/slug.git
+ *   git@bitbucket.org:workspace/slug.git
+ *   https://gitlab.com/group/project.git
+ *   git@gitlab.com:group/project.git
+ *
+ * @param {string} url - Remote URL (e.g. from `git config --get remote.origin.url`)
+ * @returns {{provider: string, owner: string, repo: string} | null}
+ */
+export function parseRemoteUrl(url) {
+  if (!url) return null;
+
+  // Match host + path from either SSH (git@host:path) or HTTPS (https://host/path) form
+  const sshMatch = url.match(/^git@([^:]+):(.+?)(?:\.git)?\/?$/);
+  const httpsMatch = url.match(/^https?:\/\/(?:[^@]+@)?([^/]+)\/(.+?)(?:\.git)?\/?$/);
+
+  const match = sshMatch || httpsMatch;
+  if (!match) return null;
+
+  const host = match[1].toLowerCase();
+  const path = match[2];
+
+  // Need at least owner/repo — anything less can't be a valid remote
+  const parts = path.split('/');
+  if (parts.length < 2) return null;
+
+  // Last segment is repo; everything before is the owner (handles GitLab subgroups)
+  const repo = parts.pop();
+  const owner = parts.join('/');
+
+  let provider = null;
+  if (host.includes('github.com')) provider = 'github';
+  else if (host.includes('bitbucket.org')) provider = 'bitbucket';
+  else if (host.includes('gitlab.com') || host.includes('gitlab.')) provider = 'gitlab';
+  else return null;
+
+  return { provider, owner, repo };
+}
+
+/**
+ * Read the origin remote URL via git. Returns null if no remote or not a git repo.
+ */
+export function getOriginUrl() {
+  try {
+    const url = execSync('git config --get remote.origin.url', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+    return url || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Detect repo provider/owner/repo from the current git remote.
+ * Respects existing env vars so the user can override auto-detection in `.env.maiass`.
+ *
+ * Sets the following on `process.env` if not already set:
+ *   MAIASS_REPO_PROVIDER, MAIASS_GITHUB_OWNER, MAIASS_GITHUB_REPO,
+ *   MAIASS_BITBUCKET_WORKSPACE, MAIASS_BITBUCKET_REPO_SLUG
+ *
+ * @returns {{provider: string, owner: string, repo: string} | null}
+ */
+export function detectRepoProvider() {
+  // Respect explicit override — if all the relevant vars are already set, skip detection
+  const overrideProvider = process.env.MAIASS_REPO_PROVIDER;
+  if (overrideProvider) {
+    return {
+      provider: overrideProvider,
+      owner: process.env.MAIASS_GITHUB_OWNER || process.env.MAIASS_BITBUCKET_WORKSPACE || '',
+      repo: process.env.MAIASS_GITHUB_REPO || process.env.MAIASS_BITBUCKET_REPO_SLUG || ''
+    };
+  }
+
+  const url = getOriginUrl();
+  const parsed = parseRemoteUrl(url);
+  if (!parsed) return null;
+
+  // Cache to env so the rest of the pipeline can read consistently
+  process.env.MAIASS_REPO_PROVIDER = parsed.provider;
+  if (parsed.provider === 'github') {
+    process.env.MAIASS_GITHUB_OWNER = parsed.owner;
+    process.env.MAIASS_GITHUB_REPO = parsed.repo;
+  } else if (parsed.provider === 'bitbucket') {
+    process.env.MAIASS_BITBUCKET_WORKSPACE = parsed.owner;
+    process.env.MAIASS_BITBUCKET_REPO_SLUG = parsed.repo;
+  }
+
+  return parsed;
+}

package/maiass.mjs

@@ -94,16 +94,33 @@ if (firstArg && versionBumpTypes.includes(firstArg)) {
   command = 'maiass';
 }
 
-// Handle --auto flag (must be before other processing)
-if (args.includes('--auto') || args.includes('-a')) {
-  // Override all auto-yes variables for non-interactive mode
+// Auto modes:
+// -a  / --auto:        full auto — stage, push, merge to develop, version bump
+//                      (kept identical to historical behaviour for CI compatibility)
+// -ac / --auto-commit: auto-yes for commit phase only — stops after commit
+//                      (no merge, no bump). Useful for CI runs that just want
+//                      the AI commit captured without touching develop.
+const isAutoCommit = args.includes('--auto-commit') || args.includes('-ac');
+const isAuto = !isAutoCommit && (args.includes('--auto') || args.includes('-a'));
+
+if (isAuto || isAutoCommit) {
+  // Shared auto-yes vars for both modes
   process.env.MAIASS_AUTO_STAGE_UNSTAGED = 'true';
   process.env.MAIASS_AUTO_PUSH_COMMITS = 'true';
-  process.env.MAIASS_AUTO_MERGE_TO_DEVELOP = 'true';
   process.env.MAIASS_AUTO_APPROVE_AI_SUGGESTIONS = 'true';
-  
+}
+
+if (isAuto) {
+  // -a: also auto-merge to develop (legacy behaviour)
+  process.env.MAIASS_AUTO_MERGE_TO_DEVELOP = 'true';
+  if (process.env.MAIASS_DEBUG === 'true') {
+    logger.debug('[DEBUG] Auto mode enabled — full pipeline runs unattended');
+  }
+} else if (isAutoCommit) {
+  // -ac: stop after commit phase. Implemented by treating it as commits-only
+  process.env.MAIASS_AUTO_FINISH_AFTER_COMMIT = 'true';
   if (process.env.MAIASS_DEBUG === 'true') {
-    logger.debug('[DEBUG] Auto-mode enabled - all prompts will be skipped');
+    logger.debug('[DEBUG] Auto-commit mode enabled — stops after commit phase');
   }
 }
 
@@ -124,6 +141,7 @@ const validFlags = [
   '--version', '-v',
   '--account-info',
   '--auto', '-a',
+  '--auto-commit', '-ac',
   '--commits-only', '-c',
   '--auto-stage',
   '--setup', '--bootstrap',
@@ -182,7 +200,8 @@ if (args.includes('--help') || args.includes('-h') || command === 'help') {
   console.log('  account-info       Show your account status (masked token)');
   console.log('\nOptions:');
   console.log('  --account-info     Show your account status (masked token)');
-  console.log('  --auto             Enable all auto-yes functionality (non-interactive mode)');
+  console.log('  --auto, -a         Full auto — stage, commit, push, merge to develop, bump version');
+  console.log('  --auto-commit, -ac Auto-yes for commit phase only — stops after commit (no merge, no bump)');
   console.log('  --commits-only, -c Generate AI commits without version management');
   console.log('  --auto-stage       Automatically stage all changes');
   console.log('  --setup, --bootstrap Run interactive project setup');
@@ -279,7 +298,8 @@ if (args.includes('--show-bb-excerpt'))  { showBitbucketExcerpt(); process.exit(
       // Handle the main MAIASS workflow
       await handleMaiassCommand({
         _: process.argv.slice(2).filter(arg => !arg.startsWith('-')),
-        'commits-only': args.includes('--commits-only') || args.includes('-c'),
+        // -ac is equivalent to -c (commits-only) plus auto-yes prompts
+        'commits-only': args.includes('--commits-only') || args.includes('-c') || args.includes('--auto-commit') || args.includes('-ac'),
         'auto-stage': args.includes('--auto-stage'),
         'auto': args.includes('--auto') || args.includes('-a'),
         'version-bump': versionBump,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "maiass",
   "type": "module",
-  "version": "5.10.6",
+  "version": "5.12.2",
   "description": "AI commit message generator, semantic versioning, and changelog automation for Git. One command stages, commits with AI, bumps version, and merges branches. Free credits on install — no sign-up needed.",
   "main": "maiass.mjs",
   "bin": {