open-index/open-npm huggingface dataset:
npm package: @jeanlauliac/upd-cli
Description: Find and run the locally installed `upd` utility
Author: Jean Lauliac
Latest version: 0.3.0

# upd-cli

Find and run the locally installed `upd` utility.

## Description

Different projects will want to use different versions of the `upd` utility
(package `@jeanlauliac/upd`), so it is preferable to not install it globally.
Instead, the utility should be installed locally, with the version specified in
your `package.json`. Then you can install this package globally, that will
find and run the locally installed version of `upd`.

## Installation

Example using `npm`:

    npm install -g @jeanlauliac/upd-cli
    npm install @jeanlauliac/upd
    upd

In practice you'll only have to install `upd-cli` once, and `upd` will be
installed as part of a project.
npm package: @jeanlauliac/upd-configure
Description: Generate `updfile.json` manifests for the `upd` utility
Author: Jean Lauliac
Latest version: 0.1.0

# upd-configure

Generate `updfile.json` manifests for the `upd` utility

## Description

When updating a project using the `upd` utility, you need to provide a file
called `updfile.json` at the root of the project, called the manifest. Even
though you can write this file manually, this is inconvenient because it is
formatted with bare JSON and it does not allow dynamic choices based on the
environment. For example, on one platform you may want to compile C++ using
`gcc` while on another you may want to use `clang++`.

To alleviate this limitation you can write a script, in any language, that will
have the responsability to generate the `updfile.json` file the first time the
project is worked on. Generally this script is named `configure`, or in the
case of JavaScript, `configure.js`.

`upd-configure` provide utility functions to generate such a manifest file.

## Interface

### upd_configure.Manifest

This class represents a manifest being built.

    const manifest = new Manifest();

#### manifest.cli_template(binary_path, args)

* `binary_path`: `string` The name or the path of the command to run. If this
  is just name, then it'll be search for in the `$PATH`.
* `args`: `Array<ArgsPart>` The argument templates.
* Returns: an opaque object representing the template.

This creates a new command-line template in the manifest and returns a handle
to that template. That handle can be used in update rules.

#### manifest.source(pattern)

TODO

#### manifest.rule(cli_template, inputs, output_pattern, dependencies)

TODO

#### manifest.export(dirname)

* `dirname`: `string`: the path of the project's root directory.

This writes the manifest to the `updfile.json` file. `dirname` should generally
just be set to `__dirname` if your `configure.js` script is at the root of the
project.
npm package: @jeanlazarou/react-time-range
Description: A time range component
Author: jeanlazarou
Latest version: 1.1.0

# @jeanlazarou/react-time-range

> A time range component

[![NPM](https://img.shields.io/npm/v/@jeanlazarou/react-time-range.svg)](https://www.npmjs.com/package/@jeanlazarou/react-time-range) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

## Demo

https://jeanlazarou.github.io/react-time-range/

## Install

```bash
yarn add @jeanlazarou/react-time-range
```

## Usage

```jsx
import React, { useState } from 'react'

import { TimeRange, TimeRangeBeforeNow } from "@jeanlazarou/react-time-range";

import '@jeanlazarou/react-time-range/dist/index.css'

function Example() {
  const [range, setRange] = useState({
    from: -9,
    to: -7
  });

  const rangeChanged = (range) => setRange(range);

  const humanizeHours = (from, to) => {
    const hours = to - from;

    return hours === 1 ? `1 hour` : `${hours} hours`;
  }

  return (
    <TimeRangeBeforeNow
      range={range}
      timespan={10}
      onChange={(x) => rangeChanged(x)}
      style={{ width: 700, height: 80 }}
    >
      <TimeRange.Now>Now</TimeRange.Now>
      <TimeRange.Size>{humanizeHours(range.from, range.to)}</TimeRange.Size>
      <TimeRange.Start>{\`\${range.from}h\`}</TimeRange.Start>
      <TimeRange.End>{\`\${range.to}h\`}</TimeRange.End>

      <TimeRange.Ticks every={1} />
    </TimeRangeBeforeNow>
  )
}
```

## Development notes

The component was build and deployed using [create-react-library](https://github.com/transitive-bullshit/create-react-library), following next article [How to publish a custom React component to NPM using Create React Library](https://dev.to/ramonak/how-to-publish-a-custom-react-component-to-npm-using-create-react-library-4bhi).

## License

MIT © [jeanlazarou](https://github.com/jeanlazarou)
npm package: @jeanmajid/windows-keylistener
Description: Low‑level keyboard hook for Windows
Latest version: 1.1.3

# @jeanmajid/windows-keylistener

A very basic Low‑level keyboard hook for Windows, with some additional functionality (currently only copyToClipboard)

## Installation

```sh
npm install @jeanmajid/windows-keylistener
```

## Usage

CommonJS (Node.js):

```javascript
const keylistener = require("@jeanmajid/windows-keylistener");

keylistener.start((keyCode) => {
    console.log("Key pressed:", keyCode);
});

// later...
keylistener.stop();

// copy a string to clipboard:
keylistener.copyToClipboard("Hello from clipboard");
```

ESM:

```javascript
import keylistener from "@jeanmajid/windows-keylistener";

keylistener.start((keyCode) => {
  console.log("Key pressed:", keyCode);
});
```

## API

- `start`  
  Starts listening; takes a callback `(keyCode: number) => void`.

- `stop`  
  Stops listening and clears the callback.

- `copyToClipboard`  
  Copies a given string into the Windows clipboard.

Type definitions are in keylistener.d.ts.

## License

MIT © 2025 jeanmajid
npm package: @jeanmemory/node
Description: Node.js SDK for Jean Memory - Power your Next.js and other Node.js backends with a perfect memory
Author: Jean Memory
Latest version: 2.0.8

# Jean Memory Node.js SDK

The official Node.js SDK for Jean Memory - Build personalized AI chatbots with persistent memory in your backend applications.

## Installation

```bash
npm install @jeanmemory/node
```

## Quick Start

```javascript
import { JeanAgent } from '@jeanmemory/node';

// Create agent
const agent = new JeanAgent({
  apiKey: process.env.JEAN_API_KEY,
  systemPrompt: 'You are a helpful assistant with memory.'
});

// For Next.js API routes
export const POST = agent.createHandler();

// For Express.js
app.post('/chat', agent.createHandler());
```

## Features

- 🧠 **Persistent Memory**: Conversations remember previous interactions
- 🚀 **Next.js Ready**: Built-in API route handlers
- 🔒 **Secure**: OAuth 2.1 authentication with JWT tokens
- ⚡ **Fast**: Optimized for serverless environments
- 🎯 **TypeScript**: Full type safety

## API Reference

### JeanAgent

```typescript
interface JeanAgentConfig {
  apiKey?: string;
  systemPrompt?: string;
  model?: string;
}

class JeanAgent {
  constructor(config: JeanAgentConfig)
  async process(message: string, userToken: string): Promise<Response>
  createHandler(): Function
}
```

### Example Usage

```javascript
import { JeanAgent } from '@jeanmemory/node';

const agent = new JeanAgent({
  apiKey: 'jean_sk_your_api_key',
  systemPrompt: 'You are a helpful tutor.',
  model: 'gpt-4o-mini'
});

// Next.js App Router
export async function POST(request) {
  const { message } = await request.json();
  const userToken = request.headers.get('authorization');
  
  return await agent.process(message, userToken);
}
```

## Links

- [Documentation](https://docs.jeanmemory.com)
- [GitHub](https://github.com/jean-technologies/jean-memory)
- [Website](https://jeanmemory.com)