pi-harness-runtime 0.10.11 → 0.10.12

package/packages/project-analyzer/src/walker.ts

@@ -0,0 +1,366 @@
+/**
+ * Bounded Filesystem Walker
+ *
+ * Provides safe, bounded filesystem traversal for project analysis.
+ * Implements security boundaries to prevent traversal outside repository.
+ */
+
+import { readdir, stat, readFile, readlink } from "node:fs/promises";
+import { join, relative, isAbsolute, resolve } from "node:path";
+import { type AnalyzerConfig, DEFAULT_ANALYZER_CONFIG } from "./types.js";
+
+/**
+ * Scanned file record.
+ */
+export interface ScannedFile {
+	/** Absolute path to file */
+	path: string;
+	/** Relative path from repository root */
+	relativePath: string;
+	/** File size in bytes */
+	size: number;
+	/** Whether file matches a sensitive pattern */
+	sensitive: boolean;
+	/** Whether file matches a generated pattern */
+	generated: boolean;
+}
+
+/**
+ * Filesystem scan result.
+ */
+export interface ScanResult {
+	/** All scanned files */
+	files: ScannedFile[];
+	/** Directories scanned */
+	directoriesScanned: number;
+	/** Files skipped due to limits */
+	filesSkipped: number;
+	/** Whether scan was truncated */
+	truncated: boolean;
+	/** Error messages if any */
+	errors: string[];
+}
+
+/**
+ * Match a path against a glob pattern.
+ */
+function matchesPattern(path: string, pattern: string): boolean {
+	// Handle simple glob patterns
+	if (pattern === "**") return true;
+
+	// Handle trailing /** for directory patterns
+	if (pattern.endsWith("/**")) {
+		const dirPattern = pattern.slice(0, -3);
+		if (path.startsWith(dirPattern + "/")) return true;
+		if (path === dirPattern) return true;
+		return false;
+	}
+
+	// Handle exact match
+	if (!pattern.includes("*")) {
+		return path === pattern || path.endsWith("/" + pattern);
+	}
+
+	// Handle wildcard in pattern
+	const parts = pattern.split("*");
+	if (parts.length === 2) {
+		const [prefix, suffix] = parts;
+		if (prefix && !path.startsWith(prefix)) return false;
+		if (suffix && !path.endsWith(suffix)) return false;
+		return true;
+	}
+
+	return false;
+}
+
+/**
+ * Check if a path matches any of the given patterns.
+ */
+function matchesAnyPattern(path: string, patterns: string[]): boolean {
+	return patterns.some((p) => matchesPattern(path, p));
+}
+
+/**
+ * Bounded filesystem walker for project analysis.
+ */
+export class FileSystemWalker {
+	private config: AnalyzerConfig;
+	private root: string;
+	private filesScanned = 0;
+	private dirsScanned = 0;
+	private skippedFiles = 0;
+	private errors: string[] = [];
+	private visitedDirs = new Set<string>();
+
+	constructor(root: string, config?: Partial<AnalyzerConfig>) {
+		if (!isAbsolute(root)) {
+			throw new Error("Repository root must be an absolute path");
+		}
+		this.root = resolve(root);
+		this.config = { ...DEFAULT_ANALYZER_CONFIG, ...config };
+	}
+
+	/**
+	 * Get canonical path and verify it's within repository root.
+	 */
+	resolvePath(path: string): string {
+		const resolved = resolve(this.root, path);
+		if (!resolved.startsWith(this.root)) {
+			throw new Error(`Path escape attempt detected: ${path}`);
+		}
+		return resolved;
+	}
+
+	/**
+	 * Check if a path should be skipped based on patterns.
+	 */
+	private isSensitive(path: string): boolean {
+		return matchesAnyPattern(path, this.config.sensitivePatterns);
+	}
+
+	/**
+	 * Check if a path is a generated file/directory.
+	 */
+	private isGenerated(path: string): boolean {
+		return matchesAnyPattern(path, this.config.generatedPatterns);
+	}
+
+	/**
+	 * Get relative path from repository root.
+	 */
+	private getRelativePath(absPath: string): string {
+		return relative(this.root, absPath);
+	}
+
+	/**
+	 * Recursively scan directory with depth limiting.
+	 */
+	private async scanDir(
+		dirPath: string,
+		depth: number,
+	): Promise<ScannedFile[]> {
+		if (depth > this.config.maxDepth) {
+			return [];
+		}
+
+		const relativePath = this.getRelativePath(dirPath);
+		const resolvedPath = this.resolvePath(dirPath);
+
+		// Prevent infinite loops from circular symlinks
+		try {
+			const realPath = (await stat(resolvedPath)).ino?.toString();
+			if (realPath && this.visitedDirs.has(realPath)) {
+				return [];
+			}
+			if (realPath) this.visitedDirs.add(realPath);
+		} catch {
+			return [];
+		}
+
+		this.dirsScanned++;
+
+		const files: ScannedFile[] = [];
+
+		try {
+			const entries = await readdir(resolvedPath, { withFileTypes: true });
+
+			for (const entry of entries) {
+				const entryPath = join(resolvedPath, entry.name);
+				const relPath = relative(this.root, entryPath);
+
+				// Skip if over file limit
+				if (this.filesScanned >= this.config.maxScanFiles) {
+					this.skippedFiles++;
+					continue;
+				}
+
+				// Check for symlink escape
+				if (entry.isSymbolicLink()) {
+					try {
+						const target = await readlink(entryPath);
+						const targetPath = isAbsolute(target)
+							? target
+							: join(dirPath, target);
+						const resolvedTarget = resolve(targetPath);
+						if (!resolvedTarget.startsWith(this.root)) {
+							this.errors.push(`Symlink escapes root: ${relPath}`);
+							continue;
+						}
+					} catch {
+						// Can't read symlink, skip it
+						continue;
+					}
+				}
+
+				if (entry.isDirectory()) {
+					// Skip hidden directories (except .git)
+					if (entry.name.startsWith(".") && entry.name !== ".git") {
+						continue;
+					}
+
+					// Recurse into subdirectory
+					const subFiles = await this.scanDir(entryPath, depth + 1);
+					files.push(...subFiles);
+				} else if (entry.isFile()) {
+					this.filesScanned++;
+					const fileStat = await stat(entryPath);
+
+					files.push({
+						path: entryPath,
+						relativePath: relPath,
+						size: fileStat.size,
+						sensitive: this.isSensitive(relPath),
+						generated: this.isGenerated(relPath),
+					});
+				}
+			}
+		} catch (err) {
+			this.errors.push(`Error reading directory ${relativePath}: ${err}`);
+		}
+
+		return files;
+	}
+
+	/**
+	 * Scan the repository and return all relevant files.
+	 */
+	async scan(): Promise<ScanResult> {
+		const files = await this.scanDir(this.root, 0);
+
+		return {
+			files,
+			directoriesScanned: this.dirsScanned,
+			filesSkipped: this.skippedFiles,
+			truncated: this.filesScanned >= this.config.maxScanFiles,
+			errors: this.errors,
+		};
+	}
+
+	/**
+	 * Read a file if it's within size limits.
+	 */
+	async readFileSafe(path: string): Promise<string | null> {
+		try {
+			const absPath = this.resolvePath(path);
+			const fileStat = await stat(absPath);
+
+			if (fileStat.size > this.config.maxFileSize) {
+				return null;
+			}
+
+			return await readFile(absPath, "utf-8");
+		} catch {
+			return null;
+		}
+	}
+
+	/**
+	 * Find files matching a pattern.
+	 */
+	async findFiles(pattern: RegExp, maxResults = 100): Promise<string[]> {
+		const results: string[] = [];
+		const files = await this.scan();
+
+		for (const file of files.files) {
+			if (pattern.test(file.relativePath)) {
+				results.push(file.path);
+				if (results.length >= maxResults) break;
+			}
+		}
+
+		return results;
+	}
+
+	/**
+	 * Check if a path exists within the repository.
+	 */
+	async exists(path: string): Promise<boolean> {
+		try {
+			const absPath = this.resolvePath(path);
+			await stat(absPath);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+
+	/**
+	 * Get statistics about the scan.
+	 */
+	getStats() {
+		return {
+			filesScanned: this.filesScanned,
+			directoriesScanned: this.dirsScanned,
+			skippedFiles: this.skippedFiles,
+			root: this.root,
+		};
+	}
+}
+
+/**
+ * Create a readonly filesystem abstraction from walker.
+ */
+export function createReadonlyFileSystem(walker: FileSystemWalker): {
+	exists(path: string): Promise<boolean>;
+	readFile(path: string): Promise<string>;
+	readDir(path: string): Promise<string[]>;
+	isDirectory(path: string): Promise<boolean>;
+	glob(pattern: string, cwd?: string): Promise<string[]>;
+} {
+	return {
+		exists: async (path: string) => walker.exists(path),
+
+		readFile: async (path: string) => {
+			const content = await walker.readFileSafe(path);
+			if (content === null) {
+				throw new Error(`Cannot read file: ${path}`);
+			}
+			return content;
+		},
+
+		readDir: async (path: string) => {
+			const absPath = walker.resolvePath(path);
+			try {
+				const entries = await readdir(absPath);
+				return entries;
+			} catch {
+				return [];
+			}
+		},
+
+		isDirectory: async (path: string) => {
+			try {
+				const absPath = walker.resolvePath(path);
+				const dirStat = await stat(absPath);
+				return dirStat.isDirectory();
+			} catch {
+				return false;
+			}
+		},
+
+		glob: async (pattern: string, _cwd?: string) => {
+			// Safely convert glob pattern to regex - only allow known safe patterns
+			const safePatterns: Record<string, string> = {
+				"*.json": "^.+\\.json$",
+				"*.ts": "^.+\\.ts$",
+				"*.tsx": "^.+\\.tsx$",
+				"*.js": "^.+\\.js$",
+				"*.jsx": "^.+\\.jsx$",
+				"*.py": "^.+\\.py$",
+				"*.md": "^.+\\.md$",
+				"*.yaml": "^.+\\.yaml$",
+				"*.yml": "^.+\\.yml$",
+				"package.json": "^package\\.json$",
+				"*.config.*": "^.+\\.config\\.[^/]+$",
+			};
+
+			const regexPattern = safePatterns[pattern];
+			if (!regexPattern) {
+				return [];
+			}
+
+			const regex = new RegExp(regexPattern);
+			return walker.findFiles(regex);
+		},
+	};
+}

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

@@ -0,0 +1,61 @@
+/**
+ * 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 declare class ProjectionEngine {
+    private decisions;
+    private taskStates;
+    private agentTimelines;
+    private messages;
+    private tools;
+    private topics;
+    private sessionId;
+    addEvent(event: SessionEvent): void;
+    getDecisions(): Decision[];
+    getTaskStates(): TaskState[];
+    getSummary(): SessionSummary;
+    getTimeline(agentId?: string): AgentTimeline[];
+    reset(): void;
+}
+export {};
+//# sourceMappingURL=engine.d.ts.map

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

@@ -0,0 +1,87 @@
+/**
+ * Projection Engine — Core
+ */
+export class ProjectionEngine {
+    decisions = [];
+    taskStates = new Map();
+    agentTimelines = new Map();
+    messages = 0;
+    tools = 0;
+    topics = new Set();
+    sessionId = "";
+    addEvent(event) {
+        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 ?? "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() {
+        return this.decisions;
+    }
+    getTaskStates() {
+        return [...this.taskStates.values()];
+    }
+    getSummary() {
+        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) {
+        if (agentId)
+            return [this.agentTimelines.get(agentId)].filter(Boolean);
+        return [...this.agentTimelines.values()];
+    }
+    reset() {
+        this.decisions = [];
+        this.taskStates.clear();
+        this.agentTimelines.clear();
+        this.messages = 0;
+        this.tools = 0;
+        this.topics.clear();
+    }
+}
+//# sourceMappingURL=engine.js.map

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

@@ -0,0 +1,2 @@
+export type { Projection, Decision, TaskState, KnowledgeExtraction, AgentTimeline, SessionSummary, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/projection-engine/dist/src/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,3 @@
+export declare function saveProjection(name: string, data: unknown): void;
+export declare function loadProjections(name: string): string[];
+//# sourceMappingURL=project.d.ts.map

package/packages/projection-engine/dist/src/project.js

@@ -0,0 +1,24 @@
+import { appendFileSync, existsSync, mkdirSync, 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, data) {
+    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) {
+    const path = join(PROJ_DIR, `${name}.jsonl`);
+    if (!existsSync(path))
+        return [];
+    try {
+        return readFileSync(path, "utf8").split("\n").filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=project.js.map

package/packages/projection-engine/dist/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/dist/src/types.js

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