tfv 5.0.1 → 6.1.0

package/lib/modules/ps1.js

@@ -1,38 +1,46 @@
-const {spawnSync} = require("child_process");
-const {P_END, P_ERROR} = require('../utils/colors');
+const { spawnSync } = require('child_process');
+const { join } = require('path');
+const { homedir } = require('os');
+const { P_END, P_ERROR, P_WARN, P_OK } = require('../utils/colors');
+const { TFV_HOME } = require('../utils/paths');
 
-exports.setWindowsTerraform = async () => {
-  const getSystemEnv = spawnSync(
-    "powershell",
-    ["(Get-ItemProperty -Path 'Registry::HKEY_LOCAL_MACHINE\\System\\CurrentControlSet\\Control\\Session Manager\\Environment' -Name PATH).path"],
-    {stdio: 'pipe'}
+const BIN_DIR = join(TFV_HOME, 'bin');
+
+/**
+ * Ensures ~/.tfv/bin is in the Windows User PATH (no admin required).
+ * Uses HKCU via [Environment]::SetEnvironmentVariable with "User" scope.
+ */
+exports.ensureWindowsPath = () => {
+  const getUserPath = spawnSync(
+    'powershell',
+    ['-NoProfile', '-NonInteractive', '-Command',
+      '[Environment]::GetEnvironmentVariable("PATH", "User")'],
+    { stdio: 'pipe', encoding: 'utf-8' }
   );
 
-  if (!getSystemEnv || getSystemEnv.status === 1) {
-    console.log(`${P_ERROR}Error ocurred while fetching windows environment${P_END}`);
-    process.exit(1);
+  if (!getUserPath || getUserPath.status !== 0) {
+    console.log(`${P_WARN}Could not read Windows User PATH. Please add manually: ${BIN_DIR}${P_END}`);
+    return;
   }
 
-  const systemEnv = getSystemEnv.stdout.toString().trim();
-
-  const terraformPath = 'C:\\terraform';
-  const getTerraformEnv = systemEnv.split(';').find(v => v === terraformPath);
+  const currentPath = (getUserPath.stdout || '').trim();
+  const pathEntries = currentPath.split(';').map(p => p.trim()).filter(Boolean);
 
-  if (!getTerraformEnv) {
-    const newSystemEnv = `${terraformPath};${systemEnv}`;
+  if (pathEntries.includes(BIN_DIR)) return; // Already in PATH
 
-    const updateEnv = spawnSync(
-      "powershell",
-      [
-        "-command",
-        `start-process powershell -verb runas -argumentlist "Set-ItemProperty -Path 'Registry::HKEY_LOCAL_MACHINE\\System\\CurrentControlSet\\Control\\Session Manager\\Environment' -Name PATH -Value '${newSystemEnv}'"`
-      ],
-      {stdio: 'pipe'}
-    );
+  const newPath = `${BIN_DIR};${currentPath}`;
+  const updateEnv = spawnSync(
+    'powershell',
+    ['-NoProfile', '-NonInteractive', '-Command',
+      `[Environment]::SetEnvironmentVariable("PATH", "${newPath}", "User")`],
+    { stdio: 'pipe' }
+  );
 
-    if (!updateEnv || updateEnv.status === 1) {
-      console.log(`${P_ERROR}Error ocurred while setting windows Environment${P_END}`);
-      process.exit(1);
-    }
+  if (updateEnv && updateEnv.status === 0) {
+    console.log(`${P_OK}Added ${BIN_DIR} to your User PATH.${P_END}`);
+    console.log(`${P_WARN}Restart your terminal for the PATH change to take effect.${P_END}`);
+  } else {
+    console.log(`${P_ERROR}Could not update PATH automatically.${P_END}`);
+    console.log(`${P_WARN}Please add manually to your User PATH: ${BIN_DIR}${P_END}`);
   }
-}
+};

package/lib/modules/remote.js

@@ -1,18 +1,71 @@
 const https = require('https');
+const { existsSync, readFileSync, writeFileSync } = require('fs');
+const { join } = require('path');
+const { getPaths, initDirs } = require('../utils/paths');
+const { formatVersions, formatOpenTofuVersions } = require('../utils/formatVersions');
 
-exports.fetchAllVersions = async () => {
-	try {
-		return new Promise((resolve, reject) => {
-			https.get('https://releases.hashicorp.com/terraform/', (resp) => {
-				let data = '';
-
-				resp.on('data', (chunk) => data += chunk);
-				resp.on('end', () => resolve(data));
-			}).on("error", (err) => {
-					reject(err);
-			});
-		});
-	} catch ({message}) {
-		console.log('ERROR:', message);
-	}
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+
+const URLS = {
+  terraform: 'https://releases.hashicorp.com/terraform/index.json',
+  opentofu: 'https://api.github.com/repos/opentofu/opentofu/releases?per_page=100',
+};
+
+const fetchUrl = (url) => new Promise((resolve, reject) => {
+  const options = { headers: { 'User-Agent': 'tfv-cli' } };
+  https.get(url, options, (res) => {
+    // Follow single redirect
+    if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+      return fetchUrl(res.headers.location).then(resolve).catch(reject);
+    }
+    let data = '';
+    res.on('data', chunk => { data += chunk; });
+    res.on('end', () => resolve(data));
+  }).on('error', reject);
+});
+
+const getCacheFile = (provider) => {
+  initDirs();
+  return join(getPaths().cache, `${provider}-versions.json`);
+};
+
+const readCache = (provider) => {
+  const cacheFile = getCacheFile(provider);
+  if (!existsSync(cacheFile)) return null;
+  try {
+    const { timestamp, data } = JSON.parse(readFileSync(cacheFile, 'utf-8'));
+    if (Date.now() - timestamp < CACHE_TTL_MS) return data;
+  } catch (_) { /* ignore corrupt cache */ }
+  return null;
+};
+
+const writeCache = (provider, data) => {
+  try {
+    writeFileSync(getCacheFile(provider), JSON.stringify({ timestamp: Date.now(), data }));
+  } catch (_) { /* non-fatal */ }
 };
+
+/**
+ * Fetch all stable versions for a given provider.
+ * Returns sorted array of version strings (descending).
+ */
+exports.fetchAllVersions = async (provider = 'terraform') => {
+  const normalized = provider === 'tofu' ? 'opentofu' : provider;
+
+  const cached = readCache(normalized);
+  if (cached) return cached;
+
+  const raw = await fetchUrl(URLS[normalized]);
+  const versions = normalized === 'opentofu'
+    ? formatOpenTofuVersions(raw)
+    : formatVersions(raw);
+
+  writeCache(normalized, versions);
+  return versions;
+};
+
+/**
+ * Fetch raw response (used for SHA256 sums and other direct URLs).
+ */
+exports.fetchUrl = fetchUrl;
+

package/lib/modules/remove.js

@@ -1,30 +1,44 @@
-const os = require('os')
-const fs = require('fs');
-const {join} = require('path');
-const {P_END, P_OK, P_ERROR} = require('../utils/colors');
+const os = require('os');
+const { existsSync, unlinkSync, readFileSync, writeFileSync } = require('fs');
+const { join } = require('path');
+const { normalizeProvider, getProviderStore, getVersionFile, getPaths } = require('../utils/paths');
+const { P_END, P_OK, P_ERROR, P_WARN } = require('../utils/colors');
 
-exports.remove = async (version) => {
+exports.remove = async (versions, providerArg = 'terraform') => {
   try {
-    const store = join(__dirname, '../..', 'store');
-    const arch = JSON.parse(fs.readFileSync(`${store}/arch.json`, 'utf-8'));
+    const provider = normalizeProvider(providerArg);
+    const store = getProviderStore(provider);
 
-    version.forEach(v => {
-      const tfVersion = os.platform() === 'win32' ? `${v}.exe` : v;
-      const file = `${store}/${tfVersion}`;
+    const archFile = join(store, 'arch.json');
+    const archMap = existsSync(archFile) ? JSON.parse(readFileSync(archFile, 'utf-8')) : {};
 
-      if (fs.existsSync(`${file}`)) {
-        fs.unlinkSync(file);
+    // Get active version for warning
+    const paths = getPaths();
+    let activeVersion = null;
+    if (existsSync(paths.active)) {
+      const active = JSON.parse(readFileSync(paths.active, 'utf-8'));
+      activeVersion = active[provider];
+    }
 
-        delete arch[v];
+    versions.forEach(v => {
+      const file = getVersionFile(provider, v);
 
-        return console.log(`${P_OK}Terraform ${v} deleted from tfv store${P_END}`);
-      } else {
-        return console.log(`${P_ERROR}Terraform ${v} does not exist in tfv store${P_END}`);
+      if (!existsSync(file)) {
+        return console.log(`${P_ERROR}${provider} ${v} is not in tfv store${P_END}`);
       }
-    })
 
-    fs.writeFileSync(`${store}/arch.json`, JSON.stringify(arch, null, 2));
-  } catch ({message}) {
-    console.log('ERROR:', message)
+      if (v === activeVersion) {
+        console.log(`${P_WARN}Warning: ${provider} ${v} is currently active. Removing it will break the active symlink.${P_END}`);
+        console.log(`${P_WARN}Run ${P_OK}tfv use <other-version>${P_END}${P_WARN} first, or reinstall after removal.${P_END}`);
+      }
+
+      unlinkSync(file);
+      delete archMap[v];
+      console.log(`${P_OK}Removed ${provider} ${v} from tfv store${P_END}`);
+    });
+
+    writeFileSync(archFile, JSON.stringify(archMap, null, 2));
+  } catch (err) {
+    console.log(`${P_ERROR}Error: ${err.message}${P_END}`);
   }
-}
+};

package/lib/modules/shell-init.js

@@ -0,0 +1,226 @@
+const { P_END, P_OK, P_ERROR, P_INFO } = require('../utils/colors');
+
+const SUPPORTED_SHELLS = ['bash', 'zsh', 'fish', 'powershell', 'pwsh'];
+
+const BASH_ZSH_HOOK = `
+# tfv - terraform version manager shell integration
+# Add this to your shell config by running: eval "$(tfv shell-init <shell>)"
+_tfv_auto_switch() {
+  if [ -f ".terraform-version" ] || find . -maxdepth 1 -name "*.tf" -print -quit 2>/dev/null | grep -q .; then
+    tfv auto-switch --silent 2>/dev/null
+  fi
+}
+
+_tfv_cd() {
+  builtin cd "$@" && _tfv_auto_switch
+}
+
+alias cd='_tfv_cd'
+
+# Run for the current directory on shell startup
+_tfv_auto_switch
+
+# ── Tab completions ────────────────────────────────────────────────────────
+_tfv_versions() {
+  ls "\$HOME/.tfv/store/\${1:-terraform}" 2>/dev/null | grep -v arch.json | sed 's/\\.exe\$//'
+}
+
+if [ -n "\${BASH_VERSION:-}" ]; then
+  _tfv_complete() {
+    local cur="\${COMP_WORDS[COMP_CWORD]}"
+    local prev="\${COMP_WORDS[COMP_CWORD-1]}"
+    local cmds="install i use auto-switch as list ls current which pin upgrade remove rm exec prune doctor shell-init fmt init validate plan apply destroy"
+    case "\$prev" in
+      use|exec|remove|rm|pin|upgrade|install|i)
+        COMPREPLY=(\$(compgen -W "\$(_tfv_versions terraform) latest" -- "\$cur")) ;;
+      --provider|-p)
+        COMPREPLY=(\$(compgen -W "terraform tofu opentofu" -- "\$cur")) ;;
+      shell-init)
+        COMPREPLY=(\$(compgen -W "bash zsh fish powershell pwsh" -- "\$cur")) ;;
+      *)
+        COMPREPLY=(\$(compgen -W "\$cmds" -- "\$cur")) ;;
+    esac
+  }
+  complete -F _tfv_complete tfv
+elif [ -n "\${ZSH_VERSION:-}" ]; then
+  _tfv_complete() {
+    local cmds
+    cmds=(install i use auto-switch as list ls current which pin upgrade remove rm exec prune doctor shell-init fmt init validate plan apply destroy)
+    local prev="\${words[CURRENT-1]}"
+    case "\$prev" in
+      use|exec|remove|rm|pin|upgrade|install|i)
+        compadd -- \$(_tfv_versions terraform) latest ;;
+      --provider|-p)
+        compadd -- terraform tofu opentofu ;;
+      shell-init)
+        compadd -- bash zsh fish powershell pwsh ;;
+      *)
+        compadd -- "\$cmds[@]" ;;
+    esac
+  }
+  compdef _tfv_complete tfv 2>/dev/null
+fi
+`.trim();
+
+const FISH_HOOK = `
+# tfv - terraform version manager shell integration
+# Add to ~/.config/fish/config.fish: tfv shell-init fish | source
+
+function _tfv_auto_switch
+  if test -f .terraform-version; or count *.tf >/dev/null 2>&1
+    tfv auto-switch --silent 2>/dev/null
+  end
+end
+
+function cd
+  builtin cd $argv
+  _tfv_auto_switch
+end
+
+_tfv_auto_switch
+
+# ── Tab completions ────────────────────────────────────────────────────────
+function __tfv_installed_versions
+  set provider terraform
+  for i in (seq 1 (count $argv))
+    if test "$argv[$i]" = "--provider" -o "$argv[$i]" = "-p"
+      set next (math $i + 1)
+      if test $next -le (count $argv)
+        set p $argv[$next]
+        if test "$p" = "tofu" -o "$p" = "opentofu"
+          set provider opentofu
+        end
+      end
+    end
+  end
+  ls $HOME/.tfv/store/$provider 2>/dev/null | grep -v arch.json | string replace -r '\\.exe$' ''
+end
+
+set -l tfv_commands install i use auto-switch as list ls current which pin upgrade remove rm exec prune doctor shell-init fmt init validate plan apply destroy
+
+complete -c tfv -f
+complete -c tfv -n 'not __fish_seen_subcommand_from $tfv_commands' -a "$tfv_commands"
+
+for subcmd in use exec remove rm pin upgrade
+  complete -c tfv -n "__fish_seen_subcommand_from $subcmd" -a '(__tfv_installed_versions (commandline -opc))' -d 'Installed version'
+  complete -c tfv -n "__fish_seen_subcommand_from $subcmd" -a 'latest' -d 'Latest version'
+end
+
+complete -c tfv -n "__fish_seen_subcommand_from install i" -a '(__tfv_installed_versions (commandline -opc))' -d 'Installed version'
+complete -c tfv -n "__fish_seen_subcommand_from install i" -a 'latest' -d 'Latest version'
+
+complete -c tfv -l provider -s p -r -a 'terraform tofu opentofu' -d 'Provider'
+complete -c tfv -n "__fish_seen_subcommand_from shell-init" -a 'bash zsh fish powershell pwsh' -d 'Shell'
+`.trim();
+
+const POWERSHELL_HOOK = `
+# tfv - terraform version manager shell integration
+# Add to your PowerShell profile ($PROFILE):
+#   Invoke-Expression (tfv shell-init powershell | Out-String)
+
+function global:Set-LocationWithTfv {
+  param([string]$Path = $PWD)
+  Set-Location $Path
+  if ((Test-Path ".terraform-version") -or (Get-ChildItem -Filter "*.tf" -ErrorAction SilentlyContinue)) {
+    tfv auto-switch --silent 2>$null
+  }
+}
+
+Remove-Item -Path Alias:cd -Force -ErrorAction SilentlyContinue
+Set-Alias -Name cd -Value Set-LocationWithTfv -Scope Global -Force
+
+# Run for current directory on shell startup
+Set-LocationWithTfv -Path $PWD
+
+# ── Tab completions ────────────────────────────────────────────────────────
+Register-ArgumentCompleter -Native -CommandName tfv -ScriptBlock {
+  param($wordToComplete, $commandAst, $cursorPosition)
+
+  $commands = @('install','i','use','auto-switch','as','list','ls','current','which','pin','upgrade','remove','rm','exec','prune','doctor','shell-init','fmt','init','validate','plan','apply','destroy')
+  $elements = $commandAst.CommandElements
+  $prev = if ($elements.Count -ge 2) { $elements[$elements.Count - 2].ToString() } else { '' }
+
+  # Detect --provider / -p anywhere on the line
+  $provider = 'terraform'
+  for ($i = 1; $i -lt $elements.Count - 1; $i++) {
+    if ($elements[$i].ToString() -in '--provider','-p') {
+      $pval = $elements[$i+1].ToString()
+      if ($pval -in 'tofu','opentofu') { $provider = 'opentofu' }
+    }
+  }
+
+  $storeDir = Join-Path $env:USERPROFILE ".tfv\\store\\$provider"
+  $installed = if (Test-Path $storeDir) {
+    Get-ChildItem $storeDir -ErrorAction SilentlyContinue |
+      Where-Object { $_.Name -ne 'arch.json' } |
+      ForEach-Object { $_.Name -replace '\\.exe$','' }
+  } else { @() }
+
+  $completions = switch ($prev) {
+    { $_ -in 'use','exec','remove','rm','pin','upgrade','install','i' } { @($installed) + 'latest' }
+    { $_ -in '--provider','-p' }  { 'terraform','tofu','opentofu' }
+    'shell-init'                  { 'bash','zsh','fish','powershell','pwsh' }
+    default                       { $commands }
+  }
+
+  $completions | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+  }
+}
+`.trim();
+
+const INSTALL_INSTRUCTIONS = {
+  bash: `
+${'\x1b[32m\x1b[1m'}Shell hook generated for bash.${'\x1b[0m'}
+To activate, add this to your ~/.bashrc:
+  eval "$(tfv shell-init bash)"
+Then restart your terminal or run: source ~/.bashrc
+`,
+  zsh: `
+${'\x1b[32m\x1b[1m'}Shell hook generated for zsh.${'\x1b[0m'}
+To activate, add this to your ~/.zshrc:
+  eval "$(tfv shell-init zsh)"
+Then restart your terminal or run: source ~/.zshrc
+`,
+  fish: `
+${'\x1b[32m\x1b[1m'}Shell hook generated for fish.${'\x1b[0m'}
+To activate, add this to your ~/.config/fish/config.fish:
+  tfv shell-init fish | source
+Then restart your terminal or run: source ~/.config/fish/config.fish
+`,
+  powershell: `
+${'\x1b[32m\x1b[1m'}Shell hook generated for PowerShell.${'\x1b[0m'}
+To activate, add this to your $PROFILE:
+  Invoke-Expression (tfv shell-init powershell | Out-String)
+Then restart PowerShell or run: . $PROFILE
+`,
+};
+
+exports.shellInit = (shell) => {
+  const s = (shell || '').toLowerCase().trim();
+
+  if (!SUPPORTED_SHELLS.includes(s)) {
+    console.error(`${P_ERROR}Unsupported shell: ${shell}${P_END}`);
+    console.error(`Supported shells: ${SUPPORTED_SHELLS.join(', ')}`);
+    process.exit(1);
+  }
+
+  // Print the hook script to stdout (intended to be eval'd)
+  if (s === 'fish') {
+    process.stdout.write(FISH_HOOK + '\n');
+  } else if (s === 'powershell' || s === 'pwsh') {
+    process.stdout.write(POWERSHELL_HOOK + '\n');
+  } else {
+    // bash and zsh use the same hook
+    process.stdout.write(BASH_ZSH_HOOK + '\n');
+  }
+
+  // Only print install instructions when stdout is a TTY (i.e. the user ran
+  // tfv shell-init directly). When called inside $() for eval, stdout is a
+  // pipe so isTTY is falsy — suppress the message to avoid it printing on
+  // every `source ~/.zshrc`.
+  const key = s === 'pwsh' ? 'powershell' : s;
+  if (INSTALL_INSTRUCTIONS[key] && process.stdout.isTTY) {
+    process.stderr.write(INSTALL_INSTRUCTIONS[key] + '\n');
+  }
+};

package/lib/modules/switch.js

@@ -1,60 +1,144 @@
 const fs = require('fs');
-const {join} = require('path');
-const {use} = require('./use');
-const {install} = require('./install');
-const {P_END, P_ERROR, P_INFO} = require('../utils/colors');
-const {checkStore} = require('../utils/store');
+const { join } = require('path');
+const { use } = require('./use');
+const { install } = require('./install');
+const { normalizeProvider, getProviderStore, initDirs } = require('../utils/paths');
+const { P_END, P_ERROR, P_INFO } = require('../utils/colors');
+
+/**
+ * Resolve required_version constraint to an exact version number.
+ * Handles: =, ==, >=, >, ~>, and compound constraints (">= 1.3, < 2.0")
+ */
+const resolveConstraint = (constraint, versions) => {
+  // Normalize: remove spaces around operators
+  const parts = constraint.split(',').map(s => s.trim());
+
+  return versions.find(v => {
+    return parts.every(part => {
+      const m = part.match(/^(~>|>=|<=|!=|>|<|=)?\s*(\d+(?:\.\d+)*)/);
+      if (!m) return false;
+      const [, op = '=', req] = m;
+
+      const vParts = v.split('.').map(n => parseInt(n, 10) || 0);
+      const rParts = req.split('.').map(n => parseInt(n, 10) || 0);
+
+      const cmp = () => {
+        for (let i = 0; i < 3; i++) {
+          const diff = (vParts[i] || 0) - (rParts[i] || 0);
+          if (diff !== 0) return diff;
+        }
+        return 0;
+      };
+
+      switch (op) {
+        case '~>': {
+          // pessimistic: allow patch or minor bumps only at the last specified segment
+          const segCount = rParts.length;
+          // major.minor segments must match, only patch can increase
+          for (let i = 0; i < segCount - 1; i++) {
+            if ((vParts[i] || 0) !== (rParts[i] || 0)) return false;
+          }
+          return (vParts[segCount - 1] || 0) >= (rParts[segCount - 1] || 0);
+        }
+        case '>=': return cmp() >= 0;
+        case '>':  return cmp() > 0;
+        case '<=': return cmp() <= 0;
+        case '<':  return cmp() < 0;
+        case '!=': return cmp() !== 0;
+        default:   return cmp() === 0;
+      }
+    });
+  }) || null;
+};
+
+exports.autoSwitch = async (options = {}, providerArg = 'terraform') => {
+  const { silent = false } = options;
+  const log = silent ? () => {} : console.log;
 
-exports.autoSwitch = async () => {
   try {
+    initDirs();
+    const provider = normalizeProvider(providerArg);
+
     let versionFile;
     let tfVersion;
-    const tfState = `terraform.tfstate`;
 
-    if (fs.existsSync(tfState)) {
-      versionFile = tfState;
-      tfVersion = JSON.parse(fs.readFileSync(tfState, 'utf-8'))['terraform_version'];
-    } else {
-      const getAllFiles = fs.readdirSync(process.cwd());
-      const likelyVersionFiles = ['main.tf', 'provider.tf', 'providers.tf', 'versions.tf', 'version.tf', 'backend.tf', 'terraform.tf'];
-      const existingFiles = getAllFiles.filter(f => likelyVersionFiles.indexOf(f) !== -1);
-      const checkVersionIn = existingFiles.concat(getAllFiles.filter(f => existingFiles.indexOf(f) === -1)).filter(f => f.endsWith('.tf'));
-
-      for (let i = 0; i < checkVersionIn.length; i++) {
-        versionFile = checkVersionIn[i];
-        const requiredVersion = fs.readFileSync(versionFile, 'utf-8');
-        const pattern = /^([\s]{0,}required_version)[\s]{0,}=[\s]{0,}"(>=|=|>|~>)[\s]{0,}\d+.*"/m;
-        const specified = requiredVersion.match(pattern);
-
-        if (specified) {
-          const vPattern = /\d+(\.\d+)?(\.\d+)?/;
-          [tfVersion] = specified[0].trim().match(vPattern);
+    // 1. Check .terraform-version file first (tfenv compatibility)
+    const dotVersionFile = join(process.cwd(), '.terraform-version');
+    if (fs.existsSync(dotVersionFile)) {
+      const pinned = fs.readFileSync(dotVersionFile, 'utf-8').trim();
+      if (pinned) {
+        versionFile = '.terraform-version';
+        tfVersion = pinned;
+      }
+    }
+
+    // 2. Check terraform.tfstate for version
+    if (!tfVersion) {
+      const tfState = 'terraform.tfstate';
+      if (fs.existsSync(tfState)) {
+        versionFile = tfState;
+        tfVersion = JSON.parse(fs.readFileSync(tfState, 'utf-8'))['terraform_version'];
+      }
+    }
+
+    // 3. Scan .tf files for required_version
+    if (!tfVersion) {
+      const allFiles = fs.readdirSync(process.cwd());
+      const priority = ['main.tf', 'provider.tf', 'providers.tf', 'versions.tf', 'version.tf', 'backend.tf', 'terraform.tf'];
+      const tfFiles = [
+        ...allFiles.filter(f => priority.includes(f)),
+        ...allFiles.filter(f => f.endsWith('.tf') && !priority.includes(f)),
+      ];
+
+      const pattern = /required_version\s*=\s*"([^"]+)"/m;
+
+      for (const file of tfFiles) {
+        const content = fs.readFileSync(file, 'utf-8');
+        const match = content.match(pattern);
+        if (match) {
+          versionFile = file;
+          tfVersion = match[1].trim();
           break;
         }
       }
     }
 
-    if (tfVersion) {
-      console.log('required_version was found in:', versionFile);
-      const store = join(__dirname, '../..', 'store');
+    if (!tfVersion) {
+      log(`${P_ERROR}No terraform version found.${P_END}`);
+      log(`Create a .terraform-version file or set required_version in a .tf file.`);
+      return;
+    }
+
+    log(`${P_INFO}Found version constraint "${tfVersion}" in: ${versionFile}${P_END}`);
 
-      checkStore(store);
+    const store = getProviderStore(provider);
+    const installedFiles = fs.readdirSync(store).filter(f => f !== 'arch.json');
+    const installedVersions = installedFiles.map(f => f.replace('.exe', ''));
 
-      const inStore = fs.readdirSync(store).find(v => v.startsWith(tfVersion));
+    // If exact version (no operators), use directly
+    let resolved = tfVersion;
+    if (/[><=~!,]/.test(tfVersion)) {
+      const { fetchAllVersions } = require('./remote');
+      const allVersions = await fetchAllVersions(provider);
+      resolved = resolveConstraint(tfVersion, allVersions);
 
-      if (inStore) {
-        await use(inStore.replace('.exe', ''));
-      } else {
-        const version = await install(`${tfVersion}^`);
-        await use(version);
+      if (!resolved) {
+        log(`${P_ERROR}No ${provider} version satisfies constraint: ${tfVersion}${P_END}`);
+        return;
       }
+      log(`${P_INFO}Resolved to: ${resolved}${P_END}`);
+    }
+
+    const inStore = installedVersions.find(v => v === resolved || v.startsWith(resolved));
+    if (inStore) {
+      await use(inStore, provider);
     } else {
-      console.log(`${P_ERROR}NOT FOUND:${P_END}${P_INFO}required_version${P_END}`);
-      console.log(`${P_INFO}check in your remote state file${P_END}`);
+      log(`${P_INFO}${provider} ${resolved} not in store. Installing...${P_END}`);
+      const installed = await install(resolved, null, provider);
+      if (installed) await use(installed, provider);
     }
 
-  } catch ({message}) {
-    console.log('ERROR:', message)
+  } catch (err) {
+    if (!options.silent) console.log(`${P_ERROR}auto-switch error: ${err.message}${P_END}`);
   }
-}
-
+};