pi-harness-runtime 0.10.7 → 0.10.12

package/packages/tencentdb-memory/src/loader.ts

@@ -0,0 +1,150 @@
+/**
+ * Skill Loader (RFC-0105)
+ *
+ * Loads and parses SKILL.md files from local skills directory.
+ * Converts to SkillMetadata for sync to TencentDB server.
+ */
+
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, basename, relative } from "node:path";
+import type { SkillMetadata } from "./types.js";
+
+/**
+ * Parse SKILL.md frontmatter
+ */
+function parseFrontmatter(content: string): Record<string, unknown> {
+	const match = content.match(/^---\n([\s\S]*?)\n---/);
+	if (!match) {
+		return {};
+	}
+	const yaml = match[1];
+	const result: Record<string, unknown> = {};
+
+	// Simple YAML parser for our format
+	for (const line of yaml.split("\n")) {
+		const colonIndex = line.indexOf(":");
+		if (colonIndex > 0) {
+			const key = line.slice(0, colonIndex).trim();
+			let value: string | string[] = line.slice(colonIndex + 1).trim();
+			// Handle array values (hyphen format)
+			if (value.startsWith("[") && value.endsWith("]")) {
+				value = value
+					.slice(1, -1)
+					.split(",")
+					.map((v) => v.trim());
+			}
+			result[key] = value;
+		}
+	}
+	return result;
+}
+
+/**
+ * Extract section content
+ */
+function extractSection(
+	content: string,
+	sectionName: string,
+): string[] | undefined {
+	const pattern = new RegExp(
+		`^##\\s+${sectionName}[^#]*\\n([\\s\\S]*?)(?=^##\\s|\\n---)`,
+		"im",
+	);
+	const match = content.match(pattern);
+	if (match) {
+		// Extract bullet points
+		return match[1]
+			.split("\n")
+			.filter((line) => line.trim().startsWith("- "))
+			.map((line) => line.replace(/^-\s*/, "").trim());
+	}
+	return undefined;
+}
+
+/**
+ * Load a single SKILL.md file
+ */
+export function loadSkill(
+	filePath: string,
+	basePath: string,
+): SkillMetadata | null {
+	try {
+		const content = readFileSync(filePath, "utf-8");
+		const stats = statSync(filePath);
+		const frontmatter = parseFrontmatter(content);
+
+		// Extract sections
+		const whenToUse = extractSection(content, "When to Use");
+		const procedureSteps = extractSection(content, "Procedure");
+		const pitfalls = extractSection(content, "Pitfalls");
+		const verificationSteps = extractSection(content, "Verification");
+
+		// Extract tags from frontmatter or content
+		const tags = (frontmatter.tags as string[]) || frontmatter.tag
+			? [(frontmatter.tag || frontmatter.tags) as string].flat()
+			: [];
+
+		// Extract related skills
+		const relatedSkills = extractSection(content, "Related Skills");
+
+		const name = basename(filePath, ".md");
+
+		return {
+			name,
+			description: (frontmatter.description as string) || "",
+			whenToUse: whenToUse?.join("\n"),
+			procedureSteps,
+			pitfalls,
+			verificationSteps,
+			relatedSkills,
+			tags,
+			sourcePath: relative(basePath, filePath),
+			lastModified: stats.mtime.toISOString(),
+		};
+	} catch (error) {
+		console.error(`Failed to load skill from ${filePath}:`, error);
+		return null;
+	}
+}
+
+/**
+ * Recursively load all skills from a directory
+ */
+export function loadSkillsFromDirectory(dirPath: string): SkillMetadata[] {
+	const skills: SkillMetadata[] = [];
+
+	function walkDirectory(currentPath: string): void {
+		const entries = readdirSync(currentPath, { withFileTypes: true });
+
+		for (const entry of entries) {
+			const fullPath = join(currentPath, entry.name);
+
+			if (entry.isDirectory()) {
+				// Recurse into subdirectories
+				walkDirectory(fullPath);
+			} else if (entry.name === "SKILL.md" || entry.name.endsWith(".md")) {
+				const skill = loadSkill(fullPath, dirPath);
+				if (skill) {
+					skills.push(skill);
+				}
+			}
+		}
+	}
+
+	walkDirectory(dirPath);
+	return skills;
+}
+
+/**
+ * Load skills from multiple directories
+ */
+export function loadSkillsFromDirectories(
+	dirPaths: string[],
+): SkillMetadata[] {
+	const allSkills: SkillMetadata[] = [];
+	for (const dirPath of dirPaths) {
+		const skills = loadSkillsFromDirectory(dirPath);
+		allSkills.push(...skills);
+	}
+	return allSkills;
+}

package/packages/tencentdb-memory/src/mcp-tools.ts

@@ -0,0 +1,213 @@
+/**
+ * MCP Tools for TencentDB Memory (RFC-0105)
+ *
+ * Provides MCP tools for agents to query centralized skills.
+ */
+
+import type {
+	MCPTool,
+	MCPToolCall,
+	ToolCallResult,
+	TencentDBConfig,
+	SearchRequest,
+} from "./types.js";
+import { TencentDBMemoryClient } from "./client.js";
+import { loadSkillsFromDirectories } from "./loader.js";
+
+// --- Tool Definitions ----------------------------------------------------------
+
+export function getTencentDBTools(config: TencentDBConfig): MCPTool[] {
+	return [
+		{
+			name: "tencentdb_search_skills",
+			description:
+				"Search skills from centralized knowledge base. Use when you need to find relevant skills or procedures for a task.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					query: {
+						type: "string",
+						description: "Search query text",
+					},
+					tags: {
+						type: "array",
+						items: { type: "string" },
+						description: "Filter by tags (optional)",
+					},
+					limit: {
+						type: "number",
+						description: "Maximum results (default: 5)",
+					},
+				},
+				required: ["query"],
+			},
+		},
+		{
+			name: "tencentdb_sync_skills",
+			description:
+				"Sync local skills directory to centralized server. Use when local skills have been updated.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					directories: {
+						type: "array",
+						items: { type: "string" },
+						description:
+							"List of directories containing SKILL.md files",
+					},
+					force: {
+						type: "boolean",
+						description: "Force sync (ignore timestamp check)",
+					},
+				},
+				required: ["directories"],
+			},
+		},
+		{
+			name: "tencentdb_list_skills",
+			description: "List all available skills from centralized knowledge base.",
+			inputSchema: {
+				type: "object",
+				properties: {},
+			},
+		},
+		{
+			name: "tencentdb_health",
+			description: "Check if TencentDB Memory server is healthy.",
+			inputSchema: {
+				type: "object",
+				properties: {},
+			},
+		},
+	];
+}
+
+// --- Tool Handler -------------------------------------------------------------
+
+export class TencentDBToolHandler {
+	private client: TencentDBMemoryClient;
+	private localDirs?: string[];
+
+	constructor(config: TencentDBConfig) {
+		this.client = new TencentDBMemoryClient(config);
+	}
+
+	/**
+	 * Set local directories for sync
+	 */
+	setLocalDirectories(dirs: string[]): void {
+		this.localDirs = dirs;
+	}
+
+	/**
+	 * Handle tool call
+	 */
+	async handleToolCall(call: MCPToolCall): Promise<ToolCallResult> {
+		try {
+			switch (call.name) {
+				case "tencentdb_search_skills": {
+					const args = call.arguments as Partial<SearchRequest>;
+					const results = await this.client.searchSkills({
+						query: args.query || "",
+						tags: args.tags,
+						limit: args.limit || 5,
+						includeDetails: true,
+					});
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(results, null, 2),
+							},
+						],
+					};
+				}
+
+				case "tencentdb_sync_skills": {
+					const args = call.arguments as {
+						directories?: string[];
+						force?: boolean;
+					};
+					const dirs = args.directories || this.localDirs || [];
+					if (dirs.length === 0) {
+						return {
+							content: [
+								{
+									type: "text",
+									text: JSON.stringify(
+										{
+											error: "No directories specified",
+										},
+										null,
+										2,
+									),
+								},
+							],
+							isError: true,
+						};
+					}
+					const skills = loadSkillsFromDirectories(dirs);
+					const result = await this.client.syncSkills({
+						skills,
+						force: args.force,
+					});
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(result, null, 2),
+							},
+						],
+					};
+				}
+
+				case "tencentdb_list_skills": {
+					const skills = await this.client.listSkills();
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(skills, null, 2),
+							},
+						],
+					};
+				}
+
+				case "tencentdb_health": {
+					const health = await this.client.health();
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(health, null, 2),
+							},
+						],
+					};
+				}
+
+				default:
+					return {
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify({ error: `Unknown tool: ${call.name}` }),
+							},
+						],
+						isError: true,
+					};
+			}
+		} catch (error) {
+			return {
+				content: [
+					{
+						type: "text",
+						text: JSON.stringify({
+							error: error instanceof Error ? error.message : String(error),
+						}),
+					},
+				],
+				isError: true,
+			};
+		}
+	}
+}

package/packages/tencentdb-memory/src/types.ts

@@ -0,0 +1,101 @@
+/**
+ * TencentDB Memory Client Types (RFC-0105)
+ *
+ * Client for TencentDB-Agent-Memory server API.
+ * Syncs skills and knowledge to centralized memory server.
+ */
+
+// --- Config Types ------------------------------------------------------------
+
+export interface TencentDBConfig {
+	/** Server URL (e.g., http://localhost:3000 or https://memory.example.com) */
+	serverUrl: string;
+	/** API key for authentication */
+	apiKey?: string;
+	/** Default embedding model */
+	embeddingModel?: string;
+	/** Chunk size for documents */
+	chunkSize?: number;
+	/** Chunk overlap */
+	chunkOverlap?: number;
+}
+
+export const DEFAULT_CONFIG: Partial<TencentDBConfig> = {
+	chunkSize: 512,
+	chunkOverlap: 50,
+	embeddingModel: "bge-m3",
+};
+
+// --- Skill Types (from SKILL.md) ----------------------------------------------
+
+export interface SkillMetadata {
+	/** Skill name (slug) */
+	name: string;
+	/** Skill description */
+	description: string;
+	/** When to use this skill */
+	whenToUse?: string;
+	/** List of procedure steps */
+	procedureSteps?: string[];
+	/** Pitfalls and gotchas */
+	pitfalls?: string[];
+	/** Verification steps */
+	verificationSteps?: string[];
+	/** Related skills */
+	relatedSkills?: string[];
+	/** Tags for categorization */
+	tags: string[];
+	/** Source file path */
+	sourcePath: string;
+	/** Last modified */
+	lastModified: string;
+}
+
+// --- API Types ----------------------------------------------------------------
+
+export interface SyncRequest {
+	/** Skills to sync */
+	skills: SkillMetadata[];
+	/** Force sync (ignore timestamp check) */
+	force?: boolean;
+}
+
+export interface SyncResponse {
+	success: boolean;
+	synced: number;
+	failed: number;
+	errors?: string[];
+}
+
+export interface SearchRequest {
+	/** Query text */
+	query: string;
+	/** Filter by tags */
+	tags?: string[];
+	/** Maximum results */
+	limit?: number;
+	/** Include skill details */
+	includeDetails?: boolean;
+}
+
+export interface SearchResult {
+	id: string;
+	name: string;
+	description: string;
+	tags: string[];
+	similarity: number;
+	/** Full skill content if includeDetails=true */
+	content?: string;
+	metadata?: SkillMetadata;
+}
+
+export interface DeleteRequest {
+	/** Skill name(s) to delete */
+	names: string[];
+}
+
+export interface HealthResponse {
+	status: "ok" | "error";
+	version: string;
+	skillsCount: number;
+}