pi-harness-runtime 0.10.11 → 0.10.12

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

@@ -0,0 +1,159 @@
+/**
+ * Memory Engine Types (RFC-0060)
+ *
+ * Interfaces for OKF-based knowledge management.
+ */
+
+// --- OKF Concept Types ---------------------------------------------------------
+
+export interface OkfLink {
+	href: string;
+	title?: string;
+	type?: string;
+}
+
+export interface OkfConcept {
+	id: string;
+	type: string;
+	title?: string;
+	description?: string;
+	resource?: string;
+	tags: string[];
+	timestamp?: string;
+	metadata: Record<string, unknown>;
+	body: string;
+	links: OkfLink[];
+}
+
+export interface OkfFrontmatter {
+	type: string;
+	title?: string;
+	tags?: string[];
+	timestamp?: string;
+	authority?: "approved" | "generated" | "unverified";
+	[key: string]: unknown;
+}
+
+// --- Bundle Types -------------------------------------------------------------
+
+export interface KnowledgeBundle {
+	path: string;
+	concepts: OkfConcept[];
+	index: string;
+	log: string;
+	directories: KnowledgeDirectory[];
+}
+
+export interface KnowledgeDirectory {
+	path: string;
+	name: string;
+	files: string[];
+	subdirectories: KnowledgeDirectory[];
+}
+
+// --- Validation Types ----------------------------------------------------------
+
+export interface ValidationError {
+	path: string;
+	message: string;
+	line?: number;
+	severity: "error" | "warning";
+}
+
+export interface ValidationResult {
+	valid: boolean;
+	errors: ValidationError[];
+	warnings: ValidationError[];
+}
+
+// --- Search Types -------------------------------------------------------------
+
+export interface KnowledgeQuery {
+	text?: string;
+	tags?: string[];
+	types?: string[];
+	authority?: ("approved" | "generated" | "unverified")[];
+	framework?: string;
+	taskType?: string;
+	limit?: number;
+}
+
+export interface KnowledgeResult {
+	concept: OkfConcept;
+	relevance: number;
+	matchedOn: ("title" | "tags" | "type" | "body" | "authority")[];
+}
+
+// --- Write Types --------------------------------------------------------------
+
+export interface WriteConceptRequest {
+	type: string;
+	title?: string;
+	body: string;
+	tags?: string[];
+	authority?: "approved" | "generated" | "unverified";
+	metadata?: Record<string, unknown>;
+	links?: OkfLink[];
+}
+
+// --- Index Types -------------------------------------------------------------
+
+export interface KnowledgeIndex {
+	concepts: Array<{
+		id: string;
+		type: string;
+		title: string;
+		tags: string[];
+		path: string;
+	}>;
+	lastUpdated: string;
+}
+
+// --- Reserved Files -----------------------------------------------------------
+
+export const RESERVED_FILES = ["index.md", "log.md"];
+
+export function isReservedFile(filename: string): boolean {
+	return RESERVED_FILES.includes(filename);
+}
+
+// --- Secret Detection ---------------------------------------------------------
+
+export const SECRET_PATTERNS = [
+	/api[_-]?key/i,
+	/password/i,
+	/secret/i,
+	/token/i,
+	/bearer/i,
+	/auth/i,
+	/credential/i,
+	/private[_-]?key/i,
+	/access[_-]?token/i,
+	/refresh[_-]?token/i,
+];
+
+export function containsSecret(value: string): boolean {
+	return SECRET_PATTERNS.some((pattern) => pattern.test(value));
+}
+
+export function filterSecrets(content: string): string {
+	return content.replace(
+		/([A-Za-z_][A-Za-z0-9_]*)\s*=\s*([^\n]+)/g,
+		(match, key: string) => {
+			if (containsSecret(key)) {
+				return `${key}=[REDACTED]`;
+			}
+			return match;
+		},
+	);
+}
+
+// --- Authority Types ---------------------------------------------------------
+
+export type Authority = "approved" | "generated" | "unverified";
+
+export const AUTHORITY_PRIORITY: Record<Authority, number> = {
+	approved: 3,
+	generated: 2,
+	unverified: 1,
+};

package/packages/model-registry/src/cost.ts

@@ -0,0 +1,80 @@
+/**
+ * Cost Calculation Functions (RFC-0053)
+ */
+
+import type { ModelInfo, Pricing } from "./types.js";
+
+/**
+ * Calculate cost for a model based on token usage
+ */
+export function calculateCost(
+	model: ModelInfo,
+	inputTokens: number,
+	outputTokens: number,
+	options?: {
+		useBatch?: boolean;
+		cacheReadTokens?: number;
+		cacheWriteTokens?: number;
+	},
+): number {
+	const { pricing } = model;
+
+	// Base cost: input + output
+	const baseInputCost = (inputTokens / 1_000_000) * pricing.inputPer1M;
+	const baseOutputCost = (outputTokens / 1_000_000) * pricing.outputPer1M;
+	let total = baseInputCost + baseOutputCost;
+
+	// Batch discount
+	if (options?.useBatch && pricing.batchInputPer1M !== undefined) {
+		const batchSavings =
+			(inputTokens / 1_000_000) *
+			(pricing.inputPer1M - pricing.batchInputPer1M);
+		total -= batchSavings;
+	}
+
+	// Cache read discount (negative cost = savings)
+	if (options?.cacheReadTokens && pricing.cacheReadPer1M !== undefined) {
+		total += (options.cacheReadTokens / 1_000_000) * pricing.cacheReadPer1M;
+	}
+
+	// Cache write cost
+	if (options?.cacheWriteTokens && pricing.cacheWritePer1M !== undefined) {
+		total += (options.cacheWriteTokens / 1_000_000) * pricing.cacheWritePer1M;
+	}
+
+	return Math.round(total * 100) / 100; // round to cents
+}
+
+/**
+ * Get the total cost per 1M tokens (input + output)
+ */
+export function getCostPer1M(pricing: Pricing): number {
+	return pricing.inputPer1M + pricing.outputPer1M;
+}
+
+/**
+ * Compare two models by cost
+ */
+export function compareCost(modelA: ModelInfo, modelB: ModelInfo): number {
+	return getCostPer1M(modelA.pricing) - getCostPer1M(modelB.pricing);
+}
+
+/**
+ * Calculate savings between two models
+ */
+export function calculateSavings(
+	currentModel: ModelInfo,
+	newModel: ModelInfo,
+	inputTokens: number,
+	outputTokens: number,
+): { absolute: number; percentage: number } {
+	const currentCost = calculateCost(currentModel, inputTokens, outputTokens);
+	const newCost = calculateCost(newModel, inputTokens, outputTokens);
+	const absolute = currentCost - newCost;
+	const percentage = currentCost > 0 ? (absolute / currentCost) * 100 : 0;
+
+	return {
+		absolute: Math.round(absolute * 100) / 100,
+		percentage: Math.round(percentage * 10) / 10,
+	};
+}

package/packages/model-registry/src/defaults.ts

@@ -0,0 +1,178 @@
+/**
+ * Default Model Definitions (RFC-0053)
+ */
+
+import type { ModelInfo } from "./types.js";
+
+export const DEFAULT_MODELS: ModelInfo[] = [
+	// OpenAI Models
+	{
+		id: "gpt-4o",
+		providerId: "openai",
+		name: "GPT-4o",
+		contextWindow: 128000,
+		maxOutputTokens: 16384,
+		pricing: {
+			currency: "USD",
+			inputPer1M: 5,
+			outputPer1M: 15,
+		},
+		capabilities: [
+			"code_generation",
+			"code_review",
+			"vision",
+			"function_calling",
+			"json_mode",
+		],
+		aliases: ["gpt4o", "gpt-4o", "openai-gpt-4o"],
+		status: "active",
+	},
+	{
+		id: "gpt-4o-mini",
+		providerId: "openai",
+		name: "GPT-4o Mini",
+		contextWindow: 128000,
+		maxOutputTokens: 16384,
+		pricing: {
+			currency: "USD",
+			inputPer1M: 0.15,
+			outputPer1M: 0.6,
+		},
+		capabilities: [
+			"code_generation",
+			"code_review",
+			"function_calling",
+			"json_mode",
+		],
+		aliases: ["gpt4o-mini", "gpt-4o-mini", "openai-gpt-4o-mini"],
+		status: "active",
+	},
+	{
+		id: "gpt-4-turbo",
+		providerId: "openai",
+		name: "GPT-4 Turbo",
+		contextWindow: 128000,
+		maxOutputTokens: 4096,
+		pricing: {
+			currency: "USD",
+			inputPer1M: 10,
+			outputPer1M: 30,
+		},
+		capabilities: [
+			"code_generation",
+			"code_review",
+			"vision",
+			"function_calling",
+		],
+		aliases: ["gpt4-turbo", "gpt-4-turbo"],
+		status: "deprecated",
+	},
+
+	// Anthropic Models
+	{
+		id: "claude-sonnet-4",
+		providerId: "anthropic",
+		name: "Claude Sonnet 4",
+		contextWindow: 200000,
+		maxOutputTokens: 8192,
+		pricing: {
+			currency: "USD",
+			inputPer1M: 3,
+			outputPer1M: 15,
+		},
+		capabilities: [
+			"code_generation",
+			"code_review",
+			"planning",
+			"vision",
+			"analysis",
+		],
+		aliases: [
+			"sonnet",
+			"claude-sonnet",
+			"anthropic-sonnet",
+			"claude-3-5-sonnet",
+		],
+		status: "active",
+	},
+	{
+		id: "claude-opus-4",
+		providerId: "anthropic",
+		name: "Claude Opus 4",
+		contextWindow: 200000,
+		maxOutputTokens: 8192,
+		pricing: {
+			currency: "USD",
+			inputPer1M: 15,
+			outputPer1M: 75,
+		},
+		capabilities: ["code_generation", "planning", "analysis", "code_review"],
+		aliases: ["opus", "claude-opus", "anthropic-opus", "claude-3-opus"],
+		status: "active",
+	},
+
+	// MiniMax Models
+	{
+		id: "MiniMax-Text-01",
+		providerId: "minimax",
+		name: "MiniMax Text 01",
+		contextWindow: 1000000,
+		maxOutputTokens: 8192,
+		pricing: {
+			currency: "USD",
+			inputPer1M: 0.1,
+			outputPer1M: 0.5,
+			batchInputPer1M: 0.01,
+		},
+		capabilities: ["code_generation", "function_calling", "json_mode"],
+		aliases: ["minimax", "minimax-text", "minimax-text-01"],
+		status: "active",
+	},
+	{
+		id: "abab6.5s-chat",
+		providerId: "minimax",
+		name: "ABAB 6.5S Chat",
+		contextWindow: 245760,
+		maxOutputTokens: 4096,
+		pricing: {
+			currency: "USD",
+			inputPer1M: 0.05,
+			outputPer1M: 0.2,
+		},
+		capabilities: ["code_generation", "function_calling"],
+		aliases: ["abab", "abab6.5s"],
+		status: "active",
+	},
+
+	// Google Models
+	{
+		id: "gemini-1.5-pro",
+		providerId: "google",
+		name: "Gemini 1.5 Pro",
+		contextWindow: 2000000,
+		maxOutputTokens: 8192,
+		pricing: {
+			currency: "USD",
+			inputPer1M: 1.25,
+			outputPer1M: 5,
+		},
+		capabilities: ["code_generation", "vision", "analysis"],
+		aliases: ["gemini-pro", "gemini-1.5-pro-latest"],
+		status: "active",
+	},
+	{
+		id: "gemini-1.5-flash",
+		providerId: "google",
+		name: "Gemini 1.5 Flash",
+		contextWindow: 1000000,
+		maxOutputTokens: 8192,
+		pricing: {
+			currency: "USD",
+			inputPer1M: 0.035,
+			outputPer1M: 0.14,
+		},
+		capabilities: ["code_generation", "vision"],
+		aliases: ["gemini-flash", "gemini-1.5-flash-latest"],
+		status: "active",
+	},
+];

package/packages/model-registry/src/index.ts

@@ -0,0 +1,57 @@
+/**
+ * Model Registry Package (RFC-0053)
+ *
+ * A centralized registry for model metadata with pricing.
+ *
+ * @example
+ * ```typescript
+ * import { createModelRegistry } from "@pi-harness/model-registry";
+ *
+ * const registry = createModelRegistry();
+ *
+ * // Get a model
+ * const model = registry.get("anthropic", "claude-sonnet-4");
+ *
+ * // Find by alias
+ * const byAlias = registry.getByAlias("sonnet");
+ *
+ * // Find active models with capabilities
+ * const models = registry.find({
+ *   capabilities: ["code_generation"],
+ *   status: "active",
+ * });
+ * ```
+ */
+
+// Types
+export type {
+	Currency,
+	Pricing,
+	ModelStatus,
+	ModelInfo,
+	ModelFilters,
+	ModelRegistry,
+	ModelRegistryEvent,
+} from "./types.js";
+
+// Registry
+export { InMemoryModelRegistry, createModelRegistry } from "./registry.js";
+
+// Defaults
+export { DEFAULT_MODELS } from "./defaults.js";
+
+// Query utilities
+export {
+	findModels,
+	getCheapestModel,
+	getLargestContextModel,
+	filterByCostEfficiency,
+} from "./query.js";
+
+// Cost utilities
+export {
+	calculateCost,
+	getCostPer1M,
+	compareCost,
+	calculateSavings,
+} from "./cost.js";

package/packages/model-registry/src/query.ts

@@ -0,0 +1,85 @@
+/**
+ * Model Query Functions (RFC-0053)
+ */
+
+import type { ModelFilters, ModelInfo } from "./types.js";
+import { getCostPer1M } from "./cost.js";
+
+/**
+ * Find models matching filters
+ */
+export function findModels(
+	models: ModelInfo[],
+	filters: ModelFilters,
+): ModelInfo[] {
+	let result = [...models];
+
+	// Filter by provider
+	if (filters.providerId) {
+		result = result.filter((m) => m.providerId === filters.providerId);
+	}
+
+	// Filter by context window
+	if (filters.minContextWindow !== undefined) {
+		result = result.filter((m) => m.contextWindow >= filters.minContextWindow!);
+	}
+
+	// Filter by cost
+	if (filters.maxCostPer1M !== undefined) {
+		result = result.filter(
+			(m) => getCostPer1M(m.pricing) <= filters.maxCostPer1M!,
+		);
+	}
+
+	// Filter by capabilities
+	if (filters.capabilities?.length) {
+		result = result.filter((m) =>
+			filters.capabilities!.every((c) => m.capabilities.includes(c)),
+		);
+	}
+
+	// Filter by status
+	if (filters.status) {
+		result = result.filter((m) => m.status === filters.status);
+	}
+
+	// Sort by cost (ascending)
+	result.sort((a, b) => getCostPer1M(a.pricing) - getCostPer1M(b.pricing));
+
+	return result;
+}
+
+/**
+ * Get the cheapest model
+ */
+export function getCheapestModel(models: ModelInfo[]): ModelInfo | undefined {
+	if (models.length === 0) return undefined;
+	return models.reduce((cheapest, current) =>
+		getCostPer1M(current.pricing) < getCostPer1M(cheapest.pricing)
+			? current
+			: cheapest,
+	);
+}
+
+/**
+ * Get the model with largest context window
+ */
+export function getLargestContextModel(
+	models: ModelInfo[],
+): ModelInfo | undefined {
+	if (models.length === 0) return undefined;
+	return models.reduce((largest, current) =>
+		current.contextWindow > largest.contextWindow ? current : largest,
+	);
+}
+
+/**
+ * Filter by cost efficiency (cost per context window)
+ */
+export function filterByCostEfficiency(models: ModelInfo[]): ModelInfo[] {
+	return [...models].sort((a, b) => {
+		const efficiencyA = getCostPer1M(a.pricing) / a.contextWindow;
+		const efficiencyB = getCostPer1M(b.pricing) / b.contextWindow;
+		return efficiencyA - efficiencyB;
+	});
+}