@adanami/kaleido 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,1489 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+import open from "open";
+
+// src/shared/commentFormat.ts
+function formatCommentPrompt(comment) {
+  if (comment.startLine === void 0 || comment.endLine === void 0) {
+    return `${comment.path}
+${comment.body}`;
+  }
+  const lines = comment.startLine === comment.endLine ? `L${comment.startLine}` : `L${comment.startLine}-L${comment.endLine}`;
+  return `${comment.path}:${lines}
+${comment.body}`;
+}
+function formatAllCommentsPrompt(comments) {
+  return comments.map(formatCommentPrompt).join("\n\n=====\n\n");
+}
+
+// src/shared/types.ts
+var BROWSE_RANGE = { target: "browse", base: "browse" };
+function rangeKey(range) {
+  const sanitize = (s) => s.replace(/[^a-zA-Z0-9_.-]/g, "_");
+  const mode = range.baseMode === "merge-base" ? "~mb" : "";
+  return `${sanitize(range.base)}${mode}__${sanitize(range.target)}`;
+}
+function describeRange(range) {
+  if (range.target === "browse") return "files";
+  if (range.target === "working") return "unstaged changes";
+  if (range.target === "staged") return `${range.base}..staged`;
+  if (range.target === ".") return `${range.base}..working tree`;
+  const sep3 = range.baseMode === "merge-base" ? "..." : "..";
+  return `${range.base}${sep3}${range.target}`;
+}
+
+// src/server/index.ts
+import { existsSync } from "fs";
+import { dirname, join as join4, relative as relative2 } from "path";
+import { fileURLToPath } from "url";
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+
+// src/server/app.ts
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { z } from "zod";
+import { zValidator } from "@hono/zod-validator";
+
+// src/server/files/tree.ts
+import { readdir, stat } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/shared/documents.ts
+var MARKDOWN_EXTENSIONS = [".md", ".markdown", ".mdown", ".mkd", ".mkdn"];
+var HTML_EXTENSIONS = [".html", ".htm"];
+function isDocumentPath(path) {
+  const lower = path.toLowerCase();
+  return [...MARKDOWN_EXTENSIONS, ...HTML_EXTENSIONS].some((ext) => lower.endsWith(ext));
+}
+
+// src/server/files/config.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+var CONFIG_FILE_NAME = ".kaleido.json";
+var DEFAULT_EXCLUDES = [
+  ".git",
+  "node_modules",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  ".turbo",
+  ".cache",
+  ".parcel-cache",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".gradle",
+  ".venv",
+  "venv",
+  "__pycache__",
+  "dist",
+  "build",
+  "out",
+  "coverage",
+  "target",
+  "vendor",
+  ".DS_Store"
+];
+var DEFAULT_MAX_FILES = 2e4;
+function loadViewerConfig(rootDir, cliExcludes = []) {
+  const file = readConfigFile(rootDir);
+  const useDefaults = file?.useDefaultExcludes !== false;
+  const exclude = [
+    ...useDefaults ? DEFAULT_EXCLUDES : [".git"],
+    ...file?.exclude ?? [],
+    ...cliExcludes
+  ];
+  const maxFiles = typeof file?.maxFiles === "number" && file.maxFiles > 0 ? file.maxFiles : DEFAULT_MAX_FILES;
+  return { exclude: [...new Set(exclude)], maxFiles };
+}
+function readConfigFile(rootDir) {
+  try {
+    const parsed = JSON.parse(readFileSync(join(rootDir, CONFIG_FILE_NAME), "utf8"));
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const raw = parsed;
+    return {
+      exclude: Array.isArray(raw.exclude) ? raw.exclude.filter((v) => typeof v === "string") : void 0,
+      useDefaultExcludes: typeof raw.useDefaultExcludes === "boolean" ? raw.useDefaultExcludes : void 0,
+      maxFiles: typeof raw.maxFiles === "number" ? raw.maxFiles : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function createExcludeMatcher(patterns) {
+  const regexps = patterns.map(toRegExp).filter((r) => r !== null);
+  return (relPath) => regexps.some((re) => re.test(relPath));
+}
+function toRegExp(pattern) {
+  let source = pattern.trim().replace(/\\/g, "/");
+  if (source.length === 0) return null;
+  source = source.replace(/^\.\//, "").replace(/^\/+/, "").replace(/\/+$/, "");
+  if (source.length === 0) return null;
+  if (!source.includes("/")) source = `**/${source}`;
+  let out = "";
+  for (let i = 0; i < source.length; i++) {
+    const char = source[i];
+    if (char === "*") {
+      if (source[i + 1] === "*") {
+        i++;
+        if (source[i + 1] === "/") {
+          i++;
+          out += "(?:[^/]+/)*";
+        } else {
+          out += ".*";
+        }
+      } else {
+        out += "[^/]*";
+      }
+      continue;
+    }
+    if (char === "?") {
+      out += "[^/]";
+      continue;
+    }
+    out += char.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }
+  try {
+    return new RegExp(`^${out}$`);
+  } catch {
+    return null;
+  }
+}
+
+// src/server/files/tree.ts
+async function collectFiles(rootDir, config, isTarget) {
+  const isExcluded = createExcludeMatcher(config.exclude);
+  const paths = [];
+  let isTruncated = false;
+  const walk = async (relDir) => {
+    if (isTruncated) return;
+    let entries;
+    try {
+      entries = await readdir(join2(rootDir, relDir), { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const subdirs = [];
+    for (const entry of entries) {
+      const rel = relDir === "" ? entry.name : `${relDir}/${entry.name}`;
+      if (isExcluded(rel)) continue;
+      if (entry.isDirectory()) {
+        subdirs.push(rel);
+      } else if (entry.isFile() && isTarget(rel)) {
+        if (paths.length >= config.maxFiles) {
+          isTruncated = true;
+          return;
+        }
+        paths.push(rel);
+      }
+    }
+    for (const subdir of subdirs) {
+      await walk(subdir);
+      if (isTruncated) return;
+    }
+  };
+  await walk("");
+  return { paths, isTruncated };
+}
+async function listDirectoryFiles(rootDir, config) {
+  const { paths, isTruncated } = await collectFiles(rootDir, config, () => true);
+  paths.sort((a, b) => a.localeCompare(b));
+  return { paths, isTruncated };
+}
+async function listDocumentFiles(rootDir, config) {
+  const { paths, isTruncated } = await collectFiles(rootDir, config, isDocumentPath);
+  const files = await Promise.all(
+    paths.map(async (path) => {
+      try {
+        return { path, mtime: (await stat(join2(rootDir, path))).mtimeMs };
+      } catch {
+        return { path, mtime: 0 };
+      }
+    })
+  );
+  files.sort((a, b) => a.path.localeCompare(b.path));
+  return { files, isTruncated };
+}
+function applyExcludes(paths, config) {
+  const isExcluded = createExcludeMatcher(config.exclude);
+  const filtered = paths.filter((path) => !isExcluded(path));
+  return {
+    paths: filtered.slice(0, config.maxFiles),
+    isTruncated: filtered.length > config.maxFiles
+  };
+}
+
+// src/server/app.ts
+var VERSION = "0.1.0";
+var MAX_RAW_BYTES = 10 * 1024 * 1024;
+var MAX_PREVIEW_BYTES = 20 * 1024 * 1024;
+var IMAGE_CONTENT_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon",
+  ".svg": "image/svg+xml"
+};
+var PREVIEW_CONTENT_TYPES = {
+  ...IMAGE_CONTENT_TYPES,
+  ".html": "text/html; charset=utf-8",
+  ".htm": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".md": "text/plain; charset=utf-8",
+  ".wasm": "application/wasm",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav"
+};
+function extensionOf(path) {
+  const index = path.lastIndexOf(".");
+  return index === -1 ? "" : path.slice(index).toLowerCase();
+}
+var rangeSchema = z.object({
+  target: z.string().min(1),
+  base: z.string().min(1),
+  baseMode: z.enum(["direct", "merge-base"]).optional()
+});
+function toRange(query) {
+  return { target: query.target, base: query.base, baseMode: query.baseMode };
+}
+function createApp(ctx) {
+  const app = new Hono();
+  app.onError((err, c) => {
+    console.error(err);
+    return c.json({ error: err instanceof Error ? err.message : "Internal error" }, 500);
+  });
+  app.use("/api/*", async (c, next) => {
+    const origin = c.req.header("Origin");
+    if (origin !== void 0 && origin !== new URL(c.req.url).origin) {
+      return c.json({ error: "Cross-origin request is not allowed" }, 403);
+    }
+    await next();
+  });
+  app.get("/preview/*", async (c) => {
+    const path = decodeURIComponent(c.req.path.slice("/preview/".length));
+    if (path.length === 0) return c.json({ error: "File not found" }, 404);
+    let buf;
+    try {
+      buf = await ctx.fileContent.readBlob("working", path);
+    } catch {
+      return c.json({ error: "File not found" }, 404);
+    }
+    if (buf.length > MAX_PREVIEW_BYTES) return c.json({ error: "File too large" }, 413);
+    return c.body(new Uint8Array(buf), 200, {
+      "Content-Type": PREVIEW_CONTENT_TYPES[extensionOf(path)] ?? "application/octet-stream",
+      "X-Content-Type-Options": "nosniff",
+      // opaque origin のページが自分のファイルを fetch できるようにする
+      "Access-Control-Allow-Origin": "*",
+      "Cache-Control": "no-store"
+    });
+  });
+  app.get("/api/meta", (c) => {
+    const meta = {
+      rootDir: ctx.rootDir,
+      isGitRepo: ctx.isGitRepo,
+      repoId: ctx.repoId,
+      initialRange: ctx.initialRange,
+      version: VERSION
+    };
+    return c.json(meta);
+  });
+  app.get("/api/ranges", async (c) => {
+    if (!ctx.gitRefs) {
+      const empty = { branches: [], recentCommits: [], defaultBranch: null };
+      return c.json(empty);
+    }
+    return c.json(await ctx.gitRefs.getRanges());
+  });
+  app.get("/api/files", async (c) => {
+    if (ctx.gitDiff) {
+      return c.json(applyExcludes(await ctx.gitDiff.listRepoFiles(), ctx.config));
+    }
+    return c.json(await listDirectoryFiles(ctx.rootDir, ctx.config));
+  });
+  app.get("/api/docs", async (c) => {
+    return c.json(await listDocumentFiles(ctx.rootDir, ctx.config));
+  });
+  app.get("/api/diff", zValidator("query", rangeSchema), async (c) => {
+    const range = toRange(c.req.valid("query"));
+    if (!ctx.gitDiff || range.target === "browse") {
+      const empty = {
+        files: [],
+        label: "Files",
+        resolvedBase: "browse",
+        resolvedTarget: "working"
+      };
+      return c.json(empty);
+    }
+    const diff = await ctx.gitDiff.getDiff(range);
+    ctx.tsService.warmup(diff.files.map((f) => f.path));
+    return c.json(diff);
+  });
+  app.post(
+    "/api/lang/hover",
+    zValidator(
+      "json",
+      z.object({
+        path: z.string().min(1),
+        line: z.number().int().min(1),
+        column: z.number().int().min(1),
+        content: z.string().optional()
+      })
+    ),
+    async (c) => {
+      return c.json(await ctx.tsService.hover(c.req.valid("json")));
+    }
+  );
+  app.post(
+    "/api/lang/definition",
+    zValidator(
+      "json",
+      z.object({
+        path: z.string().min(1),
+        line: z.number().int().min(1),
+        column: z.number().int().min(1),
+        content: z.string().optional()
+      })
+    ),
+    async (c) => {
+      return c.json(await ctx.tsService.definition(c.req.valid("json")));
+    }
+  );
+  app.post(
+    "/api/lang/references",
+    zValidator(
+      "json",
+      z.object({
+        path: z.string().min(1),
+        line: z.number().int().min(1),
+        column: z.number().int().min(1),
+        content: z.string().optional()
+      })
+    ),
+    async (c) => {
+      return c.json(await ctx.tsService.references(c.req.valid("json")));
+    }
+  );
+  app.post(
+    "/api/lint",
+    zValidator("json", z.object({ paths: z.array(z.string().min(1)).max(500) })),
+    async (c) => {
+      const { paths } = c.req.valid("json");
+      const { runEslintForFiles } = await import("../eslint-WWJOZ2KR.js");
+      return c.json(await runEslintForFiles(ctx.rootDir, paths));
+    }
+  );
+  app.post(
+    "/api/lang/diagnostics",
+    zValidator(
+      "json",
+      z.object({
+        path: z.string().min(1),
+        content: z.string().optional()
+      })
+    ),
+    async (c) => {
+      return c.json(await ctx.tsService.diagnostics(c.req.valid("json")));
+    }
+  );
+  app.get(
+    "/api/file",
+    zValidator(
+      "query",
+      rangeSchema.extend({
+        path: z.string().min(1),
+        oldPath: z.string().optional(),
+        status: z.string().default("modified")
+      })
+    ),
+    async (c) => {
+      const q = c.req.valid("query");
+      const range = toRange(q);
+      const resolvedBase = ctx.gitDiff && range.target !== "browse" ? await ctx.gitDiff.resolveBase(range) : range.base;
+      const contents = await ctx.fileContent.getFileContents({
+        range,
+        resolvedBase,
+        path: q.path,
+        oldPath: q.oldPath,
+        status: q.status
+      });
+      return c.json(contents);
+    }
+  );
+  app.get(
+    "/api/raw",
+    zValidator("query", z.object({ path: z.string().min(1) })),
+    async (c) => {
+      const { path } = c.req.valid("query");
+      const contentType = IMAGE_CONTENT_TYPES[extensionOf(path)];
+      if (!contentType) return c.json({ error: "Unsupported file type" }, 415);
+      let buf;
+      try {
+        buf = await ctx.fileContent.readBlob("working", path);
+      } catch {
+        return c.json({ error: "File not found" }, 404);
+      }
+      if (buf.length > MAX_RAW_BYTES) return c.json({ error: "File too large" }, 413);
+      return c.body(new Uint8Array(buf), 200, {
+        "Content-Type": contentType,
+        "X-Content-Type-Options": "nosniff",
+        "Content-Security-Policy": "default-src 'none'; sandbox",
+        "Cache-Control": "no-cache"
+      });
+    }
+  );
+  app.post(
+    "/api/file/save",
+    zValidator("json", z.object({ path: z.string().min(1), content: z.string() })),
+    async (c) => {
+      const { path, content } = c.req.valid("json");
+      await ctx.fileContent.writeWorkingFile(path, content);
+      return c.json({ ok: true });
+    }
+  );
+  const commentBodySchema = z.object({
+    path: z.string().min(1),
+    side: z.enum(["original", "modified"]),
+    // startLine/endLine 省略時はファイル全体へのコメント
+    startLine: z.number().int().min(1).optional(),
+    endLine: z.number().int().min(1).optional(),
+    body: z.string().min(1),
+    codeSnapshot: z.string().optional()
+  }).refine((v) => v.startLine === void 0 === (v.endLine === void 0), {
+    message: "startLine and endLine must be provided together"
+  });
+  app.get("/api/comments", zValidator("query", rangeSchema), (c) => {
+    return c.json(ctx.reviewStore.getComments(rangeKey(toRange(c.req.valid("query")))));
+  });
+  app.post(
+    "/api/comments",
+    zValidator("query", rangeSchema),
+    zValidator("json", commentBodySchema),
+    (c) => {
+      const key = rangeKey(toRange(c.req.valid("query")));
+      return c.json(ctx.reviewStore.addComment(key, c.req.valid("json")));
+    }
+  );
+  app.patch(
+    "/api/comments/:id",
+    zValidator("query", rangeSchema),
+    zValidator("json", z.object({ body: z.string().min(1) })),
+    (c) => {
+      const key = rangeKey(toRange(c.req.valid("query")));
+      const updated = ctx.reviewStore.updateComment(key, c.req.param("id"), c.req.valid("json").body);
+      if (!updated) return c.json({ error: "Comment not found" }, 404);
+      return c.json(updated);
+    }
+  );
+  app.delete("/api/comments", zValidator("query", rangeSchema), (c) => {
+    const key = rangeKey(toRange(c.req.valid("query")));
+    return c.json({ comments: ctx.reviewStore.clearComments(key) });
+  });
+  const storedCommentSchema = commentBodySchema.safeExtend({
+    id: z.string().min(1),
+    createdAt: z.string(),
+    updatedAt: z.string()
+  });
+  app.post(
+    "/api/comments/restore",
+    zValidator("query", rangeSchema),
+    zValidator("json", z.object({ comments: z.array(storedCommentSchema).max(1e3) })),
+    (c) => {
+      const key = rangeKey(toRange(c.req.valid("query")));
+      ctx.reviewStore.restoreComments(key, c.req.valid("json").comments);
+      return c.json({ ok: true });
+    }
+  );
+  app.delete("/api/comments/:id", zValidator("query", rangeSchema), (c) => {
+    const key = rangeKey(toRange(c.req.valid("query")));
+    const isDeleted = ctx.reviewStore.deleteComment(key, c.req.param("id"));
+    if (!isDeleted) return c.json({ error: "Comment not found" }, 404);
+    return c.json({ ok: true });
+  });
+  app.get(
+    "/api/events",
+    (c) => streamSSE(c, async (stream) => {
+      let isAborted = false;
+      const client = {
+        write: (event, data) => stream.writeSSE({ event, data })
+      };
+      ctx.eventBus.register(client);
+      stream.onAbort(() => {
+        isAborted = true;
+        ctx.eventBus.unregister(client);
+      });
+      await stream.writeSSE({ event: "connected", data: "{}" });
+      while (!isAborted) {
+        await stream.sleep(15e3);
+        if (isAborted) break;
+        await stream.writeSSE({ event: "heartbeat", data: "{}" }).catch(() => {
+          isAborted = true;
+        });
+      }
+    })
+  );
+  app.get("/api/viewed", (c) => c.json(ctx.reviewStore.getViewed()));
+  app.put(
+    "/api/viewed",
+    zValidator(
+      "json",
+      z.object({ path: z.string().min(1), hash: z.string().min(1), viewed: z.boolean() })
+    ),
+    (c) => {
+      const { path, hash, viewed } = c.req.valid("json");
+      ctx.reviewStore.setViewed(path, hash, viewed);
+      return c.json({ ok: true });
+    }
+  );
+  return app;
+}
+
+// src/server/context.ts
+import { realpathSync as realpathSync3 } from "fs";
+
+// src/server/files/content.ts
+import { execFile } from "child_process";
+import { realpathSync } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import { resolve, sep } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var MAX_BUFFER = 10 * 1024 * 1024;
+var MAX_CONTENT_BYTES = 2 * 1024 * 1024;
+var MAX_CONTENT_LINES = 2e4;
+var FileContent = class {
+  constructor(rootDir, isGitRepo) {
+    this.rootDir = rootDir;
+    this.isGitRepo = isGitRepo;
+  }
+  rootDir;
+  isGitRepo;
+  /**
+   * RangeSpec から original/modified 両側の参照 ref を決める。
+   * - browse:  比較なし (modified 側のみ)
+   * - working: index vs working tree
+   * - staged:  base vs index
+   * - '.':     base vs working tree
+   * - commit:  base vs target
+   */
+  resolveSideRefs(range, resolvedBase) {
+    if (range.target === "browse") return { originalRef: null, modifiedRef: "working" };
+    if (range.target === "working") return { originalRef: "staged", modifiedRef: "working" };
+    if (range.target === "staged") return { originalRef: resolvedBase, modifiedRef: "staged" };
+    if (range.target === ".") return { originalRef: resolvedBase, modifiedRef: "working" };
+    return { originalRef: resolvedBase, modifiedRef: range.target };
+  }
+  async getFileContents(params) {
+    const { range, resolvedBase, path, oldPath, status } = params;
+    const refs = this.resolveSideRefs(range, resolvedBase);
+    const [original, modified] = await Promise.all([
+      refs.originalRef === null || status === "added" ? null : this.readSide(refs.originalRef, oldPath ?? path),
+      status === "deleted" ? null : this.readSide(refs.modifiedRef, path)
+    ]);
+    const isTooLarge = isTooLargeContent(original) || isTooLargeContent(modified);
+    if (isTooLarge) {
+      return {
+        original: original ? { ...original, content: "" } : null,
+        modified: modified ? { ...modified, content: "" } : null,
+        isTooLarge: true
+      };
+    }
+    return { original, modified, isTooLarge: false };
+  }
+  async readSide(ref, filepath) {
+    try {
+      const buf = await this.readBlob(ref, filepath);
+      return { content: buf.toString("utf8"), ref };
+    } catch {
+      return null;
+    }
+  }
+  /** working tree の既存ファイルを上書き保存する (編集機能用) */
+  async writeWorkingFile(filepath, content) {
+    await writeFile(this.resolveInsideRoot(filepath), content, "utf8");
+  }
+  async readBlob(ref, filepath) {
+    if (ref === "working") {
+      return readFile(this.resolveInsideRoot(filepath));
+    }
+    if (!this.isGitRepo) {
+      throw new Error("Not a git repository");
+    }
+    const rel = normalizeRelPath(filepath);
+    if (ref === "staged") {
+      const { stdout: stdout2 } = await execFileAsync("git", ["show", `:${rel}`], {
+        cwd: this.rootDir,
+        maxBuffer: MAX_BUFFER,
+        encoding: "buffer"
+      });
+      return stdout2;
+    }
+    const { stdout: hashOut } = await execFileAsync("git", ["rev-parse", `${ref}:${rel}`], {
+      cwd: this.rootDir,
+      maxBuffer: MAX_BUFFER
+    });
+    const { stdout } = await execFileAsync("git", ["cat-file", "blob", hashOut.trim()], {
+      cwd: this.rootDir,
+      maxBuffer: MAX_BUFFER,
+      encoding: "buffer"
+    });
+    return stdout;
+  }
+  /** ルート配下の既存ファイルの絶対パスを返す (realpathSync は存在しないパスで throw する) */
+  resolveInsideRoot(filepath) {
+    const rootDir = realpathSync(resolve(this.rootDir));
+    const abs = realpathSync(resolve(rootDir, normalizeRelPath(filepath)));
+    if (abs !== rootDir && !abs.startsWith(`${rootDir}${sep}`)) {
+      throw new Error("File path outside the viewer root");
+    }
+    return abs;
+  }
+};
+function normalizeRelPath(filepath) {
+  if (filepath.length === 0) throw new Error("Invalid file path");
+  const normalized = filepath.replace(/\\/g, "/");
+  if (normalized.startsWith("/") || normalized.split("/").includes("..")) {
+    throw new Error("File path outside the viewer root");
+  }
+  return normalized;
+}
+function isTooLargeContent(side) {
+  if (!side) return false;
+  if (Buffer.byteLength(side.content, "utf8") > MAX_CONTENT_BYTES) return true;
+  let lineCount = 1;
+  for (let i = 0; i < side.content.length; i++) {
+    if (side.content.charCodeAt(i) === 10) lineCount++;
+    if (lineCount > MAX_CONTENT_LINES) return true;
+  }
+  return false;
+}
+
+// src/server/git/diff.ts
+import { createHash } from "crypto";
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { simpleGit } from "simple-git";
+var MAX_UNTRACKED_FILE_BYTES = 2 * 1024 * 1024;
+var GitDiff = class {
+  constructor(repoRoot) {
+    this.repoRoot = repoRoot;
+    this.git = simpleGit(repoRoot);
+  }
+  repoRoot;
+  git;
+  async resolveBase(range) {
+    if (range.baseMode !== "merge-base") return range.base;
+    const target = range.target === "working" || range.target === "staged" || range.target === "." ? "HEAD" : range.target;
+    const out = await this.git.raw(["merge-base", target, range.base]);
+    return out.trim();
+  }
+  async getDiff(range) {
+    const base = await this.resolveBase(range);
+    let diffArgs;
+    let label;
+    let resolvedBase = base;
+    let resolvedTarget = range.target;
+    if (range.target === "working") {
+      diffArgs = [];
+      label = "Working Directory (unstaged changes)";
+      resolvedBase = "staged";
+    } else if (range.target === "staged") {
+      const baseHash = shortHash(await this.git.revparse([base]));
+      diffArgs = ["--cached", base];
+      label = `${baseHash} vs Staging Area`;
+      resolvedBase = baseHash;
+    } else if (range.target === ".") {
+      const baseHash = shortHash(await this.git.revparse([base]));
+      diffArgs = [base];
+      label = `${baseHash} vs Working Directory`;
+      resolvedBase = baseHash;
+      resolvedTarget = "working";
+    } else {
+      const targetHash = shortHash(await this.git.revparse([range.target]));
+      const baseHash = shortHash(await this.git.revparse([base]));
+      diffArgs = [baseHash, targetHash];
+      label = `${baseHash}..${targetHash}`;
+      resolvedBase = baseHash;
+      resolvedTarget = targetHash;
+    }
+    diffArgs.push("--no-ext-diff", "--color=never");
+    const raw = await this.git.diff(diffArgs);
+    const files = parseUnifiedDiff(raw);
+    if (range.target === "working" || range.target === ".") {
+      files.push(...await this.getUntrackedFiles(new Set(files.map((f) => f.path))));
+    }
+    files.sort((a, b) => a.path.localeCompare(b.path));
+    return { files, label, resolvedBase, resolvedTarget };
+  }
+  /** untracked ファイルを added 扱いで diff に含める */
+  async getUntrackedFiles(known) {
+    const out = await this.git.raw(["ls-files", "--others", "--exclude-standard", "-z"]);
+    const paths = out.split("\0").filter((p) => p.length > 0 && !known.has(p));
+    const result = [];
+    for (const path of paths) {
+      try {
+        const buf = readFileSync2(resolve2(this.repoRoot, path));
+        if (buf.length > MAX_UNTRACKED_FILE_BYTES) continue;
+        const isBinary = buf.includes(0);
+        const text = isBinary ? "" : buf.toString("utf8");
+        const lines = text.length === 0 ? 0 : text.split("\n").filter((l, i, a) => i < a.length - 1 || l !== "").length;
+        result.push({
+          path,
+          status: "added",
+          additions: isBinary ? 0 : lines,
+          deletions: 0,
+          isBinary,
+          contentHash: sha256(`untracked:${path}:${sha256(buf.toString("base64"))}`)
+        });
+      } catch {
+      }
+    }
+    return result;
+  }
+  /** tracked + untracked (gitignore 除外) の全ファイル一覧 (Quick Open 用) */
+  async listRepoFiles() {
+    const [tracked, untracked] = await Promise.all([
+      this.git.raw(["ls-files", "-z"]),
+      this.git.raw(["ls-files", "--others", "--exclude-standard", "-z"])
+    ]);
+    const paths = /* @__PURE__ */ new Set();
+    for (const out of [tracked, untracked]) {
+      for (const path of out.split("\0")) {
+        if (path.length > 0) paths.add(path);
+      }
+    }
+    return [...paths].sort((a, b) => a.localeCompare(b));
+  }
+  async validateRef(ref) {
+    if (ref === "." || ref === "working" || ref === "staged") return true;
+    try {
+      await this.git.revparse(["--verify", `${ref}^{commit}`]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+function shortHash(hash) {
+  return hash.trim().slice(0, 7);
+}
+function sha256(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+function parseUnifiedDiff(diffText) {
+  const files = [];
+  const blocks = diffText.split(/^diff --git /m).slice(1);
+  for (const block of blocks) {
+    const file = parseFileBlock(`diff --git ${block}`);
+    if (file) files.push(file);
+  }
+  return files;
+}
+function parseFileBlock(block) {
+  const lines = block.split("\n");
+  const headerPaths = parseDiffHeaderPaths(lines[0] ?? "");
+  const minusLine = lines.find((l) => l.startsWith("--- "));
+  const plusLine = lines.find((l) => l.startsWith("+++ "));
+  const renameFrom = extractPath(lines.find((l) => l.startsWith("rename from ")), "rename from ");
+  const renameTo = extractPath(lines.find((l) => l.startsWith("rename to ")), "rename to ");
+  const plusPath = extractPath(plusLine, "+++ ");
+  const minusPath = extractPath(minusLine, "--- ");
+  const newPath = renameTo ?? plusPath ?? headerPaths?.newPath;
+  const oldPath = renameFrom ?? minusPath ?? headerPaths?.oldPath ?? newPath;
+  const path = newPath ?? oldPath;
+  if (!path) return null;
+  let status = "modified";
+  if (lines.some((l) => l.startsWith("new file mode")) || minusLine?.includes("/dev/null")) {
+    status = "added";
+  } else if (lines.some((l) => l.startsWith("deleted file mode")) || plusLine?.includes("/dev/null")) {
+    status = "deleted";
+  } else if (oldPath !== void 0 && newPath !== void 0 && oldPath !== newPath) {
+    status = "renamed";
+  }
+  const isBinary = lines.some((l) => l.startsWith("Binary files ") || l === "GIT binary patch");
+  let additions = 0;
+  let deletions = 0;
+  let inChunk = false;
+  for (const line of lines) {
+    if (line.startsWith("@@")) {
+      inChunk = true;
+      continue;
+    }
+    if (!inChunk) continue;
+    if (line.startsWith("+")) additions++;
+    else if (line.startsWith("-")) deletions++;
+  }
+  return {
+    path,
+    oldPath: status === "renamed" ? oldPath : void 0,
+    status,
+    additions,
+    deletions,
+    isBinary,
+    contentHash: sha256(block)
+  };
+}
+function parseDiffHeaderPaths(headerLine) {
+  if (!headerLine.startsWith("diff --git ")) return null;
+  const raw = headerLine.slice("diff --git ".length);
+  const segments = [];
+  let current = "";
+  let isInQuotes = false;
+  for (let i = 0; i < raw.length; i++) {
+    const char = raw[i];
+    const prev = i > 0 ? raw[i - 1] : null;
+    if (char === '"' && prev !== "\\") {
+      isInQuotes = !isInQuotes;
+      current += char;
+      continue;
+    }
+    if (char === " " && !isInQuotes && prev !== "\\") {
+      if (current) {
+        segments.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current) segments.push(current);
+  if (segments.length !== 2) return null;
+  return {
+    oldPath: decodeGitPath(segments[0]),
+    newPath: decodeGitPath(segments[1])
+  };
+}
+function extractPath(line, prefix) {
+  if (!line?.startsWith(prefix)) return void 0;
+  return decodeGitPath(line.slice(prefix.length));
+}
+function decodeGitPath(rawPath) {
+  if (typeof rawPath !== "string") return void 0;
+  const trimmed = rawPath.startsWith('"') && rawPath.endsWith('"') ? rawPath.slice(1, -1) : rawPath;
+  let path = trimmed;
+  for (const prefix of ["a/", "b/", "c/", "i/", "w/"]) {
+    if (path.startsWith(prefix)) {
+      path = path.slice(prefix.length);
+      break;
+    }
+  }
+  const tabIndex = path.indexOf("	");
+  if (tabIndex !== -1) path = path.slice(0, tabIndex);
+  if (path === "/dev/null") return void 0;
+  const bytes = [];
+  for (let i = 0; i < path.length; i++) {
+    const char = path[i];
+    if (char === "\\" && i + 1 < path.length) {
+      const next = path[i + 1];
+      if (/[0-7]/.test(next)) {
+        let octal = next;
+        let read = 1;
+        while (read < 3 && i + 1 + read < path.length && /[0-7]/.test(path[i + 1 + read])) {
+          octal += path[i + 1 + read];
+          read++;
+        }
+        bytes.push(parseInt(octal, 8));
+        i += read;
+        continue;
+      }
+      const escapes = {
+        t: 9,
+        n: 10,
+        r: 13,
+        b: 8,
+        f: 12,
+        v: 11,
+        a: 7,
+        "\\": 92,
+        '"': 34,
+        " ": 32
+      };
+      if (next in escapes) {
+        bytes.push(escapes[next]);
+      } else {
+        bytes.push(...Buffer.from(next, "utf8"));
+      }
+      i++;
+      continue;
+    }
+    bytes.push(...Buffer.from(char, "utf8"));
+  }
+  return Buffer.from(bytes).toString("utf8");
+}
+
+// src/server/git/refs.ts
+import { simpleGit as simpleGit2 } from "simple-git";
+var GitRefs = class {
+  git;
+  constructor(repoRoot) {
+    this.git = simpleGit2(repoRoot);
+  }
+  async getRanges() {
+    const [branches, log, defaultBranch] = await Promise.all([
+      this.getBranches(),
+      this.getRecentCommits(),
+      this.getDefaultBranch()
+    ]);
+    return { branches, recentCommits: log, defaultBranch };
+  }
+  async getBranches() {
+    const summary = await this.git.branch(["--sort=-committerdate"]);
+    return summary.all.filter((b) => !b.startsWith("remotes/") || b.startsWith("remotes/origin/"));
+  }
+  async getRecentCommits() {
+    const log = await this.git.log({ maxCount: 50 });
+    return log.all.map((c) => ({
+      sha: c.hash,
+      shortSha: c.hash.slice(0, 7),
+      subject: c.message,
+      date: c.date
+    }));
+  }
+  async getDefaultBranch() {
+    try {
+      const out = await this.git.raw(["symbolic-ref", "refs/remotes/origin/HEAD"]);
+      return out.trim().replace("refs/remotes/", "");
+    } catch {
+      for (const name of ["main", "master"]) {
+        try {
+          await this.git.revparse(["--verify", `refs/heads/${name}`]);
+          return name;
+        } catch {
+        }
+      }
+      return null;
+    }
+  }
+};
+
+// src/server/events.ts
+var EventBus = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  clients = /* @__PURE__ */ new Set();
+  shutdownTimer = null;
+  register(client) {
+    this.clients.add(client);
+    if (this.shutdownTimer) {
+      clearTimeout(this.shutdownTimer);
+      this.shutdownTimer = null;
+    }
+  }
+  unregister(client) {
+    this.clients.delete(client);
+    if (this.clients.size === 0 && !this.options.isKeepAlive) {
+      this.shutdownTimer = setTimeout(() => {
+        if (this.clients.size === 0) {
+          console.log("kaleido: all clients disconnected, shutting down");
+          if (this.options.onShutdown) {
+            this.options.onShutdown();
+          } else {
+            process.exit(0);
+          }
+        }
+      }, 5e3);
+    }
+  }
+  broadcast(event) {
+    for (const client of this.clients) {
+      void client.write(event.type, JSON.stringify(event)).catch(() => {
+        this.clients.delete(client);
+      });
+    }
+  }
+};
+
+// src/server/store/reviewStore.ts
+import { createHash as createHash2 } from "crypto";
+import { mkdirSync, readFileSync as readFileSync3, renameSync, writeFileSync } from "fs";
+import { realpathSync as realpathSync2 } from "fs";
+import { join as join3 } from "path";
+import envPaths from "env-paths";
+import { nanoid } from "nanoid";
+function computeRepoId(repoRoot) {
+  return createHash2("sha256").update(realpathSync2(repoRoot)).digest("hex").slice(0, 16);
+}
+function openReviewStore(repoRoot) {
+  const realRoot = realpathSync2(repoRoot);
+  return new ReviewStore(computeRepoId(realRoot), realRoot);
+}
+var STORE_VERSION = 1;
+var ReviewStore = class {
+  baseDir;
+  constructor(repoId, repoRoot) {
+    this.baseDir = join3(envPaths("kaleido", { suffix: "" }).data, "reviews", repoId);
+    mkdirSync(join3(this.baseDir, "comments"), { recursive: true });
+    this.writeAtomic(join3(this.baseDir, "meta.json"), { repoRoot });
+  }
+  readJson(path) {
+    try {
+      return JSON.parse(readFileSync3(path, "utf8"));
+    } catch {
+      return null;
+    }
+  }
+  writeAtomic(path, data) {
+    const tmp = `${path}.tmp-${process.pid}`;
+    writeFileSync(tmp, JSON.stringify(data, null, 2));
+    renameSync(tmp, path);
+  }
+  // --- viewed ---
+  get viewedPath() {
+    return join3(this.baseDir, "viewed.json");
+  }
+  getViewed() {
+    const data = this.readJson(this.viewedPath);
+    if (!data || data.version !== STORE_VERSION) return { entries: {} };
+    return { entries: data.entries };
+  }
+  setViewed(path, hash, isViewed) {
+    const state = this.getViewed();
+    if (isViewed) {
+      state.entries[path] = { hash, viewedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    } else {
+      delete state.entries[path];
+    }
+    this.writeAtomic(this.viewedPath, { version: STORE_VERSION, entries: state.entries });
+  }
+  // --- comments ---
+  commentsPath(rangeKey2) {
+    const safe = rangeKey2.replace(/[^a-zA-Z0-9_.~-]/g, "_");
+    return join3(this.baseDir, "comments", `${safe}.json`);
+  }
+  getComments(rangeKey2) {
+    const data = this.readJson(this.commentsPath(rangeKey2));
+    if (!data || data.version !== STORE_VERSION) return [];
+    return data.comments;
+  }
+  saveComments(rangeKey2, comments) {
+    this.writeAtomic(this.commentsPath(rangeKey2), { version: STORE_VERSION, comments });
+  }
+  addComment(rangeKey2, req) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const comment = { id: nanoid(10), ...req, createdAt: now, updatedAt: now };
+    const comments = this.getComments(rangeKey2);
+    comments.push(comment);
+    this.saveComments(rangeKey2, comments);
+    return comment;
+  }
+  updateComment(rangeKey2, id, body) {
+    const comments = this.getComments(rangeKey2);
+    const target = comments.find((c) => c.id === id);
+    if (!target) return null;
+    target.body = body;
+    target.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.saveComments(rangeKey2, comments);
+    return target;
+  }
+  /** 範囲のコメントを全削除し、削除したものを返す (クライアント側 Undo 用) */
+  clearComments(rangeKey2) {
+    const comments = this.getComments(rangeKey2);
+    this.saveComments(rangeKey2, []);
+    return comments;
+  }
+  /** クリアの Undo 用。id 重複は既存を優先して復元する */
+  restoreComments(rangeKey2, comments) {
+    const existing = this.getComments(rangeKey2);
+    const existingIds = new Set(existing.map((c) => c.id));
+    const restored = [...existing, ...comments.filter((c) => !existingIds.has(c.id))];
+    this.saveComments(rangeKey2, restored);
+  }
+  deleteComment(rangeKey2, id) {
+    const comments = this.getComments(rangeKey2);
+    const next = comments.filter((c) => c.id !== id);
+    if (next.length === comments.length) return false;
+    this.saveComments(rangeKey2, next);
+    return true;
+  }
+};
+
+// src/server/ts/workerClient.ts
+import { Worker } from "worker_threads";
+var CALL_TIMEOUT_MS = 3e4;
+function resolveWorker() {
+  if (import.meta.url.endsWith(".ts")) {
+    return { url: new URL("./worker.ts", import.meta.url), execArgv: ["--import", "tsx"] };
+  }
+  return { url: new URL("../server/ts/worker.js", import.meta.url), execArgv: [] };
+}
+var TsWorkerClient = class {
+  worker;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  constructor(repoRoot) {
+    const { url, execArgv } = resolveWorker();
+    this.worker = new Worker(url, { workerData: { repoRoot }, execArgv });
+    this.worker.unref();
+    this.worker.on("message", (message) => {
+      const call = this.pending.get(message.id);
+      if (!call) return;
+      this.pending.delete(message.id);
+      if (message.error !== void 0) {
+        call.reject(new Error(message.error));
+      } else {
+        call.resolve(message.result);
+      }
+    });
+    this.worker.on("error", (error) => {
+      console.error("[kaleido] ts worker error:", error);
+      const wrapped = error instanceof Error ? error : new Error(String(error));
+      for (const call of this.pending.values()) call.reject(wrapped);
+      this.pending.clear();
+    });
+    this.worker.on("exit", (code) => {
+      const error = new Error(`ts worker exited with code ${code}`);
+      for (const call of this.pending.values()) call.reject(error);
+      this.pending.clear();
+    });
+  }
+  call(method, params) {
+    const id = this.nextId++;
+    return new Promise((resolve4, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`ts worker call timed out: ${method}`));
+      }, CALL_TIMEOUT_MS);
+      this.pending.set(id, {
+        resolve: (value) => {
+          clearTimeout(timer);
+          resolve4(value);
+        },
+        reject: (reason) => {
+          clearTimeout(timer);
+          reject(reason);
+        }
+      });
+      this.worker.postMessage({ id, method, params });
+    });
+  }
+  hover(params) {
+    return this.call("hover", params);
+  }
+  diagnostics(params) {
+    return this.call("diagnostics", params);
+  }
+  definition(params) {
+    return this.call("definition", params);
+  }
+  references(params) {
+    return this.call("references", params);
+  }
+  warmup(paths) {
+    this.worker.postMessage({ method: "warmup", params: { paths } });
+  }
+  invalidateFile(path) {
+    this.worker.postMessage({ method: "invalidateFile", params: { path } });
+  }
+};
+
+// src/server/context.ts
+function createAppContext(rootDir, initialRange, options) {
+  const realRoot = realpathSync3(rootDir);
+  const repoId = computeRepoId(realRoot);
+  return {
+    rootDir: realRoot,
+    repoId,
+    isGitRepo: options.isGitRepo,
+    initialRange,
+    config: loadViewerConfig(realRoot, options.excludes),
+    gitDiff: options.isGitRepo ? new GitDiff(realRoot) : null,
+    gitRefs: options.isGitRepo ? new GitRefs(realRoot) : null,
+    fileContent: new FileContent(realRoot, options.isGitRepo),
+    tsService: new TsWorkerClient(realRoot),
+    reviewStore: new ReviewStore(repoId, realRoot),
+    eventBus: new EventBus({ isKeepAlive: options.isKeepAlive, onShutdown: options.onShutdown })
+  };
+}
+
+// src/server/watcher.ts
+import { relative, sep as sep2 } from "path";
+import watcher from "@parcel/watcher";
+var DEBOUNCE_MS = 300;
+async function startWatcher(rootDir, onChange) {
+  let pending = /* @__PURE__ */ new Set();
+  let timer = null;
+  const flush = () => {
+    timer = null;
+    const paths = [...pending];
+    pending = /* @__PURE__ */ new Set();
+    if (paths.length > 0) onChange(paths);
+  };
+  const subscription = await watcher.subscribe(
+    rootDir,
+    (err, events) => {
+      if (err) return;
+      for (const event of events) {
+        const rel = relative(rootDir, event.path).split(sep2).join("/");
+        if (rel.startsWith(".git/")) {
+          if (rel !== ".git/HEAD" && rel !== ".git/index") continue;
+        }
+        pending.add(rel);
+      }
+      if (pending.size > 0 && !timer) {
+        timer = setTimeout(flush, DEBOUNCE_MS);
+      }
+    },
+    {
+      ignore: [
+        "**/node_modules/**",
+        ".git/objects/**",
+        ".git/logs/**",
+        ".git/refs/**",
+        "**/.DS_Store"
+      ]
+    }
+  );
+  return () => subscription.unsubscribe();
+}
+
+// src/server/index.ts
+async function startServer(options) {
+  const ctx = createAppContext(options.rootDir, options.initialRange, {
+    isGitRepo: options.isGitRepo,
+    isKeepAlive: options.isKeepAlive,
+    excludes: options.excludes,
+    onShutdown: options.onShutdown
+  });
+  const app = createApp(ctx);
+  void startWatcher(ctx.rootDir, (paths) => {
+    for (const path of paths) {
+      ctx.tsService.invalidateFile(path);
+    }
+    ctx.eventBus.broadcast({ type: "files-changed" });
+  }).catch((error) => {
+    console.warn("kaleido: file watcher unavailable:", error);
+  });
+  const clientDir = join4(dirname(fileURLToPath(import.meta.url)), "..", "client");
+  if (existsSync(join4(clientDir, "index.html"))) {
+    app.use("/*", serveStatic({ root: relativizeForServeStatic(clientDir) }));
+    app.get("*", serveStatic({ path: join4(relativizeForServeStatic(clientDir), "index.html") }));
+  }
+  const port = await findAvailablePort(options.port, options.host);
+  const server = serve({ fetch: app.fetch, port, hostname: options.host });
+  const url = `http://${options.host === "0.0.0.0" ? "localhost" : options.host}:${port}`;
+  return { port, url, server };
+}
+function relativizeForServeStatic(absDir) {
+  return relative2(process.cwd(), absDir) || ".";
+}
+async function findAvailablePort(startPort, host) {
+  const { createServer } = await import("net");
+  for (let port = startPort; port < startPort + 100; port++) {
+    const isFree = await new Promise((resolvePromise) => {
+      const probe = createServer();
+      probe.once("error", () => resolvePromise(false));
+      probe.once("listening", () => probe.close(() => resolvePromise(true)));
+      probe.listen(port, host);
+    });
+    if (isFree) return port;
+  }
+  throw new Error(`No available port found in range ${startPort}-${startPort + 99}`);
+}
+
+// src/cli/args.ts
+import { execFileSync, execSync } from "child_process";
+import { realpathSync as realpathSync4, statSync } from "fs";
+import { resolve as resolve3 } from "path";
+function findGitRoot(cwd) {
+  try {
+    return execSync("git rev-parse --show-toplevel", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function isCommitish(gitRoot, ref) {
+  try {
+    execFileSync("git", ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], {
+      cwd: gitRoot,
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function resolveViewerTarget(params) {
+  const { cwd, target, base } = params;
+  if (params.dir !== void 0) {
+    const dir = resolve3(cwd, params.dir);
+    if (!isDirectory(dir)) throw new Error(`Not a directory: ${params.dir}`);
+    return forExplicitRoot(dir, target, base);
+  }
+  const gitRoot = findGitRoot(cwd);
+  if (target !== void 0 && target !== "working" && target !== "staged" && target !== "." && !(gitRoot !== null && isCommitish(gitRoot, target)) && isDirectory(resolve3(cwd, target))) {
+    if (base !== void 0) {
+      throw new Error("A base cannot be given when opening a directory");
+    }
+    return forExplicitRoot(resolve3(cwd, target), void 0, void 0);
+  }
+  if (gitRoot === null) {
+    if (target !== void 0) {
+      throw new Error(
+        `Not a git repository, and no such directory: ${target}
+Run kaleido without arguments to browse the current directory.`
+      );
+    }
+    return { rootDir: cwd, isGitRepo: false, range: BROWSE_RANGE };
+  }
+  return {
+    rootDir: gitRoot,
+    isGitRepo: true,
+    range: target ? resolveRange(target, base) : resolveDefaultRange(gitRoot)
+  };
+}
+function forExplicitRoot(dir, target, base) {
+  const gitRoot = findGitRoot(dir);
+  if (gitRoot === null || realpathSync4(gitRoot) !== realpathSync4(dir)) {
+    if (target !== void 0) {
+      throw new Error(`${dir} is not a git repository root; ranges are unavailable`);
+    }
+    return { rootDir: dir, isGitRepo: false, range: BROWSE_RANGE };
+  }
+  return {
+    rootDir: gitRoot,
+    isGitRepo: true,
+    range: target ? resolveRange(target, base) : resolveDefaultRange(gitRoot)
+  };
+}
+function resolveRange(target, base) {
+  if (target === "working") {
+    return { target: "working", base: "HEAD" };
+  }
+  if (target === "staged" || target === ".") {
+    return { target, base: base ?? "HEAD" };
+  }
+  if (base) {
+    return { target, base };
+  }
+  return { target, base: `${target}^` };
+}
+function resolveDefaultRange(rootDir) {
+  const succeeds = (command) => {
+    try {
+      execSync(command, { cwd: rootDir, stdio: ["ignore", "pipe", "pipe"] });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (!succeeds("git diff --cached --quiet")) {
+    return { target: "staged", base: "HEAD" };
+  }
+  const hasUnstaged = !succeeds("git diff --quiet");
+  const hasUntracked = execSync("git ls-files --others --exclude-standard", {
+    cwd: rootDir,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  }).trim().length > 0;
+  if (hasUnstaged || hasUntracked) {
+    return { target: ".", base: "HEAD" };
+  }
+  if (succeeds("git rev-parse --verify HEAD^")) {
+    return { target: "HEAD", base: "HEAD^" };
+  }
+  return { target: ".", base: "HEAD" };
+}
+
+// src/cli/index.ts
+var program = new Command();
+var collect = (value, previous) => [...previous, value];
+program.name("kaleido").description("Monaco-based local web file viewer with TypeScript hover, diff and review tools").version("0.1.0");
+program.command("serve", { isDefault: true }).description("start the viewer (default command)").argument(
+  "[target]",
+  'directory to browse, commit-ish to view, or "working" / "staged" / "." (default: auto-detect)'
+).argument("[base]", "commit-ish to compare against (default: HEAD or <target>^)").option("--port <port>", "preferred port (auto-increments if taken)", "4890").option("--host <host>", "host to bind", "127.0.0.1").option("--dir <path>", "directory to open (default: current directory)").option("--repo <path>", "alias of --dir").option("--exclude <pattern>", "extra path pattern to hide from the file tree", collect, []).option("--no-open", "do not open the browser").option("--no-keep-alive", "shut down the server when all browser tabs are closed").action(async (target, base, options) => {
+  try {
+    const { rootDir, isGitRepo, range } = resolveViewerTarget({
+      cwd: process.cwd(),
+      dir: options.dir ?? options.repo,
+      target,
+      base
+    });
+    const printCommentsAndExit = () => {
+      try {
+        const comments = openReviewStore(rootDir).getComments(rangeKey(range));
+        if (comments.length > 0) {
+          console.log(`
+${comments.length} comment(s) for ${describeRange(range)}:
+`);
+          console.log(formatAllCommentsPrompt(comments));
+        }
+      } catch {
+      }
+      process.exit(0);
+    };
+    const { url } = await startServer({
+      rootDir,
+      isGitRepo,
+      initialRange: range,
+      excludes: options.exclude,
+      port: parseInt(options.port, 10),
+      host: options.host,
+      isKeepAlive: options.keepAlive,
+      onShutdown: printCommentsAndExit
+    });
+    process.on("SIGINT", printCommentsAndExit);
+    process.on("SIGTERM", printCommentsAndExit);
+    console.log(`kaleido: ${describeRange(range)} @ ${rootDir}`);
+    console.log(`  ${url}`);
+    if (options.open) {
+      await open(url);
+    }
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("comments").description("print saved comments for a range as an AI prompt").argument("[target]", 'commit-ish, or "working" / "staged" / "." (default: ".")').argument("[base]", "commit-ish to compare against (default: HEAD or <target>^)").option("--dir <path>", "directory to read comments for (default: current directory)").option("--repo <path>", "alias of --dir").option("--json", "output as JSON instead of prompt text").action((target, base, options) => {
+  try {
+    const { rootDir, range } = resolveViewerTarget({
+      cwd: process.cwd(),
+      dir: options.dir ?? options.repo,
+      target,
+      base
+    });
+    const comments = openReviewStore(rootDir).getComments(rangeKey(range));
+    if (options.json) {
+      console.log(JSON.stringify(comments, null, 2));
+      return;
+    }
+    if (comments.length === 0) {
+      console.error(`No comments for ${describeRange(range)}`);
+      process.exitCode = 1;
+      return;
+    }
+    console.log(formatAllCommentsPrompt(comments));
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.parse();