@hobin/developer 0.1.9 → 0.1.10

package/extensions/compaction-language.ts

@@ -0,0 +1,303 @@
+export const COMPACTION_LANGUAGE_PROTOCOL =
+	"developer.compaction-language/v1" as const;
+export const COMPACTION_LANGUAGE_ENTRY =
+	"developer.compaction-language" as const;
+export const COMPACTION_LANGUAGE_MESSAGE =
+	"developer.compaction-language-continuity" as const;
+
+export type LanguageTag = string;
+
+export interface LanguageObserved {
+	protocol: typeof COMPACTION_LANGUAGE_PROTOCOL;
+	kind: "language-observed";
+	tag: LanguageTag;
+}
+
+export interface ContinuityPending {
+	protocol: typeof COMPACTION_LANGUAGE_PROTOCOL;
+	kind: "continuity-pending";
+	compactionId: string;
+	tag: LanguageTag;
+}
+
+export interface ContinuityConsumed {
+	protocol: typeof COMPACTION_LANGUAGE_PROTOCOL;
+	kind: "continuity-consumed";
+	compactionId: string;
+}
+
+export type CompactionLanguageEvent =
+	| LanguageObserved
+	| ContinuityPending
+	| ContinuityConsumed;
+
+export interface PendingContinuity {
+	compactionId: string;
+	tag: LanguageTag;
+	injected: boolean;
+}
+
+export interface CompactionLanguageState {
+	language?: LanguageTag;
+	pending?: PendingContinuity;
+	consumedCompactionIds: ReadonlySet<string>;
+}
+
+export interface ContinuityContextMessage {
+	role: "custom";
+	customType: typeof COMPACTION_LANGUAGE_MESSAGE;
+	content: Array<{ type: "text"; text: string }>;
+	display: false;
+	details: {
+		protocol: typeof COMPACTION_LANGUAGE_PROTOCOL;
+		compactionId: string;
+		tag: LanguageTag;
+	};
+	timestamp: number;
+}
+
+interface BranchEntryLike {
+	type?: string;
+	customType?: string;
+	data?: unknown;
+}
+
+const KOREAN_SCRIPT = /[\u3131-\u318e\uac00-\ud7a3]/u;
+const ENGLISH_WORD = /[A-Za-z]+(?:'[A-Za-z]+)?/g;
+const COMMAND_ONLY =
+	/^(?:npm|pnpm|yarn|node|npx|git|rg|grep|find|cd|ls|cat|sed|bash)\b(?:\s+[-\w./:@]+)*$/u;
+const WEAK_ENGLISH_INPUTS = new Set([
+	"continue",
+	"done",
+	"go on",
+	"next",
+	"no",
+	"ok",
+	"okay",
+	"proceed",
+	"retry",
+	"yes",
+]);
+
+function isObject(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function proseCandidate(text: string): string {
+	return text
+		.replace(/```[\s\S]*?```/gu, " ")
+		.replace(/`[^`\n]*`/gu, " ")
+		.replace(/https?:\/\/\S+/gu, " ")
+		.replace(/(?:^|\s)(?:\.{0,2}\/|\/)\S+/gu, " ")
+		.replace(/\b[\w.-]+\.[A-Za-z0-9]{1,8}\b/gu, " ")
+		.replace(/\b(?:route:\S+|[A-Za-z][A-Za-z0-9]*_[A-Za-z0-9_]+)\b/gu, " ")
+		.replace(/\s+/gu, " ")
+		.trim();
+}
+
+export function canonicalLanguageTag(value: string): LanguageTag | undefined {
+	try {
+		return Intl.getCanonicalLocales(value.trim())[0];
+	} catch {
+		return undefined;
+	}
+}
+
+/** Conservatively observes direct user prose; weak input preserves prior state. */
+export function detectStrongUserLanguage(
+	text: string,
+	source: string,
+): LanguageTag | undefined {
+	if (source !== "interactive" && source !== "rpc") return undefined;
+	const normalized = text.trim();
+	if (!normalized) return undefined;
+	if (KOREAN_SCRIPT.test(normalized)) return "ko";
+
+	const lower = normalized.toLowerCase().replace(/\s+/gu, " ");
+	if (WEAK_ENGLISH_INPUTS.has(lower) || COMMAND_ONLY.test(normalized)) {
+		return undefined;
+	}
+	const words = proseCandidate(normalized).match(ENGLISH_WORD) ?? [];
+	const letterCount = words.reduce((count, word) => count + word.length, 0);
+	return words.length >= 2 && letterCount >= 8 ? "en" : undefined;
+}
+
+export function languageObserved(tag: LanguageTag): LanguageObserved {
+	const canonical = canonicalLanguageTag(tag);
+	if (!canonical) throw new Error(`Invalid language tag: ${tag}`);
+	return {
+		protocol: COMPACTION_LANGUAGE_PROTOCOL,
+		kind: "language-observed",
+		tag: canonical,
+	};
+}
+
+export function continuityPending(
+	compactionId: string,
+	tag: LanguageTag,
+): ContinuityPending {
+	const canonical = canonicalLanguageTag(tag);
+	if (!canonical) throw new Error(`Invalid language tag: ${tag}`);
+	if (!compactionId.trim()) throw new Error("Compaction ID must not be empty.");
+	return {
+		protocol: COMPACTION_LANGUAGE_PROTOCOL,
+		kind: "continuity-pending",
+		compactionId,
+		tag: canonical,
+	};
+}
+
+export function continuityConsumed(compactionId: string): ContinuityConsumed {
+	if (!compactionId.trim()) throw new Error("Compaction ID must not be empty.");
+	return {
+		protocol: COMPACTION_LANGUAGE_PROTOCOL,
+		kind: "continuity-consumed",
+		compactionId,
+	};
+}
+
+export function normalizeCompactionLanguageEvent(
+	value: unknown,
+): CompactionLanguageEvent | undefined {
+	if (!isObject(value) || value.protocol !== COMPACTION_LANGUAGE_PROTOCOL) {
+		return undefined;
+	}
+	if (value.kind === "language-observed" && typeof value.tag === "string") {
+		const tag = canonicalLanguageTag(value.tag);
+		return tag ? languageObserved(tag) : undefined;
+	}
+	if (
+		value.kind === "continuity-pending" &&
+		typeof value.compactionId === "string" &&
+		value.compactionId.trim() &&
+		typeof value.tag === "string"
+	) {
+		const tag = canonicalLanguageTag(value.tag);
+		return tag ? continuityPending(value.compactionId, tag) : undefined;
+	}
+	if (
+		value.kind === "continuity-consumed" &&
+		typeof value.compactionId === "string" &&
+		value.compactionId.trim()
+	) {
+		return continuityConsumed(value.compactionId);
+	}
+	return undefined;
+}
+
+export function initialCompactionLanguageState(): CompactionLanguageState {
+	return { consumedCompactionIds: new Set() };
+}
+
+export function applyCompactionLanguageEvent(
+	state: CompactionLanguageState,
+	event: CompactionLanguageEvent,
+): CompactionLanguageState {
+	switch (event.kind) {
+		case "language-observed":
+			return {
+				...state,
+				language: event.tag,
+				pending: state.pending
+					? { ...state.pending, tag: event.tag }
+					: undefined,
+			};
+		case "continuity-pending":
+			if (
+				state.consumedCompactionIds.has(event.compactionId) ||
+				state.pending?.compactionId === event.compactionId
+			) {
+				return state;
+			}
+			return {
+				...state,
+				pending: {
+					compactionId: event.compactionId,
+					tag: event.tag,
+					injected: false,
+				},
+			};
+		case "continuity-consumed": {
+			if (state.consumedCompactionIds.has(event.compactionId)) return state;
+			const consumedCompactionIds = new Set(state.consumedCompactionIds);
+			consumedCompactionIds.add(event.compactionId);
+			return {
+				...state,
+				pending:
+					state.pending?.compactionId === event.compactionId
+						? undefined
+						: state.pending,
+				consumedCompactionIds,
+			};
+		}
+	}
+}
+
+export function markContinuityInjected(
+	state: CompactionLanguageState,
+): CompactionLanguageState {
+	if (!state.pending || state.pending.injected) return state;
+	return { ...state, pending: { ...state.pending, injected: true } };
+}
+
+export function settlementContinuityEvent(
+	state: CompactionLanguageState,
+): ContinuityConsumed | undefined {
+	return state.pending?.injected
+		? continuityConsumed(state.pending.compactionId)
+		: undefined;
+}
+
+export function reconstructCompactionLanguage(
+	entries: ReadonlyArray<BranchEntryLike>,
+): CompactionLanguageState {
+	return entries.reduce((state, entry) => {
+		if (
+			entry.type !== "custom" ||
+			entry.customType !== COMPACTION_LANGUAGE_ENTRY
+		) {
+			return state;
+		}
+		const event = normalizeCompactionLanguageEvent(entry.data);
+		return event ? applyCompactionLanguageEvent(state, event) : state;
+	}, initialCompactionLanguageState());
+}
+
+export function continuityMarkerText(tag: LanguageTag): string {
+	return `Post-compaction continuity: user-visible prose language=${tag}; explicit language requests win.`;
+}
+
+export function continuityContextMessage(
+	pending: PendingContinuity,
+	timestamp = Date.now(),
+): ContinuityContextMessage {
+	return {
+		role: "custom",
+		customType: COMPACTION_LANGUAGE_MESSAGE,
+		content: [{ type: "text", text: continuityMarkerText(pending.tag) }],
+		display: false,
+		details: {
+			protocol: COMPACTION_LANGUAGE_PROTOCOL,
+			compactionId: pending.compactionId,
+			tag: pending.tag,
+		},
+		timestamp,
+	};
+}
+
+export function projectCompactionContinuity<T>(
+	messages: ReadonlyArray<T>,
+	state: CompactionLanguageState,
+	timestamp = Date.now(),
+):
+	| {
+			messages: Array<T | ContinuityContextMessage>;
+			state: CompactionLanguageState;
+	  }
+	| undefined {
+	if (!state.pending) return undefined;
+	return {
+		messages: [...messages, continuityContextMessage(state.pending, timestamp)],
+		state: markContinuityInjected(state),
+	};
+}

package/extensions/developer.ts

@@ -18,6 +18,19 @@ import {
 import { Container, Markdown, Text } from "@earendil-works/pi-tui";
 import { Type, type Static } from "typebox";
 
+import {
+	COMPACTION_LANGUAGE_ENTRY,
+	applyCompactionLanguageEvent,
+	continuityConsumed,
+	continuityPending,
+	detectStrongUserLanguage,
+	initialCompactionLanguageState,
+	languageObserved,
+	projectCompactionContinuity,
+	reconstructCompactionLanguage,
+	settlementContinuityEvent,
+	type CompactionLanguageState,
+} from "./compaction-language.ts";
 import {
 	availablePackageSkills,
 	isWithinRoot,
@@ -621,6 +634,8 @@ function expandedJudgment(
 export default async function developer(pi: ExtensionAPI) {
 	let availableSkills = new Map<string, Skill>();
 	let state = initialState();
+	let compactionLanguage: CompactionLanguageState =
+		initialCompactionLanguageState();
 	let routeOpening = false;
 	const routesWithMutation = new Set<string>();
 	let toolPolicyMemory: ToolPolicyMemory = { withheldBuiltins: new Set() };
@@ -732,9 +747,11 @@ export default async function developer(pi: ExtensionAPI) {
 	};
 
 	const reconstruct = (ctx: ExtensionContext) => {
+		const branch = ctx.sessionManager.getBranch();
 		state = toolPolicyRestartRequired
 			? initialState()
-			: reconstructState(ctx.sessionManager.getBranch());
+			: reconstructState(branch);
+		compactionLanguage = reconstructCompactionLanguage(branch);
 		syncProtocolTools();
 		refreshUI(ctx);
 	};
@@ -752,6 +769,16 @@ export default async function developer(pi: ExtensionAPI) {
 		};
 		pi.appendEntry(ACTIVATION_ENTRY, event);
 		state = applyDeveloperEvent(state, event);
+		if (!enabled && compactionLanguage.pending) {
+			const consumed = continuityConsumed(
+				compactionLanguage.pending.compactionId,
+			);
+			pi.appendEntry(COMPACTION_LANGUAGE_ENTRY, consumed);
+			compactionLanguage = applyCompactionLanguageEvent(
+				compactionLanguage,
+				consumed,
+			);
+		}
 		syncProtocolTools();
 		refreshUI(ctx);
 		return true;
@@ -2274,6 +2301,41 @@ export default async function developer(pi: ExtensionAPI) {
 		},
 	);
 
+	pi.on("input", (event) => {
+		if (!state.enabled) return;
+		const tag = detectStrongUserLanguage(event.text, event.source);
+		if (!tag || tag === compactionLanguage.language) return;
+		const observed = languageObserved(tag);
+		pi.appendEntry(COMPACTION_LANGUAGE_ENTRY, observed);
+		compactionLanguage = applyCompactionLanguageEvent(
+			compactionLanguage,
+			observed,
+		);
+	});
+
+	pi.on("session_compact", (event) => {
+		if (!state.enabled || !compactionLanguage.language) return;
+		const pending = continuityPending(
+			event.compactionEntry.id,
+			compactionLanguage.language,
+		);
+		const next = applyCompactionLanguageEvent(compactionLanguage, pending);
+		if (next === compactionLanguage) return;
+		pi.appendEntry(COMPACTION_LANGUAGE_ENTRY, pending);
+		compactionLanguage = next;
+	});
+
+	pi.on("context", (event) => {
+		if (!state.enabled) return;
+		const projection = projectCompactionContinuity(
+			event.messages,
+			compactionLanguage,
+		);
+		if (!projection) return;
+		compactionLanguage = projection.state;
+		return { messages: projection.messages as typeof event.messages };
+	});
+
 	pi.on("before_agent_start", (event) => {
 		availableSkills = availablePackageSkills(
 			event.systemPromptOptions.skills ?? [],
@@ -2373,7 +2435,17 @@ export default async function developer(pi: ExtensionAPI) {
 		if (startEnabled === true && !state.enabled) setEnabled(true, ctx);
 	});
 	pi.on("session_tree", (_event, ctx) => reconstruct(ctx));
-	pi.on("agent_settled", (_event, ctx) => refreshUI(ctx));
+	pi.on("agent_settled", (_event, ctx) => {
+		const consumed = settlementContinuityEvent(compactionLanguage);
+		if (consumed) {
+			pi.appendEntry(COMPACTION_LANGUAGE_ENTRY, consumed);
+			compactionLanguage = applyCompactionLanguageEvent(
+				compactionLanguage,
+				consumed,
+			);
+		}
+		refreshUI(ctx);
+	});
 	pi.on("session_shutdown", (_event, ctx) => {
 		releaseProtocolTools();
 		if (!toolPolicyRestartRequired) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hobin/developer",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Branch-aware judgment routing, evidence gates, and focused development skills for Pi.",
   "type": "module",
   "keywords": ["pi-package", "pi", "developer", "skills"],