@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.18

package/dist/src/plugin/framework-config-loader.js

@@ -0,0 +1,235 @@
+/**
+ * FrameworkConfigLoader - Load and merge framework configurations
+ *
+ * Handles loading framework-specific configs, merging with shared configs,
+ * and managing configuration precedence. Supports JSON and YAML formats.
+ *
+ * FID-007 Framework-Scoped Workspaces configuration management.
+ *
+ * @module src/plugin/framework-config-loader
+ * @version 1.0.0
+ * @since 2025-10-23
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+// ===========================
+// FrameworkConfigLoader Class
+// ===========================
+export class FrameworkConfigLoader {
+    projectRoot;
+    configCache = new Map();
+    constructor(projectRoot) {
+        this.projectRoot = path.resolve(projectRoot);
+    }
+    /**
+     * Load framework configuration
+     *
+     * @param framework - Framework name
+     * @param options - Load options
+     * @returns Merged configuration
+     */
+    async loadConfig(framework, options = {}) {
+        const cacheKey = `${framework}-${options.environment || 'default'}`;
+        // Check cache
+        if (this.configCache.has(cacheKey)) {
+            return this.configCache.get(cacheKey);
+        }
+        // Load shared config
+        const sharedConfig = await this.loadSharedConfig();
+        // Load framework-specific config
+        const frameworkConfig = await this.loadFrameworkConfig(framework);
+        // Load environment-specific config
+        let envConfig = {};
+        if (options.environment) {
+            envConfig = await this.loadEnvironmentConfig(framework, options.environment);
+        }
+        // Load local overrides
+        let localConfig = {};
+        if (options.includeLocal) {
+            localConfig = await this.loadLocalConfig(framework);
+        }
+        // Merge configs (later configs override earlier)
+        let merged = this.deepMerge(sharedConfig, frameworkConfig, envConfig, localConfig);
+        // Apply merge strategy if requested
+        if (options.respectMergeStrategy && sharedConfig.mergeStrategy) {
+            merged = this.applyMergeStrategy(merged, sharedConfig.mergeStrategy);
+        }
+        // Cache result
+        this.configCache.set(cacheKey, merged);
+        return merged;
+    }
+    /**
+     * Get specific config value
+     *
+     * @param framework - Framework name
+     * @param key - Config key (supports dot notation)
+     * @param defaultValue - Default value if key not found
+     * @returns Config value
+     */
+    getConfigValue(framework, key, defaultValue) {
+        const config = this.configCache.get(`${framework}-default`);
+        if (!config) {
+            return defaultValue;
+        }
+        const keys = key.split('.');
+        let value = config;
+        for (const k of keys) {
+            if (value && typeof value === 'object' && k in value) {
+                value = value[k];
+            }
+            else {
+                return defaultValue;
+            }
+        }
+        return value !== undefined ? value : defaultValue;
+    }
+    /**
+     * Save framework configuration
+     *
+     * @param framework - Framework name
+     * @param config - Configuration to save
+     */
+    async saveConfig(framework, config) {
+        const configPath = path.join(this.projectRoot, '.aiwg', framework, 'settings.json');
+        // Ensure directory exists
+        await fs.mkdir(path.dirname(configPath), { recursive: true });
+        // Write config
+        await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+        // Invalidate cache
+        this.configCache.delete(`${framework}-default`);
+    }
+    // ===========================
+    // Private Methods
+    // ===========================
+    async loadSharedConfig() {
+        const workspacePath = path.join(this.projectRoot, '.aiwg', 'workspace.json');
+        try {
+            const content = await fs.readFile(workspacePath, 'utf-8');
+            const workspace = JSON.parse(content);
+            return workspace.shared || {};
+        }
+        catch {
+            return {};
+        }
+    }
+    async loadFrameworkConfig(framework) {
+        // Try JSON first
+        const jsonPath = path.join(this.projectRoot, '.aiwg', framework, 'settings.json');
+        try {
+            const content = await fs.readFile(jsonPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch {
+            // Try YAML
+            const yamlPath = path.join(this.projectRoot, '.aiwg', framework, 'config.yaml');
+            try {
+                const content = await fs.readFile(yamlPath, 'utf-8');
+                return this.parseSimpleYaml(content);
+            }
+            catch {
+                // Return default config
+                return { framework };
+            }
+        }
+    }
+    async loadEnvironmentConfig(framework, environment) {
+        const envPath = path.join(this.projectRoot, '.aiwg', framework, `settings.${environment}.json`);
+        try {
+            const content = await fs.readFile(envPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch {
+            return {};
+        }
+    }
+    async loadLocalConfig(framework) {
+        const localPath = path.join(this.projectRoot, '.aiwg', framework, 'settings.local.json');
+        try {
+            const content = await fs.readFile(localPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch {
+            return {};
+        }
+    }
+    deepMerge(...objects) {
+        const result = {};
+        for (const obj of objects) {
+            if (!obj)
+                continue;
+            for (const key in obj) {
+                if (obj.hasOwnProperty(key)) {
+                    const value = obj[key];
+                    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                        // Merge objects recursively
+                        result[key] = this.deepMerge(result[key] || {}, value);
+                    }
+                    else {
+                        // Override with new value
+                        result[key] = value;
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    applyMergeStrategy(config, strategy) {
+        // Apply merge strategies (e.g., append arrays instead of override)
+        const result = { ...config };
+        for (const key in strategy) {
+            if (strategy[key] === 'append' && Array.isArray(config[key])) {
+                // Append strategy already handled in initial merge
+                // This is a placeholder for more complex strategies
+            }
+        }
+        return result;
+    }
+    parseSimpleYaml(content) {
+        const result = {};
+        const lines = content.split('\n');
+        let currentKey = null;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            // Check for array items
+            if (trimmed.startsWith('- ')) {
+                const value = trimmed.slice(2).trim();
+                if (currentKey) {
+                    if (!Array.isArray(result[currentKey])) {
+                        result[currentKey] = [];
+                    }
+                    result[currentKey].push(value);
+                }
+                continue;
+            }
+            const colonIndex = trimmed.indexOf(':');
+            if (colonIndex === -1)
+                continue;
+            const key = trimmed.slice(0, colonIndex).trim();
+            const value = trimmed.slice(colonIndex + 1).trim();
+            if (value) {
+                // Simple key-value - handle booleans and numbers
+                if (value === 'true') {
+                    result[key] = true;
+                }
+                else if (value === 'false') {
+                    result[key] = false;
+                }
+                else if (!isNaN(Number(value))) {
+                    result[key] = Number(value);
+                }
+                else {
+                    result[key] = value;
+                }
+                currentKey = null;
+            }
+            else {
+                // Key with no value - next lines will be array items or nested object
+                currentKey = key;
+            }
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=framework-config-loader.js.map

package/dist/src/plugin/framework-detector.js

@@ -0,0 +1,186 @@
+/**
+ * FrameworkDetector - Detect framework-scoped workspaces
+ *
+ * Detects frameworks from directory structure (.claude/, .codex/, .cursor/)
+ * and configuration files. Distinguishes legacy workspaces from framework-scoped.
+ *
+ * FID-007 Framework-Scoped Workspaces detection logic.
+ *
+ * @module src/plugin/framework-detector
+ * @version 1.0.0
+ * @since 2025-10-23
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+// ===========================
+// FrameworkDetector Class
+// ===========================
+export class FrameworkDetector {
+    projectRoot;
+    // Provider directories (used by detectFrameworks() to enumerate which
+    // platforms the workspace is deployed to). These are NOT the same as
+    // "framework-scoped workspace" (`.aiwg/frameworks/`). See issue #1516.
+    FRAMEWORK_DIRS = ['claude', 'codex', 'cursor'];
+    // Marker for framework-scoped workspace layout per PR #54.
+    FRAMEWORKS_DIR = 'frameworks';
+    // SDLC-canonical artifact dirs. Their presence ALONE is not "legacy" —
+    // they coexist with `.aiwg/frameworks/` by design when sdlc-complete is
+    // deployed (documented in CLAUDE.md / AIWG.md). Treat as legacy only when
+    // `.aiwg/frameworks/` is absent.
+    SDLC_CANONICAL_DIRS = [
+        'intake', 'requirements', 'architecture', 'planning',
+        'risks', 'testing', 'security', 'quality', 'deployment',
+        'reports', 'working', 'handoffs', 'gates', 'decisions', 'team', 'management',
+        'agents', 'commands', 'memory', 'context'
+    ];
+    // Orphan non-SDLC top-level dirs left over from the pre-#1516 deploy bug.
+    // Their presence is always a migration signal regardless of frameworks/.
+    ORPHAN_LEGACY_DIRS = [
+        'forensics', 'kb', 'media', 'media-curator', 'marketing', 'security-engineering'
+    ];
+    constructor(projectRoot) {
+        this.projectRoot = path.resolve(projectRoot);
+    }
+    /**
+     * Detect all frameworks present in the project
+     *
+     * @returns Array of framework names
+     */
+    async detectFrameworks() {
+        const frameworks = new Set();
+        // Check for .framework/ directories
+        for (const framework of this.FRAMEWORK_DIRS) {
+            try {
+                await fs.access(path.join(this.projectRoot, `.${framework}`));
+                frameworks.add(framework);
+            }
+            catch {
+                // Framework directory doesn't exist
+            }
+        }
+        // Check for .aiwg/framework/ directories
+        const aiwgPath = path.join(this.projectRoot, '.aiwg');
+        try {
+            const entries = await fs.readdir(aiwgPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory() && this.FRAMEWORK_DIRS.includes(entry.name)) {
+                    frameworks.add(entry.name);
+                }
+            }
+        }
+        catch {
+            // .aiwg doesn't exist
+        }
+        return Array.from(frameworks).sort();
+    }
+    /**
+     * Check if workspace is legacy (non-framework-scoped)
+     *
+     * @returns True if legacy workspace detected
+     */
+    async isLegacyWorkspace() {
+        const aiwgPath = path.join(this.projectRoot, '.aiwg');
+        try {
+            await fs.access(aiwgPath);
+        }
+        catch {
+            return false; // No .aiwg directory
+        }
+        let sdlcCanonicalCount = 0;
+        let orphanLegacyCount = 0;
+        let hasFrameworksDir = false;
+        try {
+            const entries = await fs.readdir(aiwgPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                if (entry.name === this.FRAMEWORKS_DIR) {
+                    hasFrameworksDir = true;
+                    continue;
+                }
+                if (this.SDLC_CANONICAL_DIRS.includes(entry.name)) {
+                    sdlcCanonicalCount++;
+                }
+                if (this.ORPHAN_LEGACY_DIRS.includes(entry.name)) {
+                    orphanLegacyCount++;
+                }
+            }
+        }
+        catch {
+            return false;
+        }
+        // Orphan non-SDLC top-level dirs always indicate a migration is needed
+        // (residue from the pre-#1516 deploy bug).
+        if (orphanLegacyCount > 0)
+            return true;
+        // SDLC top-level dirs are only "legacy" when .aiwg/frameworks/ is absent;
+        // otherwise they're the documented canonical SDLC artifact layout.
+        return sdlcCanonicalCount > 0 && !hasFrameworksDir;
+    }
+    /**
+     * Get detailed information about a framework
+     *
+     * @param frameworkName - Framework name
+     * @returns Framework information
+     */
+    async getFrameworkInfo(frameworkName) {
+        // Check .aiwg/framework/ first
+        const aiwgPath = path.join(this.projectRoot, '.aiwg', frameworkName);
+        const rootPath = path.join(this.projectRoot, `.${frameworkName}`);
+        let frameworkPath;
+        let configPath;
+        try {
+            await fs.access(aiwgPath);
+            frameworkPath = aiwgPath;
+            configPath = path.join(aiwgPath, 'settings.json');
+        }
+        catch {
+            try {
+                await fs.access(rootPath);
+                frameworkPath = rootPath;
+                configPath = path.join(rootPath, 'settings.json');
+            }
+            catch {
+                throw new Error(`Framework not found: ${frameworkName}`);
+            }
+        }
+        // Load config
+        let config = {};
+        try {
+            const configContent = await fs.readFile(configPath, 'utf-8');
+            config = JSON.parse(configContent);
+        }
+        catch {
+            // Config doesn't exist or is invalid, use defaults
+        }
+        // Count agents and commands
+        let agentCount = 0;
+        let commandCount = 0;
+        try {
+            const agentsPath = path.join(frameworkPath, 'agents');
+            const agents = await fs.readdir(agentsPath);
+            agentCount = agents.filter(f => f.endsWith('.md')).length;
+        }
+        catch {
+            // Agents directory doesn't exist
+        }
+        try {
+            const commandsPath = path.join(frameworkPath, 'commands');
+            const commands = await fs.readdir(commandsPath);
+            commandCount = commands.filter(f => f.endsWith('.md')).length;
+        }
+        catch {
+            // Commands directory doesn't exist
+        }
+        return {
+            name: frameworkName,
+            path: frameworkPath,
+            type: 'ide',
+            version: config.version,
+            capabilities: config.capabilities,
+            agentCount,
+            commandCount
+        };
+    }
+}
+//# sourceMappingURL=framework-detector.js.map