antigravity-seo-kit 2.7.4 → 2.9.7

package/README.md

@@ -14,7 +14,7 @@ npx antigravity-seo-kit install-plugin --key=SK-XXXX-XXXX-XXXX
 # OR: npx antigravity-seo-kit install --global --key=SK-XXXX-XXXX-XXXX
 ```
 
-When you start work in a new workspace, run the following command to sync the agent rules and folders locally:
+When you start work in a new workspace, run the following command to sync the `.agents/` structure locally:
 ```bash
 npx antigravity-seo-kit setup-workspace
 ```
@@ -45,12 +45,15 @@ npx antigravity-seo-kit install --key=SK-XXXX-XXXX-XXXX
 # Install globally as a plugin (recommended)
 npx antigravity-seo-kit install-plugin --key=SK-XXXX-XXXX-XXXX
 
-# Replicate .agent config directory from global plugin to local workspace
+# Replicate .agents/ workspace structure from global plugin
 npx antigravity-seo-kit setup-workspace
 
 # Install locally into current workspace
 npx antigravity-seo-kit install --key=SK-XXXX-XXXX-XXXX
 
+# Migrate from v2.x (.agent/) to v3.0 (.agents/)
+npx antigravity-seo-kit migrate
+
 # Update to latest version
 npx antigravity-seo-kit update
 

package/bin/cli.js

@@ -75,6 +75,12 @@ async function main() {
         break;
       }
 
+      case 'migrate': {
+        showBanner();
+        installer.migrate(cwd);
+        break;
+      }
+
       case 'update': {
         showBanner();
         await installer.update(cwd);

package/lib/downloader.js

@@ -149,6 +149,7 @@ function extractTarGz(gzBuffer, targetDir) {
       const isConfigJson = fullName.endsWith('.json') &&
         (fullName.startsWith('config/') ||
          fullName.startsWith('.agent/config/') ||
+         fullName.startsWith('.agents/config/') ||
          fullName.includes('/config/'));
 
       fs.mkdirSync(path.dirname(targetPath), { recursive: true });

package/lib/installer.js

@@ -69,7 +69,70 @@ async function install(licenseKey, cwd) {
     process.exit(1);
   }
 
-  // Step 3: Save license info + manifest
+  // Step 3: Restructure into .agents/ format if server sent legacy .agent/
+  const legacyAgentDir = path.join(cwd, '.agent');
+  const newAgentsDir = path.join(cwd, '.agents');
+
+  if (fs.existsSync(legacyAgentDir) && !fs.existsSync(newAgentsDir)) {
+    const spinMigrate = spinner('Restructuring to .agents/ format...').start();
+    try {
+      fs.mkdirSync(newAgentsDir, { recursive: true });
+
+      // Workspace-level dirs → .agents/
+      const workspaceDirs = ['agents', 'workflows', 'scripts', 'config', 'dashboard', 'docs', '.shared'];
+      let migrateCount = 0;
+      for (const dir of workspaceDirs) {
+        const src = path.join(legacyAgentDir, dir);
+        const dest = path.join(newAgentsDir, dir);
+        if (fs.existsSync(src)) {
+          migrateCount += copyRecursive(src, dest, { overwrite: true });
+        }
+      }
+
+      // Root-level .md files → .agents/
+      for (const f of fs.readdirSync(legacyAgentDir)) {
+        const src = path.join(legacyAgentDir, f);
+        if (fs.statSync(src).isFile() && f.endsWith('.md')) {
+          fs.copyFileSync(src, path.join(newAgentsDir, f));
+          migrateCount++;
+        }
+      }
+
+      // skills + rules → .agents/plugins/antigravity-seo-kit/
+      const pluginDir = path.join(newAgentsDir, 'plugins', 'antigravity-seo-kit');
+      fs.mkdirSync(pluginDir, { recursive: true });
+
+      const skillsSrc = path.join(legacyAgentDir, 'skills');
+      if (fs.existsSync(skillsSrc)) {
+        migrateCount += copyRecursive(skillsSrc, path.join(pluginDir, 'skills'), { overwrite: true });
+      }
+      const rulesSrc = path.join(legacyAgentDir, 'rules');
+      if (fs.existsSync(rulesSrc)) {
+        migrateCount += copyRecursive(rulesSrc, path.join(pluginDir, 'rules'), { overwrite: true });
+      }
+
+      // Create plugin.json
+      const pluginJsonPath = path.join(pluginDir, 'plugin.json');
+      if (!fs.existsSync(pluginJsonPath)) {
+        fs.writeFileSync(pluginJsonPath, JSON.stringify({
+          name: 'antigravity-seo-kit',
+          version: PACKAGE_VERSION,
+          description: 'Professional Agentic SEO Platform — 44+ specialized skills',
+          author: { name: 'Solann', email: 'admin@solann.io' },
+        }, null, 2), 'utf-8');
+      }
+
+      // Remove legacy .agent/ (downloaded files only, not user data)
+      removeRecursive(legacyAgentDir);
+
+      spinMigrate.succeed(`Restructured to .agents/ format (${migrateCount} files)`);
+    } catch (err) {
+      spinMigrate.fail('Restructuring failed, keeping .agent/ as-is');
+      warn(`You can manually run: npx antigravity-seo-kit migrate`);
+    }
+  }
+
+  // Step 4: Save license info + manifest
   writeLicenseFile(cwd, {
     key: licenseKey,
     deviceId,
@@ -122,6 +185,10 @@ async function update(cwd) {
     process.exit(1);
   }
 
+  // Detect structure: v3.0 (.agents/) or v2.x (.agent/)
+  const isV3 = fs.existsSync(path.join(cwd, '.agents'));
+  const isV2 = fs.existsSync(path.join(cwd, '.agent'));
+
   // Download latest assets from server
   console.log('');
   const spinDl = spinner('Downloading latest SEO Kit assets...').start();
@@ -136,6 +203,13 @@ async function update(cwd) {
     process.exit(1);
   }
 
+  // If user was on v2 (.agent/) and download brings v3 (.agents/), inform about migrate
+  if (isV2 && !isV3 && fs.existsSync(path.join(cwd, '.agents'))) {
+    console.log('');
+    info('v3.0 structure detected in update. Run migrate to complete:');
+    console.log(`  ${colorize('cyan', 'npx antigravity-seo-kit migrate')}`);
+  }
+
   // Update license file
   config.version = PACKAGE_VERSION;
   config.updatedAt = new Date().toISOString();
@@ -160,7 +234,7 @@ async function uninstall(cwd) {
   let totalRemoved = 0;
 
   if (config.installedFiles && config.installedFiles.length > 0) {
-    // New approach: use manifest from license file
+    // Manifest-based removal
     for (const filePath of config.installedFiles) {
       const target = path.join(cwd, filePath);
       if (fs.existsSync(target)) {
@@ -168,13 +242,20 @@ async function uninstall(cwd) {
         totalRemoved++;
       }
     }
-    // Clean up empty directories
+    // Clean up empty directories for both v2 and v3 structures
     cleanEmptyDirsUp(path.join(cwd, '.agent'));
+    cleanEmptyDirsUp(path.join(cwd, '.agents'));
   } else {
-    // Legacy fallback: use hardcoded arrays
+    // Legacy fallback: use prefix scan
     totalRemoved += legacyUninstall(cwd);
   }
 
+  // Also clean .agents/plugins/antigravity-seo-kit/ if it exists (v3)
+  const v3PluginDir = path.join(cwd, '.agents', 'plugins', 'antigravity-seo-kit');
+  if (fs.existsSync(v3PluginDir)) {
+    totalRemoved += removeRecursive(v3PluginDir);
+  }
+
   // Remove license file
   removeLicenseFile(cwd);
 
@@ -253,24 +334,41 @@ async function status(cwd) {
 
   // Count installed files
   if (config.installedFiles && config.installedFiles.length > 0) {
-    // New: count from manifest
+    // Manifest-based count
     let existingFiles = 0;
     for (const f of config.installedFiles) {
       if (fs.existsSync(path.join(cwd, f))) existingFiles++;
     }
     console.log(`  ${colorize('cyan', 'Files:')}        ${existingFiles}/${config.installedFiles.length} present`);
   } else {
-    // Legacy: scan for seo-* prefixed entries
-    const agentDir = path.join(cwd, '.agent');
+    // Legacy: scan for seo-* prefixed entries in both .agent/ and .agents/
     let totalLegacy = 0;
-    for (const subDir of LEGACY_DIRS) {
-      const dirPath = path.join(agentDir, subDir);
-      if (!fs.existsSync(dirPath)) continue;
-      for (const entry of fs.readdirSync(dirPath)) {
-        if (entry.startsWith(LEGACY_SEO_PREFIX) || entry === 'seo') totalLegacy++;
+    for (const baseDir of ['.agent', '.agents']) {
+      const agentDir = path.join(cwd, baseDir);
+      if (!fs.existsSync(agentDir)) continue;
+      for (const subDir of LEGACY_DIRS) {
+        const dirPath = path.join(agentDir, subDir);
+        if (!fs.existsSync(dirPath)) continue;
+        for (const entry of fs.readdirSync(dirPath)) {
+          if (entry.startsWith(LEGACY_SEO_PREFIX) || entry === 'seo') totalLegacy++;
+        }
       }
     }
-    console.log(`  ${colorize('cyan', 'Components:')}  ${totalLegacy} installed (legacy)`);
+    // Also count plugin dir if v3
+    const pluginSkillsDir = path.join(cwd, '.agents', 'plugins', 'antigravity-seo-kit', 'skills');
+    if (fs.existsSync(pluginSkillsDir)) {
+      totalLegacy += fs.readdirSync(pluginSkillsDir).length;
+    }
+    console.log(`  ${colorize('cyan', 'Components:')}  ${totalLegacy} installed`);
+  }
+
+  // Detect structure version
+  const hasV3 = fs.existsSync(path.join(cwd, '.agents'));
+  const hasV2 = fs.existsSync(path.join(cwd, '.agent'));
+  const structureVersion = hasV3 ? 'v3.0 (.agents/)' : hasV2 ? 'v2.x (.agent/)' : 'unknown';
+  console.log(`  ${colorize('cyan', 'Structure:')}   ${structureVersion}`);
+  if (hasV2 && !hasV3) {
+    warn('Using legacy v2.x structure. Run: npx antigravity-seo-kit migrate');
   }
   console.log('');
 
@@ -436,51 +534,72 @@ async function installPlugin(licenseKey) {
     process.exit(1);
   }
 
-  // Step 3: Move files/folders inside the `.agent/` subdirectory up to the plugin root
-  const agentDir = path.join(globalPluginDir, '.agent');
-  if (fs.existsSync(agentDir)) {
-    const entries = fs.readdirSync(agentDir);
+  // Step 3: Restructure into .agents/ plugin format
+  // v3.0: Downloaded assets arrive in .agents/ structure already
+  // Handle legacy .agent/ if server still serves old format
+  const legacyAgentDir = path.join(globalPluginDir, '.agent');
+  const newAgentsDir = path.join(globalPluginDir, '.agents');
+
+  if (fs.existsSync(legacyAgentDir) && !fs.existsSync(newAgentsDir)) {
+    // Legacy format: flatten .agent/ into plugin root
+    const entries = fs.readdirSync(legacyAgentDir);
     for (const entry of entries) {
-      const srcPath = path.join(agentDir, entry);
+      const srcPath = path.join(legacyAgentDir, entry);
       const destPath = path.join(globalPluginDir, entry);
       if (fs.existsSync(destPath)) {
         removeRecursive(destPath);
       }
       fs.renameSync(srcPath, destPath);
     }
-    removeRecursive(agentDir);
+    removeRecursive(legacyAgentDir);
+  } else if (fs.existsSync(newAgentsDir)) {
+    // v3.0 format: move plugin contents (skills, rules) to plugin root
+    const pluginSrcDir = path.join(newAgentsDir, 'plugins', 'antigravity-seo-kit');
+    if (fs.existsSync(pluginSrcDir)) {
+      for (const entry of fs.readdirSync(pluginSrcDir)) {
+        const srcPath = path.join(pluginSrcDir, entry);
+        const destPath = path.join(globalPluginDir, entry);
+        if (fs.existsSync(destPath)) {
+          removeRecursive(destPath);
+        }
+        fs.renameSync(srcPath, destPath);
+      }
+    }
+    // Keep workspace-level dirs (agents, workflows) for setupWorkspace
+    const workspaceDirs = ['agents', 'workflows', 'scripts', 'config', 'dashboard', 'docs', '.shared'];
+    for (const dir of workspaceDirs) {
+      const srcDir = path.join(newAgentsDir, dir);
+      const destDir = path.join(globalPluginDir, `_workspace_${dir}`);
+      if (fs.existsSync(srcDir)) {
+        if (fs.existsSync(destDir)) removeRecursive(destDir);
+        fs.renameSync(srcDir, destDir);
+      }
+    }
+    // Copy seo-architecture.md
+    const archFile = path.join(newAgentsDir, 'seo-architecture.md');
+    if (fs.existsSync(archFile)) {
+      fs.copyFileSync(archFile, path.join(globalPluginDir, '_workspace_seo-architecture.md'));
+    }
+    removeRecursive(newAgentsDir);
   }
 
-  // Step 4: Generate plugin.json and installed_version.json
-  const pluginJson = {
-    name: "antigravity-seo-kit",
-    version: PACKAGE_VERSION,
-    description: "Professional Agentic SEO Platform for Google Antigravity 2 AI Agent — 44 specialized skills covering technical audit, E-E-A-T, schema, GEO, local SEO & more",
-    author: {
-      name: "Antigravity SEO Kit",
-      email: "admin@solann.io",
-    },
-    repository: "https://solann.io/antigravity-seo-kit",
-    license: "SEE LICENSE IN LICENSE",
-    keywords: [
-      "seo",
-      "agentic-seo",
-      "ai-agent",
-      "antigravity",
-      "seo-geo",
-      "seo-audit",
-      "seo-toolkit",
-      "agent-skills",
-      "seo-analysis",
-      "technical-seo",
-      "eeat"
-    ]
-  };
-  fs.writeFileSync(path.join(globalPluginDir, 'plugin.json'), JSON.stringify(pluginJson, null, 2), 'utf-8');
+  // Step 4: Ensure plugin.json and installed_version.json
+  const pluginJsonPath = path.join(globalPluginDir, 'plugin.json');
+  if (!fs.existsSync(pluginJsonPath)) {
+    const pluginJson = {
+      name: "antigravity-seo-kit",
+      version: PACKAGE_VERSION,
+      description: "Professional Agentic SEO Platform — 44+ specialized skills",
+      author: { name: "Solann", email: "admin@solann.io" },
+      repository: "https://solann.io/antigravity-seo-kit",
+      license: "SEE LICENSE IN LICENSE",
+      keywords: ["seo", "agentic-seo", "ai-agent", "antigravity"]
+    };
+    fs.writeFileSync(pluginJsonPath, JSON.stringify(pluginJson, null, 2), 'utf-8');
+  }
   fs.writeFileSync(path.join(globalPluginDir, 'installed_version.json'), JSON.stringify({ version: PACKAGE_VERSION }), 'utf-8');
 
   // Step 5: Save global license info + manifest
-  const LICENSE_FILE = '.seo-kit-license';
   writeLicenseFile(globalPluginDir, {
     key: licenseKey,
     deviceId,
@@ -488,19 +607,19 @@ async function installPlugin(licenseKey) {
     version: PACKAGE_VERSION,
     installedAt: new Date().toISOString(),
     plan: verifyResult?.license?.planName || verifyResult?.license?.plan || 'unknown',
-    installedFiles: downloadResult.files.map(f => f.replace(/^\.agent\//, '')),
+    installedFiles: downloadResult.files.map(f => f.replace(/^\.agents?\//, '')),
   });
 
   // Done!
   console.log('');
   console.log(colorize('green', '═══════════════════════════════════════════════════════'));
-  success(`SEO Kit v${PACKAGE_VERSION} installed successfully as a global Antigravity plugin!`);
+  success(`SEO Kit v${PACKAGE_VERSION} installed as global Antigravity plugin!`);
   console.log(colorize('green', '═══════════════════════════════════════════════════════'));
   console.log('');
 
   info('Next steps:');
   console.log(`  ${colorize('yellow', '1.')} Restart or open any workspace in ${colorize('bold', 'Google Antigravity')}`);
-  console.log(`  ${colorize('yellow', '2.')} The SEO Kit plugin will automatically load globally.`);
+  console.log(`  ${colorize('yellow', '2.')} Plugin loads globally. Run ${colorize('cyan', 'npx antigravity-seo-kit setup-workspace')} in a project.`);
   console.log('');
 
   if (verifyResult?.devicesUsed != null) {
@@ -511,10 +630,10 @@ async function installPlugin(licenseKey) {
 
 function setupWorkspace(cwd) {
   const globalDir = getGlobalPluginDir();
-  const localAgentDir = path.join(cwd, '.agent');
+  const localAgentsDir = path.join(cwd, '.agents');
 
-  if (fs.existsSync(localAgentDir)) {
-    info('Existing .agent directory found. Re-synchronizing and updating files...');
+  if (fs.existsSync(localAgentsDir)) {
+    info('Existing .agents directory found. Re-synchronizing...');
   }
 
   if (!fs.existsSync(globalDir)) {
@@ -523,40 +642,60 @@ function setupWorkspace(cwd) {
     process.exit(1);
   }
 
-  const spin = spinner('Replicating .agent directory to local workspace...').start();
+  const spin = spinner('Setting up .agents/ workspace structure...').start();
   try {
-    fs.mkdirSync(localAgentDir, { recursive: true });
+    fs.mkdirSync(localAgentsDir, { recursive: true });
 
-    // Only copy necessary directories. agents and rules are loaded globally via the plugin.
-    // skills are copied but filtered to exclude .md files to save space and avoid duplicate prompts/instructions.
-    const directoriesToCopy = ['.shared', 'config', 'dashboard', 'docs', 'scripts', 'workflows'];
+    // v3.0: Copy workspace-level dirs (agents, workflows, scripts, etc.)
+    // Plugin contents (skills, rules) stay in ~/.gemini/config/plugins/
+    const workspaceDirs = ['agents', 'workflows', 'scripts', 'config', 'dashboard', 'docs', '.shared'];
     const filesToCopy = ['seo-architecture.md'];
 
     let count = 0;
-    for (const dir of directoriesToCopy) {
-      const src = path.join(globalDir, dir);
-      const dest = path.join(localAgentDir, dir);
+    for (const dir of workspaceDirs) {
+      // Try _workspace_ prefixed dirs first (v3.0 install format)
+      let src = path.join(globalDir, `_workspace_${dir}`);
+      if (!fs.existsSync(src)) {
+        // Fallback to flat dir (v2.x compat)
+        src = path.join(globalDir, dir);
+      }
+      const dest = path.join(localAgentsDir, dir);
       if (fs.existsSync(src)) {
         count += copyRecursive(src, dest, { overwrite: true });
       }
     }
-    for (const file of filesToCopy) {
-      const src = path.join(globalDir, file);
-      const dest = path.join(localAgentDir, file);
+    for (const f of filesToCopy) {
+      let src = path.join(globalDir, `_workspace_${f}`);
+      if (!fs.existsSync(src)) {
+        src = path.join(globalDir, f);
+      }
+      const dest = path.join(localAgentsDir, f);
       if (fs.existsSync(src)) {
         fs.copyFileSync(src, dest);
         count++;
       }
     }
 
-    const LICENSE_FILE = '.seo-kit-license';
-    const globalLicense = path.join(globalDir, LICENSE_FILE);
-    const localLicense = path.join(cwd, LICENSE_FILE);
+    // Create plugin symlink/reference in workspace
+    const pluginsDir = path.join(localAgentsDir, 'plugins', 'antigravity-seo-kit');
+    if (!fs.existsSync(pluginsDir)) {
+      fs.mkdirSync(pluginsDir, { recursive: true });
+      // Write a pointer file so workspace knows where the plugin lives
+      fs.writeFileSync(
+        path.join(pluginsDir, '_global_ref.json'),
+        JSON.stringify({ globalDir, version: PACKAGE_VERSION }, null, 2),
+        'utf-8'
+      );
+    }
+
+    const LICENSE_FILE_NAME = '.seo-kit-license';
+    const globalLicense = path.join(globalDir, LICENSE_FILE_NAME);
+    const localLicense = path.join(cwd, LICENSE_FILE_NAME);
     if (fs.existsSync(globalLicense) && !fs.existsSync(localLicense)) {
       fs.copyFileSync(globalLicense, localLicense);
     }
 
-    spin.succeed(`Workspace setup complete! Copied ${count} files to .agent/`);
+    spin.succeed(`Workspace setup complete! Copied ${count} files to .agents/`);
   } catch (err) {
     spin.fail('Workspace setup failed');
     error(err.message);
@@ -564,6 +703,89 @@ function setupWorkspace(cwd) {
   }
 }
 
+// ─── Migrate Command (v2.x → v3.0) ─────────────────────────────────────────
+
+function migrate(cwd) {
+  const oldAgentDir = path.join(cwd, '.agent');
+  const newAgentsDir = path.join(cwd, '.agents');
+
+  if (!fs.existsSync(oldAgentDir)) {
+    if (fs.existsSync(newAgentsDir)) {
+      info('Already using v3.0 .agents/ structure. No migration needed.');
+      return;
+    }
+    error('No .agent/ directory found. Nothing to migrate.');
+    process.exit(1);
+  }
+
+  if (fs.existsSync(newAgentsDir)) {
+    warn('.agents/ already exists. Migration will merge/overwrite.');
+  }
+
+  const spin = spinner('Migrating .agent/ → .agents/ (v2.x → v3.0)...').start();
+  try {
+    let count = 0;
+
+    // 1. Copy workspace-level dirs
+    const workspaceDirs = ['agents', 'workflows', 'scripts', 'config', 'dashboard', 'docs', '.shared'];
+    for (const dir of workspaceDirs) {
+      const src = path.join(oldAgentDir, dir);
+      const dest = path.join(newAgentsDir, dir);
+      if (fs.existsSync(src)) {
+        count += copyRecursive(src, dest, { overwrite: true, mergeJson: true });
+      }
+    }
+
+    // Copy root-level md files
+    const rootFiles = fs.readdirSync(oldAgentDir).filter(f => f.endsWith('.md'));
+    for (const f of rootFiles) {
+      const src = path.join(oldAgentDir, f);
+      const dest = path.join(newAgentsDir, f);
+      if (fs.statSync(src).isFile()) {
+        fs.copyFileSync(src, dest);
+        count++;
+      }
+    }
+
+    // 2. Copy skills + rules into plugin structure
+    const pluginDir = path.join(newAgentsDir, 'plugins', 'antigravity-seo-kit');
+    fs.mkdirSync(pluginDir, { recursive: true });
+
+    const skillsSrc = path.join(oldAgentDir, 'skills');
+    const skillsDest = path.join(pluginDir, 'skills');
+    if (fs.existsSync(skillsSrc)) {
+      count += copyRecursive(skillsSrc, skillsDest, { overwrite: true, mergeJson: true });
+    }
+
+    const rulesSrc = path.join(oldAgentDir, 'rules');
+    const rulesDest = path.join(pluginDir, 'rules');
+    if (fs.existsSync(rulesSrc)) {
+      count += copyRecursive(rulesSrc, rulesDest, { overwrite: true });
+    }
+
+    // 3. Create plugin.json if missing
+    const pluginJsonPath = path.join(pluginDir, 'plugin.json');
+    if (!fs.existsSync(pluginJsonPath)) {
+      fs.writeFileSync(pluginJsonPath, JSON.stringify({
+        name: 'antigravity-seo-kit',
+        version: PACKAGE_VERSION,
+        description: 'Migrated from v2.x .agent/ structure',
+      }, null, 2), 'utf-8');
+    }
+
+    spin.succeed(`Migration complete! ${count} files moved to .agents/`);
+    console.log('');
+    info('The old .agent/ directory has been preserved as backup.');
+    info('After verifying everything works, you can remove it:');
+    console.log(`  ${colorize('gray', 'rm -rf .agent/')}`);
+    console.log('');
+  } catch (err) {
+    spin.fail('Migration failed');
+    error(err.message);
+    process.exit(1);
+  }
+}
+
 // ─── Exports ────────────────────────────────────────────────────────────────
 
 module.exports = {
@@ -575,4 +797,5 @@ module.exports = {
   deviceRemove,
   installPlugin,
   setupWorkspace,
+  migrate,
 };

package/lib/utils.js

@@ -307,7 +307,8 @@ function showHelp() {
   console.log(`${colorize('bold', 'Commands:')}`);
   console.log(`  ${colorize('green', 'install')}         --key=SK-XXXX-XXXX-XXXX   Install SEO Kit into current workspace`);
   console.log(`  ${colorize('green', 'install-plugin')}  --key=SK-XXXX-XXXX-XXXX   Install SEO Kit globally as an Antigravity plugin`);
-  console.log(`  ${colorize('green', 'setup-workspace')}                            Replicate .agent config directory to current workspace`);
+  console.log(`  ${colorize('green', 'setup-workspace')}                            Replicate .agents config directory to current workspace`);
+  console.log(`  ${colorize('green', 'migrate')}                                   Migrate .agent/ to .agents/ (v2.x → v3.0)`);
   console.log(`  ${colorize('green', 'update')}                                    Update to latest version`);
   console.log(`  ${colorize('green', 'uninstall')}                                 Remove SEO Kit from workspace`);
   console.log(`  ${colorize('green', 'status')}                                    Show license & installation info`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antigravity-seo-kit",
-  "version": "2.7.4",
+  "version": "2.9.7",
   "description": "Professional Agentic SEO Platform for Google Antigravity 2 AI Agent — 44 specialized skills covering technical audit, E-E-A-T, schema, GEO, local SEO & more",
   "main": "lib/installer.js",
   "bin": {