Release 0.7.0: favorite agent + Ctrl+Alt+A keybinding, install-status indicator

- Mark a favorite agent with the inline star button; launch it with Ctrl+Alt+A
  (Cmd+Alt+A on macOS, remappable). No favorite set -> picker + offer to remember.
  Stored in the new superCli.favoriteAgent setting.
- Show agents whose CLI is not on PATH as dimmed and "not installed" (best-effort,
  no process spawned; skipped under superCli.useWsl).
- New command-utils helper executableExistsOnPath (PATH + PATHEXT scan) with tests.

Author: TheStreamCode

CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [0.7.0]
+
+- **Favorite agent.** Mark an agent as your favorite with the star (★) button next to it in the
+  sidebar, and launch it from anywhere with **`Ctrl+Alt+A`** (`Cmd+Alt+A` on macOS; remappable in
+  Keyboard Shortcuts). When no favorite is set, the shortcut opens the picker and offers to remember
+  your choice. Stored in the new `superCli.favoriteAgent` setting.
+- **Install-status indicator.** Agents whose CLI isn't found on your `PATH` are shown dimmed and
+  marked *not installed* (best-effort, no process spawned). Not shown under `superCli.useWsl`, since
+  the Windows `PATH` doesn't reflect what's installed inside WSL.
+
 ## [0.6.2]
 
 - Added an **Open VSX** badge to the README (Super CLI is published on Open VSX for Cursor, Windsurf, VSCodium, and Gitpod users).

README.md

@@ -36,6 +36,11 @@ You can also open the Extensions view in VS Code (or Cursor, Antigravity, Windsu
 - **One launcher for every agent.** A **Super CLI** view in the activity bar lists all configured
   agents; click one to open it in a terminal beside your editor. A toolbar button and the
   **Super CLI: Launch Coding Agent** command open a quick pick of the same list.
+- **Favorite agent, one keystroke.** Click the star (★) next to an agent to mark it as your favorite,
+  then launch it anywhere with **`Ctrl+Alt+A`** (`Cmd+Alt+A` on macOS; remap it in Keyboard
+  Shortcuts). With no favorite set the shortcut opens the picker and offers to remember your choice.
+- **Install status at a glance.** Agents whose CLI isn't on your `PATH` are shown dimmed and marked
+  *not installed*, so you know what to install before launching.
 - **Built-in presets.** Claude Code, Codex, GitHub Copilot CLI, Cursor, Droid, Grok, Kilo, Antigravity,
   OpenCode, Command Code, Crush, Hermes, and MiMo Code are available out of the box. (Gemini CLI was
   retired by Google and replaced by Antigravity.)
@@ -103,6 +108,7 @@ an untrusted repository cannot inject commands.
 | --- | --- | --- |
 | `superCli.agents` | `[]` | Your agents (added to or overriding the built-ins). |
 | `superCli.useBuiltins` | `true` | Include the built-in agent presets. |
+| `superCli.favoriteAgent` | `""` | Id of the agent launched by `Ctrl+Alt+A`. Set it with the ★ button in the sidebar rather than by hand. |
 | `superCli.terminalLocation` | `beside` | Open the terminal `beside` the editor or in the `panel`. |
 | `superCli.useWsl` | `false` | On Windows, open agents in a WSL terminal instead of the default shell. Ignored on macOS/Linux. |
 
@@ -118,6 +124,9 @@ settings.
   directory.
 - **Nothing happens on launch.** Make sure the workspace is trusted — the launcher is disabled in
   untrusted workspaces because it runs terminal commands.
+- **"Not installed" looks wrong.** The indicator is a best-effort check of your `PATH` and doesn't
+  spawn the CLI. It isn't shown when `superCli.useWsl` is on, because the Windows `PATH` doesn't
+  reflect what's installed inside WSL. Use **Refresh Agents** after installing a CLI.
 - **Companion editor extensions (Command Code, Claude Code).** Super CLI keeps your editor free of
   per-CLI companion extensions. It launches **Command Code** with `autoInstallExtension: false` in
   `~/.commandcode/config.json`, and **Claude Code** with the `CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL=1`

package-lock.json

@@ -3,7 +3,7 @@
   "displayName": "Super CLI — AI Coding Agent Launcher (Claude Code, Codex, Copilot)",
   "description": "Launch any AI coding-agent CLI — Claude Code, Codex, GitHub Copilot, Cursor, Crush, OpenCode and more — from one sidebar and side terminal. Works in VS Code, Cursor, Antigravity & Windsurf on Windows, macOS & Linux.",
   "publisher": "mikesoft",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/TheStreamCode/super-cli.git"
@@ -102,6 +102,23 @@
         "category": "Super CLI",
         "icon": "$(play)"
       },
+      {
+        "command": "superCli.launchFavorite",
+        "title": "Launch Favorite Agent",
+        "category": "Super CLI"
+      },
+      {
+        "command": "superCli.setFavorite",
+        "title": "Set as Favorite",
+        "category": "Super CLI",
+        "icon": "$(star-empty)"
+      },
+      {
+        "command": "superCli.unsetFavorite",
+        "title": "Remove Favorite",
+        "category": "Super CLI",
+        "icon": "$(star-full)"
+      },
       {
         "command": "superCli.updateAgent",
         "title": "Update Agent",
@@ -147,16 +164,34 @@
           "group": "inline@1"
         },
         {
-          "command": "superCli.updateAgent",
-          "when": "view == superCli.agents && viewItem == agent-updatable",
+          "command": "superCli.setFavorite",
+          "when": "view == superCli.agents && viewItem =~ /^agent(?!.*favorite)/",
           "group": "inline@2"
+        },
+        {
+          "command": "superCli.unsetFavorite",
+          "when": "view == superCli.agents && viewItem =~ /favorite/",
+          "group": "inline@2"
+        },
+        {
+          "command": "superCli.updateAgent",
+          "when": "view == superCli.agents && viewItem =~ /updatable/",
+          "group": "inline@3"
         }
       ],
       "commandPalette": [
         {
           "command": "superCli.launchAgent",
           "when": "false"
         },
+        {
+          "command": "superCli.setFavorite",
+          "when": "false"
+        },
+        {
+          "command": "superCli.unsetFavorite",
+          "when": "false"
+        },
         {
           "command": "superCli.updateAgent",
           "when": "false"
@@ -167,6 +202,13 @@
         }
       ]
     },
+    "keybindings": [
+      {
+        "command": "superCli.launchFavorite",
+        "key": "ctrl+alt+a",
+        "mac": "cmd+alt+a"
+      }
+    ],
     "configuration": {
       "title": "Super CLI",
       "properties": {
@@ -280,6 +322,12 @@
           "default": true,
           "description": "Include the built-in agent presets (Claude Code, Codex, Copilot, Grok, Kilo, Antigravity, OpenCode, Command Code, Cursor, Droid, Crush, Hermes, MiMo Code) in the launcher."
         },
+        "superCli.favoriteAgent": {
+          "type": "string",
+          "scope": "machine",
+          "default": "",
+          "markdownDescription": "Id of the favorite agent launched by the `Launch Favorite Agent` command (default keybinding `Ctrl+Alt+A`, `Cmd+Alt+A` on macOS; remap it from Keyboard Shortcuts). Set this with the star (★) button next to an agent in the sidebar rather than editing it by hand."
+        },
         "superCli.terminalLocation": {
           "type": "string",
           "enum": [

package.json

@@ -109,6 +109,53 @@ export function resolveHomePath(p: string, homedir: string): string {
   return p;
 }
 
+const DEFAULT_PATHEXT = '.COM;.EXE;.BAT;.CMD';
+
+/** Returns the executable extensions to try on Windows (the bare name plus each PATHEXT entry). */
+function resolveWindowsExtensions(pathExt: string | undefined): string[] {
+  const entries = (pathExt && pathExt.trim() ? pathExt : DEFAULT_PATHEXT)
+    .split(';')
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+
+  return ['', ...entries];
+}
+
+/**
+ * Best-effort check that a command's executable resolves on PATH, without spawning a process.
+ * On Windows the bare name is also tried with each PATHEXT extension. `fileExists` is injected so
+ * the logic stays pure and testable; production passes `fs.existsSync`.
+ */
+export function executableExistsOnPath(
+  command: string,
+  env: Record<string, string | undefined>,
+  platform: string,
+  fileExists: (filePath: string) => boolean,
+): boolean {
+  const executable = extractExecutable(command);
+  if (!executable) {
+    return false;
+  }
+
+  const isWindows = platform === 'win32';
+  const extensions = isWindows ? resolveWindowsExtensions(env.PATHEXT) : [''];
+  const existsWithExt = (base: string): boolean => extensions.some((ext) => fileExists(base + ext));
+
+  // A path-qualified command is checked directly, not searched on PATH.
+  if (/[\\/]/.test(executable)) {
+    return existsWithExt(executable);
+  }
+
+  const pathValue = env.PATH ?? env.Path ?? '';
+  const delimiter = isWindows ? ';' : ':';
+  const separator = isWindows ? '\\' : '/';
+
+  return pathValue
+    .split(delimiter)
+    .filter((dir) => dir.length > 0)
+    .some((dir) => existsWithExt(dir.replace(/[\\/]+$/, '') + separator + executable));
+}
+
 /** Adds only the keys from `defaults` that are absent in `existing`; reports whether anything changed. */
 export function mergeMissingDefaults(
   existing: Record<string, unknown>,

src/command-utils.ts

@@ -1,5 +1,7 @@
+import * as fs from 'node:fs';
 import * as vscode from 'vscode';
 import { type Agent, BUILTIN_AGENTS, resolveAgents } from './agents.js';
+import { executableExistsOnPath } from './command-utils.js';
 import { AgentTreeDataProvider } from './tree.js';
 import { launchAgent, openExtensionSettings, updateAgent } from './terminal.js';
 
@@ -17,15 +19,53 @@ function getEffectiveAgents(): Agent[] {
   return resolveAgents(BUILTIN_AGENTS, userAgents, useBuiltins);
 }
 
+/** Returns the id of the user's favorite agent, or '' when none is set. */
+function getFavoriteId(): string {
+  return vscode.workspace.getConfiguration(SETTINGS_NAMESPACE).get<string>('favoriteAgent', '');
+}
+
+/** Persists the favorite agent id (or clears it when empty) at the user (global) level. */
+async function setFavoriteId(id: string): Promise<void> {
+  await vscode.workspace
+    .getConfiguration(SETTINGS_NAMESPACE)
+    .update('favoriteAgent', id || undefined, vscode.ConfigurationTarget.Global);
+}
+
 interface AgentQuickPickItem extends vscode.QuickPickItem {
   agent: Agent;
 }
 
 export function activate(context: vscode.ExtensionContext): void {
-  const treeProvider = new AgentTreeDataProvider(getEffectiveAgents);
+  // Best-effort "installed / not installed" status per agent, keyed by id (undefined = unknown).
+  const installStatus = new Map<string, boolean>();
+
+  const treeProvider = new AgentTreeDataProvider(
+    getEffectiveAgents,
+    getFavoriteId,
+    (id) => installStatus.get(id),
+  );
   const treeView = vscode.window.createTreeView('superCli.agents', { treeDataProvider: treeProvider });
 
-  const launchCommand = vscode.commands.registerCommand('superCli.launch', async () => {
+  // Recomputes install status off the activation path. Under WSL the host PATH is not representative,
+  // so status is left unknown rather than reported as missing.
+  const refreshInstallStatus = (): void => {
+    setTimeout(() => {
+      installStatus.clear();
+      const useWsl = vscode.workspace.getConfiguration(SETTINGS_NAMESPACE).get<boolean>('useWsl', false)
+        && process.platform === 'win32';
+
+      if (!useWsl) {
+        for (const agent of getEffectiveAgents()) {
+          installStatus.set(agent.id, executableExistsOnPath(agent.command, process.env, process.platform, fs.existsSync));
+        }
+      }
+
+      treeProvider.refresh();
+    }, 0);
+  };
+
+  // Shows the agent picker and launches the chosen agent; optionally offers to remember it as favorite.
+  const runLaunchQuickPick = async (offerFavorite: boolean): Promise<void> => {
     const agents = getEffectiveAgents();
 
     if (agents.length === 0) {
@@ -46,9 +86,37 @@ export function activate(context: vscode.ExtensionContext): void {
       { placeHolder: 'Select a coding agent to launch' },
     );
 
-    if (picked) {
-      await launchAgent(picked.agent, context, terminalSequence++);
+    if (!picked) {
+      return;
+    }
+
+    await launchAgent(picked.agent, context, terminalSequence++);
+
+    if (offerFavorite) {
+      const choice = await vscode.window.showInformationMessage(
+        `Set "${picked.agent.label}" as your favorite agent? You can then launch it with Ctrl+Alt+A.`,
+        'Set Favorite',
+      );
+
+      if (choice === 'Set Favorite') {
+        await setFavoriteId(picked.agent.id);
+      }
+    }
+  };
+
+  const launchCommand = vscode.commands.registerCommand('superCli.launch', () => runLaunchQuickPick(false));
+
+  const launchFavoriteCommand = vscode.commands.registerCommand('superCli.launchFavorite', async () => {
+    const favoriteId = getFavoriteId();
+    const favorite = favoriteId ? getEffectiveAgents().find((agent) => agent.id === favoriteId) : undefined;
+
+    if (favorite) {
+      await launchAgent(favorite, context, terminalSequence++);
+      return;
     }
+
+    // No favorite set (or it no longer exists): let the user pick one and offer to remember it.
+    await runLaunchQuickPick(true);
   });
 
   const launchAgentCommand = vscode.commands.registerCommand('superCli.launchAgent', async (agent?: Agent) => {
@@ -59,6 +127,23 @@ export function activate(context: vscode.ExtensionContext): void {
     await launchAgent(agent, context, terminalSequence++);
   });
 
+  const setFavoriteCommand = vscode.commands.registerCommand('superCli.setFavorite', async (agent?: Agent) => {
+    if (!agent) {
+      return;
+    }
+
+    await setFavoriteId(agent.id);
+    void vscode.window.setStatusBarMessage(`${agent.label} is now the favorite agent`, 2500);
+  });
+
+  const unsetFavoriteCommand = vscode.commands.registerCommand('superCli.unsetFavorite', async (agent?: Agent) => {
+    if (!agent) {
+      return;
+    }
+
+    await setFavoriteId('');
+  });
+
   const updateAgentCommand = vscode.commands.registerCommand('superCli.updateAgent', async (agent?: Agent) => {
     if (!agent) {
       return;
@@ -68,6 +153,7 @@ export function activate(context: vscode.ExtensionContext): void {
   });
 
   const refreshCommand = vscode.commands.registerCommand('superCli.refresh', () => {
+    refreshInstallStatus();
     treeProvider.refresh();
   });
 
@@ -76,15 +162,26 @@ export function activate(context: vscode.ExtensionContext): void {
   });
 
   const configWatcher = vscode.workspace.onDidChangeConfiguration((event) => {
-    if (event.affectsConfiguration('superCli.agents') || event.affectsConfiguration('superCli.useBuiltins')) {
+    if (event.affectsConfiguration('superCli.agents') || event.affectsConfiguration('superCli.useBuiltins')
+      || event.affectsConfiguration('superCli.useWsl')) {
+      refreshInstallStatus();
+    }
+
+    if (event.affectsConfiguration('superCli.agents') || event.affectsConfiguration('superCli.useBuiltins')
+      || event.affectsConfiguration('superCli.favoriteAgent')) {
       treeProvider.refresh();
     }
   });
 
+  refreshInstallStatus();
+
   context.subscriptions.push(
     treeView,
     launchCommand,
+    launchFavoriteCommand,
     launchAgentCommand,
+    setFavoriteCommand,
+    unsetFavoriteCommand,
     updateAgentCommand,
     refreshCommand,
     openSettingsCommand,