@gajae-code/coding-agent 0.11.6 → 0.11.8

package/src/tools/skill-discovery.ts

@@ -21,6 +21,13 @@ export type SkillDiscoveryToolInput = z.infer<typeof skillDiscoverySchema>;
 export interface SkillDiscoveryToolDetails {
 	candidates: RuntimeSkillDiscoveryCandidate[];
 	count: number;
+	/**
+	 * Present only when zero candidates were returned AND discovery config gates
+	 * (`skills.enabled` / `skills.enablePiProject` / `skills.enablePiUser`)
+	 * prevented some or all of the requested scope from being searched. Without
+	 * this, a disabled config is indistinguishable from "no skills exist".
+	 */
+	notice?: string;
 }
 
 export class SkillDiscoveryTool implements AgentTool<typeof skillDiscoverySchema, SkillDiscoveryToolDetails> {
@@ -57,17 +64,46 @@ export class SkillDiscoveryTool implements AgentTool<typeof skillDiscoverySchema
 		signal?: AbortSignal,
 	): Promise<AgentToolResult<SkillDiscoveryToolDetails>> {
 		return untilAborted(signal, async () => {
+			const source = input.source ?? "all";
 			const candidates = await discoverRuntimeSkills({
 				cwd: this.#session.cwd,
 				query: input.query,
-				source: input.source ?? "all",
+				source,
 				limit: input.limit,
 				policy: this.#getRuntimeSkillPolicy(),
 			});
+			const details: SkillDiscoveryToolDetails = { candidates, count: candidates.length };
+			if (candidates.length === 0) {
+				const notice = this.#disabledPolicyNotice(source);
+				if (notice) details.notice = notice;
+			}
 			return {
-				content: [{ type: "text", text: JSON.stringify({ candidates, count: candidates.length }, null, 2) }],
-				details: { candidates, count: candidates.length },
+				content: [{ type: "text", text: JSON.stringify(details, null, 2) }],
+				details,
 			};
 		});
 	}
+
+	/**
+	 * Explain an empty result that is caused by disabled discovery config rather
+	 * than by an actually empty skill catalog.
+	 */
+	#disabledPolicyNotice(source: "all" | "project" | "user"): string | undefined {
+		const policy = this.#getRuntimeSkillPolicy();
+		if (policy.enabled !== true) {
+			return "Runtime skill discovery is disabled: `skills.enabled` is false, so no skill directories were searched. Enable it with `gjc config set skills.enabled true` (project and user scopes additionally require `skills.enablePiProject` / `skills.enablePiUser`).";
+		}
+		const skipped: string[] = [];
+		const commands: string[] = [];
+		if ((source === "all" || source === "project") && policy.enablePiProject !== true) {
+			skipped.push("project (`skills.enablePiProject` is false)");
+			commands.push("`gjc config set skills.enablePiProject true`");
+		}
+		if ((source === "all" || source === "user") && policy.enablePiUser !== true) {
+			skipped.push("user (`skills.enablePiUser` is false)");
+			commands.push("`gjc config set skills.enablePiUser true`");
+		}
+		if (skipped.length === 0) return undefined;
+		return `Skill discovery skipped disabled scope(s): ${skipped.join(", ")}. Enable them with ${commands.join(" and ")}.`;
+	}
 }

package/src/tools/sqlite-reader.ts

@@ -272,6 +272,7 @@ const COMMENT_OR_TERMINATOR_ERROR =
 	"SQLite 'where' clause must not contain comments or statement terminators; use '?q=SELECT ...' for raw SQL";
 const FORBIDDEN_KEYWORD_ERROR =
 	"SQLite 'where' clause must not contain LIMIT/OFFSET/UNION/INTERSECT/EXCEPT/ATTACH/DETACH/PRAGMA; use '?q=SELECT ...' for raw SQL";
+const RAW_QUERY_ERROR = "SQLite raw queries must contain exactly one explicit SELECT statement";
 
 /**
  * Scans a `where=` clause character-by-character, tracking single- and double-quoted
@@ -363,6 +364,66 @@ function validateWhereClause(where: string | undefined): string | undefined {
 	return trimmed;
 }
 
+/**
+ * Keep raw reads deliberately narrower than SQLite's full grammar. Comments are
+ * rejected, and a statement terminator is accepted only as the final
+ * non-whitespace character. Quoted semicolons remain ordinary query data.
+ */
+export function validateSqliteReadQuery(sql: string): string {
+	const trimmed = sql.trim();
+	if (!/^SELECT\b/i.test(trimmed)) {
+		throw new ToolError(RAW_QUERY_ERROR);
+	}
+
+	let quoteEnd: "'" | '"' | "`" | "]" | null = null;
+	for (let index = 0; index < trimmed.length; index++) {
+		const char = trimmed[index];
+		const next = trimmed[index + 1];
+		if (char === "\0") {
+			throw new ToolError(RAW_QUERY_ERROR);
+		}
+
+		if (quoteEnd) {
+			if (char === quoteEnd) {
+				if (quoteEnd !== "]" && next === quoteEnd) {
+					index += 1;
+				} else {
+					quoteEnd = null;
+				}
+			}
+			continue;
+		}
+
+		if (char === "'" || char === '"' || char === "`") {
+			quoteEnd = char;
+			continue;
+		}
+		if (char === "[") {
+			quoteEnd = "]";
+			continue;
+		}
+		if ((char === "-" && next === "-") || (char === "/" && next === "*") || (char === "*" && next === "/")) {
+			throw new ToolError(RAW_QUERY_ERROR);
+		}
+		if (char === ";" && trimmed.slice(index + 1).trim().length > 0) {
+			throw new ToolError(RAW_QUERY_ERROR);
+		}
+	}
+
+	if (quoteEnd) {
+		throw new ToolError(RAW_QUERY_ERROR);
+	}
+	return trimmed;
+}
+
+export function enforceSqliteQueryOnly(db: Database): void {
+	db.run("PRAGMA query_only = ON");
+	const enabled = db.prepare<{ query_only: number }, []>("PRAGMA query_only").get()?.query_only;
+	if (enabled !== 1) {
+		throw new ToolError("SQLite read connection could not enable query-only mode");
+	}
+}
+
 function normalizeWriteValue(value: unknown, column: string): SqliteBinding {
 	if (value === null) return null;
 	if (
@@ -444,10 +505,7 @@ export function parseSqliteSelector(subPath: string, queryString: string): Sqlit
 		if (normalizedSubPath || otherKeys.length > 0) {
 			throw new ToolError("SQLite raw queries cannot be combined with table selectors or pagination");
 		}
-		if (!rawQuery.trim()) {
-			throw new ToolError("SQLite query parameter 'q' cannot be empty");
-		}
-		return { kind: "raw", sql: rawQuery };
+		return { kind: "raw", sql: validateSqliteReadQuery(rawQuery) };
 	}
 
 	if (!normalizedSubPath) {
@@ -602,7 +660,7 @@ export function executeReadQuery(
 	sql: string,
 	maxRows: number = MAX_RAW_QUERY_ROWS,
 ): { columns: string[]; rows: Record<string, unknown>[]; truncated: boolean } {
-	const statement = db.prepare<SqliteRow, []>(sql);
+	const statement = db.prepare<SqliteRow, []>(validateSqliteReadQuery(sql));
 	if (statement.paramsCount > 0) {
 		throw new ToolError("SQLite raw queries do not support bound parameters");
 	}

package/src/utils/edit-mode.ts

@@ -1,4 +1,4 @@
-import { $env } from "@gajae-code/utils/env";
+import { $pickenv } from "@gajae-code/utils/env";
 
 export type EditMode = "replace" | "patch" | "hashline" | "vim" | "apply_patch";
 
@@ -34,7 +34,7 @@ export function resolveEditMode(session: EditModeSessionLike): EditMode {
 	const modelVariant = session.settings.getEditVariantForModel?.(activeModel);
 	if (modelVariant) return modelVariant;
 
-	const envMode = normalizeEditMode($env.PI_EDIT_VARIANT);
+	const envMode = normalizeEditMode($pickenv("GJC_EDIT_VARIANT", "PI_EDIT_VARIANT"));
 	if (envMode) return envMode;
 
 	const settingsMode = normalizeEditMode(String(session.settings.get("edit.mode") ?? ""));

package/src/utils/pasted-image-path.ts

@@ -143,6 +143,7 @@ function tokenizePastedPathCandidates(
 	text: string,
 	options: DecodePastedPathOptions,
 	maxCandidates: number,
+	requireCompletePayload = false,
 ): TokenizePastedPathsResult {
 	if (text.length > MAX_PASTED_IMAGE_PASTE_CHARACTERS) return { kind: "invalid" };
 	const platform = options.platform ?? process.platform;
@@ -154,7 +155,9 @@ function tokenizePastedPathCandidates(
 
 	const startCandidate = (): TokenizePastedPathsResult | undefined => {
 		if (candidateStarted) return undefined;
-		if (candidates.length >= maxCandidates) return { kind: "too-many", maxCandidates, candidates: [...candidates] };
+		if (!requireCompletePayload && candidates.length >= maxCandidates) {
+			return { kind: "too-many", maxCandidates, candidates: [...candidates] };
+		}
 		candidateStarted = true;
 		return undefined;
 	};
@@ -167,7 +170,9 @@ function tokenizePastedPathCandidates(
 	const finishCandidate = (): TokenizePastedPathsResult | undefined => {
 		if (!candidateStarted) return undefined;
 		if (!candidate) return { kind: "invalid" };
-		if (candidates.length >= maxCandidates) return { kind: "too-many", maxCandidates, candidates: [...candidates] };
+		if (!requireCompletePayload && candidates.length >= maxCandidates) {
+			return { kind: "too-many", maxCandidates, candidates: [...candidates] };
+		}
 		const decoded = decodeListToken(candidate, options, platform);
 		if (decoded === undefined) return { kind: "invalid" };
 		candidates.push(decoded);
@@ -225,6 +230,7 @@ function tokenizePastedPathCandidates(
 	if (state !== "normal") return { kind: "invalid" };
 	const finalResult = finishCandidate();
 	if (finalResult) return finalResult;
+	if (candidates.length > maxCandidates) return { kind: "too-many", maxCandidates, candidates };
 	return candidates.length === 0 ? { kind: "invalid" } : { kind: "candidates", candidates };
 }
 
@@ -257,8 +263,12 @@ function isRecognizedClipboardTempPath(filePath: string, platform: NodeJS.Platfo
 /** Resolve one recognized clipboard-temp image path lexically, before any filesystem access. */
 export function resolvePastedImagePath(text: string, options: ResolvePastedImagePathOptions = {}): string | undefined {
 	const platform = options.platform ?? process.platform;
-	const candidate = decodePastedPathCandidate(text, options);
-	if (!candidate || !IMAGE_FILE_EXTENSION_PATTERN.test(candidate)) return undefined;
+	const terminalNewlinesTrimmed = text.replace(/(?:\r\n|\r|\n)+$/, "");
+	if (/\r|\n/.test(terminalNewlinesTrimmed)) return undefined;
+	const candidates = decodePastedPathCandidates(terminalNewlinesTrimmed, options, 1);
+	if (candidates?.length !== 1) return undefined;
+	const candidate = candidates[0];
+	if (!IMAGE_FILE_EXTENSION_PATTERN.test(candidate)) return undefined;
 	if (platform === "win32" && isRemoteWindowsPath(candidate)) return undefined;
 	const resolved = resolveCandidate(candidate, options, platform);
 	return isRecognizedClipboardTempPath(resolved, platform) ? resolved : undefined;
@@ -274,10 +284,9 @@ export function parsePastedImagePaths(
 	options: ResolvePastedImagePathOptions = {},
 ): PastedImagePathParseResult | undefined {
 	const platform = options.platform ?? process.platform;
-	const tokenized = tokenizePastedPathCandidates(text, options, MAX_PASTED_IMAGE_COUNT);
+	const tokenized = tokenizePastedPathCandidates(text, options, MAX_PASTED_IMAGE_COUNT, true);
 	if (tokenized.kind === "too-many") {
 		if (
-			tokenized.candidates.length !== MAX_PASTED_IMAGE_COUNT ||
 			tokenized.candidates.some(
 				candidate =>
 					!IMAGE_FILE_EXTENSION_PATTERN.test(candidate) ||

package/src/utils/prompt-suggestion.ts

@@ -0,0 +1,265 @@
+/**
+ * Predict the user's likely next prompt after an agent turn using a smol,
+ * fast model. Native GJC port of the ghost-text prompt-suggestion behavior
+ * from Claude Code: the prediction renders as dim ghost text in the empty
+ * composer and Tab accepts it.
+ */
+import type { AgentMessage } from "@gajae-code/agent-core";
+import { type Api, type AssistantMessage, completeSimple, type Model } from "@gajae-code/ai";
+import { logger, prompt } from "@gajae-code/utils";
+import type { ModelRegistry } from "../config/model-registry";
+import { resolveRoleSelection } from "../config/model-resolver";
+import type { Settings } from "../config/settings";
+import suggestionSystemPrompt from "../prompts/system/prompt-suggestion-system.md" with { type: "text" };
+
+const SUGGESTION_SYSTEM_PROMPT = prompt.render(suggestionSystemPrompt);
+
+export const PROMPT_SUGGESTION_MAX_WORDS = 12;
+export const PROMPT_SUGGESTION_MAX_CHARS = 100;
+
+const SUGGESTION_MAX_TOKENS = 64;
+const REASONING_SAFE_MAX_TOKENS = 1024;
+const MAX_CONTEXT_MESSAGES = 12;
+const MAX_MESSAGE_CHARS = 1500;
+const MAX_CONTEXT_CHARS = 8000;
+
+/** Single words a user plausibly types on their own; anything else needs >= 2 words. */
+const SINGLE_WORD_ALLOWLIST = new Set([
+	"yes",
+	"yeah",
+	"yep",
+	"yea",
+	"yup",
+	"sure",
+	"ok",
+	"okay",
+	"push",
+	"commit",
+	"deploy",
+	"stop",
+	"continue",
+	"check",
+	"exit",
+	"quit",
+	"no",
+]);
+
+/** Model responses that are meta-statements about staying silent, not suggestions. */
+const META_TEXT_PATTERN = /\bsilence is\b|\bstay(s|ing)? silent\b/;
+
+/**
+ * Strip wrapper tags and label prefixes a model sometimes adds despite being
+ * told to reply with only the suggestion.
+ */
+export function sanitizePromptSuggestion(raw: string): string {
+	return raw
+		.trim()
+		.replace(/^<(suggestion|response|output|answer|result)>([\s\S]*)<\/\1>$/i, (match, tag: string, inner: string) =>
+			// Keep the original when the inner text itself contains the closing
+			// tag (nested/ambiguous markup) instead of producing a mangled strip.
+			inner.includes(`</${tag.toLowerCase()}>`) || inner.includes(`</${tag.toUpperCase()}>`) ? match : inner,
+		)
+		.replace(
+			/^\s*(suggested\s+(response|reply|input|prompt)|suggestion|response|reply|answer|output|result)\s*:\s*/i,
+			"",
+		)
+		.trim();
+}
+
+/**
+ * Heuristic gate rejecting model output that would make a bad ghost-text
+ * suggestion. Returns the rejection reason, or null when the text is usable.
+ */
+export function suppressPromptSuggestionReason(text: string): string | null {
+	if (!text) return "empty";
+	const lower = text.toLowerCase();
+	const wordCount = text.trim().split(/\s+/).length;
+
+	if (lower === "done") return "done";
+	if (
+		lower === "nothing found" ||
+		lower === "nothing found." ||
+		lower.startsWith("nothing to suggest") ||
+		lower.startsWith("no suggestion") ||
+		META_TEXT_PATTERN.test(lower) ||
+		/^\W*silence\W*$/.test(lower)
+	) {
+		return "meta_text";
+	}
+	if (/^\(.*\)$|^\[.*\]$/.test(text)) return "meta_wrapped";
+	if (
+		lower.startsWith("api error:") ||
+		lower.startsWith("prompt is too long") ||
+		lower.startsWith("request timed out") ||
+		lower.startsWith("invalid api key")
+	) {
+		return "error_message";
+	}
+	if (/^\w+:\s/.test(text)) return "prefixed_label";
+	if (wordCount < 2 && !text.startsWith("/") && !SINGLE_WORD_ALLOWLIST.has(lower)) return "too_few_words";
+	if (wordCount > PROMPT_SUGGESTION_MAX_WORDS) return "too_many_words";
+	if (text.length >= PROMPT_SUGGESTION_MAX_CHARS) return "too_long";
+	if (/[.!?]\s+[A-Z]/.test(text)) return "multiple_sentences";
+	if (/[\n*]|\*\*/.test(text)) return "has_formatting";
+	if (
+		/thanks|thank you|looks good|sounds good|that works|that worked|that's all|nice|great|perfect|makes sense|awesome|excellent/.test(
+			lower,
+		)
+	) {
+		return "evaluative";
+	}
+	if (
+		/^(let me|i'll|i've|i'm|i can|i would|i think|i notice|here's|here is|here are|that's|this is|this will|you can|you should|you could|sure,|of course|certainly)/i.test(
+			text,
+		)
+	) {
+		return "claude_voice";
+	}
+	return null;
+}
+
+function extractTranscriptEntry(message: AgentMessage): { role: "User" | "Assistant"; text: string } | null {
+	if (message.role === "user") {
+		const content = message.content;
+		const text =
+			typeof content === "string"
+				? content
+				: content
+						.filter(block => block.type === "text")
+						.map(block => block.text)
+						.join("\n");
+		const trimmed = text.trim();
+		return trimmed ? { role: "User", text: trimmed } : null;
+	}
+	if (message.role === "assistant") {
+		const text = (message as AssistantMessage).content
+			.filter(block => block.type === "text")
+			.map(block => block.text)
+			.join("\n")
+			.trim();
+		return text ? { role: "Assistant", text } : null;
+	}
+	return null;
+}
+
+/**
+ * Build a compact recent-conversation transcript for the prediction request.
+ * Returns null when there is no user message to predict from.
+ */
+export function buildPromptSuggestionContext(messages: AgentMessage[]): string | null {
+	const entries: { role: "User" | "Assistant"; text: string }[] = [];
+	let totalChars = 0;
+	for (let index = messages.length - 1; index >= 0 && entries.length < MAX_CONTEXT_MESSAGES; index--) {
+		const message = messages[index];
+		if (!message) continue;
+		const entry = extractTranscriptEntry(message);
+		if (!entry) continue;
+		const text = entry.text.length > MAX_MESSAGE_CHARS ? `${entry.text.slice(0, MAX_MESSAGE_CHARS)}…` : entry.text;
+		if (totalChars + text.length > MAX_CONTEXT_CHARS && entries.length > 0) break;
+		entries.push({ role: entry.role, text });
+		totalChars += text.length;
+	}
+	if (!entries.some(entry => entry.role === "User")) return null;
+	entries.reverse();
+	const transcript = entries.map(entry => `${entry.role}: ${entry.text}`).join("\n\n");
+	return `<conversation>\n${transcript}\n</conversation>\n\nPredict the user's next message.`;
+}
+
+function getSuggestionModel(
+	registry: ModelRegistry,
+	settings: Settings,
+	currentModel?: Model<Api>,
+): Model<Api> | undefined {
+	const availableModels = registry.getAvailable();
+	if (availableModels.length === 0) return undefined;
+	const model = resolveRoleSelection(["default"], settings, availableModels, registry)?.model;
+	if (model) return model;
+	return currentModel;
+}
+
+function extractSuggestionText(contentBlocks: AssistantMessage["content"]): string {
+	let text = "";
+	for (const content of contentBlocks) {
+		if (content.type === "text") {
+			text += content.text;
+		}
+	}
+	return text;
+}
+
+/**
+ * Generate a predicted next user prompt from the recent conversation.
+ * Returns null when no usable suggestion is produced (silence is the
+ * expected steady state).
+ */
+export async function generatePromptSuggestion(
+	messages: AgentMessage[],
+	registry: ModelRegistry,
+	settings: Settings,
+	sessionId?: string,
+	currentModel?: Model<Api>,
+	metadataResolver?: (provider: string) => Record<string, unknown> | undefined,
+): Promise<string | null> {
+	const context = buildPromptSuggestionContext(messages);
+	if (!context) return null;
+
+	const model = getSuggestionModel(registry, settings, currentModel);
+	if (!model) {
+		logger.debug("prompt-suggestion: no model available");
+		return null;
+	}
+
+	const apiKey = await registry.getApiKey(model, sessionId);
+	if (!apiKey) {
+		logger.debug("prompt-suggestion: no API key", { provider: model.provider, id: model.id });
+		return null;
+	}
+	// Resolve metadata after getApiKey so the session-sticky credential for
+	// this request is already recorded (same contract as title-generator).
+	const metadata = metadataResolver?.(model.provider);
+
+	// A suggestion is a 2-12 word task, but some reasoning backends ignore
+	// disableReasoning; reserve output room for the answer after any
+	// unavoidable thinking tokens.
+	const maxTokens = model.reasoning
+		? Math.max(SUGGESTION_MAX_TOKENS, REASONING_SAFE_MAX_TOKENS)
+		: SUGGESTION_MAX_TOKENS;
+
+	try {
+		const response = await completeSimple(
+			model,
+			{
+				systemPrompt: [SUGGESTION_SYSTEM_PROMPT],
+				messages: [{ role: "user", content: context, timestamp: Date.now() }],
+			},
+			{
+				apiKey,
+				maxTokens,
+				disableReasoning: true,
+				metadata,
+			},
+		);
+
+		if (response.stopReason === "error") {
+			logger.debug("prompt-suggestion: response error", {
+				model: `${model.provider}/${model.id}`,
+				errorMessage: response.errorMessage,
+			});
+			return null;
+		}
+
+		const suggestion = sanitizePromptSuggestion(extractSuggestionText(response.content));
+		const suppressReason = suppressPromptSuggestionReason(suggestion);
+		if (suppressReason) {
+			logger.debug("prompt-suggestion: suppressed", { reason: suppressReason });
+			return null;
+		}
+		return suggestion;
+	} catch (err) {
+		logger.debug("prompt-suggestion: error", {
+			model: `${model.provider}/${model.id}`,
+			error: err instanceof Error ? err.message : String(err),
+		});
+		return null;
+	}
+}