pi-harness-runtime 0.10.7 → 0.10.12

package/packages/knowledge-retrieval/src/types.ts

@@ -0,0 +1,112 @@
+/**
+ * Knowledge Retrieval Types (RFC-0105)
+ *
+ * Types for TencentDB-Agent-Memory MCP integration.
+ */
+
+/**
+ * Configuration for TencentDB-Agent-Memory server connection
+ */
+export interface KnowledgeRetrievalConfig {
+  /** Server URL (e.g., http://localhost:8080 or https://memory.example.com) */
+  serverUrl: string;
+  /** Optional API key for authentication */
+  apiKey?: string;
+  /** Default max results per search */
+  maxResults?: number;
+  /** Request timeout in ms */
+  timeoutMs?: number;
+}
+
+/**
+ * Search query options
+ */
+export interface SearchOptions {
+  /** Search query string */
+  query: string;
+  /** Max results to return (default: 5) */
+  limit?: number;
+  /** Filter by tags */
+  tags?: string[];
+  /** Filter by source path */
+  source?: string;
+}
+
+/**
+ * Search result item
+ */
+export interface SearchResult {
+  /** Unique result ID */
+  id: string;
+  /** Document title */
+  title: string;
+  /** Document content/summary */
+  content: string;
+  /** Relevance score (0-1) */
+  score: number;
+  /** Original source path */
+  source: string;
+  /** Document tags */
+  tags: string[];
+  /** Links to other OKF documents */
+  links: string[];
+  /** Last updated timestamp */
+  updatedAt: string;
+}
+
+/**
+ * Code graph query result
+ */
+export interface CodeGraphResult {
+  /** Symbol/function name */
+  symbol: string;
+  /** File path */
+  file: string;
+  /** Symbol type (function, class, etc.) */
+  kind: string;
+  /** Callers of this symbol */
+  callers: string[];
+  /** Callees of this symbol */
+  callees: string[];
+  /** Impact paths */
+  impactPaths: string[];
+}
+
+/**
+ * Sync result
+ */
+export interface SyncResult {
+  /** Total skills processed */
+  total: number;
+  /** Successfully synced */
+  success: number;
+  /** Failed syncs */
+  failed: number;
+  /** Errors if any */
+  errors: string[];
+}
+
+/**
+ * OKF document format for ingestion
+ */
+export interface OKFDocument {
+  id: string;
+  title: string;
+  sections: OKFSection[];
+  links: string[];
+  metadata: OKFMetadata;
+}
+
+export interface OKFSection {
+  id: string;
+  title: string;
+  content: string;
+  level: number;
+}
+
+export interface OKFMetadata {
+  source: string;
+  tags: string[];
+  created: string;
+  updated: string;
+}

package/packages/okf-indexer/src/cli.ts

@@ -0,0 +1,25 @@
+/**
+ * CLI for indexing SKILL.md files (RFC-0106)
+ *
+ * Usage:
+ *   bun run index [directory] [--output <file>] [--format json|codegraph]
+ */
+
+import { indexDirectory, toCodeGraph, type OKFDocument } from "./indexer.js";
+
+const args = process.argv.slice(2);
+const dir = args[0] || ".";
+const outputArg = args.indexOf("--output");
+const outputFile = outputArg >= 0 ? args[outputArg + 1] : null;
+
+const docs = indexDirectory(dir);
+console.error(`Indexed ${docs.length} skills from ${dir}`);
+
+if (outputFile) {
+  const fs = await import("node:fs");
+  const data = docs.map((d) => ({ ...d, _graph: toCodeGraph(d) }));
+  fs.writeFileSync(outputFile, JSON.stringify(data, null, 2));
+  console.error(`Written to ${outputFile}`);
+} else {
+  console.log(JSON.stringify(docs, null, 2));
+}

package/packages/okf-indexer/src/indexer.ts

@@ -0,0 +1,186 @@
+/**
+ * OKF Indexer (RFC-0106)
+ *
+ * Parses SKILL.md files and extracts structured knowledge for
+ * indexing into TencentDB-Agent-Memory CodeGraph.
+ */
+
+import { readFileSync, readdirSync } from "node:fs";
+import { join, relative, basename } from "node:path";
+
+/**
+ * OKF Document structure
+ */
+export interface OKFDocument {
+  id: string;
+  title: string;
+  slug: string;
+  sections: OKFSection[];
+  links: string[];
+  metadata: OKFMetadata;
+}
+
+export interface OKFSection {
+  id: string;
+  title: string;
+  content: string;
+  level: number;
+  bullets: string[];
+}
+
+export interface OKFMetadata {
+  source: string;
+  tags: string[];
+  created: string;
+  updated: string;
+  scope?: string;
+}
+
+/**
+ * Parse frontmatter from SKILL.md
+ */
+function parseFrontmatter(content: string): Record<string, string | string[]> {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+
+  const result: Record<string, string | string[]> = {};
+  for (const line of match[1].split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx <= 0) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const val = line.slice(colonIdx + 1).trim();
+    if (val.startsWith("[") && val.endsWith("]")) {
+      result[key] = val.slice(1, -1).split(",").map((s) => s.trim());
+    } else {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+
+/**
+ * Extract markdown sections
+ */
+function extractSections(content: string): OKFSection[] {
+  const sections: OKFSection[] = [];
+  const lines = content.split("\n");
+  let current: Partial<OKFSection> | null = null;
+  let bodyLines: string[] = [];
+
+  for (const line of lines) {
+    const h2 = line.match(/^## (.+)/);
+    const h3 = line.match(/^### (.+)/);
+
+    if (h2 || h3) {
+      if (current && current.title) {
+        sections.push({
+          id: current.id!,
+          title: current.title,
+          content: bodyLines.join("\n").trim(),
+          level: current.level!,
+          bullets: bodyLines.filter((l) => l.trim().startsWith("- ")).map((l) => l.replace(/^-\s*/, "").trim()),
+        });
+      }
+      current = {
+        id: (h2 || h3)![1].toLowerCase().replace(/\s+/g, "-"),
+        title: (h2 || h3)![1],
+        level: h2 ? 2 : 3,
+      };
+      bodyLines = [];
+    } else {
+      bodyLines.push(line);
+    }
+  }
+
+  if (current && current.title) {
+    sections.push({
+      id: current.id!,
+      title: current.title,
+      content: bodyLines.join("\n").trim(),
+      level: current.level!,
+      bullets: bodyLines.filter((l) => l.trim().startsWith("- ")).map((l) => l.replace(/^-\s*/, "").trim()),
+    });
+  }
+
+  return sections;
+}
+
+/**
+ * Extract wiki-style links
+ */
+function extractLinks(content: string): string[] {
+  const links: string[] = [];
+  const regex = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
+  let m;
+  while ((m = regex.exec(content)) !== null) links.push(m[1]);
+  return [...new Set(links)];
+}
+
+/**
+ * Index a single SKILL.md file
+ */
+export function indexSkill(filePath: string, basePath: string): OKFDocument | null {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const fm = parseFrontmatter(content);
+    const sections = extractSections(content);
+    const links = extractLinks(content);
+    const name = basename(filePath, ".md");
+
+    return {
+      id: name.toLowerCase().replace(/\s+/g, "-"),
+      title: (fm.name as string) || name,
+      slug: name,
+      sections,
+      links,
+      metadata: {
+        source: relative(basePath, filePath),
+        tags: Array.isArray(fm.tags) ? fm.tags : [],
+        created: (fm.created as string) || new Date().toISOString(),
+        updated: new Date().toISOString(),
+        scope: fm.scope as string,
+      },
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Index all skills in a directory
+ */
+export function indexDirectory(dirPath: string): OKFDocument[] {
+  const docs: OKFDocument[] = [];
+
+  function walk(current: string) {
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      const full = join(current, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.name === "SKILL.md" || entry.name.endsWith(".skill.md")) {
+        const doc = indexSkill(full, dirPath);
+        if (doc) docs.push(doc);
+      }
+    }
+  }
+
+  walk(dirPath);
+  return docs;
+}
+
+/**
+ * Convert OKF document to CodeGraph nodes/edges for TencentDB
+ */
+export function toCodeGraph(doc: OKFDocument): {
+  nodes: Array<{ id: string; type: string; data: Record<string, unknown> }>;
+  edges: Array<{ from: string; to: string; type: string }>;
+} {
+  const nodes = [
+    { id: doc.id, type: "skill", data: { title: doc.title, slug: doc.slug, source: doc.metadata.source } },
+    ...doc.sections.map((s) => ({ id: `${doc.id}#${s.id}`, type: "section", data: { title: s.title, level: s.level } })),
+  ];
+
+  const edges = doc.sections.map((s) => ({ from: doc.id, to: `${doc.id}#${s.id}`, type: "has_section" }));
+  edges.push(...doc.links.map((l) => ({ from: doc.id, to: l.toLowerCase().replace(/\s+/g, "-"), type: "links_to" })));
+
+  return { nodes, edges };
+}

package/packages/providers/dist/{adapters.d.ts → src/adapters.d.ts}

@@ -9,7 +9,7 @@
  * - retry policy
  * - model capability metadata
  */
-import type { ProviderConfig, ProviderCapability, ProviderRequest, ProviderResponse } from "../../packages/types/src/runtime-types.js";
+import type { ProviderConfig, ProviderCapability, ProviderRequest, ProviderResponse } from "../../types/src/runtime-types.js";
 export interface AdapterConfig {
     provider: ProviderConfig;
     quotaSignalExtractor?: (error: unknown) => QuotaSignal | null;

package/packages/providers/dist/{deepagents-adapter.d.ts → src/deepagents-adapter.d.ts}

@@ -6,7 +6,7 @@
  *
  * @module deepagents-adapter
  */
-import type { AgentWorker, AgentWorkerConfig, AgentStatus, TaskRequest, TaskResult, HealthStatus, AgentWorkerEvents } from "../../packages/types/src/agent-worker-types.js";
+import type { AgentWorker, AgentWorkerConfig, AgentStatus, TaskRequest, TaskResult, HealthStatus, AgentWorkerEvents } from "../../types/src/agent-worker-types.js";
 /**
  * DeepAgents Adapter
  *

package/packages/providers/src/adapters.ts

@@ -15,7 +15,7 @@ import type {
 	ProviderCapability,
 	ProviderRequest,
 	ProviderResponse,
-} from "../../packages/types/src/runtime-types.js";
+} from "../../types/src/runtime-types.js";
 
 export interface AdapterConfig {
 	provider: ProviderConfig;

package/packages/providers/src/deepagents-adapter.ts

@@ -20,8 +20,8 @@ import type {
 	DeepAgentsConfig,
 	DeepAgentsTaskRequest,
 	DeepAgentsResult,
-} from "../../packages/types/src/agent-worker-types.js";
-import type { RuntimeTask } from "../../packages/types/src/runtime-types.js";
+} from "../../types/src/agent-worker-types.js";
+import type { RuntimeTask } from "../../types/src/runtime-types.js";
 
 /**
  * DeepAgents Adapter

package/packages/quota-manager/dist/{quota-manager.d.ts → src/quota-manager.d.ts}

@@ -4,7 +4,7 @@
  * Collects quota signals from API responses, provider status,
  * Playwright, and local estimates. Produces provider availability state.
  */
-import type { QuotaSignal, QuotaState } from "../../packages/types/src/runtime-types.js";
+import type { QuotaSignal, QuotaState } from "../../types/src/runtime-types.js";
 export interface QuotaSignalInput {
     provider: string;
     source: "api_response" | "provider_status" | "playwright" | "local_estimate" | "tui_message";

package/packages/quota-manager/src/quota-manager.ts

@@ -5,10 +5,7 @@
  * Playwright, and local estimates. Produces provider availability state.
  */
 
-import type {
-	QuotaSignal,
-	QuotaState,
-} from "../../packages/types/src/runtime-types.js";
+import type { QuotaSignal, QuotaState } from "../../types/src/runtime-types.js";
 
 export interface QuotaSignalInput {
 	provider: string;

package/packages/runtime/dist/{runtime-api.d.ts → src/runtime-api.d.ts}

@@ -22,7 +22,7 @@
  */
 import { EventEmitter } from "node:events";
 import type { JobStateMachine } from "../../harness/job-state-machine.js";
-import type { TaskGraphManager } from "../../harness/task-graph.js";
+import type { TaskGraphManager } from "../../../harness/task-graph.js";
 import type { CheckpointManager } from "../../harness/job-state-machine.js";
 export interface RuntimeApiConfig {
     /** Port to listen on (default: 3849) */

package/packages/runtime/src/runtime-api.ts

@@ -26,7 +26,7 @@ import { WebSocketServer, WebSocket } from "ws";
 import { URL } from "node:url";
 import { EventEmitter } from "node:events";
 import type { JobStateMachine } from "../../harness/job-state-machine.js";
-import type { TaskGraphManager } from "../../harness/task-graph.js";
+import type { TaskGraphManager } from "../../../harness/task-graph.js";
 import type { CheckpointManager } from "../../harness/job-state-machine.js";
 
 export interface RuntimeApiConfig {
@@ -512,22 +512,22 @@ export class RuntimeApi extends EventEmitter {
 		// Get job details
 		if (method === "GET") {
 			const checkpoint = await machine.getCheckpoint();
-				const graph = this.taskGraphs.get(jobId);
-				// Get progress from task graph
-				let progress = { total: 0, done: 0, running: 0, failed: 0 };
-				if (graph) {
-					try {
-						const tasks = graph.getAllTasks();
-						progress = {
-							total: tasks.length,
-							done: tasks.filter((t) => t.status === "done").length,
-							running: tasks.filter((t) => t.status === "running").length,
-							failed: tasks.filter((t) => t.status === "failed").length,
-						};
-					} catch {
-						// Fallback to default
-					}
+			const graph = this.taskGraphs.get(jobId);
+			// Get progress from task graph
+			let progress = { total: 0, done: 0, running: 0, failed: 0 };
+			if (graph) {
+				try {
+					const tasks = graph.getAllTasks();
+					progress = {
+						total: tasks.length,
+						done: tasks.filter((t) => t.status === "done").length,
+						running: tasks.filter((t) => t.status === "running").length,
+						failed: tasks.filter((t) => t.status === "failed").length,
+					};
+				} catch {
+					// Fallback to default
 				}
+			}
 
 			this.sendJson(
 				res,

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

@@ -0,0 +1,130 @@
+/**
+ * TencentDB Memory Client (RFC-0105)
+ *
+ * Client for TencentDB-Agent-Memory server API.
+ * Handles skill sync, search, and management.
+ */
+
+import type {
+	TencentDBConfig,
+	SyncRequest,
+	SyncResponse,
+	SearchRequest,
+	SearchResult,
+	DeleteRequest,
+	HealthResponse,
+	SkillMetadata,
+	DEFAULT_CONFIG,
+} from "./types.js";
+
+export class TencentDBMemoryClient {
+	private config: Required<TencentDBConfig>;
+	private baseUrl: string;
+	private headers: Record<string, string>;
+
+	constructor(config: TencentDBConfig) {
+		this.config = { ...DEFAULT_CONFIG, ...config } as Required<TencentDBConfig>;
+		this.baseUrl = this.config.serverUrl.replace(/\/$/, "");
+		this.headers = {
+			"Content-Type": "application/json",
+		};
+		if (this.config.apiKey) {
+			this.headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+		}
+	}
+
+	/**
+	 * Check server health
+	 */
+	async health(): Promise<HealthResponse> {
+		const response = await fetch(`${this.baseUrl}/health`, {
+			headers: this.headers,
+		});
+		if (!response.ok) {
+			throw new Error(`Health check failed: ${response.statusText}`);
+		}
+		return response.json();
+	}
+
+	/**
+	 * Sync skills to server
+	 */
+	async syncSkills(request: SyncRequest): Promise<SyncResponse> {
+		const response = await fetch(`${this.baseUrl}/api/skills/sync`, {
+			method: "POST",
+			headers: this.headers,
+			body: JSON.stringify(request),
+		});
+		if (!response.ok) {
+			throw new Error(`Sync failed: ${response.statusText}`);
+		}
+		return response.json();
+	}
+
+	/**
+	 * Search skills
+	 */
+	async searchSkills(request: SearchRequest): Promise<SearchResult[]> {
+		const response = await fetch(`${this.baseUrl}/api/skills/search`, {
+			method: "POST",
+			headers: this.headers,
+			body: JSON.stringify(request),
+		});
+		if (!response.ok) {
+			throw new Error(`Search failed: ${response.statusText}`);
+		}
+		return response.json();
+	}
+
+	/**
+	 * Get skill by name
+	 */
+	async getSkill(name: string): Promise<SkillMetadata | null> {
+		const response = await fetch(
+			`${this.baseUrl}/api/skills/${encodeURIComponent(name)}`,
+			{ headers: this.headers },
+		);
+		if (response.status === 404) {
+			return null;
+		}
+		if (!response.ok) {
+			throw new Error(`Get skill failed: ${response.statusText}`);
+		}
+		return response.json();
+	}
+
+	/**
+	 * Delete skills
+	 */
+	async deleteSkills(request: DeleteRequest): Promise<{ deleted: number }> {
+		const response = await fetch(`${this.baseUrl}/api/skills/delete`, {
+			method: "DELETE",
+			headers: this.headers,
+			content: JSON.stringify(request),
+		});
+		if (!response.ok) {
+			throw new Error(`Delete failed: ${response.statusText}`);
+		}
+		return response.json();
+	}
+
+	/**
+	 * List all skills
+	 */
+	async listSkills(): Promise<SkillMetadata[]> {
+		const response = await fetch(`${this.baseUrl}/api/skills`, {
+			headers: this.headers,
+		});
+		if (!response.ok) {
+			throw new Error(`List skills failed: ${response.statusText}`);
+		}
+		return response.json();
+	}
+}
+
+/**
+ * Create TencentDB Memory client
+ */
+export function createTencentDBClient(config: TencentDBConfig): TencentDBMemoryClient {
+	return new TencentDBMemoryClient(config);
+}

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

@@ -0,0 +1,32 @@
+/**
+ * TencentDB Memory (RFC-0105)
+ *
+ * Client for TencentDB-Agent-Memory server.
+ * Syncs skills and provides MCP tools for centralized knowledge retrieval.
+ */
+
+export type {
+	TencentDBConfig,
+	SkillMetadata,
+	SyncRequest,
+	SyncResponse,
+	SearchRequest,
+	SearchResult,
+	DeleteRequest,
+	HealthResponse,
+} from "./types.js";
+
+export { TencentDBMemoryClient, createTencentDBClient } from "./client.js";
+export {
+	loadSkill,
+	loadSkillsFromDirectory,
+	loadSkillsFromDirectories,
+} from "./loader.js";
+
+export type {
+	MCPTool,
+	MCPToolCall,
+	ToolCallResult,
+} from "./types.js";
+
+export { getTencentDBTools, TencentDBToolHandler } from "./mcp-tools.js";