@proteinjs/reflection-build 1.2.0 → 1.2.1

package/test/examples/source-repository/b/node_modules/@proteinjs/reflection/src/SourceRepository.ts

@@ -0,0 +1,250 @@
+import { Graph } from '@dagrejs/graphlib';
+import { graphSerializer, isInstanceOf } from '@proteinjs/util';
+import { SourceType } from './sourceGraphTypes';
+import {
+  VariableDeclaration,
+  TypeAliasDeclaration,
+  ClassDeclaration,
+  InterfaceDeclaration,
+  Class,
+  Variable,
+  TypeAlias,
+  Interface,
+  PackageScope,
+} from './types';
+import { FlattenedSourceGraph, flattenSourceGraph } from './FlattenedSourceGraph';
+import { SOURCE_REPOSITORY_FILTER_QUALIFIED_NAME, getSourceRepositoryFilters } from './SourceRepositoryFilter';
+
+type TypeMap = { [qualifiedName: string]: Interface | TypeAlias | Class | Variable };
+
+export class SourceRepository {
+  public readonly sourceGraph = new Graph();
+  private readonly sourceLinks: { [qualifiedName: string]: any } = {};
+  public flattenedSourceGraph: FlattenedSourceGraph = { variables: {}, typeAliases: {}, classes: {}, interfaces: {} };
+  // private readonly typeCache: { [type: string]: (ClassDeclaration|VariableDeclaration)[] } = {};
+  private readonly objectCache: { [type: string]: any[] } = {};
+
+  private constructor() {}
+
+  static get(): SourceRepository {
+    if (!SourceRepository.getGlobal().__proteinjs_reflection_SourceRepository) {
+      SourceRepository.getGlobal().__proteinjs_reflection_SourceRepository = new SourceRepository();
+    }
+
+    return SourceRepository.getGlobal().__proteinjs_reflection_SourceRepository;
+  }
+
+  private static getGlobal(): any {
+    if (typeof window !== 'undefined') {
+      return window;
+    }
+
+    return globalThis;
+  }
+
+  interface(qualifiedInterfaceName: string) {
+    return this.flattenedSourceGraph.interfaces[qualifiedInterfaceName];
+  }
+
+  interfaceExtends(_interface: Interface, type: string) {
+    return typeof _interface.allParents[type] !== 'undefined';
+  }
+
+  /**
+   * Same as SourceRepository.objects except assumes it will find only 1 object.
+   *
+   * @param extendingType a Type or Interface that the Class or Variable extends
+   * @return variable or instantiated class that extends `extendingType`
+   */
+  object<T>(extendingType: string): T {
+    return this.objects<T>(extendingType)[0];
+  }
+
+  /**
+   * @param extendingType a Type, Interface, or Class that the Class or Variable extends
+   * @return variables and instantiated classes that extend `extendingType`
+   */
+  objects<T>(extendingType: string): T[] {
+    if (this.objectCache[extendingType]) {
+      return this.objectCache[extendingType];
+    }
+
+    const baseChildren = this.baseChildren(extendingType);
+    const extendingObjects: T[] = [];
+    for (const baseChildQualifiedName in baseChildren) {
+      const child = baseChildren[baseChildQualifiedName];
+      if (isInstanceOf(child, Class)) {
+        extendingObjects.push(new (child as any)._constructor());
+      } else if (isInstanceOf(child, Variable)) {
+        extendingObjects.push((child as any).value);
+      }
+    }
+
+    this.objectCache[extendingType] = extendingObjects;
+    return extendingObjects;
+  }
+
+  /**
+   * @param extendingType a Type, Interface, or Class that the Class or Variable extends
+   * @returns a hashmap (key is qualified name) of base child types (vs the instantiated objects provided by the objects method) that extend `extendingType`
+   */
+  baseChildren(extendingType: string): TypeMap {
+    const _interface = SourceRepository.get().flattenedSourceGraph.interfaces[extendingType];
+    const typeAlias = SourceRepository.get().flattenedSourceGraph.typeAliases[extendingType];
+    const _class = SourceRepository.get().flattenedSourceGraph.classes[extendingType];
+    let baseChildren: TypeMap;
+    if (_interface) {
+      baseChildren = _interface.baseChildren;
+    } else if (typeAlias) {
+      baseChildren = typeAlias.baseChildren;
+    } else if (_class) {
+      baseChildren = _class.baseChildren;
+    } else {
+      throw new Error(`Unable to find type: ${extendingType}`);
+    }
+
+    if (extendingType === SOURCE_REPOSITORY_FILTER_QUALIFIED_NAME) {
+      return baseChildren;
+    }
+
+    return this.filterObjects(baseChildren);
+  }
+
+  /**
+   * @param extendingType a Type, Interface, or Class that the Class or Variable extends
+   * @returns a hashmap (key is qualified name) of direct child types (vs the instantiated objects provided by the objects method) that extend `extendingType`
+   */
+  directChildren(extendingType: string): TypeMap {
+    const _interface = SourceRepository.get().flattenedSourceGraph.interfaces[extendingType];
+    const typeAlias = SourceRepository.get().flattenedSourceGraph.typeAliases[extendingType];
+    const _class = SourceRepository.get().flattenedSourceGraph.classes[extendingType];
+    let directChildren: any;
+    if (_interface) {
+      directChildren = _interface.directChildren;
+    } else if (typeAlias) {
+      directChildren = typeAlias.directChildren;
+    } else if (_class) {
+      directChildren = _class.directChildren;
+    } else {
+      throw new Error(`Unable to find type: ${extendingType}`);
+    }
+
+    if (extendingType === SOURCE_REPOSITORY_FILTER_QUALIFIED_NAME) {
+      return directChildren;
+    }
+
+    return this.filterObjects(directChildren);
+  }
+
+  private filterObjects(typeMap: TypeMap): TypeMap {
+    const filteredTypeMap: TypeMap = {};
+    const filters = getSourceRepositoryFilters();
+    for (const qualifiedName of Object.keys(typeMap)) {
+      const packageScope = typeMap[qualifiedName];
+      let filtered = true;
+      for (const filter of filters) {
+        if (!filter.filterObject(qualifiedName)) {
+          filtered = false;
+          break;
+        }
+      }
+
+      if (filtered) {
+        filteredTypeMap[qualifiedName] = packageScope;
+      }
+    }
+
+    return filteredTypeMap;
+  }
+
+  static merge(serializedSourceGraph: string, sourceLinks: { [qualifiedName: string]: any }) {
+    const unescapedSerializedSourceGraph = serializedSourceGraph.replace(/\\'/g, "'");
+    const sourceGraph = graphSerializer.deserialize(unescapedSerializedSourceGraph);
+    for (const nodeName of sourceGraph.nodes()) {
+      const nodeValue = sourceGraph.node(nodeName);
+      if (!nodeValue) {
+        continue;
+      }
+
+      SourceRepository.get().sourceGraph.setNode(nodeName, SourceRepository.deserializeClass(nodeValue));
+    }
+
+    for (const edge of sourceGraph.edges()) {
+      const edgeValue = sourceGraph.edge(edge);
+      SourceRepository.get().sourceGraph.setEdge(edge, edgeValue);
+    }
+
+    Object.assign(SourceRepository.get().sourceLinks, sourceLinks);
+    SourceRepository.get().flattenedSourceGraph = flattenSourceGraph(
+      SourceRepository.get().sourceGraph,
+      SourceRepository.get().sourceLinks
+    );
+  }
+
+  private static deserializeClass(classJson: any): any {
+    if (classJson.sourceType === SourceType.variable) {
+      return VariableDeclaration.deserialize(classJson);
+    } else if (classJson.sourceType === SourceType.typeAlias) {
+      return TypeAliasDeclaration.deserialize(classJson);
+    } else if (classJson.sourceType === SourceType.class) {
+      return ClassDeclaration.deserialize(classJson);
+    } else if (classJson.sourceType === SourceType.interface) {
+      return InterfaceDeclaration.deserialize(classJson);
+    }
+
+    return classJson;
+  }
+
+  // objects<T>(type: string): T[] {
+  // 	if (!this.objectCache[type]) {
+  // 		this.objectCache[type] = this.types(type).map((type) => {
+  // 			if (type instanceof VariableDeclaration)
+  // 				return type.value;
+
+  // 			if (type instanceof ClassDeclaration)
+  // 				return new type._constructor();
+
+  // 			return null;
+  // 		});
+  // 	}
+
+  // 	return this.objectCache[type];
+  // }
+
+  // types(parentType: string): (ClassDeclaration|VariableDeclaration)[] {
+  // 	if (!this.typeCache[parentType]) {
+  // 		const node = this.sourceGraph.node(parentType);
+  // 		if (!node)
+  // 			throw new Error(`Failed to find types, reason: parent type does not exist: ${parentType}`);
+
+  // 		const collectedTypes: (ClassDeclaration|VariableDeclaration)[] = [];
+  // 		this.collectTypes(parentType, collectedTypes);
+  // 		this.typeCache[parentType] = collectedTypes;
+  // 	}
+
+  // 	return this.typeCache[parentType];
+  // }
+
+  // private collectTypes(type: string, collectedTypes: (ClassDeclaration|VariableDeclaration)[]): void {
+  // 	const childTypes = this.sourceGraph.successors(type);
+  // 	if (!childTypes)
+  // 		return;
+
+  // 	for (const childType of childTypes) {
+  // 		const childNode = this.sourceGraph.node(childType);
+  // 		if (!childNode)
+  // 			continue;
+
+  // 		const sourceLink = this.sourceLinks[childNode.qualifiedName];
+  // 		if (childNode instanceof VariableDeclaration) {
+  // 			childNode.value = sourceLink;
+  // 			collectedTypes.push(childNode);
+  // 		} else if (childNode instanceof ClassDeclaration && !childNode.isAbstract) {
+  // 			childNode._constructor = sourceLink;
+  // 			collectedTypes.push(childNode);
+  // 		}
+
+  // 		this.collectTypes(childType, collectedTypes);
+  // 	}
+  // }
+}

package/test/examples/source-repository/b/node_modules/@proteinjs/reflection/src/SourceRepositoryFilter.ts

@@ -0,0 +1,15 @@
+import { Loadable } from './Loadable';
+import { SourceRepository } from './SourceRepository';
+
+export const SOURCE_REPOSITORY_FILTER_QUALIFIED_NAME = '@proteinjs/reflection/SourceRepositoryFilter';
+export const getSourceRepositoryFilters = () =>
+  SourceRepository.get().objects<SourceRepositoryFilter>(SOURCE_REPOSITORY_FILTER_QUALIFIED_NAME);
+
+export interface SourceRepositoryFilter extends Loadable {
+  /**
+   * Filter objects that would be returned by `SourceRepository.object` and `SourceRepository.objects`
+   * @param qualifiedName the package-qualified name of the object to be filtered (ie. `@dependency/package/ClassName`)
+   * @return true if the object should be returned by the `SourceRepository`
+   */
+  filterObject(qualifiedName: string): boolean;
+}

package/test/examples/source-repository/b/node_modules/@proteinjs/reflection/src/sourceGraphTypes.ts

@@ -0,0 +1,14 @@
+export enum SourceType {
+  variable,
+  typeAlias,
+  class,
+  interface,
+}
+
+export enum SourceRelationship {
+  hasType = 'has type',
+  extendsType = 'extends type',
+  extendsClass = 'extends class',
+  implementsInterface = 'implements interface',
+  extendsInterface = 'extends interface',
+}

package/test/examples/source-repository/b/node_modules/@proteinjs/reflection/src/types.ts

@@ -0,0 +1,236 @@
+export abstract class PackageScope {
+  public readonly qualifiedName: string;
+
+  constructor(
+    public readonly packageName: string,
+    public readonly name: string,
+    public readonly filePath?: string
+  ) {
+    this.qualifiedName = `${packageName}/${name}`;
+  }
+}
+
+export class Variable extends PackageScope {
+  constructor(
+    packageName: string,
+    name: string,
+    filePath: string,
+    public readonly isExported: boolean,
+    public readonly isConst: boolean,
+    public readonly value: any,
+    public readonly typeParameters: { [qualifiedName: string]: (TypeAlias | Interface)[] } = {},
+    public directParentTypes: { [qualifiedName: string]: TypeAlias | Interface } = {},
+    public allParentTypes: { [qualifiedName: string]: TypeAlias | Interface } = {},
+    public rootParentTypes: { [qualifiedName: string]: TypeAlias | Interface } = {}
+  ) {
+    super(packageName, name, filePath);
+  }
+}
+
+export class TypeAlias extends PackageScope {
+  constructor(
+    packageName: string,
+    name: string,
+    filePath?: string,
+    public readonly typeParameters: { [qualifiedName: string]: (TypeAlias | Interface)[] } = {},
+    public readonly directParents: { [qualifiedName: string]: TypeAlias | Interface } = {},
+    public allParents: { [qualifiedName: string]: TypeAlias | Interface } = {},
+    public rootParents: { [qualifiedName: string]: TypeAlias | Interface } = {},
+    public directChildren: { [qualifiedName: string]: TypeAlias | Variable } = {},
+    public allChildren: { [qualifiedName: string]: TypeAlias | Variable } = {},
+    public baseChildren: { [qualifiedName: string]: TypeAlias | Variable } = {}
+  ) {
+    super(packageName, name, filePath);
+  }
+}
+
+export class Class extends PackageScope {
+  constructor(
+    packageName: string,
+    name: string,
+    filePath: string,
+    public readonly isAbstract: boolean,
+    public readonly isStatic: boolean,
+    public readonly visibility: Visibility,
+    public readonly properties: Property[],
+    public readonly methods: Method[],
+    public readonly _constructor: any,
+    public readonly directParents: { [qualifiedName: string]: Class | Interface | TypeAlias } = {},
+    public readonly typeParameters: { [qualifiedName: string]: (TypeAlias | Interface | TypeAlias)[] } = {},
+    public allParents: { [qualifiedName: string]: Class | Interface | TypeAlias } = {},
+    public rootParents: { [qualifiedName: string]: Class | Interface | TypeAlias } = {},
+    public directChildren: { [qualifiedName: string]: Class } = {},
+    public allChildren: { [qualifiedName: string]: Class } = {},
+    public baseChildren: { [qualifiedName: string]: Class } = {}
+  ) {
+    super(packageName, name, filePath);
+  }
+}
+
+export class Interface extends PackageScope {
+  constructor(
+    packageName: string,
+    name: string,
+    public readonly properties: Property[],
+    public readonly methods: Method[],
+    filePath?: string,
+    public readonly typeParameters: { [qualifiedName: string]: (TypeAlias | Interface)[] } = {},
+    public readonly directParents: { [qualifiedName: string]: Interface | TypeAlias } = {},
+    public allParents: { [qualifiedName: string]: Interface | TypeAlias } = {},
+    public rootParents: { [qualifiedName: string]: Interface | TypeAlias } = {},
+    public readonly directChildren: { [qualifiedName: string]: Interface | TypeAlias | Class | Variable } = {},
+    public allChildren: { [qualifiedName: string]: Interface | TypeAlias | Class | Variable } = {},
+    public baseChildren: { [qualifiedName: string]: Interface | TypeAlias | Class | Variable } = {}
+  ) {
+    super(packageName, name, filePath);
+  }
+}
+
+export class Method {
+  constructor(
+    public readonly name: string,
+    public readonly returnType: TypeAliasDeclaration | undefined,
+    public readonly isAsync: boolean,
+    public readonly isOptional: boolean,
+    public readonly isAbstract: boolean,
+    public readonly isStatic: boolean,
+    public readonly visibility: Visibility,
+    public readonly parameters: Parameter[]
+    // public readonly variables: VariableDeclaration[]
+  ) {}
+}
+
+export type Visibility = 'public' | 'protected' | 'private' | undefined;
+
+export class Property {
+  constructor(
+    public readonly name: string,
+    public readonly type: TypeAliasDeclaration | undefined,
+    public readonly isOptional: boolean,
+    public readonly isAbstract: boolean,
+    public readonly isStatic: boolean,
+    public readonly visibility: Visibility
+  ) {}
+}
+
+export class Parameter {
+  constructor(
+    public readonly name: string,
+    public readonly type: TypeAliasDeclaration | undefined
+    // public readonly isOptional: boolean
+  ) {}
+}
+
+/**
+ * Declarations are intermediary types created by the parser. They do not contain the deeply-nested, relational
+ * information possible at runtime.
+ *
+ * Note: The declaration types specified in typescript-parser are not used because they are not package-scoped.
+ * The typescript-parser package is a file-level parser, and reflection is a package-level parser.
+ */
+
+export class VariableDeclaration extends PackageScope {
+  constructor(
+    packageName: string,
+    name: string,
+    filePath: string,
+    public type: TypeAliasDeclaration,
+    public isExported: boolean,
+    public isConst: boolean
+  ) {
+    super(packageName, name, filePath);
+  }
+
+  static deserialize(json: any): VariableDeclaration {
+    return new VariableDeclaration(
+      json.packageName,
+      json.name,
+      json.filePath,
+      json.type,
+      json.isExported,
+      json.isConst
+    );
+  }
+}
+
+export class TypeAliasDeclaration extends PackageScope {
+  constructor(
+    packageName: string,
+    name: string,
+    public typeParameters?: string[],
+    public directParents?: TypeAliasDeclaration[],
+    filePath?: string
+  ) {
+    super(packageName, name, filePath);
+  }
+
+  static deserialize(json: any): TypeAliasDeclaration {
+    return new TypeAliasDeclaration(
+      json.packageName,
+      json.name,
+      json.typeParameters,
+      json.directParents,
+      json.filePath
+    );
+  }
+}
+
+export class ClassDeclaration extends PackageScope {
+  constructor(
+    packageName: string,
+    name: string,
+    public readonly isAbstract: boolean,
+    public readonly isStatic: boolean,
+    public readonly visibility: Visibility,
+    public readonly properties: Property[],
+    public readonly methods: Method[],
+    public readonly typeParameters: string[],
+    public readonly directParentInterfaces: InterfaceDeclaration[],
+    public readonly directParentClasses: ClassDeclaration[],
+    filePath?: string
+  ) {
+    super(packageName, name, filePath);
+  }
+
+  static deserialize(json: any): ClassDeclaration {
+    return new ClassDeclaration(
+      json.packageName,
+      json.name,
+      json.isAbstract,
+      json.isStatic,
+      json.visibility,
+      json.properties,
+      json.methods,
+      json.typeParameters,
+      json.directParentInterfaces,
+      json.directParentClasses,
+      json.filePath
+    );
+  }
+}
+
+export class InterfaceDeclaration extends PackageScope {
+  constructor(
+    packageName: string,
+    name: string,
+    public readonly properties: Property[],
+    public readonly methods: Method[],
+    public readonly typeParameters: string[],
+    public readonly directParents: InterfaceDeclaration[],
+    filePath?: string
+  ) {
+    super(packageName, name, filePath);
+  }
+
+  static deserialize(json: any): InterfaceDeclaration {
+    return new InterfaceDeclaration(
+      json.packageName,
+      json.name,
+      json.properties,
+      json.methods,
+      json.typeParameters,
+      json.directParents,
+      json.filePath
+    );
+  }
+}

package/test/examples/source-repository/b/node_modules/@proteinjs/reflection/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "declaration": true,
+    "sourceMap": true,
+    "outDir": "./dist/",
+    "strict": true,
+    "noImplicitAny": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "baseUrl": "./",
+    "paths": { "*": ["types/*"] },
+    "types": ["node", "jest"]
+  },
+  "include": ["./index.ts"]
+}

package/test/examples/source-repository/b/node_modules/@proteinjs/reflection/types/@dagrejs/graphlib.d.ts

@@ -0,0 +1 @@
+export * from 'graphlib';

package/test/examples/source-repository/b/node_modules/@proteinjs/util-node/CHANGELOG.md

@@ -3,6 +3,19 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.5.0](https://github.com/proteinjs/util/compare/@proteinjs/util-node@1.4.2...@proteinjs/util-node@1.5.0) (2025-10-14)
+
+
+### Features
+
+* `cmd` return `CmdResult` to be able to programmatically access log output and exit code. ([7dad1a1](https://github.com/proteinjs/util/commit/7dad1a158d692dab502d112b4beb0e3662a1cc70))
+* Added `Fs.grep` ([0c6b07f](https://github.com/proteinjs/util/commit/0c6b07f549122de8cc6e33ddd2480cdf38f531a3))
+* Added various git commands ([5adbfd7](https://github.com/proteinjs/util/commit/5adbfd7a05a10af3fde0949dd5c8eed02a9da571))
+
+
+
+
+
 ## [1.4.2](https://github.com/proteinjs/util/compare/@proteinjs/util-node@1.4.1...@proteinjs/util-node@1.4.2) (2025-04-11)
 
 **Note:** Version bump only for package @proteinjs/util-node

package/test/examples/source-repository/b/node_modules/@proteinjs/util-node/dist/src/Fs.d.ts

@@ -11,6 +11,11 @@ export interface FileDescriptor {
     path: string;
     projectRelativePath: string;
 }
+export type GrepMatch = {
+    path: string;
+    line: number;
+    excerpt: string;
+};
 export declare class Fs {
     static exists(path: string): Promise<boolean>;
     static createFolder(path: string): Promise<void>;
@@ -27,4 +32,22 @@ export declare class Fs {
     static rename(oldPath: string, newName: string): Promise<void>;
     static copy(sourcePath: string, destinationPath: string): Promise<void>;
     static move(sourcePath: string, destinationPath: string): Promise<void>;
+    /**
+     * Minimal, robust grep wrapper.
+     * - Literal search (-F) to avoid regex surprises like "parentheses not balanced"
+     * - Recursive (-R), show file and line (-nH), no color, ignore binary (-I)
+     * - Excludes heavy dirs: node_modules, dist, .git, generated, protein
+     * - Optional maxColumns (default 500) truncates each output line via `cut -c1-N`
+     * - Returns { code, stdout, stderr } without throwing on non-zero exit codes.
+     */
+    static grep(params: {
+        pattern: string;
+        dir?: string;
+        maxResults?: number;
+        maxColumns?: number;
+    }): Promise<{
+        code: number;
+        stdout: string;
+        stderr: string;
+    }>;
 }

package/test/examples/source-repository/b/node_modules/@proteinjs/util-node/dist/src/Fs.js

@@ -53,6 +53,7 @@ var path_1 = __importDefault(require("path"));
 var fs_extra_1 = __importDefault(require("fs-extra"));
 var promises_1 = __importDefault(require("fs/promises"));
 var globby_1 = __importDefault(require("globby"));
+var cmd_1 = require("./cmd");
 var Fs = /** @class */ (function () {
     function Fs() {
     }
@@ -295,6 +296,72 @@ var Fs = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Minimal, robust grep wrapper.
+     * - Literal search (-F) to avoid regex surprises like "parentheses not balanced"
+     * - Recursive (-R), show file and line (-nH), no color, ignore binary (-I)
+     * - Excludes heavy dirs: node_modules, dist, .git, generated, protein
+     * - Optional maxColumns (default 500) truncates each output line via `cut -c1-N`
+     * - Returns { code, stdout, stderr } without throwing on non-zero exit codes.
+     */
+    Fs.grep = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, pattern, dir, maxResults, maxColumns, cwd, args, shEscape, cols, grepCmd, pipeline, res, res, e_1, code, stdout, stderr;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = params || {}, pattern = _a.pattern, dir = _a.dir, maxResults = _a.maxResults, maxColumns = _a.maxColumns;
+                        if (!pattern || typeof pattern !== 'string') {
+                            throw new Error('Fs.grep: "pattern" (string) is required.');
+                        }
+                        cwd = dir || process.cwd();
+                        args = [
+                            '-R',
+                            '-n',
+                            '-H',
+                            '-I',
+                            '--color=never',
+                            '-F',
+                            '--exclude-dir=node_modules',
+                            '--exclude-dir=dist',
+                            '--exclude-dir=.git',
+                            '--exclude-dir=generated',
+                            '--exclude-dir=protein',
+                            '--exclude=CHANGELOG.md',
+                        ];
+                        if (typeof maxResults === 'number' && maxResults > 0) {
+                            args.push('-m', String(maxResults));
+                        }
+                        // Use -e to ensure the pattern is treated as a single argument
+                        args.push('-e', pattern, '.');
+                        shEscape = function (s) { return "'".concat(String(s).replace(/'/g, "'\\''"), "'"); };
+                        cols = typeof maxColumns === 'number' ? maxColumns : 500;
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 6, , 7]);
+                        if (!(cols > 0)) return [3 /*break*/, 3];
+                        grepCmd = __spreadArray(['grep'], args, true).map(shEscape).join(' ');
+                        pipeline = "set -o pipefail; ".concat(grepCmd, " | cut -c1-").concat(cols);
+                        return [4 /*yield*/, (0, cmd_1.cmd)('bash', ['-lc', pipeline], { cwd: cwd })];
+                    case 2:
+                        res = _b.sent();
+                        return [2 /*return*/, res]; // { code: 0, stdout, stderr: '' } on success
+                    case 3: return [4 /*yield*/, (0, cmd_1.cmd)('grep', args, { cwd: cwd })];
+                    case 4:
+                        res = _b.sent();
+                        return [2 /*return*/, res];
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        e_1 = _b.sent();
+                        code = typeof (e_1 === null || e_1 === void 0 ? void 0 : e_1.code) === 'number' ? e_1.code : -1;
+                        stdout = typeof (e_1 === null || e_1 === void 0 ? void 0 : e_1.stdout) === 'string' ? e_1.stdout : '';
+                        stderr = typeof (e_1 === null || e_1 === void 0 ? void 0 : e_1.stderr) === 'string' ? e_1.stderr : String(e_1);
+                        return [2 /*return*/, { code: code, stdout: stdout, stderr: stderr }];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
     return Fs;
 }());
 exports.Fs = Fs;