@lumenflow/cli 3.13.2 → 3.15.0

package/dist/chunk-XGI665H7.js

@@ -0,0 +1,150 @@
+import {
+  getGitForCwd
+} from "./chunk-2UFQ3A3C.js";
+import {
+  createWuPaths
+} from "./chunk-6HO4GWJE.js";
+import {
+  EMOJI,
+  LOG_PREFIX,
+  REMOTES,
+  STDIO
+} from "./chunk-DWMLTXKQ.js";
+import {
+  ErrorCodes,
+  createError
+} from "./chunk-RXRKBBSM.js";
+
+// ../core/dist/wu-done-pr.js
+import { execSync } from "child_process";
+var WU_DONE_COMPLETION_MODES = Object.freeze({
+  WORKTREE: "worktree",
+  BRANCH_ONLY: "branch-only",
+  BRANCH_PR: "branch-pr"
+});
+function isPRModeEnabled(doc, args) {
+  const claimedMode = doc.claimed_mode || "worktree";
+  const requiresReview = doc.requires_review === true;
+  return claimedMode === "worktree-pr" || args.createPR || requiresReview;
+}
+function isGhCliAvailable() {
+  try {
+    execSync("gh --version", { encoding: "utf-8", stdio: STDIO.IGNORE });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function createPR(context) {
+  const { branch, id, title, doc, draft = false } = context;
+  console.log(`
+${LOG_PREFIX.DONE} Creating PR for ${branch}...`);
+  if (!isGhCliAvailable()) {
+    printGhCliMissingMessage(branch, id);
+    return { success: false, prUrl: null, ghAvailable: false };
+  }
+  try {
+    await getGitForCwd().push(REMOTES.ORIGIN, branch);
+  } catch (e) {
+    throw createError(ErrorCodes.GIT_ERROR, `Failed to push branch ${branch}: ${e.message}`, {
+      branch,
+      operation: "push",
+      originalError: e.message
+    });
+  }
+  const body = buildPRBody(doc, id);
+  const prTitle = `${id}: ${title}`;
+  const draftFlag = draft ? "--draft" : "";
+  try {
+    const prUrl = execSync(`gh pr create --title ${JSON.stringify(prTitle)} --body ${JSON.stringify(body)} ${draftFlag} --head ${JSON.stringify(branch)} --base main`, { encoding: "utf-8" }).trim();
+    console.log(`${LOG_PREFIX.DONE} ${EMOJI.SUCCESS} PR created: ${prUrl}`);
+    return { success: true, prUrl, ghAvailable: true };
+  } catch (e) {
+    throw createError(ErrorCodes.GIT_ERROR, `Failed to create PR: ${e.message}`, {
+      branch,
+      id,
+      operation: "pr-create",
+      originalError: e.message
+    });
+  }
+}
+function buildPRBody(doc, id) {
+  const paths = createWuPaths();
+  const wuPath = paths.WU(id);
+  const description = doc.description || doc.problem || "";
+  const acceptance = doc.acceptance_criteria || doc.acceptance || {};
+  let body = `## Summary
+
+${description}
+
+`;
+  if (Object.keys(acceptance).length > 0) {
+    body += `## Acceptance Criteria
+
+`;
+    for (const [key, criteria] of Object.entries(acceptance)) {
+      body += `**${key}:**
+`;
+      if (Array.isArray(criteria)) {
+        for (const item of criteria) {
+          body += `- ${item}
+`;
+        }
+      } else if (criteria && typeof criteria === "object") {
+        for (const [subkey, items] of Object.entries(criteria)) {
+          body += `- ${subkey}:
+`;
+          if (Array.isArray(items)) {
+            for (const item of items) {
+              body += `  - ${item}
+`;
+            }
+          }
+        }
+      }
+      body += `
+`;
+    }
+  }
+  body += `
+\u{1F916} Generated with [Claude Code](https://claude.com/claude-code)
+
+`;
+  body += `WU YAML: ${wuPath}`;
+  return body;
+}
+function printGhCliMissingMessage(branch, id) {
+  console.error();
+  console.error("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+  console.error("\u2551  GH CLI NOT AVAILABLE");
+  console.error("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563");
+  console.error("\u2551  The gh CLI tool is required to create PRs.");
+  console.error("\u2551");
+  console.error("\u2551  Manual PR creation steps:");
+  console.error(`\u2551  1. Push branch: git push origin ${branch}`);
+  console.error("\u2551  2. Create PR in GitHub UI");
+  console.error(`\u2551  3. After merge, run: pnpm wu:cleanup --id ${id}`);
+  console.error("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+}
+function printPRCreatedMessage(prUrl, id) {
+  console.log("\n\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+  console.log("\u2551  PR CREATED - NEXT STEPS");
+  console.log("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563");
+  console.log(`\u2551  PR URL: ${prUrl}`);
+  console.log("\u2551");
+  console.log("\u2551  Next steps:");
+  console.log("\u2551  1. Review the PR in GitHub UI");
+  console.log("\u2551  2. Merge the PR when ready");
+  console.log(`\u2551  3. Run cleanup: pnpm wu:cleanup --id ${id}`);
+  console.log("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+}
+
+export {
+  WU_DONE_COMPLETION_MODES,
+  isPRModeEnabled,
+  isGhCliAvailable,
+  createPR,
+  buildPRBody,
+  printGhCliMissingMessage,
+  printPRCreatedMessage
+};

package/dist/chunk-XKY65P2T.js

@@ -0,0 +1,304 @@
+import {
+  asRecord
+} from "./chunk-HMEVZKPQ.js";
+import {
+  createWUParser,
+  runCLI
+} from "./chunk-2GXVIN57.js";
+import {
+  GIT_DIRECTORY_NAME,
+  WORKSPACE_CONFIG_FILE_NAME,
+  findProjectRoot,
+  getConfig
+} from "./chunk-V6OJGLBA.js";
+
+// src/lane-health.ts
+import fg from "fast-glob";
+import { minimatch } from "minimatch";
+import chalk from "chalk";
+var LOG_PREFIX = "[lane:health]";
+var CONFIG_FILE_NAME = WORKSPACE_CONFIG_FILE_NAME;
+var MAX_DISPLAY_FILES = 5;
+var MAX_DISPLAY_GAPS = 10;
+var GIT_DIR_GLOB = `${GIT_DIRECTORY_NAME}/**`;
+var RECURSIVE_GIT_DIR_GLOB = `**/${GIT_DIRECTORY_NAME}/**`;
+var DEFAULT_EXCLUDE_PATTERNS = [
+  "node_modules/**",
+  GIT_DIR_GLOB,
+  "dist/**",
+  "build/**",
+  "coverage/**",
+  ".turbo/**",
+  "*.lock",
+  "pnpm-lock.yaml",
+  "package-lock.json",
+  "yarn.lock",
+  ".lumenflow/**",
+  "worktrees/**"
+];
+var CODE_FILE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".vue",
+  ".svelte",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".swift",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".cs",
+  ".rb",
+  ".php"
+];
+function parseLaneDefinition(lane) {
+  const laneObj = asRecord(lane);
+  if (!laneObj) {
+    return null;
+  }
+  if (typeof laneObj.name !== "string" || !Array.isArray(laneObj.code_paths)) {
+    return null;
+  }
+  return {
+    name: laneObj.name,
+    code_paths: laneObj.code_paths.filter((p) => typeof p === "string"),
+    wip_limit: typeof laneObj.wip_limit === "number" ? laneObj.wip_limit : void 0
+  };
+}
+function loadLaneDefinitions(projectRoot) {
+  try {
+    const config = getConfig({
+      projectRoot,
+      reload: true,
+      strictWorkspace: true
+    });
+    return (config.lanes?.definitions ?? []).map(parseLaneDefinition).filter((lane) => lane !== null);
+  } catch {
+    return [];
+  }
+}
+function patternsCanOverlap(patternA, patternB) {
+  const testPathA = patternA.replace(/\*\*/g, "test/nested").replace(/\*/g, "testfile");
+  const testPathB = patternB.replace(/\*\*/g, "test/nested").replace(/\*/g, "testfile");
+  return minimatch(testPathB, patternA) || minimatch(testPathA, patternB);
+}
+function findOverlappingFiles(patternA, patternB) {
+  const globOptions = {
+    dot: true,
+    ignore: ["**/node_modules/**", RECURSIVE_GIT_DIR_GLOB, "**/worktrees/**"],
+    followSymbolicLinks: false,
+    suppressErrors: true
+  };
+  const filesA = new Set(fg.sync(patternA, globOptions));
+  const filesB = new Set(fg.sync(patternB, globOptions));
+  return [...filesA].filter((file) => filesB.has(file));
+}
+function checkLanePairOverlap(laneA, laneB) {
+  const overlaps = [];
+  for (const pathA of laneA.code_paths) {
+    for (const pathB of laneB.code_paths) {
+      if (patternsCanOverlap(pathA, pathB)) {
+        let files = [];
+        try {
+          files = findOverlappingFiles(pathA, pathB);
+        } catch {
+        }
+        overlaps.push({
+          lanes: [laneA.name, laneB.name],
+          pattern: `${pathA} <-> ${pathB}`,
+          files
+        });
+      }
+    }
+  }
+  return overlaps;
+}
+function detectLaneOverlaps(lanes) {
+  const overlaps = [];
+  for (let i = 0; i < lanes.length; i++) {
+    for (let j = i + 1; j < lanes.length; j++) {
+      const pairOverlaps = checkLanePairOverlap(lanes[i], lanes[j]);
+      overlaps.push(...pairOverlaps);
+    }
+  }
+  return {
+    hasOverlaps: overlaps.length > 0,
+    overlaps
+  };
+}
+function buildCodeFilesPattern() {
+  const extensions = CODE_FILE_EXTENSIONS.map((ext) => ext.replace(".", "")).join(",");
+  return `**/*.{${extensions}}`;
+}
+function detectCoverageGaps(lanes, options) {
+  const { projectRoot, excludePatterns = DEFAULT_EXCLUDE_PATTERNS, codeOnly = true } = options;
+  const allFilesPattern = codeOnly ? buildCodeFilesPattern() : "**/*";
+  const globOptions = {
+    cwd: projectRoot,
+    dot: true,
+    ignore: excludePatterns,
+    onlyFiles: true,
+    followSymbolicLinks: false,
+    suppressErrors: true
+  };
+  const allFiles = fg.sync(allFilesPattern, globOptions);
+  const coveredFiles = /* @__PURE__ */ new Set();
+  for (const lane of lanes) {
+    for (const pattern of lane.code_paths) {
+      const matchedFiles = fg.sync(pattern, {
+        ...globOptions,
+        ignore: ["**/node_modules/**", RECURSIVE_GIT_DIR_GLOB, "**/worktrees/**"]
+      });
+      matchedFiles.forEach((file) => coveredFiles.add(file));
+    }
+  }
+  const uncoveredFiles = allFiles.filter((file) => !coveredFiles.has(file));
+  return {
+    hasGaps: uncoveredFiles.length > 0,
+    uncoveredFiles
+  };
+}
+function getExitCode(report) {
+  return report.healthy ? 0 : 1;
+}
+function formatOverlapSection(overlap) {
+  const lines = [];
+  lines.push(`    ${chalk.cyan(overlap.lanes[0])} <-> ${chalk.cyan(overlap.lanes[1])}`);
+  lines.push(`    Pattern: ${overlap.pattern}`);
+  lines.push(`    Files (${overlap.files.length}):`);
+  const displayFiles = overlap.files.slice(0, MAX_DISPLAY_FILES);
+  displayFiles.forEach((file) => lines.push(`      - ${file}`));
+  if (overlap.files.length > MAX_DISPLAY_FILES) {
+    lines.push(`      ... and ${overlap.files.length - MAX_DISPLAY_FILES} more`);
+  }
+  lines.push("");
+  return lines;
+}
+function formatLaneHealthReport(report) {
+  const lines = [];
+  lines.push("");
+  lines.push(chalk.bold("=".repeat(60)));
+  lines.push(chalk.bold.cyan("  Lane Health Report"));
+  lines.push(chalk.bold("=".repeat(60)));
+  lines.push("");
+  if (report.healthy) {
+    lines.push(chalk.green.bold("  Status: healthy"));
+    lines.push("");
+    lines.push("  All lane configurations are valid:");
+    lines.push("    - No overlapping code_paths detected");
+    lines.push("    - All code files covered by lanes");
+  } else {
+    lines.push(chalk.red.bold("  Status: Issues detected"));
+  }
+  lines.push("");
+  if (report.overlaps.hasOverlaps) {
+    lines.push(chalk.yellow.bold("  Overlapping Code Paths"));
+    lines.push("  " + "-".repeat(40));
+    lines.push("");
+    report.overlaps.overlaps.forEach((overlap) => {
+      lines.push(...formatOverlapSection(overlap));
+    });
+  }
+  if (report.gaps.hasGaps) {
+    lines.push(chalk.yellow.bold("  Coverage Gaps"));
+    lines.push("  " + "-".repeat(40));
+    lines.push("");
+    lines.push(`    ${report.gaps.uncoveredFiles.length} files not covered by UnsafeAny lane:`);
+    lines.push("");
+    const displayFiles = report.gaps.uncoveredFiles.slice(0, MAX_DISPLAY_GAPS);
+    displayFiles.forEach((file) => lines.push(`      - ${file}`));
+    if (report.gaps.uncoveredFiles.length > MAX_DISPLAY_GAPS) {
+      lines.push(`      ... and ${report.gaps.uncoveredFiles.length - MAX_DISPLAY_GAPS} more`);
+    }
+    lines.push("");
+  }
+  lines.push(chalk.bold("=".repeat(60)));
+  lines.push("");
+  return lines.join("\n");
+}
+var log = console.log.bind(console);
+var warn = console.warn.bind(console);
+function runLaneHealthCheck(options) {
+  const { projectRoot = findProjectRoot(), checkCoverage = true, excludePatterns } = options;
+  const lanes = loadLaneDefinitions(projectRoot);
+  if (lanes.length === 0) {
+    warn(`${LOG_PREFIX} No lane definitions found in ${CONFIG_FILE_NAME}`);
+    return {
+      overlaps: { hasOverlaps: false, overlaps: [] },
+      gaps: { hasGaps: false, uncoveredFiles: [] },
+      healthy: true
+    };
+  }
+  const overlaps = detectLaneOverlaps(lanes);
+  let gaps = { hasGaps: false, uncoveredFiles: [] };
+  if (checkCoverage) {
+    gaps = detectCoverageGaps(lanes, { projectRoot, excludePatterns });
+  }
+  return {
+    overlaps,
+    gaps,
+    healthy: !overlaps.hasOverlaps && !gaps.hasGaps
+  };
+}
+async function main() {
+  const args = createWUParser({
+    name: "lane-health",
+    description: "Check lane configuration health (WU-1188)",
+    options: [
+      { name: "json", flags: "-j, --json", type: "boolean", description: "Output as JSON" },
+      {
+        name: "verbose",
+        flags: "-v, --verbose",
+        type: "boolean",
+        description: "Show verbose output"
+      },
+      {
+        name: "no-coverage",
+        flags: "--no-coverage",
+        type: "boolean",
+        description: "Skip coverage gap detection"
+      }
+    ],
+    required: []
+  });
+  const {
+    json,
+    verbose,
+    "no-coverage": noCoverage
+  } = args;
+  const projectRoot = findProjectRoot();
+  if (verbose) {
+    log(`${LOG_PREFIX} Checking lane health in: ${projectRoot}`);
+  }
+  const report = runLaneHealthCheck({
+    projectRoot,
+    checkCoverage: !noCoverage
+  });
+  if (json) {
+    log(JSON.stringify(report, null, 2));
+  } else {
+    log(formatLaneHealthReport(report));
+  }
+  process.exit(getExitCode(report));
+}
+if (import.meta.main) {
+  void runCLI(main);
+}
+
+export {
+  loadLaneDefinitions,
+  detectLaneOverlaps,
+  detectCoverageGaps,
+  getExitCode,
+  formatLaneHealthReport,
+  runLaneHealthCheck,
+  main
+};

package/dist/chunk-Y4CQZY65.js

@@ -0,0 +1,57 @@
+// src/constants.ts
+var GIT_SUMMARY_PREVIEW_LENGTH = 500;
+var SYSTEM_PROMPT_PREVIEW_LENGTH = 500;
+var USER_PROMPT_PREVIEW_LENGTH = 1e3;
+var CONTENT_PREVIEW_LENGTH = 200;
+var DISCOVERY_CONTENT_TRUNCATION_LENGTH = 60;
+var ISSUE_TITLE_TRUNCATION_LENGTH = 40;
+var ISSUE_TITLE_TRUNCATED_TEXT_LENGTH = 37;
+var FLOW_REPORT_TITLE_COLUMN_WIDTH = 25;
+var WU_ID_COLUMN_WIDTH = 8;
+var LANE_COLUMN_WIDTH = 15;
+var CLEANUP_LIST_DISPLAY_LIMIT = 10;
+var FLOW_REPORT_WU_DISPLAY_LIMIT = 10;
+var TOP_ISSUES_DISPLAY_LIMIT = 5;
+var RECENT_ISSUES_DISPLAY_LIMIT = 5;
+var GATE_NAME_COLUMN_WIDTH = 20;
+var SEVERITY_PADDING_WIDTH = 10;
+var CATEGORY_PADDING_WIDTH = 20;
+var GIT_CONTEXT_MAX_TOKENS = 500;
+var LOG_TAIL_MAX_LINES = 40;
+var LOG_TAIL_MAX_BYTES = 64 * 1024;
+var ONE_DECIMAL_ROUNDING_FACTOR = 10;
+var JSON_INDENT = 2;
+var BYTES_PER_KB = 1024;
+function formatBytes(bytes) {
+  if (bytes < BYTES_PER_KB) {
+    return `${bytes} B`;
+  }
+  const kb = (bytes / BYTES_PER_KB).toFixed(1);
+  return `${kb} KB`;
+}
+
+export {
+  GIT_SUMMARY_PREVIEW_LENGTH,
+  SYSTEM_PROMPT_PREVIEW_LENGTH,
+  USER_PROMPT_PREVIEW_LENGTH,
+  CONTENT_PREVIEW_LENGTH,
+  DISCOVERY_CONTENT_TRUNCATION_LENGTH,
+  ISSUE_TITLE_TRUNCATION_LENGTH,
+  ISSUE_TITLE_TRUNCATED_TEXT_LENGTH,
+  FLOW_REPORT_TITLE_COLUMN_WIDTH,
+  WU_ID_COLUMN_WIDTH,
+  LANE_COLUMN_WIDTH,
+  CLEANUP_LIST_DISPLAY_LIMIT,
+  FLOW_REPORT_WU_DISPLAY_LIMIT,
+  TOP_ISSUES_DISPLAY_LIMIT,
+  RECENT_ISSUES_DISPLAY_LIMIT,
+  GATE_NAME_COLUMN_WIDTH,
+  SEVERITY_PADDING_WIDTH,
+  CATEGORY_PADDING_WIDTH,
+  GIT_CONTEXT_MAX_TOKENS,
+  LOG_TAIL_MAX_LINES,
+  LOG_TAIL_MAX_BYTES,
+  ONE_DECIMAL_ROUNDING_FACTOR,
+  JSON_INDENT,
+  formatBytes
+};

package/dist/chunk-YFEXKLVE.js

@@ -0,0 +1,194 @@
+import {
+  MEMORY_FILE_NAME,
+  loadMemory
+} from "./chunk-DFR4DJBM.js";
+import {
+  LUMENFLOW_MEMORY_PATHS
+} from "./chunk-4N74J3UT.js";
+import {
+  MS_PER_DAY,
+  MS_PER_HOUR
+} from "./chunk-V6OJGLBA.js";
+import {
+  ErrorCodes,
+  createError
+} from "./chunk-RXRKBBSM.js";
+
+// ../memory/dist/mem-delete-core.js
+import fs from "fs/promises";
+import path from "path";
+var DURATION_MULTIPLIERS = {
+  h: MS_PER_HOUR,
+  d: MS_PER_DAY,
+  w: 7 * MS_PER_DAY
+};
+function parseDuration(duration) {
+  const durationRegex = /^(\d+)([hdw])$/;
+  const match = durationRegex.exec(duration);
+  if (!match || match.length < 3) {
+    throw createError(ErrorCodes.INVALID_DURATION, `Invalid duration format: ${duration}. Use format like '7d', '24h', '2w'`);
+  }
+  const valueStr = match[1];
+  const unit = match[2];
+  if (!valueStr || !unit) {
+    throw createError(ErrorCodes.INVALID_DURATION, `Invalid duration format: ${duration}. Use format like '7d', '24h', '2w'`);
+  }
+  const value = parseInt(valueStr, 10);
+  const multiplier = DURATION_MULTIPLIERS[unit];
+  if (!multiplier) {
+    throw createError(ErrorCodes.INVALID_DURATION, `Unknown duration unit: ${unit}`);
+  }
+  return value * multiplier;
+}
+function matchesTag(node, tag) {
+  return Array.isArray(node.tags) && node.tags.includes(tag);
+}
+function isOlderThan(node, durationMs, referenceDate) {
+  const nodeDate = new Date(node.created_at);
+  const cutoffDate = new Date(referenceDate.getTime() - durationMs);
+  return nodeDate < cutoffDate;
+}
+function isAlreadyDeleted(node) {
+  return node.metadata?.status === "deleted";
+}
+function markAsDeleted(node) {
+  return {
+    ...node,
+    metadata: {
+      ...node.metadata,
+      status: "deleted",
+      deleted_at: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function processNodeIdsFilter(nodeIds, nodeMap, toDeleteSet, errors) {
+  for (const nodeId of nodeIds) {
+    const node = nodeMap.get(nodeId);
+    if (node) {
+      toDeleteSet.add(nodeId);
+    } else {
+      errors.push(`Node not found: ${nodeId}`);
+    }
+  }
+}
+function processTagFilter(nodes, tag, toDeleteSet) {
+  for (const node of nodes) {
+    if (matchesTag(node, tag)) {
+      toDeleteSet.add(node.id);
+    }
+  }
+}
+function processOlderThanFilter(nodes, olderThan, referenceDate, tag, hasNodeIds, toDeleteSet) {
+  const durationMs = parseDuration(olderThan);
+  for (const node of nodes) {
+    const nodeIsOld = isOlderThan(node, durationMs, referenceDate);
+    if (tag) {
+      const shouldInclude = nodeIsOld && matchesTag(node, tag);
+      if (shouldInclude) {
+        toDeleteSet.add(node.id);
+      } else {
+        toDeleteSet.delete(node.id);
+      }
+    } else if (!hasNodeIds && nodeIsOld) {
+      toDeleteSet.add(node.id);
+    }
+  }
+}
+function findNodesToDelete(nodes, options) {
+  const { nodeIds, tag, olderThan, referenceDate = /* @__PURE__ */ new Date() } = options;
+  const errors = [];
+  const toDeleteSet = /* @__PURE__ */ new Set();
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    nodeMap.set(node.id, node);
+  }
+  if (nodeIds && nodeIds.length > 0) {
+    processNodeIdsFilter(nodeIds, nodeMap, toDeleteSet, errors);
+  }
+  if (tag) {
+    processTagFilter(nodes, tag, toDeleteSet);
+  }
+  if (olderThan) {
+    const hasNodeIds = Boolean(nodeIds && nodeIds.length > 0);
+    processOlderThanFilter(nodes, olderThan, referenceDate, tag, hasNodeIds, toDeleteSet);
+  }
+  const toDelete = [];
+  for (const nodeId of toDeleteSet) {
+    const node = nodeMap.get(nodeId);
+    if (node) {
+      toDelete.push(node);
+    }
+  }
+  return { toDelete, errors };
+}
+async function writeUpdatedNodes(baseDir, nodes) {
+  const filePath = path.join(baseDir, MEMORY_FILE_NAME);
+  const content = nodes.map((node) => JSON.stringify(node)).join("\n") + "\n";
+  await fs.writeFile(filePath, content, "utf-8");
+}
+async function deleteMemoryNodes(baseDir, options) {
+  const { nodeIds, tag, olderThan, dryRun = false } = options;
+  if ((!nodeIds || nodeIds.length === 0) && !tag && !olderThan) {
+    return {
+      success: false,
+      deletedCount: 0,
+      deletedIds: [],
+      skippedIds: [],
+      dryRun,
+      errors: ["At least one filter (nodeIds, tag, or olderThan) is required"]
+    };
+  }
+  const memoryDir = path.join(baseDir, LUMENFLOW_MEMORY_PATHS.MEMORY_DIR);
+  let memory;
+  try {
+    memory = await loadMemory(memoryDir, { includeArchived: true });
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    return {
+      success: false,
+      deletedCount: 0,
+      deletedIds: [],
+      skippedIds: [],
+      dryRun,
+      errors: [`Failed to load memory: ${errMsg}`]
+    };
+  }
+  const { toDelete, errors } = findNodesToDelete(memory.nodes, options);
+  const deletedIds = [];
+  const skippedIds = [];
+  const nodesToUpdate = [];
+  for (const node of toDelete) {
+    if (isAlreadyDeleted(node)) {
+      skippedIds.push(node.id);
+      errors.push(`Node already deleted: ${node.id}`);
+    } else {
+      deletedIds.push(node.id);
+      nodesToUpdate.push(node);
+    }
+  }
+  if (!dryRun && nodesToUpdate.length > 0) {
+    const deletedIdSet = new Set(deletedIds);
+    const updatedNodes = memory.nodes.map((node) => {
+      if (deletedIdSet.has(node.id)) {
+        return markAsDeleted(node);
+      }
+      return node;
+    });
+    await writeUpdatedNodes(memoryDir, updatedNodes);
+  }
+  const hasNotFoundErrors = errors.some((e) => e.startsWith("Node not found:"));
+  const allNodesHandled = deletedIds.length > 0 || skippedIds.length > 0;
+  const success = !hasNotFoundErrors || allNodesHandled;
+  return {
+    success,
+    deletedCount: deletedIds.length,
+    deletedIds,
+    skippedIds,
+    dryRun,
+    errors
+  };
+}
+
+export {
+  deleteMemoryNodes
+};