just-bash-nx 2.14.4

package/dist/commands/worker-bridge/protocol.d.ts

@@ -0,0 +1,140 @@
+/**
+ * SharedArrayBuffer protocol for synchronous worker bridge
+ *
+ * This protocol enables synchronous filesystem and I/O access from a worker thread
+ * (where CPython/Python or QuickJS runs) to the main thread (which has async IFileSystem).
+ */
+declare global {
+    interface Atomics {
+        waitAsync(typedArray: Int32Array, index: number, value: number, timeout?: number): {
+            async: false;
+            value: "not-equal" | "timed-out";
+        } | {
+            async: true;
+            value: Promise<"ok" | "timed-out">;
+        };
+    }
+}
+/** Operation codes */
+export declare const OpCode: {
+    readonly NOOP: 0;
+    readonly READ_FILE: 1;
+    readonly WRITE_FILE: 2;
+    readonly STAT: 3;
+    readonly READDIR: 4;
+    readonly MKDIR: 5;
+    readonly RM: 6;
+    readonly EXISTS: 7;
+    readonly APPEND_FILE: 8;
+    readonly SYMLINK: 9;
+    readonly READLINK: 10;
+    readonly LSTAT: 11;
+    readonly CHMOD: 12;
+    readonly REALPATH: 13;
+    readonly RENAME: 14;
+    readonly COPY_FILE: 15;
+    readonly WRITE_STDOUT: 100;
+    readonly WRITE_STDERR: 101;
+    readonly EXIT: 102;
+    readonly HTTP_REQUEST: 200;
+    readonly EXEC_COMMAND: 300;
+};
+export type OpCodeType = (typeof OpCode)[keyof typeof OpCode];
+/** Status codes for synchronization */
+export declare const Status: {
+    readonly PENDING: 0;
+    readonly READY: 1;
+    readonly SUCCESS: 2;
+    readonly ERROR: 3;
+};
+export type StatusType = (typeof Status)[keyof typeof Status];
+/** Error codes */
+export declare const ErrorCode: {
+    readonly NONE: 0;
+    readonly NOT_FOUND: 1;
+    readonly IS_DIRECTORY: 2;
+    readonly NOT_DIRECTORY: 3;
+    readonly EXISTS: 4;
+    readonly PERMISSION_DENIED: 5;
+    readonly INVALID_PATH: 6;
+    readonly IO_ERROR: 7;
+    readonly TIMEOUT: 8;
+    readonly NETWORK_ERROR: 9;
+    readonly NETWORK_NOT_CONFIGURED: 10;
+};
+export type ErrorCodeType = (typeof ErrorCode)[keyof typeof ErrorCode];
+/** Flags for operations */
+export declare const Flags: {
+    readonly NONE: 0;
+    readonly RECURSIVE: 1;
+    readonly FORCE: 2;
+    readonly MKDIR_RECURSIVE: 1;
+};
+export declare function createSharedBuffer(): SharedArrayBuffer;
+/**
+ * Helper class for reading/writing protocol data
+ */
+export declare class ProtocolBuffer {
+    private int32View;
+    private uint8View;
+    private dataView;
+    constructor(buffer: SharedArrayBuffer);
+    getOpCode(): OpCodeType;
+    setOpCode(code: OpCodeType): void;
+    getStatus(): StatusType;
+    setStatus(status: StatusType): void;
+    getPathLength(): number;
+    setPathLength(length: number): void;
+    getDataLength(): number;
+    setDataLength(length: number): void;
+    getResultLength(): number;
+    setResultLength(length: number): void;
+    getErrorCode(): ErrorCodeType;
+    setErrorCode(code: ErrorCodeType): void;
+    getFlags(): number;
+    setFlags(flags: number): void;
+    getMode(): number;
+    setMode(mode: number): void;
+    getPath(): string;
+    setPath(path: string): void;
+    getData(): Uint8Array;
+    setData(data: Uint8Array): void;
+    getDataAsString(): string;
+    setDataFromString(str: string): void;
+    getResult(): Uint8Array;
+    setResult(data: Uint8Array): void;
+    getResultAsString(): string;
+    setResultFromString(str: string): void;
+    encodeStat(stat: {
+        isFile: boolean;
+        isDirectory: boolean;
+        isSymbolicLink: boolean;
+        mode: number;
+        size: number;
+        mtime: Date;
+    }): void;
+    decodeStat(): {
+        isFile: boolean;
+        isDirectory: boolean;
+        isSymbolicLink: boolean;
+        mode: number;
+        size: number;
+        mtime: Date;
+    };
+    waitForReady(timeout?: number): "ok" | "timed-out" | "not-equal";
+    waitForReadyAsync(timeout?: number): {
+        async: false;
+        value: "not-equal" | "timed-out";
+    } | {
+        async: true;
+        value: Promise<"ok" | "timed-out">;
+    };
+    /**
+     * Wait for status to become READY.
+     * Returns immediately if status is already READY, or waits until it changes.
+     */
+    waitUntilReady(timeout: number): Promise<boolean>;
+    waitForResult(timeout?: number): "ok" | "timed-out" | "not-equal";
+    notify(): number;
+    reset(): void;
+}

package/dist/commands/worker-bridge/sync-backend.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Worker-side synchronous backend
+ *
+ * Runs in the worker thread and makes synchronous calls to the main thread
+ * via SharedArrayBuffer + Atomics.
+ */
+/**
+ * Synchronous backend for worker threads.
+ */
+export declare class SyncBackend {
+    private protocol;
+    private operationTimeoutMs;
+    constructor(sharedBuffer: SharedArrayBuffer, operationTimeoutMs?: number);
+    private execSync;
+    readFile(path: string): Uint8Array;
+    writeFile(path: string, data: Uint8Array): void;
+    stat(path: string): {
+        isFile: boolean;
+        isDirectory: boolean;
+        isSymbolicLink: boolean;
+        mode: number;
+        size: number;
+        mtime: Date;
+    };
+    lstat(path: string): {
+        isFile: boolean;
+        isDirectory: boolean;
+        isSymbolicLink: boolean;
+        mode: number;
+        size: number;
+        mtime: Date;
+    };
+    readdir(path: string): string[];
+    mkdir(path: string, recursive?: boolean): void;
+    rm(path: string, recursive?: boolean, force?: boolean): void;
+    exists(path: string): boolean;
+    appendFile(path: string, data: Uint8Array): void;
+    symlink(target: string, linkPath: string): void;
+    readlink(path: string): string;
+    chmod(path: string, mode: number): void;
+    realpath(path: string): string;
+    rename(oldPath: string, newPath: string): void;
+    copyFile(src: string, dest: string): void;
+    writeStdout(data: string): void;
+    writeStderr(data: string): void;
+    exit(code: number): void;
+    /**
+     * Make an HTTP request through the main thread's secureFetch.
+     * Returns the response as a parsed object.
+     */
+    httpRequest(url: string, options?: {
+        method?: string;
+        headers?: Record<string, string>;
+        body?: string;
+    }): {
+        status: number;
+        statusText: string;
+        headers: Record<string, string>;
+        body: string;
+        bodyBase64: string;
+        url: string;
+    };
+    /**
+     * Execute a shell command through the main thread's exec function.
+     * Returns the result as { stdout, stderr, exitCode }.
+     */
+    execCommand(command: string, stdin?: string): {
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    };
+    /**
+     * Execute a shell command with structured args (shell-escaped on the main thread).
+     * Prevents command injection from unsanitized args.
+     */
+    execCommandArgs(command: string, args: string[]): {
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    };
+}

package/dist/commands/xan/aggregation.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Aggregation functions for xan command
+ */
+import { type EvaluateOptions } from "../query-engine/index.js";
+import { type CsvData, type CsvRow } from "./csv.js";
+/** Aggregation specification from parsed expression */
+export interface AggSpec {
+    func: string;
+    expr: string;
+    alias: string;
+}
+/**
+ * Parse aggregation expression: "func(expr) as alias" or "func(expr)"
+ * Handles nested parentheses in expressions like sum(add(a, b))
+ */
+export declare function parseAggExpr(expr: string): AggSpec[];
+/** Compute aggregation on data */
+export declare function computeAgg(data: CsvData, spec: AggSpec, evalOptions?: EvaluateOptions): number | string | boolean | null;
+/** Build aggregation result row */
+export declare function buildAggRow(data: CsvData, specs: AggSpec[], evalOptions?: EvaluateOptions): CsvRow;

package/dist/commands/xan/column-selection.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared utilities for xan subcommands
+ */
+import type { AstNode } from "../query-engine/parser.js";
+/**
+ * Parse a moonblade expression and transform to jq AST
+ */
+export declare function parseMoonbladeExpr(expr: string): AstNode;
+/**
+ * Parse column specification which can include:
+ * - Column names (e.g., "name,email")
+ * - Column indices (e.g., "0,2")
+ * - Numeric ranges (e.g., "0-2" means columns 0, 1, 2)
+ * - Column name ranges (e.g., "name:email" means columns from name to email)
+ * - Glob patterns (e.g., "vec_*", "*_count")
+ * - Negation (e.g., "!name" excludes column)
+ * Returns an array of column names
+ */
+export declare function parseColumnSpec(spec: string, headers: string[]): string[];

package/dist/commands/xan/csv.d.ts

@@ -0,0 +1,37 @@
+/**
+ * CSV parsing and formatting utilities for xan command
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+export interface CsvRow {
+    [key: string]: string | number | boolean | null;
+}
+export type CsvData = CsvRow[];
+/**
+ * Create a null-prototype CsvRow to prevent prototype pollution.
+ * User-controlled CSV column names could match dangerous keys like
+ * __proto__, constructor, or prototype. Using a null-prototype object
+ * ensures these don't access the prototype chain.
+ */
+export declare function createSafeRow(): CsvRow;
+/**
+ * Set a property on a CsvRow.
+ * Since CsvRow uses null-prototype, this is safe from prototype pollution.
+ */
+export declare function safeSetRow(row: CsvRow, key: string, value: string | number | boolean | null): void;
+/**
+ * Convert a plain object row to a safe null-prototype row.
+ */
+export declare function toSafeRow(plainRow: Record<string, unknown>): CsvRow;
+/** Parse CSV input string to array of row objects */
+export declare function parseCsv(input: string): {
+    headers: string[];
+    data: CsvData;
+};
+/** Format array of row objects back to CSV string */
+export declare function formatCsv(headers: string[], data: CsvData): string;
+/** Read CSV input from file or stdin */
+export declare function readCsvInput(args: string[], ctx: CommandContext): Promise<{
+    headers: string[];
+    data: CsvData;
+    error?: ExecResult;
+}>;

package/dist/commands/xan/moonblade-parser.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Moonblade expression parser for xan
+ *
+ * Parses moonblade expressions (xan's expression language) and transforms
+ * them to jq AST for evaluation by the shared query engine.
+ *
+ * Grammar based on xan's grammar.pest
+ */
+export type MoonbladeExpr = {
+    type: "int";
+    value: number;
+} | {
+    type: "float";
+    value: number;
+} | {
+    type: "string";
+    value: string;
+} | {
+    type: "bool";
+    value: boolean;
+} | {
+    type: "null";
+} | {
+    type: "identifier";
+    name: string;
+    unsure: boolean;
+} | {
+    type: "underscore";
+} | {
+    type: "func";
+    name: string;
+    args: Array<{
+        name?: string;
+        expr: MoonbladeExpr;
+    }>;
+} | {
+    type: "list";
+    elements: MoonbladeExpr[];
+} | {
+    type: "map";
+    entries: Array<{
+        key: string;
+        value: MoonbladeExpr;
+    }>;
+} | {
+    type: "regex";
+    pattern: string;
+    caseInsensitive: boolean;
+} | {
+    type: "slice";
+    start?: MoonbladeExpr;
+    end?: MoonbladeExpr;
+} | {
+    type: "lambda";
+    params: string[];
+    body: MoonbladeExpr;
+} | {
+    type: "lambdaBinding";
+    name: string;
+} | {
+    type: "pipeline";
+    exprs: MoonbladeExpr[];
+};
+export interface NamedExpr {
+    expr: MoonbladeExpr;
+    name: string | string[];
+}
+export interface Aggregation {
+    aggName: string;
+    funcName: string;
+    args: MoonbladeExpr[];
+}
+/**
+ * Parse named expressions like: "expr1, expr2 as name, expr3 as (a, b)"
+ */
+export declare function parseNamedExpressions(input: string): NamedExpr[];
+/**
+ * Parse a moonblade expression string into AST
+ */
+export declare function parseMoonblade(input: string): MoonbladeExpr;

package/dist/commands/xan/moonblade-to-jq.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Transform moonblade AST to jq AST
+ *
+ * This module converts moonblade expressions (xan's expression language)
+ * to jq AST for evaluation by the shared query engine.
+ */
+import type { AstNode } from "../query-engine/parser.js";
+import type { MoonbladeExpr } from "./moonblade-parser.js";
+/**
+ * Transform moonblade AST to jq AST
+ */
+export declare function moonbladeToJq(expr: MoonbladeExpr, rowContext?: boolean): AstNode;

package/dist/commands/xan/moonblade-tokenizer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Moonblade expression tokenizer
+ */
+export type TokenType = "int" | "float" | "string" | "regex" | "ident" | "true" | "false" | "null" | "(" | ")" | "[" | "]" | "{" | "}" | "," | ":" | ";" | "=>" | "+" | "-" | "*" | "/" | "//" | "%" | "**" | "++" | "==" | "!=" | "<" | "<=" | ">" | ">=" | "eq" | "ne" | "lt" | "le" | "gt" | "ge" | "&&" | "||" | "and" | "or" | "!" | "." | "|" | "in" | "not in" | "as" | "=" | "_" | "eof";
+export interface Token {
+    type: TokenType;
+    value: string;
+    pos: number;
+}
+export declare class Tokenizer {
+    private input;
+    private pos;
+    private tokens;
+    constructor(input: string);
+    tokenize(): Token[];
+    private skipWhitespace;
+    private nextToken;
+    private match;
+    private isIdentStart;
+    private isIdentChar;
+    private readNumber;
+    private readString;
+    private readRegex;
+    private readIdentifier;
+}

package/dist/commands/xan/subcommands.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Barrel file for xan subcommand handlers
+ *
+ * This file re-exports all subcommands from their individual modules
+ * for cleaner organization and easier maintenance.
+ */
+export { cmdAgg, cmdFrequency, cmdGroupby, cmdStats } from "./xan-agg.js";
+export { cmdDrop, cmdEnum, cmdRename, cmdSelect } from "./xan-columns.js";
+export { cmdCount, cmdHead, cmdHeaders, cmdReverse, cmdSlice, cmdTail, } from "./xan-core.js";
+export { cmdFixlengths, cmdFrom, cmdPartition, cmdShuffle, cmdSplit, cmdTo, cmdTranspose, } from "./xan-data.js";
+export { cmdDedup, cmdFilter, cmdSort, cmdTop } from "./xan-filter.js";
+export { cmdMap, cmdTransform } from "./xan-map.js";
+export { cmdExplode, cmdImplode, cmdJoin, cmdMerge, cmdPivot, } from "./xan-reshape.js";
+export { cmdBehead, cmdCat, cmdFlatmap, cmdFmt, cmdSample, cmdSearch, } from "./xan-simple.js";
+export { cmdFlatten, cmdView } from "./xan-view.js";

package/dist/commands/xan/xan-agg.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Aggregation commands: agg, groupby, frequency, stats
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+export declare function cmdAgg(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdGroupby(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdFrequency(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdStats(args: string[], ctx: CommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-columns.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Column operation commands: select, drop, rename, enum
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+export declare function cmdSelect(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdDrop(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdRename(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdEnum(args: string[], ctx: CommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-core.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Core xan commands: headers, count, head, tail, slice, reverse
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+export declare function cmdHeaders(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdCount(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdHead(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdTail(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdSlice(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdReverse(args: string[], ctx: CommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-data.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Data utility commands: transpose, shuffle, fixlengths, split, partition
+ * Commands that exist in real xan
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+/**
+ * Transpose: swap rows and columns
+ * Usage: xan transpose [FILE]
+ *   First column becomes header row, first row becomes header column
+ */
+export declare function cmdTranspose(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Shuffle: randomly reorder rows
+ * Usage: xan shuffle [OPTIONS] [FILE]
+ *   --seed N    Random seed for reproducibility
+ */
+export declare function cmdShuffle(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Fixlengths: fix ragged CSV by padding/truncating rows
+ * Usage: xan fixlengths [OPTIONS] [FILE]
+ *   -l, --length N    Target number of columns (default: max row length)
+ *   -d, --default V   Default value for missing fields (default: empty)
+ */
+export declare function cmdFixlengths(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Split: split CSV into multiple files by row count
+ * Usage: xan split [OPTIONS] FILE
+ *   -c, --chunks N    Split into N equal chunks
+ *   -S, --size N      Split into chunks of N rows each
+ *   -o, --output DIR  Output directory (default: current)
+ *
+ * In sandbox mode, outputs as JSON with parts as array
+ */
+export declare function cmdSplit(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Partition: split CSV by column value into separate outputs
+ * Usage: xan partition COLUMN [OPTIONS] [FILE]
+ *   -o, --output DIR  Output directory (default: current)
+ */
+export declare function cmdPartition(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * To: convert CSV to other formats
+ * Usage: xan to FORMAT [OPTIONS] [FILE]
+ *   FORMAT: json
+ */
+export declare function cmdTo(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * From: convert other formats to CSV
+ * Usage: xan from [OPTIONS] [FILE]
+ *   -f, --format FORMAT   Input format (json)
+ */
+export declare function cmdFrom(args: string[], ctx: CommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-filter.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Filter and sort commands: filter, sort, dedup, top
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+export declare function cmdFilter(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdSort(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdDedup(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdTop(args: string[], ctx: CommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-map.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Map command: add computed columns
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+export declare function cmdMap(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Transform command: modify existing columns in-place
+ * Usage: xan transform COLUMN EXPR [FILE]
+ *   -r, --rename NAME  Rename the column after transformation
+ */
+export declare function cmdTransform(args: string[], ctx: CommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-reshape.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Reshape commands: explode, implode, flatmap, pivot, join, merge
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+/**
+ * Explode: split delimited column values into multiple rows
+ * Usage: xan explode COLUMN [OPTIONS] [FILE]
+ *   -s, --separator SEP  Value separator (default: |)
+ *   --drop-empty         Drop rows where column is empty
+ *   -r, --rename NAME    Rename the column
+ */
+export declare function cmdExplode(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Implode: combine consecutive rows with same key, joining column values
+ * Usage: xan implode COLUMN [OPTIONS] [FILE]
+ *   -s, --separator SEP  Value separator (default: |)
+ *   -r, --rename NAME    Rename the column
+ */
+export declare function cmdImplode(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Join: join two CSV files on key columns
+ * Usage: xan join KEY1 FILE1 KEY2 FILE2 [OPTIONS]
+ *   --left       Left outer join (keep all rows from first file)
+ *   --right      Right outer join (keep all rows from second file)
+ *   --full       Full outer join (keep all rows from both files)
+ *   -D, --default VALUE  Default value for missing fields
+ */
+export declare function cmdJoin(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Pivot: reshape data by turning row values into columns
+ * Usage: xan pivot COLUMN AGG_EXPR [OPTIONS] [FILE]
+ *   -g, --groupby COLS   Group by these columns (default: all other columns)
+ */
+export declare function cmdPivot(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Merge: merge multiple sorted CSV files
+ * Usage: xan merge [OPTIONS] FILE1 FILE2 ...
+ *   -s, --sort COLUMN   Sort column (files must be pre-sorted by this)
+ */
+export declare function cmdMerge(args: string[], ctx: CommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-simple.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Simple commands: behead, sample, cat, search, flatmap, fmt
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+/**
+ * Behead: remove header row from CSV (output data rows only)
+ * Usage: xan behead [FILE]
+ */
+export declare function cmdBehead(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Sample: randomly sample N rows from CSV
+ * Usage: xan sample [OPTIONS] <sample-size> [FILE]
+ *   --seed SEED    Random seed for reproducibility
+ */
+export declare function cmdSample(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Cat: concatenate CSV files
+ * Usage: xan cat [OPTIONS] FILE1 FILE2 ...
+ *   -p, --pad    Pad missing columns with empty values
+ */
+export declare function cmdCat(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Search: filter rows by regex match on any/specific columns
+ * Usage: xan search [OPTIONS] PATTERN [FILE]
+ *   -s, --select COLS    Only search in these columns
+ *   -v, --invert         Invert match (exclude matching rows)
+ *   -i, --ignore-case    Case insensitive match
+ */
+export declare function cmdSearch(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Flatmap: like map but expression can return multiple rows
+ * Usage: xan flatmap EXPR [FILE]
+ *   The expression should return an array; each element becomes a row
+ */
+export declare function cmdFlatmap(args: string[], ctx: CommandContext): Promise<ExecResult>;
+/**
+ * Fmt: format CSV as a table (alias for view with options)
+ * Usage: xan fmt [OPTIONS] [FILE]
+ */
+export declare function cmdFmt(args: string[], ctx: CommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan-view.d.ts

@@ -0,0 +1,12 @@
+/**
+ * View commands: pretty print CSV as table or flattened records
+ */
+import type { CommandContext, ExecResult } from "../../types.js";
+/**
+ * Flatten: display records vertically, one field per line
+ * Usage: xan flatten [OPTIONS] [FILE]
+ *   -l, --limit N    Maximum number of rows to display
+ *   -s, --select COLS  Select columns to display
+ */
+export declare function cmdFlatten(args: string[], ctx: CommandContext): Promise<ExecResult>;
+export declare function cmdView(args: string[], ctx: CommandContext): Promise<ExecResult>;

package/dist/commands/xan/xan.d.ts

@@ -0,0 +1,10 @@
+/**
+ * xan - CSV toolkit command
+ *
+ * Provides ergonomic CLI for CSV operations, translating commands to jq expressions
+ * and using the shared query engine. Inspired by xsv and xan tools.
+ */
+import type { Command } from "../../types.js";
+export declare const xanCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/xargs/xargs.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "../../types.js";
+export declare const xargsCommand: Command;
+import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
+export declare const flagsForFuzzing: CommandFuzzInfo;