lsallcp 1.0.0

package/LICENSE

@@ -0,0 +1,13 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.

package/README.md

@@ -0,0 +1,204 @@
+# 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).
+
+```bash
+bun add -g lsallcp
+```
+
+---
+
+## What it does
+
+`lsallcp` walks a directory tree and prints every file it finds as a labeled, syntax-tagged code block:
+
+```
+src/index.ts:
+<code>ts
+console.log("hello")
+</code>
+```
+
+It's built for quickly dumping a project's source into a chat window, a doc, or a clipboard -- for code review, LLM prompts, documentation, or debugging -- without manually opening and copy-pasting dozens of files.
+
+---
+
+## Features
+
+| Feature                                           | Description                                                                 |
+| ------------------------------------------------- | --------------------------------------------------------------------------- |
+| Recursive listing                                 | Walks the full directory tree from any starting path                        |
+| Smart skip patterns                               | Skip by exact name, glob (`*.png`), or regex literal (`/\.test\.ts$/i`)     |
+| True recursive pruning                            | A matched directory is never descended into -- not just filtered afterward  |
+| Binary-safe                                       | Detects binary files and shows a placeholder instead of dumping raw bytes   |
+| 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                          |
+| 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`   |
+
+> `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.
+
+---
+
+## 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
+pnpm add -g lsallcp
+yarn global add lsallcp
+```
+
+To use it inside a single project instead of globally:
+
+```bash
+bun add -d lsallcp
+bunx lsallcp .
+```
+
+---
+
+## Usage
+
+```bash
+lsallcp <path> [skipPattern...] [--copy | -c]
+```
+
+| Argument       | Required | Description                                                    |
+| -------------- | -------- | -------------------------------------------------------------- |
+| `<path>`       | Yes      | Directory to scan, e.g. `.`, `./src`, `../my-project`          |
+| `skipPattern`  | No       | Zero or more names/globs/regexes to skip, recursively          |
+| `--copy`, `-c` | No       | Copy plain-text output to the clipboard instead of printing it |
+
+Flags can appear anywhere after the path -- order doesn't matter.
+
+### Basic examples
+
+```bash
+# List every file in the current directory
+lsallcp .
+
+# Skip an exact folder name (matched at any depth)
+lsallcp . node_modules
+
+# Skip multiple exact names at once
+lsallcp . node_modules dist .env
+
+# Skip by glob pattern
+lsallcp . *.png *.lock
+
+# Skip by regex literal (wrap in slashes, flags optional)
+lsallcp . /\.test\.ts$/i
+
+# Combine skip types freely
+lsallcp . node_modules *.png /\.spec\.ts$/
+
+# Copy the result to your clipboard instead of printing it
+lsallcp . --copy
+lsallcp . node_modules -c
+```
+
+---
+
+## Skip patterns
+
+Every skip argument is compiled into a matcher and checked against both the file/folder's **basename** and its **relative path**. A match on a directory prunes the entire subtree -- files inside are never even read.
+
+| Pattern type  | Syntax              | Example               | Matches                                  |
+| ------------- | ------------------- | --------------------- | ---------------------------------------- |
+| Exact name    | plain string        | `node_modules`        | Any file/folder named exactly this       |
+| Glob          | contains `*` or `?` | `*.png`, `**/dist/**` | Shell-style wildcard match               |
+| Regex literal | `/pattern/flags`    | `/\.test\.ts$/i`      | Full regular expression, flags supported |
+
+Glob rules:
+
+- `*` matches any characters except `/`
+- `**` matches any characters, including `/`
+- `?` matches exactly one character (not `/`)
+
+`.git` is **always** skipped automatically, regardless of the patterns you pass.
+
+---
+
+## Clipboard export
+
+Passing `-c` or `--copy` copies the full, ANSI-free plain-text result directly to your system clipboard and suppresses the normal terminal printout -- you'll only see the scan log, progress bar, and a final confirmation:
+
+```bash
+lsallcp . node_modules --copy
+```
+
+```
+ℹ Target: /Users/<nolly>/projects/my-app
+ℹ Skip patterns: node_modules
+ℹ Clipboard: enabled (content will not be printed)
+✔ Found 214 file(s) after skipping
+✔ All files read
+✔ Listed 214 file(s) from /Users/<nolly>/projects/my-app
+✔ Result copied to clipboard
+```
+
+Clipboard support is zero-dependency and platform-native:
+
+| Platform | Tool used                                   |
+| -------- | ------------------------------------------- |
+| Windows  | `clip` (built-in, also works from Git Bash) |
+| macOS    | `pbcopy` (built-in)                         |
+| Linux    | `wl-copy` → `xclip` → `xsel`, first found   |
+
+If none of these tools are available on Linux, `lsallcp` prints a warning and leaves the terminal output untouched.
+
+---
+
+## Output format
+
+Each file is rendered as:
+
+<relativePath>:
+<code><extension>
+<file content>
+</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`.
+- Binary files render as a dimmed, italic `[binary file - content skipped]` placeholder instead of raw bytes.
+- Unreadable files (permissions, broken symlinks, etc.) render a red `[unreadable: <reason>]` placeholder instead of crashing the whole run.
+
+---
+
+## Exit behavior
+
+- Directory scanning never aborts on a single unreadable subdirectory -- it logs a warning and continues.
+- If the target path doesn't exist or isn't a directory, `lsallcp` exits with an error and a non-zero status code.
+- If no files remain after skip patterns are applied, `lsallcp` logs a warning and exits cleanly.
+
+---
+
+## How it works
+
+`lsallcp` is a thin, purpose-built CLI in three stages:
+
+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.
+
+---
+
+## License
+
+Released under the [WTFPL License](./LICENSE).

package/bin/lsallcp.js

@@ -0,0 +1,17 @@
+#!/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/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "lsallcp",
+  "version": "1.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"
+  },
+  "files": ["src", "bin", "package.json", "README.md", "LICENSE"],
+  "engines": {
+    "bun": ">=1.1.0"
+  },
+  "scripts": {
+    "start": "bun src/cli.ts"
+  },
+  "keywords": ["cli", "bun", "list", "files", "dump", "tree"],
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "latest"
+  },
+  "dependencies": {
+    "cli-atelier": "^1.0.2"
+  },
+  "license": "WTFPL"
+}

package/src/binary.ts

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,99 @@
+#!/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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,37 @@
+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 })
+    }
+  }
+}