@ulpi/cli 0.1.5 → 0.1.7

package/dist/chunk-JLHNLM3C.js

@@ -0,0 +1,228 @@
+import {
+  loadMcpCatalog
+} from "./chunk-4ZPOZULQ.js";
+import {
+  MCPS_LIBRARY_FILE,
+  ULPI_GLOBAL_DIR,
+  projectMcpsFile
+} from "./chunk-C7CLUQI6.js";
+import {
+  McpLibrarySchema,
+  McpRepoConfigSchema
+} from "./chunk-YOKL7RB5.js";
+
+// ../../packages/mcp-gateway-engine/dist/index.js
+import * as fs from "fs";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import * as fs2 from "fs";
+import * as path from "path";
+import { parse as parseYaml2, stringify as stringifyYaml2 } from "yaml";
+import * as fs3 from "fs";
+import * as path2 from "path";
+function loadLibrary() {
+  try {
+    if (!fs.existsSync(MCPS_LIBRARY_FILE)) {
+      return { mcps: {} };
+    }
+    const raw = fs.readFileSync(MCPS_LIBRARY_FILE, "utf-8");
+    const parsed = parseYaml(raw);
+    return McpLibrarySchema.parse(parsed ?? {});
+  } catch {
+    return { mcps: {} };
+  }
+}
+function saveLibrary(library) {
+  fs.mkdirSync(ULPI_GLOBAL_DIR, { recursive: true });
+  const yaml = stringifyYaml(library, { lineWidth: 120 });
+  fs.writeFileSync(MCPS_LIBRARY_FILE, yaml, "utf-8");
+}
+function addToLibrary(name, definition) {
+  const library = loadLibrary();
+  library.mcps[name] = { ...definition, name, added_at: definition.added_at ?? (/* @__PURE__ */ new Date()).toISOString() };
+  saveLibrary(library);
+}
+function removeFromLibrary(name) {
+  const library = loadLibrary();
+  if (!(name in library.mcps)) return false;
+  delete library.mcps[name];
+  saveLibrary(library);
+  return true;
+}
+function getLibraryEntry(name) {
+  const library = loadLibrary();
+  return library.mcps[name];
+}
+function listLibrary() {
+  const library = loadLibrary();
+  return Object.values(library.mcps);
+}
+function loadActivations(projectDir) {
+  try {
+    const filePath = projectMcpsFile(projectDir);
+    if (!fs2.existsSync(filePath)) {
+      return { mcps: {} };
+    }
+    const raw = fs2.readFileSync(filePath, "utf-8");
+    const parsed = parseYaml2(raw);
+    return McpRepoConfigSchema.parse(parsed ?? {});
+  } catch {
+    return { mcps: {} };
+  }
+}
+function saveActivations(projectDir, config) {
+  const filePath = projectMcpsFile(projectDir);
+  fs2.mkdirSync(path.dirname(filePath), { recursive: true });
+  const yaml = stringifyYaml2(config, { lineWidth: 120 });
+  fs2.writeFileSync(filePath, yaml, "utf-8");
+}
+function enableMcp(projectDir, name, config) {
+  const current = loadActivations(projectDir);
+  current.mcps[name] = { enabled: true, config: config ?? current.mcps[name]?.config ?? {} };
+  saveActivations(projectDir, current);
+}
+function disableMcp(projectDir, name) {
+  const current = loadActivations(projectDir);
+  if (!(name in current.mcps)) return false;
+  current.mcps[name] = { ...current.mcps[name], enabled: false, config: current.mcps[name]?.config ?? {} };
+  saveActivations(projectDir, current);
+  return true;
+}
+function updateActivationConfig(projectDir, name, config) {
+  const current = loadActivations(projectDir);
+  const existing = current.mcps[name];
+  current.mcps[name] = { enabled: existing?.enabled ?? true, config };
+  saveActivations(projectDir, current);
+}
+function getActivation(projectDir, name) {
+  const config = loadActivations(projectDir);
+  return config.mcps[name];
+}
+function listActivations(projectDir) {
+  const config = loadActivations(projectDir);
+  return Object.entries(config.mcps).map(([name, activation]) => ({ name, activation }));
+}
+function loadCatalog() {
+  return loadMcpCatalog();
+}
+function getCatalogEntry(name) {
+  return loadMcpCatalog().find((e) => e.name === name);
+}
+function searchCatalog(query) {
+  const q = query.toLowerCase();
+  return loadMcpCatalog().filter((entry) => {
+    if (entry.name.toLowerCase().includes(q)) return true;
+    if (entry.display_name?.toLowerCase().includes(q)) return true;
+    if (entry.description?.toLowerCase().includes(q)) return true;
+    if (entry.tags?.some((t) => t.toLowerCase().includes(q))) return true;
+    if (entry.category?.toLowerCase().includes(q)) return true;
+    return false;
+  });
+}
+function suggestMcps(input) {
+  const catalog = loadMcpCatalog();
+  const library = loadLibrary();
+  const suggestions = [];
+  for (const entry of catalog) {
+    const signals = entry.detect_signals;
+    if (!signals) continue;
+    const evidence = [];
+    const depMatches = (signals.dependencies ?? []).filter(
+      (d) => input.dependencies.some((dep) => dep === d || dep.startsWith(d + "/"))
+    );
+    if (depMatches.length > 0) {
+      evidence.push(`Dependencies: ${depMatches.join(", ")}`);
+    }
+    const envMatches = (signals.env_vars ?? []).filter((e) => input.envVars.includes(e));
+    if (envMatches.length > 0) {
+      evidence.push(`Env vars: ${envMatches.join(", ")}`);
+    }
+    const dockerMatches = (signals.docker_services ?? []).filter((s) => input.dockerServices.includes(s));
+    if (dockerMatches.length > 0) {
+      evidence.push(`Docker services: ${dockerMatches.join(", ")}`);
+    }
+    if (evidence.length === 0) continue;
+    let confidence = "low";
+    if (depMatches.length > 0 && (envMatches.length > 0 || dockerMatches.length > 0)) {
+      confidence = "high";
+    } else if (depMatches.length > 0 || envMatches.length > 0) {
+      confidence = "medium";
+    }
+    suggestions.push({
+      name: entry.name,
+      displayName: entry.display_name ?? entry.name,
+      description: entry.description ?? "",
+      category: entry.category ?? "custom",
+      confidence,
+      evidence,
+      alreadyAdded: entry.name in library.mcps
+    });
+  }
+  const order = { high: 0, medium: 1, low: 2 };
+  suggestions.sort((a, b) => order[a.confidence] - order[b.confidence] || a.name.localeCompare(b.name));
+  return suggestions;
+}
+function collectProjectSignals(projectDir) {
+  const dependencies = [];
+  const envVars = [];
+  const dockerServices = [];
+  const pkgJsonPath = path2.join(projectDir, "package.json");
+  try {
+    if (fs3.existsSync(pkgJsonPath)) {
+      const pkg = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
+      dependencies.push(...Object.keys(pkg.dependencies ?? {}));
+      dependencies.push(...Object.keys(pkg.devDependencies ?? {}));
+    }
+  } catch {
+  }
+  for (const envFile of [".env", ".env.local", ".env.example"]) {
+    const envPath = path2.join(projectDir, envFile);
+    try {
+      if (fs3.existsSync(envPath)) {
+        const content = fs3.readFileSync(envPath, "utf-8");
+        for (const line of content.split("\n")) {
+          const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+          if (match?.[1]) envVars.push(match[1]);
+        }
+      }
+    } catch {
+    }
+  }
+  for (const dcFile of ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"]) {
+    const dcPath = path2.join(projectDir, dcFile);
+    try {
+      if (fs3.existsSync(dcPath)) {
+        const content = fs3.readFileSync(dcPath, "utf-8");
+        const servicesMatch = content.match(/^services:\s*\n((?:\s+\S+.*\n?)*)/m);
+        if (servicesMatch?.[1]) {
+          for (const line of servicesMatch[1].split("\n")) {
+            const svcMatch = line.match(/^\s{2}(\w[\w-]*):/);
+            if (svcMatch?.[1]) dockerServices.push(svcMatch[1]);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return { dependencies, envVars, dockerServices };
+}
+
+export {
+  loadLibrary,
+  saveLibrary,
+  addToLibrary,
+  removeFromLibrary,
+  getLibraryEntry,
+  listLibrary,
+  loadActivations,
+  saveActivations,
+  enableMcp,
+  disableMcp,
+  updateActivationConfig,
+  getActivation,
+  listActivations,
+  loadCatalog,
+  getCatalogEntry,
+  searchCatalog,
+  suggestMcps,
+  collectProjectSignals
+};

package/dist/chunk-PO4NUZUU.js

@@ -0,0 +1,147 @@
+import {
+  REVIEW_FLAGS_DIR,
+  getPortalPort,
+  loadUlpiSettings
+} from "./chunk-C7CLUQI6.js";
+
+// src/hooks/review-integration.ts
+import * as fs from "fs";
+import * as path from "path";
+import { execFileSync } from "child_process";
+function isReviewEnabled(type, rules) {
+  const runMode = process.env.ULPI_RUN_MODE;
+  if (runMode === "loop" || runMode === "parallel" || runMode === "ci") {
+    return false;
+  }
+  const reviewConfig = rules.review;
+  if (reviewConfig) {
+    if (reviewConfig.enabled === false) return false;
+    if (type === "plan" && reviewConfig.plan_review === false) return false;
+    if (type === "code" && reviewConfig.code_review === false) return false;
+  }
+  try {
+    const settings = loadUlpiSettings();
+    if (!settings.review.enabled) return false;
+    if (type === "plan" && !settings.review.plan_review) return false;
+    if (type === "code" && !settings.review.code_review) return false;
+  } catch {
+  }
+  return true;
+}
+function extractPlanForReview(input) {
+  const toolInput = input.tool_input;
+  if (toolInput?.plan && typeof toolInput.plan === "string") {
+    return toolInput.plan;
+  }
+  if (toolInput?.content && typeof toolInput.content === "string") {
+    return toolInput.content;
+  }
+  try {
+    const plansDir = path.join(input.cwd, ".claude", "plans");
+    if (!fs.existsSync(plansDir)) return null;
+    const entries = fs.readdirSync(plansDir);
+    let newest = null;
+    for (const entry of entries) {
+      if (!entry.endsWith(".md")) continue;
+      const fullPath = path.join(plansDir, entry);
+      const stat = fs.statSync(fullPath);
+      if (!newest || stat.mtimeMs > newest.mtime) {
+        newest = { name: entry, mtime: stat.mtimeMs };
+      }
+    }
+    if (newest) {
+      return fs.readFileSync(path.join(plansDir, newest.name), "utf-8");
+    }
+  } catch {
+  }
+  return null;
+}
+async function runPlanReviewSession(plan, projectDir, sessionId) {
+  try {
+    const { discoverUlpiServer, registerWithServer, waitForServerDecision } = await import("./dist-ZG4OKCSR.js");
+    const server = await discoverUlpiServer();
+    if (!server) return null;
+    const settings = loadUlpiSettings();
+    const registration = await registerWithServer(
+      server.port,
+      { type: "plan", projectPath: projectDir, plan },
+      server.secret
+    );
+    if (!registration?.success) return null;
+    const reviewSessionId = registration.sessionId;
+    if (settings.review.auto_open_browser) {
+      const url = `http://localhost:${getPortalPort()}/review/plan?session=${reviewSessionId}`;
+      try {
+        execFileSync("open", [url], { timeout: 5e3 });
+      } catch {
+      }
+    }
+    const maxWaitMs = settings.review.review_timeout_seconds > 0 ? settings.review.review_timeout_seconds * 1e3 : void 0;
+    const decision = await waitForServerDecision(
+      server.port,
+      reviewSessionId,
+      3e4,
+      maxWaitMs,
+      registration.token,
+      server.secret
+    );
+    if (!decision) {
+      if (settings.review.timeout_behavior === "deny") {
+        return { behavior: "deny", feedback: "Plan review timed out." };
+      }
+      return null;
+    }
+    const planDecision = decision;
+    const behavior = planDecision.behavior === "deny" ? "deny" : "allow";
+    const feedback = planDecision.feedback || planDecision.message || void 0;
+    const clearContext = planDecision.clearContext ?? false;
+    writeFlagFiles(sessionId, { feedback, clearContext });
+    return { behavior, feedback, clearContext };
+  } catch {
+    return null;
+  }
+}
+function writeFlagFiles(sessionId, ctx) {
+  try {
+    const dir = path.join(REVIEW_FLAGS_DIR, sessionId);
+    fs.mkdirSync(dir, { recursive: true });
+    if (ctx.feedback) {
+      fs.writeFileSync(path.join(dir, "review-feedback.flag"), ctx.feedback, "utf-8");
+    }
+    if (ctx.clearContext) {
+      fs.writeFileSync(path.join(dir, "clear-context.flag"), "1", "utf-8");
+    }
+  } catch {
+  }
+}
+function collectPostReviewContexts(sessionId) {
+  const result = {};
+  try {
+    const dir = path.join(REVIEW_FLAGS_DIR, sessionId);
+    if (!fs.existsSync(dir)) return result;
+    const feedbackPath = path.join(dir, "review-feedback.flag");
+    if (fs.existsSync(feedbackPath)) {
+      result.feedback = fs.readFileSync(feedbackPath, "utf-8");
+      fs.unlinkSync(feedbackPath);
+    }
+    const clearPath = path.join(dir, "clear-context.flag");
+    if (fs.existsSync(clearPath)) {
+      result.clearContext = true;
+      fs.unlinkSync(clearPath);
+    }
+    try {
+      const remaining = fs.readdirSync(dir);
+      if (remaining.length === 0) fs.rmdirSync(dir);
+    } catch {
+    }
+  } catch {
+  }
+  return result;
+}
+
+export {
+  isReviewEnabled,
+  extractPlanForReview,
+  runPlanReviewSession,
+  collectPostReviewContexts
+};