k2f 0.1.0

K2F command-line tool
use std::fs;
use std::path::PathBuf;

use clap::{Parser, Subcommand};
use k2f_layout::compile_manifest;
use k2f_package::{
    generate_secret_key, inspect_package, load_dir, pack_bytes, sign_package, unpack_bytes,
    utc_unix_seconds, SecretKey,
};
use k2f_paint::{OpenedDocument, OFFICIAL_PNG_SCALE};
use k2f_pdf::{export_opened, PdfExportOptions, PdfScale};

#[derive(Parser)]
#[command(author, version, about = "K2F pack / compile / verify / sign / render / hit-test")]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    Pack {
        source: PathBuf,
        #[arg(short, long)]
        output: PathBuf,
    },
    Compile {
        package: PathBuf,
    },
    Verify {
        package: PathBuf,
    },
    Keygen {
        #[arg(short, long)]
        output: PathBuf,
    },
    Sign {
        package: PathBuf,
        #[arg(long)]
        key: PathBuf,
        #[arg(long)]
        signed_by: Option<String>,
        #[arg(long)]
        signed_at: Option<i64>,
    },
    Render {
        package: PathBuf,
        #[arg(long, default_value_t = 0)]
        page: usize,
        #[arg(long, default_value_t = OFFICIAL_PNG_SCALE)]
        scale: f32,
        #[arg(short, long)]
        output: PathBuf,
    },
    /// Hit-test lock geometry. x/y are pt, not pixels.
    HitTest {
        package: PathBuf,
        #[arg(long, default_value_t = 0)]
        page: usize,
        #[arg(long)]
        x: f64,
        #[arg(long)]
        y: f64,
    },
    /// Draw the published lock into a PDF. Not a second layout engine.
    ExportPdf {
        package: PathBuf,
        #[arg(short, long)]
        output: PathBuf,
        #[arg(long, default_value_t = OFFICIAL_PNG_SCALE)]
        scale: f32,
        /// Append per-page source captions and a final integrity verification page.
        #[arg(long)]
        trust_pack: bool,
    },
    /// Compile Markdown to a .K2F package (report theme by default).
    Markdown {
        source: PathBuf,
        #[arg(short, long)]
        output: PathBuf,
        #[arg(long, default_value = "report")]
        theme: String,
        /// Optional OTF/TTF embedded instead of the theme default face.
        #[arg(long)]
        font: Option<PathBuf>,
    },
}

fn main() -> anyhow::Result<()> {
    match Cli::parse().command {
        Commands::Pack { source, output } => {
            let pkg = load_dir(&source)?;
            fs::write(&output, pack_bytes(&pkg)?)?;
            eprintln!("packed {}", output.display());
        }
        Commands::Compile { package } => {
            let mut pkg = unpack_bytes(&fs::read(&package)?)?;
            let assets: std::collections::HashMap<String, Vec<u8>> =
                pkg.assets.clone().into_iter().collect();
            let lock = compile_manifest(
                pkg.engine_manifest(),
                &pkg.theme_json,
                &pkg.fonts,
                if assets.is_empty() {
                    None
                } else {
                    Some(&assets)
                },
            )
            .map_err(|e| anyhow::anyhow!(e))?;
            pkg.set_lock(&lock)?;
            fs::write(&package, pack_bytes(&pkg)?)?;
            eprintln!(
                "compiled {} pages={}",
                package.display(),
                lock.geometry.pages.len()
            );
        }
        Commands::Verify { package } => {
            let bytes = fs::read(&package)?;
            let pkg = unpack_bytes(&bytes)?;
            let report = inspect_package(&pkg)?;
            println!("{}", report.status.code());
            if pkg.lock_json.is_some() {
                if let Ok(doc) = OpenedDocument::open(&bytes) {
                    eprintln!("pages={}", doc.page_count());
                }
            }
            if let Some(fp) = &report.fingerprint {
                eprintln!(
                    "fingerprint={fp} signed_by={} signed_at={} generated_by={}",
                    report.signed_by.as_deref().unwrap_or("-"),
                    report
                        .signed_at
                        .map(|t| t.to_string())
                        .unwrap_or_else(|| "-".into()),
                    report.generated_by.as_deref().unwrap_or("-")
                );
            } else if let Some(agent) = &report.generated_by {
                eprintln!("generated_by={agent}");
            }
            if !report.status.is_ok() {
                std::process::exit(1);
            }
        }
        Commands::Keygen { output } => {
            let key = generate_secret_key()?;
            fs::write(&output, format!("{}\n", key.to_hex()))?;
            eprintln!("public={}", key.public_hex());
            eprintln!("fingerprint={}", key.fingerprint());
        }
        Commands::Sign {
            package,
            key,
            signed_by,
            signed_at,
        } => {
            let mut pkg = unpack_bytes(&fs::read(&package)?)?;
            let secret = SecretKey::from_hex(fs::read_to_string(&key)?.trim())?;
            sign_package(
                &mut pkg,
                &secret,
                signed_by.as_deref(),
                signed_at.unwrap_or_else(utc_unix_seconds),
            )?;
            fs::write(&package, pack_bytes(&pkg)?)?;
            eprintln!(
                "signed {} fingerprint={}",
                package.display(),
                secret.fingerprint()
            );
        }
        Commands::Render {
            package,
            page,
            scale,
            output,
        } => {
            let doc = OpenedDocument::open(&fs::read(&package)?)?;
            println!("{}", doc.banner().as_str());
            if let Some(fp) = doc.fingerprint() {
                eprintln!(
                    "fingerprint={fp} signed_by={} generated_by={}",
                    doc.signed_by().unwrap_or("-"),
                    doc.generated_by().unwrap_or("-")
                );
            }
            if doc.banner() != k2f_paint::Banner::Signed
                && doc.banner() != k2f_paint::Banner::Unsigned
            {
                eprintln!("{}", doc.status_code());
            }
            let n = doc.page_count();
            eprintln!("rendering page {page} of {n}");
            let png = doc.render_page(page, scale)?;
            fs::write(&output, png)?;
            if !matches!(
                doc.banner(),
                k2f_paint::Banner::Signed | k2f_paint::Banner::Unsigned
            ) {
                std::process::exit(1);
            }
        }
        Commands::HitTest { package, page, x, y } => {
            let doc = OpenedDocument::open(&fs::read(&package)?)?;
            let milli = |pt: f64| (pt * 1000.0).round() as i64;
            match doc.hit_test(page, milli(x), milli(y)) {
                Some(hit) => {
                    println!("{}", hit.ids.join(" "));
                    if let Some([a, b]) = hit.char_range {
                        eprintln!("chars {a}..{b}");
                    }
                }
                None => {
                    println!("MISS");
                    std::process::exit(1);
                }
            }
        }
        Commands::ExportPdf {
            package,
            output,
            scale,
            trust_pack,
        } => {
            let scale = PdfScale::from_f32(scale).map_err(|e| anyhow::anyhow!(e))?;
            let doc = OpenedDocument::open(&fs::read(&package)?)?;
            let mut options = PdfExportOptions::new(scale);
            if trust_pack {
                options = options.with_trust_pack();
            }
            let pdf = export_opened(&doc, options)?;
            fs::write(&output, pdf)?;
            eprintln!("wrote {}", output.display());
        }
        Commands::Markdown {
            source,
            output,
            theme,
            font,
        } => {
            let theme = k2f_sdk::Theme::parse(&theme).map_err(|e| anyhow::anyhow!("{e}"))?;
            let font_bytes = match font {
                Some(path) => Some(fs::read(&path)?),
                None => None,
            };
            if source.is_dir() {
                let mut files = Vec::new();
                collect_md(&source, &mut files)?;
                files.sort();
                if files.is_empty() {
                    anyhow::bail!("no .md files under {}", source.display());
                }
                for md_path in files {
                    let rel = md_path.strip_prefix(&source).unwrap_or(&md_path);
                    let dest = output.join(rel).with_extension("K2F");
                    convert_markdown(&md_path, &dest, theme, font_bytes.as_deref())?;
                    eprintln!("wrote {}", dest.display());
                }
            } else {
                convert_markdown(&source, &output, theme, font_bytes.as_deref())?;
                eprintln!("wrote {}", output.display());
            }
        }
    }
    Ok(())
}

fn collect_md(dir: &std::path::Path, out: &mut Vec<PathBuf>) -> anyhow::Result<()> {
    for entry in fs::read_dir(dir)? {
        let path = entry?.path();
        if path.is_dir() {
            collect_md(&path, out)?;
        } else if path.extension().and_then(|e| e.to_str()) == Some("md") {
            out.push(path);
        }
    }
    Ok(())
}

fn convert_markdown(
    source: &std::path::Path,
    dest: &std::path::Path,
    theme: k2f_sdk::Theme,
    font_bytes: Option<&[u8]>,
) -> anyhow::Result<()> {
    let md = fs::read_to_string(source)?;
    let title = source
        .file_stem()
        .and_then(|s| s.to_str())
        .unwrap_or("Document");
    let mut opts = k2f_sdk::MarkdownOptions::new(title, theme);
    if let Some(bytes) = font_bytes {
        opts.font_bytes = Some(bytes.to_vec());
    }
    let result = k2f_sdk::markdown_to_k2f(&md, opts).map_err(|e| anyhow::anyhow!("{e}"))?;
    if let Some(parent) = dest.parent() {
        fs::create_dir_all(parent)?;
    }
    fs::write(dest, result.bytes)?;
    Ok(())
}