open-index/open-npm huggingface dataset:
npm package: @koumoul/notif-vue
Description: Tools to manage a session from simple-directory in a vuejs project. Also a recipe/demo in ./demo/
Author: Alban Mouton
Latest version: 0.1.0

# notif-vue

Small utility to manage notifications in vuejs applications.

## Example integration

In you store:

```
import Vue from 'vue'
import Vuex from 'vuex'
import {notificationStore} from './notif-vue'

Vue.use(Vuex)

export default () => {
  return new Vuex.Store({
    modules: {notification: notificationStore},
    actions: {
      async doStuff() {
        try {
          await ...doing stuff
          dispatch('notification/queue', 'Stuff done')
        } catch(error) {
          dispatch('notification/queue', {error, msg: 'Error while doing stuff'})
        }
      }
    }
  })
}
```

In your page (example with [vuetify](https://vuetifyjs.com)):

```
<template>
  <v-app>

    <v-toolbar v-if="!!dataFairConfig" app scroll-off-screen>
      ...
    </v-toolbar>

    <v-content>
      ...
      <v-snackbar v-if="notif" ref="notificationSnackbar" v-model="notif" :color="notif.type" :timeout="0" class="notification" bottom>
        <div>
          <p>{{ notif.msg }}</p>
          <p v-if="notif.errorMsg" class="ml-3">{{ notif.errorMsg }}</p>
        </div>
        <v-btn flat icon @click.native="$store.dispatch('notification/unqueue')"><v-icon>close</v-icon></v-btn>
      </v-snackbar>
    </v-content>
  </v-app>
</template>

<script>
import {mapState, mapGetters} from 'vuex'

export default {
  computed: {
    ...mapState('notification', ['notif'])
  }
}

</script>
<style lang="less">
body .application {
  .notification .v-snack__content {
    height: auto;
    p {
      margin-bottom: 4px;
      margin-top: 4px;
    }
  }
}
</style>

```
npm package: @koumoul/nuxt-build-cache
Description: A small tool that manages a nuxt build directory based on current version and last build info.
Author: Alban Mouton
Latest version: 0.3.0

# nuxt-build-cache

A small tool that manages a nuxt build directory based on current version and last build info.

This is for people who do not wish to pre-build their nuxt projects for each environment but do not wish either to run the full build at each start/restart or replication of the service. A lock file is used to manage concurrency in case of service replication.


```js
const nuxtBuildCache = require('@koumoul/nuxt-build-cache')
const nuxtConfig = require('./nuxt.config')
const version = process.env.VERSION || require('./package.json').version
async function main() {
  // this will build only if necessary based on last build info and current version
  const nuxt = await nuxtBuildCache.prepare('my-project', version, nuxtConfig)
  const app = require('express')()
  app.use(nuxt.render)
  ...
}
```
npm package: @koumoul/nuxt-config-inject
Description: Hackish way to obtain "build once - deploy many times" with nuxtjs
Author: Alban Mouton
Latest version: 0.4.12

# nuxt-config-inject

Hackish way to obtain "build once - deploy many times" with nuxtjs.

## Why

[Nuxt](https://fr.nuxtjs.org/) is neat, but it doesn't respect principles that we consider very important. We want to [store config in the environment](https://12factor.net/config), we want to build docker images meant to be used in as many environments as possible without additional build steps.

[This issue](https://github.com/nuxt/nuxt.js/issues/5100) shows that the problem is not easily solved. There are code solutions for parts of the problem: [nuxt-env](https://github.com/samtgarson/nuxt-env), monkey-patching router base, defining `__webpack_public_path__`, etc. But we keep hitting roadblocks, incompatibility with some modules, regressions at upgrades.

This module is an attempt to solve the problem in a more brute force way. At build time a pseudo-config is transformed so that all values contain easily recognizable placeholders. Then at runtime all the files in `.nuxt` directory are read and the placeholders are replaced with actual values from current environment. This solution is kinda ugly and it certainly has limitations, but early tests are encouraging.

## Usage

```js
// somewhere at the start of nuxt.config.js

let config = require('config') // or other way to fetch a config from the environment

if (process.env.NODE_ENV === 'production') {
  const nuxtConfigInject = require('@koumoul/nuxt-config-inject')

  // take a config object and replace all values with placeholders that will be easy to find in built files afterwards
  if (process.argv.slice(-1)[0] === 'build') config = nuxtConfigInject.prepare(config)

  // read all built files and replace config placeholders with actual values
  else nuxtConfigInject.replace(config)
}
```

```shell
DEBUG=nuxt-config-inject NODE_ENV=production nuxt build
DEBUG=nuxt-config-inject NODE_ENV=production nuxt start
```

## Development

```
cd demo
DEBUG=nuxt-config-inject NODE_ENV=production npm run build
DEBUG=nuxt-config-inject NODE_ENV=production npm run start
```
npm package: @koumoul/schema-jtd
Description: JSON Schema and JSON Type Definition transformation utilities (contains the schema2td and td2schema commands)
Author: Alban Mouton
Latest version: 0.5.0

# schema-jtd
JSON Schema and JSON Type Definition transformation utilities (contains the schema2td and td2schema commands).

## CLI usage

```
npx --package @koumoul/schema-jtd schema2td --help
```

## Why

  - need help migrating from one format to another ?
  - need to make a tool written for one format work with the other at low cost ?
  - need create an Open API documentation from your JTDs ?
  - need to create code bindings from your schemas ?

## JTD or JSON Schema ?

![](doc/both-the-road-to-el-dorado.gif)

Don't be too fast in chosing one and rejecting the other. JSON schema is good for a self documented API that makes many of its validation rules explicit, JTD is great for non-ambiguous types and generating code bindings.

A possible sequence that includes both:

  1. write an API specification including self documented JSON schemas
  2. use `schema2td` to produce JTD equivalents
  3. use `jtd-codegen` to produce code bindings
  4. use JTD for fast parsing and serializing at both ends of your API endpoints
  5. use a JSON Schema validator to validate the payload with extra rules ignored by JTD

## Limitations

  - `schema2td` will reject schemas with ambiguous typing (for example a oneOf with different types)
    - this might be resolved in the future using a vocabulary to resolve ambiguous typing (for example by flagging a oneOf to be ignored)
  - `td2schema` will be missing some semantics
    - this is partially compoensated by mapping some JTD metadata to JSON Schema attributes
npm package: @koumoul/sd-express
Description: Middleware and router helpers to write expressjs applications that depend on simple-directory for authentication.
Author: Alban Mouton
Latest version: 1.1.3

# Simple Directory - Express

[![Build Status](https://travis-ci.org/koumoul-dev/sd-express.svg?branch=master)](https://travis-ci.org/koumoul-dev/sd-express)
[![Coverage Status](https://coveralls.io/repos/github/koumoul-dev/sd-express/badge.svg?branch=master)](https://coveralls.io/github/koumoul-dev/sd-express?branch=master)

Middleware and router helpers to write expressjs applications that depend on [simple-directory](https://koumoul-dev.github.io/simple-directory/) for authentication.

    npm i @koumoul/sd-express

Initialization:

```
const app = require('express')()
const session = require('simple-directory-client-express')({directoryUrl: 'http://my-simple-directory', publicUrl: 'http://localhost:8080'})

// These routes are authenticated. In your router req.user will be defined with the content of the session.
app.use('/api', session.auth, apiRouter)

// These routes can all be used as callback redirections from authentication (thanks to session.loginCallback)
// Also they will have req.user but without the cost of crypto verification and session prolongation (thanks to session.decode)
app.use('/ui', session.loginCallback, session.decode, uiRouter)
// The router exposes login, logout and ping routes to manage auth and session.
app.use('/session', session.router)
```

**TODO**: Proper documentation of options and functionalities. For now [the code is the doc](https://github.com/koumoul-dev/sd-express/blob/master/index.js).
npm package: @koumoul/sd-vue
Description: Tools to manage a session from simple-directory in a vuejs project. Also a recipe/demo in ./demo/
Author: Alban Mouton
Latest version: 1.3.0

# Simple Directory - Vue/Nuxt

Use as a module

    npm i @koumoul/sd-vue

Execute the demo/recipe project to show integration of authentication/session based on simple-directory in a nuxt project.

    cd demo
    npm i
    npm run dev

When developing you can build sd-vue then update the version in the demo using this command:

    npm run build-dev
npm package: @koumoul/vjsf
Description: Generate forms for the vuetify UI library (vuejs) based on annotated JSON schemas.
Author: Alban Mouton
Latest version: 4.3.0

# VJSF

*vuetify-json-schema-form* - *@koumoul/vjsf on npm*

Easily create beautiful forms that output valid data.

Based on [Vue.js](https://vuejs.org/) / [Vuetify](https://vuetifyjs.com/) / [JSON Schema](https://json-schema.org/) / [JSON Layout](https://github.com/json-layout/json-layout).

See [the documentation](https://koumoul-dev.github.io/vuetify-jsonschema-form/latest/).

See [the documentation for deprecated v2](https://koumoul-dev.github.io/vuetify-jsonschema-form/2.x/).

![](doc/static/vjsf.gif)

## Bug reports

Bug reports are created using github issues. The examples in the documentation include codepen links, as much as possible please save a duplicate codepen with the minimal schema/config to reproduce your problem.

## Contribute

See [CONTRIBUTE.md](./CONTRIBUTE.md).
npm package: @koumoul/vue-openapi
Description: Display API documentation that follow the OpenAPI 3.0 Specification
Author: Koumoul
Latest version: 0.12.5

# OpenAPI viewer component for VueJS

This [Vue.js](https://vuejs.org/) component is designed to easily browse and test a REST API described
with the [OpenAPI 3.0 Specification](https://github.com/OAI/OpenAPI-Specification) (formerly known as Swagger Specification). This component follows Google [Material Design](https://material.google.com/) principles and relies on the [Vue Material](https://github.com/marcosmoura/vue-material) framework. It also relies on [vue-resource](https://github.com/pagekit/vue-resource) to perform API requests.

See it in action :
 * https://koumoul.com/openapi-viewer/

## Install

npm :
```console
$ npm install --save vue-openapi
```

## Usage
```js
import Vue from 'vue'
import VueMaterial from 'vue-material'
import OpenApi from 'vue-openapi'
import 'vue-material/dist/vue-material.css'
import VueResource from 'vue-resource'

import jsonApi from './swagger.json'

Vue.use(VueMaterial)
Vue.use(VueResource)

new Vue({
  el: '#app',
  template: '<open-api v-if="jsonApi" :api="jsonApi" md-theme="\'default\'" :query-params="queryParams" :headers="headers"></open-api>',
  data: () => ({
    jsonApi: jsonApi,
    queryParams: {
      userId: 'john_doe'
    },
    headers: {
      api_key: 'my_api_key'
    }
  }),
  components: {
    OpenApi
  }
})
```

## Develop

Run webpack in watch mode:

    npm run dev

Then open test/index.html in your browser.

To switch between examples, modify the import "jsonApi" in test/app.js.

## License

[MIT License](license.md)

## Resources

* [Awesome OpenApi 3](https://github.com/Mermade/awesome-openapi3) lists various projects related to OpenApi 3.0.x
* [swagger2openapi](https://github.com/Mermade/swagger2openapi) lets you convert Swagger 2.0 definitions into OpenApi 3.0.x

## Similar projects

This project has been inspired by the following projects :

 * [angular-swagger-ui](https://github.com/Orange-OpenSource/angular-swagger-ui)
 * [angular-swagger-ui-material](https://github.com/darosh/angular-swagger-ui-material)
npm package: @koumoul/vuetify-jsonschema-form
Description: Generate forms for the vuetify UI library (vuejs) based on annotated JSON schemas.
Author: Alban Mouton
Latest version: 0.36.4

# vuetify-jsonschema-form

Generate forms for the [vuetify](https://vuetifyjs.com/en/) UI library (vuejs) based on annotated JSON schemas.

![](assets/demo-video.gif)

All basic types, nested objects, nested arrays, various display options, simple validation rules, custom content injected using slots, etc. For a view of all the functionalities check the [demo](https://koumoul-dev.github.io/vuetify-jsonschema-form/latest/).

Compatible with vuetify 1 and 2. Check this [alternative demo](https://koumoul-dev.github.io/vuetify-jsonschema-form/latest/vuetify1.html) for support of vuetify 1.

## Installation

```bash
npm i --save @koumoul/vuetify-jsonschema-form
```

## Usage

```html
<template>
  <v-form v-model="formValid">
    <v-jsonschema-form v-if="schema" :schema="schema" :model="dataObject" :options="options" @error="showError" @change="showChange" @input="showInput" />
  </v-form>
</template>

<script>
import Vue from 'vue'
import Vuetify from 'vuetify'
import 'vuetify/dist/vuetify.min.css'
import Draggable from 'vuedraggable'
import axios from 'axios'
import VueAxios from 'vue-axios'
import Swatches from 'vue-swatches'
import 'vue-swatches/dist/vue-swatches.min.css'
import VJsonschemaForm from '@koumoul/vuetify-jsonschema-form'
import '@koumoul/vuetify-jsonschema-form/dist/main.css'
import { Sketch } from 'vue-color'

Vue.use(Vuetify)
Vue.use(VueAxios, axios)

Vue.component('swatches', Swatches)
Vue.component('draggable', Draggable)
Vue.component('color-picker', Sketch)

export default {
  components: {VJsonschemaForm},
  data() {
    return {
      schema: {...},
      dataObject: {},
      formValid: false,
      options: {
        debug: false,
        disableAll: false,
        autoFoldObjects: true
      }
    }
  },
  methods: {
    showError(err) {
      window.alert(err)
    },
    showChange(e) {
      console.log('"change" event', e)
    },
    showInput(e) {
      console.log('"input" event', e)
    }
  }
}
</script>
```

The library can also be loaded from source if you use [Vuetify "à la carte"](https://vuetifyjs.com/en/framework/a-la-carte). In this case you will have to instruct your build tool to transpile the source with babel.

```js
import VJsonschemaForm from '@koumoul/vuetify-jsonschema-form/lib/index.vue'
```

I you don't use a build tool, and want to load the library through script tags, you can do something like this.

```html
...
<script src="https://cdn.jsdelivr.net/npm/@koumoul/vuetify-jsonschema-form@0.26/dist/main.js"></script>
<link href="https://cdn.jsdelivr.net/npm/@koumoul/vuetify-jsonschema-form@0.26/dist/main.css" rel="stylesheet">
...
<script>
  ...
  components: {
    "v-jsonschema-form": VJsonschemaForm.default
  }
  ...
</script>
```
npm package: @kounoike/textlint-formatter-rdjsonl
Description: A Reviewdog Diagnostic Format (rdjsonl) textlint-formatter
Author: KOUNOIKE Yuusuke
Latest version: 0.0.6

# textlint-formatter-rdjsonl


TODO: this line should checked by textlint with no-todo rule.

TODO: also this line

JavaScRipt
Java Script
JAVASCRIPT
npm package: @kouohhashi/number_formatter
Description: my first npm package
Author: Ko Ohashi
Latest version: 0.0.2

Number Formatter
=========

A small library that adds commas to numbers

## Installation

  `npm install @kouohhashi/number-formatter`

## Usage

    var numFormatter = require('@jdaudier/number-formatter');

    var formattedNum = numFormatter(35666);
  
  
  Output should be `35,666`


## Tests

  `npm test`

## Contributing

In lieu of a formal style guide, take care to maintain the existing coding style. Add unit tests for any new or changed functionality. Lint and test your code.

[![Build Status](https://travis-ci.org/kouohhashi/number-formatter.svg?branch=master)](https://travis-ci.org/kouohhashi/number-formatter)
[![Coverage Status](https://coveralls.io/repos/github/kouohhashi/number-formatter/badge.svg?branch=master)](https://coveralls.io/github/kouohhashi/number-formatter?branch=master)
npm package: @kouohhashi/wizardexpress
Description: This is a experimental node module for WizardExpress
Author: Ko Ohashi
Latest version: 1.0.4

Number Formatter
=========

A small library that adds commas to numbers

## Installation

  `npm install @kouohhashi/wizardexpress`

## Usage

    var numFormatter = require('@kouohhashi/wizardexpress');

    var formattedNum = numFormatter(35666);
  
  
  Output should be `35,666`


## Tests

  `npm test`

## Contributing

In lieu of a formal style guide, take care to maintain the existing coding style. Add unit tests for any new or changed functionality. Lint and test your code.
npm package: @kouovo/ph-cli
Description: A command-line interface tool for generating Pug resources manifests and locale files.
Latest version: 0.1.46

# @kouovo/ph-cli

A command-line interface tool for generating Pug resources manifests and locale files.

## Overview

The `@kouovo/ph-cli` package provides an interactive CLI tool that helps developers generate Pug template resources and locale files for their projects. It uses the `@clack/prompts` library for an intuitive interactive experience.

## Installation

```bash
npm install -g @kouovo/ph-cli
# or
pnpm add -g @kouovo/ph-cli
# or
yarn global add @kouovo/ph-cli
```

## Usage

Run the CLI tool using the binary name:

```bash
ovo
```

The tool will interactively prompt you for:

1. **Resources path** - Where your resources are located (default: `./src/assets`)
2. **Locales path** - Where your locale files are located (default: `./locales`)
3. **Resources output path** - Where to generate the Pug resources manifest (default: `./src/_gen.pug`)
4. **Locales output path** - Where to generate the locale files (default: `./src/locales`)

## Features

- Interactive prompts with validation
- Path validation using built-in heuristics
- Parallel generation of resources and locales
- Progress indicators and success/error feedback
- Graceful error handling and cancellation

## Path Validation

The CLI includes intelligent path validation that:
- Detects various path formats (Unix, Windows, relative)
- Validates common path separators (`/`, `\`)
- Recognizes relative path indicators (`./`, `../`)
- Handles Windows drive letters (`C:\`, `D:/`)
- Filters out URLs and invalid strings

## Dependencies

- `@clack/prompts` - Interactive command-line prompts
- `@kouovo/ph-shared` - Shared utilities for resource and locale generation

## Scripts

- `cli` - Run the CLI tool
- `build` - Build the TypeScript source
- `typecheck` - Run TypeScript type checking
- `bumpp` - Bump version numbers
- `release` - Publish the package

## License

MIT
npm package: @kouovo/utils
Description: To install dependencies:
Latest version: 0.0.1

# @kouovo/utils

To install dependencies:

```bash
bun install
```

To run:

```bash
bun run index.ts
```

This project was created using `bun init` in bun v1.3.11. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.
npm package: @koupr/ui
Description: Design system and React components.
Latest version: 1.15.0

# Koupr UI

Design system and React components.

## Installation

```shell
npm i @koupr/ui
```

Koupr UI is meant to work on top of Chakra UI: https://v2.chakra-ui.com/getting-started

## Usage

```tsx
import { theme } from '@koupr/ui'
import { createRoot } from 'react-dom/client'
import App from './App'

createRoot(document.getElementById('root') as HTMLElement).render(
  <ChakraProvider theme={theme}>
    <App />
  </ChakraProvider>,
)
```

## Releases

- Versions with _odd_ minor numbers like: `1.11` and `2.3` are LTS releases.
- Versions with _even_ minor numbers like: `1.10` and `2.2` are not meant to be relied upon in the long term.

## Development

Build library:

```shell
npm run build
```

Run Storybook:

```shell
npm run storybook
```

Build Storybook:

```shell
npm run build-storybook
```

## Licensing

Koupr UI is released under the [MIT License](LICENSE).
npm package: @kourosh-alasti/logger
Description: TypeScript-first Logging Library
Author: Kourosh Alasti
Latest version: 1.1.0
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# @kourosh-alasti/logger

[![npm version](https://badge.fury.io/js/@kourosh-alasti%2Flogger.svg)](https://badge.fury.io/js/@kourosh-alasti/logger)

[Examples](./examples/default.ts) &bullet; [Documentation](https://github.com/kourosh-alasti/logalot/wiki) &bullet; [Changelog](./CHANGELOG.md) &bullet; [License](./LICENSE)

A Zero Dependency TypeScript logging library

<div align="center"> <img src="examples/screenshot.png" alt="configured preset"> </div>

## Table of Contents

- [@kourosh-alasti/logger](#@kourosh-alasti/logger)
- [Table of Contents](#table-of-contents)
- [Installation](#installation)
- [Usage](#usage)
- [Contributing](#contributing)

## Installation

Add the package to your project via [npm](https://docs.npmjs.com/)

```bash
npm install @kourosh-alasti/logger
```

## Support Matrix

| Version | Supported |
| :-----: | :-------: |
| >=1.0.0 |    ✅    |

## Usage

There are two ways to add a logger to your application. The quickest way is using the default configuration.

```typescript
import { createLogger } from '@kourosh-alati/logger';

const logger = createLogger();

logger.log("Hello World!");
logger.warn("Hello World!");
logger.debug("Hello World!");
logger.error("Hello World!");
logger.info("Hello World!");
```

## Contributing

See [CONTRIBUTING.md](./CONTRIBUTING.md)
npm package: @kourvoisier/queb-transaction
Description: Made with create-react-library
Author: kourvoisier
Latest version: 1.3.0

# react-queb-transaction

> Made with create-react-library

[![NPM](https://img.shields.io/npm/v/react-queb-transaction.svg)](https://www.npmjs.com/package/react-queb-transaction) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

## Install

```bash
npm install --save react-queb-transaction
```

## Usage

```jsx
import React, { Component } from 'react'

import MyComponent from 'react-queb-transaction'
import 'react-queb-transaction/dist/index.css'

class Example extends Component {
  render() {
    return <MyComponent />
  }
}
```

## License

MIT © [apptomate-devops](https://github.com/apptomate-devops)
npm package: @kousaku-maron/note-search-mcp
Description: mcp server for note search
Author: @kousaku-maron
Latest version: 0.0.1

# Note Search MCP

A Model Context Protocol (MCP) server for fetching and searching content from Note.com, Japan's popular blogging platform.

## Features

- **Fetch individual articles**: Get any Note.com article converted to clean Markdown format
- **Creator top articles**: Retrieve the top 10 most liked articles from any Note.com creator
- **Smart HTML conversion**: Properly handles Note.com's HTML structure including images, embeds, and formatting
- **Social media embeds**: Converts Twitter and Instagram embeds to readable links
- **Rate limiting**: Built-in delays to be respectful to Note.com's servers

## Installation

```bash
npm install @kousaku-maron/note-search-mcp
```

## Usage

This MCP server provides two main tools:

### 1. `get_note`
Fetches a single Note.com article and converts it to Markdown.

**Parameters:**
- `notekey` (string): The article key from the Note.com URL

**Example:**
```
URL: https://note.com/username/n/n4f0c7b884789
Note key: n4f0c7b884789
```

### 2. `get_notes_by_creator`
Fetches the top 10 most liked articles from a Note.com creator.

**Parameters:**
- `creator` (string): The creator's username

**Example:**
```
URL: https://note.com/username
Creator: username
```

## Configuration

Add this to your MCP client configuration:

```json
{
  "mcpServers": {
    "note-search": {
      "command": "npx",
      "args": ["@kousaku-maron/note-search-mcp"]
    }
  }
}
```

## Output Format

Articles are converted to clean Markdown with:
- Proper heading hierarchy
- Image captions preserved
- Social media embeds converted to links
- Clean paragraph formatting
- Metadata including like counts and publish dates

## Rate Limiting

The server includes built-in rate limiting (1-second delays) to be respectful to Note.com's infrastructure when fetching multiple articles.

## Error Handling

The server provides clear error messages for common issues:
- Invalid note keys or creator names
- Articles not found (404 errors)
- Network connection problems
- Malformed API responses

## Development

```bash
# Install dependencies
pnpm install

# Build the project
pnpm run build

# Run tests
pnpm test

# Run tests in watch mode
pnpm run test:watch
```

## License

MIT

## Repository

https://github.com/kousaku-maron/mcp
npm package: @kousaku-maron/o3-search-mcp
Description: mcp server for web search by OpenAI o3 model
Author: @kousaku-maron
Latest version: 0.0.1

# @kousaku-maron/o3-search

An MCP (Model Context Protocol) server for web search powered by OpenAI's o3 model.

## Description

This package provides an MCP server that enables AI agents to perform advanced web searches using OpenAI's o3 model with web search capabilities. It's designed to help with finding latest information and troubleshooting errors through natural language queries.

## Installation

```bash
npm install @kousaku-maron/o3-search
```

## Prerequisites

- OpenAI API key with access to the o3 model
- Node.js environment

## Configuration

The server can be configured using environment variables:

- `OPENAI_API_KEY` (required): Your OpenAI API key
- `SEARCH_CONTEXT_SIZE` (optional): Search context size - "low", "medium", or "high" (default: "medium")
- `REASONING_EFFORT` (optional): Reasoning effort level for the o3 model (default: "medium")

## Usage

### As an MCP Server

Run the server directly:

```bash
@kousaku-maron/o3-search
```

Or use it in your MCP configuration file:

```json
{
  "mcpServers": {
    "o3-search": {
      "command": "@kousaku-maron/o3-search"
    }
  }
}
```

### Available Tools

- **o3-search**: An AI agent with advanced web search capabilities
  - Input: Natural language query in English
  - Output: Search results and analysis from the o3 model

## Example

```javascript
// The tool accepts natural language queries like:
"What are the latest developments in AI?"
"How to fix TypeError in Node.js?"
"Current weather in Tokyo"
```

## Development

```bash
# Build the project
pnpm run build

# Run tests
pnpm run test

# Watch mode for tests
pnpm run test:watch

# Coverage report
pnpm run test:coverage
```

## License

MIT

## Repository

[GitHub Repository](https://github.com/kousaku-maron/mcp)
npm package: @kousaku-maron/template-manager
Description: Scaffold projects from repository templates.
Latest version: 0.1.1

# @kousaku-maron/template-manager

npx コマンドでテンプレートをダウンロードし、プロジェクトをセットアップできます。

## 使い方

```bash
npx @kousaku-maron/template-manager --template=<テンプレート名> --dir=<出力先ディレクトリ>
```

### テンプレート一覧

| テンプレート名 | 説明 |
| --- | --- |
| `astro-cloudflare-blog` | Astro + Cloudflare を使ったブログテンプレート |
| `tauri-cloudflare-todo` | Tauri + Hono + better-auth で作る認証付きカンバンテンプレート |

### 例

```bash
npx @kousaku-maron/template-manager --template=astro-cloudflare-blog --dir=my-blog
npx @kousaku-maron/template-manager --template=tauri-cloudflare-todo --dir=my-kanban
```
npm package: @koush/arlo
Description: JS library for Arlo Cameras
Author: JP
Latest version: 1.2.4

<span align="center">

<p>JS library for 
<br>
<br>
<br>
<a href="https://arlo.com"><img alt="arlo" src="https://www.arlo.com/images/arlop/arlo-logo.png" width="140px"></a>
<br>
<br>
<br>
<p>Based on the awesome work done by:</p>
<p><a href="https://github.com/EpicKris/node-arlo">EpicKris (node-arlo)</a></p>
<p><a href="https://github.com/jeffreydwalter/arlo">jeffreydwalter (python arlo)</a></p>
<p><a href="https://github.com/m0urs/arlo-cl">m0urs (python arlo-cli)</a></p>
<br>
<br>
</span>
npm package: @koush/axios-digest-auth
Description: axios-like http digest auth
Latest version: 0.8.7

# axios-digest-auth

[![npm](https://img.shields.io/badge/npm-0.7.0-yellow)](https://www.npmjs.com/package/@mhoc/axios-digest-auth)
[![docs](https://img.shields.io/badge/documentation-0.7.0-blue)](https://axios-digest-auth.mhoc.co)

A library which implements HTTP digest authentication in a manner which should be familiar to any 
project which also uses Axios.

```
$ npm i @mhoc/axios-digest-auth
```

Check out [the documentation site](https://axios-digest-auth.mhoc.co) for more information 
on usage.
npm package: @koush/chatsh
Description: A terminal-based shell assistant that connects your shell session to an LLM for context-aware help.
Author: Koushik Dutta
Latest version: 1.0.16

# @koush/chatsh

A terminal-based shell assistant that connects your shell session to an LLM for context-aware help.

## Quick Start

```bash
$ npx @koush/chatsh
$ ls /nonexistent
ls: /nonexistent: No such file or directory

$ help why did this command fail

The command failed because the directory /nonexistent does not exist. 
The ls command lists directory contents, but it cannot find a path 
that doesn't exist on your filesystem. Try ls without arguments to 
see your current directory, or use ls / to list the root directory.

```

The LLM sees your entire terminal transcript and provides context-aware assistance.

## Configuration

Create `~/.chatsh/chatsh.jsonc`:

```jsonc
// OpenAI
{
  "provider": "openai",
  "model": "gpt-4-turbo",
  "options": {
    "apiKey": "sk-..."  // or set OPENAI_API_KEY env var
  }
}

// Anthropic (Claude)
{
  "provider": "anthropic",
  "model": "claude-sonnet-4-5",
  "options": {
    "apiKey": "sk-ant-..."  // or set ANTHROPIC_API_KEY env var
  }
}

// Google (Gemini)
{
  "provider": "google",
  "model": "gemini-2.5-flash",
  "options": {
    "apiKey": "..."  // or set GOOGLE_GENERATIVE_AI_API_KEY env var
  }
}

// OpenAI-Compatible (Custom Endpoint)
{
  "provider": "openai-compatible",
  "model": "your-model-name",
  "options": {
    "name": "custom",
    "baseURL": "http://localhost:8000/v1",
    "apiKey": "your-api-key"
  }
}
```

## Features

- Wraps zsh/bash/fish in a PTY session
- Multiple LLM providers (OpenAI, Anthropic, Google, OpenAI-compatible)
- Maintains full terminal history
- Resets transcript on terminal clear

## How it works

1. Spawns an interactive shell in a pseudo-terminal (PTY)
2. Starts a local HTTP server on a random port
3. Tracks all terminal output in a transcript
4. The `help` command sends the transcript + your question to an LLM
5. LLM response streams back to your terminal

## License

ISC
npm package: @koush/chrome-net
Description: Use the Node `net` API in Chrome Apps
Author: Feross Aboukhadijeh
Latest version: 3.3.3

# chrome-net [![travis][travis-image]][travis-url] [![npm][npm-image]][npm-url] [![downloads][downloads-image]][downloads-url] [![javascript style guide][standard-image]][standard-url]

[travis-image]: https://img.shields.io/travis/feross/chrome-net/master.svg
[travis-url]: https://travis-ci.org/feross/chrome-net
[npm-image]: https://img.shields.io/npm/v/chrome-net.svg
[npm-url]: https://npmjs.org/package/chrome-net
[downloads-image]: https://img.shields.io/npm/dm/chrome-net.svg
[downloads-url]: https://npmjs.org/package/chrome-net
[standard-image]: https://img.shields.io/badge/code_style-standard-brightgreen.svg
[standard-url]: https://standardjs.com

### Use the Node `net` API in Chrome Apps

This module lets you use the Node.js [net](https://nodejs.org/api/net.html) (TCP) API in [Chrome Packaged Apps](https://developer.chrome.com/apps/about_apps).

Instead of learning the quirks of Chrome's `chrome.sockets` API for networking in Chrome Apps just **use the higher-level node API you're familiar with**. Then, compile your code with [browserify](https://github.com/substack/node-browserify) and you're all set!

## install

```
npm install chrome-net
```

## methods

Use node's `net` API, including all parameter list shorthands and variations.

Example TCP client:

```js
var net = require('chrome-net')

var client = net.createConnection({
  port: 1337,
  host: '127.0.0.1'
})

client.write('beep')

client.on('data', function (data) {
  console.log(data)
})

// .pipe() streaming API works too!

```

Example TCP server:

```js
var net = require('chrome-net')

var server = net.createServer()

server.on('listening', function () {
  console.log('listening')
})

server.on('connection', function (sock) {
  console.log('Connection from ' + sock.remoteAddress + ':' + sock.remotePort)
  sock.on('data', function (data) {
    console.log(data)
  })
})

server.listen(1337)

```

See nodejs.org for full API documentation: [net](https://nodejs.org/api/net.html)

## contribute

To run tests, use `npm test`. The tests will run TCP and UDP servers and launch a few different Chrome Packaged Apps with browserified client code. The tests currently require Chrome on Windows or Chrome Canary on Mac. If you're on Linux, feel free to send a pull request to fix this limitation.

## license

MIT. Copyright (c) [Feross Aboukhadijeh](http://feross.org), John Hiesey & Jan Schär.
npm package: @koush/push-receiver
Description: A module to subscribe to GCM/FCM and receive notifications within a node process.
Author: MatthieuLemoine
Latest version: 3.1.4

# push-receiver

A library to subscribe to GCM/FCM and receive notifications within a node process.

For [Electron](https://github.com/electron/electron), you can use [electron-push-receiver](https://github.com/MatthieuLemoine/electron-push-receiver) instead which provides a convenient wrapper.

See [this blog post](https://medium.com/@MatthieuLemoine/my-journey-to-bring-web-push-support-to-node-and-electron-ce70eea1c0b0) for more details.

## When should I use `push-receiver` ?

- I want to **receive** push notifications sent using Firebase Cloud Messaging in an [electron](https://github.com/electron/electron) desktop application.
- I want to communicate with a node process/server using Firebase Cloud Messaging infrastructure.

## When should I not use `push-receiver` ?

- I want to **send** push notifications (use the firebase SDK instead)
- My application is running on a FCM supported platform (Android, iOS, Web).

## Install

`
npm i -S @eneris/push-receiver
`

## Requirements

- Node v16 (async/await/randomUUID support)
- Firebase sender id to receive notification
- Firebase serverKey to send notification (optional)


## Usage

### ClientConfig

```typescript
interface ClientConfig {
    credentials?: Credentials // Will be generated if missing - save this after first use!
    persistentIds?: PersistentId[] // Default - []
    senderId: string // Required
    bundleId?: string // Default - 'receiver.push.com'
    chromeId?: string // Default - 'org.chromium.linux'
    chromeVersion?: string // Default - '94.0.4606.51'
    skipFcmRegistration?: boolean // Default - false
    logLevel?: keyof typeof LogLevels // 'NONE'|'DEBUG'|'VERBOSE' - default: 'NONE'
    vapidKey?: string // Default - default firebase VAPID key
    heartbeatIntervalMs?: number // Default - 5 * 60 * 1000
}
```

### Node example

```javascript
import { PushReceiver } from '@eneris/push-receiver'
import { argv as parsedArgs } from 'yargs'

if (!parsedArgs.senderId) {
    console.error('Missing senderId')
    return
}

(async () => {
    const instance = new PushReceiver({
        logLevel: parsedArgs.logLevel || 'DEBUG',
        senderId: parsedArgs.senderId,
        persistentIds: [], // Recover stored ids of all previous notifications
    })

    const stopListeningToCredentials = instance.onCredentialsChanged(({ oldCredentials, newCredentials }) => {
        console.log('Client generated new credentials.', newCredentials)
        // Save them somewhere! And decide if thing are needed to re-subscribe
    })

    const stopListeningToNotifications = instance.onNotification(notification => {
        // Do someting with the notification
        console.log('Notification received', notification)
    })

    await instance.connect()

    if (parsedArgs.serverId) {
        await instance.testMessage(parsedArgs.serverId)
    }

    stopListeningToCredentials()
    stopListeningToNotifications()
    instance.destroy()
})()
```