@willwade/aac-processors 0.0.3

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const prettyPrint_1 = require("./prettyPrint");
+const analyze_1 = require("../core/analyze");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+// Helper function to detect format from file/folder path
+function detectFormat(filePath) {
+    // Check if it's a folder ending with .ascconfig
+    if (fs_1.default.existsSync(filePath) &&
+        fs_1.default.statSync(filePath).isDirectory() &&
+        filePath.endsWith('.ascconfig')) {
+        return 'ascconfig';
+    }
+    // Otherwise use file extension
+    return path_1.default.extname(filePath).slice(1);
+}
+// Helper function to parse filtering options from CLI arguments
+function parseFilteringOptions(options) {
+    const processorOptions = {};
+    // Handle preserve all buttons flag
+    if (options.preserveAllButtons) {
+        processorOptions.preserveAllButtons = true;
+        return processorOptions; // If preserving all, ignore other options
+    }
+    // Handle specific exclusion flags
+    if (options.excludeNavigation !== undefined) {
+        processorOptions.excludeNavigationButtons = options.excludeNavigation;
+    }
+    if (options.excludeSystem !== undefined) {
+        processorOptions.excludeSystemButtons = options.excludeSystem;
+    }
+    // Handle custom button exclusion list
+    if (options.excludeButtons) {
+        const excludeList = options.excludeButtons
+            .split(',')
+            .map((s) => s.trim().toLowerCase())
+            .filter((s) => s.length > 0);
+        if (excludeList.length > 0) {
+            processorOptions.customButtonFilter = (button) => {
+                const label = button.label?.toLowerCase() || '';
+                const message = button.message?.toLowerCase() || '';
+                // Exclude if button label or message contains any of the excluded terms
+                return !excludeList.some((term) => label.includes(term) || message.includes(term));
+            };
+        }
+    }
+    return processorOptions;
+}
+// Set version from package.json
+const packageJson = JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, '../../package.json'), 'utf8'));
+commander_1.program.version(packageJson.version);
+commander_1.program
+    .command('analyze <file>')
+    .option('--format <format>', 'Format type (auto-detected if not specified)')
+    .option('--pretty', 'Pretty print output')
+    .option('--preserve-all-buttons', 'Preserve all buttons including navigation/system buttons')
+    .option('--no-exclude-navigation', "Don't exclude navigation buttons (Home, Back)")
+    .option('--no-exclude-system', "Don't exclude system buttons (Delete, Clear, etc.)")
+    .option('--exclude-buttons <list>', 'Comma-separated list of button labels/terms to exclude')
+    .action((file, options) => {
+    try {
+        // Parse filtering options
+        const filteringOptions = parseFilteringOptions(options);
+        // Auto-detect format if not specified
+        const format = options.format || detectFormat(file);
+        const processor = (0, analyze_1.getProcessor)(format, filteringOptions);
+        const tree = processor.loadIntoTree(file);
+        const result = {
+            format,
+            tree,
+            filtering: filteringOptions,
+        };
+        if (options.pretty) {
+            console.log((0, prettyPrint_1.prettyPrintTree)(result.tree));
+        }
+        else {
+            console.log(JSON.stringify(result, null, 2));
+        }
+    }
+    catch (error) {
+        console.error('Error analyzing file:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+commander_1.program
+    .command('extract <file>')
+    .option('--format <format>', 'Format type (auto-detected if not specified)')
+    .option('--verbose', 'Verbose output')
+    .option('--quiet', 'Quiet output')
+    .option('--preserve-all-buttons', 'Preserve all buttons including navigation/system buttons')
+    .option('--no-exclude-navigation', "Don't exclude navigation buttons (Home, Back)")
+    .option('--no-exclude-system', "Don't exclude system buttons (Delete, Clear, etc.)")
+    .option('--exclude-buttons <list>', 'Comma-separated list of button labels/terms to exclude')
+    .action((file, options) => {
+    try {
+        // Parse filtering options
+        const filteringOptions = parseFilteringOptions(options);
+        // Auto-detect format if not specified
+        const format = options.format || detectFormat(file);
+        const processor = (0, analyze_1.getProcessor)(format, filteringOptions);
+        const texts = processor.extractTexts(file);
+        if (!options.quiet) {
+            if (options.verbose) {
+                console.log(`Extracting texts from ${file} (format: ${format})`);
+                console.log(`Found ${texts.length} text entries:`);
+                // Show filtering info in verbose mode
+                if (filteringOptions.preserveAllButtons) {
+                    console.log('Filtering: All buttons preserved');
+                }
+                else {
+                    const filters = [];
+                    if (filteringOptions.excludeNavigationButtons !== false)
+                        filters.push('navigation');
+                    if (filteringOptions.excludeSystemButtons !== false)
+                        filters.push('system');
+                    if (filteringOptions.customButtonFilter)
+                        filters.push('custom');
+                    if (filters.length > 0) {
+                        console.log(`Filtering: Excluding ${filters.join(', ')} buttons`);
+                    }
+                }
+            }
+        }
+        // Output the texts (one per line for easier processing)
+        texts.forEach((text) => console.log(text));
+    }
+    catch (error) {
+        console.error('Error extracting texts:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+commander_1.program
+    .command('convert <input> <output>')
+    .option('--format <format>', 'Output format (required)')
+    .option('--preserve-all-buttons', 'Preserve all buttons including navigation/system buttons')
+    .option('--no-exclude-navigation', "Don't exclude navigation buttons (Home, Back)")
+    .option('--no-exclude-system', "Don't exclude system buttons (Delete, Clear, etc.)")
+    .option('--exclude-buttons <list>', 'Comma-separated list of button labels/terms to exclude')
+    .action((input, output, options) => {
+    try {
+        if (!options.format) {
+            console.error('Error: --format option is required for convert command');
+            process.exit(1);
+        }
+        // Parse filtering options
+        const filteringOptions = parseFilteringOptions(options);
+        // Auto-detect input format
+        const inputFormat = detectFormat(input);
+        const inputProcessor = (0, analyze_1.getProcessor)(inputFormat, filteringOptions);
+        // Load the tree (handle both files and folders)
+        const tree = inputProcessor.loadIntoTree(input);
+        // Save using output format with same filtering options
+        const outputProcessor = (0, analyze_1.getProcessor)(options.format, filteringOptions);
+        outputProcessor.saveFromTree(tree, output);
+        // Show filtering summary
+        let filteringSummary = '';
+        if (filteringOptions.preserveAllButtons) {
+            filteringSummary = ' (all buttons preserved)';
+        }
+        else {
+            const filters = [];
+            if (filteringOptions.excludeNavigationButtons !== false)
+                filters.push('navigation');
+            if (filteringOptions.excludeSystemButtons !== false)
+                filters.push('system');
+            if (filteringOptions.customButtonFilter)
+                filters.push('custom');
+            if (filters.length > 0) {
+                filteringSummary = ` (filtered: ${filters.join(', ')} buttons)`;
+            }
+        }
+        console.log(`Successfully converted ${input} to ${output} (${options.format} format)${filteringSummary}`);
+    }
+    catch (error) {
+        console.error('Error converting file:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// Show help if no command provided
+if (process.argv.length <= 2) {
+    commander_1.program.help();
+}
+commander_1.program.parse(process.argv);

package/dist/cli/prettyPrint.d.ts

@@ -0,0 +1,2 @@
+import { AACTree } from '../core/treeStructure';
+export declare function prettyPrintTree(tree: AACTree): string;

package/dist/cli/prettyPrint.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettyPrintTree = prettyPrintTree;
+function prettyPrintTree(tree) {
+    let output = '';
+    for (const pageId in tree.pages) {
+        const page = tree.pages[pageId];
+        output += `Page: ${page.name} (ID: ${page.id})\n`;
+        if (!page.buttons || page.buttons.length === 0) {
+            output += '  (no buttons)\n';
+        }
+        else {
+            for (const btn of page.buttons) {
+                const intentStr = String(btn.semanticAction?.intent);
+                const isNavigate = intentStr === 'NAVIGATE_TO' || !!btn.targetPageId;
+                const buttonType = isNavigate ? 'NAVIGATE' : 'SPEAK';
+                output += `  - Button: ${JSON.stringify(btn.label)} [${buttonType}`;
+                if (isNavigate) {
+                    const target = btn.semanticAction?.targetId || btn.targetPageId;
+                    if (target)
+                        output += ` to page: ${target}`;
+                }
+                output += ']\n';
+            }
+        }
+    }
+    return output;
+}

package/dist/core/analyze.d.ts

@@ -0,0 +1,6 @@
+import { AACTree } from './treeStructure';
+import { BaseProcessor, ProcessorOptions } from './baseProcessor';
+export declare function getProcessor(format: string, options?: ProcessorOptions): BaseProcessor;
+export declare function analyze(file: string, format: string): {
+    tree: AACTree;
+};

package/dist/core/analyze.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProcessor = getProcessor;
+exports.analyze = analyze;
+const opmlProcessor_1 = require("../processors/opmlProcessor");
+const obfProcessor_1 = require("../processors/obfProcessor");
+const touchchatProcessor_1 = require("../processors/touchchatProcessor");
+const gridsetProcessor_1 = require("../processors/gridsetProcessor");
+const astericsGridProcessor_1 = require("../processors/astericsGridProcessor");
+const snapProcessor_1 = require("../processors/snapProcessor");
+const dotProcessor_1 = require("../processors/dotProcessor");
+const excelProcessor_1 = require("../processors/excelProcessor");
+const applePanelsProcessor_1 = require("../processors/applePanelsProcessor");
+function getProcessor(format, options) {
+    const normalizedFormat = (format || '').toLowerCase();
+    switch (normalizedFormat) {
+        case 'opml':
+            return new opmlProcessor_1.OpmlProcessor(options);
+        case 'obf':
+            return new obfProcessor_1.ObfProcessor(options);
+        case 'touchchat':
+        case 'ce': // TouchChat file extension
+            return new touchchatProcessor_1.TouchChatProcessor(options);
+        case 'gridset':
+            return new gridsetProcessor_1.GridsetProcessor(options); // Grid3 format
+        case 'grd': // Asterics Grid file extension
+            return new astericsGridProcessor_1.AstericsGridProcessor(options);
+        case 'snap':
+        case 'sps': // Snap file extension
+        case 'spb': // Snap backup file extension
+            return new snapProcessor_1.SnapProcessor(options);
+        case 'dot':
+            return new dotProcessor_1.DotProcessor(options);
+        case 'excel':
+        case 'xlsx': // Excel file extension
+            return new excelProcessor_1.ExcelProcessor(options);
+        case 'applepanels':
+        case 'panels': // Apple Panels file extension
+        case 'ascconfig': // Apple Panels folder format
+            return new applePanelsProcessor_1.ApplePanelsProcessor(options);
+        default:
+            throw new Error('Unknown format: ' + format);
+    }
+}
+function analyze(file, format) {
+    const processor = getProcessor(format);
+    const tree = processor.loadIntoTree(file);
+    return { tree };
+}

package/dist/core/baseProcessor.d.ts

@@ -0,0 +1,94 @@
+import { AACTree, AACButton } from './treeStructure';
+import { StringCasing } from './stringCasing';
+export interface ProcessorOptions {
+    excludeNavigationButtons?: boolean;
+    excludeSystemButtons?: boolean;
+    customButtonFilter?: (button: AACButton) => boolean;
+    preserveAllButtons?: boolean;
+}
+export interface ExtractedString {
+    string: string;
+    vocabPlacementMeta: VocabPlacementMetadata;
+}
+export interface VocabPlacementMetadata {
+    vocabLocations: VocabLocation[];
+}
+export interface VocabLocation {
+    table: string;
+    id: number;
+    column: string;
+    casing: StringCasing;
+}
+export interface ProcessingError {
+    message: string;
+    step: 'EXTRACT' | 'PROCESS' | 'SAVE';
+}
+export interface ExtractStringsResult {
+    errors: ProcessingError[];
+    extractedStrings: ExtractedString[];
+}
+export interface TranslatedString {
+    sourcestringid: number;
+    overridestring: string;
+    translatedstring: string;
+}
+export interface SourceString {
+    id: number;
+    sourcestring: string;
+    vocabplacementmetadata: VocabPlacementMetadata;
+}
+declare abstract class BaseProcessor {
+    protected options: ProcessorOptions;
+    constructor(options?: ProcessorOptions);
+    abstract extractTexts(filePathOrBuffer: string | Buffer): string[];
+    abstract loadIntoTree(filePathOrBuffer: string | Buffer): AACTree;
+    abstract processTexts(filePathOrBuffer: string | Buffer, translations: Map<string, string>, outputPath: string): Buffer;
+    abstract saveFromTree(tree: AACTree, outputPath: string): void | Promise<void>;
+    /**
+     * Extract strings with metadata for external platform integration
+     * @param filePath - Path to the AAC file
+     * @returns Promise with extracted strings and any errors
+     */
+    extractStringsWithMetadata?(filePath: string): Promise<ExtractStringsResult>;
+    /**
+     * Generate translated download with external translation data
+     * @param filePath - Path to the original AAC file
+     * @param translatedStrings - Array of translated string data
+     * @param sourceStrings - Array of source string data with metadata
+     * @returns Promise with path to the generated translated file
+     */
+    generateTranslatedDownload?(filePath: string, translatedStrings: TranslatedString[], sourceStrings: SourceString[]): Promise<string>;
+    protected shouldFilterButton(button: AACButton): boolean;
+    protected filterPageButtons(buttons: AACButton[]): AACButton[];
+    /**
+     * Generic implementation for extracting strings with metadata
+     * Can be used by any processor that doesn't need format-specific logic
+     * @param filePath - Path to the AAC file
+     * @returns Promise with extracted strings and metadata
+     */
+    protected extractStringsWithMetadataGeneric(filePath: string): Promise<ExtractStringsResult>;
+    /**
+     * Generic implementation for generating translated downloads
+     * Can be used by any processor that doesn't need format-specific logic
+     * @param filePath - Path to the original AAC file
+     * @param translatedStrings - Array of translated string data
+     * @param sourceStrings - Array of source string data
+     * @returns Promise with path to the generated translated file
+     */
+    protected generateTranslatedDownloadGeneric(filePath: string, translatedStrings: TranslatedString[], sourceStrings: SourceString[]): Promise<string>;
+    /**
+     * Helper method to add extracted strings to the map, handling duplicates
+     * @param extractedMap - Map to store extracted strings
+     * @param key - Lowercase key for deduplication
+     * @param originalString - Original string with proper casing
+     * @param vocabLocation - Metadata about where the string was found
+     */
+    protected addToExtractedMap(extractedMap: Map<string, ExtractedString>, key: string, originalString: string, vocabLocation: VocabLocation): void;
+    /**
+     * Generate output path for translated file based on input file extension
+     * @param filePath - Original file path
+     * @returns Path for the translated output file
+     */
+    protected generateTranslatedOutputPath(filePath: string): string;
+}
+export { BaseProcessor };

package/dist/core/baseProcessor.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProcessor = void 0;
+const treeStructure_1 = require("./treeStructure");
+const stringCasing_1 = require("./stringCasing");
+class BaseProcessor {
+    constructor(options = {}) {
+        // Default configuration: exclude navigation/system buttons
+        this.options = {
+            excludeNavigationButtons: true,
+            excludeSystemButtons: true,
+            preserveAllButtons: false,
+            ...options,
+        };
+    }
+    // Helper method to determine if a button should be filtered out
+    shouldFilterButton(button) {
+        // If preserveAllButtons is true, never filter
+        if (this.options.preserveAllButtons) {
+            return false;
+        }
+        // Apply custom filter if provided
+        if (this.options.customButtonFilter) {
+            return !this.options.customButtonFilter(button);
+        }
+        // Check semantic action-based filtering
+        if (button.semanticAction) {
+            const { category, intent } = button.semanticAction;
+            // Filter specific navigation intents (toolbar navigation only)
+            if (this.options.excludeNavigationButtons) {
+                const i = String(intent);
+                if (i === 'GO_BACK' || i === 'GO_HOME') {
+                    return true;
+                }
+            }
+            // Filter system/text editing buttons by category
+            if (this.options.excludeSystemButtons && category === treeStructure_1.AACSemanticCategory.TEXT_EDITING) {
+                return true;
+            }
+            // Filter specific system intents
+            if (this.options.excludeSystemButtons) {
+                const i = String(intent);
+                if (i === 'DELETE_WORD' ||
+                    i === 'DELETE_CHARACTER' ||
+                    i === 'CLEAR_TEXT' ||
+                    i === 'COPY_TEXT') {
+                    return true;
+                }
+            }
+        }
+        // Fallback: check button labels for common navigation/system terms
+        // Only apply label-based filtering if button doesn't have semantic actions
+        if (!button.semanticAction &&
+            (this.options.excludeNavigationButtons || this.options.excludeSystemButtons)) {
+            const label = button.label?.toLowerCase() || '';
+            const message = button.message?.toLowerCase() || '';
+            // More conservative navigation terms (exclude "more" since it's often used for legitimate page navigation)
+            const navigationTerms = ['back', 'home', 'menu', 'settings'];
+            const systemTerms = ['delete', 'clear', 'copy', 'paste', 'undo', 'redo'];
+            if (this.options.excludeNavigationButtons &&
+                navigationTerms.some((term) => label.includes(term) || message.includes(term))) {
+                return true;
+            }
+            if (this.options.excludeSystemButtons &&
+                systemTerms.some((term) => label.includes(term) || message.includes(term))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // Helper method to filter buttons from a page
+    filterPageButtons(buttons) {
+        return buttons.filter((button) => !this.shouldFilterButton(button));
+    }
+    /**
+     * Generic implementation for extracting strings with metadata
+     * Can be used by any processor that doesn't need format-specific logic
+     * @param filePath - Path to the AAC file
+     * @returns Promise with extracted strings and metadata
+     */
+    extractStringsWithMetadataGeneric(filePath) {
+        try {
+            const tree = this.loadIntoTree(filePath);
+            const extractedMap = new Map();
+            // Process all pages and buttons
+            Object.values(tree.pages).forEach((page) => {
+                // Process page names
+                if (page.name && page.name.trim().length > 1 && !(0, stringCasing_1.isNumericOrEmpty)(page.name)) {
+                    const key = page.name.trim().toLowerCase();
+                    const vocabLocation = {
+                        table: 'pages',
+                        id: parseInt(page.id) || 0,
+                        column: 'NAME',
+                        casing: (0, stringCasing_1.detectCasing)(page.name),
+                    };
+                    this.addToExtractedMap(extractedMap, key, page.name.trim(), vocabLocation);
+                }
+                page.buttons.forEach((button) => {
+                    // Process button labels
+                    if (button.label && button.label.trim().length > 1 && !(0, stringCasing_1.isNumericOrEmpty)(button.label)) {
+                        const key = button.label.trim().toLowerCase();
+                        const vocabLocation = {
+                            table: 'buttons',
+                            id: parseInt(button.id) || 0,
+                            column: 'LABEL',
+                            casing: (0, stringCasing_1.detectCasing)(button.label),
+                        };
+                        this.addToExtractedMap(extractedMap, key, button.label.trim(), vocabLocation);
+                    }
+                    // Process button messages (if different from label)
+                    if (button.message &&
+                        button.message !== button.label &&
+                        button.message.trim().length > 1 &&
+                        !(0, stringCasing_1.isNumericOrEmpty)(button.message)) {
+                        const key = button.message.trim().toLowerCase();
+                        const vocabLocation = {
+                            table: 'buttons',
+                            id: parseInt(button.id) || 0,
+                            column: 'MESSAGE',
+                            casing: (0, stringCasing_1.detectCasing)(button.message),
+                        };
+                        this.addToExtractedMap(extractedMap, key, button.message.trim(), vocabLocation);
+                    }
+                });
+            });
+            const extractedStrings = Array.from(extractedMap.values());
+            return Promise.resolve({ errors: [], extractedStrings });
+        }
+        catch (error) {
+            return Promise.resolve({
+                errors: [
+                    {
+                        message: error instanceof Error ? error.message : 'Unknown extraction error',
+                        step: 'EXTRACT',
+                    },
+                ],
+                extractedStrings: [],
+            });
+        }
+    }
+    /**
+     * Generic implementation for generating translated downloads
+     * Can be used by any processor that doesn't need format-specific logic
+     * @param filePath - Path to the original AAC file
+     * @param translatedStrings - Array of translated string data
+     * @param sourceStrings - Array of source string data
+     * @returns Promise with path to the generated translated file
+     */
+    generateTranslatedDownloadGeneric(filePath, translatedStrings, sourceStrings) {
+        try {
+            // Build translation map from the provided data
+            const translations = new Map();
+            sourceStrings.forEach((sourceString) => {
+                const translated = translatedStrings.find((ts) => ts.sourcestringid.toString() === sourceString.id.toString());
+                if (translated) {
+                    const translatedText = translated.overridestring.length > 0
+                        ? translated.overridestring
+                        : translated.translatedstring;
+                    translations.set(sourceString.sourcestring, translatedText);
+                }
+            });
+            // Generate output path based on file extension
+            const outputPath = this.generateTranslatedOutputPath(filePath);
+            // Use existing processTexts method
+            this.processTexts(filePath, translations, outputPath);
+            return Promise.resolve(outputPath);
+        }
+        catch (error) {
+            return Promise.reject(new Error(`Failed to generate translated download: ${error instanceof Error ? error.message : 'Unknown error'}`));
+        }
+    }
+    /**
+     * Helper method to add extracted strings to the map, handling duplicates
+     * @param extractedMap - Map to store extracted strings
+     * @param key - Lowercase key for deduplication
+     * @param originalString - Original string with proper casing
+     * @param vocabLocation - Metadata about where the string was found
+     */
+    addToExtractedMap(extractedMap, key, originalString, vocabLocation) {
+        const existing = extractedMap.get(key);
+        if (existing) {
+            existing.vocabPlacementMeta.vocabLocations.push(vocabLocation);
+        }
+        else {
+            extractedMap.set(key, {
+                string: originalString, // Use original casing for the string value
+                vocabPlacementMeta: {
+                    vocabLocations: [vocabLocation],
+                },
+            });
+        }
+    }
+    /**
+     * Generate output path for translated file based on input file extension
+     * @param filePath - Original file path
+     * @returns Path for the translated output file
+     */
+    generateTranslatedOutputPath(filePath) {
+        const lastDotIndex = filePath.lastIndexOf('.');
+        if (lastDotIndex === -1) {
+            return filePath + '_translated';
+        }
+        const basePath = filePath.substring(0, lastDotIndex);
+        const extension = filePath.substring(lastDotIndex);
+        return `${basePath}_translated${extension}`;
+    }
+}
+exports.BaseProcessor = BaseProcessor;

package/dist/core/fileProcessor.d.ts

@@ -0,0 +1,7 @@
+type FileFormat = 'gridset' | 'coughdrop' | 'touchchat' | 'snap' | 'dot' | 'opml' | 'excel' | 'unknown';
+declare class FileProcessor {
+    static readFile(filePath: string): Buffer;
+    static writeFile(filePath: string, data: Buffer | string): void;
+    static detectFormat(filePathOrBuffer: string | Buffer): FileFormat;
+}
+export default FileProcessor;

package/dist/core/fileProcessor.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class FileProcessor {
+    // Read a file and return its contents as a Buffer
+    static readFile(filePath) {
+        return fs_1.default.readFileSync(filePath);
+    }
+    // Write data (Buffer or string) to a file
+    static writeFile(filePath, data) {
+        fs_1.default.writeFileSync(filePath, data);
+    }
+    // Detect file format based on extension or magic bytes
+    static detectFormat(filePathOrBuffer) {
+        if (typeof filePathOrBuffer === 'string') {
+            const ext = path_1.default.extname(filePathOrBuffer).toLowerCase();
+            switch (ext) {
+                case '.gridset':
+                    return 'gridset';
+                case '.obf':
+                case '.obz':
+                    return 'coughdrop';
+                case '.ce':
+                case '.wfl':
+                case '.touchchat':
+                    return 'touchchat';
+                case '.sps':
+                case '.spb':
+                    return 'snap';
+                case '.dot':
+                    return 'dot';
+                case '.opml':
+                    return 'opml';
+                case '.xlsx':
+                    return 'excel';
+                default:
+                    return 'unknown';
+            }
+        }
+        else if (Buffer.isBuffer(filePathOrBuffer)) {
+            // Optionally: inspect magic bytes here
+            return 'unknown';
+        }
+        return 'unknown';
+    }
+}
+exports.default = FileProcessor;