Fix: Use full GitHub URLs in extension installation commands (#76)

This pull request updates all documentation to clarify and enforce the correct installation method for the `gemini-flow` extension. The shorthand `github:username/repo` syntax is no longer supported; users must use the full GitHub URL (`https://github.com/username/repo`) when installing extensions via the Gemini CLI. Additional notes and warnings have been added to prevent installation errors.

**Documentation updates to installation instructions:**

* Updated all references in `GEMINI.md`, `README.md`, `docs/releases/GEMINI_CLI_EXTENSIONS_IMPLEMENTATION.md`, and `extensions/gemini-cli/README.md` to use the full GitHub URL for `gemini extensions install`, replacing the unsupported shorthand syntax. [[1]](diffhunk://#diff-399080f41ccf73c6004e0f85c0a58fc1767080a0ef19bb3f3a90caa14f94bd79L32-R32) [[2]](diffhunk://#diff-399080f41ccf73c6004e0f85c0a58fc1767080a0ef19bb3f3a90caa14f94bd79L160-R162) [[3]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L39-R39) [[4]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L492-R492) [[5]](diffhunk://#diff-907131cd4052ab578e08c0789774605fdae373f9dc8bc7ac72acd792b9dd5fb6L86-R90) [[6]](diffhunk://#diff-907131cd4052ab578e08c0789774605fdae373f9dc8bc7ac72acd792b9dd5fb6L279-R279) [[7]](diffhunk://#diff-3fa8814b6d943af60390c832bc271fbe00a4a1085d269289cf705e159eb68d8aL20-R24)
* Updated extension management command examples to use the full GitHub URL for installing additional extensions, ensuring consistency and preventing user confusion. [[1]](diffhunk://#diff-399080f41ccf73c6004e0f85c0a58fc1767080a0ef19bb3f3a90caa14f94bd79L103-R105) [[2]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5L563-R565) [[3]](diffhunk://#diff-907131cd4052ab578e08c0789774605fdae373f9dc8bc7ac72acd792b9dd5fb6L86-R90)
* Added explicit notes and warnings in the documentation to inform users that the shorthand syntax is not supported and will cause installation errors. [[1]](diffhunk://#diff-399080f41ccf73c6004e0f85c0a58fc1767080a0ef19bb3f3a90caa14f94bd79R42-R43) [[2]](diffhunk://#diff-b335630551682c19a781afebcf4d07bf978fb1f8ac04c6bf87428ed5106870f5R502-R503) [[3]](diffhunk://#diff-3fa8814b6d943af60390c832bc271fbe00a4a1085d269289cf705e159eb68d8aL20-R24)

Author: Copilot

GEMINI.md

@@ -29,7 +29,7 @@ gemini-flow is now available as an official Gemini CLI extension, packaging:
 
 ```bash
 # Install from GitHub
-gemini extensions install github:clduab11/gemini-flow
+gemini extensions install https://github.com/clduab11/gemini-flow
 
 # Install from local clone
 cd /path/to/gemini-flow
@@ -39,6 +39,8 @@ gemini extensions install .
 gemini extensions enable gemini-flow
 ```
 
+> **⚠️ Important**: Use the full GitHub URL (`https://github.com/clduab11/gemini-flow`). The shorthand syntax `github:username/repo` is **not supported** and will cause installation errors.
+
 ### Using gemini-flow Commands
 
 Once enabled, use gemini-flow commands directly in Gemini CLI:
@@ -100,7 +102,7 @@ gemini-flow also includes its own extension management commands:
 
 ```bash
 # Using gem-extensions command
-gemini-flow gem-extensions install github:user/extension
+gemini-flow gem-extensions install https://github.com/user/extension
 gemini-flow gem-extensions list
 gemini-flow gem-extensions enable extension-name
 gemini-flow gem-extensions info extension-name
@@ -157,7 +159,7 @@ This documentation is specifically engineered for **Gemini Code Assist** using G
 gemini-flow is now available as an official Gemini CLI extension. Install it with:
 
 ```bash
-gemini extensions install github:clduab11/gemini-flow
+gemini extensions install https://github.com/clduab11/gemini-flow
 ```
 
 ---

README.md

@@ -36,9 +36,9 @@ gemini-flow init --protocols a2a,mcp --topology hierarchical
 gemini-flow agents spawn --count 50 --specialization "enterprise-ready"
 
 # NEW: Official Gemini CLI Extension (October 8, 2025)
-gemini extensions install github:clduab11/gemini-flow  # Install as Gemini extension
-gemini extensions enable gemini-flow                   # Enable the extension
-gemini hive-mind spawn "Build AI application"         # Use commands in Gemini CLI
+gemini extensions install https://github.com/clduab11/gemini-flow  # Install as Gemini extension
+gemini extensions enable gemini-flow                                # Enable the extension
+gemini hive-mind spawn "Build AI application"                      # Use commands in Gemini CLI
 ```
 
 **🚀 Modern Protocol Support**: Native A2A and MCP integration for seamless inter-agent communication and model coordination  
@@ -489,7 +489,7 @@ gemini-flow is now available as an **official Gemini CLI extension**, providing
 
 ```bash
 # Install from GitHub
-gemini extensions install github:clduab11/gemini-flow
+gemini extensions install https://github.com/clduab11/gemini-flow
 
 # Install from local clone
 cd /path/to/gemini-flow
@@ -499,6 +499,8 @@ gemini extensions install .
 gemini extensions enable gemini-flow
 ```
 
+> **Note**: Always use the full GitHub URL format (`https://github.com/username/repo`). The shorthand syntax `github:username/repo` is **not supported** by Gemini CLI and will result in "Install source not found" errors.
+
 ### What's Included
 
 The extension packages gemini-flow's complete AI orchestration platform:
@@ -560,7 +562,7 @@ gemini-flow also includes its own extension management commands:
 
 ```bash
 # Using gem-extensions command
-gemini-flow gem-extensions install github:user/extension
+gemini-flow gem-extensions install https://github.com/user/extension
 gemini-flow gem-extensions list
 gemini-flow gem-extensions enable extension-name
 gemini-flow gem-extensions info extension-name

dist/cli/commands/gem-extensions.js

@@ -0,0 +1,238 @@
+/**
+ * Gemini CLI Extensions Command
+ *
+ * Manages Gemini CLI Extensions (October 2025 framework).
+ * Supports install, enable, disable, update, uninstall, list, and info commands.
+ */
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { Logger } from "../../utils/logger.js";
+import { getExtensionManager } from "../../services/extension-manager.js";
+export class GemExtensionsCommand extends Command {
+    constructor() {
+        super("gem-extensions");
+        this.logger = new Logger("GemExtensions");
+        this.description("Manage Gemini CLI Extensions (Official Framework)")
+            .alias("gem-ext")
+            .addCommand(this.createInstallCommand())
+            .addCommand(this.createListCommand())
+            .addCommand(this.createEnableCommand())
+            .addCommand(this.createDisableCommand())
+            .addCommand(this.createUpdateCommand())
+            .addCommand(this.createUninstallCommand())
+            .addCommand(this.createInfoCommand());
+    }
+    /**
+     * Install command
+     */
+    createInstallCommand() {
+        return new Command("install")
+            .description("Install extension from GitHub or local path")
+            .argument("<source>", "GitHub URL (github:user/repo) or local path")
+            .option("--enable", "Enable extension after installation", false)
+            .action(async (source, options) => {
+            const spinner = ora(`Installing extension from ${source}...`).start();
+            try {
+                const manager = getExtensionManager();
+                const metadata = await manager.install(source);
+                spinner.succeed(`Extension ${chalk.bold(metadata.name)} installed`);
+                console.log(chalk.blue("\n📦 Extension Details:"));
+                console.log(chalk.gray(`  Name: ${metadata.name}`));
+                console.log(chalk.gray(`  Version: ${metadata.version}`));
+                console.log(chalk.gray(`  Description: ${metadata.description || 'N/A'}`));
+                if (options.enable) {
+                    spinner.start("Enabling extension...");
+                    await manager.enable(metadata.name);
+                    spinner.succeed(`Extension ${chalk.bold(metadata.name)} enabled`);
+                }
+                else {
+                    console.log(chalk.yellow("\n💡 Run 'gem-extensions enable ${metadata.name}' to activate"));
+                }
+            }
+            catch (error) {
+                spinner.fail("Installation failed");
+                console.error(chalk.red("Error:"), error instanceof Error ? error.message : error);
+                process.exit(1);
+            }
+        });
+    }
+    /**
+     * List command
+     */
+    createListCommand() {
+        return new Command("list")
+            .description("List all installed extensions")
+            .option("--enabled", "Show only enabled extensions")
+            .option("--disabled", "Show only disabled extensions")
+            .action(async (options) => {
+            const spinner = ora("Loading extensions...").start();
+            try {
+                const manager = getExtensionManager();
+                let extensions = await manager.list();
+                if (options.enabled) {
+                    extensions = extensions.filter(ext => ext.enabled);
+                }
+                else if (options.disabled) {
+                    extensions = extensions.filter(ext => !ext.enabled);
+                }
+                spinner.succeed("Extensions loaded");
+                if (extensions.length === 0) {
+                    console.log(chalk.yellow("\nNo extensions found"));
+                    console.log(chalk.gray("Install an extension with: gem-extensions install <source>"));
+                    return;
+                }
+                console.log(chalk.blue("\n📦 Installed Extensions:\n"));
+                for (const ext of extensions) {
+                    const status = ext.enabled
+                        ? chalk.green("✓ Enabled")
+                        : chalk.gray("○ Disabled");
+                    console.log(chalk.bold(`  ${ext.name}`) + chalk.gray(` v${ext.version}`));
+                    console.log(`    Status: ${status}`);
+                    console.log(chalk.gray(`    ${ext.description || 'No description'}`));
+                    console.log(chalk.gray(`    Installed: ${new Date(ext.installedAt).toLocaleDateString()}`));
+                    console.log();
+                }
+                console.log(chalk.gray(`Total: ${extensions.length} extension(s)`));
+            }
+            catch (error) {
+                spinner.fail("Failed to load extensions");
+                console.error(chalk.red("Error:"), error instanceof Error ? error.message : error);
+                process.exit(1);
+            }
+        });
+    }
+    /**
+     * Enable command
+     */
+    createEnableCommand() {
+        return new Command("enable")
+            .description("Enable an installed extension")
+            .argument("<name>", "Extension name")
+            .action(async (name) => {
+            const spinner = ora(`Enabling extension ${name}...`).start();
+            try {
+                const manager = getExtensionManager();
+                await manager.enable(name);
+                spinner.succeed(`Extension ${chalk.bold(name)} enabled`);
+                console.log(chalk.green("\n✓ Extension is now active"));
+            }
+            catch (error) {
+                spinner.fail("Failed to enable extension");
+                console.error(chalk.red("Error:"), error instanceof Error ? error.message : error);
+                process.exit(1);
+            }
+        });
+    }
+    /**
+     * Disable command
+     */
+    createDisableCommand() {
+        return new Command("disable")
+            .description("Disable an enabled extension")
+            .argument("<name>", "Extension name")
+            .action(async (name) => {
+            const spinner = ora(`Disabling extension ${name}...`).start();
+            try {
+                const manager = getExtensionManager();
+                await manager.disable(name);
+                spinner.succeed(`Extension ${chalk.bold(name)} disabled`);
+                console.log(chalk.yellow("\n⚠️  Extension is now inactive"));
+            }
+            catch (error) {
+                spinner.fail("Failed to disable extension");
+                console.error(chalk.red("Error:"), error instanceof Error ? error.message : error);
+                process.exit(1);
+            }
+        });
+    }
+    /**
+     * Update command
+     */
+    createUpdateCommand() {
+        return new Command("update")
+            .description("Update an installed extension")
+            .argument("<name>", "Extension name")
+            .action(async (name) => {
+            const spinner = ora(`Updating extension ${name}...`).start();
+            try {
+                const manager = getExtensionManager();
+                await manager.update(name);
+                spinner.succeed(`Extension ${chalk.bold(name)} updated`);
+                console.log(chalk.green("\n✓ Extension updated to latest version"));
+            }
+            catch (error) {
+                spinner.fail("Failed to update extension");
+                console.error(chalk.red("Error:"), error instanceof Error ? error.message : error);
+                process.exit(1);
+            }
+        });
+    }
+    /**
+     * Uninstall command
+     */
+    createUninstallCommand() {
+        return new Command("uninstall")
+            .description("Uninstall an extension")
+            .argument("<name>", "Extension name")
+            .option("--force", "Skip confirmation prompt", false)
+            .action(async (name, options) => {
+            if (!options.force) {
+                console.log(chalk.yellow(`\n⚠️  This will permanently remove extension: ${chalk.bold(name)}`));
+                // In a real implementation, we'd use inquirer to prompt for confirmation
+                console.log(chalk.gray("Use --force to skip this confirmation\n"));
+            }
+            const spinner = ora(`Uninstalling extension ${name}...`).start();
+            try {
+                const manager = getExtensionManager();
+                await manager.uninstall(name);
+                spinner.succeed(`Extension ${chalk.bold(name)} uninstalled`);
+                console.log(chalk.green("\n✓ Extension removed successfully"));
+            }
+            catch (error) {
+                spinner.fail("Failed to uninstall extension");
+                console.error(chalk.red("Error:"), error instanceof Error ? error.message : error);
+                process.exit(1);
+            }
+        });
+    }
+    /**
+     * Info command
+     */
+    createInfoCommand() {
+        return new Command("info")
+            .description("Show detailed information about an extension")
+            .argument("<name>", "Extension name")
+            .action(async (name) => {
+            const spinner = ora(`Loading extension info...`).start();
+            try {
+                const manager = getExtensionManager();
+                const info = await manager.info(name);
+                if (!info) {
+                    spinner.fail(`Extension ${name} not found`);
+                    return;
+                }
+                spinner.succeed("Extension info loaded");
+                console.log(chalk.blue("\n📦 Extension Details:\n"));
+                console.log(chalk.bold(`  Name: `) + info.name);
+                console.log(chalk.bold(`  Display Name: `) + (info.displayName || info.name));
+                console.log(chalk.bold(`  Version: `) + info.version);
+                console.log(chalk.bold(`  Author: `) + (info.author || 'Unknown'));
+                console.log(chalk.bold(`  Description: `) + (info.description || 'N/A'));
+                console.log(chalk.bold(`  Status: `) + (info.enabled ? chalk.green("Enabled") : chalk.gray("Disabled")));
+                console.log(chalk.bold(`  Source: `) + info.source);
+                console.log(chalk.bold(`  Installed: `) + new Date(info.installedAt).toLocaleString());
+                if (info.updatedAt) {
+                    console.log(chalk.bold(`  Updated: `) + new Date(info.updatedAt).toLocaleString());
+                }
+                console.log();
+            }
+            catch (error) {
+                spinner.fail("Failed to load extension info");
+                console.error(chalk.red("Error:"), error instanceof Error ? error.message : error);
+                process.exit(1);
+            }
+        });
+    }
+}
+export default GemExtensionsCommand;

dist/cli/commands/index.js

@@ -18,4 +18,4 @@ export { WorkspaceCommand } from "./workspace.js";
 export { GeminiCommand } from "./gemini.js";
 export { DGMCommand } from "./dgm.js";
 export { JulesCommand } from "./jules.js";
-export { ExtensionsCommand } from "./extensions.js";
+export { GemExtensionsCommand } from "./gem-extensions.js";

dist/cli/full-index.js

@@ -12,7 +12,7 @@ import { fileURLToPath } from "url";
 import { Logger } from "../utils/logger.js";
 import { ConfigManager } from "./config/config-manager.js";
 // Import all command modules
-import { InitCommand, SwarmCommand, AgentCommand, TaskCommand, SparcCommand, HiveMindCommand, MemoryCommand, HooksCommand, SecurityFlagsCommand, ConfigCommand, WorkspaceCommand, GeminiCommand, DGMCommand, JulesCommand, ExtensionsCommand, } from "./commands/index.js";
+import { InitCommand, SwarmCommand, AgentCommand, TaskCommand, SparcCommand, HiveMindCommand, MemoryCommand, HooksCommand, SecurityFlagsCommand, ConfigCommand, WorkspaceCommand, GeminiCommand, DGMCommand, JulesCommand, GemExtensionsCommand, } from "./commands/index.js";
 // ES module equivalent of __dirname
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -83,7 +83,7 @@ function setupCommands() {
     program.addCommand(new GeminiCommand());
     program.addCommand(new DGMCommand());
     program.addCommand(new JulesCommand());
-    program.addCommand(new ExtensionsCommand());
+    program.addCommand(new GemExtensionsCommand());
     // QueryCommand has a special constructor, let's skip it for now
     // program.addCommand(new QueryCommand());
     // Additional aliases for commonly used commands