FD-M06: Implement file operations with Zig FFI bindings

File Operations (FD-M06):
- Add file_ops.rs with open/save/convert functions
- Format detection from extension and content heuristics
- Support all 7 formats (TXT, MD, ADOC, DJOT, ORG, RST, TYP)
- FileInfo metadata (path, format, size, read-only)
- 5 tests all passing

FFI Updates:
- Add formatrix_open_file, formatrix_save_file, formatrix_save_file_as
- Add formatrix_detect_file_format, formatrix_format_extension
- Add Copy/Clone/Debug/PartialEq to FfiResult and FfiFormat

Zig Bindings:
- Create bindings/zig with type-safe Zig wrapper
- Document, Format, Result types with methods
- Separate repo at hyperpolymath/zig-formatrix-ffi

Tests: 47 passing

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: Jonathan D.A. Jewell

Cargo.lock

@@ -0,0 +1,18 @@
+# Zig FFI Bindings
+
+The Zig FFI bindings have been moved to a separate repository for reusability:
+
+**https://github.com/hyperpolymath/zig-formatrix-ffi**
+
+The files in this directory are kept for local development convenience.
+
+## Building formatrix-core with FFI support
+
+```bash
+cd ../..
+cargo build --release --features ffi
+```
+
+## Using the bindings
+
+See the zig-formatrix-ffi repository for full documentation and usage examples.

bindings/zig/README.md

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+//! Build configuration for formatrix Zig bindings
+//!
+//! Links against libformatrix_core from the Rust crate.
+
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    // Create the formatrix module
+    const formatrix_mod = b.addModule("formatrix", .{
+        .root_source_file = b.path("formatrix.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // Library artifact for linking
+    const lib = b.addStaticLibrary(.{
+        .name = "formatrix-zig",
+        .root_source_file = b.path("formatrix.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // Link against the Rust library
+    lib.addLibraryPath(.{ .cwd_relative = "../../target/release" });
+    lib.linkSystemLibrary("formatrix_core");
+    lib.linkLibC();
+
+    b.installArtifact(lib);
+
+    // Example executable
+    const exe = b.addExecutable(.{
+        .name = "formatrix-example",
+        .root_source_file = b.path("example.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+    exe.root_module.addImport("formatrix", formatrix_mod);
+    exe.addLibraryPath(.{ .cwd_relative = "../../target/release" });
+    exe.linkSystemLibrary("formatrix_core");
+    exe.linkLibC();
+
+    b.installArtifact(exe);
+
+    // Run step for example
+    const run_cmd = b.addRunArtifact(exe);
+    run_cmd.step.dependOn(b.getInstallStep());
+
+    const run_step = b.step("run", "Run the example");
+    run_step.dependOn(&run_cmd.step);
+
+    // Tests
+    const tests = b.addTest(.{
+        .root_source_file = b.path("formatrix.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const run_tests = b.addRunArtifact(tests);
+    const test_step = b.step("test", "Run unit tests");
+    test_step.dependOn(&run_tests.step);
+}

bindings/zig/build.zig

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+//! Example usage of formatrix Zig bindings
+
+const std = @import("std");
+const formatrix = @import("formatrix");
+
+pub fn main() !void {
+    const allocator = std.heap.page_allocator;
+
+    // Print library version
+    std.debug.print("Formatrix version: {s}\n", .{formatrix.version()});
+
+    // Parse some markdown
+    const markdown_content: [:0]const u8 = "# Hello World\n\nThis is a paragraph.";
+
+    var doc = try formatrix.Document.parse(markdown_content, .markdown);
+    defer doc.deinit();
+
+    std.debug.print("Parsed document with {d} blocks\n", .{doc.blockCount()});
+    std.debug.print("Source format: {s}\n", .{doc.sourceFormat().label()});
+
+    // Get title if present
+    if (try doc.getTitle(allocator)) |title| {
+        defer allocator.free(title);
+        std.debug.print("Document title: {s}\n", .{title});
+    }
+
+    // Render to org-mode
+    const org_output = try doc.render(.org_mode, allocator);
+    defer allocator.free(org_output);
+
+    std.debug.print("\nRendered to Org-mode:\n{s}\n", .{org_output});
+
+    // Direct conversion helper
+    const rst_output = try formatrix.convert(
+        markdown_content,
+        .markdown,
+        .restructured_text,
+        allocator,
+    );
+    defer allocator.free(rst_output);
+
+    std.debug.print("\nDirect conversion to RST:\n{s}\n", .{rst_output});
+
+    // Format detection
+    const detected = formatrix.detectFormat("#+TITLE: Test\n* Heading");
+    std.debug.print("\nDetected format for org content: {s}\n", .{detected.label()});
+}