lsallcp 1.0.0 → 2.0.0

package/README.md

@@ -1,9 +1,9 @@
 # lsallcp
 
-> Recursively dump every file in a directory as colorized, fenced-code blocks -- with smart skip patterns, a live progress bar, and one-flag clipboard export. Built on [`cli-atelier`](https://www.npmjs.com/package/cli-atelier), runs on [Bun](https://bun.sh).
+> Recursively dump every file in a directory as colorized, fenced-code blocks -- with smart skip patterns, a live progress bar, and one-flag clipboard export. Built on [`cli-atelier`](https://www.npmjs.com/package/cli-atelier), runs on Node.js.
 
 ```bash
-bun add -g lsallcp
+npm install -g lsallcp
 ```
 
 ---
@@ -34,39 +34,36 @@ It's built for quickly dumping a project's source into a chat window, a doc, or
 | Live progress bar                                 | Real-time progress while files are read, powered by `cli-atelier`           |
 | Colorized output                                  | Paths, fences, and log messages are colored for readability                 |
 | Clipboard export                                  | `-c` / `--copy` copies plain-text results directly to your system clipboard |
-| Zero runtime dependencies (besides `cli-atelier`) | No bundler, no build step -- pure Bun + TypeScript                          |
+| Zero runtime dependencies (besides `cli-atelier`) | Ships precompiled JavaScript -- no separate build step at install time      |
 | Cross-platform                                    | Works in Windows Terminal, Git Bash, macOS Terminal, and Linux shells       |
 
 ---
 
 ## Requirements
 
-| Dependency | Minimum version | Notes                                                        |
-| ---------- | --------------- | ------------------------------------------------------------ |
-| Bun        | `>= 1.1.0`      | Required at runtime -- the CLI executes as raw `.ts` via Bun |
-| Node.js    | `>= 18.0.0`     | Only needed if installing globally via `npm`/`pnpm`/`yarn`   |
+| Dependency | Minimum version | Notes                                                   |
+| ---------- | --------------- | ------------------------------------------------------- |
+| Node.js    | `>= 18.0.0`     | Runs the compiled CLI directly, no other runtime needed |
 
-> `lsallcp` always executes through Bun. When installed via `npm install -g`, the generated shim (`bin/lsallcp.js`) runs under Node just long enough to spawn Bun as a subprocess -- this is what makes the same package work identically in Windows Terminal, Git Bash, macOS, and Linux.
+`lsallcp` is a pure Node.js package. TypeScript sources are compiled to plain JavaScript with `tsc` and published under `dist/`, so no Bun, `ts-node`, or extra runtime is required to use it.
 
 ---
 
 ## Installation
 
 ```bash
-# Bun (recommended -- installs and runs natively)
-bun add -g lsallcp
-
-# npm / pnpm / yarn (cross-platform shim, still requires Bun on PATH)
 npm install -g lsallcp
+# or
 pnpm add -g lsallcp
+# or
 yarn global add lsallcp
 ```
 
 To use it inside a single project instead of globally:
 
 ```bash
-bun add -d lsallcp
-bunx lsallcp .
+npm install -D lsallcp
+npx lsallcp .
 ```
 
 ---
@@ -167,10 +164,10 @@ If none of these tools are available on Linux, `lsallcp` prints a warning and le
 
 Each file is rendered as:
 
-<relativePath>:
-<code><extension>
-<file content>
-</code>
+\<relativePath>:<br>
+\<code>\<extension><br>
+\<file content><br>
+\</code>
 
 - `<relativePath>` is colored cyan and bold, relative to the scanned root, using forward slashes on all platforms.
 - `<extension>` is the file's extension without the leading dot (`ts`, `json`, `md`); extensionless files fall back to `text`.
@@ -189,13 +186,13 @@ Each file is rendered as:
 
 ## How it works
 
-`lsallcp` is a thin, purpose-built CLI in three stages:
+`lsallcp` is a thin, purpose-built CLI in three stages, written in TypeScript and compiled to JavaScript via `tsc` (`npm run build`, wired to `prepare` so it's built automatically on install from source):
 
 1. **Scan** -- recursively walks the target directory (`src/scanner.ts`), pruning any path matched by a compiled skip matcher (`src/matcher.ts`) before ever entering it.
 2. **Read** -- reads each remaining file, detects binary content (`src/binary.ts`), and formats it into a colorized fenced block (`src/render.ts`), updating a live progress bar as it goes.
 3. **Output** -- either prints the assembled result to stdout, or strips ANSI codes and sends it to the system clipboard (`src/clipboard.ts`) when `-c`/`--copy` is set.
 
-All terminal UI -- headers, spinners, progress bars, logs, boxes -- comes from [`cli-atelier`](https://www.npmjs.com/package/cli-atelier), a zero-dependency, pure-ANSI terminal framework for Bun.
+All terminal UI -- headers, spinners, progress bars, logs, boxes -- comes from [`cli-atelier`](https://www.npmjs.com/package/cli-atelier), a zero-dependency, pure-ANSI terminal framework.
 
 ---
 

package/dist/binary.js

@@ -0,0 +1,7 @@
+export function isBinaryBuffer(buffer, sampleSize = 8000) {
+    const length = Math.min(buffer.length, sampleSize);
+    for (let index = 0; index < length; index++)
+        if (buffer[index] === 0)
+            return true;
+    return false;
+}

package/dist/cli.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { Display, Log, Header, Spinner, Progress, Box } from 'cli-atelier';
+import { buildSkipMatchers } from './matcher.js';
+import { scanDirectory } from './scanner.js';
+import { renderFile } from './render.js';
+import { copyToClipboard } from './clipboard.js';
+const COPY_FLAGS = new Set(['--copy', '-c']);
+function printHelp() {
+    Box.render([
+        Display.paint('lsallcp <path> [skipPattern...] [--copy|-c]', Display.color.white, Display.color.bold),
+        '',
+        '  lsallcp .                      List every file under the current dir',
+        '  lsallcp . node_modules         Skip any file/folder named node_modules',
+        '  lsallcp . *.png *.lock         Skip by glob pattern',
+        '  lsallcp . /\\.test\\.ts$/i     Skip by regex literal',
+        "  lsallcp . --copy               List, copy to clipboard, don't print content",
+        "  lsallcp . node_modules -c      Skip + copy, flag order doesn't matter",
+        '',
+        Display.paint('Note:', Display.color.yellow) + ' .git is always skipped.',
+    ], { style: 'round', color: Display.color.cyan, title: 'lsallcp' });
+}
+async function resolveRoot(targetArgument) {
+    const root = path.resolve(process.cwd(), targetArgument);
+    const stat = await fs.stat(root);
+    if (!stat.isDirectory())
+        throw new Error(`Target is not a directory: ${root}`);
+    return root;
+}
+function parseArgs(argv) {
+    let copy = false;
+    const rest = [];
+    for (const arg of argv) {
+        if (COPY_FLAGS.has(arg))
+            copy = true;
+        else
+            rest.push(arg);
+    }
+    const [targetArgument, ...skipArguments] = rest;
+    return { targetArgument, skipArguments, copy };
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') {
+        printHelp();
+        return;
+    }
+    const { targetArgument, skipArguments, copy } = parseArgs(argv);
+    if (!targetArgument) {
+        printHelp();
+        return;
+    }
+    Header.render('lsallcp', { style: 'banner', color: Display.color.magenta });
+    const root = await resolveRoot(targetArgument);
+    Log.info(`Target: ${Display.paint(root, Display.color.yellow)}`);
+    if (skipArguments.length > 0)
+        Log.info(`Skip patterns: ${Display.paint(skipArguments.join(', '), Display.color.gray)}`);
+    if (copy)
+        Log.info(`Clipboard: ${Display.paint('enabled', Display.color.green)} (content will not be printed)`);
+    const matchers = buildSkipMatchers(skipArguments);
+    const spinner = new Spinner('Walking directory tree...');
+    spinner.start();
+    const files = await scanDirectory(root, matchers);
+    spinner.stop(`Found ${files.length} file(s) after skipping`);
+    if (files.length === 0) {
+        Log.warn('No files matched. Nothing to list.');
+        return;
+    }
+    const bar = new Progress({ label: 'Reading files', width: 40, color: Display.color.cyan });
+    const blocks = [];
+    for (let index = 0; index < files.length; index++) {
+        blocks.push(await renderFile(files[index]));
+        bar.update(Math.round(((index + 1) / files.length) * 100));
+    }
+    bar.finish('All files read');
+    const output = blocks.join('\n\n');
+    if (!copy) {
+        Header.divider();
+        console.log(output);
+        Header.divider();
+    }
+    Log.success(`Listed ${files.length} file(s) from ${Display.paint(root, Display.color.yellow)}`);
+    if (copy) {
+        const plainOutput = Display.strip(output);
+        const copied = await copyToClipboard(plainOutput);
+        if (copied)
+            Log.success('Result copied to clipboard');
+        else
+            Log.warn('Could not copy to clipboard (no clip/pbcopy/wl-copy/xclip/xsel found)');
+    }
+}
+main().catch((error) => {
+    Log.error(error instanceof Error ? error.stack ?? error.message : String(error));
+    process.exit(1);
+});

package/dist/clipboard.js

@@ -0,0 +1,30 @@
+import { spawn } from 'node:child_process';
+function candidateCommands() {
+    switch (process.platform) {
+        case 'win32': return [{ command: 'clip', args: [] }];
+        case 'darwin': return [{ command: 'pbcopy', args: [] }];
+        default: return [
+            { command: 'wl-copy', args: [] },
+            { command: 'xclip', args: ['-selection', 'clipboard'] },
+            { command: 'xsel', args: ['--clipboard', '--input'] },
+        ];
+    }
+}
+function tryCommand(command, text) {
+    return new Promise((resolve) => {
+        const child = spawn(command.command, command.args, { stdio: ['pipe', 'ignore', 'ignore'] });
+        child.once('error', () => resolve(false));
+        child.once('close', (code) => resolve(code === 0));
+        child.stdin.on('error', () => { });
+        child.stdin.write(text);
+        child.stdin.end();
+    });
+}
+export async function copyToClipboard(text) {
+    for (const command of candidateCommands()) {
+        const ok = await tryCommand(command, text);
+        if (ok)
+            return true;
+    }
+    return false;
+}

package/dist/matcher.js

@@ -0,0 +1,51 @@
+function defaultGitMatcher(baseName) { return baseName === '.git'; }
+function parseRegexLiteral(raw) {
+    const match = raw.match(/^\/(.+)\/([a-z]*)$/i);
+    if (!match)
+        return null;
+    try {
+        return new RegExp(match[1], match[2]);
+    }
+    catch {
+        return null;
+    }
+}
+function globToRegExp(glob) {
+    let out = '^';
+    for (let index = 0; index < glob.length; index++) {
+        const char = glob[index];
+        if (char === '*') {
+            if (glob[index + 1] === '*') {
+                out += '.*';
+                index++;
+            }
+            else
+                out += '[^/]*';
+        }
+        else if (char === '?')
+            out += '[^/]';
+        else if ('.+^$()[]{}|\\'.includes(char))
+            out += '\\' + char;
+        else
+            out += char;
+    }
+    out += '$';
+    return new RegExp(out, 'i');
+}
+function compilePattern(raw) {
+    const regexLiteral = parseRegexLiteral(raw);
+    if (regexLiteral)
+        return (relativePath, baseName) => regexLiteral.test(baseName) || regexLiteral.test(relativePath);
+    if (/[*?]/.test(raw)) {
+        const compiled = globToRegExp(raw);
+        return (relativePath, baseName) => compiled.test(baseName) || compiled.test(relativePath);
+    }
+    const lowered = raw.toLowerCase();
+    return (_relativePath, baseName) => baseName.toLowerCase() === lowered;
+}
+export function buildSkipMatchers(patterns) {
+    return [defaultGitMatcher, ...patterns.map(compilePattern)];
+}
+export function shouldSkip(matchers, relativePath, baseName, isDirectory) {
+    return matchers.some((matcher) => matcher(relativePath, baseName, isDirectory));
+}

package/dist/render.js

@@ -0,0 +1,26 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { Display } from 'cli-atelier';
+import { isBinaryBuffer } from './binary.js';
+function resolveExtension(relativePath) {
+    const extension = path.extname(relativePath).slice(1);
+    return extension.length > 0 ? extension : 'text';
+}
+export async function renderFile(file) {
+    const extension = resolveExtension(file.relativePath);
+    let body;
+    try {
+        const buffer = await fs.readFile(file.absolutePath);
+        if (isBinaryBuffer(buffer))
+            body = Display.paint('[binary file - content skipped]', Display.color.gray, Display.color.italic);
+        else
+            body = buffer.toString('utf8');
+    }
+    catch (error) {
+        body = Display.paint(`[unreadable: ${error.message}]`, Display.color.red);
+    }
+    const header = Display.paint(file.relativePath, Display.color.cyan, Display.color.bold) + ':';
+    const openFence = Display.paint('```' + extension, Display.color.gray);
+    const closeFence = Display.paint('```', Display.color.gray);
+    return `${header}\n${openFence}\n${body}\n${closeFence}`;
+}

package/dist/scanner.js

@@ -0,0 +1,32 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { Log } from 'cli-atelier';
+import { shouldSkip } from './matcher.js';
+export async function scanDirectory(root, matchers) {
+    const results = [];
+    await walk(root, '', matchers, results);
+    results.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+    return results;
+}
+async function walk(directory, relativeBase, matchers, results) {
+    let entries;
+    try {
+        entries = await fs.readdir(directory, { withFileTypes: true });
+    }
+    catch (error) {
+        Log.warn(`Skipping unreadable directory: ${directory} (${error.message})`);
+        return;
+    }
+    for (const entry of entries) {
+        const relativePath = relativeBase ? `${relativeBase}/${entry.name}` : entry.name;
+        const isDirectory = entry.isDirectory();
+        if (shouldSkip(matchers, relativePath, entry.name, isDirectory))
+            continue;
+        if (isDirectory) {
+            await walk(path.join(directory, entry.name), relativePath, matchers, results);
+        }
+        else if (entry.isFile()) {
+            results.push({ absolutePath: path.join(directory, entry.name), relativePath });
+        }
+    }
+}

package/package.json

@@ -1,21 +1,24 @@
 {
   "name": "lsallcp",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Recursively list every file's content as relativePath: ```ext code fences```, with glob/regex/name skip patterns, progress bar and colored output",
   "type": "module",
   "bin": {
-    "lsallcp": "./bin/lsallcp.js"
+    "lsallcp": "./dist/cli.js"
   },
-  "files": ["src", "bin", "package.json", "README.md", "LICENSE"],
+  "main": "./dist/cli.js",
+  "files": ["dist", "package.json", "README.md", "LICENSE"],
   "engines": {
-    "bun": ">=1.1.0"
+    "node": ">=18.0.0"
   },
   "scripts": {
-    "start": "bun src/cli.ts"
+    "build": "tsc",
+    "prepare": "bun run build",
+    "start": "bun run dist/cli.js"
   },
-  "keywords": ["cli", "bun", "list", "files", "dump", "tree"],
+  "keywords": ["cli", "node", "list", "files", "dump", "tree"],
   "devDependencies": {
-    "@types/bun": "latest",
+    "@types/node": "latest",
     "typescript": "latest"
   },
   "dependencies": {

package/bin/lsallcp.js

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-
-const { spawnSync } = require('node:child_process')
-const path = require('node:path')
-
-const cliEntry = path.join(__dirname, '..', 'src', 'cli.ts')
-const args = process.argv.slice(2)
-
-const result = spawnSync('bun', [cliEntry, ...args], { stdio: 'inherit' })
-
-if (result.error) {
-  console.error('lsallcp requires Bun to be installed and available on your PATH.')
-  console.error('Install it from https://bun.sh/ then try again.')
-  process.exit(1)
-}
-
-process.exit(result.status === null ? 1 : result.status)

package/src/binary.ts

@@ -1,5 +0,0 @@
-export function isBinaryBuffer(buffer: Buffer, sampleSize = 8000): boolean {
-  const length = Math.min(buffer.length, sampleSize)
-  for (let index = 0; index < length; index++) if (buffer[index] === 0) return true
-  return false
-}

package/src/cli.ts

@@ -1,99 +0,0 @@
-#!/usr/bin/env bun
-
-import path from 'node:path'
-import { promises as fs } from 'node:fs'
-import { Display, Log, Header, Spinner, Progress, Box } from 'cli-atelier'
-import { buildSkipMatchers } from './matcher'
-import { scanDirectory } from './scanner'
-import { renderFile } from './render'
-import { copyToClipboard } from './clipboard'
-
-const COPY_FLAGS = new Set(['--copy', '-c'])
-
-function printHelp(): void {
-  Box.render(
-    [
-      Display.paint('lsallcp <path> [skipPattern...] [--copy|-c]', Display.color.white, Display.color.bold),
-      '',
-      '  lsallcp .                      List every file under the current dir',
-      '  lsallcp . node_modules         Skip any file/folder named node_modules',
-      '  lsallcp . *.png *.lock         Skip by glob pattern',
-      '  lsallcp . /\\.test\\.ts$/i     Skip by regex literal',
-      "  lsallcp . --copy               List, copy to clipboard, don't print content",
-      "  lsallcp . node_modules -c      Skip + copy, flag order doesn't matter",
-      '',
-      Display.paint('Note:', Display.color.yellow) + ' .git is always skipped.',
-    ],
-    { style: 'round', color: Display.color.cyan, title: 'lsallcp' }
-  )
-}
-
-async function resolveRoot(targetArgument: string): Promise<string> {
-  const root = path.resolve(process.cwd(), targetArgument)
-  const stat = await fs.stat(root)
-  if (!stat.isDirectory()) throw new Error(`Target is not a directory: ${root}`)
-  return root
-}
-
-function parseArgs(argv: string[]): { targetArgument: string, skipArguments: string[], copy: boolean } {
-  let copy = false
-  const rest: string[] = []
-  for (const arg of argv) {
-    if (COPY_FLAGS.has(arg)) copy = true
-    else rest.push(arg)
-  }
-  const [targetArgument, ...skipArguments] = rest
-  return { targetArgument, skipArguments, copy }
-}
-
-async function main(): Promise<void> {
-  const argv = process.argv.slice(2)
-  if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') {
-    printHelp()
-    return
-  }
-  const { targetArgument, skipArguments, copy } = parseArgs(argv)
-  if (!targetArgument) {
-    printHelp()
-    return
-  }
-  Header.render('lsallcp', { style: 'banner', color: Display.color.magenta })
-  const root = await resolveRoot(targetArgument)
-  Log.info(`Target: ${Display.paint(root, Display.color.yellow)}`)
-  if (skipArguments.length > 0) Log.info(`Skip patterns: ${Display.paint(skipArguments.join(', '), Display.color.gray)}`)
-  if (copy) Log.info(`Clipboard: ${Display.paint('enabled', Display.color.green)} (content will not be printed)`)
-  const matchers = buildSkipMatchers(skipArguments)
-  const spinner = new Spinner('Walking directory tree...')
-  spinner.start()
-  const files = await scanDirectory(root, matchers)
-  spinner.stop(`Found ${files.length} file(s) after skipping`)
-  if (files.length === 0) {
-    Log.warn('No files matched. Nothing to list.')
-    return
-  }
-  const bar = new Progress({ label: 'Reading files', width: 40, color: Display.color.cyan })
-  const blocks: string[] = []
-  for (let index = 0; index < files.length; index++) {
-    blocks.push(await renderFile(files[index]))
-    bar.update(Math.round(((index + 1) / files.length) * 100))
-  }
-  bar.finish('All files read')
-  const output = blocks.join('\n\n')
-  if (!copy) {
-    Header.divider()
-    console.log(output)
-    Header.divider()
-  }
-  Log.success(`Listed ${files.length} file(s) from ${Display.paint(root, Display.color.yellow)}`)
-  if (copy) {
-    const plainOutput = Display.strip(output)
-    const copied = await copyToClipboard(plainOutput)
-    if (copied) Log.success('Result copied to clipboard')
-    else Log.warn('Could not copy to clipboard (no clip/pbcopy/wl-copy/xclip/xsel found)')
-  }
-}
-
-main().catch((error) => {
-  Log.error(error instanceof Error ? error.stack ?? error.message : String(error))
-  process.exit(1)
-})

package/src/clipboard.ts

@@ -1,37 +0,0 @@
-import { spawn } from 'node:child_process'
-
-interface ClipboardCommand {
-  command: string
-  args: string[]
-}
-
-function candidateCommands(): ClipboardCommand[] {
-  switch (process.platform) {
-    case 'win32': return [{ command: 'clip', args: [] }]
-    case 'darwin': return [{ command: 'pbcopy', args: [] }]
-    default: return [
-      { command: 'wl-copy', args: [] },
-      { command: 'xclip', args: ['-selection', 'clipboard'] },
-      { command: 'xsel', args: ['--clipboard', '--input'] },
-    ]
-  }
-}
-
-function tryCommand(command: ClipboardCommand, text: string): Promise<boolean> {
-  return new Promise((resolve) => {
-    const child = spawn(command.command, command.args, { stdio: ['pipe', 'ignore', 'ignore'] })
-    child.once('error', () => resolve(false))
-    child.once('close', (code) => resolve(code === 0))
-    child.stdin.on('error', () => { })
-    child.stdin.write(text)
-    child.stdin.end()
-  })
-}
-
-export async function copyToClipboard(text: string): Promise<boolean> {
-  for (const command of candidateCommands()) {
-    const ok = await tryCommand(command, text)
-    if (ok) return true
-  }
-  return false
-}

package/src/matcher.ts

@@ -1,45 +0,0 @@
-export type SkipMatcher = (relativePath: string, baseName: string, isDirectory: boolean) => boolean
-
-function defaultGitMatcher(baseName: string): boolean { return baseName === '.git' }
-
-function parseRegexLiteral(raw: string): RegExp | null {
-  const match = raw.match(/^\/(.+)\/([a-z]*)$/i)
-  if (!match) return null
-  try { return new RegExp(match[1], match[2]) } catch { return null }
-}
-
-function globToRegExp(glob: string): RegExp {
-  let out = '^'
-  for (let index = 0; index < glob.length; index++) {
-    const char = glob[index]
-    if (char === '*') {
-      if (glob[index + 1] === '*') {
-        out += '.*'
-        index++
-      } else out += '[^/]*'
-    } else if (char === '?') out += '[^/]'
-    else if ('.+^$()[]{}|\\'.includes(char)) out += '\\' + char
-    else out += char
-  }
-  out += '$'
-  return new RegExp(out, 'i')
-}
-
-function compilePattern(raw: string): SkipMatcher {
-  const regexLiteral = parseRegexLiteral(raw)
-  if (regexLiteral) return (relativePath, baseName) => regexLiteral.test(baseName) || regexLiteral.test(relativePath)
-  if (/[*?]/.test(raw)) {
-    const compiled = globToRegExp(raw)
-    return (relativePath, baseName) => compiled.test(baseName) || compiled.test(relativePath)
-  }
-  const lowered = raw.toLowerCase()
-  return (_relativePath, baseName) => baseName.toLowerCase() === lowered
-}
-
-export function buildSkipMatchers(patterns: string[]): SkipMatcher[] {
-  return [defaultGitMatcher, ...patterns.map(compilePattern)]
-}
-
-export function shouldSkip(matchers: SkipMatcher[], relativePath: string, baseName: string, isDirectory: boolean): boolean {
-  return matchers.some((matcher) => matcher(relativePath, baseName, isDirectory))
-}

package/src/render.ts

@@ -1,26 +0,0 @@
-import path from 'node:path'
-import { promises as fs } from 'node:fs'
-import { Display } from 'cli-atelier'
-import type { ScannedFile } from './scanner'
-import { isBinaryBuffer } from './binary'
-
-function resolveExtension(relativePath: string): string {
-  const extension = path.extname(relativePath).slice(1)
-  return extension.length > 0 ? extension : 'text'
-}
-
-export async function renderFile(file: ScannedFile): Promise<string> {
-  const extension = resolveExtension(file.relativePath)
-  let body: string
-  try {
-    const buffer = await fs.readFile(file.absolutePath)
-    if (isBinaryBuffer(buffer)) body = Display.paint('[binary file - content skipped]', Display.color.gray, Display.color.italic)
-    else body = buffer.toString('utf8')
-  } catch (error) {
-    body = Display.paint(`[unreadable: ${(error as Error).message}]`, Display.color.red)
-  }
-  const header = Display.paint(file.relativePath, Display.color.cyan, Display.color.bold) + ':'
-  const openFence = Display.paint('```' + extension, Display.color.gray)
-  const closeFence = Display.paint('```', Display.color.gray)
-  return `${header}\n${openFence}\n${body}\n${closeFence}`
-}

package/src/scanner.ts

@@ -1,37 +0,0 @@
-import path from 'node:path'
-import { promises as fs } from 'node:fs'
-import { Log } from 'cli-atelier'
-import type { SkipMatcher } from './matcher'
-import { shouldSkip } from './matcher'
-
-export interface ScannedFile {
-  absolutePath: string
-  relativePath: string
-}
-
-export async function scanDirectory(root: string, matchers: SkipMatcher[]): Promise<ScannedFile[]> {
-  const results: ScannedFile[] = []
-  await walk(root, '', matchers, results)
-  results.sort((a, b) => a.relativePath.localeCompare(b.relativePath))
-  return results
-}
-
-async function walk(directory: string, relativeBase: string, matchers: SkipMatcher[], results: ScannedFile[]): Promise<void> {
-  let entries: import('node:fs').Dirent[]
-  try {
-    entries = await fs.readdir(directory, { withFileTypes: true })
-  } catch (error) {
-    Log.warn(`Skipping unreadable directory: ${directory} (${(error as Error).message})`)
-    return
-  }
-  for (const entry of entries) {
-    const relativePath = relativeBase ? `${relativeBase}/${entry.name}` : entry.name
-    const isDirectory = entry.isDirectory()
-    if (shouldSkip(matchers, relativePath, entry.name, isDirectory)) continue
-    if (isDirectory) {
-      await walk(path.join(directory, entry.name), relativePath, matchers, results)
-    } else if (entry.isFile()) {
-      results.push({ absolutePath: path.join(directory, entry.name), relativePath })
-    }
-  }
-}