pi-harness-runtime 0.10.11 → 0.10.12

package/packages/projection-engine/src/engine.ts

@@ -0,0 +1,134 @@
+/**
+ * Projection Engine — Core
+ */
+
+interface SessionEvent {
+	id: string;
+	sessionId: string;
+	timestamp: string;
+	type: string;
+	role?: string;
+	content?: string;
+	metadata?: Record<string, unknown>;
+}
+
+interface Decision {
+	id: string;
+	sessionId: string;
+	timestamp: string;
+	text: string;
+	confidence: number;
+	sources: string[];
+}
+
+interface TaskState {
+	id: string;
+	sessionId: string;
+	status: string;
+	createdAt: string;
+	completedAt?: string;
+}
+
+interface AgentTimeline {
+	agentId: string;
+	events: Array<{ timestamp: string; type: string; message: string }>;
+}
+
+interface SessionSummary {
+	sessionId: string;
+	durationMs: number;
+	messageCount: number;
+	toolCount: number;
+	decisionCount: number;
+	taskCount: number;
+	topics: string[];
+}
+
+export class ProjectionEngine {
+	private decisions: Decision[] = [];
+	private taskStates: Map<string, TaskState> = new Map();
+	private agentTimelines: Map<string, AgentTimeline> = new Map();
+	private messages = 0;
+	private tools = 0;
+	private topics = new Set<string>();
+	private sessionId = "";
+
+	addEvent(event: SessionEvent): void {
+		this.sessionId = event.sessionId;
+
+		if (event.type === "message") {
+			this.messages++;
+			if (event.role === "assistant") {
+				const text = event.content ?? "";
+				if (/RFC|ADR|architecture decision|design choice/i.test(text)) {
+					this.decisions.push({
+						id: event.id,
+						sessionId: this.sessionId,
+						timestamp: event.timestamp,
+						text,
+						confidence: 0.8,
+						sources: [],
+					});
+				}
+				const topicKeywords = [
+					"deploy",
+					"test",
+					"fix",
+					"refactor",
+					"migrate",
+					"security",
+				];
+				for (const kw of topicKeywords) {
+					if (text.toLowerCase().includes(kw)) this.topics.add(kw);
+				}
+			}
+		}
+
+		if (event.type === "tool_start") this.tools++;
+
+		if (event.type === "assistant_end") {
+			const id = (event.metadata?.model as string) ?? "unknown";
+			if (!this.agentTimelines.has(id)) {
+				this.agentTimelines.set(id, { agentId: id, events: [] });
+			}
+			this.agentTimelines.get(id)!.events.push({
+				timestamp: event.timestamp,
+				type: "assistant_end",
+				message: event.content ?? "",
+			});
+		}
+	}
+
+	getDecisions(): Decision[] {
+		return this.decisions;
+	}
+	getTaskStates(): TaskState[] {
+		return [...this.taskStates.values()];
+	}
+	getSummary(): SessionSummary {
+		return {
+			sessionId: this.sessionId,
+			durationMs: 0,
+			messageCount: this.messages,
+			toolCount: this.tools,
+			decisionCount: this.decisions.length,
+			taskCount: this.taskStates.size,
+			topics: [...this.topics],
+		};
+	}
+	getTimeline(agentId?: string): AgentTimeline[] {
+		if (agentId)
+			return [this.agentTimelines.get(agentId)].filter(
+				Boolean,
+			) as AgentTimeline[];
+		return [...this.agentTimelines.values()];
+	}
+	reset(): void {
+		this.decisions = [];
+		this.taskStates.clear();
+		this.agentTimelines.clear();
+		this.messages = 0;
+		this.tools = 0;
+		this.topics.clear();
+	}
+}

package/packages/projection-engine/src/index.ts

@@ -0,0 +1,8 @@
+export type {
+	Projection,
+	Decision,
+	TaskState,
+	KnowledgeExtraction,
+	AgentTimeline,
+	SessionSummary,
+} from "./types.js";

package/packages/projection-engine/src/project.ts

@@ -0,0 +1,24 @@
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const PROJ_DIR = join(process.env["HOME"] ?? "/tmp", ".pi", "projections");
+
+function ensureDir() {
+  if (!existsSync(PROJ_DIR)) mkdirSync(PROJ_DIR, { recursive: true });
+}
+
+export function saveProjection(name: string, data: unknown): void {
+  ensureDir();
+  const proj = JSON.stringify({ name, version: 1, createdAt: new Date().toISOString(), data });
+  appendFileSync(join(PROJ_DIR, `${name}.jsonl`), proj + "\n");
+}
+
+export function loadProjections(name: string): string[] {
+  const path = join(PROJ_DIR, `${name}.jsonl`);
+  if (!existsSync(path)) return [];
+  try {
+    return readFileSync(path, "utf8").split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}

package/packages/projection-engine/src/types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Projection Engine — Types
+ */
+export interface Projection<T> {
+    project(events: unknown[]): T;
+    reset(): void;
+    get(): T;
+}
+export interface Decision {
+    id: string;
+    sessionId: string;
+    timestamp: string;
+    text: string;
+    confidence: number;
+    sources: string[];
+}
+export interface TaskState {
+    id: string;
+    sessionId: string;
+    status: "pending" | "running" | "completed" | "failed";
+    createdAt: string;
+    completedAt?: string;
+    result?: {
+        delivered?: boolean;
+        files?: string[];
+        summary?: string;
+    };
+}
+export interface KnowledgeExtraction {
+    id: string;
+    sessionId: string;
+    timestamp: string;
+    concept: string;
+    content: string;
+    confidence: number;
+    approved: boolean;
+}
+export interface AgentTimeline {
+    agentId: string;
+    events: Array<{
+        timestamp: string;
+        type: string;
+        message: string;
+    }>;
+}
+export interface SessionSummary {
+    sessionId: string;
+    durationMs: number;
+    messageCount: number;
+    toolCount: number;
+    decisionCount: number;
+    taskCount: number;
+    topics: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/packages/projection-engine/src/types.js

@@ -0,0 +1,5 @@
+/**
+ * Projection Engine — Types
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/packages/projection-engine/src/types.ts

@@ -0,0 +1,60 @@
+/**
+ * Projection Engine — Types
+ */
+
+export interface Projection<T> {
+	project(events: unknown[]): T;
+	reset(): void;
+	get(): T;
+}
+
+export interface Decision {
+	id: string;
+	sessionId: string;
+	timestamp: string;
+	text: string;
+	confidence: number;
+	sources: string[];
+}
+
+export interface TaskState {
+	id: string;
+	sessionId: string;
+	status: "pending" | "running" | "completed" | "failed";
+	createdAt: string;
+	completedAt?: string;
+	result?: {
+		delivered?: boolean;
+		files?: string[];
+		summary?: string;
+	};
+}
+
+export interface KnowledgeExtraction {
+	id: string;
+	sessionId: string;
+	timestamp: string;
+	concept: string;
+	content: string;
+	confidence: number;
+	approved: boolean;
+}
+
+export interface AgentTimeline {
+	agentId: string;
+	events: Array<{
+		timestamp: string;
+		type: string;
+		message: string;
+	}>;
+}
+
+export interface SessionSummary {
+	sessionId: string;
+	durationMs: number;
+	messageCount: number;
+	toolCount: number;
+	decisionCount: number;
+	taskCount: number;
+	topics: string[];
+}

package/packages/prompt-compiler/src/budget.ts

@@ -0,0 +1,170 @@
+/**
+ * Prompt Compiler - Budget / Compaction
+ *
+ * Compacts optional sections to fit within the token budget.
+ * Required sections are never removed.
+ * Compaction order (least to most important to keep):
+ * 1. Historical logs
+ * 2. Previous successful examples
+ * 3. Low-priority repository notes
+ * 4. Non-blocking discussion
+ * 5. Redundant file summaries
+ *
+ * Priority 0 entries (critical) are never compacted.
+ */
+
+import type { PromptSection } from "./types.js";
+
+/**
+ * Compaction result.
+ */
+export interface CompactionResult {
+	sections: PromptSection[];
+	removed: string[];
+	estimatedTokens: number;
+}
+
+/**
+ * Compact sections to fit within the token budget.
+ *
+ * Only compactable sections are affected.
+ * Required sections are preserved verbatim.
+ *
+ * @param sections - Input sections
+ * @param availableTokens - Maximum tokens available
+ * @param estimateTokens - Token estimation function
+ * @returns Compacted sections and removed section IDs
+ */
+export function compactToBudget(
+	sections: PromptSection[],
+	availableTokens: number,
+	estimateTokens: (content: string) => number,
+): CompactionResult {
+	const removed: string[] = [];
+
+	// Calculate tokens used by required sections
+	let requiredTokens = 0;
+	for (const section of sections) {
+		if (!section.compactable) {
+			requiredTokens += estimateTokens(section.content);
+		}
+	}
+
+	const budgetForOptional = availableTokens - requiredTokens;
+
+	// Get compactable sections, sorted by priority (most compactable first)
+	// within each section, compact from the bottom up
+	const compactableSections = sections
+		.map((s, i) => ({ section: s, index: i }))
+		.filter(({ section }) => section.compactable)
+		.reverse(); // process from end of document
+
+	let currentOptionalTokens = 0;
+	const optionalSectionTokens: Map<number, number> = new Map();
+
+	for (const { section, index } of compactableSections) {
+		const tokens = estimateTokens(section.content);
+		optionalSectionTokens.set(index, tokens);
+		currentOptionalTokens += tokens;
+	}
+
+	// If within budget, return as-is
+	if (currentOptionalTokens <= budgetForOptional) {
+		return {
+			sections,
+			removed: [],
+			estimatedTokens: requiredTokens + currentOptionalTokens,
+		};
+	}
+
+	// Otherwise, compact compactable sections by removing low-priority content
+	// from the end of each section
+	const workingSections = sections.map((s) => ({ ...s }));
+	let overBudgetBy = currentOptionalTokens - budgetForOptional;
+
+	// Sort compactable sections by priority label (higher priority label = more important)
+	// Within each section, trim lines from the end that are marked as lower priority
+	for (const { section, index } of compactableSections) {
+		if (overBudgetBy <= 0) break;
+
+		const lines = workingSections[index]?.content.split("\n");
+		const sectionTokens = optionalSectionTokens.get(index) ?? 0;
+
+		// Estimate tokens per line (rough approximation)
+		const avgTokensPerLine =
+			lines.length > 0 ? Math.ceil(sectionTokens / lines.length) : 1;
+
+		// Remove lines from the end (least important), working backwards
+		const priorityKeywords = [
+			"SUPPLEMENTAL",
+			"NON-BLOCKING",
+			"HISTORICAL",
+			"DISCUSSION",
+			"NOTE",
+			"EXAMPLE",
+			"CONTEXT",
+			"REFERENCE",
+		];
+
+		let linesRemoved = 0;
+		const trimmedLines: string[] = [];
+
+		for (let i = 0; i < lines.length; i++) {
+			trimmedLines.push(lines[i] ?? "");
+		}
+
+		// Remove from end
+		while (trimmedLines.length > 0 && overBudgetBy > 0) {
+			const lastLine = trimmedLines[trimmedLines.length - 1];
+			if (!lastLine || lastLine.trim() === "" || lastLine.startsWith("#")) {
+				// Never remove headers or blank lines at the start
+				break;
+			}
+
+			const isLowPriority = priorityKeywords.some((kw) =>
+				lastLine.toUpperCase().includes(kw),
+			);
+
+			if (isLowPriority) {
+				trimmedLines.pop();
+				overBudgetBy -= avgTokensPerLine;
+				linesRemoved++;
+			} else {
+				break;
+			}
+		}
+
+		if (trimmedLines.length < lines.length) {
+			const removedText = lines.slice(trimmedLines.length).join("\n");
+			if (removedText.trim()) {
+				removed.push(`${section.id}: ${removedText.slice(0, 100)}...`);
+			}
+			workingSections[index] = {
+				...(workingSections[index] ?? section),
+				content: trimmedLines.join("\n"),
+			};
+		}
+	}
+
+	const finalTokens =
+		requiredTokens +
+		[...workingSections]
+			.filter((s) => s.compactable)
+			.reduce((sum, s) => sum + estimateTokens(s.content), 0);
+
+	return {
+		sections: workingSections,
+		removed,
+		estimatedTokens: finalTokens,
+	};
+}
+
+/**
+ * Simple word-based token estimator.
+ * ~4 characters per token on average.
+ */
+export function estimateTokens(text: string): number {
+	if (!text || text.trim() === "") return 0;
+	// Rough estimate: 1 token ≈ 4 characters
+	return Math.ceil(text.length / 4);
+}

package/packages/prompt-compiler/src/compiler.ts

@@ -0,0 +1,188 @@
+/**
+ * Prompt Compiler - Compiler
+ *
+ * Main entry point for prompt compilation.
+ * Orchestrates: normalize → build → redact → deduplicate → compact → validate → render → hash → persist.
+ */
+
+import type { PromptCompileRequest } from "./types.js";
+import type { PromptPackage } from "./types.js";
+import { PROVIDER_PROFILES, PromptCompileError } from "./types.js";
+
+import { compactToBudget, estimateTokens } from "./budget.js";
+import { deduplicateSections } from "./deduplicate.js";
+import { normalizeRequest } from "./normalize.js";
+import { renderForProvider } from "./render.js";
+import { buildSections } from "./section-builder.js";
+import { validateSections, validateTokenBudget } from "./validate.js";
+
+/**
+ * Dependencies required by the compiler.
+ * All I/O (filesystem, clock, hashing) is injected here.
+ */
+export interface PromptCompilerDependencies {
+	/** SHA-256 hash function */
+	hasher: {
+		sha256: (content: string) => string;
+	};
+	/** System clock */
+	clock: {
+		now: () => Date;
+	};
+	/** Redaction interface for security-sensitive content */
+	redactor: {
+		redact: (content: string) => string;
+	};
+	/** Persist the compiled prompt package */
+	persister?: {
+		persist: (pkg: PromptPackage) => Promise<void>;
+	};
+	/** Project rules (injected from project profile or policy engine) */
+	projectRules: string[];
+}
+
+/**
+ * Default in-memory redactor (identity function).
+ * Production should inject a real redaction implementation.
+ */
+export function createIdentityRedactor() {
+	return {
+		redact: (content: string) => content,
+	};
+}
+
+/**
+ * Default identity hasher (SHA-256 via Web Crypto or Node crypto).
+ */
+export function createHasher() {
+	return {
+		async sha256(content: string): Promise<string> {
+			// Use Web Crypto API (available in Node 18+ and browsers)
+			const encoder = new TextEncoder();
+			const data = encoder.encode(content);
+			const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+			const hashArray = Array.from(new Uint8Array(hashBuffer));
+			return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+		},
+	};
+}
+
+/**
+ * Synchronous SHA-256 for testing (simple string-based).
+ */
+export function createSyncHasher() {
+	let sha256Impl: ((content: string) => string) | null = null;
+	return {
+		sha256(content: string): string {
+			if (!sha256Impl) {
+				// Lazy import for Node environment
+				try {
+					// eslint-disable-next-line @typescript-eslint/no-var-requires
+					const crypto = require("node:crypto");
+					sha256Impl = (text: string) =>
+						crypto.createHash("sha256").update(text).digest("hex");
+				} catch {
+					// Fallback: simple hash for testing
+					sha256Impl = (text: string) => {
+						let hash = 0;
+						for (let i = 0; i < text.length; i++) {
+							const char = text.charCodeAt(i);
+							hash = (hash << 5) - hash + char;
+							hash |= 0;
+						}
+						return Math.abs(hash).toString(16).padStart(8, "0");
+					};
+				}
+			}
+			return sha256Impl?.(content);
+		},
+	};
+}
+
+/**
+ * Compile a prompt from a normalized request.
+ *
+ * Reference algorithm from RFC-0041:
+ * 1. normalize input
+ * 2. select provider profile
+ * 3. assemble ordered sections
+ * 4. remove duplicate context
+ * 5. enforce policy constraints
+ * 6. estimate token size
+ * 7. compact optional sections
+ * 8. validate output contract
+ * 9. calculate content hash
+ * 10. persist PromptPackage
+ */
+export async function compilePrompt(
+	request: PromptCompileRequest,
+	deps: PromptCompilerDependencies,
+): Promise<PromptPackage> {
+	// 1. Normalize input
+	const normalized = normalizeRequest(request);
+
+	// 2. Select provider profile
+	const profile = PROVIDER_PROFILES[request.provider];
+	if (!profile) {
+		throw new PromptCompileError(
+			"INVALID_TASK",
+			`Unknown provider: ${request.provider}`,
+		);
+	}
+
+	// 3. Assemble sections
+	let sections = buildSections(normalized, deps.projectRules);
+
+	// 4. Redact secrets (before persistence)
+	sections = sections.map((section) => ({
+		...section,
+		content: deps.redactor.redact(section.content),
+	}));
+
+	// 5. Deduplicate
+	sections = deduplicateSections(sections);
+
+	// 6 & 7. Estimate tokens and compact to budget
+	const availableTokens =
+		profile.maximumInputTokens - profile.reservedOutputTokens;
+
+	const estimateSectionTokens = (content: string) => estimateTokens(content);
+
+	const budgeted = compactToBudget(
+		sections,
+		availableTokens,
+		estimateSectionTokens,
+	);
+	sections = budgeted.sections;
+
+	// 8. Validate
+	validateSections(sections, normalized, { provider: profile });
+	validateTokenBudget(budgeted.estimatedTokens, profile);
+
+	// 9. Render for provider
+	const rendered = renderForProvider(sections, profile);
+
+	// 10. Calculate content hash
+	const hashContent = `${rendered.system}\n${rendered.user}`;
+	const hash = deps.hasher.sha256(hashContent);
+
+	const pkg: PromptPackage = {
+		version: "1",
+		taskId: normalized.taskId,
+		provider: request.provider,
+		system: rendered.system,
+		user: rendered.user,
+		sections,
+		estimatedInputTokens: budgeted.estimatedTokens,
+		sourceRefs: sections.flatMap((s) => s.sourceRefs),
+		hash,
+		createdAt: deps.clock.now().toISOString(),
+	};
+
+	// 11. Persist (optional)
+	if (deps.persister) {
+		await deps.persister.persist(pkg);
+	}
+
+	return pkg;
+}