open-index/open-npm huggingface dataset:
npm package: @stencitecnologia/app-kit
Description: Core utilities, HTTP client, storage, validation and error handling for Stenci projects.
Author: Stenci Tecnologia
Latest version: 0.1.8

# @stencitecnologia/app-kit

Core utilities para aplicações Vue da Stenci (HTTP client, storage, errors, context, validation e utils).

---

# 📦 Instalação (consumidor)

```bash
npm install @stencitecnologia/app-kit
```

---

# 🚀 Fluxo de Release (gerar versão, compilar e publicar)

Este pacote segue o fluxo padrão NPM com versionamento semântico.

## 1️⃣ Entrar na pasta do projeto

```bash
cd stenci-app-kit
```

Confirme que você está na pasta correta:

```bash
ls
```

Deve existir:

```
src/
package.json
vite.config.js
```

---

## 2️⃣ Instalar dependências

```bash
npm install
```

---

## 3️⃣ Gerar nova versão

Sempre que fizer alterações no código:

### Correções pequenas (mais comum)

```bash
npm version patch
```

Exemplo:

```
0.1.0 → 0.1.1
```

### Novas funcionalidades

```bash
npm version minor
```

### Mudanças que quebram compatibilidade

```bash
npm version major
```

O comando `npm version`:

* Atualiza o `package.json`
* Cria commit Git automático
* Cria tag Git automática

⚠️ Se aparecer erro `Git working directory not clean`, faça:

```bash
git add -A
git commit -m "chore: release"
```

---

## 4️⃣ Compilar o pacote

```bash
npm run build
```

Resultado esperado:

```
dist/
  index.es.js
  index.cjs
```

---

## 5️⃣ Validar antes de publicar (recomendado)

```bash
npm pack
```

Isso gera um arquivo `.tgz` local com o conteúdo que será publicado.

Verifique se contém:

```
dist/
package.json
```

---

## 6️⃣ Login no NPM

Se não estiver logado ou o token expirou:

```bash
npm logout
npm login
```

Validar login:

```bash
npm whoami
```

---

## 7️⃣ Publicar no NPM

Primeira publicação (pacote com scope):

```bash
npm publish --access public
```

Publicações futuras:

```bash
npm publish
```

O script `prepack` executa automaticamente o build antes do publish.

---

# 🔄 Atualizar no projeto consumidor

Depois de publicar nova versão:

```bash
npm update @stencitecnologia/app-kit
```

ou:

```bash
npm install @stencitecnologia/app-kit@latest
```

---

# 🧪 Desenvolvimento local (opcional)

Para testar sem publicar:

```bash
npm link
```

No consumidor:

```bash
npm link @stencitecnologia/app-kit
```

---

# ⚠️ Problemas comuns

## Pacote não encontrado (404)

O pacote ainda não foi publicado ou o nome está incorreto.

Verificar:

```bash
npm view @stencitecnologia/app-kit version
```

---

## Token expirado

```bash
npm logout
npm login
```

---

## Versão já existe

Você esqueceu de atualizar a versão:

```bash
npm version patch
npm publish
```

---

# 📁 Estrutura do projeto

```
src/
  constants/
  core/
  errors/
  http/
  storage/
  utils/
  validation/
    validators/
  index.js

dist/
vite.config.js
package.json
```

---

# 🏁 Resultado esperado

Após publicar, o pacote estará disponível em:

```
https://www.npmjs.com/package/@stencitecnologia/app-kit
```

---

# 📄 Licença

MIT — Stenci Tecnologia
npm package: @stendahls/provision-parse
Description: parse .mobileprovision(iOS) and .provisionprofile(OS X) files
Latest version: 1.0.1

# Provision parse [![Build Status](http://img.shields.io/travis/stendahls/provision-parse.svg?style=flat-square)](https://travis-ci.org/stendahls/provision-parse)
> parse .mobileprovision(iOS) and .provisionprofile(OS X) files

Converts the provisioning profile raw plist data into JavaScript objects, arrays, etc.

## Install

```sh
$ npm i @stendahls/provision-parse
```


## Usage

```js
const provisioning = require( '@stendahls/provision-parse' );

provisioning( './Payload/Facebook.app/embedded.mobileprovision', ( parseError, provisionData ) => {
    console.log( provisionData );
    // => { "AppIDName": "com.facebook.facebook",
    //      "TeamName": "Facebook Inc.",
    //      ... }
} );
```
npm package: @stendar-x/sdk
Description: TypeScript SDK for the Stendar protocol
Latest version: 0.6.7

# `@stendar-x/sdk`

TypeScript SDK for interacting with the Stendar protocol in two modes:

- `api` mode: call the backend REST API and receive unsigned transactions.
- `direct` mode: build Anchor instructions locally via the loaded IDL.

## Install

```bash
npm install @stendar-x/sdk
```

## Usage

```ts
import { Keypair } from '@solana/web3.js';
import { StendarClient } from '@stendar-x/sdk';

const keypair = Keypair.generate();

const client = new StendarClient({
  mode: 'api',
  apiUrl: process.env.STENDAR_API_URL,
  apiKey: process.env.STENDAR_API_KEY,
});

const contracts = await client.contracts.list({ status: 'Active', page: 1, limit: 20 });

const tx = await client.lending.contribute({
  contractAddress: '...',
  lenderAddress: keypair.publicKey.toBase58(),
  amount: 1_000_000,
});
```

For direct mode, pass `direct` config with `connection`, `wallet`, `idl`, and optional `programId`.

Direct/API operation coverage is documented in [`DIRECT_MODE.md`](./DIRECT_MODE.md).

## Canonical IDL Export

The SDK publishes the canonical protocol IDL as `stendarIdl`:

```ts
import { stendarIdl } from '@stendar-x/sdk';
```
npm package: @stenic/semantic-release-docker-helm-config
Description: semantic-release shareable config for docker + helm.
Author: Dries De Peuter
Latest version: 1.1.3

# @stenic/semantic-release-docker-helm-config

[**semantic-release**](https://github.com/semantic-release/semantic-release) shareable config to publish npm packages with [GitHub](https://github.com).

## Plugins

This [shareable configuration](https://github.com/stenic/semantic-release-docker-helm-config/blob/master/.releaserc.json) uses the following plugins:

- [`@semantic-release/commit-analyzer`](https://github.com/semantic-release/commit-analyzer)
- [`@semantic-release/release-notes-generator`](https://github.com/semantic-release/release-notes-generator)
- [`@semantic-release/changelog`](https://github.com/semantic-release/changelog)
- [`@semantic-release/git`](https://github.com/semantic-release/git)
- [`@semantic-release/github`](https://github.com/semantic-release/github)
- [`semantic-release-helm`](https://github.com/m1pl/semantic-release-helm)


## Github action
npm package: @stenito/renormalize
Description: A default style for HTML pages.
Author: Steven Pauwels
Latest version: 0.0.7

# Renormalize

A default style for HTML pages.

This is work in progress. Use in production at your own discretion.

## Useage

### npm

Renormalize is coded using SCSS.

`npm install @stenito/renormalize --save-dev`

Use it in your project: `@import '@stenito/renormalize/src/renormalize';`

### CDN

Latest:

- <https://cdn.jsdelivr.net/npm/@stenito/renormalize/css/renormalize.css>
- <https://unpkg.com/@stenito/renormalize/css/renormalize.css>

Specific version:

(from version 3)

- <https://cdn.jsdelivr.net/npm/@stenito/renormalize@version/css/renormalize.css>
- <https://unpkg.com/@stenito/renormalize@version/css/renormalize.css>
npm package: @stenito/tiny
Description: Removes all spaces from a string
Latest version: 2.0.1

# @stenito/tiny

![npm (scoped)](https://img.shields.io/npm/v/@stenito/tiny)
![npm bundle size (scoped)](https://img.shields.io/bundlephobia/min/@stenito/tiny)

Removes all spaces from a string.

## Install

``` commandline
npm install @stenito/tiny
```

## Usage

``` javascript
const tiny = require("@stenito/tiny");

tiny("So much space!");
//=> "Somuchspace!"

tiny(1337);
//=> Uncaught TypeError: Tiny wants a string!
//    at tiny (<anonymous>:2:41)
//    at <anonymous>:1:1
```
npm package: @steno-ai/cache-adapter
Description: In-memory cache adapter for Steno
Latest version: 0.1.1

# @steno-ai/cache-adapter

In-memory cache adapter for Steno. Implements the `CacheAdapter` interface with TTL support.

## Install

```bash
npm install @steno-ai/cache-adapter
```

## Usage

```ts
import { InMemoryCacheAdapter } from '@steno-ai/cache-adapter';

const cache = new InMemoryCacheAdapter();

await cache.set('key', { some: 'value' }, 300); // TTL: 300 seconds
const val = await cache.get('key');              // { some: 'value' }
await cache.del('key');
await cache.incr('counter');                     // atomic increment
await cache.expire('counter', 60);               // set TTL on existing key
```

## API

| Method | Description |
|--------|-------------|
| `get<T>(key)` | Get a value (returns `null` if missing or expired) |
| `set<T>(key, value, ttlSeconds?)` | Set a value with optional TTL |
| `del(key)` | Delete a key |
| `incr(key)` | Atomic increment (starts at 0) |
| `expire(key, ttlSeconds)` | Set TTL on an existing key |
| `ping()` | Always returns `true` |

## Part of [Steno](https://github.com/SankrityaT/steno-ai)

The memory layer for AI agents.
npm package: @steno-ai/db
Description: Database schema and migrations for Steno
Latest version: 0.1.1

# @steno-ai/db

Database schema and seed data for Steno's PostgreSQL backend (Supabase).

## Contents

```
packages/db/
  package.json
  schema.sql    -- Full DDL: tables, indexes, extensions (pgvector, pg_trgm)
  seed.sql      -- Optional seed data
```

## Usage

Apply the schema to a Supabase/PostgreSQL database:

```bash
# Replace the embedding dimension placeholder and apply
sed 's/{EMBEDDING_DIM}/1536/g' schema.sql | psql "$DATABASE_URL"
```

The schema requires these PostgreSQL extensions:

- `uuid-ossp` -- UUID generation
- `vector` -- pgvector for embeddings
- `pg_trgm` -- trigram indexes for keyword search

## Tables

`tenants`, `facts`, `entities`, `edges`, `triggers`, `memory_accesses`, `extractions`, `sessions`, `api_keys`, `usage_records`, `webhooks`

## Part of [Steno](https://github.com/SankrityaT/steno-ai)

The memory layer for AI agents.
npm package: @steno-ai/graph
Description: 3D memory knowledge graph visualizer for Steno
Latest version: 0.1.1

# @steno-ai/graph

3D knowledge graph visualizer for Steno. React + Three.js component that renders entities and relationships in an interactive force-directed graph.

## Install

```bash
npm install @steno-ai/graph
```

## Usage

```tsx
import { MemoryGraph, fetchGraphData } from '@steno-ai/graph';
import '@steno-ai/graph/styles.css';

const data = await fetchGraphData(apiUrl, userId);

<MemoryGraph
  data={data}
  onNodeClick={(node) => console.log(node)}
/>
```

## Exports

| Export | Description |
|--------|-------------|
| `MemoryGraph` | React component for 3D graph rendering |
| `fetchGraphData` | Fetch graph data from Steno API |
| `fetchFactsForEntity` | Fetch facts linked to an entity |
| `TYPE_COLORS` | Color map for entity types |

## Part of [Steno](https://github.com/SankrityaT/steno-ai)

The memory layer for AI agents.
npm package: @steno-ai/local
Description: Zero-config local Steno setup with SQLite
Latest version: 0.1.1

# @steno-ai/local

Zero-config local Steno setup. Runs entirely on your machine with SQLite storage and any OpenAI-compatible LLM (Ollama, LM Studio, etc.).

## Install

```bash
npm install @steno-ai/local
```

## Usage

```ts
import { createStenoLocal, OLLAMA_PRESET } from '@steno-ai/local';

const steno = await createStenoLocal({
  ...OLLAMA_PRESET,
  dbPath: './steno.db',
});

// Add memories
await steno.memory.add({
  scope: 'user',
  scopeId: 'user_123',
  data: 'I love hiking and live in Portland',
});

// Search
const results = await steno.memory.search({
  query: 'hobbies',
  scope: 'user',
  scopeId: 'user_123',
});

// Sessions, triggers, graph, feedback -- all available
steno.close();
```

## Presets

- `OLLAMA_PRESET` -- Ollama with default models
- `LM_STUDIO_PRESET` -- LM Studio with default models

## CLI

```bash
npx @steno-ai/local
```

## Part of [Steno](https://github.com/SankrityaT/steno-ai)

The memory layer for AI agents.
npm package: @steno-ai/openai-adapter
Description: OpenAI LLM and embedding adapter for Steno
Latest version: 0.1.2

# @steno-ai/openai-adapter

OpenAI LLM and embedding adapter for Steno. Uses the official OpenAI SDK.

## Install

```bash
npm install @steno-ai/openai-adapter
```

## Usage

```ts
import { OpenAILLMAdapter, OpenAIEmbeddingAdapter } from '@steno-ai/openai-adapter';

const llm = new OpenAILLMAdapter({
  apiKey: process.env.OPENAI_API_KEY,
  model: 'gpt-4.1-nano',      // default
});

const embedding = new OpenAIEmbeddingAdapter({
  apiKey: process.env.OPENAI_API_KEY,
  model: 'text-embedding-3-small', // default
  dimensions: 1536,                 // default
});

// Use with @steno-ai/engine
const result = await runExtractionPipeline({
  storage,
  embedding,
  cheapLLM: llm,
  embeddingModel: 'text-embedding-3-small',
  embeddingDim: 1536,
}, input);
```

## Part of [Steno](https://github.com/SankrityaT/steno-ai)

The memory layer for AI agents.
npm package: @steno-ai/openai-compat-adapter
Description: OpenAI-compatible LLM and embedding adapter for Steno
Latest version: 0.1.1

# @steno-ai/openai-compat-adapter

OpenAI-compatible LLM and embedding adapter for Steno. Works with any provider that implements the OpenAI chat/completions API (Ollama, LM Studio, Together, Groq, etc.).

## Install

```bash
npm install @steno-ai/openai-compat-adapter
```

## Usage

```ts
import {
  OpenAICompatLLMAdapter,
  OpenAICompatEmbeddingAdapter,
} from '@steno-ai/openai-compat-adapter';

// Ollama
const llm = new OpenAICompatLLMAdapter({
  baseUrl: 'http://localhost:11434/v1',
  model: 'llama3.2',
});

// Together AI
const embedding = new OpenAICompatEmbeddingAdapter({
  baseUrl: 'https://api.together.xyz/v1',
  model: 'togethercomputer/m2-bert-80M-8k-retrieval',
  apiKey: process.env.TOGETHER_API_KEY,
  dimensions: 768,
});
```

## Constructor Options

```ts
{
  baseUrl: string;       // Provider API base URL
  model: string;         // Model name
  apiKey?: string;       // API key (optional for local providers)
  timeout?: number;      // Request timeout in ms (default: 60000)
}
```

## Part of [Steno](https://github.com/SankrityaT/steno-ai)

The memory layer for AI agents.
npm package: @steno-ai/openclaw-plugin
Description: OpenClaw AI agent plugin for Steno
Latest version: 0.1.1

# @steno-ai/openclaw-plugin

OpenClaw AI agent plugin that gives your agent persistent memory powered by Steno.

## Setup

```bash
export STENO_API_KEY=sk_steno_...
```

## Tools

| Tool | Description |
|------|-------------|
| `steno_remember` | Remember information for future sessions |
| `steno_recall` | Recall relevant memories by query |
| `steno_feedback` | Rate a memory's usefulness |

## Structure

```
openclaw-plugin/
  SKILL.md    -- Skill manifest (name, tools, parameters)
  hooks/      -- Hook implementations
```

## Part of [Steno](https://github.com/SankrityaT/steno-ai)

The memory layer for AI agents.
npm package: @steno-ai/sdk
Description: TypeScript SDK for the Steno API
Latest version: 0.1.1

# @steno-ai/sdk

TypeScript SDK for the Steno API. Dead-simple memory for your AI apps.

## Install

```bash
npm install @steno-ai/sdk
```

## Usage

```ts
import Steno from '@steno-ai/sdk';

const steno = new Steno('sk_steno_...');

// Add a memory (string or message array)
await steno.add('user_123', 'I love pizza and I work at Google');
await steno.add('user_123', [
  { role: 'user', content: 'I just moved to SF' },
  { role: 'assistant', content: 'Welcome to San Francisco!' },
]);

// Search memories
const results = await steno.search('user_123', 'food preferences');
for (const r of results.results) {
  console.log(r.content, r.score);
}

// Feedback
await steno.feedback('fact_id', true);
```

## Sub-clients

For power users, the SDK exposes sub-clients:

```ts
steno.memory    // Full memory CRUD
steno.sessions  // Session management
steno.triggers  // Memory triggers
steno.keys      // API key management
steno.graph     // Knowledge graph API
steno.webhooks  // Webhook management
```

## Part of [Steno](https://github.com/SankrityaT/steno-ai)

The memory layer for AI agents.
npm package: @steno-ai/sqlite-adapter
Description: SQLite storage adapter for Steno
Latest version: 0.1.4

# @steno-ai/sqlite-adapter

SQLite storage adapter for Steno. Uses `better-sqlite3` with built-in FTS5 full-text search and in-process vector similarity.

## Install

```bash
npm install @steno-ai/sqlite-adapter
```

## Usage

```ts
import { SQLiteStorageAdapter } from '@steno-ai/sqlite-adapter';

const storage = new SQLiteStorageAdapter('./steno.db');

// Use with @steno-ai/engine
import { runExtractionPipeline, search } from '@steno-ai/engine';

await runExtractionPipeline({ storage, embedding, cheapLLM, ... }, input);
const results = await search({ storage, embedding }, options);
```

## Utilities

```ts
import {
  initializeDatabase,
  cosineSimilarity,
  serializeEmbedding,
  deserializeEmbedding,
} from '@steno-ai/sqlite-adapter';
```

## Part of [Steno](https://github.com/SankrityaT/steno-ai)

The memory layer for AI agents.
npm package: @steno-ai/supabase-adapter
Description: Supabase/PostgreSQL storage adapter for Steno
Latest version: 0.1.11

# @steno-ai/supabase-adapter

Supabase/PostgreSQL storage adapter for Steno. Uses pgvector for embeddings and pg_trgm for keyword search.

## Install

```bash
npm install @steno-ai/supabase-adapter
```

## Usage

```ts
import { SupabaseStorageAdapter, createSupabaseClient } from '@steno-ai/supabase-adapter';

const client = createSupabaseClient({
  url: process.env.SUPABASE_URL,
  serviceRoleKey: process.env.SUPABASE_SERVICE_ROLE_KEY,
});

const storage = new SupabaseStorageAdapter(client);

// Use with @steno-ai/engine
import { runExtractionPipeline, search } from '@steno-ai/engine';

await runExtractionPipeline({ storage, embedding, cheapLLM, ... }, input);
const results = await search({ storage, embedding }, options);
```

## Part of [Steno](https://github.com/SankrityaT/steno-ai)

The memory layer for AI agents.
npm package: @steno-ai/vercel-provider
Description: Vercel AI SDK middleware for automatic memory
Latest version: 0.1.1

# @steno-ai/vercel-provider

Vercel AI SDK middleware that adds automatic memory to any language model. Memories are searched before each call and conversations are stored after.

## Install

```bash
npm install @steno-ai/vercel-provider @steno-ai/sdk
```

## Usage

```ts
import { stenoMemory } from '@steno-ai/vercel-provider';
import { wrapLanguageModel, generateText } from 'ai';
import { openai } from '@ai-sdk/openai';

const model = wrapLanguageModel({
  model: openai('gpt-4o'),
  middleware: stenoMemory({
    apiKey: 'sk_steno_...',
    userId: 'user_123',
    maxMemories: 5,     // default
    autoStore: true,     // default
  }),
});

const { text } = await generateText({
  model,
  prompt: 'What do you remember about me?',
});
```

## Options

| Option | Default | Description |
|--------|---------|-------------|
| `apiKey` | -- | Steno API key |
| `userId` | -- | User ID to scope memories to |
| `maxMemories` | `5` | Max memories injected into context |
| `autoStore` | `true` | Auto-store conversations after generation |
| `baseUrl` | `https://api.steno.ai` | Custom API base URL |

## Part of [Steno](https://github.com/SankrityaT/steno-ai)

The memory layer for AI agents.
npm package: @stenodb/browser
Description: ✍ Easy to use local JSON database
Author: Vitalij Ryndin
Latest version: 4.0.1

# @stenodb/browser [![](https://img.shields.io/npm/v/@stenodb/browser)](https://www.npmjs.org/package/@stenodb/browser)

> ✍ Easy to use local JSON database for [LocalStorage](https://developer.mozilla.org/ru/docs/Web/API/Window/localStorage) and [SessionStorage](https://developer.mozilla.org/ru/docs/Web/API/Window/sessionStorage).

## Install

```sh
npm install @stenodb/browser
```

```sh
yarn add @stenodb/browser
```

```sh
pnpm add @stenodb/browser
```

## Usage

```ts
// entities.ts
import { Type } from 'class-transformer'

export class Users {
  @Type(() => User)
  users: User[]

  constructor(...users: User[]) {
    this.users = users
  }
}

export class User {
  username: string

  @Type(() => Post)
  posts: Post[]

  constructor(username: string, ...posts: Post[]) {
    this.username = username
    this.posts = posts
  }

  addPost(post: Post) {
    this.posts.push(post)
  }
}

export class Post {
  title: string

  constructor(text: string) {
    this.title = title
  }
}

// index.ts
import 'reflect-metadata'
import { LocalStorage, BrowserProvider } from '@stenodb/browser'
import { Users, User, Post } from './entities.js'

const initialData = new Users(new User('John Doe'))
const adapter = new LocalStorage('users', Users, initialData)
const provider = new BrowserProvider()
const db = provider.create(adapter)

db.read()
db.data?.users[0]?.addPost(new Post('Lorem ipsum'))
db.write()
```

## Credits

- [steno](https://github.com/typicode/steno) - Specialized fast async file writer.
- [class-transformer](https://github.com/typestack/class-transformer) - Decorator-based transformation, serialization, and deserialization between objects and classes.
- [class-validator](https://github.com/typestack/class-validator) - Decorator-based property validation for classes.

## License

MIT - [crashmax](https://github.com/crashmax-dev)