@ulpi/cli 0.1.5 → 0.1.6

package/dist/chunk-Z53CAR7G.js

@@ -0,0 +1,298 @@
+// ../../packages/http/dist/middleware/auth.js
+import { randomBytes } from "crypto";
+var apiSecret;
+function generateApiSecret() {
+  return randomBytes(32).toString("hex");
+}
+function setApiSecret(secret) {
+  apiSecret = secret;
+}
+function getApiSecret() {
+  return apiSecret;
+}
+var LOOPBACK_ADDRESSES = /* @__PURE__ */ new Set(["127.0.0.1", "::1", "::ffff:127.0.0.1"]);
+function validateLoopback(req) {
+  const remoteAddr = req.socket.remoteAddress ?? "";
+  return LOOPBACK_ADDRESSES.has(remoteAddr);
+}
+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;
+}
+
+// ../../packages/http/dist/router.js
+function createRouter() {
+  const routes = [];
+  function add(method, pattern, handler) {
+    routes.push({ method, pattern, handler });
+  }
+  return {
+    get(pattern, handler) {
+      add("GET", pattern, handler);
+    },
+    post(pattern, handler) {
+      add("POST", pattern, handler);
+    },
+    put(pattern, handler) {
+      add("PUT", pattern, handler);
+    },
+    patch(pattern, handler) {
+      add("PATCH", pattern, handler);
+    },
+    delete(pattern, handler) {
+      add("DELETE", pattern, handler);
+    },
+    /**
+     * Try each registered route in order. For string patterns, performs an
+     * exact match against `ctx.pathname`. For RegExp patterns, tests the
+     * pathname and extracts named groups (or positional captures indexed by
+     * their number) into `params`.
+     *
+     * Returns `true` if a matching route was found (and its handler was
+     * invoked), `false` otherwise.
+     */
+    async handle(ctx) {
+      for (const route of routes) {
+        if (route.method !== ctx.method)
+          continue;
+        let params = {};
+        if (typeof route.pattern === "string") {
+          if (ctx.pathname !== route.pattern)
+            continue;
+        } else {
+          const match = route.pattern.exec(ctx.pathname);
+          if (!match)
+            continue;
+          if (match.groups) {
+            params = { ...match.groups };
+          }
+          for (let i = 1; i < match.length; i++) {
+            if (match[i] !== void 0) {
+              params[String(i)] = decodeURIComponent(match[i]);
+            }
+          }
+        }
+        await route.handler({ ...ctx, params });
+        return true;
+      }
+      return false;
+    }
+  };
+}
+
+// ../../packages/http/dist/request.js
+function readBody(req, maxSize = 1048576) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > maxSize) {
+        req.destroy();
+        reject(new Error("Request body too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+function readBodyRaw(req, maxSize = 5 * 1024 * 1024) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > maxSize) {
+        req.destroy();
+        reject(new Error("Request body too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+async function parseJsonBody(req) {
+  try {
+    const raw = await readBody(req);
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return { data: null, error: "Expected a JSON object" };
+    }
+    return { data: parsed, error: null };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Invalid JSON body";
+    return { data: null, error: message };
+  }
+}
+function parseMultipartImage(body, boundary) {
+  const boundaryBuffer = Buffer.from(`--${boundary}`);
+  const start = body.indexOf(boundaryBuffer);
+  if (start === -1)
+    return null;
+  const headerEnd = body.indexOf(Buffer.from("\r\n\r\n"), start);
+  if (headerEnd === -1)
+    return null;
+  const headers = body.subarray(start + boundaryBuffer.length + 2, headerEnd).toString();
+  const ctMatch = headers.match(/Content-Type:\s*(.+)/i);
+  const contentType = ctMatch ? ctMatch[1].trim() : "image/png";
+  const dataStart = headerEnd + 4;
+  const nextBoundary = body.indexOf(boundaryBuffer, dataStart);
+  const dataEnd = nextBoundary !== -1 ? nextBoundary - 2 : body.length;
+  return { data: body.subarray(dataStart, dataEnd), contentType };
+}
+
+// ../../packages/http/dist/response.js
+function resolveOrigin(options, req) {
+  if (!options)
+    return "*";
+  if (typeof options.origin === "function")
+    return options.origin(req);
+  return options.origin;
+}
+function corsHeaders(options, req) {
+  const headers = {
+    "Access-Control-Allow-Origin": resolveOrigin(options, req),
+    "Access-Control-Allow-Methods": options?.methods ?? "GET, POST, PUT, PATCH, DELETE, OPTIONS",
+    "Access-Control-Allow-Headers": options?.headers ?? "Content-Type, Authorization"
+  };
+  if (options?.credentials) {
+    headers["Access-Control-Allow-Credentials"] = "true";
+  }
+  if (options?.maxAge) {
+    headers["Access-Control-Max-Age"] = String(options.maxAge);
+  }
+  return headers;
+}
+function jsonResponse(res, data, status = 200, req, cors) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    ...corsHeaders(cors, req)
+  });
+  res.end(body);
+}
+function notFound(res, message = "Not found", req, cors) {
+  jsonResponse(res, { error: message }, 404, req, cors);
+}
+function sseHeaders(res, req, cors) {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+    ...corsHeaders(cors, req)
+  });
+}
+function sseEvent(res, eventName, data) {
+  res.write(`event: ${eventName}
+data: ${JSON.stringify(data)}
+
+`);
+}
+
+// ../../packages/http/dist/middleware/rate-limit.js
+var store = /* @__PURE__ */ new Map();
+var CLEANUP_INTERVAL = 6e4;
+setInterval(() => {
+  const now = Date.now();
+  for (const [key, entry] of store) {
+    if (now >= entry.resetAt) {
+      store.delete(key);
+    }
+  }
+}, CLEANUP_INTERVAL).unref();
+function checkRateLimit(key, limit = 200, windowMs = 6e4) {
+  const now = Date.now();
+  const entry = store.get(key);
+  if (!entry || now >= entry.resetAt) {
+    store.set(key, { count: 1, resetAt: now + windowMs });
+    return true;
+  }
+  entry.count++;
+  return entry.count <= limit;
+}
+
+// ../../packages/http/dist/middleware/cors.js
+function handleCorsPreFlight(req, res, options) {
+  if ((req.method ?? "GET") !== "OPTIONS")
+    return false;
+  res.writeHead(204, corsHeaders(options, req));
+  res.end();
+  return true;
+}
+
+// ../../packages/http/dist/websocket.js
+import { WebSocketServer } from "ws";
+
+// ../../packages/http/dist/sse.js
+var SSEBroadcaster = class _SSEBroadcaster {
+  static MAX_CLIENTS = 100;
+  clients = /* @__PURE__ */ new Set();
+  /** Check if the broadcaster can accept another client. */
+  canAccept() {
+    return this.clients.size < _SSEBroadcaster.MAX_CLIENTS;
+  }
+  /** Register a new SSE client. */
+  add(res) {
+    this.clients.add(res);
+  }
+  /** Remove a disconnected SSE client. */
+  remove(res) {
+    this.clients.delete(res);
+  }
+  /** Broadcast a named SSE event to every connected client. */
+  broadcast(eventName, data) {
+    const message = `event: ${eventName}
+data: ${JSON.stringify(data)}
+
+`;
+    for (const client of this.clients) {
+      try {
+        client.write(message);
+      } catch {
+        this.clients.delete(client);
+      }
+    }
+  }
+  /** Number of currently connected clients. */
+  get size() {
+    return this.clients.size;
+  }
+};
+
+export {
+  createRouter,
+  readBody,
+  readBodyRaw,
+  parseJsonBody,
+  parseMultipartImage,
+  jsonResponse,
+  notFound,
+  sseHeaders,
+  sseEvent,
+  generateApiSecret,
+  setApiSecret,
+  getApiSecret,
+  validateLoopback,
+  validateAuth,
+  checkRateLimit,
+  handleCorsPreFlight,
+  SSEBroadcaster
+};

package/dist/{ci-JQ56YIKC.js → ci-X3U2W4HC.js}

@@ -1,6 +1,6 @@
 import {
   buildPrompt
-} from "./chunk-AV5RB3N2.js";
+} from "./chunk-76D3BYJD.js";
 import {
   external_exports
 } from "./chunk-KIKPIH6N.js";
@@ -38,12 +38,13 @@ var JobConfigSchema = external_exports.object({
   repoUrl: external_exports.string().url(),
   ref: external_exports.string(),
   baseBranch: external_exports.string(),
-  prNumber: external_exports.number().int().positive(),
+  prNumber: external_exports.number().int().positive().optional(),
   repoFullName: external_exports.string(),
   instruction: external_exports.string(),
   jiraContext: external_exports.string().optional(),
   timeoutMinutes: external_exports.number().int().positive().default(1440),
-  envVars: external_exports.record(external_exports.string()).optional()
+  envVars: external_exports.record(external_exports.string()).optional(),
+  autoCommitIgnore: external_exports.array(external_exports.string()).default([".pnpm-store/", "node_modules/", ".claude/"])
 });
 var JobResultSchema = external_exports.object({
   jobId: external_exports.string(),
@@ -69,8 +70,8 @@ var JobSchema = external_exports.object({
   startedAt: external_exports.string().datetime().optional(),
   completedAt: external_exports.string().datetime().optional(),
   cancelledBy: external_exports.string().optional(),
-  commentId: external_exports.number().int().positive(),
-  commentAuthor: external_exports.string()
+  commentId: external_exports.number().int().positive().optional(),
+  commentAuthor: external_exports.string().optional()
 });
 var GitHubAppAuthSchema = external_exports.object({
   appId: external_exports.string(),
@@ -157,6 +158,26 @@ var JiraReferenceSchema = external_exports.object({
   key: external_exports.string(),
   url: external_exports.string().url()
 });
+var JiraSprintSchema = external_exports.object({
+  id: external_exports.number().int(),
+  name: external_exports.string(),
+  state: external_exports.string(),
+  // "active", "closed", "future"
+  startDate: external_exports.string().optional(),
+  endDate: external_exports.string().optional()
+});
+var SprintImportConfigSchema = external_exports.object({
+  jiraBaseUrl: external_exports.string().url(),
+  email: external_exports.string().email(),
+  apiToken: external_exports.string(),
+  sprintId: external_exports.number().int().positive()
+});
+var JiraSprintImportSchema = external_exports.object({
+  sprintId: external_exports.number().int(),
+  tasks: external_exports.array(external_exports.unknown()),
+  // TrackerTask[] — imported at runtime
+  warnings: external_exports.array(external_exports.string())
+});
 
 // src/commands/ci.ts
 async function runCi(args, projectDir) {
@@ -185,7 +206,7 @@ async function runCiJob(args) {
   let jobId = "";
   let configJson = "";
   let outputPath = "";
-  let model = "claude-sonnet-4-20250514";
+  let model = process.env.ULPI_CLAUDE_MODEL ?? "claude-opus-4-6";
   for (let i = 0; i < args.length; i++) {
     switch (args[i]) {
       case "--job-id":
@@ -250,6 +271,7 @@ async function runCiJob(args) {
     process.exit(1);
   }
   console.log(chalk.blue(`[ulpi-ci] Using claude at: ${claudePath}`));
+  logClaudeMdFiles(projectDir);
   const claudeArgs = [
     "--print",
     "--verbose",
@@ -261,8 +283,9 @@ async function runCiJob(args) {
   ];
   console.log(chalk.blue("[ulpi-ci] Spawning Claude Code..."));
   const result = await spawnClaude(claudePath, claudeArgs, prompt, config.timeoutMinutes * 60 * 1e3);
-  commitUnstagedWork(process.cwd());
+  commitUnstagedWork(process.cwd(), config.autoCommitIgnore);
   await postSessionFinalize(process.cwd());
+  await exportShadowBranches(process.cwd());
   const baseBranch = config.baseBranch;
   let diff = "";
   let filesChanged = [];
@@ -327,7 +350,7 @@ async function initUlpiSubsystems(projectDir) {
     if (fs.existsSync(guardsPath)) {
       console.log(chalk.blue("[ulpi-ci] guards.yml found \u2014 rules will be enforced"));
     } else {
-      const { loadBundledTemplates, composeTemplates, resolveTemplate } = await import("./dist-XG2GG5SD.js");
+      const { loadBundledTemplates, composeTemplates, resolveTemplate } = await import("./dist-HU5RZAON.js");
       const stackConfig = {
         name: path.basename(projectDir),
         runtime: stack.runtime?.id ?? "unknown",
@@ -369,14 +392,14 @@ async function initUlpiSubsystems(projectDir) {
     console.log(chalk.yellow(`[ulpi-ci] Warning: Could not detect stack/generate guards.yml: ${err instanceof Error ? err.message : String(err)}`));
   }
   try {
-    const { installHooks } = await import("./hooks-installer-K2JXEBNN.js");
+    const { installHooks } = await import("./hooks-installer-UN5JZLDQ.js");
     installHooks(projectDir);
     console.log(chalk.blue("[ulpi-ci] Hooks installed"));
   } catch (err) {
     console.log(chalk.yellow(`[ulpi-ci] Warning: Could not install hooks: ${err instanceof Error ? err.message : String(err)}`));
   }
   try {
-    const { installMcpServer, installMemoryMcpServer } = await import("./mcp-installer-TOYDP77X.js");
+    const { installMcpServer, installMemoryMcpServer } = await import("./mcp-installer-PQU3XOGO.js");
     installMcpServer(projectDir);
     installMemoryMcpServer(projectDir);
     console.log(chalk.blue("[ulpi-ci] MCP servers registered"));
@@ -389,10 +412,10 @@ async function initUlpiSubsystems(projectDir) {
   } catch {
   }
   try {
-    const { historyBranchExists, initHistoryBranch } = await import("./dist-5R4RYNQO.js");
+    const { historyBranchExists, initHistoryBranch } = await import("./dist-YCNWHSLN.js");
     if (!historyBranchExists(projectDir)) {
       const projectName = path.basename(projectDir);
-      const version = true ? "0.1.5" : "0.0.0";
+      const version = true ? "0.1.6" : "0.0.0";
       initHistoryBranch(projectDir, projectName, version);
       console.log(chalk.blue("[ulpi-ci] History branch initialized"));
     } else {
@@ -402,8 +425,8 @@ async function initUlpiSubsystems(projectDir) {
     console.log(chalk.yellow(`[ulpi-ci] Warning: Could not init history: ${err instanceof Error ? err.message : String(err)}`));
   }
   try {
-    const { isMemoryInitialized, saveMemoryConfig, DEFAULT_MEMORY_CONFIG, initMemoryBranch } = await import("./dist-7WLLPWWB.js");
-    const { projectMemoryDir } = await import("./dist-GWGTAHNM.js");
+    const { isMemoryInitialized, saveMemoryConfig, DEFAULT_MEMORY_CONFIG, initMemoryBranch } = await import("./dist-JLU26AB6.js");
+    const { projectMemoryDir } = await import("./dist-NUXMDXZ3.js");
     if (!isMemoryInitialized(projectDir)) {
       const memDir = projectMemoryDir(projectDir);
       fs.mkdirSync(memDir, { recursive: true });
@@ -418,11 +441,11 @@ async function initUlpiSubsystems(projectDir) {
     console.log(chalk.yellow(`[ulpi-ci] Warning: Could not init memory: ${err instanceof Error ? err.message : String(err)}`));
   }
   try {
-    const { resolveApiKey } = await import("./dist-GWGTAHNM.js");
+    const { resolveApiKey } = await import("./dist-NUXMDXZ3.js");
     const hasOpenAiKey = !!resolveApiKey("openai");
     const hasUlpiKey = !!resolveApiKey("ulpi");
     if (hasOpenAiKey || hasUlpiKey) {
-      const { runInitPipeline } = await import("./dist-6MFVWIFF.js");
+      const { runInitPipeline } = await import("./dist-YFFG2ZD6.js");
       console.log(chalk.blue("[ulpi-ci] Indexing codebase..."));
       await runInitPipeline(projectDir, (progress) => {
         if (progress.message) {
@@ -490,8 +513,22 @@ function writeYamlFields(obj, lines, indent) {
     }
   }
 }
-function commitUnstagedWork(cwd) {
+function commitUnstagedWork(cwd, ignorePatterns = []) {
   try {
+    if (ignorePatterns.length > 0) {
+      const gitignorePath = path.join(cwd, ".gitignore");
+      try {
+        const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, "utf-8") : "";
+        const missing = ignorePatterns.filter((p) => !existing.includes(p));
+        if (missing.length > 0) {
+          const separator = existing.endsWith("\n") || existing === "" ? "" : "\n";
+          fs.appendFileSync(gitignorePath, `${separator}# Added by ULPI CI worker
+${missing.join("\n")}
+`);
+        }
+      } catch {
+      }
+    }
     const status = execFileSync("git", ["status", "--porcelain"], {
       cwd,
       encoding: "utf-8",
@@ -500,10 +537,11 @@ function commitUnstagedWork(cwd) {
     if (!status) return;
     const fileCount = status.split("\n").filter(Boolean).length;
     console.log(chalk.blue(`[ulpi-ci] Committing ${fileCount} uncommitted files...`));
-    execFileSync("git", ["add", "-A"], { cwd, timeout: 3e4 });
-    execFileSync("git", ["commit", "-m", "wip: auto-commit from ULPI CI worker"], {
+    execFileSync("git", ["add", "-A"], { cwd, timeout: 6e5, maxBuffer: 50 * 1024 * 1024 });
+    execFileSync("git", ["commit", "--no-verify", "-m", "wip: auto-commit from ULPI CI worker"], {
       cwd,
-      timeout: 3e4
+      timeout: 6e5,
+      maxBuffer: 50 * 1024 * 1024
     });
     console.log(chalk.blue("[ulpi-ci] WIP commit created"));
   } catch (err) {
@@ -522,8 +560,8 @@ async function postSessionFinalize(projectDir) {
       writeHistoryEntry,
       readBranchMeta,
       DEFAULT_HISTORY_CONFIG
-    } = await import("./dist-5R4RYNQO.js");
-    const { loadActiveGuards } = await import("./dist-5R4RYNQO.js");
+    } = await import("./dist-YCNWHSLN.js");
+    const { loadActiveGuards } = await import("./dist-YCNWHSLN.js");
     if (historyBranchExists(projectDir)) {
       const commits = listBranchOnlyCommits(projectDir, 50);
       const meta = readBranchMeta(projectDir);
@@ -563,9 +601,9 @@ async function postSessionFinalize(projectDir) {
     console.log(chalk.yellow(`[ulpi-ci] Warning: History backfill failed: ${err instanceof Error ? err.message : String(err)}`));
   }
   try {
-    const { isMemoryInitialized, classifySession } = await import("./dist-7WLLPWWB.js");
-    const { ULPI_GLOBAL_DIR } = await import("./dist-GWGTAHNM.js");
-    const { JsonSessionStore } = await import("./dist-XD4YI27T.js");
+    const { isMemoryInitialized, classifySession } = await import("./dist-JLU26AB6.js");
+    const { ULPI_GLOBAL_DIR } = await import("./dist-NUXMDXZ3.js");
+    const { JsonSessionStore } = await import("./dist-6M4MZWZW.js");
     if (isMemoryInitialized(projectDir)) {
       const store = new JsonSessionStore(ULPI_GLOBAL_DIR, projectDir);
       const latest = store.getLatestForProject(projectDir);
@@ -586,6 +624,66 @@ async function postSessionFinalize(projectDir) {
     console.log(chalk.yellow(`[ulpi-ci] Warning: Memory classify failed: ${err instanceof Error ? err.message : String(err)}`));
   }
 }
+async function exportShadowBranches(projectDir) {
+  try {
+    const { getCodemapStatus, exportIndex } = await import("./dist-YFFG2ZD6.js");
+    const { getCurrentBranch } = await import("./dist-NUXMDXZ3.js");
+    const branch = getCurrentBranch(projectDir);
+    const status = getCodemapStatus(projectDir, branch);
+    if (status.initialized) {
+      const result = await exportIndex(projectDir, branch);
+      console.log(chalk.blue(`[ulpi-ci] Codemap exported to ${result.branchName} (${result.filesExported} files)`));
+    }
+  } catch (err) {
+    console.log(chalk.yellow(`[ulpi-ci] Warning: Codemap export failed: ${err instanceof Error ? err.message : String(err)}`));
+  }
+  try {
+    const { isMemoryInitialized, exportMemories } = await import("./dist-JLU26AB6.js");
+    if (isMemoryInitialized(projectDir)) {
+      const result = await exportMemories(projectDir);
+      console.log(chalk.blue(`[ulpi-ci] Memory exported to ${result.branchName} (${result.memoriesExported} memories, ${result.filesExported} files)`));
+    }
+  } catch (err) {
+    console.log(chalk.yellow(`[ulpi-ci] Warning: Memory export failed: ${err instanceof Error ? err.message : String(err)}`));
+  }
+}
+function logClaudeMdFiles(projectDir) {
+  const rootMd = path.join(projectDir, "CLAUDE.md");
+  if (fs.existsSync(rootMd)) {
+    const stat = fs.statSync(rootMd);
+    console.log(chalk.blue(`[ulpi-ci] Found CLAUDE.md (${stat.size} bytes)`));
+  } else {
+    console.log(chalk.yellow("[ulpi-ci] No CLAUDE.md in workspace root"));
+  }
+  const claudeDir = path.join(projectDir, ".claude");
+  if (fs.existsSync(claudeDir)) {
+    const items = [];
+    try {
+      for (const entry of fs.readdirSync(claudeDir, { recursive: true })) {
+        if (entry.endsWith(".md") || entry === "settings.local.json") {
+          items.push(entry);
+        }
+      }
+    } catch {
+    }
+    console.log(chalk.blue(`[ulpi-ci] .claude/ contents: ${items.length > 0 ? items.join(", ") : "(empty)"}`));
+  } else {
+    console.log(chalk.yellow("[ulpi-ci] No .claude/ directory in workspace"));
+  }
+  try {
+    const nested = [];
+    for (const entry of fs.readdirSync(projectDir, { withFileTypes: true })) {
+      if (entry.isDirectory() && !entry.name.startsWith(".")) {
+        const nestedMd = path.join(projectDir, entry.name, "CLAUDE.md");
+        if (fs.existsSync(nestedMd)) nested.push(entry.name);
+      }
+    }
+    if (nested.length > 0) {
+      console.log(chalk.blue(`[ulpi-ci] Nested CLAUDE.md: ${nested.join(", ")}`));
+    }
+  } catch {
+  }
+}
 function findClaudeBinary() {
   try {
     const result = execFileSync("which", ["claude"], { encoding: "utf-8", timeout: 5e3 });
@@ -662,7 +760,7 @@ function spawnClaude(claudePath, args, prompt, timeoutMs) {
   return new Promise((resolve) => {
     const proc = spawn(claudePath, args, {
       cwd: process.cwd(),
-      env: process.env,
+      env: { ...process.env, ULPI_RUN_MODE: "ci" },
       stdio: ["pipe", "pipe", "pipe"]
     });
     let stdout = "";