@phi-code-admin/phi-code 0.95.0 → 0.96.1

package/extensions/phi/providers/telemetry.ts

@@ -15,6 +15,72 @@ export interface PhaseRecord {
 	verdict: string | null;
 	retried: boolean;
 	blockedRetried: boolean;
+	/** Wall-clock of this phase attempt (ms); absent on legacy records. */
+	durationMs?: number;
+}
+
+/** Aggregate .phi/runs.jsonl records into a readable markdown summary. */
+export function summarizeRuns(records: RunRecord[]): string {
+	if (records.length === 0) return "No runs recorded yet — run /fix, /debug or /build first.";
+	const byMode = new Map<string, RunRecord[]>();
+	for (const r of records) {
+		const list = byMode.get(r.mode) ?? [];
+		list.push(r);
+		byMode.set(r.mode, list);
+	}
+	const pct = (n: number, d: number) => (d ? `${Math.round((100 * n) / d)}%` : "–");
+	const avg = (xs: number[]) => (xs.length ? Math.round(xs.reduce((a, b) => a + b, 0) / xs.length) : 0);
+	let out = `**Run telemetry** — ${records.length} run(s)\n\n`;
+	out +=
+		"| mode | runs | green/finished | blocked | unverified | avg duration | avg sandbox execs |\n|---|---|---|---|---|---|---|\n";
+	for (const [mode, rs] of byMode) {
+		const green = rs.filter((r) => /GREEN|FIXED|finished/i.test(r.outcome)).length;
+		const blocked = rs.filter((r) => /BLOCKED/i.test(r.outcome)).length;
+		const unv = rs.filter((r) => /UNVERIFIED/i.test(r.outcome)).length;
+		out += `| ${mode} | ${rs.length} | ${pct(green, rs.length)} | ${pct(blocked, rs.length)} | ${pct(unv, rs.length)} | ${Math.round(avg(rs.map((x) => x.durationMs)) / 1000)}s | ${avg(rs.map((x) => x.sandboxExecs))} |\n`;
+	}
+	// /fix specifics: how often the shot alone was enough (the promise metric).
+	const fixes = byMode.get("fix") ?? [];
+	if (fixes.length) {
+		const greenShot = fixes.filter((r) => /GREEN at single-shot cost/i.test(r.outcome)).length;
+		const escalated = fixes.filter((r) => r.phases.some((p) => p.key === "localize" || p.key === "reproduce")).length;
+		out += `\n/fix: green at single-shot cost ${pct(greenShot, fixes.length)}, escalated ${pct(escalated, fixes.length)}.\n`;
+	}
+	// Slowest phase kinds (durationMs is absent on legacy records).
+	const durs = new Map<string, number[]>();
+	for (const r of records)
+		for (const ph of r.phases)
+			if (typeof ph.durationMs === "number") {
+				const l = durs.get(ph.key) ?? [];
+				l.push(ph.durationMs);
+				durs.set(ph.key, l);
+			}
+	if (durs.size) {
+		const rows = [...durs]
+			.map(([k, xs]) => ({ k, avg: avg(xs), n: xs.length }))
+			.sort((a, b) => b.avg - a.avg)
+			.slice(0, 5);
+		out += `\nSlowest phases (avg): ${rows.map((r) => `${r.k} ${Math.round(r.avg / 1000)}s ×${r.n}`).join(", ")}.\n`;
+	}
+	const timeouts = records.flatMap((r) => r.phases).filter((p) => p.verdict === "TIMEOUT").length;
+	if (timeouts) out += `\n⏰ ${timeouts} phase timeout(s) recorded.\n`;
+	return out;
+}
+
+/** Parse a runs.jsonl blob (tolerant: bad lines are skipped). */
+export function parseRunsJsonl(blob: string): RunRecord[] {
+	const out: RunRecord[] = [];
+	for (const line of blob.split("\n")) {
+		const t = line.trim();
+		if (!t) continue;
+		try {
+			const r = JSON.parse(t);
+			if (r && typeof r.mode === "string" && Array.isArray(r.phases)) out.push(r as RunRecord);
+		} catch {
+			/* skip */
+		}
+	}
+	return out;
 }
 
 export interface RunRecord {

package/extensions/phi/providers/test-discovery.ts

@@ -0,0 +1,119 @@
+/**
+ * Targeted-test discovery — the oracle upgrade the flask-4992 measurement
+ * demanded: the driver oracle validated the agent's own reproduction (exit 0)
+ * while the project's REAL tests for the touched module failed. Running the
+ * full suite is usually too slow/foreign (django ≠ pytest); the right-sized
+ * check is the EXISTING test files that belong to the modules the change
+ * touched. Pure logic with fs seams so every heuristic is unit-tested.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+export interface DiscoverySeams {
+	/** Does this repo-relative path exist? */
+	exists(relPath: string): boolean;
+	/** package.json content (for JS runner detection); null when absent. */
+	readPackageJson(): { devDependencies?: Record<string, string>; dependencies?: Record<string, string> } | null;
+}
+
+const PY_EXT = /\.py$/;
+const JS_EXT = /\.(ts|tsx|js|jsx|mjs)$/;
+
+function posix(p: string): string {
+	return p.replace(/\\/g, "/");
+}
+
+/** Candidate test-file locations for one changed source file. */
+export function testCandidatesFor(changedFile: string): string[] {
+	const f = posix(changedFile);
+	const dir = f.includes("/") ? f.slice(0, f.lastIndexOf("/")) : "";
+	const base = f.slice(f.lastIndexOf("/") + 1);
+	const stem = base.replace(/\.[^.]+$/, "");
+	const d = (s: string) => (dir ? `${dir}/${s}` : s);
+
+	if (PY_EXT.test(base)) {
+		if (base.startsWith("test_")) return [f]; // a test itself
+		return [
+			d(`test_${base}`),
+			d(`tests/test_${base}`),
+			`tests/test_${stem}.py`,
+			`test/test_${stem}.py`,
+			// package-level tests dir next to the module's parent (e.g. pkg/mod/x.py → pkg/tests/test_x.py)
+			dir.includes("/") ? `${dir.slice(0, dir.lastIndexOf("/"))}/tests/test_${stem}.py` : "",
+		].filter(Boolean);
+	}
+
+	if (JS_EXT.test(base)) {
+		if (/\.(test|spec)\./.test(base)) return [f];
+		const exts = ["ts", "tsx", "js", "mjs"];
+		const out: string[] = [];
+		for (const e of exts) {
+			out.push(
+				d(`${stem}.test.${e}`),
+				d(`__tests__/${stem}.test.${e}`),
+				`test/${stem}.test.${e}`,
+				`tests/${stem}.test.${e}`,
+			);
+		}
+		return out;
+	}
+
+	return [];
+}
+
+export interface TargetedTests {
+	/** Existing test files that cover the changed modules. */
+	files: string[];
+	/** A runnable command for them, or undefined when none could be built. */
+	command?: string;
+}
+
+/**
+ * Discover the existing targeted tests for a set of changed files and build one
+ * command to run them. Python → pytest; JS → vitest/jest when present in
+ * package.json. Deduped, capped (a huge change should not queue a full suite by
+ * the back door).
+ */
+export function discoverTargetedTests(changedFiles: string[], seams: DiscoverySeams, cap = 5): TargetedTests {
+	const found: string[] = [];
+	for (const cf of changedFiles) {
+		for (const cand of testCandidatesFor(cf)) {
+			if (!found.includes(cand) && seams.exists(cand)) {
+				found.push(cand);
+				break; // first existing candidate per changed file is enough
+			}
+		}
+		if (found.length >= cap) break;
+	}
+	if (found.length === 0) return { files: [] };
+
+	if (found.every((f) => PY_EXT.test(f))) {
+		return { files: found, command: `python -m pytest ${found.join(" ")} -x -q` };
+	}
+	const pkg = seams.readPackageJson();
+	const deps = { ...(pkg?.dependencies ?? {}), ...(pkg?.devDependencies ?? {}) };
+	if (deps.vitest) return { files: found, command: `npx vitest run ${found.join(" ")}` };
+	if (deps.jest) return { files: found, command: `npx jest ${found.join(" ")}` };
+	return { files: found };
+}
+
+/** Real-fs seams for a repo root. */
+export function fsSeamsFor(cwd: string): DiscoverySeams {
+	return {
+		exists: (rel) => {
+			try {
+				return existsSync(join(cwd, rel));
+			} catch {
+				return false;
+			}
+		},
+		readPackageJson: () => {
+			try {
+				return JSON.parse(readFileSync(join(cwd, "package.json"), "utf-8"));
+			} catch {
+				return null;
+			}
+		},
+	};
+}

package/extensions/phi/providers/triage.ts

@@ -54,6 +54,21 @@ export function estimateFiles(text: string): number {
  * decision out. Order matters — a forced mode wins, then a real failing state
  * (cheapest useful oracle), then build-scale, else single shot.
  */
+const BUG_SHAPE =
+	/\b(traceback|exception|stack ?trace|segfault|error:|fails?\b|failing|broken|crash(es|ed)?|bug\b|régression|regression|ne (marche|fonctionne) (pas|plus)|plante)\b/i;
+
+/**
+ * Does a free-form user message look like a bug report? Used to suggest /fix
+ * once (the measured-best default: never worse than a single shot, oracle-
+ * verified). Deliberately conservative — suggestion, never interception.
+ */
+export function looksLikeBugReport(text: string): boolean {
+	const t = text.trim();
+	if (!t || t.startsWith("/")) return false;
+	if (t.length < 15) return false;
+	return BUG_SHAPE.test(t);
+}
+
 export function triage(signals: TriageSignals): TriageDecision {
 	if (signals.forced) {
 		return {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@phi-code-admin/phi-code",
-	"version": "0.95.0",
+	"version": "0.96.1",
 	"description": "Coding agent CLI with persistent memory, sub-agents, intelligent routing, and orchestration",
 	"type": "module",
 	"piConfig": {
@@ -63,11 +63,11 @@
 		"marked": "^15.0.12",
 		"minimatch": "^10.2.3",
 		"phi-code-agent": "^0.74.0",
-		"phi-code-ai": "^0.74.0",
+		"phi-code-ai": "^0.74.4",
 		"phi-code-tui": "^0.74.0",
 		"proper-lockfile": "^4.1.2",
 		"sigma-agents": "^0.1.7",
-		"sigma-memory": "^0.2.2",
+		"sigma-memory": "^0.2.9",
 		"sigma-skills": "^0.1.2",
 		"strip-ansi": "^7.1.0",
 		"typebox": "^1.1.24",