@kurokeita/add-skill 2.4.0 → 2.5.0

package/dist/skills/statusline-setup/mod/hooks/discover.ts

@@ -0,0 +1,142 @@
+import type { SessionMessage } from "claude-code"
+
+import type { CheckState, Step } from "../types"
+
+export type Platform = "github" | "azure"
+
+export function platformOf(remote: string): Platform | null {
+	if (/github\.com[:/]/.test(remote)) return "github"
+	if (/dev\.azure\.com[:/]|\.visualstudio\.com\//.test(remote)) return "azure"
+	return null
+}
+
+export function repoNameOf(remote: string): string {
+	return (
+		remote
+			.trim()
+			.replace(/\.git$/, "")
+			.split(/[/:]/)
+			.pop() ?? ""
+	).toLowerCase()
+}
+
+function decoded(name: string): string {
+	try {
+		return decodeURIComponent(name).toLowerCase()
+	} catch {
+		return name.toLowerCase()
+	}
+}
+
+// PR links anywhere in the conversation: a command's output (gh pr create and
+// gh pr edit print the URL), the model's own text, or a link the person pasted.
+// Only links into this repository count, since the fetch runs against it.
+export function prNumbersIn(
+	messages: readonly SessionMessage[],
+	platform: Platform,
+	repo: string,
+): number[] {
+	const pattern =
+		platform === "github"
+			? /github\.com\/[\w.-]+\/([\w.-]+)\/pull\/(\d{1,9})/g
+			: /_git\/([^/\s?#"']+)\/pullrequest\/(\d{1,9})/gi
+	const found = new Set<number>()
+	for (const message of messages) {
+		const texts = [message.text]
+		for (const use of message.toolUses)
+			texts.push(JSON.stringify(use.input), use.text ?? "")
+		for (const result of message.toolResults ?? []) texts.push(result.text)
+		for (const text of texts) {
+			for (const match of text.matchAll(pattern)) {
+				if (decoded(match[1] ?? "") === repo) found.add(Number(match[2]))
+			}
+		}
+	}
+	return [...found]
+}
+
+// Items a branch without a PR points at: a 3-9 digit segment of its name (plus
+// gh issue develop's "<n>-slug"), then AB#N or #N in its own commits. 9 digits
+// at most, as both APIs take 32-bit ids and one bad literal fails the query.
+export function itemRefs(
+	platform: Platform,
+	branch: string,
+	commitLog: string,
+): number[] {
+	const refs: string[] = []
+	const lead =
+		platform === "github" ? /^(\d{1,9})-/.exec(branch)?.[1] : undefined
+	if (lead) refs.push(lead)
+	refs.push(
+		...branch.split(/[^A-Za-z0-9]+/).filter((part) => /^\d{3,9}$/.test(part)),
+	)
+	const pattern = platform === "github" ? /#(\d{1,9})/g : /AB#(\d{1,9})/g
+	for (const match of commitLog.matchAll(pattern)) refs.push(match[1] ?? "")
+	return [...new Set(refs.filter(Boolean).map(Number))].slice(0, 10)
+}
+
+export function githubChecks(rollup: string | null | undefined): CheckState {
+	if (rollup === "SUCCESS") return "passing"
+	if (rollup === "FAILURE" || rollup === "ERROR") return "failing"
+	if (rollup === "PENDING" || rollup === "EXPECTED") return "pending"
+	return "none"
+}
+
+export function azureChecks(statuses: readonly string[]): CheckState {
+	if (statuses.some((s) => s === "rejected" || s === "broken")) return "failing"
+	if (statuses.some((s) => s === "running" || s === "queued")) return "pending"
+	if (statuses.some((s) => s === "approved")) return "passing"
+	return "none"
+}
+
+export function azureReview(votes: readonly number[]): string {
+	if (votes.includes(-10)) return "rejected"
+	if (votes.includes(-5)) return "waiting for author"
+	if (votes.some((vote) => vote >= 5)) return "approved"
+	return ""
+}
+
+export const SUMMARY_SYSTEM = `You summarize a coding session for a side panel.
+Reply with JSON only, no prose and no code fence:
+{"goal": "<2-4 sentences: what the session is trying to achieve and where it stands now>",
+ "steps": [{"text": "<one short line>", "status": "done" | "current" | "todo"}]}
+Steps run in order, at most 12, and at most one is "current".`
+
+// The newest part of the conversation that fits the model's budget.
+export function transcriptOf(messages: readonly SessionMessage[]): string {
+	const lines = messages.map((m) => {
+		const tools = m.toolUses.map(
+			(use) => `[${use.tool}] ${JSON.stringify(use.input).slice(0, 200)}`,
+		)
+		return `${m.role}: ${[m.text.slice(0, 2000), ...tools].filter(Boolean).join("\n")}`
+	})
+	return lines.join("\n\n").slice(-60_000)
+}
+
+export function parseSummary(
+	text: string,
+): { goal: string; steps: Step[] } | null {
+	const start = text.indexOf("{")
+	const end = text.lastIndexOf("}")
+	if (start < 0 || end < start) return null
+	try {
+		const value = JSON.parse(text.slice(start, end + 1)) as {
+			goal?: unknown
+			steps?: unknown
+		}
+		if (typeof value.goal !== "string" || !Array.isArray(value.steps))
+			return null
+		const steps: Step[] = []
+		for (const step of value.steps as { text?: unknown; status?: unknown }[]) {
+			if (typeof step?.text !== "string") continue
+			const status =
+				step.status === "done" || step.status === "current"
+					? step.status
+					: "todo"
+			steps.push({ text: step.text, status })
+		}
+		return { goal: value.goal, steps }
+	} catch {
+		return null
+	}
+}

package/dist/skills/statusline-setup/mod/hooks/fetch.ts

@@ -0,0 +1,327 @@
+import type { Item, Pr, Work } from "../types"
+import {
+	azureChecks,
+	azureReview,
+	githubChecks,
+	itemRefs,
+	type Platform,
+} from "./discover"
+
+// Runs a command; register.tsx supplies it, since only that file may use $.
+export type Run = (
+	argv: string[],
+) => Promise<{ exitCode: number; stdout: string; stderr: string }>
+
+export async function git(run: Run, args: string[]): Promise<string> {
+	const { exitCode, stdout } = await run(["git", ...args])
+	return exitCode === 0 ? stdout.trim() : ""
+}
+
+function firstLine(text: string): string {
+	return text.trim().split("\n")[0] ?? ""
+}
+
+async function refsByBranch(
+	run: Run,
+	platform: Platform,
+	branches: readonly string[],
+) {
+	const base = await git(run, [
+		"symbolic-ref",
+		"--short",
+		"refs/remotes/origin/HEAD",
+	])
+	const refs = new Map<string, number[]>()
+	for (const branch of branches) {
+		const log = base
+			? await git(run, ["log", "--format=%B", `${base}..${branch}`])
+			: ""
+		refs.set(branch, itemRefs(platform, branch, log))
+	}
+	return refs
+}
+
+const PR_FIELDS = `number title url state isDraft reviewDecision headRefName
+  comments { totalCount } reviewThreads { totalCount }
+  commits(last: 1) { nodes { commit { statusCheckRollup { state } } } }
+  closingIssuesReferences(first: 10) { nodes { number title url state } }`
+
+type GhIssue = { number: number; title: string; url: string; state: string }
+type GhPr = {
+	number: number
+	title: string
+	url: string
+	state: string
+	isDraft: boolean
+	reviewDecision: string | null
+	headRefName: string
+	comments: { totalCount: number }
+	reviewThreads: { totalCount: number }
+	commits: {
+		nodes: { commit: { statusCheckRollup: { state: string } | null } }[]
+	}
+	closingIssuesReferences: { nodes: GhIssue[] }
+}
+
+const ghItem = (issue: GhIssue): Item => ({
+	id: issue.number,
+	url: issue.url,
+	title: issue.title,
+	state: issue.state.toLowerCase(),
+})
+
+// One GraphQL call: each branch's newest PR, each PR the conversation linked,
+// and every item ref, as aliases. Branch names go in as variables, never into
+// the query text. gh exits 1 when an alias does not resolve yet still prints
+// the rest, so success is judged by data.repository.
+export async function fetchGitHub(
+	run: Run,
+	branches: readonly string[],
+	prNumbers: readonly number[],
+): Promise<Work> {
+	const refs = await refsByBranch(run, "github", branches)
+	const vars: string[] = []
+	const fields: string[] = []
+	const args: string[] = []
+	branches.forEach((branch, i) => {
+		vars.push(`, $b${i}: String!`)
+		args.push("-f", `b${i}=${branch}`)
+		fields.push(`b${i}: pullRequests(headRefName: $b${i}, first: 1, states: [OPEN, MERGED, CLOSED],
+      orderBy: {field: CREATED_AT, direction: DESC}) { nodes { ...P } }`)
+	})
+	for (const n of prNumbers)
+		fields.push(`p${n}: pullRequest(number: ${n}) { ...P }`)
+	for (const n of new Set([...refs.values()].flat())) {
+		fields.push(
+			`i${n}: issueOrPullRequest(number: ${n}) { ... on Issue { number title url state } }`,
+		)
+	}
+	if (fields.length === 0) return { prs: [], items: [], fetchedAt: Date.now() }
+	const query = `query($owner: String!, $name: String!${vars.join("")}) {
+    repository(owner: $owner, name: $name) { ${fields.join("\n")} }
+  } fragment P on PullRequest { ${PR_FIELDS} }`
+	const out = await run([
+		"gh",
+		"api",
+		"graphql",
+		"-F",
+		"owner={owner}",
+		"-F",
+		"name={repo}",
+		...args,
+		"-f",
+		`query=${query}`,
+	])
+	let repo: Record<string, unknown> | undefined
+	try {
+		repo = (
+			JSON.parse(out.stdout) as {
+				data?: { repository?: Record<string, unknown> }
+			}
+		).data?.repository
+	} catch {
+		repo = undefined
+	}
+	if (!repo)
+		return {
+			prs: [],
+			items: [],
+			fetchedAt: Date.now(),
+			error: `gh: ${firstLine(out.stderr) || "no data"}`,
+		}
+
+	const prs = new Map<number, Pr>()
+	const items = new Map<number, Item>()
+	const addPr = (pr: GhPr) => {
+		prs.set(pr.number, {
+			number: pr.number,
+			url: pr.url,
+			title: pr.title,
+			branch: pr.headRefName,
+			state:
+				pr.isDraft && pr.state === "OPEN" ? "draft" : pr.state.toLowerCase(),
+			review: (pr.reviewDecision ?? "").toLowerCase().replace(/_/g, " "),
+			checks: githubChecks(
+				pr.commits.nodes[0]?.commit.statusCheckRollup?.state,
+			),
+			comments: pr.comments.totalCount + pr.reviewThreads.totalCount,
+		})
+		for (const issue of pr.closingIssuesReferences.nodes)
+			items.set(issue.number, ghItem(issue))
+	}
+	branches.forEach((branch, i) => {
+		const pr = (repo[`b${i}`] as { nodes: GhPr[] } | null)?.nodes[0]
+		if (pr) {
+			addPr(pr)
+			return
+		}
+		for (const n of refs.get(branch) ?? []) {
+			const issue = repo[`i${n}`] as GhIssue | null
+			if (issue?.number) items.set(issue.number, ghItem(issue))
+		}
+	})
+	for (const n of prNumbers) {
+		const pr = repo[`p${n}`] as GhPr | null
+		if (pr) addPr(pr)
+	}
+	return {
+		prs: [...prs.values()],
+		items: [...items.values()],
+		fetchedAt: Date.now(),
+	}
+}
+
+async function az(run: Run, args: string[]): Promise<unknown> {
+	const out = await run(["az", ...args, "--only-show-errors", "-o", "json"])
+	if (out.exitCode !== 0) return null
+	try {
+		return JSON.parse(out.stdout)
+	} catch {
+		return null
+	}
+}
+
+type AzPr = {
+	pullRequestId: number
+	title: string
+	status: string
+	isDraft: boolean
+	url: string
+	sourceRefName: string
+	reviewers?: { vote: number }[]
+	repository: { id: string; project: { id: string } }
+}
+type AzWorkItem = { id: number; url: string; fields: Record<string, string> }
+
+const AZ_STATE: Record<string, string> = {
+	active: "open",
+	completed: "merged",
+	abandoned: "closed",
+}
+
+const azItem = (w: AzWorkItem): Item => ({
+	id: w.id,
+	url: w.url.replace("/_apis/wit/workItems/", "/_workitems/edit/"),
+	title: w.fields["System.Title"] ?? "",
+	state: (w.fields["System.State"] ?? "").toLowerCase(),
+})
+
+// One az call per lookup, run in parallel: each branch's newest PR, each linked
+// PR, then each PR's work items, blocking policies (its checks) and threads.
+export async function fetchAzure(
+	run: Run,
+	branches: readonly string[],
+	prNumbers: readonly number[],
+): Promise<Work> {
+	const refs = await refsByBranch(run, "azure", branches)
+	const byBranch = await Promise.all(
+		branches.map((b) =>
+			az(run, [
+				"repos",
+				"pr",
+				"list",
+				"--source-branch",
+				b,
+				"--status",
+				"all",
+				"--top",
+				"1",
+			]),
+		),
+	)
+	const byNumber = await Promise.all(
+		prNumbers.map((n) => az(run, ["repos", "pr", "show", "--id", String(n)])),
+	)
+	if (
+		[...byBranch, ...byNumber].length > 0 &&
+		[...byBranch, ...byNumber].every((r) => r === null)
+	) {
+		return {
+			prs: [],
+			items: [],
+			fetchedAt: Date.now(),
+			error: "az: every lookup failed (logged in?)",
+		}
+	}
+
+	const raw = new Map<number, AzPr>()
+	const refsWithoutPr: number[] = []
+	byBranch.forEach((list, i) => {
+		const pr = (list as AzPr[] | null)?.[0]
+		if (pr) raw.set(pr.pullRequestId, pr)
+		else refsWithoutPr.push(...(refs.get(branches[i] ?? "") ?? []))
+	})
+	for (const pr of byNumber as (AzPr | null)[])
+		if (pr) raw.set(pr.pullRequestId, pr)
+
+	const items = new Map<number, Item>()
+	const prs = await Promise.all(
+		[...raw.values()].map(async (pr): Promise<Pr> => {
+			const id = String(pr.pullRequestId)
+			const [workItems, policies, threads] = await Promise.all([
+				az(run, ["repos", "pr", "work-item", "list", "--id", id]),
+				az(run, ["repos", "pr", "policy", "list", "--id", id]),
+				az(run, [
+					"devops",
+					"invoke",
+					"--area",
+					"git",
+					"--resource",
+					"pullRequestThreads",
+					"--api-version",
+					"7.1",
+					"--route-parameters",
+					`project=${pr.repository.project.id}`,
+					`repositoryId=${pr.repository.id}`,
+					`pullRequestId=${id}`,
+				]),
+			])
+			for (const w of (workItems as AzWorkItem[] | null) ?? [])
+				items.set(w.id, azItem(w))
+			const blocking = (
+				(policies as
+					| { status: string; configuration: { isBlocking: boolean } }[]
+					| null) ?? []
+			)
+				.filter((p) => p.configuration.isBlocking)
+				.map((p) => p.status)
+			const comments = (
+				(
+					threads as {
+						value?: {
+							isDeleted: boolean
+							comments: { commentType: string }[]
+						}[]
+					} | null
+				)?.value ?? []
+			).filter(
+				(t) => !t.isDeleted && t.comments[0]?.commentType === "text",
+			).length
+			return {
+				number: pr.pullRequestId,
+				url: pr.url
+					.replace("/_apis/git/repositories/", "/_git/")
+					.replace("/pullRequests/", "/pullrequest/"),
+				title: pr.title,
+				branch: pr.sourceRefName.replace(/^refs\/heads\//, ""),
+				state:
+					pr.isDraft && pr.status === "active"
+						? "draft"
+						: (AZ_STATE[pr.status] ?? pr.status),
+				review: azureReview((pr.reviewers ?? []).map((r) => r.vote)),
+				checks: azureChecks(blocking),
+				comments,
+			}
+		}),
+	)
+
+	const missing = [...new Set(refsWithoutPr)].filter((n) => !items.has(n))
+	if (missing.length > 0) {
+		const wiql = `SELECT [System.Id], [System.Title], [System.State] FROM WorkItems WHERE [System.Id] IN (${missing.join(", ")})`
+		for (const w of ((await az(run, ["boards", "query", "--wiql", wiql])) as
+			| AzWorkItem[]
+			| null) ?? [])
+			items.set(w.id, azItem(w))
+	}
+	return { prs, items: [...items.values()], fetchedAt: Date.now() }
+}

package/dist/skills/statusline-setup/mod/hooks/hooks.json

@@ -0,0 +1 @@
+{ "modules": ["./register.tsx"] }