@lumenflow/cli 3.12.6 → 3.12.8

package/dist/chunk-GPQHMBNN.js

@@ -1,278 +0,0 @@
-import {
-  startSession
-} from "./chunk-GTFJB67L.js";
-import {
-  parseYAML
-} from "./chunk-NRIZR3A7.js";
-import {
-  CONFIG_FILES,
-  LUMENFLOW_PATHS
-} from "./chunk-DWMLTXKQ.js";
-
-// ../agent/dist/auto-session-integration.js
-import { randomUUID } from "crypto";
-import { readFileSync, writeFileSync, existsSync, unlinkSync, mkdirSync } from "fs";
-import { join } from "path";
-
-// ../memory/dist/mem-index-core.js
-import fs from "fs/promises";
-import path from "path";
-import crypto from "crypto";
-
-// ../memory/dist/mem-promote-core.js
-import fs2 from "fs/promises";
-import path2 from "path";
-var ALLOWED_PROMOTION_TAGS = [
-  "decision",
-  "convention",
-  "pattern",
-  "pitfall",
-  "interface",
-  "invariant",
-  "faq"
-];
-var ERROR_MESSAGES = {
-  NODE_NOT_FOUND: "Node not found",
-  ALREADY_PROJECT: "Node is already at project lifecycle",
-  INVALID_TAG: `Tag must be one of: ${ALLOWED_PROMOTION_TAGS.join(", ")}`,
-  INVALID_WU_ID: "Invalid WU ID format. Expected pattern: WU-XXX (e.g., WU-1234)"
-};
-
-// ../memory/dist/memory-promotion.js
-import fs3 from "fs/promises";
-import path3 from "path";
-
-// ../memory/dist/mem-profile-core.js
-import path4 from "path";
-
-// ../memory/dist/control-plane-sync-adapter.js
-import fs4 from "fs/promises";
-import path5 from "path";
-var DEFAULT_CONTROL_PLANE_SYNC_STATE_PATH = path5.join(".lumenflow", "state", "control-plane-sync.json");
-
-// ../agent/dist/auto-session-integration.js
-var SESSION_FILENAME = "current.json";
-var WORKSPACE_CONFIG_FILE = CONFIG_FILES.WORKSPACE_CONFIG;
-var CONTROL_PLANE_REGISTER_PATH = "/api/v1/sessions/register";
-var CONTROL_PLANE_DEREGISTER_PATH = "/api/v1/sessions/deregister";
-var DEFAULT_TIER = 2;
-var DEFAULT_AGENT_TYPE = "claude-code";
-var DEFAULT_AGENT_VERSION = "unknown";
-var DEFAULT_HOST_ID = "unknown";
-var DEFAULT_AGENT_CAPABILITIES = ["session_lifecycle", "heartbeat"];
-var AGENT_CAPABILITIES_ENV = "LUMENFLOW_AGENT_CAPABILITIES";
-var AGENT_VERSION_ENV = "LUMENFLOW_AGENT_VERSION";
-var CONTEXT_TIER_MAP = {
-  1: "minimal",
-  2: "core",
-  3: "full"
-};
-function parseCapabilities(rawValue) {
-  if (!rawValue) {
-    return [...DEFAULT_AGENT_CAPABILITIES];
-  }
-  const parsed = rawValue.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
-  return parsed.length > 0 ? parsed : [...DEFAULT_AGENT_CAPABILITIES];
-}
-function asNonEmptyString(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
-}
-function normalizeEndpoint(endpoint) {
-  return endpoint.endsWith("/") ? endpoint.slice(0, endpoint.length - 1) : endpoint;
-}
-function resolveControlPlaneSessionSyncConfig(workspaceRoot, environment) {
-  const workspacePath = join(workspaceRoot, WORKSPACE_CONFIG_FILE);
-  if (!existsSync(workspacePath)) {
-    return null;
-  }
-  let parsedWorkspace;
-  try {
-    parsedWorkspace = parseYAML(readFileSync(workspacePath, { encoding: "utf-8" }));
-  } catch {
-    return null;
-  }
-  const workspaceId = asNonEmptyString(parsedWorkspace?.id);
-  const endpoint = asNonEmptyString(parsedWorkspace?.control_plane?.endpoint);
-  const tokenEnv = asNonEmptyString(parsedWorkspace?.control_plane?.auth?.token_env);
-  if (!workspaceId || !endpoint || !tokenEnv) {
-    return null;
-  }
-  const token = asNonEmptyString(environment[tokenEnv]);
-  if (!token) {
-    return null;
-  }
-  try {
-    void new URL(endpoint);
-  } catch {
-    return null;
-  }
-  return {
-    workspaceId,
-    endpoint: normalizeEndpoint(endpoint),
-    token
-  };
-}
-function resolveStandardSessionMetadata(input) {
-  const clientType = input.agentType;
-  const capabilities = parseCapabilities(asNonEmptyString(input.environment[AGENT_CAPABILITIES_ENV]));
-  const agentVersion = asNonEmptyString(input.environment[AGENT_VERSION_ENV]) ?? DEFAULT_AGENT_VERSION;
-  const hostId = asNonEmptyString(input.environment.HOSTNAME) ?? asNonEmptyString(input.environment.COMPUTERNAME) ?? DEFAULT_HOST_ID;
-  return {
-    client_type: clientType,
-    capabilities,
-    agent_version: agentVersion,
-    host_id: hostId,
-    metadata: {
-      client_type: clientType,
-      capabilities,
-      agent_version: agentVersion,
-      host_id: hostId
-    }
-  };
-}
-async function postControlPlaneSessionHook(endpoint, token, path6, payload, fetchFn) {
-  const response = await fetchFn(`${endpoint}${path6}`, {
-    method: "POST",
-    headers: {
-      authorization: `Bearer ${token}`,
-      "content-type": "application/json"
-    },
-    body: JSON.stringify(payload)
-  });
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}`);
-  }
-}
-function getSessionFilePath(sessionDir) {
-  return join(sessionDir, SESSION_FILENAME);
-}
-async function startSessionForWU(options) {
-  const { wuId, tier = DEFAULT_TIER, agentType = DEFAULT_AGENT_TYPE, lane, sessionDir, workspaceRoot = process.cwd(), environment = process.env, controlPlaneSyncPort, fetchFn = fetch, baseDir = process.cwd() } = options;
-  const sessDir = sessionDir ?? LUMENFLOW_PATHS.SESSIONS;
-  const sessionFile = getSessionFilePath(sessDir);
-  if (existsSync(sessionFile)) {
-    const existing = JSON.parse(readFileSync(sessionFile, { encoding: "utf-8" }));
-    return {
-      sessionId: existing.session_id,
-      alreadyActive: true
-    };
-  }
-  if (!existsSync(sessDir)) {
-    mkdirSync(sessDir, { recursive: true });
-  }
-  const sessionId = randomUUID();
-  const session = {
-    session_id: sessionId,
-    wu_id: wuId,
-    started: (/* @__PURE__ */ new Date()).toISOString(),
-    agent_type: agentType,
-    context_tier: tier,
-    incidents_logged: 0,
-    incidents_major: 0,
-    auto_started: true
-    // Mark as auto-started by wu:claim
-  };
-  writeFileSync(sessionFile, JSON.stringify(session, null, 2), { encoding: "utf-8" });
-  let memoryNodeId = null;
-  try {
-    const memResult = await startSession(baseDir, {
-      wuId,
-      agentType,
-      contextTier: CONTEXT_TIER_MAP[tier] ?? "full"
-    });
-    memoryNodeId = memResult.session?.id ?? null;
-  } catch {
-  }
-  const controlPlaneConfig = resolveControlPlaneSessionSyncConfig(workspaceRoot, environment);
-  if (controlPlaneConfig) {
-    const standardizedMetadata = resolveStandardSessionMetadata({
-      agentType,
-      environment
-    });
-    const registerInput = {
-      workspace_id: controlPlaneConfig.workspaceId,
-      session_id: sessionId,
-      agent_id: agentType,
-      started_at: session.started,
-      lane,
-      wu_id: wuId,
-      client_type: standardizedMetadata.client_type,
-      capabilities: standardizedMetadata.capabilities,
-      agent_version: standardizedMetadata.agent_version,
-      host_id: standardizedMetadata.host_id,
-      metadata: standardizedMetadata.metadata
-    };
-    try {
-      if (controlPlaneSyncPort) {
-        await controlPlaneSyncPort.registerSession(registerInput);
-      } else {
-        await postControlPlaneSessionHook(controlPlaneConfig.endpoint, controlPlaneConfig.token, CONTROL_PLANE_REGISTER_PATH, registerInput, fetchFn);
-      }
-    } catch {
-    }
-  }
-  return {
-    sessionId,
-    alreadyActive: false,
-    memoryNodeId
-  };
-}
-function endSessionForWU(options = {}) {
-  const { sessionDir, workspaceRoot = process.cwd(), environment = process.env, controlPlaneSyncPort, fetchFn = fetch } = options;
-  const sessDir = sessionDir ?? LUMENFLOW_PATHS.SESSIONS;
-  const sessionFile = getSessionFilePath(sessDir);
-  if (!existsSync(sessionFile)) {
-    return {
-      ended: false,
-      reason: "no_active_session"
-    };
-  }
-  const session = JSON.parse(readFileSync(sessionFile, { encoding: "utf-8" }));
-  session.completed = (/* @__PURE__ */ new Date()).toISOString();
-  const summary = {
-    wu_id: session.wu_id,
-    session_id: session.session_id,
-    started: session.started,
-    completed: session.completed,
-    agent_type: session.agent_type,
-    context_tier: session.context_tier,
-    incidents_logged: session.incidents_logged,
-    incidents_major: session.incidents_major
-  };
-  unlinkSync(sessionFile);
-  const controlPlaneConfig = resolveControlPlaneSessionSyncConfig(workspaceRoot, environment);
-  if (controlPlaneConfig) {
-    const deregisterInput = {
-      workspace_id: controlPlaneConfig.workspaceId,
-      session_id: session.session_id,
-      ended_at: session.completed,
-      reason: "wu_done"
-    };
-    if (controlPlaneSyncPort) {
-      void controlPlaneSyncPort.deregisterSession(deregisterInput).catch(() => {
-      });
-    } else {
-      void postControlPlaneSessionHook(controlPlaneConfig.endpoint, controlPlaneConfig.token, CONTROL_PLANE_DEREGISTER_PATH, deregisterInput, fetchFn).catch(() => {
-      });
-    }
-  }
-  return {
-    ended: true,
-    summary
-  };
-}
-function getCurrentSessionForWU(options = {}) {
-  const { sessionDir } = options;
-  const sessDir = sessionDir ?? LUMENFLOW_PATHS.SESSIONS;
-  const sessionFile = getSessionFilePath(sessDir);
-  if (!existsSync(sessionFile)) {
-    return null;
-  }
-  return JSON.parse(readFileSync(sessionFile, { encoding: "utf-8" }));
-}
-
-export {
-  startSessionForWU,
-  endSessionForWU,
-  getCurrentSessionForWU
-};

package/dist/chunk-GTFJB67L.js

@@ -1,68 +0,0 @@
-import {
-  ensureMemoryDir
-} from "./chunk-ND6MY37M.js";
-import {
-  generateMemId
-} from "./chunk-RIAAGL2E.js";
-import {
-  MEMORY_PATTERNS,
-  appendNode
-} from "./chunk-DFR4DJBM.js";
-import {
-  ErrorCodes,
-  createError
-} from "./chunk-RXRKBBSM.js";
-
-// ../memory/dist/mem-start-core.js
-import { randomUUID } from "crypto";
-var DEFAULTS = {
-  AGENT_TYPE: "unknown",
-  CONTEXT_TIER: "full"
-};
-var ERROR_MESSAGES = {
-  WU_ID_REQUIRED: "wuId is required",
-  WU_ID_INVALID: "Invalid WU ID format. Expected pattern: WU-XXX (e.g., WU-123)"
-};
-function isValidWuId(wuId) {
-  return MEMORY_PATTERNS.WU_ID.test(wuId);
-}
-function generateSessionContent(wuId, agentType, contextTier) {
-  return `Session started for ${wuId}. Agent: ${agentType}, Context: ${contextTier}`;
-}
-async function startSession(baseDir, options) {
-  const { wuId, agentType = DEFAULTS.AGENT_TYPE, contextTier = DEFAULTS.CONTEXT_TIER } = options;
-  if (!wuId) {
-    throw createError(ErrorCodes.VALIDATION_ERROR, ERROR_MESSAGES.WU_ID_REQUIRED);
-  }
-  if (!isValidWuId(wuId)) {
-    throw createError(ErrorCodes.INVALID_WU_ID, ERROR_MESSAGES.WU_ID_INVALID);
-  }
-  const memoryDir = await ensureMemoryDir(baseDir);
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const sessionId = randomUUID();
-  const content = generateSessionContent(wuId, agentType, contextTier);
-  const idContent = `${content}-${timestamp}-${sessionId}`;
-  const id = generateMemId(idContent);
-  const sessionNode = {
-    id,
-    type: "session",
-    lifecycle: "wu",
-    content,
-    created_at: timestamp,
-    wu_id: wuId,
-    session_id: sessionId,
-    metadata: {
-      agentType,
-      contextTier
-    }
-  };
-  await appendNode(memoryDir, sessionNode);
-  return {
-    success: true,
-    session: sessionNode
-  };
-}
-
-export {
-  startSession
-};