kcode-pi 0.1.7 → 0.1.9

package/skills/kd-execute/SKILL.md

@@ -10,7 +10,7 @@ Use this skill only after `PLAN.md` exists.
 Goal:
 
 - Implement only the approved plan.
-- Use `kd_search` and `kd_table` before relying on Kingdee APIs or table schemas.
+- Use `kd_sdk_signature` before relying on uncertain Java/C# SDK APIs. Use `kd_search` for guidance and `kd_table`/metadata tools for table schemas.
 - Update `.pi/kd/runs/<run-id>/EXECUTION.md` with every planned `STEP-###`, changed files, and evidence files.
 
 Rules:
@@ -20,7 +20,7 @@ Rules:
 - For 星空旗舰版, edit only the real target path recorded in `PLAN.md` after inspecting the project. If `code/` exists, follow its actual layout; if it does not, follow the discovered source root or existing target file. Do not create demo/sample code or root-level `src/main/java` by guesswork.
 - Do not mark work complete until verification runs.
 - Do not skip planned steps. Every `STEP-###` in `PLAN.md` must be marked complete in `EXECUTION.md` with a real `evidence/...` file before entering verify.
-- Before writing production source files, run the planned red check and record failing output in `evidence/tdd-red.md`. This can be API/base-class/method-signature, metadata, compile/build, existing project test, or minimal external-interface evidence.
+- Before writing production source files, run the planned red check and record failing output in `evidence/tdd-red.md`. This can be `kd_sdk_signature` local SDK signature, metadata, compile/build, existing project test, or minimal external-interface evidence.
 - Before entering verify, rerun the same check and record passing output in `evidence/tdd-green.md`.
 - Do not add JUnit, Mockito, NUnit, xUnit, or any extra test jar/framework only to satisfy the gate. Use existing approved project test infrastructure if it already exists.
 - If implementation needs a plan change, update `PLAN.md` first.

package/skills/kd-gen/SKILL.md

@@ -13,12 +13,13 @@ Inputs to establish before coding:
 - Plugin type and correct base class.
 - Target bill/entity/form and lifecycle event.
 - Business rule and acceptance criteria.
-- Relevant SDK/table facts from `kd_search` or `kd_table`.
+- Relevant SDK/table facts from `kd_sdk_signature`, `kd_search`, `kd_table`, or product metadata tools.
 
 Rules:
 
 - Generate code only after the active run has a `PLAN.md`.
 - Use the correct base class only when verified for the target product family.
+- Verify uncertain Java/C# class names, base classes, methods, and overloads against current project SDK jars/dlls with `kd_sdk_signature`; bundled knowledge is not enough for final signature facts.
 - For 星空旗舰版, generate or edit product code only under the real target path selected in `PLAN.md` after project inspection. Follow the existing layout, whether it uses `code/`, app modules, cloud modules, or no module split; never create demo/sample code or root-level `src/main/java` by guesswork.
 - Use `kd.bos.*` style packages for Cosmic-family Java code and `Kingdee.BOS.*` style namespaces for enterprise C# code.
 - Do not reuse Cosmic/Xinghan/Cangqiong APIs for enterprise C#.

package/skills/kd-plan/SKILL.md

@@ -13,10 +13,10 @@ Goal:
 - List files to inspect before editing.
 - List the inspected project layout and the exact target source root or file path before editing.
 - List expected files to modify.
-- List required `kd_search` and `kd_table` lookups.
+- List required `kd_sdk_signature`, `kd_search`, `kd_table`, metadata, and build/compile checks.
 - List `## Execution Steps` using `- [ ] STEP-001: ...` style IDs.
 - List `## TDD / Red-Green Checks` with red evidence, green evidence, and the command/tool or product-specific check.
-- Do not plan to add third-party test jars or frameworks only for red/green checks. For Kingdee plugin work, prefer API/base-class/method-signature checks, metadata checks, compile/build checks, existing project tests, or minimal external-interface tests.
+- Do not plan to add third-party test jars or frameworks only for red/green checks. For Kingdee plugin work, prefer `kd_sdk_signature` against current project jars/dlls, metadata checks, compile/build checks, existing project tests, or minimal external-interface tests.
 - Define validation commands and expected evidence.
 - Add rollback or containment notes for medium/high risk work.
 
@@ -27,4 +27,4 @@ Gate:
 - A plan without validation commands is incomplete.
 - A plan without structured `STEP-001` execution steps is incomplete.
 - A plan without TDD red/green checks is incomplete.
-- A plan that relies on unverified Kingdee API names is incomplete.
+- A plan that relies on unverified Kingdee API names is incomplete; bundled knowledge alone is not enough when local SDK jars/dlls or compile evidence are available.

package/skills/kd-spec/SKILL.md

@@ -20,5 +20,4 @@ Rules:
 - Separate confirmed facts from assumptions.
 - Mark every API/table assumption as requiring lookup with `kd_search` or `kd_table`.
 - Do not edit product code in this phase.
-- If acceptance criteria are vague, ask targeted questions or state explicit assumptions.
-
+- If acceptance criteria are vague, ask targeted questions one at a time or state explicit assumptions. When using `kd_question`, ask only the single most blocking question and use at most 3 short choices; never submit a numbered checklist of questions.

package/src/harness/format.ts

@@ -15,6 +15,8 @@ export function formatStatus(cwd: string, run: ActiveRun | undefined): string {
 
 	return [
 		`Run: ${refreshed.id}`,
+		refreshed.goal ? `Goal: ${refreshed.goal}` : undefined,
+		`Status: ${refreshed.status ?? "active"}`,
 		`Phase: ${refreshed.phase}`,
 		`Next: ${next}`,
 		`Product: ${formatProductProfile(refreshed.profile)}`,

package/src/harness/gates.ts

@@ -30,11 +30,13 @@ export function inspectGate(cwd: string, run: ActiveRun): GateResult {
 	const markerProblem = inspectMarkers(cwd, run, run.phase);
 	const stepProblem = inspectStepState(cwd, run, run.phase);
 	const evidenceProblem = inspectEvidence(cwd, run, run.phase);
+	const questionProblem = inspectOpenQuestions(run);
 	const reasonParts = [];
 	if (missing.length > 0) reasonParts.push(`缺少必需产物：${[...new Set(missing)].join(", ")}`);
 	if (markerProblem) reasonParts.push(markerProblem);
 	if (stepProblem) reasonParts.push(stepProblem);
 	if (evidenceProblem) reasonParts.push(evidenceProblem);
+	if (questionProblem) reasonParts.push(questionProblem);
 
 	return {
 		passed: reasonParts.length === 0,
@@ -72,6 +74,11 @@ export function canEnterPhase(cwd: string, run: ActiveRun, target: KdPhase): Gat
 		reasonParts.push(stepProblem);
 	}
 
+	const questionProblem = inspectOpenQuestions(run);
+	if (questionProblem) {
+		reasonParts.push(questionProblem);
+	}
+
 	missing.push(...missingEvidenceForPhase(cwd, run, target));
 
 	if (target === "ship" && !artifactExists(cwd, run, PHASE_ARTIFACTS.verify)) {
@@ -87,6 +94,12 @@ export function canEnterPhase(cwd: string, run: ActiveRun, target: KdPhase): Gat
 	};
 }
 
+function inspectOpenQuestions(run: ActiveRun): string | undefined {
+	const open = (run.questions ?? []).filter((question) => question.status === "open" && question.blocking);
+	if (open.length === 0) return undefined;
+	return `存在未回答的阻断问题：${open.map((question) => `${question.id} ${question.question}`).join("；")}`;
+}
+
 function inspectStepState(cwd: string, run: ActiveRun, phase: KdPhase): string | undefined {
 	if (phase === "execute") {
 		const plan = readArtifact(cwd, run, "plan") ?? "";
@@ -154,7 +167,7 @@ function planHasMetadataRequirement(cwd: string, run: ActiveRun): boolean {
 
 function planHasApiRequirement(cwd: string, run: ActiveRun): boolean {
 	const plan = readArtifact(cwd, run, "plan") ?? "";
-	return /kd_cosmic_api|cosmic-api|api signature|method signature|sdk.*签名|方法签名|接口签名/i.test(plan);
+	return /kd_sdk_signature|kd_cosmic_api|cosmic-api|api signature|method signature|sdk.*签名|方法签名|接口签名/i.test(plan);
 }
 
 function runHasKsqlDelivery(cwd: string, run: ActiveRun): boolean {

package/src/harness/paths.ts

@@ -17,7 +17,11 @@ export function runRoot(cwd: string, run: ActiveRun): string {
 	return join(runsDir(cwd), run.id);
 }
 
+export function runStatePath(cwd: string, runOrId: ActiveRun | string): string {
+	const id = typeof runOrId === "string" ? runOrId : runOrId.id;
+	return join(runsDir(cwd), id, "RUN.json");
+}
+
 export function runArtifactPath(cwd: string, run: ActiveRun, artifactName: string): string {
 	return join(runRoot(cwd, run), artifactName);
 }
-

package/src/harness/state.ts

@@ -1,7 +1,7 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import type { ActiveRun, KdPhase } from "./types.ts";
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import type { ActiveRun, KdPhase, KdQuestion } from "./types.ts";
 import { PHASE_ARTIFACTS, isKdPhase, nextPhase } from "./types.ts";
-import { activeRunPath, kdDir, runsDir } from "./paths.ts";
+import { activeRunPath, kdDir, runStatePath, runsDir } from "./paths.ts";
 import { defaultArtifactContent, ensureArtifact, ensureRunDirectories, writeArtifact } from "./artifacts.ts";
 import { canEnterPhase, inspectGate } from "./gates.ts";
 import { profileForProduct, resolveProductProfile } from "../product/profile.ts";
@@ -11,14 +11,9 @@ export function readActiveRun(cwd: string): ActiveRun | undefined {
 	if (!existsSync(path)) return undefined;
 
 	try {
-		const parsed = JSON.parse(readFileSync(path, "utf8")) as ActiveRun;
-		if (!parsed.id || !isKdPhase(parsed.phase)) return undefined;
-		parsed.artifacts ??= {};
-		const legacyEdition = (parsed as ActiveRun & { edition?: string }).edition;
-		parsed.profile = parsed.profile ?? profileForProduct(parsed.product ?? resolveProductProfile(legacyEdition).product);
-		parsed.product = parsed.profile.product;
-		parsed.gate ??= { passed: false, checkedAt: new Date().toISOString() };
-		return parsed;
+		const active = hydrateRun(JSON.parse(readFileSync(path, "utf8")) as ActiveRun);
+		if (!active) return undefined;
+		return readRun(cwd, active.id) ?? active;
 	} catch {
 		return undefined;
 	}
@@ -27,20 +22,66 @@ export function readActiveRun(cwd: string): ActiveRun | undefined {
 export function writeActiveRun(cwd: string, run: ActiveRun): void {
 	mkdirSync(kdDir(cwd), { recursive: true });
 	mkdirSync(runsDir(cwd), { recursive: true });
+	run.status = "active";
+	run.updatedAt = new Date().toISOString();
+	writeRunState(cwd, run);
 	writeFileSync(activeRunPath(cwd), `${JSON.stringify(run, null, 2)}\n`, "utf8");
 }
 
+export function readRun(cwd: string, id: string): ActiveRun | undefined {
+	const path = runStatePath(cwd, id);
+	if (!existsSync(path)) return undefined;
+	try {
+		return hydrateRun(JSON.parse(readFileSync(path, "utf8")) as ActiveRun);
+	} catch {
+		return undefined;
+	}
+}
+
+export function listRuns(cwd: string): ActiveRun[] {
+	const root = runsDir(cwd);
+	if (!existsSync(root)) return [];
+	return readdirSync(root, { withFileTypes: true })
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => readRun(cwd, entry.name))
+		.filter((run): run is ActiveRun => Boolean(run))
+		.sort((a, b) => (b.updatedAt ?? b.createdAt ?? b.id).localeCompare(a.updatedAt ?? a.createdAt ?? a.id));
+}
+
+export function switchActiveRun(cwd: string, id: string): ActiveRun | undefined {
+	const run = readRun(cwd, id);
+	if (!run) return undefined;
+	writeActiveRun(cwd, run);
+	return readActiveRun(cwd);
+}
+
+export function finishActiveRun(cwd: string, run: ActiveRun): ActiveRun {
+	run.status = "done";
+	run.updatedAt = new Date().toISOString();
+	run.gate = inspectGate(cwd, run);
+	writeRunState(cwd, run);
+	const activePath = activeRunPath(cwd);
+	if (existsSync(activePath)) unlinkSync(activePath);
+	return run;
+}
+
 export function createActiveRun(cwd: string, goal: string, productInput?: string, version?: string): ActiveRun {
 	const profile = resolveProductProfile(productInput ?? goal);
+	const now = new Date().toISOString();
 	const run: ActiveRun = {
 		id: createRunId(goal),
+		goal,
 		phase: "discuss",
 		cwd,
+		status: "active",
+		createdAt: now,
+		updatedAt: now,
 		product: profile.product,
 		version,
 		profile,
 		risk: "unknown",
 		artifacts: {},
+		questions: [],
 		gate: {
 			passed: false,
 			reason: "CONTEXT.md and product profile are required before moving to spec",
@@ -55,6 +96,43 @@ export function createActiveRun(cwd: string, goal: string, productInput?: string
 	return run;
 }
 
+export function addQuestion(
+	cwd: string,
+	run: ActiveRun,
+	input: { question: string; reason?: string; choices?: string[]; blocking?: boolean },
+): KdQuestion {
+	const existing = run.questions ?? [];
+	const question: KdQuestion = {
+		id: createQuestionId(existing.length + 1),
+		phase: run.phase,
+		question: input.question.trim(),
+		reason: input.reason?.trim() || undefined,
+		choices: input.choices?.map((choice) => choice.trim()).filter(Boolean),
+		blocking: input.blocking ?? true,
+		status: "open",
+		createdAt: new Date().toISOString(),
+	};
+	run.questions = [...existing, question];
+	run.gate = inspectGate(cwd, run);
+	writeActiveRun(cwd, run);
+	return question;
+}
+
+export function answerQuestion(cwd: string, run: ActiveRun, id: string, answer: string): KdQuestion | undefined {
+	const question = (run.questions ?? []).find((item) => item.id === id);
+	if (!question) return undefined;
+	question.status = "answered";
+	question.answer = answer.trim();
+	question.answeredAt = new Date().toISOString();
+	run.gate = inspectGate(cwd, run);
+	writeActiveRun(cwd, run);
+	return question;
+}
+
+export function openBlockingQuestions(run: ActiveRun): KdQuestion[] {
+	return (run.questions ?? []).filter((question) => question.status === "open" && question.blocking);
+}
+
 export function updateProductProfile(cwd: string, run: ActiveRun, productInput: string, version?: string): ActiveRun {
 	const profile = resolveProductProfile(productInput);
 	run.product = profile.product;
@@ -106,6 +184,26 @@ export function refreshGate(cwd: string, run: ActiveRun): ActiveRun {
 	return run;
 }
 
+function writeRunState(cwd: string, run: ActiveRun): void {
+	mkdirSync(runsDir(cwd), { recursive: true });
+	ensureRunDirectories(cwd, run);
+	writeFileSync(runStatePath(cwd, run), `${JSON.stringify(run, null, 2)}\n`, "utf8");
+}
+
+function hydrateRun(parsed: ActiveRun): ActiveRun | undefined {
+	if (!parsed.id || !isKdPhase(parsed.phase)) return undefined;
+	parsed.artifacts ??= {};
+	parsed.questions ??= [];
+	parsed.status ??= "active";
+	parsed.createdAt ??= parsed.updatedAt;
+	parsed.updatedAt ??= parsed.createdAt;
+	const legacyEdition = (parsed as ActiveRun & { edition?: string }).edition;
+	parsed.profile = parsed.profile ?? profileForProduct(parsed.product ?? resolveProductProfile(legacyEdition).product);
+	parsed.product = parsed.profile.product;
+	parsed.gate ??= { passed: false, checkedAt: new Date().toISOString() };
+	return parsed;
+}
+
 function createRunId(goal: string): string {
 	const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\..+/, "").replace("T", "-");
 	const slug = goal
@@ -115,3 +213,7 @@ function createRunId(goal: string): string {
 		.slice(0, 40);
 	return slug ? `${stamp}-${slug}` : stamp;
 }
+
+function createQuestionId(sequence: number): string {
+	return `Q-${String(sequence).padStart(3, "0")}`;
+}

package/src/harness/types.ts

@@ -2,6 +2,7 @@ import type { KdProduct, ProductProfile } from "../product/profile.ts";
 
 export type KdPhase = "discuss" | "spec" | "plan" | "execute" | "verify" | "ship";
 export type KdRisk = "unknown" | "low" | "medium" | "high";
+export type KdRunStatus = "active" | "paused" | "done";
 
 export interface GateResult {
 	passed: boolean;
@@ -9,16 +10,34 @@ export interface GateResult {
 	checkedAt: string;
 }
 
+export interface KdQuestion {
+	id: string;
+	phase: KdPhase;
+	question: string;
+	reason?: string;
+	choices?: string[];
+	blocking: boolean;
+	status: "open" | "answered";
+	answer?: string;
+	createdAt: string;
+	answeredAt?: string;
+}
+
 export interface ActiveRun {
 	id: string;
+	goal?: string;
 	phase: KdPhase;
 	cwd: string;
+	status?: KdRunStatus;
+	createdAt?: string;
+	updatedAt?: string;
 	product?: KdProduct;
 	version?: string;
 	profile?: ProductProfile;
 	risk?: KdRisk;
 	artifacts: Record<string, string>;
 	gate: GateResult;
+	questions?: KdQuestion[];
 }
 
 export const PHASE_ORDER: KdPhase[] = ["discuss", "spec", "plan", "execute", "verify", "ship"];

package/src/tools/sdk-signature.ts

@@ -0,0 +1,309 @@
+import { execFile } from "node:child_process";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { extname, join, relative } from "node:path";
+import { promisify } from "node:util";
+import { resolveWorkspacePath } from "../platform/path.ts";
+
+const execFileAsync = promisify(execFile);
+
+export type SdkSignatureLanguage = "java" | "csharp";
+
+export interface SdkSignatureParams {
+	language: SdkSignatureLanguage;
+	query?: string;
+	className?: string;
+	method?: string;
+	path?: string;
+	limit?: number;
+}
+
+export interface SdkSignatureResult {
+	language: SdkSignatureLanguage;
+	query: string;
+	exitCode: number;
+	stdout: string;
+	stderr: string;
+	sources: string[];
+}
+
+const SKIP_DIRS = new Set([
+	".git",
+	".gradle",
+	".idea",
+	".pi",
+	".tmp",
+	"dist",
+	"node_modules",
+	"out",
+	"target",
+]);
+
+export async function inspectSdkSignature(cwd: string, params: SdkSignatureParams): Promise<SdkSignatureResult> {
+	const query = (params.className || params.query || "").trim();
+	if (!query) {
+		return {
+			language: params.language,
+			query,
+			exitCode: 2,
+			stdout: "",
+			stderr: "Provide query or className for kd_sdk_signature. method is only a filter within a matched class/type.",
+			sources: [],
+		};
+	}
+
+	if (params.language === "java") return inspectJavaSignature(cwd, params, query);
+	return inspectCsharpSignature(cwd, params, query);
+}
+
+export function formatSdkSignatureResult(result: SdkSignatureResult): string {
+	return [
+		`Language: ${result.language}`,
+		`Query: ${result.query}`,
+		`Exit: ${result.exitCode}`,
+		result.sources.length ? `Sources:\n${result.sources.map((source) => `- ${source}`).join("\n")}` : "Sources: none",
+		result.stdout.trim() ? `\nSTDOUT:\n${result.stdout.trim()}` : undefined,
+		result.stderr.trim() ? `\nSTDERR:\n${result.stderr.trim()}` : undefined,
+		"",
+		"Use this as local SDK evidence only when Exit is 0. If it fails, use build output or project SDK configuration before trusting bundled knowledge.",
+	]
+		.filter(Boolean)
+		.join("\n");
+}
+
+async function inspectJavaSignature(cwd: string, params: SdkSignatureParams, query: string): Promise<SdkSignatureResult> {
+	const roots = scanRoots(cwd, params.path);
+	const jars = roots.flatMap((root) => findFiles(root, ".jar", params.limit ?? 200));
+	if (jars.length === 0) {
+		return {
+			language: "java",
+			query,
+			exitCode: 2,
+			stdout: "",
+			stderr: "No jar files found in the current project. Build/copy dependencies first or pass path=<sdk/lib directory>.",
+			sources: [],
+		};
+	}
+
+	const classNames = params.className ? [params.className] : await findJavaClasses(jars, query, params.limit ?? 20);
+	if (classNames.length === 0) {
+		return {
+			language: "java",
+			query,
+			exitCode: 1,
+			stdout: "",
+			stderr: `No class matching "${query}" found in project jars.`,
+			sources: jars.map((jar) => relativeOrSelf(cwd, jar)).slice(0, 20),
+		};
+	}
+
+	const classpath = jars.join(process.platform === "win32" ? ";" : ":");
+	const outputs: string[] = [];
+	const errors: string[] = [];
+	const inspectedSources = new Set<string>();
+
+	for (const className of classNames.slice(0, params.limit ?? 10)) {
+		try {
+			const result = await execFileAsync("javap", ["-classpath", classpath, "-public", className], {
+				cwd,
+				timeout: 60_000,
+				maxBuffer: 1024 * 1024 * 4,
+			});
+			const text = filterMethodLines(result.stdout || "", params.method);
+			if (text.trim()) outputs.push(`## ${className}\n${text.trim()}`);
+			for (const source of jarsContainingClass(jars, className)) inspectedSources.add(relativeOrSelf(cwd, source));
+		} catch (error) {
+			const err = error as { message?: string; stderr?: string };
+			errors.push(`${className}: ${err.stderr || err.message || String(error)}`);
+		}
+	}
+
+	return {
+		language: "java",
+		query,
+		exitCode: outputs.length ? 0 : 1,
+		stdout: outputs.join("\n\n"),
+		stderr: errors.join("\n").trim(),
+		sources: [...inspectedSources].sort(),
+	};
+}
+
+async function inspectCsharpSignature(cwd: string, params: SdkSignatureParams, query: string): Promise<SdkSignatureResult> {
+	const roots = scanRoots(cwd, params.path);
+	const dlls = roots.flatMap((root) => findFiles(root, ".dll", params.limit ?? 200));
+	if (dlls.length === 0) {
+		return {
+			language: "csharp",
+			query,
+			exitCode: 2,
+			stdout: "",
+			stderr: "No dll files found in the current project. Build/restore references first or pass path=<sdk/bin directory>.",
+			sources: [],
+		};
+	}
+
+	const script = [
+		"$ErrorActionPreference = 'SilentlyContinue'",
+		"$query = $args[0]",
+		"$method = $args[1]",
+		"$dlls = $args[2..($args.Length-1)]",
+		"$hits = New-Object System.Collections.Generic.List[string]",
+		"foreach ($dll in $dlls) {",
+		"  try { $asm = [System.Reflection.Assembly]::LoadFrom($dll) } catch { continue }",
+		"  try { $types = $asm.GetExportedTypes() } catch { continue }",
+		"  foreach ($type in $types) {",
+		"    if ($type.FullName -notlike \"*$query*\" -and $type.Name -notlike \"*$query*\") { continue }",
+		"    $hits.Add(\"## \" + $type.FullName + \"`nAssembly: \" + $dll)",
+		"    foreach ($m in $type.GetMethods([System.Reflection.BindingFlags]'Public,Instance,Static,DeclaredOnly')) {",
+		"      if ($method -and $m.Name -notlike \"*$method*\") { continue }",
+		"      $params = ($m.GetParameters() | ForEach-Object { $_.ParameterType.Name + ' ' + $_.Name }) -join ', '",
+		"      $hits.Add('  ' + $m.ReturnType.Name + ' ' + $m.Name + '(' + $params + ')')",
+		"    }",
+		"    foreach ($p in $type.GetProperties([System.Reflection.BindingFlags]'Public,Instance,Static,DeclaredOnly')) {",
+		"      if ($method -and $p.Name -notlike \"*$method*\") { continue }",
+		"      $hits.Add('  property ' + $p.PropertyType.Name + ' ' + $p.Name)",
+		"    }",
+		"  }",
+		"}",
+		"$hits | Select-Object -First 200",
+	].join("; ");
+
+	try {
+		const executable = process.platform === "win32" ? "powershell" : "pwsh";
+		const result = await execFileAsync(executable, ["-NoProfile", "-Command", script, query, params.method ?? "", ...dlls], {
+			cwd,
+			timeout: 60_000,
+			maxBuffer: 1024 * 1024 * 4,
+		});
+		const stdout = result.stdout || "";
+		return {
+			language: "csharp",
+			query,
+			exitCode: stdout.trim() ? 0 : 1,
+			stdout,
+			stderr: stdout.trim() ? "" : `No public type matching "${query}" found in project dlls.`,
+			sources: dlls.map((dll) => relativeOrSelf(cwd, dll)).slice(0, 20),
+		};
+	} catch (error) {
+		const err = error as { message?: string; stderr?: string };
+		return {
+			language: "csharp",
+			query,
+			exitCode: 1,
+			stdout: "",
+			stderr: err.stderr || err.message || String(error),
+			sources: dlls.map((dll) => relativeOrSelf(cwd, dll)).slice(0, 20),
+		};
+	}
+}
+
+async function findJavaClasses(jars: string[], query: string, limit: number): Promise<string[]> {
+	const basenameQuery = query.includes(".") ? query.split(".").at(-1) || query : query;
+	const classPattern = `${basenameQuery}.class`;
+	const results = new Set<string>();
+
+	for (const jar of jars) {
+		try {
+			const output = await execFileAsync("jar", ["tf", jar], { timeout: 30_000, maxBuffer: 1024 * 1024 * 4 });
+			for (const line of (output.stdout || "").split(/\r?\n/)) {
+				if (!line.endsWith(".class") || line.includes("$")) continue;
+				if (!line.toLowerCase().includes(classPattern.toLowerCase())) continue;
+				results.add(line.replace(/\.class$/, "").replace(/\//g, "."));
+				if (results.size >= limit) return [...results];
+			}
+		} catch {
+			const matched = findClassNamesInJarBytes(jar, basenameQuery, limit - results.size);
+			for (const className of matched) results.add(className);
+			if (results.size >= limit) return [...results];
+		}
+	}
+
+	return [...results];
+}
+
+function findClassNamesInJarBytes(jar: string, query: string, limit: number): string[] {
+	const data = readFileSync(jar).toString("latin1");
+	const pattern = `${query}.class`;
+	const results = new Set<string>();
+	let index = data.indexOf(pattern);
+	while (index >= 0 && results.size < limit) {
+		let start = index;
+		while (start > 0 && /[A-Za-z0-9_/$-]/.test(data[start - 1])) start--;
+		const entry = data.slice(start, index + pattern.length);
+		if (entry.includes("/") && !entry.includes("$")) {
+			results.add(entry.replace(/\.class$/, "").replace(/\//g, "."));
+		}
+		index = data.indexOf(pattern, index + pattern.length);
+	}
+	return [...results];
+}
+
+function jarsContainingClass(jars: string[], className: string): string[] {
+	const entry = `${className.replace(/\./g, "/")}.class`;
+	return jars.filter((jar) => {
+		try {
+			const data = readFileSync(jar).toString("latin1");
+			return data.includes(entry);
+		} catch {
+			return false;
+		}
+	});
+}
+
+function filterMethodLines(output: string, method?: string): string {
+	if (!method) return output;
+	const lines = output.split(/\r?\n/);
+	const kept = lines.filter((line) => line.includes(`${method}(`) || /^(Compiled from|public class|public interface)/.test(line.trim()));
+	return kept.join("\n");
+}
+
+function scanRoots(cwd: string, path?: string): string[] {
+	if (path) {
+		const resolved = resolveWorkspacePath(cwd, path);
+		return existsSync(resolved) ? [resolved] : [];
+	}
+	return [cwd];
+}
+
+function findFiles(root: string, extension: string, limit: number): string[] {
+	if (existsSync(root)) {
+		try {
+			const stat = statSync(root);
+			if (stat.isFile()) return extname(root).toLowerCase() === extension ? [root] : [];
+		} catch {
+			return [];
+		}
+	}
+	const results: string[] = [];
+	walk(root, extension, results, limit, 0);
+	return results;
+}
+
+function walk(dir: string, extension: string, results: string[], limit: number, depth: number): void {
+	if (results.length >= limit || depth > 8 || !existsSync(dir)) return;
+	let entries: string[];
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		if (results.length >= limit) return;
+		const full = join(dir, entry);
+		let stat;
+		try {
+			stat = statSync(full);
+		} catch {
+			continue;
+		}
+		if (stat.isDirectory()) {
+			if (!SKIP_DIRS.has(entry)) walk(full, extension, results, limit, depth + 1);
+			continue;
+		}
+		if (stat.isFile() && extname(entry).toLowerCase() === extension) results.push(full);
+	}
+}
+
+function relativeOrSelf(cwd: string, path: string): string {
+	const rel = relative(cwd, path);
+	return rel && !rel.startsWith("..") ? rel : path;
+}