atgc v0.15.0

atgc

agentic is in our dna

A terminal client for Tangled, a git forge with no database behind it. Your repos, pull requests and issues are records in your own PDS — you can read them, move them, and take them with you.

$ cargo install --git https://tangled.org/permadeath.com/atgc Not on crates.io yet. Needs Rust 1.89 or newer and git.

What is this?

Every forge you have used keeps your work in its own database, and lends it back to you through its API. Tangled does not have one.

aRecords, not rows

A pull request, an issue, a comment, a repo: each is an atproto record, signed by the account that wrote it and served from that account's PDS. atgc reads and writes them directly.

tYours the moment you write it

Your pull request is readable the instant you write it, whatever any index thinks. When a service is out, atgc says the index is out — not that the forge is down.

gNothing in the middle

atgc talks to your PDS, to Tangled's appview, and to the knot holding the git data. There is no atgc server in the middle, and this page is not one either: nothing the tool does depends on it being up.

cA terminal citizen

It is a CLI and it means it. Output goes to stdout, notes and errors to stderr, --json where a machine is reading, and an exit status that says which kind of no.

The terminal is the product

Not a screenshot. This page was built by the binary, and it asked the same drawing code atgc about uses to draw this — field, panel, version and all.

atgc about
----------A        A---T        G=============C        C===G        T-------------A
------------T        G===C        C=============G        T---A        A-------------T
  C=========G       C=========G       A---------T       A---------T       C=========G
        G==C         A------------T         T--A         C============G         G==C
=C        A---T        T-------------A        C===G        G=============C        A---T
-A       T---------A       G=========C       G=========C       T---------A       T------
T        G=============C        C===G        T-------------A        A---T        G======
==C         C============G         T--A         A------------T         G==C         C===
========  ╭─ atgc ───────────────────────────────────────────────────────────╮  G
--------  │                                                                  │  ----T
T-------  │  ATproto Git Client. A CLI for Tangled repos and pull requests.  │  ------A
    G===  │                                                                  │  ======C
C         │  version   0.15.0                                                │    C==G
==G       │  repo      https://tangled.org/permadeath.com/atgc               │      T--A
---T      │                                                                  │     A----
--A       ╰──────────────────────────────────────────────────────────────────╯     C====
C===G        G=============C        A---T        T-------------A        C===G        G==
=========C       T---------A       T---------A       G=========C       G=========C
T------------A         A--T         G============C         C==G         T------------A
  A-------------T        G===C        C=============G        T---A        A-------------
      C=========G       C=========G       A---------T       A---------T       C=========
==G        G===C        A-------------T        T---A        C=============G        G===C
====C         A--T         T------------A         C==G         G============C         A-
-----A       T---------A       G=========C       G=========C       T---------A       T--
A---T        G=============C        C===G        T-------------A        A---T        G==

Features, in base pairs

Read across the rungs: each pair is one fact and its consequence.

aA pull request is a record

It lives in your PDS and carries the patch itself, so filing one needs no permission on the repo.

tSo pushing never updates one

atgc pr resubmit appends a new round after an amend or a rebase. That is the habit to unlearn.

gStack them

atgc stack create chains pulls that must land bottom-up, each reviewed on its own.

cAnd reconcile after a rebase

atgc stack resubmit matches the stack up by change-id, however the branch was rewritten.

aLog in with scoped OAuth

No app passwords. atgc auth login opens a browser and gets back a token bound to this machine.

tBe several people at once

Accounts switch per worktree, so parallel agents each commit and file as themselves.

gPut pictures in a pull

A local image path in a body is uploaded as a blob on the way out — a before and after, not a link to one.

cFind anything anyone wrote

atgc search reads Tangled's full-text index of every record on the firehose, logged out.

Quickstart

Four commands from nothing to a pull request.

  1. $ cargo install --git https://tangled.org/permadeath.com/atgc

    Rust 1.89 or newer, and git. Not on crates.io yet.

  2. $ atgc auth login you.bsky.social

    Any atproto account, on any PDS. A browser opens; a token comes back.

  3. $ atgc repo clone permadeath.com/atgc

    Clones it and writes the ATproto identity into the checkout's own git config.

  4. $ atgc pr create

    Pushes the branch and files the pull request.

Made for agents

atgc is built for a dozen worktrees running at once, which is also how it is written.

aA briefing, from the binary

atgc agent prints a short briefing on what Tangled does differently from the forges an agent already knows. Compiled in, so it always describes the version that printed it.

tMachine-readable throughout

--json on every listing, --no-input to refuse a prompt rather than block on one, and an exit status per kind of failure.

gOne identity per worktree

Credentials switch per worktree, so several agents can hold several identities on one machine without stepping on each other.

cAn audit trail

Every OAuth, PDS and git operation is logged locally, and atgc report bug files an issue from inside the run that went wrong.

Say something

All of it in the open, on atproto, where you can reply with your own account.