mikser-io-git 2.1.0 → 2.3.0

package/lib/sync.js

@@ -13,6 +13,7 @@
 //     stays queued on the write branch until a human intervenes.
 
 import * as git from './git.js'
+import { changeSetTrailers } from './changeset-commit.js'
 import * as github from './forge/github.js'
 import * as gitea from './forge/gitea.js'
 
@@ -38,10 +39,42 @@ const ADAPTERS = { github, gitea }
 // returning a string — a count rather than a file list, since a full
 // list of paths in a commit message gets unwieldy past a handful of
 // files and git status is cheap to re-derive if anyone needs detail.
-export async function commitAndPushWriteBranch(folder, { paths, writeBranch, message, author, token }) {
+export async function commitAndPushWriteBranch(
+    folder, { paths, writeBranch, message, author, token, changeSets = [], onCommitted },
+) {
     const porcelain = await git.statusPorcelain(folder, paths)
     if (!porcelain) return { committed: false, pushed: false }
-    const fileCount = porcelain.split('\n').filter(Boolean).length
+
+    let committedAny = false
+
+    // Claimed writes first, each set its own commit staged to exactly the
+    // paths that set wrote.
+    //
+    // Staging by FOLDER instead would sweep in whatever else happened to be
+    // dirty — a document created through the API a second earlier lands in the
+    // agent's commit, and undoing the agent then deletes that document. The
+    // commit's contents have to match its label, or the label is a lie that
+    // only shows up at undo time.
+    for (const set of changeSets) {
+        const scoped = withinPaths(set.paths, paths)
+        if (!scoped.length) continue
+        await git.addPaths(folder, scoped)
+        if (!(await git.hasStagedChanges(folder, scoped))) continue
+        await git.commit(folder, changeSetMessage(set, scoped), { author })
+        committedAny = true
+        onCommitted?.(set.id)
+    }
+
+    // Then everything still dirty and unclaimed: API writes, human edits, a
+    // set whose attribution was lost to a crash. Unattributed and therefore
+    // not undoable, but never dropped.
+    const remaining = await git.statusPorcelain(folder, paths)
+    if (!remaining) {
+        return committedAny
+            ? { committed: true, pushed: await pushWriteBranch(folder, { writeBranch, token }) }
+            : { committed: false, pushed: false }
+    }
+    const fileCount = remaining.split('\n').filter(Boolean).length
 
     await git.addAll(folder, paths)
     if (!(await git.hasStagedChanges(folder, paths))) {
@@ -49,14 +82,36 @@ export async function commitAndPushWriteBranch(folder, { paths, writeBranch, mes
         // end up staging as a diff from HEAD in edge cases (e.g. a
         // file that matches .gitignore was force-added) — defensive,
         // should not normally happen.
-        return { committed: false, pushed: false }
+        return committedAny
+            ? { committed: true, pushed: await pushWriteBranch(folder, { writeBranch, token }) }
+            : { committed: false, pushed: false }
     }
     const resolvedMessage = typeof message === 'function' ? message({ fileCount }) : message
     await git.commit(folder, resolvedMessage, { author })
 
+    return { committed: true, pushed: await pushWriteBranch(folder, { writeBranch, token }) }
+}
+
+// Only the paths this instance is scoped to. A change set can span
+// collections this git instance does not manage; those stay for whichever
+// instance does own them, rather than being committed here.
+function withinPaths(candidates, paths) {
+    if (!paths?.length) return candidates
+    return candidates.filter(rel => paths.some(p => rel === p || rel.startsWith(`${p.replace(/\/$/, '')}/`)))
+}
+
+// Subject is the caller's own summary, so `git log --oneline` reads as a list
+// of what was asked for. Trailers carry the machine-readable half.
+function changeSetMessage(set, scoped) {
+    const subject = set.summary?.trim().split('\n')[0]
+        || `content: ${scoped.length} file(s) via mikser`
+    return `${subject}\n\n${changeSetTrailers(set)}`
+}
+
+async function pushWriteBranch(folder, { writeBranch, token }) {
     try {
         await git.push(folder, writeBranch, { token })
-        return { committed: true, pushed: true }
+        return true
     } catch (err) {
         if (!git.isNonFastForwardError(err)) throw err
         // The remote write branch moved (an inbound pull landed
@@ -69,7 +124,7 @@ export async function commitAndPushWriteBranch(folder, { paths, writeBranch, mes
         await git.fetch(folder, { token })
         await git.run(folder, ['rebase', `origin/${writeBranch}`])
         await git.push(folder, writeBranch, { token })
-        return { committed: true, pushed: true }
+        return true
     }
 }
 

package/lib/undo.js

@@ -0,0 +1,147 @@
+// Remove one change set's contribution from the current state.
+//
+// Not "restore a previous state". The site has moved on — documents were added
+// through the API, a human edited something — and the request is to take back
+// ONE change while keeping everything that came after. That is a merge-shaped
+// operation, which is exactly what `git revert` is for and exactly what a
+// snapshot restore is not.
+//
+// Git handles the textual half. It cannot handle the other half: a document
+// added after the change set may DEPEND on what the change set created, so a
+// revert that applies with no conflict at all can still leave the site
+// referencing a layout that no longer exists. Git reports success; the site is
+// broken. That check needs the reference graph, so it happens here.
+
+import { findEntities, lookupKeys } from 'mikser-io'
+
+import * as git from './git.js'
+import { parseChangeSetLog } from './changeset-commit.js'
+
+// Change sets in the branch's history, newest first.
+export async function listChangeSets(folder, { branch, limit = 20 } = {}) {
+    const raw = await git.logChangeSets(folder, { branch, limit: limit * 3 })
+    return parseChangeSetLog(raw).sort((a, b) => b.at - a.at).slice(0, limit)
+}
+
+export async function findChangeSet(folder, id, { branch } = {}) {
+    const raw = await git.logChangeSets(folder, { branch, limit: 500, id })
+    return parseChangeSetLog(raw).find(set => set.id === id) ?? null
+}
+
+// The reverse patch for a whole set: every commit undone, newest first.
+//
+// Newest-first because the commits stack — undoing the oldest edit to a file
+// before the newest one would be applying a patch to content that has moved
+// on since.
+export async function reversePatchFor(folder, set) {
+    const parts = []
+    for (const sha of [...set.commits].reverse()) {
+        const patch = await git.reversePatch(folder, sha)
+        if (patch?.trim()) parts.push(patch)
+    }
+    return parts.join('\n')
+}
+
+// Paths the undo would touch, and which of them it would REMOVE.
+//
+// A removal is where the danger is: reverting a create deletes a file, and
+// anything that came to depend on it since is what breaks.
+export function pathsInPatch(patch) {
+    const touched = new Set()
+    const deleted = new Set()
+    let current = null
+    for (const line of String(patch ?? '').split('\n')) {
+        const m = /^diff --git a\/(.+?) b\/(.+)$/.exec(line)
+        if (m) { current = m[2]; touched.add(current); continue }
+        // In a REVERSE patch, "new file mode" means the forward commit
+        // deleted it and undoing restores it; "deleted file mode" means the
+        // forward commit created it and undoing removes it.
+        if (line.startsWith('deleted file mode') && current) deleted.add(current)
+    }
+    return { touched: [...touched], deleted: [...deleted] }
+}
+
+// What would still point at the things this undo removes.
+//
+// Uses the engine's own inverse reference index rather than a text search, so
+// it sees a `$`-ref exactly the way invalidation does — and asks about every
+// key the entity can be referenced BY (`lookupKeys`), not just its id, since
+// content refers to served paths far more often than to catalog ids.
+//
+// Referrers belonging to the change set itself are excluded: undoing a
+// document together with the layout only it used is coherent, and counting
+// that as breakage would make every complete undo look dangerous.
+export async function danglingAfterUndo({ runtime, deletedPaths, setPaths }) {
+    const refs = runtime?.refs
+    const workingFolder = runtime?.options?.workingFolder
+    if (!refs?.inboundFor || !workingFolder || !deletedPaths.length) return []
+
+    const own = new Set(setPaths)
+    const relOf = (uri) => (uri && uri.startsWith(`${workingFolder}/`)
+        ? uri.slice(workingFolder.length + 1)
+        : null)
+
+    const broken = []
+    for (const rel of deletedPaths) {
+        const [entity] = await findEntities({ uri: `${workingFolder}/${rel}` }) ?? []
+        if (!entity) continue
+
+        const referrers = new Map()
+        for (const key of [entity.id, ...(lookupKeys(entity) ?? [])]) {
+            if (!key) continue
+            let inbound = []
+            try { inbound = refs.inboundFor(key) ?? [] } catch { continue }
+            for (const ref of inbound) {
+                if (!ref?.id || ref.id === entity.id) continue
+                referrers.set(ref.id, ref.field ?? null)
+            }
+        }
+
+        const outside = []
+        for (const [sourceId, field] of referrers) {
+            const [source] = await findEntities({ id: sourceId }) ?? []
+            const sourceRel = relOf(source?.uri)
+            if (sourceRel && own.has(sourceRel)) continue
+            outside.push({ id: sourceId, ...(field ? { field } : {}) })
+        }
+        if (outside.length) broken.push({ removes: rel, id: entity.id, referencedBy: outside })
+    }
+    return broken
+}
+
+// Everything a caller needs to decide, computed without touching the tree.
+export async function previewUndo(folder, { id, branch, runtime } = {}) {
+    const set = await findChangeSet(folder, id, { branch })
+    if (!set) {
+        return { ok: false, refused: 'unknown-change-set',
+                 error: `No change set ${id} in this branch's history.` }
+    }
+    const patch = await reversePatchFor(folder, set)
+    if (!patch.trim()) {
+        return { ok: false, refused: 'nothing-to-undo', set,
+                 error: 'That change set left nothing to reverse.' }
+    }
+    const { touched, deleted } = pathsInPatch(patch)
+    const applies = await git.patchApplies(folder, patch)
+    const dangling = await danglingAfterUndo({ runtime, deletedPaths: deleted, setPaths: touched })
+
+    return {
+        ok: true,
+        set: { id: set.id, summary: set.summary, at: set.at, principal: set.principal, commits: set.commits.length },
+        touched,
+        removes: deleted,
+        applies,
+        dangling,
+        patch,
+        // Two independent reasons to stop, reported separately because the
+        // answers differ: a conflict means "not automatically", dangling refs
+        // mean "this will break something that arrived later".
+        ...(applies ? {} : {
+            conflict: 'A later change edited the same content, so this undo cannot be applied automatically.',
+        }),
+        ...(dangling.length ? {
+            warning: `Undoing this removes ${dangling.length} entit${dangling.length === 1 ? 'y' : 'ies'} that `
+                + 'something added since still references.',
+        } : {}),
+    }
+}

package/package.json

@@ -1,8 +1,14 @@
 {
   "name": "mikser-io-git",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "Two-way git sync for mikser-io. The working folder itself is the checkout, on a dedicated `mikser` branch (durable write log for API/MCP/agent edits). `paths` (optional) scopes auto-commits to specific collection folders (documents, layouts, files, ...) as a hard pathspec; omit it and the whole working folder is committed, subject to .gitignore. Every green cycle commits + pushes whatever's in scope and attempts to merge into the target branch (`main`) via a pull request; a red cycle (any render/postprocess failure) holds the merge and leaves the PR open for a human to resolve. Inbound changes on the target branch merge back into the working copy via poll. Forge-portable: GitHub and Gitea adapters, plus a no-forge fast-forward-only floor for any bare remote.",
   "main": "index.js",
+  "files": [
+    "index.js",
+    "lib",
+    "README.md",
+    "LICENSE"
+  ],
   "type": "module",
   "scripts": {
     "test": "node --no-warnings --test --test-reporter=spec 'test/**/*.test.js'"
@@ -18,6 +24,7 @@
   },
   "homepage": "https://github.com/almero-digital-marketing/mikser-io-git#readme",
   "peerDependencies": {
-    "mikser-io": "^9.0.0"
+    "mikser-io": "^9.44.0",
+    "zod": "^4.0.0"
   }
 }

package/test/bootstrap.test.js

@@ -1,59 +0,0 @@
-// decideBootstrap is pure — plain facts in, a decision out — so every
-// folder-state combination is directly testable without touching a
-// filesystem or a git binary.
-
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { decideBootstrap } from '../lib/bootstrap.js'
-
-const EXPECTED = 'https://github.com/org/content.git'
-
-describe('decideBootstrap', () => {
-    it('clones into a folder that does not exist yet', () => {
-        const d = decideBootstrap({ folderExists: false, folderEmpty: true, isRepo: false, remoteUrl: null, expectedUrl: EXPECTED })
-        assert.equal(d.action, 'clone')
-    })
-
-    it('clones into an existing empty folder', () => {
-        const d = decideBootstrap({ folderExists: true, folderEmpty: true, isRepo: false, remoteUrl: null, expectedUrl: EXPECTED })
-        assert.equal(d.action, 'clone')
-    })
-
-    it('refuses a non-empty folder that is not a git repo — the destructive case', () => {
-        const d = decideBootstrap({ folderExists: true, folderEmpty: false, isRepo: false, remoteUrl: null, expectedUrl: EXPECTED })
-        assert.equal(d.action, 'refuse')
-        assert.match(d.reason, /not a git repository/i)
-        assert.match(d.reason, /git init/)   // the manual recipe must be in the message
-    })
-
-    it('verifies an existing checkout whose remote matches', () => {
-        const d = decideBootstrap({ folderExists: true, folderEmpty: false, isRepo: true, remoteUrl: EXPECTED, expectedUrl: EXPECTED })
-        assert.equal(d.action, 'verify')
-    })
-
-    it('verify tolerates a trailing-slash / missing .git cosmetic difference', () => {
-        const d = decideBootstrap({
-            folderExists: true, folderEmpty: false, isRepo: true,
-            remoteUrl: 'https://github.com/org/content',   // no .git suffix
-            expectedUrl: EXPECTED,                          // has .git suffix
-        })
-        assert.equal(d.action, 'verify')
-    })
-
-    it('refuses an existing repo with no origin remote at all', () => {
-        const d = decideBootstrap({ folderExists: true, folderEmpty: false, isRepo: true, remoteUrl: null, expectedUrl: EXPECTED })
-        assert.equal(d.action, 'refuse')
-        assert.match(d.reason, /no "origin" remote/i)
-    })
-
-    it('refuses an existing repo whose remote points somewhere else', () => {
-        const d = decideBootstrap({
-            folderExists: true, folderEmpty: false, isRepo: true,
-            remoteUrl: 'https://github.com/someone-else/other-repo.git',
-            expectedUrl: EXPECTED,
-        })
-        assert.equal(d.action, 'refuse')
-        assert.match(d.reason, /does not match the configured repo/i)
-    })
-})

package/test/config.test.js

@@ -1,101 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { resolveConfig } from '../lib/config.js'
-
-describe('resolveConfig', () => {
-    it('requires url', () => {
-        assert.throws(() => resolveConfig({}), /`url` is required/)
-    })
-
-    it('rejects an unknown forge', () => {
-        assert.throws(
-            () => resolveConfig({ url: 'https://github.com/org/repo.git', forge: 'bitbucket' }),
-            /must be "github", "gitea", or "none"/,
-        )
-    })
-
-    it('rejects an empty paths array', () => {
-        assert.throws(
-            () => resolveConfig({ url: 'https://example.com/org/repo.git', paths: [] }),
-            /`paths` must be a non-empty/,
-        )
-    })
-
-    it('normalizes a single path string to a one-element array', () => {
-        const cfg = resolveConfig({ url: 'https://example.com/org/repo.git', paths: 'layouts' })
-        assert.deepEqual(cfg.paths, ['layouts'])
-    })
-
-    it('accepts an array of paths for multiple collections sharing one checkout', () => {
-        const cfg = resolveConfig({ url: 'https://example.com/org/repo.git', paths: ['documents', 'layouts', 'files'] })
-        assert.deepEqual(cfg.paths, ['documents', 'layouts', 'files'])
-    })
-
-    it('omitting paths means "no scope" — the whole working folder, not a narrower default', () => {
-        // Deliberately distinct from '[\'documents\']': the zero-config
-        // case should match the model's own framing ("the working
-        // folder is the checkout"), not silently narrow to one
-        // collection nobody asked for.
-        const cfg = resolveConfig({ url: 'https://example.com/org/repo.git' })
-        assert.equal(cfg.paths, null)
-    })
-
-    it('applies sane defaults for a minimal forge:none config', () => {
-        const cfg = resolveConfig({ url: 'https://example.com/org/repo.git' })
-        assert.equal(cfg.forge, 'none')
-        assert.equal(cfg.paths, null)
-        assert.equal(cfg.targetBranch, 'main')
-        assert.equal(cfg.writeBranch, 'mikser')
-        assert.equal(cfg.afterMs, 60_000)
-        assert.equal(cfg.maxWaitMs, 600_000)
-        assert.equal(cfg.pollIntervalMs, 300_000)
-        // forge:none never needs owner/repo/apiBase — no API involved.
-        assert.equal(cfg.owner, undefined)
-        assert.equal(cfg.repo, undefined)
-        assert.equal(cfg.apiBase, undefined)
-    })
-
-    it('derives owner/repo/apiBase from the url when forge is github', () => {
-        const cfg = resolveConfig({ url: 'https://github.com/almero-digital-marketing/gpoint-content.git', forge: 'github', token: 'x' })
-        assert.equal(cfg.owner, 'almero-digital-marketing')
-        assert.equal(cfg.repo, 'gpoint-content')
-        assert.equal(cfg.apiBase, 'https://api.github.com')
-    })
-
-    it('derives owner/repo/apiBase from the url when forge is gitea', () => {
-        const cfg = resolveConfig({ url: 'https://git.almero.bg/org/content.git', forge: 'gitea', token: 'x' })
-        assert.equal(cfg.owner, 'org')
-        assert.equal(cfg.repo, 'content')
-        assert.equal(cfg.apiBase, 'https://git.almero.bg')
-    })
-
-    it('explicit owner/repo/apiBase override the url-derived values', () => {
-        const cfg = resolveConfig({
-            url: 'https://github.com/org/repo.git', forge: 'github', token: 'x',
-            owner: 'other-org', repo: 'other-repo', apiBase: 'https://ghe.example.com/api/v3',
-        })
-        assert.equal(cfg.owner, 'other-org')
-        assert.equal(cfg.repo, 'other-repo')
-        assert.equal(cfg.apiBase, 'https://ghe.example.com/api/v3')
-    })
-
-    it('respects custom branch names, paths, and durations', () => {
-        const cfg = resolveConfig({
-            url: 'https://example.com/org/repo.git',
-            branch: 'live', writeBranch: 'agents', paths: ['content'],
-            after: '30s', maxWait: '5m', pollInterval: '1m',
-        })
-        assert.equal(cfg.targetBranch, 'live')
-        assert.equal(cfg.writeBranch, 'agents')
-        assert.deepEqual(cfg.paths, ['content'])
-        assert.equal(cfg.afterMs, 30_000)
-        assert.equal(cfg.maxWaitMs, 300_000)
-        assert.equal(cfg.pollIntervalMs, 60_000)
-    })
-
-    it('the default message builder includes the file count', () => {
-        const cfg = resolveConfig({ url: 'https://example.com/org/repo.git' })
-        assert.equal(cfg.message({ fileCount: 3 }), 'content: 3 file(s) via mikser')
-    })
-})

package/test/debounce.test.js

@@ -1,57 +0,0 @@
-// reduceDebounce is pure — feed a sequence of green/red events with
-// explicit timestamps, assert the resulting fireAt. Covers both halves
-// of the design: the short debounce after a green cycle, and the
-// maxWait ceiling that keeps a steady stream of green cycles from
-// starving the sync forever.
-
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { reduceDebounce, IDLE_DEBOUNCE_STATE } from '../lib/debounce.js'
-
-const CFG = { afterMs: 60_000, maxWaitMs: 600_000 }   // 1m / 10m, matches the plugin's defaults
-
-describe('reduceDebounce', () => {
-    it('a single green event fires after `after`', () => {
-        const s = reduceDebounce(IDLE_DEBOUNCE_STATE, { type: 'green', now: 1000 }, CFG)
-        assert.equal(s.pendingSince, 1000)
-        assert.equal(s.fireAt, 1000 + CFG.afterMs)
-    })
-
-    it('a red event clears the window outright', () => {
-        const afterGreen = reduceDebounce(IDLE_DEBOUNCE_STATE, { type: 'green', now: 1000 }, CFG)
-        const afterRed = reduceDebounce(afterGreen, { type: 'red', now: 2000 }, CFG)
-        assert.deepEqual(afterRed, IDLE_DEBOUNCE_STATE)
-    })
-
-    it('a later green event pushes fireAt out again (trailing debounce)', () => {
-        let s = reduceDebounce(IDLE_DEBOUNCE_STATE, { type: 'green', now: 0 }, CFG)
-        s = reduceDebounce(s, { type: 'green', now: 30_000 }, CFG)
-        // pendingSince stays at the FIRST green (0); fireAt tracks the latest green + after,
-        // capped by pendingSince + maxWait (0 + 600_000 = 600_000, not yet reached).
-        assert.equal(s.pendingSince, 0)
-        assert.equal(s.fireAt, 30_000 + CFG.afterMs)
-    })
-
-    it('a steady stream of green events is bounded by maxWait — never starves forever', () => {
-        let s = reduceDebounce(IDLE_DEBOUNCE_STATE, { type: 'green', now: 0 }, CFG)
-        // Green every 30s, well under the 60s `after` window, for 20 minutes —
-        // a pure trailing debounce would never fire.
-        for (let now = 30_000; now <= 1_200_000; now += 30_000) {
-            s = reduceDebounce(s, { type: 'green', now }, CFG)
-        }
-        // fireAt must never exceed pendingSince + maxWait (0 + 600_000).
-        assert.ok(s.fireAt <= CFG.maxWaitMs, `fireAt ${s.fireAt} exceeded the maxWait ceiling ${CFG.maxWaitMs}`)
-        assert.equal(s.fireAt, CFG.maxWaitMs)
-    })
-
-    it('a red event after being interrupted then going green again starts a FRESH window', () => {
-        let s = reduceDebounce(IDLE_DEBOUNCE_STATE, { type: 'green', now: 0 }, CFG)
-        s = reduceDebounce(s, { type: 'red', now: 100_000 }, CFG)
-        s = reduceDebounce(s, { type: 'green', now: 200_000 }, CFG)
-        // pendingSince resets to the new green's timestamp, not the original 0 —
-        // otherwise the maxWait ceiling would already be looming from unrelated history.
-        assert.equal(s.pendingSince, 200_000)
-        assert.equal(s.fireAt, 200_000 + CFG.afterMs)
-    })
-})

package/test/duration.test.js

@@ -1,32 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { parseDuration } from '../lib/duration.js'
-
-describe('parseDuration', () => {
-    it('passes a plain number through unchanged', () => {
-        assert.equal(parseDuration(5000), 5000)
-    })
-
-    it('returns the fallback for null/undefined', () => {
-        assert.equal(parseDuration(undefined, 42), 42)
-        assert.equal(parseDuration(null, 42), 42)
-    })
-
-    it('parses each unit', () => {
-        assert.equal(parseDuration('500ms'), 500)
-        assert.equal(parseDuration('30s'), 30_000)
-        assert.equal(parseDuration('1m'), 60_000)
-        assert.equal(parseDuration('10m'), 600_000)
-        assert.equal(parseDuration('2h'), 7_200_000)
-        assert.equal(parseDuration('1d'), 86_400_000)
-    })
-
-    it('is case-insensitive on the unit', () => {
-        assert.equal(parseDuration('1M'), 60_000)
-    })
-
-    it('throws on an unparseable string', () => {
-        assert.throws(() => parseDuration('soon'), /invalid duration/i)
-    })
-})

package/test/forge/gitea.test.js

@@ -1,91 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { ensurePR, mergePR } from '../../lib/forge/gitea.js'
-
-function fakeResponse({ ok = true, status = 200, body = {} } = {}) {
-    return {
-        ok,
-        status,
-        statusText: ok ? 'OK' : 'Error',
-        json: async () => body,
-    }
-}
-
-const CTX = { apiBase: 'https://git.almero.bg', owner: 'org', repo: 'content', head: 'mikser', base: 'main', title: 'Promote', token: 'tok' }
-
-describe('gitea forge adapter', () => {
-    it('ensurePR reuses an existing open PR matched by head/base ref', async () => {
-        const calls = []
-        const fetchImpl = async (url, opts) => {
-            calls.push({ url, method: opts?.method ?? 'GET' })
-            return fakeResponse({
-                body: [
-                    { number: 3, head: { ref: 'some-other-branch' }, base: { ref: 'main' } },
-                    { number: 5, head: { ref: 'mikser' }, base: { ref: 'main' }, html_url: 'https://git.almero.bg/org/content/pulls/5' },
-                ],
-            })
-        }
-        const pr = await ensurePR({ ...CTX, fetchImpl })
-        assert.deepEqual(pr, { number: 5, url: 'https://git.almero.bg/org/content/pulls/5' })
-        assert.equal(calls.length, 1)
-        assert.match(calls[0].url, /\/api\/v1\/repos\/org\/content\/pulls\?state=open/)
-    })
-
-    it('ensurePR creates a new PR when the open list has no head/base match', async () => {
-        const calls = []
-        const fetchImpl = async (url, opts) => {
-            calls.push({ url, method: opts?.method ?? 'GET' })
-            if (!opts?.method || opts.method === 'GET') return fakeResponse({ body: [] })
-            return fakeResponse({ status: 201, body: { number: 11, html_url: 'https://git.almero.bg/org/content/pulls/11' } })
-        }
-        const pr = await ensurePR({ ...CTX, fetchImpl })
-        assert.deepEqual(pr, { number: 11, url: 'https://git.almero.bg/org/content/pulls/11' })
-        assert.equal(calls[1].method, 'POST')
-    })
-
-    it('ensurePR posts the correct body shape when creating', async () => {
-        let capturedBody = null
-        const fetchImpl = async (url, opts) => {
-            if (!opts?.method || opts.method === 'GET') return fakeResponse({ body: [] })
-            capturedBody = JSON.parse(opts.body)
-            return fakeResponse({ status: 201, body: { number: 1, html_url: 'x' } })
-        }
-        await ensurePR({ ...CTX, fetchImpl })
-        assert.deepEqual(capturedBody, { title: 'Promote', head: 'mikser', base: 'main' })
-    })
-
-    it('mergePR posts { Do: "merge" } — Gitea-specific field name and casing', async () => {
-        let capturedBody = null
-        let capturedMethod = null
-        const fetchImpl = async (url, opts) => {
-            capturedMethod = opts.method
-            capturedBody = JSON.parse(opts.body)
-            return fakeResponse({ body: {} })
-        }
-        const result = await mergePR({ apiBase: 'https://git.almero.bg', owner: 'org', repo: 'content', number: 5, token: 'tok', fetchImpl })
-        assert.deepEqual(result, { merged: true })
-        assert.equal(capturedMethod, 'POST')   // NOT PUT — differs from the GitHub adapter
-        assert.deepEqual(capturedBody, { Do: 'merge' })
-    })
-
-    it('mergePR reports merged:false with a reason on failure', async () => {
-        const fetchImpl = async () => fakeResponse({ ok: false, status: 409, body: { message: 'merge conflict' } })
-        const result = await mergePR({ apiBase: 'https://git.almero.bg', owner: 'org', repo: 'content', number: 5, token: 'tok', fetchImpl })
-        assert.equal(result.merged, false)
-        assert.match(result.reason, /merge conflict/)
-    })
-
-    it('auth header uses the Gitea "token" scheme, not Bearer', async () => {
-        const seenHeaders = []
-        const fetchImpl = async (url, opts) => {
-            seenHeaders.push(opts.headers)
-            return fakeResponse({ body: [] })   // empty list → falls through to create, also hit by this fetchImpl
-        }
-        await ensurePR({ ...CTX, fetchImpl })
-        assert.ok(seenHeaders.length > 0)
-        for (const headers of seenHeaders) {
-            assert.equal(headers.Authorization, 'token tok')
-        }
-    })
-})