@sanurb/ringi 0.1.0

package/dist/mcp.js

@@ -0,0 +1,1228 @@
+import { ReviewSourceType, ReviewId, TodoId, CoreLive, TodoService, ReviewService, CommentService, ExportService, parseDiff, getDiffSummary, GitService } from './chunk-3JLVANJR.js';
+import { stdin, stdout } from 'node:process';
+import { execFileSync } from 'node:child_process';
+import * as Context from 'effect/Context';
+import * as Layer2 from 'effect/Layer';
+import * as vm from 'node:vm';
+import * as Duration from 'effect/Duration';
+import * as Effect from 'effect/Effect';
+import * as ParseResult from 'effect/ParseResult';
+import * as Schema2 from 'effect/Schema';
+import * as ConfigProvider from 'effect/ConfigProvider';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
+
+var DEFAULT_DB_PATH = ".ringi/reviews.db";
+var DEFAULT_MAX_OUTPUT_BYTES = 100 * 1024;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MAX_TIMEOUT_MS = 12e4;
+var McpConfig = class extends Context.Tag("McpConfig")() {
+};
+var McpConfigLive = (config) => Layer2.succeed(McpConfig, config);
+var resolveRepositoryRoot = (repoOverride) => {
+  const cwd = repoOverride ?? process.cwd();
+  return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+    cwd,
+    encoding: "utf8"
+  }).trim();
+};
+var resolveDbPath = (repoRoot, dbPathOverride) => dbPathOverride ?? `${repoRoot}/${DEFAULT_DB_PATH}`;
+var 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;
+};
+var 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
+  };
+};
+var InvalidCodeError = class extends Schema2.TaggedError()(
+  "InvalidCodeError",
+  { message: Schema2.String }
+) {
+};
+var InvalidTimeoutError = class extends Schema2.TaggedError()(
+  "InvalidTimeoutError",
+  { message: Schema2.String, received: Schema2.Unknown }
+) {
+};
+(class extends Schema2.TaggedError()(
+  "InputDecodeError",
+  { message: Schema2.String, operation: Schema2.String }
+) {
+});
+(class extends Schema2.TaggedError()(
+  "ReadonlyViolationError",
+  { message: Schema2.String }
+) {
+});
+var ExecutionTimeoutError = class extends Schema2.TaggedError()(
+  "ExecutionTimeoutError",
+  { message: Schema2.String, timeoutMs: Schema2.Number }
+) {
+};
+var SandboxExecutionError = class extends Schema2.TaggedError()(
+  "SandboxExecutionError",
+  { error: Schema2.Defect, message: Schema2.String }
+) {
+};
+
+// src/mcp/namespaces.ts
+var PHASE_UNAVAILABLE_MESSAGE = "This capability is not available in the current server phase. Intelligence features require Phase 2.";
+var 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))
+});
+var createSessionNamespace = (deps) => Object.freeze({
+  context: async () => {
+    const repo = await deps.getRepositoryInfo();
+    const activeReviewId = await deps.getLatestReviewId();
+    return {
+      activeReviewId,
+      activeSnapshotId: null,
+      readonly: deps.readonly,
+      repository: repo,
+      serverMode: "stdio"
+    };
+  },
+  status: async () => ({
+    activeSubscriptions: 0,
+    currentPhase: "phase1",
+    ok: true,
+    readonly: deps.readonly
+  })
+});
+var 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
+    }
+  };
+};
+var 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);
+  }
+});
+var 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
+      };
+    }
+  });
+};
+
+// src/mcp/sandbox.ts
+var parseId = (value, fieldName) => {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Invalid ${fieldName}: expected a non-empty string`);
+  }
+  return value;
+};
+var 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();
+  const events = createEventsNamespace();
+  const session = createSessionNamespace({
+    getLatestReviewId: deps.getLatestReviewId,
+    getRepositoryInfo: deps.getRepositoryInfo,
+    readonly: deps.readonly
+  });
+  return { events, intelligence, reviews, session, sources, todos };
+};
+var NonEmptyString = Schema2.String.pipe(Schema2.minLength(1));
+var ReviewCreateFromSpec = Schema2.Struct({
+  source: Schema2.Struct({
+    baseRef: Schema2.optionalWith(Schema2.NullOr(Schema2.String), {
+      default: () => null
+    }),
+    type: Schema2.optionalWith(ReviewSourceType, {
+      default: () => "staged"
+    })
+  })
+});
+var ReviewCreateFromLegacy = Schema2.Struct({
+  sourceRef: Schema2.optionalWith(Schema2.NullOr(Schema2.String), {
+    default: () => null
+  }),
+  sourceType: Schema2.optionalWith(ReviewSourceType, {
+    default: () => "staged"
+  })
+});
+var decodeReviewCreateInput = (input) => {
+  if (typeof input === "object" && input !== null && "source" in input) {
+    const parsed2 = Schema2.decodeUnknownSync(ReviewCreateFromSpec)(input);
+    return {
+      sourceRef: parsed2.source.baseRef,
+      sourceType: parsed2.source.type
+    };
+  }
+  const parsed = Schema2.decodeUnknownSync(ReviewCreateFromLegacy)(input);
+  return {
+    sourceRef: parsed.sourceRef,
+    sourceType: parsed.sourceType
+  };
+};
+var ReviewExportInput = Schema2.Struct({
+  reviewId: ReviewId
+});
+var ReviewDiffQuery = Schema2.Struct({
+  filePath: NonEmptyString,
+  reviewId: ReviewId
+});
+var ReviewListFilters = Schema2.Struct({
+  limit: Schema2.optionalWith(Schema2.Number, { default: () => 20 }),
+  page: Schema2.optionalWith(Schema2.Number, { default: () => 1 }),
+  pageSize: Schema2.optionalWith(Schema2.Number, { default: () => 20 }),
+  sourceType: Schema2.optional(Schema2.String),
+  status: Schema2.optional(Schema2.String)
+});
+var TodoInputFromSpec = Schema2.Struct({
+  reviewId: Schema2.optionalWith(Schema2.NullOr(ReviewId), {
+    default: () => null
+  }),
+  text: NonEmptyString
+});
+var TodoInputFromLegacy = Schema2.Struct({
+  content: NonEmptyString,
+  reviewId: Schema2.optionalWith(Schema2.NullOr(ReviewId), {
+    default: () => null
+  })
+});
+var decodeCreateTodoInput = (input) => {
+  if (typeof input === "object" && input !== null && "text" in input) {
+    const parsed2 = Schema2.decodeUnknownSync(TodoInputFromSpec)(input);
+    return { content: parsed2.text, reviewId: parsed2.reviewId };
+  }
+  const parsed = Schema2.decodeUnknownSync(TodoInputFromLegacy)(input);
+  return { content: parsed.content, reviewId: parsed.reviewId };
+};
+var TodoListFilter = Schema2.Struct({
+  reviewId: Schema2.optional(ReviewId)
+});
+var TodoMoveInput = Schema2.Struct({
+  position: Schema2.Number,
+  todoId: TodoId
+});
+
+// src/mcp/execute.ts
+var MAX_CODE_LENGTH = 5e4;
+var MIN_PREVIEW_BYTES = 256;
+var 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);
+};
+var formatError = (error) => error instanceof Error ? error.message : String(error);
+var truncateUtf8 = (text, maxBytes) => {
+  const buffer = Buffer.from(text, "utf8");
+  if (buffer.byteLength <= maxBytes) {
+    return text;
+  }
+  return buffer.subarray(0, maxBytes).toString("utf8");
+};
+var summarizeForJournal = (value) => {
+  if (typeof value === "string") {
+    return value.length > 200 ? `${value.slice(0, 200)}\u2026` : 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;
+};
+var 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
+  };
+};
+var 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;
+};
+var decodeInputSync = (schema, input, operation) => {
+  try {
+    return Schema2.decodeUnknownSync(schema)(input);
+  } catch (error) {
+    if (error instanceof ParseResult.ParseError) {
+      throw new TypeError(
+        `${operation}: ${ParseResult.TreeFormatter.formatErrorSync(error)}`,
+        { cause: error }
+      );
+    }
+    throw error;
+  }
+};
+var validateCode = (code) => Effect.try({
+  catch: (e) => new InvalidCodeError({ message: formatError(e) }),
+  try: () => ensureCode(code)
+});
+var validateTimeout = (requested, config) => Effect.try({
+  catch: () => new InvalidTimeoutError({
+    message: `Invalid timeout: expected a positive integer, received ${requested}`,
+    received: requested
+  }),
+  try: () => clampTimeout(requested, config)
+});
+var 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}
+`);
+};
+var createSandboxConsole = () => Object.freeze({
+  error: (...args) => writeSandboxLog("error", args),
+  info: (...args) => writeSandboxLog("info", args),
+  log: (...args) => writeSandboxLog("log", args),
+  warn: (...args) => writeSandboxLog("warn", args)
+});
+var runSandbox = (globals, code, timeoutMs) => {
+  const execute = Effect.tryPromise({
+    catch: (error) => new SandboxExecutionError({
+      error,
+      message: formatError(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 () => {
+${code}
+})()`,
+        { filename: "ringi-mcp-execute.js" }
+      );
+      return Promise.resolve(
+        script.runInContext(context, { timeout: timeoutMs })
+      );
+    }
+  });
+  return execute.pipe(
+    Effect.timeoutFail({
+      duration: Duration.millis(timeoutMs),
+      onTimeout: () => new ExecutionTimeoutError({
+        message: `Execution timed out after ${timeoutMs}ms`,
+        timeoutMs
+      })
+    })
+  );
+};
+var createJournal = () => {
+  const entries = [];
+  const recordSuccess = (name, result) => {
+    entries.push({ name, ok: true, result: summarizeForJournal(result) });
+  };
+  const recordFailure = (name, error) => {
+    entries.push({ error: formatError(error), name, ok: false });
+  };
+  const tracked = (runtime, name, effect) => runtime.runPromise(
+    effect
+  ).then(
+    (result) => {
+      recordSuccess(name, result);
+      return result;
+    },
+    (error) => {
+      recordFailure(name, error);
+      throw error;
+    }
+  );
+  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 };
+};
+var 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 deps = {
+    call: trackedAsync,
+    getBranchDiff: (branch) => run(
+      "git.getBranchDiff",
+      Effect.gen(function* getBranchDiff() {
+        const git = yield* GitService;
+        return yield* git.getBranchDiff(branch);
+      })
+    ),
+    getBranches: () => run(
+      "git.getBranches",
+      Effect.gen(function* getBranches() {
+        const git = yield* GitService;
+        return yield* git.getBranches;
+      })
+    ),
+    getCommitDiff: (shas) => run(
+      "git.getCommitDiff",
+      Effect.gen(function* getCommitDiff() {
+        const git = yield* GitService;
+        return yield* git.getCommitDiff(shas);
+      })
+    ),
+    getLatestReviewId: async () => {
+      const result = await run(
+        "reviews.latestId",
+        Effect.gen(function* result2() {
+          const svc = yield* ReviewService;
+          return yield* svc.list({
+            page: 1,
+            pageSize: 1,
+            repositoryPath: config.repoRoot
+          });
+        })
+      );
+      return result.reviews[0]?.id ?? null;
+    },
+    getRecentCommits: async () => {
+      const result = await run(
+        "git.getCommits",
+        Effect.gen(function* result2() {
+          const git = yield* GitService;
+          return yield* git.getCommits({ limit: 10, offset: 0 });
+        })
+      );
+      return result.commits;
+    },
+    getRepositoryInfo: () => run(
+      "git.getRepositoryInfo",
+      Effect.gen(function* getRepositoryInfo() {
+        const git = yield* GitService;
+        return yield* git.getRepositoryInfo;
+      })
+    ),
+    getStagedDiff: () => run(
+      "git.getStagedDiff",
+      Effect.gen(function* getStagedDiff() {
+        const git = yield* GitService;
+        return yield* git.getStagedDiff;
+      })
+    ),
+    getStagedFiles: () => run(
+      "git.getStagedFiles",
+      Effect.gen(function* getStagedFiles() {
+        const git = yield* GitService;
+        return yield* git.getStagedFiles;
+      })
+    ),
+    readonly: config.readonly,
+    repoRoot: config.repoRoot,
+    requireWritable: throwIfReadonly
+  };
+  const baseGlobals = createSandboxGlobals(deps);
+  const reviews = Object.freeze({
+    create: async (inputValue) => {
+      throwIfReadonly();
+      const parsed = decodeReviewCreateInput(inputValue);
+      return run(
+        "reviews.create",
+        Effect.gen(function* create() {
+          const svc = yield* ReviewService;
+          return yield* svc.create(parsed);
+        })
+      );
+    },
+    export: async (options) => {
+      const opts = decodeInputSync(
+        ReviewExportInput,
+        options,
+        "reviews.export"
+      );
+      const markdown = await run(
+        "reviews.export",
+        Effect.gen(function* markdown2() {
+          const svc = yield* ExportService;
+          return yield* svc.exportReview(opts.reviewId);
+        })
+      );
+      return { markdown, reviewId: opts.reviewId };
+    },
+    get: (reviewIdValue) => {
+      const reviewId = reviewIdValue;
+      return run(
+        "reviews.get",
+        Effect.gen(function* get() {
+          const svc = yield* ReviewService;
+          return yield* svc.getById(reviewId);
+        })
+      );
+    },
+    getComments: (reviewIdValue, filePath) => {
+      const reviewId = reviewIdValue;
+      if (filePath !== null && filePath !== void 0 && typeof filePath !== "string") {
+        return Promise.reject(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* hunks2() {
+          const svc = yield* ReviewService;
+          return yield* svc.getFileHunks(q.reviewId, q.filePath);
+        })
+      );
+      return { filePath: q.filePath, hunks, reviewId: q.reviewId };
+    },
+    getFiles: async (reviewIdValue) => {
+      const reviewId = reviewIdValue;
+      const review = await run(
+        "reviews.getFiles",
+        Effect.gen(function* review2() {
+          const svc = yield* ReviewService;
+          return yield* svc.getById(reviewId);
+        })
+      );
+      return review.files;
+    },
+    getStatus: async (reviewIdValue) => {
+      const reviewId = reviewIdValue;
+      const [review, stats] = await Promise.all([
+        run(
+          "reviews.getStatus.review",
+          Effect.gen(function* () {
+            const svc = yield* ReviewService;
+            return yield* svc.getById(reviewId);
+          })
+        ),
+        run(
+          "reviews.getStatus.comments",
+          Effect.gen(function* () {
+            const svc = yield* CommentService;
+            return yield* svc.getStats(reviewId);
+          })
+        )
+      ]);
+      return {
+        resolvedComments: stats.resolved,
+        reviewId,
+        status: review.status,
+        totalComments: stats.total,
+        unresolvedComments: stats.unresolved,
+        withSuggestions: 0
+      };
+    },
+    getSuggestions: async (reviewIdValue) => {
+      const reviewId = reviewIdValue;
+      const comments = await run(
+        "reviews.getSuggestions",
+        Effect.gen(function* comments2() {
+          const svc = yield* CommentService;
+          return yield* svc.getByReview(reviewId);
+        })
+      );
+      return comments.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() {
+          const svc = yield* ReviewService;
+          return yield* svc.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() {
+          const svc = yield* TodoService;
+          return yield* svc.create(parsed);
+        })
+      );
+    },
+    clear: async (_reviewIdValue) => {
+      throwIfReadonly();
+      return run(
+        "todos.clear",
+        Effect.gen(function* clear() {
+          const svc = yield* TodoService;
+          const result = yield* svc.removeCompleted();
+          return { removed: result.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"
+      );
+      const result = await run(
+        "todos.list",
+        Effect.gen(function* result2() {
+          const svc = yield* TodoService;
+          return yield* svc.list({ reviewId: parsed.reviewId });
+        })
+      );
+      return result.data;
+    },
+    move: async (todoIdValue, positionValue) => {
+      throwIfReadonly();
+      const parsed = decodeInputSync(
+        TodoMoveInput,
+        { position: positionValue, todoId: todoIdValue },
+        "todos.move"
+      );
+      return run(
+        "todos.move",
+        Effect.gen(function* move() {
+          const svc = yield* TodoService;
+          return yield* svc.move(parsed.todoId, parsed.position);
+        })
+      );
+    },
+    remove: async (todoIdValue) => {
+      throwIfReadonly();
+      const todoId = todoIdValue;
+      return run(
+        "todos.remove",
+        Effect.gen(function* remove() {
+          const svc = yield* TodoService;
+          return yield* svc.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
+  };
+};
+var executeCode = (runtime, config, input) => Effect.gen(function* executeCode2() {
+  const timeoutMs = yield* validateTimeout(input.timeout, config);
+  const code = yield* validateCode(input.code);
+  const journal = createJournal();
+  const globals = buildSandboxGlobals(runtime, config, journal);
+  const sandboxResult = yield* runSandbox(globals, 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 };
+    })
+  );
+  return finalizeOutput(sandboxResult, config.maxOutputBytes);
+});
+var 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(error),
+        ok: false,
+        result: null
+      },
+      config.maxOutputBytes
+    );
+  }
+};
+var makeConfigLayer = (config) => Layer2.setConfigProvider(
+  ConfigProvider.fromMap(
+    /* @__PURE__ */ new Map([
+      ["DB_PATH", config.dbPath],
+      ["REPOSITORY_PATH", config.repoRoot]
+    ])
+  )
+);
+var makeMcpLayer = (config) => Layer2.mergeAll(CoreLive, McpConfigLive(config)).pipe(
+  Layer2.provideMerge(makeConfigLayer(config))
+);
+var createMcpRuntime = (config) => ManagedRuntime.make(makeMcpLayer(config));
+
+// src/mcp/server.ts
+var JSON_RPC_VERSION = "2.0";
+var LATEST_PROTOCOL_VERSION = "2025-11-25";
+var MCP_SERVER_NAME = "ringi";
+var MCP_SERVER_VERSION = process.env.npm_package_version ?? "0.0.0-dev";
+var 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"
+  }
+};
+var writeStderr = (message) => {
+  process.stderr.write(`[ringi:mcp] ${message}
+`);
+};
+var writeMessage = (message) => {
+  const body = JSON.stringify(message);
+  const payload = `Content-Length: ${Buffer.byteLength(body, "utf8")}\r
+\r
+${body}`;
+  stdout.write(payload);
+};
+var 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;
+};
+var formatError2 = (error) => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+};
+var sendError = (id, code, message) => {
+  writeMessage({
+    error: {
+      code,
+      message
+    },
+    id,
+    jsonrpc: JSON_RPC_VERSION
+  });
+};
+var sendResult = (id, result) => {
+  writeMessage({
+    id,
+    jsonrpc: JSON_RPC_VERSION,
+    result
+  });
+};
+var 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: ${formatError2(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 headerText = this.buffer.subarray(0, headerEnd).toString("utf8");
+      const contentLength = parseContentLength(headerText);
+      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: ${formatError2(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, formatError2(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();
+//# sourceMappingURL=mcp.js.map
+//# sourceMappingURL=mcp.js.map