@ulpi/cli 0.1.0

package/dist/chunk-2HEE5OKX.js

@@ -0,0 +1,79 @@
+import {
+  resolveApiKey
+} from "./chunk-7LXY5UVC.js";
+
+// ../../packages/codemap-engine/dist/chunk-ZW4DV263.js
+var OPENAI_EMBEDDINGS_URL = "https://api.openai.com/v1/embeddings";
+var MAX_RETRIES = 3;
+var RETRY_BASE_MS = 1e3;
+var OpenAIEmbedder = class {
+  provider = "openai";
+  model;
+  dimensions;
+  apiKey;
+  constructor(model = "text-embedding-3-small", dimensions = 1536) {
+    this.model = model;
+    this.dimensions = dimensions;
+    const key = resolveApiKey("openai");
+    if (!key) {
+      throw new Error(
+        "OpenAI API key not found. Set it with:\n  ulpi config set openai-key <your-key>\nOr switch to Ollama (local, no key needed):\n  ulpi codemap config embedding.provider ollama"
+      );
+    }
+    this.apiKey = key;
+  }
+  async embed(texts) {
+    if (texts.length === 0) return [];
+    const body = {
+      input: texts,
+      model: this.model,
+      dimensions: this.dimensions
+    };
+    let lastError = null;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        const response = await fetch(OPENAI_EMBEDDINGS_URL, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiKey}`
+          },
+          body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          if (response.status === 401 || response.status === 403) {
+            throw new Error(`OpenAI API authentication error (${response.status}): check your OPENAI_API_KEY`);
+          }
+          if (response.status === 429 || response.status >= 500) {
+            lastError = new Error(`OpenAI API error (${response.status}): ${errorText.slice(0, 200)}`);
+            const delay = RETRY_BASE_MS * Math.pow(2, attempt);
+            await sleep(delay);
+            continue;
+          }
+          throw new Error(`OpenAI API error (${response.status}): ${errorText.slice(0, 200)}`);
+        }
+        const data = await response.json();
+        const sorted = data.data.sort((a, b) => a.index - b.index);
+        return sorted.map((item) => item.embedding);
+      } catch (err) {
+        if (err instanceof Error && (err.message.includes("authentication") || err.message.includes("Unknown"))) {
+          throw err;
+        }
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < MAX_RETRIES - 1) {
+          const delay = RETRY_BASE_MS * Math.pow(2, attempt);
+          await sleep(delay);
+        }
+      }
+    }
+    throw lastError ?? new Error("OpenAI embedding failed after retries");
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export {
+  OpenAIEmbedder
+};

package/dist/chunk-2MZER6ND.js

@@ -0,0 +1,415 @@
+import {
+  extractSections,
+  extractTitle,
+  generateSlug,
+  getNextVersionNumber,
+  parseMarkdownToBlocks,
+  savePlan,
+  scorePlanQuality
+} from "./chunk-3SBPZRB5.js";
+import {
+  API_LOCK_FILE,
+  getApiHost,
+  getApiPort
+} from "./chunk-7LXY5UVC.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
+};