@ulpi/cli 0.1.5 → 0.1.7

package/dist/{chunk-5SCG7UYM.js → chunk-XKF4DPUM.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";
@@ -51,14 +51,14 @@ function installHooks(projectDir) {
 function findSkillSource() {
   if (process.argv[1]) {
     const entryDir = path.dirname(path.resolve(process.argv[1]));
-    const bundled = path.join(entryDir, "skills", "ulpi-generate-guardian");
+    const bundled = path.join(entryDir, "skills", "ulpi-generate-guards");
     if (fs.existsSync(bundled)) return bundled;
   }
   if (process.argv[1]) {
     let dir = path.dirname(path.resolve(process.argv[1]));
     for (let i = 0; i < 5; i++) {
       dir = path.dirname(dir);
-      const candidate = path.join(dir, ".claude", "skills", "ulpi-generate-guardian");
+      const candidate = path.join(dir, ".claude", "skills", "ulpi-generate-guards");
       if (fs.existsSync(candidate)) return candidate;
     }
   }
@@ -66,7 +66,7 @@ function findSkillSource() {
 }
 function installGlobalSkill() {
   const homeDir = os.homedir();
-  const globalSkillsDir = path.join(homeDir, ".claude", "skills", "ulpi-generate-guardian");
+  const globalSkillsDir = path.join(homeDir, ".claude", "skills", "ulpi-generate-guards");
   if (fs.existsSync(globalSkillsDir)) {
     return { installed: false, message: "Skill already installed globally" };
   }
@@ -77,13 +77,13 @@ function installGlobalSkill() {
   try {
     fs.mkdirSync(path.dirname(globalSkillsDir), { recursive: true });
     copyDirRecursive(skillSource, globalSkillsDir);
-    return { installed: true, message: `Installed /ulpi-generate-guardian skill globally to ${globalSkillsDir}` };
+    return { installed: true, message: `Installed /ulpi-generate-guards skill globally to ${globalSkillsDir}` };
   } catch (err) {
     return { installed: false, message: `Failed to install skill: ${err instanceof Error ? err.message : String(err)}` };
   }
 }
 function installLocalSkill(projectDir) {
-  const localSkillsDir = path.join(projectDir, ".claude", "skills", "ulpi-generate-guardian");
+  const localSkillsDir = path.join(projectDir, ".claude", "skills", "ulpi-generate-guards");
   if (fs.existsSync(localSkillsDir)) {
     return { installed: false, message: "Skill already installed locally" };
   }
@@ -94,7 +94,7 @@ function installLocalSkill(projectDir) {
   try {
     fs.mkdirSync(path.dirname(localSkillsDir), { recursive: true });
     copyDirRecursive(skillSource, localSkillsDir);
-    return { installed: true, message: `Installed /ulpi-generate-guardian skill locally` };
+    return { installed: true, message: `Installed /ulpi-generate-guards skill locally` };
   } catch (err) {
     return { installed: false, message: `Failed to install skill: ${err instanceof Error ? err.message : String(err)}` };
   }

package/dist/{chunk-74WVVWJ4.js → chunk-YOKL7RB5.js}

@@ -136,9 +136,9 @@ var PlanStatusSchema = external_exports.enum([
   "executing",
   "completed"
 ]);
-var CodemapEmbeddingProviderSchema = external_exports.enum(["openai", "ollama", "ulpi"]);
-var CodemapEmbeddingConfigSchema = external_exports.object({
-  provider: CodemapEmbeddingProviderSchema.default("ulpi"),
+var EmbeddingProviderSchema = external_exports.enum(["openai", "ollama", "ulpi"]);
+var EmbeddingConfigSchema = external_exports.object({
+  provider: EmbeddingProviderSchema.default("ulpi"),
   model: external_exports.string().max(100).default("code"),
   dimensions: external_exports.number().int().positive().max(4096).default(1024),
   baseUrl: external_exports.string().url().max(200).optional()
@@ -175,13 +175,15 @@ var CodemapHybridConfigSchema = external_exports.object({
   weights: CodemapHybridWeightsSchema.default({})
 });
 var CodemapConfigSchema = external_exports.object({
-  embedding: CodemapEmbeddingConfigSchema.default({}),
+  embedding: EmbeddingConfigSchema.default({}),
   chunking: CodemapChunkingConfigSchema.default({}),
   batch: CodemapBatchConfigSchema.default({}),
   hybrid: CodemapHybridConfigSchema.default({}),
   deny: external_exports.array(external_exports.string().max(500)).max(200).default(["**/.env*", "**/secrets/**", "**/certs/**"]),
   maxFileSize: external_exports.number().int().positive().default(1048576),
   // 1MB
+  searchTimeoutMs: external_exports.number().int().positive().default(15e3),
+  // Search embed timeout
   autoExport: external_exports.boolean().default(true),
   // Export to shadow branch on push / session-end
   autoImport: external_exports.boolean().default(true)
@@ -256,12 +258,6 @@ var MemoryEntrySchema = external_exports.object({
   lastAccessedAt: external_exports.string().optional(),
   supersededBy: external_exports.string().max(64).optional()
 });
-var MemoryEmbeddingConfigSchema = external_exports.object({
-  provider: external_exports.enum(["openai", "ollama", "ulpi"]).default("ulpi"),
-  model: external_exports.string().max(100).default("code"),
-  dimensions: external_exports.number().int().positive().max(4096).default(1024),
-  baseUrl: external_exports.string().url().max(200).optional()
-});
 var MemoryClassifierConfigSchema = external_exports.object({
   enabled: external_exports.boolean().default(true),
   model: external_exports.string().max(100).default("claude-sonnet-4-20250514"),
@@ -294,7 +290,7 @@ var MemoryConfigSchema = external_exports.object({
   captureMode: CaptureModeSchema.default("continuous"),
   surfaceOnStart: external_exports.boolean().default(true),
   surfaceLimit: external_exports.number().int().positive().max(20).default(5),
-  embedding: MemoryEmbeddingConfigSchema.default({}),
+  embedding: EmbeddingConfigSchema.default({ model: "memory" }),
   classifier: MemoryClassifierConfigSchema.default({}),
   retention: MemoryRetentionConfigSchema.default({}),
   ranking: MemoryRankingConfigSchema.default({}),
@@ -328,6 +324,159 @@ var DepgraphConfigSchema = external_exports.object({
   excludeUnranked: external_exports.boolean().default(false),
   excludeUnrankedThreshold: external_exports.number().nonnegative().default(1e-4)
 });
+var TrackerTaskStatusSchema = external_exports.enum([
+  "open",
+  "in_progress",
+  "done",
+  "failed",
+  "skipped"
+]);
+var TaskPrioritySchema = external_exports.union([
+  external_exports.literal(0),
+  external_exports.literal(1),
+  external_exports.literal(2),
+  external_exports.literal(3),
+  external_exports.literal(4)
+]);
+var TrackerTaskSchema = external_exports.object({
+  id: external_exports.string(),
+  title: external_exports.string(),
+  status: TrackerTaskStatusSchema,
+  priority: TaskPrioritySchema,
+  description: external_exports.string().optional(),
+  labels: external_exports.array(external_exports.string()).optional(),
+  type: external_exports.string().optional(),
+  parentId: external_exports.string().optional(),
+  dependsOn: external_exports.array(external_exports.string()).optional(),
+  blocks: external_exports.array(external_exports.string()).optional(),
+  assignee: external_exports.string().optional(),
+  createdAt: external_exports.string().optional(),
+  updatedAt: external_exports.string().optional(),
+  metadata: external_exports.record(external_exports.unknown()).optional()
+});
+var TaskFilterSchema = external_exports.object({
+  status: external_exports.union([TrackerTaskStatusSchema, external_exports.array(TrackerTaskStatusSchema)]).optional(),
+  priority: external_exports.union([TaskPrioritySchema, external_exports.array(TaskPrioritySchema)]).optional(),
+  labels: external_exports.array(external_exports.string()).optional(),
+  assignee: external_exports.string().optional(),
+  type: external_exports.union([external_exports.string(), external_exports.array(external_exports.string())]).optional(),
+  parentId: external_exports.string().optional(),
+  ready: external_exports.boolean().optional(),
+  limit: external_exports.number().int().positive().optional(),
+  offset: external_exports.number().int().nonnegative().optional(),
+  excludeIds: external_exports.array(external_exports.string()).optional()
+});
+var TaskCompletionResultSchema = external_exports.object({
+  taskId: external_exports.string(),
+  status: TrackerTaskStatusSchema,
+  summary: external_exports.string(),
+  filesChanged: external_exports.array(external_exports.string()).optional(),
+  commitSha: external_exports.string().optional()
+});
+var AgentPluginMetaSchema = external_exports.object({
+  name: external_exports.string(),
+  version: external_exports.string(),
+  description: external_exports.string(),
+  cliCommand: external_exports.string(),
+  supportsHooks: external_exports.boolean(),
+  supportsSkills: external_exports.boolean(),
+  supportsStreaming: external_exports.boolean(),
+  supportsSubagentTracing: external_exports.boolean()
+});
+var ExecuteOptionsSchema = external_exports.object({
+  prompt: external_exports.string(),
+  workingDir: external_exports.string(),
+  timeout: external_exports.number().positive().optional(),
+  env: external_exports.record(external_exports.string()).optional(),
+  sandboxConfig: external_exports.record(external_exports.unknown()).optional()
+});
+var ExecuteResultSchema = external_exports.object({
+  exitCode: external_exports.number(),
+  stdout: external_exports.string(),
+  stderr: external_exports.string(),
+  duration: external_exports.number(),
+  tokenUsage: external_exports.object({
+    input: external_exports.number().optional(),
+    output: external_exports.number().optional()
+  }).optional()
+});
+var TrackerPluginMetaSchema = external_exports.object({
+  id: external_exports.string(),
+  name: external_exports.string(),
+  description: external_exports.string(),
+  version: external_exports.string(),
+  supportsBidirectionalSync: external_exports.boolean(),
+  supportsHierarchy: external_exports.boolean(),
+  supportsDependencies: external_exports.boolean()
+});
+var SyncResultSchema = external_exports.object({
+  success: external_exports.boolean(),
+  message: external_exports.string(),
+  added: external_exports.number().optional(),
+  updated: external_exports.number().optional(),
+  removed: external_exports.number().optional(),
+  error: external_exports.string().optional(),
+  syncedAt: external_exports.string()
+});
+var McpConfigFieldSchema = external_exports.object({
+  type: external_exports.enum(["string", "number", "boolean"]).default("string"),
+  format: external_exports.enum(["env-ref", "plain"]).optional(),
+  required: external_exports.boolean().default(false),
+  sensitive: external_exports.boolean().default(false),
+  description: external_exports.string().optional(),
+  default: external_exports.union([external_exports.string(), external_exports.number(), external_exports.boolean()]).optional()
+});
+var McpTransportSchema = external_exports.enum(["stdio", "sse", "http"]).default("stdio");
+var McpCategorySchema = external_exports.enum([
+  "database",
+  "api",
+  "devtools",
+  "comms",
+  "analytics",
+  "cloud",
+  "ai",
+  "search",
+  "monitoring",
+  "project-management",
+  "design",
+  "custom"
+]).default("custom");
+var McpSourceSchema = external_exports.enum(["catalog", "manual"]).default("manual");
+var McpDetectSignalsSchema = external_exports.object({
+  dependencies: external_exports.array(external_exports.string()).default([]),
+  env_vars: external_exports.array(external_exports.string()).default([]),
+  docker_services: external_exports.array(external_exports.string()).default([]),
+  config_files: external_exports.array(external_exports.string()).default([])
+}).partial();
+var McpDefinitionSchema = external_exports.object({
+  name: external_exports.string().min(1).max(128),
+  display_name: external_exports.string().max(256).optional(),
+  description: external_exports.string().max(1024).optional(),
+  command: external_exports.string().min(1).max(256),
+  args: external_exports.array(external_exports.string()).default([]),
+  transport: McpTransportSchema,
+  category: McpCategorySchema,
+  config_schema: external_exports.record(external_exports.string(), McpConfigFieldSchema).optional(),
+  tags: external_exports.array(external_exports.string()).default([]),
+  source: McpSourceSchema,
+  added_at: external_exports.string().optional()
+});
+var McpLibrarySchema = external_exports.object({
+  mcps: external_exports.record(external_exports.string(), McpDefinitionSchema).default({})
+});
+var McpActivationSchema = external_exports.object({
+  enabled: external_exports.boolean().default(true),
+  config: external_exports.record(external_exports.string(), external_exports.union([external_exports.string(), external_exports.number(), external_exports.boolean()])).default({})
+});
+var McpRepoConfigSchema = external_exports.object({
+  mcps: external_exports.record(external_exports.string(), McpActivationSchema).default({})
+});
+var McpCatalogEntrySchema = McpDefinitionSchema.extend({
+  detect_signals: McpDetectSignalsSchema.optional()
+});
+var McpCatalogSchema = external_exports.object({
+  catalog: external_exports.array(McpCatalogEntrySchema).default([])
+});
 
 export {
   BlockTypeSchema,
@@ -349,8 +498,8 @@ export {
   ReviewDecisionSchema,
   RepoInfoSchema,
   PlanStatusSchema,
-  CodemapEmbeddingProviderSchema,
-  CodemapEmbeddingConfigSchema,
+  EmbeddingProviderSchema,
+  EmbeddingConfigSchema,
   CodemapChunkingStrategySchema,
   CodemapChunkingConfigSchema,
   CodemapBatchConfigSchema,
@@ -363,7 +512,6 @@ export {
   CaptureModeSchema,
   MemorySourceSchema,
   MemoryEntrySchema,
-  MemoryEmbeddingConfigSchema,
   MemoryClassifierConfigSchema,
   MemoryRetentionConfigSchema,
   MemoryRankingConfigSchema,
@@ -371,5 +519,26 @@ export {
   ClassificationResultSchema,
   DepgraphPersonalizationConfigSchema,
   DepgraphPagerankConfigSchema,
-  DepgraphConfigSchema
+  DepgraphConfigSchema,
+  TrackerTaskStatusSchema,
+  TaskPrioritySchema,
+  TrackerTaskSchema,
+  TaskFilterSchema,
+  TaskCompletionResultSchema,
+  AgentPluginMetaSchema,
+  ExecuteOptionsSchema,
+  ExecuteResultSchema,
+  TrackerPluginMetaSchema,
+  SyncResultSchema,
+  McpConfigFieldSchema,
+  McpTransportSchema,
+  McpCategorySchema,
+  McpSourceSchema,
+  McpDetectSignalsSchema,
+  McpDefinitionSchema,
+  McpLibrarySchema,
+  McpActivationSchema,
+  McpRepoConfigSchema,
+  McpCatalogEntrySchema,
+  McpCatalogSchema
 };

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
+};