tony/hive
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add comprehensive development roadmap via GitHub Issues

Browse Source 
Created 10 detailed GitHub issues covering:
- Project activation and management UI (#1-2)
- Worker node coordination and visualization (#3-4)
- Automated GitHub repository scanning (#5)
- Intelligent model-to-issue matching (#6)
- Multi-model task execution system (#7)
- N8N workflow integration (#8)
- Hive-Bzzz P2P bridge (#9)
- Peer assistance protocol (#10)

Each issue includes detailed specifications, acceptance criteria,
technical implementation notes, and dependency mapping.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
anthonyrawlins
2025-07-12 19:41:01 +10:00
parent 9a6a06da89
commit e89f2f4b7b
4980 changed files with 1501266 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
frontend/node_modules/check-error/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,19 @@
Copyright (c) 2013 Jake Luer <jake@alogicalparadox.com> (http://alogicalparadox.com)
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.

144
frontend/node_modules/check-error/README.md generated vendored Normal file
View File

@@ -0,0 +1,144 @@
<h1 align=center>
<a href="http://chaijs.com" title="Chai Documentation">
<img alt="ChaiJS" src="http://chaijs.com/img/chai-logo.png">
</a>
<br>
check-error
</h1>
<p align=center>
Error comparison and information related utility for <a href="http://nodejs.org">node</a> and the browser.
</p>
## What is Check-Error?
Check-Error is a module which you can use to retrieve an Error's information such as its `message` or `constructor` name and also to check whether two Errors are compatible based on their messages, constructors or even instances.
## Installation
### Node.js
`check-error` is available on [npm](http://npmjs.org). To install it, type:
$ npm install check-error
### Browsers
You can also use it within the browser; install via npm and use the `check-error.js` file found within the download. For example:
```html
<script src="./node_modules/check-error/check-error.js"></script>
```
## Usage
The primary export of `check-error` is an object which has the following methods:
* `compatibleInstance(err, errorLike)` - Checks if an error is compatible with another `errorLike` object. If `errorLike` is an error instance we do a strict comparison, otherwise we return `false` by default, because instances of objects can only be compatible if they're both error instances.
* `compatibleConstructor(err, errorLike)` - Checks if an error's constructor is compatible with another `errorLike` object. If `err` has the same constructor as `errorLike` or if `err` is an instance of `errorLike`.
* `compatibleMessage(err, errMatcher)` - Checks if an error message is compatible with an `errMatcher` RegExp or String (we check if the message contains the String).
* `getConstructorName(errorLike)` - Retrieves the name of a constructor, an error's constructor or `errorLike` itself if it's not an error instance or constructor.
* `getMessage(err)` - Retrieves the message of an error or `err` itself if it's a String. If `err` or `err.message` is undefined we return an empty String.
```js
var checkError = require('check-error');
```
#### .compatibleInstance(err, errorLike)
```js
var checkError = require('check-error');
var funcThatThrows = function() { throw new TypeError('I am a TypeError') };
var caughtErr;
try {
funcThatThrows();
} catch(e) {
caughtErr = e;
}
var sameInstance = caughtErr;
checkError.compatibleInstance(caughtErr, sameInstance); // true
checkError.compatibleInstance(caughtErr, new TypeError('Another error')); // false
```
#### .compatibleConstructor(err, errorLike)
```js
var checkError = require('check-error');
var funcThatThrows = function() { throw new TypeError('I am a TypeError') };
var caughtErr;
try {
funcThatThrows();
} catch(e) {
caughtErr = e;
}
checkError.compatibleConstructor(caughtErr, Error); // true
checkError.compatibleConstructor(caughtErr, TypeError); // true
checkError.compatibleConstructor(caughtErr, RangeError); // false
```
#### .compatibleMessage(err, errMatcher)
```js
var checkError = require('check-error');
var funcThatThrows = function() { throw new TypeError('I am a TypeError') };
var caughtErr;
try {
funcThatThrows();
} catch(e) {
caughtErr = e;
}
var sameInstance = caughtErr;
checkError.compatibleMessage(caughtErr, /TypeError$/); // true
checkError.compatibleMessage(caughtErr, 'I am a'); // true
checkError.compatibleMessage(caughtErr, /unicorn/); // false
checkError.compatibleMessage(caughtErr, 'I do not exist'); // false
```
#### .getConstructorName(errorLike)
```js
var checkError = require('check-error');
var funcThatThrows = function() { throw new TypeError('I am a TypeError') };
var caughtErr;
try {
funcThatThrows();
} catch(e) {
caughtErr = e;
}
var sameInstance = caughtErr;
checkError.getConstructorName(caughtErr) // 'TypeError'
```
#### .getMessage(err)
```js
var checkError = require('check-error');
var funcThatThrows = function() { throw new TypeError('I am a TypeError') };
var caughtErr;
try {
funcThatThrows();
} catch(e) {
caughtErr = e;
}
var sameInstance = caughtErr;
checkError.getMessage(caughtErr) // 'I am a TypeError'
```

135
frontend/node_modules/check-error/index.js generated vendored Normal file
View File

@@ -0,0 +1,135 @@
function isErrorInstance(obj) {
// eslint-disable-next-line prefer-reflect
return obj instanceof Error || Object.prototype.toString.call(obj) === '[object Error]';
}
function isRegExp(obj) {
// eslint-disable-next-line prefer-reflect
return Object.prototype.toString.call(obj) === '[object RegExp]';
}
/**
* ### .compatibleInstance(thrown, errorLike)
*
* Checks if two instances are compatible (strict equal).
* Returns false if errorLike is not an instance of Error, because instances
* can only be compatible if they're both error instances.
*
* @name compatibleInstance
* @param {Error} thrown error
* @param {Error|ErrorConstructor} errorLike object to compare against
* @namespace Utils
* @api public
*/
function compatibleInstance(thrown, errorLike) {
return isErrorInstance(errorLike) && thrown === errorLike;
}
/**
* ### .compatibleConstructor(thrown, errorLike)
*
* Checks if two constructors are compatible.
* This function can receive either an error constructor or
* an error instance as the `errorLike` argument.
* Constructors are compatible if they're the same or if one is
* an instance of another.
*
* @name compatibleConstructor
* @param {Error} thrown error
* @param {Error|ErrorConstructor} errorLike object to compare against
* @namespace Utils
* @api public
*/
function compatibleConstructor(thrown, errorLike) {
if (isErrorInstance(errorLike)) {
// If `errorLike` is an instance of any error we compare their constructors
return thrown.constructor === errorLike.constructor || thrown instanceof errorLike.constructor;
} else if ((typeof errorLike === 'object' || typeof errorLike === 'function') && errorLike.prototype) {
// If `errorLike` is a constructor that inherits from Error, we compare `thrown` to `errorLike` directly
return thrown.constructor === errorLike || thrown instanceof errorLike;
}
return false;
}
/**
* ### .compatibleMessage(thrown, errMatcher)
*
* Checks if an error's message is compatible with a matcher (String or RegExp).
* If the message contains the String or passes the RegExp test,
* it is considered compatible.
*
* @name compatibleMessage
* @param {Error} thrown error
* @param {String|RegExp} errMatcher to look for into the message
* @namespace Utils
* @api public
*/
function compatibleMessage(thrown, errMatcher) {
const comparisonString = typeof thrown === 'string' ? thrown : thrown.message;
if (isRegExp(errMatcher)) {
return errMatcher.test(comparisonString);
} else if (typeof errMatcher === 'string') {
return comparisonString.indexOf(errMatcher) !== -1; // eslint-disable-line no-magic-numbers
}
return false;
}
/**
* ### .getConstructorName(errorLike)
*
* Gets the constructor name for an Error instance or constructor itself.
*
* @name getConstructorName
* @param {Error|ErrorConstructor} errorLike
* @namespace Utils
* @api public
*/
function getConstructorName(errorLike) {
let constructorName = errorLike;
if (isErrorInstance(errorLike)) {
constructorName = errorLike.constructor.name;
} else if (typeof errorLike === 'function') {
// If `err` is not an instance of Error it is an error constructor itself or another function.
// If we've got a common function we get its name, otherwise we may need to create a new instance
// of the error just in case it's a poorly-constructed error. Please see chaijs/chai/issues/45 to know more.
constructorName = errorLike.name;
if (constructorName === '') {
const newConstructorName = (new errorLike().name); // eslint-disable-line new-cap
constructorName = newConstructorName || constructorName;
}
}
return constructorName;
}
/**
* ### .getMessage(errorLike)
*
* Gets the error message from an error.
* If `err` is a String itself, we return it.
* If the error has no message, we return an empty string.
*
* @name getMessage
* @param {Error|String} errorLike
* @namespace Utils
* @api public
*/
function getMessage(errorLike) {
let msg = '';
if (errorLike && errorLike.message) {
msg = errorLike.message;
} else if (typeof errorLike === 'string') {
msg = errorLike;
}
return msg;
}
export { compatibleInstance, compatibleConstructor, compatibleMessage, getMessage, getConstructorName };

66
frontend/node_modules/check-error/package.json generated vendored Normal file
View File

@@ -0,0 +1,66 @@
{
"version": "2.1.1",
"name": "check-error",
"description": "Error comparison and information related utility for node and the browser",
"keywords": ["check-error", "error", "chai util"],
"license": "MIT",
"author": "Jake Luer <jake@alogicalparadox.com> (http://alogicalparadox.com)",
"contributors": [
"David Losert (https://github.com/davelosert)",
"Keith Cirkel (https://github.com/keithamus)",
"Miroslav Bajtoš (https://github.com/bajtos)",
"Lucas Fernandes da Costa (https://github.com/lucasfcosta)"
],
"files": ["index.js", "check-error.js"],
"type": "module",
"main": "./index.js",
"module": "./index.js",
"repository": {
"type": "git",
"url": "git+ssh://git@github.com/chaijs/check-error.git"
},
"scripts": {
"lint": "eslint --ignore-path .gitignore index.js test/",
"semantic-release": "semantic-release pre && npm publish && semantic-release post",
"pretest": "npm run lint",
"test": "npm run test:node && npm run test:browser",
"test:browser": "web-test-runner",
"test:node": "mocha"
},
"config": {
"ghooks": {
"commit-msg": "validate-commit-msg"
}
},
"eslintConfig": {
"extends": ["strict/es6"],
"env": {
"es6": true
},
"globals": {
"HTMLElement": false
},
"rules": {
"complexity": "off",
"max-statements": "off",
"prefer-arrow-callback": "off",
"prefer-reflect": "off"
}
},
"devDependencies": {
"@web/test-runner": "^0.17.0",
"browserify": "^13.0.0",
"browserify-istanbul": "^1.0.0",
"eslint": "^2.4.0",
"eslint-config-strict": "^8.5.0",
"eslint-plugin-filenames": "^0.2.0",
"ghooks": "^1.0.1",
"mocha": "^9.1.2",
"semantic-release": "^4.3.5",
"simple-assert": "^2.0.0",
"validate-commit-msg": "^2.3.1"
},
"engines": {
"node": ">= 16"
}
}