claude-flow 2.7.0-alpha.9 → 2.7.1

package/docs/reasoningbank/models/safla/node_modules/prebuild-install/download.js

@@ -0,0 +1,142 @@
+const path = require('path')
+const fs = require('fs')
+const get = require('simple-get')
+const pump = require('pump')
+const tfs = require('tar-fs')
+const zlib = require('zlib')
+const util = require('./util')
+const error = require('./error')
+const proxy = require('./proxy')
+const mkdirp = require('mkdirp-classic')
+
+function downloadPrebuild (downloadUrl, opts, cb) {
+  let cachedPrebuild = util.cachedPrebuild(downloadUrl)
+  const localPrebuild = util.localPrebuild(downloadUrl, opts)
+  const tempFile = util.tempFile(cachedPrebuild)
+  const log = opts.log || util.noopLogger
+
+  if (opts.nolocal) return download()
+
+  log.info('looking for local prebuild @', localPrebuild)
+  fs.access(localPrebuild, fs.R_OK | fs.W_OK, function (err) {
+    if (err && err.code === 'ENOENT') {
+      return download()
+    }
+
+    log.info('found local prebuild')
+    cachedPrebuild = localPrebuild
+    unpack()
+  })
+
+  function download () {
+    ensureNpmCacheDir(function (err) {
+      if (err) return onerror(err)
+
+      log.info('looking for cached prebuild @', cachedPrebuild)
+      fs.access(cachedPrebuild, fs.R_OK | fs.W_OK, function (err) {
+        if (!(err && err.code === 'ENOENT')) {
+          log.info('found cached prebuild')
+          return unpack()
+        }
+
+        log.http('request', 'GET ' + downloadUrl)
+        const reqOpts = proxy({ url: downloadUrl }, opts)
+
+        if (opts.token) {
+          reqOpts.headers = {
+            'User-Agent': 'simple-get',
+            Accept: 'application/octet-stream',
+            Authorization: 'token ' + opts.token
+          }
+        }
+
+        const req = get(reqOpts, function (err, res) {
+          if (err) return onerror(err)
+          log.http(res.statusCode, downloadUrl)
+          if (res.statusCode !== 200) return onerror()
+          mkdirp(util.prebuildCache(), function () {
+            log.info('downloading to @', tempFile)
+            pump(res, fs.createWriteStream(tempFile), function (err) {
+              if (err) return onerror(err)
+              fs.rename(tempFile, cachedPrebuild, function (err) {
+                if (err) return cb(err)
+                log.info('renaming to @', cachedPrebuild)
+                unpack()
+              })
+            })
+          })
+        })
+
+        req.setTimeout(30 * 1000, function () {
+          req.abort()
+        })
+      })
+
+      function onerror (err) {
+        fs.unlink(tempFile, function () {
+          cb(err || error.noPrebuilts(opts))
+        })
+      }
+    })
+  }
+
+  function unpack () {
+    let binaryName
+
+    const updateName = opts.updateName || function (entry) {
+      if (/\.node$/i.test(entry.name)) binaryName = entry.name
+    }
+
+    log.info('unpacking @', cachedPrebuild)
+
+    const options = {
+      readable: true,
+      writable: true,
+      hardlinkAsFilesFallback: true
+    }
+    const extract = tfs.extract(opts.path, options).on('entry', updateName)
+
+    pump(fs.createReadStream(cachedPrebuild), zlib.createGunzip(), extract,
+      function (err) {
+        if (err) return cb(err)
+
+        let resolved
+        if (binaryName) {
+          try {
+            resolved = path.resolve(opts.path || '.', binaryName)
+          } catch (err) {
+            return cb(err)
+          }
+          log.info('unpack', 'resolved to ' + resolved)
+
+          if (opts.runtime === 'node' && opts.platform === process.platform && opts.abi === process.versions.modules && opts.arch === process.arch) {
+            try {
+              require(resolved)
+            } catch (err) {
+              return cb(err)
+            }
+            log.info('unpack', 'required ' + resolved + ' successfully')
+          }
+        }
+
+        cb(null, resolved)
+      })
+  }
+
+  function ensureNpmCacheDir (cb) {
+    const cacheFolder = util.npmCache()
+    fs.access(cacheFolder, fs.R_OK | fs.W_OK, function (err) {
+      if (err && err.code === 'ENOENT') {
+        return makeNpmCacheDir()
+      }
+      cb(err)
+    })
+
+    function makeNpmCacheDir () {
+      log.info('npm cache directory missing, creating it...')
+      mkdirp(cacheFolder, cb)
+    }
+  }
+}
+
+module.exports = downloadPrebuild

package/docs/reasoningbank/models/safla/node_modules/prebuild-install/error.js

@@ -0,0 +1,14 @@
+exports.noPrebuilts = function (opts) {
+  return new Error([
+    'No prebuilt binaries found',
+    '(target=' + opts.target,
+    'runtime=' + opts.runtime,
+    'arch=' + opts.arch,
+    'libc=' + opts.libc,
+    'platform=' + opts.platform + ')'
+  ].join(' '))
+}
+
+exports.invalidArchive = function () {
+  return new Error('Missing .node file in archive')
+}

package/docs/reasoningbank/models/safla/node_modules/prebuild-install/help.txt

@@ -0,0 +1,16 @@
+prebuild-install [options]
+
+  --download    -d  [url]       (download prebuilds, no url means github)
+  --target      -t  version     (version to install for)
+  --runtime     -r  runtime     (Node runtime [node or electron] to build or install for, default is node)
+  --path        -p  path        (make a prebuild-install here)
+  --token       -T  gh-token    (github token for private repos)
+  --arch            arch        (target CPU architecture, see Node OS module docs, default is current arch)
+  --platform        platform    (target platform, see Node OS module docs, default is current platform)
+  --tag-prefix <prefix>         (github tag prefix, default is "v")
+  --force                       (always use prebuilt binaries when available)
+  --build-from-source           (skip prebuild download)
+  --verbose                     (log verbosely)
+  --libc                        (use provided libc rather than system default)
+  --debug                       (set Debug or Release configuration)
+  --version                     (print prebuild-install version and exit)

package/docs/reasoningbank/models/safla/node_modules/prebuild-install/index.js

@@ -0,0 +1 @@
+exports.download = require('./download')

package/docs/reasoningbank/models/safla/node_modules/prebuild-install/log.js

@@ -0,0 +1,33 @@
+const levels = {
+  silent: 0,
+  error: 1,
+  warn: 2,
+  notice: 3,
+  http: 4,
+  timing: 5,
+  info: 6,
+  verbose: 7,
+  silly: 8
+}
+
+module.exports = function (rc, env) {
+  const level = rc.verbose
+    ? 'verbose'
+    : env.npm_config_loglevel || 'notice'
+
+  const logAtLevel = function (messageLevel) {
+    return function (...args) {
+      if (levels[messageLevel] <= levels[level]) {
+        console.error(`prebuild-install ${messageLevel} ${args.join(' ')}`)
+      }
+    }
+  }
+
+  return {
+    error: logAtLevel('error'),
+    warn: logAtLevel('warn'),
+    http: logAtLevel('http'),
+    info: logAtLevel('info'),
+    level
+  }
+}

package/docs/reasoningbank/models/safla/node_modules/prebuild-install/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "prebuild-install",
+  "version": "7.1.3",
+  "description": "A command line tool to easily install prebuilt binaries for multiple version of node/iojs on a specific platform",
+  "scripts": {
+    "test": "standard && hallmark && tape test/*-test.js",
+    "hallmark": "hallmark --fix"
+  },
+  "keywords": [
+    "prebuilt",
+    "binaries",
+    "native",
+    "addon",
+    "module",
+    "c",
+    "c++",
+    "bindings",
+    "devops",
+    "napi"
+  ],
+  "dependencies": {
+    "detect-libc": "^2.0.0",
+    "expand-template": "^2.0.3",
+    "github-from-package": "0.0.0",
+    "minimist": "^1.2.3",
+    "mkdirp-classic": "^0.5.3",
+    "napi-build-utils": "^2.0.0",
+    "node-abi": "^3.3.0",
+    "pump": "^3.0.0",
+    "rc": "^1.2.7",
+    "simple-get": "^4.0.0",
+    "tar-fs": "^2.0.0",
+    "tunnel-agent": "^0.6.0"
+  },
+  "devDependencies": {
+    "a-native-module": "^1.0.0",
+    "hallmark": "^4.0.0",
+    "nock": "^10.0.6",
+    "rimraf": "^2.5.2",
+    "standard": "^16.0.4",
+    "tape": "^5.3.1",
+    "tempy": "0.2.1"
+  },
+  "bin": "./bin.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prebuild/prebuild-install.git"
+  },
+  "author": "Mathias Buus (@mafintosh)",
+  "contributors": [
+    "Julian Gruber <julian@juliangruber.com> (https://github.com/juliangruber)",
+    "Brett Lawson <brett19@gmail.com> (https://github.com/brett19)",
+    "Pieter Hintjens <ph@imatix.com> (https://github.com/hintjens)",
+    "Lars-Magnus Skog <ralphtheninja@riseup.net> (https://github.com/ralphtheninja)",
+    "Jesús Leganés Combarro <piranna@gmail.com> (https://github.com/piranna)",
+    "Mathias Küsel <mathiask@hotmail.de> (https://github.com/mathiask88)",
+    "Lukas Geiger <lukas.geiger94@gmail.com> (https://github.com/lgeiger)"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/prebuild/prebuild-install/issues"
+  },
+  "homepage": "https://github.com/prebuild/prebuild-install",
+  "engines": {
+    "node": ">=10"
+  }
+}

package/docs/reasoningbank/models/safla/node_modules/prebuild-install/proxy.js

@@ -0,0 +1,35 @@
+const url = require('url')
+const tunnel = require('tunnel-agent')
+const util = require('./util')
+
+function applyProxy (reqOpts, opts) {
+  const log = opts.log || util.noopLogger
+
+  const proxy = opts['https-proxy'] || opts.proxy
+
+  if (proxy) {
+    // eslint-disable-next-line node/no-deprecated-api
+    const parsedDownloadUrl = url.parse(reqOpts.url)
+    // eslint-disable-next-line node/no-deprecated-api
+    const parsedProxy = url.parse(proxy)
+    const uriProtocol = (parsedDownloadUrl.protocol === 'https:' ? 'https' : 'http')
+    const proxyProtocol = (parsedProxy.protocol === 'https:' ? 'Https' : 'Http')
+    const tunnelFnName = [uriProtocol, proxyProtocol].join('Over')
+    reqOpts.agent = tunnel[tunnelFnName]({
+      proxy: {
+        host: parsedProxy.hostname,
+        port: +parsedProxy.port,
+        proxyAuth: parsedProxy.auth
+      }
+    })
+    log.http('request', 'Proxy setup detected (Host: ' +
+    parsedProxy.hostname + ', Port: ' +
+      parsedProxy.port + ', Authentication: ' +
+      (parsedProxy.auth ? 'Yes' : 'No') + ')' +
+      ' Tunneling with ' + tunnelFnName)
+  }
+
+  return reqOpts
+}
+
+module.exports = applyProxy

package/docs/reasoningbank/models/safla/node_modules/prebuild-install/rc.js

@@ -0,0 +1,64 @@
+const path = require('path')
+const minimist = require('minimist')
+const getAbi = require('node-abi').getAbi
+const detectLibc = require('detect-libc')
+const napi = require('napi-build-utils')
+
+const env = process.env
+
+const libc = env.LIBC || process.env.npm_config_libc ||
+  (detectLibc.isNonGlibcLinuxSync() && detectLibc.familySync()) || ''
+
+// Get the configuration
+module.exports = function (pkg) {
+  const pkgConf = pkg.config || {}
+  const buildFromSource = env.npm_config_build_from_source
+
+  const rc = require('rc')('prebuild-install', {
+    target: pkgConf.target || env.npm_config_target || process.versions.node,
+    runtime: pkgConf.runtime || env.npm_config_runtime || 'node',
+    arch: pkgConf.arch || env.npm_config_arch || process.arch,
+    libc: libc,
+    platform: env.npm_config_platform || process.platform,
+    debug: env.npm_config_debug === 'true',
+    force: false,
+    verbose: env.npm_config_verbose === 'true',
+    buildFromSource: buildFromSource === pkg.name || buildFromSource === 'true',
+    path: '.',
+    proxy: env.npm_config_proxy || env.http_proxy || env.HTTP_PROXY,
+    'https-proxy': env.npm_config_https_proxy || env.https_proxy || env.HTTPS_PROXY,
+    'local-address': env.npm_config_local_address,
+    'local-prebuilds': 'prebuilds',
+    'tag-prefix': 'v',
+    download: env.npm_config_download
+  }, minimist(process.argv, {
+    alias: {
+      target: 't',
+      runtime: 'r',
+      help: 'h',
+      arch: 'a',
+      path: 'p',
+      version: 'v',
+      download: 'd',
+      buildFromSource: 'build-from-source',
+      token: 'T'
+    }
+  }))
+
+  rc.path = path.resolve(rc.path === true ? '.' : rc.path || '.')
+
+  if (napi.isNapiRuntime(rc.runtime) && rc.target === process.versions.node) {
+    rc.target = napi.getBestNapiBuildVersion()
+  }
+
+  rc.abi = napi.isNapiRuntime(rc.runtime) ? rc.target : getAbi(rc.target, rc.runtime)
+
+  rc.libc = rc.platform !== 'linux' || rc.libc === detectLibc.GLIBC ? '' : rc.libc
+
+  return rc
+}
+
+// Print the configuration values when executed standalone for testing purposses
+if (!module.parent) {
+  console.log(JSON.stringify(module.exports({}), null, 2))
+}

package/docs/reasoningbank/models/safla/node_modules/prebuild-install/util.js

@@ -0,0 +1,143 @@
+const path = require('path')
+const github = require('github-from-package')
+const home = require('os').homedir
+const crypto = require('crypto')
+const expandTemplate = require('expand-template')()
+
+function getDownloadUrl (opts) {
+  const pkgName = opts.pkg.name.replace(/^@[a-zA-Z0-9_\-.~]+\//, '')
+  return expandTemplate(urlTemplate(opts), {
+    name: pkgName,
+    package_name: pkgName,
+    version: opts.pkg.version,
+    major: opts.pkg.version.split('.')[0],
+    minor: opts.pkg.version.split('.')[1],
+    patch: opts.pkg.version.split('.')[2],
+    prerelease: opts.pkg.version.split('-')[1],
+    build: opts.pkg.version.split('+')[1],
+    abi: opts.abi || process.versions.modules,
+    node_abi: process.versions.modules,
+    runtime: opts.runtime || 'node',
+    platform: opts.platform,
+    arch: opts.arch,
+    libc: opts.libc || '',
+    configuration: (opts.debug ? 'Debug' : 'Release'),
+    module_name: opts.pkg.binary && opts.pkg.binary.module_name,
+    tag_prefix: opts['tag-prefix']
+  })
+}
+
+function getApiUrl (opts) {
+  return github(opts.pkg).replace('github.com', 'api.github.com/repos') + '/releases'
+}
+
+function getAssetUrl (opts, assetId) {
+  return getApiUrl(opts) + '/assets/' + assetId
+}
+
+function urlTemplate (opts) {
+  if (typeof opts.download === 'string') {
+    return opts.download
+  }
+
+  const packageName = '{name}-v{version}-{runtime}-v{abi}-{platform}{libc}-{arch}.tar.gz'
+  const hostMirrorUrl = getHostMirrorUrl(opts)
+
+  if (hostMirrorUrl) {
+    return hostMirrorUrl + '/{tag_prefix}{version}/' + packageName
+  }
+
+  if (opts.pkg.binary && opts.pkg.binary.host) {
+    return [
+      opts.pkg.binary.host,
+      opts.pkg.binary.remote_path,
+      opts.pkg.binary.package_name || packageName
+    ].map(function (path) {
+      return trimSlashes(path)
+    }).filter(Boolean).join('/')
+  }
+
+  return github(opts.pkg) + '/releases/download/{tag_prefix}{version}/' + packageName
+}
+
+function getEnvPrefix (pkgName) {
+  return 'npm_config_' + (pkgName || '').replace(/[^a-zA-Z0-9]/g, '_').replace(/^_/, '')
+}
+
+function getHostMirrorUrl (opts) {
+  const propName = getEnvPrefix(opts.pkg.name) + '_binary_host'
+  return process.env[propName] || process.env[propName + '_mirror']
+}
+
+function trimSlashes (str) {
+  if (str) return str.replace(/^\.\/|^\/|\/$/g, '')
+}
+
+function cachedPrebuild (url) {
+  const digest = crypto.createHash('sha512').update(url).digest('hex').slice(0, 6)
+  return path.join(prebuildCache(), digest + '-' + path.basename(url).replace(/[^a-zA-Z0-9.]+/g, '-'))
+}
+
+function npmCache () {
+  const env = process.env
+  return env.npm_config_cache || (env.APPDATA ? path.join(env.APPDATA, 'npm-cache') : path.join(home(), '.npm'))
+}
+
+function prebuildCache () {
+  return path.join(npmCache(), '_prebuilds')
+}
+
+function tempFile (cached) {
+  return cached + '.' + process.pid + '-' + Math.random().toString(16).slice(2) + '.tmp'
+}
+
+function packageOrigin (env, pkg) {
+  // npm <= 6: metadata is stored on disk in node_modules
+  if (pkg._from) {
+    return pkg._from
+  }
+
+  // npm 7: metadata is exposed to environment by arborist
+  if (env.npm_package_from) {
+    // NOTE: seems undefined atm (npm 7.0.2)
+    return env.npm_package_from
+  }
+
+  if (env.npm_package_resolved) {
+    // NOTE: not sure about the difference with _from, but it's all we have
+    return env.npm_package_resolved
+  }
+}
+
+function localPrebuild (url, opts) {
+  const propName = getEnvPrefix(opts.pkg.name) + '_local_prebuilds'
+  const prefix = process.env[propName] || opts['local-prebuilds'] || 'prebuilds'
+  return path.join(prefix, path.basename(url))
+}
+
+const noopLogger = {
+  http: function () {},
+  silly: function () {},
+  debug: function () {},
+  info: function () {},
+  warn: function () {},
+  error: function () {},
+  critical: function () {},
+  alert: function () {},
+  emergency: function () {},
+  notice: function () {},
+  verbose: function () {},
+  fatal: function () {}
+}
+
+exports.getDownloadUrl = getDownloadUrl
+exports.getApiUrl = getApiUrl
+exports.getAssetUrl = getAssetUrl
+exports.urlTemplate = urlTemplate
+exports.cachedPrebuild = cachedPrebuild
+exports.localPrebuild = localPrebuild
+exports.prebuildCache = prebuildCache
+exports.npmCache = npmCache
+exports.tempFile = tempFile
+exports.packageOrigin = packageOrigin
+exports.noopLogger = noopLogger

package/docs/reasoningbank/models/safla/node_modules/pump/.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: mafintosh
+tidelift: "npm/pump"

package/docs/reasoningbank/models/safla/node_modules/pump/.travis.yml

@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - "0.10"
+
+script: "npm test"

package/docs/reasoningbank/models/safla/node_modules/pump/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Mathias Buus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/docs/reasoningbank/models/safla/node_modules/pump/README.md

@@ -0,0 +1,74 @@
+# pump
+
+pump is a small node module that pipes streams together and destroys all of them if one of them closes.
+
+```
+npm install pump
+```
+
+[![build status](http://img.shields.io/travis/mafintosh/pump.svg?style=flat)](http://travis-ci.org/mafintosh/pump)
+
+## What problem does it solve?
+
+When using standard `source.pipe(dest)` source will _not_ be destroyed if dest emits close or an error.
+You are also not able to provide a callback to tell when then pipe has finished.
+
+pump does these two things for you
+
+## Usage
+
+Simply pass the streams you want to pipe together to pump and add an optional callback
+
+``` js
+var pump = require('pump')
+var fs = require('fs')
+
+var source = fs.createReadStream('/dev/random')
+var dest = fs.createWriteStream('/dev/null')
+
+pump(source, dest, function(err) {
+  console.log('pipe finished', err)
+})
+
+setTimeout(function() {
+  dest.destroy() // when dest is closed pump will destroy source
+}, 1000)
+```
+
+You can use pump to pipe more than two streams together as well
+
+``` js
+var transform = someTransformStream()
+
+pump(source, transform, anotherTransform, dest, function(err) {
+  console.log('pipe finished', err)
+})
+```
+
+If `source`, `transform`, `anotherTransform` or `dest` closes all of them will be destroyed.
+
+Similarly to `stream.pipe()`, `pump()` returns the last stream passed in, so you can do:
+
+```
+return pump(s1, s2) // returns s2
+```
+
+Note that `pump` attaches error handlers to the streams to do internal error handling, so if `s2` emits an
+error in the above scenario, it will not trigger a `proccess.on('uncaughtException')` if you do not listen for it.
+
+If you want to return a stream that combines *both* s1 and s2 to a single stream use
+[pumpify](https://github.com/mafintosh/pumpify) instead.
+
+## License
+
+MIT
+
+## Related
+
+`pump` is part of the [mississippi stream utility collection](https://github.com/maxogden/mississippi) which includes more useful stream modules similar to this one.
+
+## For enterprise
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of pump and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-pump?utm_source=npm-pump&utm_medium=referral&utm_campaign=enterprise)

package/docs/reasoningbank/models/safla/node_modules/pump/SECURITY.md

@@ -0,0 +1,5 @@
+## Security contact information
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.