@kitlangton/ghui 0.2.1 → 0.3.2

package/src/keymap/themeModal.ts

@@ -1,49 +0,0 @@
-import { context } from "@ghui/keymap"
-
-export interface ThemeModalCtx {
-	readonly filterMode: boolean
-	readonly hasFilteredResults: boolean
-	readonly closeWithoutSaving: () => void
-	readonly clearFilter: () => void
-	readonly enterFilterMode: () => void
-	readonly confirmSelection: () => void
-	readonly moveSelection: (delta: -1 | 1) => void
-}
-
-const Theme = context<ThemeModalCtx>()
-
-export const themeModalKeymap = Theme(
-	{
-		id: "theme-modal.escape",
-		title: "Cancel",
-		keys: ["escape"],
-		run: (s) => {
-			if (s.filterMode) s.clearFilter()
-			else s.closeWithoutSaving()
-		},
-	},
-	{ id: "theme-modal.filter", title: "Filter themes", keys: ["/"], run: (s) => s.enterFilterMode() },
-	{
-		id: "theme-modal.confirm",
-		title: "Apply theme",
-		keys: ["return"],
-		enabled: (s) => s.filterMode && !s.hasFilteredResults ? "No matching themes." : true,
-		run: (s) => s.confirmSelection(),
-	},
-	{ id: "theme-modal.up-arrow", title: "Up", keys: ["up"], run: (s) => s.moveSelection(-1) },
-	{ id: "theme-modal.down-arrow", title: "Down", keys: ["down"], run: (s) => s.moveSelection(1) },
-	{
-		id: "theme-modal.up-letter",
-		title: "Up",
-		keys: ["k"],
-		when: (s) => !s.filterMode,
-		run: (s) => s.moveSelection(-1),
-	},
-	{
-		id: "theme-modal.down-letter",
-		title: "Down",
-		keys: ["j"],
-		when: (s) => !s.filterMode,
-		run: (s) => s.moveSelection(1),
-	},
-)

package/src/mergeActions.ts

@@ -1,88 +0,0 @@
-import type { PullRequestItem, PullRequestMergeAction, PullRequestMergeInfo, PullRequestState } from "./domain.js"
-
-export interface MergeActionDefinition {
-	readonly action: PullRequestMergeAction
-	readonly title: string
-	readonly description: string
-	readonly cliArgs: readonly string[]
-	readonly pastTense: string
-	readonly danger?: boolean
-	readonly refreshOnSuccess?: boolean
-	readonly optimisticState?: PullRequestState
-	readonly optimisticAutoMergeEnabled?: boolean
-	readonly isAvailable: (info: PullRequestMergeInfo) => boolean
-}
-
-const isCleanlyMergeable = (info: PullRequestMergeInfo) =>
-	info.state === "open" &&
-	!info.isDraft &&
-	info.mergeable === "mergeable" &&
-	info.reviewStatus !== "changes" &&
-	info.reviewStatus !== "review" &&
-	info.checkStatus !== "pending" &&
-	info.checkStatus !== "failing"
-
-const mergeActionDefinitions = {
-	squash: {
-		action: "squash",
-		title: "Squash merge now",
-		description: "Merge this pull request and delete the branch.",
-		cliArgs: ["--squash", "--delete-branch"],
-		pastTense: "Merged",
-		refreshOnSuccess: true,
-		optimisticState: "merged",
-		isAvailable: isCleanlyMergeable,
-	},
-	auto: {
-		action: "auto",
-		title: "Enable auto-merge",
-		description: "Squash merge automatically after GitHub requirements pass.",
-		cliArgs: ["--squash", "--auto", "--delete-branch"],
-		pastTense: "Enabled auto-merge",
-		optimisticAutoMergeEnabled: true,
-		isAvailable: (info) => info.state === "open" && !info.autoMergeEnabled && !info.isDraft && info.mergeable !== "conflicting",
-	},
-	"disable-auto": {
-		action: "disable-auto",
-		title: "Disable auto-merge",
-		description: "Cancel the pending GitHub auto-merge request.",
-		cliArgs: ["--disable-auto"],
-		pastTense: "Disabled auto-merge",
-		optimisticAutoMergeEnabled: false,
-		isAvailable: (info) => info.state === "open" && info.autoMergeEnabled,
-	},
-	admin: {
-		action: "admin",
-		title: "Admin override merge",
-		description: "Bypass unmet merge requirements with --admin.",
-		cliArgs: ["--squash", "--admin", "--delete-branch"],
-		pastTense: "Admin merged",
-		danger: true,
-		refreshOnSuccess: true,
-		optimisticState: "merged",
-		isAvailable: (info) => info.state === "open" && !info.isDraft && info.mergeable !== "conflicting",
-	},
-} as const satisfies Record<PullRequestMergeAction, MergeActionDefinition>
-
-export const mergeActions: readonly MergeActionDefinition[] = Object.values(mergeActionDefinitions)
-
-export const availableMergeActions = (info: PullRequestMergeInfo | null): readonly MergeActionDefinition[] => {
-	if (!info) return []
-	return mergeActions.filter((action) => action.isAvailable(info))
-}
-
-export const getMergeActionDefinition = (action: PullRequestMergeAction): MergeActionDefinition =>
-	mergeActionDefinitions[action]
-
-export const mergeInfoFromPullRequest = (pullRequest: PullRequestItem): PullRequestMergeInfo => ({
-	repository: pullRequest.repository,
-	number: pullRequest.number,
-	title: pullRequest.title,
-	state: pullRequest.state,
-	isDraft: pullRequest.reviewStatus === "draft",
-	mergeable: "unknown",
-	reviewStatus: pullRequest.reviewStatus,
-	checkStatus: pullRequest.checkStatus,
-	checkSummary: pullRequest.checkSummary,
-	autoMergeEnabled: pullRequest.autoMergeEnabled,
-})

package/src/observability.ts

@@ -1,46 +0,0 @@
-import { Config, Effect, Layer } from "effect"
-import { FetchHttpClient } from "effect/unstable/http"
-import { OtlpLogger, OtlpSerialization, OtlpTracer } from "effect/unstable/observability"
-
-const observabilityConfig = Config.all({
-	endpoint: Config.string("GHUI_OTLP_ENDPOINT").pipe(
-		Config.withDefault(""),
-		Config.map((value) => value.trim()),
-	),
-	motelPort: Config.string("GHUI_MOTEL_PORT").pipe(
-		Config.withDefault(""),
-		Config.map((value) => value.trim()),
-	),
-})
-
-const resource = {
-	serviceName: "ghui",
-	serviceVersion: "local",
-}
-
-export const Observability = {
-	layer: Layer.unwrap(Effect.gen(function*() {
-		const { endpoint, motelPort } = yield* observabilityConfig
-		const baseUrl = endpoint || (motelPort ? `http://127.0.0.1:${motelPort}` : null)
-
-		return baseUrl === null
-			? Layer.empty
-			: Layer.merge(
-				OtlpTracer.layer({
-					url: `${baseUrl}/v1/traces`,
-					exportInterval: "500 millis",
-					shutdownTimeout: "1 second",
-					resource,
-				}),
-				OtlpLogger.layer({
-					url: `${baseUrl}/v1/logs`,
-					exportInterval: "500 millis",
-					shutdownTimeout: "1 second",
-					resource,
-				}),
-			).pipe(
-				Layer.provide(OtlpSerialization.layerJson),
-				Layer.provide(FetchHttpClient.layer),
-			)
-	})),
-} as const

package/src/pullRequestCache.ts

@@ -1,19 +0,0 @@
-import type { PullRequestItem } from "./domain.js"
-
-export const mergeCachedDetails = (fresh: readonly PullRequestItem[], cached: readonly PullRequestItem[] | undefined) => {
-	if (!cached) return fresh
-	const cachedByUrl = new Map(cached.map((pullRequest) => [pullRequest.url, pullRequest]))
-	return fresh.map((pullRequest) => {
-		const cachedPullRequest = cachedByUrl.get(pullRequest.url)
-		if (!cachedPullRequest?.detailLoaded || cachedPullRequest.headRefOid !== pullRequest.headRefOid) return pullRequest
-		return {
-			...pullRequest,
-			body: cachedPullRequest.body,
-			labels: cachedPullRequest.labels,
-			additions: cachedPullRequest.additions,
-			deletions: cachedPullRequest.deletions,
-			changedFiles: cachedPullRequest.changedFiles,
-			detailLoaded: true,
-		} satisfies PullRequestItem
-	})
-}

package/src/pullRequestViews.ts

@@ -1,45 +0,0 @@
-import { pullRequestQueueLabels, pullRequestQueueModes, type PullRequestQueueMode, type PullRequestUserQueueMode } from "./domain.js"
-
-export type PullRequestView =
-	| { readonly _tag: "Repository"; readonly repository: string }
-	| { readonly _tag: "Queue"; readonly mode: PullRequestUserQueueMode; readonly repository: string | null }
-
-export const initialPullRequestView = (repository: string | null): PullRequestView => repository
-	? { _tag: "Repository", repository }
-	: { _tag: "Queue", mode: "authored", repository: null }
-
-export const viewMode = (view: PullRequestView): PullRequestQueueMode => view._tag === "Repository" ? "repository" : view.mode
-
-export const viewRepository = (view: PullRequestView) => view.repository
-
-export const viewCacheKey = (view: PullRequestView) => view._tag === "Repository" ? `repository:${view.repository}` : view.mode
-
-export const viewEquals = (left: PullRequestView, right: PullRequestView) =>
-	left._tag === right._tag && viewMode(left) === viewMode(right) && left.repository === right.repository
-
-export const activePullRequestViews = (view: PullRequestView): readonly PullRequestView[] => {
-	const repository = viewRepository(view)
-	return [
-		...(repository ? [{ _tag: "Repository" as const, repository }] : []),
-		...pullRequestQueueModes.map((mode) => ({ _tag: "Queue" as const, mode, repository })),
-	]
-}
-
-export const nextView = (view: PullRequestView, views: readonly PullRequestView[], delta: 1 | -1) => {
-	const index = Math.max(0, views.findIndex((candidate) => viewEquals(candidate, view)))
-	return views[(index + delta + views.length) % views.length]!
-}
-
-export const viewLabel = (view: PullRequestView) => view._tag === "Repository" ? view.repository : pullRequestQueueLabels[view.mode]
-
-export const parseRepositoryInput = (input: string) => {
-	const trimmed = input.trim()
-	const urlMatch = trimmed.match(/^(?:https?:\/\/)?(?:www\.)?github\.com\/([^/\s]+)\/([^/\s?#]+)(?:[/?#].*)?$/i)
-	const shorthandMatch = trimmed.match(/^([^/\s]+)\/([^/\s]+)$/)
-	const match = urlMatch ?? shorthandMatch
-	if (!match) return null
-	const owner = match[1]!
-	const repo = match[2]!.replace(/\.git$/i, "")
-	if (!/^[A-Za-z0-9_.-]+$/.test(owner) || !/^[A-Za-z0-9_.-]+$/.test(repo)) return null
-	return `${owner}/${repo}`
-}

package/src/services/BrowserOpener.ts

@@ -1,22 +0,0 @@
-import { Context, Effect, Layer } from "effect"
-import type { PullRequestItem } from "../domain.js"
-import { CommandRunner, type CommandError } from "./CommandRunner.js"
-
-export class BrowserOpener extends Context.Service<BrowserOpener, {
-	readonly openPullRequest: (pullRequest: PullRequestItem) => Effect.Effect<void, CommandError>
-}>()("ghui/BrowserOpener") {
-	static readonly layerNoDeps = Layer.effect(
-		BrowserOpener,
-		Effect.gen(function*() {
-			const command = yield* CommandRunner
-
-			const openPullRequest = Effect.fn("BrowserOpener.openPullRequest")(function*(pullRequest: PullRequestItem) {
-				yield* command.run("gh", ["pr", "view", String(pullRequest.number), "--repo", pullRequest.repository, "--web"])
-			})
-
-			return BrowserOpener.of({ openPullRequest })
-		}),
-	)
-
-	static readonly layer = BrowserOpener.layerNoDeps.pipe(Layer.provide(CommandRunner.layer))
-}

package/src/services/Clipboard.ts

@@ -1,46 +0,0 @@
-import { Context, Effect, Layer, Schema } from "effect"
-import { CommandRunner } from "./CommandRunner.js"
-
-export class ClipboardError extends Schema.TaggedErrorClass<ClipboardError>()("ClipboardError", {
-	detail: Schema.String,
-}) {}
-
-const clipboardCommands: readonly (readonly [string, ...readonly string[]])[] =
-	process.platform === "darwin" ? [["pbcopy"]]
-	: process.platform === "linux" ? [
-		...(process.env.WAYLAND_DISPLAY ? [["wl-copy"] as const] : []),
-		["xclip", "-selection", "clipboard"] as const,
-		["xsel", "--clipboard", "--input"] as const,
-	]
-	: []
-
-const installHint = process.platform === "linux" ? " Install wl-clipboard, xclip, or xsel." : ""
-const unavailableDetail = `Clipboard is not available.${installHint}`
-
-export class Clipboard extends Context.Service<Clipboard, {
-	readonly copy: (text: string) => Effect.Effect<void, ClipboardError>
-}>()("ghui/Clipboard") {
-	static readonly layerNoDeps = Layer.effect(
-		Clipboard,
-		Effect.gen(function*() {
-			const command = yield* CommandRunner
-
-			const copy = Effect.fn("Clipboard.copy")(function*(text: string) {
-				if (clipboardCommands.length === 0) {
-					return yield* new ClipboardError({ detail: unavailableDetail })
-				}
-				let lastDetail = ""
-				for (const [cmd, ...args] of clipboardCommands) {
-					const result = yield* command.run(cmd, args, { stdin: text }).pipe(Effect.result)
-					if (result._tag === "Success") return
-					lastDetail = result.failure.detail
-				}
-				return yield* new ClipboardError({ detail: lastDetail || unavailableDetail })
-			})
-
-			return Clipboard.of({ copy })
-		}),
-	)
-
-	static readonly layer = Clipboard.layerNoDeps.pipe(Layer.provide(CommandRunner.layer))
-}

package/src/services/CommandRunner.ts

@@ -1,91 +0,0 @@
-import { Context, Effect, Layer, Schema } from "effect"
-
-export interface CommandResult {
-	readonly stdout: string
-	readonly stderr: string
-	readonly exitCode: number
-}
-
-export interface RunOptions {
-	readonly stdin?: string
-}
-
-export class CommandError extends Schema.TaggedErrorClass<CommandError>()("CommandError", {
-	command: Schema.String,
-	args: Schema.Array(Schema.String),
-	detail: Schema.String,
-	cause: Schema.Defect,
-}) {}
-
-export class JsonParseError extends Schema.TaggedErrorClass<JsonParseError>()("JsonParseError", {
-	command: Schema.String,
-	args: Schema.Array(Schema.String),
-	stdout: Schema.String,
-	cause: Schema.Defect,
-}) {}
-
-const readStream = async (stream: ReadableStream | null | undefined) => {
-	if (!stream) return ""
-	return Bun.readableStreamToText(stream)
-}
-
-export class CommandRunner extends Context.Service<CommandRunner, {
-	readonly run: (command: string, args: readonly string[], options?: RunOptions) => Effect.Effect<CommandResult, CommandError>
-	readonly runSchema: <S extends Schema.Top>(schema: S, command: string, args: readonly string[]) =>
-		Effect.Effect<S["Type"], CommandError | JsonParseError | Schema.SchemaError, S["DecodingServices"]>
-}>()("ghui/CommandRunner") {
-	static readonly layer = Layer.effect(
-		CommandRunner,
-		Effect.gen(function*() {
-			const runProcess = Effect.fn("CommandRunner.runProcess")((command: string, args: readonly string[], stdin: string | undefined) =>
-				Effect.tryPromise({
-					async try() {
-						const proc = Bun.spawn({
-							cmd: [command, ...args],
-							stdin: stdin === undefined ? "ignore" : "pipe",
-							stdout: "pipe",
-							stderr: "pipe",
-						})
-						if (stdin !== undefined && proc.stdin) {
-							proc.stdin.write(stdin)
-							proc.stdin.end()
-						}
-
-						const [exitCode, stdout, stderr] = await Promise.all([proc.exited, readStream(proc.stdout), readStream(proc.stderr)])
-						return { stdout, stderr, exitCode }
-					},
-					catch: (cause) => new CommandError({ command, args: [...args], detail: `Failed to run ${command}`, cause }),
-				})
-			)
-
-			const run = Effect.fn("CommandRunner.run")(function*(command: string, args: readonly string[], options?: RunOptions) {
-				const result = yield* runProcess(command, args, options?.stdin).pipe(Effect.withSpan("ghui.command.runProcess", {
-					attributes: {
-						"process.command": command,
-						"process.argv.count": args.length,
-					},
-				}))
-				if (result.exitCode !== 0) {
-					const detail = result.stderr.trim() || result.stdout.trim() || `exit code ${result.exitCode}`
-					return yield* new CommandError({ command, args: [...args], detail, cause: detail })
-				}
-				return result
-			})
-
-			const runJson = Effect.fn("CommandRunner.runJson")(function*<A>(command: string, args: readonly string[]) {
-				const result = yield* run(command, args)
-				return yield* Effect.try({
-					try: () => JSON.parse(result.stdout) as A,
-					catch: (cause) => new JsonParseError({ command, args: [...args], stdout: result.stdout, cause }),
-				})
-			})
-
-			const runSchema = Effect.fn("CommandRunner.runSchema")(function*<S extends Schema.Top>(schema: S, command: string, args: readonly string[]) {
-				const value = yield* runJson<unknown>(command, args)
-				return yield* Schema.decodeUnknownEffect(schema)(value)
-			})
-
-			return CommandRunner.of({ run, runSchema })
-		}),
-	)
-}