agentic-flow 2.0.1-alpha → 2.0.1-alpha.3

package/packages/agentic-jujutsu/node_modules/mocha/lib/cli/lookup-files.js

@@ -1,155 +0,0 @@
-'use strict';
-/**
- * Contains `lookupFiles`, which takes some globs/dirs/options and returns a list of files.
- * @module
- * @private
- */
-
-var fs = require('node:fs');
-var path = require('node:path');
-var glob = require('glob');
-var errors = require('../errors');
-var createNoFilesMatchPatternError = errors.createNoFilesMatchPatternError;
-var createMissingArgumentError = errors.createMissingArgumentError;
-const debug = require('debug')('mocha:cli:lookup-files');
-
-/**
- * Determines if pathname would be a "hidden" file (or directory) on UN*X.
- *
- * @description
- * On UN*X, pathnames beginning with a full stop (aka dot) are hidden during
- * typical usage. Dotfiles, plain-text configuration files, are prime examples.
- *
- * @see {@link http://xahlee.info/UnixResource_dir/writ/unix_origin_of_dot_filename.html|Origin of Dot File Names}
- *
- * @private
- * @param {string} pathname - Pathname to check for match.
- * @return {boolean} whether pathname would be considered a hidden file.
- * @example
- * isHiddenOnUnix('.profile'); // => true
- */
-const isHiddenOnUnix = pathname => path.basename(pathname).startsWith('.');
-
-/**
- * Determines if pathname has a matching file extension.
- *
- * Supports multi-part extensions.
- *
- * @private
- * @param {string} pathname - Pathname to check for match.
- * @param {string[]} exts - List of file extensions, w/-or-w/o leading period
- * @return {boolean} `true` if file extension matches.
- * @example
- * hasMatchingExtname('foo.html', ['js', 'css']); // false
- * hasMatchingExtname('foo.js', ['.js']); // true
- * hasMatchingExtname('foo.js', ['js']); // ture
- */
-const hasMatchingExtname = (pathname, exts = []) =>
-  exts
-    .map(ext => (ext.startsWith('.') ? ext : `.${ext}`))
-    .some(ext => pathname.endsWith(ext));
-
-/**
- * Lookup file names at the given `path`.
- *
- * @description
- * Filenames are returned in _traversal_ order by the OS/filesystem.
- * **Make no assumption that the names will be sorted in any fashion.**
- *
- * @public
- * @alias module:lib/cli.lookupFiles
- * @param {string} filepath - Base path to start searching from.
- * @param {string[]} [extensions=[]] - File extensions to look for.
- * @param {boolean} [recursive=false] - Whether to recurse into subdirectories.
- * @return {string[]} An array of paths.
- * @throws {Error} if no files match pattern.
- * @throws {TypeError} if `filepath` is directory and `extensions` not provided.
- */
-module.exports = function lookupFiles(
-  filepath,
-  extensions = [],
-  recursive = false
-) {
-  const files = [];
-  let stat;
-
-  if (!fs.existsSync(filepath)) {
-    let pattern;
-    if (glob.hasMagic(filepath, {windowsPathsNoEscape: true})) {
-      // Handle glob as is without extensions
-      pattern = filepath;
-    } else {
-      // glob pattern e.g. 'filepath+(.js|.ts)'
-      const strExtensions = extensions
-        .map(ext => (ext.startsWith('.') ? ext : `.${ext}`))
-        .join('|');
-      pattern = `${filepath}+(${strExtensions})`;
-      debug('looking for files using glob pattern: %s', pattern);
-    }
-    files.push(
-      ...glob
-        .sync(pattern, {
-          nodir: true,
-          windowsPathsNoEscape: true
-        })
-        // glob@8 and earlier sorted results in en; glob@9 depends on OS sorting.
-        // This preserves the older glob behavior.
-        // https://github.com/mochajs/mocha/pull/5250/files#r1840469747
-        .sort((a, b) => a.localeCompare(b, 'en'))
-    );
-    if (!files.length) {
-      throw createNoFilesMatchPatternError(
-        `Cannot find any files matching pattern "${filepath}"`,
-        filepath
-      );
-    }
-    return files;
-  }
-
-  // Handle file
-  try {
-    stat = fs.statSync(filepath);
-    if (stat.isFile()) {
-      return filepath;
-    }
-  } catch (err) {
-    // ignore error
-    return;
-  }
-
-  // Handle directory
-  fs.readdirSync(filepath).forEach(dirent => {
-    const pathname = path.join(filepath, dirent);
-    let stat;
-
-    try {
-      stat = fs.statSync(pathname);
-      if (stat.isDirectory()) {
-        if (recursive) {
-          files.push(...lookupFiles(pathname, extensions, recursive));
-        }
-        return;
-      }
-    } catch (ignored) {
-      return;
-    }
-    if (!extensions.length) {
-      throw createMissingArgumentError(
-        `Argument '${extensions}' required when argument '${filepath}' is a directory`,
-        'extensions',
-        'array'
-      );
-    }
-
-    if (
-      !stat.isFile() ||
-      !hasMatchingExtname(pathname, extensions) ||
-      isHiddenOnUnix(pathname)
-    ) {
-      return;
-    }
-    files.push(pathname);
-  });
-
-  return files;
-};

package/packages/agentic-jujutsu/node_modules/mocha/lib/cli/node-flags.js

@@ -1,85 +0,0 @@
-'use strict';
-
-/**
- * Some settings and code related to Mocha's handling of Node.js/V8 flags.
- * @private
- * @module
- */
-
-const nodeFlags = process.allowedNodeEnvironmentFlags;
-const {isMochaFlag} = require('./run-option-metadata');
-const unparse = require('yargs-unparser');
-
-/**
- * These flags are considered "debug" flags.
- * @see {@link impliesNoTimeouts}
- * @private
- */
-const debugFlags = new Set(['inspect', 'inspect-brk']);
-
-/**
- * Mocha has historical support for various `node` and V8 flags which might not
- * appear in `process.allowedNodeEnvironmentFlags`.
- * These include:
- *   - `--preserve-symlinks`
- *   - `--harmony-*`
- *   - `--gc-global`
- *   - `--trace-*`
- *   - `--es-staging`
- *   - `--use-strict`
- *   - `--v8-*` (but *not* `--v8-options`)
- * @summary Whether or not to pass a flag along to the `node` executable.
- * @param {string} flag - Flag to test
- * @param {boolean} [bareword=true] - If `false`, we expect `flag` to have one or two leading dashes.
- * @returns {boolean} If the flag is considered a "Node" flag.
- * @private
- */
-exports.isNodeFlag = (flag, bareword = true) => {
-  if (!bareword) {
-    // check if the flag begins with dashes; if not, not a node flag.
-    if (!/^--?/.test(flag)) {
-      return false;
-    }
-    // strip the leading dashes to match against subsequent checks
-    flag = flag.replace(/^--?/, '');
-  }
-  return (
-    // check actual node flags from `process.allowedNodeEnvironmentFlags`,
-    // then historical support for various V8 and non-`NODE_OPTIONS` flags
-    // and also any V8 flags with `--v8-` prefix
-    (!isMochaFlag(flag) && nodeFlags && nodeFlags.has(flag)) ||
-    debugFlags.has(flag) ||
-    /(?:preserve-symlinks(?:-main)?|harmony(?:[_-]|$)|(?:trace[_-].+$)|gc[_-]global$|es[_-]staging$|use[_-]strict$|v8[_-](?!options).+?$)/.test(
-      flag
-    )
-  );
-};
-
-/**
- * Returns `true` if the flag is a "debug-like" flag.  These require timeouts
- * to be suppressed, or pausing the debugger on breakpoints will cause test failures.
- * @param {string} flag - Flag to test
- * @returns {boolean}
- * @private
- */
-exports.impliesNoTimeouts = flag => debugFlags.has(flag);
-
-/**
- * All non-strictly-boolean arguments to node--those with values--must specify those values using `=`, e.g., `--inspect=0.0.0.0`.
- * Unparse these arguments using `yargs-unparser` (which would result in `--inspect 0.0.0.0`), then supply `=` where we have values.
- * There's probably an easier or more robust way to do this; fixes welcome
- * @param {Object} opts - Arguments object
- * @returns {string[]} Unparsed arguments using `=` to specify values
- * @private
- */
-exports.unparseNodeFlags = opts => {
-  var args = unparse(opts);
-  return args.length
-    ? args
-        .join(' ')
-        .split(/\b/)
-        .map(arg => (arg === ' ' ? '=' : arg))
-        .join('')
-        .split(' ')
-    : [];
-};

package/packages/agentic-jujutsu/node_modules/mocha/lib/cli/one-and-dones.js

@@ -1,69 +0,0 @@
-'use strict';
-
-/**
- * Contains "command" code for "one-and-dones"--options passed
- * to Mocha which cause it to just dump some info and exit.
- * See {@link module:lib/cli/one-and-dones.ONE_AND_DONE_ARGS ONE_AND_DONE_ARGS} for more info.
- * @module
- * @private
- */
-
-const Mocha = require('../mocha');
-
-/**
- * Dumps a sorted list of the enumerable, lower-case keys of some object
- * to `STDOUT`.
- * @param {Object} obj - Object, ostensibly having some enumerable keys
- * @ignore
- * @private
- */
-const showKeys = obj => {
-  console.log();
-  const keys = Object.keys(obj);
-  const maxKeyLength = keys.reduce((max, key) => Math.max(max, key.length), 0);
-  keys
-    .filter(
-      key => /^[a-z]/.test(key) && !obj[key].browserOnly && !obj[key].abstract
-    )
-    .sort()
-    .forEach(key => {
-      const description = obj[key].description;
-      console.log(
-        `    ${key.padEnd(maxKeyLength + 1)}${
-          description ? `- ${description}` : ''
-        }`
-      );
-    });
-  console.log();
-};
-
-/**
- * Handlers for one-and-done options
- * @namespace
- * @private
- */
-exports.ONE_AND_DONES = {
-  /**
-   * Dump list of built-in interfaces
-   * @private
-   */
-  'list-interfaces': () => {
-    showKeys(Mocha.interfaces);
-  },
-  /**
-   * Dump list of built-in reporters
-   * @private
-   */
-  'list-reporters': () => {
-    showKeys(Mocha.reporters);
-  }
-};
-
-/**
- * A Set of all one-and-done options
- * @type Set<string>
- * @private
- */
-exports.ONE_AND_DONE_ARGS = new Set(
-  ['help', 'h', 'version', 'V'].concat(Object.keys(exports.ONE_AND_DONES))
-);

package/packages/agentic-jujutsu/node_modules/mocha/lib/cli/options.js

@@ -1,337 +0,0 @@
-'use strict';
-
-/**
- * Main entry point for handling filesystem-based configuration,
- * whether that's a config file or `package.json` or whatever.
- * @module lib/cli/options
- * @private
- */
-
-const fs = require('node:fs');
-const pc = require('picocolors');
-const yargsParser = require('yargs-parser');
-const {
-  types,
-  aliases,
-  isMochaFlag,
-  expectedTypeForFlag
-} = require('./run-option-metadata');
-const {ONE_AND_DONE_ARGS} = require('./one-and-dones');
-const mocharc = require('../mocharc.json');
-const {list} = require('./run-helpers');
-const {loadConfig, findConfig} = require('./config');
-const findUp = require('find-up');
-const debug = require('debug')('mocha:cli:options');
-const {isNodeFlag} = require('./node-flags');
-const {
-  createUnparsableFileError,
-  createInvalidArgumentTypeError,
-  createUnsupportedError
-} = require('../errors');
-const {isNumeric} = require('../utils');
-
-/**
- * The `yargs-parser` namespace
- * @external yargsParser
- * @see {@link https://npm.im/yargs-parser}
- */
-
-/**
- * An object returned by a configured `yargs-parser` representing arguments
- * @memberof external:yargsParser
- * @interface Arguments
- */
-
-/**
- * Base yargs parser configuration
- * @private
- */
-const YARGS_PARSER_CONFIG = {
-  'combine-arrays': true,
-  'short-option-groups': false,
-  'dot-notation': false,
-  'strip-aliased': true
-};
-
-/**
- * This is the config pulled from the `yargs` property of Mocha's
- * `package.json`, but it also disables camel case expansion as to
- * avoid outputting non-canonical keynames, as we need to do some
- * lookups.
- * @private
- * @ignore
- */
-const configuration = Object.assign({}, YARGS_PARSER_CONFIG, {
-  'camel-case-expansion': false
-});
-
-/**
- * This is a really fancy way to:
- * - `array`-type options: ensure unique values and evtl. split comma-delimited lists
- * - `boolean`/`number`/`string`- options: use last element when given multiple times
- * This is passed as the `coerce` option to `yargs-parser`
- * @private
- * @ignore
- */
-const globOptions = ['spec', 'ignore'];
-const coerceOpts = Object.assign(
-  types.array.reduce(
-    (acc, arg) =>
-      Object.assign(acc, {
-        [arg]: v => Array.from(new Set(globOptions.includes(arg) ? v : list(v)))
-      }),
-    {}
-  ),
-  types.boolean
-    .concat(types.string, types.number)
-    .reduce(
-      (acc, arg) =>
-        Object.assign(acc, {[arg]: v => (Array.isArray(v) ? v.pop() : v)}),
-      {}
-    )
-);
-
-/**
- * We do not have a case when multiple arguments are ever allowed after a flag
- * (e.g., `--foo bar baz quux`), so we fix the number of arguments to 1 across
- * the board of non-boolean options.
- * This is passed as the `narg` option to `yargs-parser`
- * @private
- * @ignore
- */
-const nargOpts = types.array
-  .concat(types.string, types.number)
-  .reduce((acc, arg) => Object.assign(acc, {[arg]: 1}), {});
-
-/**
- * Throws either "UNSUPPORTED" error or "INVALID_ARG_TYPE" error for numeric positional arguments.
- * @param {string[]} allArgs - Stringified args passed to mocha cli
- * @param {number} numericArg - Numeric positional arg for which error must be thrown
- * @param {Object} parsedResult - Result from `yargs-parser`
- * @private
- * @ignore
- */
-const createErrorForNumericPositionalArg = (
-  numericArg,
-  allArgs,
-  parsedResult
-) => {
-  // A flag for `numericArg` exists if:
-  // 1. A mocha flag immediately preceeded the numericArg in `allArgs` array and
-  // 2. `numericArg` value could not be assigned to this flag by `yargs-parser` because of incompatible datatype.
-  const flag = allArgs.find((arg, index) => {
-    const normalizedArg = arg.replace(/^--?/, '');
-    return (
-      isMochaFlag(arg) &&
-      allArgs[index + 1] === String(numericArg) &&
-      parsedResult[normalizedArg] !== String(numericArg)
-    );
-  });
-
-  if (flag) {
-    throw createInvalidArgumentTypeError(
-      `Mocha flag '${flag}' given invalid option: '${numericArg}'`,
-      numericArg,
-      expectedTypeForFlag(flag)
-    );
-  } else {
-    throw createUnsupportedError(
-      `Option ${numericArg} is unsupported by the mocha cli`
-    );
-  }
-};
-
-/**
- * Wrapper around `yargs-parser` which applies our settings
- * @param {string|string[]} args - Arguments to parse
- * @param {Object} defaultValues - Default values of mocharc.json
- * @param  {...Object} configObjects - `configObjects` for yargs-parser
- * @private
- * @ignore
- */
-const parse = (args = [], defaultValues = {}, ...configObjects) => {
-  // save node-specific args for special handling.
-  // 1. when these args have a "=" they should be considered to have values
-  // 2. if they don't, they are just boolean flags
-  // 3. to avoid explicitly defining the set of them, we tell yargs-parser they
-  //    are ALL boolean flags.
-  // 4. we can then reapply the values after yargs-parser is done.
-  const allArgs = Array.isArray(args) ? args : args.split(' ');
-  const nodeArgs = allArgs.reduce((acc, arg) => {
-    const pair = arg.split('=');
-    let flag = pair[0];
-    if (isNodeFlag(flag, false)) {
-      flag = flag.replace(/^--?/, '');
-      return acc.concat([[flag, arg.includes('=') ? pair[1] : true]]);
-    }
-    return acc;
-  }, []);
-
-  const result = yargsParser.detailed(args, {
-    configuration,
-    configObjects,
-    default: defaultValues,
-    coerce: coerceOpts,
-    narg: nargOpts,
-    alias: aliases,
-    string: types.string,
-    array: types.array,
-    number: types.number,
-    boolean: types.boolean.concat(nodeArgs.map(pair => pair[0]))
-  });
-  if (result.error) {
-    console.error(pc.red(`Error: ${result.error.message}`));
-    process.exit(1);
-  }
-
-  const numericPositionalArg = result.argv._.find(arg => isNumeric(arg));
-  if (numericPositionalArg) {
-    createErrorForNumericPositionalArg(
-      numericPositionalArg,
-      allArgs,
-      result.argv
-    );
-  }
-
-  // reapply "=" arg values from above
-  nodeArgs.forEach(([key, value]) => {
-    result.argv[key] = value;
-  });
-
-  return result.argv;
-};
-
-/**
- * Given path to config file in `args.config`, attempt to load & parse config file.
- * @param {Object} [args] - Arguments object
- * @param {string|boolean} [args.config] - Path to config file or `false` to skip
- * @public
- * @alias module:lib/cli.loadRc
- * @returns {external:yargsParser.Arguments|void} Parsed config, or nothing if `args.config` is `false`
- */
-const loadRc = (args = {}) => {
-  if (args.config !== false) {
-    const config = args.config || findConfig();
-    return config ? loadConfig(config) : {};
-  }
-};
-
-module.exports.loadRc = loadRc;
-
-/**
- * Given path to `package.json` in `args.package`, attempt to load config from `mocha` prop.
- * @param {Object} [args] - Arguments object
- * @param {string|boolean} [args.config] - Path to `package.json` or `false` to skip
- * @public
- * @alias module:lib/cli.loadPkgRc
- * @returns {external:yargsParser.Arguments|void} Parsed config, or nothing if `args.package` is `false`
- */
-const loadPkgRc = (args = {}) => {
-  let result;
-  if (args.package === false) {
-    return result;
-  }
-  result = {};
-  const filepath = args.package || findUp.sync(mocharc.package);
-  if (filepath) {
-    let configData;
-    try {
-      configData = fs.readFileSync(filepath, 'utf8');
-    } catch (err) {
-      // If `args.package` was explicitly specified, throw an error
-      if (filepath == args.package) {
-        throw createUnparsableFileError(
-          `Unable to read ${filepath}: ${err}`,
-          filepath
-        );
-      } else {
-        debug('failed to read default package.json at %s; ignoring',
-              filepath);
-        return result;
-      }
-    }
-    try {
-      const pkg = JSON.parse(configData);
-      if (pkg.mocha) {
-        debug('`mocha` prop of package.json parsed: %O', pkg.mocha);
-        result = pkg.mocha;
-      } else {
-        debug('no config found in %s', filepath);
-      }
-    } catch (err) {
-      // If JSON failed to parse, throw an error.
-      throw createUnparsableFileError(
-        `Unable to parse ${filepath}: ${err}`,
-        filepath
-      );
-    }
-  }
-  return result;
-};
-
-module.exports.loadPkgRc = loadPkgRc;
-
-/**
- * Priority list:
- *
- * 1. Command-line args
- * 2. `MOCHA_OPTIONS` environment variable.
- * 3. RC file (`.mocharc.c?js`, `.mocharc.ya?ml`, `mocharc.json`)
- * 4. `mocha` prop of `package.json`
- * 5. default configuration (`lib/mocharc.json`)
- *
- * If a {@link module:lib/cli/one-and-dones.ONE_AND_DONE_ARGS "one-and-done" option} is present in the `argv` array, no external config files will be read.
- * @summary Parses options read from `.mocharc.*` and `package.json`.
- * @param {string|string[]} [argv] - Arguments to parse
- * @public
- * @alias module:lib/cli.loadOptions
- * @returns {external:yargsParser.Arguments} Parsed args from everything
- */
-const loadOptions = (argv = []) => {
-  let args = parse(argv);
-  // short-circuit: look for a flag that would abort loading of options
-  if (
-    Array.from(ONE_AND_DONE_ARGS).reduce(
-      (acc, arg) => acc || arg in args,
-      false
-    )
-  ) {
-    return args;
-  }
-
-  const envConfig = parse(process.env.MOCHA_OPTIONS || '');
-  const rcConfig = loadRc(args);
-  const pkgConfig = loadPkgRc(args);
-
-  if (rcConfig) {
-    args.config = false;
-    args._ = args._.concat(rcConfig._ || []);
-  }
-  if (pkgConfig) {
-    args.package = false;
-    args._ = args._.concat(pkgConfig._ || []);
-  }
-
-  args = parse(
-    args._,
-    mocharc,
-    args,
-    envConfig,
-    rcConfig || {},
-    pkgConfig || {}
-  );
-
-  // recombine positional arguments and "spec"
-  if (args.spec) {
-    args._ = args._.concat(args.spec);
-    delete args.spec;
-  }
-
-  // make unique
-  args._ = Array.from(new Set(args._));
-
-  return args;
-};
-
-module.exports.loadOptions = loadOptions;
-module.exports.YARGS_PARSER_CONFIG = YARGS_PARSER_CONFIG;