aios-core 4.2.3 → 4.2.5

package/packages/installer/src/wizard/ide-config-generator.js

@@ -12,6 +12,7 @@ const path = require('path');
 const yaml = require('js-yaml');
 const inquirer = require('inquirer');
 const ora = require('ora');
+const { spawnSync } = require('child_process');
 const { getIDEConfig } = require('../config/ide-configs');
 const { validateProjectName } = require('./validators');
 const { getMergeStrategy, hasMergeStrategy } = require('../merger/index.js');
@@ -386,8 +387,8 @@ async function createAntiGravityConfigJson(projectRoot, ideConfig) {
  * @returns {Promise<{success: boolean, files: string[], errors: Array}>}
  *
  * @example
- * const result = await generateIDEConfigs(['cursor', 'windsurf'], wizardState);
- * console.log(result.files); // ['.cursorrules', '.windsurfrules']
+ * const result = await generateIDEConfigs(['cursor', 'github-copilot'], wizardState);
+ * console.log(result.files); // ['.cursorrules', '.github/copilot-instructions.md']
  */
 async function generateIDEConfigs(selectedIDEs, wizardState, options = {}) {
   const projectRoot = options.projectRoot || process.cwd();
@@ -538,6 +539,44 @@ async function generateIDEConfigs(selectedIDEs, wizardState, options = {}) {
           } else {
             spinner.info('Skipped settings.local.json (no hooks to register)');
           }
+
+          // Silent statusline setup (graceful skip if user already has one)
+          const statuslineResult = await setupGlobalStatusline();
+          if (statuslineResult.installed) {
+            createdFiles.push(...statuslineResult.files);
+          }
+        }
+
+        // Gemini parity with Claude Code: copy hooks and configure settings
+        if (ideKey === 'gemini') {
+          spinner.start('Copying Gemini CLI hooks...');
+          const hookFiles = await copyGeminiHooksFolder(projectRoot);
+          createdFiles.push(...hookFiles);
+          if (hookFiles.length > 0) {
+            createdFolders.push(path.join(projectRoot, '.gemini', 'hooks'));
+            spinner.succeed(`Copied ${hookFiles.length} hook file(s) to .gemini/hooks`);
+          } else {
+            spinner.info('No Gemini hook files to copy');
+          }
+
+          spinner.start('Configuring Gemini CLI settings...');
+          const settingsFile = await createGeminiSettings(projectRoot);
+          if (settingsFile) {
+            createdFiles.push(settingsFile);
+            spinner.succeed('Created .gemini/settings.json with AIOS hooks');
+          } else {
+            spinner.info('Skipped .gemini/settings.json (no hooks to register)');
+          }
+
+          spinner.start('Linking Gemini AIOS extension...');
+          const extensionResult = await linkGeminiExtension(projectRoot);
+          if (extensionResult.status === 'linked') {
+            spinner.succeed('Gemini extension "aios" linked and enabled');
+          } else if (extensionResult.status === 'already-linked') {
+            spinner.succeed('Gemini extension "aios" already linked');
+          } else {
+            spinner.info(`Skipped Gemini extension linking (${extensionResult.reason})`);
+          }
         }
 
       } catch (error) {
@@ -724,6 +763,334 @@ async function createClaudeSettingsLocal(projectRoot) {
   return settingsPath;
 }
 
+/**
+<<<<<<< HEAD
+ * Copy .aios-core/hooks/gemini folder into .gemini/hooks during installation
+ * @param {string} projectRoot - Project root directory
+ * @returns {Promise<string[]>} List of copied files
+ */
+async function copyGeminiHooksFolder(projectRoot) {
+  const sourceDir = path.join(__dirname, '..', '..', '..', '..', '.aios-core', 'hooks', 'gemini');
+  const targetDir = path.join(projectRoot, '.gemini', 'hooks');
+  const copiedFiles = [];
+
+  if (!await fs.pathExists(sourceDir)) {
+    return copiedFiles;
+  }
+
+  if (path.resolve(sourceDir) === path.resolve(targetDir)) {
+    return copiedFiles;
+  }
+
+  await fs.ensureDir(targetDir);
+
+  const files = await fs.readdir(sourceDir);
+  for (const file of files) {
+    if (!file.endsWith('.js')) continue;
+
+    const sourcePath = path.join(sourceDir, file);
+    const targetPath = path.join(targetDir, file);
+    const stat = await fs.stat(sourcePath);
+    if (stat.isFile()) {
+      await fs.copy(sourcePath, targetPath);
+      copiedFiles.push(targetPath);
+    }
+  }
+
+  return copiedFiles;
+}
+
+/**
+ * Create/merge .gemini/settings.json and register AIOS hooks as enabled.
+ * @param {string} projectRoot - Project root directory
+ * @returns {Promise<string|null>} Path to settings file or null if skipped
+ */
+async function createGeminiSettings(projectRoot) {
+  const settingsPath = path.join(projectRoot, '.gemini', 'settings.json');
+  const hooksDir = path.join(projectRoot, '.gemini', 'hooks');
+
+  if (!await fs.pathExists(hooksDir)) {
+    return null;
+  }
+
+  const hookEntries = [
+    {
+      event: 'SessionStart',
+      matcher: '*',
+      hook: {
+        name: 'aios-session-init',
+        type: 'command',
+        command: 'node ".gemini/hooks/session-start.js"',
+        timeout: 5000,
+        enabled: true,
+      },
+    },
+    {
+      event: 'BeforeAgent',
+      matcher: '*',
+      hook: {
+        name: 'aios-context-inject',
+        type: 'command',
+        command: 'node ".gemini/hooks/before-agent.js"',
+        timeout: 3000,
+        enabled: true,
+      },
+    },
+    {
+      event: 'BeforeTool',
+      matcher: 'write_file|replace|shell|bash|execute',
+      hook: {
+        name: 'aios-security-check',
+        type: 'command',
+        command: 'node ".gemini/hooks/before-tool.js"',
+        timeout: 2000,
+        enabled: true,
+      },
+    },
+    {
+      event: 'AfterTool',
+      matcher: '*',
+      hook: {
+        name: 'aios-audit-log',
+        type: 'command',
+        command: 'node ".gemini/hooks/after-tool.js"',
+        timeout: 2000,
+        enabled: true,
+      },
+    },
+    {
+      event: 'SessionEnd',
+      matcher: '*',
+      hook: {
+        name: 'aios-session-persist',
+        type: 'command',
+        command: 'node ".gemini/hooks/session-end.js"',
+        timeout: 5000,
+        enabled: true,
+      },
+    },
+  ];
+
+  let settings = {};
+  if (await fs.pathExists(settingsPath)) {
+    try {
+      settings = JSON.parse(await fs.readFile(settingsPath, 'utf8'));
+    } catch (error) {
+      console.error(`   ⚠️  Could not parse ${settingsPath}: ${error.message}`);
+      settings = {};
+    }
+  }
+
+  settings.previewFeatures = true;
+  settings.folderTrust = settings.folderTrust || { enabled: true };
+  settings.hooks = settings.hooks || {};
+
+  for (const entry of hookEntries) {
+    if (!Array.isArray(settings.hooks[entry.event])) {
+      settings.hooks[entry.event] = [];
+    }
+
+    const alreadyRegistered = settings.hooks[entry.event].some((wrapper) => {
+      if (wrapper && Array.isArray(wrapper.hooks)) {
+        return wrapper.hooks.some((h) => h && h.name === entry.hook.name);
+      }
+      return false;
+    });
+
+    if (!alreadyRegistered) {
+      settings.hooks[entry.event].push({
+        matcher: entry.matcher,
+        hooks: [entry.hook],
+      });
+    }
+  }
+
+  await fs.ensureDir(path.dirname(settingsPath));
+  await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+  return settingsPath;
+}
+
+/**
+ * Best-effort Gemini extension linking for AIOS project.
+ * Does not fail installation when auth/CLI is unavailable.
+ * @param {string} projectRoot
+ * @returns {Promise<{status: 'linked'|'already-linked'|'skipped', reason?: string}>}
+ */
+async function linkGeminiExtension(projectRoot) {
+  const extensionDir = path.join(projectRoot, 'packages', 'gemini-aios-extension');
+  const manifestPath = path.join(extensionDir, 'gemini-extension.json');
+  const legacyManifestPath = path.join(extensionDir, 'extension.json');
+
+  if (!await fs.pathExists(extensionDir)) {
+    return { status: 'skipped', reason: 'extension-dir-not-found' };
+  }
+
+  // Gemini CLI >=0.28 expects gemini-extension.json
+  if (!await fs.pathExists(manifestPath) && await fs.pathExists(legacyManifestPath)) {
+    await fs.copy(legacyManifestPath, manifestPath);
+  }
+
+  if (!await fs.pathExists(manifestPath)) {
+    return { status: 'skipped', reason: 'manifest-not-found' };
+  }
+
+  const versionCheck = spawnSync('gemini', ['--version'], { encoding: 'utf8' });
+  if (versionCheck.status !== 0) {
+    return { status: 'skipped', reason: 'gemini-cli-not-available' };
+  }
+
+  let linkResult = spawnSync('gemini', ['extensions', 'link', extensionDir, '--consent'], {
+    cwd: projectRoot,
+    encoding: 'utf8',
+    timeout: 30000,
+  });
+
+  if (linkResult.status === 0) {
+    return { status: 'linked' };
+  }
+
+  const output = `${linkResult.stdout || ''}\n${linkResult.stderr || ''}`;
+
+  // When already installed, perform idempotent relink.
+  if (output.includes('already installed')) {
+    const uninstall = spawnSync('gemini', ['extensions', 'uninstall', 'aios'], {
+      cwd: projectRoot,
+      encoding: 'utf8',
+      timeout: 30000,
+    });
+
+    if (uninstall.status !== 0) {
+      return { status: 'skipped', reason: 'uninstall-failed' };
+    }
+
+    linkResult = spawnSync('gemini', ['extensions', 'link', extensionDir, '--consent'], {
+      cwd: projectRoot,
+      encoding: 'utf8',
+      timeout: 30000,
+    });
+
+    if (linkResult.status === 0) {
+      return { status: 'linked' };
+    }
+    return { status: 'skipped', reason: 'relink-failed' };
+  }
+
+  if (output.toLowerCase().includes('authentication')) {
+    return { status: 'skipped', reason: 'authentication-required' };
+  }
+
+  return { status: 'skipped', reason: 'link-failed' };
+}
+
+/**
+ * Setup global statusline for Claude Code
+ *
+ * Copies statusline-script.js and track-agent.sh to ~/.claude/
+ * and configures ~/.claude/settings.json with statusLine + hook entries.
+ *
+ * GRACEFUL SKIP: If user already has a statusLine configured, this function
+ * returns silently without any output — the user never knows it was checked.
+ *
+ * @returns {Promise<{installed: boolean, files: string[]}>}
+ */
+async function setupGlobalStatusline() {
+  const homeDir = require('os').homedir();
+  const globalSettingsPath = path.join(homeDir, '.claude', 'settings.json');
+  const result = { installed: false, files: [] };
+
+  // Read existing global settings
+  let settings = {};
+  try {
+    if (await fs.pathExists(globalSettingsPath)) {
+      const content = await fs.readFile(globalSettingsPath, 'utf8');
+      settings = JSON.parse(content);
+    }
+  } catch {
+    // Corrupted or unreadable — treat as empty
+    settings = {};
+  }
+
+  // GRACEFUL SKIP: User already has a statusLine configured
+  if (settings.statusLine) {
+    return result;
+  }
+
+  // Source templates
+  const templatesDir = path.join(__dirname, '..', '..', '..', '..', '.aios-core', 'product', 'templates', 'statusline');
+
+  const scriptSource = path.join(templatesDir, 'statusline-script.js');
+  const hookSource = path.join(templatesDir, 'track-agent.sh');
+
+  // Verify templates exist
+  if (!await fs.pathExists(scriptSource) || !await fs.pathExists(hookSource)) {
+    return result;
+  }
+
+  // Target paths
+  const scriptTarget = path.join(homeDir, '.claude', 'statusline-script.js');
+  const hookTarget = path.join(homeDir, '.claude', 'hooks', 'track-agent.sh');
+  const cacheDir = path.join(homeDir, '.claude', 'session-cache');
+
+  // Copy files
+  try {
+    await fs.ensureDir(path.join(homeDir, '.claude', 'hooks'));
+    await fs.ensureDir(cacheDir);
+    await fs.copy(scriptSource, scriptTarget);
+    await fs.copy(hookSource, hookTarget);
+    result.files.push(scriptTarget, hookTarget);
+  } catch {
+    return result;
+  }
+
+  // Build the statusLine command with platform-appropriate path
+  const scriptPathEscaped = scriptTarget.replace(/\\/g, '\\\\');
+
+  // Add statusLine to settings
+  settings.statusLine = {
+    type: 'command',
+    command: `node "${scriptPathEscaped}"`,
+  };
+
+  // Add track-agent hook to UserPromptSubmit (if not already present)
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  if (!Array.isArray(settings.hooks.UserPromptSubmit)) {
+    settings.hooks.UserPromptSubmit = [];
+  }
+
+  const hookPathEscaped = hookTarget.replace(/\\/g, '\\\\');
+  const alreadyHasTrackAgent = settings.hooks.UserPromptSubmit.some(entry => {
+    if (Array.isArray(entry.hooks)) {
+      return entry.hooks.some(h => h.command && h.command.includes('track-agent'));
+    }
+    return entry.command && entry.command.includes('track-agent');
+  });
+
+  if (!alreadyHasTrackAgent) {
+    settings.hooks.UserPromptSubmit.push({
+      matcher: '',
+      hooks: [
+        {
+          type: 'command',
+          command: `bash "${hookPathEscaped}"`,
+        },
+      ],
+    });
+  }
+
+  // Write settings back
+  try {
+    await fs.ensureDir(path.dirname(globalSettingsPath));
+    await fs.writeFile(globalSettingsPath, JSON.stringify(settings, null, 2), 'utf8');
+    result.installed = true;
+  } catch {
+    return result;
+  }
+
+  return result;
+}
+
 module.exports = {
   generateIDEConfigs,
   showSuccessSummary,
@@ -734,4 +1101,8 @@ module.exports = {
   generateTemplateVariables,
   copyClaudeHooksFolder,
   createClaudeSettingsLocal,
+  copyGeminiHooksFolder,
+  createGeminiSettings,
+  linkGeminiExtension,
+  setupGlobalStatusline,
 };

package/packages/installer/src/wizard/ide-selector.js

@@ -46,7 +46,7 @@ function validateIDESelection(selectedIDEs) {
  *
  * @example
  * const selectedIDEs = await selectIDEs();
- * console.log(selectedIDEs); // ['cursor', 'windsurf']
+ * console.log(selectedIDEs); // ['cursor', 'github-copilot']
  */
 async function selectIDEs() {
   const { selectedIDEs } = await inquirer.prompt([

package/pro/README.md

@@ -0,0 +1,66 @@
+# AIOS Pro
+
+Premium features for [Synkra AIOS](https://github.com/SynkraAI/aios-core).
+
+## Overview
+
+AIOS Pro extends the open-source AIOS framework with premium capabilities:
+
+- **Premium Squads** - Pre-built squads for SaaS, e-commerce, and fintech
+- **Persistent Memory** - Cross-session context and memory analytics
+- **Usage Metrics** - Dashboards, team analytics, and cost tracking
+- **Enterprise Integrations** - ClickUp, Google Drive, GitLab, Jira, Azure DevOps
+
+## Installation
+
+AIOS Pro requires an active license and is distributed via npm.
+
+```bash
+# Install
+npm install @aios-fullstack/pro
+
+# Activate license
+aios pro activate --key PRO-XXXX-XXXX-XXXX-XXXX
+```
+
+## Usage with aios-core
+
+AIOS Pro is designed to work as a git submodule of `aios-core`:
+
+```bash
+# Clone aios-core with pro submodule
+git clone --recurse-submodules https://github.com/SynkraAI/aios-core.git
+
+# Or add to existing clone
+cd aios-core
+git submodule update --init pro
+```
+
+## Activate License
+
+```bash
+aios pro activate --key PRO-XXXX-XXXX-XXXX-XXXX
+aios pro status
+```
+
+## Structure
+
+```
+aios-pro/
+├── squads/          # Premium squad definitions
+├── memory/          # Persistent memory modules
+├── metrics/         # Usage dashboards and analytics
+├── integrations/    # Enterprise integration adapters
+├── license/         # License infrastructure
+└── pro-config.yaml  # Pro extension configuration
+```
+
+## Requirements
+
+- Node.js >= 18
+- aios-core >= 3.12.0
+- Active AIOS Pro license
+
+## License
+
+Proprietary - Copyright (c) 2026 SynkraAI. All rights reserved.

package/pro/license/degradation.js

@@ -0,0 +1,220 @@
+/**
+ * Graceful Degradation Module
+ *
+ * Utilities for handling pro feature unavailability with user-friendly
+ * messages that preserve data and provide clear next steps.
+ *
+ * Per ADR-PRO-003 and AC-8:
+ * - Never show upgrade prompts on core features
+ * - Never delete or corrupt user data
+ * - Always provide actionable next steps
+ * - Keep messages non-intrusive
+ *
+ * @module pro/license/degradation
+ * @see ADR-PRO-003 - Feature Gating & Licensing
+ * @see Story PRO-6 - License Key & Feature Gating System
+ */
+
+'use strict';
+
+const { featureGate } = require('./feature-gate');
+const { ProFeatureError } = require('./errors');
+
+/**
+ * Default degradation message template.
+ * @private Reserved for future customization support.
+ */
+const _DEFAULT_MESSAGE_TEMPLATE = `
+{featureName} requires an active AIOS Pro license.
+
+Your data and configurations are preserved.
+
+Activate: aios pro activate --key <KEY>
+Purchase: https://synkra.ai/pro
+`;
+
+/**
+ * Handle pro feature gracefully - return fallback instead of throwing.
+ *
+ * Use this when you want to provide a degraded experience instead
+ * of completely blocking the feature.
+ *
+ * @param {string} featureId - Feature ID to check
+ * @param {Function} proAction - Function to execute if feature is available
+ * @param {Function} [fallbackAction] - Function to execute if not available
+ * @param {object} [options] - Options
+ * @param {boolean} [options.silent=false] - Don't log degradation message
+ * @returns {*} Result of proAction or fallbackAction
+ */
+function withGracefulDegradation(featureId, proAction, fallbackAction, options = {}) {
+  if (featureGate.isAvailable(featureId)) {
+    return proAction();
+  }
+
+  if (!options.silent) {
+    const featureName = getFeatureFriendlyName(featureId);
+    logDegradationMessage(featureName, featureId);
+  }
+
+  if (typeof fallbackAction === 'function') {
+    return fallbackAction();
+  }
+
+  return null;
+}
+
+/**
+ * Execute action only if pro feature is available.
+ *
+ * Unlike featureGate.require(), this doesn't throw - it just
+ * returns undefined if the feature isn't available.
+ *
+ * @param {string} featureId - Feature ID to check
+ * @param {Function} action - Action to execute if available
+ * @returns {*|undefined} Result of action or undefined
+ */
+function ifProAvailable(featureId, action) {
+  if (featureGate.isAvailable(featureId)) {
+    return action();
+  }
+  return undefined;
+}
+
+/**
+ * Get a user-friendly name for a feature.
+ *
+ * @param {string} featureId - Feature ID
+ * @returns {string} Friendly name
+ */
+function getFeatureFriendlyName(featureId) {
+  const all = featureGate.listAll();
+  const feature = all.find((f) => f.id === featureId);
+  return feature ? feature.name : featureId;
+}
+
+/**
+ * Log a degradation message to the console.
+ *
+ * This is used internally when a pro feature is accessed without
+ * a license. Messages are non-intrusive and informative.
+ *
+ * @param {string} featureName - Human-friendly feature name
+ * @param {string} _featureId - Feature ID for reference (reserved for logging)
+ */
+function logDegradationMessage(featureName, _featureId) {
+  console.log('');
+  console.log(`  ${featureName} requires an active AIOS Pro license.`);
+  console.log('');
+  console.log('  Your data and configurations are preserved.');
+  console.log('');
+  console.log('  Activate: aios pro activate --key <KEY>');
+  console.log('  Purchase: https://synkra.ai/pro');
+  console.log('');
+}
+
+/**
+ * Create a degradation-aware wrapper for a pro module.
+ *
+ * This creates a proxy that catches ProFeatureError and provides
+ * a graceful degradation experience.
+ *
+ * @param {object} proModule - Pro module with methods
+ * @param {object} fallbacks - Map of method names to fallback functions
+ * @returns {Proxy} Wrapped module
+ *
+ * @example
+ *   const safePremiumSquads = createDegradationWrapper(
+ *     PremiumSquads,
+ *     {
+ *       listTemplates: () => ['basic'], // Fallback to basic templates
+ *       exportSquad: () => null,        // No export without license
+ *     }
+ *   );
+ */
+function createDegradationWrapper(proModule, fallbacks = {}) {
+  return new Proxy(proModule, {
+    get(target, prop) {
+      const original = target[prop];
+
+      if (typeof original !== 'function') {
+        return original;
+      }
+
+      return function (...args) {
+        try {
+          return original.apply(target, args);
+        } catch (error) {
+          if (error instanceof ProFeatureError) {
+            if (fallbacks[prop]) {
+              logDegradationMessage(error.friendlyName, error.featureId);
+              return fallbacks[prop](...args);
+            }
+            // Re-throw if no fallback
+            throw error;
+          }
+          // Re-throw non-license errors
+          throw error;
+        }
+      };
+    },
+  });
+}
+
+/**
+ * Check if the system is in degraded mode (expired/no license).
+ *
+ * @returns {boolean} true if pro features are unavailable
+ */
+function isInDegradedMode() {
+  const state = featureGate.getLicenseState();
+  return state === 'Expired' || state === 'Not Activated';
+}
+
+/**
+ * Get degradation status summary.
+ *
+ * @returns {{ degraded: boolean, reason: string, action: string }}
+ */
+function getDegradationStatus() {
+  const state = featureGate.getLicenseState();
+
+  if (state === 'Active') {
+    return {
+      degraded: false,
+      reason: 'License is active',
+      action: null,
+    };
+  }
+
+  if (state === 'Grace') {
+    return {
+      degraded: false,
+      reason: 'License in grace period - revalidate soon',
+      action: 'aios pro validate',
+    };
+  }
+
+  if (state === 'Expired') {
+    return {
+      degraded: true,
+      reason: 'License has expired',
+      action: 'aios pro activate --key <KEY>',
+    };
+  }
+
+  return {
+    degraded: true,
+    reason: 'No license activated',
+    action: 'aios pro activate --key <KEY>',
+  };
+}
+
+module.exports = {
+  withGracefulDegradation,
+  ifProAvailable,
+  getFeatureFriendlyName,
+  logDegradationMessage,
+  createDegradationWrapper,
+  isInDegradedMode,
+  getDegradationStatus,
+};