kcode-pi 0.1.0 → 0.1.1

package/src/knowledge/format.ts

@@ -0,0 +1,48 @@
+import { relative } from "node:path";
+import type { SearchResult, TableSchema } from "./types.ts";
+
+export function formatSearchResults(query: string, results: SearchResult[], basePath: string): string {
+	if (results.length === 0) {
+		return `No Kingdee knowledge results found for "${query}".`;
+	}
+
+	const lines = [`Kingdee knowledge results for "${query}":`, ""];
+	for (let i = 0; i < results.length; i++) {
+		const result = results[i];
+		lines.push(`[${i + 1}] ${result.section.heading}`);
+		lines.push(`Source: ${relative(basePath, result.file.path)}:${result.section.lineStart + 1}`);
+		lines.push(`Score: ${result.score.toFixed(2)}`);
+		lines.push(result.highlights[0] || result.section.content.trim().split("\n").slice(0, 5).join("\n"));
+		lines.push("");
+	}
+	return lines.join("\n").trim();
+}
+
+export function formatTableSchema(tableName: string, schema: TableSchema | undefined): string {
+	if (!schema) {
+		return `No table schema found for "${tableName}".`;
+	}
+
+	const lines = [
+		`Table: ${schema.name} (${tableName.toUpperCase()})`,
+		`Module: ${schema.module || "unknown"}`,
+		`Description: ${schema.description || "none"}`,
+		"",
+		"Fields:",
+	];
+
+	for (const field of schema.fields) {
+		const nullable = field.nullable ? "nullable" : "required";
+		lines.push(`- ${field.name} ${field.type} ${nullable} - ${field.description}`);
+	}
+
+	if (schema.relatedTables.length > 0) {
+		lines.push("", "Related tables:");
+		for (const related of schema.relatedTables) {
+			lines.push(`- ${related.table}: ${related.relation} - ${related.description}`);
+		}
+	}
+
+	return lines.join("\n");
+}
+

package/src/knowledge/loader.ts

@@ -0,0 +1,147 @@
+import { basename, extname, join } from "node:path";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import type { KnowledgeBase, KnowledgeFile, KnowledgeScope, KnowledgeSection, TableSchema } from "./types.ts";
+
+interface CacheEntry {
+	mtime: number;
+	knowledge: KnowledgeBase;
+}
+
+const cache = new Map<string, CacheEntry>();
+
+export function loadKnowledge(scope: KnowledgeScope, basePath: string): KnowledgeBase {
+	const cacheKey = `${basePath}:${scope}`;
+	const cached = cache.get(cacheKey);
+	if (cached && !isCacheStale(basePath, cached.mtime)) {
+		return cached.knowledge;
+	}
+
+	const commonPath = join(basePath, "common");
+	const editionPath = join(basePath, scope);
+	const knowledge: KnowledgeBase = {
+		common: loadDirectory(commonPath),
+		edition: loadDirectory(editionPath),
+		tables: loadTables(editionPath),
+	};
+
+	cache.set(cacheKey, { mtime: Date.now(), knowledge });
+	return knowledge;
+}
+
+function loadDirectory(dirPath: string): KnowledgeFile[] {
+	if (!existsSync(dirPath)) return [];
+
+	const files: KnowledgeFile[] = [];
+	for (const entry of readdirSync(dirPath)) {
+		const filePath = join(dirPath, entry);
+		const stat = statSync(filePath);
+		if (!stat.isFile()) continue;
+
+		const ext = extname(entry).toLowerCase();
+		if (ext !== ".md") continue;
+
+		const file = parseMarkdown(filePath, readFileSync(filePath, "utf8"), stat.mtime.toISOString());
+		files.push(file);
+	}
+	return files;
+}
+
+function parseMarkdown(filePath: string, content: string, lastModified: string): KnowledgeFile {
+	const lines = content.split("\n");
+	const sections: KnowledgeSection[] = [];
+	const tags: string[] = [];
+	let currentSection: Partial<KnowledgeSection> | undefined;
+	let title = "";
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i].replace(/\r$/, "");
+		const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+
+		if (headingMatch) {
+			if (currentSection) {
+				currentSection.lineEnd = i - 1;
+				sections.push(currentSection as KnowledgeSection);
+			}
+
+			const level = headingMatch[1].length;
+			const heading = headingMatch[2].trim();
+			if (level === 1 && !title) title = heading;
+			if (level <= 2) tags.push(heading);
+
+			currentSection = {
+				heading,
+				level,
+				content: "",
+				lineStart: i,
+				lineEnd: i,
+			};
+		} else if (currentSection) {
+			currentSection.content = `${currentSection.content ?? ""}${line}\n`;
+		}
+	}
+
+	if (currentSection) {
+		currentSection.lineEnd = lines.length - 1;
+		sections.push(currentSection as KnowledgeSection);
+	}
+
+	const fileName = basename(filePath, ".md");
+	tags.push(fileName);
+
+	return {
+		path: filePath,
+		title: title || fileName,
+		type: "markdown",
+		sections,
+		tags: [...new Set(tags)],
+		lastModified,
+	};
+}
+
+function loadTables(editionPath: string): Map<string, TableSchema> {
+	const tables = new Map<string, TableSchema>();
+	const tablesPath = join(editionPath, "tables.json");
+	if (!existsSync(tablesPath)) return tables;
+
+	const data = JSON.parse(readFileSync(tablesPath, "utf8")) as Record<string, unknown>;
+	for (const [tableName, tableData] of Object.entries(data)) {
+		const table = tableData as {
+			name?: string;
+			module?: string;
+			description?: string;
+			fields?: Array<{ name?: string; type?: string; nullable?: boolean; description?: string }>;
+			relatedTables?: Array<{ table?: string; relation?: string; description?: string }>;
+		};
+
+		tables.set(tableName.toUpperCase(), {
+			name: table.name || tableName,
+			module: table.module || "",
+			description: table.description || "",
+			fields: (table.fields || []).map((field) => ({
+				name: field.name || "",
+				type: field.type || "",
+				nullable: field.nullable ?? true,
+				description: field.description || "",
+			})),
+			relatedTables: (table.relatedTables || []).map((related) => ({
+				table: related.table || "",
+				relation: related.relation || "",
+				description: related.description || "",
+			})),
+		});
+	}
+
+	return tables;
+}
+
+function isCacheStale(knowledgePath: string, cachedMtime: number): boolean {
+	try {
+		return statSync(knowledgePath).mtimeMs > cachedMtime;
+	} catch {
+		return true;
+	}
+}
+
+export function clearKnowledgeCache(): void {
+	cache.clear();
+}

package/src/knowledge/search.ts

@@ -0,0 +1,118 @@
+import type { Edition, KnowledgeFile, KnowledgeScope, KnowledgeSection, SearchOptions, SearchResult, TableSchema } from "./types.ts";
+import { loadKnowledge } from "./loader.ts";
+
+export function searchKnowledge(query: string, options: SearchOptions = {}, basePath: string): SearchResult[] {
+	if (!query.trim()) return [];
+
+	const { tags, edition, scope, scopes, topK = 10, minScore = 0 } = options;
+	const targetScopes = normalizeScopes(scopes ?? [scope ?? edition ?? "flagship"]);
+	const results: SearchResult[] = [];
+
+	const seenFiles = new Set<string>();
+	for (const targetScope of targetScopes) {
+		const knowledge = loadKnowledge(targetScope, basePath);
+		for (const file of [...knowledge.common, ...knowledge.edition]) {
+			if (seenFiles.has(file.path)) continue;
+			seenFiles.add(file.path);
+			results.push(...searchFile(file, query, tags));
+		}
+	}
+
+	return results
+		.filter((result) => result.score >= minScore)
+		.sort((a, b) => b.score - a.score)
+		.slice(0, topK);
+}
+
+export function findTableSchema(tableName: string, edition: Edition, basePath: string): TableSchema | undefined {
+	const knowledge = loadKnowledge(edition, basePath);
+	return knowledge.tables.get(tableName.toUpperCase());
+}
+
+function normalizeScopes(scopes: KnowledgeScope[]): KnowledgeScope[] {
+	return [...new Set(scopes)];
+}
+
+function searchFile(file: KnowledgeFile, query: string, tags?: string[]): SearchResult[] {
+	if (tags?.length) {
+		const hasTag = tags.some((tag) => file.tags.some((fileTag) => fileTag.toLowerCase().includes(tag.toLowerCase())));
+		if (!hasTag) return [];
+	}
+
+	const queryTokens = tokenize(query);
+	const results: SearchResult[] = [];
+
+	for (const section of file.sections) {
+		const score = calculateScore(queryTokens, section, file);
+		if (score <= 0) continue;
+
+		results.push({
+			file,
+			section,
+			score,
+			highlights: highlightMatches(section.content, query),
+		});
+	}
+
+	return results;
+}
+
+export function tokenize(text: string): string[] {
+	return text
+		.toLowerCase()
+		.replace(/[^\w\u4e00-\u9fff]/g, " ")
+		.split(/\s+/)
+		.filter(Boolean);
+}
+
+function calculateScore(queryTokens: string[], section: KnowledgeSection, file: KnowledgeFile): number {
+	let score = 0;
+	const headingLower = section.heading.toLowerCase();
+	const contentLower = section.content.toLowerCase();
+	const titleLower = file.title.toLowerCase();
+	const fullQuery = queryTokens.join(" ");
+
+	if (fullQuery && titleLower.includes(fullQuery)) score += 5;
+	if (fullQuery && headingLower.includes(fullQuery)) score += 5;
+	if (fullQuery && contentLower.includes(fullQuery)) score += 5;
+
+	for (let i = 0; i < queryTokens.length; i++) {
+		const token = queryTokens[i];
+		const positionWeight = 1 + 1 / (i + 1);
+		if (titleLower.includes(token)) score += 3 * positionWeight;
+		if (headingLower.includes(token)) score += 2 * positionWeight;
+		if (contentLower.includes(token)) {
+			const matchCount = contentLower.split(token).length - 1;
+			score += (1 + Math.min(matchCount * 0.2, 2)) * positionWeight;
+		}
+	}
+
+	return score;
+}
+
+function highlightMatches(content: string, query: string): string[] {
+	const highlights: string[] = [];
+	const queryTokens = tokenize(query);
+	const lines = content.split("\n");
+	const matchedLines: number[] = [];
+
+	for (let i = 0; i < lines.length; i++) {
+		const lineLower = lines[i].toLowerCase();
+		if (queryTokens.some((token) => lineLower.includes(token))) {
+			matchedLines.push(i);
+		}
+	}
+
+	const visited = new Set<number>();
+	for (const lineIdx of matchedLines) {
+		if (visited.has(lineIdx)) continue;
+		const start = Math.max(0, lineIdx - 2);
+		const end = Math.min(lines.length - 1, lineIdx + 2);
+		for (let i = start; i <= end; i++) visited.add(i);
+
+		const context = lines.slice(start, end + 1).join("\n").trim();
+		if (context) highlights.push(context);
+	}
+
+	return highlights.slice(0, 3);
+}

package/src/knowledge/types.ts

@@ -0,0 +1,64 @@
+export type KnowledgeScope = "enterprise" | "flagship" | "cosmic" | "xinghan" | "cangqiong";
+export type Edition = Extract<KnowledgeScope, "enterprise" | "flagship">;
+
+export type KnowledgeFileType = "markdown" | "json";
+
+export interface KnowledgeFile {
+	path: string;
+	title: string;
+	type: KnowledgeFileType;
+	sections: KnowledgeSection[];
+	tags: string[];
+	lastModified: string;
+}
+
+export interface KnowledgeSection {
+	heading: string;
+	level: number;
+	content: string;
+	lineStart: number;
+	lineEnd: number;
+}
+
+export interface TableSchema {
+	name: string;
+	module: string;
+	description: string;
+	fields: FieldDefinition[];
+	relatedTables: RelatedTable[];
+}
+
+export interface FieldDefinition {
+	name: string;
+	type: string;
+	nullable: boolean;
+	description: string;
+}
+
+export interface RelatedTable {
+	table: string;
+	relation: string;
+	description: string;
+}
+
+export interface KnowledgeBase {
+	common: KnowledgeFile[];
+	edition: KnowledgeFile[];
+	tables: Map<string, TableSchema>;
+}
+
+export interface SearchResult {
+	file: KnowledgeFile;
+	section: KnowledgeSection;
+	score: number;
+	highlights: string[];
+}
+
+export interface SearchOptions {
+	tags?: string[];
+	edition?: Edition;
+	scope?: KnowledgeScope;
+	scopes?: KnowledgeScope[];
+	topK?: number;
+	minScore?: number;
+}

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, '\\"')}"`;
+}