@sanurb/ringi 0.2.0 → 0.2.1

package/dist/mcp.js

@@ -1,1228 +0,0 @@
-import { ReviewSourceType, ReviewId, TodoId, CoreLive, TodoService, ReviewService, CommentService, ExportService, parseDiff, getDiffSummary, GitService } from './chunk-KMYSGMD3.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