{% extends "base.html" %}

{% block content %}
<!-- First screen: the hero + terminal are held to one viewport height so the
     next section (About) stays below the fold until the visitor scrolls. -->
<div class="hero-screen">
<!-- Hero -->
<section class="hero" id="top">
  <img class="hero-logo" src="/tapir-icon.svg"
       alt="The Tapir logo: a stylized tapir on a teal background."
       width="96" height="96">
  <h1>A small, extensible coding agent for your terminal.</h1>
  <p class="hero-subtitle"
     aria-label="Small enough to read end to end. Stubborn enough to finish the job.">
    Small enough to read end to end. Stubborn enough to
    <span class="hero-rotator" aria-hidden="true">finish the job</span>.
  </p>

  <!-- Install: a one-line curl that downloads the prebuilt binary. -->
  <div class="install-box">
    <code><span class="prefix">$ </span>curl -fsSL {{ config.base_url | safe }}/install.sh | sh</code>
    <button class="copy-btn"
            data-copy="curl -fsSL {{ config.base_url | safe }}/install.sh | sh">Copy</button>
  </div>
</section>

<!-- Demo: a live asciinema recording of a Tapir session. The static
     terminal inside #demo is the no-JS fallback; the player replaces it
     on load. The cast is authored (not a real capture) — regenerate it
     with gen-demo-cast.py. -->
<div class="demo">
  <div class="demo-bar" aria-hidden="true">
    <span class="demo-dot"></span><span class="demo-dot"></span><span class="demo-dot"></span>
    <span class="demo-title">tapir</span>
  </div>
  <div id="demo" class="demo-player">
<pre class="demo-body" role="img" aria-label="A Tapir terminal session: the user asks Tapir to add a --version flag and a test; Tapir greps the source, reads cli.rs, edits it with a diff, writes a test, runs cargo test, then switches model with /model."><span class="c-dim">$</span> tapir
<span class="c-dim">tapir · </span><span class="c-prompt">claude-sonnet-4-6</span><span class="c-dim"> · ~/src/acme</span>

<span class="c-prompt">›</span> add a --version flag to the CLI and a test for it

<span class="c-tool">⟳ grep</span> <span class="c-path">"struct Args"</span> src/
<span class="c-tool">⟳ read</span> <span class="c-path">src/cli.rs</span>
<span class="c-tool">⟳ edit</span> <span class="c-path">src/cli.rs</span>
<span class="c-dim">  @@ struct Args @@</span>
<span class="c-del">  -    // TODO: --version</span>
<span class="c-tool">  +    /// Print version and exit
  +    #[arg(long)]
  +    version: bool,</span>
<span class="c-tool">⟳ write</span> <span class="c-path">tests/cli_version.rs</span>
<span class="c-tool">⟳ bash</span> cargo test --test cli_version

Added a `--version` flag and a test asserting it prints
the crate version. <span class="c-tool">cargo test — 7 passed, 0 failed.</span>

<span class="c-prompt">›</span> <span class="c-dim">/model </span><span class="c-prompt">claude-haiku</span></pre>
  </div>
</div>
<p class="demo-note">A Tapir session: edits the CLI, writes a test, runs it, switches model.</p>
</div><!-- /.hero-screen -->

<link rel="stylesheet" href="/asciinema/asciinema-player.css">
<script src="/asciinema/asciinema-player.min.js"></script>
<script>
  (function () {
    var el = document.getElementById('demo');
    if (!el || !window.AsciinemaPlayer) return;
    var reduce = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
    el.innerHTML = '';
    AsciinemaPlayer.create('/demo.cast', el, {
      theme: 'tapir',
      fit: 'width',
      loop: !reduce,
      autoPlay: !reduce,
      controls: reduce,
      idleTimeLimit: 2
    });
  })();
</script>

<!-- About -->
<section class="section" id="about">
  <div class="section-label">About</div>
  <h2 class="section-title">A core small enough to trust</h2>
  <p>
    The core stays deliberately small —
    <code>read</code>, <code>bash</code>, <code>edit</code>, <code>write</code> —
    and everything past it is something you bolt on: tools, providers, skills,
    plugins. Tapir bends to the habits you already have instead of teaching you
    new ones.
  </p>
  <p>
    It ships as one self-contained binary on a Tokio async runtime — nothing to
    install but the file itself. It cold-starts in milliseconds, streams as it
    thinks, and leaves your terminal the way it found it.
  </p>
  <p class="docs-button">
    <a href="/docs/">Read the docs</a>
  </p>
</section>

<!-- Providers -->
<section class="section" id="providers">
  <div class="section-label">Providers &amp; Models</div>
  <h2 class="section-title">Every model behind one flag</h2>
  <p>
    Anthropic, Google, OpenAI (Responses) and any OpenAI-compatible endpoint —
    OpenRouter, DeepSeek, local servers. Authenticate with API keys, or with
    OAuth for Claude Pro/Max (<code>tapir --login anthropic</code>) and skip the
    key entirely.
  </p>
  <p>
    Pick per run, by fuzzy name, with a thinking level:
  </p>
  <div class="install-box">
    <code><span class="prefix">$ </span>tapir --provider google --model gemini-2.5-flash -p "..."
<span class="prefix">$ </span>tapir --model claude-sonnet-4-6:medium -p "..."</code>
  </div>
  <p>
    Switch mid-session with <code>/model</code>, or list the whole catalog with
    <code>tapir --list-models</code>:
  </p>
  <div class="install-box">
    <code><span class="prefix">$ </span>tapir --list-models
anthropic    claude-opus-4-8   claude-sonnet-4-6   claude-haiku-4-5
google       gemini-2.5-pro    gemini-2.5-flash
openai       gpt-5.4           gpt-4.1
openrouter   deepseek/deepseek-chat   # …and any OpenAI-compatible model</code>
  </div>
  <ul class="pills">
    <li>Anthropic</li>
    <li>Google</li>
    <li>OpenAI (Responses)</li>
    <li>OpenRouter</li>
    <li>DeepSeek</li>
    <li>local servers</li>
    <li>OAuth · Claude Pro/Max</li>
  </ul>
</section>

<!-- Sessions -->
<section class="section" id="sessions">
  <div class="section-label">Sessions</div>
  <h2 class="section-title">Every session is a file you can rewind</h2>
  <p>
    Conversations persist as JSONL under <code>~/.tapir/sessions/</code> and
    reload with context intact. Resume the last one with <code>--continue</code>,
    branch with <code>--fork</code>, or pick any with <code>--session &lt;id&gt;</code>.
    <code>--no-session</code> when you want it ephemeral.
  </p>
  <p>
    Long runs <strong>compact</strong> themselves: as the context nears the model
    window, older turns are summarized and dropped, so <code>--continue</code>
    keeps working. In the TUI, <code>/tree</code> walks the whole history,
    <code>/share</code> and <code>/export</code> get it out, <code>/compact</code>
    trims it by hand.
  </p>
</section>

<!-- Context -->
<section class="section" id="context">
  <div class="section-label">Context</div>
  <h2 class="section-title">You own the context window</h2>
  <p>
    Tapir keeps a minimal system prompt and hands you the levers that decide
    what goes into the window.
  </p>
  <p>
    <strong>AGENTS.md / CLAUDE.md:</strong> project instructions from the
    current directory and its ancestors, injected at startup (disable with
    <code>--no-context-files</code>).
  </p>
  <p>
    <strong>Compaction:</strong> automatic, structured summaries of older turns.
    Tune the reserve and keep windows with <code>TAPIR_COMPACT_RESERVE</code> and
    <code>TAPIR_COMPACT_KEEP</code>.
  </p>
  <p>
    <strong>Skills:</strong> drop a <code>SKILL.md</code> in
    <code>~/.tapir/skills/&lt;name&gt;/</code>; Tapir surfaces it and loads it on
    demand when the task matches.
  </p>
  <p>
    <strong>Prompt templates:</strong> Markdown files become <code>/name</code>
    commands with <code>$1</code>, <code>$@</code> and <code>$ARGUMENTS</code>
    substitution.
  </p>
</section>

<!-- Extensibility -->
<section class="section" id="extend">
  <div class="section-label">Extensibility</div>
  <h2 class="section-title">New tricks without a recompile</h2>
  <p>
    Built-in tools — <code>read</code>, <code>bash</code>, <code>edit</code>,
    <code>write</code>, plus <code>grep</code>, <code>find</code> and
    <code>ls</code>. Search is native (no <code>rg</code>/<code>fd</code>
    download) and respects <code>.gitignore</code>.
  </p>
  <p>
    <strong>Tool plugins:</strong> any executable in
    <code>~/.tapir/plugins/</code> adds a tool via a tiny protocol —
    <code>describe</code> prints a JSON schema, <code>call</code> reads args on
    stdin. Any language, no recompile.
  </p>
  <p>
    <strong>MCP servers:</strong> configure <code>mcpServers</code> and Tapir
    spawns each over stdio (JSON-RPC), adapting its tools as
    <code>mcp__&lt;server&gt;__&lt;tool&gt;</code>.
  </p>
</section>

<!-- Packages -->
<section class="section" id="packages">
  <div class="section-label">Packages</div>
  <h2 class="section-title">Bundle your setup, ship it anywhere</h2>
  <p>
    Bundle skills, prompts, themes and plugins as a package and install it from
    a git URL, an <code>owner/repo</code>, or a local path:
  </p>
  <div class="install-box">
    <code><span class="prefix">$ </span>tapir install owner/repo
<span class="prefix">$ </span>tapir install {{ config.extra.repo | safe }}</code>
  </div>
  <p>
    Everything is tracked in <code>tapir.toml</code>. List what's installed with
    <code>tapir list</code>, drop one with <code>tapir remove &lt;name&gt;</code>.
  </p>
</section>

<!-- Modes -->
<section class="section" id="modes">
  <div class="section-label">Integration</div>
  <h2 class="section-title">Four ways in</h2>
  <p>
    <strong>Interactive:</strong> the full TUI — streaming output, slash
    commands and themes, rendered inline in your terminal (no alternate screen).
  </p>
  <p>
    <strong>Print:</strong> <code>tapir -p "query"</code> for one-shots and
    scripts.
  </p>
  <p>
    <strong>JSON:</strong> <code>--mode json</code> streams structured events as
    JSONL.
  </p>
  <p>
    <strong>RPC:</strong> a JSON protocol over stdin/stdout to embed Tapir in
    other tools.
  </p>
</section>

<!-- Philosophy -->
<section class="section" id="philosophy">
  <div class="section-label">Philosophy</div>
  <h2 class="section-title">Small core, sharp edges</h2>
  <p>
    Tapir stays small on purpose. Everything past the core is a tool, a skill, a
    plugin or a package you opt into — so it stays something you reach for, not a
    framework you live inside.
  </p>
  <p>
    <strong>Safe by default:</strong> a native permission gate blocks
    catastrophic bash — <code>rm -rf /</code>, fork bombs, <code>mkfs</code>,
    <code>dd</code> to a device — and you extend it with <code>denyBash</code> in
    settings.
  </p>
  <p>
    <strong>Yours to look at:</strong> ships with <code>tapir</code>,
    <code>claude</code>, <code>dark</code> and <code>light</code> themes —
    switch live with <code>/theme</code>.
  </p>
</section>

<!-- Download -->
<section class="section" id="download">
  <div class="section-label">Releases</div>
  <h2 class="section-title">Download &amp; verify</h2>
  <p>
    Every release lives in its own directory, mirror-style. The latest is
    <strong>{{ config.extra.version }}</strong>. Grab a prebuilt binary or build
    from source — then verify it with <code>signify</code> before you run it.
  </p>

  <div class="filelist" role="group" aria-labelledby="filelist-caption">
    <p id="filelist-caption" class="filelist-caption">
      <a href="{{ config.base_url | safe }}/{{ config.extra.version }}/">/{{ config.extra.version }}/</a>
    </p>
    <ul>
      <li>
        <a href="{{ config.base_url | safe }}/{{ config.extra.version }}/ANNOUNCEMENT">ANNOUNCEMENT</a>
        <span>Release notes &amp; changes</span>
      </li>
      <li>
        <a href="{{ config.base_url | safe }}/{{ config.extra.version }}/SHA256">SHA256</a>
        <span>Checksums for every file below</span>
      </li>
      <li>
        <a href="{{ config.base_url | safe }}/{{ config.extra.version }}/SHA256.sig">SHA256.sig</a>
        <span>The checksum list, signed with signify</span>
      </li>
      <li>
        <a href="{{ config.base_url | safe }}/tapir.pub">tapir.pub</a>
        <span>signify public key (verify the signature)</span>
      </li>
      <li>
        <a href="{{ config.base_url | safe }}/{{ config.extra.version }}/tapir-{{ config.extra.version }}.tar.gz">tapir-{{ config.extra.version }}.tar.gz</a>
        <span>Source</span>
      </li>
      <li>
        <a href="{{ config.base_url | safe }}/{{ config.extra.version }}/tapir-{{ config.extra.version }}-x86_64-linux-gnu.tar.gz">tapir-{{ config.extra.version }}-x86_64-linux-gnu.tar.gz</a>
        <span>Linux x86-64 (glibc)</span>
      </li>
      <li>
        <a href="{{ config.base_url | safe }}/{{ config.extra.version }}/tapir-{{ config.extra.version }}-aarch64-linux-gnu.tar.gz">tapir-{{ config.extra.version }}-aarch64-linux-gnu.tar.gz</a>
        <span>Linux ARM64 (glibc)</span>
      </li>
      <li>
        <a href="{{ config.base_url | safe }}/{{ config.extra.version }}/tapir-{{ config.extra.version }}-x86_64-linux-musl.tar.gz">tapir-{{ config.extra.version }}-x86_64-linux-musl.tar.gz</a>
        <span>Linux x86-64 (musl, static)</span>
      </li>
      <li class="soon">
        <span class="badge">Soon</span>
        <span>tapir-{{ config.extra.version }}-x86_64-openbsd.tar.gz — OpenBSD
          x86-64 (once the local QEMU build lands)</span>
      </li>
    </ul>
  </div>

  <p style="margin-top:1.5rem">
    Fetch the public key once, then check the signed checksum list (and every
    file in the directory) against it:
  </p>
  <div class="install-box">
    <code><span class="prefix">$ </span>signify -C -p tapir.pub -x SHA256.sig</code>
    <button class="copy-btn"
            data-copy="signify -C -p tapir.pub -x SHA256.sig">Copy</button>
  </div>
  <p>To check a single artifact, name it explicitly:</p>
  <div class="install-box">
    <code><span class="prefix">$ </span>signify -C -p tapir.pub -x SHA256.sig \
    tapir-{{ config.extra.version }}-x86_64-linux-gnu.tar.gz</code>
  </div>
</section>

<!-- Contribute -->
<section class="section" id="contribute">
  <div class="section-label">Contributing</div>
  <h2 class="section-title">Send patches by email</h2>
  <p>
    Tapir takes contributions the old, durable way: <code>git send-email</code>.
    No account, no pull request — just a patch in your maintainer's inbox.
    Patches go to <a href="mailto:{{ config.extra.email }}">{{ config.extra.email }}</a>.
  </p>
  <p>Point send-email at the maintainer once for this repo, then send:</p>
  <div class="install-box">
    <code><span class="prefix">$ </span>git config sendemail.to "{{ config.extra.email }}"
<span class="prefix">$ </span>git send-email HEAD^          <span class="prefix"># last commit</span>
<span class="prefix">$ </span>git send-email origin/main..   <span class="prefix"># a series</span></code>
  </div>
  <p>
    Reply to feedback with a new revision via <code>git send-email -v2</code>.
    New to this flow?
    <a href="https://git-send-email.io/" rel="noopener">git-send-email.io</a>
    walks through the one-time setup.
  </p>
</section>
{% endblock content %}