@demon-utils/playwright 0.1.6 → 0.1.7

package/dist/bin/demoon.js

@@ -0,0 +1,1445 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/bin/demoon.ts
+import { resolve } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+
+// src/orchestrator.ts
+import { mkdirSync, existsSync as existsSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync3 } from "node:fs";
+import { join as join2, dirname as pathDirname } from "node:path";
+import { spawnSync as spawnSync3 } from "node:child_process";
+
+// src/review.ts
+import { spawn } from "node:child_process";
+import { Readable } from "node:stream";
+async function invokeClaude(prompt, options) {
+  const spawnFn = options?.spawn ?? defaultSpawn;
+  const agent = options?.agent ?? "claude";
+  const proc = spawnFn([agent, "-p", prompt]);
+  const reader = proc.stdout.getReader();
+  const chunks = [];
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    chunks.push(value);
+  }
+  const exitCode = await proc.exitCode;
+  const output = new TextDecoder().decode(concatUint8Arrays(chunks));
+  if (exitCode !== 0) {
+    throw new Error(`claude process exited with code ${exitCode}: ${output.trim()}`);
+  }
+  return output.trim();
+}
+var VALID_VERDICTS = new Set(["approve", "request_changes"]);
+var VALID_SEVERITIES = new Set(["major", "minor", "nit"]);
+function extractJson(raw) {
+  try {
+    JSON.parse(raw);
+    return raw;
+  } catch {}
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  if (start === -1 || end === -1 || end <= start) {
+    throw new Error(`No JSON object found in LLM response: ${raw.slice(0, 200)}`);
+  }
+  return raw.slice(start, end + 1);
+}
+function parseLlmResponse(raw) {
+  const jsonStr = extractJson(raw);
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonStr);
+  } catch {
+    throw new Error(`Invalid JSON from LLM: ${raw.slice(0, 200)}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || !("demos" in parsed)) {
+    throw new Error("Missing 'demos' array in review metadata");
+  }
+  const obj = parsed;
+  if (!Array.isArray(obj["demos"])) {
+    throw new Error("'demos' must be an array");
+  }
+  for (const demo of obj["demos"]) {
+    if (typeof demo !== "object" || demo === null) {
+      throw new Error("Each demo must be an object");
+    }
+    const d = demo;
+    if (typeof d["file"] !== "string") {
+      throw new Error("Each demo must have a 'file' string");
+    }
+    if (typeof d["summary"] !== "string") {
+      throw new Error("Each demo must have a 'summary' string");
+    }
+  }
+  if (typeof obj["review"] !== "object" || obj["review"] === null) {
+    throw new Error("Missing 'review' object in response");
+  }
+  const review = obj["review"];
+  if (typeof review["summary"] !== "string") {
+    throw new Error("review.summary must be a string");
+  }
+  if (!Array.isArray(review["highlights"])) {
+    throw new Error("review.highlights must be an array");
+  }
+  if (review["highlights"].length === 0) {
+    throw new Error("review.highlights must not be empty");
+  }
+  for (const h of review["highlights"]) {
+    if (typeof h !== "string") {
+      throw new Error("Each highlight must be a string");
+    }
+  }
+  if (typeof review["verdict"] !== "string" || !VALID_VERDICTS.has(review["verdict"])) {
+    throw new Error("review.verdict must be 'approve' or 'request_changes'");
+  }
+  if (typeof review["verdictReason"] !== "string") {
+    throw new Error("review.verdictReason must be a string");
+  }
+  if (!Array.isArray(review["issues"])) {
+    throw new Error("review.issues must be an array");
+  }
+  for (const issue of review["issues"]) {
+    if (typeof issue !== "object" || issue === null) {
+      throw new Error("Each issue must be an object");
+    }
+    const i = issue;
+    if (typeof i["severity"] !== "string" || !VALID_SEVERITIES.has(i["severity"])) {
+      throw new Error("Each issue severity must be 'major', 'minor', or 'nit'");
+    }
+    if (typeof i["description"] !== "string") {
+      throw new Error("Each issue must have a 'description' string");
+    }
+  }
+  return parsed;
+}
+function defaultSpawn(cmd) {
+  const [command, ...args] = cmd;
+  const proc = spawn(command, args, {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const exitCode = new Promise((resolve) => {
+    proc.on("close", (code) => resolve(code ?? 1));
+  });
+  const stdout = Readable.toWeb(proc.stdout);
+  return { exitCode, stdout };
+}
+function concatUint8Arrays(arrays) {
+  const totalLength = arrays.reduce((sum, a) => sum + a.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const a of arrays) {
+    result.set(a, offset);
+    offset += a.length;
+  }
+  return result;
+}
+
+// src/git-context.ts
+import { readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+async function detectDefaultBase(exec, gitRoot) {
+  let currentBranch;
+  try {
+    currentBranch = (await exec(["git", "rev-parse", "--abbrev-ref", "HEAD"], gitRoot)).trim();
+  } catch {
+    return null;
+  }
+  if (currentBranch === "main" || currentBranch === "master") {
+    return null;
+  }
+  for (const candidate of ["main", "master"]) {
+    try {
+      await exec(["git", "rev-parse", "--verify", candidate], gitRoot);
+      return candidate;
+    } catch {}
+  }
+  return null;
+}
+var defaultExec = async (cmd, cwd) => {
+  const [command, ...args] = cmd;
+  const proc = spawnSync(command, args, { cwd, encoding: "utf-8" });
+  if (proc.status !== 0) {
+    const stderr = (proc.stderr ?? "").trim();
+    throw new Error(`Command failed (exit ${proc.status}): ${cmd.join(" ")}${stderr ? `: ${stderr}` : ""}`);
+  }
+  return proc.stdout ?? "";
+};
+var defaultReadFile = (path) => {
+  return readFileSync(path, "utf-8");
+};
+async function getRepoContext(demosDir, options) {
+  const exec = options?.exec ?? defaultExec;
+  const readFile = options?.readFile ?? defaultReadFile;
+  const gitRoot = (await exec(["git", "rev-parse", "--show-toplevel"], demosDir)).trim();
+  const diffBase = options?.diffBase ?? await detectDefaultBase(exec, gitRoot);
+  let gitDiff;
+  if (diffBase) {
+    gitDiff = (await exec(["git", "diff", `${diffBase}...HEAD`], gitRoot)).trim();
+  } else {
+    const workingDiff = (await exec(["git", "diff", "HEAD"], gitRoot)).trim();
+    if (workingDiff.length > 0) {
+      gitDiff = workingDiff;
+    } else {
+      gitDiff = (await exec(["git", "diff", "HEAD~1..HEAD"], gitRoot)).trim();
+    }
+  }
+  const lsOutput = (await exec(["git", "ls-files"], gitRoot)).trim();
+  const files = lsOutput.split(`
+`).filter((f) => f.length > 0);
+  const guidelinePatterns = ["CLAUDE.md", "SKILL.md"];
+  const guidelines = [];
+  for (const file of files) {
+    const basename = file.split("/").pop() ?? "";
+    if (guidelinePatterns.includes(basename)) {
+      const fullPath = `${gitRoot}/${file}`;
+      const content = readFile(fullPath);
+      guidelines.push(`# ${file}
+${content}`);
+    }
+  }
+  return { gitDiff, guidelines };
+}
+
+// ../../node_modules/universal-user-agent/index.js
+function getUserAgent() {
+  if (typeof navigator === "object" && "userAgent" in navigator) {
+    return navigator.userAgent;
+  }
+  if (typeof process === "object" && process.version !== undefined) {
+    return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`;
+  }
+  return "<environment undetectable>";
+}
+
+// ../../node_modules/@octokit/endpoint/dist-bundle/index.js
+var VERSION = "0.0.0-development";
+var userAgent = `octokit-endpoint.js/${VERSION} ${getUserAgent()}`;
+var DEFAULTS = {
+  method: "GET",
+  baseUrl: "https://api.github.com",
+  headers: {
+    accept: "application/vnd.github.v3+json",
+    "user-agent": userAgent
+  },
+  mediaType: {
+    format: ""
+  }
+};
+function lowercaseKeys(object) {
+  if (!object) {
+    return {};
+  }
+  return Object.keys(object).reduce((newObj, key) => {
+    newObj[key.toLowerCase()] = object[key];
+    return newObj;
+  }, {});
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  if (Object.prototype.toString.call(value) !== "[object Object]")
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null)
+    return true;
+  const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value);
+}
+function mergeDeep(defaults, options) {
+  const result = Object.assign({}, defaults);
+  Object.keys(options).forEach((key) => {
+    if (isPlainObject(options[key])) {
+      if (!(key in defaults))
+        Object.assign(result, { [key]: options[key] });
+      else
+        result[key] = mergeDeep(defaults[key], options[key]);
+    } else {
+      Object.assign(result, { [key]: options[key] });
+    }
+  });
+  return result;
+}
+function removeUndefinedProperties(obj) {
+  for (const key in obj) {
+    if (obj[key] === undefined) {
+      delete obj[key];
+    }
+  }
+  return obj;
+}
+function merge(defaults, route, options) {
+  if (typeof route === "string") {
+    let [method, url] = route.split(" ");
+    options = Object.assign(url ? { method, url } : { url: method }, options);
+  } else {
+    options = Object.assign({}, route);
+  }
+  options.headers = lowercaseKeys(options.headers);
+  removeUndefinedProperties(options);
+  removeUndefinedProperties(options.headers);
+  const mergedOptions = mergeDeep(defaults || {}, options);
+  if (options.url === "/graphql") {
+    if (defaults && defaults.mediaType.previews?.length) {
+      mergedOptions.mediaType.previews = defaults.mediaType.previews.filter((preview) => !mergedOptions.mediaType.previews.includes(preview)).concat(mergedOptions.mediaType.previews);
+    }
+    mergedOptions.mediaType.previews = (mergedOptions.mediaType.previews || []).map((preview) => preview.replace(/-preview/, ""));
+  }
+  return mergedOptions;
+}
+function addQueryParameters(url, parameters) {
+  const separator = /\?/.test(url) ? "&" : "?";
+  const names = Object.keys(parameters);
+  if (names.length === 0) {
+    return url;
+  }
+  return url + separator + names.map((name) => {
+    if (name === "q") {
+      return "q=" + parameters.q.split("+").map(encodeURIComponent).join("+");
+    }
+    return `${name}=${encodeURIComponent(parameters[name])}`;
+  }).join("&");
+}
+var urlVariableRegex = /\{[^{}}]+\}/g;
+function removeNonChars(variableName) {
+  return variableName.replace(/(?:^\W+)|(?:(?<!\W)\W+$)/g, "").split(/,/);
+}
+function extractUrlVariableNames(url) {
+  const matches = url.match(urlVariableRegex);
+  if (!matches) {
+    return [];
+  }
+  return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []);
+}
+function omit(object, keysToOmit) {
+  const result = { __proto__: null };
+  for (const key of Object.keys(object)) {
+    if (keysToOmit.indexOf(key) === -1) {
+      result[key] = object[key];
+    }
+  }
+  return result;
+}
+function encodeReserved(str) {
+  return str.split(/(%[0-9A-Fa-f]{2})/g).map(function(part) {
+    if (!/%[0-9A-Fa-f]/.test(part)) {
+      part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]");
+    }
+    return part;
+  }).join("");
+}
+function encodeUnreserved(str) {
+  return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
+    return "%" + c.charCodeAt(0).toString(16).toUpperCase();
+  });
+}
+function encodeValue(operator, value, key) {
+  value = operator === "+" || operator === "#" ? encodeReserved(value) : encodeUnreserved(value);
+  if (key) {
+    return encodeUnreserved(key) + "=" + value;
+  } else {
+    return value;
+  }
+}
+function isDefined(value) {
+  return value !== undefined && value !== null;
+}
+function isKeyOperator(operator) {
+  return operator === ";" || operator === "&" || operator === "?";
+}
+function getValues(context, operator, key, modifier) {
+  var value = context[key], result = [];
+  if (isDefined(value) && value !== "") {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      value = value.toString();
+      if (modifier && modifier !== "*") {
+        value = value.substring(0, parseInt(modifier, 10));
+      }
+      result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : ""));
+    } else {
+      if (modifier === "*") {
+        if (Array.isArray(value)) {
+          value.filter(isDefined).forEach(function(value2) {
+            result.push(encodeValue(operator, value2, isKeyOperator(operator) ? key : ""));
+          });
+        } else {
+          Object.keys(value).forEach(function(k) {
+            if (isDefined(value[k])) {
+              result.push(encodeValue(operator, value[k], k));
+            }
+          });
+        }
+      } else {
+        const tmp = [];
+        if (Array.isArray(value)) {
+          value.filter(isDefined).forEach(function(value2) {
+            tmp.push(encodeValue(operator, value2));
+          });
+        } else {
+          Object.keys(value).forEach(function(k) {
+            if (isDefined(value[k])) {
+              tmp.push(encodeUnreserved(k));
+              tmp.push(encodeValue(operator, value[k].toString()));
+            }
+          });
+        }
+        if (isKeyOperator(operator)) {
+          result.push(encodeUnreserved(key) + "=" + tmp.join(","));
+        } else if (tmp.length !== 0) {
+          result.push(tmp.join(","));
+        }
+      }
+    }
+  } else {
+    if (operator === ";") {
+      if (isDefined(value)) {
+        result.push(encodeUnreserved(key));
+      }
+    } else if (value === "" && (operator === "&" || operator === "?")) {
+      result.push(encodeUnreserved(key) + "=");
+    } else if (value === "") {
+      result.push("");
+    }
+  }
+  return result;
+}
+function parseUrl(template) {
+  return {
+    expand: expand.bind(null, template)
+  };
+}
+function expand(template, context) {
+  var operators = ["+", "#", ".", "/", ";", "?", "&"];
+  template = template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function(_, expression, literal) {
+    if (expression) {
+      let operator = "";
+      const values = [];
+      if (operators.indexOf(expression.charAt(0)) !== -1) {
+        operator = expression.charAt(0);
+        expression = expression.substr(1);
+      }
+      expression.split(/,/g).forEach(function(variable) {
+        var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable);
+        values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3]));
+      });
+      if (operator && operator !== "+") {
+        var separator = ",";
+        if (operator === "?") {
+          separator = "&";
+        } else if (operator !== "#") {
+          separator = operator;
+        }
+        return (values.length !== 0 ? operator : "") + values.join(separator);
+      } else {
+        return values.join(",");
+      }
+    } else {
+      return encodeReserved(literal);
+    }
+  });
+  if (template === "/") {
+    return template;
+  } else {
+    return template.replace(/\/$/, "");
+  }
+}
+function parse(options) {
+  let method = options.method.toUpperCase();
+  let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{$1}");
+  let headers = Object.assign({}, options.headers);
+  let body;
+  let parameters = omit(options, [
+    "method",
+    "baseUrl",
+    "url",
+    "headers",
+    "request",
+    "mediaType"
+  ]);
+  const urlVariableNames = extractUrlVariableNames(url);
+  url = parseUrl(url).expand(parameters);
+  if (!/^http/.test(url)) {
+    url = options.baseUrl + url;
+  }
+  const omittedParameters = Object.keys(options).filter((option) => urlVariableNames.includes(option)).concat("baseUrl");
+  const remainingParameters = omit(parameters, omittedParameters);
+  const isBinaryRequest = /application\/octet-stream/i.test(headers.accept);
+  if (!isBinaryRequest) {
+    if (options.mediaType.format) {
+      headers.accept = headers.accept.split(/,/).map((format) => format.replace(/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/, `application/vnd$1$2.${options.mediaType.format}`)).join(",");
+    }
+    if (url.endsWith("/graphql")) {
+      if (options.mediaType.previews?.length) {
+        const previewsFromAcceptHeader = headers.accept.match(/(?<![\w-])[\w-]+(?=-preview)/g) || [];
+        headers.accept = previewsFromAcceptHeader.concat(options.mediaType.previews).map((preview) => {
+          const format = options.mediaType.format ? `.${options.mediaType.format}` : "+json";
+          return `application/vnd.github.${preview}-preview${format}`;
+        }).join(",");
+      }
+    }
+  }
+  if (["GET", "HEAD"].includes(method)) {
+    url = addQueryParameters(url, remainingParameters);
+  } else {
+    if ("data" in remainingParameters) {
+      body = remainingParameters.data;
+    } else {
+      if (Object.keys(remainingParameters).length) {
+        body = remainingParameters;
+      }
+    }
+  }
+  if (!headers["content-type"] && typeof body !== "undefined") {
+    headers["content-type"] = "application/json; charset=utf-8";
+  }
+  if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") {
+    body = "";
+  }
+  return Object.assign({ method, url, headers }, typeof body !== "undefined" ? { body } : null, options.request ? { request: options.request } : null);
+}
+function endpointWithDefaults(defaults, route, options) {
+  return parse(merge(defaults, route, options));
+}
+function withDefaults(oldDefaults, newDefaults) {
+  const DEFAULTS2 = merge(oldDefaults, newDefaults);
+  const endpoint2 = endpointWithDefaults.bind(null, DEFAULTS2);
+  return Object.assign(endpoint2, {
+    DEFAULTS: DEFAULTS2,
+    defaults: withDefaults.bind(null, DEFAULTS2),
+    merge: merge.bind(null, DEFAULTS2),
+    parse
+  });
+}
+var endpoint = withDefaults(null, DEFAULTS);
+
+// ../../node_modules/fast-content-type-parse/index.js
+var NullObject = function NullObject2() {};
+NullObject.prototype = Object.create(null);
+var paramRE = /; *([!#$%&'*+.^\w`|~-]+)=("(?:[\v\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\v\u0020-\u00ff])*"|[!#$%&'*+.^\w`|~-]+) */gu;
+var quotedPairRE = /\\([\v\u0020-\u00ff])/gu;
+var mediaTypeRE = /^[!#$%&'*+.^\w|~-]+\/[!#$%&'*+.^\w|~-]+$/u;
+var defaultContentType = { type: "", parameters: new NullObject };
+Object.freeze(defaultContentType.parameters);
+Object.freeze(defaultContentType);
+function safeParse(header) {
+  if (typeof header !== "string") {
+    return defaultContentType;
+  }
+  let index = header.indexOf(";");
+  const type = index !== -1 ? header.slice(0, index).trim() : header.trim();
+  if (mediaTypeRE.test(type) === false) {
+    return defaultContentType;
+  }
+  const result = {
+    type: type.toLowerCase(),
+    parameters: new NullObject
+  };
+  if (index === -1) {
+    return result;
+  }
+  let key;
+  let match;
+  let value;
+  paramRE.lastIndex = index;
+  while (match = paramRE.exec(header)) {
+    if (match.index !== index) {
+      return defaultContentType;
+    }
+    index += match[0].length;
+    key = match[1].toLowerCase();
+    value = match[2];
+    if (value[0] === '"') {
+      value = value.slice(1, value.length - 1);
+      quotedPairRE.test(value) && (value = value.replace(quotedPairRE, "$1"));
+    }
+    result.parameters[key] = value;
+  }
+  if (index !== header.length) {
+    return defaultContentType;
+  }
+  return result;
+}
+var $safeParse = safeParse;
+
+// ../../node_modules/@octokit/request-error/dist-src/index.js
+class RequestError extends Error {
+  name;
+  status;
+  request;
+  response;
+  constructor(message, statusCode, options) {
+    super(message);
+    this.name = "HttpError";
+    this.status = Number.parseInt(statusCode);
+    if (Number.isNaN(this.status)) {
+      this.status = 0;
+    }
+    if ("response" in options) {
+      this.response = options.response;
+    }
+    const requestCopy = Object.assign({}, options.request);
+    if (options.request.headers.authorization) {
+      requestCopy.headers = Object.assign({}, options.request.headers, {
+        authorization: options.request.headers.authorization.replace(/(?<! ) .*$/, " [REDACTED]")
+      });
+    }
+    requestCopy.url = requestCopy.url.replace(/\bclient_secret=\w+/g, "client_secret=[REDACTED]").replace(/\baccess_token=\w+/g, "access_token=[REDACTED]");
+    this.request = requestCopy;
+  }
+}
+
+// ../../node_modules/@octokit/request/dist-bundle/index.js
+var VERSION2 = "9.2.4";
+var defaults_default = {
+  headers: {
+    "user-agent": `octokit-request.js/${VERSION2} ${getUserAgent()}`
+  }
+};
+function isPlainObject2(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  if (Object.prototype.toString.call(value) !== "[object Object]")
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null)
+    return true;
+  const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value);
+}
+async function fetchWrapper(requestOptions) {
+  const fetch = requestOptions.request?.fetch || globalThis.fetch;
+  if (!fetch) {
+    throw new Error("fetch is not set. Please pass a fetch implementation as new Octokit({ request: { fetch }}). Learn more at https://github.com/octokit/octokit.js/#fetch-missing");
+  }
+  const log = requestOptions.request?.log || console;
+  const parseSuccessResponseBody = requestOptions.request?.parseSuccessResponseBody !== false;
+  const body = isPlainObject2(requestOptions.body) || Array.isArray(requestOptions.body) ? JSON.stringify(requestOptions.body) : requestOptions.body;
+  const requestHeaders = Object.fromEntries(Object.entries(requestOptions.headers).map(([name, value]) => [
+    name,
+    String(value)
+  ]));
+  let fetchResponse;
+  try {
+    fetchResponse = await fetch(requestOptions.url, {
+      method: requestOptions.method,
+      body,
+      redirect: requestOptions.request?.redirect,
+      headers: requestHeaders,
+      signal: requestOptions.request?.signal,
+      ...requestOptions.body && { duplex: "half" }
+    });
+  } catch (error) {
+    let message = "Unknown Error";
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        error.status = 500;
+        throw error;
+      }
+      message = error.message;
+      if (error.name === "TypeError" && "cause" in error) {
+        if (error.cause instanceof Error) {
+          message = error.cause.message;
+        } else if (typeof error.cause === "string") {
+          message = error.cause;
+        }
+      }
+    }
+    const requestError = new RequestError(message, 500, {
+      request: requestOptions
+    });
+    requestError.cause = error;
+    throw requestError;
+  }
+  const status = fetchResponse.status;
+  const url = fetchResponse.url;
+  const responseHeaders = {};
+  for (const [key, value] of fetchResponse.headers) {
+    responseHeaders[key] = value;
+  }
+  const octokitResponse = {
+    url,
+    status,
+    headers: responseHeaders,
+    data: ""
+  };
+  if ("deprecation" in responseHeaders) {
+    const matches = responseHeaders.link && responseHeaders.link.match(/<([^<>]+)>; rel="deprecation"/);
+    const deprecationLink = matches && matches.pop();
+    log.warn(`[@octokit/request] "${requestOptions.method} ${requestOptions.url}" is deprecated. It is scheduled to be removed on ${responseHeaders.sunset}${deprecationLink ? `. See ${deprecationLink}` : ""}`);
+  }
+  if (status === 204 || status === 205) {
+    return octokitResponse;
+  }
+  if (requestOptions.method === "HEAD") {
+    if (status < 400) {
+      return octokitResponse;
+    }
+    throw new RequestError(fetchResponse.statusText, status, {
+      response: octokitResponse,
+      request: requestOptions
+    });
+  }
+  if (status === 304) {
+    octokitResponse.data = await getResponseData(fetchResponse);
+    throw new RequestError("Not modified", status, {
+      response: octokitResponse,
+      request: requestOptions
+    });
+  }
+  if (status >= 400) {
+    octokitResponse.data = await getResponseData(fetchResponse);
+    throw new RequestError(toErrorMessage(octokitResponse.data), status, {
+      response: octokitResponse,
+      request: requestOptions
+    });
+  }
+  octokitResponse.data = parseSuccessResponseBody ? await getResponseData(fetchResponse) : fetchResponse.body;
+  return octokitResponse;
+}
+async function getResponseData(response) {
+  const contentType = response.headers.get("content-type");
+  if (!contentType) {
+    return response.text().catch(() => "");
+  }
+  const mimetype = $safeParse(contentType);
+  if (isJSONResponse(mimetype)) {
+    let text = "";
+    try {
+      text = await response.text();
+      return JSON.parse(text);
+    } catch (err) {
+      return text;
+    }
+  } else if (mimetype.type.startsWith("text/") || mimetype.parameters.charset?.toLowerCase() === "utf-8") {
+    return response.text().catch(() => "");
+  } else {
+    return response.arrayBuffer().catch(() => new ArrayBuffer(0));
+  }
+}
+function isJSONResponse(mimetype) {
+  return mimetype.type === "application/json" || mimetype.type === "application/scim+json";
+}
+function toErrorMessage(data) {
+  if (typeof data === "string") {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return "Unknown error";
+  }
+  if ("message" in data) {
+    const suffix = "documentation_url" in data ? ` - ${data.documentation_url}` : "";
+    return Array.isArray(data.errors) ? `${data.message}: ${data.errors.map((v) => JSON.stringify(v)).join(", ")}${suffix}` : `${data.message}${suffix}`;
+  }
+  return `Unknown error: ${JSON.stringify(data)}`;
+}
+function withDefaults2(oldEndpoint, newDefaults) {
+  const endpoint2 = oldEndpoint.defaults(newDefaults);
+  const newApi = function(route, parameters) {
+    const endpointOptions = endpoint2.merge(route, parameters);
+    if (!endpointOptions.request || !endpointOptions.request.hook) {
+      return fetchWrapper(endpoint2.parse(endpointOptions));
+    }
+    const request2 = (route2, parameters2) => {
+      return fetchWrapper(endpoint2.parse(endpoint2.merge(route2, parameters2)));
+    };
+    Object.assign(request2, {
+      endpoint: endpoint2,
+      defaults: withDefaults2.bind(null, endpoint2)
+    });
+    return endpointOptions.request.hook(request2, endpointOptions);
+  };
+  return Object.assign(newApi, {
+    endpoint: endpoint2,
+    defaults: withDefaults2.bind(null, endpoint2)
+  });
+}
+var request = withDefaults2(endpoint, defaults_default);
+
+// ../../node_modules/@octokit/graphql/dist-bundle/index.js
+var VERSION3 = "0.0.0-development";
+function _buildMessageForResponseErrors(data) {
+  return `Request failed due to following response errors:
+` + data.errors.map((e) => ` - ${e.message}`).join(`
+`);
+}
+var GraphqlResponseError = class extends Error {
+  constructor(request2, headers, response) {
+    super(_buildMessageForResponseErrors(response));
+    this.request = request2;
+    this.headers = headers;
+    this.response = response;
+    this.errors = response.errors;
+    this.data = response.data;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  name = "GraphqlResponseError";
+  errors;
+  data;
+};
+var NON_VARIABLE_OPTIONS = [
+  "method",
+  "baseUrl",
+  "url",
+  "headers",
+  "request",
+  "query",
+  "mediaType",
+  "operationName"
+];
+var FORBIDDEN_VARIABLE_OPTIONS = ["query", "method", "url"];
+var GHES_V3_SUFFIX_REGEX = /\/api\/v3\/?$/;
+function graphql(request2, query, options) {
+  if (options) {
+    if (typeof query === "string" && "query" in options) {
+      return Promise.reject(new Error(`[@octokit/graphql] "query" cannot be used as variable name`));
+    }
+    for (const key in options) {
+      if (!FORBIDDEN_VARIABLE_OPTIONS.includes(key))
+        continue;
+      return Promise.reject(new Error(`[@octokit/graphql] "${key}" cannot be used as variable name`));
+    }
+  }
+  const parsedOptions = typeof query === "string" ? Object.assign({ query }, options) : query;
+  const requestOptions = Object.keys(parsedOptions).reduce((result, key) => {
+    if (NON_VARIABLE_OPTIONS.includes(key)) {
+      result[key] = parsedOptions[key];
+      return result;
+    }
+    if (!result.variables) {
+      result.variables = {};
+    }
+    result.variables[key] = parsedOptions[key];
+    return result;
+  }, {});
+  const baseUrl = parsedOptions.baseUrl || request2.endpoint.DEFAULTS.baseUrl;
+  if (GHES_V3_SUFFIX_REGEX.test(baseUrl)) {
+    requestOptions.url = baseUrl.replace(GHES_V3_SUFFIX_REGEX, "/api/graphql");
+  }
+  return request2(requestOptions).then((response) => {
+    if (response.data.errors) {
+      const headers = {};
+      for (const key of Object.keys(response.headers)) {
+        headers[key] = response.headers[key];
+      }
+      throw new GraphqlResponseError(requestOptions, headers, response.data);
+    }
+    return response.data.data;
+  });
+}
+function withDefaults3(request2, newDefaults) {
+  const newRequest = request2.defaults(newDefaults);
+  const newApi = (query, options) => {
+    return graphql(newRequest, query, options);
+  };
+  return Object.assign(newApi, {
+    defaults: withDefaults3.bind(null, newRequest),
+    endpoint: newRequest.endpoint
+  });
+}
+var graphql2 = withDefaults3(request, {
+  headers: {
+    "user-agent": `octokit-graphql.js/${VERSION3} ${getUserAgent()}`
+  },
+  method: "POST",
+  url: "/graphql"
+});
+
+// src/github-issue.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+var ISSUE_QUERY = `
+  query($owner: String!, $repo: String!, $number: Int!) {
+    repository(owner: $owner, name: $repo) {
+      issue(number: $number) {
+        number
+        title
+        body
+        state
+        labels(first: 20) {
+          nodes {
+            name
+          }
+        }
+      }
+    }
+  }
+`;
+function getRepoInfoFromGit() {
+  try {
+    const proc = spawnSync2("git", ["remote", "get-url", "origin"], { encoding: "utf-8" });
+    if (proc.status !== 0 || !proc.stdout) {
+      return null;
+    }
+    const url = proc.stdout.trim();
+    const sshMatch = url.match(/git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/);
+    if (sshMatch) {
+      return { owner: sshMatch[1], repo: sshMatch[2] };
+    }
+    const httpsMatch = url.match(/https:\/\/github\.com\/([^/]+)\/(.+?)(?:\.git)?$/);
+    if (httpsMatch) {
+      return { owner: httpsMatch[1], repo: httpsMatch[2] };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getTokenFromEnvironment() {
+  return process.env["GITHUB_TOKEN"] ?? process.env["GH_TOKEN"] ?? null;
+}
+async function fetchGitHubIssue(issueId, options) {
+  const issueNumber = typeof issueId === "string" ? parseInt(issueId, 10) : issueId;
+  if (isNaN(issueNumber)) {
+    throw new Error(`Invalid issue ID: ${issueId}`);
+  }
+  let owner = options?.owner;
+  let repo = options?.repo;
+  if (!owner || !repo) {
+    const detected = getRepoInfoFromGit();
+    if (!detected) {
+      throw new Error("Could not detect repository owner/name from git remote. " + "Please provide owner and repo options, or run from a git repository with a GitHub origin.");
+    }
+    owner = owner ?? detected.owner;
+    repo = repo ?? detected.repo;
+  }
+  const token = options?.token ?? getTokenFromEnvironment();
+  if (!token) {
+    throw new Error("No GitHub token found. Please set GITHUB_TOKEN or GH_TOKEN environment variable, " + "or provide token in options.");
+  }
+  const graphqlFn = options?.graphql ?? graphql2.defaults({
+    headers: {
+      authorization: `token ${token}`
+    }
+  });
+  const response = await graphqlFn(ISSUE_QUERY, {
+    owner,
+    repo,
+    number: issueNumber
+  });
+  const issue = response.repository.issue;
+  return {
+    number: issue.number,
+    title: issue.title,
+    body: issue.body ?? "",
+    labels: issue.labels.nodes.map((l) => l.name),
+    state: issue.state.toLowerCase()
+  };
+}
+
+// src/review-generator.ts
+import { existsSync, readdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { join, dirname, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+function getReviewTemplate() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const distDir = dirname(currentFile);
+  const templatePath = join(distDir, "review-template.html");
+  if (!existsSync(templatePath)) {
+    throw new Error(`Review template not found at ${templatePath}. ` + `Make sure to build the review-app package first.`);
+  }
+  return readFileSync2(templatePath, "utf-8");
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function generateReviewHtml(appData) {
+  const template = getReviewTemplate();
+  const jsonData = JSON.stringify(appData);
+  return template.replace("<title>Demo Review</title>", `<title>${escapeHtml(appData.title)}</title>`).replace('"{{__INJECT_REVIEW_DATA__}}"', jsonData);
+}
+function discoverDemoFiles(directory) {
+  const files = [];
+  const processFile = (filePath, filename) => {
+    const relativePath = relative(directory, filePath);
+    if (filename.endsWith(".webm")) {
+      files.push({ path: filePath, filename, relativePath, type: "web-ux" });
+    } else if (filename.endsWith(".jsonl")) {
+      files.push({ path: filePath, filename, relativePath, type: "log-based" });
+    }
+  };
+  for (const f of readdirSync(directory)) {
+    processFile(join(directory, f), f);
+  }
+  if (files.length === 0) {
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+      if (!entry.isDirectory())
+        continue;
+      const subdir = join(directory, entry.name);
+      for (const f of readdirSync(subdir)) {
+        processFile(join(subdir, f), f);
+      }
+    }
+  }
+  return files.sort((a, b) => a.filename.localeCompare(b.filename));
+}
+
+// src/orchestrator.ts
+var GIT_DIFF_MAX_CHARS = 50000;
+var defaultExec2 = async (cmd, cwd) => {
+  const [command, ...args] = cmd;
+  const proc = spawnSync3(command, args, { cwd, encoding: "utf-8" });
+  if (proc.status !== 0) {
+    const stderr = (proc.stderr ?? "").trim();
+    throw new Error(`Command failed (exit ${proc.status}): ${cmd.join(" ")}${stderr ? `: ${stderr}` : ""}`);
+  }
+  return proc.stdout ?? "";
+};
+async function getGitRoot(exec, cwd) {
+  return (await exec(["git", "rev-parse", "--show-toplevel"], cwd)).trim();
+}
+async function getCurrentBranch(exec, cwd) {
+  const branch = (await exec(["git", "branch", "--show-current"], cwd)).trim();
+  return branch.replace(/\//g, "-") || "unknown";
+}
+function buildPresenterPrompt(options) {
+  const { issue, gitDiff, guidelines, reviewFolder, assetsFolder, testsFolder } = options;
+  let diff = gitDiff;
+  if (diff.length > GIT_DIFF_MAX_CHARS) {
+    diff = diff.slice(0, GIT_DIFF_MAX_CHARS) + `
+
+... (diff truncated at 50k characters)`;
+  }
+  const sections = [];
+  sections.push(`## GitHub Issue #${issue.number}: ${issue.title}
+
+${issue.body}`);
+  if (guidelines.length > 0) {
+    sections.push(`## Coding Guidelines
+
+${guidelines.join(`
+
+`)}`);
+  }
+  sections.push(`## Git Diff
+
+\`\`\`diff
+${diff}
+\`\`\``);
+  return `You are a demo presenter. You must create demo recordings that showcase the feature described in the GitHub issue.
+
+${sections.join(`
+
+`)}
+
+## Configuration
+
+- **Review Folder:** ${reviewFolder}
+- **Assets Directory:** ${assetsFolder}
+- **Tests Directory:** ${testsFolder}
+
+## Task
+
+Based on the GitHub issue and git diff above, create demo recordings that demonstrate each acceptance criterion is met.
+
+For web-ux demos:
+- Create Playwright test files in the Tests Directory
+- Use DemoRecorder to capture steps
+- Save recordings to the Assets Directory
+
+For log-based demos:
+- Create .jsonl files directly in the Assets Directory
+- Use demon__highlight annotations for key lines
+
+After creating demos, report:
+1. List of demo test files created (paths to .demo.ts files)
+2. List of artifact files generated (.webm for web-ux, .jsonl for log-based)
+3. Any errors encountered`;
+}
+function buildReviewerPrompt(options) {
+  const { issue, gitDiff, guidelines, demoFiles, stepsMap, logsMap } = options;
+  let diff = gitDiff;
+  if (diff.length > GIT_DIFF_MAX_CHARS) {
+    diff = diff.slice(0, GIT_DIFF_MAX_CHARS) + `
+
+... (diff truncated at 50k characters)`;
+  }
+  const sections = [];
+  sections.push(`## GitHub Issue #${issue.number}: ${issue.title}
+
+${issue.body}`);
+  if (guidelines.length > 0) {
+    sections.push(`## Coding Guidelines
+
+${guidelines.join(`
+
+`)}`);
+  }
+  sections.push(`## Git Diff
+
+\`\`\`diff
+${diff}
+\`\`\``);
+  const demoEntries = demoFiles.map((f) => {
+    if (f.type === "web-ux") {
+      const steps = stepsMap[f.filename] ?? stepsMap[f.relativePath] ?? [];
+      const stepLines = steps.map((s) => `- [${s.timestampSeconds}s] ${s.text}`).join(`
+`);
+      return `Video: ${f.relativePath}
+Recorded steps:
+${stepLines || "(no steps recorded)"}`;
+    } else {
+      const logContent = logsMap[f.relativePath] ?? "";
+      const preview = logContent.split(`
+`).slice(0, 20).join(`
+`);
+      return `Log: ${f.relativePath}
+Content preview:
+${preview}`;
+    }
+  });
+  sections.push(`## Demo Recordings
+
+${demoEntries.join(`
+
+`)}`);
+  return `You are a code reviewer. You are given a GitHub issue, git diff, coding guidelines, and demo recordings that show the feature in action.
+
+${sections.join(`
+
+`)}
+
+## Task
+
+Review the code changes and demo recordings against the GitHub issue's acceptance criteria. Generate a JSON object matching this exact schema:
+
+{
+  "demos": [
+    {
+      "file": "<filename>",
+      "summary": "<a meaningful sentence describing what this demo showcases based on the steps>"
+    }
+  ],
+  "review": {
+    "summary": "<2-3 sentence overview of the changes>",
+    "highlights": ["<positive aspect 1>", "<positive aspect 2>"],
+    "verdict": "approve" | "request_changes",
+    "verdictReason": "<one sentence justifying the verdict>",
+    "issues": [
+      {
+        "severity": "major" | "minor" | "nit",
+        "description": "<what the issue is and how to fix it>"
+      }
+    ]
+  }
+}
+
+Rules:
+- Return ONLY the JSON object, no markdown fences or extra text.
+- Include one entry in "demos" for each demo file, in the same order.
+- "file" must exactly match the provided relative path.
+- "verdict" must be exactly "approve" or "request_changes".
+- Use "request_changes" if acceptance criteria from the issue are not demonstrated.
+- "severity" must be exactly "major", "minor", or "nit".
+- "major": bugs, security issues, broken functionality, missing acceptance criteria.
+- "minor": code quality, readability, missing edge cases.
+- "nit": style, naming, trivial improvements.
+- "highlights" must have at least one entry.
+- "issues" can be an empty array if there are no issues.
+- Verify that demo steps demonstrate ALL acceptance criteria from the issue.`;
+}
+function collectDemoData(demoFiles) {
+  const stepsMapByFilename = {};
+  const stepsMapByRelativePath = {};
+  const logsMap = {};
+  for (const demo of demoFiles) {
+    if (demo.type === "web-ux") {
+      const stepsPath = join2(pathDirname(demo.path), "demo-steps.json");
+      if (existsSync2(stepsPath)) {
+        try {
+          const raw = readFileSync3(stepsPath, "utf-8");
+          const parsed = JSON.parse(raw);
+          if (Array.isArray(parsed)) {
+            stepsMapByFilename[demo.filename] = parsed;
+            stepsMapByRelativePath[demo.relativePath] = parsed;
+          }
+        } catch {}
+      }
+    } else {
+      logsMap[demo.relativePath] = readFileSync3(demo.path, "utf-8");
+    }
+  }
+  return { stepsMapByFilename, stepsMapByRelativePath, logsMap };
+}
+async function runReviewOrchestration(options) {
+  const exec = options.exec ?? defaultExec2;
+  const cwd = options.cwd ?? process.cwd();
+  const issue = options.issue ?? await fetchGitHubIssue(options.issueId, options.github);
+  const gitRoot = await getGitRoot(exec, cwd);
+  const branchName = await getCurrentBranch(exec, cwd);
+  const repoContext = await getRepoContext(gitRoot, {
+    exec,
+    diffBase: options.diffBase
+  });
+  const reviewFolder = join2(gitRoot, ".demoon", "reviews", branchName);
+  const assetsFolder = join2(reviewFolder, "assets");
+  const testsFolder = join2(reviewFolder, "tests");
+  if (!existsSync2(reviewFolder)) {
+    mkdirSync(reviewFolder, { recursive: true });
+  }
+  if (!existsSync2(assetsFolder)) {
+    mkdirSync(assetsFolder, { recursive: true });
+  }
+  if (!existsSync2(testsFolder)) {
+    mkdirSync(testsFolder, { recursive: true });
+  }
+  const presenterPrompt = buildPresenterPrompt({
+    issue,
+    gitDiff: repoContext.gitDiff,
+    guidelines: repoContext.guidelines,
+    reviewFolder,
+    assetsFolder,
+    testsFolder
+  });
+  await invokeClaude(presenterPrompt, { agent: options.agent, spawn: options.spawn });
+  const demoFiles = discoverDemoFiles(assetsFolder);
+  if (demoFiles.length === 0) {
+    throw new Error(`No demo files (.webm or .jsonl) found in ${assetsFolder} after Presenter phase`);
+  }
+  const { stepsMapByFilename, stepsMapByRelativePath, logsMap } = collectDemoData(demoFiles);
+  const reviewerPrompt = buildReviewerPrompt({
+    issue,
+    gitDiff: repoContext.gitDiff,
+    guidelines: repoContext.guidelines,
+    demoFiles,
+    stepsMap: stepsMapByFilename,
+    logsMap
+  });
+  const rawOutput = await invokeClaude(reviewerPrompt, { agent: options.agent, spawn: options.spawn });
+  const llmResponse = parseLlmResponse(rawOutput);
+  const filenameToRelativePath = new Map(demoFiles.map((d) => [d.filename, d.relativePath]));
+  const typeMap = new Map(demoFiles.map((d) => [d.filename, d.type]));
+  const metadata = {
+    demos: llmResponse.demos.map((demo) => {
+      const relativePath = filenameToRelativePath.get(demo.file) ?? demo.file;
+      return {
+        file: relativePath,
+        type: typeMap.get(demo.file) ?? "web-ux",
+        summary: demo.summary,
+        steps: stepsMapByRelativePath[relativePath] ?? []
+      };
+    }),
+    review: llmResponse.review
+  };
+  const metadataPath = join2(assetsFolder, "review-metadata.json");
+  writeFileSync2(metadataPath, JSON.stringify(metadata, null, 2) + `
+`);
+  const appData = {
+    metadata,
+    title: `Review: Issue #${issue.number} - ${issue.title}`,
+    videos: {},
+    logs: Object.keys(logsMap).length > 0 ? logsMap : undefined,
+    feedbackEndpoint: options.feedbackEndpoint
+  };
+  const html = generateReviewHtml(appData);
+  const htmlPath = join2(assetsFolder, "review.html");
+  writeFileSync2(htmlPath, html);
+  return {
+    reviewFolder,
+    htmlPath,
+    metadataPath,
+    metadata,
+    issue
+  };
+}
+
+// src/feedback-server.ts
+import { randomUUID } from "node:crypto";
+var pendingReviews = new Map;
+var CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "POST, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type"
+};
+function isValidPayload(body) {
+  if (typeof body !== "object" || body === null)
+    return false;
+  const obj = body;
+  if (obj["verdict"] !== "approve" && obj["verdict"] !== "request_changes")
+    return false;
+  if (obj["feedback"] !== undefined && typeof obj["feedback"] !== "string")
+    return false;
+  return true;
+}
+function startFeedbackServer(preferredPort = 0) {
+  const reviewId = randomUUID();
+  const server = Bun.serve({
+    port: preferredPort,
+    async fetch(req) {
+      const url = new URL(req.url);
+      if (req.method === "OPTIONS") {
+        return new Response(null, {
+          status: 204,
+          headers: CORS_HEADERS
+        });
+      }
+      if (url.pathname === "/feedback" && req.method === "POST") {
+        const requestReviewId = url.searchParams.get("reviewId");
+        const headers = {
+          "Content-Type": "application/json",
+          ...CORS_HEADERS
+        };
+        if (!requestReviewId) {
+          return new Response(JSON.stringify({ error: "Missing reviewId query parameter" }), { status: 400, headers });
+        }
+        const pending = pendingReviews.get(requestReviewId);
+        if (!pending) {
+          return new Response(JSON.stringify({ error: "Review not found or already completed" }), { status: 404, headers });
+        }
+        let body;
+        try {
+          body = await req.json();
+        } catch {
+          return new Response(JSON.stringify({ error: "Invalid JSON" }), { status: 400, headers });
+        }
+        if (!isValidPayload(body)) {
+          return new Response(JSON.stringify({ error: "Invalid payload" }), { status: 400, headers });
+        }
+        pending.resolve(body);
+        pendingReviews.delete(requestReviewId);
+        return new Response(JSON.stringify({ success: true, verdict: body.verdict }), { status: 200, headers });
+      }
+      if (url.pathname === "/health") {
+        return new Response(JSON.stringify({ status: "ok" }), {
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      return new Response("Not Found", { status: 404 });
+    }
+  });
+  const port = server.port ?? 3000;
+  const feedbackEndpoint = `http://localhost:${port}/feedback?reviewId=${reviewId}`;
+  const feedbackPromise = new Promise((resolve, reject) => {
+    pendingReviews.set(reviewId, { resolve, reject });
+  });
+  return {
+    server,
+    port,
+    reviewId,
+    feedbackEndpoint,
+    waitForFeedback: () => feedbackPromise,
+    stop: () => {
+      const pending = pendingReviews.get(reviewId);
+      if (pending) {
+        pending.reject(new Error("Server stopped"));
+        pendingReviews.delete(reviewId);
+      }
+      server.stop();
+    }
+  };
+}
+
+// src/bin/demoon.ts
+function printUsage() {
+  console.error("Usage: demoon <command> [options]");
+  console.error("");
+  console.error("Commands:");
+  console.error("  review    Generate a review from a GitHub issue");
+  console.error("");
+  console.error("Review options:");
+  console.error("  --github-issue-id <id>  GitHub issue number (required unless --issue-file is provided)");
+  console.error("  --issue-file <path>     Path to JSON file with issue data (for testing, skips GitHub API)");
+  console.error("  --base <ref>            Base commit/branch for diff (auto-detects main/master if on feature branch)");
+  console.error("  --agent <path>          Path to Claude agent binary");
+  console.error("  --port <number>         Port for feedback server (default: random available port)");
+  console.error("");
+  console.error("Environment variables:");
+  console.error("  GITHUB_TOKEN or GH_TOKEN  GitHub personal access token (required for API access)");
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    printUsage();
+    process.exit(args.length === 0 ? 1 : 0);
+  }
+  const command = args[0];
+  if (command !== "review") {
+    console.error(`Unknown command: ${command}`);
+    console.error("");
+    printUsage();
+    process.exit(1);
+  }
+  let issueId;
+  let issueFile;
+  let diffBase;
+  let agent;
+  let port = 0;
+  for (let i = 1;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--github-issue-id" || arg === "--issue") {
+      issueId = args[++i];
+    } else if (arg === "--issue-file") {
+      issueFile = args[++i];
+    } else if (arg === "--base") {
+      diffBase = args[++i];
+    } else if (arg === "--agent") {
+      agent = args[++i];
+    } else if (arg === "--port") {
+      port = parseInt(args[++i] ?? "0", 10);
+    } else if (!arg?.startsWith("-")) {
+      if (!issueId) {
+        issueId = arg;
+      }
+    }
+  }
+  let issue;
+  if (issueFile) {
+    const content = readFileSync4(issueFile, "utf-8");
+    issue = JSON.parse(content);
+    issueId = String(issue.number);
+  }
+  if (!issueId && !issue) {
+    console.error("Error: --github-issue-id or --issue-file is required");
+    console.error("");
+    printUsage();
+    process.exit(1);
+  }
+  const feedbackServer = startFeedbackServer(port);
+  try {
+    if (issue) {
+      console.log(`Using issue from file: #${issue.number} - ${issue.title}`);
+    } else {
+      console.log(`Fetching GitHub issue #${issueId}...`);
+    }
+    const result = await runReviewOrchestration({
+      issueId,
+      issue,
+      diffBase,
+      agent,
+      feedbackEndpoint: feedbackServer.feedbackEndpoint
+    });
+    console.log("");
+    console.log(`Review generated for issue #${result.issue.number}: ${result.issue.title}`);
+    console.log("");
+    console.log(`Verdict: ${result.metadata.review?.verdict ?? "unknown"}`);
+    if (result.metadata.review?.verdictReason) {
+      console.log(`Reason: ${result.metadata.review.verdictReason}`);
+    }
+    console.log("");
+    console.log(`Review folder: ${result.reviewFolder}`);
+    console.log(`Review HTML: ${resolve(result.htmlPath)}`);
+    console.log("");
+    console.log(`Feedback server running at: http://localhost:${feedbackServer.port}`);
+    console.log(`Open the review HTML and approve/request changes to complete.`);
+    console.log("");
+    const feedback = await feedbackServer.waitForFeedback();
+    console.log("");
+    console.log("=".repeat(60));
+    console.log(`User verdict: ${feedback.verdict}`);
+    if (feedback.feedback) {
+      console.log("");
+      console.log("Feedback:");
+      console.log(feedback.feedback);
+    }
+    console.log("=".repeat(60));
+    process.exit(feedback.verdict === "approve" ? 0 : 1);
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    feedbackServer.stop();
+    process.exit(1);
+  }
+}
+main();
+
+//# debugId=ABC1559AB7B4086F64756E2164756E21