claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/web/frontend/node_modules/.nanoid-PAMEV9Hd/index.js

@@ -1,45 +0,0 @@
-import crypto from 'crypto'
-import { urlAlphabet } from './url-alphabet/index.js'
-const POOL_SIZE_MULTIPLIER = 128
-let pool, poolOffset
-let fillPool = bytes => {
-  if (!pool || pool.length < bytes) {
-    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER)
-    crypto.randomFillSync(pool)
-    poolOffset = 0
-  } else if (poolOffset + bytes > pool.length) {
-    crypto.randomFillSync(pool)
-    poolOffset = 0
-  }
-  poolOffset += bytes
-}
-let random = bytes => {
-  fillPool((bytes |= 0))
-  return pool.subarray(poolOffset - bytes, poolOffset)
-}
-let customRandom = (alphabet, defaultSize, getRandom) => {
-  let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1
-  let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length)
-  return (size = defaultSize) => {
-    let id = ''
-    while (true) {
-      let bytes = getRandom(step)
-      let i = step
-      while (i--) {
-        id += alphabet[bytes[i] & mask] || ''
-        if (id.length === size) return id
-      }
-    }
-  }
-}
-let customAlphabet = (alphabet, size = 21) =>
-  customRandom(alphabet, size, random)
-let nanoid = (size = 21) => {
-  fillPool((size |= 0))
-  let id = ''
-  for (let i = poolOffset - size; i < poolOffset; i++) {
-    id += urlAlphabet[pool[i] & 63]
-  }
-  return id
-}
-export { nanoid, customAlphabet, customRandom, urlAlphabet, random }

package/dist/src/web/frontend/node_modules/.nanoid-PAMEV9Hd/nanoid.js

@@ -1 +0,0 @@
-export let nanoid=(t=21)=>crypto.getRandomValues(new Uint8Array(t)).reduce(((t,e)=>t+=(e&=63)<36?e.toString(36):e<62?(e-26).toString(36).toUpperCase():e<63?"_":"-"),"");

package/dist/src/web/frontend/node_modules/.nanoid-PAMEV9Hd/non-secure/index.js

@@ -1,21 +0,0 @@
-let urlAlphabet =
-  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
-let customAlphabet = (alphabet, defaultSize = 21) => {
-  return (size = defaultSize) => {
-    let id = ''
-    let i = size | 0
-    while (i--) {
-      id += alphabet[(Math.random() * alphabet.length) | 0]
-    }
-    return id
-  }
-}
-let nanoid = (size = 21) => {
-  let id = ''
-  let i = size | 0
-  while (i--) {
-    id += urlAlphabet[(Math.random() * 64) | 0]
-  }
-  return id
-}
-export { nanoid, customAlphabet }

package/dist/src/web/frontend/node_modules/.nanoid-PAMEV9Hd/url-alphabet/index.js

@@ -1,3 +0,0 @@
-let urlAlphabet =
-  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
-export { urlAlphabet }

package/dist/src/web/frontend/node_modules/.nodemon-QcvNKhKT/bin/nodemon.js

@@ -1,16 +0,0 @@
-#!/usr/bin/env node
-
-const cli = require('../lib/cli');
-const nodemon = require('../lib/');
-const options = cli.parse(process.argv);
-
-nodemon(options);
-
-const fs = require('fs');
-
-// checks for available update and returns an instance
-const pkg = JSON.parse(fs.readFileSync(__dirname + '/../package.json'));
-
-if (pkg.version.indexOf('0.0.0') !== 0 && options.noUpdateNotifier !== true) {
-  require('simple-update-notifier')({ pkg });
-}

package/dist/src/web/frontend/node_modules/.nodemon-QcvNKhKT/lib/cli/index.js

@@ -1,49 +0,0 @@
-var parse = require('./parse');
-
-/**
- * Converts a string to command line args, in particular
- * groups together quoted values.
- * This is a utility function to allow calling nodemon as a required
- * library, but with the CLI args passed in (instead of an object).
- *
- * @param  {String} string
- * @return {Array}
- */
-function stringToArgs(string) {
-  var args = [];
-
-  var parts = string.split(' ');
-  var length = parts.length;
-  var i = 0;
-  var open = false;
-  var grouped = '';
-  var lead = '';
-
-  for (; i < length; i++) {
-    lead = parts[i].substring(0, 1);
-    if (lead === '"' || lead === '\'') {
-      open = lead;
-      grouped = parts[i].substring(1);
-    } else if (open && parts[i].slice(-1) === open) {
-      open = false;
-      grouped += ' ' + parts[i].slice(0, -1);
-      args.push(grouped);
-    } else if (open) {
-      grouped += ' ' + parts[i];
-    } else {
-      args.push(parts[i]);
-    }
-  }
-
-  return args;
-}
-
-module.exports = {
-  parse: function (argv) {
-    if (typeof argv === 'string') {
-      argv = stringToArgs(argv);
-    }
-
-    return parse(argv);
-  },
-};

package/dist/src/web/frontend/node_modules/.nodemon-QcvNKhKT/lib/cli/parse.js

@@ -1,230 +0,0 @@
-/*
-
-nodemon is a utility for node, and replaces the use of the executable
-node. So the user calls `nodemon foo.js` instead.
-
-nodemon can be run in a number of ways:
-
-`nodemon` - tries to use package.json#main property to run
-`nodemon` - if no package, looks for index.js
-`nodemon app.js` - runs app.js
-`nodemon --arg app.js --apparg` - eats arg1, and runs app.js with apparg
-`nodemon --apparg` - as above, but passes apparg to package.json#main (or
-  index.js)
-`nodemon --debug app.js
-
-*/
-
-var fs = require('fs');
-var path = require('path');
-var existsSync = fs.existsSync || path.existsSync;
-
-module.exports = parse;
-
-/**
- * Parses the command line arguments `process.argv` and returns the
- * nodemon options, the user script and the executable script.
- *
- * @param  {Array<string> | string} argv full process arguments, including `node` leading arg
- * @return {Object} { options, script, args }
- */
-function parse(argv) {
-  if (typeof argv === 'string') {
-    argv = argv.split(' ');
-  }
-
-  var eat = function (i, args) {
-    if (i <= args.length) {
-      return args.splice(i + 1, 1).pop();
-    }
-  };
-
-  var args = argv.slice(2);
-  var script = null;
-  var nodemonOptions = { scriptPosition: null };
-
-  var nodemonOpt = nodemonOption.bind(null, nodemonOptions);
-  var lookForArgs = true;
-
-  // move forward through the arguments
-  for (var i = 0; i < args.length; i++) {
-    // if the argument looks like a file, then stop eating
-    if (!script) {
-      if (args[i] === '.' || existsSync(args[i])) {
-        script = args.splice(i, 1).pop();
-
-        // we capture the position of the script because we'll reinsert it in
-        // the right place in run.js:command (though I'm not sure we should even
-        // take it out of the array in the first place, but this solves passing
-        // arguments to the exec process for now).
-        nodemonOptions.scriptPosition = i;
-        i--;
-        continue;
-      }
-    }
-
-    if (lookForArgs) {
-      // respect the standard way of saying: hereafter belongs to my script
-      if (args[i] === '--') {
-        args.splice(i, 1);
-        nodemonOptions.scriptPosition = i;
-        // cycle back one argument, as we just ate this one up
-        i--;
-
-        // ignore all further nodemon arguments
-        lookForArgs = false;
-
-        // move to the next iteration
-        continue;
-      }
-
-      if (nodemonOpt(args[i], eat.bind(null, i, args)) !== false) {
-        args.splice(i, 1);
-        // cycle back one argument, as we just ate this one up
-        i--;
-      }
-    }
-  }
-
-  nodemonOptions.script = script;
-  nodemonOptions.args = args;
-
-  return nodemonOptions;
-}
-
-
-/**
- * Given an argument (ie. from process.argv), sets nodemon
- * options and can eat up the argument value
- *
- * @param {import('../..').NodemonSettings} options object that will be updated
- * @param {String} arg current argument from argv
- * @param {Function} eatNext the callback to eat up the next argument in argv
- * @return {Boolean} false if argument was not a nodemon arg
- */
-function nodemonOption(options, arg, eatNext) {
-  // line separation on purpose to help legibility
-  if (arg === '--help' || arg === '-h' || arg === '-?') {
-    var help = eatNext();
-    options.help = help ? help : true;
-  } else
-
-  if (arg === '--version' || arg === '-v') {
-    options.version = true;
-  } else
-
-  if (arg === '--no-update-notifier') {
-    options.noUpdateNotifier = true;
-  } else
-
-  if (arg === '--spawn') {
-    options.spawn = true;
-  } else
-
-  if (arg === '--dump') {
-    options.dump = true;
-  } else
-
-  if (arg === '--verbose' || arg === '-V') {
-    options.verbose = true;
-  } else
-
-  if (arg === '--legacy-watch' || arg === '-L') {
-    options.legacyWatch = true;
-  } else
-
-  if (arg === '--polling-interval' || arg === '-P') {
-    options.pollingInterval = parseInt(eatNext(), 10);
-  } else
-
-  // Depricated as this is "on" by default
-  if (arg === '--js') {
-    options.js = true;
-  } else
-
-  if (arg === '--quiet' || arg === '-q') {
-    options.quiet = true;
-  } else
-
-  if (arg === '--config') {
-    options.configFile = eatNext();
-  } else
-
-  if (arg === '--watch' || arg === '-w') {
-    if (!options.watch) { options.watch = []; }
-    options.watch.push(eatNext());
-  } else
-
-  if (arg === '--ignore' || arg === '-i') {
-    if (!options.ignore) { options.ignore = []; }
-    options.ignore.push(eatNext());
-  } else
-
-  if (arg === '--exitcrash') {
-    options.exitCrash = true;
-  } else
-
-  if (arg === '--delay' || arg === '-d') {
-    options.delay = parseDelay(eatNext());
-  } else
-
-  if (arg === '--exec' || arg === '-x') {
-    options.exec = eatNext();
-  } else
-
-  if (arg === '--no-stdin' || arg === '-I') {
-    options.stdin = false;
-  } else
-
-  if (arg === '--on-change-only' || arg === '-C') {
-    options.runOnChangeOnly = true;
-  } else
-
-  if (arg === '--ext' || arg === '-e') {
-    options.ext = eatNext();
-  } else
-
-  if (arg === '--no-colours' || arg === '--no-colors') {
-    options.colours = false;
-  } else
-
-  if (arg === '--signal' || arg === '-s') {
-    options.signal = eatNext();
-  } else
-
-  if (arg === '--cwd') {
-    options.cwd = eatNext();
-
-    // go ahead and change directory. This is primarily for nodemon tools like
-    // grunt-nodemon - we're doing this early because it will affect where the
-    // user script is searched for.
-    process.chdir(path.resolve(options.cwd));
-  } else {
-
-    // this means we didn't match
-    return false;
-  }
-}
-
-/**
- * Given an argument (ie. from nodemonOption()), will parse and return the
- * equivalent millisecond value or 0 if the argument cannot be parsed
- *
- * @param {String} value argument value given to the --delay option
- * @return {Number} millisecond equivalent of the argument
- */
-function parseDelay(value) {
-  var millisPerSecond = 1000;
-  var millis = 0;
-
-  if (value.match(/^\d*ms$/)) {
-    // Explicitly parse for milliseconds when using ms time specifier
-    millis = parseInt(value, 10);
-  } else {
-    // Otherwise, parse for seconds, with or without time specifier then convert
-    millis = parseFloat(value) * millisPerSecond;
-  }
-
-  return isNaN(millis) ? 0 : millis;
-}
-

package/dist/src/web/frontend/node_modules/.nodemon-QcvNKhKT/lib/config/command.js

@@ -1,43 +0,0 @@
-module.exports = command;
-
-/**
- * command constructs the executable command to run in a shell including the
- * user script, the command arguments.
- *
- * @param  {Object} settings Object as:
- *                           { execOptions: {
- *                               exec: String,
- *                               [script: String],
- *                               [scriptPosition: Number],
- *                               [execArgs: Array<string>]
- *                             }
- *                           }
- * @return {Object}          an object with the node executable and the
- *                           arguments to the command
- */
-function command(settings) {
-  var options = settings.execOptions;
-  var executable = options.exec;
-  var args = [];
-
-  // after "executable" go the exec args (like --debug, etc)
-  if (options.execArgs) {
-    [].push.apply(args, options.execArgs);
-  }
-
-  // then goes the user's script arguments
-  if (options.args) {
-    [].push.apply(args, options.args);
-  }
-
-  // after the "executable" goes the user's script
-  if (options.script) {
-    args.splice((options.scriptPosition || 0) +
-      options.execArgs.length, 0, options.script);
-  }
-
-  return {
-    executable: executable,
-    args: args,
-  };
-}

package/dist/src/web/frontend/node_modules/.nodemon-QcvNKhKT/lib/config/defaults.js

@@ -1,34 +0,0 @@
-var ignoreRoot = require('ignore-by-default').directories();
-
-// default options for config.options
-const defaults = {
-  restartable: 'rs',
-  colours: true,
-  execMap: {
-    py: 'python',
-    rb: 'ruby',
-    ts: 'ts-node',
-    // more can be added here such as ls: lsc - but please ensure it's cross
-    // compatible with linux, mac and windows, or make the default.js
-    // dynamically append the `.cmd` for node based utilities
-  },
-  ignoreRoot: ignoreRoot.map((_) => `**/${_}/**`),
-  watch: ['*.*'],
-  stdin: true,
-  runOnChangeOnly: false,
-  verbose: false,
-  signal: 'SIGUSR2',
-  // 'stdout' refers to the default behaviour of a required nodemon's child,
-  // but also includes stderr. If this is false, data is still dispatched via
-  // nodemon.on('stdout/stderr')
-  stdout: true,
-  watchOptions: {},
-};
-
-const nodeOptions = process.env.NODE_OPTIONS || ''; // ?
-
-if (/--(loader|import)\b/.test(nodeOptions)) {
-  delete defaults.execMap.ts;
-}
-
-module.exports = defaults;

package/dist/src/web/frontend/node_modules/.nodemon-QcvNKhKT/lib/config/exec.js

@@ -1,234 +0,0 @@
-const path = require('path');
-const fs = require('fs');
-const existsSync = fs.existsSync;
-const utils = require('../utils');
-
-module.exports = exec;
-module.exports.expandScript = expandScript;
-
-/**
- * Reads the cwd/package.json file and looks to see if it can load a script
- * and possibly an exec first from package.main, then package.start.
- *
- * @return {Object} exec & script if found
- */
-function execFromPackage() {
-  // doing a try/catch because we can't use the path.exist callback pattern
-  // or we could, but the code would get messy, so this will do exactly
-  // what we're after - if the file doesn't exist, it'll throw.
-  try {
-    // note: this isn't nodemon's package, it's the user's cwd package
-    var pkg = require(path.join(process.cwd(), 'package.json'));
-    if (pkg.main !== undefined) {
-      // no app found to run - so give them a tip and get the feck out
-      return { exec: null, script: pkg.main };
-    }
-
-    if (pkg.scripts && pkg.scripts.start) {
-      return { exec: pkg.scripts.start };
-    }
-  } catch (e) {}
-
-  return null;
-}
-
-function replace(map, str) {
-  var re = new RegExp('{{(' + Object.keys(map).join('|') + ')}}', 'g');
-  return str.replace(re, function (all, m) {
-    return map[m] || all || '';
-  });
-}
-
-function expandScript(script, ext) {
-  if (!ext) {
-    ext = '.js';
-  }
-  if (script.indexOf(ext) !== -1) {
-    return script;
-  }
-
-  if (existsSync(path.resolve(script))) {
-    return script;
-  }
-
-  if (existsSync(path.resolve(script + ext))) {
-    return script + ext;
-  }
-
-  return script;
-}
-
-/**
- * Discovers all the options required to run the script
- * and if a custom exec has been passed in, then it will
- * also try to work out what extensions to monitor and
- * whether there's a special way of running that script.
- *
- * @param  {Object} nodemonOptions
- * @param  {Object} execMap
- * @return {Object} new and updated version of nodemonOptions
- */
-function exec(nodemonOptions, execMap) {
-  if (!execMap) {
-    execMap = {};
-  }
-
-  var options = utils.clone(nodemonOptions || {});
-  var script;
-
-  // if there's no script passed, try to get it from the first argument
-  if (!options.script && (options.args || []).length) {
-    script = expandScript(
-      options.args[0],
-      options.ext && '.' + (options.ext || 'js').split(',')[0]
-    );
-
-    // if the script was found, shift it off our args
-    if (script !== options.args[0]) {
-      options.script = script;
-      options.args.shift();
-    }
-  }
-
-  // if there's no exec found yet, then try to read it from the local
-  // package.json this logic used to sit in the cli/parse, but actually the cli
-  // should be parsed first, then the user options (via nodemon.json) then
-  // finally default down to pot shots at the directory via package.json
-  if (!options.exec && !options.script) {
-    var found = execFromPackage();
-    if (found !== null) {
-      if (found.exec) {
-        options.exec = found.exec;
-      }
-      if (!options.script) {
-        options.script = found.script;
-      }
-      if (Array.isArray(options.args) && options.scriptPosition === null) {
-        options.scriptPosition = options.args.length;
-      }
-    }
-  }
-
-  // var options = utils.clone(nodemonOptions || {});
-  script = path.basename(options.script || '');
-
-  var scriptExt = path.extname(script).slice(1);
-
-  var extension = options.ext;
-  if (extension === undefined) {
-    var isJS = scriptExt === 'js' || scriptExt === 'mjs' || scriptExt === 'cjs';
-    extension = isJS || !scriptExt ? 'js,mjs,cjs' : scriptExt;
-    extension += ',json'; // Always watch JSON files
-  }
-
-  var execDefined = !!options.exec;
-
-  // allows the user to simplify cli usage:
-  // https://github.com/remy/nodemon/issues/195
-  // but always give preference to the user defined argument
-  if (!options.exec && execMap[scriptExt] !== undefined) {
-    options.exec = execMap[scriptExt];
-    execDefined = true;
-  }
-
-  options.execArgs = nodemonOptions.execArgs || [];
-
-  if (Array.isArray(options.exec)) {
-    options.execArgs = options.exec;
-    options.exec = options.execArgs.shift();
-  }
-
-  if (options.exec === undefined) {
-    options.exec = 'node';
-  } else {
-    // allow variable substitution for {{filename}} and {{pwd}}
-    var substitution = replace.bind(null, {
-      filename: options.script,
-      pwd: process.cwd(),
-    });
-
-    var newExec = substitution(options.exec);
-    if (
-      newExec !== options.exec &&
-      options.exec.indexOf('{{filename}}') !== -1
-    ) {
-      options.script = null;
-    }
-    options.exec = newExec;
-
-    var newExecArgs = options.execArgs.map(substitution);
-    if (newExecArgs.join('') !== options.execArgs.join('')) {
-      options.execArgs = newExecArgs;
-      delete options.script;
-    }
-  }
-
-  if (options.exec === 'node' && options.nodeArgs && options.nodeArgs.length) {
-    options.execArgs = options.execArgs.concat(options.nodeArgs);
-  }
-
-  // note: indexOf('coffee') handles both .coffee and .litcoffee
-  if (
-    !execDefined &&
-    options.exec === 'node' &&
-    scriptExt.indexOf('coffee') !== -1
-  ) {
-    options.exec = 'coffee';
-
-    // we need to get execArgs set before the script
-    // for example, in `nodemon --debug my-script.coffee --my-flag`, debug is an
-    // execArg, while my-flag is a script arg
-    var leadingArgs = (options.args || []).splice(0, options.scriptPosition);
-    options.execArgs = options.execArgs.concat(leadingArgs);
-    options.scriptPosition = 0;
-
-    if (options.execArgs.length > 0) {
-      // because this is the coffee executable, we need to combine the exec args
-      // into a single argument after the nodejs flag
-      options.execArgs = ['--nodejs', options.execArgs.join(' ')];
-    }
-  }
-
-  if (options.exec === 'coffee') {
-    // don't override user specified extension tracking
-    if (options.ext === undefined) {
-      if (extension) {
-        extension += ',';
-      }
-      extension += 'coffee,litcoffee';
-    }
-
-    // because windows can't find 'coffee', it needs the real file 'coffee.cmd'
-    if (utils.isWindows) {
-      options.exec += '.cmd';
-    }
-  }
-
-  // allow users to make a mistake on the extension to monitor
-  // converts .js, pug => js,pug
-  // BIG NOTE: user can't do this: nodemon -e *.js
-  // because the terminal will automatically expand the glob against
-  // the file system :(
-  extension = (extension.match(/[^,*\s]+/g) || [])
-    .map((ext) => ext.replace(/^\./, ''))
-    .join(',');
-
-  options.ext = extension;
-
-  if (options.script) {
-    options.script = expandScript(
-      options.script,
-      extension && '.' + extension.split(',')[0]
-    );
-  }
-
-  options.env = {};
-  // make sure it's an object (and since we don't have )
-  if ({}.toString.apply(nodemonOptions.env) === '[object Object]') {
-    options.env = utils.clone(nodemonOptions.env);
-  } else if (nodemonOptions.env !== undefined) {
-    throw new Error('nodemon env values must be an object: { PORT: 8000 }');
-  }
-
-  return options;
-}