kcode-pi 0.1.0 → 0.1.2

package/src/official/kingdee-skills.ts

@@ -0,0 +1,230 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
+import type { ProductProfile } from "../product/profile.ts";
+import { readActiveRun } from "../harness/state.ts";
+import { runArtifactPath } from "../harness/paths.ts";
+
+const execFileAsync = promisify(execFile);
+
+export type OfficialSkillKey = "ok-cosmic" | "ok-ksql";
+
+export interface CommandSpec {
+	executable: string;
+	args: string[];
+	cwd: string;
+	display: string;
+}
+
+export interface CommandResult {
+	command: string;
+	exitCode: number;
+	stdout: string;
+	stderr: string;
+}
+
+export type OfficialEvidenceFile = "cosmic-config.txt" | "cosmic-metadata.json" | "cosmic-api.txt" | "ksql-lint.txt";
+
+const SKILL_DIRS: Record<OfficialSkillKey, string> = {
+	"ok-cosmic": "ok-cosmic",
+	"ok-ksql": "ok-ksql",
+};
+
+const packageRoot = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+
+export function isCosmicFamily(profile: ProductProfile): boolean {
+	return profile.platform === "cosmic";
+}
+
+export function officialSkillsSourceRoot(): string {
+	return officialSkillsSourceRoots()[0];
+}
+
+export function officialSkillsSourceRoots(): string[] {
+	return [
+		process.env.KCODE_KINGDEE_SKILLS_ROOT,
+		join(packageRoot, "vendor", "kingdee-skills"),
+		"E:\\projects\\kingdee\\skills",
+	].filter((value): value is string => Boolean(value));
+}
+
+export function officialSkillsCacheRoot(cwd: string): string {
+	return join(cwd, ".pi", "kd", "official-skills");
+}
+
+export async function ensureOfficialSkillRoot(_cwd: string, skill: OfficialSkillKey): Promise<string> {
+	for (const sourceRoot of officialSkillsSourceRoots()) {
+		const expandedSource = join(sourceRoot, SKILL_DIRS[skill]);
+		if (existsSync(expandedSource)) return expandedSource;
+	}
+
+	throw new Error(`Official skill directory not found for ${skill}. Checked: ${officialSkillsSourceRoots().join(", ")}`);
+}
+
+export function resolveWorkspacePath(cwd: string, path: string): string {
+	return isAbsolute(path) ? path : resolve(cwd, path);
+}
+
+export function pythonExecutable(): string {
+	return process.env.KCODE_PYTHON ?? (process.platform === "win32" ? "python" : "python3");
+}
+
+export function buildPythonCommand(cwd: string, scriptPath: string, args: string[]): CommandSpec {
+	const executable = pythonExecutable();
+	const fullArgs = [scriptPath, ...args];
+	return {
+		executable,
+		args: fullArgs,
+		cwd,
+		display: formatCommand(executable, fullArgs),
+	};
+}
+
+export async function runCommand(command: CommandSpec, timeoutMs = 120_000): Promise<CommandResult> {
+	try {
+		const result = await execFileAsync(command.executable, command.args, {
+			cwd: command.cwd,
+			timeout: timeoutMs,
+			maxBuffer: 1024 * 1024 * 4,
+		});
+
+		return {
+			command: command.display,
+			exitCode: 0,
+			stdout: result.stdout ?? "",
+			stderr: result.stderr ?? "",
+		};
+	} catch (error) {
+		const err = error as {
+			code?: number | string;
+			stdout?: string;
+			stderr?: string;
+			message?: string;
+		};
+
+		return {
+			command: command.display,
+			exitCode: typeof err.code === "number" ? err.code : 1,
+			stdout: err.stdout ?? "",
+			stderr: err.stderr ?? err.message ?? "",
+		};
+	}
+}
+
+export async function cosmicConfigCommand(cwd: string, config?: string): Promise<CommandSpec> {
+	const root = await ensureOfficialSkillRoot(cwd, "ok-cosmic");
+	const script = join(root, "scripts", "cosmic-config-check.py");
+	const args = config ? ["--config", resolveWorkspacePath(cwd, config)] : [];
+	return buildPythonCommand(cwd, script, args);
+}
+
+export async function cosmicMetadataCommand(
+	cwd: string,
+	params: {
+		form: string;
+		config?: string;
+		fuzzy?: string;
+		typeFilter?: string;
+		sql?: boolean;
+		op?: boolean;
+		showDetail?: boolean;
+	},
+): Promise<CommandSpec> {
+	const root = await ensureOfficialSkillRoot(cwd, "ok-cosmic");
+	const script = join(root, "scripts", "cosmic-form-metadata.py");
+	const args = withConfig(["get", params.form], cwd, params.config);
+	if (params.sql) args.push("--sql");
+	if (params.op) args.push("--op");
+	if (params.showDetail) args.push("--show-detail");
+	if (params.fuzzy) args.push("--fuzzy", ...splitTerms(params.fuzzy));
+	if (params.typeFilter) args.push("--type", params.typeFilter);
+	return buildPythonCommand(cwd, script, args);
+}
+
+export async function cosmicApiCommand(
+	cwd: string,
+	params: {
+		mode: "search" | "search-method" | "detail";
+		query: string;
+		config?: string;
+		method?: string;
+		compact?: boolean;
+	},
+): Promise<CommandSpec> {
+	const root = await ensureOfficialSkillRoot(cwd, "ok-cosmic");
+	const script = join(root, "scripts", "cosmic-api-knowledge.py");
+	const args = withConfig([params.mode, params.query], cwd, params.config);
+	if (params.method) args.push("--method", params.method);
+	if (params.compact) args.push("--compact");
+	return buildPythonCommand(cwd, script, args);
+}
+
+export async function ksqlLintCommand(cwd: string, path: string): Promise<CommandSpec> {
+	const root = await ensureOfficialSkillRoot(cwd, "ok-ksql");
+	const script = join(root, "scripts", "ksql_lint.py");
+	return buildPythonCommand(cwd, script, [resolveWorkspacePath(cwd, path)]);
+}
+
+export function formatCommandResult(result: CommandResult): string {
+	return [
+		`Command: ${result.command}`,
+		`Exit: ${result.exitCode}`,
+		result.stdout.trim() ? `\nSTDOUT:\n${result.stdout.trim()}` : undefined,
+		result.stderr.trim() ? `\nSTDERR:\n${result.stderr.trim()}` : undefined,
+	]
+		.filter(Boolean)
+		.join("\n");
+}
+
+export function writeOfficialEvidence(cwd: string, evidenceFile: OfficialEvidenceFile, result: CommandResult): string | undefined {
+	const run = readActiveRun(cwd);
+	if (!run) return undefined;
+
+	const path = runArtifactPath(cwd, run, join("evidence", evidenceFile));
+	mkdirSync(dirname(path), { recursive: true });
+
+	const content =
+		evidenceFile === "cosmic-metadata.json"
+			? formatJsonEvidence(evidenceFile, result)
+			: `${formatCommandResult(result)}\nCaptured: ${new Date().toISOString()}\n`;
+	writeFileSync(path, content.endsWith("\n") ? content : `${content}\n`, "utf8");
+	return path;
+}
+
+function formatJsonEvidence(evidenceFile: OfficialEvidenceFile, result: CommandResult): string {
+	return `${JSON.stringify(
+		{
+			evidence: evidenceFile,
+			capturedAt: new Date().toISOString(),
+			command: result.command,
+			exitCode: result.exitCode,
+			stdout: result.stdout,
+			stderr: result.stderr,
+		},
+		null,
+		2,
+	)}\n`;
+}
+
+function withConfig(args: string[], cwd: string, config?: string): string[] {
+	if (!config) return args;
+	return ["--config", resolveWorkspacePath(cwd, config), ...args];
+}
+
+function splitTerms(value: string): string[] {
+	return value
+		.split(/[,\s]+/)
+		.map((term) => term.trim())
+		.filter(Boolean);
+}
+
+function formatCommand(executable: string, args: string[]): string {
+	return [executable, ...args].map(quoteArg).join(" ");
+}
+
+function quoteArg(value: string): string {
+	if (!/[\s"'&|<>]/.test(value)) return value;
+	return `"${value.replace(/"/g, '\\"')}"`;
+}

package/src/product/profile.ts

@@ -0,0 +1,115 @@
+export type KdProduct = "unknown" | "flagship" | "cosmic" | "xinghan" | "cangqiong" | "enterprise";
+export type KdPlatform = "unknown" | "cosmic" | "enterprise-csharp";
+export type KdTechStack = "unknown" | "java-bos" | "java-cosmic" | "csharp-bos" | "ksql";
+export type KdLanguage = "unknown" | "java" | "csharp" | "sql";
+export type KnowledgeScope = "common" | "flagship" | "enterprise" | "cosmic" | "xinghan" | "cangqiong";
+
+export interface ProductProfile {
+	product: KdProduct;
+	displayName: string;
+	platform: KdPlatform;
+	techStack: KdTechStack;
+	language: KdLanguage;
+	knowledgeScope: KnowledgeScope;
+	requiresMetadataVerification: boolean;
+	notes: string[];
+}
+
+const PROFILES: Record<KdProduct, ProductProfile> = {
+	unknown: {
+		product: "unknown",
+		displayName: "unknown",
+		platform: "unknown",
+		techStack: "unknown",
+		language: "unknown",
+		knowledgeScope: "common",
+		requiresMetadataVerification: true,
+		notes: ["Product is not selected; do not assume Java, C#, BOS, Cosmic, or KSQL rules."],
+	},
+	flagship: {
+		product: "flagship",
+		displayName: "Kingdee Xingkong Flagship",
+		platform: "cosmic",
+		techStack: "java-cosmic",
+		language: "java",
+		knowledgeScope: "flagship",
+		requiresMetadataVerification: true,
+		notes: ["Xingkong Flagship is Cosmic-family. Use Cosmic metadata, plugin lifecycle, SDK, and post-check constraints."],
+	},
+	cosmic: {
+		product: "cosmic",
+		displayName: "Kingdee Cosmic Platform",
+		platform: "cosmic",
+		techStack: "java-cosmic",
+		language: "java",
+		knowledgeScope: "cosmic",
+		requiresMetadataVerification: true,
+		notes: ["Cosmic is the shared platform base for Cangqiong, Xinghan, and Xingkong Flagship."],
+	},
+	xinghan: {
+		product: "xinghan",
+		displayName: "Kingdee Xinghan",
+		platform: "cosmic",
+		techStack: "java-cosmic",
+		language: "java",
+		knowledgeScope: "xinghan",
+		requiresMetadataVerification: true,
+		notes: ["Treat as Cosmic-family Java unless a Xinghan-specific rule overrides it."],
+	},
+	cangqiong: {
+		product: "cangqiong",
+		displayName: "Kingdee Cangqiong",
+		platform: "cosmic",
+		techStack: "java-cosmic",
+		language: "java",
+		knowledgeScope: "cangqiong",
+		requiresMetadataVerification: true,
+		notes: ["Use Cangqiong/Cosmic plugin, SDK, metadata, KSQL, and lifecycle rules."],
+	},
+	enterprise: {
+		product: "enterprise",
+		displayName: "Kingdee Enterprise",
+		platform: "enterprise-csharp",
+		techStack: "csharp-bos",
+		language: "csharp",
+		knowledgeScope: "enterprise",
+		requiresMetadataVerification: true,
+		notes: ["Use enterprise C# stack. Java plugin rules and Cosmic APIs are not applicable."],
+	},
+};
+
+const PRODUCT_ALIASES: Array<[RegExp, KdProduct]> = [
+	[/企业版|enterprise|csharp|c#|\.net/i, "enterprise"],
+	[/星瀚|xinghan/i, "xinghan"],
+	[/苍穹|cangqiong/i, "cangqiong"],
+	[/cosmic|云苍穹/i, "cosmic"],
+	[/星空旗舰版|星空旗舰|旗舰版|旗舰|flagship/i, "flagship"],
+];
+
+export function profileForProduct(product: KdProduct | undefined): ProductProfile {
+	return PROFILES[product ?? "unknown"] ?? PROFILES.unknown;
+}
+
+export function resolveProductProfile(input: string | undefined): ProductProfile {
+	const text = input?.trim();
+	if (!text) return profileForProduct("unknown");
+
+	for (const [pattern, product] of PRODUCT_ALIASES) {
+		if (pattern.test(text)) return profileForProduct(product);
+	}
+
+	return profileForProduct("unknown");
+}
+
+export function normalizeProduct(value: string | undefined): KdProduct {
+	return resolveProductProfile(value).product;
+}
+
+export function isKnownProduct(product: KdProduct | undefined): boolean {
+	return Boolean(product && product !== "unknown");
+}
+
+export function formatProductProfile(profile: ProductProfile | undefined): string {
+	const resolved = profile ?? profileForProduct("unknown");
+	return `${resolved.product}/${resolved.platform}/${resolved.techStack}/${resolved.language}`;
+}