pi-harness-runtime 0.10.7 → 0.10.11

package/packages/intent-analyzer/src/analyzer.ts

@@ -1,259 +0,0 @@
-/**
- * Intent Analyzer — Analyzer
- *
- * Keyword-based intent detection.
- */
-
-import type {
-	Intent,
-	IntentConfidence,
-	IntentKind,
-	IntentRule,
-	IntentSignal,
-} from "./types.js";
-
-const INTENT_RULES: IntentRule[] = [
-	{
-		kind: "bug_fix",
-		keywords: [
-			"fix",
-			"bug",
-			"error",
-			"crash",
-			"fail",
-			"broken",
-			"issue",
-			"defect",
-			"patch",
-			"hotfix",
-		],
-		weight: 2,
-		confidence: "high",
-	},
-	{
-		kind: "feature",
-		keywords: ["add", "implement", "new", "create", "build", "introduce"],
-		weight: 2,
-		confidence: "high",
-	},
-	{
-		kind: "refactor",
-		keywords: [
-			"refactor",
-			"rename",
-			"move",
-			"extract",
-			"restructure",
-			"cleanup",
-			"simplify",
-			"rewrite",
-		],
-		weight: 2,
-		confidence: "high",
-	},
-	{
-		kind: "code_review",
-		keywords: [
-			"review",
-			"check code",
-			"audit",
-			"critique",
-			"evaluate",
-			"assess",
-		],
-		weight: 2,
-		confidence: "high",
-	},
-	{
-		kind: "deployment",
-		keywords: [
-			"deploy",
-			"release",
-			"publish",
-			"ship",
-			"launch",
-			"rollout",
-			"promote",
-		],
-		weight: 2,
-		confidence: "high",
-	},
-	{
-		kind: "testing",
-		keywords: [
-			"test",
-			"spec",
-			"coverage",
-			"unit test",
-			"integration test",
-			"e2e",
-			"specify",
-		],
-		weight: 2,
-		confidence: "high",
-	},
-	{
-		kind: "documentation",
-		keywords: [
-			"doc",
-			"readme",
-			"comment",
-			"document",
-			"guide",
-			"changelog",
-			"spec",
-		],
-		weight: 1,
-		confidence: "medium",
-	},
-	{
-		kind: "migration",
-		keywords: [
-			"migrate",
-			"convert",
-			"port",
-			"upgrade",
-			"move to",
-			"transition",
-		],
-		weight: 2,
-		confidence: "high",
-	},
-	{
-		kind: "security",
-		keywords: [
-			"security",
-			"vulnerability",
-			"exploit",
-			"auth",
-			"permission",
-			"cve",
-			"secret",
-			"token",
-		],
-		weight: 2,
-		confidence: "high",
-	},
-	{
-		kind: "performance",
-		keywords: [
-			"performance",
-			"speed",
-			"optimize",
-			"fast",
-			"slow",
-			"latency",
-			"benchmark",
-		],
-		weight: 2,
-		confidence: "high",
-	},
-	{
-		kind: "architecture",
-		keywords: [
-			"architecture",
-			"design",
-			"structure",
-			"system design",
-			"pattern",
-			"abstraction",
-			"component",
-		],
-		weight: 2,
-		confidence: "medium",
-	},
-	{
-		kind: "research",
-		keywords: [
-			"research",
-			"investigate",
-			"explore",
-			"analyze",
-			"study",
-			"understand",
-		],
-		weight: 1,
-		confidence: "medium",
-	},
-	{
-		kind: "learning",
-		keywords: [
-			"learn",
-			"teach",
-			"explain",
-			"how does",
-			"understand",
-			"what is",
-		],
-		weight: 1,
-		confidence: "low",
-	},
-];
-
-function tokenize(text: string): string[] {
-	return text
-		.toLowerCase()
-		.replace(/[^a-z0-9\s]/g, " ")
-		.split(/\s+/)
-		.filter(Boolean);
-}
-
-export class IntentAnalyzer {
-	private rules: IntentRule[];
-
-	constructor(rules: IntentRule[] = INTENT_RULES) {
-		this.rules = rules;
-	}
-
-	analyze(text: string): Intent {
-		const lower = text.toLowerCase();
-		const tokens = tokenize(text);
-
-		const matchedSignals: IntentSignal[] = [];
-		let topKind: IntentKind = "general";
-		let topScore = 0;
-		let topConfidence: IntentConfidence = "low";
-
-		for (const rule of this.rules) {
-			let ruleScore = 0;
-			const matchedKeywords: string[] = [];
-
-			for (const keyword of rule.keywords) {
-				if (lower.includes(keyword)) {
-					ruleScore += rule.weight;
-					matchedKeywords.push(keyword);
-				}
-			}
-
-			if (ruleScore > topScore) {
-				topScore = ruleScore;
-				topKind = rule.kind;
-				topConfidence = rule.confidence;
-			}
-
-			for (const kw of matchedKeywords) {
-				matchedSignals.push({
-					keyword: kw,
-					weight: rule.weight,
-					matched: true,
-				});
-			}
-		}
-
-		if (topScore === 0) {
-			topKind = "general";
-			topConfidence = "low";
-		}
-
-		return {
-			kind: topKind,
-			confidence: topConfidence,
-			signals: matchedSignals,
-			originalText: text,
-		};
-	}
-
-	analyzeBatch(texts: string[]): Intent[] {
-		return texts.map((t) => this.analyze(t));
-	}
-}

package/packages/intent-analyzer/src/index.ts

@@ -1,8 +0,0 @@
-export { IntentAnalyzer } from "./analyzer.js";
-export type {
-	Intent,
-	IntentKind,
-	IntentConfidence,
-	IntentSignal,
-	IntentRule,
-} from "./types.js";

package/packages/intent-analyzer/src/types.ts

@@ -1,44 +0,0 @@
-/**
- * Intent Analyzer — Types
- *
- * Determines what the user is actually trying to accomplish.
- */
-
-export type IntentKind =
-	| "bug_fix"
-	| "feature"
-	| "architecture"
-	| "refactor"
-	| "code_review"
-	| "documentation"
-	| "testing"
-	| "deployment"
-	| "research"
-	| "learning"
-	| "migration"
-	| "security"
-	| "performance"
-	| "general";
-
-export type IntentConfidence = "high" | "medium" | "low";
-
-export interface IntentSignal {
-	keyword: string;
-	weight: number;
-	matched: boolean;
-}
-
-export interface Intent {
-	kind: IntentKind;
-	confidence: IntentConfidence;
-	signals: IntentSignal[];
-	originalText: string;
-	derivedTask?: string;
-}
-
-export interface IntentRule {
-	kind: IntentKind;
-	keywords: string[];
-	weight: number;
-	confidence: IntentConfidence;
-}

package/packages/intent-analyzer/test/analyzer.test.ts

@@ -1,72 +0,0 @@
-import { describe, it } from "node:test";
-import { IntentAnalyzer } from "../src/analyzer.js";
-import { equal } from "node:assert";
-
-describe("IntentAnalyzer", () => {
-	const analyzer = new IntentAnalyzer();
-
-	it("detects bug_fix from fix keyword", () => {
-		const result = analyzer.analyze("fix the login bug on line 42");
-		equal(result.kind, "bug_fix");
-	});
-
-	it("detects feature from add keyword", () => {
-		const result = analyzer.analyze("add dark mode support");
-		equal(result.kind, "feature");
-	});
-
-	it("detects refactor from refactor keyword", () => {
-		const result = analyzer.analyze("refactor the auth module");
-		equal(result.kind, "refactor");
-	});
-
-	it("detects testing from test keyword", () => {
-		const result = analyzer.analyze("write tests for the payment module");
-		equal(result.kind, "testing");
-	});
-
-	it("detects deployment from deploy keyword", () => {
-		const result = analyzer.analyze("deploy to production");
-		equal(result.kind, "deployment");
-	});
-
-	it("detects security from security keyword", () => {
-		const result = analyzer.analyze("fix the auth vulnerability");
-		equal(result.kind, "security");
-	});
-
-	it("detects performance from optimize keyword", () => {
-		const result = analyzer.analyze("optimize the database query");
-		equal(result.kind, "performance");
-	});
-
-	it("detects architecture from architecture keyword", () => {
-		const result = analyzer.analyze("review the architecture design");
-		equal(result.kind, "architecture");
-	});
-
-	it("detects migration from migrate keyword", () => {
-		const result = analyzer.analyze("migrate to TypeScript");
-		equal(result.kind, "migration");
-	});
-
-	it("falls back to general for unknown text", () => {
-		const result = analyzer.analyze("hello world");
-		equal(result.kind, "general");
-	});
-
-	it("returns matched signals", () => {
-		const result = analyzer.analyze("fix the authentication bug");
-		equal(
-			result.signals.some((s) => s.keyword === "fix"),
-			true,
-		);
-	});
-
-	it("analyzeBatch returns multiple intents", () => {
-		const results = analyzer.analyzeBatch(["fix bug", "add feature"]);
-		equal(results.length, 2);
-		equal(results[0].kind, "bug_fix");
-		equal(results[1].kind, "feature");
-	});
-});

package/packages/intent-analyzer/tsconfig.json

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

package/packages/laravel-plugin/README.md

@@ -1 +0,0 @@
-# laravel-plugin

package/packages/laravel-plugin/dist/analyzer.d.ts

@@ -1,8 +0,0 @@
-/**
- * Laravel Analyzer (RFC-0065)
- *
- * Deep analysis of Laravel workspaces via filesystem inspection.
- */
-import type { LaravelAnalysis } from "./types.js";
-export declare function analyzeLaravel(root: string): Promise<LaravelAnalysis | null>;
-//# sourceMappingURL=analyzer.d.ts.map

package/packages/laravel-plugin/dist/analyzer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAkRlD,wBAAsB,cAAc,CACnC,IAAI,EAAE,MAAM,GACV,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAqCjC"}

package/packages/laravel-plugin/dist/analyzer.js

@@ -1,297 +0,0 @@
-/**
- * Laravel Analyzer (RFC-0065)
- *
- * Deep analysis of Laravel workspaces via filesystem inspection.
- */
-import { existsSync } from "node:fs";
-import { readdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
-// --- Detection ---------------------------------------------------------------
-function isLaravelWorkspace(root) {
-    if (existsSync(join(root, "artisan")))
-        return true;
-    if (existsSync(join(root, "bootstrap", "app.php")))
-        return true;
-    if (existsSync(join(root, "composer.json"))) {
-        // Defer to async version; use basic file presence check as proxy
-        return (existsSync(join(root, "app", "Http", "Controllers")) ||
-            existsSync(join(root, "app", "Models")) ||
-            existsSync(join(root, "app", "Console", "Commands")) ||
-            existsSync(join(root, "database", "migrations")) ||
-            existsSync(join(root, "bootstrap", "app.php")));
-    }
-    return false;
-}
-// --- Version ----------------------------------------------------------------
-async function detectVersion(root) {
-    const composerPath = join(root, "composer.json");
-    if (!existsSync(composerPath))
-        return undefined;
-    try {
-        const composer = JSON.parse(await readFile(composerPath, "utf-8"));
-        const requires = {
-            ...(composer.require ?? {}),
-            ...(composer["require-dev"] ?? {}),
-        };
-        const laravel = requires["laravel/framework"];
-        if (laravel) {
-            return laravel.replace(/[\^~>=<]/, "");
-        }
-        // Also check for laravel/installer pattern
-        const pkg = composer.name;
-        if (pkg && pkg.toLowerCase().includes("laravel")) {
-            return composer.version ?? undefined;
-        }
-        return undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-// --- Packages ----------------------------------------------------------------
-async function detectPackages(root) {
-    const composerPath = join(root, "composer.json");
-    if (!existsSync(composerPath))
-        return [];
-    try {
-        const composer = JSON.parse(await readFile(composerPath, "utf-8"));
-        const deps = {
-            ...(composer.require ?? {}),
-            ...(composer["require-dev"] ?? {}),
-        };
-        return Object.keys(deps);
-    }
-    catch {
-        return [];
-    }
-}
-// --- Auth Detection --------------------------------------------------------
-async function detectAuth(root) {
-    const packages = await detectPackages(root);
-    if (packages.includes("laravel/sanctum"))
-        return "sanctum";
-    if (packages.includes("laravel/passport"))
-        return "passport";
-    if (packages.includes("laravel/spark-aurelius"))
-        return "spark";
-    if (packages.includes("tymon/jwt-auth"))
-        return "jwt";
-    // Check config files
-    for (const authFile of [
-        join(root, "config", "auth.php"),
-        join(root, "config", "sanctum.php"),
-    ]) {
-        if (existsSync(authFile)) {
-            try {
-                const content = await readFile(authFile, "utf-8");
-                if (content.includes("Sanctum") || content.includes("sanctum")) {
-                    return "sanctum";
-                }
-            }
-            catch {
-                /* ignore */
-            }
-        }
-    }
-    return undefined;
-}
-// --- Controllers -----------------------------------------------------------
-async function findControllers(root) {
-    const controllerDirs = [
-        join(root, "app", "Http", "Controllers"),
-        join(root, "app", "Controllers"),
-    ];
-    const controllers = [];
-    for (const dir of controllerDirs) {
-        if (!existsSync(dir))
-            continue;
-        try {
-            const entries = await readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (entry.name.startsWith(".") || entry.name === "Controller.php")
-                    continue;
-                if (entry.name.endsWith("Controller.php") ||
-                    entry.name.endsWith("Controller.ts")) {
-                    controllers.push(entry.name.replace(/\.(php|ts)$/, ""));
-                }
-                else if (entry.isDirectory()) {
-                    // Nested controller directory
-                    const subEntries = await readdir(join(dir, entry.name));
-                    for (const sub of subEntries) {
-                        if (sub.endsWith("Controller.php") ||
-                            sub.endsWith("Controller.ts")) {
-                            controllers.push(`${entry.name}/${sub.replace(/\.(php|ts)$/, "")}`);
-                        }
-                    }
-                }
-            }
-        }
-        catch {
-            /* ignore */
-        }
-    }
-    return controllers;
-}
-// --- Models ----------------------------------------------------------------
-async function findModels(root) {
-    const modelDirs = [join(root, "app", "Models"), join(root, "app", "Models")];
-    const models = [];
-    for (const dir of modelDirs) {
-        if (!existsSync(dir))
-            continue;
-        try {
-            const entries = await readdir(dir);
-            for (const entry of entries) {
-                if (entry.startsWith(".") || entry === "User.php")
-                    continue;
-                if (entry.endsWith(".php")) {
-                    models.push(entry.replace(/\.php$/, ""));
-                }
-            }
-        }
-        catch {
-            /* ignore */
-        }
-    }
-    return models;
-}
-// --- Blade Views -----------------------------------------------------------
-async function findViews(root) {
-    const viewDirs = [join(root, "resources", "views"), join(root, "views")];
-    const views = [];
-    for (const dir of viewDirs) {
-        if (!existsSync(dir))
-            continue;
-        try {
-            const entries = await readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (entry.name.startsWith("."))
-                    continue;
-                const fullPath = join(dir, entry.name);
-                if (entry.isDirectory()) {
-                    const subEntries = await readdir(fullPath);
-                    for (const sub of subEntries) {
-                        if (sub.endsWith(".blade.php")) {
-                            views.push(`${entry.name}/${sub}`);
-                        }
-                    }
-                }
-                else if (entry.name.endsWith(".blade.php")) {
-                    views.push(entry.name);
-                }
-            }
-        }
-        catch {
-            /* ignore */
-        }
-    }
-    return views;
-}
-// --- Artisan Commands ------------------------------------------------------
-async function findCommands(root) {
-    const commandDirs = [
-        join(root, "app", "Console", "Commands"),
-        join(root, "app", "Commands"),
-    ];
-    const commands = [];
-    for (const dir of commandDirs) {
-        if (!existsSync(dir))
-            continue;
-        try {
-            const entries = await readdir(dir);
-            for (const entry of entries) {
-                if (entry.startsWith(".") || !entry.endsWith(".php"))
-                    continue;
-                commands.push(entry.replace(/\.php$/, ""));
-            }
-        }
-        catch {
-            /* ignore */
-        }
-    }
-    return commands;
-}
-// --- Migrations Count -----------------------------------------------------
-async function countMigrations(root) {
-    const migrationDirs = [
-        join(root, "database", "migrations"),
-        join(root, "migrations"),
-    ];
-    let count = 0;
-    for (const dir of migrationDirs) {
-        if (!existsSync(dir))
-            continue;
-        try {
-            const entries = await readdir(dir);
-            count += entries.filter((e) => !e.startsWith(".") && e.endsWith(".php")).length;
-        }
-        catch {
-            /* ignore */
-        }
-    }
-    return count;
-}
-// --- Env Variables --------------------------------------------------------
-async function findEnvVars(root) {
-    const envFiles = [join(root, ".env.example"), join(root, ".env")];
-    const vars = [];
-    const seen = new Set();
-    for (const envPath of envFiles) {
-        if (!existsSync(envPath))
-            continue;
-        try {
-            const content = await readFile(envPath, "utf-8");
-            for (const line of content.split("\n")) {
-                const trimmed = line.trim();
-                if (trimmed && !trimmed.startsWith("#") && trimmed.includes("=")) {
-                    const key = trimmed.split("=")[0].trim();
-                    if (key && !seen.has(key)) {
-                        seen.add(key);
-                        vars.push(key);
-                    }
-                }
-            }
-        }
-        catch {
-            /* ignore */
-        }
-    }
-    return vars;
-}
-// --- Main Analyzer ---------------------------------------------------------
-export async function analyzeLaravel(root) {
-    if (!isLaravelWorkspace(root))
-        return null;
-    const [version, packages, authType] = await Promise.all([
-        detectVersion(root),
-        detectPackages(root),
-        detectAuth(root),
-    ]);
-    const [controllers, models, views, commands, migrations, envVars] = await Promise.all([
-        findControllers(root),
-        findModels(root),
-        findViews(root),
-        findCommands(root),
-        countMigrations(root),
-        findEnvVars(root),
-    ]);
-    return {
-        framework: {
-            id: "laravel",
-            name: "Laravel",
-            category: "fullstack",
-            description: "The PHP Framework for Web Artisans",
-            tags: ["php", "fullstack", "eloquent"],
-        },
-        version,
-        controllers,
-        models,
-        views,
-        commands,
-        migrations,
-        authType,
-        envVars,
-        packages,
-    };
-}
-//# sourceMappingURL=analyzer.js.map