@lumenflow/cli 3.17.7 → 3.18.1

package/dist/chunk-ISZR5N4K.js

@@ -0,0 +1,60 @@
+import {
+  PROGRESSABLE_WU_STATUSES
+} from "./chunk-V6OJGLBA.js";
+
+// ../initiatives/dist/initiative-validation.js
+var PROGRESSABLE_STATUSES = ["draft", "open"];
+function validateInitiativeCompleteness(initiative) {
+  const warnings = [];
+  const id = initiative.id || "unknown";
+  if (!initiative.description || initiative.description.trim() === "") {
+    warnings.push(`[${id}] Initiative has no description. Add a description to explain its purpose.`);
+  }
+  if (!initiative.phases || initiative.phases.length === 0) {
+    warnings.push(`[${id}] Initiative has no phases defined. Add phases to break down the work.`);
+  }
+  if (!initiative.success_metrics || initiative.success_metrics.length === 0) {
+    warnings.push(`[${id}] Initiative has no success_metrics defined. Add metrics to measure completion.`);
+  }
+  return {
+    valid: true,
+    // Always valid - issues are warnings not errors
+    warnings
+  };
+}
+function checkInitiativePhases(initiative) {
+  const hasPhases = Array.isArray(initiative.phases) && initiative.phases.length > 0;
+  const id = initiative.id || "unknown";
+  return {
+    hasPhases,
+    warning: hasPhases ? null : `Initiative ${id} has no phases defined. Consider adding phases before linking WUs.`
+  };
+}
+function shouldProgressInitiativeStatus(initiative, wus) {
+  const currentStatus = initiative.status || "draft";
+  const initiativeId = initiative.id;
+  if (!PROGRESSABLE_STATUSES.includes(currentStatus)) {
+    return {
+      shouldProgress: false,
+      newStatus: null
+    };
+  }
+  const initiativeWUs = wus.filter((wu) => wu.initiative === initiativeId);
+  const hasActiveWU = initiativeWUs.some((wu) => PROGRESSABLE_WU_STATUSES.includes(wu.status || ""));
+  if (hasActiveWU) {
+    return {
+      shouldProgress: true,
+      newStatus: "in_progress"
+    };
+  }
+  return {
+    shouldProgress: false,
+    newStatus: null
+  };
+}
+
+export {
+  validateInitiativeCompleteness,
+  checkInitiativePhases,
+  shouldProgressInitiativeStatus
+};

package/dist/chunk-J6SUPR2C.js

@@ -0,0 +1,226 @@
+import {
+  appendNode,
+  loadMemory
+} from "./chunk-DFR4DJBM.js";
+import {
+  validateLaneFormat
+} from "./chunk-JONWQUB5.js";
+import {
+  LUMENFLOW_MEMORY_PATHS
+} from "./chunk-4N74J3UT.js";
+import {
+  createWuPaths
+} from "./chunk-6HO4GWJE.js";
+import {
+  ErrorCodes,
+  createError
+} from "./chunk-RXRKBBSM.js";
+
+// ../memory/dist/mem-triage-core.js
+import fs from "fs/promises";
+import path from "path";
+var RELATIONSHIPS_FILE_NAME = "relationships.jsonl";
+var DEFAULT_PRIORITY = "P2";
+var MAX_TITLE_LENGTH = 80;
+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) {
+  const status = node.metadata?.status;
+  if (status === "closed" || status === "archived") {
+    return true;
+  }
+  if (node.lifecycle === "ephemeral") {
+    return true;
+  }
+  return false;
+}
+async function listOpenDiscoveries(baseDir, options = {}) {
+  const memoryDir = path.join(baseDir, LUMENFLOW_MEMORY_PATHS.MEMORY_DIR);
+  const memory = await loadMemory(memoryDir);
+  const relationships = await loadRelationships(memoryDir);
+  const blockedByRelationships = buildBlockedSet(relationships);
+  let nodes = memory.nodes.filter((node) => node.type === "discovery");
+  nodes = nodes.filter((node) => !isBlocked(node, blockedByRelationships));
+  nodes = nodes.filter((node) => !isClosed(node));
+  if (options.wuId) {
+    if (options.wuId === "unlinked") {
+      nodes = nodes.filter((node) => !node.wu_id);
+    } else {
+      nodes = nodes.filter((node) => node.wu_id === options.wuId);
+    }
+  }
+  if (options.tag) {
+    const filterTag = options.tag;
+    nodes = nodes.filter((node) => node.tags?.includes(filterTag));
+  }
+  return nodes.sort(compareNodes);
+}
+async function archiveDiscovery(baseDir, options) {
+  const { nodeId, reason } = options;
+  const memoryDir = path.join(baseDir, LUMENFLOW_MEMORY_PATHS.MEMORY_DIR);
+  const memory = await loadMemory(memoryDir);
+  const node = memory.byId.get(nodeId);
+  if (!node) {
+    throw createError(ErrorCodes.NODE_NOT_FOUND, `Node not found: ${nodeId}`);
+  }
+  if (node.type !== "discovery") {
+    throw createError(ErrorCodes.VALIDATION_ERROR, `Node ${nodeId} is not a discovery (type: ${node.type})`);
+  }
+  if (node.metadata?.status === "archived" || node.metadata?.status === "closed") {
+    throw createError(ErrorCodes.ALREADY_EXISTS, `Node ${nodeId} is already archived/closed`);
+  }
+  const archivedNode = {
+    ...node,
+    metadata: {
+      ...node.metadata,
+      status: "archived",
+      archive_reason: reason,
+      archived_at: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+  await appendNode(memoryDir, archivedNode);
+  return {
+    success: true,
+    nodeId
+  };
+}
+async function getNextWuId(baseDir) {
+  const paths = createWuPaths({ projectRoot: baseDir });
+  const wuDir = path.join(baseDir, paths.WU_DIR());
+  let maxId = 0;
+  try {
+    const files = await fs.readdir(wuDir);
+    for (const file of files) {
+      const match = file.match(/^WU-(\d+)\.yaml$/);
+      if (match && match[1]) {
+        const id = parseInt(match[1], 10);
+        if (id > maxId) {
+          maxId = id;
+        }
+      }
+    }
+  } catch (err) {
+    const error = err;
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  return `WU-${maxId + 1}`;
+}
+function truncateToTitle(content) {
+  const parts = content.split(/[.!?]/);
+  const firstSentence = (parts[0] ?? "").trim();
+  if (firstSentence.length <= MAX_TITLE_LENGTH) {
+    return firstSentence;
+  }
+  return firstSentence.substring(0, MAX_TITLE_LENGTH - 3) + "...";
+}
+async function promoteDiscovery(baseDir, options) {
+  const { nodeId, lane, title, wuId, priority, dryRun: _dryRun = false } = options;
+  const memoryDir = path.join(baseDir, LUMENFLOW_MEMORY_PATHS.MEMORY_DIR);
+  try {
+    validateLaneFormat(lane);
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    throw createError(ErrorCodes.INVALID_LANE, `Invalid lane format: ${errMsg}`, { cause: err });
+  }
+  const memory = await loadMemory(memoryDir);
+  const node = memory.byId.get(nodeId);
+  if (!node) {
+    throw createError(ErrorCodes.NODE_NOT_FOUND, `Node not found: ${nodeId}`);
+  }
+  if (node.type !== "discovery") {
+    throw createError(ErrorCodes.VALIDATION_ERROR, `Node ${nodeId} is not a discovery (type: ${node.type})`);
+  }
+  if (node.metadata?.status === "archived" || node.metadata?.status === "closed") {
+    throw createError(ErrorCodes.ALREADY_EXISTS, `Node ${nodeId} is already archived/closed`);
+  }
+  const resolvedWuId = wuId || await getNextWuId(baseDir);
+  const resolvedTitle = title || truncateToTitle(node.content);
+  const resolvedPriority = priority || node.metadata?.priority || DEFAULT_PRIORITY;
+  const wuSpec = {
+    id: resolvedWuId,
+    title: resolvedTitle,
+    lane,
+    priority: resolvedPriority,
+    notes: `Promoted from discovery ${nodeId}`
+  };
+  return {
+    success: true,
+    wuSpec
+  };
+}
+
+export {
+  listOpenDiscoveries,
+  archiveDiscovery,
+  promoteDiscovery
+};

package/dist/chunk-JERYVEIZ.js

@@ -0,0 +1,244 @@
+import {
+  WU_LIFECYCLE_CLAIM_DEFAULTS,
+  WU_LIFECYCLE_COMMANDS,
+  WU_LIFECYCLE_EVENT_KINDS,
+  WU_LIFECYCLE_EVENT_SCHEMA_VERSION,
+  WU_LIFECYCLE_SPEC_HASH,
+  WU_LIFECYCLE_SYNC_CONFIG,
+  WU_LIFECYCLE_SYNC_LOG_PREFIX,
+  WU_LIFECYCLE_SYNC_RESULT_DEFAULTS,
+  WU_LIFECYCLE_SYNC_SKIPPED_REASONS
+} from "./chunk-EK2AKZKD.js";
+import {
+  CONFIG_FILES
+} from "./chunk-DWMLTXKQ.js";
+import {
+  ErrorCodes,
+  createError,
+  getErrorMessage
+} from "./chunk-RXRKBBSM.js";
+
+// src/wu-lifecycle-sync/service.ts
+import { createHash } from "crypto";
+import { readFileSync } from "fs";
+
+// src/wu-lifecycle-sync/control-plane-sink.ts
+import path from "path";
+import { readFile } from "fs/promises";
+import YAML from "yaml";
+
+// src/wu-lifecycle-sync/noop-sink.ts
+function createNoopSink(skippedReason) {
+  return {
+    async push() {
+      return {
+        sent: WU_LIFECYCLE_SYNC_RESULT_DEFAULTS.SENT,
+        accepted: WU_LIFECYCLE_SYNC_RESULT_DEFAULTS.ACCEPTED,
+        skippedReason
+      };
+    }
+  };
+}
+
+// src/wu-lifecycle-sync/control-plane-sink.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function asNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function createNoopSyncResult(skippedReason) {
+  return {
+    sent: WU_LIFECYCLE_SYNC_RESULT_DEFAULTS.SENT,
+    accepted: WU_LIFECYCLE_SYNC_RESULT_DEFAULTS.ACCEPTED,
+    skippedReason
+  };
+}
+function createParseInput(workspaceId, controlPlaneRaw) {
+  return {
+    [WU_LIFECYCLE_SYNC_CONFIG.WORKSPACE_ID_FIELD]: workspaceId,
+    [WU_LIFECYCLE_SYNC_CONFIG.CONTROL_PLANE_FIELD]: controlPlaneRaw
+  };
+}
+async function loadControlPlaneSdk(logger) {
+  try {
+    return await import("./dist-IY3UUMWK.js");
+  } catch (error) {
+    logger?.warn?.(
+      `${WU_LIFECYCLE_SYNC_LOG_PREFIX} control-plane SDK unavailable: ${getErrorMessage(error)}`
+    );
+    return null;
+  }
+}
+async function resolveWuLifecycleEventSink(options = {}) {
+  const workspaceRoot = options.workspaceRoot ?? process.cwd();
+  const workspacePath = path.join(workspaceRoot, CONFIG_FILES.WORKSPACE_CONFIG);
+  let workspaceContent;
+  try {
+    workspaceContent = await readFile(workspacePath, WU_LIFECYCLE_SYNC_CONFIG.TEXT_ENCODING_UTF8);
+  } catch {
+    return createNoopSink(WU_LIFECYCLE_SYNC_SKIPPED_REASONS.WORKSPACE_CONFIG_MISSING);
+  }
+  let parsedWorkspace;
+  try {
+    parsedWorkspace = YAML.parse(workspaceContent);
+  } catch {
+    return createNoopSink(WU_LIFECYCLE_SYNC_SKIPPED_REASONS.WORKSPACE_CONFIG_INVALID);
+  }
+  if (!isRecord(parsedWorkspace)) {
+    return createNoopSink(WU_LIFECYCLE_SYNC_SKIPPED_REASONS.WORKSPACE_CONFIG_INVALID);
+  }
+  const workspaceId = asNonEmptyString(
+    Reflect.get(parsedWorkspace, WU_LIFECYCLE_SYNC_CONFIG.WORKSPACE_ID_FIELD)
+  );
+  if (!workspaceId) {
+    return createNoopSink(WU_LIFECYCLE_SYNC_SKIPPED_REASONS.WORKSPACE_ID_MISSING);
+  }
+  const controlPlaneRaw = Reflect.get(
+    parsedWorkspace,
+    WU_LIFECYCLE_SYNC_CONFIG.CONTROL_PLANE_FIELD
+  );
+  if (!isRecord(controlPlaneRaw)) {
+    return createNoopSink(WU_LIFECYCLE_SYNC_SKIPPED_REASONS.CONTROL_PLANE_NOT_CONFIGURED);
+  }
+  const controlPlaneSdk = await loadControlPlaneSdk(options.logger);
+  if (!controlPlaneSdk) {
+    return createNoopSink(WU_LIFECYCLE_SYNC_SKIPPED_REASONS.CONTROL_PLANE_SDK_UNAVAILABLE);
+  }
+  const { parseWorkspaceControlPlaneConfig, createHttpControlPlaneSyncPort } = controlPlaneSdk;
+  let runtimeConfig;
+  try {
+    runtimeConfig = parseWorkspaceControlPlaneConfig(
+      createParseInput(workspaceId, controlPlaneRaw)
+    );
+  } catch {
+    return createNoopSink(WU_LIFECYCLE_SYNC_SKIPPED_REASONS.CONTROL_PLANE_INVALID);
+  }
+  const environment = options.environment ?? process.env;
+  const tokenEnv = runtimeConfig.control_plane.auth.token_env;
+  const token = asNonEmptyString(environment[tokenEnv]);
+  if (!token) {
+    return createNoopSink(WU_LIFECYCLE_SYNC_SKIPPED_REASONS.MISSING_TOKEN_ENV);
+  }
+  const syncPort = createHttpControlPlaneSyncPort(runtimeConfig.control_plane, options.logger, {
+    fetchFn: options.fetchFn,
+    environment,
+    timeoutMs: options.timeoutMs
+  });
+  return {
+    async push(events) {
+      if (events.length === 0) {
+        return createNoopSyncResult(WU_LIFECYCLE_SYNC_SKIPPED_REASONS.NO_EVENTS);
+      }
+      try {
+        const result = await syncPort.pushKernelEvents({
+          workspace_id: workspaceId,
+          events
+        });
+        return {
+          sent: result.accepted > 0,
+          accepted: result.accepted,
+          ...result.accepted > 0 ? {} : {
+            skippedReason: WU_LIFECYCLE_SYNC_SKIPPED_REASONS.NO_EVENTS_ACCEPTED
+          }
+        };
+      } catch (error) {
+        options.logger?.warn?.(
+          `${WU_LIFECYCLE_SYNC_LOG_PREFIX} pushKernelEvents failed: ${getErrorMessage(error)}`
+        );
+        return createNoopSyncResult(WU_LIFECYCLE_SYNC_SKIPPED_REASONS.PUSH_FAILED);
+      }
+    }
+  };
+}
+
+// src/wu-lifecycle-sync/service.ts
+function asNonEmptyString2(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function createSha256Hex(input) {
+  return createHash(WU_LIFECYCLE_SPEC_HASH.ALGORITHM).update(input).digest(WU_LIFECYCLE_SPEC_HASH.DIGEST_ENCODING);
+}
+function resolveSpecHash(input) {
+  const explicitSpecHash = asNonEmptyString2(input.specHash);
+  if (explicitSpecHash && WU_LIFECYCLE_SPEC_HASH.HEX_256_REGEX.test(explicitSpecHash)) {
+    return explicitSpecHash;
+  }
+  const specPath = asNonEmptyString2(input.specPath);
+  if (specPath) {
+    try {
+      const fileContent = readFileSync(specPath, WU_LIFECYCLE_SYNC_CONFIG.TEXT_ENCODING_UTF8);
+      return createSha256Hex(fileContent);
+    } catch {
+    }
+  }
+  return createSha256Hex(`${WU_LIFECYCLE_COMMANDS.CREATE}:${input.wuId}`);
+}
+function resolveTimestamp(input) {
+  return input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+}
+function buildWuLifecycleKernelEvent(input) {
+  const timestamp = resolveTimestamp(input);
+  switch (input.command) {
+    case WU_LIFECYCLE_COMMANDS.CREATE:
+      return {
+        schema_version: WU_LIFECYCLE_EVENT_SCHEMA_VERSION,
+        kind: WU_LIFECYCLE_EVENT_KINDS.CREATE,
+        task_id: input.wuId,
+        timestamp,
+        spec_hash: resolveSpecHash(input)
+      };
+    case WU_LIFECYCLE_COMMANDS.CLAIM:
+      return {
+        schema_version: WU_LIFECYCLE_EVENT_SCHEMA_VERSION,
+        kind: WU_LIFECYCLE_EVENT_KINDS.CLAIM,
+        task_id: input.wuId,
+        timestamp,
+        by: asNonEmptyString2(input.by) ?? WU_LIFECYCLE_CLAIM_DEFAULTS.ACTOR,
+        session_id: asNonEmptyString2(input.sessionId) ?? WU_LIFECYCLE_CLAIM_DEFAULTS.SESSION_ID
+      };
+    case WU_LIFECYCLE_COMMANDS.DONE:
+      return {
+        schema_version: WU_LIFECYCLE_EVENT_SCHEMA_VERSION,
+        kind: WU_LIFECYCLE_EVENT_KINDS.DONE,
+        task_id: input.wuId,
+        timestamp,
+        ...input.evidenceRefs && input.evidenceRefs.length > 0 ? { evidence_refs: input.evidenceRefs } : {}
+      };
+    default: {
+      const exhaustiveCheck = input.command;
+      throw createError(
+        ErrorCodes.INVALID_ARGUMENT,
+        `Unsupported WU lifecycle command: ${exhaustiveCheck}`
+      );
+    }
+  }
+}
+async function flushWuLifecycleSync(input, options = {}) {
+  const logger = options.logger;
+  try {
+    const sink = options.sink ?? await resolveWuLifecycleEventSink(options);
+    const event = buildWuLifecycleKernelEvent(input);
+    return await sink.push([event]);
+  } catch (error) {
+    logger?.warn?.(`${WU_LIFECYCLE_SYNC_LOG_PREFIX} fail-open: ${getErrorMessage(error)}`);
+    return {
+      sent: WU_LIFECYCLE_SYNC_RESULT_DEFAULTS.SENT,
+      accepted: WU_LIFECYCLE_SYNC_RESULT_DEFAULTS.ACCEPTED,
+      skippedReason: WU_LIFECYCLE_SYNC_SKIPPED_REASONS.PUSH_FAILED
+    };
+  }
+}
+
+export {
+  buildWuLifecycleKernelEvent,
+  flushWuLifecycleSync
+};

package/dist/chunk-JHHWGL2N.js

@@ -0,0 +1,87 @@
+import {
+  loadMemory
+} from "./chunk-DFR4DJBM.js";
+import {
+  LUMENFLOW_MEMORY_PATHS
+} from "./chunk-4N74J3UT.js";
+
+// ../memory/dist/mem-export-core.js
+import path from "path";
+function applyFilters(nodes, options) {
+  const { wuId, type, lifecycle } = options;
+  return nodes.filter((node) => {
+    if (wuId && node.wu_id !== wuId)
+      return false;
+    if (type && node.type !== type)
+      return false;
+    if (lifecycle && node.lifecycle !== lifecycle)
+      return false;
+    return true;
+  });
+}
+function formatFilters(options) {
+  const parts = [];
+  if (options.wuId)
+    parts.push(`wu=${options.wuId}`);
+  if (options.type)
+    parts.push(`type=${options.type}`);
+  if (options.lifecycle)
+    parts.push(`lifecycle=${options.lifecycle}`);
+  return parts.length === 0 ? "none" : parts.join(", ");
+}
+function formatMarkdown(nodes, options) {
+  const lines = [];
+  lines.push("# Memory Export");
+  lines.push(`Filters: ${formatFilters(options)}`);
+  lines.push(`Total: ${nodes.length}`);
+  lines.push("");
+  if (nodes.length === 0) {
+    lines.push("No matching nodes.");
+    return lines.join("\n");
+  }
+  for (const node of nodes) {
+    lines.push(`## ${node.id} (${node.type})`);
+    lines.push(`- Created: ${node.created_at}`);
+    lines.push(`- Lifecycle: ${node.lifecycle}`);
+    if (node.wu_id) {
+      lines.push(`- WU: ${node.wu_id}`);
+    }
+    lines.push(`- Content: ${node.content}`);
+    if (node.tags && node.tags.length > 0) {
+      lines.push(`- Tags: ${node.tags.join(", ")}`);
+    }
+    if (node.metadata && Object.keys(node.metadata).length > 0) {
+      lines.push(`- Metadata: ${JSON.stringify(node.metadata)}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatJson(nodes, options) {
+  const payload = {
+    count: nodes.length,
+    filters: {
+      wuId: options.wuId ?? null,
+      type: options.type ?? null,
+      lifecycle: options.lifecycle ?? null
+    },
+    nodes
+  };
+  return JSON.stringify(payload, null, 2);
+}
+async function exportMemory(baseDir, options = {}) {
+  const memoryDir = path.join(baseDir, LUMENFLOW_MEMORY_PATHS.MEMORY_DIR);
+  const memory = await loadMemory(memoryDir);
+  const nodes = applyFilters(memory.nodes, options);
+  const format = options.format ?? "markdown";
+  const output = format === "json" ? formatJson(nodes, options) : formatMarkdown(nodes, options);
+  return {
+    format,
+    nodes,
+    output
+  };
+}
+
+export {
+  exportMemory
+};