@lumenflow/cli 4.0.0 → 4.0.1

package/dist/chunk-D3UOFRSB.js

@@ -1,81 +0,0 @@
-import {
-  ErrorCodes,
-  createError
-} from "./chunk-RXRKBBSM.js";
-
-// src/template-directory-resolver.ts
-import * as fs from "fs";
-import * as path from "path";
-import { fileURLToPath } from "url";
-var CLI_SCOPE_DIR = "@lumenflow";
-var CLI_PACKAGE_DIR = "cli";
-var TEMPLATES_DIR = "templates";
-var PACKAGES_DIR = "packages";
-function collectAncestorDirectories(startDir) {
-  const directories = [];
-  let current = path.resolve(startDir);
-  while (true) {
-    directories.push(current);
-    const parent = path.dirname(current);
-    if (parent === current) {
-      return directories;
-    }
-    current = parent;
-  }
-}
-function isCliPackageRoot(candidate) {
-  return path.basename(candidate) === CLI_PACKAGE_DIR && path.basename(path.dirname(candidate)) === CLI_SCOPE_DIR;
-}
-function collectCwdCandidates(cwd) {
-  const candidates = [];
-  for (const directory of collectAncestorDirectories(cwd)) {
-    if (isCliPackageRoot(directory)) {
-      candidates.push(path.join(directory, TEMPLATES_DIR));
-    }
-    candidates.push(
-      path.join(directory, PACKAGES_DIR, CLI_SCOPE_DIR, CLI_PACKAGE_DIR, TEMPLATES_DIR)
-    );
-  }
-  return candidates;
-}
-function collectModuleCandidates(moduleUrl) {
-  const modulePath = fileURLToPath(moduleUrl);
-  const moduleDir = path.dirname(modulePath);
-  const packageRoot = path.resolve(moduleDir, "..");
-  return [path.join(packageRoot, TEMPLATES_DIR)];
-}
-function dedupeCandidates(candidates) {
-  const seen = /* @__PURE__ */ new Set();
-  const unique = [];
-  for (const candidate of candidates) {
-    const normalized = path.resolve(candidate);
-    if (seen.has(normalized)) {
-      continue;
-    }
-    seen.add(normalized);
-    unique.push(normalized);
-  }
-  return unique;
-}
-function resolveCliTemplatesDir(options = {}) {
-  const existsSync2 = options.existsSync ?? fs.existsSync;
-  const cwd = options.cwd ?? process.cwd();
-  const moduleUrl = options.moduleUrl ?? import.meta.url;
-  const candidates = dedupeCandidates([
-    ...collectCwdCandidates(cwd),
-    ...collectModuleCandidates(moduleUrl)
-  ]);
-  for (const candidate of candidates) {
-    if (existsSync2(candidate)) {
-      return candidate;
-    }
-  }
-  throw createError(
-    ErrorCodes.FILE_NOT_FOUND,
-    `Templates directory not found. Checked: ${candidates.join(", ")}`
-  );
-}
-
-export {
-  resolveCliTemplatesDir
-};

package/dist/chunk-DFR4DJBM.js

@@ -1,230 +0,0 @@
-import {
-  ErrorCodes,
-  createError
-} from "./chunk-RXRKBBSM.js";
-
-// ../memory/dist/memory-store.js
-import fs from "fs/promises";
-import path from "path";
-
-// ../memory/dist/memory-schema.js
-import { z } from "zod";
-var MEMORY_NODE_TYPES = ["session", "discovery", "checkpoint", "note", "summary"];
-var MEMORY_LIFECYCLES = ["ephemeral", "session", "wu", "project"];
-var RELATIONSHIP_TYPES = ["blocks", "parent_child", "related", "discovered_from"];
-var MEMORY_PATTERNS = {
-  /** Memory ID format: mem-[a-z0-9]{4} */
-  MEMORY_ID: /^mem-[a-z0-9]{4}$/,
-  /** WU ID format (reused from wu-schema) */
-  WU_ID: /^WU-\d+$/
-};
-var ERROR_MESSAGES = {
-  MEMORY_ID: "ID must match pattern mem-[a-z0-9]{4} (e.g., mem-abc1)",
-  NODE_TYPE: `Type must be one of: ${MEMORY_NODE_TYPES.join(", ")}`,
-  LIFECYCLE: `Lifecycle must be one of: ${MEMORY_LIFECYCLES.join(", ")}`,
-  RELATIONSHIP_TYPE: `Type must be one of: ${RELATIONSHIP_TYPES.join(", ")}`,
-  WU_ID: "WU ID must match pattern WU-XXX (e.g., WU-1462)",
-  CONTENT_REQUIRED: "Content is required",
-  DATETIME_REQUIRED: "Created timestamp is required"
-};
-var MemoryNodeSchema = z.object({
-  /** Memory node identifier (mem-[a-z0-9]{4}) */
-  id: z.string().regex(MEMORY_PATTERNS.MEMORY_ID, { message: ERROR_MESSAGES.MEMORY_ID }),
-  /** Node type classification */
-  type: z.enum(MEMORY_NODE_TYPES, {
-    error: ERROR_MESSAGES.NODE_TYPE
-  }),
-  /** Lifecycle duration */
-  lifecycle: z.enum(MEMORY_LIFECYCLES, {
-    error: ERROR_MESSAGES.LIFECYCLE
-  }),
-  /** Node content (required, non-empty) */
-  content: z.string().min(1, { message: ERROR_MESSAGES.CONTENT_REQUIRED }),
-  /** Creation timestamp (ISO 8601 datetime) */
-  created_at: z.string().datetime({ message: ERROR_MESSAGES.DATETIME_REQUIRED }),
-  /** Last update timestamp (optional, ISO 8601 datetime) */
-  updated_at: z.string().datetime().optional(),
-  /** Associated WU ID (optional) */
-  wu_id: z.string().regex(MEMORY_PATTERNS.WU_ID, { message: ERROR_MESSAGES.WU_ID }).optional(),
-  /** Session ID this node belongs to (optional, UUID) */
-  session_id: z.string().uuid().optional(),
-  /** Arbitrary metadata (optional) */
-  metadata: z.record(z.string(), z.unknown()).optional(),
-  /** Tags for categorization (optional) */
-  tags: z.array(z.string()).optional()
-});
-var RelationshipSchema = z.object({
-  /** Source node ID (mem-[a-z0-9]{4}) */
-  from_id: z.string().regex(MEMORY_PATTERNS.MEMORY_ID, { message: ERROR_MESSAGES.MEMORY_ID }),
-  /** Target node ID (mem-[a-z0-9]{4}) */
-  to_id: z.string().regex(MEMORY_PATTERNS.MEMORY_ID, { message: ERROR_MESSAGES.MEMORY_ID }),
-  /** Relationship type */
-  type: z.enum(RELATIONSHIP_TYPES, {
-    error: ERROR_MESSAGES.RELATIONSHIP_TYPE
-  }),
-  /** Creation timestamp (optional, ISO 8601 datetime) */
-  created_at: z.string().datetime().optional(),
-  /** Arbitrary metadata (optional) */
-  metadata: z.record(z.string(), z.unknown()).optional()
-});
-function validateMemoryNode(data) {
-  return MemoryNodeSchema.safeParse(data);
-}
-function validateRelationship(data) {
-  return RelationshipSchema.safeParse(data);
-}
-
-// ../memory/dist/memory-store.js
-var MEMORY_FILE_NAME = "memory.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);
-}
-function isNodeArchived(node) {
-  return node.metadata?.status === "archived";
-}
-async function loadMemory(baseDir, options = {}) {
-  const { includeArchived = false } = options;
-  const filePath = path.join(baseDir, MEMORY_FILE_NAME);
-  const content = await readMemoryFileOrEmpty(filePath);
-  if (content === null) {
-    return createEmptyIndexedMemory();
-  }
-  return parseAndIndexMemory(content, includeArchived);
-}
-async function readMemoryFileOrEmpty(filePath) {
-  try {
-    return await fs.readFile(filePath, { encoding: "utf-8" });
-  } catch (err) {
-    const error = err;
-    if (error.code === "ENOENT") {
-      return null;
-    }
-    throw error;
-  }
-}
-function createEmptyIndexedMemory() {
-  return {
-    nodes: [],
-    byId: /* @__PURE__ */ new Map(),
-    byWu: /* @__PURE__ */ new Map()
-  };
-}
-function parseAndValidateLine(line, lineNumber) {
-  let parsed;
-  try {
-    parsed = JSON.parse(line);
-  } catch (err) {
-    const errMsg = err instanceof Error ? err.message : String(err);
-    throw createError(ErrorCodes.PARSE_ERROR, `Malformed JSON on line ${lineNumber}: ${errMsg}`, {
-      cause: err
-    });
-  }
-  const validation = validateMemoryNode(parsed);
-  if (!validation.success) {
-    const issues = validation.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
-    throw createError(ErrorCodes.VALIDATION_ERROR, `Validation error on line ${lineNumber}: ${issues}`);
-  }
-  return validation.data;
-}
-function indexNodeByWu(result, node) {
-  if (!node.wu_id)
-    return;
-  if (!result.byWu.has(node.wu_id)) {
-    result.byWu.set(node.wu_id, []);
-  }
-  const wuNodes = result.byWu.get(node.wu_id);
-  if (wuNodes) {
-    wuNodes.push(node);
-  }
-}
-function parseAndIndexMemory(content, includeArchived) {
-  const result = createEmptyIndexedMemory();
-  const lines = content.split("\n");
-  const allParsed = [];
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]?.trim() ?? "";
-    if (!line)
-      continue;
-    const node = parseAndValidateLine(line, i + 1);
-    allParsed.push(node);
-    result.byId.set(node.id, node);
-  }
-  const seen = /* @__PURE__ */ new Set();
-  for (const node of allParsed) {
-    if (seen.has(node.id))
-      continue;
-    const latestVersion = result.byId.get(node.id);
-    if (!latestVersion)
-      continue;
-    seen.add(node.id);
-    if (!includeArchived && isNodeArchived(latestVersion)) {
-      result.byId.delete(node.id);
-      continue;
-    }
-    result.nodes.push(latestVersion);
-    result.byId.set(node.id, latestVersion);
-    indexNodeByWu(result, latestVersion);
-  }
-  return result;
-}
-async function loadMemoryAll(baseDir) {
-  return loadMemory(baseDir, { includeArchived: true });
-}
-async function appendNode(baseDir, node) {
-  const validation = validateMemoryNode(node);
-  if (!validation.success) {
-    const issues = validation.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
-    throw createError(ErrorCodes.VALIDATION_ERROR, `Validation error: ${issues}`);
-  }
-  const filePath = path.join(baseDir, MEMORY_FILE_NAME);
-  const line = JSON.stringify(node) + "\n";
-  await fs.appendFile(filePath, line, { encoding: "utf-8" });
-  return node;
-}
-async function queryReady(baseDir, wuId, options = {}) {
-  const { includeArchived = false } = options;
-  const memory = await loadMemory(baseDir, { includeArchived });
-  const wuNodes = memory.byWu.get(wuId) ?? [];
-  return [...wuNodes].sort(compareNodes);
-}
-async function queryByWu(baseDir, wuId, options = {}) {
-  const { includeArchived = false } = options;
-  const memory = await loadMemory(baseDir, { includeArchived });
-  return memory.byWu.get(wuId) ?? [];
-}
-
-export {
-  MEMORY_NODE_TYPES,
-  MEMORY_PATTERNS,
-  validateMemoryNode,
-  validateRelationship,
-  MEMORY_FILE_NAME,
-  loadMemory,
-  loadMemoryAll,
-  appendNode,
-  queryReady,
-  queryByWu
-};

package/dist/chunk-DSYBDHYH.js

@@ -1,79 +0,0 @@
-import {
-  SIZING_GUIDE_REF
-} from "./chunk-DWMLTXKQ.js";
-
-// src/wu-sizing-validation.ts
-var SIZING_STRATEGIES = [
-  "single-session",
-  "checkpoint-resume",
-  "orchestrator-worker",
-  "decomposition"
-];
-var SIZING_EXCEPTION_TYPES = ["docs-only", "shallow-multi-file"];
-var SIZING_THRESHOLDS = {
-  SIMPLE: { files: 20, tool_calls: 50 },
-  MEDIUM: { files: 50, tool_calls: 100 },
-  OVERSIZED: { files: 100, tool_calls: 200 },
-  /** Docs-only exception thresholds (section 1.1) */
-  DOCS_ONLY: { files: 40, tool_calls: 50 }
-};
-function validateSizingEstimate(estimate) {
-  if (estimate === void 0) {
-    return { valid: true, errors: [] };
-  }
-  const errors = [];
-  if (typeof estimate.estimated_files !== "number" || estimate.estimated_files < 0) {
-    errors.push("sizing_estimate.estimated_files must be a non-negative number");
-  }
-  if (typeof estimate.estimated_tool_calls !== "number" || estimate.estimated_tool_calls < 0) {
-    errors.push("sizing_estimate.estimated_tool_calls must be a non-negative number");
-  }
-  if (!SIZING_STRATEGIES.includes(estimate.strategy)) {
-    errors.push(`sizing_estimate.strategy must be one of: ${SIZING_STRATEGIES.join(", ")}`);
-  }
-  if (estimate.exception_type !== void 0) {
-    if (!SIZING_EXCEPTION_TYPES.includes(estimate.exception_type)) {
-      errors.push(
-        `sizing_estimate.exception_type must be one of: ${SIZING_EXCEPTION_TYPES.join(", ")}`
-      );
-    }
-    if (!estimate.exception_reason || estimate.exception_reason.trim().length === 0) {
-      errors.push("sizing_estimate.exception_reason is required when exception_type is set");
-    }
-  }
-  return { valid: errors.length === 0, errors };
-}
-function hasValidException(estimate) {
-  return estimate.exception_type !== void 0 && estimate.exception_reason !== void 0 && estimate.exception_reason.trim().length > 0;
-}
-function checkSizingAdvisory(estimate) {
-  if (estimate === void 0) {
-    return { oversize: false, warnings: [] };
-  }
-  if (hasValidException(estimate)) {
-    return { oversize: false, warnings: [] };
-  }
-  const warnings = [];
-  if (estimate.estimated_files > SIZING_THRESHOLDS.OVERSIZED.files || estimate.estimated_tool_calls > SIZING_THRESHOLDS.OVERSIZED.tool_calls) {
-    warnings.push(
-      `Sizing estimate exceeds OVERSIZED threshold (${estimate.estimated_files} files, ${estimate.estimated_tool_calls} tool calls). This WU MUST be split per ${SIZING_GUIDE_REF}.`
-    );
-    return { oversize: true, warnings };
-  }
-  if (estimate.estimated_files > SIZING_THRESHOLDS.SIMPLE.files) {
-    warnings.push(
-      `sizing: estimated_files (${estimate.estimated_files}) exceeds Simple threshold (${SIZING_THRESHOLDS.SIMPLE.files}). Consider adding exception_type/exception_reason or splitting the WU. See ${SIZING_GUIDE_REF}.`
-    );
-  }
-  if (estimate.estimated_tool_calls > SIZING_THRESHOLDS.SIMPLE.tool_calls) {
-    warnings.push(
-      `sizing: estimated_tool_calls (${estimate.estimated_tool_calls}) exceeds Simple threshold (${SIZING_THRESHOLDS.SIMPLE.tool_calls}). Consider checkpoint-resume strategy or splitting the WU. See ${SIZING_GUIDE_REF}.`
-    );
-  }
-  return { oversize: warnings.length > 0, warnings };
-}
-
-export {
-  validateSizingEstimate,
-  checkSizingAdvisory
-};