pi-harness-runtime 0.9.2 → 0.9.5

package/packages/django-plugin/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@pi/django-plugin",
+  "version": "0.9.5",
+  "description": "Django framework analysis — models, management commands, settings",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test"
+  },
+  "dependencies": {},
+  "devDependencies": {}
+}

package/packages/django-plugin/src/analyzer.ts

@@ -0,0 +1,284 @@
+/**
+ * Django Analyzer (RFC-0064)
+ *
+ * Deep analysis of Django workspaces via filesystem inspection.
+ */
+
+import { existsSync } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { DjangoAnalysis, DjangoApp, ConfigFile } from "./types.js";
+
+// ─── Detection ───────────────────────────────────────────────────────────────
+
+function isDjangoWorkspace(root: string): boolean {
+	return (
+		existsSync(join(root, "manage.py")) ||
+		(existsSync(join(root, "settings.py")) &&
+			existsSync(join(root, "requirements.txt"))) ||
+		(existsSync(join(root, "requirements.txt")) &&
+			existsSync(join(root, "manage.py")))
+	);
+}
+
+// ─── Version ────────────────────────────────────────────────────────────────
+
+async function detectVersion(root: string): Promise<string | undefined> {
+	try {
+		const content = await readFile(join(root, "requirements.txt"), "utf-8");
+		const match = content.match(/Django[=<>~!^]*((\d+)\.\d+(?:\.\d+)?)/i);
+		if (match) return match[1];
+	} catch {
+		/* ignore */
+	}
+
+	// Check setup.py or pyproject.toml
+	for (const cfg of ["setup.py", "pyproject.toml"]) {
+		const cfgPath = join(root, cfg);
+		if (existsSync(cfgPath)) {
+			try {
+				const content = await readFile(cfgPath, "utf-8");
+				const match = content.match(/django[=<>~!^\s]*(\d+\.\d+(?:\.\d+)?)/i);
+				if (match) return match[1];
+			} catch {
+				/* ignore */
+			}
+		}
+	}
+	return undefined;
+}
+
+// ─── Settings Parser ─────────────────────────────────────────────────────────
+
+async function parseSettings(root: string): Promise<{
+	installedApps: string[];
+	middleware: string[];
+}> {
+	const installedApps: string[] = [];
+	const middleware: string[] = [];
+
+	const candidates = [
+		join(root, "settings.py"),
+		join(root, "core", "settings.py"),
+		join(root, "config", "settings.py"),
+	];
+
+	for (const settingsPath of candidates) {
+		if (!existsSync(settingsPath)) continue;
+		try {
+			const content = await readFile(settingsPath, "utf-8");
+
+			// Parse INSTALLED_APPS = [ ... ]
+			const installedMatch = content.match(
+				/INSTALLED_APPS\s*=\s*\[([\s\S]*?)\]/m,
+			);
+			if (installedMatch) {
+				const listContent = installedMatch[1];
+				// Match quoted strings and identifiers
+				const appMatches = listContent.matchAll(
+					/(?:^|\s|,)\s*['"]?([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)['"]?/g,
+				);
+				for (const m of appMatches) {
+					const app = m[1].trim();
+					if (app && !app.startsWith("#")) {
+						installedApps.push(app);
+					}
+				}
+			}
+
+			// Parse MIDDLEWARE = [ ... ]
+			const middlewareMatch = content.match(/MIDDLEWARE\s*=\s*\[([\s\S]*?)\]/m);
+			if (middlewareMatch) {
+				const listContent = middlewareMatch[1];
+				const mwMatches = listContent.matchAll(
+					/(?:^|\s|,)\s*['"]?([a-zA-Z_][a-zA-Z0-9_.]*)['"]?/g,
+				);
+				for (const m of mwMatches) {
+					const mw = m[1].trim();
+					if (mw && !mw.startsWith("#")) {
+						middleware.push(mw);
+					}
+				}
+			}
+
+			if (installedApps.length > 0) break;
+		} catch {
+			// ignore
+		}
+	}
+
+	return { installedApps, middleware };
+}
+
+// ─── Django App Scanner ─────────────────────────────────────────────────────
+
+async function scanDjangoApps(root: string): Promise<DjangoApp[]> {
+	const apps: DjangoApp[] = [];
+
+	// Django project apps can be:
+	// 1. Top-level directories with models.py
+	// 2. Apps in an "apps/" directory
+	const searchDirs = [root, join(root, "apps")];
+
+	const seen = new Set<string>();
+
+	for (const searchDir of searchDirs) {
+		if (!existsSync(searchDir)) continue;
+		let entries: string[] = [];
+		try {
+			entries = await readdir(searchDir);
+		} catch {
+			continue;
+		}
+
+		for (const entry of entries) {
+			if (entry.startsWith(".") || entry.startsWith("_")) continue;
+			const appPath = join(searchDir, entry);
+			let isDir = false;
+			try {
+				isDir = (
+					await import("node:fs/promises").then((m) => m.stat(appPath))
+				).isDirectory();
+			} catch {
+				continue;
+			}
+			if (!isDir) continue;
+			if (seen.has(entry)) continue;
+			seen.add(entry);
+
+			const modelsPath = join(appPath, "models.py");
+			const adminPath = join(appPath, "admin.py");
+			const migrationsDir = join(appPath, "migrations");
+
+			let modelCount = 0;
+			if (existsSync(modelsPath)) {
+				try {
+					const modelsContent = await readFile(modelsPath, "utf-8");
+					// Count class definitions that inherit from models.Model
+					const match1 = modelsContent.match(
+						/^class\s+\w+\s*\([^)]*models?\.[Mm]odel[^)]*\)/gm,
+					);
+					modelCount = (match1 ?? []).length;
+					// Also count class definitions (conservative)
+					const match2 = modelsContent.match(/class\s+\w+\s*\(/g);
+					modelCount = Math.max(modelCount, (match2 ?? []).length);
+				} catch {
+					// ignore
+				}
+			}
+
+			apps.push({
+				name: entry,
+				path: appPath,
+				modelCount,
+				hasAdmin: existsSync(adminPath),
+				hasMigrations: existsSync(migrationsDir),
+			});
+		}
+	}
+
+	return apps;
+}
+
+// ─── Management Commands ────────────────────────────────────────────────────
+
+async function findManagementCommands(root: string): Promise<string[]> {
+	const commands: string[] = [];
+
+	// Simple recursive scan for management/commands directories
+	const searchDirs: string[] = [];
+	try {
+		const entries = await readdir(root);
+		for (const entry of entries) {
+			if (entry.startsWith(".")) continue;
+			const managementDir = join(root, entry, "management", "commands");
+			if (existsSync(managementDir)) {
+				searchDirs.push(managementDir);
+			}
+			const appsMgmt = join(root, "apps", entry, "management", "commands");
+			if (existsSync(appsMgmt)) {
+				searchDirs.push(appsMgmt);
+			}
+		}
+	} catch {
+		// ignore
+	}
+
+	for (const cmdDir of searchDirs) {
+		try {
+			const cmdEntries = await readdir(cmdDir);
+			for (const cmd of cmdEntries) {
+				if (cmd.startsWith("_") || !cmd.endsWith(".py")) continue;
+				commands.push(cmd.replace(/\.py$/, ""));
+			}
+		} catch {
+			// ignore
+		}
+	}
+
+	return [...new Set(commands)];
+}
+
+// ─── Requirements ───────────────────────────────────────────────────────────
+
+async function parseRequirements(root: string): Promise<string[]> {
+	const reqPath = join(root, "requirements.txt");
+	if (!existsSync(reqPath)) return [];
+
+	try {
+		const content = await readFile(reqPath, "utf-8");
+		return content
+			.split("\n")
+			.map((l) => l.trim())
+			.filter((l) => l && !l.startsWith("#") && !l.startsWith("-"))
+			.map((l) => l.split(/[=<>~!^]/)[0].trim());
+	} catch {
+		return [];
+	}
+}
+
+// ─── Main Analyzer ─────────────────────────────────────────────────────────
+
+export async function analyzeDjango(
+	root: string,
+): Promise<DjangoAnalysis | null> {
+	if (!isDjangoWorkspace(root)) return null;
+
+	const [version, settings, requirements] = await Promise.all([
+		detectVersion(root),
+		parseSettings(root),
+		parseRequirements(root),
+	]);
+
+	const apps = await scanDjangoApps(root);
+	const managementCommands = await findManagementCommands(root);
+	const drfEnabled =
+		requirements.some((r) => r.toLowerCase().includes("djangorestframework")) ||
+		settings.installedApps.some((a) => a.includes("rest_framework"));
+
+	// Config files
+	const configs: ConfigFile[] = [];
+	for (const cfg of ["settings.py", "urls.py", "wsgi.py", "manage.py"]) {
+		const p = join(root, cfg);
+		if (existsSync(p)) {
+			configs.push({ name: cfg, path: p });
+		}
+	}
+
+	return {
+		framework: {
+			id: "django",
+			name: "Django",
+			category: "fullstack",
+			description: "Python web framework for perfectionists with deadlines",
+			tags: ["python", "fullstack", "orm"],
+		},
+		version,
+		apps,
+		managementCommands,
+		middleware: settings.middleware,
+		drfEnabled,
+		requirements,
+		configs,
+	};
+}

package/packages/django-plugin/src/index.ts

@@ -0,0 +1,39 @@
+/**
+ * Django Plugin — Main Entry (RFC-0064)
+ */
+
+import type { FrameworkExtension } from "../../framework-plugin-sdk/src/types.js";
+import { analyzeDjango } from "./analyzer.js";
+
+export type { DjangoAnalysis, DjangoApp, ConfigFile } from "./types.js";
+
+export async function analyzeDjangoWorkspace(
+	root: string,
+): Promise<import("./types.js").DjangoAnalysis | null> {
+	return analyzeDjango(root);
+}
+
+export function createDjangoPlugin(): FrameworkExtension {
+	return {
+		capability: "framework",
+		name: "Django Framework Plugin",
+		detector: {
+			detect: async (root: unknown): Promise<unknown> => {
+				const r = root as string;
+				const { existsSync } = await import("node:fs");
+				return (
+					existsSync(`${r}/manage.py`) ||
+					(existsSync(`${r}/settings.py`) &&
+						existsSync(`${r}/requirements.txt`))
+				);
+			},
+			signals: [
+				{ type: "file", pattern: "manage.py", weight: 0.6 },
+				{ type: "file", pattern: "settings.py", weight: 0.4 },
+				{ type: "package", pattern: "django", weight: 0.5 },
+				{ type: "directory", pattern: "migrations", weight: 0.3 },
+			],
+		},
+		config: {},
+	};
+}

package/packages/django-plugin/src/types.ts

@@ -0,0 +1,35 @@
+/**
+ * Django Plugin — Types (RFC-0064)
+ */
+
+export interface DjangoAnalysis {
+	framework: FrameworkInfo;
+	version?: string;
+	apps: DjangoApp[];
+	managementCommands: string[];
+	middleware: string[];
+	drfEnabled: boolean;
+	requirements: string[];
+	configs: ConfigFile[];
+}
+
+export interface FrameworkInfo {
+	id: string;
+	name: string;
+	category: string;
+	description: string;
+	tags: string[];
+}
+
+export interface DjangoApp {
+	name: string;
+	path: string;
+	modelCount: number;
+	hasAdmin: boolean;
+	hasMigrations: boolean;
+}
+
+export interface ConfigFile {
+	name: string;
+	path: string;
+}

package/packages/django-plugin/test/analyzer.test.ts

@@ -0,0 +1,195 @@
+/**
+ * Django Plugin Tests (RFC-0064)
+ */
+
+import { describe, it, expect, afterEach } from "bun:test";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import { analyzeDjango } from "../src/analyzer.js";
+
+const roots: string[] = [];
+
+async function mkdtemp(): Promise<string> {
+	const d = await fs.mkdtemp(path.join(os.tmpdir(), "django-plugin-"));
+	roots.push(d);
+	return d;
+}
+
+afterEach(async () => {
+	for (const d of roots) {
+		try {
+			await fs.rm(d, { recursive: true, force: true });
+		} catch {
+			/* ignore */
+		}
+	}
+	roots.length = 0;
+});
+
+describe("analyzeDjango", () => {
+	it("returns null for non-django workspace", async () => {
+		const dir = await mkdtemp();
+		await fs.writeFile(path.join(dir, "package.json"), "{}", "utf-8");
+		expect(await analyzeDjango(dir)).toBeNull();
+	});
+
+	it("detects django workspace via manage.py", async () => {
+		const dir = await mkdtemp();
+		await fs.writeFile(
+			path.join(dir, "manage.py"),
+			"#!/usr/bin/env python",
+			"utf-8",
+		);
+		await fs.writeFile(
+			path.join(dir, "requirements.txt"),
+			"django>=4.0\ndjangorestframework",
+			"utf-8",
+		);
+		const result = await analyzeDjango(dir);
+		expect(result).not.toBeNull();
+		expect(result!.framework.id).toBe("django");
+	});
+
+	it("detects django workspace via settings.py", async () => {
+		const dir = await mkdtemp();
+		await fs.writeFile(path.join(dir, "settings.py"), "DEBUG = True", "utf-8");
+		await fs.writeFile(
+			path.join(dir, "requirements.txt"),
+			"django>=4.0",
+			"utf-8",
+		);
+		const result = await analyzeDjango(dir);
+		expect(result).not.toBeNull();
+	});
+
+	it("extracts version from requirements.txt", async () => {
+		const dir = await mkdtemp();
+		await fs.writeFile(
+			path.join(dir, "manage.py"),
+			"#!/usr/bin/env python",
+			"utf-8",
+		);
+		await fs.writeFile(
+			path.join(dir, "requirements.txt"),
+			"django==4.2.10\ndjangorestframework==3.14.0",
+			"utf-8",
+		);
+		const result = await analyzeDjango(dir);
+		expect(result!.version).toBe("4.2.10");
+	});
+
+	it("parses INSTALLED_APPS from settings.py", async () => {
+		const dir = await mkdtemp();
+		await fs.writeFile(
+			path.join(dir, "settings.py"),
+			`
+INSTALLED_APPS = [
+    'django.contrib.admin',
+    'django.contrib.auth',
+    'rest_framework',
+    'myapp.core',
+]
+MIDDLEWARE = [
+    'django.middleware.security.SecurityMiddleware',
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.middleware.common.CommonMiddleware',
+]
+`.trim(),
+			"utf-8",
+		);
+		await fs.writeFile(
+			path.join(dir, "requirements.txt"),
+			"django>=4.0",
+			"utf-8",
+		);
+		const result = await analyzeDjango(dir);
+		expect(result!.middleware).toContain(
+			"django.middleware.security.SecurityMiddleware",
+		);
+	});
+
+	it("detects Django REST Framework", async () => {
+		const dir = await mkdtemp();
+		await fs.writeFile(
+			path.join(dir, "settings.py"),
+			`
+INSTALLED_APPS = [
+    'django.contrib.admin',
+    'rest_framework',
+]
+`.trim(),
+			"utf-8",
+		);
+		await fs.writeFile(
+			path.join(dir, "requirements.txt"),
+			"django>=4.0\ndjangorestframework",
+			"utf-8",
+		);
+		const result = await analyzeDjango(dir);
+		expect(result!.drfEnabled).toBe(true);
+	});
+
+	it("counts model classes in app models.py", async () => {
+		const dir = await mkdtemp();
+		await fs.mkdir(path.join(dir, "myapp"), { recursive: true });
+		await fs.writeFile(
+			path.join(dir, "settings.py"),
+			"INSTALLED_APPS = []",
+			"utf-8",
+		);
+		await fs.writeFile(
+			path.join(dir, "requirements.txt"),
+			"django>=4.0",
+			"utf-8",
+		);
+		await fs.writeFile(
+			path.join(dir, "myapp", "models.py"),
+			`
+from django.db import models
+
+class Customer(models.Model):
+    name = models.CharField(max_length=100)
+
+class Order(models.Model):
+    customer = models.ForeignKey(Customer, on_delete=models.CASCADE)
+`,
+			"utf-8",
+		);
+		const result = await analyzeDjango(dir);
+		const myApp = result!.apps.find((a) => a.name === "myapp");
+		expect(myApp).toBeDefined();
+		// Conservative: at least 2 classes detected
+		expect(myApp!.modelCount).toBeGreaterThanOrEqual(2);
+	});
+
+	it("finds management commands", async () => {
+		const dir = await mkdtemp();
+		await fs.mkdir(path.join(dir, "myapp", "management", "commands"), {
+			recursive: true,
+		});
+		await fs.writeFile(
+			path.join(dir, "settings.py"),
+			"INSTALLED_APPS = []",
+			"utf-8",
+		);
+		await fs.writeFile(
+			path.join(dir, "requirements.txt"),
+			"django>=4.0",
+			"utf-8",
+		);
+		await fs.writeFile(
+			path.join(dir, "myapp", "management", "commands", "send_email.py"),
+			"# management command",
+			"utf-8",
+		);
+		await fs.writeFile(
+			path.join(dir, "myapp", "management", "commands", "cleanup.py"),
+			"# cleanup",
+			"utf-8",
+		);
+		const result = await analyzeDjango(dir);
+		expect(result!.managementCommands).toContain("send_email");
+		expect(result!.managementCommands).toContain("cleanup");
+	});
+});

package/packages/django-plugin/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "references": [
+    { "path": "../framework-plugin-sdk" },
+    { "path": "../framework-detector" }
+  ]
+}

package/packages/doc-generator/dist/detector.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Doc Generator — Project Detection (RFC-0014)
+ */
+import type { ProjectDetection } from "./types.js";
+/** Detect project type from a list of file paths. */
+export declare function detectProjectType(filePaths: string[]): ProjectDetection;
+/** Parse signals from a directory listing. */
+export declare function parseSignals(entries: string[]): string[];
+//# sourceMappingURL=detector.d.ts.map

package/packages/doc-generator/dist/detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector.d.ts","sourceRoot":"","sources":["../src/detector.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAe,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAiEhE,qDAAqD;AACrD,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,gBAAgB,CAqCvE;AAED,8CAA8C;AAC9C,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAExD"}

package/packages/doc-generator/dist/detector.js

@@ -0,0 +1,98 @@
+/**
+ * Doc Generator — Project Detection (RFC-0014)
+ */
+const SIGNALS = {
+    frappe_erpnext: [
+        { pattern: /frappe-bench|hooks\.py/, weight: 0.3 },
+        { pattern: /doctype[/\\]/, weight: 0.4 },
+        { pattern: /\bapps\/[^/]+\/[^/]+\.py\b/, weight: 0.2 },
+    ],
+    frappe_spa: [
+        { pattern: /frappe-bench\/apps\/[^/]+\/frontend/, weight: 0.4 },
+        { pattern: /vite\.config\./, weight: 0.3 },
+        { pattern: /frappe\.call|frappe\.ui\./, weight: 0.3 },
+    ],
+    nextjs: [
+        { pattern: /next\.config\./, weight: 0.4 },
+        { pattern: /\/(app|pages)\/[^/]+\.(tsx|jsx|ts|js)/, weight: 0.3 },
+        { pattern: /"next"|'next'/, weight: 0.2 },
+    ],
+    react_vite: [
+        { pattern: /vite\.config\.(ts|js|mjs)/, weight: 0.4 },
+        { pattern: /src\/main\.(tsx|jsx)/, weight: 0.3 },
+        { pattern: /index\.html/, weight: 0.2 },
+    ],
+    django: [
+        { pattern: /manage\.py/, weight: 0.4 },
+        { pattern: /settings\.py/, weight: 0.3 },
+        { pattern: /models?\.py/, weight: 0.2 },
+    ],
+    laravel: [
+        { pattern: /artisan/, weight: 0.4 },
+        { pattern: /database\/seeders/, weight: 0.3 },
+        { pattern: /composer\.json/, weight: 0.2 },
+    ],
+    generic_web: [
+        { pattern: /package\.json/, weight: 0.2 },
+        { pattern: /index\.(html?|js|ts)/, weight: 0.2 },
+    ],
+    unknown: [],
+};
+const SEED_STRATEGIES = {
+    frappe_erpnext: "frappe_doc_insert",
+    frappe_spa: "frappe_fixtures",
+    nextjs: "nextjs_factory",
+    react_vite: "vite_seed",
+    django: "django_migrations",
+    laravel: "laravel_seeders",
+    generic_web: "generic_faker",
+    unknown: "generic_faker",
+};
+const E2E_STRATEGIES = {
+    frappe_erpnext: "bench_site_browser_flow",
+    frappe_spa: "api_plus_spa_flow",
+    nextjs: "nextjs_dev_server_flow",
+    react_vite: "vite_dev_server_flow",
+    django: "django_test_client_flow",
+    laravel: "laravel_dusk_flow",
+    generic_web: "playwright_generic_flow",
+    unknown: "playwright_generic_flow",
+};
+/** Detect project type from a list of file paths. */
+export function detectProjectType(filePaths) {
+    const scores = {
+        frappe_erpnext: 0,
+        frappe_spa: 0,
+        nextjs: 0,
+        react_vite: 0,
+        django: 0,
+        laravel: 0,
+        generic_web: 0,
+        unknown: 0,
+    };
+    const signals = [];
+    for (const filePath of filePaths) {
+        for (const [pType, pSignals] of Object.entries(SIGNALS)) {
+            for (const { pattern, weight } of pSignals) {
+                if (pattern.test(filePath)) {
+                    scores[pType] += weight;
+                    signals.push(filePath);
+                }
+            }
+        }
+    }
+    const best = Object.entries(scores).sort((a, b) => b[1] - a[1])[0];
+    const projectType = best[1] > 0 ? best[0] : "unknown";
+    return {
+        projectType,
+        confidence: Math.min(best[1], 1),
+        signals: [...new Set(signals)],
+        recommendedSeedStrategy: SEED_STRATEGIES[projectType],
+        recommendedE2EStrategy: E2E_STRATEGIES[projectType],
+    };
+}
+/** Parse signals from a directory listing. */
+export function parseSignals(entries) {
+    return entries.filter((e) => /[./]/.test(e));
+}
+//# sourceMappingURL=detector.js.map