@lumenflow/cli 3.12.6 → 3.12.8

package/dist/chunk-ADN5NHG4.js

@@ -1,126 +0,0 @@
-import {
-  MEMORY_PATTERNS,
-  loadMemory
-} from "./chunk-DFR4DJBM.js";
-import {
-  LUMENFLOW_MEMORY_PATHS
-} from "./chunk-4N74J3UT.js";
-import {
-  ErrorCodes,
-  createError
-} from "./chunk-RXRKBBSM.js";
-
-// ../memory/dist/mem-ready-core.js
-import fs from "fs/promises";
-import path from "path";
-var RELATIONSHIPS_FILE_NAME = "relationships.jsonl";
-var PRIORITY_RANK = {
-  P0: 0,
-  P1: 1,
-  P2: 2,
-  P3: 3
-};
-var DEFAULT_PRIORITY_RANK = 999;
-function getPriorityRank(node) {
-  const priority = node.metadata?.priority;
-  if (!priority) {
-    return DEFAULT_PRIORITY_RANK;
-  }
-  return PRIORITY_RANK[priority] ?? DEFAULT_PRIORITY_RANK;
-}
-function compareNodes(a, b) {
-  const priorityDiff = getPriorityRank(a) - getPriorityRank(b);
-  if (priorityDiff !== 0) {
-    return priorityDiff;
-  }
-  const aTime = new Date(a.created_at).getTime();
-  const bTime = new Date(b.created_at).getTime();
-  if (aTime !== bTime) {
-    return aTime - bTime;
-  }
-  return a.id.localeCompare(b.id);
-}
-async function loadRelationships(memoryDir) {
-  const filePath = path.join(memoryDir, RELATIONSHIPS_FILE_NAME);
-  try {
-    const content = await fs.readFile(filePath, { encoding: "utf-8" });
-    const lines = content.split("\n");
-    const relationships = [];
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed)
-        continue;
-      try {
-        relationships.push(JSON.parse(trimmed));
-      } catch {
-        continue;
-      }
-    }
-    return relationships;
-  } catch (err) {
-    const error = err;
-    if (error.code === "ENOENT") {
-      return [];
-    }
-    throw error;
-  }
-}
-function buildBlockedSet(relationships) {
-  const blocked = /* @__PURE__ */ new Set();
-  for (const rel of relationships) {
-    if (rel.type === "blocks") {
-      blocked.add(rel.to_id);
-    }
-  }
-  return blocked;
-}
-function isBlocked(node, blockedByRelationships) {
-  if (blockedByRelationships.has(node.id)) {
-    return true;
-  }
-  const blockedBy = node.metadata?.blocked_by;
-  if (Array.isArray(blockedBy) && blockedBy.length > 0) {
-    return true;
-  }
-  return false;
-}
-function isClosed(node) {
-  if (node.lifecycle === "ephemeral") {
-    return true;
-  }
-  if (node.metadata?.status === "closed") {
-    return true;
-  }
-  return false;
-}
-function validateWuId(wuId) {
-  if (!MEMORY_PATTERNS.WU_ID.test(wuId)) {
-    throw createError(ErrorCodes.INVALID_WU_ID, `Invalid WU ID format: ${wuId}. Expected format: WU-XXX (e.g., WU-1234)`);
-  }
-}
-async function queryReadyNodes(baseDir, options) {
-  const { wuId, type } = options;
-  validateWuId(wuId);
-  const memoryDir = path.join(baseDir, LUMENFLOW_MEMORY_PATHS.MEMORY_DIR);
-  const memory = await loadMemory(memoryDir);
-  const relationships = await loadRelationships(memoryDir);
-  const blockedByRelationships = buildBlockedSet(relationships);
-  const wuNodes = memory.byWu.get(wuId) ?? [];
-  const readyNodes = wuNodes.filter((node) => {
-    if (isBlocked(node, blockedByRelationships)) {
-      return false;
-    }
-    if (isClosed(node)) {
-      return false;
-    }
-    if (type && node.type !== type) {
-      return false;
-    }
-    return true;
-  });
-  return readyNodes.sort(compareNodes);
-}
-
-export {
-  queryReadyNodes
-};

package/dist/chunk-B7YJYJKG.js

@@ -1,33 +0,0 @@
-import {
-  CLAIMED_MODES
-} from "./chunk-V6OJGLBA.js";
-
-// src/wu-state-cloud.ts
-var BRANCH_PR_MODE = CLAIMED_MODES.BRANCH_PR;
-var BRANCH_ONLY_MODE = CLAIMED_MODES.BRANCH_ONLY;
-var WORKTREE_EDIT_MODE = "worktree";
-var BRANCH_PR_EDIT_MODE = "branch-pr";
-var BLOCKED_EDIT_MODE = "blocked";
-function shouldUseBranchPrStatePath(doc) {
-  return doc.claimed_mode === BRANCH_PR_MODE;
-}
-function resolveInProgressEditMode(claimedMode) {
-  if (claimedMode === BRANCH_PR_MODE) {
-    return BRANCH_PR_EDIT_MODE;
-  }
-  if (claimedMode === BRANCH_ONLY_MODE) {
-    return BLOCKED_EDIT_MODE;
-  }
-  return WORKTREE_EDIT_MODE;
-}
-function shouldUseBranchPrDeletePath(docs) {
-  return docs.some((doc) => shouldUseBranchPrStatePath(doc));
-}
-
-export {
-  BRANCH_PR_EDIT_MODE,
-  BLOCKED_EDIT_MODE,
-  shouldUseBranchPrStatePath,
-  resolveInProgressEditMode,
-  shouldUseBranchPrDeletePath
-};

package/dist/chunk-CCLHCPKG.js

@@ -1,210 +0,0 @@
-import {
-  ensureMemoryDir
-} from "./chunk-ND6MY37M.js";
-import {
-  generateMemId
-} from "./chunk-RIAAGL2E.js";
-import {
-  MEMORY_NODE_TYPES,
-  MEMORY_PATTERNS,
-  appendNode,
-  validateMemoryNode,
-  validateRelationship
-} from "./chunk-DFR4DJBM.js";
-import {
-  LUMENFLOW_MEMORY_PATHS
-} from "./chunk-4N74J3UT.js";
-import {
-  GIT_DIRECTORY_NAME,
-  GIT_WORKTREES_SENTINEL
-} from "./chunk-V6OJGLBA.js";
-import {
-  ErrorCodes,
-  createError
-} from "./chunk-RXRKBBSM.js";
-
-// ../memory/dist/mem-create-core.js
-import fs from "fs/promises";
-import path from "path";
-var RELATIONSHIPS_FILE_NAME = "relationships.jsonl";
-var DEFAULT_NODE_TYPE = "discovery";
-var TYPE_ALIASES = {
-  bug: { type: "discovery", tag: "bug" },
-  idea: { type: "discovery", tag: "idea" },
-  question: { type: "discovery", tag: "question" },
-  dependency: { type: "discovery", tag: "dependency" }
-};
-var LIFECYCLE_BY_TYPE = {
-  session: "wu",
-  discovery: "wu",
-  checkpoint: "session",
-  note: "session",
-  summary: "project"
-};
-var ERROR_MESSAGES = {
-  TITLE_REQUIRED: "title is required",
-  TITLE_EMPTY: "title cannot be empty",
-  INVALID_TYPE: `Invalid node type. Must be one of: ${MEMORY_NODE_TYPES.join(", ")}`,
-  WU_ID_INVALID: "Invalid WU ID format. Expected pattern: WU-XXX (e.g., WU-123)",
-  MEMORY_ID_INVALID: "Invalid memory ID format. Expected pattern: mem-XXXX (e.g., mem-a1b2)"
-};
-function normalizeType(inputType) {
-  const alias = TYPE_ALIASES[inputType];
-  if (alias) {
-    return { type: alias.type, aliasTag: alias.tag };
-  }
-  return { type: inputType, aliasTag: null };
-}
-async function getMainCheckoutFromWorktree(dir) {
-  const gitPath = path.join(dir, GIT_DIRECTORY_NAME);
-  try {
-    const stat = await fs.stat(gitPath);
-    if (stat.isFile()) {
-      const gitContent = await fs.readFile(gitPath, { encoding: "utf-8" });
-      const match = gitContent.match(/^gitdir:\s*(.+)/);
-      if (match && match[1]) {
-        const gitDir = match[1].trim();
-        const worktreesIndex = gitDir.indexOf(GIT_WORKTREES_SENTINEL);
-        if (worktreesIndex !== -1) {
-          return gitDir.substring(0, worktreesIndex);
-        }
-      }
-    }
-  } catch {
-  }
-  return null;
-}
-async function readCurrentSession(baseDir) {
-  const sessionPath = path.join(baseDir, LUMENFLOW_MEMORY_PATHS.SESSION_CURRENT);
-  try {
-    const content = await fs.readFile(sessionPath, { encoding: "utf-8" });
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-async function inferSessionFromSessionFile(baseDir) {
-  let session = await readCurrentSession(baseDir);
-  if (session) {
-    return session;
-  }
-  const mainCheckout = await getMainCheckoutFromWorktree(baseDir);
-  if (mainCheckout) {
-    session = await readCurrentSession(mainCheckout);
-    if (session) {
-      return session;
-    }
-  }
-  return null;
-}
-function isValidSessionId(value) {
-  if (!value)
-    return false;
-  if (typeof value !== "string")
-    return false;
-  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
-}
-function isValidWuId(wuId) {
-  if (!wuId)
-    return true;
-  return MEMORY_PATTERNS.WU_ID.test(wuId);
-}
-function isValidMemoryId(memId) {
-  return MEMORY_PATTERNS.MEMORY_ID.test(memId);
-}
-async function appendRelationship(memoryDir, relationship) {
-  const validation = validateRelationship(relationship);
-  if (!validation.success) {
-    const issues = validation.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
-    throw createError(ErrorCodes.VALIDATION_ERROR, `Relationship validation error: ${issues}`);
-  }
-  const filePath = path.join(memoryDir, RELATIONSHIPS_FILE_NAME);
-  const line = `${JSON.stringify(relationship)}
-`;
-  await fs.appendFile(filePath, line, { encoding: "utf-8" });
-  return relationship;
-}
-function getLifecycleForType(type) {
-  return LIFECYCLE_BY_TYPE[type];
-}
-async function createMemoryNode(baseDir, options) {
-  const { title, type: inputType = DEFAULT_NODE_TYPE, wuId: explicitWuId, sessionId: explicitSessionId, discoveredFrom, tags: inputTags, priority } = options;
-  if (title == null) {
-    throw createError(ErrorCodes.VALIDATION_ERROR, ERROR_MESSAGES.TITLE_REQUIRED);
-  }
-  if (title === "") {
-    throw createError(ErrorCodes.VALIDATION_ERROR, ERROR_MESSAGES.TITLE_EMPTY);
-  }
-  const { type: normalizedType, aliasTag } = normalizeType(inputType);
-  if (!MEMORY_NODE_TYPES.includes(normalizedType)) {
-    throw createError(ErrorCodes.VALIDATION_ERROR, ERROR_MESSAGES.INVALID_TYPE);
-  }
-  const type = normalizedType;
-  let tags = inputTags ? [...inputTags] : [];
-  if (aliasTag && !tags.includes(aliasTag)) {
-    tags = [aliasTag, ...tags];
-  }
-  tags = [...new Set(tags)];
-  const inferredSession = explicitWuId && explicitSessionId ? null : await inferSessionFromSessionFile(baseDir);
-  const wuId = explicitWuId || inferredSession?.wu_id;
-  const sessionId = explicitSessionId || (isValidSessionId(inferredSession?.session_id) ? inferredSession.session_id : void 0);
-  if (wuId && !isValidWuId(wuId)) {
-    throw createError(ErrorCodes.INVALID_WU_ID, ERROR_MESSAGES.WU_ID_INVALID);
-  }
-  if (discoveredFrom && !isValidMemoryId(discoveredFrom)) {
-    throw createError(ErrorCodes.VALIDATION_ERROR, ERROR_MESSAGES.MEMORY_ID_INVALID);
-  }
-  const memoryDir = await ensureMemoryDir(baseDir);
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const idContent = `${title}-${timestamp}`;
-  const id = generateMemId(idContent);
-  const lifecycle = getLifecycleForType(type);
-  const metadata = {};
-  if (priority) {
-    metadata.priority = priority;
-  }
-  const node = {
-    id,
-    type,
-    lifecycle,
-    content: title,
-    created_at: timestamp
-  };
-  if (wuId) {
-    node.wu_id = wuId;
-  }
-  if (sessionId) {
-    node.session_id = sessionId;
-  }
-  if (Object.keys(metadata).length > 0) {
-    node.metadata = metadata;
-  }
-  if (tags && tags.length > 0) {
-    node.tags = tags;
-  }
-  const nodeValidation = validateMemoryNode(node);
-  if (!nodeValidation.success) {
-    const issues = nodeValidation.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
-    throw createError(ErrorCodes.VALIDATION_ERROR, `Node validation error: ${issues}`);
-  }
-  await appendNode(memoryDir, node);
-  const result = {
-    success: true,
-    node
-  };
-  if (discoveredFrom) {
-    const relationship = {
-      from_id: node.id,
-      to_id: discoveredFrom,
-      type: "discovered_from",
-      created_at: timestamp
-    };
-    await appendRelationship(memoryDir, relationship);
-    result.relationship = relationship;
-  }
-  return result;
-}
-
-export {
-  createMemoryNode
-};