getgloss 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,638 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+import openBrowser from "open";
+
+// src/mcp/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod/v4";
+
+// src/cli/lifecycle.ts
+import { spawn } from "child_process";
+import { existsSync, openSync } from "fs";
+import { readFile, rm, writeFile } from "fs/promises";
+import { fileURLToPath } from "url";
+import getPort from "get-port";
+
+// src/shared/paths.ts
+import { mkdir } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+var packageVersion = "0.1.0";
+function expandHome(input) {
+  if (input === "~") {
+    return homedir();
+  }
+  if (input.startsWith("~/")) {
+    return path.join(homedir(), input.slice(2));
+  }
+  return input;
+}
+function globalStateDir() {
+  return expandHome(process.env.GLOSS_STATE_DIR ?? "~/.gloss");
+}
+function globalServerFile() {
+  return path.join(globalStateDir(), "server.json");
+}
+function globalLogDir() {
+  return path.join(globalStateDir(), "logs");
+}
+function globalServerLogFile() {
+  return path.join(globalLogDir(), "server.log");
+}
+async function ensureDir(dir) {
+  await mkdir(dir, { recursive: true });
+}
+
+// src/cli/server-client.ts
+var ServerClient = class {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  baseUrl;
+  async health() {
+    return this.get("/api/health");
+  }
+  async createReview(diff) {
+    return this.post("/api/reviews", diff);
+  }
+  async getReview(reviewId) {
+    return this.get(`/api/reviews/${reviewId}`);
+  }
+  async listReviews() {
+    return this.get("/api/reviews");
+  }
+  async getFeedback(reviewId) {
+    return this.get(`/api/reviews/${reviewId}/feedback`);
+  }
+  async markResolved(reviewId, summary) {
+    return this.post(`/api/reviews/${reviewId}/resolved`, { summary });
+  }
+  async submitReview(reviewId, comments) {
+    return this.post(`/api/reviews/${reviewId}/submit`, { comments });
+  }
+  async watchReview(reviewId, timeoutSeconds) {
+    const controller = new AbortController();
+    const timeout = timeoutSeconds && timeoutSeconds > 0 ? setTimeout(() => controller.abort(), timeoutSeconds * 1e3) : null;
+    try {
+      const response = await fetch(`${this.baseUrl}/api/reviews/${reviewId}/events`, {
+        signal: controller.signal
+      });
+      if (!response.ok || !response.body) {
+        throw new Error(`watch failed: ${response.status} ${await response.text()}`);
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) {
+          throw new Error("watch stream ended before completion");
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const events = buffer.split("\n\n");
+        buffer = events.pop() ?? "";
+        for (const eventChunk of events) {
+          const dataLine = eventChunk.split("\n").find((line) => line.startsWith("data:"));
+          if (!dataLine) {
+            continue;
+          }
+          const event = JSON.parse(dataLine.slice(5).trim());
+          if (event.type === "review.completed" || event.type === "review.cancelled") {
+            return event;
+          }
+        }
+      }
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+    }
+  }
+  async get(path3) {
+    const response = await fetch(`${this.baseUrl}${path3}`);
+    return parseResponse(response);
+  }
+  async post(path3, body) {
+    const response = await fetch(`${this.baseUrl}${path3}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    return parseResponse(response);
+  }
+};
+async function parseResponse(response) {
+  if (!response.ok) {
+    throw new Error(`${response.status} ${response.statusText}: ${await response.text()}`);
+  }
+  return await response.json();
+}
+
+// src/cli/lifecycle.ts
+async function readServerInfo() {
+  try {
+    return JSON.parse(await readFile(globalServerFile(), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function serverUrl(info) {
+  return `http://localhost:${info.port}`;
+}
+async function isServerResponsive(info) {
+  if (!isPidAlive(info.pid)) {
+    return false;
+  }
+  try {
+    const health = await new ServerClient(serverUrl(info)).health();
+    return health.ok === true;
+  } catch {
+    return false;
+  }
+}
+async function ensureServer(options = {}) {
+  const existing = await readServerInfo();
+  if (existing && await isServerResponsive(existing)) {
+    return existing;
+  }
+  return startServer(options);
+}
+async function startServer(options = {}) {
+  const existing = await readServerInfo();
+  if (existing && await isServerResponsive(existing)) {
+    return existing;
+  }
+  await ensureDir(globalStateDir());
+  await ensureDir(globalLogDir());
+  const port = options.port ?? await getPort();
+  const daemonPath = fileURLToPath(new URL("../server/daemon.js", import.meta.url));
+  if (!existsSync(daemonPath)) {
+    throw new Error(`Cannot find server daemon at ${daemonPath}. Run pnpm build first.`);
+  }
+  const logFd = openSync(globalServerLogFile(), "a");
+  const child = spawn(process.execPath, [daemonPath], {
+    detached: true,
+    env: {
+      ...process.env,
+      GLOSS_PORT: String(port),
+      GLOSS_STATE_DIR: globalStateDir()
+    },
+    stdio: ["ignore", logFd, logFd]
+  });
+  child.unref();
+  const info = {
+    pid: child.pid ?? -1,
+    port,
+    version: packageVersion,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    stateDir: globalStateDir()
+  };
+  await writeFile(globalServerFile(), `${JSON.stringify(info, null, 2)}
+`);
+  const deadline = Date.now() + 8e3;
+  while (Date.now() < deadline) {
+    if (await isServerResponsive(info)) {
+      return info;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 150));
+  }
+  throw new Error(`Server did not become responsive. See ${globalServerLogFile()}`);
+}
+async function stopServer() {
+  const info = await readServerInfo();
+  if (!info) {
+    return { stopped: false, info: null };
+  }
+  if (isPidAlive(info.pid)) {
+    process.kill(info.pid, "SIGTERM");
+  }
+  await rm(globalServerFile(), { force: true });
+  return { stopped: true, info };
+}
+function isPidAlive(pid) {
+  if (pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/mcp/index.ts
+function textResult(value) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+      }
+    ]
+  };
+}
+async function client() {
+  const info = await ensureServer();
+  return new ServerClient(serverUrl(info));
+}
+async function startMcpServer() {
+  const server = new McpServer({
+    name: "gloss",
+    version: packageVersion
+  });
+  server.registerTool(
+    "list_pending_reviews",
+    {
+      title: "List pending Gloss reviews",
+      description: "List pending local Gloss review sessions."
+    },
+    async () => {
+      const api = await client();
+      const { reviews } = await api.listReviews();
+      return textResult({ reviews: reviews.filter((review) => review.status === "pending") });
+    }
+  );
+  server.registerTool(
+    "get_review",
+    {
+      title: "Get Gloss review",
+      description: "Fetch review metadata and diff payload.",
+      inputSchema: { id: z.string() }
+    },
+    async ({ id }) => textResult(await (await client()).getReview(id))
+  );
+  server.registerTool(
+    "watch_review",
+    {
+      title: "Watch Gloss review",
+      description: "Block until a review completes, then return feedback.",
+      inputSchema: {
+        id: z.string(),
+        timeout: z.number().optional()
+      }
+    },
+    async ({ id, timeout }) => {
+      const api = await client();
+      await api.watchReview(id, timeout);
+      return textResult(await api.getFeedback(id));
+    }
+  );
+  server.registerTool(
+    "get_review_feedback",
+    {
+      title: "Get Gloss review feedback",
+      description: "Fetch completed review feedback.",
+      inputSchema: { id: z.string() }
+    },
+    async ({ id }) => textResult(await (await client()).getFeedback(id))
+  );
+  server.registerTool(
+    "mark_review_resolved",
+    {
+      title: "Mark Gloss review resolved",
+      description: "Write a resolved marker for a completed review.",
+      inputSchema: {
+        id: z.string(),
+        summary: z.string().optional()
+      }
+    },
+    async ({ id, summary }) => textResult(await (await client()).markResolved(id, summary))
+  );
+  await server.connect(new StdioServerTransport());
+}
+
+// src/cli/git.ts
+import { execa } from "execa";
+
+// src/cli/diff-parser.ts
+import path2 from "path";
+var hunkHeaderPattern = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/;
+function stripGitPath(input) {
+  return input.replace(/^[ab]\//, "");
+}
+function languageForPath(filePath) {
+  const ext = path2.extname(filePath).slice(1).toLowerCase();
+  if (!ext) {
+    return null;
+  }
+  const map = {
+    cjs: "js",
+    mjs: "js",
+    js: "js",
+    jsx: "jsx",
+    ts: "ts",
+    tsx: "tsx",
+    py: "python",
+    rb: "ruby",
+    sh: "bash",
+    md: "markdown",
+    yml: "yaml",
+    yaml: "yaml"
+  };
+  return map[ext] ?? ext;
+}
+function emptyFile() {
+  return {
+    path: "",
+    oldPath: null,
+    additions: 0,
+    deletions: 0,
+    isBinary: false,
+    isDeleted: false,
+    isNew: false,
+    isRenamed: false,
+    language: null,
+    hunks: []
+  };
+}
+function parseUnifiedDiff(diffText) {
+  const files = [];
+  let current = null;
+  let currentHunk = null;
+  let oldCursor = 0;
+  let newCursor = 0;
+  const finalizeFile = () => {
+    if (current?.path) {
+      current.language = languageForPath(current.path);
+      files.push(current);
+    }
+  };
+  for (const line of diffText.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      finalizeFile();
+      current = emptyFile();
+      currentHunk = null;
+      oldCursor = 0;
+      newCursor = 0;
+      const match = /^diff --git a\/(.+) b\/(.+)$/.exec(line);
+      if (match) {
+        current.oldPath = match[1];
+        current.path = match[2];
+      }
+      continue;
+    }
+    if (!current) {
+      continue;
+    }
+    if (line.startsWith("new file mode")) {
+      current.isNew = true;
+      continue;
+    }
+    if (line.startsWith("deleted file mode")) {
+      current.isDeleted = true;
+      continue;
+    }
+    if (line.startsWith("rename from ")) {
+      current.oldPath = line.slice("rename from ".length);
+      current.isRenamed = true;
+      continue;
+    }
+    if (line.startsWith("rename to ")) {
+      current.path = line.slice("rename to ".length);
+      current.isRenamed = true;
+      continue;
+    }
+    if (line.startsWith("Binary files ") || line.startsWith("GIT binary patch")) {
+      current.isBinary = true;
+      continue;
+    }
+    if (line.startsWith("--- ")) {
+      const oldPath = line.slice(4).trim();
+      current.oldPath = oldPath === "/dev/null" ? null : stripGitPath(oldPath);
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      const newPath = line.slice(4).trim();
+      current.path = newPath === "/dev/null" ? current.oldPath ?? current.path : stripGitPath(newPath);
+      continue;
+    }
+    const hunkMatch = hunkHeaderPattern.exec(line);
+    if (hunkMatch) {
+      const oldStart = Number(hunkMatch[1]);
+      const oldLines = Number(hunkMatch[2] ?? "1");
+      const newStart = Number(hunkMatch[3]);
+      const newLines = Number(hunkMatch[4] ?? "1");
+      currentHunk = {
+        oldStart,
+        oldLines,
+        newStart,
+        newLines,
+        header: hunkMatch[5]?.trim() ?? "",
+        lines: []
+      };
+      current.hunks.push(currentHunk);
+      oldCursor = oldStart;
+      newCursor = newStart;
+      continue;
+    }
+    if (!currentHunk) {
+      continue;
+    }
+    const marker = line[0];
+    const content = line.slice(1);
+    let diffLine = null;
+    if (marker === "+") {
+      diffLine = { type: "add", oldLine: null, newLine: newCursor, content };
+      current.additions += 1;
+      newCursor += 1;
+    } else if (marker === "-") {
+      diffLine = { type: "delete", oldLine: oldCursor, newLine: null, content };
+      current.deletions += 1;
+      oldCursor += 1;
+    } else if (marker === " ") {
+      diffLine = { type: "context", oldLine: oldCursor, newLine: newCursor, content };
+      oldCursor += 1;
+      newCursor += 1;
+    } else if (line.startsWith("\")) {
+      continue;
+    }
+    if (diffLine) {
+      currentHunk.lines.push(diffLine);
+    }
+  }
+  finalizeFile();
+  return files;
+}
+
+// src/cli/git.ts
+async function git(args, cwd = process.cwd()) {
+  const result = await execa("git", args, { cwd });
+  return result.stdout.trimEnd();
+}
+async function gitLenient(args, cwd) {
+  const result = await execa("git", args, { cwd, reject: false });
+  if (result.exitCode !== 0 && result.stdout.length === 0) {
+    throw new Error(result.stderr || `git ${args.join(" ")} failed`);
+  }
+  return result.stdout.trimEnd();
+}
+async function getRepoRoot(cwd = process.cwd()) {
+  return git(["rev-parse", "--show-toplevel"], cwd);
+}
+async function captureDiff(baseRef = "HEAD", cwd = process.cwd()) {
+  const repoRoot = await getRepoRoot(cwd);
+  const [baseSha, branchResult, trackedDiff, untrackedFilesRaw] = await Promise.all([
+    git(["rev-parse", baseRef], repoRoot),
+    execa("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: repoRoot, reject: false }),
+    git(["diff", "--no-color", "--find-renames", "--find-copies", baseRef, "--"], repoRoot),
+    git(["ls-files", "--others", "--exclude-standard", "-z"], repoRoot)
+  ]);
+  const untrackedFiles = untrackedFilesRaw.split("\0").filter(Boolean);
+  const untrackedDiffs = await Promise.all(
+    untrackedFiles.map(
+      (filePath) => gitLenient(["diff", "--no-color", "--no-index", "--", "/dev/null", filePath], repoRoot)
+    )
+  );
+  const rawDiff = [trackedDiff, ...untrackedDiffs].filter(Boolean).join("\n");
+  const branch = branchResult.exitCode === 0 ? branchResult.stdout.trim() : null;
+  return {
+    base: { ref: baseRef, sha: baseSha },
+    branch: branch && branch !== "HEAD" ? branch : null,
+    cwd: repoRoot,
+    rawDiff,
+    files: parseUnifiedDiff(rawDiff),
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function assertGitAvailable() {
+  await execa("git", ["--version"]);
+}
+
+// src/cli/index.ts
+function printJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+function printPlain(value) {
+  process.stdout.write(`${value}
+`);
+}
+var program = new Command();
+program.name("gloss").description("Local browser-based diff review for coding-agent loops.").version(packageVersion).option("--json", "print JSON for supported commands").option("--no-color", "disable color output");
+program.command("open").description("Capture diff vs. base and open it for review").option("--base <ref>", "base git ref", "HEAD").option("--print-url", "print review URL").option("--no-open", "do not open a browser").option("--no-watch", "return immediately after registering the review").option("--timeout <seconds>", "watch timeout in seconds", Number).action(
+  async (options) => {
+    const globals = program.opts();
+    const info = await ensureServer();
+    const client2 = new ServerClient(serverUrl(info));
+    const diff = await captureDiff(options.base);
+    const { meta, url } = await client2.createReview(diff);
+    if (options.printUrl) {
+      printPlain(url);
+    }
+    if (options.open !== false) {
+      await openBrowser(url);
+    }
+    if (options.watch === false) {
+      const result2 = { reviewId: meta.id, url, files: diff.files.length };
+      globals.json ? printJson(result2) : printPlain(`Review ${meta.id}: ${url}`);
+      return;
+    }
+    const event = await client2.watchReview(meta.id, options.timeout);
+    if (event.type === "review.cancelled") {
+      process.exitCode = 2;
+      globals.json ? printJson(event) : printPlain(`Review ${meta.id} cancelled`);
+      return;
+    }
+    if (event.type !== "review.completed") {
+      throw new Error(`Unexpected review event ${event.type}`);
+    }
+    const feedback = await client2.getFeedback(meta.id);
+    const result = {
+      reviewId: meta.id,
+      url,
+      files: event.counts.files,
+      comments: event.counts.comments,
+      feedbackPath: `${diff.cwd}/.gloss/reviews/${meta.id}/feedback.json`,
+      markdownPath: `${diff.cwd}/.gloss/reviews/${meta.id}/feedback.md`,
+      feedback
+    };
+    globals.json ? printJson(result) : printPlain(`Review ${meta.id} completed with ${event.counts.comments} comments`);
+  }
+);
+program.command("watch").argument("<reviewId>", "review id").description("Wait for review.completed for an existing review").option("--timeout <seconds>", "watch timeout in seconds", Number).action(async (reviewId, options) => {
+  const globals = program.opts();
+  const info = await ensureServer();
+  const client2 = new ServerClient(serverUrl(info));
+  const event = await client2.watchReview(reviewId, options.timeout);
+  globals.json ? printJson(event) : printPlain(`${event.type} ${event.reviewId}`);
+});
+program.command("start").description("Start or reuse the background server").option("--port <port>", "port to bind", Number).action(async (options) => {
+  const globals = program.opts();
+  const info = await startServer({ port: options.port });
+  globals.json ? printJson(info) : printPlain(`Gloss server running at ${serverUrl(info)} (pid ${info.pid})`);
+});
+program.command("status").description("Show server and active reviews").action(async () => {
+  const globals = program.opts();
+  const info = await readServerInfo();
+  const responsive = info ? await isServerResponsive(info) : false;
+  let reviews = [];
+  if (info && responsive) {
+    reviews = (await new ServerClient(serverUrl(info)).listReviews()).reviews;
+  }
+  const status = { running: responsive, server: info, reviews };
+  globals.json ? printJson(status) : printPlain(
+    responsive && info ? `Gloss server running at ${serverUrl(info)} with ${reviews.length} active review(s)` : "Gloss server is not running"
+  );
+});
+program.command("stop").description("Stop the managed background server").option("--all", "reserved for future multi-server cleanup").action(async () => {
+  const globals = program.opts();
+  const result = await stopServer();
+  globals.json ? printJson(result) : printPlain(result.stopped ? "Gloss server stopped" : "Gloss server was not running");
+});
+program.command("mcp").description("Start the experimental stdio MCP server").action(async () => {
+  await startMcpServer();
+});
+program.command("doctor").description("Diagnose setup and validate git/state").action(async () => {
+  const globals = program.opts();
+  const checks = [];
+  try {
+    await assertGitAvailable();
+    checks.push({ name: "git", ok: true });
+  } catch (error) {
+    checks.push({
+      name: "git",
+      ok: false,
+      detail: error instanceof Error ? error.message : String(error)
+    });
+  }
+  try {
+    const root = await getRepoRoot();
+    checks.push({ name: "repo", ok: true, detail: root });
+  } catch (error) {
+    checks.push({
+      name: "repo",
+      ok: false,
+      detail: error instanceof Error ? error.message : String(error)
+    });
+  }
+  const info = await readServerInfo();
+  checks.push({
+    name: "server",
+    ok: info ? await isServerResponsive(info) : false,
+    detail: info ? serverUrl(info) : "not started"
+  });
+  checks.push({
+    name: "@pierre/diffs license",
+    ok: true,
+    detail: "apache-2.0 dependency present"
+  });
+  if (globals.json) {
+    printJson({ checks });
+  } else {
+    for (const check of checks) {
+      printPlain(
+        `${check.ok ? "ok" : "fail"} ${check.name}${check.detail ? ` - ${check.detail}` : ""}`
+      );
+    }
+  }
+});
+program.parseAsync(process.argv).catch((error) => {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+  process.exitCode = 1;
+});
+//# sourceMappingURL=index.js.map