aios-core 2.1.0

package/.aios-core/core/mcp/index.js

@@ -0,0 +1,34 @@
+/**
+ * MCP Module Index
+ *
+ * Exports all MCP-related functionality for global configuration management.
+ *
+ * @module core/mcp
+ * @version 1.0.0
+ * @story 2.11 - MCP System Global
+ */
+
+const osDetector = require('./os-detector');
+const globalConfigManager = require('./global-config-manager');
+const symlinkManager = require('./symlink-manager');
+const configMigrator = require('./config-migrator');
+
+module.exports = {
+  // OS Detection
+  ...osDetector,
+
+  // Global Config Management
+  ...globalConfigManager,
+
+  // Symlink Management
+  ...symlinkManager,
+
+  // Config Migration
+  ...configMigrator,
+
+  // Namespaced exports for clarity
+  osDetector,
+  globalConfigManager,
+  symlinkManager,
+  configMigrator,
+};

package/.aios-core/core/mcp/os-detector.js

@@ -0,0 +1,188 @@
+/**
+ * OS Detector Utility
+ *
+ * Provides cross-platform detection utilities for MCP system.
+ * Detects operating system and provides appropriate commands.
+ *
+ * @module core/mcp/os-detector
+ * @version 1.0.0
+ * @story 2.11 - MCP System Global
+ */
+
+const os = require('os');
+const path = require('path');
+
+/**
+ * Operating system types
+ * @enum {string}
+ */
+const OS_TYPES = {
+  WINDOWS: 'windows',
+  MACOS: 'macos',
+  LINUX: 'linux',
+  UNKNOWN: 'unknown',
+};
+
+/**
+ * Detect current operating system
+ * @returns {string} One of OS_TYPES values
+ */
+function detectOS() {
+  const platform = os.platform();
+
+  switch (platform) {
+    case 'win32':
+      return OS_TYPES.WINDOWS;
+    case 'darwin':
+      return OS_TYPES.MACOS;
+    case 'linux':
+      return OS_TYPES.LINUX;
+    default:
+      return OS_TYPES.UNKNOWN;
+  }
+}
+
+/**
+ * Check if running on Windows
+ * @returns {boolean}
+ */
+function isWindows() {
+  return detectOS() === OS_TYPES.WINDOWS;
+}
+
+/**
+ * Check if running on macOS
+ * @returns {boolean}
+ */
+function isMacOS() {
+  return detectOS() === OS_TYPES.MACOS;
+}
+
+/**
+ * Check if running on Linux
+ * @returns {boolean}
+ */
+function isLinux() {
+  return detectOS() === OS_TYPES.LINUX;
+}
+
+/**
+ * Check if running on Unix-like system (macOS or Linux)
+ * @returns {boolean}
+ */
+function isUnix() {
+  const osType = detectOS();
+  return osType === OS_TYPES.MACOS || osType === OS_TYPES.LINUX;
+}
+
+/**
+ * Get user home directory
+ * @returns {string} Home directory path
+ */
+function getHomeDir() {
+  return os.homedir();
+}
+
+/**
+ * Get global AIOS directory path
+ * @returns {string} Path to ~/.aios/
+ */
+function getGlobalAiosDir() {
+  return path.join(getHomeDir(), '.aios');
+}
+
+/**
+ * Get global MCP directory path
+ * @returns {string} Path to ~/.aios/mcp/
+ */
+function getGlobalMcpDir() {
+  return path.join(getGlobalAiosDir(), 'mcp');
+}
+
+/**
+ * Get global MCP config file path
+ * @returns {string} Path to ~/.aios/mcp/global-config.json
+ */
+function getGlobalConfigPath() {
+  return path.join(getGlobalMcpDir(), 'global-config.json');
+}
+
+/**
+ * Get global MCP servers directory path
+ * @returns {string} Path to ~/.aios/mcp/servers/
+ */
+function getServersDir() {
+  return path.join(getGlobalMcpDir(), 'servers');
+}
+
+/**
+ * Get global MCP cache directory path
+ * @returns {string} Path to ~/.aios/mcp/cache/
+ */
+function getCacheDir() {
+  return path.join(getGlobalMcpDir(), 'cache');
+}
+
+/**
+ * Get global credentials directory path
+ * @returns {string} Path to ~/.aios/credentials/
+ */
+function getCredentialsDir() {
+  return path.join(getGlobalAiosDir(), 'credentials');
+}
+
+/**
+ * Get OS-specific information
+ * @returns {Object} OS information object
+ */
+function getOSInfo() {
+  return {
+    type: detectOS(),
+    platform: os.platform(),
+    release: os.release(),
+    arch: os.arch(),
+    homeDir: getHomeDir(),
+    supportsSymlinks: !isWindows() || hasWindowsSymlinkSupport(),
+  };
+}
+
+/**
+ * Check if Windows has symlink support (Developer Mode or admin)
+ * This is a heuristic check - actual support depends on permissions
+ * @returns {boolean}
+ */
+function hasWindowsSymlinkSupport() {
+  if (!isWindows()) return true;
+
+  // On Windows, we use junctions which don't require special permissions
+  // True symlinks require Developer Mode or admin
+  // For our use case, junctions work fine for directories
+  return true;
+}
+
+/**
+ * Get the link type to use on current OS
+ * @returns {string} 'junction' for Windows, 'symlink' for Unix
+ */
+function getLinkType() {
+  return isWindows() ? 'junction' : 'symlink';
+}
+
+module.exports = {
+  OS_TYPES,
+  detectOS,
+  isWindows,
+  isMacOS,
+  isLinux,
+  isUnix,
+  getHomeDir,
+  getGlobalAiosDir,
+  getGlobalMcpDir,
+  getGlobalConfigPath,
+  getServersDir,
+  getCacheDir,
+  getCredentialsDir,
+  getOSInfo,
+  hasWindowsSymlinkSupport,
+  getLinkType,
+};

package/.aios-core/core/mcp/symlink-manager.js

@@ -0,0 +1,413 @@
+/**
+ * Symlink Manager
+ *
+ * Manages symlinks (Unix) and junctions (Windows) for MCP configuration.
+ * Provides cross-platform link creation and verification.
+ *
+ * @module core/mcp/symlink-manager
+ * @version 1.0.0
+ * @story 2.11 - MCP System Global
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { isWindows, getGlobalMcpDir, getLinkType } = require('./os-detector');
+
+/**
+ * Link status types
+ * @enum {string}
+ */
+const LINK_STATUS = {
+  LINKED: 'linked',
+  NOT_LINKED: 'not_linked',
+  BROKEN: 'broken',
+  DIRECTORY: 'directory',
+  ERROR: 'error',
+};
+
+/**
+ * Get the project MCP link path
+ * @param {string} projectRoot - Project root directory
+ * @returns {string} Path to .aios-core/tools/mcp
+ */
+function getProjectMcpPath(projectRoot = process.cwd()) {
+  return path.join(projectRoot, '.aios-core', 'tools', 'mcp');
+}
+
+/**
+ * Check if a path is a symbolic link or junction
+ * @param {string} linkPath - Path to check
+ * @returns {boolean}
+ */
+function isLink(linkPath) {
+  try {
+    const stats = fs.lstatSync(linkPath);
+    return stats.isSymbolicLink();
+  } catch (error) {
+    // On Windows, junctions might not show as symlinks via lstat
+    if (isWindows()) {
+      return isWindowsJunction(linkPath);
+    }
+    return false;
+  }
+}
+
+/**
+ * Check if a path is a Windows junction
+ * @param {string} linkPath - Path to check
+ * @returns {boolean}
+ */
+function isWindowsJunction(linkPath) {
+  if (!isWindows()) return false;
+
+  try {
+    // Use fsutil to check if it's a junction
+    const result = execSync(`fsutil reparsepoint query "${linkPath}"`, {
+      encoding: 'utf8',
+      windowsHide: true,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return result.includes('Symbolic Link') || result.includes('Mount Point');
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Get the target of a symlink/junction
+ * @param {string} linkPath - Path to the link
+ * @returns {string|null} Target path or null
+ */
+function getLinkTarget(linkPath) {
+  try {
+    return fs.readlinkSync(linkPath);
+  } catch (error) {
+    // On Windows, try alternative method for junctions
+    if (isWindows()) {
+      return getWindowsJunctionTarget(linkPath);
+    }
+    return null;
+  }
+}
+
+/**
+ * Get the target of a Windows junction
+ * @param {string} linkPath - Path to junction
+ * @returns {string|null} Target path or null
+ */
+function getWindowsJunctionTarget(linkPath) {
+  if (!isWindows()) return null;
+
+  try {
+    const result = execSync(`fsutil reparsepoint query "${linkPath}"`, {
+      encoding: 'utf8',
+      windowsHide: true,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    // Parse the target from fsutil output
+    const match = result.match(/Print Name:\s*(.+)/);
+    if (match) {
+      return match[1].trim();
+    }
+
+    // Alternative: parse Substitute Name
+    const substMatch = result.match(/Substitute Name:\s*(.+)/);
+    if (substMatch) {
+      let target = substMatch[1].trim();
+      // Remove \\?\ prefix if present
+      target = target.replace(/^\\\\\?\\/g, '');
+      return target;
+    }
+
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Check link status
+ * @param {string} projectRoot - Project root directory
+ * @returns {Object} Link status information
+ */
+function checkLinkStatus(projectRoot = process.cwd()) {
+  const linkPath = getProjectMcpPath(projectRoot);
+  const globalPath = getGlobalMcpDir();
+
+  // Check if parent directory exists
+  const toolsDir = path.dirname(linkPath);
+  if (!fs.existsSync(toolsDir)) {
+    return {
+      status: LINK_STATUS.NOT_LINKED,
+      linkPath,
+      globalPath,
+      type: getLinkType(),
+      message: 'Tools directory does not exist',
+    };
+  }
+
+  // Check if path exists
+  if (!fs.existsSync(linkPath)) {
+    return {
+      status: LINK_STATUS.NOT_LINKED,
+      linkPath,
+      globalPath,
+      type: getLinkType(),
+      message: 'MCP link does not exist',
+    };
+  }
+
+  // Check if it's a link
+  if (isLink(linkPath)) {
+    const target = getLinkTarget(linkPath);
+
+    // Verify target matches global MCP dir
+    if (target) {
+      // Resolve to absolute paths for accurate comparison
+      const resolvedTarget = path.resolve(target);
+      const resolvedGlobal = path.resolve(globalPath);
+
+      // Check exact match or if target is the global directory
+      // Use path.relative to safely compare - empty string means same path,
+      // no '..' prefix means target is equal to or child of global
+      const relativePath = path.relative(resolvedGlobal, resolvedTarget);
+      const isLinkedToGlobal = relativePath === '' || (!relativePath.startsWith('..') && !path.isAbsolute(relativePath));
+
+      if (isLinkedToGlobal) {
+        return {
+          status: LINK_STATUS.LINKED,
+          linkPath,
+          globalPath,
+          target,
+          type: getLinkType(),
+          message: 'Linked to global MCP config',
+        };
+      } else {
+        return {
+          status: LINK_STATUS.BROKEN,
+          linkPath,
+          globalPath,
+          target,
+          type: getLinkType(),
+          message: `Link points to different location: ${target}`,
+        };
+      }
+    }
+
+    return {
+      status: LINK_STATUS.BROKEN,
+      linkPath,
+      globalPath,
+      type: getLinkType(),
+      message: 'Could not resolve link target',
+    };
+  }
+
+  // It's a regular directory
+  return {
+    status: LINK_STATUS.DIRECTORY,
+    linkPath,
+    globalPath,
+    type: getLinkType(),
+    message: 'Path exists as regular directory (not linked)',
+  };
+}
+
+/**
+ * Create symlink (Unix) or junction (Windows)
+ * @param {string} projectRoot - Project root directory
+ * @param {Object} options - Options
+ * @param {boolean} options.force - Force creation (remove existing)
+ * @returns {Object} Result with success status
+ */
+function createLink(projectRoot = process.cwd(), options = {}) {
+  const linkPath = getProjectMcpPath(projectRoot);
+  const globalPath = getGlobalMcpDir();
+
+  // Verify global MCP directory exists
+  if (!fs.existsSync(globalPath)) {
+    return {
+      success: false,
+      error: 'Global MCP directory does not exist. Run "aios mcp setup" first.',
+      linkPath,
+      globalPath,
+    };
+  }
+
+  // Ensure tools directory exists
+  const toolsDir = path.dirname(linkPath);
+  if (!fs.existsSync(toolsDir)) {
+    try {
+      fs.mkdirSync(toolsDir, { recursive: true });
+    } catch (error) {
+      return {
+        success: false,
+        error: `Could not create tools directory: ${error.message}`,
+        linkPath,
+        globalPath,
+      };
+    }
+  }
+
+  // Check existing link status
+  const status = checkLinkStatus(projectRoot);
+
+  // If already properly linked, no action needed
+  if (status.status === LINK_STATUS.LINKED) {
+    return {
+      success: true,
+      alreadyLinked: true,
+      linkPath,
+      globalPath,
+      type: getLinkType(),
+    };
+  }
+
+  // Handle existing path
+  if (fs.existsSync(linkPath)) {
+    if (!options.force) {
+      return {
+        success: false,
+        error: 'Path already exists. Use --force to overwrite.',
+        status: status.status,
+        linkPath,
+        globalPath,
+      };
+    }
+
+    // Remove existing
+    try {
+      if (status.status === LINK_STATUS.DIRECTORY) {
+        // Backup existing config if it has content
+        const configFile = path.join(linkPath, 'global-config.json');
+        if (fs.existsSync(configFile)) {
+          const backupPath = linkPath + '.backup.' + Date.now();
+          fs.renameSync(linkPath, backupPath);
+          return {
+            success: false,
+            error: `Existing config backed up to ${backupPath}. Run with --migrate to merge configs.`,
+            linkPath,
+            globalPath,
+            backup: backupPath,
+          };
+        }
+        fs.rmSync(linkPath, { recursive: true });
+      } else {
+        // Remove symlink/junction
+        fs.unlinkSync(linkPath);
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: `Could not remove existing path: ${error.message}`,
+        linkPath,
+        globalPath,
+      };
+    }
+  }
+
+  // Create the link
+  try {
+    if (isWindows()) {
+      // Use mklink /J for Windows junction
+      execSync(`mklink /J "${linkPath}" "${globalPath}"`, {
+        windowsHide: true,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+    } else {
+      // Use fs.symlinkSync for Unix (type 'dir' for directory symlinks)
+      fs.symlinkSync(globalPath, linkPath, 'dir');
+    }
+
+    // Verify the link was created
+    const verifyStatus = checkLinkStatus(projectRoot);
+    if (verifyStatus.status === LINK_STATUS.LINKED) {
+      return {
+        success: true,
+        linkPath,
+        globalPath,
+        type: getLinkType(),
+      };
+    } else {
+      return {
+        success: false,
+        error: 'Link created but verification failed',
+        linkPath,
+        globalPath,
+        status: verifyStatus.status,
+      };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: `Could not create link: ${error.message}`,
+      linkPath,
+      globalPath,
+      hint: isWindows()
+        ? 'Try running as Administrator or enable Developer Mode'
+        : 'Check directory permissions',
+    };
+  }
+}
+
+/**
+ * Remove symlink/junction
+ * @param {string} projectRoot - Project root directory
+ * @returns {Object} Result with success status
+ */
+function removeLink(projectRoot = process.cwd()) {
+  const linkPath = getProjectMcpPath(projectRoot);
+  const status = checkLinkStatus(projectRoot);
+
+  if (status.status === LINK_STATUS.NOT_LINKED) {
+    return {
+      success: true,
+      alreadyRemoved: true,
+      linkPath,
+    };
+  }
+
+  if (status.status === LINK_STATUS.DIRECTORY) {
+    return {
+      success: false,
+      error: 'Path is a directory, not a link. Cannot remove.',
+      linkPath,
+    };
+  }
+
+  try {
+    if (isWindows()) {
+      // Remove junction using rmdir
+      execSync(`rmdir "${linkPath}"`, {
+        windowsHide: true,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+    } else {
+      fs.unlinkSync(linkPath);
+    }
+
+    return {
+      success: true,
+      linkPath,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Could not remove link: ${error.message}`,
+      linkPath,
+    };
+  }
+}
+
+module.exports = {
+  LINK_STATUS,
+  getProjectMcpPath,
+  isLink,
+  isWindowsJunction,
+  getLinkTarget,
+  checkLinkStatus,
+  createLink,
+  removeLink,
+};

package/.aios-core/core/migration/migration-config.yaml

@@ -0,0 +1,83 @@
+# AIOS Migration Configuration
+# Story 2.14 - Migration Script v2.0 → v2.1
+
+version: "1.0.0"
+story: "2.14"
+
+# Supported migration paths
+migrations:
+  - from: "2.0"
+    to: "2.1"
+    description: "Migrate from flat to modular structure"
+    status: "supported"
+
+# Backup configuration
+backup:
+  prefix: ".aios-backup-"
+  format: "YYYY-MM-DD"
+  include:
+    - ".aios-core/**"
+    - "aios.config.js"
+    - "aios.config.json"
+    - ".aios/config.yaml"
+    - ".mcp.json"
+  exclude:
+    - "node_modules/**"
+    - ".git/**"
+    - "*.log"
+  verification:
+    algorithm: "md5"
+    parallel: true
+
+# Module configuration for v2.1
+modules:
+  core:
+    description: "Core framework utilities and runtime"
+    directories:
+      - registry
+      - quality-gates
+      - manifest
+      - utils
+      - elicitation
+      - session
+      - config
+      - mcp
+      - data
+      - docs
+  development:
+    description: "Development tools and workflows"
+    directories:
+      - agents
+      - tasks
+      - templates
+      - checklists
+      - scripts
+      - personas
+  product:
+    description: "Product interfaces and APIs"
+    directories:
+      - cli
+      - api
+  infrastructure:
+    description: "Infrastructure and deployment"
+    directories:
+      - hooks
+      - telemetry
+      - integrations
+
+# Validation settings
+validation:
+  structure: true
+  imports: true
+  lint: true
+  tests: true
+  timeout:
+    lint: 60000      # 1 minute
+    tests: 300000    # 5 minutes
+
+# Safety settings
+safety:
+  requireBackup: true
+  verifyBackup: true
+  confirmBeforeExecute: true
+  atomicOperations: true