@jacobknightley/fabric-format 0.0.1

package/dist/cli.js

@@ -0,0 +1,435 @@
+#!/usr/bin/env node
+/**
+ * CLI for Fabric Notebook Formatter (Spark SQL & Python)
+ *
+ * Commands:
+ *   fabfmt format <files...>       - Format files in-place
+ *   fabfmt format --type sparksql  - Format stdin (pipe mode)
+ *   fabfmt check <files...>        - Check if files need formatting
+ */
+import { formatNotebook } from './notebook-formatter.js';
+import { formatCell, initializePythonFormatter } from './cell-formatter.js';
+import * as fs from 'fs';
+import * as path from 'path';
+const args = process.argv.slice(2);
+/** Supported file extensions for formatting */
+const SUPPORTED_EXTENSIONS = ['.sql', '.py', '.scala', '.r'];
+/**
+ * Read all content from stdin.
+ */
+async function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = '';
+        process.stdin.setEncoding('utf-8');
+        process.stdin.on('data', chunk => data += chunk);
+        process.stdin.on('end', () => resolve(data));
+        process.stdin.on('error', reject);
+    });
+}
+/**
+ * Recursively find all files with supported extensions in a directory.
+ */
+function findSupportedFiles(dir) {
+    const files = [];
+    function walk(currentDir) {
+        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                // Skip common non-source directories
+                if (!['node_modules', '.git', '__pycache__', '.venv', 'venv', 'dist', 'build'].includes(entry.name)) {
+                    walk(fullPath);
+                }
+            }
+            else if (entry.isFile()) {
+                const ext = path.extname(entry.name).toLowerCase();
+                if (SUPPORTED_EXTENSIONS.includes(ext)) {
+                    files.push(fullPath);
+                }
+            }
+        }
+    }
+    walk(dir);
+    return files;
+}
+/**
+ * Expand a list of paths to include files from directories.
+ */
+function expandPaths(paths) {
+    const files = [];
+    for (const p of paths) {
+        if (fs.existsSync(p)) {
+            const stat = fs.statSync(p);
+            if (stat.isDirectory()) {
+                files.push(...findSupportedFiles(p));
+            }
+            else {
+                files.push(p);
+            }
+        }
+        else {
+            console.error(`Error: File or directory not found: ${p}`);
+            process.exit(2);
+        }
+    }
+    return files;
+}
+/**
+ * Format a Fabric notebook file.
+ */
+async function formatFile(content, filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const { content: formatted } = await formatNotebook(content, ext, {
+        formatPython: true,
+        formatSql: true,
+    });
+    return formatted;
+}
+/**
+ * Detect the line ending style used in content.
+ */
+function detectLineEnding(content) {
+    if (content.includes('\r\n')) {
+        return '\r\n';
+    }
+    return '\n';
+}
+/**
+ * Normalize line endings to Unix style.
+ */
+function normalizeLineEndings(content) {
+    return content.replace(/\r\n/g, '\n');
+}
+/**
+ * Convert line endings to the specified style.
+ */
+function convertLineEndings(content, lineEnding) {
+    const normalized = normalizeLineEndings(content);
+    if (lineEnding === '\r\n') {
+        return normalized.replace(/\n/g, '\r\n');
+    }
+    return normalized;
+}
+/** Print main help */
+function printHelp() {
+    console.log(`fabfmt - Fabric Notebook Formatter (Spark SQL & Python)
+
+Usage:
+  fabfmt <command> [options] [arguments]
+
+Commands:
+  format <files...>    Format files or directories in-place
+  check <files...>     Check if files need formatting (exit 1 if so)
+
+Run 'fabfmt <command> --help' for command-specific help.
+`);
+}
+/** Print format command help */
+function printFormatHelp() {
+    console.log(`fabfmt format - Format files in-place
+
+Usage:
+  fabfmt format [options] <file|directory...>
+  fabfmt format --type <type> [-i <string>]
+
+Arguments:
+  file        A .sql, .py, .scala, or .r Fabric notebook file
+  directory   Recursively format all supported files
+
+Options:
+  --type <type>  Cell type: sparksql, python, or pyspark
+                 Required for stdin or inline input
+  -i <string>    Inline string to format (requires --type)
+  --print        Print formatted output instead of modifying file
+  -h, --help     Show this help message
+
+Examples:
+  fabfmt format notebook.py                                Format a single file
+  fabfmt format ./src                                      Format all files in directory
+  fabfmt format query.sql --print                          Print formatted output
+  fabfmt format --type sparksql -i "select * from t"       Format inline string
+  echo "select * from t" | fabfmt format --type sparksql   Format from stdin
+`);
+}
+/** Print check command help */
+function printCheckHelp() {
+    console.log(`fabfmt check - Check if files need formatting
+
+Usage:
+  fabfmt check [options] <file|directory...>
+  fabfmt check --type <type> [-i <string>]
+
+Arguments:
+  file        A .sql, .py, .scala, or .r Fabric notebook file
+  directory   Recursively check all supported files
+
+Options:
+  --type <type>  Cell type: sparksql, python, or pyspark
+                 Required for stdin or inline input
+  -i <string>    Inline string to check (requires --type)
+  -h, --help     Show this help message
+
+Exit codes:
+  0  All files are properly formatted / input needs no changes
+  1  One or more files need formatting / input needs formatting
+
+Examples:
+  fabfmt check notebook.py                                Check a single file
+  fabfmt check ./src                                      Check all files in directory
+  fabfmt check --type sparksql -i "select * from t"       Check inline string
+  echo "select * from t" | fabfmt check --type sparksql   Check from stdin
+`);
+}
+/** Parse --type argument */
+function parseType(args) {
+    const remaining = [];
+    let type = null;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--type') {
+            const nextArg = args[i + 1];
+            if (nextArg && !nextArg.startsWith('-')) {
+                const cellType = nextArg.toLowerCase();
+                if (cellType === 'sparksql' || cellType === 'python' || cellType === 'pyspark') {
+                    type = cellType;
+                    i++; // Skip next arg
+                }
+                else {
+                    console.error(`Error: Invalid type '${cellType}'. Use sparksql, python, or pyspark.`);
+                    process.exit(2);
+                }
+            }
+            else {
+                console.error('Error: --type requires a value (sparksql, python, or pyspark)');
+                process.exit(2);
+            }
+        }
+        else {
+            remaining.push(args[i]);
+        }
+    }
+    return { type, remaining };
+}
+/** Parse -i argument */
+function parseInline(args) {
+    const remaining = [];
+    let inline = null;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '-i') {
+            const nextArg = args[i + 1];
+            if (nextArg !== undefined) {
+                inline = nextArg;
+                i++; // Skip next arg
+            }
+            else {
+                console.error('Error: -i requires a string value');
+                process.exit(2);
+            }
+        }
+        else {
+            remaining.push(args[i]);
+        }
+    }
+    return { inline, remaining };
+}
+/** Format command: format files in-place or stdin */
+async function cmdFormat(args) {
+    if (args.includes('-h') || args.includes('--help')) {
+        printFormatHelp();
+        return;
+    }
+    const toPrint = args.includes('--print');
+    const argsWithoutPrint = args.filter(a => a !== '--print');
+    const { type, remaining: argsAfterType } = parseType(argsWithoutPrint);
+    const { inline, remaining: paths } = parseInline(argsAfterType);
+    // Inline mode: -i with --type
+    if (inline !== null) {
+        if (!type) {
+            console.error('Error: -i requires --type (sparksql, python, or pyspark)');
+            process.exit(2);
+        }
+        // Initialize Python formatter if needed
+        if (type === 'python' || type === 'pyspark') {
+            await initializePythonFormatter();
+        }
+        const result = formatCell(inline, type);
+        if (result.error) {
+            console.error(`Error: ${result.error}`);
+            process.exit(1);
+        }
+        process.stdout.write(result.formatted);
+        return;
+    }
+    // Stdin mode: --type specified with no files
+    if (type && paths.length === 0) {
+        // Initialize Python formatter if needed
+        if (type === 'python' || type === 'pyspark') {
+            await initializePythonFormatter();
+        }
+        const content = await readStdin();
+        const result = formatCell(content, type);
+        if (result.error) {
+            console.error(`Error: ${result.error}`);
+            process.exit(1);
+        }
+        process.stdout.write(result.formatted);
+        return;
+    }
+    if (paths.length === 0) {
+        console.error('Error: No files or directories specified');
+        console.error('Run "fabfmt format --help" for usage');
+        process.exit(2);
+    }
+    // --print mode: single file to stdout
+    if (toPrint) {
+        if (paths.length !== 1) {
+            console.error('Error: --print requires exactly one file');
+            process.exit(2);
+        }
+        const file = paths[0];
+        const stat = fs.statSync(file);
+        if (stat.isDirectory()) {
+            console.error('Error: --print cannot be used with directories');
+            process.exit(2);
+        }
+        const content = fs.readFileSync(file, 'utf-8');
+        const formatted = await formatFile(content, file);
+        process.stdout.write(formatted);
+        return;
+    }
+    // Expand directories to files
+    const files = expandPaths(paths);
+    if (files.length === 0) {
+        console.log('No supported files found');
+        return;
+    }
+    // Format files in-place
+    let formattedCount = 0;
+    for (const file of files) {
+        try {
+            const content = fs.readFileSync(file, 'utf-8');
+            const originalLineEnding = detectLineEnding(content);
+            const normalizedContent = normalizeLineEndings(content);
+            const formatted = await formatFile(normalizedContent, file);
+            const formattedWithOriginalEndings = convertLineEndings(formatted, originalLineEnding);
+            if (formattedWithOriginalEndings !== content) {
+                fs.writeFileSync(file, formattedWithOriginalEndings, 'utf-8');
+                console.log(`Formatted ${file}`);
+                formattedCount++;
+            }
+        }
+        catch (e) {
+            console.error(`Error formatting ${file}: ${e.message}`);
+            process.exit(1);
+        }
+    }
+    if (formattedCount === 0) {
+        console.log(`All ${files.length} file(s) already formatted`);
+    }
+    else {
+        console.log(`Formatted ${formattedCount} of ${files.length} file(s)`);
+    }
+}
+/** Check command: check if files need formatting */
+async function cmdCheck(args) {
+    if (args.includes('-h') || args.includes('--help')) {
+        printCheckHelp();
+        return;
+    }
+    const { type, remaining: argsAfterType } = parseType(args);
+    const { inline, remaining: paths } = parseInline(argsAfterType);
+    // Inline mode: -i with --type
+    if (inline !== null) {
+        if (!type) {
+            console.error('Error: -i requires --type (sparksql, python, or pyspark)');
+            process.exit(2);
+        }
+        // Initialize Python formatter if needed
+        if (type === 'python' || type === 'pyspark') {
+            await initializePythonFormatter();
+        }
+        const result = formatCell(inline, type);
+        if (result.error) {
+            console.error(`Error: ${result.error}`);
+            process.exit(1);
+        }
+        // Exit 1 if formatting would change the input
+        if (result.formatted !== inline) {
+            process.exit(1);
+        }
+        return;
+    }
+    // Stdin mode: --type specified with no files
+    if (type && paths.length === 0) {
+        // Initialize Python formatter if needed
+        if (type === 'python' || type === 'pyspark') {
+            await initializePythonFormatter();
+        }
+        const content = await readStdin();
+        const result = formatCell(content, type);
+        if (result.error) {
+            console.error(`Error: ${result.error}`);
+            process.exit(1);
+        }
+        // Exit 1 if formatting would change the input
+        if (result.formatted !== content) {
+            process.exit(1);
+        }
+        return;
+    }
+    if (paths.length === 0) {
+        console.error('Error: No files or directories specified');
+        console.error('Run "fabfmt check --help" for usage');
+        process.exit(2);
+    }
+    // Expand directories to files
+    const files = expandPaths(paths);
+    if (files.length === 0) {
+        console.log('No supported files found');
+        return;
+    }
+    // Check mode: check without modifying
+    let needsFormatting = false;
+    for (const file of files) {
+        try {
+            const content = fs.readFileSync(file, 'utf-8');
+            const formatted = await formatFile(content, file);
+            if (formatted !== content) {
+                console.log(file);
+                needsFormatting = true;
+            }
+        }
+        catch (e) {
+            console.error(`Error checking ${file}: ${e.message}`);
+        }
+    }
+    if (needsFormatting) {
+        process.exit(1);
+    }
+    console.log(`All ${files.length} file(s) are properly formatted`);
+}
+/** Main entry point */
+async function main() {
+    const command = args[0];
+    const commandArgs = args.slice(1);
+    if (!command || command === '-h' || command === '--help') {
+        printHelp();
+        return;
+    }
+    switch (command) {
+        case 'format':
+            await cmdFormat(commandArgs);
+            break;
+        case 'check':
+            await cmdCheck(commandArgs);
+            break;
+        default:
+            console.error(`Error: Unknown command '${command}'`);
+            console.error('Run "fabfmt --help" for usage');
+            process.exit(2);
+    }
+}
+// Run main
+main().catch((e) => {
+    console.error(`Error: ${e.message}`);
+    process.exit(1);
+});

package/dist/formatters/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Formatter Registry
+ *
+ * Central registry for all language formatters.
+ * Provides a unified interface for formatting any supported language.
+ */
+import type { FormatterRegistry } from './types.js';
+export type { LanguageFormatter, FormatterOptions, FormatResult, FormatterConfig, FormatterRegistry } from './types.js';
+export { SqlFormatter, getSqlFormatter, isSqlCode } from './sparksql/index.js';
+export { PythonFormatter, getPythonFormatter, isPythonCode } from './python/index.js';
+/**
+ * Get the global formatter registry.
+ * Registers default formatters on first call.
+ */
+export declare function getFormatterRegistry(): FormatterRegistry;
+/**
+ * Detect the language of code based on cell type or magic command.
+ */
+export declare function detectLanguage(cellType: string, code?: string): string;

package/dist/formatters/index.js

@@ -0,0 +1,76 @@
+/**
+ * Formatter Registry
+ *
+ * Central registry for all language formatters.
+ * Provides a unified interface for formatting any supported language.
+ */
+import { getSqlFormatter, isSqlCode } from './sparksql/index.js';
+import { getPythonFormatter, isPythonCode } from './python/index.js';
+// Re-export formatters
+export { SqlFormatter, getSqlFormatter, isSqlCode } from './sparksql/index.js';
+export { PythonFormatter, getPythonFormatter, isPythonCode } from './python/index.js';
+/**
+ * Default formatter registry implementation.
+ */
+class DefaultFormatterRegistry {
+    formatters = new Map();
+    get(language) {
+        return this.formatters.get(language.toLowerCase());
+    }
+    register(formatter) {
+        this.formatters.set(formatter.language.toLowerCase(), formatter);
+    }
+    languages() {
+        return Array.from(this.formatters.keys());
+    }
+    async initializeAll() {
+        const promises = Array.from(this.formatters.values()).map(f => f.initialize());
+        await Promise.all(promises);
+    }
+}
+/** Global formatter registry */
+let registryInstance = null;
+/**
+ * Get the global formatter registry.
+ * Registers default formatters on first call.
+ */
+export function getFormatterRegistry() {
+    if (!registryInstance) {
+        registryInstance = new DefaultFormatterRegistry();
+        // Register built-in formatters
+        registryInstance.register(getSqlFormatter());
+        registryInstance.register(getPythonFormatter());
+    }
+    return registryInstance;
+}
+/**
+ * Detect the language of code based on cell type or magic command.
+ */
+export function detectLanguage(cellType, code) {
+    // Check for cell magic commands at the start
+    if (code) {
+        const firstLine = code.trim().split('\n')[0].trim();
+        if (firstLine === '%%sql' || firstLine.startsWith('%%sql ')) {
+            return 'sql';
+        }
+        if (firstLine === '%%python' || firstLine.startsWith('%%python ')) {
+            return 'python';
+        }
+        if (firstLine === '%%pyspark' || firstLine.startsWith('%%pyspark ')) {
+            return 'python'; // PySpark is Python
+        }
+        if (firstLine === '%%scala' || firstLine.startsWith('%%scala ')) {
+            return 'scala';
+        }
+        if (firstLine === '%%r' || firstLine.startsWith('%%r ') || firstLine === '%%R') {
+            return 'r';
+        }
+    }
+    // Fall back to cell type
+    const type = cellType.toLowerCase();
+    if (isSqlCode(type))
+        return 'sql';
+    if (isPythonCode(type))
+        return 'python';
+    return type;
+}

package/dist/formatters/python/config.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Python Formatter Configuration
+ *
+ * Hardcoded ruff configuration - no file loading needed.
+ */
+/** Ruff format-specific configuration */
+export interface RuffFormatConfig {
+    'quote-style'?: 'single' | 'double' | 'preserve';
+    'indent-style'?: 'space' | 'tab';
+    'skip-magic-trailing-comma'?: boolean;
+    'line-ending'?: 'auto' | 'lf' | 'cr-lf' | 'native';
+    'docstring-code-format'?: boolean;
+    'docstring-code-line-length'?: number | 'dynamic';
+}
+/** Full ruff configuration (subset relevant to formatting) */
+export interface RuffConfig {
+    'line-length'?: number;
+    'indent-width'?: number;
+    format?: RuffFormatConfig;
+}
+/** Default ruff configuration matching our style (140 char lines, 4 space indent) */
+export declare const DEFAULT_RUFF_CONFIG: RuffConfig;
+/** Ruff WASM config format (kebab-case keys as per the Ruff WASM API) */
+export declare const RUFF_WASM_CONFIG: {
+    'line-length': number;
+    'indent-width': number;
+    format: {
+        'quote-style': "double" | "single" | "preserve";
+        'indent-style': "space" | "tab";
+        'skip-magic-trailing-comma': boolean;
+        'line-ending': "auto" | "lf" | "cr-lf" | "native";
+    };
+};

package/dist/formatters/python/config.js

@@ -0,0 +1,29 @@
+/**
+ * Python Formatter Configuration
+ *
+ * Hardcoded ruff configuration - no file loading needed.
+ */
+/** Default ruff configuration matching our style (140 char lines, 4 space indent) */
+export const DEFAULT_RUFF_CONFIG = {
+    'line-length': 140,
+    'indent-width': 4,
+    format: {
+        'quote-style': 'double',
+        'indent-style': 'space',
+        'skip-magic-trailing-comma': false,
+        'line-ending': 'lf',
+        'docstring-code-format': true,
+        'docstring-code-line-length': 'dynamic',
+    }
+};
+/** Ruff WASM config format (kebab-case keys as per the Ruff WASM API) */
+export const RUFF_WASM_CONFIG = {
+    'line-length': DEFAULT_RUFF_CONFIG['line-length'],
+    'indent-width': DEFAULT_RUFF_CONFIG['indent-width'],
+    format: {
+        'quote-style': DEFAULT_RUFF_CONFIG.format['quote-style'],
+        'indent-style': DEFAULT_RUFF_CONFIG.format['indent-style'],
+        'skip-magic-trailing-comma': DEFAULT_RUFF_CONFIG.format['skip-magic-trailing-comma'],
+        'line-ending': DEFAULT_RUFF_CONFIG.format['line-ending'],
+    }
+};

package/dist/formatters/python/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Python Formatter - Module Exports
+ *
+ * Python/PySpark formatting using Ruff WASM.
+ */
+export { PythonFormatter, getPythonFormatter, resetPythonFormatter, isPythonCode, type PythonFormatterOptions, type WasmInitOptions, } from './python-formatter.js';
+export { DEFAULT_RUFF_CONFIG, RUFF_WASM_CONFIG, type RuffConfig, type RuffFormatConfig, } from './config.js';

package/dist/formatters/python/index.js

@@ -0,0 +1,13 @@
+/**
+ * Python Formatter - Module Exports
+ *
+ * Python/PySpark formatting using Ruff WASM.
+ */
+// ============================================================================
+// FORMATTER CLASS (LanguageFormatter interface)
+// ============================================================================
+export { PythonFormatter, getPythonFormatter, resetPythonFormatter, isPythonCode, } from './python-formatter.js';
+// ============================================================================
+// CONFIGURATION (types only, no file loading)
+// ============================================================================
+export { DEFAULT_RUFF_CONFIG, RUFF_WASM_CONFIG, } from './config.js';

package/dist/formatters/python/python-formatter.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Python Formatter
+ *
+ * Uses Ruff WASM to format Python/PySpark code.
+ * Handles Jupyter/IPython magic commands by preserving them.
+ */
+import type { LanguageFormatter, FormatterOptions, FormatResult } from '../types.js';
+/** Options for initializing the WASM module */
+export interface WasmInitOptions {
+    /** URL to the .wasm file (for browser environments) */
+    wasmUrl?: string | URL;
+    /** WASM binary as ArrayBuffer or Uint8Array (for sync initialization) */
+    wasmBinary?: ArrayBuffer | Uint8Array;
+}
+/** Options specific to Python formatting */
+export interface PythonFormatterOptions extends FormatterOptions {
+    /** Strip trailing newlines from formatted output */
+    stripTrailingNewline?: boolean;
+}
+/**
+ * Python formatter using Ruff WASM.
+ */
+export declare class PythonFormatter implements LanguageFormatter {
+    readonly language = "python";
+    readonly displayName = "Python (Ruff)";
+    private initialized;
+    private initError;
+    private wasmOptions;
+    /**
+     * Create a new Python formatter.
+     * @param options - Optional WASM initialization options for browser environments
+     */
+    constructor(options?: WasmInitOptions);
+    isReady(): boolean;
+    initialize(): Promise<void>;
+    format(code: string, options?: PythonFormatterOptions): FormatResult;
+    needsFormatting(code: string, options?: PythonFormatterOptions): boolean;
+}
+/**
+ * Detect if a cell/file is Python/PySpark.
+ */
+export declare function isPythonCode(cellType: string): boolean;
+/**
+ * Get the Python formatter instance (creates on first call).
+ * @param options - Optional WASM initialization options. Only used on first call.
+ */
+export declare function getPythonFormatter(options?: WasmInitOptions): PythonFormatter;
+/**
+ * Reset the Python formatter instance (for testing or reinitialization with different options).
+ */
+export declare function resetPythonFormatter(): void;