repo-timelapse 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 0scar07
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.es.md

@@ -0,0 +1,145 @@
+<div align="center">
+
+# repo timelapse
+
+**Mira crecer tu repositorio, en video.**
+
+Un comando convierte tu historial de git en un timelapse: las carpetas se ramifican, los archivos se encienden al nacer, las personas saltan a lo que tocan y cada release importante tiene su momento. Con banda sonora propia.
+
+[![npm](https://img.shields.io/npm/v/repo-timelapse?color=9D8CFF&label=npm)](https://www.npmjs.com/package/repo-timelapse)
+[![CI](https://github.com/0scar07/repo-timelapse/actions/workflows/ci.yml/badge.svg)](https://github.com/0scar07/repo-timelapse/actions/workflows/ci.yml)
+[![licencia](https://img.shields.io/badge/licencia-MIT-9D8CFF)](LICENSE)
+
+[English](README.md)
+
+<img src="docs/demo-es.gif" alt="Demo de repo timelapse: un árbol radial de carpetas y archivos que crece con el tiempo, con personas, una tarjeta de hito y un resumen final" width="720">
+
+<sub>Datos de ejemplo. Ejemplos reales con sonido (como <b>expressjs/express</b>, 17 años en menos de un minuto) en <a href="https://github.com/0scar07/repo-timelapse/releases">Releases</a>.</sub>
+
+</div>
+
+## Empieza
+
+```bash
+npx repo-timelapse
+```
+
+Ejecútalo dentro de cualquier repositorio de git. Obtienes `<repo>-timelapse.mp4`.
+
+También sirve con cualquier repo público de GitHub, sin clonarlo tú:
+
+```bash
+npx repo-timelapse --github expressjs/express
+```
+
+Solo descarga la historia (commits y estructura de carpetas), no el contenido de los archivos, así que hasta los repos enormes van rápido.
+
+**Requisitos:** Node.js 18.17+ y git. La primera vez tarda un par de minutos: npx instala el renderizador y descarga un Chrome sin interfaz (solo una vez).
+
+## Qué vas a ver
+
+| Momento | Qué pasa |
+|---|---|
+| Intro | El nombre del repo, el día que empezó y su primer commit, como una semilla |
+| Crecimiento | Las carpetas son ramas y los archivos luces, con el color de su lenguaje. Las carpetas principales llevan su nombre. Los archivos nuevos brillan, los editados destellan y los borrados se apagan en rojo. La cámara se aleja a medida que el árbol crece |
+| Personas | Quienes más aportan saltan a los archivos que tocan, con un rayo punteado. En repos de GitHub aparecen con su foto de perfil real |
+| Hitos | En cada release importante (`v1.0.0`, `2.0.0`…) o número redondo de commits, el tiempo se frena y una tarjeta muestra cuánto había crecido el proyecto |
+| Marcadores | Contadores en vivo de commits, archivos y personas, el último commit y una línea de tiempo con los hitos |
+| Cierre | El árbol completo y el resumen: cuánto tiempo, cuántos commits, personas, archivos y días activos |
+
+La duración se adapta a la historia: unos 25 segundos para repos chicos y alrededor de un minuto para los grandes. Los hitos salen solos de tus tags.
+
+## En tu README, en cada release
+
+Crea `.github/workflows/timelapse.yml` y tu README mostrará cómo creció el proyecto, actualizado en cada release (el MP4 también se adjunta a la release):
+
+```yaml
+name: timelapse
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  timelapse:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0                                   # toda la historia
+          ref: ${{ github.event.repository.default_branch }}
+      - uses: 0scar07/repo-timelapse@v1
+        with:
+          lang: es
+```
+
+Pon estas dos líneas donde quieras el GIF; si no, va al final:
+
+```md
+<!-- repo-timelapse:start -->
+<!-- repo-timelapse:end -->
+```
+
+| Entrada | Por defecto | Qué hace |
+|---|---|---|
+| `title` | nombre del repo | Nombre que se muestra |
+| `lang` | `en` | `en` o `es` |
+| `readme` | `README.md` | README a actualizar (vacío para omitirlo) |
+| `output-dir` | `.github/timelapse` | Dónde se guardan el MP4, el GIF y los datos |
+| `vertical` | `false` | Genera también el video 9:16 |
+| `release-asset` | `true` | Adjunta el MP4 a la release que lo disparó |
+| `commit` | `true` | Hace commit y push a la rama principal |
+
+## Opciones
+
+| Opción | Qué hace |
+|---|---|
+| `--github <owner/repo>` | Un repo de GitHub en vez de una carpeta local |
+| `--token <token>` | Token de GitHub (o `GITHUB_TOKEN`) para repos privados |
+| `--since <fecha>` / `--until <fecha>` | Solo una parte de la historia, ej. `--since 2024-01-01` |
+| `--title <texto>` | Nombre que se muestra (por defecto, el de la carpeta o el repo) |
+| `--lang es\|en` | Idioma del video (por defecto, el de tu sistema) |
+| `--vertical` | Video vertical 9:16 para TikTok, Reels y Shorts |
+| `--fps 30\|60` | Fotogramas por segundo (30 por defecto) |
+| `--no-music` | Video sin audio |
+| `--no-avatars` | Iniciales en vez de las fotos de perfil de GitHub |
+| `--gif` | Genera también un GIF liviano (para READMEs) |
+| `--readme <archivo>` | Pone el GIF en ese README, entre marcadores |
+| `--gl <modo>` | Renderizado de Chrome: `angle` (GPU, por defecto en Windows y macOS), `swangle`, `default` |
+| `-o, --out <archivo>` | Archivo de salida |
+| `--json` | Solo imprime los datos, sin renderizar |
+| `--data <archivo>` | Renderiza desde un JSON guardado |
+| `--demo` | Renderiza con datos de ejemplo |
+
+**Repos grandes:** si hay más de ~1.400 archivos, las carpetas más profundas se agrupan en racimos para que el video siga fluido. Los bots (dependabot, renovate…) cuentan en los totales pero no salen como personas.
+
+## Cómo funciona
+
+1. `git log --name-status` da cada commit con los archivos que añadió, cambió o borró. No se calculan diffs, por eso es rápido.
+2. El árbol de carpetas se dibuja en forma radial: el ángulo según la cantidad de archivos y el radio según la profundidad.
+3. Cada fotograma del video es una función pura del tiempo ([Remotion](https://www.remotion.dev)), así que los renders son deterministas.
+4. La banda sonora se sintetiza para cada video (120 BPM, original, MIT): el ritmo se corta en cada hito y el cierre tiene un brillo.
+
+## Desarrollo
+
+```bash
+npm install
+npm run studio   # preview en vivo en Remotion Studio con los datos de ejemplo
+npm run demo     # renderiza el video de ejemplo
+npm test
+```
+
+Las contribuciones son bienvenidas. Mira [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## De la misma familia
+
+[git wrapped](https://github.com/0scar07/git-wrapped): tu año en git en un video de 18 segundos.
+
+Inspirado en [Gource](https://github.com/acaudwell/Gource), el visualizador de repositorios clásico.
+
+## Licencia
+
+[MIT](LICENSE)

package/README.md

@@ -1,3 +1,143 @@
-# Temporary Holding Version
+<div align="center">
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# repo timelapse
+
+**Watch your repository grow, as a video.**
+
+One command turns your git history into a timelapse: folders branch out, files light up as they're born, contributors jump to what they touch, and every big release gets its moment. With its own soundtrack.
+
+[![npm](https://img.shields.io/npm/v/repo-timelapse?color=9D8CFF&label=npm)](https://www.npmjs.com/package/repo-timelapse)
+[![CI](https://github.com/0scar07/repo-timelapse/actions/workflows/ci.yml/badge.svg)](https://github.com/0scar07/repo-timelapse/actions/workflows/ci.yml)
+[![license](https://img.shields.io/badge/license-MIT-9D8CFF)](LICENSE)
+
+[Español](README.es.md)
+
+<img src="docs/demo-en.gif" alt="repo timelapse demo: a radial tree of folders and files growing over time, with contributors, a milestone card and a closing summary" width="720">
+
+<sub>Sample data. Real examples with sound (like <b>expressjs/express</b>, 17 years in under a minute) in <a href="https://github.com/0scar07/repo-timelapse/releases">Releases</a>.</sub>
+
+</div>
+
+## Quick start
+
+```bash
+npx repo-timelapse
+```
+
+Run it inside any git repository. You get `<repo>-timelapse.mp4`.
+
+Any public GitHub repo works too, without cloning it yourself:
+
+```bash
+npx repo-timelapse --github expressjs/express
+```
+
+It only downloads the history (commits and folder structure), not the file contents, so even huge repos are fast.
+
+**Requirements:** Node.js 18.17+ and git. The first run takes a couple of minutes: npx installs the renderer and downloads a headless Chrome (only once).
+
+## What you'll see
+
+| Moment | What happens |
+|---|---|
+| Intro | The repo name, the day it started and its first commit, as a seed |
+| Growth | Folders are branches and files are lights, colored by language. The main folders are labeled. New files glow, edited files flash, deleted ones fade out in red. The camera pulls back as the tree grows |
+| Contributors | The top contributors jump to the files they touch, with a dotted beam. On GitHub repos they show their real profile photo |
+| Milestones | At each big release (`v1.0.0`, `2.0.0`…) or round number of commits, time stops and a card shows how far the project had come |
+| HUD | Live counters of commits, files and people, the latest commit, and a timeline with every milestone |
+| Ending | The full tree and a summary: how long, how many commits, people, files and active days |
+
+The video length adapts to the history: from about 25 seconds for small repos to about a minute for big ones. Milestones are picked automatically from your tags.
+
+## In your README, on every release
+
+Add `.github/workflows/timelapse.yml` and your README will show how the project grew, updated on each release (the MP4 is also attached to the release):
+
+```yaml
+name: timelapse
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  timelapse:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0                                   # the whole history
+          ref: ${{ github.event.repository.default_branch }}
+      - uses: 0scar07/repo-timelapse@v1
+```
+
+Put these two lines where you want the GIF; otherwise it goes at the end:
+
+```md
+<!-- repo-timelapse:start -->
+<!-- repo-timelapse:end -->
+```
+
+| Input | Default | What it does |
+|---|---|---|
+| `title` | repo name | Name shown in the video |
+| `lang` | `en` | `en` or `es` |
+| `readme` | `README.md` | README to update (empty to skip) |
+| `output-dir` | `.github/timelapse` | Where the MP4, GIF and data go |
+| `vertical` | `false` | Also render a 9:16 video |
+| `release-asset` | `true` | Attach the MP4 to the release that triggered it |
+| `commit` | `true` | Commit and push to the default branch |
+
+## Options
+
+| Flag | What it does |
+|---|---|
+| `--github <owner/repo>` | A GitHub repo instead of a local folder |
+| `--token <token>` | GitHub token (or `GITHUB_TOKEN`) for private repos |
+| `--since <date>` / `--until <date>` | Only part of the history, e.g. `--since 2024-01-01` |
+| `--title <text>` | Name shown in the video (default: folder or repo name) |
+| `--lang es\|en` | Video language (default: your system language) |
+| `--vertical` | Vertical 9:16 video for TikTok, Reels and Shorts |
+| `--fps 30\|60` | Frame rate (default 30) |
+| `--no-music` | Silent video |
+| `--no-avatars` | Initials instead of GitHub profile photos |
+| `--gif` | Also make a light GIF (for READMEs) |
+| `--readme <file>` | Put the GIF into that README, between markers |
+| `--gl <mode>` | Chrome rendering: `angle` (GPU, default on Windows and macOS), `swangle`, `default` |
+| `-o, --out <file>` | Output file |
+| `--json` | Print the computed data and skip rendering |
+| `--data <file>` | Render from a saved JSON |
+| `--demo` | Render with sample data |
+
+**Big repos:** if there are more than ~1,400 files, the deepest folders are grouped into clusters so the video stays smooth. Bots (dependabot, renovate…) count in the totals but don't appear as contributors.
+
+## How it works
+
+1. `git log --name-status` gives every commit with the files it added, changed or deleted. No diffs are computed, which keeps it fast.
+2. The folder tree is laid out radially: angle by number of files, radius by depth.
+3. Each frame of the video is a pure function of time ([Remotion](https://www.remotion.dev)), so renders are deterministic.
+4. The soundtrack is synthesized for each video (120 BPM, original, MIT): the beat drops at every milestone and the ending gets a shimmer.
+
+## Development
+
+```bash
+npm install
+npm run studio   # live preview in Remotion Studio with the sample data
+npm run demo     # render the sample video
+npm test
+```
+
+Contributions are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Related
+
+From the same family: [git wrapped](https://github.com/0scar07/git-wrapped), your year in git as an 18-second video.
+
+Inspired by [Gource](https://github.com/acaudwell/Gource), the classic repository visualizer.
+
+## License
+
+[MIT](LICENSE)

package/bin/cli.mjs

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+// repo-timelapse: mira crecer tu repo en un video.
+import { parseArgs } from 'node:util';
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { analyzeRepo } from '../src/history.mjs';
+import { makeTimeline } from '../src/timing.mjs';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const pkg = JSON.parse(readFileSync(path.join(root, 'package.json'), 'utf8'));
+
+const { values: o, positionals } = parseArgs({
+  allowPositionals: true,
+  options: {
+    github: { type: 'string' },
+    token: { type: 'string' },
+    since: { type: 'string' },
+    until: { type: 'string' },
+    title: { type: 'string' },
+    lang: { type: 'string' },
+    vertical: { type: 'boolean' },
+    fps: { type: 'string' },
+    'no-music': { type: 'boolean' },
+    'no-avatars': { type: 'boolean' },
+    gif: { type: 'boolean' },
+    readme: { type: 'string' },
+    gl: { type: 'string' },
+    out: { type: 'string', short: 'o' },
+    json: { type: 'boolean' },
+    data: { type: 'string' },
+    demo: { type: 'boolean' },
+    help: { type: 'boolean', short: 'h' },
+    version: { type: 'boolean', short: 'v' },
+  },
+});
+
+const sysLang = (Intl.DateTimeFormat().resolvedOptions().locale || 'en').toLowerCase().startsWith('es') ? 'es' : 'en';
+const lang = o.lang === 'es' || o.lang === 'en' ? o.lang : sysLang;
+const es = lang === 'es';
+const say = (e, n) => console.log(es ? e : n);
+const log = o.json ? () => {} : say;
+const fail = (e, n) => { say(e, n); process.exit(1); };
+
+if (o.version) { console.log(pkg.version); process.exit(0); }
+if (o.help) {
+  console.log(`
+  repo-timelapse ${pkg.version}
+
+  ${es ? 'Uso' : 'Usage'}:  npx repo-timelapse [${es ? 'ruta' : 'path'}] [${es ? 'opciones' : 'options'}]
+
+  --github <owner/repo> ${es ? 'Un repo público de GitHub (se clona sin el contenido de los archivos, rápido)' : 'A public GitHub repo (cloned without file contents, fast)'}
+  --token <token>       ${es ? 'Token de GitHub (o GITHUB_TOKEN) para repos privados' : 'GitHub token (or GITHUB_TOKEN) for private repos'}
+  --since <fecha>       ${es ? 'Empieza en esa fecha (ej.: 2024-01-01)' : 'Start at that date (e.g. 2024-01-01)'}
+  --until <fecha>       ${es ? 'Termina en esa fecha' : 'End at that date'}
+  --title <texto>       ${es ? 'Nombre que se muestra (por defecto, el de la carpeta)' : 'Name shown (default: the folder name)'}
+  --lang es|en          ${es ? 'Idioma del video' : 'Video language'}
+  --vertical            ${es ? 'Formato vertical 9:16 para TikTok, Reels y Shorts' : 'Vertical 9:16 for TikTok, Reels and Shorts'}
+  --fps 30|60           ${es ? 'Fotogramas por segundo (30 por defecto)' : 'Frames per second (default 30)'}
+  --no-music            ${es ? 'Video sin audio' : 'Silent video'}
+  --no-avatars          ${es ? 'Iniciales en vez de las fotos de GitHub' : 'Initials instead of GitHub photos'}
+  --gif                 ${es ? 'Genera también un GIF (para READMEs)' : 'Also make a GIF (for READMEs)'}
+  --readme <archivo>    ${es ? 'Pone el GIF en ese README, entre marcadores' : 'Put the GIF into that README, between markers'}
+  --gl <modo>           ${es ? 'Renderizado de Chrome: angle (GPU), swangle, default…' : 'Chrome rendering: angle (GPU), swangle, default…'}
+  -o, --out <archivo>   ${es ? 'Archivo de salida' : 'Output file'}
+  --json                ${es ? 'Solo imprime los datos, sin renderizar' : 'Print the data only, no render'}
+  --data <json>         ${es ? 'Renderiza desde un JSON ya generado' : 'Render from a saved JSON'}
+  --demo                ${es ? 'Renderiza con datos de ejemplo' : 'Render with sample data'}
+`);
+  process.exit(0);
+}
+
+const git = (args, opts = {}) => execFileSync('git', args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], ...opts });
+let data, cleanup = null;
+
+if (o.demo) {
+  data = { ...JSON.parse(readFileSync(path.join(root, 'src/demo.json'), 'utf8')), lang };
+} else if (o.data) {
+  data = { ...JSON.parse(readFileSync(path.resolve(o.data), 'utf8')), ...(o.lang ? { lang } : {}) };
+} else {
+  let repo = path.resolve(positionals[0] || '.');
+  let name = o.title;
+  if (o.github) {
+    const slug = o.github.replace(/^https?:\/\/github\.com\//, '').replace(/\.git$/, '').replace(/\/$/, '');
+    if (!/^[\w.-]+\/[\w.-]+$/.test(slug)) fail('Usa --github owner/repo (ej.: --github vercel/next.js)', 'Use --github owner/repo (e.g. --github vercel/next.js)');
+    const token = o.token || process.env.GITHUB_TOKEN || process.env.GH_TOKEN || '';
+    const dir = mkdtempSync(path.join(tmpdir(), 'repo-timelapse-'));
+    cleanup = () => rmSync(dir, { recursive: true, force: true });
+    const auth = token ? ['-c', `http.https://github.com/.extraheader=AUTHORIZATION: basic ${Buffer.from(`x-access-token:${token}`).toString('base64')}`] : [];
+    log(`Clonando ${slug} (solo la historia, sin el contenido de los archivos)…`, `Cloning ${slug} (history only, no file contents)…`);
+    try {
+      git([...auth, 'clone', '--quiet', '--no-checkout', '--filter=blob:none', `https://github.com/${slug}.git`, dir], { env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } });
+    } catch {
+      cleanup();
+      fail(`No pude clonar ${slug}. ¿Existe y es público? Para privados usa --token.`, `Couldn't clone ${slug}. Does it exist and is it public? For private repos use --token.`);
+    }
+    repo = dir;
+    name = name || slug.split('/')[1];
+  } else {
+    try { repo = git(['-C', repo, 'rev-parse', '--show-toplevel']).trim(); }
+    catch { fail('Aquí no hay un repo de git. Pasa una ruta o usa --github owner/repo.', 'No git repo here. Pass a path or use --github owner/repo.'); }
+  }
+  log('Leyendo la historia…', 'Reading the history…');
+  data = analyzeRepo(repo, { since: o.since, until: o.until, name, lang });
+  if (data) {
+    const { githubSlug } = await import('../src/github.mjs');
+    data.slug = githubSlug(repo, o.github ? o.github.replace(/^https?:\/\/github\.com\//, '').replace(/\.git$/, '').replace(/\/$/, '') : null);
+  }
+  cleanup?.();
+  if (!data) fail('Ese repo no tiene commits (o ninguno en ese rango de fechas).', 'That repo has no commits (or none in that date range).');
+}
+
+if (o.json) { console.log(JSON.stringify(data)); process.exit(0); }
+
+const tl = makeTimeline(data);
+say(`${data.totals.commits} commits · ${data.totals.authors} ${es ? 'personas' : 'people'} · ${data.milestones.length} ${es ? 'hitos' : 'milestones'} · ${tl.total.toFixed(0)} s`,
+  `${data.totals.commits} commits · ${data.totals.authors} people · ${data.milestones.length} milestones · ${tl.total.toFixed(0)}s`);
+if (data.collapsed) say('(Repo grande: las carpetas más profundas se agrupan para que el video sea fluido.)', '(Big repo: the deepest folders are grouped so the video stays smooth.)');
+
+const fps = o.fps === '60' ? 60 : 30;
+const safe = data.name.replace(/[^\w.-]+/g, '-');
+const out = path.resolve(o.out || `${safe}-timelapse${o.vertical ? '-vertical' : ''}.mp4`);
+mkdirSync(path.dirname(out), { recursive: true });
+const publicDir = mkdtempSync(path.join(tmpdir(), 'repo-timelapse-pub-'));
+let music = null;
+if (!o['no-music']) {
+  const { synthMusic } = await import('../src/music.mjs');
+  writeFileSync(path.join(publicDir, 'music.wav'), synthMusic(tl));
+  music = 'music.wav';
+}
+// fotos de perfil de GitHub para los avatares (si el repo es de GitHub)
+if (data.slug && !o['no-avatars'] && data.authors.length) {
+  const { fetchAvatars } = await import('../src/github.mjs');
+  const files = await fetchAvatars({ slug: data.slug, authors: data.authors, token: o.token || process.env.GITHUB_TOKEN || process.env.GH_TOKEN || '', outDir: publicDir });
+  data.authors.forEach((a, i) => { a.avatar = files[i]; });
+  const got = files.filter(Boolean).length;
+  if (got) say(`Fotos de GitHub: ${got}/${files.length}`, `GitHub photos: ${got}/${files.length}`);
+}
+
+const { bundle } = await import('@remotion/bundler');
+const { renderMedia, selectComposition } = await import('@remotion/renderer');
+say('Preparando el video…', 'Preparing the video…');
+const serveUrl = await bundle({ entryPoint: path.join(root, 'src/remotion/index.ts'), publicDir });
+const inputProps = { data, fps, music, vertical: Boolean(o.vertical) };
+const composition = await selectComposition({ serveUrl, id: 'Timelapse', inputProps });
+let gl = o.gl ?? (process.platform === 'linux' ? null : 'angle');
+const t0 = Date.now();
+const render = () => {
+  let last = -1;
+  return renderMedia({
+    composition, serveUrl, inputProps, codec: 'h264', outputLocation: out, crf: 18,
+    chromiumOptions: gl && gl !== 'default' ? { gl } : {},
+    onProgress: ({ progress }) => { const p = Math.floor(progress * 100); if (p !== last && p % 5 === 0) { last = p; process.stdout.write(`\r${es ? 'Renderizando' : 'Rendering'} ${p}%   `); } },
+  });
+};
+try { await render(); } catch (err) {
+  if (!gl || gl === 'default') throw err;
+  say('\nLa aceleración por GPU falló; reintento sin ella…', '\nGPU acceleration failed; retrying without it…');
+  gl = null; await render();
+}
+console.log('');
+const base = out.replace(/\.mp4$/i, '');
+if (o.gif || o.readme) {
+  // GIF liviano para READMEs: 10 fps y ~576 px de ancho
+  let last = -1;
+  await renderMedia({
+    composition, serveUrl, inputProps, codec: 'gif', outputLocation: base + '.gif', everyNthFrame: fps / 10, scale: o.vertical ? 0.4 : 0.3, muted: true,
+    chromiumOptions: gl && gl !== 'default' ? { gl } : {},
+    onProgress: ({ progress }) => { const p = Math.floor(progress * 100); if (p !== last && p % 10 === 0) { last = p; process.stdout.write(`\rGIF ${p}%   `); } },
+  });
+  console.log('');
+  say(`GIF: ${base}.gif`, `GIF: ${base}.gif`);
+}
+if (o.readme) {
+  const { updateReadme } = await import('../src/readme.mjs');
+  updateReadme({ readme: path.resolve(o.readme), image: base + '.gif', video: out, lang, name: data.name });
+  say(`README actualizado: ${path.resolve(o.readme)}`, `README updated: ${path.resolve(o.readme)}`);
+}
+rmSync(publicDir, { recursive: true, force: true });
+const secs = Math.round((Date.now() - t0) / 1000);
+say(`Listo en ${secs} s: ${out}\nCompártelo con #RepoTimelapse`, `Done in ${secs}s: ${out}\nShare it with #RepoTimelapse`);

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "repo-timelapse",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Watch your git repository grow: a timelapse video of its history, with one command. Mira crecer tu repo en un video.",
+  "type": "module",
+  "bin": {
+    "repo-timelapse": "bin/cli.mjs"
+  },
+  "files": [
+    "bin",
+    "src",
+    "assets"
+  ],
+  "scripts": {
+    "studio": "remotion studio src/remotion/index.ts",
+    "demo": "node bin/cli.mjs --demo",
+    "test": "node --test tests/history.test.mjs",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "git",
+    "timelapse",
+    "gource",
+    "visualization",
+    "remotion",
+    "video",
+    "cli",
+    "history",
+    "data-visualization"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/0scar07/repo-timelapse.git"
+  },
+  "homepage": "https://github.com/0scar07/repo-timelapse#readme",
+  "bugs": {
+    "url": "https://github.com/0scar07/repo-timelapse/issues"
+  },
+  "author": "0scar07",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.17"
+  },
+  "dependencies": {
+    "@remotion/bundler": "4.0.543",
+    "@remotion/cli": "4.0.543",
+    "@remotion/google-fonts": "4.0.543",
+    "@remotion/layout-utils": "4.0.543",
+    "@remotion/renderer": "4.0.543",
+    "react": "19.3.1",
+    "react-dom": "19.3.1",
+    "remotion": "4.0.543"
+  },
+  "devDependencies": {
+    "@types/react": "^19.3.0",
+    "typescript": "^7.0.2"
+  }
+}