@gajae-code/coding-agent 0.12.21 → 0.13.0

package/src/quick-lane/classify.ts

@@ -0,0 +1,257 @@
+/**
+ * Deterministic quick-lane classifier (issue #3984).
+ *
+ * The deep-interview and ralplan skills describe a task-routing surface in
+ * prose: small, clearly scoped, low-risk work should take a quick lane
+ * (minimal orchestration) while vague, ambiguous, risky, or wide-breadth work
+ * keeps the existing deep path. That gate existed only as prompt guidance, so
+ * it was not auditable or testable. This module encodes the same signals as
+ * deterministic, pure code so eligibility and exclusions are explicit and
+ * regression-covered.
+ *
+ * The classifier is intentionally conservative and fail-closed:
+ * - Any exclusion signal forces the `deep` lane, even when the task also names
+ *   concrete files or symbols. Safety is never overridden by a concrete anchor.
+ * - The `deep` lane preserves the existing deep/interview behavior untouched;
+ *   this module only *classifies*, it never routes or mutates.
+ * - A task with neither a concrete anchor nor an exclusion defaults to `deep`
+ *   because boundness cannot be confirmed.
+ */
+
+export type QuickLane = "quick" | "deep";
+
+export interface QuickLaneDecision {
+	/** The routed lane: `quick` (bounded, direct execution) or `deep` (planning/interview path). */
+	lane: QuickLane;
+	/** Concrete anchors that made the task eligible for the quick lane (empty when `deep`). */
+	reasons: string[];
+	/** Exclusions that forced the deep lane (empty when `quick`). */
+	exclusions: string[];
+}
+
+/** Build a standalone-word regex so keywords do not match inside joined identifiers or file names. */
+function standalone(word: string): RegExp {
+	return new RegExp(`(?<![A-Za-z0-9_-])${word}(?![A-Za-z0-9_-])`, "i");
+}
+
+/** Source/config file extensions treated as concrete file-path anchors. */
+const FILE_EXT =
+	"(?:ts|tsx|js|jsx|mjs|cjs|py|rs|go|rb|md|markdown|json|jsonl|yml|yaml|toml|xml|sql|sh|bash|css|scss|html|vue|svelte|java|kt|scala|c|cpp|h|hpp|csv|txt|env|tf)";
+
+/** Regex matching one concrete file-path anchor (also used to count distinct paths). */
+const FILE_PATH_PATTERN = new RegExp(
+	`(?:(?:[A-Za-z0-9_@.+~\\-]+/)*[A-Za-z0-9_.@+\\-]+|(?:[A-Za-z0-9_@.+~\\-]+/)*\\.[A-Za-z0-9_-]+|(?:[A-Za-z0-9_@.+~\\-]+/)*)\\.${FILE_EXT}(?![A-Za-z0-9])`,
+	"i",
+);
+
+/** Global variant of FILE_PATH_PATTERN for counting distinct file-path anchors. */
+const FILE_PATH_PATTERN_GLOBAL = new RegExp(FILE_PATH_PATTERN.source, "gi");
+
+/** Concrete anchors that establish quick-lane eligibility. */
+const QUICK_SIGNALS: ReadonlyArray<{ id: string; label: string; pattern: RegExp }> = [
+	{
+		id: "file-path",
+		label: "explicit file path",
+		pattern: FILE_PATH_PATTERN,
+	},
+	{
+		id: "issue-number",
+		label: "issue/PR number",
+		// Hex-color-shaped tokens (#rgb/#rgba/#rrggbb/#rrggbbaa) must not read as
+		// issue/PR numbers: exclude 3-digit rgb short forms, any token containing
+		// a hex letter (a-f), and 6/8-digit color forms. Pure 4+ digit numbers
+		// like #4146 remain issue/PR references.
+		pattern: /#(?!\d{3}\b|[0-9a-fA-F]*[a-fA-F][0-9a-fA-F]*\b)\d+/,
+	},
+	{
+		id: "named-symbol",
+		label: "named symbol (camelCase / snake_case)",
+		// lowerCamelCase and snake_case identifiers are unambiguous code anchors
+		// and rarely appear in ordinary prose. PascalCase is deliberately
+		// excluded to avoid false positives on proper nouns ("Google").
+		pattern:
+			/\b[a-z]{2,}[a-zA-Z0-9]*[A-Z][a-zA-Z0-9]*\b|\b[a-z][a-z0-9]*(?:_[a-z0-9]+)+\b|\b[A-Z][A-Z]+\b|\b[A-Z][a-z]+[A-Z][a-zA-Z0-9]*\b/,
+	},
+	{
+		id: "named-symbol-pascal",
+		label: "named symbol (PascalCase)",
+		// Two or more capitalized segments ("UserService" = User+Service) are
+		// unambiguous code anchors; single-segment proper nouns ("Google") and
+		// lowercase-leading names ("iPhone") must not match.
+		pattern: /\b[A-Z][a-z]+(?:[A-Z][a-z]*)+\b/,
+	},
+	{
+		id: "explicit-test",
+		label: "explicit test/validation request",
+		pattern:
+			/\b(?:bun test|unit test|integration test|regression(?: test)?|e2e(?: test)?|add (?:a )?(?:test|validation)|write (?:a )?(?:test|test case)|tests? for)\b/i,
+	},
+	{
+		id: "test-runner",
+		label: "test runner",
+		pattern:
+			/\b(?:run (?:pytest|vitest|jest|mocha|rspec|go test|cargo test|bun test|npm test|pnpm test|yarn test|deno test))\b/i,
+	},
+	{
+		id: "numbered-steps",
+		label: "numbered steps",
+		pattern: /(?:^|\n)\s*\d+[.)]\s+/m,
+	},
+	{
+		id: "acceptance-criteria",
+		label: "acceptance criteria / expected behavior",
+		pattern:
+			/\b(?:acceptance criteria|expected behavior|should (?:be|work|return|pass|fail|not|throw)|must (?:be|work|return|pass|not|throw)|when .*expect)\b/i,
+	},
+	{
+		id: "error-reference",
+		label: "error/failure reference",
+		pattern: /\b(?:error|exception|throws?|stack trace|fails? when|does not (?:work|load|start|run)|broken)\b/i,
+	},
+	{
+		id: "code-block",
+		label: "inline code or code fence",
+		pattern: /`[^`\n]+`|\n```/,
+	},
+	{
+		id: "explicit-override",
+		label: "explicit quick-lane override (force: / !)",
+		// The gate prose says "prefix `force:` or `!`" — only a prefix at the
+		// very start of the trimmed request counts, never mid-text.
+		pattern: /^(?:force:|!)\s*/,
+	},
+];
+
+/** Safety/risk exclusions that always force the deep lane. */
+const RISK_KEYWORDS = [
+	"auth",
+	"authentication",
+	"authorization",
+	"login",
+	"logout",
+	"security",
+	"secure",
+	"vulnerability",
+	"migrate",
+	"migration",
+	"destructive",
+	"compliance",
+	"pii",
+	"payment",
+	"ledger",
+	"legal",
+	"credential",
+	"secret",
+	"password",
+	"passphrase",
+	"passwd",
+	"privilege",
+	"firewall",
+	"encryption",
+	"decrypt",
+	"rollback",
+	"audit",
+	"breaking change",
+	"public api",
+	"api contract",
+];
+
+/** Explicit ambiguity / brainstorming exclusions that force the deep lane. */
+const AMBIGUITY_KEYWORDS = [
+	"i don't know",
+	"i do not know",
+	"not sure",
+	"unsure",
+	"vague",
+	"explore",
+	"brainstorm",
+	"open-ended",
+	"what should",
+	"what would",
+	"how should",
+	"kind of",
+	"something like",
+	"a thing",
+	"maybe",
+];
+
+/** Wide-breadth exclusions indicating multi-file / cross-contract scope. */
+const BREADTH_KEYWORDS = [
+	"all files",
+	"all modules",
+	"across modules",
+	"across every",
+	"everywhere",
+	"across the board",
+	"multiple modules",
+	"many files",
+	"entire",
+	"whole codebase",
+	"entire app",
+	"whole app",
+	"cross-cutting",
+	"cross-contract",
+	"the whole",
+	"redesign",
+	"redesigning",
+	"rewrite",
+	"rewriting",
+	"from scratch",
+];
+
+const EXCLUSION_KEYWORDS: ReadonlyArray<{ id: string; label: string; words: readonly string[] }> = [
+	{ id: "risk", label: "risk/safety-sensitive scope", words: RISK_KEYWORDS },
+	{ id: "ambiguity", label: "ambiguous or exploratory scope", words: AMBIGUITY_KEYWORDS },
+	{ id: "breadth", label: "multi-file / cross-contract breadth", words: BREADTH_KEYWORDS },
+];
+
+function matchesAny(text: string, words: readonly string[]): boolean {
+	return words.some(word => standalone(word).test(text));
+}
+
+/**
+ * Classify a task request into the quick lane (bounded, direct execution) or
+ * the deep path (existing planning/interview orchestration).
+ *
+ * Order of operations (fail-closed):
+ * 1. Exclusions are authoritative — any risk/ambiguity/breadth signal (including
+ *    two or more distinct file-path anchors) forces `deep`, even when concrete
+ *    anchors are present.
+ * 2. Otherwise, any concrete anchor yields `quick`.
+ * 3. Otherwise, `deep` (boundness could not be confirmed).
+ */
+export function classifyQuickLane(input: string): QuickLaneDecision {
+	const text = input.trim();
+	if (!text) {
+		return { lane: "deep", reasons: [], exclusions: ["empty request"] };
+	}
+
+	const exclusions: string[] = [];
+	for (const group of EXCLUSION_KEYWORDS) {
+		if (matchesAny(text, group.words)) {
+			exclusions.push(`${group.label} (matched keyword group "${group.id}")`);
+		}
+	}
+	const distinctFilePaths = new Set(Array.from(text.matchAll(FILE_PATH_PATTERN_GLOBAL), match => match[0]));
+	if (distinctFilePaths.size >= 2) {
+		exclusions.push("multi-file / cross-contract breadth (matched 2 or more distinct file paths)");
+	}
+	if (exclusions.length > 0) {
+		return { lane: "deep", reasons: [], exclusions };
+	}
+
+	const reasons: string[] = [];
+	for (const signal of QUICK_SIGNALS) {
+		if (signal.pattern.test(text)) {
+			reasons.push(signal.label);
+		}
+	}
+	if (reasons.length === 0) {
+		return {
+			lane: "deep",
+			reasons: [],
+			exclusions: ["no concrete anchor — boundedness cannot be confirmed"],
+		};
+	}
+	return { lane: "quick", reasons, exclusions: [] };
+}

package/src/rlm/index.ts

@@ -262,6 +262,7 @@ export async function runRlmCommand(argv: string[]): Promise<void> {
 	const cwd = getProjectDir();
 	ensureRlmGjcSessionId();
 	const { dataPath, resumeSessionId, minSuccessfulRuns, rest } = extractRlmFlags(argv);
+	const parsed = parseArgs(rest, "local");
 	const dataContext = await loadRlmDataContext(cwd, dataPath);
 
 	const sessionId = resumeSessionId ?? generateRlmSessionId();
@@ -297,7 +298,6 @@ export async function runRlmCommand(argv: string[]): Promise<void> {
 		},
 	});
 
-	const parsed = parseArgs(rest);
 	parsed.sessionDir = paths.agentSessionDir;
 	if (resumeSessionId) {
 		parsed.continue = true;

package/src/runtime/stt-settings-setup.ts

@@ -0,0 +1,57 @@
+export interface SttDependencySetupProgress {
+	stage: string;
+	percent?: number;
+}
+
+export interface SttDependencySetupOptions {
+	modelName?: string;
+	onProgress?: (progress: SttDependencySetupProgress) => void;
+}
+
+export type EnsureSttDependencies = (options?: SttDependencySetupOptions) => Promise<void>;
+
+export interface ConfigureSttFromSettingsOptions {
+	modelName?: string;
+	ensureDependencies?: EnsureSttDependencies;
+	setEnabled(enabled: false): void;
+	flush(): Promise<void>;
+	showStatus(message: string): void;
+	showError(message: string): void;
+}
+
+let ensureDependenciesPromise: Promise<EnsureSttDependencies> | undefined;
+
+async function loadEnsureSttDependencies(): Promise<EnsureSttDependencies> {
+	ensureDependenciesPromise ??= import("../stt/downloader").then(module => module.ensureSTTDependencies);
+	return ensureDependenciesPromise;
+}
+
+export async function configureSttFromSettings(options: ConfigureSttFromSettingsOptions): Promise<boolean> {
+	options.showStatus("Checking speech-to-text dependencies...");
+	try {
+		const ensureDependencies = options.ensureDependencies ?? (await loadEnsureSttDependencies());
+		await ensureDependencies({
+			modelName: options.modelName,
+			onProgress: progress => {
+				options.showStatus(progress.stage + (progress.percent === undefined ? "" : ` (${progress.percent}%)`));
+			},
+		});
+		options.showStatus("Speech-to-text is ready. Use /hotkeys or Ctrl+P → Toggle speech-to-text.");
+		return true;
+	} catch (error) {
+		const cause = error instanceof Error ? error.message : String(error);
+		let rollbackFailure: string | undefined;
+		try {
+			options.setEnabled(false);
+			await options.flush();
+		} catch (rollbackError) {
+			rollbackFailure = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
+		}
+		options.showError(
+			rollbackFailure
+				? `Speech-to-text setup failed: ${cause}. Disabling STT also failed: ${rollbackFailure}`
+				: `Speech-to-text setup failed: ${cause}. STT was disabled; fix the dependency and enable it again.`,
+		);
+		return false;
+	}
+}

package/src/sdk/acp/adapter.ts

@@ -229,10 +229,11 @@ export class AcpSdkAdapter {
 		// request that named no readiness budget is queued for the default one, so it
 		// needs the same extension rather than the client's generic request deadline.
 		const timeoutMs = lifecycleRequestTimeoutMs(operation, input);
-		return await this.#client.global(operation, input, {
+		const response = await this.#client.global(operation, input, {
 			idempotencyKey,
 			...(timeoutMs === undefined ? {} : { timeoutMs }),
 		});
+		return response;
 	}
 
 	async sdkControl(params: { operation: string; input?: JsonObject }): Promise<unknown> {