opkg 0.9.0 → 0.9.2

package/packages/core/dist/core/install/detection-types.d.ts

@@ -0,0 +1,216 @@
+/**
+ * Detection Types Module
+ *
+ * Type definitions for file-level format detection system.
+ * Platform IDs are dynamic strings (any key from platforms.jsonc).
+ */
+import type { Flow } from '../../types/flows.js';
+/**
+ * Platform ID is a dynamic string - any key from platforms.jsonc
+ * NOT a hardcoded union type. This enables extensibility without code changes.
+ */
+export type PlatformId = string;
+/**
+ * Special format values for edge cases
+ */
+export type SpecialFormat = 'universal' | 'unknown';
+/**
+ * Detected format for a single file
+ */
+export interface FileFormat {
+    /** Platform ID from platforms.jsonc or special value */
+    platform: PlatformId | SpecialFormat;
+    /** Confidence score (0-1) normalized */
+    confidence: number;
+    /** The flow that matched (if any) */
+    matchedFlow: Flow | null;
+    /** Schema path that matched (if any) */
+    matchedSchema: string | null;
+    /** Fields that contributed to score */
+    matchedFields: string[];
+    /** Original file path */
+    path: string;
+}
+/**
+ * Flow pattern object with optional schema reference
+ */
+export interface FlowPattern {
+    /** Glob pattern (e.g., "agents/**\/*.md") */
+    pattern: string;
+    /** Explicit path to schema (e.g., "./schemas/formats/claude-agent.schema.json") */
+    schema?: string;
+}
+/**
+ * Extended flow type supporting pattern objects with schema references
+ * Note: This is a separate interface, not extending Flow, because the pattern types differ
+ */
+export interface FlowWithSchema {
+    /** Source pattern(s) - can be string, array of strings, pattern objects, or switch expression */
+    from: string | string[] | FlowPattern | FlowPattern[] | Flow['from'];
+    /** Target pattern - can be string, pattern object, or switch expression */
+    to: string | FlowPattern | Flow['to'];
+    /** All other Flow properties */
+    map?: Flow['map'];
+    pick?: Flow['pick'];
+    omit?: Flow['omit'];
+    path?: Flow['path'];
+    embed?: Flow['embed'];
+    section?: Flow['section'];
+    when?: Flow['when'];
+    merge?: Flow['merge'];
+    handler?: Flow['handler'];
+    priority?: Flow['priority'];
+    description?: Flow['description'];
+}
+/**
+ * JSON Schema with detection extensions
+ */
+export interface DetectionSchema {
+    $schema: string;
+    $id: string;
+    title: string;
+    description?: string;
+    type: string;
+    properties?: {
+        [key: string]: SchemaProperty;
+    };
+    'x-detection'?: {
+        platform: string;
+    };
+}
+/**
+ * Schema property with detection extensions
+ */
+export interface SchemaProperty {
+    type?: string | string[];
+    enum?: any[];
+    pattern?: string;
+    items?: SchemaProperty;
+    properties?: {
+        [key: string]: SchemaProperty;
+    };
+    additionalProperties?: boolean | SchemaProperty;
+    description?: string;
+    /** Detection weight (0-1) - contribution to confidence score */
+    'x-detection-weight'?: number;
+    /** Field only exists in this platform format (stronger signal) */
+    'x-exclusive'?: boolean;
+}
+/**
+ * Detection result for a single file against a single schema
+ */
+export interface SchemaMatchResult {
+    /** Platform ID from schema */
+    platform: PlatformId;
+    /** Schema path */
+    schemaPath: string;
+    /** Flow that referenced this schema */
+    flow: Flow;
+    /** Confidence score (0-1) */
+    score: number;
+    /** Maximum possible score for this schema */
+    maxScore: number;
+    /** Fields that matched */
+    matchedFields: string[];
+    /** Path boost applied (if file path matches flow pattern) */
+    pathBoost: number;
+}
+/**
+ * Package file interface for detection
+ */
+export interface PackageFile {
+    /** File path relative to package root */
+    path: string;
+    /** File content (may be lazy-loaded) */
+    content?: string;
+    /** Parsed frontmatter (if markdown file) */
+    frontmatter?: Record<string, any>;
+}
+/**
+ * Special format identifier for mixed packages
+ */
+export type MixedFormat = 'mixed';
+/**
+ * Enhanced package format detection result
+ *
+ * Comprehensive format analysis for entire package including:
+ * - Overall package format
+ * - Detection method used
+ * - Per-file format breakdown
+ * - Package-level markers found
+ * - Distribution statistics
+ */
+export interface EnhancedPackageFormat {
+    /**
+     * Overall package format
+     * - Dynamic platform ID from platforms.jsonc (e.g., 'claude', 'cursor', 'opencode')
+     * - 'universal' - no platform-specific format detected
+     * - 'mixed' - multiple platform formats detected
+     * - 'unknown' - could not determine format
+     */
+    packageFormat: PlatformId | SpecialFormat | MixedFormat;
+    /**
+     * Detection method used
+     * - 'package-marker' - Fast path via explicit markers (e.g., .claude-plugin/plugin.json)
+     * - 'per-file' - Detailed path via schema-based per-file detection
+     * - 'directory-structure' - Fallback via directory pattern analysis
+     */
+    detectionMethod: 'package-marker' | 'per-file' | 'directory-structure';
+    /**
+     * Overall confidence (0-1)
+     * Higher = more certain about the format
+     */
+    confidence: number;
+    /**
+     * Per-file format breakdown (for mixed packages)
+     * Map of file path -> detected format
+     */
+    fileFormats?: Map<string, FileFormat>;
+    /**
+     * Files grouped by platform ID
+     * Map of platform -> array of file paths
+     */
+    formatGroups?: Map<PlatformId | SpecialFormat, string[]>;
+    /**
+     * Package-level markers found
+     * Derived from platforms.jsonc detection arrays
+     */
+    markers?: {
+        /** Patterns that matched from platforms.jsonc */
+        matchedPatterns: Array<{
+            platformId: PlatformId;
+            pattern: string;
+        }>;
+        /** Whether openpackage.yml exists */
+        hasOpenPackageYml?: boolean;
+        /** Whether package.yml exists (legacy) */
+        hasPackageYml?: boolean;
+    };
+    /**
+     * Analysis metadata for debugging/logging
+     */
+    analysis: {
+        /** Total files in package */
+        totalFiles: number;
+        /** Files analyzed (with frontmatter) */
+        analyzedFiles: number;
+        /** Files skipped (no frontmatter or non-markdown) */
+        skippedFiles: number;
+        /** Distribution by platform ID - count per platform */
+        formatDistribution: Map<PlatformId | SpecialFormat, number>;
+    };
+}
+/**
+ * Format group - files grouped by detected platform
+ *
+ * Used in Phase 3 for per-group conversion
+ */
+export interface FormatGroup {
+    /** Platform ID for this group */
+    platformId: PlatformId | SpecialFormat;
+    /** Files in this group */
+    files: PackageFile[];
+    /** Average confidence across files */
+    confidence: number;
+}
+//# sourceMappingURL=detection-types.d.ts.map

package/packages/core/dist/core/install/detection-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detection-types.d.ts","sourceRoot":"","sources":["../../../src/core/install/detection-types.ts"],"names":[],"mappings":"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"}

package/packages/core/dist/core/install/detection-types.js

@@ -0,0 +1,8 @@
+/**
+ * Detection Types Module
+ *
+ * Type definitions for file-level format detection system.
+ * Platform IDs are dynamic strings (any key from platforms.jsonc).
+ */
+export {};
+//# sourceMappingURL=detection-types.js.map

package/packages/core/dist/core/install/detection-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detection-types.js","sourceRoot":"","sources":["../../../src/core/install/detection-types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/packages/core/dist/core/install/download-keys.d.ts

@@ -0,0 +1,10 @@
+import type { PullPackageDownload } from '../../types/api.js';
+/**
+ * Create a unique key for a download based on name and version
+ */
+export declare function createDownloadKey(name: string, version: string): string;
+/**
+ * Compute which download keys are missing locally
+ */
+export declare function computeMissingDownloadKeys(downloads: PullPackageDownload[]): Promise<Set<string>>;
+//# sourceMappingURL=download-keys.d.ts.map

package/packages/core/dist/core/install/download-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"download-keys.d.ts","sourceRoot":"","sources":["../../../src/core/install/download-keys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAI9D;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvE;AAED;;GAEG;AACH,wBAAsB,0BAA0B,CAAC,SAAS,EAAE,mBAAmB,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAwBvG"}

package/packages/core/dist/core/install/download-keys.js

@@ -0,0 +1,34 @@
+import { hasPackageVersion } from '../directory.js';
+import { parseDownloadIdentifier } from '../remote-pull.js';
+/**
+ * Create a unique key for a download based on name and version
+ */
+export function createDownloadKey(name, version) {
+    return `${name}@${version}`;
+}
+/**
+ * Compute which download keys are missing locally
+ */
+export async function computeMissingDownloadKeys(downloads) {
+    const missingKeys = new Set();
+    for (const download of downloads) {
+        if (!download?.name) {
+            continue;
+        }
+        try {
+            const { packageName: name, version } = parseDownloadIdentifier(download.name);
+            if (!version) {
+                continue;
+            }
+            const existsLocally = await hasPackageVersion(name, version);
+            if (!existsLocally) {
+                missingKeys.add(createDownloadKey(name, version));
+            }
+        }
+        catch (error) {
+            // Skip download due to invalid name
+        }
+    }
+    return missingKeys;
+}
+//# sourceMappingURL=download-keys.js.map

package/packages/core/dist/core/install/download-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"download-keys.js","sourceRoot":"","sources":["../../../src/core/install/download-keys.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAE5D;;GAEG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAY,EAAE,OAAe;IAC7D,OAAO,GAAG,IAAI,IAAI,OAAO,EAAE,CAAC;AAC9B,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,0BAA0B,CAAC,SAAgC;IAC/E,MAAM,WAAW,GAAG,IAAI,GAAG,EAAU,CAAC;IAEtC,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;QACjC,IAAI,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC;YACpB,SAAS;QACX,CAAC;QAED,IAAI,CAAC;YACH,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,uBAAuB,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YAC9E,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,SAAS;YACX,CAAC;YAED,MAAM,aAAa,GAAG,MAAM,iBAAiB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;YAC7D,IAAI,CAAC,aAAa,EAAE,CAAC;gBACnB,WAAW,CAAC,GAAG,CAAC,iBAAiB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;YACpD,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,oCAAoC;QACtC,CAAC;IACH,CAAC;IAED,OAAO,WAAW,CAAC;AACrB,CAAC"}

package/packages/core/dist/core/install/file-format-detector.d.ts

@@ -0,0 +1,52 @@
+/**
+ * File Format Detector Module
+ *
+ * Detects format for individual files using schema-based scoring.
+ * Core detection logic for per-file format analysis.
+ */
+import type { Flow } from '../../types/flows.js';
+import type { DetectionSchema, FileFormat, SchemaMatchResult, PackageFile, PlatformId } from './detection-types.js';
+/**
+ * Detect format for a single file
+ *
+ * Main entry point for file-level format detection.
+ * Scores file against all platform schemas and returns best match.
+ *
+ * @param file - Package file with path and optional content/frontmatter
+ * @param targetDir - Optional target directory for local platform config
+ * @returns Detected format with confidence score
+ */
+export declare function detectFileFormat(file: PackageFile, targetDir?: string): FileFormat;
+/**
+ * Score frontmatter against a schema
+ *
+ * Calculates confidence score based on:
+ * - Field presence and type matching
+ * - Detection weights from schema
+ * - Exclusive field bonuses
+ * - Path pattern matching boost
+ *
+ * @param frontmatter - Parsed frontmatter object
+ * @param schema - Detection schema with x-detection-weight extensions
+ * @param flow - Flow that references this schema
+ * @param filePath - File path for pattern matching
+ * @param platformId - Platform ID for result
+ * @returns Schema match result with score breakdown
+ */
+export declare function scoreAgainstSchema(frontmatter: Record<string, any>, schema: DetectionSchema, flow: Flow, filePath: string, platformId: PlatformId): SchemaMatchResult;
+/**
+ * Batch detect formats for multiple files
+ *
+ * @param files - Array of package files
+ * @param targetDir - Optional target directory
+ * @returns Map of file path -> detected format
+ */
+export declare function detectFileFormats(files: PackageFile[], targetDir?: string): Map<string, FileFormat>;
+/**
+ * Group files by detected format
+ *
+ * @param formats - Map of file path -> format
+ * @returns Map of platform -> file paths
+ */
+export declare function groupFilesByFormat(formats: Map<string, FileFormat>): Map<PlatformId | 'unknown', string[]>;
+//# sourceMappingURL=file-format-detector.d.ts.map

package/packages/core/dist/core/install/file-format-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-format-detector.d.ts","sourceRoot":"","sources":["../../../src/core/install/file-format-detector.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,KAAK,EACV,eAAe,EAEf,UAAU,EACV,iBAAiB,EACjB,WAAW,EACX,UAAU,EACX,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,WAAW,EACjB,SAAS,CAAC,EAAE,MAAM,GACjB,UAAU,CAyGZ;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAChC,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,UAAU,GACrB,iBAAiB,CAkDnB;AAgID;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,WAAW,EAAE,EACpB,SAAS,CAAC,EAAE,MAAM,GACjB,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CASzB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,GAC/B,GAAG,CAAC,UAAU,GAAG,SAAS,EAAE,MAAM,EAAE,CAAC,CAWvC"}

package/packages/core/dist/core/install/file-format-detector.js

@@ -0,0 +1,317 @@
+/**
+ * File Format Detector Module
+ *
+ * Detects format for individual files using schema-based scoring.
+ * Core detection logic for per-file format analysis.
+ */
+import { minimatch } from 'minimatch';
+import { logger } from '../../utils/logger.js';
+import { splitFrontmatter } from '../markdown-frontmatter.js';
+import { schemaRegistry, getPatternFromFlow } from './schema-registry.js';
+import { getPlatformDefinitions, isPlatformId, matchesUniversalPattern } from '../platforms.js';
+import { extractPlatformSuffixFromFilename } from '../flows/platform-suffix-handler.js';
+/**
+ * Detect format for a single file
+ *
+ * Main entry point for file-level format detection.
+ * Scores file against all platform schemas and returns best match.
+ *
+ * @param file - Package file with path and optional content/frontmatter
+ * @param targetDir - Optional target directory for local platform config
+ * @returns Detected format with confidence score
+ */
+export function detectFileFormat(file, targetDir) {
+    // Parse frontmatter if not already parsed
+    let frontmatter = file.frontmatter;
+    if (!frontmatter && file.content) {
+        const parsed = splitFrontmatter(file.content);
+        frontmatter = parsed.frontmatter || {};
+    }
+    // No frontmatter - use path-based fallback for universal locations
+    if (!frontmatter || Object.keys(frontmatter).length === 0) {
+        // Files at universal paths (commands/, agents/, rules/, etc.) or config files
+        // are already in universal format; treat as universal, not unknown
+        const normalizedPath = file.path.replace(/\\/g, '/').replace(/^\.\/?/, '');
+        if (matchesUniversalPattern(normalizedPath, targetDir)) {
+            return {
+                platform: 'universal',
+                confidence: 0.3,
+                matchedFlow: null,
+                matchedSchema: null,
+                matchedFields: [],
+                path: file.path
+            };
+        }
+        return {
+            platform: 'unknown',
+            confidence: 0,
+            matchedFlow: null,
+            matchedSchema: null,
+            matchedFields: [],
+            path: file.path
+        };
+    }
+    // Score against all platform schemas
+    const platforms = getPlatformDefinitions(targetDir);
+    const matches = [];
+    for (const [platformId, def] of Object.entries(platforms)) {
+        // Check both export and import flows for schemas
+        // Export flows: universal -> platform (has platform schema on 'to')
+        // Import flows: platform -> universal (has platform schema on 'from')
+        // Check export flows for platform format schemas (on 'to' field)
+        if (def.export && def.export.length > 0) {
+            for (const flow of def.export) {
+                const schema = schemaRegistry.getSchemaForFlow(flow, 'to');
+                if (!schema)
+                    continue;
+                const match = scoreAgainstSchema(frontmatter, schema, flow, file.path, platformId);
+                if (match.score > 0) {
+                    matches.push(match);
+                }
+            }
+        }
+        // Check import flows for platform format schemas (on 'from' field)
+        if (def.import && def.import.length > 0) {
+            for (const flow of def.import) {
+                const schema = schemaRegistry.getSchemaForFlow(flow, 'from');
+                if (!schema)
+                    continue;
+                const match = scoreAgainstSchema(frontmatter, schema, flow, file.path, platformId);
+                if (match.score > 0) {
+                    matches.push(match);
+                }
+            }
+        }
+    }
+    // No matches - use path-based platform suffix if present (e.g. foo.opencode.md)
+    if (matches.length === 0) {
+        const pathPlatform = extractPlatformSuffixFromFilename(file.path);
+        if (pathPlatform && isPlatformId(pathPlatform)) {
+            return {
+                platform: pathPlatform,
+                confidence: 0.7,
+                matchedFlow: null,
+                matchedSchema: null,
+                matchedFields: [],
+                path: file.path
+            };
+        }
+        return {
+            platform: 'universal',
+            confidence: 0.3,
+            matchedFlow: null,
+            matchedSchema: null,
+            matchedFields: [],
+            path: file.path
+        };
+    }
+    // Select best match
+    const bestMatch = matches.reduce((best, current) => current.score > best.score ? current : best);
+    return {
+        platform: bestMatch.platform,
+        confidence: Math.min(1.0, bestMatch.score / bestMatch.maxScore),
+        matchedFlow: bestMatch.flow,
+        matchedSchema: bestMatch.schemaPath,
+        matchedFields: bestMatch.matchedFields,
+        path: file.path
+    };
+}
+/**
+ * Score frontmatter against a schema
+ *
+ * Calculates confidence score based on:
+ * - Field presence and type matching
+ * - Detection weights from schema
+ * - Exclusive field bonuses
+ * - Path pattern matching boost
+ *
+ * @param frontmatter - Parsed frontmatter object
+ * @param schema - Detection schema with x-detection-weight extensions
+ * @param flow - Flow that references this schema
+ * @param filePath - File path for pattern matching
+ * @param platformId - Platform ID for result
+ * @returns Schema match result with score breakdown
+ */
+export function scoreAgainstSchema(frontmatter, schema, flow, filePath, platformId) {
+    let score = 0;
+    let maxScore = 0;
+    const matchedFields = [];
+    // Score each field
+    if (schema.properties) {
+        for (const [fieldName, property] of Object.entries(schema.properties)) {
+            const weight = property['x-detection-weight'] || 0.1;
+            maxScore += weight;
+            // Check if field exists in frontmatter
+            if (!(fieldName in frontmatter)) {
+                continue;
+            }
+            const value = frontmatter[fieldName];
+            // Validate against schema constraints
+            if (!validateFieldAgainstSchema(value, property)) {
+                continue;
+            }
+            // Field matches - add weight
+            score += weight;
+            matchedFields.push(fieldName);
+            // Bonus for exclusive fields
+            if (property['x-exclusive']) {
+                score += 0.1;
+            }
+        }
+    }
+    // Add path boost if file matches flow pattern
+    const pathBoost = getPathBoost(filePath, flow);
+    score += pathBoost;
+    // Extract schema path from flow
+    const schemaPath = extractSchemaPathFromFlow(flow);
+    return {
+        platform: platformId,
+        schemaPath: schemaPath || 'unknown',
+        flow,
+        score,
+        maxScore,
+        matchedFields,
+        pathBoost
+    };
+}
+/**
+ * Validate a value against schema property constraints
+ *
+ * Checks type, enum, pattern, etc.
+ */
+function validateFieldAgainstSchema(value, property) {
+    // Check type
+    if (property.type) {
+        const types = Array.isArray(property.type) ? property.type : [property.type];
+        const valueType = getValueType(value);
+        if (!types.includes(valueType)) {
+            return false;
+        }
+    }
+    // Check enum
+    if (property.enum && !property.enum.includes(value)) {
+        return false;
+    }
+    // Check pattern (for strings)
+    if (property.pattern && typeof value === 'string') {
+        const regex = new RegExp(property.pattern);
+        if (!regex.test(value)) {
+            return false;
+        }
+    }
+    // Check array items
+    if (property.type === 'array' && Array.isArray(value)) {
+        if (property.items) {
+            // Basic validation - all items should match item schema type
+            if (property.items.type) {
+                const itemType = property.items.type;
+                for (const item of value) {
+                    if (getValueType(item) !== itemType) {
+                        return false;
+                    }
+                }
+            }
+        }
+    }
+    // Check object properties
+    if (property.type === 'object' && typeof value === 'object' && value !== null) {
+        // Basic validation passed - could add more detailed object validation
+        return true;
+    }
+    return true;
+}
+/**
+ * Get JSON Schema type for a value
+ */
+function getValueType(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+}
+/**
+ * Get path boost for file matching flow pattern
+ *
+ * @param filePath - File path to check
+ * @param flow - Flow with pattern
+ * @returns Boost value (0-0.2)
+ */
+function getPathBoost(filePath, flow) {
+    const pattern = getPatternFromFlow(flow, 'from');
+    if (!pattern) {
+        return 0;
+    }
+    // Check if file path matches pattern
+    if (matchGlob(filePath, pattern)) {
+        return 0.2;
+    }
+    return 0;
+}
+/**
+ * Match file path against glob pattern
+ */
+function matchGlob(filePath, pattern) {
+    try {
+        return minimatch(filePath, pattern);
+    }
+    catch (error) {
+        logger.warn(`Invalid glob pattern: ${pattern}`, error);
+        return false;
+    }
+}
+/**
+ * Extract schema path from flow
+ */
+function extractSchemaPathFromFlow(flow) {
+    const from = flow.from;
+    // Skip switch expressions
+    if (typeof from === 'object' && from !== null && '$switch' in from) {
+        return null;
+    }
+    // Array - check first element
+    if (Array.isArray(from) && from.length > 0) {
+        const first = from[0];
+        if (typeof first === 'object' && 'schema' in first) {
+            return first.schema || null;
+        }
+        return null;
+    }
+    // Object with schema
+    if (typeof from === 'object' && from !== null && 'schema' in from) {
+        return from.schema || null;
+    }
+    return null;
+}
+/**
+ * Batch detect formats for multiple files
+ *
+ * @param files - Array of package files
+ * @param targetDir - Optional target directory
+ * @returns Map of file path -> detected format
+ */
+export function detectFileFormats(files, targetDir) {
+    const results = new Map();
+    for (const file of files) {
+        const format = detectFileFormat(file, targetDir);
+        results.set(file.path, format);
+    }
+    return results;
+}
+/**
+ * Group files by detected format
+ *
+ * @param formats - Map of file path -> format
+ * @returns Map of platform -> file paths
+ */
+export function groupFilesByFormat(formats) {
+    const groups = new Map();
+    for (const [filePath, format] of formats) {
+        const platform = format.platform;
+        const group = groups.get(platform) || [];
+        group.push(filePath);
+        groups.set(platform, group);
+    }
+    return groups;
+}
+//# sourceMappingURL=file-format-detector.js.map