@oh-my-pi/pi-coding-agent 15.10.4 → 15.10.6

package/src/export/ttsr.ts

@@ -5,6 +5,8 @@
  * the agent's output. When a match occurs, the stream is aborted, the rule is
  * injected as a system reminder, and the request is retried.
  */
+import * as path from "node:path";
+import { AstMatchStrictness, astMatch } from "@oh-my-pi/pi-natives";
 import { logger } from "@oh-my-pi/pi-utils";
 import type { Rule } from "../capability/rule";
 import type { TtsrSettings } from "../config/settings";
@@ -38,6 +40,8 @@ interface TtsrScope {
 interface TtsrEntry {
 	rule: Rule;
 	conditions: RegExp[];
+	/** ast-grep pattern strings; matched only against edit/write tool snapshots. */
+	astConditions: string[];
 	scope: TtsrScope;
 	globalPathGlobs?: Bun.Glob[];
 }
@@ -70,6 +74,8 @@ export class TtsrManager {
 	readonly #rules = new Map<string, TtsrEntry>();
 	readonly #injectionRecords = new Map<string, InjectionRecord>();
 	readonly #buffers = new Map<string, string>();
+	/** Last snapshot evaluated for AST conditions, keyed by stream key, to dedupe matcher runs. */
+	readonly #lastAstSnapshots = new Map<string, string>();
 	#messageCount = 0;
 
 	constructor(settings?: TtsrSettings) {
@@ -302,7 +308,8 @@ export class TtsrManager {
 		}
 
 		const conditions = this.#compileConditions(rule);
-		if (conditions.length === 0) {
+		const astConditions = (rule.astCondition ?? []).map(pattern => pattern.trim()).filter(p => p.length > 0);
+		if (conditions.length === 0 && astConditions.length === 0) {
 			return false;
 		}
 
@@ -318,6 +325,7 @@ export class TtsrManager {
 		this.#rules.set(rule.name, {
 			rule,
 			conditions,
+			astConditions,
 			scope,
 			globalPathGlobs,
 		});
@@ -325,6 +333,7 @@ export class TtsrManager {
 		logger.debug("TTSR rule registered", {
 			ruleName: rule.name,
 			conditions: rule.condition,
+			astConditions: rule.astCondition,
 			scope: rule.scope,
 			globs: rule.globs,
 		});
@@ -359,6 +368,112 @@ export class TtsrManager {
 		return this.#matchBuffer(snapshot, context);
 	}
 
+	/** Derive an ast-grep language alias from candidate paths (bare extension, e.g. "ts"), if any. */
+	#deriveLang(filePaths: string[] | undefined): string | undefined {
+		for (const filePath of filePaths ?? []) {
+			const ext = path.extname(this.#normalizePath(filePath));
+			if (ext.length > 1) {
+				return ext.slice(1).toLowerCase();
+			}
+		}
+		return undefined;
+	}
+
+	/**
+	 * Evaluate ast-grep `astCondition` rules against a reconstructed tool snapshot.
+	 *
+	 * Only edit/write tool streams reach here (AST conditions need a language, which
+	 * we infer from the file extension on the tool's path argument). The snapshot is
+	 * matched in memory by the native engine (`astMatch`), so this is async and
+	 * intentionally throttled: identical consecutive snapshots (the common case when
+	 * only non-source arguments change between deltas) are skipped.
+	 */
+	async checkAstSnapshot(snapshot: string, context: TtsrMatchContext): Promise<Rule[]> {
+		if (!this.#settings.enabled || context.source !== "tool") {
+			return [];
+		}
+
+		const lang = this.#deriveLang(context.filePaths);
+		if (!lang) {
+			return [];
+		}
+
+		const candidates: TtsrEntry[] = [];
+		for (const [name, entry] of this.#rules) {
+			if (entry.astConditions.length === 0) {
+				continue;
+			}
+			if (
+				!this.#canTrigger(name) ||
+				!this.#matchesScope(entry, context) ||
+				!this.#matchesGlobalPaths(entry, context)
+			) {
+				continue;
+			}
+			candidates.push(entry);
+		}
+		if (candidates.length === 0) {
+			return [];
+		}
+
+		// Throttle: skip re-running the matcher when the source content is unchanged.
+		const bufferKey = this.#bufferKey(context);
+		if (this.#lastAstSnapshots.get(bufferKey) === snapshot) {
+			return [];
+		}
+		this.#lastAstSnapshots.set(bufferKey, snapshot);
+
+		const matches: Rule[] = [];
+		for (const entry of candidates) {
+			if (await this.#astConditionsMatch(entry.astConditions, snapshot, lang)) {
+				matches.push(entry.rule);
+				logger.debug("TTSR ast condition matched", {
+					ruleName: entry.rule.name,
+					astConditions: entry.rule.astCondition,
+					toolName: context.toolName,
+					filePaths: context.filePaths,
+				});
+			}
+		}
+		return matches;
+	}
+
+	async #astConditionsMatch(patterns: string[], source: string, lang: string): Promise<boolean> {
+		try {
+			const result = await astMatch({
+				patterns,
+				source,
+				lang,
+				strictness: AstMatchStrictness.Smart,
+				limit: 1,
+			});
+			if (result.parseErrors && result.parseErrors.length > 0) {
+				logger.debug("TTSR ast match reported parse errors", { parseErrors: result.parseErrors });
+			}
+			return result.totalMatches > 0;
+		} catch (error) {
+			logger.warn("TTSR ast match failed, treating as no match", {
+				patterns,
+				lang,
+				error: error instanceof Error ? error.message : String(error),
+			});
+			return false;
+		}
+	}
+
+	/** True when any registered rule carries ast-grep conditions. */
+	hasAstRules(): boolean {
+		if (!this.#settings.enabled) {
+			return false;
+		}
+		for (const entry of this.#rules.values()) {
+			if (entry.astConditions.length > 0) {
+				return true;
+			}
+		}
+		return false;
+	}
+
 	#matchBuffer(buffer: string, context: TtsrMatchContext): Rule[] {
 		if (!this.#settings.enabled) {
 			return [];
@@ -435,6 +550,7 @@ export class TtsrManager {
 	/** Reset stream buffers (called on new turn). */
 	resetBuffer(): void {
 		this.#buffers.clear();
+		this.#lastAstSnapshots.clear();
 	}
 
 	/** Check if any TTSR rules are registered. */
@@ -445,6 +561,11 @@ export class TtsrManager {
 		return this.#rules.size > 0;
 	}
 
+	/** All rules currently registered for TTSR monitoring, in registration order. */
+	getRules(): Rule[] {
+		return Array.from(this.#rules.values(), entry => entry.rule);
+	}
+
 	/** Increment message counter (call after each turn). */
 	incrementMessageCount(): void {
 		this.#messageCount++;

package/src/extensibility/extensions/types.ts

@@ -28,7 +28,7 @@ import type {
 	TextContent,
 	TSchema,
 } from "@oh-my-pi/pi-ai";
-import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/utils/oauth/types";
+import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/oauth/types";
 import type * as piCodingAgent from "@oh-my-pi/pi-coding-agent";
 import type { AutocompleteItem, Component, EditorTheme, KeyId, TUI } from "@oh-my-pi/pi-tui";
 import type { logger as PiLogger } from "@oh-my-pi/pi-utils";
@@ -1134,6 +1134,13 @@ export interface ProviderConfig {
 		/** Optional model rewrite hook for credential-aware routing (e.g., enterprise URLs). */
 		modifyModels?(models: Model<Api>[], credentials: OAuthCredentials): Model<Api>[];
 	};
+	/**
+	 * Async factory that fetches the live model list from the provider endpoint.
+	 * Runs through the same SQLite model-cache as built-in providers (keyed by
+	 * provider name, default 24 h TTL). Receives the resolved API key (undefined
+	 * when unauthenticated). Mutually exclusive with `models`.
+	 */
+	fetchDynamicModels?: (apiKey: string | undefined) => Promise<readonly ProviderModelConfig[]>;
 }
 
 /** Configuration for a model within a provider. */

package/src/extensibility/legacy-pi-ai-shim.ts

@@ -8,7 +8,7 @@
  * entrypoint. Legacy extensions still author parameter schemas as
  * `Type.Object({ ... })`, so this file is served by `legacy-pi-compat.ts` in
  * place of the real pi-ai entrypoint whenever a legacy extension imports the
- * bare package root. Subpath imports (`@oh-my-pi/pi-ai/utils/oauth`, etc.)
+ * bare package root. Subpath imports (`@oh-my-pi/pi-ai/oauth`, etc.)
  * continue to resolve directly against the bundled pi-ai package.
  *
  * The `Type` runtime is borrowed from the Zod-backed TypeBox shim that

package/src/extensibility/plugins/doctor.ts

@@ -48,7 +48,7 @@ export function formatDoctorResults(checks: DoctorCheck[]): string {
 	for (const check of checks) {
 		const icon =
 			check.status === "ok"
-				? theme.status.success
+				? theme.status.enabled
 				: check.status === "warning"
 					? theme.status.warning
 					: theme.status.error;

package/src/extensibility/plugins/legacy-pi-compat.ts

@@ -33,10 +33,11 @@ const PI_PACKAGE_ALTERNATION = PI_PACKAGE_NAMES.join("|");
 // bundled copy. Add new entries as `pkg/from -> pkg/to` whenever a plugin
 // surfaces another upstream-only subpath that breaks resolution.
 const PI_SUBPATH_REMAPS: ReadonlyMap<string, string> = new Map<string, string>([
-	// `@mariozechner/pi-ai/oauth` re-exported `./utils/oauth/index.js`.
-	// Our pi-ai keeps the implementation under `utils/oauth` but never added a
-	// root-level re-export, so map the upstream subpath onto it directly.
-	["pi-ai/oauth", "pi-ai/utils/oauth"],
+	// (currently empty) Upstream `@mariozechner/pi-ai/oauth` re-exported
+	// `./utils/oauth/index.js`. Our pi-ai now exposes the same surface at the
+	// real `@oh-my-pi/pi-ai/oauth` export, so the legacy subpath canonicalizes
+	// straight to it with no rewrite. Add `from -> to` entries here whenever a
+	// future upstream-only subpath surfaces that breaks resolution.
 ]);
 
 const LEGACY_PI_SPECIFIER_FILTER = new RegExp(`^@(?:${PI_SCOPE_ALTERNATION})/(?:${PI_PACKAGE_ALTERNATION})(?:/.*)?$`);
@@ -119,7 +120,7 @@ const TYPEBOX_SHIM_PATH = BUNFS_PACKAGE_ROOT
 // longer satisfies those imports. The override below redirects only the bare
 // pi-ai package root onto a sibling shim that re-exports the canonical surface
 // plus the borrowed `Type` runtime from the Zod-backed TypeBox shim. Subpath
-// imports such as `@oh-my-pi/pi-ai/utils/oauth` continue to resolve directly
+// imports such as `@oh-my-pi/pi-ai/oauth` continue to resolve directly
 // against the bundled pi-ai package.
 const LEGACY_PI_AI_SHIM_PATH = BUNFS_PACKAGE_ROOT
 	? bunfsPath("coding-agent", "src", "extensibility", "legacy-pi-ai-shim.js")

package/src/goals/tools/goal-tool.ts

@@ -209,7 +209,7 @@ export const goalToolRenderer = {
 
 		const header = renderStatusLine(
 			{
-				icon: "success",
+				iconOverride: uiTheme.styledSymbol("tool.goal", "accent"),
 				title: "Goal",
 				description,
 				badge: { label: goal.status, color: goalBadgeColor(goal.status) },