@evanpurkhiser/tooling-personal 1.44.0 → 1.46.0

package/dist/assignees.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.selectAssignee = exports.AssigneeType = void 0;
+exports.getAssignees = getAssignees;
 const chalk_1 = __importDefault(require("chalk"));
 const fast_merge_async_iterators_1 = __importDefault(require("fast-merge-async-iterators"));
 const graphql_request_1 = require("graphql-request");

package/dist/blame.js

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDiff = parseDiff;
+exports.blameFile = blameFile;
+exports.aggregateBlame = aggregateBlame;
+const simple_git_1 = __importDefault(require("simple-git"));
+function hunkFromHeader(line, contextWindow) {
+    const match = line.match(/^@@ -(\d+)(?:,(\d+))?/);
+    if (!match) {
+        return null;
+    }
+    const oldStart = Number(match[1]);
+    const oldCount = match[2] === undefined ? 1 : Number(match[2]);
+    if (oldCount === 0) {
+        return {
+            start: Math.max(1, oldStart - contextWindow + 1),
+            end: oldStart + contextWindow,
+        };
+    }
+    return { start: oldStart, end: oldStart + oldCount - 1 };
+}
+function parseFileSection(section, contextWindow) {
+    const lines = section.split('\n');
+    const fromLine = lines.find(l => l.startsWith('--- '));
+    const toLine = lines.find(l => l.startsWith('+++ '));
+    if (!fromLine || !toLine) {
+        return null;
+    }
+    const fromPath = fromLine.slice(4);
+    const toPath = toLine.slice(4);
+    // Skip added files (no prior history) and deleted files.
+    if (fromPath === '/dev/null' || toPath === '/dev/null') {
+        return null;
+    }
+    // Blame the old path at `rev` so rename-with-edits hits the right file.
+    const file = fromPath.startsWith('a/') ? fromPath.slice(2) : fromPath;
+    const hunks = lines
+        .filter(l => l.startsWith('@@'))
+        .map(l => hunkFromHeader(l, contextWindow))
+        .filter((r) => r !== null);
+    return hunks.length > 0 ? { file, hunks } : null;
+}
+/**
+ * Parse a unified diff into per-file old-side line ranges. Pure insertions
+ * expand to a small context window so nearby lines still contribute. Added
+ * files (from /dev/null) are skipped.
+ */
+function parseDiff(diff, contextWindow = 3) {
+    return diff
+        .split(/^diff --git /m)
+        .slice(1)
+        .map(section => parseFileSection(section, contextWindow))
+        .filter((f) => f !== null);
+}
+function mergeRanges(ranges) {
+    if (ranges.length === 0) {
+        return [];
+    }
+    const sorted = [...ranges].sort((a, b) => a.start - b.start);
+    const merged = [{ ...sorted[0] }];
+    for (let i = 1; i < sorted.length; i++) {
+        const last = merged[merged.length - 1];
+        const curr = sorted[i];
+        if (curr.start <= last.end + 1) {
+            last.end = Math.max(last.end, curr.end);
+        }
+        else {
+            merged.push({ ...curr });
+        }
+    }
+    return merged;
+}
+function lineInRanges(line, ranges) {
+    return ranges.some(r => line >= r.start && line <= r.end);
+}
+/**
+ * Blame the full file at `rev`, tallying per-author totals over the whole
+ * file and the subset of lines inside the given hunk ranges.
+ */
+async function blameFile(file, hunks, rev) {
+    const empty = {
+        fileLines: new Map(),
+        hunkLines: new Map(),
+        authorNames: new Map(),
+        fileTotal: 0,
+        hunkTotal: 0,
+    };
+    let output;
+    try {
+        output = await (0, simple_git_1.default)().raw(['blame', '--porcelain', rev, '--', file]);
+    }
+    catch {
+        return empty;
+    }
+    const merged = mergeRanges(hunks);
+    const shaToEmail = new Map();
+    const shaToName = new Map();
+    const entries = [];
+    // 01. Parse porcelain into per-line blame entries + per-sha author headers
+    for (const line of output.split('\n')) {
+        const shaMatch = line.match(/^([0-9a-f]{40}) \d+ (\d+)(?: \d+)?$/);
+        if (shaMatch) {
+            entries.push({ sha: shaMatch[1], finalLine: Number(shaMatch[2]) });
+            continue;
+        }
+        const last = entries[entries.length - 1];
+        if (!last) {
+            continue;
+        }
+        if (line.startsWith('author-mail ')) {
+            const email = line.slice('author-mail '.length).replace(/^<|>$/g, '');
+            if (!shaToEmail.has(last.sha)) {
+                shaToEmail.set(last.sha, email);
+            }
+        }
+        else if (line.startsWith('author ')) {
+            const name = line.slice('author '.length);
+            if (!shaToName.has(last.sha)) {
+                shaToName.set(last.sha, name);
+            }
+        }
+    }
+    // 02. Tally per-author counts, splitting hunk vs file totals
+    const fileLines = new Map();
+    const hunkLines = new Map();
+    const authorNames = new Map();
+    let fileTotal = 0;
+    let hunkTotal = 0;
+    for (const { sha, finalLine } of entries) {
+        const email = shaToEmail.get(sha);
+        if (!email) {
+            continue;
+        }
+        fileLines.set(email, (fileLines.get(email) ?? 0) + 1);
+        fileTotal++;
+        if (lineInRanges(finalLine, merged)) {
+            hunkLines.set(email, (hunkLines.get(email) ?? 0) + 1);
+            hunkTotal++;
+        }
+        const name = shaToName.get(sha);
+        if (name && !authorNames.has(email)) {
+            authorNames.set(email, name);
+        }
+    }
+    return { fileLines, hunkLines, authorNames, fileTotal, hunkTotal };
+}
+/**
+ * Blame every file in parallel and fold the per-file results together.
+ */
+async function aggregateBlame(fileHunks, rev) {
+    const results = await Promise.all(fileHunks.map(({ file, hunks }) => blameFile(file, hunks, rev)));
+    const agg = {
+        fileLines: new Map(),
+        hunkLines: new Map(),
+        authorNames: new Map(),
+        fileTotal: 0,
+        hunkTotal: 0,
+    };
+    for (const r of results) {
+        agg.fileTotal += r.fileTotal;
+        agg.hunkTotal += r.hunkTotal;
+        for (const [email, n] of r.fileLines) {
+            agg.fileLines.set(email, (agg.fileLines.get(email) ?? 0) + n);
+        }
+        for (const [email, n] of r.hunkLines) {
+            agg.hunkLines.set(email, (agg.hunkLines.get(email) ?? 0) + n);
+        }
+        for (const [email, name] of r.authorNames) {
+            if (!agg.authorNames.has(email)) {
+                agg.authorNames.set(email, name);
+            }
+        }
+    }
+    return agg;
+}

package/dist/cherry-pick.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cherryPickOnto = cherryPickOnto;
+const simple_git_1 = __importDefault(require("simple-git"));
+/**
+ * Build a commit object equivalent to cherry-picking `sha` onto `base`, without
+ * touching the working tree or any ref.
+ *
+ * Uses `git merge-tree --write-tree` (git >= 2.38) to produce the merged tree
+ * in the object database, then `git commit-tree` to wrap it in a commit whose
+ * parent is `base`. Author info and the full commit message are preserved from
+ * the original commit; the committer is the current user (mirrors the way
+ * `git rebase` / `git cherry-pick` work).
+ *
+ * Throws if the three-way merge has conflicts.
+ */
+async function cherryPickOnto(sha, base) {
+    const git = (0, simple_git_1.default)();
+    const parentSha = (await git.revparse([`${sha}^`])).trim();
+    const baseSha = (await git.revparse([base])).trim();
+    let treeOid;
+    try {
+        treeOid = (await git.raw([
+            'merge-tree',
+            '--write-tree',
+            '--no-messages',
+            `--merge-base=${parentSha}`,
+            baseSha,
+            sha,
+        ])).trim();
+    }
+    catch (error) {
+        throw new Error(`Conflicts applying ${sha.slice(0, 8)} onto ${base}. Rebase locally and retry.\n${error}`);
+    }
+    const info = await git.raw(['show', '-s', '--format=%an%n%ae%n%aI%n%B', sha]);
+    const lines = info.split('\n');
+    const authorName = lines[0];
+    const authorEmail = lines[1];
+    const authorDate = lines[2];
+    const message = lines.slice(3).join('\n').replace(/\n+$/, '');
+    const newCommit = await git
+        .env({
+        ...process.env,
+        GIT_AUTHOR_NAME: authorName,
+        GIT_AUTHOR_EMAIL: authorEmail,
+        GIT_AUTHOR_DATE: authorDate,
+    })
+        .raw(['commit-tree', treeOid, '-p', baseSha, '-m', message]);
+    return newCommit.trim();
+}

package/dist/cmd/pr-create.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prCreate = prCreate;
+const chalk_1 = __importDefault(require("chalk"));
+const open_1 = __importDefault(require("open"));
+const simple_git_1 = __importDefault(require("simple-git"));
+const assignees_1 = require("../assignees");
+const cherry_pick_1 = require("../cherry-pick");
+const pulls_1 = require("../pulls");
+const utils_1 = require("../utils");
+async function readStdin() {
+    if (process.stdin.isTTY) {
+        return '';
+    }
+    process.stdin.setEncoding('utf8');
+    let data = '';
+    for await (const chunk of process.stdin) {
+        data += chunk;
+    }
+    return data.trim();
+}
+function parseSlugs(input) {
+    return (input ?? '')
+        .split(',')
+        .map(s => s.trim().replace(/^@/, ''))
+        .filter(Boolean);
+}
+async function resolveReviewers(repo, slugs) {
+    if (slugs.length === 0) {
+        return [];
+    }
+    const want = new Set(slugs.map(s => s.toLowerCase()));
+    const found = [];
+    for await (const assignee of (0, assignees_1.getAssignees)(repo)) {
+        const key = assignee.slug.toLowerCase();
+        if (want.has(key)) {
+            found.push(assignee);
+            want.delete(key);
+            if (want.size === 0) {
+                break;
+            }
+        }
+    }
+    if (want.size > 0) {
+        throw new Error(`Could not resolve reviewer(s): ${[...want].join(', ')}`);
+    }
+    return found;
+}
+async function prCreate(argv) {
+    if (!argv.title) {
+        throw new Error('--title is required');
+    }
+    const username = await (0, utils_1.getEmailUsername)();
+    const repo = await (0, utils_1.getRepoKey)();
+    const { head, origin } = await (0, utils_1.getBranchNames)();
+    if (head === null) {
+        throw new Error('Cannot determine HEAD branch name');
+    }
+    if (origin === null) {
+        throw new Error('Cannot determine upstream HEAD branch name');
+    }
+    const body = await readStdin();
+    const unpublished = (0, simple_git_1.default)().log({ from: 'HEAD', to: origin });
+    const [repoDetails, commits, prs] = await Promise.all([
+        (0, pulls_1.getRepoInfo)(repo),
+        unpublished,
+        (0, pulls_1.getPulls)(repo),
+    ]);
+    if (repoDetails === null) {
+        throw new Error('Failed to get repository ID');
+    }
+    const commit = commits.all.find(c => c.hash.startsWith(argv.sha));
+    if (!commit) {
+        throw new Error(`Commit ${argv.sha} not found in unpublished commits`);
+    }
+    const branchName = (0, utils_1.branchFromMessage)(username, commit.message);
+    const existingPr = prs.find(p => p.headRefName === branchName);
+    if (argv.updateOnly && !existingPr) {
+        throw new Error(`No existing PR for branch ${branchName}`);
+    }
+    const reviewerSlugs = parseSlugs(argv.reviewer);
+    // Reviewers only apply on PR creation (matches `pt pr` behavior).
+    const reviewers = existingPr ? [] : await resolveReviewers(repo, reviewerSlugs);
+    console.error(chalk_1.default.gray(`Cherry-picking ${commit.hash.slice(0, 8)} onto ${origin}`));
+    const newSha = await (0, cherry_pick_1.cherryPickOnto)(commit.hash, origin);
+    console.error(chalk_1.default.gray(`Pushing ${branchName}`));
+    await (0, simple_git_1.default)().push(['--force', 'origin', `${newSha}:refs/heads/${branchName}`]);
+    if (existingPr) {
+        const url = `https://github.com/${repo.fullName}/pull/${existingPr.number}`;
+        console.error(chalk_1.default.green(`Updated existing PR #${existingPr.number}: ${existingPr.title}`));
+        console.log(url);
+        return;
+    }
+    console.error(chalk_1.default.gray('Creating Pull Request'));
+    const { createPullRequest } = await (0, pulls_1.createPull)({
+        baseRefName: repoDetails.defaultBranch,
+        headRefName: branchName,
+        repositoryId: repoDetails.repoId,
+        draft: argv.draft,
+        title: argv.title,
+        body,
+    });
+    const pr = createPullRequest.pullRequest;
+    if (argv.autoMerge) {
+        try {
+            await (0, pulls_1.enableAutoMerge)({ pullRequestId: pr.id, mergeMethod: 'SQUASH' });
+        }
+        catch {
+            console.error(chalk_1.default.yellow('Auto merge not available, skipping'));
+        }
+    }
+    if (reviewers.length > 0) {
+        await (0, pulls_1.requestReview)({
+            pullRequestId: pr.id,
+            userIds: reviewers.filter(r => r.type === assignees_1.AssigneeType.User).map(r => r.id),
+            teamIds: reviewers.filter(r => r.type === assignees_1.AssigneeType.Team).map(r => r.id),
+        });
+    }
+    console.error(chalk_1.default.green(`Created PR: ${pr.url}`));
+    console.log(pr.url);
+    if (!argv.noOpen) {
+        await (0, open_1.default)(pr.url);
+    }
+}

package/dist/cmd/pr.js

@@ -9,6 +9,7 @@ const listr2_1 = require("listr2");
 const open_1 = __importDefault(require("open"));
 const simple_git_1 = __importDefault(require("simple-git"));
 const assignees_1 = require("../assignees");
+const cherry_pick_1 = require("../cherry-pick");
 const editor_1 = require("../editor");
 const fzf_1 = require("../fzf");
 const pulls_1 = require("../pulls");
@@ -62,8 +63,9 @@ async function pr(argv) {
         },
     });
     const { repoId, defaultBranch, commits, prs } = await collectInfoTask.run();
-    const selectCommits = () => (0, fzf_1.fzfSelect)({
-        prompt: 'Select commit(s) for PR:',
+    const pickCommit = () => (0, fzf_1.fzfSelect)({
+        prompt: 'Select commit for PR:',
+        multi: false,
         genValues: addOption => commits.all.forEach(commit => {
             const branchName = (0, utils_1.branchFromMessage)(username, commit.message);
             const pr = prs.find(pr => pr.headRefName === branchName);
@@ -73,68 +75,44 @@ async function pr(argv) {
             addOption({ label, id: commit.hash, ...commit });
         }),
     });
-    // 01. Select which commits to turn into PRs
-    const selectedCommits = commits.total === 1
-        ? [{ id: commits.all[0].hash, ...commits.all[0] }]
-        : await selectCommits();
-    const selectedShas = selectedCommits.map(option => option.hash);
-    // 02. Re-order our commits when there are multiple
-    //     commits and the selected commits are not already at
-    //     the end of the list.
-    const rebaseContents = [
-        ...selectedShas,
-        ...commits.all
-            .filter(c => !selectedShas.includes(c.hash))
-            .map(c => c.hash)
-            .reverse(),
-    ]
-        .map(sha => `pick ${sha}`)
-        .join('\n');
-    const targetCommit = selectedCommits[selectedCommits.length - 1];
-    const branchName = (0, utils_1.branchFromMessage)(username, targetCommit.message);
+    // 01. Select which commit to turn into a PR
+    const selectedCommit = commits.total === 1
+        ? { id: commits.all[0].hash, ...commits.all[0] }
+        : (await pickCommit())[0];
+    if (!selectedCommit) {
+        console.log(chalk_1.default.red `No commit selected, aborting`);
+        process.exit(1);
+    }
+    const branchName = (0, utils_1.branchFromMessage)(username, selectedCommit.message);
     const willOpenPr = prs.some(pr => pr.headRefName === branchName);
-    // 03. Rebase and push the selected commits
-    const doRebase = async () => {
-        const rebase = (0, simple_git_1.default)()
-            .env({ ...process.env, GIT_SEQUENCE_EDITOR: `echo "${rebaseContents}" >` })
-            .rebase(['--interactive', '--autostash', origin]);
-        try {
-            await rebase;
-        }
-        catch (error) {
-            // Abort a failed rebase
-            await (0, simple_git_1.default)().rebase(['--abort']);
-            throw new Error(`Failed to rebase\n${error}`);
-        }
-    };
+    // 02. Build a branch-tip commit by cherry-picking the selected commit onto
+    //     origin/<default> via plumbing, then push that commit. Local main is
+    //     never touched.
     const doPush = async () => {
-        const newCommits = await getCommits(origin);
-        const commitIdx = newCommits.all.length - selectedCommits.length;
-        const rebaseTargetCommit = newCommits.all[commitIdx];
-        const refSpec = `${rebaseTargetCommit.hash}:refs/heads/${branchName}`;
+        const newSha = await (0, cherry_pick_1.cherryPickOnto)(selectedCommit.hash, origin);
+        const refSpec = `${newSha}:refs/heads/${branchName}`;
         await (0, simple_git_1.default)().push(['--force', 'origin', refSpec]);
     };
-    const rebaseAndPushTask = new listr2_1.Listr([], { rendererOptions });
-    rebaseAndPushTask.add({ title: 'Rebasing commits', task: doRebase });
-    rebaseAndPushTask.add({ title: 'Pushing to GitHub', task: doPush });
-    // 04. Nothing left to do if we just updated an existing
+    const pushTask = new listr2_1.Listr([], { rendererOptions });
+    pushTask.add({ title: 'Building and pushing commit', task: doPush });
+    // 03. Nothing left to do if we just updated an existing
     //     pull request.
     if (willOpenPr) {
-        await rebaseAndPushTask.run();
+        await pushTask.run();
         return;
     }
     // Cork stdout to avoid listr output polluting vim. We'll uncork after we
     // close vim
     process.stdout.cork();
-    // 05. Open an editor to write the pull request
-    const { editor, editorResult } = await (0, editor_1.editPullRequest)(targetCommit);
-    const rebaseAndPush = rebaseAndPushTask.run();
-    rebaseAndPush.catch(() => editor.kill());
+    // 04. Open an editor to write the pull request
+    const { editor, editorResult } = await (0, editor_1.editPullRequest)(selectedCommit);
+    const pushPromise = pushTask.run();
+    pushPromise.catch(() => editor.kill());
     const { title, body } = await editorResult;
     // XXX: We cork stdout here to avoid listr from corrupting vims output
     process.stdout.uncork();
     try {
-        await rebaseAndPush;
+        await pushPromise;
     }
     catch {
         process.exit(1);
@@ -164,12 +142,12 @@ async function pr(argv) {
         }
     };
     const prTasks = new listr2_1.Listr([], { rendererOptions });
-    // 06-a. Create a Pull Request
+    // 05-a. Create a Pull Request
     prTasks.add({
         title: 'Creating Pull Request',
         task: createPrTask,
     });
-    // 06-a. Enable auto merge
+    // 05-b. Enable auto merge
     prTasks.add({
         enabled: !!argv.autoMerge,
         title: 'Enabling auto merge',
@@ -181,7 +159,7 @@ async function pr(argv) {
     const reviewers = await (0, assignees_1.selectAssignee)(repo);
     const { pr } = await asyncPrTasks;
     process.stdout.uncork();
-    // 07. Request reviews
+    // 06. Request reviews
     const reviewRequestTask = new listr2_1.Listr([], { rendererOptions });
     reviewRequestTask.add({
         enabled: () => reviewers.length > 0,
@@ -193,6 +171,6 @@ async function pr(argv) {
         }),
     });
     await reviewRequestTask.run();
-    // 08. Open in browser
+    // 07. Open in browser
     (0, open_1.default)(pr.url);
 }

package/dist/cmd/suggest-assignees.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suggestAssignees = suggestAssignees;
+const simple_git_1 = __importDefault(require("simple-git"));
+const blame_1 = require("../blame");
+const config_1 = require("../config");
+const identity_1 = require("../identity");
+const utils_1 = require("../utils");
+async function getDiffSource(commit) {
+    const git = (0, simple_git_1.default)();
+    if (commit) {
+        const diff = await git.raw(['show', '-U0', '--format=', commit]);
+        const rev = (await git.revparse([`${commit}^`])).trim();
+        return { diff, rev, label: `commit ${commit}` };
+    }
+    const staged = await git.diff(['-U0', '--cached']);
+    if (staged.trim()) {
+        return { diff: staged, rev: 'HEAD', label: 'staged changes' };
+    }
+    const unstaged = await git.diff(['-U0']);
+    if (unstaged.trim()) {
+        return { diff: unstaged, rev: 'HEAD', label: 'unstaged changes' };
+    }
+    throw new Error('No staged or unstaged changes to suggest assignees for');
+}
+async function suggestAssignees(argv) {
+    const repo = await (0, utils_1.getRepoKey)();
+    const selfEmail = (await (0, simple_git_1.default)().raw('config', '--get', 'user.email')).trim();
+    // 01. Figure out what we're scoring against (staged, unstaged, or a commit)
+    const { diff, rev, label } = await getDiffSource(argv.commit);
+    const fileHunks = (0, blame_1.parseDiff)(diff);
+    if (fileHunks.length === 0) {
+        console.error(`No files with prior history in ${label}`);
+        if (argv.format === 'slugs') {
+            console.log('');
+        }
+        else {
+            console.log(JSON.stringify({ source: label, fileTotal: 0, hunkTotal: 0, suggestions: [], unresolved: [] }, null, 2));
+        }
+        return;
+    }
+    // 02. Blame every file + resolve the repo's assignable user directory
+    const [blame, resolver] = await Promise.all([
+        (0, blame_1.aggregateBlame)(fileHunks, rev),
+        (0, identity_1.buildResolver)(repo),
+    ]);
+    // 03. Score each author: weighted combination of hunk and file ownership
+    const ignoreRegexes = config_1.config.get('ignoreAssignees').map(value => new RegExp(value));
+    const emails = new Set([...blame.fileLines.keys(), ...blame.hunkLines.keys()]);
+    const scored = [];
+    for (const email of emails) {
+        if (email.toLowerCase() === selfEmail.toLowerCase()) {
+            continue;
+        }
+        const login = resolver.resolve(email, blame.authorNames.get(email));
+        if (login && ignoreRegexes.some(r => r.test(login))) {
+            continue;
+        }
+        const fileLines = blame.fileLines.get(email) ?? 0;
+        const hunkLines = blame.hunkLines.get(email) ?? 0;
+        const fileShare = blame.fileTotal > 0 ? fileLines / blame.fileTotal : 0;
+        const hunkShare = blame.hunkTotal > 0 ? hunkLines / blame.hunkTotal : 0;
+        const score = hunkShare * argv.hunkWeight + fileShare * (1 - argv.hunkWeight);
+        scored.push({
+            email,
+            name: blame.authorNames.get(email),
+            login,
+            fileLines,
+            hunkLines,
+            fileShare,
+            hunkShare,
+            score,
+        });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    const resolved = scored.filter(s => s.login !== null);
+    const unresolved = scored.filter(s => s.login === null);
+    const top = resolved.slice(0, argv.limit);
+    // 04. Render
+    if (argv.format === 'slugs') {
+        console.log(top.map(s => s.login).join(','));
+        return;
+    }
+    console.log(JSON.stringify({
+        source: label,
+        fileTotal: blame.fileTotal,
+        hunkTotal: blame.hunkTotal,
+        suggestions: top,
+        unresolved,
+    }, null, 2));
+}

package/dist/fzf.js

@@ -2,15 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fzfSelect = fzfSelect;
 const child_process_1 = require("child_process");
-async function fzfSelect({ prompt, genValues, }) {
-    const fzf = (0, child_process_1.spawn)('fzf', [
+async function fzfSelect({ prompt, multi = true, genValues, }) {
+    const fzfArgs = [
         '--ansi',
         '--height=40%',
         '--reverse',
         `--header="${prompt}"`,
         '--with-nth=2..',
-        '-m',
-    ], { shell: true, stdio: ['pipe', 'pipe', 'inherit'] });
+    ];
+    if (multi) {
+        fzfArgs.push('-m');
+    }
+    const fzf = (0, child_process_1.spawn)('fzf', fzfArgs, { shell: true, stdio: ['pipe', 'pipe', 'inherit'] });
     fzf.stdin.setDefaultEncoding('utf-8');
     const options = {};
     const valuesDone = genValues(option => {

package/dist/identity.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAssignableUsers = loadAssignableUsers;
+exports.buildResolver = buildResolver;
+const graphql_request_1 = require("graphql-request");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = require("path");
+const graphql_1 = require("./graphql");
+function cachePath(repo) {
+    const base = process.env.XDG_CACHE_HOME || (0, path_1.join)(process.env.HOME ?? '', '.cache');
+    return (0, path_1.join)(base, 'pt', `assignees-${repo.owner}-${repo.repo}.json`);
+}
+async function readCache(repo) {
+    try {
+        const raw = await promises_1.default.readFile(cachePath(repo), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+async function writeCache(repo, users) {
+    const path = cachePath(repo);
+    await promises_1.default.mkdir((0, path_1.join)(path, '..'), { recursive: true });
+    await promises_1.default.writeFile(path, JSON.stringify(users));
+}
+/**
+ * Fetch every assignable user for a repo. Cached to disk indefinitely; pass
+ * `refresh` to force a refetch.
+ */
+async function loadAssignableUsers(repo, opts = {}) {
+    if (!opts.refresh) {
+        const cached = await readCache(repo);
+        if (cached) {
+            return cached;
+        }
+    }
+    // We don't request the `email` field here — it requires the
+    // `user:email` scope, which `gh auth token` doesn't grant by default.
+    const query = (0, graphql_request_1.gql) `
+    query userAssignees($owner: String!, $repo: String!, $cursor: String) {
+      repository(owner: $owner, name: $repo) {
+        assignableUsers(first: 100, after: $cursor) {
+          nodes {
+            login
+            name
+          }
+          pageInfo {
+            endCursor
+            hasNextPage
+          }
+        }
+      }
+    }
+  `;
+    const pages = (0, graphql_1.paginatedRequest)(query, { ...repo }, (obj) => obj.repository.assignableUsers.pageInfo);
+    const users = [];
+    for await (const page of pages) {
+        for (const node of page.repository.assignableUsers.nodes ?? []) {
+            if (!node) {
+                continue;
+            }
+            users.push({ login: node.login, name: node.name ?? null });
+        }
+    }
+    await writeCache(repo, users);
+    return users;
+}
+/**
+ * Extract the login from a GitHub noreply email.
+ *
+ *   `<id>+<login>@users.noreply.github.com`
+ *   `<login>@users.noreply.github.com`
+ */
+function parseNoreplyLogin(email) {
+    const m = email.match(/^(?:\d+\+)?([^@]+)@users\.noreply\.github\.com$/);
+    return m ? m[1] : null;
+}
+/**
+ * Strip emoji / punctuation, collapse whitespace, lowercase. Keeps letters
+ * from any script plus spaces and hyphens.
+ */
+function normalizeName(name) {
+    return name
+        .replace(/[^\p{L}\p{N}\s-]/gu, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
+function nameTokens(name) {
+    return new Set(normalizeName(name)
+        .split(/[\s-]+/)
+        .filter(t => t.length >= 2));
+}
+/**
+ * Build a resolver mapping git author emails to GitHub logins. Tries in
+ * order: noreply parse, exact name-to-login, normalized name match,
+ * unambiguous token-subset match.
+ */
+async function buildResolver(repo) {
+    const users = await loadAssignableUsers(repo);
+    const loginIndex = new Map();
+    const nameIndex = new Map();
+    const tokenizedUsers = [];
+    for (const u of users) {
+        loginIndex.set(u.login.toLowerCase(), u.login);
+        if (!u.name) {
+            continue;
+        }
+        const key = normalizeName(u.name);
+        if (key) {
+            // Mark as ambiguous on collision so we never guess the wrong user.
+            nameIndex.set(key, nameIndex.has(key) ? null : u.login);
+        }
+        const tokens = nameTokens(u.name);
+        if (tokens.size > 0) {
+            tokenizedUsers.push({ login: u.login, tokens });
+        }
+    }
+    function resolveByTokens(authorName) {
+        const authorTokens = nameTokens(authorName);
+        if (authorTokens.size < 2) {
+            return null;
+        }
+        const matches = tokenizedUsers.filter(u => [...authorTokens].every(t => u.tokens.has(t)));
+        return matches.length === 1 ? matches[0].login : null;
+    }
+    return {
+        resolve(email, authorName) {
+            const noreply = parseNoreplyLogin(email);
+            if (noreply) {
+                return noreply;
+            }
+            if (!authorName) {
+                return null;
+            }
+            const byLogin = loginIndex.get(authorName.toLowerCase().trim());
+            if (byLogin) {
+                return byLogin;
+            }
+            const byName = nameIndex.get(normalizeName(authorName));
+            if (byName) {
+                return byName;
+            }
+            return resolveByTokens(authorName);
+        },
+    };
+}

package/dist/index.js

@@ -7,7 +7,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const chalk_1 = __importDefault(require("chalk"));
 const yargs_1 = __importDefault(require("yargs"));
 const pr_1 = require("./cmd/pr");
+const pr_create_1 = require("./cmd/pr-create");
 const select_commit_1 = require("./cmd/select-commit");
+const suggest_assignees_1 = require("./cmd/suggest-assignees");
 (0, yargs_1.default)(process.argv.slice(2))
     .option('color', {
     boolean: true,
@@ -29,6 +31,64 @@ const select_commit_1 = require("./cmd/select-commit");
     boolean: true,
     desc: 'Enable auto merge for the PR',
 }), pr_1.pr)
+    .command('pr-create <sha>', 'Non-interactively create or update a PR for a single commit. Body is read from stdin.', y => y
+    .positional('sha', {
+    type: 'string',
+    demandOption: true,
+    desc: 'Commit SHA (full or prefix) to publish as a PR',
+})
+    .option('title', {
+    type: 'string',
+    demandOption: true,
+    desc: 'PR title',
+})
+    .option('reviewer', {
+    type: 'string',
+    desc: 'Comma-separated list of reviewers (user logins or org/team slugs)',
+})
+    .option('draft', {
+    alias: 'd',
+    boolean: true,
+    desc: 'Create PR as a draft',
+})
+    .option('autoMerge', {
+    alias: 'm',
+    boolean: true,
+    desc: 'Enable auto merge for the PR',
+})
+    .option('updateOnly', {
+    boolean: true,
+    desc: 'Only update an existing PR; fail if none exists for the generated branch',
+})
+    .option('noOpen', {
+    boolean: true,
+    desc: 'Do not open the PR in the browser after creation',
+}), pr_create_1.prCreate)
+    .command('suggest-assignees', 'Suggest reviewers for current diff based on blame ownership', y => y
+    .option('commit', {
+    type: 'string',
+    desc: 'Analyze the files changed in this commit instead of staged changes',
+})
+    .option('limit', {
+    type: 'number',
+    default: 3,
+    desc: 'Max number of suggestions',
+})
+    .option('format', {
+    type: 'string',
+    choices: ['slugs', 'json'],
+    default: 'slugs',
+    desc: 'Output format',
+})
+    .option('hunkWeight', {
+    type: 'number',
+    default: 0.7,
+    desc: 'Weight of hunk-level ownership vs whole-file ownership (0..1)',
+})
+    .option('refresh', {
+    boolean: true,
+    desc: 'Ignore the cached assignable-users list and refetch',
+}), suggest_assignees_1.suggestAssignees)
     .command('select-commit', 'Select a commit hash', select_commit_1.selectCommit)
     .demandCommand(1, '')
     .parse();

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@evanpurkhiser/tooling-personal",
-  "version": "1.44.0",
+  "version": "1.46.0",
   "description": "Evan Purkhiser's personal tooling",
   "license": "MIT",
   "author": "Evan Purkhiser",
@@ -16,7 +16,7 @@
   "scripts": {
     "build": "tsc && chmod +x ./dist/index.js",
     "start": "ts-node ./src/index.ts",
-    "lint": "oxlint src/**/*.ts",
+    "lint": "oxlint src",
     "format": "oxfmt .",
     "format:check": "oxfmt --check ."
   },