fln 1.1.2 → 1.2.0

package/dist/core/renderOutput.js

@@ -1,10 +1,10 @@
 import { createReadStream } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { extname, join } from "node:path";
-import { createOutputWriter, formatDateTime } from "../infra";
-import { VERSION } from "../version";
-import { renderTree } from "./renderTree";
-import { formatByteSize } from "./size";
+import { createOutputWriter, formatDateTime } from "../infra/index.js";
+import { VERSION } from "../version.js";
+import { renderTree } from "./renderTree.js";
+import { formatByteSize } from "./size.js";
 function getLanguageFromFilename(fileName) {
     const extension = extname(fileName).replace(".", "");
     return extension === "" ? "txt" : extension;
@@ -48,34 +48,38 @@ async function writeMarkdownContent(writer, filePath) {
     if (lastCharacter !== "" && lastCharacter !== "\n")
         await writer.write("\n");
 }
-function* iterateFileNodes(node) {
-    if (node.type === "file")
-        yield node;
-    if (node.children)
-        for (const child of node.children)
-            yield* iterateFileNodes(child);
-}
-function filterSkippedNodes(node) {
+function filterAndCollectFileNodes(node) {
     if (node.skipReason)
-        return undefined;
-    if (!node.children || node.children.length === 0)
-        return { ...node };
-    const children = node.children
-        .map(child => filterSkippedNodes(child))
-        .filter((child) => child !== undefined);
-    return { ...node, children };
+        return { filtered: undefined, fileNodes: [] };
+    if (node.type === "file")
+        return { filtered: { ...node }, fileNodes: [node] };
+    const allFileNodes = [];
+    const filteredChildren = [];
+    for (const child of node.children ?? []) {
+        const { filtered, fileNodes } = filterAndCollectFileNodes(child);
+        allFileNodes.push(...fileNodes);
+        if (filtered)
+            filteredChildren.push(filtered);
+    }
+    if (filteredChildren.length === 0)
+        return { filtered: undefined, fileNodes: allFileNodes };
+    return {
+        filtered: { ...node, children: filteredChildren },
+        fileNodes: allFileNodes
+    };
 }
 async function writeMarkdown(result, config) {
-    const writer = await createOutputWriter(config.outputFile, config.maximumTotalSizeBytes);
-    const outputRoot = filterSkippedNodes(result.root);
-    if (!outputRoot)
-        throw new Error("Root directory was skipped.");
+    const writer = await createOutputWriter(config.output, config.maxTotalSize);
+    const { filtered: outputRoot, fileNodes } = filterAndCollectFileNodes(result.root);
+    const effectiveRoot = outputRoot ?? { ...result.root, children: [] };
     try {
-        await writer.writeLine(`<!-- 🥞 fln ${VERSION} -->`);
-        await writer.writeLine("");
+        if (config.output !== "-") {
+            await writer.writeLine(`<!-- 🥞 fln ${VERSION} -->`);
+            await writer.writeLine("");
+        }
         await writer.writeLine(`# Codebase Snapshot: ${result.projectName}`);
         await writer.writeLine("");
-        await writer.writeLine(`Generated: ${config.generatedDate ?? formatDateTime()}  `);
+        await writer.writeLine(`Generated: ${config.date ?? formatDateTime()}  `);
         await writer.writeLine(`Files: ${result.stats.files} | Directories: ${result.stats.directories}`);
         await writer.writeLine("");
         await writer.writeLine("---");
@@ -87,14 +91,14 @@ async function writeMarkdown(result, config) {
         if (config.includeTree) {
             await writer.writeLine("## Directory Tree");
             await writer.writeLine("```text");
-            await writer.write(renderTree(outputRoot));
+            await writer.write(renderTree(effectiveRoot));
             await writer.writeLine("```");
             await writer.writeLine("");
             await writer.writeLine("---");
             await writer.writeLine("");
         }
-        if (config.includeContents)
-            await writeMarkdownFiles(outputRoot, writer, config);
+        if (config.includeContents && fileNodes.length > 0)
+            await writeMarkdownFiles(fileNodes, writer, config);
         if (config.footer) {
             await writer.writeLine("");
             await writer.writeLine(config.footer);
@@ -109,15 +113,14 @@ async function writeMarkdown(result, config) {
         throw error;
     }
 }
-async function writeMarkdownFiles(rootNode, outputWriter, renderConfig) {
+async function writeMarkdownFiles(fileNodes, outputWriter, renderConfig) {
     await outputWriter.writeLine("## Source Files");
     await outputWriter.writeLine("");
-    const fileNodes = Array.from(iterateFileNodes(rootNode));
     for (let i = 0; i < fileNodes.length; i++) {
         const node = fileNodes[i];
         const language = getLanguageFromFilename(node.name);
         const isLastFile = i === fileNodes.length - 1;
-        const filePath = join(renderConfig.rootDirectory, node.path);
+        const filePath = join(renderConfig.input, node.path);
         let fenceLength = 3;
         if (!node.isBinary)
             try {
@@ -144,37 +147,37 @@ async function writeMarkdownFiles(rootNode, outputWriter, renderConfig) {
     }
 }
 async function writeJson(result, config) {
-    const writer = await createOutputWriter(config.outputFile, config.maximumTotalSizeBytes);
-    const outputRoot = filterSkippedNodes(result.root);
-    if (!outputRoot)
-        throw new Error("Root directory was skipped.");
+    const writer = await createOutputWriter(config.output, config.maxTotalSize);
+    const { filtered: outputRoot, fileNodes } = filterAndCollectFileNodes(result.root);
+    const effectiveRoot = outputRoot ?? { ...result.root, children: [] };
     try {
         await writer.write("{");
         await writer.write(`"version":${JSON.stringify(VERSION)}`);
-        await writer.write(`,"generated":${JSON.stringify(config.generatedDate ?? formatDateTime())}`);
+        await writer.write(`,"generated":${JSON.stringify(config.date ?? formatDateTime())}`);
         await writer.write(`,"projectName":${JSON.stringify(result.projectName)}`);
-        await writer.write(`,"rootDirectory":${JSON.stringify(config.rootDirectory)}`);
-        await writer.write(`,"stats":${JSON.stringify(result.stats)}`);
+        await writer.write(`,"input":${JSON.stringify(config.input)}`);
+        await writer.write(`,"rootDirectory":${JSON.stringify(config.input)}`);
+        const { outputSizeBytes: _, outputTokenCount: __, ...statsForJson } = result.stats;
+        await writer.write(`,"stats":${JSON.stringify(statsForJson)}`);
         await writer.write(`,"options":${JSON.stringify({
             includeTree: config.includeTree,
             includeContents: config.includeContents,
             format: config.format,
-            maximumFileSizeBytes: config.maximumFileSizeBytes,
-            maximumTotalSizeBytes: config.maximumTotalSizeBytes,
+            maxFileSize: config.maxFileSize,
+            maxTotalSize: config.maxTotalSize,
             includeHidden: config.includeHidden,
-            useGitignore: config.useGitignore,
+            gitignore: config.gitignore,
             excludePatterns: config.excludePatterns,
             includePatterns: config.includePatterns,
             followSymlinks: config.followSymlinks,
             banner: config.banner,
             footer: config.footer
         })}`);
-        await writer.write(`,"tree":${JSON.stringify(outputRoot)}`);
-        await writer.write(`,"stats":${JSON.stringify(result.stats)}`);
+        await writer.write(`,"tree":${JSON.stringify(effectiveRoot)}`);
         if (config.includeContents) {
             await writer.write(",\"files\":[");
             let isFirst = true;
-            for (const node of iterateFileNodes(outputRoot)) {
+            for (const node of fileNodes) {
                 if (!isFirst)
                     await writer.write(",");
                 isFirst = false;
@@ -182,13 +185,11 @@ async function writeJson(result, config) {
                 await writer.write(`"path":${JSON.stringify(node.path)}`);
                 await writer.write(`,"language":${JSON.stringify(getLanguageFromFilename(node.name))}`);
                 await writer.write(`,"isBinary":${JSON.stringify(Boolean(node.isBinary))}`);
-                if (node.skipReason)
-                    await writer.write(`,"skipReason":${JSON.stringify(node.skipReason)}`);
-                if (node.isBinary || node.skipReason)
+                if (node.isBinary)
                     await writer.write(",\"content\":null");
                 else
                     try {
-                        const filePath = join(config.rootDirectory, node.path);
+                        const filePath = join(config.input, node.path);
                         const content = await readFile(filePath, "utf8");
                         await writer.write(`,"content":${JSON.stringify(content)}`);
                     }

package/dist/core/renderTree.d.ts

@@ -1,2 +1,2 @@
-import type { FileNode } from "./types";
+import type { FileNode } from "./types.js";
 export declare function renderTree(root: FileNode): string;

package/dist/core/scanTree.d.ts

@@ -1,3 +1,3 @@
-import type { Logger } from "../infra";
-import type { ScanOptions, ScanResult } from "./types";
+import type { Logger } from "../infra/index.js";
+import type { ScanOptions, ScanResult } from "./types.js";
 export declare function scanTree(options: ScanOptions, logger: Logger): Promise<ScanResult>;

package/dist/core/scanTree.js

@@ -2,12 +2,10 @@ import { lstat, open, readdir, readlink, realpath, stat } from "node:fs/promises
 import { cpus } from "node:os";
 import { relative, sep } from "node:path";
 import ignore from "ignore";
-import { IgnoreMatcher } from "./ignoreMatcher";
-function normalizePathSegment(pathSegment) {
-    if (sep === "/")
-        return pathSegment;
-    return pathSegment.split(sep).join("/");
-}
+import pLimit from "p-limit";
+import { toCanonicalRelative, toIgnoreSafePath, toPosixPath } from "../path/index.js";
+import { normalizeIncludePattern } from "../pattern/index.js";
+import { IgnoreMatcher } from "./ignoreMatcher.js";
 function getFileScore(fileName) {
     const lowerName = fileName.toLowerCase();
     if (lowerName.startsWith("readme"))
@@ -21,6 +19,7 @@ function getFileScore(fileName) {
         lowerName === "makefile" ||
         lowerName === "dockerfile" ||
         lowerName === "vcpkg.json" ||
+        lowerName === "pom.xml" ||
         lowerName.startsWith(".env") ||
         lowerName.includes(".config.") ||
         lowerName.startsWith(".prettier") ||
@@ -55,34 +54,17 @@ function getFileScore(fileName) {
         return 20;
     return 10;
 }
-async function isBinaryFile(filePath, fileSize) {
+async function inspectFile(filePath, fileSize) {
     if (fileSize === 0)
-        return false;
+        return { isGenerated: false, isBinary: false };
     const handle = await open(filePath, "r");
     try {
         const buffer = Buffer.alloc(Math.min(512, fileSize));
         const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-        for (let index = 0; index < bytesRead; index++)
-            if (buffer[index] === 0)
-                return true;
-        return false;
-    }
-    finally {
-        await handle.close();
-    }
-}
-async function isGeneratedFile(filePath, fileSize) {
-    if (fileSize === 0)
-        return false;
-    const handle = await open(filePath, "r");
-    try {
-        const buffer = Buffer.alloc(Math.min(100, fileSize));
-        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-        const content = buffer.toString("utf8", 0, bytesRead);
-        return content.includes("<!-- 🥞 fln");
-    }
-    catch {
-        return false;
+        const header = buffer.toString("utf8", 0, Math.min(100, bytesRead));
+        const isGenerated = header.includes("<!-- 🥞 fln");
+        const isBinary = !isGenerated && buffer.slice(0, bytesRead).includes(0);
+        return { isGenerated, isBinary };
     }
     finally {
         await handle.close();
@@ -100,37 +82,52 @@ export async function scanTree(options, logger) {
         outputTokenCount: 0
     };
     const ignoreMatcher = new IgnoreMatcher({
-        rootDirectory: options.rootDirectory,
+        input: options.input,
         excludePatterns: options.excludePatterns,
-        useGitignore: options.useGitignore,
+        gitignore: options.gitignore,
         logger
     });
-    const includeMatcher = ignore().add(options.includePatterns);
+    const normalizedIncludePatterns = options.includePatterns
+        .map(pattern => normalizeIncludePattern(pattern, options.input))
+        .filter((p) => p !== null);
+    const includeMatcher = ignore().add(normalizedIncludePatterns);
     const concurrencyLimit = Math.max(8, Math.min(64, cpus().length * 4));
-    const excludedPathSet = new Set(options.excludedPaths.map(pathItem => normalizePathSegment(pathItem)));
+    const limit = pLimit(concurrencyLimit);
+    const excludedPathSet = new Set(options.excludedPaths
+        .map(path => toCanonicalRelative(path, options.input))
+        .filter((p) => p !== null && p !== ""));
     const visitedRealPaths = new Set();
     let processedItems = 0;
     let totalEstimate = 0;
     if (options.followSymlinks)
         try {
-            const rootRealPath = await realpath(options.rootDirectory);
+            const rootRealPath = await realpath(options.input);
             visitedRealPaths.add(rootRealPath);
         }
         catch {
             logger.debug("Failed to resolve root real path.");
         }
-    const rootNode = await scanEntry(options.rootDirectory, "");
+    const rootNode = await scanEntry(options.input, "");
     if (!rootNode || rootNode.type !== "directory")
         throw new Error("Root directory is empty or all files were excluded.");
     return { projectName: options.projectName, root: rootNode, stats };
     async function scanEntry(currentPath, relativePath, dirent) {
-        const normalizedRelativePath = normalizePathSegment(relativePath);
+        const normalizedRelativePath = toPosixPath(relativePath);
         const name = dirent?.name ?? currentPath.split(sep).pop() ?? "";
         if (normalizedRelativePath !== "" && excludedPathSet.has(normalizedRelativePath))
             return undefined;
-        const isExplicitlyIncluded = normalizedRelativePath !== "" && includeMatcher.ignores(normalizedRelativePath);
-        const pathForIgnoreCheck = normalizedRelativePath === "" ? "" : (dirent?.isDirectory() ? `${normalizedRelativePath}/` : normalizedRelativePath);
-        if (!isExplicitlyIncluded && pathForIgnoreCheck !== "" && ignoreMatcher.ignores(pathForIgnoreCheck))
+        const pathForCheck = normalizedRelativePath === "" ? "" : (dirent?.isDirectory() ? `${normalizedRelativePath}/` : normalizedRelativePath);
+        const safePath = toIgnoreSafePath(pathForCheck, options.input);
+        const isExplicitlyIncluded = safePath !== null &&
+            safePath !== "" &&
+            includeMatcher.ignores(safePath);
+        const isDirectory = pathForCheck.endsWith("/");
+        if (normalizedIncludePatterns.length > 0 &&
+            !isExplicitlyIncluded &&
+            pathForCheck !== "" &&
+            !isDirectory)
+            return undefined;
+        if (!isExplicitlyIncluded && pathForCheck !== "" && ignoreMatcher.ignoresSafePath(safePath))
             return undefined;
         if (!options.includeHidden && name.startsWith(".") && name !== ".")
             return undefined;
@@ -255,20 +252,23 @@ export async function scanTree(options, logger) {
         if (options.onProgress)
             options.onProgress(processedItems, Math.max(totalEstimate, processedItems));
         let skipReason;
-        if (!input.isExplicitlyIncluded && await isGeneratedFile(input.currentPath, input.fileSize))
-            skipReason = "generated";
-        if (!skipReason && input.fileSize > options.maximumFileSizeBytes)
-            skipReason = "tooLarge";
         let isBinary = false;
-        if (!skipReason)
+        const needsRead = input.fileSize > 0 &&
+            (input.fileSize <= options.maxFileSize || !input.isExplicitlyIncluded);
+        if (needsRead)
             try {
-                isBinary = await isBinaryFile(input.currentPath, input.fileSize);
+                const { isGenerated, isBinary: binary } = await inspectFile(input.currentPath, input.fileSize);
+                if (!input.isExplicitlyIncluded && isGenerated)
+                    skipReason = "generated";
+                isBinary = binary;
             }
             catch (error) {
                 stats.errors++;
                 skipReason = "readError";
                 logger.warn(`Failed to read ${input.normalizedRelativePath || "."}: ${String(error)}`);
             }
+        if (!skipReason && input.fileSize > options.maxFileSize)
+            skipReason = "tooLarge";
         if (isBinary)
             stats.binary++;
         if (skipReason) {
@@ -297,11 +297,11 @@ export async function scanTree(options, logger) {
         await ignoreMatcher.addGitignoreForDirectory(input.currentPath);
         const entries = await readdir(input.currentPath, { withFileTypes: true });
         totalEstimate = Math.max(totalEstimate, processedItems + entries.length);
-        const children = (await mapWithConcurrency(entries, concurrencyLimit, async (entry) => {
+        const children = (await Promise.all(entries.map(entry => limit(() => {
             const childPath = `${input.currentPath}${sep}${entry.name}`;
-            const childRelativePath = relative(options.rootDirectory, childPath);
+            const childRelativePath = relative(options.input, childPath);
             return scanEntry(childPath, childRelativePath, entry);
-        }))
+        }))))
             .filter((node) => node !== undefined)
             .sort((left, right) => {
             if (left.type !== right.type)
@@ -324,26 +324,3 @@ export async function scanTree(options, logger) {
         };
     }
 }
-async function mapWithConcurrency(items, concurrency, mapper) {
-    if (items.length === 0)
-        return [];
-    const limit = Math.max(1, Math.min(concurrency, items.length));
-    if (limit === 1) {
-        const results = [];
-        for (const item of items)
-            results.push(await mapper(item));
-        return results;
-    }
-    const results = new Array(items.length);
-    let nextIndex = 0;
-    const workers = Array.from({ length: limit }, async () => {
-        while (true) {
-            const currentIndex = nextIndex++;
-            if (currentIndex >= items.length)
-                return;
-            results[currentIndex] = await mapper(items[currentIndex]);
-        }
-    });
-    await Promise.all(workers);
-    return results;
-}

package/dist/core/size.js

@@ -1,27 +1,13 @@
-const kibibyte = 1024;
-const mebibyte = kibibyte * 1024;
-const gibibyte = mebibyte * 1024;
+import bytes from "bytes";
 export function parseByteSize(input) {
-    const normalizedInput = input.trim().toLowerCase();
-    const match = normalizedInput.match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/);
-    if (!match)
+    const result = bytes.parse(input.trim());
+    if (result === null || result < 0)
         throw new Error(`Invalid size: "${input}"`);
-    const value = Number(match[1]);
-    const unit = match[2] ?? "b";
-    const multiplier = unit === "kb" ? kibibyte :
-        unit === "mb" ? mebibyte :
-            unit === "gb" ? gibibyte :
-                1;
-    return Math.floor(value * multiplier);
+    return Math.floor(result);
 }
 export function formatByteSize(sizeBytes) {
-    if (sizeBytes >= gibibyte)
-        return `${(sizeBytes / gibibyte).toFixed(2)} GB`;
-    if (sizeBytes >= mebibyte)
-        return `${(sizeBytes / mebibyte).toFixed(2)} MB`;
-    if (sizeBytes >= kibibyte)
-        return `${(sizeBytes / kibibyte).toFixed(2)} KB`;
-    return `${sizeBytes} B`;
+    const result = bytes(sizeBytes, { unitSeparator: " " });
+    return result ?? `${sizeBytes} B`;
 }
 export function formatTokenCount(count) {
     if (count >= 1_000_000)

package/dist/core/statsCollector.d.ts

@@ -1,3 +1,3 @@
-import type { FileNode } from "./types";
+import type { FileNode } from "./types.js";
 export declare function collectExtensionStats(root: FileNode): Map<string, number>;
 export declare function collectProcessedFiles(root: FileNode): string[];

package/dist/core/types.d.ts

@@ -30,23 +30,23 @@ export type ScanResult = {
 export type ProgressCallback = (current: number, total: number) => void;
 export type ScanOptions = {
     projectName: string;
-    rootDirectory: string;
+    input: string;
     excludePatterns: string[];
     includePatterns: string[];
     excludedPaths: string[];
     includeHidden: boolean;
-    useGitignore: boolean;
-    maximumFileSizeBytes: number;
-    maximumTotalSizeBytes: number;
+    gitignore: boolean;
+    maxFileSize: number;
+    maxTotalSize: number;
     followSymlinks: boolean;
     onProgress?: ProgressCallback;
 };
 export type RenderOptions = {
-    outputFile: string;
+    output: string;
     format: OutputFormat;
     includeTree: boolean;
     includeContents: boolean;
-    useAnsi: boolean;
+    ansi: boolean;
     banner?: string;
     footer?: string;
 };

package/dist/index.d.ts

@@ -1,3 +1 @@
-export * from "./api";
-export * from "./core";
-export * from "./version";
+export * from "./api/index.js";

package/dist/index.js

@@ -1,3 +1 @@
-export * from "./api";
-export * from "./core";
-export * from "./version";
+export * from "./api/index.js";

package/dist/infra/datetime.js

@@ -1,12 +1,14 @@
 const generatedDateRegex = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/;
 export function formatDateTime() {
     const now = new Date();
-    const year = now.getFullYear();
-    const month = String(now.getMonth() + 1).padStart(2, "0");
-    const day = String(now.getDate()).padStart(2, "0");
-    const hours = String(now.getHours()).padStart(2, "0");
-    const minutes = String(now.getMinutes()).padStart(2, "0");
-    return `${year}-${month}-${day} ${hours}:${minutes}`;
+    return `${[
+        now.getFullYear(),
+        String(now.getMonth() + 1).padStart(2, "0"),
+        String(now.getDate()).padStart(2, "0")
+    ].join("-")} ${[
+        String(now.getHours()).padStart(2, "0"),
+        String(now.getMinutes()).padStart(2, "0")
+    ].join(":")}`;
 }
 export function parseGeneratedDate(value) {
     if (!generatedDateRegex.test(value.trim()))

package/dist/infra/deprecate.d.ts

@@ -0,0 +1,2 @@
+export declare function warnDeprecated(oldName: string, newName: string, context?: string): void;
+export declare function resolveOption<T, O extends Record<string, unknown> = Record<string, unknown>>(options: O, newKey: keyof O, deprecatedKey: keyof O, context: string, parse?: (value: unknown) => T | undefined): T | undefined;

package/dist/infra/deprecate.js

@@ -0,0 +1,14 @@
+export function warnDeprecated(oldName, newName, context) {
+    const message = context ?
+        `fln: "${oldName}" is deprecated, use "${newName}" instead (${context})` :
+        `fln: "${oldName}" is deprecated, use "${newName}" instead`;
+    console.warn(message);
+}
+export function resolveOption(options, newKey, deprecatedKey, context, parse) {
+    const newVal = options[newKey];
+    const deprecatedVal = options[deprecatedKey];
+    if (deprecatedVal !== undefined && newVal === undefined)
+        warnDeprecated(String(deprecatedKey), String(newKey), context);
+    const raw = newVal ?? deprecatedVal;
+    return raw === undefined ? undefined : (parse ? parse(raw) : raw);
+}

package/dist/infra/gitDiff.d.ts

@@ -0,0 +1,2 @@
+export declare function getChangedFilesSince(ref: string, cwd: string): string[];
+export declare function filterPathsUnderBase(gitPaths: string[], cwd: string, inputBase: string): string[];

package/dist/infra/gitDiff.js

@@ -0,0 +1,33 @@
+import { spawnSync } from "node:child_process";
+import { join, relative } from "node:path";
+import { toPosixPath } from "../path/index.js";
+export function getChangedFilesSince(ref, cwd) {
+    const result = spawnSync("git", ["diff", "--name-only", ref], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (result.error)
+        throw new Error(`fln: git not found (${result.error.message}). Install git and ensure it is in PATH.`);
+    if (result.status !== 0) {
+        const stderr = (result.stderr ?? "").trim();
+        throw new Error(stderr ?
+            `fln: git diff failed: ${stderr}` :
+            `fln: git diff failed (exit ${result.status}). Not a git repository or invalid ref: ${ref}`);
+    }
+    const output = (result.stdout ?? "").trim();
+    if (!output)
+        return [];
+    return output.split("\n").filter(Boolean);
+}
+export function filterPathsUnderBase(gitPaths, cwd, inputBase) {
+    return gitPaths
+        .map(gitPath => {
+        const absolutePath = join(cwd, gitPath);
+        const relativeToInput = relative(inputBase, absolutePath);
+        if (relativeToInput.startsWith("..") || relativeToInput === "")
+            return null;
+        return toPosixPath(relativeToInput);
+    })
+        .filter((path) => path !== null && path !== "");
+}

package/dist/infra/index.d.ts

@@ -1,6 +1,8 @@
-export * from "./countTokens";
-export * from "./datetime";
-export * from "./logger";
-export * from "./outputWriter";
-export * from "./terminal";
-export * from "./usageTracker";
+export * from "./countTokens.js";
+export * from "./datetime.js";
+export * from "./deprecate.js";
+export * from "./gitDiff.js";
+export * from "./logger.js";
+export * from "./outputWriter.js";
+export * from "./terminal.js";
+export * from "./usageTracker.js";

package/dist/infra/index.js

@@ -1,6 +1,8 @@
-export * from "./countTokens";
-export * from "./datetime";
-export * from "./logger";
-export * from "./outputWriter";
-export * from "./terminal";
-export * from "./usageTracker";
+export * from "./countTokens.js";
+export * from "./datetime.js";
+export * from "./deprecate.js";
+export * from "./gitDiff.js";
+export * from "./logger.js";
+export * from "./outputWriter.js";
+export * from "./terminal.js";
+export * from "./usageTracker.js";

package/dist/infra/logger.d.ts

@@ -1,6 +1,6 @@
-import type { LogLevel } from "../core";
+import type { LogLevel } from "../core/index.js";
 type LoggerOptions = {
-    useAnsi: boolean;
+    ansi: boolean;
     logLevel: LogLevel;
 };
 export type Logger = {