pi-harness-runtime 0.10.11 → 0.10.12

package/packages/cost-optimizer/src/types.ts

@@ -0,0 +1,134 @@
+/**
+ * Cost Optimizer Types (RFC-0055)
+ */
+
+// Re-export Currency type
+export type Currency = "USD" | "THB";
+
+// --- Cost Entry Types -------------------------------------------------
+
+export interface CostEntry {
+	id: string;
+	jobId: string;
+	taskId?: string;
+	providerId: string;
+	modelId: string;
+	inputTokens: number;
+	outputTokens: number;
+	cost: number;
+	currency: Currency;
+	timestamp: string;
+}
+
+// --- Budget Types -----------------------------------------------------
+
+export interface CostBudget {
+	daily?: number;
+	weekly?: number;
+	monthly?: number;
+	perJob?: number;
+	perTask?: number;
+}
+
+export interface BudgetStatus {
+	daily: { used: number; budget: number; remaining: number };
+	weekly: { used: number; budget: number; remaining: number };
+	monthly: { used: number; budget: number; remaining: number };
+	exhausted: boolean;
+	nextReset?: string;
+}
+
+export interface CostSummary {
+	total: number;
+	currency: Currency;
+	byProvider: Record<string, number>;
+	byModel: Record<string, number>;
+	byJob: Record<string, number>;
+	period: CostPeriod;
+}
+
+export interface CostPeriod {
+	start: string;
+	end: string;
+	type: "day" | "week" | "month" | "custom";
+}
+
+// --- Optimization Types ------------------------------------------------
+
+export interface CostOptimizerConfig {
+	defaultBudget: CostBudget;
+	currency: Currency;
+	alertThreshold: number;
+	autoSwitchToCheaper: boolean;
+	maxQualityLossPercent: number;
+}
+
+export interface SwitchOptions {
+	maxQualityLoss?: number;
+	maxLatencyIncrease?: "fast" | "medium" | "slow";
+}
+
+export interface ModelSwitchRecommendation {
+	currentModel: { id: string; providerId: string };
+	recommendedModel: { id: string; providerId: string };
+	costSavings: number;
+	qualityImpact: number;
+	reason: string;
+}
+
+export interface CostForecast {
+	estimatedTotal: number;
+	byTaskType: Record<string, number>;
+	confidence: number;
+	assumptions: string[];
+}
+
+export interface TaskRequirements {
+	requiredCapabilities: string[];
+	minContextWindow: number;
+	maxLatency?: "fast" | "medium" | "slow";
+	estimatedInputTokens: number;
+	estimatedOutputTokens: number;
+}
+
+export interface OptimizedSelection {
+	model: { id: string; providerId: string; name: string };
+	estimatedCost: number;
+	qualityScore: number;
+	reason: string;
+	tradeoffs: string[];
+}
+
+// --- Optimizer Interface ---------------------------------------------
+
+export interface CostOptimizer {
+	trackCost(entry: Omit<CostEntry, "id" | "timestamp">): CostEntry;
+	getSummary(period: CostPeriod): CostSummary;
+	getBudgetStatus(): BudgetStatus;
+	canAfford(cost: number): boolean;
+	shouldSwitchToCheaper(
+		currentModel: { id: string; providerId: string },
+		requiredCapabilities: string[],
+		options?: SwitchOptions,
+	): ModelSwitchRecommendation | null;
+	forecastCosts(jobRequirements: TaskRequirements[]): CostForecast;
+	optimizeModelSelection(
+		taskId: string,
+		requirements: TaskRequirements,
+	): OptimizedSelection[];
+}
+
+// --- Event Types -----------------------------------------------------
+
+export type CostOptimizerEvent =
+	| { type: "cost.tracked"; entryId: string; cost: number; total: number }
+	| { type: "cost.budget_warning"; threshold: number; percentage: number }
+	| { type: "cost.budget_exhausted"; period: string }
+	| {
+			type: "cost.switch_recommended";
+			from: string;
+			to: string;
+			savings: number;
+	  }
+	| { type: "cost.forecast"; estimated: number; confidence: number }
+	| { type: "cost.optimization_applied"; model: string; savings: number };

package/packages/dependency-analyzer/dist/src/analyzer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Dependency Analyzer — Main Analyzer
+ */
+import type { DependencyGraph } from "./types.js";
+export declare class DependencyAnalyzer {
+    private rootPath;
+    private maxDepth;
+    private excludePatterns;
+    constructor(rootPath: string);
+    analyze(entryFile: string): Promise<DependencyGraph>;
+    getStats(graph: DependencyGraph): {
+        totalFiles: number;
+        totalImports: number;
+        cycles: number;
+    };
+}
+//# sourceMappingURL=analyzer.d.ts.map

package/packages/dependency-analyzer/dist/src/analyzer.js

@@ -0,0 +1,119 @@
+/**
+ * Dependency Analyzer — Main Analyzer
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { parseImports } from "./imports.js";
+function detectCycle(graph) {
+    const cycles = [];
+    const visited = new Set();
+    const stack = [];
+    function dfs(nodeId) {
+        if (stack.includes(nodeId)) {
+            const cycleStart = stack.indexOf(nodeId);
+            const cycle = stack.slice(cycleStart);
+            if (cycle.length > 1)
+                cycles.push([...cycle, nodeId]);
+            return;
+        }
+        if (visited.has(nodeId))
+            return;
+        visited.add(nodeId);
+        stack.push(nodeId);
+        const node = graph.nodes.get(nodeId);
+        if (node) {
+            for (const imp of node.imports) {
+                const target = graph.nodes.get(imp);
+                if (target)
+                    dfs(imp);
+            }
+        }
+        stack.pop();
+    }
+    for (const id of graph.nodes.keys()) {
+        if (!visited.has(id))
+            dfs(id);
+    }
+    return cycles;
+}
+export class DependencyAnalyzer {
+    rootPath;
+    maxDepth;
+    excludePatterns;
+    constructor(rootPath) {
+        this.rootPath = rootPath;
+        this.maxDepth = 10;
+        this.excludePatterns = [
+            "node_modules",
+            "dist",
+            ".git",
+            "coverage",
+            "__pycache__",
+        ];
+    }
+    async analyze(entryFile) {
+        const nodes = new Map();
+        const edges = [];
+        const visited = new Set();
+        const queue = [
+            { file: entryFile, depth: 0 },
+        ];
+        while (queue.length > 0) {
+            const { file, depth } = queue.shift();
+            if (depth > this.maxDepth)
+                continue;
+            if (visited.has(file))
+                continue;
+            for (const pat of this.excludePatterns) {
+                if (file.includes(pat)) {
+                    visited.add(file);
+                }
+            }
+            if (!existsSync(file))
+                continue;
+            visited.add(file);
+            let content;
+            try {
+                content = readFileSync(file, "utf8");
+            }
+            catch {
+                continue;
+            }
+            const imports = parseImports(content, file);
+            const relativePath = relative(this.rootPath, file);
+            const node = {
+                id: relativePath,
+                filePath: file,
+                kind: "import",
+                imports: imports.filter((imp) => !imp.startsWith(".") || existsSync(join(this.rootPath, imp))),
+            };
+            nodes.set(relativePath, node);
+            for (const imp of node.imports) {
+                const targetFile = join(this.rootPath, imp);
+                if (existsSync(targetFile)) {
+                    const targetRelative = relative(this.rootPath, targetFile);
+                    if (!nodes.has(targetRelative)) {
+                        queue.push({ file: targetFile, depth: depth + 1 });
+                    }
+                    edges.push({
+                        from: relativePath,
+                        to: targetRelative,
+                        kind: "import",
+                        weight: 1,
+                    });
+                }
+            }
+        }
+        const graph = { nodes, edges, cycles: [] };
+        graph.cycles = detectCycle(graph);
+        return graph;
+    }
+    getStats(graph) {
+        return {
+            totalFiles: graph.nodes.size,
+            totalImports: graph.edges.length,
+            cycles: graph.cycles.length,
+        };
+    }
+}
+//# sourceMappingURL=analyzer.js.map

package/packages/dependency-analyzer/dist/src/imports.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Dependency Analyzer — Import Parsing
+ */
+/**
+ * Parse imports from file content. Supports TypeScript, JavaScript, CommonJS, Python.
+ */
+export declare function parseImports(content: string, filePath: string): string[];
+/**
+ * Resolve an import path relative to a file path.
+ */
+export declare function resolveImport(importPath: string, fromFile: string): string | null;
+//# sourceMappingURL=imports.d.ts.map

package/packages/dependency-analyzer/dist/src/imports.js

@@ -0,0 +1,73 @@
+/**
+ * Dependency Analyzer — Import Parsing
+ */
+import { extname, resolve } from "node:path";
+/**
+ * Parse imports from file content. Supports TypeScript, JavaScript, CommonJS, Python.
+ */
+export function parseImports(content, filePath) {
+    const ext = extname(filePath).toLowerCase();
+    const imports = [];
+    if (["ts", "tsx", "js", "jsx", "mjs", "cjs"].includes(ext)) {
+        imports.push(...parseTypeScriptImports(content));
+        imports.push(...parsePythonImports(content));
+    }
+    else if (ext === "py") {
+        imports.push(...parsePythonImports(content));
+    }
+    return [...new Set(imports)].filter(Boolean);
+}
+function parseTypeScriptImports(content) {
+    const imports = [];
+    // ESM: import X from './y' or import X from 'package'
+    const esmDefault = /import\s+(?:(?:type\s+)?(?:\{[^}]*\}|[A-Z][\w$]*)\s+from\s+)?['"]([^'"]+)['"]/g;
+    for (const match of content.matchAll(esmDefault)) {
+        imports.push(match[1]);
+    }
+    // ESM: import * as X from './y'
+    const esmNamespace = /import\s+\*\s+as\s+\w+\s+from\s+['"]([^'"]+)['"]/g;
+    for (const match of content.matchAll(esmNamespace)) {
+        imports.push(match[1]);
+    }
+    // ESM: import './x' (side-effect only)
+    const esmSideEffect = /import\s+['"]([^'"]+)['"]/g;
+    for (const match of content.matchAll(esmSideEffect)) {
+        imports.push(match[1]);
+    }
+    // CommonJS: const X = require('./y')
+    const cjs = /const\s+\w+\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    for (const match of content.matchAll(cjs)) {
+        imports.push(match[1]);
+    }
+    // CommonJS: require('./y')
+    const cjsBare = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    for (const match of content.matchAll(cjsBare)) {
+        imports.push(match[1]);
+    }
+    return imports;
+}
+function parsePythonImports(content) {
+    const imports = [];
+    // from module import x, y
+    const fromImport = /from\s+([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*)\s+import/g;
+    for (const match of content.matchAll(fromImport)) {
+        imports.push(match[1]);
+    }
+    // import module
+    const directImport = /^import\s+([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*)/gm;
+    for (const match of content.matchAll(directImport)) {
+        imports.push(match[1]);
+    }
+    return imports;
+}
+/**
+ * Resolve an import path relative to a file path.
+ */
+export function resolveImport(importPath, fromFile) {
+    if (importPath.startsWith(".")) {
+        return resolve(fromFile, "..", importPath);
+    }
+    // Package imports — return as-is (not a file path)
+    return null;
+}
+//# sourceMappingURL=imports.js.map

package/packages/dependency-analyzer/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export { DependencyAnalyzer } from "./analyzer.js";
+export { parseImports } from "./imports.js";
+export type { DependencyGraph, DependencyNode, DependencyEdge, DependencyKind, DepAnalysisOptions, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/dependency-analyzer/dist/src/index.js

@@ -0,0 +1,3 @@
+export { DependencyAnalyzer } from "./analyzer.js";
+export { parseImports } from "./imports.js";
+//# sourceMappingURL=index.js.map

package/packages/dependency-analyzer/dist/src/types.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Dependency Analyzer — Types
+ */
+export type DependencyKind = "import" | "export" | "extends" | "implements" | "call" | "reference";
+export interface DependencyNode {
+    id: string;
+    filePath: string;
+    kind: DependencyKind;
+    imports: string[];
+}
+export interface DependencyEdge {
+    from: string;
+    to: string;
+    kind: DependencyKind;
+    weight: number;
+}
+export interface DependencyGraph {
+    nodes: Map<string, DependencyNode>;
+    edges: DependencyEdge[];
+    cycles: string[][];
+}
+export interface DepAnalysisOptions {
+    rootPath: string;
+    maxDepth?: number;
+    excludePatterns?: string[];
+    includeDev?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/packages/dependency-analyzer/dist/src/types.js

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

package/packages/dependency-analyzer/src/analyzer.ts

@@ -0,0 +1,140 @@
+/**
+ * Dependency Analyzer — Main Analyzer
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { parseImports } from "./imports.js";
+import type {
+	DependencyEdge,
+	DependencyGraph,
+	DependencyNode,
+	DepAnalysisOptions,
+} from "./types.js";
+
+function detectCycle(graph: DependencyGraph): string[][] {
+	const cycles: string[][] = [];
+	const visited = new Set<string>();
+	const stack: string[] = [];
+
+	function dfs(nodeId: string): void {
+		if (stack.includes(nodeId)) {
+			const cycleStart = stack.indexOf(nodeId);
+			const cycle = stack.slice(cycleStart);
+			if (cycle.length > 1) cycles.push([...cycle, nodeId]);
+			return;
+		}
+		if (visited.has(nodeId)) return;
+		visited.add(nodeId);
+		stack.push(nodeId);
+
+		const node = graph.nodes.get(nodeId);
+		if (node) {
+			for (const imp of node.imports) {
+				const target = graph.nodes.get(imp);
+				if (target) dfs(imp);
+			}
+		}
+		stack.pop();
+	}
+
+	for (const id of graph.nodes.keys()) {
+		if (!visited.has(id)) dfs(id);
+	}
+
+	return cycles;
+}
+
+export class DependencyAnalyzer {
+	private rootPath: string;
+	private maxDepth: number;
+	private excludePatterns: string[];
+
+	constructor(rootPath: string) {
+		this.rootPath = rootPath;
+		this.maxDepth = 10;
+		this.excludePatterns = [
+			"node_modules",
+			"dist",
+			".git",
+			"coverage",
+			"__pycache__",
+		];
+	}
+
+	async analyze(entryFile: string): Promise<DependencyGraph> {
+		const nodes = new Map<string, DependencyNode>();
+		const edges: DependencyEdge[] = [];
+		const visited = new Set<string>();
+
+		const queue: Array<{ file: string; depth: number }> = [
+			{ file: entryFile, depth: 0 },
+		];
+
+		while (queue.length > 0) {
+			const { file, depth } = queue.shift()!;
+			if (depth > this.maxDepth) continue;
+			if (visited.has(file)) continue;
+			for (const pat of this.excludePatterns) {
+				if (file.includes(pat)) {
+					visited.add(file);
+				}
+			}
+			if (!existsSync(file)) continue;
+			visited.add(file);
+
+			let content: string;
+			try {
+				content = readFileSync(file, "utf8");
+			} catch {
+				continue;
+			}
+
+			const imports = parseImports(content, file);
+			const relativePath = relative(this.rootPath, file);
+
+			const node: DependencyNode = {
+				id: relativePath,
+				filePath: file,
+				kind: "import",
+				imports: imports.filter(
+					(imp) => !imp.startsWith(".") || existsSync(join(this.rootPath, imp)),
+				),
+			};
+			nodes.set(relativePath, node);
+
+			for (const imp of node.imports) {
+				const targetFile = join(this.rootPath, imp);
+				if (existsSync(targetFile)) {
+					const targetRelative = relative(this.rootPath, targetFile);
+					if (!nodes.has(targetRelative)) {
+						queue.push({ file: targetFile, depth: depth + 1 });
+					}
+					edges.push({
+						from: relativePath,
+						to: targetRelative,
+						kind: "import",
+						weight: 1,
+					});
+				}
+			}
+		}
+
+		const graph: DependencyGraph = { nodes, edges, cycles: [] };
+		graph.cycles = detectCycle(graph);
+
+		return graph;
+	}
+
+	getStats(graph: DependencyGraph): {
+		totalFiles: number;
+		totalImports: number;
+		cycles: number;
+	} {
+		return {
+			totalFiles: graph.nodes.size,
+			totalImports: graph.edges.length,
+			cycles: graph.cycles.length,
+		};
+	}
+}

package/packages/dependency-analyzer/src/imports.ts

@@ -0,0 +1,93 @@
+/**
+ * Dependency Analyzer — Import Parsing
+ */
+
+import { extname, join, resolve } from "node:path";
+
+/**
+ * Parse imports from file content. Supports TypeScript, JavaScript, CommonJS, Python.
+ */
+export function parseImports(content: string, filePath: string): string[] {
+	const ext = extname(filePath).toLowerCase();
+	const imports: string[] = [];
+
+	if (["ts", "tsx", "js", "jsx", "mjs", "cjs"].includes(ext)) {
+		imports.push(...parseTypeScriptImports(content));
+		imports.push(...parsePythonImports(content));
+	} else if (ext === "py") {
+		imports.push(...parsePythonImports(content));
+	}
+
+	return [...new Set(imports)].filter(Boolean);
+}
+
+function parseTypeScriptImports(content: string): string[] {
+	const imports: string[] = [];
+
+	// ESM: import X from './y' or import X from 'package'
+	const esmDefault =
+		/import\s+(?:(?:type\s+)?(?:\{[^}]*\}|[A-Z][\w$]*)\s+from\s+)?['"]([^'"]+)['"]/g;
+	for (const match of content.matchAll(esmDefault)) {
+		imports.push(match[1]);
+	}
+
+	// ESM: import * as X from './y'
+	const esmNamespace = /import\s+\*\s+as\s+\w+\s+from\s+['"]([^'"]+)['"]/g;
+	for (const match of content.matchAll(esmNamespace)) {
+		imports.push(match[1]);
+	}
+
+	// ESM: import './x' (side-effect only)
+	const esmSideEffect = /import\s+['"]([^'"]+)['"]/g;
+	for (const match of content.matchAll(esmSideEffect)) {
+		imports.push(match[1]);
+	}
+
+	// CommonJS: const X = require('./y')
+	const cjs = /const\s+\w+\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+	for (const match of content.matchAll(cjs)) {
+		imports.push(match[1]);
+	}
+
+	// CommonJS: require('./y')
+	const cjsBare = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+	for (const match of content.matchAll(cjsBare)) {
+		imports.push(match[1]);
+	}
+
+	return imports;
+}
+
+function parsePythonImports(content: string): string[] {
+	const imports: string[] = [];
+
+	// from module import x, y
+	const fromImport =
+		/from\s+([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*)\s+import/g;
+	for (const match of content.matchAll(fromImport)) {
+		imports.push(match[1]);
+	}
+
+	// import module
+	const directImport =
+		/^import\s+([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*)/gm;
+	for (const match of content.matchAll(directImport)) {
+		imports.push(match[1]);
+	}
+
+	return imports;
+}
+
+/**
+ * Resolve an import path relative to a file path.
+ */
+export function resolveImport(
+	importPath: string,
+	fromFile: string,
+): string | null {
+	if (importPath.startsWith(".")) {
+		return resolve(fromFile, "..", importPath);
+	}
+	// Package imports — return as-is (not a file path)
+	return null;
+}

package/packages/dependency-analyzer/src/index.ts

@@ -0,0 +1,9 @@
+export { DependencyAnalyzer } from "./analyzer.js";
+export { parseImports } from "./imports.js";
+export type {
+	DependencyGraph,
+	DependencyNode,
+	DependencyEdge,
+	DependencyKind,
+	DepAnalysisOptions,
+} from "./types.js";

package/packages/dependency-analyzer/src/types.ts

@@ -0,0 +1,38 @@
+/**
+ * Dependency Analyzer — Types
+ */
+
+export type DependencyKind =
+	| "import"
+	| "export"
+	| "extends"
+	| "implements"
+	| "call"
+	| "reference";
+
+export interface DependencyNode {
+	id: string;
+	filePath: string;
+	kind: DependencyKind;
+	imports: string[];
+}
+
+export interface DependencyEdge {
+	from: string;
+	to: string;
+	kind: DependencyKind;
+	weight: number;
+}
+
+export interface DependencyGraph {
+	nodes: Map<string, DependencyNode>;
+	edges: DependencyEdge[];
+	cycles: string[][];
+}
+
+export interface DepAnalysisOptions {
+	rootPath: string;
+	maxDepth?: number;
+	excludePatterns?: string[];
+	includeDev?: boolean;
+}