@ulpi/cli 0.1.5 → 0.1.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 ULPI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/{auth-PN7TMQHV-2W4ICG64.js → auth-FWM7MM4Q-VZC3U2XZ.js}

@@ -4,7 +4,7 @@ import {
   setApiSecret,
   validateAuth,
   validateLoopback
-} from "./chunk-MIAQVCFW.js";
+} from "./chunk-Z53CAR7G.js";
 import "./chunk-4VNS5WPM.js";
 export {
   generateApiSecret,

package/dist/{auth-BFFBUJUC.js → auth-HDK7ECJL.js}

@@ -2,7 +2,8 @@ import {
   extractCredentials,
   getCredentialExpiry,
   validateCredentials
-} from "./chunk-AV5RB3N2.js";
+} from "./chunk-76D3BYJD.js";
+import "./chunk-KIKPIH6N.js";
 import "./chunk-4VNS5WPM.js";
 
 // src/commands/auth.ts

package/dist/{chunk-RJIRWQJD.js → chunk-3BCW6ABU.js}

@@ -1,22 +1,20 @@
+import {
+  API_LOCK_FILE,
+  REVIEWS_DIR,
+  getApiHost,
+  getApiPort
+} from "./chunk-C7CLUQI6.js";
 import {
   external_exports
 } from "./chunk-KIKPIH6N.js";
-import {
-  REVIEWS_DIR
-} from "./chunk-DDRLI6JU.js";
-import {
-  __require
-} from "./chunk-4VNS5WPM.js";
+
+// ../../packages/review-runtime/dist/index.js
+import { basename } from "path";
+import { randomUUID } from "crypto";
 
 // ../../packages/review-engine/dist/index.js
 import { promises as fs } from "fs";
 import { join } from "path";
-var __require2 = /* @__PURE__ */ ((x) => typeof __require !== "undefined" ? __require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof __require !== "undefined" ? __require : a)[b]
-}) : x)(function(x) {
-  if (typeof __require !== "undefined") return __require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 function parseMarkdownToBlocks(markdown) {
   if (!markdown) return [];
   try {
@@ -251,9 +249,6 @@ function extractSections(blocks) {
   }
   return sections;
 }
-function getSectionFullText(section, blocks) {
-  return section.blockIds.map((id) => blocks.find((b) => b.id === id)).filter((b) => b != null).map((b) => b.content).join("\n\n");
-}
 var FILE_PATH_PATTERN = /(?:src\/|\.\/|\/)[a-zA-Z0-9_\-/.]+\.[a-zA-Z]{1,5}/g;
 var DIMENSION_CHECKERS = [
   {
@@ -617,156 +612,421 @@ async function collectPlansFromDir(baseDir, summaries) {
   } catch {
   }
 }
-function isGitCommitCommand(command) {
-  if (!command) return false;
-  const subcommands = command.split(/\s*(?:&&|\|\||[;|])\s*/);
-  return subcommands.some((sub) => /(?:^|\b)(?:\w+=\S*\s+)*git(?:\s+-c\s+\S+)*\s+commit\b/.test(sub));
+var ReviewConfigSchema = external_exports.object({
+  enabled: external_exports.boolean().default(true),
+  plan_review: external_exports.boolean().default(true),
+  code_review: external_exports.boolean().default(true),
+  auto_open_browser: external_exports.boolean().default(true),
+  require_server: external_exports.boolean().default(false),
+  review_timeout_seconds: external_exports.number().int().min(0).max(600).default(0),
+  timeout_behavior: external_exports.enum(["allow", "deny"]).default("allow"),
+  default_export_format: external_exports.enum(["markdown", "github", "jira", "json"]).default("markdown"),
+  webhook_url: external_exports.string().default("")
+});
+
+// ../../packages/review-runtime/dist/index.js
+import * as fs2 from "fs";
+var ReviewHub = class _ReviewHub {
+  sessions = /* @__PURE__ */ new Map();
+  awaitWaiters = /* @__PURE__ */ new Map();
+  decidedEvictionMs = 5 * 60 * 1e3;
+  longPollTimeoutMs = 30 * 1e3;
+  /** Maximum number of concurrent sessions to prevent unbounded memory growth. */
+  static MAX_SESSIONS = 100;
+  /** Sessions older than this TTL are automatically evicted. */
+  static SESSION_TTL_MS = 30 * 60 * 1e3;
+  // 30 minutes
+  /**
+   * Register a new review session.
+   */
+  async register(payload) {
+    this.cleanupExpired();
+    if (this.sessions.size >= _ReviewHub.MAX_SESSIONS) {
+      const oldest = [...this.sessions.entries()].sort(([, a], [, b]) => a.registeredAt - b.registeredAt)[0];
+      if (oldest) {
+        this.sessions.delete(oldest[0]);
+        this.awaitWaiters.delete(oldest[0]);
+      }
+    }
+    const sessionId = randomUUID();
+    const token = randomUUID();
+    const projectSlug = basename(payload.projectPath);
+    let resolveDecision;
+    const decisionPromise = new Promise((resolve) => {
+      resolveDecision = resolve;
+    });
+    const session = {
+      id: sessionId,
+      type: payload.type,
+      projectPath: payload.projectPath,
+      projectSlug,
+      title: "",
+      status: "pending",
+      registeredAt: Date.now(),
+      resolveDecision,
+      token
+    };
+    if (payload.type === "plan" && payload.plan) {
+      const blocks = parseMarkdownToBlocks(payload.plan);
+      const sections = extractSections(blocks);
+      const quality = scorePlanQuality(blocks, sections);
+      const title = extractTitle(blocks);
+      const slug = generateSlug(title);
+      const versionNumber = await getNextVersionNumber(slug, payload.projectPath);
+      const version = {
+        id: randomUUID(),
+        versionNumber,
+        markdown: payload.plan,
+        annotations: [],
+        inlineEdits: [],
+        instructions: [],
+        priorities: [],
+        risks: [],
+        createdAt: Date.now()
+      };
+      try {
+        await savePlan(payload.plan, version, slug, payload.projectPath);
+      } catch (err) {
+        console.error(`[review-hub] Failed to persist plan: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      session.plan = payload.plan;
+      session.blocks = blocks;
+      session.sections = sections;
+      session.quality = quality;
+      session.version = version;
+      session.slug = slug;
+      session.title = title;
+    } else if (payload.type === "code") {
+      session.diff = payload.diff;
+      session.commitMessage = payload.commitMessage;
+      session.title = payload.commitMessage || "Code Review";
+    }
+    this.sessions.set(sessionId, session);
+    decisionPromise.then((decision) => {
+      const waiters = this.awaitWaiters.get(sessionId) || [];
+      for (const resolve of waiters) {
+        resolve(decision);
+      }
+      this.awaitWaiters.delete(sessionId);
+    });
+    return { session: this.toPublicSession(session), sessionId, token };
+  }
+  /**
+   * Get a session by ID.
+   */
+  getSession(id) {
+    const session = this.sessions.get(id);
+    return session ? this.toPublicSession(session) : null;
+  }
+  /**
+   * List all sessions, optionally filtered by type/status.
+   */
+  listSessions(opts) {
+    let sessions = [...this.sessions.values()];
+    if (opts?.type) sessions = sessions.filter((s) => s.type === opts.type);
+    if (opts?.status) sessions = sessions.filter((s) => s.status === opts.status);
+    sessions.sort((a, b) => a.registeredAt - b.registeredAt);
+    return sessions.map((s) => this.toPublicSession(s));
+  }
+  /**
+   * Verify a session token.
+   */
+  verifyToken(sessionId, token) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return false;
+    return session.token === token;
+  }
+  /**
+   * Submit a decision for a session.
+   * When token is provided, it must match the session token.
+   */
+  async submitDecision(sessionId, decision, token) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return false;
+    if (token !== void 0 && session.token !== token) return false;
+    if (!isValidDecision(decision)) return false;
+    try {
+      if (session.type === "plan" && session.version && session.slug) {
+        const planDecision = decision;
+        const reviewedVersion = {
+          ...session.version,
+          annotations: planDecision.annotations || [],
+          inlineEdits: planDecision.inlineEdits || [],
+          instructions: planDecision.instructions || [],
+          priorities: planDecision.priorities || [],
+          risks: planDecision.risks || [],
+          decision: {
+            behavior: planDecision.behavior,
+            message: planDecision.message,
+            decidedAt: Date.now()
+          }
+        };
+        await savePlan(session.plan, reviewedVersion, session.slug, session.projectPath);
+      }
+    } catch {
+    }
+    session.status = "decided";
+    session.decidedAt = Date.now();
+    session.decisionPayload = decision;
+    session.resolveDecision(decision);
+    const waiters = this.awaitWaiters.get(sessionId);
+    if (waiters && waiters.length > 0) {
+      for (const waiter of waiters) {
+        waiter(decision);
+      }
+      this.awaitWaiters.delete(sessionId);
+    }
+    setTimeout(() => {
+      this.sessions.delete(sessionId);
+      this.awaitWaiters.delete(sessionId);
+    }, this.decidedEvictionMs);
+    return true;
+  }
+  /**
+   * Long-poll waiting for a decision on a session.
+   * Returns the decision or null on timeout.
+   */
+  awaitDecision(sessionId, timeoutMs) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return Promise.resolve(null);
+    if (session.status === "decided" && session.decisionPayload) {
+      return Promise.resolve(session.decisionPayload);
+    }
+    const timeout = timeoutMs ?? this.longPollTimeoutMs;
+    return new Promise((resolve) => {
+      const waiters = this.awaitWaiters.get(sessionId) || [];
+      const timer = setTimeout(() => {
+        const idx = waiters.indexOf(onDecision);
+        if (idx !== -1) waiters.splice(idx, 1);
+        resolve(null);
+      }, timeout);
+      function onDecision(decision) {
+        clearTimeout(timer);
+        resolve(decision);
+      }
+      waiters.push(onDecision);
+      this.awaitWaiters.set(sessionId, waiters);
+    });
+  }
+  /**
+   * Save annotations/version for a plan session.
+   */
+  async saveVersion(sessionId, data) {
+    const session = this.sessions.get(sessionId);
+    if (!session || session.type !== "plan" || !session.version || !session.slug) {
+      return false;
+    }
+    const updatedVersion = {
+      ...session.version,
+      annotations: data.annotations || [],
+      inlineEdits: data.inlineEdits || [],
+      instructions: data.instructions || [],
+      priorities: data.priorities || [],
+      risks: data.risks || []
+    };
+    await savePlan(session.plan, updatedVersion, session.slug, session.projectPath);
+    Object.assign(session.version, updatedVersion);
+    return true;
+  }
+  /**
+   * Get the session token (for loopback clients that need to pass it to the UI).
+   */
+  getSessionToken(id) {
+    const session = this.sessions.get(id);
+    return session?.token ?? null;
+  }
+  /**
+   * Get the raw decision payload for a session (used by await endpoint).
+   */
+  getDecisionPayload(id) {
+    const session = this.sessions.get(id);
+    return session?.decisionPayload ?? null;
+  }
+  /**
+   * Cleanup orphaned sessions (pending for over 1 hour).
+   */
+  cleanup() {
+    const now = Date.now();
+    for (const [id, session] of this.sessions) {
+      if (session.status === "pending" && now - session.registeredAt > 60 * 60 * 1e3) {
+        this.sessions.delete(id);
+        this.awaitWaiters.delete(id);
+      }
+    }
+  }
+  /**
+   * Remove sessions that have exceeded the TTL, regardless of status.
+   */
+  cleanupExpired() {
+    const now = Date.now();
+    for (const [id, session] of this.sessions) {
+      if (now - session.registeredAt > _ReviewHub.SESSION_TTL_MS) {
+        this.sessions.delete(id);
+        this.awaitWaiters.delete(id);
+      }
+    }
+  }
+  toPublicSession(session) {
+    const { resolveDecision, decisionPayload, token: _token, ...pub } = session;
+    if (decisionPayload && !pub.decision) {
+      if ("behavior" in decisionPayload) {
+        pub.decision = {
+          behavior: decisionPayload.behavior,
+          message: decisionPayload.message,
+          decidedAt: session.decidedAt ?? Date.now()
+        };
+      } else if ("approved" in decisionPayload) {
+        pub.decision = {
+          behavior: decisionPayload.approved ? "allow" : "deny",
+          message: decisionPayload.message ?? decisionPayload.feedback,
+          decidedAt: session.decidedAt ?? Date.now()
+        };
+      }
+    }
+    return pub;
+  }
+};
+function isValidDecision(d) {
+  if (!d || typeof d !== "object") return false;
+  if ("behavior" in d) {
+    return d.behavior === "allow" || d.behavior === "deny";
+  }
+  if ("approved" in d) {
+    return typeof d.approved === "boolean";
+  }
+  return false;
 }
-function gitOutputSync(args, cwd) {
-  const { execFileSync } = __require2("child_process");
+var DISCOVERY_TIMEOUT_MS = 2e3;
+var MAX_PORTS_TO_PROBE = 5;
+function isProcessAlive(pid) {
   try {
-    return execFileSync(args[0], args.slice(1), {
-      cwd,
-      encoding: "utf-8",
-      timeout: 1e4,
-      maxBuffer: 10 * 1024 * 1024
-    });
+    process.kill(pid, 0);
+    return true;
   } catch {
-    return "";
+    return false;
   }
 }
-function captureUntrackedDiff(files, cwd) {
-  const { existsSync, readFileSync } = __require2("fs");
-  const { join: join2 } = __require2("path");
-  const parts = [];
-  for (const file of files) {
-    const fullPath = join2(cwd, file);
-    if (!existsSync(fullPath)) continue;
-    const noIndexDiff = gitOutputSync(["git", "diff", "--no-index", "--", "/dev/null", file], cwd);
-    if (noIndexDiff.trim()) {
-      parts.push(noIndexDiff);
-    } else {
+function readLockFile() {
+  try {
+    const raw = fs2.readFileSync(API_LOCK_FILE, "utf-8");
+    const data = JSON.parse(raw);
+    if (typeof data === "object" && data !== null && typeof data.port === "number" && typeof data.pid === "number") {
+      const { port, pid, secret } = data;
+      if (isProcessAlive(pid)) {
+        return { port, secret };
+      }
       try {
-        const content = readFileSync(fullPath, "utf-8");
-        const lines = content.split("\n");
-        const header = `diff --git a/${file} b/${file}
-new file mode 100644
---- /dev/null
-+++ b/${file}
-@@ -0,0 +1,${lines.length} @@`;
-        const body = lines.map((l) => `+${l}`).join("\n");
-        parts.push(`${header}
-${body}`);
+        fs2.unlinkSync(API_LOCK_FILE);
       } catch {
       }
     }
+  } catch {
   }
-  return parts.join("\n");
+  return null;
 }
-function captureCommitDiff(opts) {
-  const { command, cwd } = opts;
-  let commitMessage = "";
-  const heredocMatch = command.match(/<<'?EOF'?\s*\n([\s\S]*?)\n\s*EOF/);
-  if (heredocMatch) {
-    commitMessage = heredocMatch[1].trim();
-  } else {
-    const mMatch = command.match(/-m\s+(?:"([^"]*(?:\\.[^"]*)*)"|'([^']*)'|(\S+))/);
-    if (mMatch) {
-      commitMessage = mMatch[1] ?? mMatch[2] ?? mMatch[3] ?? "";
-    }
-  }
-  const hasAllFlag = /\bcommit\b[^|&;]*(?:-[a-z]*a[a-z]*\b|--all\b)/.test(command);
-  const isAmend = /\bcommit\b[^|&;\n]*--amend\b/.test(command);
-  const allowEmpty = /\bcommit\b[^|&;\n]*--allow-empty\b/.test(command);
-  const scopedFiles = [];
-  let hasChainedAdd = false;
-  let isBroadAdd = false;
-  const chainedAddMatch = command.match(/\bgit\s+add\s+([\s\S]*?)(?:&&|;|\n)\s*git\b.*\bcommit\b/);
-  if (chainedAddMatch) {
-    hasChainedAdd = true;
-    const addArgs = chainedAddMatch[1].trim();
-    isBroadAdd = addArgs === "." || /(?:^|\s)(?:-A|--all|-u|--update)(?:\s|$)/.test(addArgs);
-    const files = addArgs.split(/\s+/).filter((arg) => !arg.startsWith("-") && arg !== ".");
-    scopedFiles.push(...files);
-  }
-  const commitPart = command.match(/\bgit\b.*\bcommit\b(.*)/s);
-  if (commitPart) {
-    let rest = commitPart[1];
-    rest = rest.replace(/-m\s+(?:"[^"]*(?:\\.[^"]*)*"|'[^']*'|\S+)/, "");
-    rest = rest.replace(/<<'?EOF'?\s*\n[\s\S]*?\n\s*EOF/, "");
-    rest = rest.replace(/-m\s*"?\$\(cat\s*<<'?EOF'?[\s\S]*?EOF\s*\)"?/, "");
-    rest = rest.replace(/\s--(?:amend|no-edit|no-verify|allow-empty|signoff|gpg-sign|no-gpg-sign|fixup|squash|reset-author|short|branch|long|porcelain|dry-run|verbose|quiet|all)\b/g, "");
-    rest = rest.replace(/\s-[aSsnvq]\b/g, "");
-    rest = rest.replace(/\s--\s/, " ");
-    const commitFiles = rest.trim().split(/\s+/).filter((f) => f && !f.startsWith("-"));
-    if (commitFiles.length > 0) {
-      scopedFiles.push(...commitFiles);
-    }
-  }
-  let diff = "";
-  if (isAmend) {
-    const baseArgs = scopedFiles.length > 0 ? ["git", "diff", "HEAD~1", "--", ...scopedFiles] : ["git", "diff", "HEAD~1"];
-    diff = gitOutputSync(baseArgs, cwd);
-    if (!diff.trim()) {
-      const fallbackArgs = scopedFiles.length > 0 ? ["git", "diff", "HEAD", "--", ...scopedFiles] : ["git", "diff", "HEAD"];
-      diff = gitOutputSync(fallbackArgs, cwd);
-    }
-  } else if (hasChainedAdd && !isBroadAdd && scopedFiles.length > 0) {
-    const stagedDiff = gitOutputSync(["git", "diff", "--cached", "--", ...scopedFiles], cwd);
-    const unstagedDiff = gitOutputSync(["git", "diff", "--", ...scopedFiles], cwd);
-    diff = [stagedDiff, unstagedDiff].filter((d) => d.trim()).join("\n");
-    if (!diff.trim()) {
-      diff = captureUntrackedDiff(scopedFiles, cwd);
-    }
-  } else if (hasChainedAdd && isBroadAdd) {
-    const stagedDiff = gitOutputSync(["git", "diff", "--cached"], cwd);
-    const unstagedDiff = gitOutputSync(["git", "diff"], cwd);
-    diff = [stagedDiff, unstagedDiff].filter((d) => d.trim()).join("\n");
-    if (!diff.trim()) {
-      const untrackedFiles = gitOutputSync(["git", "ls-files", "--others", "--exclude-standard"], cwd).split("\n").filter((f) => f.trim());
-      if (untrackedFiles.length > 0) {
-        diff = captureUntrackedDiff(untrackedFiles, cwd);
-      }
+async function healthCheck(host, port) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), DISCOVERY_TIMEOUT_MS);
+    const res = await fetch(`http://${host}:${port}/api/health`, {
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function discoverUlpiServer() {
+  const host = getApiHost();
+  const lockData = readLockFile();
+  if (lockData !== null) {
+    if (await healthCheck(host, lockData.port)) {
+      return lockData;
     }
-  } else {
-    const baseArgs = hasAllFlag ? ["git", "diff", "HEAD"] : ["git", "diff", "--cached"];
-    const diffArgs = scopedFiles.length > 0 ? [...baseArgs, "--", ...scopedFiles] : baseArgs;
-    diff = gitOutputSync(diffArgs, cwd);
-    if (!diff.trim() && hasAllFlag) {
-      const fallbackArgs = scopedFiles.length > 0 ? ["git", "diff", "--cached", "--", ...scopedFiles] : ["git", "diff", "--cached"];
-      diff = gitOutputSync(fallbackArgs, cwd);
+  }
+  const configPort = getApiPort();
+  const ports = [configPort, ...configPort !== 9800 ? [9800] : []].slice(0, MAX_PORTS_TO_PROBE);
+  for (const port of ports) {
+    if (port === lockData?.port) continue;
+    if (await healthCheck(host, port)) {
+      return { port };
     }
-    if (!diff.trim() && scopedFiles.length > 0) {
-      diff = captureUntrackedDiff(scopedFiles, cwd);
+  }
+  return null;
+}
+function buildHeaders(secret) {
+  const headers = { "Content-Type": "application/json" };
+  if (secret) headers["X-Ulpi-Secret"] = secret;
+  return headers;
+}
+async function registerWithServer(port, payload, secret) {
+  try {
+    const host = getApiHost();
+    const res = await fetch(`http://${host}:${port}/api/review/hub/register`, {
+      method: "POST",
+      headers: buildHeaders(secret),
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data;
+  } catch {
+    return null;
+  }
+}
+async function waitForServerDecision(port, sessionId, timeoutMs = 3e4, maxWaitMs, token, secret) {
+  const deadline = Date.now() + (maxWaitMs && maxWaitMs > 0 ? maxWaitMs : 10 * 60 * 1e3);
+  const host = getApiHost();
+  const tokenParam = token ? `?token=${encodeURIComponent(token)}` : "";
+  const secretHeaders = secret ? { "X-Ulpi-Secret": secret } : {};
+  while (Date.now() < deadline) {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeoutMs + 5e3);
+      const res = await fetch(
+        `http://${host}:${port}/api/review/hub/session/${sessionId}/await${tokenParam}`,
+        { signal: controller.signal, headers: secretHeaders }
+      );
+      clearTimeout(timer);
+      if (res.status === 204) {
+        continue;
+      }
+      if (res.ok) {
+        const data = await res.json();
+        return data.decision;
+      }
+      if (res.status === 410) {
+        try {
+          const data = await res.json();
+          if (data.decision) return data.decision;
+        } catch {
+        }
+        return null;
+      }
+      if (res.status >= 500) {
+        await new Promise((resolve) => setTimeout(resolve, 2e3));
+        continue;
+      }
+      return null;
+    } catch {
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
     }
   }
-  return { diff, commitMessage, allowEmpty, isAmend };
+  return null;
 }
-var ReviewConfigSchema = external_exports.object({
-  enabled: external_exports.boolean().default(true),
-  plan_review: external_exports.boolean().default(true),
-  code_review: external_exports.boolean().default(true),
-  auto_open_browser: external_exports.boolean().default(true),
-  require_server: external_exports.boolean().default(false),
-  review_timeout_seconds: external_exports.number().int().min(0).max(600).default(0),
-  timeout_behavior: external_exports.enum(["allow", "deny"]).default("allow"),
-  default_export_format: external_exports.enum(["markdown", "github", "jira", "json"]).default("markdown"),
-  webhook_url: external_exports.string().default("")
-});
 
 export {
   parseMarkdownToBlocks,
-  extractTitle,
-  generateSlug,
   extractSections,
-  getSectionFullText,
   scorePlanQuality,
   buildAiScoringPrompt,
   savePlan,
   loadPlan,
-  getNextVersionNumber,
   listPlansWithMeta,
-  isGitCommitCommand,
-  captureCommitDiff,
-  ReviewConfigSchema
+  ReviewConfigSchema,
+  ReviewHub,
+  discoverUlpiServer,
+  registerWithServer,
+  waitForServerDecision
 };