@ulpi/cli 0.1.0

package/dist/chunk-74WVVWJ4.js

@@ -0,0 +1,375 @@
+import {
+  external_exports
+} from "./chunk-KIKPIH6N.js";
+
+// ../../packages/contracts/dist/index.js
+var BlockTypeSchema = external_exports.enum([
+  "heading",
+  "paragraph",
+  "code",
+  "list-item",
+  "blockquote",
+  "table",
+  "hr"
+]);
+var BlockSchema = external_exports.object({
+  id: external_exports.string().max(200),
+  type: BlockTypeSchema,
+  content: external_exports.string().max(1e5),
+  level: external_exports.number().optional(),
+  language: external_exports.string().max(100).optional(),
+  checked: external_exports.boolean().optional(),
+  order: external_exports.number().int(),
+  startLine: external_exports.number().int()
+});
+var SectionStatusSchema = external_exports.enum([
+  "pending",
+  "in_progress",
+  "completed",
+  "skipped"
+]);
+var PlanSectionSchema = external_exports.object({
+  id: external_exports.string().max(200),
+  blockIds: external_exports.array(external_exports.string().max(200)),
+  title: external_exports.string().max(1e3),
+  level: external_exports.number().int().min(0).max(6),
+  path: external_exports.string().max(2e3),
+  status: SectionStatusSchema,
+  order: external_exports.number().int()
+});
+var PriorityLevelSchema = external_exports.enum([
+  "must-have",
+  "should-have",
+  "nice-to-have",
+  "out-of-scope"
+]);
+var SectionPrioritySchema = external_exports.object({
+  sectionId: external_exports.string().max(200),
+  priority: PriorityLevelSchema,
+  note: external_exports.string().max(5e3).optional()
+});
+var RiskLevelSchema = external_exports.enum(["low", "medium", "high"]);
+var SectionRiskSchema = external_exports.object({
+  sectionId: external_exports.string().max(200),
+  level: RiskLevelSchema,
+  description: external_exports.string().max(1e4)
+});
+var SectionInstructionSchema = external_exports.object({
+  id: external_exports.string().max(200),
+  sectionId: external_exports.string().max(200),
+  instruction: external_exports.string().max(1e4),
+  priority: external_exports.enum(["must", "should", "nice-to-have"]).optional(),
+  createdAt: external_exports.number(),
+  author: external_exports.string().max(200).optional()
+});
+var AnnotationTypeSchema = external_exports.enum([
+  "comment",
+  "suggestion",
+  "concern",
+  "question",
+  "approval",
+  "instruction",
+  "global_comment"
+]);
+var ReviewAnnotationSchema = external_exports.object({
+  id: external_exports.string().max(200),
+  type: AnnotationTypeSchema,
+  blockId: external_exports.string().max(200),
+  sectionId: external_exports.string().max(200).optional(),
+  startOffset: external_exports.number().optional(),
+  endOffset: external_exports.number().optional(),
+  originalText: external_exports.string().max(5e4),
+  text: external_exports.string().max(5e4),
+  author: external_exports.string().max(200).optional(),
+  authorColor: external_exports.string().max(50).optional(),
+  resolved: external_exports.boolean().optional(),
+  createdAt: external_exports.number(),
+  imagePaths: external_exports.array(external_exports.string().max(500)).optional()
+});
+var ANNOTATION_TYPE_LABELS = {
+  comment: "Comment",
+  suggestion: "Suggestion",
+  concern: "Concern",
+  question: "Question",
+  approval: "Approved",
+  instruction: "Instruction",
+  global_comment: "Global Comment"
+};
+var ANNOTATION_TYPE_FEEDBACK_PREFIX = {
+  comment: "COMMENT",
+  suggestion: "SUGGESTION",
+  concern: "CONCERN",
+  question: "QUESTION",
+  approval: "APPROVAL",
+  instruction: "INSTRUCTION",
+  global_comment: "GLOBAL"
+};
+var DiffChunkTypeSchema = external_exports.enum(["equal", "insert", "delete"]);
+var DiffChunkSchema = external_exports.object({
+  type: DiffChunkTypeSchema,
+  value: external_exports.string().max(5e5)
+});
+var InlineEditSchema = external_exports.object({
+  id: external_exports.string().max(200),
+  blockId: external_exports.string().max(200),
+  sectionId: external_exports.string().max(200).optional(),
+  originalContent: external_exports.string().max(1e5),
+  editedContent: external_exports.string().max(1e5),
+  characterDiff: external_exports.array(DiffChunkSchema),
+  author: external_exports.string().max(200).optional(),
+  createdAt: external_exports.number()
+});
+var ReviewDecisionSchema = external_exports.object({
+  behavior: external_exports.enum(["allow", "deny"]),
+  message: external_exports.string().max(1e4).optional(),
+  decidedAt: external_exports.number()
+});
+var RepoInfoSchema = external_exports.object({
+  remote: external_exports.string().max(2e3).optional(),
+  branch: external_exports.string().max(500).optional(),
+  display: external_exports.string().max(500).optional()
+});
+var PlanStatusSchema = external_exports.enum([
+  "reviewing",
+  "approved",
+  "denied",
+  "executing",
+  "completed"
+]);
+var CodemapEmbeddingProviderSchema = external_exports.enum(["openai", "ollama", "ulpi"]);
+var CodemapEmbeddingConfigSchema = external_exports.object({
+  provider: CodemapEmbeddingProviderSchema.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 CodemapChunkingStrategySchema = external_exports.enum(["sliding-window", "ast"]);
+var CodemapChunkingConfigSchema = external_exports.object({
+  strategy: CodemapChunkingStrategySchema.default("ast"),
+  windowSize: external_exports.number().int().positive().max(500).default(60),
+  overlap: external_exports.number().int().nonnegative().max(100).default(10),
+  maxChunkSize: external_exports.number().int().positive().max(1e3).default(300),
+  minChunkSize: external_exports.number().int().positive().max(50).default(5),
+  contextLines: external_exports.number().int().nonnegative().max(20).default(3),
+  version: external_exports.number().int().positive().default(2)
+});
+var CodemapBatchConfigSchema = external_exports.object({
+  size: external_exports.number().int().positive().max(1e4).default(1e4),
+  debounceMs: external_exports.number().int().nonnegative().max(3e4).default(500),
+  timeoutMs: external_exports.number().int().nonnegative().max(36e5).default(6e5),
+  // 0 = no timeout
+  pollIntervalMs: external_exports.number().int().positive().max(6e4).default(2e3)
+  // 2s
+});
+var CodemapHybridWeightsSchema = external_exports.object({
+  vector: external_exports.number().min(0).max(1).default(0.6),
+  bm25: external_exports.number().min(0).max(1).default(0.25),
+  symbolBoost: external_exports.number().min(0).max(1).default(0.1),
+  pathBoost: external_exports.number().min(0).max(1).default(0.05),
+  graphRank: external_exports.number().min(0).max(1).default(0)
+});
+var CodemapHybridConfigSchema = external_exports.object({
+  enabled: external_exports.boolean().default(true),
+  vectorK: external_exports.number().int().positive().max(200).default(30),
+  bm25K: external_exports.number().int().positive().max(200).default(30),
+  weights: CodemapHybridWeightsSchema.default({})
+});
+var CodemapConfigSchema = external_exports.object({
+  embedding: CodemapEmbeddingConfigSchema.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
+  autoExport: external_exports.boolean().default(true),
+  // Export to shadow branch on push / session-end
+  autoImport: external_exports.boolean().default(true)
+  // Import from shadow branch on session-start
+});
+var CodemapSymbolTypeSchema = external_exports.enum([
+  "function",
+  "class",
+  "method",
+  "interface",
+  "type",
+  "const",
+  "variable",
+  "enum",
+  "unknown"
+]);
+var MemoryTypeSchema = external_exports.enum([
+  "DECISION",
+  // Architecture/design decisions with rationale
+  "PATTERN",
+  // Code patterns adopted or enforced
+  "BUG_ROOT_CAUSE",
+  // Root causes of bugs discovered
+  "PREFERENCE",
+  // User preferences (style, tools, workflow)
+  "CONSTRAINT",
+  // Project constraints (perf budgets, compat)
+  "CONTEXT",
+  // Domain knowledge, terminology, relationships
+  "LESSON",
+  // Lessons learned from mistakes
+  "RELATIONSHIP"
+  // Inter-component relationships
+]);
+var MemoryImportanceSchema = external_exports.enum([
+  "critical",
+  // Never decay, always surface
+  "high",
+  // Slow decay
+  "medium",
+  // Moderate decay
+  "low"
+  // Fast decay
+]);
+var CaptureModeSchema = external_exports.enum([
+  "continuous",
+  // Append events via post-tool hook during session
+  "end_of_session"
+  // Bulk-capture from session-engine JSONL at session-end
+]);
+var MemorySourceSchema = external_exports.object({
+  type: external_exports.enum(["explicit", "classifier", "import"]),
+  sessionId: external_exports.string().max(200).optional(),
+  author: external_exports.string().max(100).optional()
+});
+var MemoryEntrySchema = external_exports.object({
+  id: external_exports.string().max(64),
+  // SHA-256 hash of type + content
+  type: MemoryTypeSchema,
+  summary: external_exports.string().max(2e3),
+  // The memory text
+  detail: external_exports.string().max(1e4).nullable().default(null),
+  importance: MemoryImportanceSchema.default("medium"),
+  tags: external_exports.array(external_exports.string().max(50)).max(20).default([]),
+  relatedFiles: external_exports.array(external_exports.string().max(500)).max(50).default([]),
+  source: MemorySourceSchema,
+  createdAt: external_exports.string(),
+  // ISO timestamp
+  updatedAt: external_exports.string(),
+  // ISO timestamp (for reinforcement)
+  accessCount: external_exports.number().int().nonnegative().default(0),
+  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"),
+  windowSize: external_exports.number().int().positive().max(200).default(50),
+  windowOverlap: external_exports.number().int().nonnegative().max(50).default(10),
+  maxTranscriptChars: external_exports.number().int().positive().default(1e4),
+  timeout: external_exports.number().int().positive().default(12e4),
+  includeTranscript: external_exports.boolean().default(true),
+  maxSinglePromptEvents: external_exports.number().int().positive().max(500).default(100),
+  minSignificantEvents: external_exports.number().int().nonnegative().max(50).default(5),
+  filterNoiseEvents: external_exports.boolean().default(true)
+});
+var MemoryRetentionConfigSchema = external_exports.object({
+  maxMemories: external_exports.number().int().positive().max(1e4).default(5e3),
+  maxAgeDays: external_exports.number().int().positive().default(365),
+  deduplicationThreshold: external_exports.number().min(0).max(1).default(0.92)
+});
+var MemoryRankingConfigSchema = external_exports.object({
+  importanceWeights: external_exports.object({
+    critical: external_exports.number().min(0).max(1).default(1),
+    high: external_exports.number().min(0).max(1).default(0.8),
+    medium: external_exports.number().min(0).max(1).default(0.6),
+    low: external_exports.number().min(0).max(1).default(0.4)
+  }).default({}),
+  accessBoostPerHit: external_exports.number().min(0).max(0.1).default(0.05),
+  accessBoostCap: external_exports.number().min(0).max(1).default(0.2)
+});
+var MemoryConfigSchema = external_exports.object({
+  enabled: external_exports.boolean().default(false),
+  captureMode: CaptureModeSchema.default("continuous"),
+  surfaceOnStart: external_exports.boolean().default(true),
+  surfaceLimit: external_exports.number().int().positive().max(20).default(5),
+  embedding: MemoryEmbeddingConfigSchema.default({}),
+  classifier: MemoryClassifierConfigSchema.default({}),
+  retention: MemoryRetentionConfigSchema.default({}),
+  ranking: MemoryRankingConfigSchema.default({}),
+  redactPatterns: external_exports.array(external_exports.string().max(500)).max(50).default([]),
+  autoExport: external_exports.boolean().default(false)
+});
+var ClassificationResultSchema = external_exports.object({
+  memories: external_exports.array(external_exports.object({
+    type: MemoryTypeSchema,
+    summary: external_exports.string().max(2e3),
+    detail: external_exports.string().max(1e4).optional(),
+    importance: MemoryImportanceSchema.default("medium"),
+    tags: external_exports.array(external_exports.string().max(50)).max(20).default([]),
+    relatedFiles: external_exports.array(external_exports.string().max(500)).max(50).default([])
+  })).max(20)
+});
+var DepgraphPersonalizationConfigSchema = external_exports.object({
+  activeFileBoost: external_exports.number().positive().default(100),
+  mentionedFileBoost: external_exports.number().positive().default(5),
+  mentionedIdentifierBoost: external_exports.number().positive().default(10)
+});
+var DepgraphPagerankConfigSchema = external_exports.object({
+  dampingFactor: external_exports.number().min(0).max(1).default(0.85),
+  maxIterations: external_exports.number().int().positive().max(1e4).default(100),
+  convergenceThreshold: external_exports.number().positive().default(1e-6)
+});
+var DepgraphConfigSchema = external_exports.object({
+  enabled: external_exports.boolean().default(true),
+  personalization: DepgraphPersonalizationConfigSchema.default({}),
+  pagerank: DepgraphPagerankConfigSchema.default({}),
+  excludeUnranked: external_exports.boolean().default(false),
+  excludeUnrankedThreshold: external_exports.number().nonnegative().default(1e-4)
+});
+
+export {
+  BlockTypeSchema,
+  BlockSchema,
+  SectionStatusSchema,
+  PlanSectionSchema,
+  PriorityLevelSchema,
+  SectionPrioritySchema,
+  RiskLevelSchema,
+  SectionRiskSchema,
+  SectionInstructionSchema,
+  AnnotationTypeSchema,
+  ReviewAnnotationSchema,
+  ANNOTATION_TYPE_LABELS,
+  ANNOTATION_TYPE_FEEDBACK_PREFIX,
+  DiffChunkTypeSchema,
+  DiffChunkSchema,
+  InlineEditSchema,
+  ReviewDecisionSchema,
+  RepoInfoSchema,
+  PlanStatusSchema,
+  CodemapEmbeddingProviderSchema,
+  CodemapEmbeddingConfigSchema,
+  CodemapChunkingStrategySchema,
+  CodemapChunkingConfigSchema,
+  CodemapBatchConfigSchema,
+  CodemapHybridWeightsSchema,
+  CodemapHybridConfigSchema,
+  CodemapConfigSchema,
+  CodemapSymbolTypeSchema,
+  MemoryTypeSchema,
+  MemoryImportanceSchema,
+  CaptureModeSchema,
+  MemorySourceSchema,
+  MemoryEntrySchema,
+  MemoryEmbeddingConfigSchema,
+  MemoryClassifierConfigSchema,
+  MemoryRetentionConfigSchema,
+  MemoryRankingConfigSchema,
+  MemoryConfigSchema,
+  ClassificationResultSchema,
+  DepgraphPersonalizationConfigSchema,
+  DepgraphPagerankConfigSchema,
+  DepgraphConfigSchema
+};

package/dist/chunk-7AL4DOEJ.js

@@ -0,0 +1,131 @@
+import {
+  getApiSecret
+} from "./chunk-MIAQVCFW.js";
+import {
+  getProject
+} from "./chunk-SPOI23SB.js";
+import {
+  JsonSessionStore,
+  readEvents
+} from "./chunk-YM2HV4IA.js";
+import {
+  getApiHost
+} from "./chunk-7LXY5UVC.js";
+
+// ../api/dist/chunk-F3LN44RE.js
+import { WebSocketServer } from "ws";
+function attachWebSocket(server, defaultProjectDir) {
+  const wss = new WebSocketServer({
+    server,
+    path: "/ws",
+    verifyClient: ({ req }, cb) => {
+      const remoteAddr = req.socket.remoteAddress ?? "";
+      const isLoopback = remoteAddr === "127.0.0.1" || remoteAddr === "::1" || remoteAddr === "::ffff:127.0.0.1";
+      if (!isLoopback) {
+        cb(false, 403, "Forbidden: only local connections allowed");
+        return;
+      }
+      const secret = getApiSecret();
+      if (secret) {
+        try {
+          const wsUrl = new URL(req.url ?? "/", `http://${req.headers.host}`);
+          const reqSecret = wsUrl.searchParams.get("secret");
+          if (reqSecret !== secret) {
+            cb(false, 403, "Forbidden: invalid API secret");
+            return;
+          }
+        } catch {
+          cb(false, 403, "Forbidden: invalid request URL");
+          return;
+        }
+      }
+      const origin = req.headers.origin;
+      if (origin) {
+        let originHostname;
+        let originProtocol;
+        try {
+          const parsed = new URL(origin);
+          originHostname = parsed.hostname;
+          originProtocol = parsed.protocol;
+        } catch {
+          cb(false, 403, "Forbidden: malformed origin");
+          return;
+        }
+        if (originProtocol !== "http:") {
+          cb(false, 403, "Forbidden: origin not allowed");
+          return;
+        }
+        const allowedHostnames = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", getApiHost()]);
+        if (!allowedHostnames.has(originHostname)) {
+          cb(false, 403, "Forbidden: origin not allowed");
+          return;
+        }
+      }
+      cb(true);
+    }
+  });
+  wss.on("connection", (ws, req) => {
+    let lastSessionJson = "";
+    let lastEventCount = 0;
+    let lastSessionId = "";
+    let projectDir = defaultProjectDir;
+    let pinnedSessionId = null;
+    if (req.url) {
+      try {
+        const url = new URL(req.url, `http://${req.headers.host}`);
+        const projectParam = url.searchParams.get("project");
+        if (projectParam) {
+          const entry = getProject(projectParam);
+          if (entry) {
+            projectDir = entry.path;
+          }
+        }
+        pinnedSessionId = url.searchParams.get("session");
+      } catch {
+      }
+    }
+    const store = new JsonSessionStore(void 0, projectDir);
+    const poll = setInterval(() => {
+      try {
+        let state;
+        if (pinnedSessionId) {
+          state = store.load(pinnedSessionId);
+        } else {
+          state = store.getLatestForProject(projectDir);
+        }
+        if (!state) return;
+        const currentSessionId = state.sessionId;
+        if (currentSessionId !== lastSessionId) {
+          lastSessionId = currentSessionId;
+          lastEventCount = 0;
+          lastSessionJson = "";
+        }
+        const stateJson = JSON.stringify(state);
+        if (stateJson !== lastSessionJson) {
+          lastSessionJson = stateJson;
+          ws.send(JSON.stringify({ type: "session-update", data: state }));
+        }
+        const events = readEvents(currentSessionId, projectDir);
+        if (events.length > lastEventCount) {
+          const newEvents = events.slice(lastEventCount);
+          for (const event of newEvents) {
+            ws.send(JSON.stringify({ type: "event", data: event }));
+          }
+          lastEventCount = events.length;
+        }
+      } catch {
+      }
+    }, 2e3);
+    ws.on("close", () => {
+      clearInterval(poll);
+    });
+    ws.on("error", () => {
+      clearInterval(poll);
+    });
+  });
+  return wss;
+}
+
+export {
+  attachWebSocket
+};