Something went wrong. Try again.
A collaborative coding-agent orchestrator for atproto radl.app
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288import { FIXTURE_DIDS } from '@radial/core/fixture'import { describe, expect, it } from 'vitest'import { buildFixtureSpace } from './fixture.js'import { DOC_TYPE_DRAFTS, ROADMAP_DOC_TYPE, USER_DOC_TYPE, docDrift, docGroups, docPostArgs, docTier, docTitle, docsHref, docsOf, driftBadges, editRequestArgs, hasDrifted, headMoved, isEditable, missingDocTypes, repinnedSources, resumableEdit, roadmapSections, tierFromParam,} from './docs.js'import { projectByName, unitsOf } from './space.js'import { artifactTypes, type UnitView } from '@radial/core'
// The docs route's whole knowledge of what a tier is, tested against the fixture rather than against// invented records — the same rule the request tests follow, for the same reason: no answer here may// come from a type NAME being special, only from what the registry says.const space = buildFixtureSpace()
const project = () => { const found = projectByName(space.index, 'radial-ng') if (!found) throw new Error('fixture project missing') return found}
const doc = (title: string): UnitView => { const found = unitsOf(space.index, project()).find((unit) => docTitle(unit) === title) if (!found) throw new Error(`fixture doc missing: ${title}`) return found}
describe('tiers', () => { it('is two registry entries and everything else', () => { // The design decision, as an assertion: the tiers are registry data, so the fixture's registry // is what puts a unit in one — nothing in the app carries a list of document names. const registry = artifactTypes(space.index) expect(registry.get(USER_DOC_TYPE)?.scope).toBe('project') expect(registry.get(ROADMAP_DOC_TYPE)?.durability).toBe('living') expect(missingDocTypes(space.index)).toEqual([]) })
it('splits a project’s units into dev, user and roadmap', () => { const tiers = docsOf(space.index, project()) expect(new Set(tiers.dev.map((unit) => unit.type))).toEqual( new Set(['adr', 'architecture', 'conventions']), ) expect(tiers.user.map(docTitle)).toEqual(['Artifact types', 'Review queue']) expect(tiers.roadmap.map(docTitle)).toEqual(['Ingestion']) })
it('puts an unknown project-scoped type in the dev tier, with no code change', () => { // A type an admin registers tomorrow. It is a dev doc because it is not one of the two, which is // the only rule there is — nothing has to learn its name. expect(docTier({ type: 'fdr' })).toBe('dev') expect(docTier({ type: USER_DOC_TYPE })).toBe('user') expect(isEditable('dev')).toBe(false) expect(isEditable('roadmap')).toBe(true) })
it('groups a tier by the kind of document, alphabetically and with nothing hard-coded', () => { const tiers = docsOf(space.index, project()) const dev = docGroups(tiers.dev) expect(dev.map((group) => group.type)).toEqual(['adr', 'architecture', 'conventions']) // The label is `typeLabel`'s, so an acronym is spoken as one and everything else is shown as the // registry spells it. Nothing here knows which names exist. expect(dev.map((group) => group.label)).toEqual(['ADR', 'architecture', 'conventions']) // Every page still appears exactly once, and a group keeps the reading order `docsOf` sorted. const byName = (left: string, right: string) => left.localeCompare(right) expect([...dev.flatMap((group) => group.units.map(docTitle))].sort(byName)).toEqual( [...tiers.dev.map(docTitle)].sort(byName), ) for (const group of dev) { const titles = group.units.map(docTitle) expect(titles).toEqual([...titles].sort(byName)) } // An editable tier IS one registry type, so it has exactly one group — which is why the page // draws the disclosures only where there is more than one. expect(docGroups(tiers.user).map((group) => group.type)).toEqual([USER_DOC_TYPE]) expect(docGroups([])).toEqual([]) })
it('reads the tier out of the URL and puts it back', () => { expect(tierFromParam(null)).toBe('dev') expect(tierFromParam('nonsense')).toBe('dev') expect(tierFromParam('roadmap')).toBe('roadmap') const href = docsHref(project(), 'user', doc('Review queue')) expect(href).toContain('tier=user') expect(href).toContain(`doc=${encodeURIComponent(doc('Review queue').key)}`) // The default tier is not spelled out: a docs link a person pastes should be the short one. expect(docsHref(project(), 'dev')).not.toContain('tier=') })})
describe('the two drift signals', () => { it('reports a moved source, and reports it as a source rather than as a merge', () => { // "Review queue" documents the architecture at v1 and the architecture is at v3. Nothing has // merged under the project since the page landed, so the other signal is silent — which is the // point: source drift is a thing a quiet repository can still accumulate. const drift = docDrift(space.index, project(), doc('Review queue')) expect(drift.sources.map((entry) => entry.behind)).toEqual([2]) expect(drift.merges).toBe(0) expect(hasDrifted(drift)).toBe(true) expect(driftBadges(drift).map((badge) => badge.text)).toEqual(['1 source moved on']) })
it('badges the two signals separately and never adds them together', () => { // They answer different questions — "the sources moved" and "the code moved" — and a reader // acts on each differently, so a single summed number would be the app inventing a fact. const [sources] = docDrift(space.index, project(), doc('Review queue')).sources if (!sources) throw new Error('fixture doc is not drifted') const badges = driftBadges({ merges: 3, sources: [sources] }) expect(badges.map((badge) => badge.text)).toEqual(['1 source moved on', '3 merges since']) expect(badges.map((badge) => badge.text).join(' ')).not.toContain('4') })
it('counts merge drift on a dev doc, where nothing else can have drifted', () => { const architecture = docsOf(space.index, project()).dev.find( (unit) => unit.type === 'architecture', ) if (!architecture) throw new Error('fixture project has no architecture doc') const drift = docDrift(space.index, project(), architecture) expect(drift.merges).toBe(3) expect(driftBadges(drift).map((badge) => badge.text)).toEqual(['3 merges since']) })
it('says nothing about sources for a page pinned at every head', () => { const drift = docDrift(space.index, project(), doc('Artifact types')) expect(drift.sources).toEqual([]) expect(driftBadges(drift).some((badge) => badge.text.includes('source'))).toBe(false) })
it('never claims a dev doc has drifted from a source: it IS the source', () => { const architecture = docsOf(space.index, project()).dev.find( (unit) => unit.type === 'architecture', ) expect(architecture).toBeDefined() expect(docDrift(space.index, project(), architecture as UnitView).sources).toEqual([]) })})
describe('the roadmap tier', () => { it('derives the road ahead and the road travelled from live goal state', () => { const sections = roadmapSections(space.index, doc('Ingestion')) expect(sections.ahead.map((entry) => entry.goal.target.value.title)).toEqual([ 'Jetstream subscription with polling fallback', ]) expect(sections.travelled.map((entry) => entry.goal.disposition)).toEqual([ 'completed', 'dropped', ]) // "here's where we got web push" — the merged implementations under an ended goal, derived // rather than authored, which is what the roadmap tier exists to show. expect(sections.travelled[0]?.landed.length).toBeGreaterThan(0) })
it('ignores refs that are not goals, so an artifact ref on a roadmap is provenance only', () => { const named = doc('Ingestion').current?.request?.value.basedOn.length ?? 0 const sections = roadmapSections(space.index, doc('Ingestion')) expect(named).toBe(4) expect(sections.ahead.length + sections.travelled.length).toBe(3) })})
describe('writing a doc', () => { const did = FIXTURE_DIDS.tim
it('always assigns an edit request to its own author', () => { // The load-bearing one. An unassigned open request is claimable by any operator's daemon, so a // half-written page must never look open — `dispatch.ts` refuses a request named to a person. const args = editRequestArgs({ project: project(), type: USER_DOC_TYPE, did, sources: [], }) expect(args.slice(0, 6)).toEqual([ 'request', 'create', '--project', project().target.uri, '--type', USER_DOC_TYPE, ]) expect(args).toContain('--assignee') expect(args[args.indexOf('--assignee') + 1]).toBe(did) })
it('pins the predecessor first, then every source, so the edit continues the chain', () => { const unit = doc('Review queue') const previous = unit.current if (!previous) throw new Error('fixture doc has no version') const sources = repinnedSources(space.index, unit) const args = editRequestArgs({ project: project(), type: USER_DOC_TYPE, did, prev: previous, sources, }) const based = args.flatMap((value, position) => value === '--based-on' ? [args[position + 1] as string] : [], ) expect(based[0]).toBe(`${previous.artifact.uri}#${previous.artifact.cid}`) expect(based).toHaveLength(1 + sources.length) })
it('re-pins a drifted source to the current head — that is what clears the badge', () => { const unit = doc('Review queue') const drifted = docDrift(space.index, project(), unit).sources[0] if (!drifted) throw new Error('fixture doc is not drifted') const repinned = repinnedSources(space.index, unit) expect(repinned).toContainEqual({ uri: drifted.current.artifact.uri, cid: drifted.current.artifact.cid, }) expect(repinned.map((reference) => reference.uri)).not.toContain(drifted.ref.uri) // A source that had not moved is carried through untouched, at the version it was read at. expect(repinned).toHaveLength(unit.current?.request?.value.basedOn.length ?? 0) // And the page's own predecessor is never in the list: it is pinned as `prev`, not as a source. for (const version of unit.versions) { expect(repinned.map((reference) => reference.uri)).not.toContain(version.artifact.uri) } })
it('posts the artifact with the title, the body and the version it supersedes', () => { const unit = doc('Review queue') const previous = unit.current if (!previous) throw new Error('fixture doc has no version') const args = docPostArgs({ request: { uri: 'at://did:plc:x/com.disnetdev.radial.artifactRequest/1', cid: 'cid-1' }, title: ' Review queue ', body: '# Body', prev: previous, }) expect(args).toEqual([ 'artifact', 'post', '--request', 'at://did:plc:x/com.disnetdev.radial.artifactRequest/1#cid-1', '--prev', `${previous.artifact.uri}#${previous.artifact.cid}`, '--title', 'Review queue', '--body', '# Body', ]) })
it('offers to resume an edit whose artifact never landed, and only to its own author', () => { // Nothing in the fixture is half-written, which is the state this predicate must not invent. expect(resumableEdit(space.index, project(), did)).toEqual([]) expect(resumableEdit(space.index, project(), '')).toEqual([]) })
it('notices the head moving under an open form without refusing the save', () => { const unit = doc('Review queue') expect(headMoved(unit, unit.current?.artifact.uri)).toBe(false) expect(headMoved(unit, 'at://did:plc:x/com.disnetdev.radial.artifact/older')).toBe(true) // Nothing to compare against — a new page — is not a fork. expect(headMoved(unit, undefined)).toBe(false) })})
describe('setting the tiers up', () => { it('offers the two registry drafts a space needs, briefed for an agent', () => { expect(DOC_TYPE_DRAFTS.map((draft) => draft.name)).toEqual([USER_DOC_TYPE, ROADMAP_DOC_TYPE]) for (const draft of DOC_TYPE_DRAFTS) { expect(draft.scope).toBe('project') expect(draft.durability).toBe('living') expect(draft.brief.length).toBeGreaterThan(80) } })})