@pome-sh/cli 0.9.0 → 0.11.0

package/node_modules/@pome-sh/twin-github/dist/src/domain/github-domain.js

@@ -0,0 +1,794 @@
+import { notFound, validationFailed } from "../errors.js";
+import { fileSha, linesChanged, makeSha, nowIso, treeSha } from "../util.js";
+import { defaultSeedState, parseSeed } from "../seed.js";
+import { contentDirectoryEntryJson, labelJson, pullRequestJson, pullRequestListJson, } from "../serializers.js";
+import { resetDatabase } from "../db.js";
+import * as checks from "./checks.js";
+import * as git from "./git.js";
+import * as issues from "./issues.js";
+import * as pulls from "./pulls.js";
+import * as releases from "./releases.js";
+import * as repos from "./repos.js";
+import * as search from "./search.js";
+import { commitIdentityKey, normalizePath } from "./helpers.js";
+export class GitHubDomain {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    seed(seed = defaultSeedState(), onDelta) {
+        const parsedSeed = parseSeed(seed);
+        const before = this.summarizeRepositories();
+        const tx = this.db.transaction(() => {
+            resetDatabase(this.db);
+            const users = new Set(parsedSeed.users?.map((user) => user.login) ?? []);
+            for (const repo of parsedSeed.repositories) {
+                users.add(repo.owner);
+                for (const login of repo.collaborators ?? [])
+                    users.add(login);
+                for (const issue of repo.issues ?? [])
+                    for (const login of issue.assignees ?? [])
+                        users.add(login);
+            }
+            users.add("pome-agent");
+            for (const user of parsedSeed.users ?? []) {
+                this.upsertUser(user.login, user.type ?? "User", user.name ?? "");
+            }
+            for (const login of users) {
+                this.upsertUser(login, login === "acme" ? "Organization" : "User", login);
+            }
+            for (const repoSeed of parsedSeed.repositories) {
+                const repo = this.insertRepository({
+                    owner: repoSeed.owner,
+                    name: repoSeed.name,
+                    description: repoSeed.description ?? "",
+                    private: repoSeed.private ?? false,
+                    defaultBranch: repoSeed.default_branch ?? "main",
+                    fork: false,
+                    parentFullName: null
+                });
+                for (const login of repoSeed.collaborators ?? [])
+                    this.addCollaborator(repo.id, login);
+                this.addCollaborator(repo.id, "pome-agent");
+                for (const label of repoSeed.labels ?? []) {
+                    this.createLabel(repo, label.name, label.color ?? "ededed", label.description ?? "");
+                }
+                this.createBranchInternal(repo, repo.default_branch, null);
+                const files = repoSeed.files?.filter((file) => (file.branch ?? repo.default_branch) === repo.default_branch) ?? [];
+                this.commitFiles(repo, repo.default_branch, "Initial seed commit", files, "pome-agent");
+                const nonDefaultBranches = new Set((repoSeed.files ?? []).map((file) => file.branch ?? repo.default_branch).filter((branch) => branch !== repo.default_branch));
+                for (const branch of nonDefaultBranches) {
+                    this.createBranch({ owner: repo.owner, repo: repo.name, branch, from_branch: repo.default_branch });
+                    const branchFiles = repoSeed.files?.filter((file) => (file.branch ?? repo.default_branch) === branch) ?? [];
+                    this.commitFiles(repo, branch, `Seed ${branch}`, branchFiles, "pome-agent");
+                }
+                for (const issue of repoSeed.issues ?? []) {
+                    const legacyAssignee = issue.assignee;
+                    const assignees = issue.assignees ?? (legacyAssignee ? [legacyAssignee] : []);
+                    const created = this.createIssue({ owner: repo.owner, repo: repo.name, title: issue.title, body: issue.body ?? "", labels: issue.labels ?? [], assignees });
+                    if (issue.number && issue.number !== created.number) {
+                        const from = created.number;
+                        const to = issue.number;
+                        this.db.prepare("UPDATE issues SET number = ? WHERE repo_id = ? AND number = ?").run(to, repo.id, from);
+                        this.db.prepare("UPDATE issue_labels SET issue_number = ? WHERE repo_id = ? AND issue_number = ?").run(to, repo.id, from);
+                        this.db.prepare("UPDATE issue_assignees SET issue_number = ? WHERE repo_id = ? AND issue_number = ?").run(to, repo.id, from);
+                        this.db.prepare("UPDATE issue_comments SET issue_number = ? WHERE repo_id = ? AND issue_number = ?").run(to, repo.id, from);
+                        this.bumpEntityCounter(repo.id, to);
+                    }
+                    if (issue.state === "closed")
+                        this.updateIssue({ owner: repo.owner, repo: repo.name, issue_number: issue.number ?? created.number, state: "closed" });
+                }
+                for (const pull of repoSeed.pull_requests ?? []) {
+                    const createdPr = this.createPullRequest({ owner: repo.owner, repo: repo.name, title: pull.title, body: pull.body ?? "", head: pull.head, base: pull.base ?? repo.default_branch, actor: pull.author });
+                    const prNumber = createdPr.number;
+                    // The PR row and its head branch don't change across seeded reviews /
+                    // statuses, so resolve the head SHA once rather than re-querying it on
+                    // every iteration (and in both blocks below).
+                    const seedsHead = (pull.reviews ?? []).length > 0 || (pull.statuses ?? []).length > 0;
+                    const prRow = seedsHead ? this.requirePullRequest(repo.id, prNumber) : null;
+                    const headRepo = prRow ? this.requireRepoById(prRow.head_repo_id) : null;
+                    const headSha = prRow && headRepo ? this.requireBranch(headRepo.id, prRow.head_ref).head_sha ?? "" : "";
+                    // Seed reviews directly into pull_request_reviews so we can record
+                    // the author and state honestly. Going through createPullRequestReview
+                    // would hardcode user_login = "pome-agent" and lose author identity.
+                    for (const review of pull.reviews ?? []) {
+                        users.add(review.author);
+                        this.upsertUser(review.author, "User", review.author);
+                        this.db.prepare("INSERT INTO pull_request_reviews (repo_id, pull_number, user_login, state, body, commit_sha, submitted_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(repo.id, prNumber, review.author, 
+                        // parseSeed defaults this to "APPROVED"; guard direct seed() callers
+                        // that pass a hand-built seed with no explicit review state.
+                        review.state ?? "APPROVED", review.body ?? "", headSha, nowIso());
+                    }
+                    // Seed commit statuses on the PR head SHA. Same shape as
+                    // createStatus() so merge_pull_request's required-status check
+                    // sees the seeded value.
+                    if ((pull.statuses ?? []).length > 0 && headRepo) {
+                        for (const status of pull.statuses ?? []) {
+                            this.createStatus({
+                                owner: headRepo.owner,
+                                repo: headRepo.name,
+                                sha: headSha,
+                                state: status.state ?? "success",
+                                context: status.context ?? "ci/build",
+                                description: status.description ?? ""
+                            });
+                        }
+                    }
+                }
+            }
+            this.audit("seed", null, { repositories: parsedSeed.repositories.length });
+        });
+        tx();
+        onDelta?.({
+            before: { repositories: before },
+            after: { repositories: this.summarizeRepositories() }
+        });
+    }
+    summarizeRepositories() {
+        const rows = this.db.prepare("SELECT owner, name FROM repositories ORDER BY full_name ASC").all();
+        return rows;
+    }
+    exportState() {
+        const repos = this.db.prepare("SELECT * FROM repositories ORDER BY full_name ASC").all();
+        return {
+            repositories: repos.map((repo) => ({
+                ...repo,
+                branches: this.listBranches(repo.id),
+                files: this.db.prepare("SELECT * FROM files WHERE repo_id = ? ORDER BY branch, path").all(repo.id),
+                labels: this.listLabels(repo.id),
+                issues: this.listIssuesRows(repo.id).map((issue) => ({
+                    ...issue,
+                    labels: this.listIssueLabels(repo.id, issue.number),
+                    assignees: this.listIssueAssignees(repo.id, issue.number),
+                    comments: this.listIssueCommentRows(repo.id, issue.number)
+                })),
+                pull_requests: this.listPullRequestRows(repo.id).map((pull) => ({
+                    ...pull,
+                    files: this.listPullRequestFileRows(repo.id, pull.number),
+                    reviews: this.listPullRequestReviewRows(repo.id, pull.number),
+                    review_comments: this.listPullRequestReviewCommentRows(repo.id, pull.number)
+                })),
+                commit_statuses: this.db.prepare("SELECT * FROM commit_statuses WHERE repo_id = ? ORDER BY id ASC").all(repo.id),
+                check_runs: this.db.prepare("SELECT * FROM check_runs WHERE repo_id = ? ORDER BY id ASC").all(repo.id)
+            }))
+        };
+    }
+    getRepository(input) {
+        return repos.getRepository(this, input);
+    }
+    createRepository(input, onDelta) {
+        return repos.createRepository(this, input, onDelta);
+    }
+    forkRepository(input, onDelta) {
+        return repos.forkRepository(this, input, onDelta);
+    }
+    searchRepositories(input) {
+        return search.searchRepositories(this, input);
+    }
+    searchUsers(input) {
+        return search.searchUsers(this, input);
+    }
+    searchCode(input) {
+        return search.searchCode(this, input);
+    }
+    searchCommits(input) {
+        return search.searchCommits(this, input);
+    }
+    getFileContents(input) {
+        return git.getFileContents(this, input);
+    }
+    listCommits(input) {
+        return git.listCommits(this, input);
+    }
+    createOrUpdateFile(input, options = {}, onDelta) {
+        return git.createOrUpdateFile(this, input, options, onDelta);
+    }
+    pushFiles(input, options = {}, onDelta) {
+        return git.pushFiles(this, input, options, onDelta);
+    }
+    createBranch(input, onDelta) {
+        return git.createBranch(this, input, onDelta);
+    }
+    createIssue(input, onDelta) {
+        return issues.createIssue(this, input, onDelta);
+    }
+    listIssues(input) {
+        return issues.listIssues(this, input);
+    }
+    searchIssues(input) {
+        return search.searchIssues(this, input);
+    }
+    getIssue(input) {
+        return issues.getIssue(this, input);
+    }
+    updateIssue(input, onDelta) {
+        return issues.updateIssue(this, input, onDelta);
+    }
+    addIssueComment(input, onDelta) {
+        return issues.addIssueComment(this, input, onDelta);
+    }
+    listIssueComments(input) {
+        return issues.listIssueComments(this, input);
+    }
+    listRepositoryLabels(input) {
+        return issues.listRepositoryLabels(this, input);
+    }
+    createRepositoryLabel(input, onDelta) {
+        return issues.createRepositoryLabel(this, input, onDelta);
+    }
+    listIssueLabelsForIssue(input) {
+        return issues.listIssueLabelsForIssue(this, input);
+    }
+    addIssueLabels(input, onDelta) {
+        return issues.addIssueLabels(this, input, onDelta);
+    }
+    deleteIssueLabel(input, onDelta) {
+        return issues.deleteIssueLabel(this, input, onDelta);
+    }
+    listCollaborators(input) {
+        return repos.listCollaborators(this, input);
+    }
+    isCollaborator(input) {
+        return repos.isCollaborator(this, input);
+    }
+    hasRepositoryPermission(input) {
+        return repos.hasRepositoryPermission(this, input);
+    }
+    addAssignees(input, onDelta) {
+        return issues.addAssignees(this, input, onDelta);
+    }
+    createPullRequest(input, onDelta) {
+        return pulls.createPullRequest(this, input, onDelta);
+    }
+    listPullRequests(input) {
+        return pulls.listPullRequests(this, input);
+    }
+    getPullRequest(input) {
+        return pulls.getPullRequest(this, input);
+    }
+    getPullRequestFiles(input) {
+        return pulls.getPullRequestFiles(this, input);
+    }
+    getPullRequestReviews(input) {
+        return pulls.getPullRequestReviews(this, input);
+    }
+    createPullRequestReview(input, onDelta) {
+        return pulls.createPullRequestReview(this, input, onDelta);
+    }
+    getPullRequestComments(input) {
+        return pulls.getPullRequestComments(this, input);
+    }
+    getPullRequestStatus(input) {
+        return pulls.getPullRequestStatus(this, input);
+    }
+    mergePullRequest(input, onDelta) {
+        return pulls.mergePullRequest(this, input, onDelta);
+    }
+    updatePullRequestBranch(input, onDelta) {
+        return pulls.updatePullRequestBranch(this, input, onDelta);
+    }
+    createStatus(input) {
+        return checks.createStatus(this, input);
+    }
+    listBranchesForRepo(input) {
+        return git.listBranchesForRepo(this, input);
+    }
+    getBranchByName(input) {
+        return git.getBranchByName(this, input);
+    }
+    deleteBranch(input, onDelta) {
+        return git.deleteBranch(this, input, onDelta);
+    }
+    deleteFile(input, options = {}, onDelta) {
+        return git.deleteFile(this, input, options, onDelta);
+    }
+    getCommitWithFiles(input) {
+        return git.getCommitWithFiles(this, input);
+    }
+    compareCommits(input) {
+        return git.compareCommits(this, input);
+    }
+    getPullRequestDiff(input) {
+        return pulls.getPullRequestDiff(this, input);
+    }
+    updatePullRequest(input, onDelta) {
+        return pulls.updatePullRequest(this, input, onDelta);
+    }
+    getPullRequestCommits(input) {
+        return pulls.getPullRequestCommits(this, input);
+    }
+    createPullRequestReviewComment(input, options = {}, onDelta) {
+        return pulls.createPullRequestReviewComment(this, input, options, onDelta);
+    }
+    addReplyToPullRequestComment(input, options = {}, onDelta) {
+        return pulls.addReplyToPullRequestComment(this, input, options, onDelta);
+    }
+    updateIssueComment(input, onDelta) {
+        return issues.updateIssueComment(this, input, onDelta);
+    }
+    deleteIssueComment(input, onDelta) {
+        return issues.deleteIssueComment(this, input, onDelta);
+    }
+    listMilestones(input) {
+        return issues.listMilestones(this, input);
+    }
+    createMilestone(input, onDelta) {
+        return issues.createMilestone(this, input, onDelta);
+    }
+    updateMilestone(input, onDelta) {
+        return issues.updateMilestone(this, input, onDelta);
+    }
+    deleteMilestone(input, onDelta) {
+        return issues.deleteMilestone(this, input, onDelta);
+    }
+    createCommitStatus(input, onDelta) {
+        return checks.createCommitStatus(this, input, onDelta);
+    }
+    getCombinedStatusForRef(input) {
+        return checks.getCombinedStatusForRef(this, input);
+    }
+    createCheckRun(input, onDelta) {
+        return checks.createCheckRun(this, input, onDelta);
+    }
+    listCheckRunsForRef(input) {
+        return checks.listCheckRunsForRef(this, input);
+    }
+    listTags(input) {
+        return releases.listTags(this, input);
+    }
+    listReleases(input) {
+        return releases.listReleases(this, input);
+    }
+    getLatestRelease(input) {
+        return releases.getLatestRelease(this, input);
+    }
+    getReleaseByTag(input) {
+        return releases.getReleaseByTag(this, input);
+    }
+    getTag(input) {
+        return releases.getTag(this, input);
+    }
+    createRelease(input, options = {}, onDelta) {
+        return releases.createRelease(this, input, options, onDelta);
+    }
+    getMe(input = {}) {
+        return repos.getMe(this, input);
+    }
+    addCollaboratorAction(input, onDelta) {
+        return repos.addCollaboratorAction(this, input, onDelta);
+    }
+    // ----- shared helpers (used by domain/* modules) -----
+    latestCommitStatuses(repoId, sha) {
+        const statuses = this.db.prepare("SELECT * FROM commit_statuses WHERE repo_id = ? AND sha = ? ORDER BY updated_at DESC, id DESC").all(repoId, sha);
+        const latestByContext = new Map();
+        for (const status of statuses) {
+            if (!latestByContext.has(status.context))
+                latestByContext.set(status.context, status);
+        }
+        return [...latestByContext.values()];
+    }
+    // ===== private helpers added for v2 hot paths ============================
+    requireCommitOnRepo(repoId, sha) {
+        const exists = this.db.prepare("SELECT 1 FROM commits WHERE repo_id = ? AND sha = ?").get(repoId, sha);
+        if (!exists)
+            notFound("No commit found for SHA");
+    }
+    resolveCommitByRef(repo, ref) {
+        // Try as SHA first.
+        const byHash = this.db.prepare("SELECT * FROM commits WHERE repo_id = ? AND sha = ?").get(repo.id, ref);
+        if (byHash)
+            return byHash;
+        // Try as branch name.
+        const branch = this.getBranch(repo.id, ref);
+        if (branch?.head_sha) {
+            const commit = this.db.prepare("SELECT * FROM commits WHERE repo_id = ? AND sha = ?").get(repo.id, branch.head_sha);
+            if (commit)
+                return commit;
+        }
+        // Try as tag name.
+        const tag = this.db.prepare("SELECT * FROM tags WHERE repo_id = ? AND name = ?").get(repo.id, ref);
+        if (tag) {
+            const commit = this.db.prepare("SELECT * FROM commits WHERE repo_id = ? AND sha = ?").get(repo.id, tag.commit_sha);
+            if (commit)
+                return commit;
+        }
+        notFound("No commit found for ref");
+    }
+    resolveRefToSha(repo, ref) {
+        return this.resolveCommitByRef(repo, ref).sha;
+    }
+    commitAncestry(repoId, sha) {
+        const all = this.db.prepare("SELECT * FROM commits WHERE repo_id = ?").all(repoId);
+        const bySha = new Map(all.map((commit) => [commit.sha, commit]));
+        const out = [];
+        const seen = new Set();
+        const MAX_DEPTH = 2000;
+        let cursor = sha;
+        while (cursor && out.length < MAX_DEPTH) {
+            if (seen.has(cursor))
+                break;
+            seen.add(cursor);
+            const commit = bySha.get(cursor);
+            if (!commit)
+                break;
+            out.push(commit);
+            cursor = commit.parent_sha;
+        }
+        return out;
+    }
+    findMergeBase(baseRepo, baseSha, headRepo, headSha) {
+        if (!baseSha || !headSha)
+            return null;
+        const headAncestry = this.commitAncestry(headRepo.id, headSha);
+        const headShas = new Set(headAncestry.map((commit) => commit.sha));
+        // Fork heads carry copies of the base commits with randomized SHAs
+        // (copyForkCommits salts makeSha with a UUID), but the copy preserves
+        // message/authors/tree_sha/created_at verbatim — match cross-repo
+        // ancestry on that identity tuple. Returns the base-space SHA.
+        const headKeys = baseRepo.id === headRepo.id ? null : new Set(headAncestry.map((commit) => commitIdentityKey(commit)));
+        for (const commit of this.commitAncestry(baseRepo.id, baseSha)) {
+            if (headShas.has(commit.sha))
+                return commit.sha;
+            if (headKeys?.has(commitIdentityKey(commit)))
+                return commit.sha;
+        }
+        return null;
+    }
+    /** File state (path → blob) as of a commit, reconstructed from file_versions. */
+    fileStateAtCommit(repoId, sha) {
+        const state = new Map();
+        if (!sha)
+            return state;
+        const seen = new Set();
+        for (const commit of this.commitAncestry(repoId, sha)) {
+            const versions = this.db.prepare("SELECT path, content, sha, status FROM file_versions WHERE repo_id = ? AND commit_sha = ?").all(repoId, commit.sha);
+            for (const version of versions) {
+                if (seen.has(version.path))
+                    continue;
+                seen.add(version.path);
+                if (version.status !== "removed")
+                    state.set(version.path, { content: version.content, sha: version.sha });
+            }
+        }
+        return state;
+    }
+    /** Net base-branch changes since the merge base, skipping paths the head branch also touched (head wins). */
+    mergeChangesFromBase(baseRepo, baseRef, headRepo, headRef, mergeBase) {
+        const branchFiles = (repoId, branch) => new Map(this.db.prepare("SELECT * FROM files WHERE repo_id = ? AND branch = ?").all(repoId, branch).map((file) => [file.path, file]));
+        const baseNow = branchFiles(baseRepo.id, baseRef);
+        const headNow = branchFiles(headRepo.id, headRef);
+        const atMergeBase = this.fileStateAtCommit(baseRepo.id, mergeBase);
+        const changes = [];
+        for (const path of new Set([...baseNow.keys(), ...atMergeBase.keys()])) {
+            const current = baseNow.get(path);
+            const original = atMergeBase.get(path);
+            if (current?.sha === original?.sha)
+                continue;
+            if (headNow.get(path)?.sha !== original?.sha)
+                continue;
+            if (!current)
+                changes.push({ path, content: "", delete: true });
+            else
+                changes.push({ path, content: current.content });
+        }
+        return changes;
+    }
+    commitsBetween(repoId, headSha, baseSha) {
+        const ancestry = this.commitAncestry(repoId, headSha);
+        if (!baseSha)
+            return ancestry;
+        const stopIndex = ancestry.findIndex((commit) => commit.sha === baseSha);
+        if (stopIndex === -1)
+            return ancestry;
+        return ancestry.slice(0, stopIndex);
+    }
+    computeCommitFiles(repo, commit) {
+        const versions = this.db.prepare("SELECT path, content, sha, status FROM file_versions WHERE repo_id = ? AND commit_sha = ?").all(repo.id, commit.sha);
+        return versions.map((version) => {
+            const additions = version.status === "removed" ? 0 : version.content.split("\n").filter(Boolean).length || 1;
+            const deletions = version.status === "added" ? 0 : version.content.split("\n").filter(Boolean).length || 0;
+            return {
+                repo_id: repo.id,
+                pull_number: 0,
+                filename: version.path,
+                status: version.status,
+                additions,
+                deletions,
+                changes: additions + deletions,
+                blob_url: `https://github.com/${repo.full_name}/blob/${commit.sha}/${version.path}`,
+                raw_url: `https://raw.githubusercontent.com/${repo.full_name}/${commit.sha}/${version.path}`,
+                contents_url: `https://api.github.com/repos/${repo.full_name}/contents/${version.path}?ref=${commit.sha}`,
+                patch: `@@ ${version.path} @@`
+            };
+        });
+    }
+    computeCompareFiles(repo, base, head) {
+        // Build path → latest version snapshot at each commit by walking ancestry
+        // and folding file_versions. Used by /compare.
+        const baseSnapshot = this.snapshotAtCommit(repo.id, base.sha);
+        const headSnapshot = this.snapshotAtCommit(repo.id, head.sha);
+        const paths = [...new Set([...baseSnapshot.keys(), ...headSnapshot.keys()])].sort();
+        const rows = [];
+        for (const path of paths) {
+            const baseFile = baseSnapshot.get(path);
+            const headFile = headSnapshot.get(path);
+            if (baseFile?.sha === headFile?.sha)
+                continue;
+            const diff = linesChanged(baseFile?.content, headFile?.content ?? "");
+            rows.push({
+                repo_id: repo.id,
+                pull_number: 0,
+                filename: path,
+                status: baseFile && headFile ? "modified" : headFile ? "added" : "removed",
+                additions: diff.additions,
+                deletions: headFile ? diff.deletions : (baseFile?.content.split("\n").length ?? 0),
+                changes: diff.additions + diff.deletions,
+                blob_url: `https://github.com/${repo.full_name}/blob/${head.sha}/${path}`,
+                raw_url: `https://raw.githubusercontent.com/${repo.full_name}/${head.sha}/${path}`,
+                contents_url: `https://api.github.com/repos/${repo.full_name}/contents/${path}?ref=${head.sha}`,
+                patch: `@@ ${path} @@`
+            });
+        }
+        return rows;
+    }
+    snapshotAtCommit(repoId, sha) {
+        // Walk ancestry oldest → newest, folding file_versions per path. Removed rows clear the entry.
+        const ancestry = this.commitAncestry(repoId, sha).reverse();
+        const out = new Map();
+        for (const commit of ancestry) {
+            const versions = this.db.prepare("SELECT path, content, sha, status FROM file_versions WHERE repo_id = ? AND commit_sha = ?").all(repoId, commit.sha);
+            for (const version of versions) {
+                if (version.status === "removed")
+                    out.delete(version.path);
+                else
+                    out.set(version.path, { content: version.content, sha: version.sha });
+            }
+        }
+        return out;
+    }
+    nextMilestoneNumber(repoId) {
+        const row = this.db.prepare("SELECT COALESCE(MAX(number), 0) AS max FROM milestones WHERE repo_id = ?").get(repoId);
+        return row.max + 1;
+    }
+    transaction(fn) {
+        return this.db.transaction(fn).immediate();
+    }
+    insertRepository(input) {
+        const now = nowIso();
+        this.db.prepare("INSERT INTO repositories (owner, name, full_name, description, private, default_branch, fork, parent_full_name, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").run(input.owner, input.name, `${input.owner}/${input.name}`, input.description, input.private ? 1 : 0, input.defaultBranch, input.fork ? 1 : 0, input.parentFullName, now, now);
+        return this.requireRepo(input.owner, input.name);
+    }
+    copyForkCommits(source, fork) {
+        const sourceCommits = this.db.prepare("SELECT * FROM commits WHERE repo_id = ?").all(source.id);
+        const bySha = new Map(sourceCommits.map((commit) => [commit.sha, commit]));
+        const copied = new Map();
+        const copyCommit = (commit) => {
+            const existing = copied.get(commit.sha);
+            if (existing)
+                return existing;
+            const parent = commit.parent_sha ? bySha.get(commit.parent_sha) : undefined;
+            const parentSha = parent ? copyCommit(parent) : null;
+            const sha = makeSha(fork.full_name, commit.sha);
+            copied.set(commit.sha, sha);
+            this.db.prepare("INSERT INTO commits (sha, repo_id, message, author_login, committer_login, parent_sha, tree_sha, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(sha, fork.id, commit.message, commit.author_login, commit.committer_login, parentSha, commit.tree_sha, commit.created_at);
+            const versions = this.db.prepare("SELECT path, content, sha, status FROM file_versions WHERE repo_id = ? AND commit_sha = ?").all(source.id, commit.sha);
+            for (const version of versions) {
+                this.db.prepare("INSERT INTO file_versions (commit_sha, repo_id, path, content, sha, status) VALUES (?, ?, ?, ?, ?, ?)").run(sha, fork.id, version.path, version.content, version.sha, version.status);
+            }
+            return sha;
+        };
+        for (const commit of sourceCommits)
+            copyCommit(commit);
+        return copied;
+    }
+    commitFiles(repo, branchName, message, files, actor) {
+        const branch = this.requireBranch(repo.id, branchName);
+        const now = nowIso();
+        const normalizedFiles = files.map((file) => ({ ...file, path: normalizePath(file.path) }));
+        const existingPaths = this.db.prepare("SELECT path FROM files WHERE repo_id = ? AND branch = ? ORDER BY path").all(repo.id, branchName).map((row) => row.path);
+        const nextPaths = new Set(existingPaths);
+        for (const file of normalizedFiles) {
+            if (file.delete)
+                nextPaths.delete(file.path);
+            else
+                nextPaths.add(file.path);
+        }
+        const sha = makeSha(repo.full_name, branchName, message, normalizedFiles, now);
+        const commit = {
+            sha,
+            repo_id: repo.id,
+            message,
+            author_login: actor,
+            committer_login: actor,
+            parent_sha: branch.head_sha,
+            tree_sha: treeSha([...nextPaths]),
+            created_at: now
+        };
+        this.db.prepare("INSERT INTO commits (sha, repo_id, message, author_login, committer_login, parent_sha, tree_sha, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(commit.sha, commit.repo_id, commit.message, commit.author_login, commit.committer_login, commit.parent_sha, commit.tree_sha, commit.created_at);
+        for (const file of normalizedFiles) {
+            const path = file.path;
+            const existing = this.getFile(repo.id, branchName, path);
+            if (file.delete) {
+                if (!existing)
+                    validationFailed("files", "missing", path);
+                this.db.prepare("INSERT INTO file_versions (commit_sha, repo_id, path, content, sha, status) VALUES (?, ?, ?, ?, ?, 'removed')").run(commit.sha, repo.id, path, existing.content, existing.sha);
+                this.db.prepare("DELETE FROM files WHERE repo_id = ? AND branch = ? AND path = ?").run(repo.id, branchName, path);
+                continue;
+            }
+            const sha = fileSha(file.content);
+            this.db.prepare("INSERT INTO file_versions (commit_sha, repo_id, path, content, sha, status) VALUES (?, ?, ?, ?, ?, ?)").run(commit.sha, repo.id, path, file.content, sha, existing ? "modified" : "added");
+            this.db.prepare("INSERT INTO files (repo_id, branch, path, content, sha, size, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT(repo_id, branch, path) DO UPDATE SET content = excluded.content, sha = excluded.sha, size = excluded.size, updated_at = excluded.updated_at").run(repo.id, branchName, path, file.content, sha, Buffer.byteLength(file.content), now);
+        }
+        this.db.prepare("UPDATE branches SET head_sha = ?, updated_at = ? WHERE repo_id = ? AND name = ?").run(commit.sha, now, repo.id, branchName);
+        this.db.prepare("UPDATE repositories SET updated_at = ? WHERE id = ?").run(now, repo.id);
+        return commit;
+    }
+    calculatePullFiles(baseRepo, baseRef, headRepo, headRef) {
+        const baseFiles = new Map(this.db.prepare("SELECT * FROM files WHERE repo_id = ? AND branch = ?").all(baseRepo.id, baseRef).map((file) => [file.path, file]));
+        const headFiles = new Map(this.db.prepare("SELECT * FROM files WHERE repo_id = ? AND branch = ?").all(headRepo.id, headRef).map((file) => [file.path, file]));
+        const paths = [...new Set([...baseFiles.keys(), ...headFiles.keys()])].sort();
+        const rows = [];
+        for (const path of paths) {
+            const base = baseFiles.get(path);
+            const head = headFiles.get(path);
+            if (base?.sha === head?.sha)
+                continue;
+            const diff = linesChanged(base?.content, head?.content ?? "");
+            rows.push({
+                repo_id: baseRepo.id,
+                pull_number: 0,
+                filename: path,
+                status: base && head ? "modified" : head ? "added" : "removed",
+                additions: diff.additions,
+                deletions: head ? diff.deletions : base?.content.split("\n").length ?? 0,
+                changes: diff.additions + diff.deletions,
+                blob_url: `https://github.com/${headRepo.full_name}/blob/${headRef}/${path}`,
+                raw_url: `https://raw.githubusercontent.com/${headRepo.full_name}/${headRef}/${path}`,
+                contents_url: `https://api.github.com/repos/${headRepo.full_name}/contents/${path}`,
+                patch: `@@ ${path} @@`
+            });
+        }
+        return rows;
+    }
+    replacePullFiles(repoId, pullNumber, files) {
+        this.db.prepare("DELETE FROM pull_request_files WHERE repo_id = ? AND pull_number = ?").run(repoId, pullNumber);
+        for (const file of files) {
+            this.db.prepare("INSERT INTO pull_request_files (repo_id, pull_number, filename, status, additions, deletions, changes, blob_url, raw_url, contents_url, patch) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)").run(repoId, pullNumber, file.filename, file.status, file.additions, file.deletions, file.changes, file.blob_url, file.raw_url, file.contents_url, file.patch);
+        }
+    }
+    // Single-PR GET (full PullRequest shape: keeps merged / commits / additions /
+    // deletions / changed_files).
+    serializePull(pr) {
+        const baseRepo = this.requireRepoById(pr.base_repo_id);
+        const headRepo = this.requireRepoById(pr.head_repo_id);
+        const files = this.db.prepare("SELECT * FROM pull_request_files WHERE repo_id = ? AND pull_number = ?").all(pr.repo_id, pr.number);
+        const headSha = this.getBranch(headRepo.id, pr.head_ref)?.head_sha ?? pr.head_sha;
+        const baseSha = this.getBranch(baseRepo.id, pr.base_ref)?.head_sha ?? pr.base_sha;
+        return pullRequestJson(pr, baseRepo, headRepo, 1, files.length, headSha, baseSha);
+    }
+    // LIST endpoint (leaner PullRequestSimple shape: drops the single-PR-only
+    // diff-stat fields, matching real GitHub).
+    serializePullSimple(pr) {
+        const baseRepo = this.requireRepoById(pr.base_repo_id);
+        const headRepo = this.requireRepoById(pr.head_repo_id);
+        const headSha = this.getBranch(headRepo.id, pr.head_ref)?.head_sha ?? pr.head_sha;
+        const baseSha = this.getBranch(baseRepo.id, pr.base_ref)?.head_sha ?? pr.base_sha;
+        return pullRequestListJson(pr, baseRepo, headRepo, headSha, baseSha);
+    }
+    resolveHeadRef(baseRepo, head) {
+        const [owner, ref] = head.includes(":") ? head.split(":", 2) : [baseRepo.owner, head];
+        const repo = this.requireRepo(owner, baseRepo.name);
+        return { repo, ref: ref };
+    }
+    listDirectory(repo, branch, path) {
+        const prefix = path ? `${path}/` : "";
+        const rows = this.db.prepare("SELECT * FROM files WHERE repo_id = ? AND branch = ? AND path LIKE ? ORDER BY path ASC").all(repo.id, branch, `${prefix}%`);
+        const seen = new Set();
+        const entries = [];
+        for (const file of rows) {
+            const rest = file.path.slice(prefix.length);
+            const first = rest.split("/")[0];
+            const childPath = prefix ? `${prefix}${first}` : first;
+            if (seen.has(childPath))
+                continue;
+            seen.add(childPath);
+            entries.push(contentDirectoryEntryJson(childPath, repo, branch, rest.includes("/") ? undefined : file));
+        }
+        return entries;
+    }
+    createBranchInternal(repo, name, headSha) {
+        const now = nowIso();
+        this.db.prepare("INSERT INTO branches (repo_id, name, head_sha, created_at, updated_at) VALUES (?, ?, ?, ?, ?)").run(repo.id, name, headSha, now, now);
+        return this.requireBranch(repo.id, name);
+    }
+    upsertUser(login, type, name) {
+        this.db.prepare("INSERT INTO users (login, type, name, created_at) VALUES (?, ?, ?, ?) ON CONFLICT(login) DO UPDATE SET type = excluded.type, name = excluded.name").run(login, type, name, nowIso());
+    }
+    addCollaborator(repoId, login) {
+        this.upsertUser(login, "User", login);
+        this.db.prepare("INSERT OR IGNORE INTO collaborators (repo_id, login, permission) VALUES (?, ?, 'push')").run(repoId, login);
+    }
+    createLabel(repo, name, color, description) {
+        this.db.prepare("INSERT OR IGNORE INTO labels (repo_id, name, color, description) VALUES (?, ?, ?, ?)").run(repo.id, name, color, description);
+        return labelJson(this.getLabel(repo.id, name));
+    }
+    getRepo(owner, repo) {
+        return this.db.prepare("SELECT * FROM repositories WHERE owner = ? AND name = ?").get(owner, repo);
+    }
+    requireRepo(owner, repo) {
+        return this.getRepo(owner, repo) ?? notFound("Not Found");
+    }
+    requireRepoById(repoId) {
+        return this.db.prepare("SELECT * FROM repositories WHERE id = ?").get(repoId) ?? notFound("Not Found");
+    }
+    getBranch(repoId, name) {
+        return this.db.prepare("SELECT * FROM branches WHERE repo_id = ? AND name = ?").get(repoId, name);
+    }
+    requireBranch(repoId, name) {
+        return this.getBranch(repoId, name) ?? notFound("Branch not found");
+    }
+    listBranches(repoId) {
+        return this.db.prepare("SELECT * FROM branches WHERE repo_id = ? ORDER BY name ASC").all(repoId);
+    }
+    getFile(repoId, branch, path) {
+        return this.db.prepare("SELECT * FROM files WHERE repo_id = ? AND branch = ? AND path = ?").get(repoId, branch, path);
+    }
+    getLabel(repoId, name) {
+        return this.db.prepare("SELECT * FROM labels WHERE repo_id = ? AND name = ?").get(repoId, name);
+    }
+    listLabels(repoId) {
+        return this.db.prepare("SELECT * FROM labels WHERE repo_id = ? ORDER BY name ASC").all(repoId);
+    }
+    listIssuesRows(repoId) {
+        return this.db.prepare("SELECT * FROM issues WHERE repo_id = ? ORDER BY number ASC").all(repoId);
+    }
+    requireIssue(repoId, number) {
+        return this.db.prepare("SELECT * FROM issues WHERE repo_id = ? AND number = ?").get(repoId, number) ?? notFound("Issue not found");
+    }
+    listIssueLabels(repoId, issueNumber) {
+        return this.db
+            .prepare("SELECT labels.* FROM labels INNER JOIN issue_labels ON labels.repo_id = issue_labels.repo_id AND labels.name = issue_labels.label_name WHERE issue_labels.repo_id = ? AND issue_labels.issue_number = ? ORDER BY labels.name ASC")
+            .all(repoId, issueNumber);
+    }
+    listIssueAssignees(repoId, issueNumber) {
+        const rows = this.db.prepare("SELECT login FROM issue_assignees WHERE repo_id = ? AND issue_number = ? ORDER BY login ASC").all(repoId, issueNumber);
+        return rows.map((row) => row.login);
+    }
+    issueCommentCount(repoId, issueNumber) {
+        const row = this.db.prepare("SELECT COUNT(*) AS count FROM issue_comments WHERE repo_id = ? AND issue_number = ?").get(repoId, issueNumber);
+        return row.count;
+    }
+    listIssueCommentRows(repoId, issueNumber) {
+        return this.db.prepare("SELECT * FROM issue_comments WHERE repo_id = ? AND issue_number = ? ORDER BY id ASC").all(repoId, issueNumber);
+    }
+    hasCollaborator(repoId, login) {
+        return Boolean(this.db.prepare("SELECT 1 FROM collaborators WHERE repo_id = ? AND login = ?").get(repoId, login));
+    }
+    listPullRequestRows(repoId) {
+        return this.db.prepare("SELECT * FROM pull_requests WHERE repo_id = ? ORDER BY number ASC").all(repoId);
+    }
+    listPullRequestFileRows(repoId, pullNumber) {
+        return this.db.prepare("SELECT * FROM pull_request_files WHERE repo_id = ? AND pull_number = ? ORDER BY filename ASC").all(repoId, pullNumber);
+    }
+    listPullRequestReviewRows(repoId, pullNumber) {
+        return this.db.prepare("SELECT * FROM pull_request_reviews WHERE repo_id = ? AND pull_number = ? ORDER BY submitted_at ASC").all(repoId, pullNumber);
+    }
+    listPullRequestReviewCommentRows(repoId, pullNumber) {
+        return this.db.prepare("SELECT * FROM pull_request_review_comments WHERE repo_id = ? AND pull_number = ? ORDER BY id ASC").all(repoId, pullNumber);
+    }
+    requirePullRequest(repoId, number) {
+        return this.db.prepare("SELECT * FROM pull_requests WHERE repo_id = ? AND number = ?").get(repoId, number) ?? notFound("Pull request not found");
+    }
+    nextNumber(repoId) {
+        this.db.prepare("UPDATE repositories SET entity_counter = entity_counter + 1 WHERE id = ?").run(repoId);
+        const row = this.db.prepare("SELECT entity_counter AS next FROM repositories WHERE id = ?").get(repoId);
+        return row.next;
+    }
+    bumpEntityCounter(repoId, number) {
+        this.db.prepare("UPDATE repositories SET entity_counter = CASE WHEN entity_counter < ? THEN ? ELSE entity_counter END WHERE id = ?").run(number, number, repoId);
+    }
+    audit(action, repoFullName, payload) {
+        this.db.prepare("INSERT INTO audit_log (ts, action, repo_full_name, payload_json) VALUES (?, ?, ?, ?)").run(nowIso(), action, repoFullName, JSON.stringify(payload));
+    }
+}
+//# sourceMappingURL=github-domain.js.map