Lyon
368 lines
15 KiB
TypeScript
368 lines
15 KiB
TypeScript
// SPEC: PJ2026-010606 GitHub入口 draft-2026-06-25-gh-split
|
|
// Moved mechanically from scripts/src/gh.ts:7148-7472.
|
|
|
|
import path from "node:path";
|
|
import { bodySha, preview, previewLines, readIssueLifecycleCommentBody, repoParts } from "./auth-and-safety";
|
|
import { assertConcurrencyOptions, validateCommentConcurrency } from "./body-guards";
|
|
import { applyVirtualBodyPatch, bodyPatchErrorSummary, readBodyPatch, readIssueCommentBody } from "./body-input";
|
|
import { commandError, githubRequest, isGitHubError, issueBodyReadCommands, issueCommentReadCommands, validationError, writeBodyPlan } from "./client";
|
|
import { getIssueComment } from "./issue-read";
|
|
import { issueLifecycleDisclosure, issueLifecycleSummary } from "./issue-summary";
|
|
import { isRecord } from "./notify-claudeqq";
|
|
import { commentSummary, compactCommentSummary, ghShort, ghTable, ghText } from "./render";
|
|
import type { GitHubCommandResult, GitHubComment, GitHubIssue, GitHubOptions } from "./types";
|
|
|
|
export function withIssueCommentCreateRendered(result: GitHubCommandResult): GitHubCommandResult {
|
|
return {
|
|
...result,
|
|
contentType: "text/plain",
|
|
renderedText: renderIssueCommentCreateTable(result),
|
|
};
|
|
}
|
|
|
|
export function renderIssueCommentCreateTable(result: GitHubCommandResult): string {
|
|
const comment = isRecord(result.comment) ? result.comment : {};
|
|
const readCommands = isRecord(result.readCommands) ? result.readCommands : {};
|
|
const status = result.dryRun === true ? "dry-run" : "created";
|
|
const issueNumber = ghText(result.issueNumber);
|
|
const commentId = ghText(comment.id ?? result.commentId);
|
|
const sourceKind = isRecord(result.bodySource) ? result.bodySource.kind : result.source;
|
|
const lines = [
|
|
`gh issue comment create (${status})`,
|
|
"",
|
|
ghTable(["ISSUE", "COMMENT", "STATUS", "BODY", "URL"], [[
|
|
issueNumber === "-" ? "-" : `#${issueNumber}`,
|
|
commentId,
|
|
status,
|
|
`${ghText(result.bodyChars ?? comment.bodyChars)} chars`,
|
|
ghShort(ghText(comment.url ?? result.url), 96),
|
|
]]),
|
|
"",
|
|
"Summary:",
|
|
` repo=${ghText(result.repo)} source=${ghText(sourceKind)} bodySha=${ghText(result.bodySha ?? comment.bodySha)}`,
|
|
"",
|
|
"Next:",
|
|
` ${ghText(readCommands.comments ?? readCommands.full ?? readCommands.raw)}`,
|
|
"",
|
|
"Disclosure:",
|
|
" default view is a bounded table; use --full/--raw or the read command for full comment metadata/body.",
|
|
];
|
|
return lines.join("\n");
|
|
}
|
|
|
|
export async function issueComment(repo: string, token: string, issueNumber: number, options: GitHubOptions): Promise<GitHubCommandResult> {
|
|
let bodyInput: { body: string; bodySource: Record<string, unknown> };
|
|
try {
|
|
bodyInput = readIssueCommentBody(options, "issue comment create");
|
|
} catch (error) {
|
|
return validationError("issue comment create", repo, error instanceof Error ? error.message : String(error), { issueNumber });
|
|
}
|
|
const { body, bodySource } = bodyInput;
|
|
if (options.dryRun) {
|
|
return withIssueCommentCreateRendered({
|
|
ok: true,
|
|
command: "issue comment create",
|
|
repo,
|
|
dryRun: true,
|
|
planned: true,
|
|
issueNumber,
|
|
readCommands: issueCommentReadCommands(repo, issueNumber),
|
|
...writeBodyPlan("issue comment create", repo, body, bodySource, { issueNumber }),
|
|
});
|
|
}
|
|
const { owner, name } = repoParts(repo);
|
|
const comment = await githubRequest<GitHubComment>(token, "POST", `/repos/${owner}/${name}/issues/${issueNumber}/comments`, { body });
|
|
if (isGitHubError(comment)) return commandError("issue comment", repo, comment, { issueNumber });
|
|
return withIssueCommentCreateRendered({
|
|
ok: true,
|
|
command: "issue comment create",
|
|
repo,
|
|
issueNumber,
|
|
comment: compactCommentSummary(comment),
|
|
bodySource,
|
|
bodyChars: body.length,
|
|
bodySha: bodySha(body),
|
|
bodyPreview: preview(body),
|
|
source: String(bodySource.kind ?? "unknown"),
|
|
readCommands: issueCommentReadCommands(repo, issueNumber),
|
|
rest: true,
|
|
});
|
|
}
|
|
|
|
export async function commentPatch(repo: string, token: string, ownerKind: "issue" | "pr", commentId: number, options: GitHubOptions, commandName?: string): Promise<GitHubCommandResult> {
|
|
const command = commandName ?? `${ownerKind} comment patch`;
|
|
const concurrencyOptionError = assertConcurrencyOptions(options, command);
|
|
if (concurrencyOptionError !== null) return concurrencyOptionError;
|
|
let patchInput: { patch: string; patchSource: Record<string, unknown> };
|
|
try {
|
|
patchInput = readBodyPatch(options, command);
|
|
} catch (error) {
|
|
return validationError(command, repo, error instanceof Error ? error.message : String(error), { commentId });
|
|
}
|
|
const { patch, patchSource } = patchInput;
|
|
const readCommands = ownerKind === "issue"
|
|
? {
|
|
comments: `bun scripts/cli.ts gh issue view <issueNumber> --repo ${repo} --json comments`,
|
|
full: `bun scripts/cli.ts gh issue view <issueNumber> --repo ${repo} --full`,
|
|
note: "GitHub comment patch targets commentId directly; use the owning issue number to read the surrounding comments.",
|
|
}
|
|
: {
|
|
comments: `bun scripts/cli.ts gh issue view <prNumber> --repo ${repo} --json comments`,
|
|
full: `bun scripts/cli.ts gh issue view <prNumber> --repo ${repo} --full`,
|
|
note: "GitHub PR comments are issue comments; use the owning PR number through gh issue view to read the surrounding comments.",
|
|
};
|
|
const oldComment = await getIssueComment(token, repo, commentId);
|
|
if (isGitHubError(oldComment)) return commandError(command, repo, oldComment, { commentId, phase: "read-before-patch" });
|
|
const concurrencyError = validateCommentConcurrency(repo, commentId, oldComment, options, command);
|
|
if (concurrencyError !== null) return concurrencyError;
|
|
const oldBody = oldComment.body ?? "";
|
|
let patched: { newBody: string; patchSummary: Record<string, unknown> };
|
|
try {
|
|
patched = applyVirtualBodyPatch("comment.md", oldBody, patch);
|
|
} catch (error) {
|
|
return validationError(command, repo, "body patch failed; no GitHub write performed", {
|
|
commentId,
|
|
patchSource,
|
|
patchError: bodyPatchErrorSummary(error),
|
|
oldBody: {
|
|
bodyChars: oldBody.length,
|
|
bodySha: bodySha(oldBody),
|
|
updatedAt: oldComment.updated_at ?? null,
|
|
},
|
|
noWrite: true,
|
|
});
|
|
}
|
|
const bodyChange = {
|
|
oldBodyChars: oldBody.length,
|
|
newBodyChars: patched.newBody.length,
|
|
deltaChars: patched.newBody.length - oldBody.length,
|
|
oldBodySha: bodySha(oldBody),
|
|
newBodySha: bodySha(patched.newBody),
|
|
oldUpdatedAt: oldComment.updated_at ?? null,
|
|
};
|
|
const concurrency = {
|
|
checked: true,
|
|
oldCommentUpdatedAt: oldComment.updated_at ?? null,
|
|
oldBodySha: bodySha(oldBody),
|
|
expectUpdatedAt: options.expectUpdatedAt ?? null,
|
|
expectBodySha: options.expectBodySha ?? null,
|
|
};
|
|
if (options.dryRun) {
|
|
return {
|
|
ok: true,
|
|
command,
|
|
repo,
|
|
dryRun: true,
|
|
planned: true,
|
|
commentId,
|
|
patchSource,
|
|
patch: patched.patchSummary,
|
|
bodyPreview: preview(patched.newBody),
|
|
bodyPreviewLines: previewLines(patched.newBody, 4),
|
|
bodyChars: patched.newBody.length,
|
|
bodySha: bodySha(patched.newBody),
|
|
bodyChange,
|
|
concurrency: { ...concurrency, dryRunNoWrite: true },
|
|
readCommands,
|
|
wouldPatch: {
|
|
commentId,
|
|
bodyChars: patched.newBody.length,
|
|
bodySha: bodySha(patched.newBody),
|
|
method: "PATCH",
|
|
path: `/repos/{owner}/{repo}/issues/comments/${commentId}`,
|
|
},
|
|
};
|
|
}
|
|
const { owner, name } = repoParts(repo);
|
|
const comment = await githubRequest<GitHubComment>(token, "PATCH", `/repos/${owner}/${name}/issues/comments/${commentId}`, { body: patched.newBody });
|
|
if (isGitHubError(comment)) return commandError(command, repo, comment, { commentId });
|
|
return {
|
|
ok: true,
|
|
command,
|
|
repo,
|
|
commentId,
|
|
comment: compactCommentSummary(comment),
|
|
patchSource,
|
|
patch: patched.patchSummary,
|
|
bodyChange: {
|
|
...bodyChange,
|
|
newUpdatedAt: comment.updated_at ?? null,
|
|
},
|
|
concurrency,
|
|
readCommands,
|
|
request: {
|
|
method: "PATCH",
|
|
path: `/repos/${owner}/${name}/issues/comments/${commentId}`,
|
|
bodyChars: patched.newBody.length,
|
|
},
|
|
rest: true,
|
|
};
|
|
}
|
|
|
|
export async function commentUpdate(repo: string, token: string, ownerKind: "issue" | "pr", commentId: number, options: GitHubOptions, commandName?: string): Promise<GitHubCommandResult> {
|
|
const command = commandName ?? `${ownerKind} comment update`;
|
|
let bodyInput: { body: string; bodySource: Record<string, unknown> };
|
|
try {
|
|
bodyInput = readIssueCommentBody(options, command);
|
|
} catch (error) {
|
|
return validationError(command, repo, error instanceof Error ? error.message : String(error), { commentId });
|
|
}
|
|
const { body, bodySource } = bodyInput;
|
|
const readCommands = ownerKind === "issue"
|
|
? {
|
|
comments: `bun scripts/cli.ts gh issue view <issueNumber> --repo ${repo} --json comments`,
|
|
full: `bun scripts/cli.ts gh issue view <issueNumber> --repo ${repo} --full`,
|
|
note: "GitHub comment update targets commentId directly; use the owning issue number to read the surrounding comments.",
|
|
}
|
|
: {
|
|
comments: `bun scripts/cli.ts gh issue view <prNumber> --repo ${repo} --json comments`,
|
|
full: `bun scripts/cli.ts gh issue view <prNumber> --repo ${repo} --full`,
|
|
note: "GitHub PR comments are issue comments; use the owning PR number through gh issue view to read the surrounding comments.",
|
|
};
|
|
const writePlanCommand = ownerKind === "issue" ? "issue comment update" : "pr comment update";
|
|
if (options.dryRun) {
|
|
return {
|
|
ok: true,
|
|
command,
|
|
repo,
|
|
dryRun: true,
|
|
planned: true,
|
|
commentId,
|
|
readCommands,
|
|
...writeBodyPlan(writePlanCommand, repo, body, bodySource, { commentId }),
|
|
};
|
|
}
|
|
const { owner, name } = repoParts(repo);
|
|
const comment = await githubRequest<GitHubComment>(token, "PATCH", `/repos/${owner}/${name}/issues/comments/${commentId}`, { body });
|
|
if (isGitHubError(comment)) return commandError(command, repo, comment, { commentId });
|
|
return {
|
|
ok: true,
|
|
command,
|
|
repo,
|
|
commentId,
|
|
comment: compactCommentSummary(comment),
|
|
bodySource,
|
|
bodyChars: body.length,
|
|
bodySha: bodySha(body),
|
|
bodyPreview: preview(body),
|
|
source: String(bodySource.kind ?? "unknown"),
|
|
readCommands,
|
|
request: {
|
|
method: "PATCH",
|
|
path: `/repos/${owner}/${name}/issues/comments/${commentId}`,
|
|
bodyChars: body.length,
|
|
},
|
|
rest: true,
|
|
};
|
|
}
|
|
|
|
export async function commentView(repo: string, token: string, ownerKind: "issue" | "pr", commentId: number, includeBody: boolean, commandName?: string): Promise<GitHubCommandResult> {
|
|
const command = commandName ?? `${ownerKind} comment view`;
|
|
const comment = await getIssueComment(token, repo, commentId);
|
|
if (isGitHubError(comment)) return commandError(command, repo, comment, { commentId });
|
|
const body = comment.body ?? "";
|
|
return {
|
|
ok: true,
|
|
command,
|
|
repo,
|
|
commentId,
|
|
comment: includeBody ? commentSummary(comment) : compactCommentSummary(comment),
|
|
bodyChars: body.length,
|
|
bodySha: bodySha(body),
|
|
bodyOmitted: !includeBody,
|
|
fullBodyIncluded: includeBody,
|
|
readCommands: {
|
|
compact: `bun scripts/cli.ts gh ${ownerKind} comment view ${commentId} --repo ${repo}`,
|
|
full: `bun scripts/cli.ts gh ${ownerKind} comment view ${commentId} --repo ${repo} --full`,
|
|
raw: `bun scripts/cli.ts gh ${ownerKind} comment view ${commentId} --repo ${repo} --raw`,
|
|
},
|
|
request: {
|
|
method: "GET",
|
|
path: `/repos/{owner}/{repo}/issues/comments/${commentId}`,
|
|
},
|
|
rest: true,
|
|
};
|
|
}
|
|
|
|
export async function commentDelete(repo: string, token: string, ownerKind: "issue" | "pr", commentId: number, dryRun: boolean): Promise<GitHubCommandResult> {
|
|
const command = `${ownerKind} comment delete`;
|
|
const { owner, name } = repoParts(repo);
|
|
if (dryRun) {
|
|
return {
|
|
ok: true,
|
|
command,
|
|
repo,
|
|
dryRun: true,
|
|
planned: true,
|
|
commentId,
|
|
request: { method: "DELETE", path: `/repos/{owner}/{repo}/issues/comments/${commentId}` },
|
|
};
|
|
}
|
|
const result = await githubRequest<null>(token, "DELETE", `/repos/${owner}/${name}/issues/comments/${commentId}`);
|
|
if (isGitHubError(result)) return commandError(command, repo, result, { commentId });
|
|
return {
|
|
ok: true,
|
|
command,
|
|
repo,
|
|
commentId,
|
|
deleted: true,
|
|
request: { method: "DELETE", path: `/repos/${owner}/${name}/issues/comments/${commentId}` },
|
|
rest: true,
|
|
};
|
|
}
|
|
|
|
export async function issueState(repo: string, token: string, issueNumber: number, state: "open" | "closed", dryRun: boolean, options?: GitHubOptions): Promise<GitHubCommandResult> {
|
|
const command = state === "closed" ? "issue close" : "issue reopen";
|
|
let lifecycleComment: { body: string; bodySource: Record<string, unknown> } | null = null;
|
|
try {
|
|
lifecycleComment = options === undefined ? null : readIssueLifecycleCommentBody(options, command);
|
|
} catch (error) {
|
|
return validationError(command, repo, error instanceof Error ? error.message : String(error), { issueNumber });
|
|
}
|
|
if (dryRun) {
|
|
return {
|
|
ok: true,
|
|
command,
|
|
dryRun: true,
|
|
repo,
|
|
issueNumber,
|
|
disclosure: issueLifecycleDisclosure(repo, issueNumber, true),
|
|
readCommands: issueBodyReadCommands(repo, issueNumber),
|
|
comment: lifecycleComment === null
|
|
? null
|
|
: {
|
|
planned: true,
|
|
...writeBodyPlan("issue comment create", repo, lifecycleComment.body, lifecycleComment.bodySource, { issueNumber }),
|
|
},
|
|
wouldPatch: { state },
|
|
};
|
|
}
|
|
const { owner, name } = repoParts(repo);
|
|
let commentSummary: Record<string, unknown> | null = null;
|
|
if (lifecycleComment !== null) {
|
|
const comment = await githubRequest<GitHubComment>(token, "POST", `/repos/${owner}/${name}/issues/${issueNumber}/comments`, { body: lifecycleComment.body });
|
|
if (isGitHubError(comment)) {
|
|
return commandError(command, repo, comment, {
|
|
issueNumber,
|
|
phase: "comment",
|
|
commentBodySource: lifecycleComment.bodySource,
|
|
commentBodyChars: lifecycleComment.body.length,
|
|
commentBodySha: bodySha(lifecycleComment.body),
|
|
});
|
|
}
|
|
commentSummary = compactCommentSummary(comment);
|
|
}
|
|
const issue = await githubRequest<GitHubIssue>(token, "PATCH", `/repos/${owner}/${name}/issues/${issueNumber}`, { state });
|
|
if (isGitHubError(issue)) return commandError(command, repo, issue, { issueNumber, phase: "state", comment: commentSummary });
|
|
return {
|
|
ok: true,
|
|
command,
|
|
repo,
|
|
comment: commentSummary,
|
|
issue: issueLifecycleSummary(issue),
|
|
disclosure: issueLifecycleDisclosure(repo, issueNumber, false),
|
|
readCommands: issueBodyReadCommands(repo, issueNumber),
|
|
rest: true,
|
|
};
|
|
}
|