@ulpi/cli 0.1.5 → 0.1.6

package/dist/chunk-MIAQVCFW.js

@@ -1,39 +0,0 @@
-// ../api/dist/chunk-UOFEIZ6Y.js
-import { randomBytes } from "crypto";
-var apiSecret;
-function generateApiSecret() {
-  return randomBytes(32).toString("hex");
-}
-function setApiSecret(secret) {
-  apiSecret = secret;
-}
-function getApiSecret() {
-  return apiSecret;
-}
-function validateLoopback(req) {
-  const remoteAddr = req.socket.remoteAddress ?? "";
-  return remoteAddr === "127.0.0.1" || remoteAddr === "::1" || remoteAddr === "::ffff:127.0.0.1";
-}
-function validateAuth(req) {
-  if (!validateLoopback(req)) return false;
-  if (apiSecret) {
-    const headerSecret = req.headers["x-ulpi-secret"];
-    if (headerSecret === apiSecret) return true;
-    try {
-      const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
-      const paramSecret = url.searchParams.get("secret");
-      if (paramSecret === apiSecret) return true;
-    } catch {
-    }
-    return false;
-  }
-  return true;
-}
-
-export {
-  generateApiSecret,
-  setApiSecret,
-  getApiSecret,
-  validateLoopback,
-  validateAuth
-};

package/dist/chunk-YYZOFYS6.js

@@ -1,415 +0,0 @@
-import {
-  extractSections,
-  extractTitle,
-  generateSlug,
-  getNextVersionNumber,
-  parseMarkdownToBlocks,
-  savePlan,
-  scorePlanQuality
-} from "./chunk-RJIRWQJD.js";
-import {
-  API_LOCK_FILE,
-  getApiHost,
-  getApiPort
-} from "./chunk-DDRLI6JU.js";
-
-// ../../packages/review-runtime/dist/index.js
-import { basename } from "path";
-import { randomUUID } from "crypto";
-import * as fs 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;
-}
-var DISCOVERY_TIMEOUT_MS = 2e3;
-var MAX_PORTS_TO_PROBE = 5;
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function readLockFile() {
-  try {
-    const raw = fs.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 {
-        fs.unlinkSync(API_LOCK_FILE);
-      } catch {
-      }
-    }
-  } catch {
-  }
-  return null;
-}
-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;
-    }
-  }
-  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 };
-    }
-  }
-  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 null;
-}
-
-export {
-  ReviewHub,
-  discoverUlpiServer,
-  registerWithServer,
-  waitForServerDecision
-};

package/dist/dist-XD4YI27T.js

@@ -1,26 +0,0 @@
-import {
-  JsonSessionStore,
-  appendEvent,
-  createEmptyState,
-  createInitialState,
-  detectNewCommit,
-  nextPhase,
-  projectDirToSlug,
-  readEvents,
-  updateStateFromInput,
-  validateSessionId
-} from "./chunk-26LLDX2T.js";
-import "./chunk-DDRLI6JU.js";
-import "./chunk-4VNS5WPM.js";
-export {
-  JsonSessionStore,
-  appendEvent,
-  createEmptyState,
-  createInitialState,
-  detectNewCommit,
-  nextPhase,
-  projectDirToSlug,
-  readEvents,
-  updateStateFromInput,
-  validateSessionId
-};

package/dist/mcp-installer-TOYDP77X.js

@@ -1,124 +0,0 @@
-import {
-  getBinaryPath
-} from "./chunk-DDRLI6JU.js";
-import "./chunk-4VNS5WPM.js";
-
-// src/mcp-installer.ts
-import * as fs from "fs";
-import * as path from "path";
-function installMcpServer(projectDir) {
-  const settingsDir = path.join(projectDir, ".claude");
-  const settingsPath = path.join(settingsDir, "settings.local.json");
-  let settings = {};
-  if (fs.existsSync(settingsPath)) {
-    try {
-      settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
-    } catch {
-    }
-  }
-  const mcpServers = settings.mcpServers ?? {};
-  if (mcpServers["codemap"]) {
-    return { installed: false, message: "CodeMap MCP server already registered" };
-  }
-  const binary = getBinaryPath();
-  const parts = binary.split(" ");
-  const command = parts[0];
-  const baseArgs = parts.length > 1 ? [...parts.slice(1).map((a) => a.replace(/"/g, "")), "codemap", "serve"] : ["codemap", "serve"];
-  mcpServers["codemap"] = {
-    command,
-    args: baseArgs
-  };
-  settings.mcpServers = mcpServers;
-  fs.mkdirSync(settingsDir, { recursive: true });
-  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-  return { installed: true, message: "CodeMap MCP server registered in .claude/settings.local.json" };
-}
-function uninstallMcpServer(projectDir) {
-  const settingsPath = path.join(projectDir, ".claude", "settings.local.json");
-  if (!fs.existsSync(settingsPath)) return;
-  try {
-    const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
-    const mcpServers = settings.mcpServers;
-    if (mcpServers?.["codemap"]) {
-      delete mcpServers["codemap"];
-      if (Object.keys(mcpServers).length === 0) {
-        delete settings.mcpServers;
-      }
-      fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-    }
-  } catch {
-  }
-}
-function isMcpServerInstalled(projectDir) {
-  const settingsPath = path.join(projectDir, ".claude", "settings.local.json");
-  if (!fs.existsSync(settingsPath)) return false;
-  try {
-    const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
-    const mcpServers = settings.mcpServers;
-    return !!mcpServers?.["codemap"];
-  } catch {
-    return false;
-  }
-}
-function installMemoryMcpServer(projectDir) {
-  const settingsDir = path.join(projectDir, ".claude");
-  const settingsPath = path.join(settingsDir, "settings.local.json");
-  let settings = {};
-  if (fs.existsSync(settingsPath)) {
-    try {
-      settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
-    } catch {
-    }
-  }
-  const mcpServers = settings.mcpServers ?? {};
-  if (mcpServers["memory"]) {
-    return { installed: false, message: "Memory MCP server already registered" };
-  }
-  const binary = getBinaryPath();
-  const parts = binary.split(" ");
-  const command = parts[0];
-  const baseArgs = parts.length > 1 ? [...parts.slice(1).map((a) => a.replace(/"/g, "")), "memory", "serve"] : ["memory", "serve"];
-  mcpServers["memory"] = {
-    command,
-    args: baseArgs
-  };
-  settings.mcpServers = mcpServers;
-  fs.mkdirSync(settingsDir, { recursive: true });
-  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-  return { installed: true, message: "Memory MCP server registered in .claude/settings.local.json" };
-}
-function uninstallMemoryMcpServer(projectDir) {
-  const settingsPath = path.join(projectDir, ".claude", "settings.local.json");
-  if (!fs.existsSync(settingsPath)) return;
-  try {
-    const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
-    const mcpServers = settings.mcpServers;
-    if (mcpServers?.["memory"]) {
-      delete mcpServers["memory"];
-      if (Object.keys(mcpServers).length === 0) {
-        delete settings.mcpServers;
-      }
-      fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-    }
-  } catch {
-  }
-}
-function isMemoryMcpServerInstalled(projectDir) {
-  const settingsPath = path.join(projectDir, ".claude", "settings.local.json");
-  if (!fs.existsSync(settingsPath)) return false;
-  try {
-    const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
-    const mcpServers = settings.mcpServers;
-    return !!mcpServers?.["memory"];
-  } catch {
-    return false;
-  }
-}
-export {
-  installMcpServer,
-  installMemoryMcpServer,
-  isMcpServerInstalled,
-  isMemoryMcpServerInstalled,
-  uninstallMcpServer,
-  uninstallMemoryMcpServer
-};