@gajae-code/coding-agent 0.11.3 → 0.11.5

package/src/gjc-runtime/state-argv.ts

@@ -0,0 +1,292 @@
+import { CANONICAL_GJC_WORKFLOW_SKILLS, type CanonicalGjcWorkflowSkill } from "../skill-state/canonical-skills";
+import { typedArgsFor } from "./workflow-manifest";
+
+export type StateAction =
+	| "read"
+	| "write"
+	| "clear"
+	| "contract"
+	| "handoff"
+	| "graph"
+	| "prune"
+	| "gc"
+	| "migrate"
+	| "status"
+	| "doctor";
+
+export const STATE_ACTION_NAMES: ReadonlySet<StateAction> = new Set([
+	"read",
+	"write",
+	"clear",
+	"contract",
+	"handoff",
+	"graph",
+	"prune",
+	"gc",
+	"migrate",
+	"status",
+	"doctor",
+]);
+
+export const STATE_FLAGS_WITH_VALUES: ReadonlySet<string> = new Set([
+	"--input",
+	"--mode",
+	"--session-id",
+	"--thread-id",
+	"--turn-id",
+	"--to",
+	"--skill",
+	"--format",
+	"--older-than",
+	"--status",
+	"--fields",
+	"--since",
+	"--limit",
+]);
+
+export const STATE_BOOLEAN_FLAGS: ReadonlySet<string> = new Set([
+	"--json",
+	"--replace",
+	"--hard",
+	"--dry-run",
+	"--migrate",
+	"--compact",
+	"--history",
+	"--force",
+]);
+
+export interface StateFlagOccurrence {
+	name: string;
+	index: number;
+	value?: string;
+	arity: "boolean" | "value";
+	form: "separate" | "attached";
+	malformed: boolean;
+}
+
+export interface StateSelectorCandidate {
+	source: "mode" | "positional" | "input.mode" | "input.skill";
+	value: string | undefined;
+	index: number;
+}
+
+export type StateInputKind = "empty" | "inline" | "file" | "invalid";
+
+export interface StateInputClassification {
+	index: number;
+	raw: string;
+	kind: StateInputKind;
+	selectors: StateSelectorCandidate[];
+}
+
+export interface StateArgvClassification {
+	argv: readonly string[];
+	action: StateAction;
+	effectiveAction: StateAction;
+	positionalSkill?: string;
+	positionals: readonly string[];
+	flags: readonly StateFlagOccurrence[];
+	unknownFlags: readonly string[];
+	inputs: readonly StateInputClassification[];
+	runtimeSelectorCandidates: readonly StateSelectorCandidate[];
+	selectorCandidates: readonly StateSelectorCandidate[];
+}
+
+function normalizedFlagName(arg: string): string | undefined {
+	if (!arg.startsWith("--")) return undefined;
+	const equalsIndex = arg.indexOf("=");
+	return equalsIndex < 0 ? arg : arg.slice(0, equalsIndex);
+}
+
+function normalizedSelector(value: unknown): string | undefined {
+	return typeof value === "string" ? value.trim() || undefined : undefined;
+}
+
+interface StatePositional {
+	value: string;
+	index: number;
+}
+
+function parseRuntimePositionals(argv: readonly string[]): StatePositional[] {
+	const positionals: StatePositional[] = [];
+	let skipNext = false;
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index]!;
+		if (skipNext) {
+			skipNext = false;
+			continue;
+		}
+		if (STATE_FLAGS_WITH_VALUES.has(arg)) {
+			skipNext = true;
+			continue;
+		}
+		if (!arg.startsWith("-")) positionals.push({ value: arg, index });
+	}
+	return positionals;
+}
+
+function parseAction(positionals: readonly StatePositional[]): {
+	action: StateAction;
+	positionalSkill?: string;
+	positionalSkillIndex: number;
+} {
+	const [first, second] = positionals;
+	if (first?.value && STATE_ACTION_NAMES.has(first.value as StateAction)) {
+		return {
+			action: first.value as StateAction,
+			...(second?.value ? { positionalSkill: second.value } : {}),
+			positionalSkillIndex: second?.value ? second.index : -1,
+		};
+	}
+	if (first?.value && second?.value && STATE_ACTION_NAMES.has(second.value as StateAction)) {
+		return { action: second.value as StateAction, positionalSkill: first.value, positionalSkillIndex: first.index };
+	}
+	if (first?.value && !second?.value) {
+		return { action: "read", positionalSkill: first.value, positionalSkillIndex: first.index };
+	}
+	return { action: "read", positionalSkillIndex: -1 };
+}
+
+function stateFlagArities(
+	action: StateAction,
+	positionalSkill: string | undefined,
+): ReadonlyMap<string, "boolean" | "value"> {
+	const arities = new Map<string, "boolean" | "value">();
+	for (const flag of STATE_FLAGS_WITH_VALUES) arities.set(flag, "value");
+	for (const flag of STATE_BOOLEAN_FLAGS) arities.set(flag, "boolean");
+
+	const skills =
+		positionalSkill && CANONICAL_GJC_WORKFLOW_SKILLS.includes(positionalSkill as CanonicalGjcWorkflowSkill)
+			? [positionalSkill as CanonicalGjcWorkflowSkill]
+			: CANONICAL_GJC_WORKFLOW_SKILLS;
+	for (const skill of skills) {
+		for (const arg of typedArgsFor(skill, action)) {
+			const name = `--${arg.name}`;
+			if (!arities.has(name)) arities.set(name, arg.type === "boolean" ? "boolean" : "value");
+		}
+	}
+	return arities;
+}
+
+function classifyInput(occurrence: StateFlagOccurrence): StateInputClassification {
+	const raw = occurrence.value ?? "";
+	const trimmed = raw.trim();
+	if (!trimmed) return { index: occurrence.index, raw, kind: "empty", selectors: [] };
+	if (trimmed.startsWith("@")) return { index: occurrence.index, raw, kind: "file", selectors: [] };
+	try {
+		const payload = JSON.parse(trimmed) as unknown;
+		if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+			return { index: occurrence.index, raw, kind: "invalid", selectors: [] };
+		}
+		const record = payload as Record<string, unknown>;
+		return {
+			index: occurrence.index,
+			raw,
+			kind: "inline",
+			selectors: [
+				{ source: "input.mode", value: normalizedSelector(record.mode), index: occurrence.index },
+				{ source: "input.skill", value: normalizedSelector(record.skill), index: occurrence.index },
+			],
+		};
+	} catch {
+		return { index: occurrence.index, raw, kind: "invalid", selectors: [] };
+	}
+}
+
+export function firstStateFlagValue(classification: StateArgvClassification, name: string): string | undefined {
+	const index = classification.argv.indexOf(name);
+	return index < 0 ? undefined : classification.argv[index + 1];
+}
+
+export function classifyStateArgv(argv: readonly string[]): StateArgvClassification {
+	const preservedArgv = [...argv];
+	const positionalEntries = parseRuntimePositionals(preservedArgv);
+	const positionals = positionalEntries.map(positional => positional.value);
+	const { action, positionalSkill, positionalSkillIndex } = parseAction(positionalEntries);
+	const flagArities = stateFlagArities(action, positionalSkill);
+	const flags: StateFlagOccurrence[] = [];
+	const unknownFlags: string[] = [];
+
+	for (let index = 0; index < preservedArgv.length; index += 1) {
+		const arg = preservedArgv[index]!;
+		const name = normalizedFlagName(arg);
+		if (!name) continue;
+		const arity = flagArities.get(name);
+		if (!arity) {
+			unknownFlags.push(name);
+			continue;
+		}
+		if (arg !== name) {
+			flags.push({
+				name,
+				index,
+				value: arg.slice(name.length + 1),
+				arity,
+				form: "attached",
+				malformed: true,
+			});
+			continue;
+		}
+		if (arity === "boolean") {
+			flags.push({ name, index, arity, form: "separate", malformed: false });
+			continue;
+		}
+		const value = preservedArgv[index + 1];
+		flags.push({
+			name,
+			index,
+			...(value === undefined ? {} : { value }),
+			arity,
+			form: "separate",
+			malformed: value === undefined || value.startsWith("--"),
+		});
+	}
+	const effectiveAction = action === "read" && preservedArgv.includes("--migrate") ? "migrate" : action;
+
+	const modeFlags = flags.filter(flag => flag.name === "--mode" && flag.form === "separate");
+	const inputFlags = flags.filter(flag => flag.name === "--input" && flag.form === "separate");
+	const inputs = inputFlags.map(classifyInput);
+	const positionalCandidate: StateSelectorCandidate = {
+		source: "positional",
+		value: normalizedSelector(positionalSkill),
+		index: positionalSkillIndex,
+	};
+	const modeCandidates = modeFlags.map(flag => ({
+		source: "mode" as const,
+		value: normalizedSelector(flag.value),
+		index: flag.index,
+	}));
+	const selectorCandidates = [positionalCandidate, ...modeCandidates, ...inputs.flatMap(input => input.selectors)];
+	const firstModeIndex = preservedArgv.indexOf("--mode");
+	const firstModeCandidate: StateSelectorCandidate = {
+		source: "mode",
+		value: normalizedSelector(firstModeIndex < 0 ? undefined : preservedArgv[firstModeIndex + 1]),
+		index: firstModeIndex,
+	};
+	const firstInputIndex = preservedArgv.indexOf("--input");
+	const firstInput =
+		firstInputIndex < 0
+			? undefined
+			: classifyInput({
+					name: "--input",
+					index: firstInputIndex,
+					value: preservedArgv[firstInputIndex + 1],
+					arity: "value",
+					form: "separate",
+					malformed: false,
+				});
+	const runtimeSelectorCandidates = [firstModeCandidate, positionalCandidate, ...(firstInput?.selectors ?? [])];
+
+	return {
+		argv: preservedArgv,
+		action,
+		effectiveAction,
+		...(positionalSkill === undefined ? {} : { positionalSkill }),
+		positionals,
+		flags,
+		unknownFlags,
+		inputs,
+		runtimeSelectorCandidates,
+		selectorCandidates,
+	};
+}