@reliverse/dler 1.7.153 → 2.0.0

package/bin/impl/magic/magic-spells.d.ts

@@ -1,46 +0,0 @@
-/**
- * Spell engine – parses and evaluates magic comments embedded
- * in a single line of code.
- *
- * Supported directives:
- *   // <dler-replace-line-to `NEW CONTENT` [if 'cond'] [else 'alt']>
- *   // <dler-remove-line>
- *   // <dler-remove-file>
- *   // <dler-remove-comment>
- *
- * A directive is recognised whether written as:
- *   // <dler-…>                or
- *   // @ts-expect-error * <dler-…>
- *
- * Conditions (if/else) – currently supported:
- *   current file path starts with <prefix> [or <prefix> ...]
- */
-export interface SpellEvaluationContext {
-    /** Path relative to project root (slash-separated) */
-    filePath: string;
-}
-export interface SpellOutcome {
-    replacement?: string;
-    removeLine: boolean;
-    removeFile: boolean;
-}
-export type SpellDirective = "dler-replace-line-to" | "dler-remove-line" | "dler-remove-file" | "dler-remove-comment" | "dler-ignore-this-line";
-export interface SpellInfo {
-    /** The name of the spell directive */
-    name: SpellDirective;
-    /** A short description of what the spell does */
-    description: string;
-    /** Example usage of the spell */
-    example: string;
-    /** Additional notes about the spell's behavior */
-    notes?: string;
-}
-/**
- * Returns information about all available magic directives
- */
-export declare function getAvailableSpells(): SpellInfo[];
-/**
- * Evaluates a single line for magic directives and returns the effect.
- * If no directive is present, returns neutral outcome.
- */
-export declare function evaluateMagicDirective(line: string, ctx: SpellEvaluationContext): SpellOutcome;

package/bin/impl/magic/magic-spells.js

@@ -1,144 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-const SPELL_REGEX = /\/\/\s*(?:@ts-expect-error\s+.*?)?<\s*(dler-[^>\s]+)(.*?)>/i;
-const REPLACEMENT_REGEX = /`([^`]+)`/;
-const IF_CONDITION_REGEX = /\bif\s+['"`]([^'"`]+)['"`]/i;
-const ELSE_CONTENT_REGEX = /\belse\s+['"`]([^'"`]+)['"`]/i;
-const STARTS_WITH_REGEX = /current file path starts with\s+(.+)$/i;
-export function getAvailableSpells() {
-  return [
-    {
-      name: "dler-replace-line-to",
-      description: "Replaces the current line with new content, optionally based on a condition",
-      example: "// <dler-replace-line-to `export const version = \"1.0.0\";` if 'current file path starts with dist-npm'>",
-      notes: "If no condition is specified, replacement always applies. If condition is not met and else content is provided, uses else content. Otherwise keeps original line. Also supports @ts-expect-error prefix."
-    },
-    {
-      name: "dler-remove-line",
-      description: "Removes the current line from the output",
-      example: "// <dler-remove-line>",
-      notes: "Also supports @ts-expect-error prefix."
-    },
-    {
-      name: "dler-remove-file",
-      description: "Removes the entire file from the output",
-      example: "// <dler-remove-file>",
-      notes: "This directive should be placed at the top of the file for clarity. Also supports @ts-expect-error prefix."
-    },
-    {
-      name: "dler-remove-comment",
-      description: "Removes only the comment portion containing this directive from the line",
-      example: "console.log('debug info'); // <dler-remove-comment>",
-      notes: "Removes everything from '//' to the end of the line when the comment contains this directive. The code portion before the comment is preserved. Also supports @ts-expect-error prefix."
-    },
-    {
-      name: "dler-ignore-this-line",
-      description: "Prevents any magic directives on this line from being processed",
-      example: "// <dler-remove-line> // <dler-ignore-this-line>",
-      notes: "When present on a line, all magic directives on that line are ignored and the line is kept as-is. Useful for code that contains magic directive strings that shouldn't be executed."
-    }
-  ];
-}
-export function evaluateMagicDirective(line, ctx) {
-  if (line.includes("<dler-ignore-this-line>")) {
-    return NO_OP;
-  }
-  const match = line.match(SPELL_REGEX);
-  if (!match) return NO_OP;
-  const [, directive = "", body] = match;
-  if (!isValidMagicDirective(directive)) {
-    relinka("warn", `[spells] unknown directive: ${directive}`);
-    return NO_OP;
-  }
-  switch (directive) {
-    /* -------------------------------------------------------------- */
-    /* dler-remove-file                                               */
-    /* -------------------------------------------------------------- */
-    case "dler-remove-file": {
-      return { removeFile: true, removeLine: true };
-    }
-    /* -------------------------------------------------------------- */
-    /* dler-remove-line                                               */
-    /* -------------------------------------------------------------- */
-    case "dler-remove-line": {
-      return { removeLine: true, removeFile: false };
-    }
-    /* -------------------------------------------------------------- */
-    /* dler-remove-comment                                            */
-    /* -------------------------------------------------------------- */
-    case "dler-remove-comment": {
-      const commentIndex = line.indexOf("//");
-      if (commentIndex !== -1) {
-        const codeBeforeComment = line.substring(0, commentIndex).trimEnd();
-        return { replacement: codeBeforeComment, removeLine: false, removeFile: false };
-      }
-      return NO_OP;
-    }
-    /* -------------------------------------------------------------- */
-    /* dler-replace-line-to                                           */
-    /* -------------------------------------------------------------- */
-    case "dler-replace-line-to": {
-      const { replacement, elseContent, condition } = parseReplacementDirective(body ?? "");
-      if (!replacement) {
-        relinka("warn", "[spells] dler-replace-line-to missing replacement content");
-        return NO_OP;
-      }
-      const condMet = condition === void 0 ? true : evaluatePathCondition(condition, ctx);
-      if (condMet) {
-        return { replacement, removeLine: false, removeFile: false };
-      }
-      if (elseContent !== void 0) {
-        return { replacement: elseContent, removeLine: false, removeFile: false };
-      }
-      return NO_OP;
-    }
-    /* -------------------------------------------------------------- */
-    /* dler-ignore-this-line                                          */
-    /* -------------------------------------------------------------- */
-    case "dler-ignore-this-line": {
-      return NO_OP;
-    }
-    default:
-      return NO_OP;
-  }
-}
-const NO_OP = { removeLine: false, removeFile: false };
-function isValidMagicDirective(directive) {
-  return [
-    "dler-replace-line-to",
-    "dler-remove-line",
-    "dler-remove-file",
-    "dler-remove-comment",
-    "dler-ignore-this-line",
-    "dler-disable-agg"
-  ].includes(directive);
-}
-function parseReplacementDirective(body) {
-  const parts = {
-    replacement: ""
-  };
-  const replacementMatch = body.match(REPLACEMENT_REGEX);
-  if (replacementMatch?.[1]) parts.replacement = replacementMatch[1].trim();
-  const ifMatch = body.match(IF_CONDITION_REGEX);
-  if (ifMatch?.[1]) {
-    parts.condition = ifMatch[1].trim();
-  }
-  const elseMatch = body.match(ELSE_CONTENT_REGEX);
-  if (elseMatch?.[1]) parts.elseContent = elseMatch[1].trim();
-  return parts;
-}
-function evaluatePathCondition(condition, ctx) {
-  const STARTS_WITH = STARTS_WITH_REGEX.exec(condition)?.[1];
-  if (STARTS_WITH) {
-    const prefixes = STARTS_WITH.split(/\s+or\s+/i).map(
-      (p) => p.replace(/['"`]/g, "").trim().replaceAll("\\", "/")
-    );
-    return prefixes.some((p) => ctx.filePath.startsWith(p));
-  }
-  if (condition.trim()) {
-    relinka(
-      "warn",
-      `[spells] unsupported condition "${condition}" - only "current file path starts with <prefix> [or <prefix> ...]" is supported`
-    );
-  }
-  return false;
-}

package/bin/impl/merge/mod.d.ts

@@ -1,8 +0,0 @@
-export declare const DEFAULT_IGNORES: readonly ["**/.git/**", "**/node_modules/**"];
-export declare const DEFAULT_SEPARATOR_RAW = "\\n\\n";
-export declare const normalizeGlobPattern: (pattern: string) => string;
-export declare const parseCSV: (s: string) => any[];
-export declare const unescape: (s: string) => string;
-export declare const writeResult: (sections: string[], _separator: string, toFile: string | undefined, toStdout: boolean, dryRun: boolean, backup: boolean, generateSourceMap?: boolean) => Promise<void>;
-export declare const writeFilesPreserveStructure: (files: string[], outDir: string, preserveStructure: boolean, increment: boolean, concurrency: number, dryRun: boolean, backup: boolean) => Promise<void>;
-export declare const processSection: (raw: string, rel: string, prefix: string, pathAbove: boolean, injectPath: boolean) => string;

package/bin/impl/merge/mod.js

@@ -1,160 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { withEnhancedSpinner } from "@reliverse/rempts";
-import MagicString, { Bundle } from "magic-string";
-import pMap from "p-map";
-import {
-  checkPermissions,
-  handleCtxError,
-  sanitizeInput,
-  validateContent,
-  validateFileType,
-  validateMergeOperation,
-  validatePath
-} from "../utils/utils-security.js";
-export const DEFAULT_IGNORES = ["**/.git/**", "**/node_modules/**"];
-export const DEFAULT_SEPARATOR_RAW = "\\n\\n";
-export const normalizeGlobPattern = (pattern) => {
-  const sanitizedPattern = sanitizeInput(pattern);
-  if (!sanitizedPattern.includes("*") && !sanitizedPattern.includes("?") && !sanitizedPattern.endsWith("/")) {
-    return `${sanitizedPattern}/**/*`;
-  }
-  return sanitizedPattern;
-};
-export const parseCSV = (s) => s.split(",").map((t) => sanitizeInput(t.trim())).filter(Boolean);
-export const unescape = (s) => s.replace(/\\n/g, "\n").replace(/\\t/g, "	");
-export const writeResult = async (sections, _separator, toFile, toStdout, dryRun, backup, generateSourceMap = false) => {
-  try {
-    const bundle = new Bundle();
-    for (const section of sections) {
-      validateContent(section, "text");
-      bundle.addSource({
-        content: new MagicString(section)
-      });
-    }
-    const content = bundle.toString();
-    const finalContent = `${content}
-`;
-    if (toStdout || !toFile) {
-      process.stdout.write(finalContent);
-      return;
-    }
-    const sanitizedPath = sanitizeInput(toFile);
-    const dir = path.dirname(sanitizedPath);
-    if (dir && dir !== ".") {
-      await fs.ensureDir(dir);
-      await checkPermissions(dir, "write");
-    }
-    if (backup && await fs.pathExists(sanitizedPath)) {
-      const backupPath = `${sanitizedPath}.${Date.now()}.bak`;
-      await checkPermissions(sanitizedPath, "read");
-      await fs.copyFile(sanitizedPath, backupPath);
-    }
-    if (!dryRun) {
-      await checkPermissions(sanitizedPath, "write");
-      validatePath(sanitizedPath, process.cwd());
-      validateFileType("text");
-      await fs.writeFile(sanitizedPath, finalContent, "utf8");
-      if (generateSourceMap) {
-        const map = bundle.generateMap({
-          file: path.basename(sanitizedPath),
-          source: sanitizedPath,
-          includeContent: true,
-          hires: true
-        });
-        const mapPath = `${sanitizedPath}.map`;
-        await fs.writeFile(mapPath, map.toString(), "utf8");
-        const sourceMapRef = `
-//# sourceMappingURL=${path.basename(mapPath)}`;
-        await fs.appendFile(sanitizedPath, sourceMapRef, "utf8");
-      }
-    }
-  } catch (error) {
-    handleCtxError(error, "writeResult");
-  }
-};
-export const writeFilesPreserveStructure = async (files, outDir, preserveStructure, increment, concurrency, dryRun, backup) => {
-  await withEnhancedSpinner(
-    {
-      text: `Copying ${files.length} files`,
-      showTiming: true,
-      successText: "File copy operation completed",
-      failText: "File copy operation failed",
-      color: "cyan"
-    },
-    async (spinner) => {
-      try {
-        if (!files?.length) {
-          throw new Error("No files provided for merge operation");
-        }
-        const cwd = process.cwd();
-        const fileNameCounts = /* @__PURE__ */ new Map();
-        spinner.updateText("Validating files");
-        await validateMergeOperation(files);
-        let processedCount = 0;
-        await pMap(
-          files,
-          async (file) => {
-            const sanitizedFile = sanitizeInput(file);
-            const relPath = preserveStructure ? path.relative(cwd, sanitizedFile) : path.basename(sanitizedFile);
-            let destPath = path.join(outDir, relPath);
-            if (increment) {
-              const dir = path.dirname(destPath);
-              const base = path.basename(destPath);
-              let dirMap = fileNameCounts.get(dir);
-              if (!dirMap) {
-                dirMap = /* @__PURE__ */ new Map();
-                fileNameCounts.set(dir, dirMap);
-              }
-              const count = dirMap.get(base) || 0;
-              if (count > 0) {
-                const extMatch = base.match(/(.*)(\.[^./\\]+)$/);
-                let newBase;
-                if (extMatch) {
-                  newBase = `${extMatch[1]}-${count + 1}${extMatch[2]}`;
-                } else {
-                  newBase = `${base}-${count + 1}`;
-                }
-                destPath = path.join(dir, newBase);
-              }
-              dirMap.set(base, count + 1);
-            }
-            await fs.ensureDir(path.dirname(destPath));
-            if (backup && await fs.pathExists(destPath)) {
-              const backupPath = `${destPath}.${Date.now()}.bak`;
-              await checkPermissions(destPath, "read");
-              await fs.copyFile(destPath, backupPath);
-            }
-            if (!dryRun) {
-              await checkPermissions(destPath, "write");
-              await fs.copyFile(sanitizedFile, destPath);
-            }
-            processedCount++;
-            spinner.setProgress(
-              processedCount,
-              files.length,
-              `Copying ${path.basename(sanitizedFile)}`
-            );
-          },
-          { concurrency }
-        );
-        return processedCount;
-      } catch (error) {
-        handleCtxError(error, "writeFilesPreserveStructure");
-        throw error;
-      }
-    }
-  );
-};
-export const processSection = (raw, rel, prefix, pathAbove, injectPath) => {
-  const magic = new MagicString(raw);
-  if (pathAbove) {
-    magic.prepend(`${prefix}${rel}
-`);
-  }
-  if (injectPath) {
-    magic.append(`
-${prefix}${rel}`);
-  }
-  return magic.toString();
-};

package/bin/impl/monorepo/cache-mod.d.ts

@@ -1,29 +0,0 @@
-import type { Monorepo, Package } from "./monorepo-mod";
-export interface CacheResult {
-    packageHash: string;
-    fileHashes: string;
-}
-/**
- * Hash a package based on its files and configuration
- */
-export declare function hashPackage(pkg: Package): Promise<CacheResult>;
-/**
- * Get the cache directory for a package
- */
-export declare function getPackageCacheDir(monorepo: Monorepo, pkg: Package, packageHash: string): string;
-/**
- * Check if a package cache exists and is valid
- */
-export declare function isPackageCached(monorepo: Monorepo, pkg: Package, packageHash: string): Promise<boolean>;
-/**
- * Restore package from cache
- */
-export declare function restorePackageCache(monorepo: Monorepo, pkg: Package, packageHash: string): Promise<void>;
-/**
- * Cache package build output
- */
-export declare function cachePackageOutput(monorepo: Monorepo, pkg: Package, packageHash: string): Promise<void>;
-/**
- * Clean the entire cache directory
- */
-export declare function cleanCache(monorepo: Monorepo): Promise<void>;

package/bin/impl/monorepo/cache-mod.js

@@ -1,61 +0,0 @@
-import { createHash } from "node:crypto";
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { globby } from "globby";
-export async function hashPackage(pkg) {
-  const files = await globby(pkg.config.include, {
-    cwd: pkg.dir,
-    ignore: pkg.config.exclude,
-    absolute: true
-  });
-  files.sort();
-  const fileHashes = files.filter((file) => fs.statSync(file).isFile()).map((file) => {
-    const hash = hashFile(file);
-    const relativePath = path.relative(pkg.dir, file);
-    return `${hash}-${relativePath}`;
-  }).join("\n");
-  const packageHash = createHash("md5").update(fileHashes).digest("hex");
-  return {
-    packageHash,
-    fileHashes
-  };
-}
-function hashFile(filePath) {
-  const content = fs.readFileSync(filePath);
-  return createHash("md5").update(content).digest("hex");
-}
-export function getPackageCacheDir(monorepo, pkg, packageHash) {
-  return path.join(monorepo.root, ".cache", pkg.name, packageHash);
-}
-export async function isPackageCached(monorepo, pkg, packageHash) {
-  const cacheDir = getPackageCacheDir(monorepo, pkg, packageHash);
-  return await fs.pathExists(cacheDir);
-}
-export async function restorePackageCache(monorepo, pkg, packageHash) {
-  const cacheDir = getPackageCacheDir(monorepo, pkg, packageHash);
-  const outDir = path.join(pkg.dir, pkg.config.outDir);
-  if (!await fs.pathExists(cacheDir)) {
-    throw new Error(`Cache directory not found: ${cacheDir}`);
-  }
-  await fs.ensureDir(outDir);
-  await fs.copy(cacheDir, outDir, { overwrite: true });
-}
-export async function cachePackageOutput(monorepo, pkg, packageHash) {
-  const cacheDir = getPackageCacheDir(monorepo, pkg, packageHash);
-  const outDir = path.join(pkg.dir, pkg.config.outDir);
-  if (!await fs.pathExists(outDir)) {
-    throw new Error(`Output directory not found: ${outDir}`);
-  }
-  await fs.ensureDir(cacheDir);
-  await fs.copy(outDir, cacheDir, { overwrite: true });
-}
-export async function cleanCache(monorepo) {
-  const cacheDir = path.join(monorepo.root, ".cache");
-  if (await fs.pathExists(cacheDir)) {
-    await fs.remove(cacheDir);
-    relinka("log", `Cache cleaned: ${cacheDir}`);
-  } else {
-    relinka("log", "No cache directory found");
-  }
-}

package/bin/impl/monorepo/commands-mod.d.ts

@@ -1,24 +0,0 @@
-export interface MonorepoContext {
-    isDebug: boolean;
-    cmdArgs: string[];
-}
-/**
- * Build command - builds dependencies and runs the command
- */
-export declare function buildCommand(ctx: MonorepoContext): Promise<void>;
-/**
- * Deps command - builds dependencies only
- */
-export declare function depsCommand(ctx: MonorepoContext): Promise<void>;
-/**
- * All command - builds all packages in the monorepo
- */
-export declare function allCommand(ctx: MonorepoContext): Promise<void>;
-/**
- * Graph command - prints the dependency graph
- */
-export declare function graphCommand(ctx: MonorepoContext): Promise<void>;
-/**
- * Clean command - deletes the build cache
- */
-export declare function cleanCommand(ctx: MonorepoContext): Promise<void>;

package/bin/impl/monorepo/commands-mod.js

@@ -1,159 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { execaCommand } from "execa";
-import { globby } from "globby";
-import {
-  cachePackageOutput,
-  cleanCache,
-  hashPackage,
-  isPackageCached,
-  restorePackageCache
-} from "./cache-mod.js";
-import { DependencyGraph } from "./graph-mod.js";
-import {
-  findMonorepo,
-  getCacheDir,
-  readPackageJson
-} from "./monorepo-mod.js";
-export async function buildCommand(ctx) {
-  if (process.env.INSIDE_DLER === "true") {
-    if (ctx.isDebug) {
-      relinka(
-        "log",
-        `[dler] \u2192 Ignoring dler, running command immediately: ${ctx.cmdArgs.join(" ")}`
-      );
-    }
-    if (ctx.cmdArgs.length === 0) {
-      relinka("error", "No command provided");
-      process.exit(1);
-    }
-    const command = ctx.cmdArgs.join(" ");
-    await execaCommand(command);
-    return;
-  }
-  const monorepo = await requireMonorepo(ctx);
-  const graph = await createGraph(monorepo);
-  const activePackage = requireActivePackage(ctx, graph);
-  const dependencies = graph.getPackageDependenciesBuildOrder(activePackage.name);
-  const packagesToBuild = [...dependencies, activePackage];
-  await buildCachedPackages(ctx, monorepo, packagesToBuild);
-}
-export async function depsCommand(ctx) {
-  if (process.env.INSIDE_DLER === "true") {
-    return;
-  }
-  const monorepo = await requireMonorepo(ctx);
-  const graph = await createGraph(monorepo);
-  const activePackage = requireActivePackage(ctx, graph);
-  const dependencies = graph.getPackageDependenciesBuildOrder(activePackage.name);
-  await buildCachedPackages(ctx, monorepo, dependencies);
-}
-export async function allCommand(ctx) {
-  const monorepo = await requireMonorepo(ctx);
-  const graph = await createGraph(monorepo);
-  const packages = graph.getOverallBuildOrder();
-  await buildCachedPackages(ctx, monorepo, packages);
-}
-export async function graphCommand(ctx) {
-  const monorepo = await requireMonorepo(ctx);
-  const graph = await createGraph(monorepo);
-  graph.print();
-}
-export async function cleanCommand(ctx) {
-  const monorepo = await findMonorepo();
-  if (monorepo) {
-    const cacheDir = getCacheDir(monorepo);
-    if (ctx.isDebug) {
-      relinka("log", `[dler] \u2192 Deleting cache at ${cacheDir}`);
-    }
-    await cleanCache(monorepo);
-  } else {
-    if (ctx.isDebug) {
-      relinka("log", "[dler] \u2192 Not in monorepo");
-    }
-  }
-  relinka("log", "\u2713 Cache deleted");
-}
-async function requireMonorepo(ctx) {
-  const monorepo = await findMonorepo();
-  if (!monorepo) {
-    relinka("error", "Monorepo root not found. Are you inside a monorepo?");
-    process.exit(1);
-  }
-  if (ctx.isDebug) {
-    relinka("log", `[dler] \u2192 Monorepo found at ${monorepo.root}`);
-  }
-  return monorepo;
-}
-async function createGraph(monorepo) {
-  const packageJsonGlobs = monorepo.packageGlobs.map((glob) => `${glob}/package.json`);
-  const matches = await globby(packageJsonGlobs, { cwd: monorepo.root, absolute: true });
-  const packages = [];
-  for (const packageJsonPath of matches) {
-    const pkg = await readPackageJson(packageJsonPath);
-    if (pkg) {
-      packages.push(pkg);
-    }
-  }
-  return new DependencyGraph(packages);
-}
-function requireActivePackage(ctx, graph) {
-  const activePackage = graph.findActivePackage();
-  if (!activePackage) {
-    relinka("error", "Not inside a package directory, could not determine dependencies to build");
-    process.exit(1);
-  }
-  if (ctx.isDebug) {
-    relinka("log", `[dler] \u2192 Active package ${activePackage.dir}`);
-  }
-  return activePackage;
-}
-async function buildCachedPackages(ctx, monorepo, packages) {
-  if (ctx.isDebug) {
-    const packageNames = packages.map((p) => p.name);
-    relinka("log", `[dler] \u2192 Packages to build: ${packageNames.join(", ")}`);
-  }
-  for (const pkg of packages) {
-    await buildCachedPackage(ctx, monorepo, pkg);
-  }
-}
-async function buildCachedPackage(ctx, monorepo, pkg) {
-  if (!pkg.buildScript) {
-    relinka("log", `\u2713 ${pkg.name}: Nothing to build`);
-    return;
-  }
-  const args = [...monorepo.packageManager.runCmd, "build"];
-  if (ctx.isDebug) {
-    const relativeDir = pkg.dir.replace(monorepo.root, "").replace(/^\//, "");
-    relinka("log", `[dler] \u2192 Running ${args.join(" ")} in ${relativeDir}`);
-  }
-  relinka("log", `\u25D0 ${pkg.name}: ${pkg.buildScript}`);
-  const { packageHash } = await hashPackage(pkg);
-  const cacheDir = getPackageCacheDir(monorepo, pkg, packageHash);
-  if (ctx.isDebug) {
-    relinka("log", `[dler] \u2192 Cache dir: ${cacheDir}`);
-  }
-  if (await isPackageCached(monorepo, pkg, packageHash) && pkg.config.cache) {
-    await restorePackageCache(monorepo, pkg, packageHash);
-    relinka("log", `\u2713 ${pkg.name}: Cached!`);
-    return;
-  }
-  await execInDir(pkg.dir, args);
-  if (pkg.config.cache) {
-    await cachePackageOutput(monorepo, pkg, packageHash);
-  }
-  relinka("log", `\u2713 ${pkg.name}: Built`);
-}
-async function execInDir(dir, args) {
-  if (args.length === 0) {
-    relinka("error", "No command provided");
-    process.exit(1);
-  }
-  const command = args.join(" ");
-  await execaCommand(command, {
-    cwd: dir,
-    env: { ...process.env, INSIDE_DLER: "true" }
-  });
-}
-function getPackageCacheDir(monorepo, pkg, packageHash) {
-  return `${monorepo.root}/.cache/${pkg.name}/${packageHash}`;
-}

package/bin/impl/monorepo/graph-mod.d.ts

@@ -1,29 +0,0 @@
-import type { Package } from "./monorepo-mod";
-export interface GraphNode {
-    id: string;
-    package: Package;
-    children: GraphNode[];
-}
-export declare class DependencyGraph {
-    private readonly root;
-    private readonly nodeMap;
-    constructor(packages: Package[]);
-    /**
-     * Get all packages in build order (dependencies first)
-     */
-    getOverallBuildOrder(): Package[];
-    /**
-     * Get dependencies for a specific package in build order
-     */
-    getPackageDependenciesBuildOrder(packageName: string): Package[];
-    /**
-     * Find the package that contains the current working directory
-     */
-    findActivePackage(): Package | null;
-    /**
-     * Print the dependency graph as a tree
-     */
-    print(): void;
-    private depthFirstSearch;
-    private printNode;
-}