pi-harness-runtime 0.10.11 → 0.10.12

package/packages/auth/src/run-minimax-auth.ts

@@ -0,0 +1,150 @@
+#!/usr/bin/env bun
+/**
+ * run-minimax-auth.ts
+ *
+ * CLI to authenticate with MiniMax using Playwright persistent browser.
+ *
+ * Usage:
+ *   bun packages/auth/src/run-minimax-auth.ts auth    # First-time: login in browser
+ *   bun packages/auth/src/run-minimax-auth.ts scrape  # Scrape usage (silent)
+ *   bun packages/auth/src/run-minimax-auth.ts check   # Check status
+ *   bun packages/auth/src/run-minimax-auth.ts open    # Open browser with profile
+ *
+ * Security:
+ *   - Human logs in manually in the browser
+ *   - Playwright persistent profile auto-saves session
+ *   - No credentials are processed by this code
+ */
+
+import {
+	authenticateWithPersistentBrowser,
+	scrapeWithExistingProfile,
+	checkAuthStatus,
+	getProfileDir,
+	getStatusPath,
+	getLiveSessionPath,
+	startPersistentBrowserDaemon,
+	stopPersistentBrowserDaemon,
+} from "./minimax-browser-auth.js";
+
+async function main() {
+	const args = process.argv.slice(2);
+	const command = args[0] ?? "auth";
+
+	console.log("");
+	console.log("🔐 MiniMax Browser Authentication");
+	console.log("=".repeat(50));
+	console.log("");
+
+	if (command === "check") {
+		console.log("Command: check");
+		console.log("");
+		const status = await checkAuthStatus();
+		console.log("");
+		console.log("Status:");
+		console.log(JSON.stringify(status, null, 2));
+		console.log("");
+		console.log("Profile dir:", getProfileDir());
+		console.log("Status file:", getStatusPath());
+		return;
+	}
+
+	if (command === "scrape" || command === "usage") {
+		console.log(
+			"Command: scrape (prefers live browser, falls back to saved profile)",
+		);
+		console.log("");
+		const status = await scrapeWithExistingProfile();
+		console.log("");
+		console.log("Result:");
+		console.log(JSON.stringify(status, null, 2));
+		return;
+	}
+
+	if (command === "open" || command === "daemon") {
+		console.log("Command: open (live browser daemon mode)");
+		console.log("");
+		console.log("This will:");
+		console.log("1. Launch a real Chrome window with the MiniMax profile");
+		console.log("2. Keep that browser session running for unattended scrapes");
+		console.log("3. Let you sign in manually once and leave the window open");
+		console.log("");
+		console.log("Profile dir:", getProfileDir());
+		console.log("");
+
+		const session = await startPersistentBrowserDaemon();
+		console.log("Live browser session:");
+		console.log(JSON.stringify(session, null, 2));
+		console.log("");
+		console.log("Next:");
+		console.log("- Sign in inside that Chrome window if needed");
+		console.log("- Leave the MiniMax Chrome window open overnight");
+		console.log(
+			"- Later, run: bun packages/auth/src/run-minimax-auth.ts scrape",
+		);
+		console.log(
+			"- To stop it, run: bun packages/auth/src/run-minimax-auth.ts stop",
+		);
+		console.log("Live session file:", getLiveSessionPath());
+		return;
+	}
+
+	if (command === "stop" || command === "close") {
+		console.log("Command: stop");
+		console.log("");
+		const stopped = await stopPersistentBrowserDaemon();
+		console.log(
+			stopped
+				? "✅ Stopped MiniMax live browser session"
+				: "ℹ️  No active MiniMax live browser session was found",
+		);
+		console.log("Live session file:", getLiveSessionPath());
+		return;
+	}
+
+	if (command === "auth" || command === "login") {
+		console.log("Command: auth (persistent browser mode)");
+		console.log("");
+		console.log("This will:");
+		console.log("1. Launch a Chrome browser with persistent profile");
+		console.log("2. Navigate to MiniMax usage page");
+		console.log("3. Let you log in (first time only)");
+		console.log("4. Auto-save profile for future use");
+		console.log("");
+		console.log("Profile dir:", getProfileDir());
+		console.log("");
+
+		const status = await authenticateWithPersistentBrowser();
+		console.log("");
+		console.log("Result:");
+		console.log(JSON.stringify(status, null, 2));
+		return;
+	}
+
+	console.log("Usage:");
+	console.log(
+		"  bun packages/auth/src/run-minimax-auth.ts auth    # Manual login + confirmation",
+	);
+	console.log(
+		"  bun packages/auth/src/run-minimax-auth.ts open    # Start keep-open browser daemon",
+	);
+	console.log(
+		"  bun packages/auth/src/run-minimax-auth.ts scrape  # Scrape usage (prefers live browser)",
+	);
+	console.log(
+		"  bun packages/auth/src/run-minimax-auth.ts stop    # Stop live browser daemon",
+	);
+	console.log(
+		"  bun packages/auth/src/run-minimax-auth.ts check   # Check status",
+	);
+	console.log("");
+	console.log("Security:");
+	console.log("- Human logs in manually in the browser");
+	console.log("- Playwright auto-saves persistent profile");
+	console.log("- No credentials are processed by this code");
+}
+
+main().catch((error) => {
+	console.error("Error:", error.message);
+	process.exit(1);
+});

package/packages/autonomous-refactor/src/detector.ts

@@ -0,0 +1,219 @@
+/**
+ * Autonomous Refactor — Pattern Detection (RFC-0092)
+ */
+
+import type { RefactorFinding, RiskLevel } from "./types.js";
+
+let findingCounter = 0;
+
+export function detectRefactorings(
+	files: Array<{ path: string; content: string }>,
+): RefactorFinding[] {
+	const findings: RefactorFinding[] = [];
+
+	for (const file of files) {
+		findings.push(...detectMagicLiterals(file));
+		findings.push(...detectLongFunctions(file));
+		findings.push(...detectNestedConditionals(file));
+		findings.push(...detectUnusedVariables(file));
+	}
+
+	return findings.sort((a, b) => b.confidence - a.confidence);
+}
+
+function detectMagicLiterals(file: {
+	path: string;
+	content: string;
+}): RefactorFinding[] {
+	const findings: RefactorFinding[] = [];
+	const lines = file.content.split("\n");
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (line.includes("//") || line.includes("/*")) continue;
+
+		const magicMatch = line.match(/\b([2-9]|[1-9]\d+)\b/g);
+		if (magicMatch && magicMatch.length > 0) {
+			findings.push({
+				id: `ref-${++findingCounter}-${Date.now()}`,
+				type: "replace-magic-literal",
+				file: file.path,
+				location: { line: i + 1, column: line.search(/\d/) + 1 },
+				description: `Magic number "${magicMatch[0]}" found`,
+				risk: "low",
+				confidence: 0.75,
+				rationale: [
+					"Magic numbers reduce readability",
+					"Named constants are self-documenting",
+				],
+			});
+		}
+
+		const strMatch = line.match(/'([^']{4,})'/g) || line.match(/"([^"]{4,})"/g);
+		if (strMatch && !strMatch.some((m) => m.toLowerCase().includes("url"))) {
+			findings.push({
+				id: `ref-${++findingCounter}-${Date.now()}`,
+				type: "replace-magic-literal",
+				file: file.path,
+				location: { line: i + 1, column: line.indexOf(strMatch[0]) + 1 },
+				description: `Magic string literal found`,
+				risk: "low",
+				confidence: 0.6,
+				rationale: ["String literals without context reduce clarity"],
+			});
+		}
+	}
+
+	return findings.slice(0, 5);
+}
+
+function detectLongFunctions(file: {
+	path: string;
+	content: string;
+}): RefactorFinding[] {
+	const findings: RefactorFinding[] = [];
+	const lines = file.content.split("\n");
+	const THRESHOLD = 30;
+	let braceDepth = 0;
+	let funcStart = -1;
+	// foundFunc removed, use funcStart < 0 as sentinel
+	let funcName = "anonymous";
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		braceDepth += (line.match(/\{/g) || []).length;
+		braceDepth -= (line.match(/\}/g) || []).length;
+
+		const funcMatch = line.match(
+			/(?:function\s+(\w+)|const\s+(\w+)\s*=|(\w+)\s*\([^)]*\)\s*\{)/,
+		);
+		// Only capture function start once — avoid re-matching const/arrow as functions
+		if (funcMatch && funcStart < 0) {
+			funcStart = i;
+			funcName = funcMatch[1] ?? funcMatch[2] ?? funcMatch[3] ?? "anonymous";
+		}
+
+		if (funcStart >= 0 && braceDepth === 0) {
+			const funcLength = i - funcStart + 1;
+			if (funcLength > THRESHOLD) {
+				findings.push({
+					id: `ref-${++findingCounter}-${Date.now()}`,
+					type: "extract-method",
+					file: file.path,
+					location: { line: funcStart + 1, column: 1 },
+					description: `Function "${funcName}" is ${funcLength} lines (threshold: ${THRESHOLD})`,
+					risk: "medium",
+					confidence: 0.7,
+					rationale: [
+						"Long functions are harder to test",
+						"Splitting improves single responsibility",
+						`Current length: ${funcLength} lines`,
+					],
+				});
+			}
+			funcStart = -1;
+		}
+	}
+
+	return findings;
+}
+
+function detectNestedConditionals(file: {
+	path: string;
+	content: string;
+}): RefactorFinding[] {
+	const findings: RefactorFinding[] = [];
+	const lines = file.content.split("\n");
+	let maxDepth = 0;
+	let currentDepth = 0;
+	let maxLine = 0;
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i].trim();
+		if (
+			line.startsWith("if") ||
+			line.startsWith("else if") ||
+			line.includes("?")
+		) {
+			currentDepth++;
+			if (currentDepth > maxDepth) {
+				maxDepth = currentDepth;
+				maxLine = i + 1;
+			}
+		}
+		if (line === "}" && currentDepth > 0) currentDepth--;
+	}
+
+	if (maxDepth > 3) {
+		findings.push({
+			id: `ref-${++findingCounter}-${Date.now()}`,
+			type: "simplify-conditional",
+			file: file.path,
+			location: { line: maxLine, column: 1 },
+			description: `${maxDepth} levels of nested conditionals detected`,
+			risk: "medium",
+			confidence: 0.65,
+			rationale: [
+				"Deep nesting reduces readability",
+				"Consider early returns or polymorphism",
+			],
+		});
+	}
+
+	return findings;
+}
+
+function detectUnusedVariables(file: {
+	path: string;
+	content: string;
+}): RefactorFinding[] {
+	const findings: RefactorFinding[] = [];
+	const lines = file.content.split("\n");
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const declMatch = line.match(/^\s*(const|let|var)\s+([a-zA-Z_]\w*)\s*=/);
+		if (!declMatch) continue;
+
+		const varName = declMatch[2];
+		const afterDecl = lines.slice(i + 1).join("\n");
+
+		// Count by splitting instead of regex to avoid ReDoS
+		const escaped = varName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		const pattern = new RegExp(`\\b${escaped}\\b`, "g");
+		const occurrences = (afterDecl.match(pattern) || []).length;
+
+		if (occurrences === 0 && !varName.startsWith("_")) {
+			findings.push({
+				id: `ref-${++findingCounter}-${Date.now()}`,
+				type: "rename-variable",
+				file: file.path,
+				location: { line: i + 1, column: line.indexOf(varName) + 1 },
+				description: `Variable "${varName}" appears unused after declaration`,
+				risk: "low",
+				confidence: 0.6,
+				rationale: ["Unused variables add noise", "Remove or use the variable"],
+			});
+		}
+	}
+
+	return findings;
+}
+
+export function assessRisk(finding: RefactorFinding): RiskLevel {
+	return finding.risk;
+}
+
+export function calculatePriority(finding: RefactorFinding): number {
+	const confidenceWeight = 0.4;
+	const riskWeight: Record<RiskLevel, number> = {
+		low: 0.2,
+		medium: 0.4,
+		high: 0.7,
+		critical: 1.0,
+	};
+	return (
+		finding.confidence * confidenceWeight +
+		(1 - finding.confidence) * riskWeight[finding.risk]
+	);
+}

package/packages/autonomous-refactor/src/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Autonomous Refactor — Main Entry (RFC-0092)
+ */
+
+export {
+	detectRefactorings,
+	assessRisk,
+	calculatePriority,
+} from "./detector.js";
+export {
+	createPlan,
+	filterByRisk,
+	groupByFile,
+	groupByType,
+} from "./planner.js";
+export type * from "./types.js";

package/packages/autonomous-refactor/src/planner.ts

@@ -0,0 +1,99 @@
+/**
+ * Autonomous Refactor — Planning Engine (RFC-0092)
+ */
+
+import type {
+	RefactorFinding,
+	RefactorPlan,
+	RefactorConfig,
+	RiskLevel,
+} from "./types.js";
+import { DEFAULT_CONFIG } from "./types.js";
+import { calculatePriority } from "./detector.js";
+
+export function createPlan(
+	findings: RefactorFinding[],
+	config?: Partial<RefactorConfig>,
+): RefactorPlan {
+	const cfg = { ...DEFAULT_CONFIG, ...config } as Required<RefactorConfig>;
+
+	const riskOrder: Record<RiskLevel, number> = {
+		low: 0,
+		medium: 1,
+		high: 2,
+		critical: 3,
+	};
+	const threshold = riskOrder[cfg.riskThreshold];
+
+	const filtered = findings.filter((f) => riskOrder[f.risk] <= threshold);
+	const sorted = [...filtered].sort(
+		(a, b) => calculatePriority(b) - calculatePriority(a),
+	);
+	const limited = sorted.slice(0, cfg.maxFindings);
+
+	const blockers: string[] = [];
+	if (cfg.preserveBehavior) {
+		blockers.push("All changes must preserve existing behavior");
+	}
+
+	const avgRisk =
+		limited.reduce((sum, f) => {
+			const riskMap: Record<RiskLevel, number> = {
+				low: 5,
+				medium: 15,
+				high: 30,
+				critical: 50,
+			};
+			return sum + (riskMap[f.risk] ?? 0);
+		}, 0) / Math.max(limited.length, 1);
+
+	return {
+		id: `plan-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+		findings: limited,
+		priorityOrder: limited.map((f) => f.id),
+		estimatedImpact: {
+			complexityReduction: Math.min(avgRisk, 40),
+			maintainabilityImprovement: avgRisk * 0.8,
+			riskExposure: avgRisk * 0.6,
+		},
+		blockers,
+	};
+}
+
+export function filterByRisk(
+	findings: RefactorFinding[],
+	maxRisk: RiskLevel,
+): RefactorFinding[] {
+	const riskOrder: Record<RiskLevel, number> = {
+		low: 0,
+		medium: 1,
+		high: 2,
+		critical: 3,
+	};
+	const threshold = riskOrder[maxRisk];
+	return findings.filter((f) => riskOrder[f.risk] <= threshold);
+}
+
+export function groupByFile(
+	findings: RefactorFinding[],
+): Map<string, RefactorFinding[]> {
+	const groups = new Map<string, RefactorFinding[]>();
+	for (const f of findings) {
+		const existing = groups.get(f.file) ?? [];
+		existing.push(f);
+		groups.set(f.file, existing);
+	}
+	return groups;
+}
+
+export function groupByType(
+	findings: RefactorFinding[],
+): Map<RefactorFinding["type"], RefactorFinding[]> {
+	const groups = new Map<RefactorFinding["type"], RefactorFinding[]>();
+	for (const f of findings) {
+		const existing = groups.get(f.type) ?? [];
+		existing.push(f);
+		groups.set(f.type, existing);
+	}
+	return groups;
+}

package/packages/autonomous-refactor/src/types.ts

@@ -0,0 +1,57 @@
+/**
+ * Autonomous Refactor — Types (RFC-0092)
+ */
+
+export type RefactorType =
+	| "extract-method"
+	| "inline-method"
+	| "rename-variable"
+	| "move-function"
+	| "extract-interface"
+	| "replace-loop-pipeline"
+	| "introduce-null-object"
+	| "extract-superclass"
+	| "simplify-conditional"
+	| "replace-magic-literal";
+
+export type RiskLevel = "low" | "medium" | "high" | "critical";
+
+export interface RefactorFinding {
+	id: string;
+	type: RefactorType;
+	file: string;
+	location: { line: number; column: number };
+	description: string;
+	risk: RiskLevel;
+	confidence: number;
+	suggestedFix?: string;
+	rationale?: string[];
+}
+
+export interface RefactorPlan {
+	id: string;
+	findings: RefactorFinding[];
+	priorityOrder: string[];
+	estimatedImpact: {
+		complexityReduction: number;
+		maintainabilityImprovement: number;
+		riskExposure: number;
+	};
+	blockers: string[];
+}
+
+export interface RefactorConfig {
+	maxFindings: number;
+	riskThreshold: RiskLevel;
+	autoApply: boolean;
+	requireReviewAbove: RiskLevel;
+	preserveBehavior: boolean;
+}
+
+export const DEFAULT_CONFIG: Required<RefactorConfig> = {
+	maxFindings: 50,
+	riskThreshold: "medium",
+	autoApply: false,
+	requireReviewAbove: "high",
+	preserveBehavior: true,
+};