claude-flow-novice 2.2.1 → 2.2.3

package/dist/src/web/frontend/node_modules/.lint-staged-PLgU0Zyn/lib/state.js

@@ -0,0 +1,72 @@
+import EventEmitter from 'events'
+
+import { GIT_ERROR, TASK_ERROR } from './messages.js'
+import {
+  GitError,
+  RestoreOriginalStateError,
+  RestoreUnstagedChangesError,
+  TaskError,
+} from './symbols.js'
+
+export const getInitialState = ({ quiet = false } = {}) => ({
+  hasPartiallyStagedFiles: null,
+  shouldBackup: null,
+  backupHash: null,
+  shouldHidePartiallyStaged: true,
+  errors: new Set([]),
+  events: new EventEmitter(),
+  output: [],
+  quiet,
+})
+
+export const shouldHidePartiallyStagedFiles = (ctx) =>
+  ctx.hasPartiallyStagedFiles && ctx.shouldHidePartiallyStaged
+
+export const applyModificationsSkipped = (ctx) => {
+  // Always apply back unstaged modifications when skipping backup
+  if (!ctx.shouldBackup) return false
+  // Should be skipped in case of git errors
+  if (ctx.errors.has(GitError)) {
+    return GIT_ERROR
+  }
+  // Should be skipped when tasks fail
+  if (ctx.errors.has(TaskError)) {
+    return TASK_ERROR
+  }
+}
+
+export const restoreUnstagedChangesSkipped = (ctx) => {
+  // Should be skipped in case of git errors
+  if (ctx.errors.has(GitError)) {
+    return GIT_ERROR
+  }
+
+  // Should be skipped when tasks fail
+  if (ctx.errors.has(TaskError)) {
+    return TASK_ERROR
+  }
+}
+
+export const restoreOriginalStateEnabled = (ctx) =>
+  ctx.shouldBackup && (ctx.errors.has(TaskError) || ctx.errors.has(RestoreUnstagedChangesError))
+
+export const restoreOriginalStateSkipped = (ctx) => {
+  // Should be skipped in case of unknown git errors
+  if (ctx.errors.has(GitError) && !ctx.errors.has(RestoreUnstagedChangesError)) {
+    return GIT_ERROR
+  }
+}
+
+export const cleanupEnabled = (ctx) => ctx.shouldBackup
+
+export const cleanupSkipped = (ctx) => {
+  // Should be skipped in case of unknown git errors
+  if (restoreOriginalStateSkipped(ctx)) {
+    return GIT_ERROR
+  }
+
+  // Should be skipped when reverting to original state fails
+  if (ctx.errors.has(RestoreOriginalStateError)) {
+    return GIT_ERROR
+  }
+}

package/dist/src/web/frontend/node_modules/.lint-staged-PLgU0Zyn/lib/symbols.js

@@ -0,0 +1,27 @@
+export const ApplyEmptyCommitError = Symbol('ApplyEmptyCommitError')
+
+export const ConfigNotFoundError = new Error('Configuration could not be found')
+
+export const ConfigFormatError = new Error('Configuration should be an object or a function')
+
+export const ConfigEmptyError = new Error('Configuration should not be empty')
+
+export const GetBackupStashError = Symbol('GetBackupStashError')
+
+export const GetStagedFilesError = Symbol('GetStagedFilesError')
+
+export const GitError = Symbol('GitError')
+
+export const GitRepoError = Symbol('GitRepoError')
+
+export const HideUnstagedChangesError = Symbol('HideUnstagedChangesError')
+
+export const InvalidOptionsError = new Error('Invalid Options')
+
+export const RestoreMergeStatusError = Symbol('RestoreMergeStatusError')
+
+export const RestoreOriginalStateError = Symbol('RestoreOriginalStateError')
+
+export const RestoreUnstagedChangesError = Symbol('RestoreUnstagedChangesError')
+
+export const TaskError = Symbol('TaskError')

package/dist/src/web/frontend/node_modules/.lint-staged-PLgU0Zyn/lib/validateBraces.js

@@ -0,0 +1,91 @@
+import { incorrectBraces } from './messages.js'
+
+/**
+ * A correctly-formed brace expansion must contain unquoted opening and closing braces,
+ * and at least one unquoted comma or a valid sequence expression.
+ * Any incorrectly formed brace expansion is left unchanged.
+ *
+ * @see https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html
+ *
+ * Lint-staged uses `micromatch` for brace expansion, and its behavior is to treat
+ * invalid brace expansions as literal strings, which means they (typically) do not match
+ * anything.
+ *
+ * This RegExp tries to match most cases of invalid brace expansions, so that they can be
+ * detected, warned about, and re-formatted by removing the braces and thus hopefully
+ * matching the files as intended by the user. The only real fix is to remove the incorrect
+ * braces from user configuration, but this is left to the user (after seeing the warning).
+ *
+ * @example <caption>Globs with brace expansions</caption>
+ * - *.{js,tx}        // expanded as *.js, *.ts
+ * - *.{{j,t}s,css}   // expanded as *.js, *.ts, *.css
+ * - file_{1..10}.css  // expanded as file_1.css, file_2.css, …, file_10.css
+ *
+ * @example <caption>Globs with incorrect brace expansions</caption>
+ * - *.{js}       // should just be *.js
+ * - *.{js,{ts}}  // should just be *.{js,ts}
+ * - *.\{js\}     // escaped braces, so they're treated literally
+ * - *.${js}      // dollar-sign inhibits expansion, so treated literally
+ * - *.{js\,ts}   // the comma is escaped, so treated literally
+ */
+export const INCORRECT_BRACES_REGEXP = /(?<![\\$])({)(?:(?!(?<!\\),|\.\.|\{|\}).)*?(?<!\\)(})/g
+
+/**
+ * @param {string} pattern
+ * @returns {string}
+ */
+const stripIncorrectBraces = (pattern) => {
+  let output = `${pattern}`
+  let match = null
+
+  while ((match = INCORRECT_BRACES_REGEXP.exec(pattern))) {
+    const fullMatch = match[0]
+    const withoutBraces = fullMatch.replace(/{/, '').replace(/}/, '')
+    output = output.replace(fullMatch, withoutBraces)
+  }
+
+  return output
+}
+
+/**
+ * This RegExp matches "duplicate" opening and closing braces, without any other braces
+ * in between, where the duplication is redundant and should be removed.
+ *
+ * @example *.{{js,ts}}  // should just be *.{js,ts}
+ */
+export const DOUBLE_BRACES_REGEXP = /{{[^}{]*}}/
+
+/**
+ * @param {string} pattern
+ * @returns {string}
+ */
+const stripDoubleBraces = (pattern) => {
+  let output = `${pattern}`
+  const match = DOUBLE_BRACES_REGEXP.exec(pattern)?.[0]
+
+  if (match) {
+    const withoutBraces = match.replace('{{', '{').replace('}}', '}')
+    output = output.replace(match, withoutBraces)
+  }
+
+  return output
+}
+
+/**
+ * Validate and remove incorrect brace expansions from glob pattern.
+ * For example `*.{js}` is incorrect because it doesn't contain a `,` or `..`,
+ * and will be reformatted as `*.js`.
+ *
+ * @param {string} pattern the glob pattern
+ * @param {*} logger
+ * @returns {string}
+ */
+export const validateBraces = (pattern, logger) => {
+  const fixedPattern = stripDoubleBraces(stripIncorrectBraces(pattern))
+
+  if (fixedPattern !== pattern) {
+    logger.warn(incorrectBraces(pattern, fixedPattern))
+  }
+
+  return fixedPattern
+}

package/dist/src/web/frontend/node_modules/.lint-staged-PLgU0Zyn/lib/validateConfig.js

@@ -0,0 +1,121 @@
+/** @typedef {import('./index').Logger} Logger */
+
+import { inspect } from 'node:util'
+
+import debug from 'debug'
+
+import { configurationError, failedToParseConfig } from './messages.js'
+import { ConfigEmptyError, ConfigFormatError } from './symbols.js'
+import { validateBraces } from './validateBraces.js'
+
+const debugLog = debug('lint-staged:validateConfig')
+
+const isObject = (test) => test && typeof test === 'object' && !Array.isArray(test)
+
+const TEST_DEPRECATED_KEYS = new Map([
+  ['concurrent', (key) => typeof key === 'boolean'],
+  ['chunkSize', (key) => typeof key === 'number'],
+  ['globOptions', isObject],
+  ['linters', isObject],
+  ['ignore', (key) => Array.isArray(key)],
+  ['subTaskConcurrency', (key) => typeof key === 'number'],
+  ['renderer', (key) => typeof key === 'string'],
+  ['relative', (key) => typeof key === 'boolean'],
+])
+
+export const validateConfigLogic = (config, configPath, logger) => {
+  debugLog('Validating config from `%s`...', configPath)
+
+  if (!config || (typeof config !== 'object' && typeof config !== 'function')) {
+    throw ConfigFormatError
+  }
+
+  /**
+   * Function configurations receive all staged files as their argument.
+   * They are not further validated here to make sure the function gets
+   * evaluated only once.
+   *
+   * @see makeCmdTasks
+   */
+  if (typeof config === 'function') {
+    return { '*': config }
+  }
+
+  if (Object.entries(config).length === 0) {
+    throw ConfigEmptyError
+  }
+
+  const errors = []
+
+  /**
+   * Create a new validated config because the keys (patterns) might change.
+   * Since the Object.reduce method already loops through each entry in the config,
+   * it can be used for validating the values at the same time.
+   */
+  const validatedConfig = Object.entries(config).reduce((collection, [pattern, task]) => {
+    /** Versions < 9 had more complex configuration options that are no longer supported. */
+    if (TEST_DEPRECATED_KEYS.has(pattern)) {
+      const testFn = TEST_DEPRECATED_KEYS.get(pattern)
+      if (testFn(task)) {
+        errors.push(
+          configurationError(pattern, 'Advanced configuration has been deprecated.', task)
+        )
+      }
+
+      /** Return early for deprecated keys to skip validating their (deprecated) values */
+      return collection
+    }
+
+    if (
+      (!Array.isArray(task) ||
+        task.some((item) => typeof item !== 'string' && typeof item !== 'function')) &&
+      typeof task !== 'string' &&
+      typeof task !== 'function'
+    ) {
+      errors.push(
+        configurationError(
+          pattern,
+          'Should be a string, a function, or an array of strings and functions.',
+          task
+        )
+      )
+    }
+
+    /**
+     * A typical configuration error is using invalid brace expansion, like `*.{js}`.
+     * These are automatically fixed and warned about.
+     */
+    const fixedPattern = validateBraces(pattern, logger)
+
+    return Object.assign(collection, { [fixedPattern]: task })
+  }, {})
+
+  if (errors.length) {
+    const message = errors.join('\n\n')
+
+    logger.error(failedToParseConfig(configPath, message))
+
+    throw new Error(message)
+  }
+
+  debugLog('Validated config from `%s`:', configPath)
+  debugLog(inspect(config, { compact: false }))
+
+  return validatedConfig
+}
+
+/**
+ * Runs config validation. Throws error if the config is not valid.
+ * @param {Object} config
+ * @param {string} configPath
+ * @param {Logger} logger
+ * @returns {Object} config
+ */
+export const validateConfig = (config, configPath, logger) => {
+  try {
+    return validateConfigLogic(config, configPath, logger)
+  } catch (error) {
+    logger.error(failedToParseConfig(configPath, error))
+    throw error
+  }
+}

package/dist/src/web/frontend/node_modules/.lint-staged-PLgU0Zyn/lib/validateOptions.js

@@ -0,0 +1,47 @@
+import { constants } from 'node:fs'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+import debug from 'debug'
+
+import { invalidOption } from './messages.js'
+import { InvalidOptionsError } from './symbols.js'
+
+const debugLog = debug('lint-staged:validateOptions')
+
+/**
+ * Validate lint-staged options, either from the Node.js API or the command line flags.
+ * @param {*} options
+ * @param {boolean|string} [options.cwd] - Current working directory
+ * @param {boolean|string} [options.shell] - Skip parsing of tasks for better shell support
+ *
+ * @throws {InvalidOptionsError}
+ */
+export const validateOptions = async (options = {}, logger) => {
+  debugLog('Validating options...')
+
+  /** Ensure the passed cwd option exists; it might also be relative */
+  if (typeof options.cwd === 'string') {
+    try {
+      const resolved = path.resolve(options.cwd)
+      await fs.access(resolved, constants.F_OK)
+    } catch (error) {
+      debugLog('Failed to validate options: %o', options)
+      logger.error(invalidOption('cwd', options.cwd, error.message))
+      throw InvalidOptionsError
+    }
+  }
+
+  /** Ensure the passed shell option is executable */
+  if (typeof options.shell === 'string') {
+    try {
+      await fs.access(options.shell, constants.X_OK)
+    } catch (error) {
+      debugLog('Failed to validate options: %o', options)
+      logger.error(invalidOption('shell', options.shell, error.message))
+      throw InvalidOptionsError
+    }
+  }
+
+  debugLog('Validated options: %o', options)
+}

package/dist/src/web/frontend/node_modules/.lint-staged-PLgU0Zyn/lib/version.js

@@ -0,0 +1,6 @@
+import fs from 'node:fs/promises'
+
+export const getVersion = async () => {
+  const packageJson = JSON.parse(await fs.readFile(new URL('../package.json', import.meta.url)))
+  return packageJson.version
+}

package/dist/src/web/frontend/node_modules/.lint-staged-PLgU0Zyn/node_modules/chalk/source/index.js

@@ -0,0 +1,225 @@
+import ansiStyles from '#ansi-styles';
+import supportsColor from '#supports-color';
+import { // eslint-disable-line import/order
+	stringReplaceAll,
+	stringEncaseCRLFWithFirstIndex,
+} from './utilities.js';
+
+const {stdout: stdoutColor, stderr: stderrColor} = supportsColor;
+
+const GENERATOR = Symbol('GENERATOR');
+const STYLER = Symbol('STYLER');
+const IS_EMPTY = Symbol('IS_EMPTY');
+
+// `supportsColor.level` → `ansiStyles.color[name]` mapping
+const levelMapping = [
+	'ansi',
+	'ansi',
+	'ansi256',
+	'ansi16m',
+];
+
+const styles = Object.create(null);
+
+const applyOptions = (object, options = {}) => {
+	if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+		throw new Error('The `level` option should be an integer from 0 to 3');
+	}
+
+	// Detect level if not set manually
+	const colorLevel = stdoutColor ? stdoutColor.level : 0;
+	object.level = options.level === undefined ? colorLevel : options.level;
+};
+
+export class Chalk {
+	constructor(options) {
+		// eslint-disable-next-line no-constructor-return
+		return chalkFactory(options);
+	}
+}
+
+const chalkFactory = options => {
+	const chalk = (...strings) => strings.join(' ');
+	applyOptions(chalk, options);
+
+	Object.setPrototypeOf(chalk, createChalk.prototype);
+
+	return chalk;
+};
+
+function createChalk(options) {
+	return chalkFactory(options);
+}
+
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+
+for (const [styleName, style] of Object.entries(ansiStyles)) {
+	styles[styleName] = {
+		get() {
+			const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+			Object.defineProperty(this, styleName, {value: builder});
+			return builder;
+		},
+	};
+}
+
+styles.visible = {
+	get() {
+		const builder = createBuilder(this, this[STYLER], true);
+		Object.defineProperty(this, 'visible', {value: builder});
+		return builder;
+	},
+};
+
+const getModelAnsi = (model, level, type, ...arguments_) => {
+	if (model === 'rgb') {
+		if (level === 'ansi16m') {
+			return ansiStyles[type].ansi16m(...arguments_);
+		}
+
+		if (level === 'ansi256') {
+			return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_));
+		}
+
+		return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_));
+	}
+
+	if (model === 'hex') {
+		return getModelAnsi('rgb', level, type, ...ansiStyles.hexToRgb(...arguments_));
+	}
+
+	return ansiStyles[type][model](...arguments_);
+};
+
+const usedModels = ['rgb', 'hex', 'ansi256'];
+
+for (const model of usedModels) {
+	styles[model] = {
+		get() {
+			const {level} = this;
+			return function (...arguments_) {
+				const styler = createStyler(getModelAnsi(model, levelMapping[level], 'color', ...arguments_), ansiStyles.color.close, this[STYLER]);
+				return createBuilder(this, styler, this[IS_EMPTY]);
+			};
+		},
+	};
+
+	const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
+	styles[bgModel] = {
+		get() {
+			const {level} = this;
+			return function (...arguments_) {
+				const styler = createStyler(getModelAnsi(model, levelMapping[level], 'bgColor', ...arguments_), ansiStyles.bgColor.close, this[STYLER]);
+				return createBuilder(this, styler, this[IS_EMPTY]);
+			};
+		},
+	};
+}
+
+const proto = Object.defineProperties(() => {}, {
+	...styles,
+	level: {
+		enumerable: true,
+		get() {
+			return this[GENERATOR].level;
+		},
+		set(level) {
+			this[GENERATOR].level = level;
+		},
+	},
+});
+
+const createStyler = (open, close, parent) => {
+	let openAll;
+	let closeAll;
+	if (parent === undefined) {
+		openAll = open;
+		closeAll = close;
+	} else {
+		openAll = parent.openAll + open;
+		closeAll = close + parent.closeAll;
+	}
+
+	return {
+		open,
+		close,
+		openAll,
+		closeAll,
+		parent,
+	};
+};
+
+const createBuilder = (self, _styler, _isEmpty) => {
+	// Single argument is hot path, implicit coercion is faster than anything
+	// eslint-disable-next-line no-implicit-coercion
+	const builder = (...arguments_) => applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));
+
+	// We alter the prototype because we must return a function, but there is
+	// no way to create a function with a different prototype
+	Object.setPrototypeOf(builder, proto);
+
+	builder[GENERATOR] = self;
+	builder[STYLER] = _styler;
+	builder[IS_EMPTY] = _isEmpty;
+
+	return builder;
+};
+
+const applyStyle = (self, string) => {
+	if (self.level <= 0 || !string) {
+		return self[IS_EMPTY] ? '' : string;
+	}
+
+	let styler = self[STYLER];
+
+	if (styler === undefined) {
+		return string;
+	}
+
+	const {openAll, closeAll} = styler;
+	if (string.includes('\u001B')) {
+		while (styler !== undefined) {
+			// Replace any instances already present with a re-opening code
+			// otherwise only the part of the string until said closing code
+			// will be colored, and the rest will simply be 'plain'.
+			string = stringReplaceAll(string, styler.close, styler.open);
+
+			styler = styler.parent;
+		}
+	}
+
+	// We can move both next actions out of loop, because remaining actions in loop won't have
+	// any/visible effect on parts we add here. Close the styling before a linebreak and reopen
+	// after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92
+	const lfIndex = string.indexOf('\n');
+	if (lfIndex !== -1) {
+		string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+	}
+
+	return openAll + string + closeAll;
+};
+
+Object.defineProperties(createChalk.prototype, styles);
+
+const chalk = createChalk();
+export const chalkStderr = createChalk({level: stderrColor ? stderrColor.level : 0});
+
+export {
+	modifierNames,
+	foregroundColorNames,
+	backgroundColorNames,
+	colorNames,
+
+	// TODO: Remove these aliases in the next major version
+	modifierNames as modifiers,
+	foregroundColorNames as foregroundColors,
+	backgroundColorNames as backgroundColors,
+	colorNames as colors,
+} from './vendor/ansi-styles/index.js';
+
+export {
+	stdoutColor as supportsColor,
+	stderrColor as supportsColorStderr,
+};
+
+export default chalk;

package/dist/src/web/frontend/node_modules/.lint-staged-PLgU0Zyn/node_modules/chalk/source/utilities.js

@@ -0,0 +1,33 @@
+// TODO: When targeting Node.js 16, use `String.prototype.replaceAll`.
+export function stringReplaceAll(string, substring, replacer) {
+	let index = string.indexOf(substring);
+	if (index === -1) {
+		return string;
+	}
+
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = '';
+	do {
+		returnValue += string.slice(endIndex, index) + substring + replacer;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
+
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+
+export function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+	let endIndex = 0;
+	let returnValue = '';
+	do {
+		const gotCR = string[index - 1] === '\r';
+		returnValue += string.slice(endIndex, (gotCR ? index - 1 : index)) + prefix + (gotCR ? '\r\n' : '\n') + postfix;
+		endIndex = index + 1;
+		index = string.indexOf('\n', endIndex);
+	} while (index !== -1);
+
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}