kcode-pi 0.1.0 → 0.1.2

package/src/tools/build-debug.ts

@@ -0,0 +1,214 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { extname, join } from "node:path";
+import type { ProductProfile } from "../product/profile.ts";
+import { type CommandSpec, formatCommandResult, resolveWorkspacePath, runCommand } from "../official/kingdee-skills.ts";
+
+export interface BuildPlan {
+	profile: string;
+	command: CommandSpec;
+	reason: string;
+}
+
+export interface DebugFinding {
+	severity: "error" | "warning" | "info";
+	rule: string;
+	message: string;
+	evidence: string;
+	nextStep: string;
+}
+
+export function planBuild(cwd: string, profile: ProductProfile, target?: string): BuildPlan {
+	if (profile.product === "unknown") {
+		throw new Error("Product profile is unknown. Set product before running kd_build.");
+	}
+
+	if (profile.platform === "cosmic") return planJavaBuild(cwd, profile, target);
+	if (profile.platform === "enterprise-csharp") return planCsharpBuild(cwd, profile, target);
+	throw new Error(`No build strategy for ${profile.product}/${profile.platform}/${profile.techStack}.`);
+}
+
+export async function runBuild(plan: BuildPlan, dryRun?: boolean) {
+	if (dryRun) {
+		return {
+			content: [{ type: "text" as const, text: formatBuildPlan(plan) }],
+			details: { dryRun: true, command: plan.command.display, reason: plan.reason },
+		};
+	}
+
+	const result = await runCommand(plan.command, 10 * 60 * 1000);
+	return {
+		content: [{ type: "text" as const, text: `${formatBuildPlan(plan)}\n\n${formatCommandResult(result)}` }],
+		details: { dryRun: false, command: result.command, exitCode: result.exitCode, reason: plan.reason },
+	};
+}
+
+export function analyzeDebugText(text: string): DebugFinding[] {
+	const findings: DebugFinding[] = [];
+	const lines = text.split(/\r?\n/);
+
+	pushIfMatch(findings, lines, /NullPointerException|Object reference not set/i, {
+		severity: "error",
+		rule: "null-pointer",
+		message: "Detected null pointer failure.",
+		nextStep: "Check field metadata, nullable fields, DynamicObject access, and DataSet row getters near the stack frame.",
+	});
+
+	pushIfMatch(findings, lines, /ClassNotFoundException|NoClassDefFoundError|FileNotFoundException.*\.jar/i, {
+		severity: "error",
+		rule: "classpath",
+		message: "Detected missing class or jar dependency.",
+		nextStep: "Verify module dependency, biz/cuslib deployment, and whether the correct product/version SDK is used.",
+	});
+
+	pushIfMatch(findings, lines, /DataSet.*closed|ResultSet.*closed|connection.*closed/i, {
+		severity: "error",
+		rule: "dataset-scope",
+		message: "Detected closed DataSet/connection usage.",
+		nextStep: "Keep DataSet processing inside try-with-resources and inside the transaction/resource scope that created it.",
+	});
+
+	pushIfMatch(findings, lines, /SQLSyntaxErrorException|PSQLException|syntax error|invalid column|column .* does not exist/i, {
+		severity: "error",
+		rule: "sql-metadata",
+		message: "Detected SQL or metadata mismatch.",
+		nextStep: "Use kd_cosmic_metadata with sql=true to verify table names, DB fields, enum values, and dbName/dbKey.",
+	});
+
+	pushIfMatch(findings, lines, /deadlock|lock wait timeout|could not serialize access|并发|死锁/i, {
+		severity: "error",
+		rule: "transaction-lock",
+		message: "Detected transaction locking or concurrency failure.",
+		nextStep: "Review transaction size, cross-database writes, update ordering, and whether external calls run inside transactions.",
+	});
+
+	pushIfMatch(findings, lines, /OutOfMemoryError|GC overhead|Java heap space|内存溢出/i, {
+		severity: "error",
+		rule: "memory",
+		message: "Detected memory pressure or OOM.",
+		nextStep: "Check full-table queries, unbounded collections, deep field paths, and large DataSet/materialized loads.",
+	});
+
+	pushIfMatch(findings, lines, /StackOverflowError|propertyChanged/i, {
+		severity: "warning",
+		rule: "event-recursion",
+		message: "Potential recursive event handling.",
+		nextStep: "Check propertyChanged/setValue loops and compare old/new values before writing fields.",
+	});
+
+	pushIfMatch(findings, lines, /Gradle|Compilation failed|javac|CS\d{4}|MSB\d{4}|BUILD FAILED|BUILD FAILURE/i, {
+		severity: "error",
+		rule: "build-error",
+		message: "Detected build or compiler error.",
+		nextStep: "Use product-specific build output. For Cosmic Java verify SDK signatures; for enterprise C# verify namespaces and references.",
+	});
+
+	if (findings.length === 0) {
+		findings.push({
+			severity: "info",
+			rule: "no-known-pattern",
+			message: "No known Kingdee debug pattern matched.",
+			evidence: "",
+			nextStep: "Provide fuller logs, stack trace, product/version, target bill/form, and recent code changes.",
+		});
+	}
+
+	return findings;
+}
+
+export function formatDebugFindings(findings: DebugFinding[]): string {
+	return findings
+		.map((finding) =>
+			[
+				`[${finding.severity}] ${finding.rule}`,
+				finding.message,
+				finding.evidence ? `Evidence: ${finding.evidence}` : undefined,
+				`Next: ${finding.nextStep}`,
+			]
+				.filter(Boolean)
+				.join("\n"),
+		)
+		.join("\n\n");
+}
+
+export function readDebugInput(cwd: string, text?: string, path?: string): { source: string; text: string } {
+	if (text) return { source: "inline", text };
+	if (!path) throw new Error("Provide either text or path for kd_debug.");
+
+	const fullPath = resolveWorkspacePath(cwd, path);
+	return { source: path, text: readFileSync(fullPath, "utf8") };
+}
+
+function planJavaBuild(cwd: string, profile: ProductProfile, target?: string): BuildPlan {
+	const task = target ?? "build";
+	const gradlewBat = join(cwd, "gradlew.bat");
+	const gradlew = join(cwd, "gradlew");
+	const mvnwBat = join(cwd, "mvnw.cmd");
+	const mvnw = join(cwd, "mvnw");
+
+	if (existsSync(gradlewBat)) {
+		return buildPlan(profile, gradlewBat, [task], cwd, "Detected Gradle wrapper for Cosmic-family Java project.");
+	}
+	if (existsSync(gradlew)) {
+		return buildPlan(profile, gradlew, [task], cwd, "Detected Gradle wrapper for Cosmic-family Java project.");
+	}
+	if (existsSync(mvnwBat)) {
+		return buildPlan(profile, mvnwBat, [target ?? "test"], cwd, "Detected Maven wrapper for Cosmic-family Java project.");
+	}
+	if (existsSync(mvnw)) {
+		return buildPlan(profile, mvnw, [target ?? "test"], cwd, "Detected Maven wrapper for Cosmic-family Java project.");
+	}
+	if (existsSync(join(cwd, "build.gradle")) || existsSync(join(cwd, "build.gradle.kts"))) {
+		return buildPlan(profile, "gradle", [task], cwd, "Detected Gradle build file; wrapper not found.");
+	}
+	if (existsSync(join(cwd, "pom.xml"))) {
+		return buildPlan(profile, "mvn", [target ?? "test"], cwd, "Detected Maven pom.xml; wrapper not found.");
+	}
+
+	throw new Error("No Java build entry found. Expected gradlew, build.gradle, mvnw, or pom.xml in workspace root.");
+}
+
+function planCsharpBuild(cwd: string, profile: ProductProfile, target?: string): BuildPlan {
+	const explicit = target ? resolveWorkspacePath(cwd, target) : undefined;
+	if (explicit && existsSync(explicit)) {
+		return buildPlan(profile, "dotnet", ["build", explicit], cwd, "Using explicit C# project or solution target.");
+	}
+
+	const candidates = readdirSync(cwd).filter((entry) => [".sln", ".csproj"].includes(extname(entry).toLowerCase()));
+	if (candidates.length > 0) {
+		return buildPlan(profile, "dotnet", ["build", join(cwd, candidates[0])], cwd, `Detected ${candidates[0]} for enterprise C# project.`);
+	}
+
+	throw new Error("No C# build entry found. Expected .sln or .csproj in workspace root, or pass target path.");
+}
+
+function buildPlan(profile: ProductProfile, executable: string, args: string[], cwd: string, reason: string): BuildPlan {
+	return {
+		profile: `${profile.product}/${profile.platform}/${profile.techStack}`,
+		command: {
+			executable,
+			args,
+			cwd,
+			display: [executable, ...args].map(formatArg).join(" "),
+		},
+		reason,
+	};
+}
+
+function formatBuildPlan(plan: BuildPlan): string {
+	return [`Product: ${plan.profile}`, `Reason: ${plan.reason}`, `Command: ${plan.command.display}`].join("\n");
+}
+
+function formatArg(value: string): string {
+	return /[\s"'&|<>]/.test(value) ? `"${value.replace(/"/g, '\\"')}"` : value;
+}
+
+function pushIfMatch(
+	findings: DebugFinding[],
+	lines: string[],
+	pattern: RegExp,
+	template: Omit<DebugFinding, "evidence">,
+): void {
+	const line = lines.find((candidate) => pattern.test(candidate));
+	if (!line) return;
+	findings.push({ ...template, evidence: line.trim().slice(0, 500) });
+}