@sanurb/ringi 0.2.0 → 0.2.1

package/dist/mcp.mjs

@@ -0,0 +1,1061 @@
+import { a as GitService, c as CommentService, d as ReviewId, i as ReviewService, l as TodoId, n as ExportService, o as getDiffSummary, p as ReviewSourceType, r as TodoService, s as parseDiff, t as CoreLive } from "./runtime.mjs";
+import { execFileSync } from "node:child_process";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as ManagedRuntime from "effect/ManagedRuntime";
+import * as ConfigProvider from "effect/ConfigProvider";
+import { stdin, stdout } from "node:process";
+import * as vm from "node:vm";
+import * as Duration from "effect/Duration";
+import * as ParseResult from "effect/ParseResult";
+//#region src/mcp/config.ts
+const DEFAULT_DB_PATH = ".ringi/reviews.db";
+const DEFAULT_MAX_OUTPUT_BYTES = 100 * 1024;
+const DEFAULT_TIMEOUT_MS = 3e4;
+const MAX_TIMEOUT_MS = 12e4;
+var McpConfig = class extends Context.Tag("McpConfig")() {};
+const McpConfigLive = (config) => Layer.succeed(McpConfig, config);
+const resolveRepositoryRoot = (repoOverride) => {
+	return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+		cwd: repoOverride ?? process.cwd(),
+		encoding: "utf8"
+	}).trim();
+};
+const resolveDbPath = (repoRoot, dbPathOverride) => dbPathOverride ?? `${repoRoot}/${DEFAULT_DB_PATH}`;
+const parseNumberFlag = (flagValue, fallback, name) => {
+	if (flagValue === void 0) return fallback;
+	const parsed = Number.parseInt(flagValue, 10);
+	if (!Number.isFinite(parsed) || parsed <= 0) throw new Error(`Invalid ${name}: expected a positive integer, received ${flagValue}`);
+	return parsed;
+};
+const resolveMcpConfig = (argv) => {
+	const args = [...argv];
+	const readonly = args.includes("--readonly");
+	const dbIndex = args.indexOf("--db-path");
+	const repoIndex = args.indexOf("--repo");
+	const timeoutIndex = args.indexOf("--timeout-ms");
+	const maxOutputIndex = args.indexOf("--max-output-bytes");
+	const repoRoot = resolveRepositoryRoot(repoIndex === -1 ? void 0 : args[repoIndex + 1]);
+	return {
+		cwd: process.cwd(),
+		dbPath: resolveDbPath(repoRoot, dbIndex === -1 ? void 0 : args[dbIndex + 1]),
+		defaultTimeoutMs: parseNumberFlag(timeoutIndex === -1 ? void 0 : args[timeoutIndex + 1], DEFAULT_TIMEOUT_MS, "timeout"),
+		maxOutputBytes: parseNumberFlag(maxOutputIndex === -1 ? void 0 : args[maxOutputIndex + 1], DEFAULT_MAX_OUTPUT_BYTES, "max output bytes"),
+		maxTimeoutMs: MAX_TIMEOUT_MS,
+		readonly,
+		repoRoot
+	};
+};
+//#endregion
+//#region src/mcp/errors.ts
+/**
+* MCP execution domain errors.
+*
+* All errors that can occur during sandbox execution are modeled as typed,
+* tagged errors for exhaustive handling via catchTag/catchTags.
+*/
+/** Code validation failed (empty, too long, non-string). */
+var InvalidCodeError = class extends Schema.TaggedError()("InvalidCodeError", { message: Schema.String }) {};
+/** Timeout parameter is invalid (non-finite, zero, negative). */
+var InvalidTimeoutError = class extends Schema.TaggedError()("InvalidTimeoutError", {
+	message: Schema.String,
+	received: Schema.Unknown
+}) {};
+/** Sandbox execution timed out. */
+var ExecutionTimeoutError = class extends Schema.TaggedError()("ExecutionTimeoutError", {
+	message: Schema.String,
+	timeoutMs: Schema.Number
+}) {};
+/** Sandbox execution failed with an unrecoverable error. */
+var SandboxExecutionError = class extends Schema.TaggedError()("SandboxExecutionError", {
+	error: Schema.Defect,
+	message: Schema.String
+}) {};
+//#endregion
+//#region src/mcp/namespaces.ts
+/**
+* MCP sandbox namespace factories.
+*
+* Each factory creates a frozen namespace object suitable for injection into the
+* vm.Context sandbox. Factories accept dependency-injected callbacks so they can
+* be tested without an Effect runtime.
+*/
+const PHASE_UNAVAILABLE_MESSAGE = "This capability is not available in the current server phase. Intelligence features require Phase 2.";
+const createIntelligenceNamespace = () => Object.freeze({
+	getConfidence: (_reviewId) => Promise.reject(new Error(PHASE_UNAVAILABLE_MESSAGE)),
+	getImpacts: (_reviewId) => Promise.reject(new Error(PHASE_UNAVAILABLE_MESSAGE)),
+	getRelationships: (_reviewId) => Promise.reject(new Error(PHASE_UNAVAILABLE_MESSAGE)),
+	validate: (_options) => Promise.reject(new Error(PHASE_UNAVAILABLE_MESSAGE))
+});
+const createSessionNamespace = (deps) => Object.freeze({
+	context: async () => {
+		const repo = await deps.getRepositoryInfo();
+		return {
+			activeReviewId: await deps.getLatestReviewId(),
+			activeSnapshotId: null,
+			readonly: deps.readonly,
+			repository: repo,
+			serverMode: "stdio"
+		};
+	},
+	status: async () => ({
+		activeSubscriptions: 0,
+		currentPhase: "phase1",
+		ok: true,
+		readonly: deps.readonly
+	})
+});
+const buildPreview = (diffText, source) => {
+	const files = parseDiff(diffText);
+	const summary = getDiffSummary(files);
+	return {
+		files: files.map((f) => ({
+			additions: f.additions,
+			deletions: f.deletions,
+			path: f.newPath,
+			status: f.status
+		})),
+		source,
+		summary: {
+			totalAdditions: summary.totalAdditions,
+			totalDeletions: summary.totalDeletions,
+			totalFiles: summary.totalFiles
+		}
+	};
+};
+const createSourcesNamespace = (deps) => Object.freeze({
+	list: async () => {
+		const [stagedFiles, branches, commits] = await Promise.all([
+			deps.getStagedFiles(),
+			deps.getBranches(),
+			deps.getRecentCommits()
+		]);
+		return {
+			branches: branches.map((b) => ({
+				current: b.current,
+				name: b.name
+			})),
+			recentCommits: commits.map((c) => ({
+				author: c.author,
+				date: c.date,
+				hash: c.hash,
+				message: c.message
+			})),
+			staged: { available: stagedFiles.length > 0 }
+		};
+	},
+	previewDiff: async (source) => {
+		let diffText;
+		switch (source.type) {
+			case "staged":
+				diffText = await deps.getStagedDiff();
+				break;
+			case "branch":
+				diffText = await deps.getBranchDiff(source.baseRef);
+				break;
+			case "commits":
+				diffText = await deps.getCommitDiff(source.commits);
+				break;
+			default: throw new Error(`Unsupported source type: ${source.type}`);
+		}
+		return buildPreview(diffText, source);
+	}
+});
+const createEventsNamespace = () => {
+	let subscriptionCounter = 0;
+	return Object.freeze({
+		listRecent: async (_filter) => [],
+		subscribe: async (filter) => {
+			subscriptionCounter += 1;
+			return {
+				eventTypes: filter?.eventTypes ?? [
+					"reviews.updated",
+					"comments.updated",
+					"todos.updated",
+					"files.changed"
+				],
+				id: `sub_${subscriptionCounter}`,
+				reviewId: filter?.reviewId
+			};
+		}
+	});
+};
+//#endregion
+//#region src/mcp/sandbox.ts
+/**
+* MCP sandbox global construction.
+*
+* Creates the six spec-compliant namespaces (`reviews`, `todos`, `sources`,
+* `intelligence`, `events`, `session`) from injected dependencies.
+*
+* All domain interaction goes through the `call` callback so the sandbox module
+* stays testable without an Effect runtime.
+*/
+const parseId = (value, fieldName) => {
+	if (typeof value !== "string" || value.length === 0) throw new Error(`Invalid ${fieldName}: expected a non-empty string`);
+	return value;
+};
+/**
+* Build the six frozen namespace objects for sandbox injection.
+*
+* The `call` callback wraps every domain operation with journal tracking and
+* error handling. This keeps the sandbox module free of Effect imports.
+*/
+const createSandboxGlobals = (deps) => {
+	const reviews = Object.freeze({
+		create: async (_input) => {
+			deps.requireWritable();
+			return deps.call("reviews.create", async () => {
+				throw new Error("reviews.create: not wired to runtime");
+			});
+		},
+		export: (_options) => deps.call("reviews.export", async () => {
+			throw new Error("reviews.export: not wired to runtime");
+		}),
+		get: (reviewIdValue) => {
+			parseId(reviewIdValue, "reviewId");
+			return deps.call("reviews.get", async () => {
+				throw new Error("reviews.get: not wired to runtime");
+			});
+		},
+		getComments: (reviewIdValue, _filePath) => {
+			parseId(reviewIdValue, "reviewId");
+			return deps.call("reviews.getComments", async () => {
+				throw new Error("reviews.getComments: not wired to runtime");
+			});
+		},
+		getDiff: (_query) => deps.call("reviews.getDiff", async () => {
+			throw new Error("reviews.getDiff: not wired to runtime");
+		}),
+		getFiles: (reviewIdValue) => {
+			parseId(reviewIdValue, "reviewId");
+			return deps.call("reviews.getFiles", async () => {
+				throw new Error("reviews.getFiles: not wired to runtime");
+			});
+		},
+		getStatus: (reviewIdValue) => {
+			parseId(reviewIdValue, "reviewId");
+			return deps.call("reviews.getStatus", async () => {
+				throw new Error("reviews.getStatus: not wired to runtime");
+			});
+		},
+		getSuggestions: (reviewIdValue) => {
+			parseId(reviewIdValue, "reviewId");
+			return deps.call("reviews.getSuggestions", async () => {
+				throw new Error("reviews.getSuggestions: not wired to runtime");
+			});
+		},
+		list: (_filters) => deps.call("reviews.list", async () => {
+			throw new Error("reviews.list: not wired to runtime");
+		})
+	});
+	const todos = Object.freeze({
+		add: async (_input) => {
+			deps.requireWritable();
+			return deps.call("todos.add", async () => {
+				throw new Error("todos.add: not wired to runtime");
+			});
+		},
+		clear: async (_reviewIdValue) => {
+			deps.requireWritable();
+			return deps.call("todos.clear", async () => {
+				throw new Error("todos.clear: not wired to runtime");
+			});
+		},
+		done: async (todoIdValue) => {
+			deps.requireWritable();
+			parseId(todoIdValue, "todoId");
+			return deps.call("todos.done", async () => {
+				throw new Error("todos.done: not wired to runtime");
+			});
+		},
+		list: (_filter) => deps.call("todos.list", async () => {
+			throw new Error("todos.list: not wired to runtime");
+		}),
+		move: async (todoIdValue, _positionValue) => {
+			deps.requireWritable();
+			parseId(todoIdValue, "todoId");
+			return deps.call("todos.move", async () => {
+				throw new Error("todos.move: not wired to runtime");
+			});
+		},
+		remove: async (todoIdValue) => {
+			deps.requireWritable();
+			parseId(todoIdValue, "todoId");
+			return deps.call("todos.remove", async () => {
+				throw new Error("todos.remove: not wired to runtime");
+			});
+		},
+		undone: async (todoIdValue) => {
+			deps.requireWritable();
+			parseId(todoIdValue, "todoId");
+			return deps.call("todos.undone", async () => {
+				throw new Error("todos.undone: not wired to runtime");
+			});
+		}
+	});
+	const sources = createSourcesNamespace({
+		getBranchDiff: deps.getBranchDiff,
+		getBranches: deps.getBranches,
+		getCommitDiff: deps.getCommitDiff,
+		getRecentCommits: deps.getRecentCommits,
+		getRepositoryInfo: deps.getRepositoryInfo,
+		getStagedDiff: deps.getStagedDiff,
+		getStagedFiles: deps.getStagedFiles
+	});
+	const intelligence = createIntelligenceNamespace();
+	return {
+		events: createEventsNamespace(),
+		intelligence,
+		reviews,
+		session: createSessionNamespace({
+			getLatestReviewId: deps.getLatestReviewId,
+			getRepositoryInfo: deps.getRepositoryInfo,
+			readonly: deps.readonly
+		}),
+		sources,
+		todos
+	};
+};
+//#endregion
+//#region src/mcp/schemas.ts
+/**
+* MCP sandbox input schemas.
+*
+* Centralizes all validation for sandbox namespace inputs using Effect Schema.
+* Replaces hand-written parse* helpers with declarative, composable schemas.
+*/
+const NonEmptyString = Schema.String.pipe(Schema.minLength(1));
+/**
+* Spec shape: `{ source: { type, baseRef } }`.
+* Legacy shape: `{ sourceType, sourceRef }`.
+*
+* We use Schema.Union to accept either and normalize to the legacy shape.
+*/
+const ReviewCreateFromSpec = Schema.Struct({ source: Schema.Struct({
+	baseRef: Schema.optionalWith(Schema.NullOr(Schema.String), { default: () => null }),
+	type: Schema.optionalWith(ReviewSourceType, { default: () => "staged" })
+}) });
+const ReviewCreateFromLegacy = Schema.Struct({
+	sourceRef: Schema.optionalWith(Schema.NullOr(Schema.String), { default: () => null }),
+	sourceType: Schema.optionalWith(ReviewSourceType, { default: () => "staged" })
+});
+/** Decode unknown input into a normalized ReviewCreateInput. */
+const decodeReviewCreateInput = (input) => {
+	if (typeof input === "object" && input !== null && "source" in input) {
+		const parsed = Schema.decodeUnknownSync(ReviewCreateFromSpec)(input);
+		return {
+			sourceRef: parsed.source.baseRef,
+			sourceType: parsed.source.type
+		};
+	}
+	const parsed = Schema.decodeUnknownSync(ReviewCreateFromLegacy)(input);
+	return {
+		sourceRef: parsed.sourceRef,
+		sourceType: parsed.sourceType
+	};
+};
+const ReviewExportInput = Schema.Struct({ reviewId: ReviewId });
+const ReviewDiffQuery = Schema.Struct({
+	filePath: NonEmptyString,
+	reviewId: ReviewId
+});
+const ReviewListFilters = Schema.Struct({
+	limit: Schema.optionalWith(Schema.Number, { default: () => 20 }),
+	page: Schema.optionalWith(Schema.Number, { default: () => 1 }),
+	pageSize: Schema.optionalWith(Schema.Number, { default: () => 20 }),
+	sourceType: Schema.optional(Schema.String),
+	status: Schema.optional(Schema.String)
+});
+const TodoInputFromSpec = Schema.Struct({
+	reviewId: Schema.optionalWith(Schema.NullOr(ReviewId), { default: () => null }),
+	text: NonEmptyString
+});
+const TodoInputFromLegacy = Schema.Struct({
+	content: NonEmptyString,
+	reviewId: Schema.optionalWith(Schema.NullOr(ReviewId), { default: () => null })
+});
+/** Decode unknown input into a normalized CreateTodoInput. */
+const decodeCreateTodoInput = (input) => {
+	if (typeof input === "object" && input !== null && "text" in input) {
+		const parsed = Schema.decodeUnknownSync(TodoInputFromSpec)(input);
+		return {
+			content: parsed.text,
+			reviewId: parsed.reviewId
+		};
+	}
+	const parsed = Schema.decodeUnknownSync(TodoInputFromLegacy)(input);
+	return {
+		content: parsed.content,
+		reviewId: parsed.reviewId
+	};
+};
+const TodoListFilter = Schema.Struct({ reviewId: Schema.optional(ReviewId) });
+const TodoMoveInput = Schema.Struct({
+	position: Schema.Number,
+	todoId: TodoId
+});
+//#endregion
+//#region src/mcp/execute.ts
+const MAX_CODE_LENGTH = 5e4;
+const MIN_PREVIEW_BYTES = 256;
+const clampTimeout = (requestedTimeout, config) => {
+	if (requestedTimeout === void 0) return config.defaultTimeoutMs;
+	if (!Number.isFinite(requestedTimeout) || requestedTimeout <= 0) throw new Error(`Invalid timeout: expected a positive integer, received ${requestedTimeout}`);
+	return Math.min(Math.trunc(requestedTimeout), config.maxTimeoutMs);
+};
+const formatError$1 = (error) => error instanceof Error ? error.message : String(error);
+const truncateUtf8 = (text, maxBytes) => {
+	const buffer = Buffer.from(text, "utf8");
+	if (buffer.byteLength <= maxBytes) return text;
+	return buffer.subarray(0, maxBytes).toString("utf8");
+};
+const summarizeForJournal = (value) => {
+	if (typeof value === "string") return value.length > 200 ? `${value.slice(0, 200)}…` : value;
+	if (typeof value === "number" || typeof value === "boolean" || value === null || value === void 0) return value;
+	if (Array.isArray(value)) return {
+		kind: "array",
+		length: value.length
+	};
+	if (typeof value === "object") return {
+		keys: Object.keys(value).slice(0, 10),
+		kind: "object"
+	};
+	return typeof value;
+};
+const finalizeOutput = (output, maxOutputBytes) => {
+	const serialized = JSON.stringify(output);
+	if (Buffer.byteLength(serialized, "utf8") <= maxOutputBytes) return output;
+	const previewBudget = Math.max(MIN_PREVIEW_BYTES, maxOutputBytes - Math.min(1024, Math.floor(maxOutputBytes / 4)));
+	return {
+		...output,
+		result: {
+			note: "Result truncated to fit MCP output budget",
+			preview: truncateUtf8(JSON.stringify(output.result), previewBudget)
+		},
+		truncated: true
+	};
+};
+const ensureCode = (code) => {
+	if (typeof code !== "string") throw new TypeError("Invalid code: expected a string");
+	const trimmed = code.trim();
+	if (trimmed.length === 0) throw new Error("Invalid code: expected a non-empty string");
+	if (trimmed.length > MAX_CODE_LENGTH) throw new Error(`Invalid code: maximum length is ${MAX_CODE_LENGTH} characters`);
+	return trimmed;
+};
+/** Synchronous decode — throws on failure (for use inside Promise-returning sandbox callbacks). */
+const decodeInputSync = (schema, input, operation) => {
+	try {
+		return Schema.decodeUnknownSync(schema)(input);
+	} catch (error) {
+		if (error instanceof ParseResult.ParseError) throw new TypeError(`${operation}: ${ParseResult.TreeFormatter.formatErrorSync(error)}`, { cause: error });
+		throw error;
+	}
+};
+const validateCode = (code) => Effect.try({
+	catch: (e) => new InvalidCodeError({ message: formatError$1(e) }),
+	try: () => ensureCode(code)
+});
+const validateTimeout = (requested, config) => Effect.try({
+	catch: () => new InvalidTimeoutError({
+		message: `Invalid timeout: expected a positive integer, received ${requested}`,
+		received: requested
+	}),
+	try: () => clampTimeout(requested, config)
+});
+const writeSandboxLog = (level, args) => {
+	const line = args.map((arg) => {
+		if (typeof arg === "string") return arg;
+		try {
+			return JSON.stringify(arg);
+		} catch {
+			return String(arg);
+		}
+	}).join(" ");
+	process.stderr.write(`[ringi:mcp:${level}] ${line}\n`);
+};
+const createSandboxConsole = () => Object.freeze({
+	error: (...args) => writeSandboxLog("error", args),
+	info: (...args) => writeSandboxLog("info", args),
+	log: (...args) => writeSandboxLog("log", args),
+	warn: (...args) => writeSandboxLog("warn", args)
+});
+/**
+* Runs user code in a VM sandbox with a single, deterministic timeout model:
+*
+* 1. `vm.Script.runInContext({ timeout })` — CPU-bound timeout for sync JS
+* 2. `Effect.timeoutFail` — wall-clock timeout for the full async execution
+*
+* No `Promise.race` — timeout is handled by fiber interruption which properly
+* cleans up resources. The vm timeout catches infinite sync loops while the
+* Effect timeout catches slow async operations.
+*/
+const runSandbox = (globals, code, timeoutMs) => {
+	return Effect.tryPromise({
+		catch: (error) => new SandboxExecutionError({
+			error,
+			message: formatError$1(error)
+		}),
+		try: () => {
+			const context = vm.createContext({
+				...globals,
+				Buffer: void 0,
+				clearImmediate: void 0,
+				clearInterval: void 0,
+				clearTimeout: void 0,
+				console: createSandboxConsole(),
+				fetch: void 0,
+				process: void 0,
+				queueMicrotask,
+				require: void 0,
+				setImmediate: void 0,
+				setInterval: void 0,
+				setTimeout: void 0
+			});
+			const script = new vm.Script(`"use strict"; (async () => {\n${code}\n})()`, { filename: "ringi-mcp-execute.js" });
+			return Promise.resolve(script.runInContext(context, { timeout: timeoutMs }));
+		}
+	}).pipe(Effect.timeoutFail({
+		duration: Duration.millis(timeoutMs),
+		onTimeout: () => new ExecutionTimeoutError({
+			message: `Execution timed out after ${timeoutMs}ms`,
+			timeoutMs
+		})
+	}));
+};
+const createJournal = () => {
+	const entries = [];
+	const recordSuccess = (name, result) => {
+		entries.push({
+			name,
+			ok: true,
+			result: summarizeForJournal(result)
+		});
+	};
+	const recordFailure = (name, error) => {
+		entries.push({
+			error: formatError$1(error),
+			name,
+			ok: false
+		});
+	};
+	/**
+	* Runs a runtime Effect with journal tracking. Returns a Promise for sandbox use.
+	*
+	* The R parameter accepts any subset of McpRuntimeContext — the managed runtime
+	* provides all services, so any effect requiring a subset of them is safe to run.
+	*/
+	const tracked = (runtime, name, effect) => runtime.runPromise(effect).then((result) => {
+		recordSuccess(name, result);
+		return result;
+	}, (error) => {
+		recordFailure(name, error);
+		throw error;
+	});
+	/** Promise-based call wrapper for non-Effect operations. */
+	const trackedAsync = async (name, fn) => {
+		try {
+			const result = await fn();
+			recordSuccess(name, result);
+			return result;
+		} catch (error) {
+			recordFailure(name, error);
+			throw error;
+		}
+	};
+	return {
+		entries,
+		recordFailure,
+		recordSuccess,
+		tracked,
+		trackedAsync
+	};
+};
+const buildSandboxGlobals = (runtime, config, journal) => {
+	const { tracked, trackedAsync } = journal;
+	const throwIfReadonly = () => {
+		if (config.readonly) throw new Error("Mutation rejected: MCP server is running in readonly mode");
+	};
+	const run = (name, effect) => tracked(runtime, name, effect);
+	const baseGlobals = createSandboxGlobals({
+		call: trackedAsync,
+		getBranchDiff: (branch) => run("git.getBranchDiff", Effect.gen(function* getBranchDiff() {
+			return yield* (yield* GitService).getBranchDiff(branch);
+		})),
+		getBranches: () => run("git.getBranches", Effect.gen(function* getBranches() {
+			return yield* (yield* GitService).getBranches;
+		})),
+		getCommitDiff: (shas) => run("git.getCommitDiff", Effect.gen(function* getCommitDiff() {
+			return yield* (yield* GitService).getCommitDiff(shas);
+		})),
+		getLatestReviewId: async () => {
+			return (await run("reviews.latestId", Effect.gen(function* result() {
+				return yield* (yield* ReviewService).list({
+					page: 1,
+					pageSize: 1,
+					repositoryPath: config.repoRoot
+				});
+			}))).reviews[0]?.id ?? null;
+		},
+		getRecentCommits: async () => {
+			return (await run("git.getCommits", Effect.gen(function* result() {
+				return yield* (yield* GitService).getCommits({
+					limit: 10,
+					offset: 0
+				});
+			}))).commits;
+		},
+		getRepositoryInfo: () => run("git.getRepositoryInfo", Effect.gen(function* getRepositoryInfo() {
+			return yield* (yield* GitService).getRepositoryInfo;
+		})),
+		getStagedDiff: () => run("git.getStagedDiff", Effect.gen(function* getStagedDiff() {
+			return yield* (yield* GitService).getStagedDiff;
+		})),
+		getStagedFiles: () => run("git.getStagedFiles", Effect.gen(function* getStagedFiles() {
+			return yield* (yield* GitService).getStagedFiles;
+		})),
+		readonly: config.readonly,
+		repoRoot: config.repoRoot,
+		requireWritable: throwIfReadonly
+	});
+	const reviews = Object.freeze({
+		create: async (inputValue) => {
+			throwIfReadonly();
+			const parsed = decodeReviewCreateInput(inputValue);
+			return run("reviews.create", Effect.gen(function* create() {
+				return yield* (yield* ReviewService).create(parsed);
+			}));
+		},
+		export: async (options) => {
+			const opts = decodeInputSync(ReviewExportInput, options, "reviews.export");
+			return {
+				markdown: await run("reviews.export", Effect.gen(function* markdown() {
+					return yield* (yield* ExportService).exportReview(opts.reviewId);
+				})),
+				reviewId: opts.reviewId
+			};
+		},
+		get: (reviewIdValue) => {
+			const reviewId = reviewIdValue;
+			return run("reviews.get", Effect.gen(function* get() {
+				return yield* (yield* ReviewService).getById(reviewId);
+			}));
+		},
+		getComments: (reviewIdValue, filePath) => {
+			const reviewId = reviewIdValue;
+			if (filePath !== null && filePath !== void 0 && typeof filePath !== "string") return Promise.reject(/* @__PURE__ */ new Error("Invalid filePath: expected a string"));
+			return run("reviews.getComments", Effect.gen(function* getComments() {
+				const svc = yield* CommentService;
+				return filePath ? yield* svc.getByFile(reviewId, filePath) : yield* svc.getByReview(reviewId);
+			}));
+		},
+		getDiff: async (query) => {
+			const q = decodeInputSync(ReviewDiffQuery, query, "reviews.getDiff");
+			const hunks = await run(`reviews.getDiff:${q.filePath}`, Effect.gen(function* hunks() {
+				return yield* (yield* ReviewService).getFileHunks(q.reviewId, q.filePath);
+			}));
+			return {
+				filePath: q.filePath,
+				hunks,
+				reviewId: q.reviewId
+			};
+		},
+		getFiles: async (reviewIdValue) => {
+			const reviewId = reviewIdValue;
+			return (await run("reviews.getFiles", Effect.gen(function* review() {
+				return yield* (yield* ReviewService).getById(reviewId);
+			}))).files;
+		},
+		getStatus: async (reviewIdValue) => {
+			const reviewId = reviewIdValue;
+			const [review, stats] = await Promise.all([run("reviews.getStatus.review", Effect.gen(function* () {
+				return yield* (yield* ReviewService).getById(reviewId);
+			})), run("reviews.getStatus.comments", Effect.gen(function* () {
+				return yield* (yield* CommentService).getStats(reviewId);
+			}))]);
+			return {
+				resolvedComments: stats.resolved,
+				reviewId,
+				status: review.status,
+				totalComments: stats.total,
+				unresolvedComments: stats.unresolved,
+				withSuggestions: 0
+			};
+		},
+		getSuggestions: async (reviewIdValue) => {
+			const reviewId = reviewIdValue;
+			return (await run("reviews.getSuggestions", Effect.gen(function* comments() {
+				return yield* (yield* CommentService).getByReview(reviewId);
+			}))).filter((c) => c.suggestion != null).map((c) => ({
+				commentId: c.id,
+				id: c.id,
+				originalCode: "",
+				suggestedCode: c.suggestion ?? ""
+			}));
+		},
+		list: async (filters) => {
+			const parsed = decodeInputSync(ReviewListFilters, filters ?? {}, "reviews.list");
+			return run("reviews.list", Effect.gen(function* list() {
+				return yield* (yield* ReviewService).list({
+					page: parsed.page,
+					pageSize: parsed.limit,
+					repositoryPath: config.repoRoot,
+					sourceType: parsed.sourceType,
+					status: parsed.status
+				});
+			}));
+		}
+	});
+	const todos = Object.freeze({
+		add: async (inputValue) => {
+			throwIfReadonly();
+			const parsed = decodeCreateTodoInput(inputValue);
+			return run("todos.add", Effect.gen(function* add() {
+				return yield* (yield* TodoService).create(parsed);
+			}));
+		},
+		clear: async (_reviewIdValue) => {
+			throwIfReadonly();
+			return run("todos.clear", Effect.gen(function* clear() {
+				return {
+					removed: (yield* (yield* TodoService).removeCompleted()).deleted,
+					success: true
+				};
+			}));
+		},
+		done: async (todoIdValue) => {
+			throwIfReadonly();
+			const todoId = todoIdValue;
+			return run("todos.done", Effect.gen(function* done() {
+				const svc = yield* TodoService;
+				const todo = yield* svc.getById(todoId);
+				if (todo.completed) return todo;
+				return yield* svc.toggle(todoId);
+			}));
+		},
+		list: async (filter) => {
+			const parsed = decodeInputSync(TodoListFilter, filter ?? {}, "todos.list");
+			return (await run("todos.list", Effect.gen(function* result() {
+				return yield* (yield* TodoService).list({ reviewId: parsed.reviewId });
+			}))).data;
+		},
+		move: async (todoIdValue, positionValue) => {
+			throwIfReadonly();
+			const parsed = decodeInputSync(TodoMoveInput, {
+				position: positionValue,
+				todoId: todoIdValue
+			}, "todos.move");
+			return run("todos.move", Effect.gen(function* move() {
+				return yield* (yield* TodoService).move(parsed.todoId, parsed.position);
+			}));
+		},
+		remove: async (todoIdValue) => {
+			throwIfReadonly();
+			const todoId = todoIdValue;
+			return run("todos.remove", Effect.gen(function* remove() {
+				return yield* (yield* TodoService).remove(todoId);
+			}));
+		},
+		undone: async (todoIdValue) => {
+			throwIfReadonly();
+			const todoId = todoIdValue;
+			return run("todos.undone", Effect.gen(function* undone() {
+				const svc = yield* TodoService;
+				const todo = yield* svc.getById(todoId);
+				if (!todo.completed) return todo;
+				return yield* svc.toggle(todoId);
+			}));
+		}
+	});
+	return {
+		events: baseGlobals.events,
+		intelligence: baseGlobals.intelligence,
+		reviews,
+		session: baseGlobals.session,
+		sources: baseGlobals.sources,
+		todos
+	};
+};
+/**
+* Execute sandboxed user code against the Ringi core services.
+*
+* The execution pipeline is an Effect that:
+* - Validates code and timeout via typed errors
+* - Builds schema-validated sandbox namespaces
+* - Runs the VM sandbox with a deterministic timeout model
+*   (vm.Script timeout for sync loops + Effect.timeoutFail for async wall-clock)
+* - Propagates errors via typed tagged errors, never raw throws
+*
+* The managed runtime is passed explicitly — it provides the concrete service
+* environment. Individual sandbox namespace methods use `runtime.runPromise`
+* because they are called from user JS inside the vm sandbox (Promise boundary).
+*/
+const executeCode = (runtime, config, input) => Effect.gen(function* executeCode() {
+	const timeoutMs = yield* validateTimeout(input.timeout, config);
+	const code = yield* validateCode(input.code);
+	const journal = createJournal();
+	return finalizeOutput(yield* runSandbox(buildSandboxGlobals(runtime, config, journal), code, timeoutMs).pipe(Effect.catchTags({
+		ExecutionTimeoutError: (e) => Effect.succeed({
+			error: e.message,
+			ok: false,
+			result: journal.entries.length === 0 ? null : { operations: journal.entries }
+		}),
+		SandboxExecutionError: (e) => Effect.succeed({
+			error: e.message,
+			ok: false,
+			result: journal.entries.length === 0 ? null : { operations: journal.entries }
+		})
+	}), Effect.map((result) => {
+		if (typeof result === "object" && result !== null && "ok" in result && result.ok === false) return result;
+		return {
+			ok: true,
+			result
+		};
+	})), config.maxOutputBytes);
+});
+/**
+* Runs the Effect-based `executeCode` pipeline against the managed runtime.
+* This is the ONLY place `runtime.runPromise` is called for the execution
+* pipeline — the server boundary.
+*
+* Typed errors (InvalidCodeError, InvalidTimeoutError) are caught and
+* formatted as ExecuteOutput instead of propagating as rejections.
+*/
+const executeCodeToPromise = async (runtime, config, input) => {
+	const program = executeCode(runtime, config, input).pipe(Effect.catchTags({
+		InvalidCodeError: (e) => Effect.succeed({
+			error: e.message,
+			ok: false,
+			result: null
+		}),
+		InvalidTimeoutError: (e) => Effect.succeed({
+			error: e.message,
+			ok: false,
+			result: null
+		})
+	}));
+	try {
+		return await Effect.runPromise(program);
+	} catch (error) {
+		return finalizeOutput({
+			error: formatError$1(error),
+			ok: false,
+			result: null
+		}, config.maxOutputBytes);
+	}
+};
+//#endregion
+//#region src/mcp/runtime.ts
+const makeConfigLayer = (config) => Layer.setConfigProvider(ConfigProvider.fromMap(new Map([["DB_PATH", config.dbPath], ["REPOSITORY_PATH", config.repoRoot]])));
+const makeMcpLayer = (config) => Layer.mergeAll(CoreLive, McpConfigLive(config)).pipe(Layer.provideMerge(makeConfigLayer(config)));
+const createMcpRuntime = (config) => ManagedRuntime.make(makeMcpLayer(config));
+//#endregion
+//#region src/mcp/server.ts
+const JSON_RPC_VERSION = "2.0";
+const LATEST_PROTOCOL_VERSION = "2025-11-25";
+const MCP_SERVER_NAME = "ringi";
+const MCP_SERVER_VERSION = process.env.npm_package_version ?? "0.0.0-dev";
+const EXECUTE_TOOL = {
+	description: "Run constrained JavaScript against Ringi review namespaces: review, todo, comment, diff, export, and session.",
+	inputSchema: {
+		additionalProperties: false,
+		properties: {
+			code: {
+				description: "JavaScript snippet to evaluate inside the Ringi MCP sandbox.",
+				type: "string"
+			},
+			timeout: {
+				description: "Optional timeout in milliseconds. Defaults to 30000 and clamps at 120000.",
+				type: "number"
+			}
+		},
+		required: ["code"],
+		type: "object"
+	},
+	name: "execute",
+	outputSchema: {
+		additionalProperties: false,
+		properties: {
+			error: { type: "string" },
+			ok: { type: "boolean" },
+			result: {},
+			truncated: { type: "boolean" }
+		},
+		required: ["ok", "result"],
+		type: "object"
+	}
+};
+const writeStderr = (message) => {
+	process.stderr.write(`[ringi:mcp] ${message}\n`);
+};
+const writeMessage = (message) => {
+	const body = JSON.stringify(message);
+	const payload = `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+	stdout.write(payload);
+};
+const parseContentLength = (headerText) => {
+	const headerLine = headerText.split("\r\n").find((line) => line.toLowerCase().startsWith("content-length:"));
+	if (!headerLine) throw new Error("Missing Content-Length header");
+	const rawValue = headerLine.slice(headerLine.indexOf(":") + 1).trim();
+	const parsed = Number.parseInt(rawValue, 10);
+	if (!Number.isFinite(parsed) || parsed < 0) throw new Error(`Invalid Content-Length header: ${rawValue}`);
+	return parsed;
+};
+const formatError = (error) => {
+	if (error instanceof Error) return error.message;
+	return String(error);
+};
+const sendError = (id, code, message) => {
+	writeMessage({
+		error: {
+			code,
+			message
+		},
+		id,
+		jsonrpc: JSON_RPC_VERSION
+	});
+};
+const sendResult = (id, result) => {
+	writeMessage({
+		id,
+		jsonrpc: JSON_RPC_VERSION,
+		result
+	});
+};
+const createInitializeResult = () => ({
+	capabilities: { tools: { listChanged: false } },
+	protocolVersion: LATEST_PROTOCOL_VERSION,
+	serverInfo: {
+		description: "Local-first MCP codemode adapter over the Ringi core runtime.",
+		name: MCP_SERVER_NAME,
+		version: MCP_SERVER_VERSION
+	}
+});
+var StdioJsonRpcServer = class {
+	config = resolveMcpConfig(process.argv.slice(2));
+	runtime = createMcpRuntime(this.config);
+	buffer = Buffer.alloc(0);
+	initialized = false;
+	shuttingDown = false;
+	start() {
+		stdin.on("data", async (chunk) => {
+			this.buffer = Buffer.concat([this.buffer, chunk]);
+			try {
+				await this.drainBuffer();
+			} catch (error) {
+				writeStderr(`fatal buffer drain error: ${formatError(error)}`);
+			}
+		});
+		stdin.on("end", async () => {
+			await this.runtime.dispose();
+		});
+		process.on("SIGINT", async () => {
+			await this.close(0);
+		});
+		process.on("SIGTERM", async () => {
+			await this.close(0);
+		});
+		writeStderr(`server started readonly=${String(this.config.readonly)} repo=${this.config.repoRoot}`);
+	}
+	async close(code) {
+		await this.runtime.dispose();
+		process.exit(code);
+	}
+	async drainBuffer() {
+		while (true) {
+			const headerEnd = this.buffer.indexOf("\r\n\r\n");
+			if (headerEnd === -1) return;
+			const contentLength = parseContentLength(this.buffer.subarray(0, headerEnd).toString("utf8"));
+			const messageEnd = headerEnd + 4 + contentLength;
+			if (this.buffer.byteLength < messageEnd) return;
+			const payload = this.buffer.subarray(headerEnd + 4, messageEnd).toString("utf8");
+			this.buffer = this.buffer.subarray(messageEnd);
+			let message;
+			try {
+				message = JSON.parse(payload);
+			} catch (error) {
+				sendError(null, -32700, `Parse error: ${formatError(error)}`);
+				continue;
+			}
+			await this.handleMessage(message);
+		}
+	}
+	async handleMessage(message) {
+		if (typeof message.method !== "string") {
+			sendError(message.id ?? null, -32600, "Invalid JSON-RPC request");
+			return;
+		}
+		try {
+			if (await this.handleLifecycleMessage(message)) return;
+			this.assertInitialized();
+			if (message.method === "tools/list") {
+				sendResult(message.id ?? null, { tools: [EXECUTE_TOOL] });
+				return;
+			}
+			if (message.method === "tools/call") {
+				await this.handleToolCall(message.id ?? null, message.params);
+				return;
+			}
+			sendError(message.id ?? null, -32601, `Method not found: ${message.method}`);
+		} catch (error) {
+			sendError(message.id ?? null, -32603, formatError(error));
+		}
+	}
+	async handleLifecycleMessage(message) {
+		if (message.method === "initialize") {
+			this.initialized = true;
+			sendResult(message.id ?? null, createInitializeResult());
+			return true;
+		}
+		if (message.method === "notifications/initialized") return true;
+		if (message.method === "ping") {
+			sendResult(message.id ?? null, {});
+			return true;
+		}
+		if (message.method === "shutdown") {
+			this.shuttingDown = true;
+			sendResult(message.id ?? null, {});
+			return true;
+		}
+		if (message.method === "exit") {
+			await this.close(this.shuttingDown ? 0 : 1);
+			return true;
+		}
+		return false;
+	}
+	assertInitialized() {
+		if (!this.initialized) throw new Error("Server is not initialized");
+		if (this.shuttingDown) throw new Error("Server is shutting down");
+	}
+	async handleToolCall(id, params) {
+		if (!params || typeof params.name !== "string") {
+			sendError(id, -32602, "Invalid tools/call params");
+			return;
+		}
+		if (params.name !== EXECUTE_TOOL.name) {
+			sendError(id, -32602, `Tool not found: ${String(params.name)}`);
+			return;
+		}
+		const argumentsValue = params.arguments;
+		if (typeof argumentsValue !== "object" || argumentsValue === null) {
+			sendError(id, -32602, "Invalid tools/call arguments");
+			return;
+		}
+		const executeResult = await executeCodeToPromise(this.runtime, this.config, argumentsValue);
+		sendResult(id, {
+			content: [{
+				text: JSON.stringify(executeResult),
+				type: "text"
+			}],
+			isError: !executeResult.ok,
+			structuredContent: executeResult
+		});
+	}
+};
+new StdioJsonRpcServer().start();
+//#endregion
+export {};
+
+//# sourceMappingURL=mcp.mjs.map