text-compress.test.ts

import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"
import { tmpdir } from "node:os"
import { join } from "node:path"
import { afterEach, describe, expect, it } from "vitest"
import {
  AUTO_SPLIT_CHARS,
  assertDirectory,
  compress,
  compressFolder,
  decompress,
  decompressPayload,
  decompressToPath,
  extractFilenamePrefix,
  formatSplitOutputPath,
  parseSplitPartPath,
  readSplitInput,
  readTextFile,
  resolveSplitChunkSize,
  resolveSplitInputPaths,
  SPLIT_MAGIC,
  splitEncodedIntoWrappedParts,
  splitString,
  TAG_TEXT,
  unpackDirectory,
  wrapSplitChunk,
} from "../src/index.js"

const tempDirs: string[] = []

afterEach(() => {
  for (const dir of tempDirs.splice(0)) {
    rmSync(dir, { recursive: true, force: true })
  }
})

function makeTempDir(): string {
  const dir = mkdtempSync(join(tmpdir(), "text-compress-"))
  tempDirs.push(dir)
  return dir
}

describe("text compression", () => {
  it("round-trips text with base64", () => {
    const input = "Hello, world! This is a test of brotli compression."
    expect(decompress(compress(input, 64), 64)).toBe(input)
  })

  it("round-trips text with base85", () => {
    const input = "Hello, world! This is a test of brotli compression."
    expect(decompress(compress(input, 85), 85)).toBe(input)
  })

  it("round-trips empty string", () => {
    expect(decompress(compress("", 64), 64)).toBe("")
  })

  it("round-trips unicode text", () => {
    const input = "日本語 🎉 émojis and spëcial chars"
    expect(decompress(compress(input, 64), 64)).toBe(input)
    expect(decompress(compress(input, 85), 85)).toBe(input)
  })

  it("tags text payloads correctly", () => {
    const encoded = compress("hello", 64)
    const { tag } = decompressPayload(encoded, 64)
    expect(tag).toBe(TAG_TEXT)
  })

  it("rejects folder payload in decompress()", () => {
    const dir = makeTempDir()
    mkdirSync(join(dir, "sub"))
    writeFileSync(join(dir, "sub", "a.txt"), "content")
    const { encoded } = compressFolder(dir, 64)
    expect(() => decompress(encoded, 64)).toThrow(/compressed folder/)
  })

  it("round-trips text with a password", () => {
    const input = "Secret payload with password protection."
    const password = "hunter2"
    expect(decompress(compress(input, 64, password), 64, password)).toBe(input)
  })

  it("rejects password-protected payload without a password", () => {
    const encoded = compress("secret", 64, "hunter2")
    expect(() => decompress(encoded, 64)).toThrow(/password-protected/)
  })

  it("rejects password-protected payload with the wrong password", () => {
    const encoded = compress("secret", 64, "hunter2")
    expect(() => decompress(encoded, 64, "wrong")).toThrow(/Invalid password/)
  })
})

describe("folder compression", () => {
  it("round-trips a folder tree", () => {
    const src = makeTempDir()
    mkdirSync(join(src, "nested"))
    writeFileSync(join(src, "readme.txt"), "hello")
    writeFileSync(join(src, "nested", "data.json"), '{"x":1}')

    const { encoded } = compressFolder(src, 64)
    const dest = makeTempDir()
    const stats = decompressToPath(encoded, dest, 64)

    expect(stats.files).toBe(2)
    expect(readFileSync(join(dest, "readme.txt"), "utf-8")).toBe("hello")
    expect(readFileSync(join(dest, "nested", "data.json"), "utf-8")).toBe('{"x":1}')
  })

  it("round-trips folder with base85", () => {
    const src = makeTempDir()
    writeFileSync(join(src, "file.txt"), "z85 test")

    const { encoded } = compressFolder(src, 85)
    const dest = makeTempDir()
    decompressToPath(encoded, dest, 85)

    expect(readFileSync(join(dest, "file.txt"), "utf-8")).toBe("z85 test")
  })

  it("reports file and directory counts", () => {
    const src = makeTempDir()
    mkdirSync(join(src, "a"))
    mkdirSync(join(src, "b"))
    writeFileSync(join(src, "a", "1.txt"), "1")
    writeFileSync(join(src, "b", "2.txt"), "22")

    const result = compressFolder(src, 64)
    expect(result.fileCount).toBe(2)
    expect(result.dirCount).toBe(2)
    expect(result.originalBytes).toBe(3)
  })

  it("round-trips a folder tree with a password", () => {
    const src = makeTempDir()
    mkdirSync(join(src, "nested"))
    writeFileSync(join(src, "readme.txt"), "hello")
    writeFileSync(join(src, "nested", "data.json"), '{"x":1}')

    const password = "folder-secret"
    const { encoded } = compressFolder(src, 64, password)
    const dest = makeTempDir()
    const stats = decompressToPath(encoded, dest, 64, password)

    expect(stats.files).toBe(2)
    expect(readFileSync(join(dest, "readme.txt"), "utf-8")).toBe("hello")
    expect(readFileSync(join(dest, "nested", "data.json"), "utf-8")).toBe('{"x":1}')
  })
})

describe("unpackDirectory", () => {
  it("rejects unsafe archive paths", () => {
    const badArchive = Buffer.concat([
      Buffer.from([0x46]),
      (() => {
        const p = Buffer.from("../evil", "utf-8")
        const len = Buffer.alloc(4)
        len.writeUInt32LE(p.length, 0)
        return Buffer.concat([len, p])
      })(),
      (() => {
        const c = Buffer.from("x", "utf-8")
        const len = Buffer.alloc(4)
        len.writeUInt32LE(c.length, 0)
        return Buffer.concat([len, c])
      })(),
    ])

    expect(() => unpackDirectory(badArchive, makeTempDir())).toThrow(/Unsafe path/)
  })
})

describe("split output", () => {
  it("splits a string into fixed-size chunks", () => {
    expect(splitString("abcdefghij", 4)).toEqual(["abcd", "efgh", "ij"])
  })

  it("returns a single empty chunk for empty input", () => {
    expect(splitString("", 10)).toEqual([""])
  })

  it("rejects invalid split sizes", () => {
    expect(() => splitString("abc", 0)).toThrow(/positive integer/)
    expect(() => splitString("abc", 1.5)).toThrow(/positive integer/)
  })

  it("formats numbered output paths before the extension", () => {
    expect(formatSplitOutputPath("output.txt", 1, 3)).toBe("output.1.txt")
    expect(formatSplitOutputPath("output.txt", 2, 12)).toBe("output.02.txt")
    expect(formatSplitOutputPath("archive", 5, 5)).toBe("archive.5")
  })

  it("round-trips split compressed output when concatenated", () => {
    const input = "Split test payload.\n".repeat(100)
    const encoded = compress(input, 64)
    const parts = splitString(encoded, 40)
    expect(decompress(parts.join(""), 64)).toBe(input)
  })

  it("discovers and reads numbered split part files", () => {
    const dir = makeTempDir()
    const basePath = join(dir, "output.txt")
    const encoded = compress("split file round trip", 64)
    const chunks = splitString(encoded, 10)
    const totalParts = chunks.length

    const paths = chunks.map((chunk, index) => {
      const partPath = formatSplitOutputPath(basePath, index + 1, totalParts)
      writeFileSync(partPath, wrapSplitChunk(index + 1, totalParts, chunk), "utf-8")
      return partPath
    })

    expect(parseSplitPartPath(paths[0])).toEqual({ prefix: "output" })
    expect(extractFilenamePrefix(paths[2])).toBe("output")
    expect(resolveSplitInputPaths(paths[2])).toEqual(paths)
    expect(readSplitInput(paths[1]).content).toBe(encoded)
    expect(decompress(readSplitInput(paths[0]).content, 64)).toBe("split file round trip")
  })

  it("reassembles split output when filenames are shuffled", () => {
    const dir = makeTempDir()
    const basePath = join(dir, "output.txt")
    const encoded = compress("shuffled split parts", 64)
    const chunks = splitString(encoded, 12)
    const totalParts = chunks.length

    for (let index = 0; index < totalParts; index++) {
      const shuffledIndex = totalParts - index
      const partPath = formatSplitOutputPath(basePath, shuffledIndex, totalParts)
      writeFileSync(partPath, wrapSplitChunk(index + 1, totalParts, chunks[index]), "utf-8")
    }

    expect(readSplitInput(join(dir, "output.1.txt")).content).toBe(encoded)
    expect(decompress(readSplitInput(join(dir, "output.1.txt")).content, 64)).toBe(
      "shuffled split parts",
    )
  })

  it("reassembles split output merged into fewer files", () => {
    const dir = makeTempDir()
    const basePath = join(dir, "output.txt")
    const encoded = compress("merged split parts", 64)
    const chunks = splitString(encoded, 11)
    const totalParts = chunks.length

    const mergedPath = join(dir, "output.1.txt")
    const mergedContent = [
      wrapSplitChunk(1, totalParts, chunks[0]),
      wrapSplitChunk(2, totalParts, chunks[1]),
    ].join("")
    writeFileSync(mergedPath, mergedContent, "utf-8")

    for (let index = 2; index < totalParts; index++) {
      const partPath = formatSplitOutputPath(basePath, index + 1, totalParts)
      writeFileSync(partPath, wrapSplitChunk(index + 1, totalParts, chunks[index]), "utf-8")
    }

    expect(readSplitInput(mergedPath).content).toBe(encoded)
    expect(decompress(readSplitInput(mergedPath).content, 64)).toBe("merged split parts")
  })

  it("reassembles split output merged into a single file", () => {
    const dir = makeTempDir()
    const encoded = compress("single merged file", 64)
    const chunks = splitString(encoded, 9)
    const totalParts = chunks.length
    const mergedPath = join(dir, "all.txt")

    writeFileSync(
      mergedPath,
      chunks.map((chunk, index) => wrapSplitChunk(index + 1, totalParts, chunk)).join(""),
      "utf-8",
    )

    expect(readSplitInput(mergedPath).content).toBe(encoded)
    expect(decompress(readSplitInput(mergedPath).content, 64)).toBe("single merged file")
  })

  it("errors when split parts are missing", () => {
    const dir = makeTempDir()
    writeFileSync(join(dir, "output.1.txt"), wrapSplitChunk(1, 3, "a"))
    writeFileSync(join(dir, "output.3.txt"), wrapSplitChunk(3, 3, "c"))
    expect(() => readSplitInput(join(dir, "output.1.txt"))).toThrow(/Missing split part 2/)
  })

  it("discovers prefix siblings with shuffled names and skips invalid files", () => {
    const dir = makeTempDir()
    const encoded = compress(`prefix discovery ${"x".repeat(2000)}`, 64)
    const chunks = splitString(encoded, 10)
    expect(chunks.length).toBeGreaterThanOrEqual(3)
    const totalParts = chunks.length

    writeFileSync(join(dir, "file.1.md"), wrapSplitChunk(3, totalParts, chunks[2]), "utf-8")
    writeFileSync(join(dir, "file.2.md"), "not valid split data", "utf-8")
    writeFileSync(join(dir, "file.3.md"), wrapSplitChunk(2, totalParts, chunks[1]), "utf-8")
    writeFileSync(join(dir, "file.7.md"), wrapSplitChunk(1, totalParts, chunks[0]), "utf-8")

    for (let index = 3; index < totalParts; index++) {
      const partPath = join(dir, `file.${index + 10}.md`)
      writeFileSync(partPath, wrapSplitChunk(index + 1, totalParts, chunks[index]), "utf-8")
    }

    for (const entry of ["file.1.md", "file.2.md", "file.7.md"]) {
      expect(readSplitInput(join(dir, entry)).content).toBe(encoded)
      expect(decompress(readSplitInput(join(dir, entry)).content, 64)).toBe(
        `prefix discovery ${"x".repeat(2000)}`,
      )
    }
  })

  it("discovers prefix siblings regardless of extension", () => {
    const dir = makeTempDir()
    const encoded = compress("mixed extensions", 64)
    const chunks = splitString(encoded, 10)
    const totalParts = chunks.length
    const extensions = [".md", ".txt", ".bin", ".dat", ".z"]

    for (let index = 0; index < totalParts; index++) {
      const ext = extensions[index % extensions.length]
      writeFileSync(
        join(dir, `blob.${index + 1}${ext}`),
        wrapSplitChunk(index + 1, totalParts, chunks[index]),
        "utf-8",
      )
    }

    expect(readSplitInput(join(dir, "blob.2.txt")).content).toBe(encoded)
  })

  it("auto-splits above 30,000 characters when -s is omitted", () => {
    expect(resolveSplitChunkSize(30_000)).toBeUndefined()
    expect(resolveSplitChunkSize(30_001)).toBe(AUTO_SPLIT_CHARS)
    expect(resolveSplitChunkSize(50_000, 4_000)).toBe(4_000)
  })

  it("disables splitting when explicit size is 0", () => {
    expect(resolveSplitChunkSize(50_000, 0)).toBeUndefined()
    expect(resolveSplitChunkSize(30_001, 0)).toBeUndefined()
  })

  it("uses a printable ASCII split header so files stay text-only", () => {
    const wrapped = wrapSplitChunk(2, 5, "AwEAAA==")
    expect(wrapped.startsWith(";TCP2;2;5;")).toBe(true)
    expect(SPLIT_MAGIC).toBe(";TCP2;")
    for (const char of wrapped) {
      const code = char.charCodeAt(0)
      expect(code).toBeGreaterThanOrEqual(32)
      expect(code).toBeLessThan(127)
    }
  })

  it("limits each split part file to -s characters including the header", () => {
    const dir = makeTempDir()
    const encoded = compress("x".repeat(500), 64)
    const maxPartChars = 100
    const wrappedParts = splitEncodedIntoWrappedParts(encoded, maxPartChars)
    for (const part of wrappedParts) {
      expect(part.length).toBeLessThanOrEqual(maxPartChars)
    }

    const totalParts = wrappedParts.length
    for (let index = 0; index < totalParts; index++) {
      const partPath = formatSplitOutputPath(join(dir, "out.txt"), index + 1, totalParts)
      writeFileSync(partPath, wrappedParts[index], "utf-8")
    }
    expect(readSplitInput(join(dir, "out.1.txt")).content).toBe(encoded)
    expect(decompress(readSplitInput(join(dir, "out.1.txt")).content, 64)).toBe("x".repeat(500))
  })

  it("accounts for wider headers when part counts cross digit boundaries", () => {
    const encoded = "a".repeat(950)
    const parts = splitEncodedIntoWrappedParts(encoded, 100)
    expect(parts.length).toBeGreaterThan(1)
    for (const part of parts) {
      expect(part.length).toBeLessThanOrEqual(100)
    }
    const dir = makeTempDir()
    const totalParts = parts.length
    for (let index = 0; index < totalParts; index++) {
      writeFileSync(
        formatSplitOutputPath(join(dir, "wide.txt"), index + 1, totalParts),
        parts[index],
        "utf-8",
      )
    }
    expect(readSplitInput(join(dir, "wide.1.txt")).content).toBe(encoded)
  })

  it("still reads legacy binary TCP\\x02 split headers", () => {
    const dir = makeTempDir()
    const legacyHeader = Buffer.alloc(12)
    Buffer.from([0x54, 0x43, 0x50, 0x02]).copy(legacyHeader, 0)
    legacyHeader.writeUInt32LE(1, 4)
    legacyHeader.writeUInt32LE(1, 8)
    const encoded = compress("legacy split header", 64)
    writeFileSync(
      join(dir, "legacy.txt"),
      Buffer.concat([legacyHeader, Buffer.from(encoded, "utf-8")]),
    )
    expect(readSplitInput(join(dir, "legacy.txt")).content).toBe(encoded)
    expect(decompress(readSplitInput(join(dir, "legacy.txt")).content, 64)).toBe(
      "legacy split header",
    )
  })
})

describe("input path validation", () => {
  it("rejects -f input when the path is a directory", () => {
    const dir = makeTempDir()
    expect(() => readTextFile(dir, "compress")).toThrow(/is a directory/)
    expect(() => readTextFile(dir, "decompress")).toThrow(/compressed .txt file/)
    expect(() => resolveSplitInputPaths(dir)).toThrow(/is a directory/)
    expect(() => readSplitInput(dir)).toThrow(/is a directory/)
  })

  it("rejects -d input when the path is a file", () => {
    const dir = makeTempDir()
    const file = join(dir, "notes.txt")
    writeFileSync(file, "hello")
    expect(() => assertDirectory(file)).toThrow(/is not a directory/)
  })
})

describe("base85 encoding", () => {
  it("produces smaller output than base64 for larger payloads", () => {
    const input = "The quick brown fox jumps over the lazy dog.\n".repeat(200)
    const b64 = compress(input, 64)
    const b85 = compress(input, 85)
    expect(b85.length).toBeLessThan(b64.length)
  })
})