open-index/open-npm huggingface dataset:
npm package: @getplumb/cli
Description: Plumb CLI — memory management and AI context tools
Author: Plumb Team
Latest version: 0.1.8

# plumb-memory

CLI for managing and exporting Plumb memory data.

## Installation

```bash
npm install -g plumb-memory
```

## Usage

### Export memories

```bash
plumb export
```

Exports all memories to stdout in JSON format.

Options:
- `--format json|csv` — output format (default: json)
- `--output <file>` — write to file instead of stdout

### Check status

```bash
plumb status
```

Shows connection status and memory count.

### Connect to cloud

```bash
plumb connect
```

Link your local Plumb instance to the cloud sync service.

## Documentation

Full docs at [docs.getplumb.dev](https://docs.getplumb.dev)

## License

MIT
npm package: @getplumb/core
Description: Plumb memory engine — storage abstraction, types, and local SQLite driver
Author: Clay Waters
Latest version: 0.4.14

# @getplumb/core

> Cross-session AI memory — storage abstraction, types, and local SQLite driver

The core library for [Plumb](https://plumb.run) — a local-first, MCP-native memory layer for AI agents.

## What it does

- **Two-layer memory:** raw conversation log (Layer 1) + extracted fact graph (Layer 2)
- **Hybrid search:** BM25 + semantic vectors + RRF fusion + cross-encoder reranking
- **Local storage:** SQLite WASM, zero native dependencies (works on all platforms)
- **Pluggable LLM:** bring your own OpenAI or Anthropic client for fact extraction

## Install

```bash
npm install @getplumb/core
```

## Quick start

```ts
import { LocalStore } from '@getplumb/core';

// Create store (async factory required for WASM initialization)
const store = await LocalStore.create({ dbPath: '~/.plumb/memory.db' });

// Ingest a conversation turn
await store.ingest({
  sessionId: 'my-session',
  userMessage: 'I prefer TypeScript over Python',
  agentResponse: 'Noted! TypeScript it is.',
  timestamp: new Date(),
  source: 'openclaw'
});

// Retrieve relevant memory
const results = await store.searchRawLog('TypeScript preferences', 5);
```

## Links

- [Docs](https://docs.getplumb.dev)
- [GitHub](https://github.com/getplumb/plumb)
- [plumb.run](https://plumb.run)

## License

MIT
npm package: @getplumb/mcp-server
Description: Plumb MCP stdio server — exposes memory tools to Claude and other MCP clients
Author: Clay Waters
Latest version: 0.4.8

# @getplumb/mcp-server

Local MCP server that provides memory tools to Claude Desktop and other MCP clients.

## Installation

```bash
npm install -g @getplumb/mcp-server
```

## Quick Start

Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):

```json
{
  "mcpServers": {
    "plumb": {
      "command": "plumb-mcp"
    }
  }
}
```

Restart Claude Desktop. You'll now have access to memory tools:
- `plumb_add_memory` — store thoughts, facts, and context
- `plumb_search_memory` — retrieve relevant memories
- `plumb_list_memory` — browse all memories

## Documentation

Full docs at [plumb.run](https://plumb.run)

## License

MIT
npm package: @getplumb/openclaw-plugin
Description: Plumb OpenClaw plugin — auto-ingest and memory injection for OpenClaw
Latest version: 0.1.3
Deprecated: DEPRECATED: This package has moved to @getplumb/plumb. Install with: openclaw plugins install @getplumb/plumb

# @getplumb/openclaw-plugin

> Plumb memory plugin for [OpenClaw](https://openclaw.ai)

Automatically ingests conversations and injects relevant memory context into every AI response — no "remember this" commands needed.

## What it does

- **Auto-ingest:** every conversation turn is stored to your local Plumb DB after the response
- **Context injection:** relevant memory facts are injected into the system prompt before each response
- **Shadow mode:** try it without injection first — observe what would be injected

## Install

```bash
npm install @getplumb/openclaw-plugin
```

Then add to your `openclaw.json`:

```json
{
  "plugins": {
    "plumb": {
      "package": "@getplumb/openclaw-plugin",
      "dbPath": "~/.plumb/memory.db",
      "userId": "your-user-id",
      "shadowMode": false
    }
  },
  "slots": {
    "memory": "plumb"
  }
}
```

## Links

- [Docs](https://docs.getplumb.dev)
- [GitHub](https://github.com/getplumb/plumb)
- [getplumb.dev](https://getplumb.dev)

## License

MIT
npm package: @getplumb/plumb-openclaw
Description: Plumb OpenClaw plugin — auto-ingest and memory injection for OpenClaw
Latest version: 0.1.8

# @getplumb/plumb-openclaw

> Persistent memory for [OpenClaw](https://openclaw.ai) — automatic ingest and context injection, no setup required.

## Install

```bash
openclaw plugins install @getplumb/plumb-openclaw
```

Then restart the gateway to activate:

```bash
openclaw gateway restart
```

That's it. Plumb starts learning from your conversations immediately.

## What it does

- **Auto-ingest** — every conversation turn is stored to a local SQLite DB after the response
- **Context injection** — relevant memory facts are injected into the system prompt before each response
- **Shadow mode** — observe what would be injected without actually injecting it (good for testing)
- **Local only** — all data stays on your machine; nothing is sent to external servers

## Configuration

Configuration lives under `plugins.entries.plumb.config` in your `openclaw.json`. All fields are optional — defaults work out of the box.

| Field | Default | Description |
|---|---|---|
| `dbPath` | `~/.plumb/memory.db` | Path to the SQLite database file |
| `userId` | `default` | User ID for scoping memory |
| `shadowMode` | `false` | If true, retrieves context but does not inject it |
| `llmProvider` | *(inherits from OpenClaw)* | LLM provider for fact extraction (`openai`, `anthropic`, `ollama`, `openai-compatible`) |
| `llmModel` | *(inherits from OpenClaw)* | Model for fact extraction |
| `llmApiKey` | *(inherits from OpenClaw)* | API key for fact extraction |

To configure via CLI:

```bash
openclaw config set plugins.entries.plumb.config.userId "clay"
openclaw gateway restart
```

## Uninstall

```bash
openclaw plugins uninstall plumb
openclaw gateway restart
```

## Links

- [Plumb](https://getplumb.dev)
- [OpenClaw](https://openclaw.ai)

## License

MIT
npm package: @getportal/mcp
Description: MCP server for Portal - Autonomous service signup for AI agents
Author: OpenHolly
Latest version: 0.1.0

# Portal MCP

MCP server for [Portal](https://getportal.dev) — Autonomous service signup for AI agents.

## What is Portal?

Portal lets AI agents autonomously sign up for services and retrieve credentials. Pay per signup with USDC on Base via x402 — no human intervention needed.

## Installation

### With Claude Desktop / Cursor

Add to your `mcp.json`:

```json
{
  "mcpServers": {
    "portal": {
      "command": "npx",
      "args": ["github:moltyfromclaw/portal-mcp"]
    }
  }
}
```

### Direct Usage (npx from GitHub)

```bash
npx github:moltyfromclaw/portal-mcp
```

### Clone and Run

```bash
git clone https://github.com/moltyfromclaw/portal-mcp.git
cd portal-mcp
npm install
npm start
```

## Wallet Setup

On first run, Portal creates a wallet at `~/.portal/wallet.json`. You need to fund this wallet with USDC on Base network before making paid API calls.

Use the `portal_wallet` tool to get your wallet address and check balance.

## Available Tools

### `portal_services`
List all services that Portal can sign up for, with pricing.

### `portal_signup`
Create a new account signup job. 

**Parameters:**
- `service` (required): Service ID (resend, railway, vercel, supabase, cloudflare)
- `email_mode`: "portal_managed" (default) or "agent_provided"
- `agent_email`: Required if email_mode is "agent_provided"
- `callback_url`: Optional webhook URL

### `portal_status`
Check the status of a signup job.

**Parameters:**
- `job_id` (required): The job ID from portal_signup

### `portal_credentials`
Retrieve credentials for a completed signup. **ONE-TIME RETRIEVAL** — credentials are deleted after access!

**Parameters:**
- `job_id` (required): The job ID of the completed signup

### `portal_wallet`
Get your Portal wallet address and USDC balance on Base.

## Supported Services

| Service | Price | Time |
|---------|-------|------|
| Resend | $0.50 | ~20s |
| Railway | $0.50 | ~25s |
| Vercel | $1.00 | ~30s |
| Supabase | $1.00 | ~35s |
| Cloudflare | $1.00 | ~30s |

## Example Workflow

```
1. Use portal_services to see available services
2. Use portal_signup with service="resend"
3. Poll portal_status until status="completed"
4. Use portal_credentials to retrieve API key (one-time!)
5. Save the credentials - they won't be shown again
```

## Environment Variables

- `PORTAL_API`: Override the Portal API URL (default: https://getportal.dev)

## Links

- [Portal Website](https://getportal.dev)
- [Documentation](https://getportal.dev/docs)
- [llms.txt](https://getportal.dev/llms.txt)
- [GitHub](https://github.com/moltyfromclaw/portal)

## License

MIT
npm package: @getproductstack/jobs
Description: Simple, type-safe functions that can be triggered as background jobs or queued. Built on top of [Upstash QStash](https://upstash.com/docs/qstash/) for Next.js and Vercel.
Author: Ryan T. Brown
Latest version: 0.3.0

# ProductStack Jobs

Simple, type-safe functions that can be triggered as background jobs or queued. Built on top of [Upstash QStash](https://upstash.com/docs/qstash/) for Next.js and Vercel.

## Example

```ts
export const job = createJob("hello", async ({ name }: { name: string }) => {
  console.log(`Hello from the background, ${name}!`);
});

await job.trigger({ name: "world" });
```

## Motivation

Background jobs, events, queues, etc. are notoriously missing from Next.js and Vercel. There are services like [Inngest](https://inngest.com/) and [Trigger.dev](https://trigger.dev/) that provide these async workflows but they are not as simple or as cost-effective as Upstash QStash.

This library aims to improve the developer experience when using QStash by treating jobs as first-class objects that can be triggered and/or queued.

## Get started

Before you get started, make sure you have your [QStash token and signing keys](https://upstash.com/docs/qstash/overall/getstarted#get-your-token).

**Install the package**

```sh
pnpm add @getproductstack/jobs
```
  
**Create a route handler**

```ts
// app/api/jobs/route.ts
import { createHandler } from "@productstack/jobs/nextjs";

export const { POST } = createHandler({
  jobs: [// jobs you define here],
  receiver: new Receiver({
    currentSigningKey: process.env.QSTASH_CURRENT_SIGNING_KEY,
    nextSigningKey: process.env.QSTASH_NEXT_SIGNING_KEY,
  }),
});
```

**Configure the client**

```ts
// lib/jobs.ts
import { createManager } from "@productstack/jobs";

const { createJob } = createManager({
  token: "qstash-token",
  // the URL for theroute you created in step 1
  endpoint: "https://my-app.com/api/jobs",
});
```

**Define and register a job**

```ts
export const myJob = createJob("my-job", async (payload) => {
  console.log(payload);
});

// app/api/queue/route.ts
export const { POST } = createHandler({
  jobs: [myJob],
});
```

**Trigger the job**

```ts
await myJob.trigger({ name: "world" });
```
npm package: @getprofile/types
Description: Shared Profile types for GetProfile AI
Author: Egor Miliukov
Latest version: 1.0.0
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# @getprofile/types

**Shared TypeScript definitions for GetProfile AI**  
A standalone package providing type-safe interfaces for the `Profile` data structure, enabling consistency across backend, frontend, and Node.js client codebases.

---

## Installation

```bash
npm install @getprofile/types
# or with yarn
yarn add @getprofile/types
```

---

## Usage

Import your types anywhere:

```ts
import type { Profile, ScoredValue } from "@getprofile/types";

function handleProfile(profile: Profile) {
  console.log(`Profile ${profile.profile_id} status: ${profile.status}`);
}
```

---

## Key Types

### `ScoredValue<T = string>`

Represents a value with associated confidence (0–1):

```ts
export interface ScoredValue<T = string> {
  value: T;
  confidence: number;
}
```

### `Profile`

Comprehensive user profile schema:

- **Metadata**: `profile_id`, `tenant_id`, `status` (`processing` | `summarizing` | `ready`)
- **Core Info**: name, age, gender, etc., each with `ScoredValue`
- **Interest Categories**: hobbies, music, books, etc.
- **Personality**: traits, mood trends
- **Memories**: events with timestamps and importance
- **Preferences**: conversation style, topics to avoid
- **Timestamps**: tracked per section
- **Update Log**: history of changes
- **Dates**: `created_at`, `last_updated` (both `Date`)
- **Optional Summary**

Read full definitions in [`types/Profile.ts`](https://github.com/getprofile/types/blob/main/index.d.ts).

---

## Development & Publishing

1. Clone repo & install dependencies:

   ```bash
   git clone https://github.com/getprofile/types.git
   cd types
   npm install
   ```

2. Publish to npm:

   ```
   npm login
   npm publish --access public
   ```

No build step required, as this package is pure TypeScript.

---

## Contributing

Contributions welcome! Open a PR to refine types, add fields, or improve examples. Please follow project guidelines, include tests (if applicable), and update version/tags upon release.

---

## License

MIT © GetProfile AI
npm package: @getpromptly/mcp-server
Description: MCP server for capturing AI coding conversations
Latest version: 0.1.11

# @getpromptly/mcp-server

MCP server for capturing AI coding conversations. Used by [@getpromptly/cli](https://www.npmjs.com/package/@getpromptly/cli).

## Overview

This package provides an MCP (Model Context Protocol) server that integrates with any MCP-compatible AI coding tool (Claude Code, Gemini CLI, Codex CLI, Cursor, Windsurf, VS Code/Copilot) to capture conversation turns, token usage, and tool calls during development sessions.

## Installation

Installed automatically when you run `promptly init` from [@getpromptly/cli](https://www.npmjs.com/package/@getpromptly/cli). You don't need to install this separately.

```bash
npm i -g @getpromptly/cli
promptly init    # Select which AI tools to configure
```

The init command auto-detects installed AI tools and lets you choose which ones to configure with this MCP server.

## MCP Tools

| Tool | Description |
|------|-------------|
| `promptly_start` | Initialize buffer for a ticket |
| `promptly_log` | Log a conversation turn (role, content, model, tokens) |
| `promptly_status` | Check active session stats |
| `promptly_finish` | Finalize session and write to SQLite |

## Links

- [Website](https://getpromptly.xyz)
- [GitHub](https://github.com/akoskomuves/promptly)
- [CLI package](https://www.npmjs.com/package/@getpromptly/cli)

## License

MIT
npm package: @getpromptly/shared
Description: Shared types and utilities for Promptly
Latest version: 0.1.10

# @getpromptly/shared

Shared TypeScript types and utilities for [Promptly](https://getpromptly.xyz).

## Usage

```typescript
import type { LocalSession, ConversationTurn, CliConfig } from "@getpromptly/shared";
```

## Links

- [Website](https://getpromptly.xyz)
- [GitHub](https://github.com/akoskomuves/promptly)

## License

MIT
npm package: @getpubby/sdk
Description: Pubby SDK for real-time messaging - a Pusher-compatible alternative
Author: Pubby
Latest version: 0.2.0

# @getpubby/sdk

Official SDK for [Pubby](https://github.com/Art-of-Technology/pubby) - a self-hosted, Pusher-compatible real-time messaging platform.

## Installation

```bash
npm install @getpubby/sdk
```

## Quick Start

### Client (Browser/Node.js)

```typescript
import { Pubby } from "@getpubby/sdk";

const pubby = new Pubby("your-app-key", {
  wsHost: "wss://your-socket-server.com",
  authEndpoint: "/api/pubby/auth",
});

pubby.connect();

const channel = pubby.subscribe("my-channel");
channel.bind("my-event", (data) => {
  console.log(data);
});
```

### Server (Node.js)

```typescript
import { PubbyServer } from "@getpubby/sdk/server";

const pubby = new PubbyServer({
  appId: "your-app-id",
  key: "your-app-key",
  secret: "your-app-secret",
});

// Trigger events
await pubby.trigger("my-channel", "my-event", { message: "Hello!" });

// Authenticate private channels
const auth = pubby.authenticatePrivateChannel(socketId, channelName);
```

## Channel Types

| Prefix | Type | Auth Required |
|--------|------|---------------|
| (none) | Public | No |
| `private-` | Private | Yes |
| `presence-` | Presence | Yes |

## Documentation

- [Full Documentation](https://github.com/Art-of-Technology/pubby)
- [AI Agent Guide](https://github.com/Art-of-Technology/pubby/blob/main/packages/sdk/AGENTS.md)

## License

MIT
npm package: @getresponse/eslint-config
Description: GetResponse ESLint shareable config
Author: GetResponse
Latest version: 8.1.1

# @getresponse/eslint-config

[![npm version](https://badge.fury.io/js/@getresponse%2Feslint-config.svg)](https://badge.fury.io/js/@getresponse%2Feslint-config)
[![Build Status](https://github.com/GetResponse/eslint-config-getresponse/actions/workflows/main.yml/badge.svg)](https://github.com/GetResponse/eslint-config-getresponse/actions)
![Dependencies](https://img.shields.io/librariesio/github/GetResponse/eslint-config-getresponse.svg)
[![License](http://img.shields.io/:license-mit-blue.svg)](http://badges.mit-license.org)

---

An opinionated ESLint ruleset targeting TypeScript + React web apps

## Installation

1. Install `eslint` and `@getresponse/eslint-config`:

   ```bash
   npm i -D eslint @getresponse/eslint-config
   ```

2. Add `"extends": "@getresponse/eslint-config"` to your ESLint [configuration file](https://eslint.org/docs/latest/user-guide/configuring/configuration-files)

## Rules list
The web version of the rules list is available on [GitHub Pages](https://getresponse.github.io/eslint-config-getresponse/)
npm package: @getresponse/stylelint-config
Description: GetResponse stylelint shareable config
Author: GetResponse
Latest version: 3.3.0

# @getresponse/stylelint-config

[![npm version](https://badge.fury.io/js/@getresponse%2Fstylelint-config.svg)](https://badge.fury.io/js/@getresponse%2Fstylelint-config)
[![Build Status](https://github.com/GetResponse/stylelint-config-getresponse/actions/workflows/main.yml/badge.svg)](https://github.com/GetResponse/stylelint-config-getresponse/actions)
![Dependencies](https://img.shields.io/librariesio/github/GetResponse/stylelint-config-getresponse.svg)
[![License](http://img.shields.io/:license-mit-blue.svg)](http://badges.mit-license.org)

---

This package contains all of our stylelint rules. It requires [stylelint](https://stylelint.io/).

1. Install correct versions of each dependant package:

   ```bash
   npm install --save-dev @getresponse/stylelint-config
   ```

2. Add `"extends": "@getresponse/stylelint-config"` to your stylelint config.
npm package: @getresponse/tsconfig
Description: Common tsconfig.json files
Author: GetResponse
Latest version: 2.0.1

# @getresponse/tsconfig

[![License](http://img.shields.io/:license-mit-blue.svg)](http://badges.mit-license.org)

---

This package contains a universal tsconfig file that is optimized for browser, library, and Node.js LTS projects. It can help you set up your TypeScript projects quickly and easily.

## Compatibility

- `@getresponse/tsconfig@2.x` - TypeScript >=6.0.0 <7.0.0
- `@getresponse/tsconfig@1.x` - TypeScript 5.x (no longer maintained)

## Installation

1. Install @getresponse/tsconfig as a development dependency:

   ```bash
   npm i --save-dev @getresponse/tsconfig
   ```

2. Choose the appropriate config file for your project from `@getresponse/tsconfig/configs`:

- For browser projects, use `browser/tsconfig.json`
- For library projects with CommonJS modules, use `lib/tsconfig.cjs.json`
- For library projects with ES modules, use `lib/tsconfig.esm.json`
- For Node.js LTS projects, use either `node-lts/tsconfig.cjs.json` (CommonJS modules) or `node-lts/tsconfig.json` (ES modules)

3. In your TypeScript configuration file (tsconfig.json), extend the chosen config file, for example (see [documentation](https://www.typescriptlang.org/tsconfig#extends)):

   ```json
   {
        "extends": "@getresponse/tsconfig/configs/browser/tsconfig.json"
   }
   ```

4. Optionally, customize the configuration options based on your project setup:

   - `rootDir`: set the root directory of your project (see [rootDir](https://www.typescriptlang.org/tsconfig#rootDir))

   - `include`: specify which files should be included in the compilation process (see [include](https://www.typescriptlang.org/tsconfig#include))

   - `exclude`: specify which files should be excluded from the compilation process (see [exclude](https://www.typescriptlang.org/tsconfig#exclude))

   Here's an example with customized options:
   ```json
   {
      "extends": "@getresponse/tsconfig/configs/browser/tsconfig.json",
      "compilerOptions": {
         "rootDir": "src"
      },
      "include": [
         "src/**/*",
         "types/**/*"
      ],
      "exclude": [
         "node_modules",
         "src/example-nested"
      ]
   }
   ```


5. TypeScript 6 no longer auto-loads `@types/*` packages. If your project uses type definitions (e.g. `@types/node`, `@types/react`), add them explicitly in your `tsconfig.json`:

   ```json
   {
      "extends": "@getresponse/tsconfig/configs/browser/tsconfig.json",
      "compilerOptions": {
         "types": ["react", "vite"]
      }
   }
   ```

   Note: `node-lts` configs already include `"types": ["node"]` by default.

That's it! Now you can enjoy the benefits of using a standardized tsconfig file in your TypeScript projects.