open-index/open-npm huggingface dataset:
npm package: @songkeys/posthog-node
Description: PostHog Node.js integration
Author: PostHog
Latest version: 5.0.0-beta.0

# PostHog Node.js

Please see the main [PostHog docs](https://www.posthog.com/docs).

Specifically, the [Node.js integration](https://posthog.com/docs/integrate/server/node) details.

## Questions?

### [Check out our community page.](https://posthog.com/posts)
npm package: @songkick/eslint-config-songkick
Description: A base for our ESLint configurations.
Author: Songkick
Latest version: 0.3.0

# songick-eslint-config

A base configuration for ESLinting our JavaScript projects.

## Base Rules:

- `use strict` is not allowed, because when the app is wrapped with Babel it will have this added.
- `debugger;` statements are errors.
- `indent` must be 2 spaces, and indentation is enforced within `switch` statements.
- `quotes` must be single quotes, and template literals are also allowed.
- `max-len` must be no more than 120 characters
- `linebreak-style` is set to `unix`.

## Environments

- `browser` and `node` environments are enabled

## Plugins:

- [eslint-plugin-jasmine](https://github.com/tlvince/eslint-plugin-jasmine)
- [eslint-plugin-import](https://github.com/benmosher/eslint-plugin-import)

## Extends

We also extend from some other configurations:

- `plugin:jasmine/recommended`
- `plugin:import/errors`
- `plugin:import/warnings`

## Parser

[babel-eslint](https://github.com/babel/babel-eslint) is used as the parser.
npm package: @songkick/promise-condition
Description: Rejects a promise based on a condition
Author: dvemac
Latest version: 1.0.0

# promise-condition [![Build Status](https://travis-ci.org/songkick/promise-condition.svg)](https://travis-ci.org/songkick/promise-condition) [![Code Climate](https://codeclimate.com/github/songkick/promise-condition/badges/gpa.svg)](https://codeclimate.com/github/songkick/promise-condition) [![Test Coverage](https://codeclimate.com/github/songkick/promise-condition/badges/coverage.svg)](https://codeclimate.com/github/songkick/promise-condition/coverage)

Rejects a promise that fails a test condition

```js
var condition = require('promise-condition');
var rejectAbove400 = condition(function (data) { return data.status < 400; });

function fetch200(){
    return fetch('/path/to/a/http-200-ok');
}

function fetch400(){
    return fetch('/path/to/a/http-400-bad-request');
}

rejectAbove400(fetch200)()
  .then(function(response){
    // the initial fetch response
  }).catch(function(err){
    // probably won't happen here, unless /200 doesn't return a HTTP - 200
  });

rejectAbove400(fetch400)()
  .then(function(response){
    // should not happen here
  }).catch(function(err){
      // err instanceof condition.ConditionError === true
      // err === {
      //   message: 'Condition test failed',
      //   fn: fetch400,
      //   data: // the original data
      // }
  });
```

## Composition

As `promise-condition` input and output is a function returning a promise, you can compose them easily with other similar helpers ([see below](#see-also)).

In the example below, our `/data` API is a bit janky and might return HTTP 500 errors. We'll retry them twice before giving up.

```js
var promiseRetry = require('promise-retry');
var promiseCondition = require('promise-condition');

var retryTwice = promiseRetry({ retries: 2 });
var rejectAbove500 = promiseCondition(function (data) {
	return data.status < 500;
});

function fetchData() {
    // this call might return 500 sometimes
    return fetch('/data');
}

retryTwice(rejectAbove500(fetchData))().then(function(response){
  // yay !
}).catch(function(err){
  // we retried the call twice but always got 500s :(
});
```

# See also

`promise-condition` composes really well with the following promise helper:

* [`promise-retry`](https://github.com/songkick/promise-retry)
* [`promise-timeout`](https://github.com/songkick/promise-timeout)
* [`promise-condition`](https://github.com/songkick/promise-condition)
npm package: @songkick/promise-reject-status-above
Description: Rejects a promise returned by fetch() if status above threshold
Author: Arnaud Rinquin
Latest version: 1.0.0

# promise-reject-status-above [![Build Status](https://travis-ci.org/songkick/promise-reject-status-above.svg)](https://travis-ci.org/songkick/promise-promise-reject-status-above) [![Code Climate](https://codeclimate.com/github/songkick/promise-reject-status-above/badges/gpa.svg)](https://codeclimate.com/github/songkick/promise-reject-status-above) [![Test Coverage](https://codeclimate.com/github/songkick/promise-reject-status-above/badges/coverage.svg)](https://codeclimate.com/github/songkick/promise-reject-status-above/coverage)

Rejects a promise returned by `fetch()` if status above threshold

```js
var rejectStatusAbove = require('promise-reject-status-above');
var rejectAbove400 = rejectStatusAbove({status: 400});

function fetch200(){
    return fetch('/path/to/a/http-200-ok');
}

function fetch400(){
    return fetch('/path/to/a/http-400-bad-request');
}

rejectAbove400(fetch200)()
  .then(function(response){
    // the initial fetch response
  }).catch(function(err){
    // probably won't happen here, unless /200 doesn't return a HTTP - 200
  });

rejectAbove400(fetch400)()
  .then(function(response){
    // should not happen here
  }).catch(function(err){
      // err instanceof rejectStatusAbove.StatusAboveError === true
      // err === {
      //   message: 'Response status above accepted status',
      //   settings: {
      //     status: 400,
      //   },
      //   fn: fetch400,
      //   response: window.Response // the original fetch Response
      // }
  });
```

## Options

`status`: positive (>= 0) number. The returned promise will be rejected if the
response's status is equal or above this number.

## Composition

As `promise-reject-status-above` input and output is a function returning a promise, you can compose them easily with other simial helpers ([see below](#see-also)).

In the example below, our `/data` API is a bit janky and might return HTTP 500 errors. We'll retry them twice before giving up.

```js
var promiseRetry = require('promise-retry');
var rejectStatusAbove = require('promise-reject-status-above');

var retryTwice = promiseRetry({ retries: 2 });
var rejectAbove500 = rejectStatusAbove({status: 500});

function fetchData() {
    // this call might return 500 sometimes
    return fetch('/data');
}

retryTwice(rejectAbove500(fetchData))().then(function(response){
  // yay !
}).catch(function(err){
  // we retried the call twice but always got 500s :(
});
```

# See also

`promise-reject-status-above` composes really well with the following promise helper:

* [`promise-retry`](https://github.com/songkick/promise-retry)
* [`promise-timeout`](https://github.com/songkick/promise-timeout)
npm package: @songkick/promise-retry
Description: Retry a function until its returned promise succeeds
Author: Arnaud Rinquin
Latest version: 1.2.1

# promise-retry [![Build Status](https://travis-ci.org/songkick/promise-retry.svg)](https://travis-ci.org/songkick/promise-retry) [![Code Climate](https://codeclimate.com/github/songkick/promise-retry/badges/gpa.svg)](https://codeclimate.com/github/songkick/promise-retry) [![Test Coverage](https://codeclimate.com/github/songkick/promise-retry/badges/coverage.svg)](https://codeclimate.com/github/songkick/promise-retry/coverage)

Retry a function until its returned promise succeeds

```js
var retryPromise = require('promise-retry');
var retryTwiceEveryHundredMil = retryPromise({ retries: 2, delay: 100 });

retryTwiceEveryHundredMil(resolvesTheThirdTime)()
  .then(function(result){
    // never called here,
    // but if `retries` was >= 3,
    // result would be === 'yay!'
  }).catch(function(err){
    // err instanceof retryPromise.OutOfRetriesError === true
    // err === {
    //   message: 'Maximum retries count reached',
    //   settings: {
    //     retries: 2,
    //   },
    //   fn: resolvesTheThirdTime,
    //   errors: ['nope', 'nope', 'nope']
    // }
  });

var calls = 0;
function resolvesTheThirdTime() {
  if (++calls < 3) {
    return Promise.reject('nope');
  } else {
    return Promise.resolve('yay!');
  }
}
```

## Options

`retries`: positive (>= 0) number. The initial call doesn't count as a retry. If you set it to `3`, then your function might be called up to 4 times.

`delay`: the delay between retries or a `function(retryIndex){}` returning the delay. Does not apply on initial call. If a function is passed, it will receive the retry index as first argument (`1, 2, 3 ...`).

### Example:

```js
var retryWithIncreasingDelay = retryPromise({ retries: 10, delay: function(retryIndex) {
    return 100 * retryIndex;
});

/* time line:

0 > initial fail
0 + 100 > first retry
100 + 200 > second retry
300 + 300 > third retry
600 + 400 > fourth...

```

## Composition

As `promise-retry` input and output is a function returning a promise, you can compose them easily:

```js
var retryTwice = retryPromise({ retries: 2 });
var retryAterTwoSeconds = retryPromise({ retries: 1, delay: 2000 });
var getRejected = function(){
  return Promise.reject('nope');
};

retryOnceAterTwoSeconds(retryTwice(getRejected))().then(function(){
  // no way here
}).catch(function(){
  // at this point, `getRejected` will have been called 6 times
});
```

In the above exemple, the `getRejected`, this will happen:

1. Initial nest retry call
  1. initial `getRejected` call - callcount: 1
  1. first of two retries - callcount: 2
  1. second of two retries - callcount: 3
1. wait 2000ms
1. first and only retry
  1. initial `getRejected` call - callcount: 4
  1. first of two retries - callcount: 5
  1. second of two retries - callcount: 6
1. final rejection

# See also

`promise-retry` composes really well with the following promise helper:

* [`promise-timeout`](https://github.com/songkick/promise-timeout):
npm package: @songkick/promise-stopwatch
Description: Mesure a Promise resolution duration using Performance API with fallback to `new Data()`
Author: Arnaud Rinquin
Latest version: 0.0.1

# promise-stopwatch [![Build Status](https://travis-ci.org/songkick/promise-stopwatch.svg)](https://travis-ci.org/songkick/promise-stopwatch) [![Code Climate](https://codeclimate.com/github/songkick/promise-stopwatch/badges/gpa.svg)](https://codeclimate.com/github/songkick/promise-stopwatch) [![Test Coverage](https://codeclimate.com/github/songkick/promise-stopwatch/badges/coverage.svg)](https://codeclimate.com/github/songkick/promise-stopwatch/coverage)

Mesure a Promise resolution duration using Performance API with fallback to `new Data()`.

```js
var stopwatch = require('promise-stopwatch');
function resolveInOneSec() {
  return new Promise(function(resolve, reject){
    setTimeout(function(){
      resolve('yay');
    }, 1000);
  });
}

var settings = {}; // there is none available for now

stopwatch(settings)(resolveInOneSec)().then(function(response){
  var result = response.result;  // === 'yay'
  var duration = response.duration; // ~== 1000
  var settings = response.settings; // === {}

  console.log('Resolution took ' + duration + 'ms');

  return result; // return the result so you can handle it normally
});

function rejectInOneSec() {
  return new Promise(function(resolve, reject){
    setTimeout(function(){
      reject('nay');
    }, 1000);
  });
}

stopwatch(settings)(rejectInOneSec)().catch(function(response){
  var error = response.error;  // === 'nay'
  var duration = response.duration; // ~== 1000
  var settings = response.settings; // === {}

  console.log('Rejection took ' + duration + 'ms');

  throw error; // possibly re-throw the error so you can handle it normally
});
```

## Options

None, for now, but it might come, so we keep this signature similar to other promise helper and be able to some without change the API.

## See also

`promise-stopwatch` composes really well with the following promise helper:

* [`promise-retry`](https://github.com/songkick/promise-retry):
* [`promise-timeout`](https://github.com/songkick/promise-timeout):
* [`promise-reject-status-above`](https://github.com/songkick/promise-reject-status-above):
npm package: @songkick/promise-timeout
Description: Reject a promise if it does not resolve before specified delay
Author: Arnaud Rinquin
Latest version: 1.0.1

# promise-timeout [![Build Status](https://travis-ci.org/songkick/promise-timeout.svg)](https://travis-ci.org/songkick/promise-timeout) [![Code Climate](https://codeclimate.com/github/songkick/promise-timeout/badges/gpa.svg)](https://codeclimate.com/github/songkick/promise-timeout) [![Test Coverage](https://codeclimate.com/github/songkick/promise-timeout/badges/coverage.svg)](https://codeclimate.com/github/songkick/promise-timeout/coverage)

Reject a promise if it does not resolve before specified delay

```js
var timeoutPromise = require('promise-timeout');

var hundredMilTimeout = timeoutPromise({delay: 100 });
var boundToReject = hundredMilTimeout(resolvesAfter200);

boundToReject().then(function(result){
  // never called here,
  // but if `delay` was >= 300,
  // result would be === 'yay!'
}).catch(function(err){
  // err instanceof timeoutPromise.TimeoutError === true
  // err === {
  //   message: 'Promise resolution timed out',
  //   settings: {
  //    delay: 100
  //   },
  //   fn: resolvesAfter200
  // }
});

// or if the initial promise rejects before the delay:
//.catch(function(err){
  // err is the original error
//});

function resolvesAfter200() {
  return new Promise(function(resolve, reject){
    setTimeout(resolve, 200)
  });
}
```

## Options

`delay`: the delay before the promise gets rejected

## See also

`promise-timeout` composes really well with the following promise helper:

* [`promise-retry`](https://github.com/songkick/promise-retry):
npm package: @songlingqing/mcp-batch-processing
Description: MCP服务器用于分步审核可行性研究报告等文件的批处理
Author: songlingqing
Latest version: 0.0.1

# MCP Batch Processing

一共用于批量处理可行性研究报告或其他长文本的mcp.

## Installation

```bash
npx @songlingqing/mcp-batch-processing
```

Or install globally:

```bash
npm install -g @songlingqing/mcp-batch-processing
@songlingqing/mcp-batch-processing
```
## Configuration

### Environment Variables

Create a `.env` file in your project root or set the following environment variables:

```bash
# Required (if your service needs API access)
TAVILY_API_KEY=your_api_key_here

# Optional
LOG_LEVEL=info
BATCH_SIZE=100

## Usage

先将长文本分块，然后再比对知识库，最后用TAVILY进行内部搜索

### Basic Usage

```bash
# Using environment variables from .env file
@songlingqing/mcp-batch-processing

# Or set variables inline
TAVILY_API_KEY=your_key @songlingqing/mcp-batch-processing
```

## Requirements

- Node.js >= 16.0.0

## License

MIT
npm package: @songm_d/standalone-toolbar-service
Description: 独立的Stagewise工具栏服务 - 支持SRPC通信和WebSocket广播，可与MCP反馈收集器集成
Author: SMD
Latest version: 1.0.0

# @songm_d/standalone-toolbar-service

[![npm version](https://badge.fury.io/js/@smd%2Fstandalone-toolbar-service.svg)](https://badge.fury.io/js/@smd%2Fstandalone-toolbar-service)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Node.js Version](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)](https://nodejs.org/)

独立的Stagewise工具栏服务，支持SRPC通信和WebSocket广播。

## 快速启动

使用npx直接启动服务（无需安装）：

```bash
npx @smd/standalone-toolbar-service
```

## 服务端点

- **SRPC WebSocket**: `ws://localhost:5748` - Stagewise工具栏连接
- **广播WebSocket**: `ws://localhost:5748/broadcast` - WebService客户端连接
- **健康检查**: `http://localhost:5748/health`

## 开发

```bash
# 克隆项目
git clone <repository-url>
cd toolbar

# 安装依赖
npm install

# 开发模式
npm run dev

# 构建
npm run build

# 启动
npm start
```