opkg 0.6.1 → 0.7.0

package/dist/core/platforms.js

@@ -2,219 +2,658 @@
  * Platform Management Module
  * Centralized platform definitions, directory mappings, and file patterns
  * for all 13 supported AI coding platforms
+ *
+ * Now supports flow-based configurations for declarative transformations.
  */
-import { join, relative } from 'path';
-import { exists, ensureDir } from '../utils/fs.js';
-import { logger } from '../utils/logger.js';
-import { getPathLeaf } from '../utils/path-normalization.js';
-import { DIR_PATTERNS, FILE_PATTERNS, UNIVERSAL_SUBDIRS } from '../constants/index.js';
-import { mapPlatformFileToUniversal } from '../utils/platform-mapper.js';
-import { parseUniversalPath } from '../utils/platform-file.js';
-import { readJsoncFileSync } from '../utils/jsonc.js';
-/**
- * Normalize subdir config from JSONC to internal SubdirDef format
- */
-function normalizeSubdirs(subdirs) {
-    if (!subdirs) {
-        return {};
-    }
-    const normalized = {};
-    for (const [subdirKey, subdirConfig] of Object.entries(subdirs)) {
-        // Validate that the subdir key is a valid universal subdir
-        if (!isValidUniversalSubdir(subdirKey)) {
-            logger.warn(`Invalid universal subdir key in platforms.jsonc: ${subdirKey}`);
-            continue;
-        }
-        // Skip if subdirConfig is undefined
-        if (!subdirConfig) {
-            continue;
-        }
-        normalized[subdirKey] = subdirConfig;
-    }
-    return normalized;
+import { join, relative } from "path";
+import { exists, ensureDir } from "../utils/fs.js";
+import { logger } from "../utils/logger.js";
+import { getPathLeaf } from "../utils/path-normalization.js";
+import { DIR_PATTERNS, FILE_PATTERNS, } from "../constants/index.js";
+import { mapPlatformFileToUniversal } from "../utils/platform-mapper.js";
+import { parseUniversalPath } from "../utils/platform-file.js";
+import { readJsoncFileSync, readJsoncOrJson } from "../utils/jsonc.js";
+import * as os from "os";
+import { matchesAnyPattern, extractSubdirectoriesFromPatterns } from "./universal-patterns.js";
+/**
+ * Check if a config entry is a global flows config
+ */
+function isGlobalFlowsConfig(cfg) {
+    return ('export' in cfg || 'import' in cfg) && !('name' in cfg) && !('rootDir' in cfg);
 }
 /**
- * Load platform definitions from platforms.jsonc file
+ * Create platform definitions from a PlatformsConfig object
+ * Export/import flows configuration (no legacy subdirs support)
+ * Assumes config is already validated.
+ * @param config - The merged platforms configuration
  */
-function loadPlatformDefinitionsFromConfig() {
-    const raw = readJsoncFileSync('platforms.jsonc');
+function createPlatformDefinitions(config) {
     const result = {};
-    for (const [id, cfg] of Object.entries(raw)) {
+    for (const [id, cfg] of Object.entries(config)) {
+        // Skip special keys
+        if (id === '$schema')
+            continue;
+        // Skip global config entry
+        if (id === 'global')
+            continue;
+        // Type guard for platform config
+        if (isGlobalFlowsConfig(cfg))
+            continue;
+        // Now we know cfg is PlatformConfig
+        const platformConfig = cfg;
         const platformId = id;
         result[platformId] = {
             id: platformId,
-            name: cfg.name,
-            rootDir: cfg.rootDir,
-            rootFile: cfg.rootFile,
-            subdirs: normalizeSubdirs(cfg.subdirs),
-            aliases: cfg.aliases,
-            enabled: cfg.enabled !== false
+            name: platformConfig.name,
+            rootDir: platformConfig.rootDir,
+            rootFile: platformConfig.rootFile,
+            export: platformConfig.export || [],
+            import: platformConfig.import || [],
+            aliases: platformConfig.aliases,
+            enabled: platformConfig.enabled !== false,
+            description: platformConfig.description,
+            variables: platformConfig.variables,
         };
     }
     return result;
 }
-// Unified platform definitions loaded from platforms.jsonc
-export const PLATFORM_DEFINITIONS = loadPlatformDefinitionsFromConfig();
-const PLATFORM_IDS = Object.freeze(Object.keys(PLATFORM_DEFINITIONS));
-// All platforms (including disabled) for internal reference
-export const ALL_PLATFORMS = PLATFORM_IDS;
-/**
- * Lookup map from platform directory name to platform ID.
- * Used for quickly inferring platform from source directory.
- */
-export const PLATFORM_DIR_LOOKUP = (() => {
-    const map = {};
-    for (const def of Object.values(PLATFORM_DEFINITIONS)) {
-        map[def.rootDir] = def.id;
-    }
-    return map;
-})();
-const PLATFORM_ALIAS_LOOKUP = (() => {
-    const map = {};
-    for (const def of Object.values(PLATFORM_DEFINITIONS)) {
+const BUILT_IN_CONFIG = readJsoncFileSync("platforms.jsonc");
+const builtinErrors = validatePlatformsConfig(BUILT_IN_CONFIG);
+if (builtinErrors.length > 0) {
+    throw new Error(`Built-in platforms.jsonc validation failed:\n  - ${builtinErrors.join('\n  - ')}`);
+}
+/**
+ * Merge two PlatformsConfig objects, handling per-platform fields and subdirs arrays properly.
+ * Adds new platforms from override; merges existing with override preferences.
+ */
+export function mergePlatformsConfig(base, override) {
+    const merged = { ...base };
+    for (const [platformId, overridePlat] of Object.entries(override)) {
+        // Skip special keys
+        if (platformId === '$schema') {
+            merged[platformId] = overridePlat;
+            continue;
+        }
+        const basePlat = base[platformId];
+        if (!basePlat) {
+            merged[platformId] = overridePlat;
+            continue;
+        }
+        // Handle global config separately
+        if (platformId === 'global') {
+            if (isGlobalFlowsConfig(overridePlat)) {
+                merged[platformId] = overridePlat; // Replace global config entirely
+            }
+            continue;
+        }
+        // Type guard for platform config
+        if (isGlobalFlowsConfig(overridePlat) || isGlobalFlowsConfig(basePlat)) {
+            merged[platformId] = overridePlat;
+            continue;
+        }
+        // Now we know both are PlatformConfig
+        const overrideCfg = overridePlat;
+        const baseCfg = basePlat;
+        merged[platformId] = {
+            name: overrideCfg.name ?? baseCfg.name,
+            rootDir: overrideCfg.rootDir ?? baseCfg.rootDir,
+            rootFile: overrideCfg.rootFile ?? baseCfg.rootFile,
+            aliases: overrideCfg.aliases ?? baseCfg.aliases, // replace array
+            enabled: overrideCfg.enabled ?? baseCfg.enabled,
+            description: overrideCfg.description ?? baseCfg.description,
+            variables: overrideCfg.variables ?? baseCfg.variables,
+            export: overrideCfg.export ?? baseCfg.export, // replace array (no merge)
+            import: overrideCfg.import ?? baseCfg.import, // replace array (no merge)
+        };
+    }
+    return merged;
+}
+/**
+ * Validate a PlatformsConfig object and return any validation errors.
+ * Export/import flows configuration (no legacy subdirs support).
+ * @param config - The config to validate
+ * @returns Array of error messages; empty if valid
+ */
+export function validatePlatformsConfig(config) {
+    const errors = [];
+    for (const [platformId, platConfig] of Object.entries(config)) {
+        // Skip special keys
+        if (platformId === '$schema') {
+            continue;
+        }
+        // Skip global config - validate separately
+        if (platformId === 'global') {
+            if (isGlobalFlowsConfig(platConfig)) {
+                errors.push(...validateGlobalFlowsConfig(platConfig));
+            }
+            continue;
+        }
+        // Type guard for platform config
+        if (isGlobalFlowsConfig(platConfig)) {
+            errors.push(`Platform '${platformId}': Cannot use global flows config format for platform entry`);
+            continue;
+        }
+        // Now we know platConfig is PlatformConfig
+        const cfg = platConfig;
+        if (!cfg.rootDir || cfg.rootDir.trim() === '') {
+            errors.push(`Platform '${platformId}': Missing or empty rootDir`);
+        }
+        if (!cfg.name || cfg.name.trim() === '') {
+            errors.push(`Platform '${platformId}': Missing or empty name`);
+        }
+        // Validate export flows
+        if (cfg.export !== undefined) {
+            if (!Array.isArray(cfg.export)) {
+                errors.push(`Platform '${platformId}': export must be array or undefined`);
+            }
+            else {
+                errors.push(...validateFlows(cfg.export, `${platformId}.export`));
+            }
+        }
+        // Validate import flows
+        if (cfg.import !== undefined) {
+            if (!Array.isArray(cfg.import)) {
+                errors.push(`Platform '${platformId}': import must be array or undefined`);
+            }
+            else {
+                errors.push(...validateFlows(cfg.import, `${platformId}.import`));
+            }
+        }
+        // Validate that export or import or rootFile is present
+        const hasExport = cfg.export && cfg.export.length > 0;
+        const hasImport = cfg.import && cfg.import.length > 0;
+        if (!hasExport && !hasImport && !cfg.rootFile) {
+            errors.push(`Platform '${platformId}': Must define at least one of 'export', 'import', or 'rootFile'`);
+        }
+        if (cfg.aliases !== undefined && (!Array.isArray(cfg.aliases) || cfg.aliases.some((a) => typeof a !== 'string'))) {
+            errors.push(`Platform '${platformId}': aliases must be array of strings or undefined`);
+        }
+        if (typeof cfg.enabled !== 'boolean' && cfg.enabled !== undefined) {
+            errors.push(`Platform '${platformId}': enabled must be boolean or undefined`);
+        }
+        if (cfg.variables !== undefined && (typeof cfg.variables !== 'object' || Array.isArray(cfg.variables))) {
+            errors.push(`Platform '${platformId}': variables must be object or undefined`);
+        }
+    }
+    return errors;
+}
+/**
+ * Validate global flows configuration
+ */
+function validateGlobalFlowsConfig(config) {
+    const errors = [];
+    if (config.export !== undefined) {
+        if (!Array.isArray(config.export)) {
+            errors.push(`Global config: export must be array or undefined`);
+        }
+        else {
+            errors.push(...validateFlows(config.export, 'global.export'));
+        }
+    }
+    if (config.import !== undefined) {
+        if (!Array.isArray(config.import)) {
+            errors.push(`Global config: import must be array or undefined`);
+        }
+        else {
+            errors.push(...validateFlows(config.import, 'global.import'));
+        }
+    }
+    if (config.description !== undefined && typeof config.description !== 'string') {
+        errors.push(`Global config: description must be string or undefined`);
+    }
+    return errors;
+}
+/**
+ * Validate an array of flows
+ */
+function validateFlows(flows, context) {
+    const errors = [];
+    for (let i = 0; i < flows.length; i++) {
+        const flow = flows[i];
+        // Required fields
+        if (!flow.from) {
+            errors.push(`${context}, flows[${i}]: Missing 'from' field`);
+        }
+        else if (typeof flow.from !== 'string' && !Array.isArray(flow.from)) {
+            errors.push(`${context}, flows[${i}]: 'from' must be string or array of strings`);
+        }
+        else if (typeof flow.from === 'string' && flow.from.trim() === '') {
+            errors.push(`${context}, flows[${i}]: 'from' cannot be empty`);
+        }
+        else if (Array.isArray(flow.from) && (flow.from.length === 0 || flow.from.some(p => typeof p !== 'string' || p.trim() === ''))) {
+            errors.push(`${context}, flows[${i}]: 'from' array must contain non-empty strings`);
+        }
+        if (!flow.to) {
+            errors.push(`${context}, flows[${i}]: Missing 'to' field`);
+        }
+        else if (typeof flow.to !== 'string' && typeof flow.to !== 'object') {
+            errors.push(`${context}, flows[${i}]: 'to' must be string or object`);
+        }
+        // Validate merge strategy
+        if (flow.merge !== undefined) {
+            const validMerges = ['replace', 'shallow', 'deep', 'composite'];
+            if (!validMerges.includes(flow.merge)) {
+                errors.push(`${context}, flows[${i}]: Invalid merge strategy '${flow.merge}'. Must be one of: ${validMerges.join(', ')}`);
+            }
+        }
+        // Note: pipe transforms are now handled within map pipeline via $pipe operation
+        // Validate map pipeline (must be array)
+        if (flow.map !== undefined && !Array.isArray(flow.map)) {
+            errors.push(`${context}, flows[${i}]: 'map' must be array of operations`);
+        }
+        // Validate pick/omit
+        if (flow.pick !== undefined && !Array.isArray(flow.pick)) {
+            errors.push(`${context}, flows[${i}]: 'pick' must be array or undefined`);
+        }
+        if (flow.omit !== undefined && !Array.isArray(flow.omit)) {
+            errors.push(`${context}, flows[${i}]: 'omit' must be array or undefined`);
+        }
+        // Validate embed
+        if (flow.embed !== undefined && (typeof flow.embed !== 'string' || flow.embed.trim() === '')) {
+            errors.push(`${context}, flows[${i}]: 'embed' must be non-empty string or undefined`);
+        }
+    }
+    return errors;
+}
+const GLOBAL_DIR = join(os.homedir(), ".openpackage");
+const stateCache = new Map();
+/**
+ * Clear the platforms cache. Useful for testing.
+ * @param cwd Optional path to clear cache for. If not provided, clears all cache.
+ */
+export function clearPlatformsCache(cwd) {
+    if (cwd !== undefined) {
+        stateCache.delete(cwd);
+    }
+    else {
+        stateCache.clear();
+    }
+}
+function getPlatformsState(cwd) {
+    const key = cwd ?? null;
+    if (stateCache.has(key)) {
+        return stateCache.get(key);
+    }
+    let config;
+    if (key === null) {
+        // Global
+        const globalFile = readJsoncOrJson(join(GLOBAL_DIR, "platforms.jsonc")) ??
+            readJsoncOrJson(join(GLOBAL_DIR, "platforms.json"));
+        config = globalFile
+            ? mergePlatformsConfig(BUILT_IN_CONFIG, globalFile)
+            : BUILT_IN_CONFIG;
+        const errors = validatePlatformsConfig(config);
+        if (errors.length > 0) {
+            throw new Error(`Global platforms config validation failed:\n  - ${errors.join('\n  - ')}`);
+        }
+    }
+    else {
+        // Local
+        const globalState = getPlatformsState(null);
+        const globalConfig = globalState.config;
+        const localDir = join(key, DIR_PATTERNS.OPENPACKAGE);
+        const localFile = readJsoncOrJson(join(localDir, "platforms.jsonc")) ??
+            readJsoncOrJson(join(localDir, "platforms.json"));
+        config = localFile
+            ? mergePlatformsConfig(globalConfig, localFile)
+            : globalConfig;
+        const errors = validatePlatformsConfig(config);
+        if (errors.length > 0) {
+            throw new Error(`Local platforms config validation failed in ${key}:\n  - ${errors.join('\n  - ')}`);
+        }
+    }
+    // Extract global flows if present
+    const globalConfig = config['global'];
+    const globalExportFlows = (globalConfig && isGlobalFlowsConfig(globalConfig))
+        ? globalConfig.export
+        : undefined;
+    const globalImportFlows = (globalConfig && isGlobalFlowsConfig(globalConfig))
+        ? globalConfig.import
+        : undefined;
+    // Create definitions and compute state
+    const defs = createPlatformDefinitions(config);
+    const dirLookup = {};
+    const aliasLookup = {};
+    const universalPatterns = new Set();
+    const rootFiles = [];
+    const allPlatforms = [];
+    // Collect all universal patterns from platform export flows
+    for (const def of Object.values(defs)) {
+        allPlatforms.push(def.id);
+        dirLookup[def.rootDir] = def.id;
         for (const alias of def.aliases ?? []) {
-            map[alias.toLowerCase()] = def.id;
+            aliasLookup[alias.toLowerCase()] = def.id;
+        }
+        // Collect all 'from' patterns from export flows
+        if (def.export && def.export.length > 0) {
+            for (const flow of def.export) {
+                // For array patterns, add all patterns
+                if (Array.isArray(flow.from)) {
+                    flow.from.forEach((p) => universalPatterns.add(p));
+                }
+                else {
+                    universalPatterns.add(flow.from);
+                }
+            }
         }
+        if (def.rootFile) {
+            rootFiles.push(def.rootFile);
+        }
+    }
+    // Add patterns from global export flows
+    if (globalExportFlows && globalExportFlows.length > 0) {
+        for (const flow of globalExportFlows) {
+            // For array patterns, add all patterns
+            if (Array.isArray(flow.from)) {
+                flow.from.forEach((p) => universalPatterns.add(p));
+            }
+            else {
+                universalPatterns.add(flow.from);
+            }
+        }
+    }
+    // Derive subdirectories from patterns (backward compatibility)
+    const universalSubdirs = extractSubdirectoriesFromPatterns(universalPatterns);
+    const enabledPlatforms = allPlatforms.filter((p) => defs[p].enabled);
+    const state = {
+        config,
+        globalExportFlows,
+        globalImportFlows,
+        defs,
+        dirLookup,
+        aliasLookup,
+        universalPatterns,
+        universalSubdirs,
+        rootFiles,
+        allPlatforms,
+        enabledPlatforms
+    };
+    stateCache.set(key, state);
+    return state;
+}
+export function getPlatformDefinitions(cwd) {
+    return getPlatformsState(cwd).defs;
+}
+/**
+ * Get global export flows that apply to all platforms (install/apply)
+ */
+export function getGlobalExportFlows(cwd) {
+    return getPlatformsState(cwd).globalExportFlows;
+}
+/**
+ * Get global import flows that apply to all platforms (save)
+ */
+export function getGlobalImportFlows(cwd) {
+    return getPlatformsState(cwd).globalImportFlows;
+}
+/**
+ * @deprecated Use getGlobalExportFlows() for export flows or getGlobalImportFlows() for import flows
+ */
+export function getGlobalFlows(cwd) {
+    // Return export flows for backward compatibility
+    return getPlatformsState(cwd).globalExportFlows;
+}
+/**
+ * Check if a platform uses flow-based configuration (export or import)
+ */
+export function platformUsesFlows(platform, cwd) {
+    try {
+        const def = getPlatformDefinition(platform, cwd);
+        const hasExport = def.export !== undefined && def.export.length > 0;
+        const hasImport = def.import !== undefined && def.import.length > 0;
+        return hasExport || hasImport;
     }
-    return map;
-})();
-const PLATFORM_ROOT_FILES = Object.freeze(Object.values(PLATFORM_DEFINITIONS)
-    .map(def => def.rootFile)
-    .filter((file) => typeof file === 'string'));
+    catch (error) {
+        // Platform not found - return false
+        return false;
+    }
+}
+/**
+ * Check if a platform uses legacy subdirs configuration
+ * @deprecated Always returns false - subdirs support removed
+ */
+export function platformUsesSubdirs(platform, cwd) {
+    return false;
+}
+/**
+ * Get all universal path patterns from flow definitions.
+ * These patterns define which files are considered universal package content.
+ * This is the source of truth for determining what belongs in a package.
+ *
+ * @param cwd - Optional cwd for local config overrides
+ * @returns Set of glob patterns from all platform flows
+ *
+ * @example
+ * // Returns: Set(["rules/**\/*.md", "mcp.jsonc", "commands/*.md", ...])
+ * const patterns = getAllUniversalPatterns()
+ */
+export function getAllUniversalPatterns(cwd) {
+    return new Set(getPlatformsState(cwd).universalPatterns);
+}
+/**
+ * Check if a file path matches any universal pattern from flows.
+ * This is the primary method for determining if a file is universal content.
+ *
+ * @param filePath - File path to check (normalized, no leading slash)
+ * @param cwd - Optional cwd for local config overrides
+ * @returns true if path matches any universal pattern
+ *
+ * @example
+ * matchesUniversalPattern("mcp.jsonc") // true (if defined in flows)
+ * matchesUniversalPattern("rules/typescript.md") // true
+ * matchesUniversalPattern("random-file.txt") // false
+ */
+export function matchesUniversalPattern(filePath, cwd) {
+    const patterns = getAllUniversalPatterns(cwd);
+    return matchesAnyPattern(filePath, patterns);
+}
+/**
+ * Get all unique universal subdirectory names defined across all platforms.
+ * This is derived from universal patterns for backward compatibility.
+ *
+ * @param cwd - Optional cwd for local config overrides
+ * @returns Set of all universal subdir names
+ * @deprecated Prefer using matchesUniversalPattern for file validation
+ */
+export function getAllUniversalSubdirs(cwd) {
+    return new Set(getPlatformsState(cwd).universalSubdirs);
+}
+/**
+ * Check if a string is a recognized universal subdir.
+ *
+ * @param subdirName - Name to check
+ * @param cwd - Optional cwd for local config overrides
+ * @returns true if the subdir is defined in any platform
+ * @deprecated Prefer using matchesUniversalPattern for file validation
+ */
+export function isKnownUniversalSubdir(subdirName, cwd) {
+    return getPlatformsState(cwd).universalSubdirs.has(subdirName);
+}
+/**
+ * Get lookup map from platform directory name to platform ID.
+ */
+export function getPlatformDirLookup(cwd) {
+    return getPlatformsState(cwd).dirLookup;
+}
+/**
+ * Get lookup map from platform alias to platform ID.
+ */
+export function getPlatformAliasLookup(cwd) {
+    return getPlatformsState(cwd).aliasLookup;
+}
+/**
+ * Get all known platform root files.
+ */
+export function getPlatformRootFiles(cwd) {
+    return getPlatformsState(cwd).rootFiles;
+}
 /**
  * Get platform definition by name
+ * @throws Error if platform not found
  */
-export function getPlatformDefinition(name) {
-    return PLATFORM_DEFINITIONS[name];
+export function getPlatformDefinition(name, cwd) {
+    const state = getPlatformsState(cwd);
+    const def = state.defs[name];
+    if (!def) {
+        throw new Error(`Unknown platform: ${name}`);
+    }
+    return def;
 }
 /**
  * Get all platforms
  */
-export function getAllPlatforms(options) {
+export function getAllPlatforms(options, cwd) {
+    const state = getPlatformsState(cwd);
     if (options?.includeDisabled) {
-        return [...PLATFORM_IDS];
+        return state.allPlatforms;
     }
-    return PLATFORM_IDS.filter(platform => PLATFORM_DEFINITIONS[platform].enabled);
+    return state.enabledPlatforms;
 }
-export function resolvePlatformName(input) {
+export function resolvePlatformName(input, cwd) {
     if (!input) {
         return undefined;
     }
+    const state = getPlatformsState(cwd);
     const normalized = input.toLowerCase();
-    if (normalized in PLATFORM_DEFINITIONS) {
+    if (normalized in state.defs) {
         return normalized;
     }
-    return PLATFORM_ALIAS_LOOKUP[normalized];
+    return state.aliasLookup[normalized];
 }
-export function getAllRootFiles() {
-    return [...PLATFORM_ROOT_FILES];
+/**
+ * Resolve a frontmatter/platform key (id or alias, case-insensitive) to a canonical platform id.
+ * Returns null when the key is not a known platform or alias.
+ */
+export function resolvePlatformKey(key, cwd) {
+    if (!key)
+        return null;
+    const normalized = key.toLowerCase();
+    const state = getPlatformsState(cwd);
+    if (normalized in state.defs) {
+        return normalized;
+    }
+    return state.aliasLookup[normalized] ?? null;
+}
+/**
+ * Internal helper to build directory paths for a single platform definition.
+ */
+function buildDirectoryPaths(definition, cwd) {
+    const subdirsPaths = {};
+    // Build from export flows (the flows that define workspace structure)
+    if (definition.export && definition.export.length > 0) {
+        for (const flow of definition.export) {
+            // Extract universal subdir from 'from' pattern
+            // For array patterns, use the first pattern
+            const fromPattern = Array.isArray(flow.from) ? flow.from[0] : flow.from;
+            const firstComponent = fromPattern.split('/')[0];
+            // Skip if it's a file (contains extension) or already exists
+            if (firstComponent && !firstComponent.includes('.') && !subdirsPaths[firstComponent]) {
+                // Extract platform subdir from 'to' pattern
+                const toPattern = typeof flow.to === 'string' ? flow.to : Object.values(flow.to)[0];
+                if (typeof toPattern === 'string') {
+                    // Get the directory part of the target path
+                    const targetPath = toPattern.split('/').slice(0, -1).join('/');
+                    if (targetPath) {
+                        subdirsPaths[firstComponent] = join(cwd, targetPath);
+                    }
+                }
+            }
+        }
+    }
+    return {
+        rootDir: join(cwd, definition.rootDir),
+        rootFile: definition.rootFile ? join(cwd, definition.rootFile) : undefined,
+        subdirs: subdirsPaths
+    };
 }
 /**
  * Get platform directory paths for a given working directory
  */
 export function getPlatformDirectoryPaths(cwd) {
+    const state = getPlatformsState(cwd);
     const paths = {};
-    for (const platform of getAllPlatforms()) {
-        const definition = getPlatformDefinition(platform);
-        const rulesSubdir = definition.subdirs[UNIVERSAL_SUBDIRS.RULES];
-        paths[platform] = {
-            rulesDir: join(cwd, definition.rootDir, rulesSubdir?.path || '')
-        };
-        if (definition.rootFile) {
-            paths[platform].rootFile = join(cwd, definition.rootFile);
-        }
-        const commandsSubdir = definition.subdirs[UNIVERSAL_SUBDIRS.COMMANDS];
-        if (commandsSubdir) {
-            paths[platform].commandsDir = join(cwd, definition.rootDir, commandsSubdir.path);
-        }
-        const agentsSubdir = definition.subdirs[UNIVERSAL_SUBDIRS.AGENTS];
-        if (agentsSubdir) {
-            paths[platform].agentsDir = join(cwd, definition.rootDir, agentsSubdir.path);
-        }
-        const skillsSubdir = definition.subdirs[UNIVERSAL_SUBDIRS.SKILLS];
-        if (skillsSubdir) {
-            paths[platform].skillsDir = join(cwd, definition.rootDir, skillsSubdir.path);
-        }
+    for (const platform of state.enabledPlatforms) {
+        paths[platform] = buildDirectoryPaths(state.defs[platform], cwd);
     }
     return paths;
 }
 /**
- * Detect platforms by their root files
- * Note: AGENTS.md is ambiguous (maps to multiple platforms), so we return empty for it
+ * Get directory paths for a specific platform.
+ * @throws Error if platform unknown
  */
-export async function detectPlatformByRootFile(cwd) {
-    const detectedPlatforms = [];
-    // Build dynamic root file mapping from platform definitions
-    const rootFileToPlatform = new Map();
-    for (const platform of getAllPlatforms()) {
-        const def = getPlatformDefinition(platform);
-        if (def.rootFile && def.rootFile !== FILE_PATTERNS.AGENTS_MD) {
-            rootFileToPlatform.set(def.rootFile, platform);
-        }
-    }
-    // Check for existence of each root file at cwd
-    for (const [rootFile, platform] of rootFileToPlatform.entries()) {
-        const filePath = join(cwd, rootFile);
-        if (await exists(filePath)) {
-            detectedPlatforms.push(platform);
-        }
+export function getPlatformDirectoryPathsForPlatform(platform, cwd) {
+    const state = getPlatformsState(cwd);
+    const definition = state.defs[platform];
+    if (!definition) {
+        throw new Error(`Unknown platform: ${platform}`);
     }
-    return detectedPlatforms;
+    return buildDirectoryPaths(definition, cwd);
 }
 /**
  * Detect all platforms present in a directory
- * Checks both platform directories and root files
+ * Checks both platform directories (.platform/) and unique root files (e.g., CLAUDE.md)
+ * AGENTS.md is skipped as it's universal/ambiguous.
  */
 export async function detectAllPlatforms(cwd) {
-    // Check all platforms by directory in parallel
-    const detectionPromises = getAllPlatforms().map(async (platform) => {
-        const definition = getPlatformDefinition(platform);
+    const state = getPlatformsState(cwd);
+    const detectionPromises = state.enabledPlatforms.map(async (platform) => {
+        const definition = state.defs[platform];
         const rootDirPath = join(cwd, definition.rootDir);
-        // Check if the rootDir exists strictly in the cwd
-        const detected = await exists(rootDirPath);
+        // Detected if root dir exists OR unique root file exists (skip AGENTS.md)
+        const dirExists = await exists(rootDirPath);
+        let fileExists = false;
+        if (definition.rootFile &&
+            definition.rootFile !== FILE_PATTERNS.AGENTS_MD) {
+            const rootFilePath = join(cwd, definition.rootFile);
+            fileExists = await exists(rootFilePath);
+        }
+        const detected = dirExists || fileExists;
         return {
             name: platform,
-            detected
+            detected,
         };
     });
-    const detectionResults = await Promise.all(detectionPromises);
-    // Also detect by root files
-    const rootFileDetectedPlatforms = await detectPlatformByRootFile(cwd);
-    // Merge results - mark platforms as detected if they have either directory or root file
-    for (const platform of rootFileDetectedPlatforms) {
-        const result = detectionResults.find(r => r.name === platform);
-        if (result && !result.detected) {
-            result.detected = true;
-        }
-    }
-    return detectionResults;
+    return await Promise.all(detectionPromises);
 }
 /**
  * Get detected platforms only
  */
 export async function getDetectedPlatforms(cwd) {
     const results = await detectAllPlatforms(cwd);
-    return results.filter(result => result.detected).map(result => result.name);
+    return results
+        .filter((result) => result.detected)
+        .map((result) => result.name);
 }
 /**
  * Create platform directories
  */
+/**
+ * Create platform directories
+ * @deprecated Subdirs support removed - flows create directories as needed
+ * Only creates root directory for platforms now
+ */
 export async function createPlatformDirectories(cwd, platforms) {
+    const state = getPlatformsState(cwd);
     const created = [];
-    const paths = getPlatformDirectoryPaths(cwd);
     for (const platform of platforms) {
-        const platformPaths = paths[platform];
+        const definition = state.defs[platform];
+        if (!definition) {
+            throw new Error(`Unknown platform: ${platform}`);
+        }
+        // Only create root directory
+        const rootPath = join(cwd, definition.rootDir);
         try {
-            const dirExists = await exists(platformPaths.rulesDir);
+            const dirExists = await exists(rootPath);
             if (!dirExists) {
-                await ensureDir(platformPaths.rulesDir);
-                created.push(relative(cwd, platformPaths.rulesDir));
-                logger.debug(`Created platform directory: ${platformPaths.rulesDir}`);
+                await ensureDir(rootPath);
+                created.push(relative(cwd, rootPath));
+                logger.debug(`Created platform root directory: ${rootPath}`);
             }
         }
         catch (error) {
-            logger.error(`Failed to create platform directory ${platformPaths.rulesDir}: ${error}`);
+            logger.error(`Failed to create platform root directory (${rootPath}): ${error}`);
         }
+        // Flow-based installations will create subdirectories as needed
     }
     return created;
 }
@@ -222,109 +661,125 @@ export async function createPlatformDirectories(cwd, platforms) {
  * Validate platform directory structure
  */
 export async function validatePlatformStructure(cwd, platform) {
-    const issues = [];
-    const definition = getPlatformDefinition(platform);
-    const paths = getPlatformDirectoryPaths(cwd);
-    const platformPaths = paths[platform];
-    // Check if rules directory exists
-    if (!(await exists(platformPaths.rulesDir))) {
-        issues.push(`Rules directory does not exist: ${platformPaths.rulesDir}`);
+    const state = getPlatformsState(cwd);
+    const definition = state.defs[platform];
+    if (!definition) {
+        throw new Error(`Unknown platform: ${platform}`);
     }
-    // Check root file for platforms that require it
-    if (definition.rootFile && platformPaths.rootFile) {
-        if (!(await exists(platformPaths.rootFile))) {
-            issues.push(`Root file does not exist: ${platformPaths.rootFile}`);
+    const issues = [];
+    // Check root file
+    if (definition.rootFile) {
+        const rootFilePath = join(cwd, definition.rootFile);
+        if (!(await exists(rootFilePath))) {
+            issues.push(`Root file does not exist: ${rootFilePath}`);
         }
     }
+    // TODO: Optionally check flow-based directories exist
+    // (may not be necessary since flows handle missing directories gracefully)
     return {
         valid: issues.length === 0,
-        issues
+        issues,
     };
 }
 /**
- * Get rules directory file patterns for a specific platform
+ * Get file extensions allowed in a specific universal subdir for a platform
+ * @param universalSubdir - The universal subdirectory name (e.g., 'rules', 'commands', or custom)
+ * @returns Allowed extensions or empty array if subdir not supported
  */
-export function getPlatformRulesDirFilePatterns(platform) {
-    const definition = getPlatformDefinition(platform);
-    return definition.subdirs[UNIVERSAL_SUBDIRS.RULES]?.exts || [];
+export function getPlatformSubdirExts(platform, universalSubdir, cwd) {
+    const state = getPlatformsState(cwd);
+    const definition = state.defs[platform];
+    if (!definition) {
+        throw new Error(`Unknown platform: ${platform}`);
+    }
+    // Check export flows
+    if (definition.export && definition.export.length > 0) {
+        const extensions = new Set();
+        for (const flow of definition.export) {
+            // Check if this flow matches the universal subdir
+            // For array patterns, use the first pattern
+            const fromPattern = Array.isArray(flow.from) ? flow.from[0] : flow.from;
+            if (fromPattern.startsWith(`${universalSubdir}/`)) {
+                // Extract extension from the 'from' pattern
+                const extMatch = fromPattern.match(/\.[^./]+$/);
+                if (extMatch) {
+                    extensions.add(extMatch[0]);
+                }
+                // Also check 'to' pattern for extension changes
+                const toPattern = typeof flow.to === 'string' ? flow.to : Object.values(flow.to)[0];
+                if (typeof toPattern === 'string') {
+                    const toExtMatch = toPattern.match(/\.[^./]+$/);
+                    if (toExtMatch) {
+                        extensions.add(toExtMatch[0]);
+                    }
+                }
+            }
+        }
+        if (extensions.size > 0) {
+            return Array.from(extensions);
+        }
+    }
+    logger.warn(`Platform ${platform} does not support universal subdir '${universalSubdir}'`);
+    return [];
 }
 /**
  * Get all universal subdirs that exist for a platform
  */
 export function getPlatformUniversalSubdirs(cwd, platform) {
-    const paths = getPlatformDirectoryPaths(cwd);
-    const platformPaths = paths[platform];
+    const paths = getPlatformDirectoryPathsForPlatform(platform, cwd);
     const subdirs = [];
-    if (platformPaths.rulesDir)
-        subdirs.push({ dir: platformPaths.rulesDir, label: UNIVERSAL_SUBDIRS.RULES, leaf: getPathLeaf(platformPaths.rulesDir) });
-    if (platformPaths.commandsDir)
-        subdirs.push({ dir: platformPaths.commandsDir, label: UNIVERSAL_SUBDIRS.COMMANDS, leaf: getPathLeaf(platformPaths.commandsDir) });
-    if (platformPaths.agentsDir)
-        subdirs.push({ dir: platformPaths.agentsDir, label: UNIVERSAL_SUBDIRS.AGENTS, leaf: getPathLeaf(platformPaths.agentsDir) });
-    if (platformPaths.skillsDir)
-        subdirs.push({ dir: platformPaths.skillsDir, label: UNIVERSAL_SUBDIRS.SKILLS, leaf: getPathLeaf(platformPaths.skillsDir) });
+    for (const [label, dir] of Object.entries(paths.subdirs)) {
+        subdirs.push({
+            dir,
+            label,
+            leaf: getPathLeaf(dir),
+        });
+    }
     return subdirs;
 }
 /**
  * Check if a normalized path represents a universal subdir
  */
-export function isUniversalSubdirPath(normalizedPath) {
-    return Object.values(UNIVERSAL_SUBDIRS).some(subdir => {
-        return (normalizedPath.startsWith(`${subdir}/`) ||
+export function isUniversalSubdirPath(normalizedPath, cwd) {
+    const state = getPlatformsState(cwd);
+    for (const subdir of state.universalSubdirs) {
+        if (normalizedPath.startsWith(`${subdir}/`) ||
             normalizedPath === subdir ||
             normalizedPath.startsWith(`${DIR_PATTERNS.OPENPACKAGE}/${subdir}/`) ||
-            normalizedPath === `${DIR_PATTERNS.OPENPACKAGE}/${subdir}`);
-    });
-}
-/**
- * Check if a subKey is a valid universal subdir
- * Used for validating subdir keys before processing
- */
-export function isValidUniversalSubdir(subKey) {
-    return Object.values(UNIVERSAL_SUBDIRS).includes(subKey);
+            normalizedPath === `${DIR_PATTERNS.OPENPACKAGE}/${subdir}`) {
+            return true;
+        }
+    }
+    return false;
 }
 /**
  * Check if a value is a valid platform ID.
  */
-export function isPlatformId(value) {
-    return !!value && value in PLATFORM_DEFINITIONS;
+export function isPlatformId(value, cwd) {
+    if (!value)
+        return false;
+    return value in getPlatformsState(cwd).defs;
 }
 /**
- * Determine whether an extension is allowed for a given subdir definition.
+ * @deprecated Subdirs support removed - use flows instead
+ * Always returns false for backward compatibility
  */
 export function isExtAllowed(subdirDef, ext) {
-    if (!subdirDef) {
-        return false;
-    }
-    if (subdirDef.exts === undefined) {
-        return true;
-    }
-    if (subdirDef.exts.length === 0) {
-        return false;
-    }
-    return subdirDef.exts.includes(ext);
+    return false;
 }
 /**
- * Convert a package (registry) extension to the workspace extension.
- * Falls back to the original extension if no transformation applies.
+ * @deprecated Subdirs support removed - use flows instead
+ * Always returns original extension for backward compatibility
  */
 export function getWorkspaceExt(subdirDef, packageExt) {
-    if (!subdirDef.transformations || packageExt === '') {
-        return packageExt;
-    }
-    const transformation = subdirDef.transformations.find(({ packageExt: candidate }) => candidate === packageExt);
-    return transformation?.workspaceExt ?? packageExt;
+    return packageExt;
 }
 /**
- * Convert a workspace extension to the package (registry) extension.
- * Falls back to the original extension if no transformation applies.
+ * @deprecated Subdirs support removed - use flows instead
+ * Always returns original extension for backward compatibility
  */
 export function getPackageExt(subdirDef, workspaceExt) {
-    if (!subdirDef.transformations || workspaceExt === '') {
-        return workspaceExt;
-    }
-    const transformation = subdirDef.transformations.find(({ workspaceExt: candidate }) => candidate === workspaceExt);
-    return transformation?.packageExt ?? workspaceExt;
+    return workspaceExt;
 }
 /**
  * Infer platform from workspace file information.
@@ -337,22 +792,23 @@ export function getPackageExt(subdirDef, workspaceExt) {
  * @param fullPath - Full absolute path to the file
  * @param sourceDir - Source directory name (e.g., '.cursor', 'ai')
  * @param registryPath - Registry path (e.g., 'rules/file.md')
+ * @param cwd - Optional cwd for local platform config overrides
  * @returns Platform ID, 'ai', or undefined if cannot be determined
  */
-export function inferPlatformFromWorkspaceFile(fullPath, sourceDir, registryPath) {
+export function inferPlatformFromWorkspaceFile(fullPath, sourceDir, registryPath, cwd) {
     // First try to get platform from full path using existing mapper
-    const mapping = mapPlatformFileToUniversal(fullPath);
+    const mapping = mapPlatformFileToUniversal(fullPath, cwd);
     if (mapping?.platform) {
         return mapping.platform;
     }
     // Look up platform from source directory
-    const fromSource = PLATFORM_DIR_LOOKUP[sourceDir];
+    const fromSource = getPlatformDirLookup(cwd)[sourceDir];
     if (fromSource) {
         return fromSource;
     }
     // Fallback: check registry path for platform suffix
     const parsed = parseUniversalPath(registryPath, { allowPlatformSuffix: true });
-    if (parsed?.platformSuffix && isPlatformId(parsed.platformSuffix)) {
+    if (parsed?.platformSuffix && isPlatformId(parsed.platformSuffix, cwd)) {
         return parsed.platformSuffix;
     }
     return undefined;