@pruddiman/hem 0.0.1-beta-5671db0

package/dist/grouping.js

@@ -0,0 +1,343 @@
+/**
+ * File grouping module for Hem.
+ *
+ * Analyses discovered source files and groups them by feature vertical
+ * (e.g., "user", "order") or architectural layer (e.g., controllers,
+ * services). Each file appears in at most one group; feature grouping
+ * takes priority over layer grouping.
+ *
+ * Reference: FR-003, data-model.md lines 93-108.
+ */
+import { dirname } from "node:path";
+import { toKebabCase } from "./helpers/strings.js";
+// ── Layer detection ─────────────────────────────────────────────────────
+/**
+ * Maps well-known file name suffixes to their architectural layer label.
+ * Order matters: first match wins.
+ */
+const LAYER_SUFFIXES = [
+    { suffix: ".controller", label: "Controllers" },
+    { suffix: ".controllers", label: "Controllers" },
+    { suffix: ".service", label: "Services" },
+    { suffix: ".services", label: "Services" },
+    { suffix: ".repository", label: "Repositories" },
+    { suffix: ".repositories", label: "Repositories" },
+    { suffix: ".repo", label: "Repositories" },
+    { suffix: ".model", label: "Models" },
+    { suffix: ".models", label: "Models" },
+    { suffix: ".entity", label: "Models" },
+    { suffix: ".middleware", label: "Middleware" },
+    { suffix: ".guard", label: "Guards" },
+    { suffix: ".pipe", label: "Pipes" },
+    { suffix: ".interceptor", label: "Interceptors" },
+    { suffix: ".filter", label: "Filters" },
+    { suffix: ".decorator", label: "Decorators" },
+    { suffix: ".dto", label: "DTOs" },
+    { suffix: ".schema", label: "Schemas" },
+    { suffix: ".migration", label: "Migrations" },
+    { suffix: ".seed", label: "Seeds" },
+    { suffix: ".test", label: "Tests" },
+    { suffix: ".spec", label: "Tests" },
+    { suffix: ".util", label: "Utilities" },
+    { suffix: ".utils", label: "Utilities" },
+    { suffix: ".helper", label: "Utilities" },
+    { suffix: ".helpers", label: "Utilities" },
+    { suffix: ".config", label: "Configuration" },
+    { suffix: ".route", label: "Routes" },
+    { suffix: ".routes", label: "Routes" },
+    { suffix: ".router", label: "Routes" },
+    { suffix: ".component", label: "Components" },
+    { suffix: ".hook", label: "Hooks" },
+    { suffix: ".context", label: "Contexts" },
+    { suffix: ".provider", label: "Providers" },
+    { suffix: ".resolver", label: "Resolvers" },
+    { suffix: ".module", label: "Modules" },
+];
+/**
+ * Well-known directory names that indicate an architectural layer.
+ */
+const LAYER_DIRECTORIES = new Map([
+    ["controllers", "Controllers"],
+    ["controller", "Controllers"],
+    ["services", "Services"],
+    ["service", "Services"],
+    ["repositories", "Repositories"],
+    ["repository", "Repositories"],
+    ["repos", "Repositories"],
+    ["models", "Models"],
+    ["model", "Models"],
+    ["entities", "Models"],
+    ["entity", "Models"],
+    ["middleware", "Middleware"],
+    ["middlewares", "Middleware"],
+    ["guards", "Guards"],
+    ["pipes", "Pipes"],
+    ["interceptors", "Interceptors"],
+    ["filters", "Filters"],
+    ["decorators", "Decorators"],
+    ["dtos", "DTOs"],
+    ["dto", "DTOs"],
+    ["schemas", "Schemas"],
+    ["migrations", "Migrations"],
+    ["seeds", "Seeds"],
+    ["tests", "Tests"],
+    ["test", "Tests"],
+    ["__tests__", "Tests"],
+    ["spec", "Tests"],
+    ["utils", "Utilities"],
+    ["util", "Utilities"],
+    ["helpers", "Utilities"],
+    ["lib", "Utilities"],
+    ["config", "Configuration"],
+    ["configs", "Configuration"],
+    ["routes", "Routes"],
+    ["router", "Routes"],
+    ["routers", "Routes"],
+    ["components", "Components"],
+    ["hooks", "Hooks"],
+    ["contexts", "Contexts"],
+    ["providers", "Providers"],
+    ["resolvers", "Resolvers"],
+    ["modules", "Modules"],
+]);
+// ── Helpers ─────────────────────────────────────────────────────────────
+/**
+ * Finds the common parent directory for a set of file paths.
+ *
+ * @param files - Array of FileInfo objects.
+ * @returns The common parent directory (relative path), or `"."` for root.
+ */
+export function commonDirectory(files) {
+    if (files.length === 0)
+        return ".";
+    const first = files[0];
+    if (files.length === 1)
+        return dirname(first.path);
+    const dirs = files.map((f) => dirname(f.path).split("/"));
+    const minLen = Math.min(...dirs.map((d) => d.length));
+    const common = [];
+    const head = dirs[0];
+    for (let i = 0; i < minLen; i++) {
+        const segment = head[i];
+        if (dirs.every((d) => d[i] === segment)) {
+            common.push(segment);
+        }
+        else {
+            break;
+        }
+    }
+    return common.length === 0 ? "." : common.join("/");
+}
+/**
+ * Extracts the file stem (name without the final extension).
+ * For multi-part suffixes like `user.controller.ts`, the stem is `user`.
+ */
+function fileStem(relativePath) {
+    const base = relativePath.split("/").pop() ?? "";
+    const dotIndex = base.indexOf(".");
+    return dotIndex === -1 ? base : base.substring(0, dotIndex);
+}
+/**
+ * Returns the "name" portion of the file without known layer suffixes
+ * and without the actual file extension.
+ * E.g. `user.controller.ts` → the layer suffix is `.controller` → stem `user`.
+ * `helpers.ts` → no layer suffix → stem `helpers`.
+ */
+function fileNameWithoutExtension(relativePath) {
+    const base = relativePath.split("/").pop() ?? "";
+    // Remove the last extension (.ts, .js, etc.)
+    const lastDot = base.lastIndexOf(".");
+    return lastDot === -1 ? base : base.substring(0, lastDot);
+}
+/**
+ * Detects the architectural layer for a file by checking its name
+ * against known suffixes.
+ *
+ * @returns The layer label (e.g., "Controllers") or `undefined`.
+ */
+function detectLayer(relativePath) {
+    const nameNoExt = fileNameWithoutExtension(relativePath).toLowerCase();
+    for (const { suffix, label } of LAYER_SUFFIXES) {
+        if (nameNoExt.endsWith(suffix)) {
+            return label;
+        }
+    }
+    return undefined;
+}
+/**
+ * Detects the architectural layer for a file by checking its containing
+ * directory name against known layer directories.
+ *
+ * @returns The layer label or `undefined`.
+ */
+function detectLayerByDirectory(relativePath) {
+    const segments = dirname(relativePath).split("/");
+    // Check from innermost to outermost directory
+    for (let i = segments.length - 1; i >= 0; i--) {
+        const segment = segments[i];
+        if (!segment)
+            continue;
+        const label = LAYER_DIRECTORIES.get(segment.toLowerCase());
+        if (label)
+            return label;
+    }
+    return undefined;
+}
+/**
+ * Extracts a feature name from a file's path by looking at directory
+ * segments. Returns the most specific (deepest) non-layer directory
+ * segment, or `undefined` if the file is at root level or only in
+ * layer directories.
+ */
+function extractFeatureName(relativePath) {
+    const dir = dirname(relativePath);
+    if (dir === ".")
+        return undefined;
+    const segments = dir.split("/");
+    // Walk from deepest to shallowest, find first segment that is NOT
+    // a known layer directory
+    for (let i = segments.length - 1; i >= 0; i--) {
+        const original = segments[i];
+        if (!original)
+            continue;
+        if (!LAYER_DIRECTORIES.has(original.toLowerCase())) {
+            return original; // preserve original casing
+        }
+    }
+    return undefined;
+}
+/**
+ * Capitalises the first letter and replaces hyphens/underscores with
+ * spaces for display labels. E.g., `user-auth` → `User Auth`.
+ */
+function toDisplayLabel(name) {
+    return name
+        .replace(/[-_]/g, " ")
+        .replace(/\b\w/g, (ch) => ch.toUpperCase());
+}
+// ── Main ────────────────────────────────────────────────────────────────
+/**
+ * Groups discovered files by feature vertical or architectural layer.
+ *
+ * Grouping strategy:
+ *   1. Filter out binary files.
+ *   2. Attempt to assign each file to a **feature vertical** group
+ *      based on its directory structure (e.g., files under `user/` →
+ *      "User" feature group).
+ *   3. Files not assigned to a feature group are checked for
+ *      **architectural layer** membership based on file name suffixes
+ *      (e.g., `.controller.ts` → "Controllers" layer) or containing
+ *      directory (e.g., `services/` → "Services").
+ *   4. Remaining files go into a catch-all "Other" group.
+ *   5. Each file appears in at most one group.
+ *
+ * @param files - Discovered files (may include binary files).
+ * @returns Array of `FileGroup` objects.
+ */
+export function groupFiles(files) {
+    // Step 1: filter to non-binary files only
+    const textFiles = files.filter((f) => !f.isBinary);
+    if (textFiles.length === 0)
+        return [];
+    // Step 2: Build feature and layer buckets
+    const featureBuckets = new Map();
+    const layerBuckets = new Map();
+    const ungrouped = [];
+    const assigned = new Set(); // track by relative path
+    // First pass: try to assign every file to a feature vertical
+    for (const file of textFiles) {
+        const feature = extractFeatureName(file.path);
+        if (feature) {
+            const key = feature.toLowerCase();
+            if (!featureBuckets.has(key)) {
+                featureBuckets.set(key, []);
+            }
+            featureBuckets.get(key).push(file);
+            assigned.add(file.path);
+        }
+    }
+    // Promote single-file features back to unassigned — features with
+    // only one file aren't meaningful groups by themselves. They'll get
+    // a chance to be grouped by layer instead.
+    for (const [key, bucket] of featureBuckets) {
+        if (bucket.length < 2) {
+            for (const file of bucket) {
+                assigned.delete(file.path);
+            }
+            featureBuckets.delete(key);
+        }
+    }
+    // Second pass: unassigned files → try layer grouping
+    for (const file of textFiles) {
+        if (assigned.has(file.path))
+            continue;
+        const layer = detectLayer(file.path) ?? detectLayerByDirectory(file.path);
+        if (layer) {
+            if (!layerBuckets.has(layer)) {
+                layerBuckets.set(layer, []);
+            }
+            layerBuckets.get(layer).push(file);
+            assigned.add(file.path);
+        }
+    }
+    // Promote single-file layers back to ungrouped
+    for (const [key, bucket] of layerBuckets) {
+        if (bucket.length < 2) {
+            for (const file of bucket) {
+                assigned.delete(file.path);
+            }
+            layerBuckets.delete(key);
+        }
+    }
+    // Third pass: remaining → "Other"
+    for (const file of textFiles) {
+        if (!assigned.has(file.path)) {
+            ungrouped.push(file);
+        }
+    }
+    // Step 3: Convert buckets to FileGroup objects
+    const groups = [];
+    // Feature (vertical) groups
+    for (const [key, bucket] of featureBuckets) {
+        const displayLabel = toDisplayLabel(key);
+        groups.push({
+            id: toKebabCase(displayLabel) + "-feature",
+            label: displayLabel,
+            type: "vertical",
+            files: bucket.sort((a, b) => a.path.localeCompare(b.path)),
+            directory: commonDirectory(bucket),
+        });
+    }
+    // Layer (horizontal) groups
+    for (const [label, bucket] of layerBuckets) {
+        groups.push({
+            id: toKebabCase(label) + "-layer",
+            label,
+            type: "horizontal",
+            files: bucket.sort((a, b) => a.path.localeCompare(b.path)),
+            directory: commonDirectory(bucket),
+        });
+    }
+    // Catch-all "Other" group
+    if (ungrouped.length > 0) {
+        groups.push({
+            id: "other",
+            label: "Other",
+            type: "vertical",
+            files: ungrouped.sort((a, b) => a.path.localeCompare(b.path)),
+            directory: commonDirectory(ungrouped),
+        });
+    }
+    // Sort groups: verticals first, then horizontals, alphabetically within
+    groups.sort((a, b) => {
+        if (a.type !== b.type)
+            return a.type === "vertical" ? -1 : 1;
+        // "Other" always last within its type
+        if (a.id === "other")
+            return 1;
+        if (b.id === "other")
+            return -1;
+        return a.label.localeCompare(b.label);
+    });
+    return groups;
+}

package/dist/helpers/format.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Format elapsed time as human-readable string.
+ * @internal
+ */
+export declare function formatElapsed(startMs: number, endMs: number): string;

package/dist/helpers/format.js

@@ -0,0 +1,13 @@
+/**
+ * Format elapsed time as human-readable string.
+ * @internal
+ */
+export function formatElapsed(startMs, endMs) {
+    const totalSeconds = Math.round((endMs - startMs) / 1000);
+    if (totalSeconds < 60) {
+        return `${totalSeconds}s`;
+    }
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    return `${minutes}m ${seconds}s`;
+}

package/dist/helpers/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Barrel file for src/helpers — re-exports all public symbols from
+ * the helper modules for convenient single-point imports.
+ *
+ * Usage:
+ *   import { toKebabCase, formatElapsed } from "./helpers/index.js";
+ */
+export * from "./strings.js";
+export * from "./paths.js";
+export * from "./parsing.js";
+export * from "./format.js";

package/dist/helpers/index.js

@@ -0,0 +1,11 @@
+/**
+ * Barrel file for src/helpers — re-exports all public symbols from
+ * the helper modules for convenient single-point imports.
+ *
+ * Usage:
+ *   import { toKebabCase, formatElapsed } from "./helpers/index.js";
+ */
+export * from "./strings.js";
+export * from "./paths.js";
+export * from "./parsing.js";
+export * from "./format.js";

package/dist/helpers/parsing.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Text extraction and parsing utilities for Hem.
+ *
+ * Provides helpers for extracting structured content (Markdown, JSON,
+ * file lists, concepts) from LLM response text.
+ */
+import type { MessagePart } from "../session.js";
+/**
+ * Extracts the Markdown content from the OpenCode prompt response.
+ *
+ * Concatenates all text parts from the response, stripping any wrapping
+ * code fences if the LLM returned the content inside a fenced block.
+ *
+ * @param parts - The response parts from `promptAndWait()`.
+ * @returns The extracted Markdown string.
+ */
+export declare function extractMarkdown(parts: Array<MessagePart>): string;
+/**
+ * Extracts a JSON string from an LLM response that may contain preamble text.
+ *
+ * LLMs often prepend commentary (e.g., "Now I have all the information I need.")
+ * before the actual JSON payload.  This function tries three strategies in order:
+ *
+ * 1. Fenced code block — extracts content from `` ```json ... ``` `` fences.
+ * 2. First brace / bracket — locates the first `{` or `[` and the last matching
+ *    `}` or `]` to isolate the JSON object/array from surrounding text.
+ * 3. Entire string — falls back to returning the full input (for responses that
+ *    are already pure JSON).
+ *
+ * @param response - The raw LLM response string.
+ * @returns The extracted JSON substring (not yet parsed).
+ */
+export declare function extractJSON(response: string): string;
+/**
+ * Extracts `relatedFiles` from generated Markdown content.
+ *
+ * Looks for the "Source Files" or "Related Files" section and extracts file
+ * paths from backtick-quoted entries (e.g., `` `src/user/controller.ts` ``).
+ *
+ * @param content - The generated Markdown content.
+ * @returns Array of relative file paths found in the Source Files section.
+ */
+export declare function parseRelatedFiles(content: string): string[];
+/**
+ * Extracts key concept names from section content.
+ *
+ * Looks for backtick-quoted identifiers as a heuristic for concepts.
+ *
+ * @param content - The section body text.
+ * @returns Array of unique concept strings.
+ */
+export declare function extractConcepts(content: string): string[];

package/dist/helpers/parsing.js

@@ -0,0 +1,128 @@
+/**
+ * Text extraction and parsing utilities for Hem.
+ *
+ * Provides helpers for extracting structured content (Markdown, JSON,
+ * file lists, concepts) from LLM response text.
+ */
+/**
+ * Extracts the Markdown content from the OpenCode prompt response.
+ *
+ * Concatenates all text parts from the response, stripping any wrapping
+ * code fences if the LLM returned the content inside a fenced block.
+ *
+ * @param parts - The response parts from `promptAndWait()`.
+ * @returns The extracted Markdown string.
+ */
+export function extractMarkdown(parts) {
+    const textParts = parts.filter((p) => p.type === "text" && typeof p.text === "string");
+    let content = textParts.map((p) => p.text).join("\n");
+    // Strip wrapping ```markdown ... ``` fences if present
+    const fencePattern = /^```(?:markdown|md)?\s*\n([\s\S]*?)\n```\s*$/;
+    const match = content.match(fencePattern);
+    if (match) {
+        content = match[1];
+    }
+    // Strip preamble text before the first Markdown heading.
+    // LLMs sometimes produce commentary like "Now I have a thorough
+    // understanding of the codebase..." before the actual document.
+    const h1Match = content.search(/^# .+/m);
+    if (h1Match > 0) {
+        content = content.slice(h1Match);
+    }
+    return content.trim();
+}
+/**
+ * Extracts a JSON string from an LLM response that may contain preamble text.
+ *
+ * LLMs often prepend commentary (e.g., "Now I have all the information I need.")
+ * before the actual JSON payload.  This function tries three strategies in order:
+ *
+ * 1. Fenced code block — extracts content from `` ```json ... ``` `` fences.
+ * 2. First brace / bracket — locates the first `{` or `[` and the last matching
+ *    `}` or `]` to isolate the JSON object/array from surrounding text.
+ * 3. Entire string — falls back to returning the full input (for responses that
+ *    are already pure JSON).
+ *
+ * @param response - The raw LLM response string.
+ * @returns The extracted JSON substring (not yet parsed).
+ */
+export function extractJSON(response) {
+    // Strategy 1: fenced ```json block
+    const fencePattern = /```(?:json)?\s*\n([\s\S]*?)\n```/;
+    const fenceMatch = response.match(fencePattern);
+    if (fenceMatch) {
+        return fenceMatch[1];
+    }
+    // Strategy 2: locate first { or [ and matching last } or ]
+    const braceIdx = response.indexOf("{");
+    const bracketIdx = response.indexOf("[");
+    let startChar = null;
+    let startIdx = -1;
+    if (braceIdx >= 0 && (bracketIdx < 0 || braceIdx < bracketIdx)) {
+        startChar = "{";
+        startIdx = braceIdx;
+    }
+    else if (bracketIdx >= 0) {
+        startChar = "[";
+        startIdx = bracketIdx;
+    }
+    if (startChar !== null && startIdx >= 0) {
+        const endChar = startChar === "{" ? "}" : "]";
+        const endIdx = response.lastIndexOf(endChar);
+        if (endIdx > startIdx) {
+            return response.slice(startIdx, endIdx + 1);
+        }
+    }
+    // Strategy 3: return full string (caller's JSON.parse will validate)
+    return response;
+}
+/**
+ * Extracts `relatedFiles` from generated Markdown content.
+ *
+ * Looks for the "Source Files" or "Related Files" section and extracts file
+ * paths from backtick-quoted entries (e.g., `` `src/user/controller.ts` ``).
+ *
+ * @param content - The generated Markdown content.
+ * @returns Array of relative file paths found in the Source Files section.
+ */
+export function parseRelatedFiles(content) {
+    const files = [];
+    const lines = content.split("\n");
+    let inSection = false;
+    for (const line of lines) {
+        // Detect start of Source Files / Related Files section
+        if (/^##\s+(Source|Related) Files/i.test(line)) {
+            inSection = true;
+            continue;
+        }
+        // End section at next heading
+        if (inSection && /^##\s+/.test(line)) {
+            break;
+        }
+        // Extract file paths from backtick-quoted list items
+        if (inSection) {
+            const match = line.match(/`([^`]+)`/);
+            if (match) {
+                files.push(match[1]);
+            }
+        }
+    }
+    return files;
+}
+/**
+ * Extracts key concept names from section content.
+ *
+ * Looks for backtick-quoted identifiers as a heuristic for concepts.
+ *
+ * @param content - The section body text.
+ * @returns Array of unique concept strings.
+ */
+export function extractConcepts(content) {
+    const matches = content.match(/`([^`]+)`/g);
+    if (!matches)
+        return [];
+    const unique = new Set(matches
+        .map((m) => m.slice(1, -1))
+        .filter((c) => c.length > 0 && !/^\s|\s$/.test(c) && !c.includes("  ")));
+    return Array.from(unique);
+}

package/dist/helpers/paths.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Path validation and resolution utilities for Hem.
+ *
+ * Provides helpers for checking path containment, resolving output
+ * paths within a destination directory, and validating source/destination
+ * relationships.
+ */
+/**
+ * Checks whether `child` is within (or equal to) `parent` after
+ * resolving both to absolute paths.
+ *
+ * Uses a trailing-separator prefix check to prevent false positives
+ * where `/foo/bar` would incorrectly match `/foo/barbaz`.
+ *
+ * @param child - The path to test.
+ * @param parent - The potential ancestor path.
+ * @returns `true` if `child` is the same as or a descendant of `parent`.
+ */
+export declare function isPathWithin(child: string, parent: string): boolean;
+/**
+ * Resolves the full output path for a file within the destination directory.
+ *
+ * Safety: Rejects any `relativePath` that would escape the destination
+ * directory (e.g., paths containing `..` segments that resolve outside).
+ *
+ * @param destinationPath - Path to the destination directory.
+ * @param relativePath    - Relative path for the output file.
+ * @returns The resolved absolute output path.
+ * @throws If the resolved path falls outside the destination directory.
+ */
+export declare function resolveOutputPath(destinationPath: string, relativePath: string): string;
+/**
+ * Validates the relationship between destination and source paths.
+ *
+ * When the destination directory is inside the source directory, logs
+ * a note that destination files will be excluded from scanning.
+ *
+ * @param destinationPath - Path to the destination directory.
+ * @param sourcePath - Path to the source directory.
+ */
+export declare function validateDestinationPath(destinationPath: string, sourcePath: string): void;

package/dist/helpers/paths.js

@@ -0,0 +1,67 @@
+/**
+ * Path validation and resolution utilities for Hem.
+ *
+ * Provides helpers for checking path containment, resolving output
+ * paths within a destination directory, and validating source/destination
+ * relationships.
+ */
+import { resolve, normalize, relative } from "node:path";
+/**
+ * Checks whether `child` is within (or equal to) `parent` after
+ * resolving both to absolute paths.
+ *
+ * Uses a trailing-separator prefix check to prevent false positives
+ * where `/foo/bar` would incorrectly match `/foo/barbaz`.
+ *
+ * @param child - The path to test.
+ * @param parent - The potential ancestor path.
+ * @returns `true` if `child` is the same as or a descendant of `parent`.
+ */
+export function isPathWithin(child, parent) {
+    const absoluteChild = resolve(child);
+    const absoluteParent = resolve(parent);
+    if (absoluteChild === absoluteParent) {
+        return true;
+    }
+    const parentPrefix = absoluteParent.endsWith("/")
+        ? absoluteParent
+        : absoluteParent + "/";
+    return absoluteChild.startsWith(parentPrefix);
+}
+/**
+ * Resolves the full output path for a file within the destination directory.
+ *
+ * Safety: Rejects any `relativePath` that would escape the destination
+ * directory (e.g., paths containing `..` segments that resolve outside).
+ *
+ * @param destinationPath - Path to the destination directory.
+ * @param relativePath    - Relative path for the output file.
+ * @returns The resolved absolute output path.
+ * @throws If the resolved path falls outside the destination directory.
+ */
+export function resolveOutputPath(destinationPath, relativePath) {
+    const absoluteDestination = resolve(destinationPath);
+    const resolved = resolve(absoluteDestination, normalize(relativePath));
+    const rel = relative(absoluteDestination, resolved);
+    if (rel.startsWith("..") || resolve(absoluteDestination, rel) !== resolved) {
+        throw new Error(`Output path "${relativePath}" escapes the destination directory "${absoluteDestination}".`);
+    }
+    return resolved;
+}
+/**
+ * Validates the relationship between destination and source paths.
+ *
+ * When the destination directory is inside the source directory, logs
+ * a note that destination files will be excluded from scanning.
+ *
+ * @param destinationPath - Path to the destination directory.
+ * @param sourcePath - Path to the source directory.
+ */
+export function validateDestinationPath(destinationPath, sourcePath) {
+    const absoluteDestination = resolve(destinationPath);
+    const absoluteSource = resolve(sourcePath);
+    if (isPathWithin(absoluteDestination, absoluteSource)) {
+        console.log(`Note: Destination "${absoluteDestination}" is inside source "${absoluteSource}". ` +
+            `Destination files will be excluded from scanning.`);
+    }
+}