kcode-pi 0.1.0

package/extensions/kingdee-harness.ts

@@ -0,0 +1,180 @@
+import { Type } from "@earendil-works/pi-ai";
+import { defineTool, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { formatStatus } from "../src/harness/format.ts";
+import { PHASE_ORDER, isKdPhase, type KdPhase } from "../src/harness/types.ts";
+import {
+	advanceRun,
+	createActiveRun,
+	ensurePhaseArtifact,
+	readActiveRun,
+	refreshGate,
+	updateProductProfile,
+	updatePhaseArtifact,
+} from "../src/harness/state.ts";
+
+function requireRun(cwd: string): ReturnType<typeof readActiveRun> {
+	return readActiveRun(cwd);
+}
+
+function parseArtifactArgs(args: string, currentPhase: KdPhase): { phase: KdPhase; content?: string } | undefined {
+	const trimmed = args.trim();
+	if (!trimmed) return { phase: currentPhase };
+
+	const [first, ...rest] = trimmed.split(/\s+/);
+	if (isKdPhase(first)) {
+		const contentStart = trimmed.indexOf(first) + first.length;
+		const content = trimmed.slice(contentStart).trim();
+		return { phase: first, content: content || undefined };
+	}
+
+	return { phase: currentPhase, content: trimmed };
+}
+
+function parseStartArgs(args: string): { goal: string; product?: string; version?: string } {
+	const tokens = args.trim().split(/\s+/).filter(Boolean);
+	const goal: string[] = [];
+	let product: string | undefined;
+	let version: string | undefined;
+
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		if ((token === "--product" || token === "-p") && tokens[i + 1]) {
+			product = tokens[++i];
+			continue;
+		}
+		if ((token === "--version" || token === "-v") && tokens[i + 1]) {
+			version = tokens[++i];
+			continue;
+		}
+		goal.push(token);
+	}
+
+	return { goal: goal.join(" "), product, version };
+}
+
+function parseProductArgs(args: string): { product: string; version?: string } | undefined {
+	const parsed = parseStartArgs(args);
+	const product = parsed.product ?? parsed.goal.split(/\s+/)[0];
+	if (!product) return undefined;
+	return { product, version: parsed.version };
+}
+
+const kdPlanStatusTool = defineTool({
+	name: "kd_plan_status",
+	label: "KD Status",
+	description: "Inspect the active Kingdee Harness Engineering run, current phase, required artifacts, and gate status.",
+	parameters: Type.Object({}),
+
+	async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+		const run = readActiveRun(ctx.cwd);
+		return {
+			content: [{ type: "text", text: formatStatus(ctx.cwd, run) }],
+			details: { run },
+		};
+	},
+});
+
+export default function (pi: ExtensionAPI) {
+	pi.registerTool(kdPlanStatusTool);
+
+	pi.registerCommand("kd-status", {
+		description: "Show the active Kingdee harness run and gate status",
+		handler: async (_args, ctx) => {
+			ctx.ui.notify(formatStatus(ctx.cwd, readActiveRun(ctx.cwd)), "info");
+		},
+	});
+
+	pi.registerCommand("kd-gate", {
+		description: "Refresh and show the active Kingdee harness gate",
+		handler: async (_args, ctx) => {
+			const run = requireRun(ctx.cwd);
+			if (!run) {
+				ctx.ui.notify("No active Kingdee harness run. Use /kd-start <goal>.", "error");
+				return;
+			}
+			const refreshed = refreshGate(ctx.cwd, run);
+			ctx.ui.notify(refreshed.gate.passed ? "Gate passed" : `Gate blocked: ${refreshed.gate.reason}`, "info");
+		},
+	});
+
+	pi.registerCommand("kd-start", {
+		description: "Start a Kingdee harness run: /kd-start [--product product] [--version version] <goal>",
+		handler: async (args, ctx) => {
+			const parsed = parseStartArgs(args);
+			const goal = parsed.goal;
+			if (!goal) {
+				ctx.ui.notify("Usage: /kd-start [--product product] [--version version] <goal>", "error");
+				return;
+			}
+
+			const run = createActiveRun(ctx.cwd, goal, parsed.product, parsed.version);
+			ctx.ui.notify(`Started Kingdee harness run: ${run.id} (${run.profile?.product}/${run.profile?.techStack})`, "info");
+		},
+	});
+
+	pi.registerCommand("kd-product", {
+		description: "Set the active Kingdee product profile: /kd-product <flagship|cosmic|xinghan|cangqiong|enterprise> [--version version]",
+		handler: async (args, ctx) => {
+			const run = requireRun(ctx.cwd);
+			if (!run) {
+				ctx.ui.notify("No active Kingdee harness run. Use /kd-start <goal>.", "error");
+				return;
+			}
+
+			const parsed = parseProductArgs(args);
+			if (!parsed) {
+				ctx.ui.notify("Usage: /kd-product <flagship|cosmic|xinghan|cangqiong|enterprise> [--version version]", "error");
+				return;
+			}
+
+			const updated = updateProductProfile(ctx.cwd, run, parsed.product, parsed.version);
+			ctx.ui.notify(`Product profile: ${updated.profile?.product}/${updated.profile?.techStack}/${updated.profile?.language}`, "info");
+		},
+	});
+
+	pi.registerCommand("kd-advance", {
+		description: `Advance Kingdee run to the next phase or a named phase: ${PHASE_ORDER.join("|")}`,
+		handler: async (args, ctx) => {
+			const run = requireRun(ctx.cwd);
+			if (!run) {
+				ctx.ui.notify("No active Kingdee harness run. Use /kd-start <goal>.", "error");
+				return;
+			}
+
+			const requestedText = args.trim();
+			let requested: KdPhase | undefined;
+			if (requestedText) {
+				if (!isKdPhase(requestedText)) {
+					ctx.ui.notify(`Unknown phase "${requestedText}". Valid phases: ${PHASE_ORDER.join(", ")}`, "error");
+					return;
+				}
+				requested = requestedText;
+			}
+
+			const result = advanceRun(ctx.cwd, run, requested);
+			ctx.ui.notify(result.message, result.run.gate.passed ? "info" : "warning");
+		},
+	});
+
+	pi.registerCommand("kd-artifact", {
+		description: "Create or update a phase artifact: /kd-artifact [phase] [content]",
+		handler: async (args, ctx) => {
+			const run = requireRun(ctx.cwd);
+			if (!run) {
+				ctx.ui.notify("No active Kingdee harness run. Use /kd-start <goal>.", "error");
+				return;
+			}
+
+			const parsed = parseArtifactArgs(args, run.phase);
+			if (!parsed) {
+				ctx.ui.notify("Usage: /kd-artifact [phase] [content]", "error");
+				return;
+			}
+
+			const path = parsed.content
+				? updatePhaseArtifact(ctx.cwd, run, parsed.phase, parsed.content)
+				: ensurePhaseArtifact(ctx.cwd, run, parsed.phase);
+			ctx.ui.notify(`Artifact ready: ${path}`, "info");
+		},
+	});
+}

package/extensions/kingdee-header.ts

@@ -0,0 +1,122 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+
+type KdPhase = "discuss" | "spec" | "plan" | "execute" | "verify" | "ship";
+
+interface ActiveRun {
+	id?: string;
+	phase?: KdPhase;
+	product?: string;
+	profile?: {
+		product?: string;
+		techStack?: string;
+		language?: string;
+	};
+	risk?: "low" | "medium" | "high";
+	gate?: {
+		passed?: boolean;
+		reason?: string;
+	};
+}
+
+function readActiveRun(cwd: string): ActiveRun | undefined {
+	const activeRunPath = join(cwd, ".pi", "kd", "active-run.json");
+	if (!existsSync(activeRunPath)) return undefined;
+
+	try {
+		return JSON.parse(readFileSync(activeRunPath, "utf8")) as ActiveRun;
+	} catch {
+		return undefined;
+	}
+}
+
+function formatProduct(run: ActiveRun | undefined): string {
+	if (!run) return "unselected";
+	const product = run.profile?.product ?? run.product ?? "unknown";
+	const techStack = run.profile?.techStack ?? "unknown";
+	const language = run.profile?.language ?? "unknown";
+	return `${product}/${techStack}/${language}`;
+}
+
+function formatPhase(phase: ActiveRun["phase"]): string {
+	return phase ?? "idle";
+}
+
+function formatGate(run: ActiveRun | undefined): string {
+	if (!run?.gate) return "gate: pending";
+	if (run.gate.passed) return "gate: pass";
+	return `gate: blocked${run.gate.reason ? ` - ${run.gate.reason}` : ""}`;
+}
+
+function padOrTrim(text: string, width: number): string {
+	if (width <= 0) return "";
+	if (text.length > width) return text.slice(0, Math.max(0, width - 1)) + ">";
+	return text + " ".repeat(width - text.length);
+}
+
+function logoLines(theme: Theme): string[] {
+	const accent = (text: string) => theme.fg("accent", text);
+	const muted = (text: string) => theme.fg("muted", text);
+
+	return [
+		`${accent("KCode")} ${muted("Kingdee Pi Harness")}`,
+		`${accent("=====")} ${muted("discuss -> spec -> plan -> execute -> verify -> ship")}`,
+	];
+}
+
+export default function (pi: ExtensionAPI) {
+	pi.on("session_start", async (_event, ctx) => {
+		if (ctx.mode !== "tui") return;
+
+		ctx.ui.setHeader((_tui, theme) => {
+			return {
+				render(width: number): string[] {
+					const run = readActiveRun(ctx.cwd);
+					const phase = formatPhase(run?.phase);
+					const product = formatProduct(run);
+					const gate = formatGate(run);
+					const risk = run?.risk ?? "unknown";
+					const runId = run?.id ?? "none";
+
+					const status = [
+						theme.fg("muted", "phase: "),
+						theme.fg("accent", phase),
+						theme.fg("muted", " | product: "),
+						theme.fg("text", product),
+						theme.fg("muted", " | risk: "),
+						theme.fg(risk === "high" ? "error" : risk === "medium" ? "warning" : "success", risk),
+						theme.fg("muted", " | "),
+						theme.fg(run?.gate?.passed === false ? "error" : "muted", gate),
+					].join("");
+
+					return [
+						"",
+						...logoLines(theme).map((line) => padOrTrim(line, width)),
+						padOrTrim(status, width),
+						padOrTrim(theme.fg("dim", `run: ${runId}`), width),
+						"",
+					];
+				},
+				invalidate() {},
+			};
+		});
+	});
+
+	pi.registerCommand("kcode-header", {
+		description: "Restore the KCode Kingdee header",
+		handler: async (_args, ctx) => {
+			if (ctx.mode !== "tui") return;
+			ctx.ui.notify("Restart the session or reload extensions to restore the KCode header.", "info");
+		},
+	});
+
+	pi.registerCommand("builtin-header", {
+		description: "Restore Pi's built-in header",
+		handler: async (_args, ctx) => {
+			if (ctx.mode !== "tui") return;
+			ctx.ui.setHeader(undefined);
+			ctx.ui.notify("Built-in header restored", "info");
+		},
+	});
+}

package/extensions/kingdee-tools.ts

@@ -0,0 +1,379 @@
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
+import { Type } from "@earendil-works/pi-ai";
+import { defineTool, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { formatSearchResults, formatTableSchema } from "../src/knowledge/format.ts";
+import { findTableSchema, searchKnowledge } from "../src/knowledge/search.ts";
+import type { Edition, KnowledgeScope } from "../src/knowledge/types.ts";
+import { resolveProductProfile, type ProductProfile } from "../src/product/profile.ts";
+import { checkCode, formatCheckResults, type CheckLanguage } from "../src/rules/checker.ts";
+import { analyzeDebugText, formatDebugFindings, planBuild, readDebugInput, runBuild } from "../src/tools/build-debug.ts";
+import {
+	cosmicApiCommand,
+	cosmicConfigCommand,
+	cosmicMetadataCommand,
+	formatCommandResult,
+	type OfficialEvidenceFile,
+	isCosmicFamily,
+	ksqlLintCommand,
+	runCommand,
+	writeOfficialEvidence,
+} from "../src/official/kingdee-skills.ts";
+
+const extensionDir = dirname(fileURLToPath(import.meta.url));
+const knowledgePath = join(extensionDir, "..", "knowledge");
+
+function normalizeEdition(value: string | undefined): Edition {
+	return value === "enterprise" ? "enterprise" : "flagship";
+}
+
+function resolveToolProfile(product: string | undefined, edition: string | undefined): ProductProfile {
+	return resolveProductProfile(product ?? edition);
+}
+
+function editionForBundledKnowledge(profile: ProductProfile, edition: string | undefined): Edition | undefined {
+	if (profile.product === "enterprise") return "enterprise";
+	if (profile.product === "flagship") return "flagship";
+	if (profile.product === "unknown" && edition) return normalizeEdition(edition);
+	return undefined;
+}
+
+function scopesForProfile(profile: ProductProfile, edition: string | undefined): KnowledgeScope[] | undefined {
+	if (profile.product === "unknown") return edition ? [normalizeEdition(edition)] : undefined;
+	if (profile.platform === "enterprise-csharp") return ["enterprise"];
+	if (profile.platform === "cosmic") {
+		const scopes: KnowledgeScope[] = ["cosmic"];
+		if (profile.knowledgeScope !== "cosmic" && profile.knowledgeScope !== "common") scopes.push(profile.knowledgeScope);
+		return scopes;
+	}
+	return undefined;
+}
+
+function normalizeLanguage(value: string | undefined): CheckLanguage {
+	return value === "csharp" ? "csharp" : "java";
+}
+
+function languageForProfile(profile: ProductProfile, value: string | undefined): CheckLanguage {
+	if (value) return normalizeLanguage(value);
+	if (profile.language === "csharp") return "csharp";
+	return "java";
+}
+
+function rejectNonCosmic(profile: ProductProfile): string | undefined {
+	if (isCosmicFamily(profile)) return undefined;
+	if (profile.product === "unknown") return "Provide a Cosmic-family product first: cangqiong, xinghan, flagship, or cosmic.";
+	return `Product ${profile.product} uses ${profile.platform}/${profile.techStack}; Cosmic official scripts are not applicable.`;
+}
+
+async function runOrDryRun(
+	commandPromise: Promise<ReturnType<typeof cosmicConfigCommand> extends Promise<infer T> ? T : never>,
+	dryRun: boolean | undefined,
+	ctx: { cwd: string },
+	evidenceFile?: OfficialEvidenceFile,
+) {
+	const command = await commandPromise;
+	if (dryRun) {
+		return {
+			content: [{ type: "text" as const, text: `Dry run command:\n${command.display}` }],
+			details: { command: command.display, dryRun: true },
+		};
+	}
+
+	const result = await runCommand(command);
+	const evidencePath = evidenceFile ? writeOfficialEvidence(ctx.cwd, evidenceFile, result) : undefined;
+	return {
+		content: [{ type: "text" as const, text: formatCommandResult(result) }],
+		details: { command: result.command, exitCode: result.exitCode, evidencePath },
+	};
+}
+
+const kdSearchTool = defineTool({
+	name: "kd_search",
+	label: "KD Search",
+	description: "Search bundled Kingdee SDK knowledge, plugin lifecycle notes, code patterns, and common implementation guidance.",
+	parameters: Type.Object({
+		query: Type.String({ description: "Keyword or API/class/table/lifecycle term to search for" }),
+		product: Type.Optional(Type.String({ description: "Kingdee product: flagship, cosmic, xinghan, cangqiong, or enterprise." })),
+		edition: Type.Optional(Type.String({ description: "Legacy alias for product. Prefer product." })),
+		limit: Type.Optional(Type.Number({ description: "Maximum number of results. Defaults to 5." })),
+	}),
+
+	async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+		const profile = resolveToolProfile(params.product, params.edition);
+		const scopes = scopesForProfile(profile, params.edition);
+		if (!scopes) {
+			const guidance =
+				profile.product === "unknown"
+					? "Provide product first, for example product=flagship, enterprise, cosmic, xinghan, or cangqiong."
+					: "No knowledge scope is configured for this product profile.";
+			return {
+				content: [
+					{
+						type: "text",
+						text: [
+							`Product profile: ${profile.product}/${profile.techStack}/${profile.language}`,
+							"Bundled searchable knowledge requires a known product profile.",
+							guidance,
+						].join("\n"),
+					},
+				],
+				details: { query: params.query, product: profile.product, knowledgeImported: false },
+			};
+		}
+
+		const limit = Math.max(1, Math.min(params.limit ?? 5, 10));
+		const results = searchKnowledge(params.query, { scopes, topK: limit, minScore: 1 }, knowledgePath);
+		return {
+			content: [{ type: "text", text: formatSearchResults(params.query, results, knowledgePath) }],
+			details: { query: params.query, product: profile.product, scopes, count: results.length },
+		};
+	},
+});
+
+const kdTableTool = defineTool({
+	name: "kd_table",
+	label: "KD Table",
+	description: "Look up a bundled Kingdee table schema by table name for the selected product profile.",
+	parameters: Type.Object({
+		table: Type.String({ description: "Table name, for example T_PUR_POORDER" }),
+		product: Type.Optional(Type.String({ description: "Kingdee product: flagship, cosmic, xinghan, cangqiong, or enterprise." })),
+		edition: Type.Optional(Type.String({ description: "Legacy alias for product. Prefer product." })),
+	}),
+
+	async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+		const profile = resolveToolProfile(params.product, params.edition);
+		const edition = editionForBundledKnowledge(profile, params.edition);
+		if (!edition) {
+			const guidance =
+				profile.product === "unknown"
+					? "Provide product first. Do not assume a table schema across Kingdee product families."
+					: "Do not reuse flagship/enterprise table assumptions for Cosmic/Xinghan/Cangqiong without metadata verification.";
+			return {
+				content: [
+					{
+						type: "text",
+						text: [
+							`Product profile: ${profile.product}/${profile.techStack}/${profile.language}`,
+							"Bundled table schemas currently cover flagship and enterprise only.",
+							guidance,
+						].join("\n"),
+					},
+				],
+				details: { table: params.table, product: profile.product, knowledgeImported: false },
+			};
+		}
+
+		const schema = findTableSchema(params.table, edition, knowledgePath);
+		return {
+			content: [{ type: "text", text: formatTableSchema(params.table, schema) }],
+			details: { table: params.table, product: profile.product, edition, found: Boolean(schema) },
+		};
+	},
+});
+
+const kdCheckTool = defineTool({
+	name: "kd_check",
+	label: "KD Check",
+	description:
+		"Check Kingdee Java/C# plugin code for magic values, naming issues, DB calls in loops, and empty catch blocks.",
+	parameters: Type.Object({
+		code: Type.Optional(Type.String({ description: "Source code to check. Use this or path." })),
+		path: Type.Optional(Type.String({ description: "Path to a source file to check. Use this or code." })),
+		product: Type.Optional(Type.String({ description: "Kingdee product. Used to derive Java or C# when language is omitted." })),
+		language: Type.Optional(Type.String({ description: "Language: java or csharp. Overrides product-derived language." })),
+	}),
+
+	async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+		const profile = resolveToolProfile(params.product, undefined);
+		const language = languageForProfile(profile, params.language);
+		let code = params.code;
+		let source = "inline";
+
+		if (!code && params.path) {
+			const filePath = join(ctx.cwd, params.path);
+			code = readFileSync(filePath, "utf8");
+			source = params.path;
+		}
+
+		if (!code) {
+			return {
+				content: [{ type: "text", text: "Provide either code or path for kd_check." }],
+				details: { error: "missing-code-or-path" },
+			};
+		}
+
+		const results = checkCode(code, language);
+		return {
+			content: [
+				{
+					type: "text",
+					text: `Source: ${source}\nProduct: ${profile.product}/${profile.techStack}\nLanguage: ${language}\n\n${formatCheckResults(results)}`,
+				},
+			],
+			details: { source, product: profile.product, language, issues: results },
+		};
+	},
+});
+
+const kdCosmicConfigTool = defineTool({
+	name: "kd_cosmic_config",
+	label: "KD Cosmic Config",
+	description: "Run the official ok-cosmic configuration precheck for Cosmic-family Kingdee products.",
+	parameters: Type.Object({
+		product: Type.String({ description: "Cosmic-family product: cangqiong, xinghan, flagship, or cosmic." }),
+		config: Type.Optional(Type.String({ description: "Optional ok-cosmic.json path. Defaults to current working directory behavior." })),
+		dryRun: Type.Optional(Type.Boolean({ description: "Return the command without executing it." })),
+	}),
+
+	async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+		const profile = resolveToolProfile(params.product, undefined);
+		const rejection = rejectNonCosmic(profile);
+		if (rejection) return { content: [{ type: "text", text: rejection }], details: { rejected: true, product: profile.product } };
+		return runOrDryRun(cosmicConfigCommand(ctx.cwd, params.config), params.dryRun, ctx, "cosmic-config.txt");
+	},
+});
+
+const kdCosmicMetadataTool = defineTool({
+	name: "kd_cosmic_metadata",
+	label: "KD Cosmic Metadata",
+	description: "Query official Cosmic form/bill metadata for fields, enum values, operations, and SQL table details.",
+	parameters: Type.Object({
+		product: Type.String({ description: "Cosmic-family product: cangqiong, xinghan, flagship, or cosmic." }),
+		form: Type.String({ description: "Form ID, bill ID, or Chinese bill name. Multiple targets can be comma-separated." }),
+		config: Type.Optional(Type.String({ description: "Optional ok-cosmic.json path." })),
+		fuzzy: Type.Optional(Type.String({ description: "Optional field keywords separated by spaces or commas." })),
+		typeFilter: Type.Optional(Type.String({ description: "Optional field type regex, for example combo|check or decimal." })),
+		sql: Type.Optional(Type.Boolean({ description: "Include database table and field information." })),
+		op: Type.Optional(Type.Boolean({ description: "Show operations for the form/bill." })),
+		showDetail: Type.Optional(Type.Boolean({ description: "Show detailed metadata output." })),
+		dryRun: Type.Optional(Type.Boolean({ description: "Return the command without executing it." })),
+	}),
+
+	async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+		const profile = resolveToolProfile(params.product, undefined);
+		const rejection = rejectNonCosmic(profile);
+		if (rejection) return { content: [{ type: "text", text: rejection }], details: { rejected: true, product: profile.product } };
+		return runOrDryRun(cosmicMetadataCommand(ctx.cwd, params), params.dryRun, ctx, "cosmic-metadata.json");
+	},
+});
+
+const kdCosmicApiTool = defineTool({
+	name: "kd_cosmic_api",
+	label: "KD Cosmic API",
+	description: "Query official Cosmic API knowledge for class names, method names, and method signatures.",
+	parameters: Type.Object({
+		product: Type.String({ description: "Cosmic-family product: cangqiong, xinghan, flagship, or cosmic." }),
+		mode: Type.String({ description: "search, search-method, or detail." }),
+		query: Type.String({ description: "Class name, method name, or fully qualified class name." }),
+		config: Type.Optional(Type.String({ description: "Optional ok-cosmic.json path." })),
+		method: Type.Optional(Type.String({ description: "Optional method filter for detail mode." })),
+		compact: Type.Optional(Type.Boolean({ description: "Request compact detail output when supported." })),
+		dryRun: Type.Optional(Type.Boolean({ description: "Return the command without executing it." })),
+	}),
+
+	async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+		const profile = resolveToolProfile(params.product, undefined);
+		const rejection = rejectNonCosmic(profile);
+		if (rejection) return { content: [{ type: "text", text: rejection }], details: { rejected: true, product: profile.product } };
+		if (!["search", "search-method", "detail"].includes(params.mode)) {
+			return { content: [{ type: "text", text: "mode must be one of: search, search-method, detail" }], details: { error: "invalid-mode" } };
+		}
+		return runOrDryRun(
+			cosmicApiCommand(ctx.cwd, {
+				...params,
+				mode: params.mode as "search" | "search-method" | "detail",
+			}),
+			params.dryRun,
+			ctx,
+			"cosmic-api.txt",
+		);
+	},
+});
+
+const kdKsqlLintTool = defineTool({
+	name: "kd_ksql_lint",
+	label: "KD KSQL Lint",
+	description: "Run the official ok-ksql lint script against a generated KSQL/SQL file.",
+	parameters: Type.Object({
+		product: Type.String({ description: "Cosmic-family product: cangqiong, xinghan, flagship, or cosmic." }),
+		path: Type.String({ description: "SQL/KSQL file path, relative to workspace or absolute." }),
+		dryRun: Type.Optional(Type.Boolean({ description: "Return the command without executing it." })),
+	}),
+
+	async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+		const profile = resolveToolProfile(params.product, undefined);
+		const rejection = rejectNonCosmic(profile);
+		if (rejection) return { content: [{ type: "text", text: rejection }], details: { rejected: true, product: profile.product } };
+		return runOrDryRun(ksqlLintCommand(ctx.cwd, params.path), params.dryRun, ctx, "ksql-lint.txt");
+	},
+});
+
+const kdBuildTool = defineTool({
+	name: "kd_build",
+	label: "KD Build",
+	description: "Run or dry-run a product-aware Kingdee build command for Cosmic Java or enterprise C# projects.",
+	parameters: Type.Object({
+		product: Type.String({ description: "Kingdee product: cangqiong, xinghan, flagship, cosmic, or enterprise." }),
+		target: Type.Optional(Type.String({ description: "Optional Gradle/Maven task for Java or .sln/.csproj path for C#." })),
+		dryRun: Type.Optional(Type.Boolean({ description: "Return the build command without executing it." })),
+	}),
+
+	async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+		const profile = resolveToolProfile(params.product, undefined);
+		try {
+			const plan = planBuild(ctx.cwd, profile, params.target);
+			return runBuild(plan, params.dryRun);
+		} catch (error) {
+			return {
+				content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+				details: { error: "build-plan-failed", product: profile.product },
+			};
+		}
+	},
+});
+
+const kdDebugTool = defineTool({
+	name: "kd_debug",
+	label: "KD Debug",
+	description: "Analyze Kingdee build/runtime logs or stack traces and map them to likely causes and next checks.",
+	parameters: Type.Object({
+		text: Type.Optional(Type.String({ description: "Log text or stack trace. Use this or path." })),
+		path: Type.Optional(Type.String({ description: "Path to a log file. Use this or text." })),
+		product: Type.Optional(Type.String({ description: "Optional product hint for context." })),
+	}),
+
+	async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+		const profile = resolveToolProfile(params.product, undefined);
+		try {
+			const input = readDebugInput(ctx.cwd, params.text, params.path);
+			const findings = analyzeDebugText(input.text);
+			return {
+				content: [
+					{
+						type: "text",
+						text: `Source: ${input.source}\nProduct: ${profile.product}/${profile.platform}/${profile.techStack}\n\n${formatDebugFindings(findings)}`,
+					},
+				],
+				details: { source: input.source, product: profile.product, findings },
+			};
+		} catch (error) {
+			return {
+				content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+				details: { error: "debug-input-failed", product: profile.product },
+			};
+		}
+	},
+});
+
+export default function (pi: ExtensionAPI) {
+	pi.registerTool(kdSearchTool);
+	pi.registerTool(kdTableTool);
+	pi.registerTool(kdCheckTool);
+	pi.registerTool(kdCosmicConfigTool);
+	pi.registerTool(kdCosmicMetadataTool);
+	pi.registerTool(kdCosmicApiTool);
+	pi.registerTool(kdKsqlLintTool);
+	pi.registerTool(kdBuildTool);
+	pi.registerTool(kdDebugTool);
+}

package/knowledge/.backup/v1.0.0/version.json

@@ -0,0 +1,10 @@
+{
+  "version": "1.0.0",
+  "lastUpdated": "2026-05-29",
+  "modules": [
+    "common",
+    "flagship",
+    "enterprise"
+  ],
+  "checksum": ""
+}