@oh-my-pi/pi-coding-agent 3.1.1337 → 3.4.1337

package/src/core/ttsr.ts

@@ -0,0 +1,211 @@
+/**
+ * Time Traveling Stream Rules (TTSR) Manager
+ *
+ * Manages rules that get injected mid-stream when their trigger pattern matches
+ * 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 type { Rule } from "../capability/rule";
+import { logger } from "./logger";
+import type { TtsrSettings } from "./settings-manager";
+
+interface TtsrEntry {
+	rule: Rule;
+	regex: RegExp;
+}
+
+/** Tracks when a rule was last injected (for repeat-after-gap mode) */
+interface InjectionRecord {
+	/** Message count when the rule was last injected */
+	lastInjectedAt: number;
+}
+
+export interface TtsrManager {
+	/** Add a TTSR rule to be monitored */
+	addRule(rule: Rule): void;
+
+	/** Check if any uninjected TTSR matches the stream buffer. Returns matching rules. */
+	check(streamBuffer: string): Rule[];
+
+	/** Mark rules as injected (won't trigger again until conditions allow) */
+	markInjected(rules: Rule[]): void;
+
+	/** Get names of all injected rules (for persistence) */
+	getInjectedRuleNames(): string[];
+
+	/** Restore injected state from a list of rule names */
+	restoreInjected(ruleNames: string[]): void;
+
+	/** Reset stream buffer (called on new turn) */
+	resetBuffer(): void;
+
+	/** Get current stream buffer */
+	getBuffer(): string;
+
+	/** Append to stream buffer */
+	appendToBuffer(text: string): void;
+
+	/** Check if any TTSRs are registered */
+	hasRules(): boolean;
+
+	/** Increment message counter (call after each turn) */
+	incrementMessageCount(): void;
+
+	/** Get current message count */
+	getMessageCount(): number;
+
+	/** Get settings */
+	getSettings(): Required<TtsrSettings>;
+}
+
+const DEFAULT_SETTINGS: Required<TtsrSettings> = {
+	enabled: true,
+	contextMode: "discard",
+	repeatMode: "once",
+	repeatGap: 10,
+};
+
+export function createTtsrManager(settings?: TtsrSettings): TtsrManager {
+	/** Resolved settings with defaults */
+	const resolvedSettings: Required<TtsrSettings> = {
+		...DEFAULT_SETTINGS,
+		...settings,
+	};
+
+	/** Map of rule name -> { rule, compiled regex } */
+	const rules = new Map<string, TtsrEntry>();
+
+	/** Map of rule name -> injection record */
+	const injectionRecords = new Map<string, InjectionRecord>();
+
+	/** Current stream buffer for pattern matching */
+	let buffer = "";
+
+	/** Message counter for tracking gap between injections */
+	let messageCount = 0;
+
+	/** Check if a rule can be triggered based on repeat settings */
+	function canTrigger(ruleName: string): boolean {
+		const record = injectionRecords.get(ruleName);
+		if (!record) {
+			// Never injected, can trigger
+			return true;
+		}
+
+		if (resolvedSettings.repeatMode === "once") {
+			// Once mode: never trigger again after first injection
+			return false;
+		}
+
+		// After-gap mode: check if enough messages have passed
+		const gap = messageCount - record.lastInjectedAt;
+		return gap >= resolvedSettings.repeatGap;
+	}
+
+	return {
+		addRule(rule: Rule): void {
+			// Only add rules that have a TTSR trigger pattern
+			if (!rule.ttsrTrigger) {
+				return;
+			}
+
+			// Skip if already registered
+			if (rules.has(rule.name)) {
+				return;
+			}
+
+			// Compile the regex pattern
+			try {
+				const regex = new RegExp(rule.ttsrTrigger);
+				rules.set(rule.name, { rule, regex });
+				logger.debug("TTSR rule registered", {
+					ruleName: rule.name,
+					pattern: rule.ttsrTrigger,
+				});
+			} catch (err) {
+				logger.warn("TTSR rule has invalid regex pattern, skipping", {
+					ruleName: rule.name,
+					pattern: rule.ttsrTrigger,
+					error: err instanceof Error ? err.message : String(err),
+				});
+			}
+		},
+
+		check(streamBuffer: string): Rule[] {
+			const matches: Rule[] = [];
+
+			for (const [name, entry] of rules) {
+				// Skip rules that can't trigger yet
+				if (!canTrigger(name)) {
+					continue;
+				}
+
+				// Test the buffer against the rule's pattern
+				if (entry.regex.test(streamBuffer)) {
+					matches.push(entry.rule);
+					logger.debug("TTSR pattern matched", {
+						ruleName: name,
+						pattern: entry.rule.ttsrTrigger,
+					});
+				}
+			}
+
+			return matches;
+		},
+
+		markInjected(rulesToMark: Rule[]): void {
+			for (const rule of rulesToMark) {
+				injectionRecords.set(rule.name, { lastInjectedAt: messageCount });
+				logger.debug("TTSR rule marked as injected", {
+					ruleName: rule.name,
+					messageCount,
+					repeatMode: resolvedSettings.repeatMode,
+				});
+			}
+		},
+
+		getInjectedRuleNames(): string[] {
+			return Array.from(injectionRecords.keys());
+		},
+
+		restoreInjected(ruleNames: string[]): void {
+			// When restoring, we don't know the original message count, so use 0
+			// This means in "after-gap" mode, rules can trigger again after the gap
+			for (const name of ruleNames) {
+				injectionRecords.set(name, { lastInjectedAt: 0 });
+			}
+			if (ruleNames.length > 0) {
+				logger.debug("TTSR injected state restored", { ruleNames });
+			}
+		},
+
+		resetBuffer(): void {
+			buffer = "";
+		},
+
+		getBuffer(): string {
+			return buffer;
+		},
+
+		appendToBuffer(text: string): void {
+			buffer += text;
+		},
+
+		hasRules(): boolean {
+			return rules.size > 0;
+		},
+
+		incrementMessageCount(): void {
+			messageCount++;
+		},
+
+		getMessageCount(): number {
+			return messageCount;
+		},
+
+		getSettings(): Required<TtsrSettings> {
+			return resolvedSettings;
+		},
+	};
+}

package/src/discovery/builtin.ts

@@ -310,6 +310,7 @@ function loadRules(ctx: LoadContext): LoadResult<Rule> {
 					globs: frontmatter.globs as string[] | undefined,
 					alwaysApply: frontmatter.alwaysApply as boolean | undefined,
 					description: frontmatter.description as string | undefined,
+					ttsrTrigger: typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined,
 					_source: source,
 				};
 			},

package/src/discovery/cline.ts

@@ -52,6 +52,7 @@ function loadRules(ctx: LoadContext): LoadResult<Rule> {
 					globs,
 					alwaysApply: typeof frontmatter.alwaysApply === "boolean" ? frontmatter.alwaysApply : undefined,
 					description: typeof frontmatter.description === "string" ? frontmatter.description : undefined,
+					ttsrTrigger: typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined,
 					_source: source,
 				};
 			},
@@ -85,6 +86,7 @@ function loadRules(ctx: LoadContext): LoadResult<Rule> {
 			globs,
 			alwaysApply: typeof frontmatter.alwaysApply === "boolean" ? frontmatter.alwaysApply : undefined,
 			description: typeof frontmatter.description === "string" ? frontmatter.description : undefined,
+			ttsrTrigger: typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined,
 			_source: source,
 		});
 	}

package/src/discovery/cursor.ts

@@ -163,6 +163,7 @@ function transformMDCRule(
 	// Extract frontmatter fields
 	const description = typeof frontmatter.description === "string" ? frontmatter.description : undefined;
 	const alwaysApply = frontmatter.alwaysApply === true;
+	const ttsrTrigger = typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined;
 
 	// Parse globs (can be array or single string)
 	let globs: string[] | undefined;
@@ -182,6 +183,7 @@ function transformMDCRule(
 		description,
 		alwaysApply,
 		globs,
+		ttsrTrigger,
 		_source: source,
 	};
 }

package/src/discovery/windsurf.ts

@@ -128,6 +128,7 @@ function loadRules(ctx: LoadContext): LoadResult<Rule> {
 				globs,
 				alwaysApply: frontmatter.alwaysApply as boolean | undefined,
 				description: frontmatter.description as string | undefined,
+				ttsrTrigger: typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined,
 				_source: createSourceMeta(PROVIDER_ID, userPath, "user"),
 			});
 		}
@@ -157,6 +158,7 @@ function loadRules(ctx: LoadContext): LoadResult<Rule> {
 					globs,
 					alwaysApply: frontmatter.alwaysApply as boolean | undefined,
 					description: frontmatter.description as string | undefined,
+					ttsrTrigger: typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined,
 					_source: source,
 				};
 			},
@@ -187,6 +189,7 @@ function loadRules(ctx: LoadContext): LoadResult<Rule> {
 				globs,
 				alwaysApply: frontmatter.alwaysApply as boolean | undefined,
 				description: frontmatter.description as string | undefined,
+				ttsrTrigger: typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined,
 				_source: createSourceMeta(PROVIDER_ID, legacyPath, "project"),
 			});
 		}

package/src/modes/interactive/components/footer.ts

@@ -58,6 +58,10 @@ export class FooterComponent implements Component {
 	private autoCompactEnabled: boolean = true;
 	private hookStatuses: Map<string, string> = new Map();
 
+	// Git status caching (1s TTL to avoid excessive subprocess spawns)
+	private cachedGitStatus: { staged: number; unstaged: number; untracked: number } | null = null;
+	private gitStatusLastFetch = 0;
+
 	constructor(session: AgentSession) {
 		this.session = session;
 	}
@@ -165,8 +169,14 @@ export class FooterComponent implements Component {
 	/**
 	 * Get git status indicators (staged, unstaged, untracked counts).
 	 * Returns null if not in a git repo.
+	 * Cached for 1s to avoid excessive subprocess spawns.
 	 */
 	private getGitStatus(): { staged: number; unstaged: number; untracked: number } | null {
+		const now = Date.now();
+		if (now - this.gitStatusLastFetch < 1000) {
+			return this.cachedGitStatus;
+		}
+
 		try {
 			const output = execSync("git status --porcelain 2>/dev/null", {
 				encoding: "utf8",
@@ -200,8 +210,12 @@ export class FooterComponent implements Component {
 				}
 			}
 
-			return { staged, unstaged, untracked };
+			this.cachedGitStatus = { staged, unstaged, untracked };
+			this.gitStatusLastFetch = now;
+			return this.cachedGitStatus;
 		} catch {
+			this.cachedGitStatus = null;
+			this.gitStatusLastFetch = now;
 			return null;
 		}
 	}

package/src/modes/interactive/components/settings-defs.ts

@@ -155,6 +155,35 @@ export const SETTINGS_DEFS: SettingDef[] = [
 		get: (sm) => sm.getEditFuzzyMatch(),
 		set: (sm, v) => sm.setEditFuzzyMatch(v),
 	},
+	{
+		id: "ttsrEnabled",
+		tab: "config",
+		type: "boolean",
+		label: "TTSR enabled",
+		description: "Time Traveling Stream Rules: interrupt agent when output matches rule patterns",
+		get: (sm) => sm.getTtsrEnabled(),
+		set: (sm, v) => sm.setTtsrEnabled(v),
+	},
+	{
+		id: "ttsrContextMode",
+		tab: "config",
+		type: "enum",
+		label: "TTSR context mode",
+		description: "What to do with partial output when TTSR triggers",
+		values: ["discard", "keep"],
+		get: (sm) => sm.getTtsrContextMode(),
+		set: (sm, v) => sm.setTtsrContextMode(v as "keep" | "discard"),
+	},
+	{
+		id: "ttsrRepeatMode",
+		tab: "config",
+		type: "enum",
+		label: "TTSR repeat mode",
+		description: "How rules can repeat: once per session or after a message gap",
+		values: ["once", "after-gap"],
+		get: (sm) => sm.getTtsrRepeatMode(),
+		set: (sm, v) => sm.setTtsrRepeatMode(v as "once" | "after-gap"),
+	},
 	{
 		id: "thinkingLevel",
 		tab: "config",

package/src/modes/interactive/components/ttsr-notification.ts

@@ -0,0 +1,82 @@
+import { Box, Container, Spacer, Text } from "@oh-my-pi/pi-tui";
+import type { Rule } from "../../../capability/rule";
+import { theme } from "../theme/theme";
+
+/**
+ * Component that renders a TTSR (Time Traveling Stream Rules) notification.
+ * Shows when a rule violation is detected and the stream is being rewound.
+ */
+export class TtsrNotificationComponent extends Container {
+	private rules: Rule[];
+	private box: Box;
+	private _expanded = false;
+
+	constructor(rules: Rule[]) {
+		super();
+		this.rules = rules;
+
+		this.addChild(new Spacer(1));
+
+		// Use inverse warning color for yellow background effect
+		this.box = new Box(1, 1, (t) => theme.inverse(theme.fg("warning", t)));
+		this.addChild(this.box);
+
+		this.rebuild();
+	}
+
+	setExpanded(expanded: boolean): void {
+		if (this._expanded !== expanded) {
+			this._expanded = expanded;
+			this.rebuild();
+		}
+	}
+
+	isExpanded(): boolean {
+		return this._expanded;
+	}
+
+	private rebuild(): void {
+		this.box.clear();
+
+		// Build header: ⚠ Injecting <bold>rule-name</bold>    ↩
+		const ruleNames = this.rules.map((r) => theme.bold(r.name)).join(", ");
+		const label = this.rules.length === 1 ? "rule" : "rules";
+		const header = `\u26A0 Injecting ${label}: ${ruleNames}`;
+
+		// Create header with rewind icon on the right
+		const rewindIcon = "\u21A9"; // ↩
+
+		this.box.addChild(new Text(`${header}  ${rewindIcon}`, 0, 0));
+
+		// Show description(s) - italic and truncated
+		for (const rule of this.rules) {
+			const desc = rule.description || rule.content;
+			if (desc) {
+				this.box.addChild(new Spacer(1));
+
+				let displayText = desc.trim();
+				if (!this._expanded) {
+					// Truncate to first 2 lines
+					const lines = displayText.split("\n");
+					if (lines.length > 2) {
+						displayText = `${lines.slice(0, 2).join("\n")}...`;
+					}
+				}
+
+				// Use italic for subtle distinction (fg colors conflict with inverse)
+				this.box.addChild(new Text(theme.italic(displayText), 0, 0));
+			}
+		}
+
+		// Show expand hint if collapsed and there's more content
+		if (!this._expanded) {
+			const hasMoreContent = this.rules.some((r) => {
+				const desc = r.description || r.content;
+				return desc && desc.split("\n").length > 2;
+			});
+			if (hasMoreContent) {
+				this.box.addChild(new Text(theme.italic(" (ctrl+o to expand)"), 0, 0));
+			}
+		}
+	}
+}