@a-company/paradigm 5.10.0 → 5.21.0

package/dist/echo-O2LY7CC2.js

@@ -1,248 +0,0 @@
-#!/usr/bin/env node
-import {
-  log
-} from "./chunk-4NCFWYGG.js";
-import "./chunk-PDX44BCA.js";
-
-// src/commands/echo.ts
-import * as fs from "fs";
-import * as path from "path";
-import chalk from "chalk";
-var ECHOES_TEMPLATE = `# Echoes - Error to Symbol Mapping
-# When errors occur, they echo back to their source symbol.
-# Run \`paradigm echo ERROR_CODE\` to look up context.
-
-version: "1.0"
-
-errors:
-  # Example error mapping
-  AUTH_REQUIRED:
-    symbol: "^authenticated"
-    location: "src/middleware/auth.ts"
-    ripple:
-      - "@checkout"
-      - "@profile"
-      - "@settings"
-    resolution: "Ensure user token is passed in request headers"
-
-  # Add your error mappings below
-  # ERROR_CODE:
-  #   symbol: "^portal-name"       # or signal: "!signal-name"
-  #   location: "path/to/file.ts"
-  #   ripple:
-  #     - "@feature1"
-  #     - "@feature2"
-  #   resolution: "How to fix this error"
-`;
-function parseEchoes(content) {
-  const data = {
-    version: "1.0",
-    errors: {}
-  };
-  const lines = content.split("\n");
-  let currentError = null;
-  let currentEntry = {};
-  let inRipple = false;
-  for (const line of lines) {
-    if (line.trim().startsWith("#") || line.trim() === "") continue;
-    const versionMatch = line.match(/^version:\s*"?([^"]+)"?/);
-    if (versionMatch) {
-      data.version = versionMatch[1];
-      continue;
-    }
-    if (line.match(/^errors:\s*$/)) continue;
-    const errorKeyMatch = line.match(/^  ([A-Z_][A-Z0-9_]*):\s*$/);
-    if (errorKeyMatch) {
-      if (currentError && Object.keys(currentEntry).length > 0) {
-        data.errors[currentError] = currentEntry;
-      }
-      currentError = errorKeyMatch[1];
-      currentEntry = {};
-      inRipple = false;
-      continue;
-    }
-    if (currentError) {
-      const symbolMatch = line.match(/^\s{4}symbol:\s*"?([^"]+)"?/);
-      if (symbolMatch) {
-        currentEntry.symbol = symbolMatch[1];
-        inRipple = false;
-        continue;
-      }
-      const signalMatch = line.match(/^\s{4}signal:\s*"?([^"]+)"?/);
-      if (signalMatch) {
-        currentEntry.signal = signalMatch[1];
-        inRipple = false;
-        continue;
-      }
-      const locationMatch = line.match(/^\s{4}location:\s*"?([^"]+)"?/);
-      if (locationMatch) {
-        currentEntry.location = locationMatch[1];
-        inRipple = false;
-        continue;
-      }
-      const resolutionMatch = line.match(/^\s{4}resolution:\s*"?([^"]+)"?/);
-      if (resolutionMatch) {
-        currentEntry.resolution = resolutionMatch[1];
-        inRipple = false;
-        continue;
-      }
-      if (line.match(/^\s{4}ripple:\s*$/)) {
-        currentEntry.ripple = [];
-        inRipple = true;
-        continue;
-      }
-      if (inRipple) {
-        const rippleMatch = line.match(/^\s{6}-\s*"?([^"]+)"?/);
-        if (rippleMatch) {
-          if (!currentEntry.ripple) currentEntry.ripple = [];
-          currentEntry.ripple.push(rippleMatch[1]);
-          continue;
-        }
-      }
-    }
-  }
-  if (currentError && Object.keys(currentEntry).length > 0) {
-    data.errors[currentError] = currentEntry;
-  }
-  return data;
-}
-async function echoCommand(errorCode, targetPath, options = {}) {
-  const cwd = process.cwd();
-  const absolutePath = targetPath ? path.resolve(cwd, targetPath) : cwd;
-  const echoesPath = path.join(absolutePath, ".paradigm", "echoes.yaml");
-  log.command("echo").debug("Looking up error code", { errorCode });
-  if (!fs.existsSync(echoesPath)) {
-    if (options.json) {
-      console.log(JSON.stringify({ found: false, error: "No echoes.yaml found" }, null, 2));
-      return;
-    }
-    log.command("echo").warn("No echoes.yaml found");
-    console.log(chalk.yellow("\n\u{1F4E2} No echoes.yaml found.\n"));
-    console.log(chalk.gray("  Run `paradigm echo --init` to create one.\n"));
-    return;
-  }
-  const content = fs.readFileSync(echoesPath, "utf8");
-  const data = parseEchoes(content);
-  log.component("echoes-parser").debug("Echoes file parsed", { count: Object.keys(data.errors).length });
-  const entry = data.errors[errorCode.toUpperCase()];
-  if (!entry) {
-    log.command("echo").warn("Error code not found", { errorCode });
-    if (options.json) {
-      console.log(JSON.stringify({
-        found: false,
-        errorCode: errorCode.toUpperCase(),
-        available: Object.keys(data.errors)
-      }, null, 2));
-      return;
-    }
-    console.log(chalk.yellow(`
-\u{1F4E2} No echo found for: ${errorCode}
-`));
-    const available = Object.keys(data.errors);
-    if (available.length > 0) {
-      console.log(chalk.gray("  Available error codes:"));
-      for (const code of available.slice(0, 10)) {
-        const e = data.errors[code];
-        const symbolInfo = e.symbol || e.signal || "";
-        console.log(chalk.gray(`    ${code} \u2192 ${symbolInfo}`));
-      }
-      if (available.length > 10) {
-        console.log(chalk.gray(`    ... and ${available.length - 10} more`));
-      }
-    }
-    console.log("");
-    return;
-  }
-  log.command("echo").success("Error code found", { errorCode, hasSymbol: !!entry.symbol, hasResolution: !!entry.resolution });
-  if (options.json) {
-    console.log(JSON.stringify({
-      found: true,
-      errorCode: errorCode.toUpperCase(),
-      ...entry
-    }, null, 2));
-    return;
-  }
-  console.log(chalk.blue(`
-\u{1F4E2} Echo: ${chalk.cyan(errorCode)}
-`));
-  console.log(chalk.gray("\u2500".repeat(50)));
-  if (entry.symbol) {
-    console.log(`  Symbol:     ${chalk.red(entry.symbol)}`);
-  }
-  if (entry.signal) {
-    console.log(`  Signal:     ${chalk.yellow(entry.signal)}`);
-  }
-  if (entry.location) {
-    console.log(`  Location:   ${chalk.gray(entry.location)}`);
-  }
-  if (entry.ripple && entry.ripple.length > 0) {
-    console.log(`  Ripple:     ${entry.ripple.map((r) => {
-      if (r.startsWith("@")) return chalk.blue(r);
-      if (r.startsWith("#")) return chalk.green(r);
-      if (r.startsWith("^")) return chalk.red(r);
-      return chalk.gray(r);
-    }).join(", ")}`);
-  }
-  console.log("");
-  if (entry.resolution) {
-    console.log(chalk.white("Resolution:"));
-    console.log(chalk.gray("\u2500".repeat(50)));
-    console.log(chalk.green(`  ${entry.resolution}`));
-    console.log("");
-  }
-  console.log(chalk.gray("Tip: Run `paradigm ripple " + (entry.symbol || entry.signal || "") + "` for full impact analysis.\n"));
-}
-async function echoInitCommand(targetPath, options = {}) {
-  const cwd = process.cwd();
-  const absolutePath = targetPath ? path.resolve(cwd, targetPath) : cwd;
-  const paradigmDir = path.join(absolutePath, ".paradigm");
-  const echoesPath = path.join(paradigmDir, "echoes.yaml");
-  if (!fs.existsSync(paradigmDir)) {
-    fs.mkdirSync(paradigmDir, { recursive: true });
-  }
-  if (fs.existsSync(echoesPath) && !options.quiet) {
-    console.log(chalk.yellow("\n\u26A0\uFE0F  echoes.yaml already exists.\n"));
-    console.log(chalk.gray(`  Path: ${echoesPath}
-`));
-    return;
-  }
-  fs.writeFileSync(echoesPath, ECHOES_TEMPLATE, "utf8");
-  if (!options.quiet) {
-    console.log(chalk.green("\n\u2713 Created .paradigm/echoes.yaml\n"));
-    console.log(chalk.gray("  Edit this file to add error-to-symbol mappings."));
-    console.log(chalk.gray("  Then use `paradigm echo ERROR_CODE` to look them up.\n"));
-  }
-}
-async function echoListCommand(targetPath, _options = {}) {
-  const cwd = process.cwd();
-  const absolutePath = targetPath ? path.resolve(cwd, targetPath) : cwd;
-  const echoesPath = path.join(absolutePath, ".paradigm", "echoes.yaml");
-  if (!fs.existsSync(echoesPath)) {
-    console.log(chalk.yellow("\n\u{1F4E2} No echoes.yaml found.\n"));
-    console.log(chalk.gray("  Run `paradigm echo --init` to create one.\n"));
-    return;
-  }
-  const content = fs.readFileSync(echoesPath, "utf8");
-  const data = parseEchoes(content);
-  console.log(chalk.blue("\n\u{1F4E2} All Echoes\n"));
-  console.log(chalk.gray("\u2500".repeat(50)));
-  const codes = Object.keys(data.errors);
-  if (codes.length === 0) {
-    console.log(chalk.gray("  No error mappings defined yet.\n"));
-    return;
-  }
-  for (const code of codes) {
-    const entry = data.errors[code];
-    const symbol = entry.symbol || entry.signal || "";
-    const location = entry.location ? chalk.gray(` @ ${entry.location}`) : "";
-    console.log(`  ${chalk.cyan(code.padEnd(20))} \u2192 ${symbol}${location}`);
-  }
-  console.log(chalk.gray(`
-  Total: ${codes.length} error mappings
-`));
-}
-export {
-  echoCommand,
-  echoInitCommand,
-  echoListCommand
-};

package/dist/edit-R2HNLMOG.js

@@ -1,63 +0,0 @@
-#!/usr/bin/env node
-import {
-  loadLoreEntry,
-  updateLoreEntry
-} from "./chunk-EKGMAM62.js";
-import "./chunk-PDX44BCA.js";
-
-// src/commands/lore/edit.ts
-import chalk from "chalk";
-async function loreEditCommand(id, options) {
-  const rootDir = process.cwd();
-  const entry = await loadLoreEntry(rootDir, id);
-  if (!entry) {
-    console.error(chalk.red(`
-  Entry not found: ${id}
-`));
-    process.exitCode = 1;
-    return;
-  }
-  const partial = {};
-  if (options.title) partial.title = options.title;
-  if (options.summary) partial.summary = options.summary;
-  if (options.type) {
-    const validTypes = ["agent-session", "human-note", "decision", "review", "incident", "milestone"];
-    if (!validTypes.includes(options.type)) {
-      console.error(chalk.red(`Invalid type: ${options.type}. Valid: ${validTypes.join(", ")}`));
-      process.exitCode = 1;
-      return;
-    }
-    partial.type = options.type;
-  }
-  if (options.symbols) {
-    partial.symbols_touched = options.symbols.split(",").map((s) => s.trim());
-  }
-  if (options.tags) {
-    partial.tags = options.tags.split(",").map((t) => t.trim());
-  }
-  if (options.learnings) {
-    partial.learnings = options.learnings.split(",").map((l) => l.trim());
-  }
-  if (Object.keys(partial).length === 0) {
-    console.log(chalk.yellow("\n  No changes specified. Use --title, --summary, --type, --symbols, --tags, or --learnings.\n"));
-    return;
-  }
-  const success = await updateLoreEntry(rootDir, id, partial);
-  if (success) {
-    console.log(chalk.green(`
-  Updated lore entry: ${id}`));
-    for (const [key, value] of Object.entries(partial)) {
-      const display = Array.isArray(value) ? value.join(", ") : String(value);
-      console.log(chalk.gray(`    ${key}: ${display}`));
-    }
-    console.log();
-  } else {
-    console.error(chalk.red(`
-  Failed to update: ${id}
-`));
-    process.exitCode = 1;
-  }
-}
-export {
-  loreEditCommand
-};

package/dist/event-25OJKDCE.js

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-import "./chunk-PDX44BCA.js";
-
-// src/commands/event.ts
-import * as fs from "fs";
-import * as path from "path";
-async function eventEmitCommand(options) {
-  const cwd = process.cwd();
-  const eventsDir = path.join(cwd, ".paradigm", "events");
-  const streamFile = path.join(eventsDir, "stream.jsonl");
-  const now = Date.now();
-  const rand = Math.floor(Math.random() * 9999).toString().padStart(4, "0");
-  const event = {
-    id: `ev-${now}-${rand}`,
-    type: options.type,
-    source: options.source,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    ...options.path ? { path: options.path } : {},
-    ...options.symbols?.length ? { symbols: options.symbols } : {},
-    ...options.context ? { context: options.context } : {},
-    ...options.severity ? { severity: options.severity } : {}
-  };
-  try {
-    fs.mkdirSync(eventsDir, { recursive: true });
-    fs.appendFileSync(streamFile, JSON.stringify(event) + "\n", "utf8");
-  } catch {
-  }
-}
-export {
-  eventEmitCommand
-};

package/dist/export-IWVL7XLF.js

@@ -1,38 +0,0 @@
-#!/usr/bin/env node
-import {
-  AuditLogger
-} from "./chunk-PBHIFAL4.js";
-import "./chunk-PDX44BCA.js";
-
-// src/commands/team/export.ts
-import * as path from "path";
-import chalk from "chalk";
-async function teamExportCommand(targetPath, options) {
-  const rootDir = targetPath ? path.resolve(targetPath) : process.cwd();
-  let from;
-  let to;
-  if (options.from) {
-    from = new Date(options.from);
-  }
-  if (options.to) {
-    to = new Date(options.to);
-  }
-  const auditLogger = new AuditLogger(rootDir);
-  const format = options.format || "json";
-  let output;
-  if (format === "csv") {
-    output = auditLogger.exportToCsv({ from, to });
-  } else {
-    output = auditLogger.exportToJson({ from, to });
-  }
-  if (options.output) {
-    const fs = await import("fs");
-    fs.writeFileSync(options.output, output);
-    console.log(chalk.green(`\u2713 Exported to ${options.output}`));
-  } else {
-    console.log(output);
-  }
-}
-export {
-  teamExportCommand
-};

package/dist/flow-CRRVV3O3.js

@@ -1,185 +0,0 @@
-#!/usr/bin/env node
-import {
-  log
-} from "./chunk-4NCFWYGG.js";
-import "./chunk-YMDLDELF.js";
-import "./chunk-PDX44BCA.js";
-
-// src/commands/flow.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-import chalk from "chalk";
-
-// src/core/flow-validator.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as yaml from "js-yaml";
-import { execSync } from "child_process";
-
-// src/core/flow-schema.ts
-function configToFlowDefinitions(config) {
-  return Object.entries(config.flows).map(([id, flow]) => ({
-    id,
-    ...flow
-  }));
-}
-
-// src/core/flow-validator.ts
-function loadFlowsConfig(rootDir) {
-  const flowsPath = path.join(rootDir, ".paradigm", "flows.yaml");
-  if (!fs.existsSync(flowsPath)) {
-    return null;
-  }
-  try {
-    const content = fs.readFileSync(flowsPath, "utf-8");
-    return yaml.load(content);
-  } catch {
-    return null;
-  }
-}
-function loadFlowsFromPurpose(rootDir) {
-  const flows = [];
-  try {
-    const result = execSync(
-      `find "${rootDir}" -name ".purpose" -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null || true`,
-      { encoding: "utf-8" }
-    );
-    for (const purposePath of result.split("\n").filter(Boolean)) {
-      try {
-        const content = fs.readFileSync(purposePath, "utf-8");
-        const flowsMatch = content.match(/flows:\s*\n([\s\S]*?)(?=\n[a-z_]+:|$)/);
-        if (flowsMatch) {
-          const flowsYaml = yaml.load(`flows:
-${flowsMatch[1]}`);
-          if (flowsYaml && typeof flowsYaml === "object" && "flows" in flowsYaml) {
-            const flowsData = flowsYaml.flows;
-            for (const [id, flow] of Object.entries(flowsData)) {
-              flows.push({
-                id,
-                ...flow,
-                definedIn: path.relative(rootDir, purposePath)
-              });
-            }
-          }
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-  return flows;
-}
-function getAllFlows(rootDir) {
-  const flows = [];
-  const config = loadFlowsConfig(rootDir);
-  if (config) {
-    const configFlows = configToFlowDefinitions(config);
-    for (const flow of configFlows) {
-      flow.definedIn = ".paradigm/flows.yaml";
-      flows.push(flow);
-    }
-  }
-  const purposeFlows = loadFlowsFromPurpose(rootDir);
-  for (const flow of purposeFlows) {
-    if (!flows.some((f) => f.id === flow.id)) {
-      flows.push(flow);
-    }
-  }
-  return flows;
-}
-function generateMermaidDiagram(flow) {
-  const lines = [];
-  lines.push("```mermaid");
-  lines.push("flowchart TD");
-  lines.push(`  START([${escapeLabel(flow.trigger)}])`);
-  let prevId = "START";
-  for (let i = 0; i < flow.steps.length; i++) {
-    const step = flow.steps[i];
-    const nodeId = `S${i}`;
-    const label = escapeLabel(step.symbol);
-    switch (step.type) {
-      case "gate": {
-        const gateStep = step;
-        lines.push(`  ${nodeId}{${label}}`);
-        lines.push(`  ${prevId} --> ${nodeId}`);
-        if (gateStep.failResponse || step.errorSignal) {
-          const denyId = `DENY${i}`;
-          const denyLabel = gateStep.failResponse || step.errorSignal || "Denied";
-          lines.push(`  ${denyId}[/${escapeLabel(denyLabel)}/]`);
-          lines.push(`  ${nodeId} -->|deny| ${denyId}`);
-        }
-        break;
-      }
-      case "action":
-        lines.push(`  ${nodeId}[${label}]`);
-        lines.push(`  ${prevId} -->|${step.optional ? "optional" : "allow"}| ${nodeId}`);
-        break;
-      case "signal":
-        lines.push(`  ${nodeId}([${label}])`);
-        lines.push(`  ${prevId} --> ${nodeId}`);
-        break;
-    }
-    prevId = nodeId;
-  }
-  if (flow.successSignal) {
-    lines.push(`  SUCCESS([${escapeLabel(flow.successSignal)}])`);
-    lines.push(`  ${prevId} --> SUCCESS`);
-  }
-  lines.push("");
-  lines.push("  classDef gate fill:#f9d71c,stroke:#333,color:#000");
-  lines.push("  classDef action fill:#4a90d9,stroke:#333,color:#fff");
-  lines.push("  classDef signal fill:#50c878,stroke:#333,color:#fff");
-  for (let i = 0; i < flow.steps.length; i++) {
-    const step = flow.steps[i];
-    lines.push(`  class S${i} ${step.type}`);
-  }
-  lines.push("```");
-  return lines.join("\n");
-}
-function escapeLabel(text) {
-  return text.replace(/"/g, '\\"').replace(/[[\]{}()]/g, "");
-}
-
-// src/commands/flow.ts
-async function flowDiagramCommand(flowId, options) {
-  const rootDir = process.cwd();
-  const config = loadFlowsConfig(rootDir);
-  if (!config) {
-    console.log(chalk.red("\n\u274C No flows.yaml found"));
-    console.log(chalk.gray("Create .paradigm/flows.yaml to define flows.\n"));
-    process.exit(1);
-  }
-  const flows = getAllFlows(rootDir);
-  const normalizedId = flowId.startsWith("$") ? flowId : `$${flowId}`;
-  const flow = flows.find((f) => f.id === normalizedId || f.id === flowId);
-  if (!flow) {
-    console.log(chalk.red(`
-\u274C Flow not found: ${flowId}`));
-    console.log(chalk.gray(`
-Available flows:`));
-    for (const f of flows) {
-      console.log(chalk.gray(`  ${f.id} \u2014 ${f.name}`));
-    }
-    console.log("");
-    process.exit(1);
-  }
-  log.command("flow-diagram").info("Generating Mermaid diagram", { flowId: flow.id });
-  const diagram = generateMermaidDiagram(flow);
-  if (options.output) {
-    const outputPath = path2.resolve(rootDir, options.output);
-    fs2.writeFileSync(outputPath, diagram, "utf-8");
-    console.log(chalk.green(`
-\u2713 Diagram written to ${path2.relative(rootDir, outputPath)}
-`));
-  } else {
-    console.log("");
-    console.log(chalk.blue(`Flow: ${flow.name} (${flow.id})`));
-    console.log(chalk.gray(`Trigger: ${flow.trigger}`));
-    console.log("");
-    console.log(diagram);
-    console.log("");
-  }
-}
-export {
-  flowDiagramCommand
-};

package/dist/global-3NG5JXUB.js

@@ -1,136 +0,0 @@
-#!/usr/bin/env node
-import {
-  log
-} from "./chunk-4NCFWYGG.js";
-import "./chunk-PDX44BCA.js";
-
-// src/commands/global.ts
-import * as fs from "fs";
-import * as path from "path";
-import chalk from "chalk";
-import ora from "ora";
-function parseDuration(duration) {
-  const match = duration.match(/^(\d+)(d|h|m)$/);
-  if (!match) return null;
-  const [, num, unit] = match;
-  const value = parseInt(num, 10);
-  switch (unit) {
-    case "d":
-      return value * 24 * 60 * 60 * 1e3;
-    case "h":
-      return value * 60 * 60 * 1e3;
-    case "m":
-      return value * 60 * 1e3;
-    default:
-      return null;
-  }
-}
-function findOldFiles(dir, cutoffMs) {
-  const results = [];
-  if (!fs.existsSync(dir)) return results;
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      results.push(...findOldFiles(fullPath, cutoffMs));
-    } else if (entry.isFile()) {
-      try {
-        const stat = fs.statSync(fullPath);
-        const age = Date.now() - stat.mtimeMs;
-        if (age > cutoffMs) {
-          const days = Math.floor(age / (24 * 60 * 60 * 1e3));
-          results.push({ path: fullPath, age: `${days}d` });
-        }
-      } catch {
-      }
-    }
-  }
-  return results;
-}
-async function globalCleanCommand(options) {
-  const homeDir = process.env.HOME || process.env.USERPROFILE || "~";
-  const globalDir = path.join(homeDir, ".paradigm");
-  const spinner = ora();
-  if (!fs.existsSync(globalDir)) {
-    console.log(chalk.yellow("\nNo ~/.paradigm/ directory found.\n"));
-    return;
-  }
-  const durationStr = options.olderThan || "90d";
-  const durationMs = parseDuration(durationStr);
-  if (!durationMs) {
-    console.log(chalk.red(`
-Invalid duration: ${durationStr}`));
-    console.log(chalk.gray("Use format: 90d, 30d, 7d, 24h, etc.\n"));
-    process.exit(1);
-  }
-  console.log(chalk.blue(`
-Global Brain Rotation
-`));
-  console.log(chalk.gray(`  Scanning ~/.paradigm/ for files older than ${durationStr}...
-`));
-  spinner.start("Scanning...");
-  const cleanableDirs = ["wisdom", "lore", "history", "cache"];
-  const allOldFiles = [];
-  for (const sub of cleanableDirs) {
-    const subDir = path.join(globalDir, sub);
-    const oldFiles = findOldFiles(subDir, durationMs);
-    allOldFiles.push(...oldFiles);
-  }
-  spinner.stop();
-  if (allOldFiles.length === 0) {
-    console.log(chalk.green(`  No files older than ${durationStr} found.
-`));
-    return;
-  }
-  console.log(chalk.gray(`  Found ${allOldFiles.length} files older than ${durationStr}:
-`));
-  for (const file of allOldFiles.slice(0, 20)) {
-    const relPath = path.relative(globalDir, file.path);
-    console.log(chalk.gray(`    ${file.age} old - ${relPath}`));
-  }
-  if (allOldFiles.length > 20) {
-    console.log(chalk.gray(`    ... and ${allOldFiles.length - 20} more`));
-  }
-  if (options.dryRun) {
-    console.log(chalk.yellow(`
-  Dry run - no files deleted.
-`));
-    log.command("global-clean").info("Dry run completed", { count: allOldFiles.length, olderThan: durationStr });
-    return;
-  }
-  spinner.start(`Deleting ${allOldFiles.length} files...`);
-  let deleted = 0;
-  for (const file of allOldFiles) {
-    try {
-      fs.unlinkSync(file.path);
-      deleted++;
-    } catch {
-    }
-  }
-  spinner.succeed(`Deleted ${deleted} files older than ${durationStr}`);
-  for (const sub of cleanableDirs) {
-    const subDir = path.join(globalDir, sub);
-    cleanEmptyDirs(subDir);
-  }
-  console.log("");
-  log.command("global-clean").success("Global brain rotation completed", { deleted, olderThan: durationStr });
-}
-function cleanEmptyDirs(dir) {
-  if (!fs.existsSync(dir)) return;
-  const entries = fs.readdirSync(dir);
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry);
-    if (fs.statSync(fullPath).isDirectory()) {
-      cleanEmptyDirs(fullPath);
-    }
-  }
-  if (fs.readdirSync(dir).length === 0) {
-    try {
-      fs.rmdirSync(dir);
-    } catch {
-    }
-  }
-}
-export {
-  globalCleanCommand
-};