@ulpi/cli 0.1.5 → 0.1.6

package/dist/{chunk-EIWYSP3A.js → chunk-UXHCHOWQ.js}

@@ -2,14 +2,15 @@ import {
   ULPI_GLOBAL_DIR,
   projectGuardsFile,
   projectGuardsFileAlt
-} from "./chunk-DDRLI6JU.js";
+} from "./chunk-C7CLUQI6.js";
 
-// ../../packages/projects-engine/dist/index.js
+// ../../packages/repos-engine/dist/index.js
 import * as fs from "fs";
 import * as path from "path";
 import * as crypto from "crypto";
 var DEFAULT_BASE_DIR = ULPI_GLOBAL_DIR;
-var REGISTRY_FILE = "projects.json";
+var REGISTRY_FILE = "repos.json";
+var LEGACY_REGISTRY_FILE = "projects.json";
 function registryPath(baseDir) {
   return path.join(baseDir, REGISTRY_FILE);
 }
@@ -18,7 +19,7 @@ function atomicWrite(filePath, data) {
   fs.writeFileSync(tmpPath, data, "utf-8");
   fs.renameSync(tmpPath, filePath);
 }
-function generateProjectId(projectPath) {
+function generateRepoId(projectPath) {
   const normalized = path.resolve(projectPath);
   const hash = crypto.createHash("sha256").update(normalized).digest("hex");
   return hash.slice(0, 12);
@@ -26,11 +27,31 @@ function generateProjectId(projectPath) {
 function createEmptyRegistry() {
   return {
     version: 1,
-    projects: {},
-    defaultProject: void 0
+    repos: {},
+    defaultRepo: void 0
   };
 }
-function loadProjectRegistry(baseDir = DEFAULT_BASE_DIR) {
+function migrateIfNeeded(baseDir) {
+  const newPath = registryPath(baseDir);
+  if (fs.existsSync(newPath)) return;
+  const legacyPath = path.join(baseDir, LEGACY_REGISTRY_FILE);
+  if (!fs.existsSync(legacyPath)) return;
+  try {
+    const raw = fs.readFileSync(legacyPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const migrated = {
+      version: 1,
+      repos: parsed.projects ?? parsed.repos ?? {},
+      defaultRepo: parsed.defaultProject ?? parsed.defaultRepo
+    };
+    fs.mkdirSync(path.dirname(newPath), { recursive: true });
+    atomicWrite(newPath, JSON.stringify(migrated, null, 2));
+    fs.unlinkSync(legacyPath);
+  } catch {
+  }
+}
+function loadRepoRegistry(baseDir = DEFAULT_BASE_DIR) {
+  migrateIfNeeded(baseDir);
   const filePath = registryPath(baseDir);
   if (!fs.existsSync(filePath)) {
     return createEmptyRegistry();
@@ -38,7 +59,7 @@ function loadProjectRegistry(baseDir = DEFAULT_BASE_DIR) {
   try {
     const raw = fs.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object" && parsed.version === 1 && typeof parsed.projects === "object") {
+    if (parsed && typeof parsed === "object" && parsed.version === 1 && typeof parsed.repos === "object") {
       return parsed;
     }
     return createEmptyRegistry();
@@ -46,17 +67,17 @@ function loadProjectRegistry(baseDir = DEFAULT_BASE_DIR) {
     return createEmptyRegistry();
   }
 }
-function saveProjectRegistry(registry, baseDir = DEFAULT_BASE_DIR) {
+function saveRepoRegistry(registry, baseDir = DEFAULT_BASE_DIR) {
   const filePath = registryPath(baseDir);
   const dir = path.dirname(filePath);
   fs.mkdirSync(dir, { recursive: true });
   atomicWrite(filePath, JSON.stringify(registry, null, 2));
 }
-function registerProject(projectDir, options = {}, baseDir = DEFAULT_BASE_DIR) {
+function registerRepo(projectDir, options = {}, baseDir = DEFAULT_BASE_DIR) {
   const absPath = path.resolve(projectDir);
-  const id = generateProjectId(absPath);
-  const registry = loadProjectRegistry(baseDir);
-  const existing = registry.projects[id];
+  const id = generateRepoId(absPath);
+  const registry = loadRepoRegistry(baseDir);
+  const existing = registry.repos[id];
   let configStatus = "none";
   const rulesPath = projectGuardsFile(absPath);
   const rulesYamlPath = projectGuardsFileAlt(absPath);
@@ -88,80 +109,80 @@ function registerProject(projectDir, options = {}, baseDir = DEFAULT_BASE_DIR) {
     hooksInstalled: options.hooksInstalled ?? hooksInstalled,
     stack: options.stack ?? existing?.stack
   };
-  registry.projects[id] = entry;
-  saveProjectRegistry(registry, baseDir);
+  registry.repos[id] = entry;
+  saveRepoRegistry(registry, baseDir);
   return entry;
 }
-function unregisterProject(idOrPath, baseDir = DEFAULT_BASE_DIR) {
-  const registry = loadProjectRegistry(baseDir);
-  if (registry.projects[idOrPath]) {
-    delete registry.projects[idOrPath];
-    if (registry.defaultProject === idOrPath) {
-      registry.defaultProject = void 0;
+function unregisterRepo(idOrPath, baseDir = DEFAULT_BASE_DIR) {
+  const registry = loadRepoRegistry(baseDir);
+  if (registry.repos[idOrPath]) {
+    delete registry.repos[idOrPath];
+    if (registry.defaultRepo === idOrPath) {
+      registry.defaultRepo = void 0;
     }
-    saveProjectRegistry(registry, baseDir);
+    saveRepoRegistry(registry, baseDir);
     return true;
   }
   const absPath = path.resolve(idOrPath);
-  const id = generateProjectId(absPath);
-  if (registry.projects[id]) {
-    delete registry.projects[id];
-    if (registry.defaultProject === id) {
-      registry.defaultProject = void 0;
+  const id = generateRepoId(absPath);
+  if (registry.repos[id]) {
+    delete registry.repos[id];
+    if (registry.defaultRepo === id) {
+      registry.defaultRepo = void 0;
     }
-    saveProjectRegistry(registry, baseDir);
+    saveRepoRegistry(registry, baseDir);
     return true;
   }
   return false;
 }
-function getProject(idOrPath, baseDir = DEFAULT_BASE_DIR) {
-  const registry = loadProjectRegistry(baseDir);
-  if (registry.projects[idOrPath]) {
-    return registry.projects[idOrPath];
+function getRepo(idOrPath, baseDir = DEFAULT_BASE_DIR) {
+  const registry = loadRepoRegistry(baseDir);
+  if (registry.repos[idOrPath]) {
+    return registry.repos[idOrPath];
   }
   const absPath = path.resolve(idOrPath);
-  const id = generateProjectId(absPath);
-  return registry.projects[id] ?? null;
+  const id = generateRepoId(absPath);
+  return registry.repos[id] ?? null;
 }
-function listProjects(baseDir = DEFAULT_BASE_DIR) {
-  const registry = loadProjectRegistry(baseDir);
-  return Object.values(registry.projects).sort((a, b) => {
+function listRepos(baseDir = DEFAULT_BASE_DIR) {
+  const registry = loadRepoRegistry(baseDir);
+  return Object.values(registry.repos).sort((a, b) => {
     return new Date(b.lastAccessed).getTime() - new Date(a.lastAccessed).getTime();
   });
 }
-function setDefaultProject(idOrPath, baseDir = DEFAULT_BASE_DIR) {
-  const registry = loadProjectRegistry(baseDir);
+function setDefaultRepo(idOrPath, baseDir = DEFAULT_BASE_DIR) {
+  const registry = loadRepoRegistry(baseDir);
   if (!idOrPath) {
-    registry.defaultProject = void 0;
-    saveProjectRegistry(registry, baseDir);
+    registry.defaultRepo = void 0;
+    saveRepoRegistry(registry, baseDir);
     return true;
   }
   let id = idOrPath;
-  if (!registry.projects[id]) {
+  if (!registry.repos[id]) {
     const absPath = path.resolve(idOrPath);
-    id = generateProjectId(absPath);
+    id = generateRepoId(absPath);
   }
-  if (!registry.projects[id]) {
+  if (!registry.repos[id]) {
     return false;
   }
-  registry.defaultProject = id;
-  saveProjectRegistry(registry, baseDir);
+  registry.defaultRepo = id;
+  saveRepoRegistry(registry, baseDir);
   return true;
 }
-function getDefaultProject(baseDir = DEFAULT_BASE_DIR) {
-  const registry = loadProjectRegistry(baseDir);
-  if (!registry.defaultProject) {
+function getDefaultRepo(baseDir = DEFAULT_BASE_DIR) {
+  const registry = loadRepoRegistry(baseDir);
+  if (!registry.defaultRepo) {
     return null;
   }
-  return registry.projects[registry.defaultProject] ?? null;
+  return registry.repos[registry.defaultRepo] ?? null;
 }
-function scanForProjects(rootDir, maxDepth = 3) {
-  const projects = [];
+function scanForRepos(rootDir, maxDepth = 3) {
+  const repos = [];
   function scan(dir, depth) {
     if (depth > maxDepth) return;
     const ulpiPath = path.join(dir, ".ulpi");
     if (fs.existsSync(path.join(ulpiPath, "guards.yml")) || fs.existsSync(path.join(ulpiPath, "guards.yaml"))) {
-      projects.push(dir);
+      repos.push(dir);
       return;
     }
     try {
@@ -182,16 +203,16 @@ function scanForProjects(rootDir, maxDepth = 3) {
     }
   }
   scan(path.resolve(rootDir), 0);
-  return projects;
+  return repos;
 }
 
 export {
-  loadProjectRegistry,
-  registerProject,
-  unregisterProject,
-  getProject,
-  listProjects,
-  setDefaultProject,
-  getDefaultProject,
-  scanForProjects
+  loadRepoRegistry,
+  registerRepo,
+  unregisterRepo,
+  getRepo,
+  listRepos,
+  setDefaultRepo,
+  getDefaultRepo,
+  scanForRepos
 };

package/dist/chunk-V2H5D6Y3.js

@@ -0,0 +1,146 @@
+import {
+  REVIEW_FLAGS_DIR,
+  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://127.0.0.1:${server.port}/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
+};

package/dist/{chunk-5SCG7UYM.js → chunk-VVEDXI7E.js}

@@ -1,7 +1,7 @@
 import {
   CLI_BIN_NAME,
   getBinaryPath
-} from "./chunk-DDRLI6JU.js";
+} from "./chunk-C7CLUQI6.js";
 
 // src/hooks-installer.ts
 import * as fs from "fs";