claude-flow-novice 2.3.1 → 2.3.3

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

@@ -0,0 +1,160 @@
+import debugLib from 'debug'
+
+import { execGit } from './execGit.js'
+import {
+  GIT_ERROR,
+  NO_CONFIGURATION,
+  PREVENTED_EMPTY_COMMIT,
+  RESTORE_STASH_EXAMPLE,
+} from './messages.js'
+import { printTaskOutput } from './printTaskOutput.js'
+import { runAll } from './runAll.js'
+import { cleanupSkipped } from './state.js'
+import {
+  ApplyEmptyCommitError,
+  ConfigNotFoundError,
+  GetBackupStashError,
+  GitError,
+} from './symbols.js'
+import { validateOptions } from './validateOptions.js'
+import { getVersion } from './version.js'
+
+const debugLog = debugLib('lint-staged')
+
+/**
+ * Get the maximum length of a command-line argument string based on current platform
+ *
+ * https://serverfault.com/questions/69430/what-is-the-maximum-length-of-a-command-line-in-mac-os-x
+ * https://support.microsoft.com/en-us/help/830473/command-prompt-cmd-exe-command-line-string-limitation
+ * https://unix.stackexchange.com/a/120652
+ */
+const getMaxArgLength = () => {
+  switch (process.platform) {
+    case 'darwin':
+      return 262144
+    case 'win32':
+      return 8191
+    default:
+      return 131072
+  }
+}
+
+/**
+ * @typedef {(...any) => void} LogFunction
+ * @typedef {{ error: LogFunction, log: LogFunction, warn: LogFunction }} Logger
+ *
+ * Root lint-staged function that is called from `bin/lint-staged`.
+ *
+ * @param {object} options
+ * @param {Object} [options.allowEmpty] - Allow empty commits when tasks revert all staged changes
+ * @param {boolean | number} [options.concurrent] - The number of tasks to run concurrently, or false to run tasks serially
+ * @param {object}  [options.config] - Object with configuration for programmatic API
+ * @param {string} [options.configPath] - Path to configuration file
+ * @param {Object} [options.cwd] - Current working directory
+ * @param {boolean} [options.debug] - Enable debug mode
+ * @param {string} [options.diff] - Override the default "--staged" flag of "git diff" to get list of files
+ * @param {string} [options.diffFilter] - Override the default "--diff-filter=ACMR" flag of "git diff" to get list of files
+ * @param {number} [options.maxArgLength] - Maximum argument string length
+ * @param {boolean} [options.quiet] - Disable lint-staged’s own console output
+ * @param {boolean} [options.relative] - Pass relative filepaths to tasks
+ * @param {boolean|string} [options.shell] - Skip parsing of tasks for better shell support
+ * @param {boolean} [options.stash] - Enable the backup stash, and revert in case of errors
+ * @param {boolean} [options.verbose] - Show task output even when tasks succeed; by default only failed output is shown
+ * @param {Logger} [logger]
+ *
+ * @returns {Promise<boolean>} Promise of whether the task passed or failed
+ */
+const lintStaged = async (
+  {
+    allowEmpty = false,
+    concurrent = true,
+    config: configObject,
+    configPath,
+    cwd,
+    debug = false,
+    diff,
+    diffFilter,
+    maxArgLength = getMaxArgLength() / 2,
+    quiet = false,
+    relative = false,
+    shell = false,
+    // Stashing should be disabled by default when the `diff` option is used
+    stash = diff === undefined,
+    hidePartiallyStaged = stash,
+    verbose = false,
+  } = {},
+  logger = console
+) => {
+  // Seemingly enable debug twice (also done in bin), so that it also works when using the Node.js API
+  if (debug) {
+    debugLib.enable('lint-staged*')
+
+    debugLog(
+      'Running `lint-staged@%s` on Node.js %s (%s)',
+      await getVersion(),
+      process.version,
+      process.platform
+    )
+  }
+
+  const gitVersion = await execGit(['version', '--build-options'], { cwd })
+  debugLog('%s', gitVersion)
+
+  const options = {
+    allowEmpty,
+    concurrent,
+    configObject,
+    configPath,
+    cwd,
+    debug,
+    diff,
+    diffFilter,
+    maxArgLength,
+    quiet,
+    relative,
+    shell,
+    stash,
+    hidePartiallyStaged,
+    verbose,
+  }
+
+  await validateOptions(options, logger)
+
+  // Unset GIT_LITERAL_PATHSPECS to not mess with path interpretation
+  debugLog('Unset GIT_LITERAL_PATHSPECS (was `%s`)', process.env.GIT_LITERAL_PATHSPECS)
+  delete process.env.GIT_LITERAL_PATHSPECS
+
+  try {
+    const ctx = await runAll(options, logger)
+    debugLog('Tasks were executed successfully!')
+    printTaskOutput(ctx, logger)
+    return true
+  } catch (runAllError) {
+    if (runAllError?.ctx?.errors) {
+      const { ctx } = runAllError
+
+      if (ctx.errors.has(ConfigNotFoundError)) {
+        logger.error(NO_CONFIGURATION)
+      } else if (ctx.errors.has(ApplyEmptyCommitError)) {
+        logger.warn(PREVENTED_EMPTY_COMMIT)
+      } else if (
+        (ctx.errors.has(GitError) || cleanupSkipped(ctx)) &&
+        !ctx.errors.has(GetBackupStashError)
+      ) {
+        logger.error(GIT_ERROR)
+        if (ctx.shouldBackup) {
+          // No sense to show this if the backup stash itself is missing.
+          logger.error(RESTORE_STASH_EXAMPLE + '\n')
+        }
+      }
+
+      printTaskOutput(ctx, logger)
+      return false
+    }
+
+    // Probably a compilation error in the config js file. Pass it up to the outer error handler for logging.
+    throw runAllError
+  }
+}
+
+export default lintStaged

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

@@ -0,0 +1,127 @@
+/** @typedef {import('./index').Logger} Logger */
+
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+import debug from 'debug'
+import YAML from 'yaml'
+
+import {
+  CONFIG_FILE_NAMES,
+  CONFIG_NAME,
+  PACKAGE_JSON_FILE,
+  PACKAGE_YAML_FILES,
+} from './configFiles.js'
+import { dynamicImport } from './dynamicImport.js'
+import { failedToLoadConfig } from './messages.js'
+import { resolveConfig } from './resolveConfig.js'
+
+const debugLog = debug('lint-staged:loadConfig')
+
+const jsonParse = (filePath, content) => {
+  const isPackageFile = PACKAGE_JSON_FILE.includes(path.basename(filePath))
+  try {
+    const json = JSON.parse(content)
+    return isPackageFile ? json[CONFIG_NAME] : json
+  } catch (error) {
+    if (path.basename(filePath) === PACKAGE_JSON_FILE) {
+      debugLog('Ignoring invalid package file `%s` with content:\n%s', filePath, content)
+      return undefined
+    }
+
+    throw error
+  }
+}
+
+const yamlParse = (filePath, content) => {
+  const isPackageFile = PACKAGE_YAML_FILES.includes(path.basename(filePath))
+  try {
+    const yaml = YAML.parse(content)
+    return isPackageFile ? yaml[CONFIG_NAME] : yaml
+  } catch (error) {
+    if (isPackageFile) {
+      debugLog('Ignoring invalid package file `%s` with content:\n%s', filePath, content)
+      return undefined
+    }
+
+    throw error
+  }
+}
+
+const NO_EXT = 'noExt'
+
+/**
+ * `lilconfig` doesn't support yaml files by default,
+ * so we add custom loaders for those. Files without
+ * an extensions are assumed to be yaml — this
+ * assumption is in `cosmiconfig` as well.
+ */
+const loaders = {
+  [NO_EXT]: yamlParse,
+  '.cjs': dynamicImport,
+  '.cts': dynamicImport,
+  '.js': dynamicImport,
+  '.json': jsonParse,
+  '.mjs': dynamicImport,
+  '.mts': dynamicImport,
+  '.ts': dynamicImport,
+  '.yaml': yamlParse,
+  '.yml': yamlParse,
+}
+
+const readFile = async (filepath) => {
+  const absolutePath = path.resolve(filepath)
+  return fs.readFile(absolutePath, 'utf-8')
+}
+
+const loadConfigByExt = async (filepath) => {
+  filepath = path.resolve(filepath)
+  const ext = path.extname(filepath) || NO_EXT
+  const loader = loaders[ext]
+
+  /**
+   * No need to read file contents when loader only takes in the filepath argument
+   * and reads itself; this is for `lilconfig` compatibility
+   */
+  const content = loader.length > 1 ? await readFile(filepath) : undefined
+
+  return {
+    config: await loader(filepath, content),
+    filepath,
+  }
+}
+
+/**
+ * @param {object} options
+ * @param {string} [options.configPath] - Explicit path to a config file
+ * @param {string} [options.cwd] - Current working directory
+ */
+export const loadConfig = async ({ configPath, cwd }, logger) => {
+  try {
+    let result
+
+    if (configPath) {
+      debugLog('Loading configuration from `%s`...', configPath)
+      result = await loadConfigByExt(resolveConfig(configPath))
+    } else {
+      debugLog('Searching for configuration from `%s`...', cwd)
+      const { lilconfig } = await import('lilconfig')
+      const explorer = lilconfig(CONFIG_NAME, { searchPlaces: CONFIG_FILE_NAMES, loaders })
+      result = await explorer.search(cwd)
+    }
+
+    if (!result) return {}
+
+    // config is a promise when using the `dynamicImport` loader
+    const config = (await result.config) ?? null
+    const filepath = result.filepath
+
+    debugLog('Successfully loaded config from `%s`:\n%O', filepath, config)
+
+    return { config, filepath }
+  } catch (error) {
+    debugLog('Failed to load configuration from `%s` with error:\n', configPath, error)
+    logger.error(failedToLoadConfig(configPath))
+    return {}
+  }
+}

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

@@ -0,0 +1,52 @@
+import debug from 'debug'
+
+import { configurationError } from './messages.js'
+import { resolveTaskFn } from './resolveTaskFn.js'
+
+const debugLog = debug('lint-staged:makeCmdTasks')
+
+/**
+ * Creates and returns an array of listr tasks which map to the given commands.
+ *
+ * @param {object} options
+ * @param {Array<string|Function>|string|Function} options.commands
+ * @param {string} options.cwd
+ * @param {Array<string>} options.files
+ * @param {string} options.topLevelDir
+ * @param {Boolean} shell
+ * @param {Boolean} verbose
+ */
+export const makeCmdTasks = async ({ commands, cwd, files, topLevelDir, shell, verbose }) => {
+  debugLog('Creating listr tasks for commands %o', commands)
+  const commandArray = Array.isArray(commands) ? commands : [commands]
+  const cmdTasks = []
+
+  for (const cmd of commandArray) {
+    // command function may return array of commands that already include `stagedFiles`
+    const isFn = typeof cmd === 'function'
+
+    /** Pass copy of file list to prevent mutation by function from config file. */
+    const resolved = isFn ? await cmd([...files]) : cmd
+
+    const resolvedArray = Array.isArray(resolved) ? resolved : [resolved] // Wrap non-array command as array
+
+    for (const command of resolvedArray) {
+      // If the function linter didn't return string | string[]  it won't work
+      // Do the validation here instead of `validateConfig` to skip evaluating the function multiple times
+      if (isFn && typeof command !== 'string') {
+        throw new Error(
+          configurationError(
+            '[Function]',
+            'Function task should return a string or an array of strings',
+            resolved
+          )
+        )
+      }
+
+      const task = resolveTaskFn({ command, cwd, files, topLevelDir, isFn, shell, verbose })
+      cmdTasks.push({ title: command, command, task })
+    }
+  }
+
+  return cmdTasks
+}

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

@@ -0,0 +1,98 @@
+import { inspect } from 'node:util'
+
+import chalk from 'chalk'
+
+import { error, info, warning } from './figures.js'
+
+export const configurationError = (opt, helpMsg, value) =>
+  `${chalk.redBright(`${error} Validation Error:`)}
+
+  Invalid value for '${chalk.bold(opt)}': ${chalk.bold(inspect(value))}
+
+  ${helpMsg}`
+
+export const NOT_GIT_REPO = chalk.redBright(`${error} Current directory is not a git directory!`)
+
+export const FAILED_GET_STAGED_FILES = chalk.redBright(`${error} Failed to get staged files!`)
+
+export const incorrectBraces = (before, after) =>
+  chalk.yellow(
+    `${warning} Detected incorrect braces with only single value: \`${before}\`. Reformatted as: \`${after}\`
+`
+  )
+
+export const NO_CONFIGURATION = `${error} No valid configuration found.`
+
+export const NO_STAGED_FILES = `${info} No staged files found.`
+
+export const NO_TASKS = `${info} No staged files match any configured task.`
+
+export const skippingBackup = (hasInitialCommit, diff) => {
+  const reason =
+    diff !== undefined
+      ? '`--diff` was used'
+      : hasInitialCommit
+        ? '`--no-stash` was used'
+        : 'there’s no initial commit yet'
+
+  return chalk.yellow(`${warning} Skipping backup because ${reason}.\n`)
+}
+
+export const skippingHidePartiallyStaged = (stash, diff) => {
+  const reason =
+    diff !== undefined
+      ? '`--diff` was used'
+      : !stash
+        ? '`--no-stash` was used'
+        : '`--no-hide-partially-staged` was used'
+
+  return chalk.yellow(
+    `${warning} Skipping hiding unstaged changes from partially staged files because ${reason}.\n`
+  )
+}
+
+export const DEPRECATED_GIT_ADD = chalk.yellow(
+  `${warning} Some of your tasks use \`git add\` command. Please remove it from the config since all modifications made by tasks will be automatically added to the git commit index.
+`
+)
+
+export const TASK_ERROR = 'Skipped because of errors from tasks.'
+
+export const SKIPPED_GIT_ERROR = 'Skipped because of previous git error.'
+
+export const GIT_ERROR = `\n  ${chalk.redBright(`${error} lint-staged failed due to a git error.`)}`
+
+export const invalidOption = (name, value, message) => `${chalk.redBright(
+  `${error} Validation Error:`
+)}
+
+  Invalid value for option '${chalk.bold(name)}': ${chalk.bold(value)}
+
+  ${message}
+
+See https://github.com/okonet/lint-staged#command-line-flags`
+
+export const PREVENTED_EMPTY_COMMIT = `
+  ${chalk.yellow(`${warning} lint-staged prevented an empty git commit.
+  Use the --allow-empty option to continue, or check your task configuration`)}
+`
+
+export const RESTORE_STASH_EXAMPLE = `Any lost modifications can be restored from a git stash:
+
+  > git stash list
+  stash@{0}: automatic lint-staged backup
+  > git stash apply --index stash@{0}`
+
+export const CONFIG_STDIN_ERROR = chalk.redBright(`${error} Failed to read config from stdin.`)
+
+export const failedToLoadConfig = (filepath) =>
+  chalk.redBright(`${error} Failed to read config from file "${filepath}".`)
+
+export const failedToParseConfig = (
+  filepath,
+  error
+) => `${chalk.redBright(`${error} Failed to parse config from file "${filepath}".`)}
+
+${error}
+
+See https://github.com/okonet/lint-staged#configuration.`

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

@@ -0,0 +1,50 @@
+/**
+ * Reimplementation of "normalize-path"
+ * @see https://github.com/jonschlinkert/normalize-path/blob/52c3a95ebebc2d98c1ad7606cbafa7e658656899/index.js
+ */
+
+/*!
+ * normalize-path <https://github.com/jonschlinkert/normalize-path>
+ *
+ * Copyright (c) 2014-2018, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+import path from 'node:path'
+
+/**
+ * A file starting with \\?\
+ * @see https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#win32-file-namespaces
+ */
+const WIN32_FILE_NS = '\\\\?\\'
+
+/**
+ * A file starting with \\.\
+ * @see https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#win32-file-namespaces
+ */
+const WIN32_DEVICE_NS = '\\\\.\\'
+
+/**
+ * Normalize input file path to use POSIX separators
+ * @param {String} input
+ * @returns String
+ */
+export const normalizePath = (input) => {
+  if (input === path.posix.sep || input === path.win32.sep) {
+    return path.posix.sep
+  }
+
+  let normalized = input.split(/[/\\]+/).join(path.posix.sep)
+
+  /** Handle win32 Namespaced paths by changing e.g. \\.\ to //./ */
+  if (input.startsWith(WIN32_FILE_NS) || input.startsWith(WIN32_DEVICE_NS)) {
+    normalized = normalized.replace(/^\/(\.|\?)/, '//$1')
+  }
+
+  /** Remove trailing slash */
+  if (normalized.endsWith(path.posix.sep)) {
+    normalized = normalized.slice(0, -1)
+  }
+
+  return normalized
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Return array of strings split from the output of `git <something> -z`.
+ * With `-z`, git prints `fileA\u0000fileB\u0000fileC\u0000` so we need to
+ * remove the last occurrence of `\u0000` before splitting
+ */
+export const parseGitZOutput = (input) =>
+  input
+    ? input
+        .replace(/\u0000$/, '') // eslint-disable-line no-control-regex
+        .split('\u0000')
+    : []

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

@@ -0,0 +1,12 @@
+/**
+ * Handle logging of listr `ctx.output` to the specified `logger`
+ * @param {Object} ctx - The listr initial state
+ * @param {Object} logger - The logger
+ */
+export const printTaskOutput = (ctx = {}, logger) => {
+  if (!Array.isArray(ctx.output)) return
+  const log = ctx.errors?.size > 0 ? logger.error : logger.log
+  for (const line of ctx.output) {
+    log(line)
+  }
+}

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

@@ -0,0 +1,19 @@
+import { createInterface } from 'node:readline'
+
+/**
+ * Returns a promise resolving to the first line written to stdin after invoking.
+ * @warn will never resolve if called after writing to stdin
+ *
+ * @returns {Promise<string>}
+ */
+export const readStdin = () => {
+  const readline = createInterface({ input: process.stdin })
+
+  return new Promise((resolve) => {
+    readline.prompt()
+    readline.on('line', (line) => {
+      readline.close()
+      resolve(line)
+    })
+  })
+}

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

@@ -0,0 +1,15 @@
+import { createRequire } from 'node:module'
+
+/**
+ * require() does not exist for ESM, so we must create it to use require.resolve().
+ * @see https://nodejs.org/api/module.html#modulecreaterequirefilename
+ */
+const require = createRequire(import.meta.url)
+
+export function resolveConfig(configPath) {
+  try {
+    return require.resolve(configPath)
+  } catch {
+    return configPath
+  }
+}

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

@@ -0,0 +1,66 @@
+import path from 'node:path'
+
+import debug from 'debug'
+
+import { execGit } from './execGit.js'
+import { normalizePath } from './normalizePath.js'
+
+const debugLog = debug('lint-staged:resolveGitRepo')
+
+/**
+ * Resolve .git directory relative to repo top-level directory
+ *
+ * @example ".git"
+ */
+const resolveRelativeGitDir = async (cwd) => {
+  /**
+   * Absolute repo top-level directory
+   *
+   * @example <caption>Git on macOS</caption>
+   * "/Users/iiro/Documents/git/lint-staged"
+   *
+   * @example <caption>Git for Windows</caption>
+   * "C:\Users\iiro\Documents\git\lint-staged"
+   *
+   * @example <caption>Git installed with MSYS2, this doesn't work when used as CWD with Node.js child_process</caption>
+   * "/c/Users/iiro/Documents/git/lint-staged"
+   */
+  const topLevelPromise = execGit(['rev-parse', '--show-toplevel'], { cwd })
+
+  /**
+   * Absolute .git directory, similar to top-level
+   *
+   * @example "/Users/iiro/Documents/git/lint-staged/.git"
+   */
+  const absoluteGitDirPromise = execGit(['rev-parse', '--absolute-git-dir'], { cwd })
+
+  const [topLevel, absoluteGitDir] = await Promise.all([topLevelPromise, absoluteGitDirPromise])
+
+  return path.relative(topLevel, absoluteGitDir)
+}
+
+/** Resolve git directory and possible submodule paths */
+export const resolveGitRepo = async (cwd = process.cwd()) => {
+  try {
+    debugLog('Resolving git repo from `%s`', cwd)
+
+    // Unset GIT_DIR before running any git operations in case it's pointing to an incorrect location
+    debugLog('Unset GIT_DIR (was `%s`)', process.env.GIT_DIR)
+    delete process.env.GIT_DIR
+    debugLog('Unset GIT_WORK_TREE (was `%s`)', process.env.GIT_WORK_TREE)
+    delete process.env.GIT_WORK_TREE
+
+    const relativeTopLevelDir = await execGit(['rev-parse', '--show-cdup'], { cwd })
+    const topLevelDir = normalizePath(path.join(cwd, relativeTopLevelDir))
+    debugLog('Resolved git repository top-level directory to be `%s`', topLevelDir)
+
+    const relativeGitConfigDir = await resolveRelativeGitDir(cwd)
+    const gitConfigDir = normalizePath(path.join(topLevelDir, relativeGitConfigDir))
+    debugLog('Resolved git config directory to be `%s`', gitConfigDir)
+
+    return { topLevelDir, gitConfigDir }
+  } catch (error) {
+    debugLog('Failed to resolve git repo with error:', error)
+    return { error, topLevelDir: null, gitConfigDir: null }
+  }
+}