@xopcai/xopc 0.0.189 → 0.0.190

package/dist/src/agent/code-intelligence/runtime.js

@@ -1,280 +0,0 @@
-import { resolveStateDir } from "../../config/paths-state.js";
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-import { init_paths } from "../../config/paths.js";
-import { XopcStdioClientTransport } from "../mcp/mcp-stdio-transport.js";
-import { ensureCodebaseMemoryBinary } from "./binary.js";
-import { isAbsolute, join, relative, resolve, sep } from "node:path";
-import { mkdirSync } from "node:fs";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-//#region src/agent/code-intelligence/runtime.ts
-init_paths();
-init_logger();
-const log = createLogger("CodeIntelligence");
-function deriveProjectName(workspace) {
-	return workspace.replace(/^[\\/]+/, "").replace(/[\\/:]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-}
-function timeout(promise, timeoutMs, operation) {
-	return new Promise((resolvePromise, reject) => {
-		const timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`${operation} timed out after ${timeoutMs}ms`)), timeoutMs);
-		promise.then((value) => {
-			clearTimeout(timer);
-			resolvePromise(value);
-		}, (error) => {
-			clearTimeout(timer);
-			reject(error);
-		});
-	});
-}
-function resultText(result) {
-	const parts = [];
-	for (const item of result.content ?? []) if (item.type === "text" && typeof item.text === "string") parts.push(item.text);
-	return parts.join("\n").trim();
-}
-function parseJsonRecord(text) {
-	try {
-		const parsed = JSON.parse(text);
-		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
-	} catch {
-		return;
-	}
-}
-function abortError() {
-	return new DOMException("Code intelligence operation aborted", "AbortError");
-}
-var CodeIntelligenceRuntime = class {
-	workspace;
-	project;
-	getConfig;
-	state = "idle";
-	coverage = "unknown";
-	indexedAt;
-	errorMessage;
-	dirtyPaths = /* @__PURE__ */ new Set();
-	dirtyVersion = 0;
-	refreshTimer;
-	connectionPromise;
-	indexPromise;
-	client;
-	transport;
-	availableTools = /* @__PURE__ */ new Set();
-	disposed = false;
-	constructor(options) {
-		this.workspace = resolve(options.workspace);
-		this.project = deriveProjectName(this.workspace);
-		this.getConfig = options.getConfig;
-	}
-	getStatus() {
-		return {
-			state: this.state,
-			workspace: this.workspace,
-			project: this.project,
-			indexedAt: this.indexedAt,
-			dirtyPaths: [...this.dirtyPaths].toSorted(),
-			coverage: this.coverage,
-			errorMessage: this.errorMessage
-		};
-	}
-	supportsTool(name) {
-		return this.availableTools.has(name);
-	}
-	async prime() {
-		const config = this.getConfig().codeIntelligence;
-		if (!config.enabled || !config.autoIndex || this.disposed) return;
-		if (this.indexPromise) return this.indexPromise;
-		if (this.indexedAt && this.dirtyPaths.size === 0) return;
-		await this.refreshIndex();
-	}
-	markDirty(paths) {
-		const config = this.getConfig().codeIntelligence;
-		if (!config.enabled || !config.autoRefresh || this.disposed) return;
-		let changed = false;
-		for (const input of paths) {
-			if (!input?.trim()) continue;
-			const absolute = isAbsolute(input) ? resolve(input) : resolve(this.workspace, input);
-			const rel = relative(this.workspace, absolute);
-			if (!rel || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) continue;
-			this.dirtyPaths.add(rel.split(sep).join("/"));
-			changed = true;
-		}
-		if (!changed) return;
-		this.dirtyVersion += 1;
-		if (this.state === "ready" || this.state === "degraded") this.state = "dirty";
-		if (this.refreshTimer) clearTimeout(this.refreshTimer);
-		this.refreshTimer = setTimeout(() => {
-			this.refreshTimer = void 0;
-			this.refreshIndex().catch(() => {});
-		}, config.refreshDebounceMs);
-		this.refreshTimer.unref?.();
-	}
-	async callTool(toolNames, input, signal) {
-		if (signal?.aborted) throw abortError();
-		const config = this.getConfig().codeIntelligence;
-		if (!config.enabled) throw new Error("Code intelligence is disabled");
-		if (config.autoIndex && (this.indexedAt === void 0 || this.state === "idle" || this.dirtyPaths.size > 0)) await this.refreshIndex();
-		else await this.ensureConnected();
-		if (signal?.aborted) throw abortError();
-		const names = typeof toolNames === "string" ? [toolNames] : [...toolNames];
-		const toolName = names.find((name) => this.availableTools.has(name));
-		if (!toolName) throw new Error(`CBM does not expose a supported tool: ${names.join(" or ")}`);
-		const result = await this.callRaw(toolName, input, config.queryTimeoutMs);
-		const text = resultText(result);
-		if (result.isError) throw new Error(text || `CBM ${toolName} failed`);
-		return {
-			text,
-			status: this.getStatus()
-		};
-	}
-	async ensureConnected() {
-		if (this.disposed) throw new Error("Code intelligence runtime is disposed");
-		if (this.client && this.transport) return;
-		if (this.connectionPromise) return this.connectionPromise;
-		this.connectionPromise = (async () => {
-			this.state = "connecting";
-			const config = this.getConfig().codeIntelligence;
-			const binary = await ensureCodebaseMemoryBinary(config.binaryPath);
-			const cacheDir = join(resolveStateDir(), "code-intelligence", "cbm");
-			mkdirSync(cacheDir, { recursive: true });
-			const transport = new XopcStdioClientTransport({
-				command: binary,
-				cwd: this.workspace,
-				env: {
-					CBM_ALLOWED_ROOT: this.workspace,
-					CBM_CACHE_DIR: cacheDir,
-					CBM_LOG_LEVEL: process.env.XOPC_LOG_LEVEL === "debug" ? "debug" : "warn"
-				},
-				stderr: "pipe"
-			});
-			const client = new Client({
-				name: "xopc-code-intelligence",
-				version: "1.0.0"
-			});
-			transport.stderr?.on("data", (chunk) => {
-				for (const line of String(chunk).split(/\r?\n/)) if (line.trim()) log.debug({ workspace: this.workspace }, `CBM: ${line.trim()}`);
-			});
-			try {
-				await timeout(client.connect(transport), 3e4, "CBM connection");
-				const toolNames = /* @__PURE__ */ new Set();
-				let cursor;
-				do {
-					const page = await timeout(client.listTools(cursor ? { cursor } : void 0), 2e4, "CBM tool discovery");
-					for (const tool of page.tools) toolNames.add(tool.name);
-					cursor = page.nextCursor;
-				} while (cursor);
-				this.client = client;
-				this.transport = transport;
-				this.availableTools = toolNames;
-				this.state = this.dirtyPaths.size > 0 ? "dirty" : "idle";
-				this.errorMessage = void 0;
-				log.info({
-					workspace: this.workspace,
-					project: this.project,
-					toolCount: this.availableTools.size
-				}, "Code intelligence runtime connected");
-			} catch (error) {
-				await transport.close().catch(() => {});
-				await client.close().catch(() => {});
-				throw error;
-			}
-		})();
-		try {
-			await this.connectionPromise;
-		} catch (error) {
-			this.state = "unavailable";
-			this.errorMessage = error instanceof Error ? error.message : String(error);
-			log.warn({
-				err: error,
-				workspace: this.workspace,
-				project: this.project
-			}, `Code intelligence unavailable: ${this.errorMessage}`);
-			throw error;
-		} finally {
-			this.connectionPromise = void 0;
-		}
-	}
-	async refreshIndex() {
-		if (this.disposed) throw new Error("Code intelligence runtime is disposed");
-		if (this.indexPromise) return this.indexPromise;
-		const versionAtStart = this.dirtyVersion;
-		this.indexPromise = (async () => {
-			await this.ensureConnected();
-			const config = this.getConfig().codeIntelligence;
-			this.state = "indexing";
-			const result = await this.callRaw("index_repository", {
-				repo_path: this.workspace,
-				name: this.project,
-				mode: config.indexMode,
-				persistence: false
-			}, config.indexTimeoutMs);
-			const text = resultText(result);
-			const parsed = parseJsonRecord(text);
-			const resultStatus = typeof parsed?.status === "string" ? parsed.status : "indexed";
-			if (result.isError || resultStatus === "error") throw new Error(text || "CBM indexing failed");
-			this.indexedAt = (/* @__PURE__ */ new Date()).toISOString();
-			this.coverage = resultStatus === "degraded" ? "partial" : "unknown";
-			this.errorMessage = void 0;
-			if (versionAtStart === this.dirtyVersion) {
-				this.dirtyPaths.clear();
-				this.state = resultStatus === "degraded" ? "degraded" : "ready";
-			} else this.state = "dirty";
-			log.info({
-				workspace: this.workspace,
-				project: this.project,
-				indexMode: config.indexMode,
-				status: resultStatus,
-				dirtyPaths: this.dirtyPaths.size
-			}, "Code intelligence index refreshed");
-		})();
-		try {
-			await this.indexPromise;
-		} catch (error) {
-			this.state = "degraded";
-			this.coverage = "unknown";
-			this.errorMessage = error instanceof Error ? error.message : String(error);
-			log.warn({
-				err: error,
-				workspace: this.workspace,
-				project: this.project
-			}, `Code intelligence indexing failed: ${this.errorMessage}`);
-			throw error;
-		} finally {
-			this.indexPromise = void 0;
-			if (!this.disposed && this.dirtyPaths.size > 0 && versionAtStart !== this.dirtyVersion) queueMicrotask(() => void this.refreshIndex().catch(() => {}));
-		}
-	}
-	async callRaw(toolName, input, timeoutMs) {
-		await this.ensureConnected();
-		if (!this.client) throw new Error("CBM client is not connected");
-		if (!this.availableTools.has(toolName)) throw new Error(`CBM tool is unavailable: ${toolName}`);
-		try {
-			return await timeout(this.client.callTool({
-				name: toolName,
-				arguments: input
-			}), timeoutMs, `CBM ${toolName}`);
-		} catch (error) {
-			this.state = "unavailable";
-			this.errorMessage = error instanceof Error ? error.message : String(error);
-			await this.resetConnection();
-			throw error;
-		}
-	}
-	async resetConnection() {
-		const transport = this.transport;
-		const client = this.client;
-		this.transport = void 0;
-		this.client = void 0;
-		this.availableTools.clear();
-		await client?.close().catch(() => {});
-		await transport?.close().catch(() => {});
-	}
-	async dispose() {
-		if (this.disposed) return;
-		this.disposed = true;
-		this.state = "disposed";
-		if (this.refreshTimer) clearTimeout(this.refreshTimer);
-		this.refreshTimer = void 0;
-		await this.resetConnection();
-	}
-};
-//#endregion
-export { CodeIntelligenceRuntime };

package/dist/src/agent/code-intelligence/tool-gating.d.ts

@@ -1,5 +0,0 @@
-export interface CodeIntelligenceAgentGateConfig {
-    enabled?: boolean;
-    agentIds?: readonly string[];
-}
-export declare function isCodeIntelligenceEnabledForAgent(config: CodeIntelligenceAgentGateConfig | undefined, agentId: string | undefined): boolean;

package/dist/src/agent/code-intelligence/tool-gating.js

@@ -1,6 +0,0 @@
-//#region src/agent/code-intelligence/tool-gating.ts
-function isCodeIntelligenceEnabledForAgent(config, agentId) {
-	return config?.enabled === true && agentId !== void 0 && config.agentIds?.includes(agentId) === true;
-}
-//#endregion
-export { isCodeIntelligenceEnabledForAgent };

package/dist/src/agent/code-intelligence/tools.d.ts

@@ -1,6 +0,0 @@
-import type { AgentTool } from '@earendil-works/pi-agent-core';
-import type { CodeIntelligenceRuntimeLike } from './types.js';
-export interface CodeIntelligenceToolDeps {
-    getRuntime: () => CodeIntelligenceRuntimeLike;
-}
-export declare function createCodeIntelligenceTools(deps: CodeIntelligenceToolDeps): AgentTool[];

package/dist/src/agent/code-intelligence/tools.js

@@ -1,266 +0,0 @@
-import { execFile } from "node:child_process";
-import { Type } from "@sinclair/typebox";
-import { promisify } from "node:util";
-//#region src/agent/code-intelligence/tools.ts
-const execFileAsync = promisify(execFile);
-function statusHeader(status) {
-	const fields = [
-		`project=${status.project}`,
-		`freshness=${status.state}`,
-		`coverage=${status.coverage}`
-	];
-	if (status.indexedAt) fields.push(`indexedAt=${status.indexedAt}`);
-	if (status.dirtyPaths.length > 0) fields.push(`dirtyPaths=${status.dirtyPaths.length}`);
-	return `[Code intelligence: ${fields.join(", ")}]`;
-}
-function success(result) {
-	return {
-		content: [{
-			type: "text",
-			text: `${statusHeader(result.status)}\n${result.text}`.trim()
-		}],
-		details: { codeIntelligence: result.status }
-	};
-}
-function failure(error, runtime) {
-	const status = runtime.getStatus();
-	const message = error instanceof Error ? error.message : String(error);
-	return {
-		content: [{
-			type: "text",
-			text: `${statusHeader(status)}\nCode intelligence failed: ${message}\nUse grep/find/read_file for direct source inspection and do not infer absence from the graph.`
-		}],
-		details: { codeIntelligence: status }
-	};
-}
-function searchWasEmpty(text) {
-	try {
-		return JSON.parse(text).total === 0;
-	} catch {
-		return /(?:^|\n)total:\s*0(?:\n|$)/.test(text);
-	}
-}
-function escapeCypherString(value) {
-	return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-}
-function normalizeDetectChangesResult(result, limit) {
-	try {
-		const parsed = JSON.parse(result.text);
-		if (!Array.isArray(parsed.changed_files)) return result;
-		const changedFiles = [...new Set(parsed.changed_files.filter((file) => typeof file === "string"))];
-		const impactedSymbols = Array.isArray(parsed.impacted_symbols) ? parsed.impacted_symbols : [];
-		const impactedSymbolCount = impactedSymbols.length;
-		return {
-			...result,
-			text: JSON.stringify({
-				...parsed,
-				changed_files: changedFiles,
-				changed_count: changedFiles.length,
-				impacted_symbols: impactedSymbols.slice(0, limit),
-				impacted_symbol_count: impactedSymbolCount,
-				impacted_symbols_truncated: impactedSymbolCount > limit
-			})
-		};
-	} catch {
-		return result;
-	}
-}
-async function changedFilesForImpact(params) {
-	const args = ["diff", "--name-only"];
-	if (params.baseBranch) args.push(`${params.baseBranch}...HEAD`);
-	else args.push(params.since ?? "HEAD");
-	args.push("--");
-	if (params.scope) args.push(params.scope);
-	const untrackedArgs = [
-		"ls-files",
-		"--others",
-		"--exclude-standard",
-		"--"
-	];
-	if (params.scope) untrackedArgs.push(params.scope);
-	const [diff, untracked] = await Promise.all([execFileAsync("git", args, {
-		cwd: params.workspace,
-		timeout: 2e4,
-		maxBuffer: 1024 * 1024
-	}), execFileAsync("git", untrackedArgs, {
-		cwd: params.workspace,
-		timeout: 2e4,
-		maxBuffer: 1024 * 1024
-	})]);
-	return [...new Set(`${diff.stdout}\n${untracked.stdout}`.split(/\r?\n/).map((line) => line.trim()).filter(Boolean))].slice(0, 100);
-}
-async function queryImpactCompatibility(runtime, params, signal) {
-	const status = runtime.getStatus();
-	const files = await changedFilesForImpact({
-		workspace: status.workspace,
-		since: params.since,
-		baseBranch: params.baseBranch,
-		scope: params.scope
-	});
-	if (files.length === 0) return {
-		text: "No changed files found for the requested Git comparison.",
-		status
-	};
-	const predicate = files.map((file) => `changed.file_path = '${escapeCypherString(file)}'`).join(" OR ");
-	const depth = Math.max(1, Math.min(5, Math.floor(params.depth ?? 3)));
-	const limit = Math.max(1, Math.min(500, Math.floor(params.limit ?? 100)));
-	const query = [
-		"MATCH (changed)",
-		`WHERE ${predicate}`,
-		`OPTIONAL MATCH (caller)-[:CALLS*1..${depth}]->(changed)`,
-		"RETURN DISTINCT changed.qualified_name AS changed_symbol, changed.file_path AS changed_file,",
-		"caller.qualified_name AS affected_caller, caller.file_path AS affected_file",
-		`LIMIT ${limit}`
-	].join(" ");
-	const result = await runtime.callTool("query_graph", {
-		project: status.project,
-		query,
-		max_rows: limit
-	}, signal);
-	return {
-		...result,
-		text: `Changed files (${files.length}):\n${files.join("\n")}\n\nGraph impact:\n${result.text}`
-	};
-}
-function buildTool(options) {
-	return {
-		name: options.name,
-		label: options.name,
-		description: options.description,
-		parameters: options.parameters,
-		supportsParallel: true,
-		idempotent: true,
-		async execute(_toolCallId, params, signal) {
-			const runtime = options.deps.getRuntime();
-			try {
-				return success(await options.run(runtime, params, signal));
-			} catch (error) {
-				return failure(error, runtime);
-			}
-		}
-	};
-}
-const SearchSchema = Type.Object({
-	query: Type.String({ description: "Natural-language intent or symbol keywords" }),
-	label: Type.Optional(Type.String({ description: "Optional graph label such as Function, Method, Class, Interface, or Route" })),
-	filePattern: Type.Optional(Type.String({ description: "Optional file/path pattern to narrow the search" })),
-	semanticKeywords: Type.Optional(Type.Array(Type.String(), { description: "Optional semantic concepts; use 2-4 concise terms" })),
-	limit: Type.Optional(Type.Number({ description: "Maximum results, default 20" }))
-});
-const ReadSymbolSchema = Type.Object({
-	qualifiedName: Type.String({ description: "Exact qualified_name returned by code_search" }),
-	includeNeighbors: Type.Optional(Type.Boolean({ description: "Include nearby source context" }))
-});
-const TraceSchema = Type.Object({
-	functionName: Type.String({ description: "Exact or unambiguous function/method name" }),
-	direction: Type.Optional(Type.Union([
-		Type.Literal("inbound"),
-		Type.Literal("outbound"),
-		Type.Literal("both")
-	])),
-	depth: Type.Optional(Type.Number({ description: "Traversal depth, default 3" })),
-	mode: Type.Optional(Type.Union([
-		Type.Literal("calls"),
-		Type.Literal("data_flow"),
-		Type.Literal("cross_service")
-	])),
-	parameterName: Type.Optional(Type.String({ description: "Parameter to follow in data_flow mode" })),
-	includeTests: Type.Optional(Type.Boolean()),
-	riskLabels: Type.Optional(Type.Boolean())
-});
-const ImpactSchema = Type.Object({
-	since: Type.Optional(Type.String({ description: "Git ref or date, for example HEAD~1 or a tag" })),
-	baseBranch: Type.Optional(Type.String({ description: "Base branch for comparison" })),
-	scope: Type.Optional(Type.String({ description: "Optional file or directory scope" })),
-	depth: Type.Optional(Type.Number({ description: "Impact traversal depth, default 3" })),
-	limit: Type.Optional(Type.Number({ description: "Maximum impacted symbols, default 100, maximum 500" }))
-});
-const ArchitectureSchema = Type.Object({ aspects: Type.Optional(Type.Array(Type.String(), { description: "Optional aspects such as packages, boundaries, layers, entry_points, hotspots, or clusters" })) });
-function createCodeIntelligenceTools(deps) {
-	return [
-		buildTool({
-			name: "code_search",
-			description: "Search the repository knowledge graph for definitions, implementations, routes, types, and structurally important symbols. Prefer this over grep for code discovery.",
-			parameters: SearchSchema,
-			deps,
-			run: async (runtime, params, signal) => {
-				const graphResult = await runtime.callTool("search_graph", {
-					project: runtime.getStatus().project,
-					query: params.query,
-					...params.label ? { label: params.label } : {},
-					...params.filePattern ? { file_pattern: params.filePattern } : {},
-					...params.semanticKeywords?.length ? { semantic_query: params.semanticKeywords } : {},
-					limit: params.limit ?? 20
-				}, signal);
-				if (!searchWasEmpty(graphResult.text)) return graphResult;
-				const textResult = await runtime.callTool("search_code", {
-					project: runtime.getStatus().project,
-					pattern: params.query,
-					...params.filePattern ? { path_filter: params.filePattern } : {},
-					mode: "compact",
-					limit: params.limit ?? 20
-				}, signal);
-				return {
-					...textResult,
-					text: `No graph symbol matched; graph-augmented text fallback:\n${textResult.text}`
-				};
-			}
-		}),
-		buildTool({
-			name: "code_read_symbol",
-			description: "Read the exact source for a symbol returned by code_search. Use this to ground graph results in current source before editing.",
-			parameters: ReadSymbolSchema,
-			deps,
-			run: (runtime, params, signal) => runtime.callTool("get_code_snippet", {
-				project: runtime.getStatus().project,
-				qualified_name: params.qualifiedName,
-				include_neighbors: params.includeNeighbors ?? false
-			}, signal)
-		}),
-		buildTool({
-			name: "code_trace",
-			description: "Trace callers, callees, data flow, or cross-service paths for a function or method.",
-			parameters: TraceSchema,
-			deps,
-			run: (runtime, params, signal) => runtime.callTool(["trace_path", "trace_call_path"], {
-				project: runtime.getStatus().project,
-				function_name: params.functionName,
-				direction: params.direction ?? "both",
-				depth: params.depth ?? 3,
-				mode: params.mode ?? "calls",
-				...params.parameterName ? { parameter_name: params.parameterName } : {},
-				include_tests: params.includeTests ?? false,
-				risk_labels: params.riskLabels ?? false
-			}, signal)
-		}),
-		buildTool({
-			name: "code_impact",
-			description: "Map the current git diff or a git range to changed symbols, callers, and blast radius before or after edits.",
-			parameters: ImpactSchema,
-			deps,
-			run: async (runtime, params, signal) => {
-				const limit = Math.max(1, Math.min(500, Math.floor(params.limit ?? 100)));
-				if (runtime.supportsTool("detect_changes")) return normalizeDetectChangesResult(await runtime.callTool("detect_changes", {
-					project: runtime.getStatus().project,
-					...params.since || !params.baseBranch ? { since: params.since ?? "HEAD" } : {},
-					...params.baseBranch ? { base_branch: params.baseBranch } : {},
-					...params.scope ? { scope: params.scope } : {},
-					depth: params.depth ?? 3
-				}, signal), limit);
-				return queryImpactCompatibility(runtime, params, signal);
-			}
-		}),
-		buildTool({
-			name: "code_architecture",
-			description: "Get a compact repository architecture map including packages, boundaries, layers, entry points, hotspots, and graph-derived clusters.",
-			parameters: ArchitectureSchema,
-			deps,
-			run: (runtime, params, signal) => runtime.callTool("get_architecture", {
-				project: runtime.getStatus().project,
-				...params.aspects?.length ? { aspects: params.aspects } : {}
-			}, signal)
-		})
-	];
-}
-//#endregion
-export { createCodeIntelligenceTools };

package/dist/src/agent/code-intelligence/types.d.ts

@@ -1,22 +0,0 @@
-export type CodeIntelligenceState = 'idle' | 'connecting' | 'indexing' | 'ready' | 'dirty' | 'degraded' | 'unavailable' | 'disposed';
-export interface CodeIntelligenceStatus {
-    state: CodeIntelligenceState;
-    workspace: string;
-    project: string;
-    indexedAt?: string;
-    dirtyPaths: string[];
-    coverage: 'complete' | 'partial' | 'unknown';
-    errorMessage?: string;
-}
-export interface CodeIntelligenceToolResult {
-    text: string;
-    status: CodeIntelligenceStatus;
-}
-export interface CodeIntelligenceRuntimeLike {
-    prime(): Promise<void>;
-    markDirty(paths: readonly string[]): void;
-    supportsTool(name: string): boolean;
-    callTool(toolNames: string | readonly string[], input: Record<string, unknown>, signal?: AbortSignal): Promise<CodeIntelligenceToolResult>;
-    getStatus(): CodeIntelligenceStatus;
-    dispose(): Promise<void>;
-}