pi-harness-runtime 0.9.19 → 0.9.21

package/packages/workspace-scanner/src/detect.ts

@@ -0,0 +1,77 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { ProjectConfig } from "./types.js";
+
+export function detectProject(rootPath: string): ProjectConfig {
+	const config: ProjectConfig = {};
+
+	// Node.js detection
+	const packageJsonPath = join(rootPath, "package.json");
+	if (existsSync(packageJsonPath)) {
+		try {
+			const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8")) as Record<
+				string,
+				unknown
+			>;
+			if (pkg.name) config.name = String(pkg.name);
+			config.language = "TypeScript";
+			if (pkg.workspaces) config.packageManager = "npm";
+			if (existsSync(join(rootPath, "pnpm-lock.yaml")))
+				config.packageManager = "pnpm";
+			if (existsSync(join(rootPath, "yarn.lock")))
+				config.packageManager = "yarn";
+			if (existsSync(join(rootPath, "bun.lockb")))
+				config.packageManager = "bun";
+		} catch {
+			/* ignore */
+		}
+	}
+
+	// Python detection
+	if (
+		existsSync(join(rootPath, "pyproject.toml")) ||
+		existsSync(join(rootPath, "setup.py"))
+	) {
+		config.language = "Python";
+		config.packageManager = "pip";
+	}
+
+	// Go detection
+	if (existsSync(join(rootPath, "go.mod"))) {
+		config.language = "Go";
+		config.packageManager = "go";
+	}
+
+	// Rust detection
+	if (existsSync(join(rootPath, "Cargo.toml"))) {
+		config.language = "Rust";
+		config.packageManager = "cargo";
+	}
+
+	// Frappe/ERPNext detection
+	if (
+		existsSync(join(rootPath, "sites")) ||
+		existsSync(join(rootPath, "apps")) ||
+		existsSync(join(rootPath, "hooks.py"))
+	) {
+		config.framework = "frappe";
+	}
+
+	// Next.js detection
+	if (
+		existsSync(join(rootPath, "next.config.js")) ||
+		existsSync(join(rootPath, "next.config.ts"))
+	) {
+		config.framework = "nextjs";
+	}
+
+	// Vite detection
+	if (
+		existsSync(join(rootPath, "vite.config.js")) ||
+		existsSync(join(rootPath, "vite.config.ts"))
+	) {
+		config.buildTool = "vite";
+	}
+
+	return config;
+}

package/packages/workspace-scanner/src/git.ts

@@ -0,0 +1,83 @@
+/**
+ * Workspace Scanner — Git State Detection
+ */
+
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type { GitState } from "./types.js";
+
+export function isGitRepo(rootPath: string): boolean {
+	return existsSync(join(rootPath, ".git"));
+}
+
+export function getGitState(rootPath: string): GitState | null {
+	if (!isGitRepo(rootPath)) return null;
+
+	try {
+		const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+			cwd: rootPath,
+			encoding: "utf8",
+			stdio: ["ignore", "pipe", "ignore"],
+		}).trim();
+
+		const status = execSync("git status --porcelain", {
+			cwd: rootPath,
+			encoding: "utf8",
+			stdio: ["ignore", "pipe", "ignore"],
+		}).trim();
+
+		const lines = status.split("\n").filter(Boolean);
+		const modified: string[] = [];
+		const untracked: string[] = [];
+
+		for (const line of lines) {
+			if (line.startsWith("?? ")) {
+				untracked.push(line.slice(3));
+			} else if (line.length >= 3) {
+				modified.push(line.slice(3));
+			}
+		}
+
+		let ahead = 0;
+		let behind = 0;
+		try {
+			const revlist = execSync(
+				"git rev-list --left-right --count HEAD@{upstream}...HEAD",
+				{
+					cwd: rootPath,
+					encoding: "utf8",
+					stdio: ["ignore", "pipe", "ignore"],
+				},
+			).trim();
+			const [a, b] = revlist.split("\t");
+			ahead = parseInt(a, 10) || 0;
+			behind = parseInt(b, 10) || 0;
+		} catch {
+			// upstream not configured
+		}
+
+		let lastCommitAt: string | undefined;
+		try {
+			lastCommitAt = execSync("git log -1 --format=%aI", {
+				cwd: rootPath,
+				encoding: "utf8",
+				stdio: ["ignore", "pipe", "ignore"],
+			}).trim();
+		} catch {
+			// no commits
+		}
+
+		return {
+			branch,
+			isDirty: modified.length > 0 || untracked.length > 0,
+			modified,
+			untracked,
+			ahead,
+			behind,
+			lastCommitAt,
+		};
+	} catch {
+		return null;
+	}
+}

package/packages/workspace-scanner/src/index.ts

@@ -0,0 +1,9 @@
+export type {
+	WorkspaceSnapshot,
+	GitState,
+	ProjectConfig,
+	ScannerOptions,
+} from "./types.js";
+export { WorkspaceScanner, scanWorkspace } from "./scanner.js";
+export { getGitState, isGitRepo } from "./git.js";
+export { detectProject } from "./detect.js";

package/packages/workspace-scanner/src/scanner.ts

@@ -0,0 +1,73 @@
+/**
+ * Workspace Scanner — Main Scanner
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getGitState, isGitRepo } from "./git.js";
+import { detectProject } from "./detect.js";
+import type {
+	ProjectConfig,
+	ScannerOptions,
+	WorkspaceSnapshot,
+} from "./types.js";
+
+export class WorkspaceScanner {
+	private root: string;
+
+	constructor(root: string) {
+		this.root = root;
+	}
+
+	async scan(opts: ScannerOptions = {}): Promise<WorkspaceSnapshot> {
+		const rootPath = opts.rootPath ?? this.root;
+
+		const hasGit = isGitRepo(rootPath);
+		const git = !opts.skipGit && hasGit ? getGitState(rootPath) : null;
+		const project: ProjectConfig = opts.skipConfig
+			? {}
+			: detectProject(rootPath);
+
+		const envFiles: string[] = [];
+		const configFiles: string[] = [];
+
+		if (!opts.skipConfig) {
+			for (const name of [
+				".env",
+				".env.local",
+				".env.example",
+				".env.production",
+			]) {
+				if (existsSync(join(rootPath, name))) envFiles.push(name);
+			}
+			for (const name of [
+				"tsconfig.json",
+				"jsconfig.json",
+				"vite.config.ts",
+				"next.config.js",
+				"nuxt.config.ts",
+				"eslint.config.js",
+			]) {
+				if (existsSync(join(rootPath, name))) configFiles.push(name);
+			}
+		}
+
+		return {
+			root: rootPath,
+			git,
+			project,
+			envFiles,
+			configFiles,
+			hasGit,
+			hasNode: existsSync(join(rootPath, "package.json")),
+			hasPython: existsSync(join(rootPath, "pyproject.toml")),
+		};
+	}
+}
+
+export function scanWorkspace(
+	rootPath: string,
+	opts: ScannerOptions = {},
+): Promise<WorkspaceSnapshot> {
+	return new WorkspaceScanner(rootPath).scan(opts);
+}

package/packages/workspace-scanner/src/types.ts

@@ -0,0 +1,48 @@
+/**
+ * Workspace Scanner — Types
+ */
+
+export interface GitState {
+	branch: string;
+	isDirty: boolean;
+	modified: string[];
+	untracked: string[];
+	ahead: number;
+	behind: number;
+	lastCommitAt?: string;
+}
+
+export interface ProjectConfig {
+	name?: string;
+	packageManager?:
+		| "npm"
+		| "pnpm"
+		| "yarn"
+		| "bun"
+		| "pip"
+		| "go"
+		| "cargo"
+		| "maven"
+		| "gradle"
+		| "composer";
+	language?: string;
+	framework?: string;
+	buildTool?: string;
+}
+
+export interface ScannerOptions {
+	rootPath?: string;
+	skipGit?: boolean;
+	skipConfig?: boolean;
+}
+
+export interface WorkspaceSnapshot {
+	root: string;
+	git: GitState | null;
+	project: ProjectConfig;
+	envFiles: string[];
+	configFiles: string[];
+	hasGit: boolean;
+	hasNode: boolean;
+	hasPython: boolean;
+}

package/packages/workspace-scanner/test/scanner.test.js

@@ -0,0 +1,31 @@
+import { describe, it } from "node:test";
+import { equal } from "node:assert";
+import { WorkspaceScanner } from "../src/scanner.js";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+describe("WorkspaceScanner", () => {
+    const testDir = join(tmpdir(), "ws-scanner-test-" + Date.now());
+    mkdirSync(testDir, { recursive: true });
+    writeFileSync(join(testDir, "package.json"), JSON.stringify({ name: "test", scripts: { dev: "vite" } }));
+    const scanner = new WorkspaceScanner(testDir);
+    it("scans workspace with git state", async () => {
+        const snapshot = await scanner.scan();
+        equal(typeof snapshot.root, "string");
+        equal(typeof snapshot.hasGit, "boolean");
+        equal(typeof snapshot.hasNode, "boolean");
+    });
+    it("skips git when requested", async () => {
+        const snapshot = await scanner.scan({ skipGit: true });
+        equal(snapshot.git, null);
+    });
+    it("skips config when requested", async () => {
+        const snapshot = await scanner.scan({ skipConfig: true });
+        equal(snapshot.project, {});
+    });
+    it("detects package.json", async () => {
+        const snapshot = await scanner.scan();
+        equal(snapshot.hasNode, true);
+    });
+    rmSync(testDir, { recursive: true, force: true });
+});

package/packages/workspace-scanner/test/scanner.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import { equal } from "node:assert";
+import { join } from "node:path";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { WorkspaceScanner } from "../src/scanner.js";
+
+describe("WorkspaceScanner", () => {
+	const testDir = join(tmpdir(), "ws-test-" + Date.now());
+	beforeEach(() => mkdirSync(testDir, { recursive: true }));
+	afterEach(() => rmSync(testDir, { recursive: true, force: true }));
+
+	it("detects package.json", async () => {
+		writeFileSync(
+			join(testDir, "package.json"),
+			JSON.stringify({ name: "test" }),
+		);
+		const scanner = new WorkspaceScanner(testDir);
+		const snap = await scanner.scan();
+		equal(snap.hasNode, true);
+	});
+
+	it("skips git when requested", async () => {
+		const scanner = new WorkspaceScanner(testDir);
+		const snap = await scanner.scan({ skipGit: true });
+		equal(snap.git, null);
+	});
+
+	it("skips config when requested", async () => {
+		const scanner = new WorkspaceScanner(testDir);
+		const snap = await scanner.scan({ skipConfig: true });
+		equal(snap.project, {});
+		equal(snap.configFiles.length, 0);
+	});
+
+	it("detects env files", async () => {
+		writeFileSync(join(testDir, ".env.local"), "SECRET=x");
+		const scanner = new WorkspaceScanner(testDir);
+		const snap = await scanner.scan({ skipConfig: false });
+		equal(snap.envFiles.includes(".env.local"), true);
+	});
+});

package/packages/workspace-scanner/tsconfig.json

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