"""Prepare this repository's review cut, not an inherited narrative template.
Requires a local MLX-Audio environment, a downloaded Kokoro snapshot, ImageMagick,
ffmpeg, and an explicit font. Produces inputs for the portable litai video builder.
No cloud speech, voice cloning, demo execution, installation, or publication.
"""
from __future__ import annotations
import argparse
import hashlib
import html
import json
import shutil
import subprocess
from pathlib import Path
def run(*argv: str, source: str | None = None) -> str:
return subprocess.run(
argv, input=source, text=True, capture_output=True, check=True, timeout=300
).stdout
def text(x: int, y: int, value: str, size: int = 28, color: str = "#e9edf5") -> str:
# The SVG reader can swallow a final quote; an invisible sentinel preserves
# literal shell-command punctuation in the rendered artwork.
return (
f''
f"{html.escape(value, quote=False)}\u200b"
)
def panel(x: int, y: int, w: int, h: int, fill: str = "#21304b") -> str:
return (
f''
)
def laptop(x: int, y: int, label: str, screen: str, color: str) -> str:
return (
panel(x, y, 210, 140, "#0b1221")
+ f''
+ text(x + 24, y + 88, screen, 35, color)
+ text(x + 15, y + 200, label, 24)
)
def arrow(x: int, y: int, width: int, color: str = "#37d8b7") -> str:
return (
f''
f''
)
HEADINGS = {
"zip": "It builds. But can you ship it?",
"proof": "Which version did you actually test?",
"shrug": "Reassuring is not reproducible.",
"bridge": "Close the gap between built and shipped.",
"where": "Start here. No secret handshake.",
"repo": "Get Literate AI from the public repository",
"tools": "A small starting kit",
"clone": "Clone. Enter. Install.",
"consent": "Read the prerequisite prompt.",
"path": "Installed is not always on your PATH.",
"doctor": "Prove your command is available.",
"login": "The harness and the agent are separate.",
"next": "Now give the agent a destination.",
"pipeline": "A candidate must earn its way to shipping.",
"end": "Next: your first real coding session.",
}
def artwork(shot: str, active: str) -> str:
parts = [
'")
return "\n".join(parts)
def main() -> None:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--output", required=True, type=Path)
parser.add_argument("--font", required=True, type=Path)
parser.add_argument(
"--model", required=True, type=Path, help="downloaded Kokoro snapshot"
)
parser.add_argument("--repository-image", required=True, type=Path)
args = parser.parse_args()
from importlib.metadata import version
import numpy as np
import soundfile as sf
from mlx_audio.tts.utils import load_model
story_path = Path(__file__).with_name("storyboard.json")
story = json.loads(story_path.read_text())
root = args.output.resolve()
root.mkdir(parents=True, exist_ok=True)
assets = root / "assets"
assets.mkdir(exist_ok=True)
shutil.copy2(args.repository_image, assets / "repository.png")
model = load_model(args.model.resolve(), model_type="kokoro")
scenes = []
for number, turn in enumerate(story["turns"], 1):
print(
f"Preparing shot {number}/{len(story['turns'])}: {turn['shot']}", flush=True
)
stem = f"shot-{number:02}"
voice = (
args.model / "voices" / f"{story['voices'][turn['speaker']]}.safetensors"
)
result = list(
model.generate(
text=turn["text"], voice=str(voice.absolute()), speed=1.0, lang_code="a"
)
)
audio = np.concatenate([np.asarray(part.audio) for part in result])
raw = assets / f"{stem}-raw.wav"
sf.write(raw, audio, result[0].sample_rate)
narration = assets / f"{stem}.wav"
run(
"ffmpeg",
"-v",
"error",
"-y",
"-i",
str(raw),
"-af",
"loudnorm=I=-16:TP=-1.5:LRA=9",
"-ar",
"24000",
str(narration),
)
slide = assets / f"{stem}.png"
run(
"magick",
"-font",
str(args.font),
"svg:-",
str(slide),
source=artwork(turn["shot"], turn["speaker"]),
)
if turn["shot"] in {"where", "repo"}:
browser = assets / "browser-thumb.png"
run(
"magick",
str(assets / "repository.png"),
"-resize",
"720x355",
"-background",
"white",
"-gravity",
"north",
"-extent",
"720x355",
str(browser),
)
run(
"magick",
str(slide),
str(browser),
"-geometry",
"+290+195",
"-composite",
str(slide),
)
for speaker, filename, x in (
("litai", "litai-guide.png", 15),
("sam", "sam-engineer.png", 1020),
):
portrait = assets / f"portrait-{speaker}.png"
run(
"magick",
str(story_path.parent.parent / "assets" / filename),
"-resize",
"245x315",
"-channel",
"A",
"-evaluate",
"multiply",
"1" if speaker == turn["speaker"] else "0.55",
str(portrait),
)
run(
"magick",
str(slide),
str(portrait),
"-geometry",
f"+{x}+215",
"-composite",
str(slide),
)
scenes.append(
{
"title": HEADINGS[turn["shot"]],
"visual": f"assets/{slide.name}",
"dialogue": [
{
"speaker": turn["speaker"],
"text": turn["text"]
.replace("Literate A I", "Literate AI")
.replace("lit eye", "litai"),
"audio": f"assets/{narration.name}",
}
],
}
)
provenance = {
"model": "mlx-community/Kokoro-82M-bf16",
"snapshot": args.model.name,
"mlx_audio": version("mlx-audio"),
"voices": story["voices"],
"storyboard_sha256": hashlib.sha256(story_path.read_bytes()).hexdigest(),
"synthetic_voices": True,
"cloud_speech": False,
"repository_screenshot": "https://github.com/jordanhubbard/literate-ai",
"status": "creative-review-only; setup walkthrough, not a recorded installation",
}
(root / "production.json").write_text(json.dumps(provenance, indent=2) + "\n")
manifest = {
"schema": "literate-ai/video-course@1",
"id": story["id"],
"title": story["title"],
"speakers": {"litai": {"name": "LitAI"}, "sam": {"name": "Sam"}},
"scenes": scenes,
"evidence": ["production.json"],
}
(root / "course.json").write_text(json.dumps(manifest, indent=2) + "\n")
print(root / "course.json")
if __name__ == "__main__":
main()