just-bash 2.4.4 → 2.5.1

package/dist/commands/registry.d.ts

@@ -1,6 +1,6 @@
 import type { Command } from "../types.js";
 /** All available built-in command names (excludes network commands) */
-export type CommandName = "echo" | "cat" | "printf" | "ls" | "mkdir" | "touch" | "rm" | "cp" | "mv" | "ln" | "chmod" | "pwd" | "readlink" | "head" | "tail" | "wc" | "stat" | "grep" | "fgrep" | "egrep" | "sed" | "awk" | "sort" | "uniq" | "comm" | "cut" | "paste" | "tr" | "rev" | "nl" | "fold" | "expand" | "unexpand" | "strings" | "split" | "column" | "join" | "tee" | "find" | "basename" | "dirname" | "tree" | "du" | "env" | "printenv" | "alias" | "unalias" | "history" | "xargs" | "true" | "false" | "clear" | "bash" | "sh" | "jq" | "base64" | "diff" | "date" | "sleep" | "timeout" | "seq" | "expr" | "md5sum" | "sha1sum" | "sha256sum" | "file" | "html-to-markdown" | "help" | "which" | "tac" | "hostname" | "od" | "gzip" | "gunzip" | "zcat" | "yq" | "xan" | "sqlite3";
+export type CommandName = "echo" | "cat" | "printf" | "ls" | "mkdir" | "touch" | "rm" | "cp" | "mv" | "ln" | "chmod" | "pwd" | "readlink" | "head" | "tail" | "wc" | "stat" | "grep" | "fgrep" | "egrep" | "rg" | "sed" | "awk" | "sort" | "uniq" | "comm" | "cut" | "paste" | "tr" | "rev" | "nl" | "fold" | "expand" | "unexpand" | "strings" | "split" | "column" | "join" | "tee" | "find" | "basename" | "dirname" | "tree" | "du" | "env" | "printenv" | "alias" | "unalias" | "history" | "xargs" | "true" | "false" | "clear" | "bash" | "sh" | "jq" | "base64" | "diff" | "date" | "sleep" | "timeout" | "seq" | "expr" | "md5sum" | "sha1sum" | "sha256sum" | "file" | "html-to-markdown" | "help" | "which" | "tac" | "hostname" | "od" | "gzip" | "gunzip" | "zcat" | "tar" | "yq" | "xan" | "sqlite3";
 /** Network command names (only available when network is configured) */
 export type NetworkCommandName = "curl";
 /** All command names including network commands */

package/dist/commands/rg/file-types.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Built-in file type definitions for rg
+ *
+ * Maps type names to file extensions and glob patterns.
+ * Based on ripgrep's default type definitions.
+ */
+export interface FileType {
+    extensions: string[];
+    globs: string[];
+}
+/**
+ * Mutable file type registry for runtime type modifications
+ * Supports --type-add and --type-clear flags
+ */
+export declare class FileTypeRegistry {
+    private types;
+    constructor();
+    /**
+     * Add a type definition
+     * Format: "name:pattern" where pattern can be:
+     * - "*.ext" - glob pattern
+     * - "include:other" - include patterns from another type
+     */
+    addType(spec: string): void;
+    /**
+     * Clear all patterns from a type
+     */
+    clearType(name: string): void;
+    /**
+     * Get a type by name
+     */
+    getType(name: string): FileType | undefined;
+    /**
+     * Get all type names
+     */
+    getAllTypes(): Map<string, FileType>;
+    /**
+     * Check if a filename matches any of the specified types
+     */
+    matchesType(filename: string, typeNames: string[]): boolean;
+    /**
+     * Check if a filename matches any recognized type
+     */
+    private matchesAnyType;
+}
+/**
+ * Format type list for --type-list output
+ */
+export declare function formatTypeList(): string;

package/dist/commands/rg/gitignore.d.ts

@@ -0,0 +1,98 @@
+/**
+ * .gitignore parser for rg
+ *
+ * Handles:
+ * - Simple patterns (*.log, node_modules/)
+ * - Negation patterns (!important.log)
+ * - Directory-only patterns (build/)
+ * - Rooted patterns (/root-only)
+ * - Double-star patterns (for matching across directories)
+ */
+import type { IFileSystem } from "../../fs/interface.js";
+export declare class GitignoreParser {
+    private patterns;
+    private basePath;
+    constructor(basePath?: string);
+    /**
+     * Parse .gitignore content and add patterns
+     */
+    parse(content: string): void;
+    /**
+     * Convert a gitignore pattern to a regex
+     */
+    private patternToRegex;
+    /**
+     * Check if a path should be ignored
+     *
+     * @param relativePath Path relative to the gitignore location
+     * @param isDirectory Whether the path is a directory
+     * @returns true if the path should be ignored
+     */
+    matches(relativePath: string, isDirectory: boolean): boolean;
+    /**
+     * Check if a path is explicitly whitelisted by a negation pattern
+     *
+     * @param relativePath Path relative to the gitignore location
+     * @param isDirectory Whether the path is a directory
+     * @returns true if the path is whitelisted by a negation pattern
+     */
+    isWhitelisted(relativePath: string, isDirectory: boolean): boolean;
+    /**
+     * Get the base path for this gitignore
+     */
+    getBasePath(): string;
+}
+/**
+ * Hierarchical gitignore manager
+ *
+ * Loads .gitignore and .ignore files from the root down to the current directory,
+ * applying patterns in order (child patterns override parent patterns).
+ */
+export declare class GitignoreManager {
+    private parsers;
+    private fs;
+    private skipDotIgnore;
+    private skipVcsIgnore;
+    private loadedDirs;
+    constructor(fs: IFileSystem, _rootPath: string, skipDotIgnore?: boolean, skipVcsIgnore?: boolean);
+    /**
+     * Load all .gitignore and .ignore files from root to the specified path
+     */
+    load(targetPath: string): Promise<void>;
+    /**
+     * Load ignore files for a directory during traversal.
+     * Only loads if the directory hasn't been loaded before.
+     */
+    loadForDirectory(dir: string): Promise<void>;
+    /**
+     * Add patterns from raw content at the specified base path.
+     * Used for --ignore-file flag.
+     */
+    addPatternsFromContent(content: string, basePath: string): void;
+    /**
+     * Check if a path should be ignored
+     *
+     * @param absolutePath Absolute path to check
+     * @param isDirectory Whether the path is a directory
+     * @returns true if the path should be ignored
+     */
+    matches(absolutePath: string, isDirectory: boolean): boolean;
+    /**
+     * Check if a path is explicitly whitelisted by a negation pattern.
+     * Used to include hidden files that have negation patterns like "!.foo"
+     *
+     * @param absolutePath Absolute path to check
+     * @param isDirectory Whether the path is a directory
+     * @returns true if the path is whitelisted by a negation pattern
+     */
+    isWhitelisted(absolutePath: string, isDirectory: boolean): boolean;
+    /**
+     * Quick check for common ignored directories
+     * Used for early pruning during traversal
+     */
+    static isCommonIgnored(name: string): boolean;
+}
+/**
+ * Load gitignore files for a search starting at the given path
+ */
+export declare function loadGitignores(fs: IFileSystem, startPath: string, skipDotIgnore?: boolean, skipVcsIgnore?: boolean, customIgnoreFiles?: string[]): Promise<GitignoreManager>;

package/dist/commands/rg/rg-options.d.ts

@@ -0,0 +1,61 @@
+/**
+ * RgOptions interface and default values
+ */
+export interface RgOptions {
+    ignoreCase: boolean;
+    caseSensitive: boolean;
+    smartCase: boolean;
+    fixedStrings: boolean;
+    wordRegexp: boolean;
+    lineRegexp: boolean;
+    invertMatch: boolean;
+    multiline: boolean;
+    multilineDotall: boolean;
+    patterns: string[];
+    patternFiles: string[];
+    count: boolean;
+    countMatches: boolean;
+    files: boolean;
+    filesWithMatches: boolean;
+    filesWithoutMatch: boolean;
+    stats: boolean;
+    onlyMatching: boolean;
+    maxCount: number;
+    lineNumber: boolean;
+    noFilename: boolean;
+    withFilename: boolean;
+    nullSeparator: boolean;
+    byteOffset: boolean;
+    column: boolean;
+    vimgrep: boolean;
+    replace: string | null;
+    afterContext: number;
+    beforeContext: number;
+    contextSeparator: string;
+    quiet: boolean;
+    heading: boolean;
+    passthru: boolean;
+    includeZero: boolean;
+    sort: "path" | "none";
+    json: boolean;
+    globs: string[];
+    iglobs: string[];
+    globCaseInsensitive: boolean;
+    types: string[];
+    typesNot: string[];
+    typeAdd: string[];
+    typeClear: string[];
+    hidden: boolean;
+    noIgnore: boolean;
+    noIgnoreDot: boolean;
+    noIgnoreVcs: boolean;
+    ignoreFiles: string[];
+    maxDepth: number;
+    maxFilesize: number;
+    followSymlinks: boolean;
+    searchZip: boolean;
+    searchBinary: boolean;
+    preprocessor: string | null;
+    preprocessorGlobs: string[];
+}
+export declare function createDefaultOptions(): RgOptions;

package/dist/commands/rg/rg-parser.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Argument parsing for rg command - Declarative approach
+ */
+import type { ExecResult } from "../../types.js";
+import { type RgOptions } from "./rg-options.js";
+export interface ParseResult {
+    success: true;
+    options: RgOptions;
+    paths: string[];
+    explicitLineNumbers: boolean;
+}
+export interface ParseError {
+    success: false;
+    error: ExecResult;
+}
+export type ParseArgsResult = ParseResult | ParseError;
+/**
+ * Parse rg command arguments
+ */
+export declare function parseArgs(args: string[]): ParseArgsResult;

package/dist/commands/rg/rg-search.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Core search logic for rg command
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+import type { RgOptions } from "./rg-options.js";
+export interface SearchContext {
+    ctx: CommandContext;
+    options: RgOptions;
+    paths: string[];
+    explicitLineNumbers: boolean;
+}
+/**
+ * Execute the search with parsed options
+ */
+export declare function executeSearch(searchCtx: SearchContext): Promise<ExecResult>;

package/dist/commands/rg/rg.d.ts

@@ -0,0 +1,12 @@
+/**
+ * rg - ripgrep-like recursive search
+ *
+ * Fast recursive search with smart defaults:
+ * - Recursive by default (unlike grep)
+ * - Respects .gitignore
+ * - Skips hidden files by default
+ * - Skips binary files by default
+ * - Smart case sensitivity (case-insensitive unless pattern has uppercase)
+ */
+import type { Command } from "../../types.js";
+export declare const rgCommand: Command;

package/dist/commands/search-engine/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared search engine for grep and rg commands
+ *
+ * Provides core text searching functionality:
+ * - Line-by-line content matching
+ * - Context lines (before/after)
+ * - Regex building for different modes (basic, extended, fixed, perl)
+ */
+export { type SearchOptions, type SearchResult, searchContent, } from "./matcher.js";
+export { buildRegex, convertReplacement, type RegexMode, type RegexOptions, } from "./regex.js";

package/dist/commands/search-engine/matcher.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Core content matching logic for search commands
+ */
+export interface SearchOptions {
+    /** Select non-matching lines */
+    invertMatch?: boolean;
+    /** Print line number with output lines */
+    showLineNumbers?: boolean;
+    /** Print only a count of matching lines */
+    countOnly?: boolean;
+    /** Count individual matches instead of lines (--count-matches) */
+    countMatches?: boolean;
+    /** Filename prefix for output (empty string for no prefix) */
+    filename?: string;
+    /** Show only the matching parts of lines */
+    onlyMatching?: boolean;
+    /** Print NUM lines of leading context */
+    beforeContext?: number;
+    /** Print NUM lines of trailing context */
+    afterContext?: number;
+    /** Stop after NUM matches (0 = unlimited) */
+    maxCount?: number;
+    /** Separator between context groups (default: --) */
+    contextSeparator?: string;
+    /** Show column number of first match */
+    showColumn?: boolean;
+    /** Output each match separately (vimgrep format) */
+    vimgrep?: boolean;
+    /** Show byte offset of each match */
+    showByteOffset?: boolean;
+    /** Replace matched text with this string */
+    replace?: string | null;
+    /** Print all lines (matches use :, non-matches use -) */
+    passthru?: boolean;
+    /** Enable multiline matching (patterns can span lines) */
+    multiline?: boolean;
+}
+export interface SearchResult {
+    /** The formatted output string */
+    output: string;
+    /** Whether any matches were found */
+    matched: boolean;
+    /** Number of matches found */
+    matchCount: number;
+}
+/**
+ * Search content for regex matches and format output
+ *
+ * Handles:
+ * - Count only mode (-c)
+ * - Line numbers (-n)
+ * - Invert match (-v)
+ * - Only matching (-o)
+ * - Context lines (-A, -B, -C)
+ * - Max count (-m)
+ */
+export declare function searchContent(content: string, regex: RegExp, options?: SearchOptions): SearchResult;

package/dist/commands/search-engine/regex.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Regex building utilities for search commands
+ */
+export type RegexMode = "basic" | "extended" | "fixed" | "perl";
+export interface RegexOptions {
+    mode: RegexMode;
+    ignoreCase?: boolean;
+    wholeWord?: boolean;
+    lineRegexp?: boolean;
+    multiline?: boolean;
+    /** Makes . match newlines in multiline mode (ripgrep --multiline-dotall) */
+    multilineDotall?: boolean;
+}
+/**
+ * Build a JavaScript RegExp from a pattern with the specified mode
+ */
+export declare function buildRegex(pattern: string, options: RegexOptions): RegExp;
+/**
+ * Convert replacement string syntax to JavaScript's String.replace format
+ *
+ * Conversions:
+ * - $0 and ${0} -> $& (full match)
+ * - $name -> $<name> (named capture groups)
+ * - ${name} -> $<name> (braced named capture groups)
+ * - Preserves $1, $2, etc. for numbered groups
+ */
+export declare function convertReplacement(replacement: string): string;

package/dist/commands/tar/archive.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Tar archive utilities using modern-tar
+ *
+ * Provides helpers for creating and extracting tar archives
+ * with optional gzip, bzip2, and xz compression.
+ */
+import { type ParsedTarEntryWithData, type TarEntry, type TarHeader } from "modern-tar";
+export type { TarEntry, TarHeader, ParsedTarEntryWithData };
+/**
+ * Entry for creating a tar archive
+ */
+export interface TarCreateEntry {
+    name: string;
+    content?: Uint8Array | string;
+    mode?: number;
+    mtime?: Date;
+    isDirectory?: boolean;
+    isSymlink?: boolean;
+    linkTarget?: string;
+    uid?: number;
+    gid?: number;
+}
+/**
+ * Create a tar archive from entries
+ */
+export declare function createArchive(entries: TarCreateEntry[]): Promise<Uint8Array>;
+/**
+ * Create a gzip-compressed tar archive from entries
+ */
+export declare function createCompressedArchive(entries: TarCreateEntry[]): Promise<Uint8Array>;
+/**
+ * Parsed tar entry for extraction
+ */
+export interface ParsedEntry {
+    name: string;
+    mode: number;
+    uid: number;
+    gid: number;
+    size: number;
+    mtime: Date;
+    type: "file" | "directory" | "symlink" | "hardlink" | "other";
+    linkTarget?: string;
+    content: Uint8Array;
+}
+/**
+ * Parse a tar archive and return entries
+ */
+export declare function parseArchive(data: Uint8Array): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;
+/**
+ * Parse a gzip-compressed tar archive
+ */
+export declare function parseCompressedArchive(data: Uint8Array): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;
+/**
+ * Check if data is gzip compressed (magic bytes 0x1f 0x8b)
+ */
+export declare function isGzipCompressed(data: Uint8Array): boolean;
+/**
+ * Check if data is bzip2 compressed (magic bytes "BZh")
+ */
+export declare function isBzip2Compressed(data: Uint8Array): boolean;
+/**
+ * Check if data is xz compressed (magic bytes 0xFD 0x37 0x7A 0x58 0x5A 0x00)
+ */
+export declare function isXzCompressed(data: Uint8Array): boolean;
+/**
+ * Create a bzip2-compressed tar archive from entries
+ */
+export declare function createBzip2CompressedArchive(entries: TarCreateEntry[]): Promise<Uint8Array>;
+/**
+ * Create an xz-compressed tar archive from entries
+ */
+export declare function createXzCompressedArchive(entries: TarCreateEntry[]): Promise<Uint8Array>;
+/**
+ * Parse a bzip2-compressed tar archive
+ */
+export declare function parseBzip2CompressedArchive(data: Uint8Array): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;
+/**
+ * Parse an xz-compressed tar archive
+ */
+export declare function parseXzCompressedArchive(data: Uint8Array): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;
+/**
+ * Check if data is zstd compressed (magic number 0x28 0xB5 0x2F 0xFD)
+ */
+export declare function isZstdCompressed(data: Uint8Array): boolean;
+/**
+ * Create a zstd-compressed tar archive from entries
+ */
+export declare function createZstdCompressedArchive(entries: TarCreateEntry[]): Promise<Uint8Array>;
+/**
+ * Parse a zstd-compressed tar archive
+ */
+export declare function parseZstdCompressedArchive(data: Uint8Array): Promise<{
+    entries: ParsedEntry[];
+    error?: string;
+}>;

package/dist/commands/tar/tar.d.ts

@@ -0,0 +1,8 @@
+/**
+ * tar - manipulate tape archives
+ *
+ * Supports creating, extracting, and listing tar archives
+ * with optional gzip, bzip2, and xz compression.
+ */
+import type { Command } from "../../types.js";
+export declare const tarCommand: Command;

package/dist/fs/in-memory-fs/in-memory-fs.d.ts

@@ -0,0 +1,51 @@
+import type { BufferEncoding, CpOptions, DirectoryEntry, DirentEntry, FileContent, FileEntry, FsEntry, FsStat, IFileSystem, InitialFiles, MkdirOptions, ReadFileOptions, RmOptions, SymlinkEntry, WriteFileOptions } from "../interface.js";
+export type { BufferEncoding, FileContent, FileEntry, DirectoryEntry, SymlinkEntry, FsEntry, FsStat, IFileSystem, };
+export interface FsData {
+    [path: string]: FsEntry;
+}
+export declare class InMemoryFs implements IFileSystem {
+    private data;
+    constructor(initialFiles?: InitialFiles);
+    private normalizePath;
+    private dirname;
+    private ensureParentDirs;
+    writeFileSync(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding, metadata?: {
+        mode?: number;
+        mtime?: Date;
+    }): void;
+    readFile(path: string, options?: ReadFileOptions | BufferEncoding): Promise<string>;
+    readFileBuffer(path: string): Promise<Uint8Array>;
+    writeFile(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding): Promise<void>;
+    appendFile(path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<FsStat>;
+    lstat(path: string): Promise<FsStat>;
+    private resolveSymlink;
+    /**
+     * Resolve symlinks in intermediate path components only (not the final component).
+     * Used by lstat which should not follow the final symlink.
+     */
+    private resolveIntermediateSymlinks;
+    /**
+     * Resolve all symlinks in a path, including intermediate components.
+     * For example: /home/user/linkdir/file.txt where linkdir is a symlink to "subdir"
+     * would resolve to /home/user/subdir/file.txt
+     */
+    private resolvePathWithSymlinks;
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    /**
+     * Synchronous version of mkdir
+     */
+    mkdirSync(path: string, options?: MkdirOptions): void;
+    readdir(path: string): Promise<string[]>;
+    readdirWithFileTypes(path: string): Promise<DirentEntry[]>;
+    rm(path: string, options?: RmOptions): Promise<void>;
+    cp(src: string, dest: string, options?: CpOptions): Promise<void>;
+    mv(src: string, dest: string): Promise<void>;
+    getAllPaths(): string[];
+    resolvePath(base: string, path: string): string;
+    chmod(path: string, mode: number): Promise<void>;
+    symlink(target: string, linkPath: string): Promise<void>;
+    link(existingPath: string, newPath: string): Promise<void>;
+    readlink(path: string): Promise<string>;
+}

package/dist/fs/in-memory-fs/index.d.ts

@@ -0,0 +1 @@
+export { InMemoryFs } from "./in-memory-fs.js";

package/dist/fs/init.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Filesystem Initialization
+ *
+ * Sets up the default filesystem structure for the bash environment
+ * including /dev, /proc, and common directories.
+ */
+import type { IFileSystem } from "./interface.js";
+/**
+ * Initialize the filesystem with standard directories and files
+ * Works with both InMemoryFs and OverlayFs (both write to memory)
+ */
+export declare function initFilesystem(fs: IFileSystem, useDefaultLayout: boolean): void;