@gajae-code/coding-agent 0.2.1 → 0.2.3

package/src/gjc-runtime/tmux-common.ts

@@ -0,0 +1,119 @@
+export const GJC_DEFAULT_TMUX_SESSION = "gajae_code";
+export const GJC_TMUX_SESSION_PREFIX = `${GJC_DEFAULT_TMUX_SESSION}_`;
+export const GJC_TMUX_COMMAND_ENV = "GJC_TMUX_COMMAND";
+export const GJC_TMUX_PROFILE_ENV = "GJC_TMUX_PROFILE";
+export const GJC_TMUX_MOUSE_ENV = "GJC_MOUSE";
+export const GJC_TMUX_PROFILE_OPTION = "@gjc-profile";
+export const GJC_TMUX_PROFILE_VALUE = "1";
+export const GJC_TMUX_BRANCH_OPTION = "@gjc-branch";
+export const GJC_TMUX_BRANCH_SLUG_OPTION = "@gjc-branch-slug";
+export const GJC_TMUX_PROJECT_OPTION = "@gjc-project";
+
+export interface GjcTmuxProfileCommand {
+	description: string;
+	args: string[];
+}
+
+export interface TmuxCommandResult {
+	exitCode: number | null;
+	stdout?: string;
+	stderr?: string;
+	signalCode?: string | null;
+}
+
+export type TmuxCommandRunner = (args: string[]) => TmuxCommandResult;
+
+export function envDisabled(value: string | undefined): boolean {
+	const normalized = value?.trim().toLowerCase();
+	return normalized === "0" || normalized === "false" || normalized === "off" || normalized === "no";
+}
+
+export function resolveGjcTmuxCommand(env: NodeJS.ProcessEnv = process.env): string {
+	return env[GJC_TMUX_COMMAND_ENV]?.trim() || env.GJC_TEAM_TMUX_COMMAND?.trim() || "tmux";
+}
+
+export function sanitizeTmuxToken(value: string): string {
+	return (
+		value
+			.toLowerCase()
+			.replace(/[^a-z0-9]+/g, "-")
+			.replace(/-+/g, "-")
+			.replace(/^-|-$/g, "") || "default"
+	);
+}
+
+export function buildGjcTmuxSessionSlug(value: string): string {
+	return sanitizeTmuxToken(value);
+}
+
+function randomTmuxSessionSuffix(): string {
+	return Math.random().toString(36).slice(2, 10);
+}
+
+export function buildGjcTmuxSessionName(
+	env: NodeJS.ProcessEnv = process.env,
+	context: { branch?: string | null; now?: number; id?: string } = {},
+): string {
+	const explicit = env.GJC_TMUX_SESSION?.trim();
+	if (explicit) return explicit;
+	const timestamp = (context.now ?? Date.now()).toString(36);
+	const id = context.id ?? randomTmuxSessionSuffix();
+	const branchSlug = context.branch ? `${buildGjcTmuxSessionSlug(context.branch)}_` : "";
+	return `${GJC_TMUX_SESSION_PREFIX}${branchSlug}${timestamp}_${id}`;
+}
+
+export function buildGjcTmuxRequiredProfileCommands(
+	target: string,
+	metadata: { branch?: string | null; branchSlug?: string | null; project?: string | null } = {},
+): GjcTmuxProfileCommand[] {
+	const commands: GjcTmuxProfileCommand[] = [
+		{
+			description: "mark GJC tmux ownership",
+			args: ["set-option", "-t", target, GJC_TMUX_PROFILE_OPTION, GJC_TMUX_PROFILE_VALUE],
+		},
+	];
+	if (metadata.branch)
+		commands.push({
+			description: "record GJC branch identity",
+			args: ["set-option", "-t", target, GJC_TMUX_BRANCH_OPTION, metadata.branch],
+		});
+	if (metadata.branchSlug)
+		commands.push({
+			description: "record GJC branch slug",
+			args: ["set-option", "-t", target, GJC_TMUX_BRANCH_SLUG_OPTION, metadata.branchSlug],
+		});
+	if (metadata.project)
+		commands.push({
+			description: "record GJC project identity",
+			args: ["set-option", "-t", target, GJC_TMUX_PROJECT_OPTION, metadata.project],
+		});
+	return commands;
+}
+
+export function buildGjcTmuxProfileCommands(
+	target: string,
+	env: NodeJS.ProcessEnv = process.env,
+	metadata: { branch?: string | null; branchSlug?: string | null; project?: string | null } = {},
+): GjcTmuxProfileCommand[] {
+	const commands = buildGjcTmuxRequiredProfileCommands(target, metadata);
+	if (envDisabled(env[GJC_TMUX_PROFILE_ENV])) return commands;
+	commands.push(
+		{ description: "enable tmux clipboard integration", args: ["set-option", "-t", target, "set-clipboard", "on"] },
+		{
+			description: "make copy-mode selection readable",
+			args: ["set-window-option", "-t", target, "mode-style", "fg=colour231,bg=colour60"],
+		},
+	);
+	if (!envDisabled(env[GJC_TMUX_MOUSE_ENV]))
+		commands.unshift({
+			description: "enable tmux mouse scrolling",
+			args: ["set-option", "-t", target, "mouse", "on"],
+		});
+	return commands;
+}
+
+export function normalizeTmuxCreatedAt(raw: string): string {
+	const seconds = Number.parseInt(raw, 10);
+	if (!Number.isFinite(seconds) || seconds <= 0) return raw;
+	return new Date(seconds * 1000).toISOString();
+}

package/src/gjc-runtime/tmux-sessions.ts

@@ -0,0 +1,165 @@
+import {
+	buildGjcTmuxProfileCommands,
+	buildGjcTmuxSessionName,
+	GJC_TMUX_BRANCH_OPTION,
+	GJC_TMUX_BRANCH_SLUG_OPTION,
+	GJC_TMUX_PROFILE_OPTION,
+	GJC_TMUX_PROFILE_VALUE,
+	GJC_TMUX_PROJECT_OPTION,
+	normalizeTmuxCreatedAt,
+	resolveGjcTmuxCommand,
+} from "./tmux-common";
+
+export interface GjcTmuxSessionStatus {
+	name: string;
+	attached: boolean;
+	windows: number;
+	panes: number;
+	bindings: string;
+	createdAt: string;
+	branch?: string;
+	branchSlug?: string;
+	project?: string;
+}
+
+function runTmux(args: string[], env: NodeJS.ProcessEnv = process.env): string {
+	const tmuxCommand = resolveGjcTmuxCommand(env);
+	const result = Bun.spawnSync([tmuxCommand, ...args], { stdout: "pipe", stderr: "pipe", env });
+	if (result.exitCode === 0) return result.stdout.toString();
+	throw new Error(result.stderr.toString().trim() || `tmux ${args.join(" ")} failed`);
+}
+
+function tryKillSession(sessionName: string, env: NodeJS.ProcessEnv): void {
+	try {
+		runTmux(["kill-session", "-t", `=${sessionName}`], env);
+	} catch {
+		// Best-effort cleanup only; preserve the original create/tag failure.
+	}
+}
+
+function parseBooleanFlag(value: string | undefined): boolean {
+	return value === "1";
+}
+
+function parseNumber(value: string | undefined): number {
+	const parsed = Number.parseInt(value ?? "0", 10);
+	return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function parseSessionLine(line: string): GjcTmuxSessionStatus | null {
+	const [
+		name = "",
+		windows = "0",
+		attached = "0",
+		created = "",
+		profile = "",
+		bindings = "",
+		panes = "0",
+		branch = "",
+		branchSlug = "",
+		project = "",
+	] = line.split("\t");
+	if (!name || profile !== GJC_TMUX_PROFILE_VALUE) return null;
+	return {
+		name,
+		attached: parseBooleanFlag(attached),
+		windows: parseNumber(windows),
+		panes: parseNumber(panes),
+		bindings,
+		createdAt: normalizeTmuxCreatedAt(created),
+		branch: branch || undefined,
+		branchSlug: branchSlug || undefined,
+		project: project || undefined,
+	};
+}
+
+function listSessionLines(env: NodeJS.ProcessEnv = process.env): string[] {
+	let output = "";
+	try {
+		output = runTmux(
+			[
+				"list-sessions",
+				"-F",
+				`#{session_name}\t#{session_windows}\t#{session_attached}\t#{session_created}\t#{${GJC_TMUX_PROFILE_OPTION}}\t#{session_key_table}\t#{session_panes}\t#{${GJC_TMUX_BRANCH_OPTION}}\t#{${GJC_TMUX_BRANCH_SLUG_OPTION}}\t#{${GJC_TMUX_PROJECT_OPTION}}`,
+			],
+			env,
+		);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		if (message.includes("no server running") || message.includes("failed to connect to server")) return [];
+		throw error;
+	}
+	return output
+		.split("\n")
+		.map(line => line.trim())
+		.filter(Boolean);
+}
+
+export function listGjcTmuxSessions(env: NodeJS.ProcessEnv = process.env): GjcTmuxSessionStatus[] {
+	return listSessionLines(env)
+		.map(parseSessionLine)
+		.filter((session): session is GjcTmuxSessionStatus => session != null)
+		.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function findGjcTmuxSessionByBranch(
+	branch: string,
+	env: NodeJS.ProcessEnv = process.env,
+	project?: string | null,
+): GjcTmuxSessionStatus | undefined {
+	return listGjcTmuxSessions(env).find(
+		session => session.branch === branch && (!project || session.project === project),
+	);
+}
+
+export function statusGjcTmuxSession(sessionName: string, env: NodeJS.ProcessEnv = process.env): GjcTmuxSessionStatus {
+	const session = listGjcTmuxSessions(env).find(candidate => candidate.name === sessionName);
+	if (!session) throw new Error(`gjc_tmux_session_not_found:${sessionName}`);
+	return session;
+}
+
+export function createGjcTmuxSession(env: NodeJS.ProcessEnv = process.env): GjcTmuxSessionStatus {
+	const tmuxCommand = resolveGjcTmuxCommand(env);
+	const sessionName = buildGjcTmuxSessionName(env);
+	const command = "exec env GJC_TMUX_LAUNCHED=1 gjc";
+	const created = Bun.spawnSync([tmuxCommand, "new-session", "-d", "-s", sessionName, command], {
+		stdout: "pipe",
+		stderr: "pipe",
+		env,
+	});
+	if (created.exitCode !== 0) throw new Error(created.stderr.toString().trim() || "gjc_tmux_session_create_failed");
+	try {
+		for (const profileCommand of buildGjcTmuxProfileCommands(sessionName, env)) {
+			runTmux(profileCommand.args, env);
+		}
+	} catch (error) {
+		tryKillSession(sessionName, env);
+		throw error;
+	}
+	return statusGjcTmuxSession(sessionName, env);
+}
+
+function readProfileForExactTarget(sessionName: string, env: NodeJS.ProcessEnv): string {
+	return runTmux(["show-options", "-qv", "-t", `=${sessionName}`, GJC_TMUX_PROFILE_OPTION], env).trim();
+}
+
+export function removeGjcTmuxSession(sessionName: string, env: NodeJS.ProcessEnv = process.env): GjcTmuxSessionStatus {
+	const session = statusGjcTmuxSession(sessionName, env);
+	if (readProfileForExactTarget(session.name, env) !== GJC_TMUX_PROFILE_VALUE) {
+		throw new Error(`gjc_tmux_session_not_managed:${sessionName}`);
+	}
+	runTmux(["kill-session", "-t", `=${session.name}`], env);
+	return session;
+}
+
+export function attachGjcTmuxSession(sessionName: string, env: NodeJS.ProcessEnv = process.env): never {
+	const session = statusGjcTmuxSession(sessionName, env);
+	const tmuxCommand = resolveGjcTmuxCommand(env);
+	const result = Bun.spawnSync([tmuxCommand, "attach-session", "-t", `=${session.name}`], {
+		stdin: "inherit",
+		stdout: "inherit",
+		stderr: "inherit",
+		env,
+	});
+	process.exit(result.exitCode ?? 1);
+}

package/src/gjc-runtime/ultragoal-guard.ts

@@ -171,7 +171,7 @@ export function validateCompletionReceipt(input: {
 	if (hashStructuredValue(event.gjcGoalJson) !== receipt.gjcGoalSnapshotHash) {
 		return {
 			state: "active_stale_receipt",
-			message: `Ultragoal ${input.goal.id} receipt get_goal snapshot hash does not match ledger.`,
+			message: `Ultragoal ${input.goal.id} receipt goal({"op":"get"}) snapshot hash does not match ledger.`,
 			goalId: input.goal.id,
 		};
 	}
@@ -275,7 +275,10 @@ export async function assertCanCompleteCurrentGoal(input: {
 }
 
 export function isUltragoalBypassPrompt(prompt: string): boolean {
-	return /update_goal\s*\(|goal\s+complete|checkpoint[^\n]+--status\s+complete|skip\s+verification|weaken\s+verification|mark\s+.*complete/i.test(
-		prompt,
+	const normalized = prompt.replace(/\\?"/g, '"');
+	return (
+		/update_goal\s*\(|goal\s+complete|checkpoint[^\n]+--status\s+complete|skip\s+verification|weaken\s+verification|mark\s+.*complete/i.test(
+			normalized,
+		) || /goal[\s\S]{0,80}complete/i.test(normalized)
 	);
 }

package/src/gjc-runtime/ultragoal-runtime.ts

@@ -645,7 +645,7 @@ async function readGjcGoalSnapshot(input: {
 }): Promise<unknown> {
 	if (!input.value?.trim()) {
 		if (!input.required) return undefined;
-		throw new Error(`${input.errorPrefix} require --gjc-goal-json from a fresh active get_goal snapshot`);
+		throw new Error(`${input.errorPrefix} require --gjc-goal-json from a fresh active goal({"op":"get"}) snapshot`);
 	}
 	const snapshot = await readStructuredValue(input.cwd, input.value);
 	const snapshotObject = qualityGateObject(snapshot);
@@ -653,7 +653,8 @@ async function readGjcGoalSnapshot(input: {
 	const goalObject = qualityGateObject(snapshotObject?.goal) ?? qualityGateObject(detailsObject?.goal);
 	if (!goalObject) throw new Error(`${input.errorPrefix} require --gjc-goal-json with a goal object`);
 	const updatedAt = typeof goalObject.updatedAt === "number" ? goalObject.updatedAt : null;
-	if (!updatedAt) throw new Error(`${input.errorPrefix} require --gjc-goal-json goal.updatedAt from get_goal`);
+	if (!updatedAt)
+		throw new Error(`${input.errorPrefix} require --gjc-goal-json goal.updatedAt from goal({"op":"get"})`);
 	const nowMilliseconds = Date.now();
 	if (updatedAt < nowMilliseconds - GJC_GOAL_SNAPSHOT_MAX_AGE_MILLISECONDS) {
 		throw new Error(`${input.errorPrefix} require a fresh --gjc-goal-json snapshot`);
@@ -817,7 +818,7 @@ export async function recordUltragoalReviewBlockers(input: {
 	const objective = input.objective.trim();
 	if (!objective) throw new Error("record-review-blockers --objective is required");
 	if (!input.gjcGoalJson?.trim()) {
-		throw new Error("record-review-blockers require --gjc-goal-json from a fresh active get_goal snapshot");
+		throw new Error('record-review-blockers require --gjc-goal-json from a fresh active goal({"op":"get"}) snapshot');
 	}
 	const plan = await checkpointUltragoalGoal({
 		cwd: input.cwd,
@@ -913,7 +914,7 @@ function renderCompleteHandoff(
 		`Ultragoal handoff: ${result.goal.id} — ${result.goal.title}`,
 		`Objective: ${result.goal.objective}`,
 		`GJC objective: ${result.plan.gjcObjective}`,
-		"Call get_goal({}); create_goal only if no active GJC goal exists, then complete this GJC story.",
+		'Call goal({"op":"get"}); call goal({"op":"create","objective":"<printed objective>"}) only if no active GJC goal exists, then complete this GJC story with goal({"op":"complete"}) after verification.',
 		"Before checkpointing complete, obtain a passing architectReview (architecture/product/code CLEAR + APPROVE) and executorQa (e2e/red-team passed); record blockers instead of completing on any finding.",
 		"",
 	].join("\n");