@gajae-code/coding-agent 0.2.1 → 0.2.2

package/src/tools/gh.ts

@@ -225,6 +225,10 @@ const RUN_SUCCESS_CONCLUSIONS = new Set(["success", "neutral", "skipped"]);
 const RUN_FAILURE_CONCLUSIONS = new Set(["failure", "timed_out", "cancelled", "action_required", "startup_failure"]);
 const JOB_FAILURE_CONCLUSIONS = new Set(["failure", "timed_out", "cancelled", "action_required"]);
 
+const PR_CREATE_BASE_CONFIG_KEYS = ["github.prBase", "gh.prBase", "gjc.github.prBase"] as const;
+const ISSUE_CLOSING_REFERENCE_PATTERN =
+	/(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)\s+(?:https:\/\/github\.com\/([^\s/]+\/[^\s/]+)\/issues\/)?#(\d+)\b/gi;
+
 const githubSchema = z
 	.object({
 		op: z
@@ -407,6 +411,23 @@ interface GhIssueViewData {
 	updatedAt?: string;
 	url?: string;
 }
+interface GhPrListData {
+	baseRefName?: string;
+	headRefName?: string;
+	isDraft?: boolean;
+	number?: number;
+	state?: string;
+	title?: string;
+	url?: string;
+}
+
+interface PrCreateDuplicateCheck {
+	base: string;
+	head: string;
+	issue?: GhIssueViewData;
+	linkedPr?: GhPrListData;
+	pr?: GhPrListData;
+}
 
 interface GhPrFile {
 	path?: string;
@@ -659,6 +680,185 @@ function resolveSearchLimit(value: number | undefined): number {
 
 	return Math.min(Math.floor(value), SEARCH_LIMIT_MAX);
 }
+async function resolvePrCreateBase(
+	cwd: string,
+	explicitBase: string | undefined,
+	repo: string | undefined,
+	signal?: AbortSignal,
+): Promise<string | undefined> {
+	if (explicitBase) return explicitBase;
+	try {
+		for (const key of PR_CREATE_BASE_CONFIG_KEYS) {
+			const configured = normalizeOptionalString(await git.config.get(cwd, key, signal));
+			if (configured) return configured;
+		}
+	} catch {
+		// Repository config is optional for pr_create; prefer GitHub metadata when
+		// local git metadata is unavailable.
+	}
+	try {
+		const resolvedRepo = repo ?? (await resolveDefaultRepoMemoized(cwd, signal));
+		const repoView = await git.github.json<GhRepoViewData>(
+			cwd,
+			["repo", "view", resolvedRepo, "--json", "defaultBranchRef"],
+			signal,
+			{ repoProvided: true },
+		);
+		const defaultBranch = normalizeOptionalString(repoView.defaultBranchRef?.name);
+		if (defaultBranch) return defaultBranch;
+	} catch {
+		// Fall back to local git metadata below so pr_create can still work when gh
+		// cannot resolve repository metadata in otherwise-valid checkouts.
+	}
+	return (await git.branch.default(cwd, signal)) ?? undefined;
+}
+
+function normalizePrHead(value: string): string {
+	const separator = value.lastIndexOf(":");
+	return separator >= 0 ? value.slice(separator + 1) : value;
+}
+
+function extractClosingIssueReferences(body: string | undefined, repo: string | undefined): number[] {
+	if (!body) return [];
+	const issueNumbers: number[] = [];
+	ISSUE_CLOSING_REFERENCE_PATTERN.lastIndex = 0;
+	let match = ISSUE_CLOSING_REFERENCE_PATTERN.exec(body);
+	while (match !== null) {
+		const issueRepo = normalizeOptionalString(match[1]);
+		if (!issueRepo || !repo || issueRepo.toLowerCase() === repo.toLowerCase()) {
+			const issueNumber = Number(match[2]);
+			if (Number.isInteger(issueNumber) && issueNumber > 0) issueNumbers.push(issueNumber);
+		}
+		match = ISSUE_CLOSING_REFERENCE_PATTERN.exec(body);
+	}
+	return issueNumbers;
+}
+
+async function resolvePrCreateHead(
+	cwd: string,
+	explicitHead: string | undefined,
+	signal?: AbortSignal,
+): Promise<string | undefined> {
+	if (explicitHead) return explicitHead;
+	try {
+		return (await git.branch.current(cwd, signal)) ?? undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+async function fetchPrCreateDuplicateCheck(
+	cwd: string,
+	repo: string | undefined,
+	base: string | undefined,
+	head: string | undefined,
+	body: string | undefined,
+	signal: AbortSignal | undefined,
+): Promise<PrCreateDuplicateCheck | undefined> {
+	if (!base || !head) return undefined;
+	const resolvedRepo = repo ?? (await resolveDefaultRepoMemoized(cwd, signal));
+	const normalizedHead = normalizePrHead(head);
+	const prs = await git.github.json<GhPrListData[]>(
+		cwd,
+		[
+			"pr",
+			"list",
+			"--repo",
+			resolvedRepo,
+			"--head",
+			normalizedHead,
+			"--base",
+			base,
+			"--state",
+			"all",
+			"--json",
+			"number,title,state,url,baseRefName,headRefName,isDraft",
+		],
+		signal,
+		{ repoProvided: true },
+	);
+	const existingPr = prs.find(pr => pr.headRefName === normalizedHead && pr.baseRefName === base) ?? prs[0];
+	const issueNumbers = existingPr ? [] : extractClosingIssueReferences(body, resolvedRepo);
+	let issue: GhIssueViewData | undefined;
+	let linkedPr: GhPrListData | undefined;
+	for (const issueNumber of issueNumbers) {
+		const candidateIssue = await git.github.json<GhIssueViewData>(
+			cwd,
+			[
+				"issue",
+				"view",
+				String(issueNumber),
+				"--repo",
+				resolvedRepo,
+				"--json",
+				GH_ISSUE_FIELDS_NO_COMMENTS.join(","),
+			],
+			signal,
+			{ repoProvided: true },
+		);
+		issue = candidateIssue;
+		if (candidateIssue.state && candidateIssue.state.toUpperCase() !== "OPEN") break;
+		const linkedPrs = await git.github.json<GhPrListData[]>(
+			cwd,
+			[
+				"pr",
+				"list",
+				"--repo",
+				resolvedRepo,
+				"--search",
+				`${issueNumber} linked:issue`,
+				"--state",
+				"open",
+				"--json",
+				"number,title,state,url,baseRefName,headRefName,isDraft",
+			],
+			signal,
+			{ repoProvided: true },
+		);
+		linkedPr = linkedPrs.find(pr => pr.headRefName !== normalizedHead) ?? linkedPrs[0];
+		if (linkedPr) break;
+	}
+	return { base, head: normalizedHead, issue, linkedPr, pr: existingPr };
+}
+
+function formatPrCreateExistingResult(check: PrCreateDuplicateCheck): string | undefined {
+	if (check.issue?.state && check.issue.state.toUpperCase() !== "OPEN") {
+		const lines = [
+			"# Pull Request Not Created",
+			"",
+			`Issue #${check.issue.number ?? ""} is ${check.issue.state.toLowerCase()}.`,
+		];
+		pushLine(lines, "Issue", check.issue.url);
+		if (check.pr) pushLine(lines, "Existing PR", check.pr.url);
+		pushLine(lines, "Base", check.base);
+		pushLine(lines, "Head", check.head);
+		return lines.join("\n").trim();
+	}
+	if (check.linkedPr) {
+		const number = check.linkedPr.number !== undefined ? ` #${check.linkedPr.number}` : "";
+		const title = check.linkedPr.title ? `: ${check.linkedPr.title}` : "";
+		const lines = [`# Pull Request Already Linked${number}${title}`, ""];
+		pushLine(lines, "URL", check.linkedPr.url);
+		pushLine(lines, "Issue", check.issue?.url);
+		pushLine(lines, "State", check.linkedPr.state);
+		pushLine(lines, "Draft", check.linkedPr.isDraft);
+		pushLine(lines, "Base", check.linkedPr.baseRefName ?? check.base);
+		pushLine(lines, "Head", check.linkedPr.headRefName ?? check.head);
+		return lines.join("\n").trim();
+	}
+	if (check.pr) {
+		const number = check.pr.number !== undefined ? ` #${check.pr.number}` : "";
+		const title = check.pr.title ? `: ${check.pr.title}` : "";
+		const lines = [`# Pull Request Already Exists${number}${title}`, ""];
+		pushLine(lines, "URL", check.pr.url);
+		pushLine(lines, "State", check.pr.state);
+		pushLine(lines, "Draft", check.pr.isDraft);
+		pushLine(lines, "Base", check.pr.baseRefName ?? check.base);
+		pushLine(lines, "Head", check.pr.headRefName ?? check.head);
+		return lines.join("\n").trim();
+	}
+	return undefined;
+}
 
 function resolveTailLimit(value: number | undefined): number {
 	if (value === undefined) {
@@ -3117,8 +3317,8 @@ async function executePrCreate(
 	const repo = normalizeOptionalString(params.repo);
 	const title = normalizeOptionalString(params.title);
 	const body = params.body;
-	const base = normalizeOptionalString(params.base);
-	const head = normalizeOptionalString(params.head);
+	const requestedBase = normalizeOptionalString(params.base);
+	const requestedHead = normalizeOptionalString(params.head);
 	const draft = params.draft ?? false;
 	const fill = params.fill ?? false;
 	const reviewers = normalizePrIdentifierList(params.reviewer);
@@ -3131,6 +3331,16 @@ async function executePrCreate(
 	if (fill && (title || body !== undefined)) {
 		throw new ToolError("fill is mutually exclusive with title and body");
 	}
+	const base = await resolvePrCreateBase(session.cwd, requestedBase, repo, signal);
+	const head = await resolvePrCreateHead(session.cwd, requestedHead, signal);
+	const duplicateCheck = await fetchPrCreateDuplicateCheck(session.cwd, repo, base, head, body, signal);
+	const existingText = duplicateCheck ? formatPrCreateExistingResult(duplicateCheck) : undefined;
+	if (existingText) {
+		return buildTextResult(
+			existingText,
+			duplicateCheck?.pr?.url ?? duplicateCheck?.linkedPr?.url ?? duplicateCheck?.issue?.url,
+		);
+	}
 
 	const args = ["pr", "create"];
 	appendRepoFlag(args, repo);

package/src/tools/index.ts

@@ -7,7 +7,7 @@ import { EditTool } from "../edit";
 import { checkPythonKernelAvailability } from "../eval/py/kernel";
 import type { Skill } from "../extensibility/skills";
 import type { GoalModeState, GoalRuntime } from "../goals";
-import { CreateGoalTool, GetGoalTool, GoalTool, UpdateGoalTool } from "../goals/tools/goal-tool";
+import { GoalTool } from "../goals/tools/goal-tool";
 import type { HindsightSessionState } from "../hindsight/state";
 import { LspTool } from "../lsp";
 import type { PlanModeState } from "../plan-mode/state";
@@ -309,12 +309,9 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	recall: HindsightRecallTool.createIf,
 	reflect: HindsightReflectTool.createIf,
 	goal: s => new GoalTool(s),
-	get_goal: GetGoalTool.createIf,
-	create_goal: CreateGoalTool.createIf,
-	update_goal: UpdateGoalTool.createIf,
 };
 
-const GOAL_MODE_TOOL_NAMES = ["get_goal", "create_goal", "update_goal"] as const;
+const GOAL_MODE_TOOL_NAMES = [] as const;
 
 export const HIDDEN_TOOLS: Record<string, ToolFactory> = {
 	yield: s => new YieldTool(s),

package/dist/types/commands/gjc-runtime-bridge.d.ts

@@ -1,30 +0,0 @@
-import { type WorkflowHudSummary } from "../skill-state/active-state";
-export declare const WORKFLOW_HUD_PROTOCOL = "workflow-hud-summary-v1";
-export interface GjcRuntimeBridgeResult {
-    status: number;
-    error?: string;
-}
-export interface WorkflowHudBridgePayload {
-    version: 1;
-    skill: string;
-    phase?: string;
-    active?: boolean;
-    session_id?: string;
-    thread_id?: string;
-    turn_id?: string;
-    hud: WorkflowHudSummary;
-}
-export interface GjcRuntimeHudBridgeResult extends GjcRuntimeBridgeResult {
-    hudPayload?: WorkflowHudBridgePayload;
-}
-export interface GjcRuntimeHudBridgeOptions {
-    cwd?: string;
-    env?: NodeJS.ProcessEnv;
-    sidecarSkill: string;
-    onHudPayload?: (payload: WorkflowHudBridgePayload) => Promise<void> | void;
-    pollIntervalMs?: number;
-}
-export declare function normalizeWorkflowHudBridgePayload(raw: unknown, expectedSkill: string): WorkflowHudBridgePayload | null;
-export declare function runGjcRuntimeBridge(endpoint: string, args: string[], env?: NodeJS.ProcessEnv): GjcRuntimeBridgeResult;
-export declare function runGjcRuntimeBridgeWithHudSidecar(endpoint: string, args: string[], options: GjcRuntimeHudBridgeOptions): Promise<GjcRuntimeHudBridgeResult>;
-export declare function runBridgedRuntimeEndpoint(endpoint: string, args: string[]): Promise<void>;

package/dist/types/commands/question.d.ts

@@ -1,7 +0,0 @@
-import { Command } from "@gajae-code/utils/cli";
-export default class Question extends Command {
-    static description: string;
-    static strict: boolean;
-    static examples: string[];
-    run(): Promise<void>;
-}

package/dist/types/modes/loop-limit.d.ts

@@ -1,22 +0,0 @@
-export type LoopLimitConfig = {
-    kind: "iterations";
-    iterations: number;
-} | {
-    kind: "duration";
-    durationMs: number;
-};
-export type LoopLimitRuntime = {
-    kind: "iterations";
-    initial: number;
-    remaining: number;
-} | {
-    kind: "duration";
-    durationMs: number;
-    deadlineMs: number;
-};
-export declare function parseLoopLimitArgs(args: string): LoopLimitConfig | undefined | string;
-export declare function createLoopLimitRuntime(config: LoopLimitConfig | undefined, nowMs?: number): LoopLimitRuntime | undefined;
-export declare function consumeLoopLimitIteration(limit: LoopLimitRuntime | undefined, nowMs?: number): boolean;
-export declare function isLoopDurationExpired(limit: LoopLimitRuntime | undefined, nowMs?: number): boolean;
-export declare function describeLoopLimit(config: LoopLimitConfig): string;
-export declare function describeLoopLimitRuntime(limit: LoopLimitRuntime): string;

package/src/commands/gjc-runtime-bridge.ts

@@ -1,227 +0,0 @@
-import { spawn, spawnSync } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { existsSync } from "node:fs";
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { normalizeWorkflowHudSummary, type WorkflowHudSummary } from "../skill-state/active-state";
-
-const BRIDGE_ENV = "GJC_RUNTIME_BINARY";
-const LEGACY_BRIDGE_ENV = "GJC_LEGACY_RUNTIME_BINARY";
-const GUARD_ENV = "GJC_RUNTIME_BRIDGE_ACTIVE";
-export const WORKFLOW_HUD_PROTOCOL = "workflow-hud-summary-v1";
-
-export interface GjcRuntimeBridgeResult {
-	status: number;
-	error?: string;
-}
-
-const SKILL_ENTRYPOINT_ENDPOINTS = new Set(["deep-interview", "ralplan"]);
-
-export interface WorkflowHudBridgePayload {
-	version: 1;
-	skill: string;
-	phase?: string;
-	active?: boolean;
-	session_id?: string;
-	thread_id?: string;
-	turn_id?: string;
-	hud: WorkflowHudSummary;
-}
-
-export interface GjcRuntimeHudBridgeResult extends GjcRuntimeBridgeResult {
-	hudPayload?: WorkflowHudBridgePayload;
-}
-
-export interface GjcRuntimeHudBridgeOptions {
-	cwd?: string;
-	env?: NodeJS.ProcessEnv;
-	sidecarSkill: string;
-	onHudPayload?: (payload: WorkflowHudBridgePayload) => Promise<void> | void;
-	pollIntervalMs?: number;
-}
-
-function candidateBinaries(env: NodeJS.ProcessEnv): string[] {
-	return [env[BRIDGE_ENV], env[LEGACY_BRIDGE_ENV]].filter(
-		(value): value is string => typeof value === "string" && value.trim().length > 0,
-	);
-}
-
-function isPathLike(command: string): boolean {
-	return command.includes("/") || command.includes("\\");
-}
-
-function canAttempt(command: string): boolean {
-	return !isPathLike(command) || existsSync(command);
-}
-
-function unavailableBridgeResult(
-	endpoint: string,
-	env: NodeJS.ProcessEnv,
-	attempted: string[],
-): GjcRuntimeBridgeResult {
-	const configured = [env[BRIDGE_ENV], env[LEGACY_BRIDGE_ENV]].filter(Boolean).join(", ");
-	const guidance = SKILL_ENTRYPOINT_ENDPOINTS.has(endpoint)
-		? `Inside a GJC agent session, invoke /skill:${endpoint} instead so the bundled skill is loaded directly.`
-		: `Configure ${BRIDGE_ENV} with a GJC-compatible private runtime binary for the ${endpoint} endpoint.`;
-	return {
-		status: 1,
-		error: [
-			`gjc ${endpoint} is a private runtime bridge command.`,
-			guidance,
-			`Only private runtime deployments should call this bridge command; configure them with ${BRIDGE_ENV}.`,
-			configured
-				? `Configured runtime candidates failed: ${configured}.`
-				: "No private GJC runtime binary was configured.",
-			attempted.length > 0 ? `Attempted: ${attempted.join(", ")}.` : undefined,
-		]
-			.filter(Boolean)
-			.join("\n"),
-	};
-}
-
-export function normalizeWorkflowHudBridgePayload(
-	raw: unknown,
-	expectedSkill: string,
-): WorkflowHudBridgePayload | null {
-	if (!raw || typeof raw !== "object") return null;
-	const record = raw as Record<string, unknown>;
-	if (record.version !== 1 || record.skill !== expectedSkill) return null;
-	const hud = normalizeWorkflowHudSummary(record.hud);
-	if (!hud) return null;
-	return {
-		version: 1,
-		skill: expectedSkill,
-		phase: typeof record.phase === "string" && record.phase.trim() ? record.phase.trim() : undefined,
-		active: typeof record.active === "boolean" ? record.active : undefined,
-		session_id:
-			typeof record.session_id === "string" && record.session_id.trim() ? record.session_id.trim() : undefined,
-		thread_id: typeof record.thread_id === "string" && record.thread_id.trim() ? record.thread_id.trim() : undefined,
-		turn_id: typeof record.turn_id === "string" && record.turn_id.trim() ? record.turn_id.trim() : undefined,
-		hud,
-	};
-}
-
-async function readHudPayload(sidecarPath: string, expectedSkill: string): Promise<WorkflowHudBridgePayload | null> {
-	try {
-		return normalizeWorkflowHudBridgePayload(JSON.parse(await Bun.file(sidecarPath).text()), expectedSkill);
-	} catch {
-		return null;
-	}
-}
-
-export function runGjcRuntimeBridge(
-	endpoint: string,
-	args: string[],
-	env: NodeJS.ProcessEnv = process.env,
-): GjcRuntimeBridgeResult {
-	if (env[GUARD_ENV] === "1") {
-		return {
-			status: 1,
-			error: `Refusing recursive gjc runtime bridge for ${endpoint}.`,
-		};
-	}
-
-	const attempted: string[] = [];
-	for (const binary of candidateBinaries(env)) {
-		const command = binary.trim();
-		if (!canAttempt(command)) continue;
-		attempted.push(command);
-		const child = spawnSync(command, [endpoint, ...args], {
-			stdio: "inherit",
-			env: {
-				...env,
-				[GUARD_ENV]: "1",
-			},
-		});
-
-		if (child.error) {
-			const error = child.error as NodeJS.ErrnoException;
-			if (error.code === "ENOENT") continue;
-			return { status: 1, error: error.message };
-		}
-
-		return { status: child.status ?? (child.signal ? 1 : 0) };
-	}
-
-	return unavailableBridgeResult(endpoint, env, attempted);
-}
-
-export async function runGjcRuntimeBridgeWithHudSidecar(
-	endpoint: string,
-	args: string[],
-	options: GjcRuntimeHudBridgeOptions,
-): Promise<GjcRuntimeHudBridgeResult> {
-	const env = options.env ?? process.env;
-	if (env[GUARD_ENV] === "1") return { status: 1, error: `Refusing recursive gjc runtime bridge for ${endpoint}.` };
-
-	const attempted: string[] = [];
-	for (const binary of candidateBinaries(env)) {
-		const command = binary.trim();
-		if (!canAttempt(command)) continue;
-		attempted.push(command);
-		const sidecarDir = await fs.mkdtemp(path.join(os.tmpdir(), "gjc-workflow-hud-"));
-		const sidecarPath = path.join(sidecarDir, `${options.sidecarSkill}-${randomUUID()}.json`);
-		let latestPayload: WorkflowHudBridgePayload | undefined;
-		let lastRaw = "";
-		const publishPayload = async (): Promise<void> => {
-			let raw = "";
-			try {
-				raw = await Bun.file(sidecarPath).text();
-			} catch {
-				return;
-			}
-			if (!raw || raw === lastRaw) return;
-			lastRaw = raw;
-			const payload = await readHudPayload(sidecarPath, options.sidecarSkill);
-			if (!payload) return;
-			latestPayload = payload;
-			try {
-				await options.onHudPayload?.(payload);
-			} catch {
-				// HUD sidecar sync is best-effort and must not change child command semantics.
-			}
-		};
-		try {
-			const child = spawn(command, [endpoint, ...args], {
-				cwd: options.cwd,
-				stdio: "inherit",
-				env: {
-					...env,
-					[GUARD_ENV]: "1",
-					GJC_WORKFLOW_HUD_PROTOCOL: WORKFLOW_HUD_PROTOCOL,
-					GJC_WORKFLOW_HUD_SIDECAR: sidecarPath,
-					GJC_WORKFLOW_HUD_SKILL: options.sidecarSkill,
-				},
-			});
-			const interval = setInterval(() => {
-				void publishPayload();
-			}, options.pollIntervalMs ?? 100);
-			const exit = Promise.withResolvers<{ status: number; error?: string; code?: string }>();
-			child.on("error", error => {
-				const fsError = error as NodeJS.ErrnoException;
-				exit.resolve({ status: 1, error: error.message, code: fsError.code });
-			});
-			child.on("exit", (code, signal) => exit.resolve({ status: code ?? (signal ? 1 : 0) }));
-			const result = await exit.promise;
-			clearInterval(interval);
-			await publishPayload();
-			if (result.code === "ENOENT") continue;
-			return {
-				status: result.status,
-				...(result.error ? { error: result.error } : {}),
-				...(latestPayload ? { hudPayload: latestPayload } : {}),
-			};
-		} finally {
-			await fs.rm(sidecarDir, { recursive: true, force: true });
-		}
-	}
-
-	return unavailableBridgeResult(endpoint, env, attempted);
-}
-
-export async function runBridgedRuntimeEndpoint(endpoint: string, args: string[]): Promise<void> {
-	const result = runGjcRuntimeBridge(endpoint, args);
-	if (result.error) process.stderr.write(`${result.error}\n`);
-	process.exitCode = result.status;
-}

package/src/commands/question.ts

@@ -1,12 +0,0 @@
-import { Command } from "@gajae-code/utils/cli";
-import { runBridgedRuntimeEndpoint } from "./gjc-runtime-bridge";
-
-export default class Question extends Command {
-	static description = "Ask a blocking private runtime question through the GJC bridge";
-	static strict = false;
-	static examples = ["$ gjc question --input '<json>' --json"];
-
-	async run(): Promise<void> {
-		await runBridgedRuntimeEndpoint("question", this.argv);
-	}
-}