vibeutils - GNU Coreutils in Zig

Progress Summary

Completed: 47/47 utilities - ALL IMPLEMENTED
Utilities: basename, cat, chmod, chown, cp, cut, date, dd, df, dirname, du, echo, env, false, find, free, grep, head, id, ln, ls, mkdir, mktemp, mv, nl, printf, pwd, readlink, realpath, rm, rmdir, seq, sleep, sort, stat, tac, tail, tee, test, timeout, touch, tr, true, uniq, wc, whoami, yes
Flag coverage: 288/288 MUST, 220/220 SHOULD (100%)
Compatibility: 90-100% GNU feature coverage for completed utilities
Infrastructure: justfile build system, CI/CD, privileged testing, writer-based I/O, Zig 0.16.0, 7 shared common modules (time, path, glob, prompt, format, file_ops, lib color detection)
Packaging: Homebrew tap, Nix flake with Cachix binary cache (4 platforms), GitHub release binaries
Documentation: Claude Code quality check (/qc), man page style guide, testing strategy, CHANGELOG.md

Tiger Style remediation (deferred)

Enable scripts/tiger-check.sh in CI after the Tiger Style migration is finished (Phases 3-6 in docs/tiger-style-review/README.md). Add a CI job running scripts/tiger-check.sh --base origin/main to gate PRs on NEW Tiger Style violations. Deferred deliberately: the pre-commit hook already blocks NEW violations locally, and we want builds green through the migration before enforcing in CI (the tree still carries ~3442 pre-existing violations; --base only fails on newly introduced ones, but enable CI once the debt is burned down by the function-length, assertion, and cleanup phases).

Project Goals

Balance: 80% of GNU's usefulness with 20% of the complexity
High test coverage: 90%+ with TDD approach
Modern enhancements: Colors, icons, smart formatting, performance
OpenBSD-inspired: Clear options, concise man pages with examples
Practical compatibility: Features people actually use

POSIX Compliance & Flag Coverage

Step 1: Download POSIX specs

For each of the 37 POSIX utilities, download the OPTIONS section from pubs.opengroup.org/onlinepubs/9699919799/utilities/<util>.html and save as docs/specs/<util>-posix.txt. Plain text, flags and descriptions only.

37 POSIX utilities: basename, cat, chmod, chown, cp, cut, date, dd, df, dirname, du, echo, env, false, find, grep, head, id, ln, ls, mkdir, mv, nl, printf, pwd, rm, rmdir, sleep, sort, tail, tee, test, touch, tr, true, uniq, wc

Skip (non-POSIX): free, mktemp, readlink, realpath, seq, stat, tac, timeout, whoami, yes

Step 2: Capture reference flags from all sources

For each of the 47 utilities, capture four sources:

macOS man page + help: Parse flags from MANPATH=/usr/share/man man <util>, then append /bin/<util> --help (or -h) output under a --- --help output --- separator. Save to docs/specs/<util>-macos.txt.
OpenBSD man page: Fetch from man.openbsd.org/<util>.1 and save to docs/specs/<util>-openbsd.txt.
GNU coreutils: Run g<util> --help (from Nix coreutils package), save to docs/specs/<util>-gnu.txt.
Our flags: Run ./zig-out/bin/<util> --help, save to docs/specs/<util>-vibeutils.txt.

Step 3: Coverage decisions (interactive)

Create docs/specs/<util>-flags.md for each utility with a flags table:

| Flag | POSIX | macOS | OpenBSD | GNU | Ours | Tier |
|------|-------|-------|---------|-----|------|------|
| -a   | yes   | yes   | yes     | yes | yes  | MUST |
| -X   | no    | yes   | no      | yes | no   | SHOULD |
| -Z   | no    | no    | no      | yes | no   | WONT |

Auto-assign tiers:

MUST: All POSIX-required flags (target 100%)
MUST: All flags present in both macOS AND OpenBSD (platform parity baseline)

Prompt user for remaining flags: Use AskUserQuestion menu per utility to decide tier for flags that are GNU-only, macOS-only, or OpenBSD-only. Present the flag, its description, and which sources have it. Let user pick SHOULD or WONT.

Tiers:

MUST: POSIX-required + macOS/OpenBSD parity
SHOULD: User-approved GNU/platform flags
WONT: Rare/legacy flags (document rationale)

Step 4: Integration tests

Write bash scripts in tests/posix/, one per utility (e.g., tests/posix/test_cp.sh). Each script:

Validates every MUST and SHOULD flag is accepted
Tests correct behavior against expected output
Does NOT compare against GNU coreutils directly
Run via just test-posix

TDD Development Cycle

For each utility:

Red: Write failing tests for basic functionality
Green: Implement minimal code to pass tests
Refactor: Improve code quality while keeping tests green
Repeat: Add more test cases for edge cases and flags

Implementation Order

Phase 1: Essential & Simple Utilities

1. echo ✓

echo - Additional GNU features (TDD): ✓

Test: -E flag disables escapes even after -e
Test: -E flag behavior in combined flags
Implement: -E flag to explicitly disable escape sequences

2. cat ✓

cat - Additional GNU features (TDD): ✓

3. ls ✓ (Phases 1-5 complete)

ls - Implementation Plan (Balanced Approach)

Phase 1: Essential Features (TDD) ✓

Phase 2: Sorting & Display Options (TDD)

Phase 3: Modern UX & Color (TDD)

Phase 4: Recursive & Nice-to-Have (TDD) ✓

Phase 5: Modern Enhancements ✓

Test: Nerd font icon detection
Test: Icon mapping for common file types
Test: Git status integration (modified/new files)
Test: Smart date formatting ("2 hours ago")
Implement: Optional icon system
Implement: Git repository detection
Implement: Human-friendly date formatting

ls - Features We're NOT Implementing

SELinux context (-Z, --context) - Too Linux-specific
Author field (--author) - Nobody uses this
Emacs dired mode (-D, --dired) - Too niche
Complex quoting styles - Just escape when needed
Multiple time formats - One smart format is enough
Block size gymnastics (--block-size) - Just -h and -k
All the --indicator-style variants - Just -F
Explicit --si flag - We use binary (1024) for -h

4. cp ✓ (Complete implementation)

5. mv ✓

6. rm ✓

rm - Advanced Implementation (TDD) ✓

Phase 1: Basic File Removal

Test: Basic file removal
Test: Non-existent file with force
Test: Multiple file removal
Test: Directory without recursive flag
Test: Verbose output
Implement: Core removal logic
Implement: Force mode handling
Implement: Error reporting

Phase 2: Safety and Interaction

Phase 3: Recursive Directory Operations

Test: Recursive directory removal
Test: Deep nested directories
Test: Symlink handling (don't follow)
Test: Permission handling with force
Implement: Depth-first directory traversal
Implement: Symlink detection
Implement: Permission modification for force mode
Implement: Inode tracking for cycles

Phase 4: Advanced Safety Features

Test: Symlink cycle detection
Test: Cross-filesystem boundary handling
Test: Race condition protection
Implement: Complex symlink cycle detection
Implement: Device ID tracking for filesystem boundaries
Implement: Atomic operations using *at() syscalls
Implement: File descriptor-based removal for TOCTOU protection

7. mkdir ✓

8. rmdir ✓

9. touch ✓

10. pwd ✓

11. chmod ✓

12. chown ✓

13. ln ✓

14. basename ✓

Test: Strip directory from path
Test: Strip suffix (-s, --suffix)
Test: Multiple paths (-a, --multiple)
Test: Zero delimiter (-z, --zero)
Test: Edge cases (/, //, no slash)
Implement: Path parsing logic
Implement: Suffix stripping
Implement: Multiple file handling
Man page: Write concise man page with examples

15. dirname ✓

Test: Extract directory from path
Test: Multiple paths
Test: Zero delimiter (-z, --zero)
Test: Edge cases (/, //, no slash, .)
Implement: Path parsing logic
Implement: Multiple path handling
Man page: Write concise man page with examples

16. sleep ✓

Test: Sleep for seconds
Test: Sleep for decimal seconds (0.5)
Test: Sleep for minutes/hours/days suffix (5m, 2h, 1d)
Test: Multiple time arguments (sleep 1m 30s)
Test: Signal handling (interruptible)
Implement: Time parsing with units
Implement: High-precision sleep
Implement: Signal-safe sleep
Man page: Write concise man page with examples

17. true ✓

Test: Always returns 0 exit code
Test: Ignores all arguments
Implement: Minimal implementation
Man page: Write concise man page

18. false ✓

Test: Always returns 1 exit code
Test: Ignores all arguments
Test: Produces no output
Test: Handles empty arguments array
Test: Handles many arguments
Implement: Minimal implementation
Man page: Write concise man page

19. test ✓

20. date ✓

21. env ✓

22. seq ✓

23. tee ✓

24. yes ✓

Test: Repeat "y" infinitely
Test: Repeat custom string
Test: Multiple arguments joined with space
Test: Performance (must be fast)
Test: SIGPIPE handling
Implement: Efficient output loop
Implement: Buffer optimization
Implement: Signal handling
Man page: Write concise man page with examples

25. whoami ✓

Test: Print effective username
Test: No options accepted
Test: Error when can't determine user
Implement: Get effective user ID
Implement: User lookup
Man page: Write concise man page with examples

26. id ✓

27. printf ✓

28. free ✓

Phase 2: Text Processing Utilities

29. dd ✓

30. realpath ✓

31. readlink ✓

Test: Print symlink target
Test: Canonicalize (-f, --canonicalize)
Test: Canonicalize existing (-e)
Test: Canonicalize missing (-m)
Test: No newline (-n, --no-newline)
Test: Error on non-symlink
Implement: Symlink reading
Implement: Path canonicalization
Man page: Write concise man page with examples

32. mktemp ✓

33. timeout ✓

timeout - Implementation Notes

Why Priority: macOS lacks timeout, causing issues in scripts/CI Key Features: Must support both simple (timeout 5 cmd) and complex (timeout -k 2s -s INT 10s cmd) usage Platform Considerations:

Linux: Use timerfd_create for precise timing
macOS/BSD: Use setitimer or kqueue timers
Signal handling must be robust across platforms

34. tac ✓

35. nl ✓

36. head ✓

37. tail ✓

38. wc ✓

39. sort ✓

40. uniq ✓

41. cut ✓

42. tr ✓

Phase 3: File Information Utilities

43. stat ✓

Test: File information display
Test: Custom format (-c)
Test: Filesystem info (-f)
Test: Dereference (-L)
Test: Terse output (-t)
Implement: System call wrapper
Implement: Format string parser
Implement: Human-readable output
Man page: Write concise man page with examples

44. du ✓

45. df ✓

Test: Filesystem listing
Test: Human readable (-h)
Test: Filesystem type (-t)
Test: Inode information (-i)
Test: Mount point resolution
Implement: Mount point parsing
Implement: Space calculation
Implement: Filesystem filtering
Man page: Write concise man page with examples

Phase 4: Advanced Utilities

46. find ✓

47. grep ✓

Testing Strategy

Coverage Goals: 90%+ line, 85%+ branch, 100% error paths
Unit Tests: Individual flags, combinations, edge cases
Integration Tests: Pipes, signals, GNU compatibility, benchmarks

Custom Argument Parser Implementation ✓

Replace zig-clap Dependency (COMPLETED)

Goal: Replace zig-clap's 3,000 lines with focused ~400-line library supporting 95% of real usage patterns

Design Philosophy:

API-first design with type-safe interfaces
Zero allocations for flag parsing (positionals may allocate)
Compile-time validation where possible
Self-documenting through struct field names
OpenBSD-inspired simplicity with GNU compatibility

Phase 1: Core Parsing Engine (COMPLETED) ✓

Phase 2: String Options and Positionals (COMPLETED) ✓

Phase 3: Help Generation System (COMPLETED) ✓

Test: Help text parsing from struct meta field
Test: Automatic help formatting matching GNU style
Test: Usage line generation with positional indicators
Test: Option description alignment and formatting
Test: Integration with existing --help flag patterns
Implement: printHelp() function
Implement: Help text parser for embedded descriptions
Implement: GNU-style help formatting
Implement: Usage line generation based on struct analysis

Phase 4: GNU Compatibility and Edge Cases (COMPLETED) ✓

Test: POSIX compliance for argument ordering
Test: Error message format matching GNU conventions
Test: Complex combined flags with string options
Test: Edge cases (empty args, only positionals, only flags)
Test: Integration with all existing utility patterns
Implement: Full GNU argument parsing compatibility
Implement: Comprehensive error reporting
Implement: Performance optimization (comptime where possible)

Migration Plan (COMPLETED) ✓

echo: Migrated simplest case (boolean flags only)
cat: Multiple boolean flags, combination flags (-A, -e, -t)
ls: Complex case with string options (--color, --time-style)
cp/mv/rm: Interactive flags and mixed option types
mkdir/rmdir/touch: Mode settings and timestamp options
All utilities: Complete migration for all 22 implemented utilities

Integration and Cleanup (COMPLETED) ✓

Test: Drop-in compatibility with existing utility code
Test: Performance benchmarks vs zig-clap
Test: Binary size comparison
Test: Compile time comparison
Update: build.zig to remove zig-clap dependency
Update: build.zig.zon to remove clap entry
Verify: All existing tests pass with new parser
Document: API documentation in argparse.zig

Success Criteria:

Library under 500 lines total (vs 3,000 for zig-clap)
95%+ test coverage with embedded tests
All existing utilities work unchanged
Argument parsing <1ms for complex cases
Zero regressions in functionality
Binary size comparable or smaller than zig-clap

API Design Pattern:

const EchoArgs = struct {
    help: bool = false,        // -h, --help
    version: bool = false,     // -V, --version
    suppress_newline: bool = false, // -n
    positionals: []const []const u8,
    
    pub const help_text = 
        \\-h, --help     Display this help and exit.
        \\-V, --version  Output version information and exit.
        \\-n             Do not output the trailing newline.
        \\<str>...       Text to echo.
    ;
};

const args = Args.parse(EchoArgs, allocator) catch |err| switch (err) {
    error.InvalidArgument => return usage_error(),
    else => return err,
};
defer args.deinit(allocator);

Stdout Testing Infrastructure ✓

Overview

Implemented idiomatic Zig writer pattern to enable comprehensive testing of stdout/stderr output without hangs or skipped tests.

Design Principles

Pass writers as parameters (idiomatic Zig pattern) ✓
Enable full output testing without process-level complexity ✓
Maintain production behavior while improving testability ✓
Zero allocation overhead for production code ✓

Implementation Completed

Phase 1: Core Infrastructure ✓

Writer parameter pattern implemented across all utilities
Test infrastructure using buffer writers (std.ArrayList(u8).writer())
Stdout/stderr isolation in all utilities
Memory management with proper cleanup patterns

Phase 2: All Utilities Updated ✓

Phase 3: Test Infrastructure ✓

Implemented anytype writer compatibility across all utilities
Verified stdout/stderr isolation in tests
Removed dead code buffering tests (746 lines of stdlib testing)
Fixed writer parameter patterns to prevent test stderr pollution

Phase 4: Pattern Documentation ✓

Consistent runXxx() pattern returning ExitCode
main() as thin wrapper calling runXxx()
All output functions accept writer parameters
Tests use buffer writers for output verification

Success Achieved

Zero test hangs due to stdout buffering
All utilities use consistent writer pattern
Full test coverage for output functionality
No performance regression (verified with timing tests)
Clear pattern established for future utilities

Architecture Decisions

Design Philosophy

Balance OpenBSD clarity with GNU usefulness
Modern UX improvements (colors, icons, responsive layouts)
Smart defaults (auto-color, readable dates, parallel I/O)

Shared Components

Build System

Documentation

Modern Enhancements

Color Support

Terminal capability detection (basic, 256, truecolor)
NO_COLOR environment variable support
VIBEUTILS_STYLE environment variable (plain/color/full)
Graceful fallback for limited terminals
Colored help output with syntax highlighting
Nerd Font glyphs in help and ls
LS_COLORS parsing and theming

Privileged Testing Strategy

Overview

Comprehensive cross-platform testing for commands that require elevated privileges (chmod, chown, etc.) across Linux, macOS, OpenBSD, FreeBSD, and NetBSD in GitHub Actions.

Platform-Specific Approaches

Linux (Best Support)

Tools: fakeroot, unshare (user namespaces), podman (rootless containers)
Strategy: Full privilege simulation without actual root
Coverage: 100% of privilege-related tests

macOS (Limited Options)

Tools: Real sudo (GitHub Actions allows), limited fakeroot
Strategy: Focus on error paths, use sudo for critical tests
Coverage: ~70% through error simulation + real sudo tests

BSD Systems (VM-Based)

FreeBSD: fakeroot available in ports
OpenBSD: Use doas for privilege testing
NetBSD: Basic permission testing
Strategy: Run in VMs via vmactions/* GitHub Actions

Commands Requiring Privileged Testing

Currently Implemented

rm: chmod operations on write-protected files
mkdir: Setting custom permissions with -m flag
cp: Preserving permissions/ownership with -p
ls: Displaying special permission bits
chmod: Permission modification (setuid/setgid/sticky) - tests migrated to privilege framework ✓
chown: Ownership changes

Planned Commands

ln: Hard link permission requirements
stat: Ownership/permission display
find: Permission-denied scenarios
du/df: Restricted directory access

Implementation Plan

1. Test Infrastructure ✓

Create src/common/privilege_test.zig module
Add platform detection (fakeroot, unshare, etc.)
Implement test skip annotations for unprivileged environments
Add mock system calls for unit testing

2. GitHub Actions Workflow ✓

Linux: Test with fakeroot (automated privilege simulation)
macOS: Native testing with privilege simulation support
BSD: Set up VM-based testing with vmactions (not implemented; no BSD workflow in .github/workflows/)
Add privileged test matrix to CI pipeline
Cross-platform CI/CD with Ubuntu and macOS runners
Coverage reporting with Codecov integration
Security scanning with Dependabot and CodeQL
Automated release workflow with multi-platform binaries

3. Test Categories

Permission Simulation: Test actual permission changes (infrastructure ready)
Error Paths: Test permission-denied handling
Integration Tests: Real operations in permitted locations (tests/privilege_integration/file_ops_test.zig, workflow_test.zig)
Mock Tests: Unit tests with injected syscalls (via requiresPrivilege)

4. justfile Targets ✓

test-privileged: Cross-platform privileged test runner
test-privileged-local: macOS with Docker fallback
test-linux-privileged: Linux Docker container

Fallback Strategies

Test error paths (permission denied scenarios)
Use dependency injection for mockable syscalls
Focus on logic testing without privilege operations
Document privilege requirements

Success Metrics

All privilege-related tests pass on Linux with fakeroot (infrastructure ready)
Core functionality works without privileges
Clear test output indicating skipped privileged tests

CI/CD Infrastructure (Implemented) ✓

GitHub Actions Workflows

Supporting Infrastructure

Cachix Binary Cache: Prebuilt binaries for darwin-arm64, darwin-amd64, linux-arm64, linux-amd64
Release Script: Extracts notes from CHANGELOG.md, updates GitHub release after CI
Privileged Testing: Smart detection and fallback for privilege simulation
CI Environment Detection: Helper functions for CI-specific behavior

Modern Features Roadmap

See docs/plans/2026-03-01-modern-features-design.md for full design.

1. Colored `--help` Output ✓

Modify argparse to render colored help on TTY
Bold utility name and section headers
Cyan flag names, yellow arguments
Respect NO_COLOR, plain text when piped
Nerd-font glyphs for section headers
Yellow UPPERCASE metavariable highlighting in descriptions
Handle trailing punctuation and (s) suffixes

2. `grep --color=auto` ✓

Highlight matched text in bold red
Filename in magenta, line numbers in green
--color=auto/always/never flags
Match GNU grep color conventions

3. `VIBEUTILS_STYLE` Environment Variable ✓

3a. Command Linter Warnings ✓

chown: warn when argument looks like octal mode
chmod: warn when numeric mode contains 8 or 9
rm: refuse to remove '/' without --no-preserve-root
cp/mv: hint about -i for interactive overwrite prompts
ln: warn when creating dangling symlinks

3b. ls Git Status Auto-Detection ✓

Auto-enable git status when inside a git repo
--git=WHEN flag (always/auto/never)
Respects VIBEUTILS_STYLE (plain/color disable git)
Fix: suppress git status and icons in -1 mode
Fix: alphabetize --help flags
Fix: flush stderr in fatalWithWriter before exit

4. Color-Coded Numeric Output

df: green/yellow/red by usage percentage
df: optional inline usage bar
du: color size relative to largest entry
du: file-type icons before paths (--icons=WHEN)
wc: semantic column colors (--color=WHEN)
Icon coverage: 59 extensions, brand colors, dark-bg visibility

5. `tree` Utility

Recursive directory listing with box-drawing lines
File-type icons via common/icons
Truecolor/256/basic icon coloring (reuse ls pattern)
-L depth limit, -d directories only
-I pattern exclusion
Summary line (N directories, M files)
--color=auto/always/never, respect NO_COLOR
Man page

6. Progress Feedback for `cp`/`mv`/`dd`

Progress module in src/common/
Show status line on stderr after 2s delay
Update in place, clear when done
Only when stderr is a TTY

7. Smarter Error Messages

Permission denied with actionable hint
Directory not empty with rm -r suggestion

Testing Improvements (Post-Issue #5 Analysis)

The O_APPEND bug (issue #5) exposed gaps in our testing strategy. These items address the categories of testing that would have caught it — and similar bugs — earlier.

1. File Descriptor Mode Tests

Generic test harness that runs each binary under different fd configurations
Test >> file append mode for every utility
Test pipe mode (| cat) for every utility
Test truncate mode (> file) for every utility
Test dup'd descriptors (2>&1 >> file)

2. POSIX Behavioral Conformance Suite

>> must append, not overwrite
Stdout to a closed pipe must produce SIGPIPE/EPIPE
Stderr must be unbuffered
Exit codes conform to POSIX spec
Utility-agnostic: same I/O contract tests run against every binary

3. Adopt Shared TestDir Across All Utilities

Replace ad-hoc testing.tmpDir(.{}) usage with shared common.test_dir.TestDir in all utility tests
Ensure all tests use absolute paths (no fchdir)
Utilities to migrate: cat, chmod, chown, cut, dd, du, find, grep, head, ln, ls, mkdir, mktemp, nl, pwd, readlink, realpath, rm, rmdir, stat, tac, tail, tee, test, touch, tr, uniq, wc
Consolidate mv.zig's local TestDir into the shared one

4. Fix LLVM Backend Test Failures ✓

cp overwrite hint test fails under .use_llvm = true but passes with self-hosted backend
mv overwrite hint test has the same issue
Root cause: likely Style/writer generic instantiation differs between backends
Blocking accurate coverage numbers (2 of 49 binaries fail)

Resolved during the Zig 0.16 migration. build.zig:409, 434 still set use_llvm = true and zig build test is fully green, including cp.zig:1181-1276 and mv.zig:1033+ overwrite-hint tests.

5. main() Function Coverage

Test the writer setup code path in main(), not just runUtil() with test-provided writers
Integration tests that exercise the compiled binary's actual I/O initialization

6. dd MUST-tier conv= Integration Coverage

Salvaged from closed PR #34. tests/utilities/dd_test.sh lacks behavioral coverage for several MUST-tier conv= values; some existing tests also compare against macOS /usr/bin/dd, which produces empty output and silently passes.

Replace macOS /usr/bin/dd comparisons with hardcoded GNU-equivalent expected values
Add behavioral tests for conv=sync (NUL padding + full block), conv=notrunc vs. truncate contrast, conv=fsync, conv=osync, conv=ascii, conv=ebcdic, conv=ibm, conv=noerror
Cross-check against the existing rejection tests added in commit cc57c2a (conv=sparse/par*/files=)

Bugs

ls does not switch to single-column output when stdout is a pipe (POSIX violation, found 2026-04-25, tracked as #113). GNU/BSD ls auto-detect a non-tty stdout and emit one entry per line. vibeutils ls keeps multi-column layout with column-aligned padding even under a pipe, so pipelines like ls dir | grep | sort | tail see lines with embedded trailing whitespace from the alignment. This silently broke the gale upgrade script (gale-project/scripts/bootstrap.sh): the padded line 0.11.3.lock slipped past grep -v '\.lock$' because the suffix is no longer at end-of-line, then sort -V | tail -1 picked it as the "highest" version, and the script wrote that garbage into ~/.gale/gale.toml. gale-project worked around it by replacing the ls pipeline with a bash glob, but the underlying behavior is non-POSIX and surprises any tool that pipes ls. Repro:
```
ls /Users/tcole/.gale/pkg/gale | grep -v '\.lock$' \
  | sort -V | tail -1 | cat -A
# 0.11.3.lock                   $
```
Expected (matching GNU/BSD): single-column output, no padding, the highest non-.lock entry on its own line. Spec: POSIX ls says "If the standard output is not a terminal, the default format shall be the same as the -1 option." (pubs.opengroup.org/onlinepubs/9699919799/utilities/ls.html).

Success Criteria

All utilities pass GNU coreutils test suite
90%+ test coverage
Clean static analysis reports
Privileged operations tested (Linux, macOS)
CI/CD pipeline operational

FilesExpand file tree

TODO.md

Latest commit

History