@lumenflow/cli 4.0.0 → 4.1.0

package/dist/chunk-ISZR5N4K.js

@@ -1,60 +0,0 @@
-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

@@ -1,226 +0,0 @@
-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

@@ -1,244 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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
-};