pi-harness-runtime 0.5.0 → 0.6.3-beta.13

package/packages/experience-replay/test/replay.test.ts

@@ -0,0 +1,267 @@
+/**
+ * Experience Replay Tests (RFC-0059)
+ */
+
+import { describe, it, expect, beforeEach } from "@jest/globals";
+import { type ExperienceReplay, createExperienceReplay } from "../src/index.js";
+import type { ReplayRequest, ReplaySources } from "../src/index.js";
+
+describe("ExperienceReplay", () => {
+	let replay: ExperienceReplay;
+
+	beforeEach(() => {
+		replay = createExperienceReplay();
+	});
+
+	describe("replay", () => {
+		it("reconstructs state from event log", async () => {
+			const request: ReplayRequest = {
+				jobId: "job-1",
+				mode: "inspect",
+				allowExternalCalls: false,
+			};
+
+			const sources: ReplaySources = {
+				checkpoint: {
+					version: 1,
+					jobId: "job-1",
+					status: "running",
+					requirement: "Test requirement",
+					createdAt: new Date().toISOString(),
+					updatedAt: new Date().toISOString(),
+				},
+				events: [
+					{
+						ts: new Date().toISOString(),
+						jobId: "job-1",
+						type: "task.started",
+						message: "Task started",
+						data: { taskId: "task-1" },
+					},
+					{
+						ts: new Date().toISOString(),
+						jobId: "job-1",
+						type: "task.completed",
+						message: "Task completed",
+						data: { taskId: "task-1" },
+					},
+				],
+			};
+
+			const result = await replay.replay(request, sources);
+
+			expect(result.jobId).toBe("job-1");
+			expect(result.reconstructedState).toBeDefined();
+			expect(result.timeline.length).toBe(2);
+		});
+
+		it("returns error for missing sources", async () => {
+			const request: ReplayRequest = {
+				jobId: "job-1",
+				mode: "inspect",
+				allowExternalCalls: false,
+			};
+
+			const sources: ReplaySources = {};
+
+			const result = await replay.replay(request, sources);
+
+			expect(result.divergences.length).toBeGreaterThan(0);
+			expect(result.divergences[0].severity).toBe("error");
+		});
+
+		it("supports inspect mode (read-only)", async () => {
+			const request: ReplayRequest = {
+				jobId: "job-1",
+				mode: "inspect",
+				allowExternalCalls: false,
+			};
+
+			const sources: ReplaySources = {
+				events: [
+					{
+						ts: new Date().toISOString(),
+						jobId: "job-1",
+						type: "test",
+						message: "Test event",
+					},
+				],
+			};
+
+			const result = await replay.replay(request, sources);
+
+			expect(result.reconstructedState).toBeDefined();
+			// No external calls made in inspect mode
+		});
+
+		it("emits replay.started event", async () => {
+			const events: any[] = [];
+			replay.onEvent((e) => events.push(e));
+
+			const request: ReplayRequest = {
+				jobId: "job-1",
+				mode: "inspect",
+				allowExternalCalls: false,
+			};
+
+			const sources: ReplaySources = {
+				events: [],
+			};
+
+			await replay.replay(request, sources);
+
+			expect(events.some((e) => e.type === "replay.started")).toBe(true);
+		});
+
+		it("emits replay.completed event", async () => {
+			const events: any[] = [];
+			replay.onEvent((e) => events.push(e));
+
+			const request: ReplayRequest = {
+				jobId: "job-1",
+				mode: "inspect",
+				allowExternalCalls: false,
+			};
+
+			const sources: ReplaySources = {
+				events: [],
+			};
+
+			await replay.replay(request, sources);
+
+			expect(events.some((e) => e.type === "replay.completed")).toBe(true);
+		});
+
+		it("filters events by sequence range", async () => {
+			const request: ReplayRequest = {
+				jobId: "job-1",
+				mode: "inspect",
+				fromSequence: 1,
+				toSequence: 3,
+				allowExternalCalls: false,
+			};
+
+			const sources: ReplaySources = {
+				events: [
+					{
+						ts: new Date().toISOString(),
+						jobId: "job-1",
+						type: "event-0",
+						message: "0",
+					},
+					{
+						ts: new Date().toISOString(),
+						jobId: "job-1",
+						type: "event-1",
+						message: "1",
+					},
+					{
+						ts: new Date().toISOString(),
+						jobId: "job-1",
+						type: "event-2",
+						message: "2",
+					},
+					{
+						ts: new Date().toISOString(),
+						jobId: "job-1",
+						type: "event-3",
+						message: "3",
+					},
+				],
+			};
+
+			const result = await replay.replay(request, sources);
+
+			expect(result.timeline.length).toBe(2); // events 1 and 2
+			expect(result.timeline[0].sequence).toBe(1);
+		});
+
+		it("simulate mode performs no external calls", async () => {
+			const request: ReplayRequest = {
+				jobId: "job-1",
+				mode: "simulate",
+				allowExternalCalls: false,
+			};
+
+			const sources: ReplaySources = {
+				events: [
+					{
+						ts: new Date().toISOString(),
+						jobId: "job-1",
+						type: "test",
+						message: "Test",
+					},
+				],
+			};
+
+			const result = await replay.replay(request, sources);
+
+			// Should complete without making external calls
+			expect(result.reconstructedState).toBeDefined();
+		});
+
+		it("requires approval for reexecute mode", async () => {
+			const request: ReplayRequest = {
+				jobId: "job-1",
+				mode: "reexecute",
+				allowExternalCalls: false, // No approval
+			};
+
+			const sources: ReplaySources = {
+				events: [],
+			};
+
+			const result = await replay.replay(request, sources);
+
+			// Should have error divergence
+			expect(result.divergences.some((d) => d.severity === "error")).toBe(true);
+		});
+
+		it("collects artifact references", async () => {
+			const request: ReplayRequest = {
+				jobId: "job-1",
+				mode: "inspect",
+				allowExternalCalls: false,
+			};
+
+			const sources: ReplaySources = {
+				prompts: {
+					"prompt-1": "Test prompt",
+					"prompt-2": "Another prompt",
+				},
+				outputs: {
+					"output-1": "Test output",
+				},
+				events: [],
+			};
+
+			const result = await replay.replay(request, sources);
+
+			expect(result.artifacts.length).toBe(3);
+		});
+	});
+
+	describe("timeline reconstruction", () => {
+		it("preserves event sequence", async () => {
+			const request: ReplayRequest = {
+				jobId: "job-1",
+				mode: "inspect",
+				allowExternalCalls: false,
+			};
+
+			const events = [
+				{ ts: "2024-01-01T00:00:01Z", jobId: "job-1", type: "a", message: "a" },
+				{ ts: "2024-01-01T00:00:02Z", jobId: "job-1", type: "b", message: "b" },
+				{ ts: "2024-01-01T00:00:03Z", jobId: "job-1", type: "c", message: "c" },
+			];
+
+			const sources: ReplaySources = { events };
+
+			const result = await replay.replay(request, sources);
+
+			expect(result.timeline[0].sequence).toBe(0);
+			expect(result.timeline[1].sequence).toBe(1);
+			expect(result.timeline[2].sequence).toBe(2);
+		});
+	});
+});

package/packages/experience-replay/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}

package/packages/framework-detector/README.md

@@ -0,0 +1,283 @@
+# @pi/framework-detector
+
+Intelligent framework detection system that identifies project frameworks, libraries, and architectures with confidence scoring.
+
+## Features
+
+- **Signal-Based Detection** - Multiple signals per framework with weighted scoring
+- **Confidence Scoring** - 0-1 confidence score based on matched signals
+- **Framework Implications** - Auto-detect implied frameworks (e.g., Next.js implies React)
+- **Version Detection** - Extract framework versions from dependencies
+- **Language Detection** - Identify primary programming language
+- **Package Manager Detection** - Detect npm, yarn, pnpm, or bun
+- **Caching** - Cache scan results for performance
+- **Extensible** - Add custom framework signatures
+
+## Installation
+
+```bash
+npm install @pi/framework-detector
+```
+
+## Quick Start
+
+### Basic Usage
+
+```typescript
+import { createFrameworkDetector } from "@pi/framework-detector";
+
+const detector = createFrameworkDetector();
+
+// Detect frameworks in a project
+const analysis = await detector.detect("/path/to/project");
+
+console.log(`Primary: ${analysis.primaryFramework?.framework.name}`);
+console.log(`Confidence: ${(analysis.primaryFramework?.confidence ?? 0) * 100}%`);
+console.log(`Language: ${analysis.language}`);
+console.log(`TypeScript: ${analysis.hasTypeScript}`);
+console.log(`Tests: ${analysis.hasTests}`);
+```
+
+### Detection Results
+
+```typescript
+// All detected frameworks
+for (const result of analysis.frameworks) {
+  console.log(`${result.framework.name}: ${(result.confidence * 100).toFixed(1)}%`);
+  console.log("Matched signals:");
+  for (const signal of result.signals) {
+    console.log(`  - ${signal.signal.type}: ${signal.match} (${signal.weight})`);
+  }
+}
+```
+
+### Custom Signatures
+
+```typescript
+import { createFrameworkDetector } from "@pi/framework-detector";
+
+const detector = createFrameworkDetector({
+  signatures: [
+    {
+      id: "my-framework",
+      name: "My Custom Framework",
+      category: "fullstack",
+      description: "Custom framework for my projects",
+      signals: [
+        { type: "package", pattern: "my-framework", weight: 0.4, source: "package" },
+        { type: "file", pattern: "my.config.js", weight: 0.3, source: "file" },
+        { type: "import", pattern: "from ['\"]my-framework['\"]", weight: 0.2, source: "code" },
+      ],
+      tags: ["custom", "internal"],
+    },
+  ],
+});
+```
+
+### Confidence Threshold
+
+```typescript
+const detector = createFrameworkDetector({
+  confidenceThreshold: 0.5, // Only show frameworks with >50% confidence
+});
+
+// Only high-confidence results will be returned
+const analysis = await detector.detect("/path/to/project");
+```
+
+## Supported Frameworks
+
+### Frontend
+
+- React
+- Vue.js
+- Angular
+- Svelte
+- Ember.js
+- Preact
+
+### Fullstack
+
+- Next.js
+- Nuxt.js
+- Remix
+- Astro
+- Frappe
+- ERPNext
+- Frappe SPA
+
+### Backend
+
+- Express.js
+- Fastify
+- NestJS
+- Django
+- Flask
+- FastAPI
+- Spring Boot
+
+### Desktop
+
+- Electron
+- Tauri
+- NW.js
+
+### Mobile
+
+- React Native
+- Flutter
+- Ionic
+
+## How Detection Works
+
+### Signal Types
+
+| Type | Source | Description |
+| ------ | -------- | ------------- |
+| `package` | package.json | Package name in dependencies |
+| `file` | Directory scan | File name or extension |
+| `config` | Directory scan | Config file name |
+| `directory` | Directory scan | Directory name |
+| `import` | Config files | Import statement in code |
+
+### Confidence Calculation
+
+```
+confidence = matched_signal_weights / total_signal_weights
+```
+
+For example, Next.js has these signals:
+
+- `next` package: 0.4 weight
+- `next.config.js`: 0.3 weight
+- `pages` directory: 0.2 weight
+- `app` directory: 0.2 weight
+- `react` package: 0.1 weight
+
+If `next`, `next.config.js`, and `react` are matched:
+
+```
+confidence = (0.4 + 0.3 + 0.1) / (0.4 + 0.3 + 0.2 + 0.2 + 0.1) = 0.8 / 1.2 = 0.67
+```
+
+### Framework Implications
+
+Some frameworks imply others:
+
+- Next.js implies React
+- Nuxt.js implies Vue.js
+- Remix implies React
+- ERPNext implies Frappe
+- Frappe SPA implies Frappe
+
+Implied frameworks get 80% of the parent framework's confidence.
+
+## API Reference
+
+### FrameworkDetector
+
+```typescript
+const detector = createFrameworkDetector({
+  confidenceThreshold?: number;    // Min confidence (0-1), default: 0.3
+  detectVersions?: boolean;       // Extract versions, default: true
+  resolveImplications?: boolean; // Add implied frameworks, default: true
+  cache?: boolean;              // Enable caching, default: true
+  cacheTtlMs?: number;          // Cache TTL, default: 5 minutes
+  timeoutMs?: number;           // Scan timeout, default: 30 seconds
+  signatures?: FrameworkSignature[]; // Custom signatures
+});
+```
+
+### Methods
+
+```typescript
+// Detect frameworks in a project
+detector.detect(projectPath): Promise<ProjectAnalysis>;
+
+// Scan project files
+detector.scan(options): Promise<ScanResult>;
+
+// Clear scan cache
+detector.clearCache(): void;
+
+// Get signature registry
+detector.getRegistry(): SignatureRegistry;
+```
+
+### ProjectAnalysis
+
+```typescript
+interface ProjectAnalysis {
+  projectPath: string;
+  frameworks: DetectionResult[];
+  primaryFramework?: DetectionResult;
+  language?: string;
+  packageManager?: "npm" | "yarn" | "pnpm" | "bun";
+  hasTypeScript?: boolean;
+  hasTests?: boolean;
+  files: ScannedFile[];
+  scanTimeMs: number;
+}
+```
+
+### DetectionResult
+
+```typescript
+interface DetectionResult {
+  framework: FrameworkInfo;
+  confidence: number;          // 0-1
+  signals: MatchedSignal[];
+  version?: string;             // Detected version
+  metadata?: Record<string, unknown>;
+}
+```
+
+### FrameworkSignature
+
+```typescript
+interface FrameworkSignature {
+  id: string;
+  name: string;
+  category: FrameworkCategory;
+  description: string;
+  signals: DetectionSignal[];
+  requires?: string[];         // Required frameworks
+  implies?: string[];          // Implied frameworks
+  excludes?: string[];         // Excluded frameworks
+  tags?: string[];
+}
+```
+
+### DetectionSignal
+
+```typescript
+interface DetectionSignal {
+  type: SignalType;
+  pattern: string;
+  weight: number;               // 0-1
+  source?: SignalType;
+}
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                  FrameworkDetector                        │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────┐  │
+│  │   Scanner   │  │   Matcher   │  │  Confidence     │  │
+│  │             │──│             │──│  Calculator    │  │
+│  └─────────────┘  └─────────────┘  └─────────────────┘  │
+│         │                                       │        │
+│         ▼                                       ▼        │
+│  ┌─────────────┐                       ┌─────────────────┐│
+│  │   File     │                       │  Detection      ││
+│  │   Cache    │                       │  Results        ││
+│  └─────────────┘                       └─────────────────┘│
+│                                                  │        │
+│  ┌─────────────────────────────────────────────────────┐│
+│  │              Signature Registry                     ││
+│  │  [React] [Vue] [Next.js] [Django] [Frappe] [...]   ││
+│  └─────────────────────────────────────────────────────┘│
+└─────────────────────────────────────────────────────────┘
+```

package/packages/framework-detector/dist/detector.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Framework Detector - Detector
+ *
+ * Main framework detection engine.
+ */
+import type { DetectorConfig, ProjectAnalysis, ScanOptions, ScanResult } from "./types.js";
+import { SignatureRegistry } from "./signatures/registry.js";
+export declare class FrameworkDetector {
+    private readonly config;
+    private readonly registry;
+    private readonly scanCache;
+    constructor(config?: DetectorConfig);
+    /**
+     * Detect frameworks in a project
+     */
+    detect(projectPath: string): Promise<ProjectAnalysis>;
+    /**
+     * Scan project files
+     */
+    scan(options: ScanOptions): Promise<ScanResult>;
+    /**
+     * Scan directory recursively
+     */
+    private scanDirectory;
+    /**
+     * Parse package.json
+     */
+    private parsePackageJson;
+    /**
+     * Detect frameworks from scan result
+     */
+    private detectFrameworks;
+    /**
+     * Match signature against scan data
+     */
+    private matchSignature;
+    /**
+     * Calculate confidence score
+     */
+    private calculateConfidence;
+    /**
+     * Determine primary framework
+     */
+    private determinePrimaryFramework;
+    /**
+     * Detect programming language
+     */
+    private detectLanguage;
+    /**
+     * Detect package manager
+     */
+    private detectPackageManager;
+    /**
+     * Resolve framework implications
+     */
+    private resolveImplications;
+    /**
+     * Get config type
+     */
+    private getConfigType;
+    /**
+     * Clear cache
+     */
+    clearCache(): void;
+    /**
+     * Get registry
+     */
+    getRegistry(): SignatureRegistry;
+}
+/**
+ * Create a framework detector
+ */
+export declare function createFrameworkDetector(config?: DetectorConfig): FrameworkDetector;
+//# sourceMappingURL=detector.d.ts.map

package/packages/framework-detector/dist/detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector.d.ts","sourceRoot":"","sources":["../src/detector.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,KAAK,EAEX,cAAc,EAId,eAAe,EACf,WAAW,EACX,UAAU,EAEV,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAgB7D,qBAAa,iBAAiB;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2B;IAClD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoB;IAC7C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAGZ;gBAEF,MAAM,GAAE,cAAmB;IAYvC;;OAEG;IACG,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAwC3D;;OAEG;IACG,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IA+FrD;;OAEG;YACW,aAAa;IAwD3B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAIxB;;OAEG;YACW,gBAAgB;IAyE9B;;OAEG;IACH,OAAO,CAAC,cAAc;IA4EtB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAY3B;;OAEG;IACH,OAAO,CAAC,yBAAyB;IASjC;;OAEG;IACH,OAAO,CAAC,cAAc;IA2CtB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAa5B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAoC3B;;OAEG;IACH,OAAO,CAAC,aAAa;IAYrB;;OAEG;IACH,UAAU,IAAI,IAAI;IAIlB;;OAEG;IACH,WAAW,IAAI,iBAAiB;CAGhC;AAID;;GAEG;AACH,wBAAgB,uBAAuB,CACtC,MAAM,CAAC,EAAE,cAAc,GACrB,iBAAiB,CAEnB"}