open-index/open-npm huggingface dataset:
npm package: @sschepis/as-agent
Description: AssemblyScript agent runtime — conversation engine, session management, tool execution, and slash commands compiled to WebAssembly
Author: Sebastian Schepis
Latest version: 0.1.2

# @sschepis/as-agent

AssemblyScript agent runtime — conversation engine, session management, tool execution, permission system, and slash commands.

## Install

```bash
npm install @sschepis/as-agent
```

## Quick start

```typescript
import { createRuntime } from "@sschepis/as-agent";

const rt = await createRuntime();

// Slash command help
console.log(rt.renderSlashCommandHelp());

// Model pricing
const pricing = rt.pricingForModel("claude-opus-4-6");

// Format costs
console.log(rt.formatUsd(15.0)); // "$15.0000"

// Enums
console.log(rt.MessageRole.Assistant); // 2
console.log(rt.PermissionMode.WorkspaceWrite); // 1
```

## Package structure

### JavaScript/TypeScript consumers

```typescript
// High-level API (loads Wasm automatically)
import { createRuntime } from "@sschepis/as-agent";

// Type-only imports for your own code
import type {
  Session,
  ConversationMessage,
  ContentBlock,
  TokenUsage,
  PermissionPolicy,
  CompactionConfig,
  SlashCommandSpec,
} from "@sschepis/as-agent";
```

### Raw Wasm bindings

```typescript
// Direct access to the auto-generated Wasm bindings
import { renderSlashCommandHelp, formatUsd } from "@sschepis/as-agent/wasm";
```

### AssemblyScript consumers

```typescript
// Import AS source files directly for AS-to-AS projects
import { Session, ConversationMessage } from "@sschepis/as-agent/assembly";
```

## Modules

| Module | Description |
|--------|-------------|
| `json` | JSON value type and parser (zero dependencies) |
| `session` | `MessageRole`, `ContentBlock`, `ConversationMessage`, `Session` with JSON serialization |
| `usage` | `TokenUsage`, `UsageTracker`, `ModelPricing`, cost estimation |
| `permissions` | `PermissionMode`, `PermissionPolicy`, authorization logic |
| `compact` | Session compaction with summary generation |
| `conversation` | `ConversationRuntime` with turn loop, `ApiClient`/`ToolExecutor` interfaces |
| `commands` | 22 slash commands, parsing, help rendering |
| `config` | `RuntimeConfig`, MCP server configs, config parsing |
| `hooks` | Hook runner with pluggable command handler |
| `sandbox` | `SandboxConfig`, filesystem isolation modes |
| `bootstrap` | Bootstrap phase definitions |
| `stubs` | Abstract interfaces for host I/O (file system, bash, MCP, OAuth) |

## I/O stubs

The core logic is pure computation. I/O operations are defined as abstract classes in the AssemblyScript source, meant to be implemented by the host environment:

- **`FileSystem`** — `readFile`, `writeFile`, `editFile`, `globSearch`, `grepSearch`
- **`BashExecutor`** — Shell command execution
- **`McpServerManager`** — MCP tool/resource operations
- **`OAuthHandler`** — PKCE + credential persistence
- **`HookCommandHandler`** — Hook shell execution

## Building from source

```bash
cd assembly
npm install
npm run build          # builds Wasm + TypeScript
npm test               # runs smoke tests
```

## License

MIT
npm package: @sschepis/flexible-data-importer
Description: AI-driven data ingestion for CSV, JSON, XLSX with auto-schema generation and Supabase integration.
Author: OpenClaw
Latest version: 1.0.0

# OpenClaw Data Importer Skill

The **OpenClaw Data Importer** is an AI-driven tool for ingesting unstructured or semi-structured data (CSV, JSON, XLSX) into Supabase. It uses an LLM to automatically infer relationships, generate relational schemas, and map data types, removing the need for manual ETL scripting.

## Features

- **Auto-Schema Generation**: Reads a sample of your file and proposes a SQL schema.
- **Intelligent Mapping**: Transforms raw keys (e.g., "First Name") to database columns (e.g., "first_name") and casts types (strings to dates/booleans).
- **Streaming & Batching**: Handles large datasets efficiently by streaming files and uploading in batches.
- **Supabase Integration**: Direct UPSERT support via PostgREST.

## Installation

```bash
npm install flexible-data-importer
```

## Usage

### CLI

Ensure you have a `.env` file with:
```env
SUPABASE_URL=...
SUPABASE_KEY=...
OPENAI_API_KEY=...
```

Run the importer:
```bash
npx data-importer ./path/to/my-data.csv
```

### Programmatic

```typescript
import { UniversalImporter, NodeFileAdapter, OpenAILLMAdapter, SupabaseAdapter } from 'flexible-data-importer';

const importer = new UniversalImporter(
  new NodeFileAdapter(),
  new OpenAILLMAdapter(process.env.OPENAI_API_KEY),
  new SupabaseAdapter(process.env.SUPABASE_URL, process.env.SUPABASE_KEY)
);

await importer.execute('./large-dataset.xlsx');
```

## Architecture

The system uses a **UniversalImporter** core that orchestrates three adapters:
1. **FileAdapter**: Abstracts filesystem access (Node streams vs OpenClaw sandbox).
2. **LLMAdapter**: Abstracts the intelligence provider (OpenAI vs OpenClaw Internal).
3. **DatabaseAdapter**: Abstracts the storage layer (Supabase vs Postgres).

This architecture allows the skill to be run standalone or injected with OpenClaw's native capabilities when running inside the agent runtime.
npm package: @sschepis/peer-reviewer
Description: AI-powered academic paper reviewer using OpenClaw agentic patterns
Author: Sebastian Schepis
Latest version: 1.0.0

# Peer Reviewer Skill

**AI-powered academic rigor for your research.**

Peer Reviewer is an OpenClaw skill that simulates a multi-agent academic peer review process. It employs a "Council of Agents" to deconstruct arguments, find contradictions in established literature, and render a final judgment on the merit of a scientific paper or claim.

## 🧠 How It Works

The system uses three specialized AI agents:

1.  **The Deconstructor:** Parses raw text into a formal Logic Graph (Toulmin Model), extracting claims, premises, and evidence without judgment.
2.  **The Devil's Advocate:** Takes the claims and actively searches for contradictions (using Google Serper & ArXiv). It looks for theoretical conflicts, empirical contradictions, and prior art.
3.  **The Judge:** Evaluates the Logic Graph against the Devil's Advocate's objections. It scores the paper on logical coherence, foundational integrity, and empirical falsifiability, ignoring "consensus" in favor of strict logical validity.

## 🚀 Installation

```bash
npm install @sschepis/peer-reviewer
```

*Note: This package is designed to be used as an OpenClaw skill but can also run standalone.*

## 🛠️ Usage

### As an OpenClaw Skill

Trigger the skill by asking OpenClaw:
> "Review this paper for flaws."
> "Analyze the logic of this argument."

(Ensure the skill is loaded in your OpenClaw configuration).

### Standalone CLI

You can run the reviewer directly on a text file or a raw string:

```bash
# Review a file
node dist/index.js "/path/to/paper.txt"

# Review a raw claim
node dist/index.js "Claim: We can exceed the speed of light by..."
```

## ⚙️ Configuration

The reviewer requires access to LLM and Search providers. Create a `.env` file or set environment variables:

```env
# Google Vertex AI (Gemini)
GOOGLE_APPLICATION_CREDENTIALS="path/to/google.json"
VERTEX_AI_MODEL="gemini-3-pro-preview"
VERTEX_AI_LOCATION="us-central1"

# Search Provider (Google Serper)
SERPER_API_KEY="your_serper_key"
```

## 📊 Output: The Merit Report

The tool generates a JSON report containing:

*   **Overall Score (0-10):** A weighted metric of logical and empirical strength.
*   **Defense Strategy:** How the author might address the strongest objections.
*   **Suggestions:** Concrete steps to improve the paper's rigor.
*   **Dimensions:** Detailed scores for Logical Coherence, Causal Robustness, etc.

## License

MIT
npm package: @sschepis/react-copilot
Description: Dynamic React app assistance through AI-powered chat interface
Latest version: 0.1.0

# React Copilot

React Copilot is a powerful library that enables React applications to be controlled and modified by Large Language Models (LLMs) through natural language conversations.

## Overview

React Copilot connects your React application with AI language models like OpenAI's GPT models, Anthropic's Claude, or DeepSeek. It provides a chat interface where users can request UI changes, new features, or application improvements, and see them applied in real-time without losing application state.

## Key Features

- **Dynamic Component Modification**: Update React components on-the-fly
- **Multi-Model Support**: Works with OpenAI, Anthropic Claude, and DeepSeek models
- **Chat Interface**: Intuitive overlay for user interactions
- **Hot Reloading**: Apply changes without losing application state
- **Autonomous Mode**: AI can implement requirements automatically
- **Plugin System**: Extend functionality with specialized plugins
- **Debug Panel**: Interactive tools for component inspection
- **Version Control**: Track and revert component changes

## Installation

```bash
npm install react-copilot
```

or

```bash
yarn add react-copilot
```

## Create React Copilot App

We provide a CLI tool to quickly create a new React project with React Copilot pre-configured:

```bash
npx create-react-copilot-app my-app
```

This sets up a complete React application with React Copilot already integrated. Learn more in the [Create React Copilot App documentation](./docs/create-react-copilot-app.md).

## Quick Example

```jsx
import React from 'react';
import { LLMProvider, ModifiableApp, ChatOverlay } from 'react-copilot';

function App() {
  return (
    <LLMProvider
      config={{
        provider: 'openai', // or 'anthropic' or 'deepseek'
        model: 'gpt-4', // or 'claude-3-sonnet-20240229' or 'deepseek-chat'
      }}
    >
      <ModifiableApp>
        <YourExistingApp />
      </ModifiableApp>
      <ChatOverlay position="bottom-right" />
    </LLMProvider>
  );
}
```

## Documentation

For complete documentation, visit the [docs directory](./docs/index.md) or our website.

- [Installation Guide](./docs/installation-guide.md)
- [Getting Started](./docs/getting-started.md)
- [API Reference](./docs/api-reference.md)
- [Examples](./docs/examples.md)
- [Troubleshooting](./docs/troubleshooting.md)

## Contributing

We welcome contributions! Please see our [Contributing Guidelines](CONTRIBUTING.md) for more information.

## Publishing

React Copilot and its associated packages are published to npm automatically via GitHub Actions:

- The main `react-copilot` package is published via the [publish-react-copilot.yml](./.github/workflows/publish-react-copilot.yml) workflow
- The `create-react-copilot-app` CLI tool is published via the [publish-create-react-copilot-app.yml](./.github/workflows/publish-create-react-copilot-app.yml) workflow

To trigger a new publication, create a new version tag or GitHub release.

## License

React Copilot is released under the MIT License.
npm package: @sschw/openapi-codegen-cli
Description: OpenAPI Codegen cli
Author: Fabien Bernard
Latest version: 2.1.3

### This is a fork of the original project [openapi-codegen](https://github.com/fabien0102/openapi-codegen) by Fabien BERNARD.

# OpenAPI Codegen

## Getting started

1. Add a `openapi-codegen.config.ts` at the root of your project

```ts
// openapi-codegen.config.ts
import { defineConfig } from "@sschw/openapi-codegen-cli";
import {
  generateSchemaTypes,
  generateReactQueryComponents,
} from "@sschw/openapi-codegen-typescript";

export default defineConfig({
  example: {
    from: {
      source: "github",
      owner: "fabien0102",
      repository: "openapi-codegen",
      ref: "main",
      specPath: "examples/spec.yaml",
    },

    // can be overridden from cli
    outputDir: "src/queries",

    to: async (context) => {
      const filenamePrefix = "example";

      // Generate all the schemas types (components & responses)
      const { schemasFiles } = await generateSchemaTypes(context, {
        filenamePrefix,
      });

      // Generate all react-query components
      await generateReactQueryComponents(context, {
        filenamePrefix,
        schemasFiles,
      });
    },
  },
});
```

2. Expose openapi-codegen in your `package.json`

```diff
--- a/package.json
+++ b/package.json
   "scripts": {
+    "gen": "openapi-codegen",
   }
```

3. Run the generator (`example` is the config key defined in the step 1)

```bash
$ yarn gen example
```

4. Start playing! 🥳
npm package: @sscode-smith/cs-utils
Description: CodeSmith Utilities
Author: danju
Latest version: 0.2.0

# CodeSmith Utilities

## Introduction

`@sscpde-smith/cs-utils`는 함수형 프로그래밍을 위한 유틸리티 함수들의 모음입니다.

## Installation

```bash
npm install @sscode-smith/cs-utils
```
npm package: @sscustom/plugin-custom
Description: Superset Chart - Custom Chart
Author: Superset
Latest version: 0.0.1

## @superset-ui/plugin-chart-custom-chart

[![Version](https://img.shields.io/npm/v/@superset-ui/plugin-chart-custom-chart.svg?style=flat-square)](https://www.npmjs.com/package/@superset-ui/plugin-chart-custom-chart)

This plugin provides Custom Chart for Superset.

### Usage

Configure `key`, which can be any `string`, and register the plugin. This `key` will be used to lookup this chart throughout the app.

```js
import CustomChartChartPlugin from '@superset-ui/plugin-chart-custom-chart';

new CustomChartChartPlugin()
  .configure({ key: 'custom-chart' })
  .register();
```

Then use it via `SuperChart`. See [storybook](https://apache-superset.github.io/superset-ui/?selectedKind=plugin-chart-custom-chart) for more details.

```js
<SuperChart
  chartType="custom-chart"
  width={600}
  height={600}
  formData={...}
  queriesData={[{
    data: {...},
  }]}
/>
```

### File structure generated

```
├── package.json
├── README.md
├── tsconfig.json
├── src
│   ├── CustomChart.tsx
│   ├── images
│   │   └── thumbnail.png
│   ├── index.ts
│   ├── plugin
│   │   ├── buildQuery.ts
│   │   ├── controlPanel.ts
│   │   ├── index.ts
│   │   └── transformProps.ts
│   └── types.ts
├── test
│   └── index.test.ts
└── types
    └── external.d.ts
```
npm package: @ssdcode/js-behaviour
Description: Class with a set of methods representing post form submission behaviour
Author: Sebastian Sulinski
Latest version: 0.1.0
Deprecated: WARNING: This project has been renamed to @ssdcode/js-behaviours. Install using @ssdcode/js-behaviours instead.

# Behaviour

Class with a set of methods representing post form submission behaviour.
To accompany [@ssdcode/vue-form](https://github.com/sebastiansulinski/vue-form) v2.

## Installation

```bash
npm install @ssdcode/js-behaviours --save-dev
```

## Usage

```bash
import { reload, redirect, confirmClear } from '@ssdcode/js-behaviours'

reload();
redirect('/home');

// from within `vue-form` instance
confirmClear({ message: 'You did it!' }, this);
```

## Tests

You can execute tests by calling

```bash
npm run test:unit
```

## Contributions

Contributions are welcome - please make sure all PRs have their associated test.
npm package: @ssdcode/js-behaviours
Description: Class with a set of methods representing post form submission behaviour
Author: Sebastian Sulinski
Latest version: 0.1.2

# Js Behaviours

Set of methods representing post form submission behaviour.
To accompany [@ssdcode/vue-form](https://github.com/sebastiansulinski/vue-form) v2.

## Installation

```bash
npm install @ssdcode/js-behaviours --save-dev
```

## Usage

```bash
import { reload, redirect, confirmClear } from '@ssdcode/js-behaviours'

reload();
redirect('/home');

// from within `vue-form` instance
confirmClear({ message: 'You did it!' }, this);
```

## Tests

You can execute tests by calling

```bash
npm run test:unit
```

## Contributions

Contributions are welcome - please make sure all PRs have their associated test.
npm package: @ssdcode/js-caller
Description: Lightweight axios wrapper
Author: Sebastian Sulinski
Latest version: 1.0.5

# JS Caller

Lightweight [axios](https://github.com/axios/axios) wrapper pre-configured with the following headers:

```javascript
'X-Requested-With': 'XMLHttpRequest'
Accept: 'application/json'
'Content-Type': 'application/json'
```

### Installation

```bash
npm i @ssdcode/js-caller
```

### Usage

```bash
import Caller from '@ssdcode/js-caller';

Caller.request(
  '/end-point',
  'post',
  { id: 1 },
  {
    timeout: 1000,
    headers: { 'X-Custom-Header': 'foobar' },
  }
);
```

`Caller.request` method takes 4 arguments:

```bash
- endpoint: request destination
- request method: get (default), post, put, patch, delete
- payload: data you wish to send with the request. If request method is in ['post', 'put', 'patch'] - payload will automaticaly be associated with 'data' index - otherwise 'params' will be used
- config: axios specific configuration
```

If you're using `csrf` token, make sure it is included as a meta tag and `js-caller` will fetch and attach it to the request automatically as a `X-CSRF-TOKEN` header.

```html
<meta name="csrf-token" content="{{ csrf_token() }}">
```
npm package: @ssdcode/js-mutators
Description: Set of methods providing functionality to mutate the given value
Author: Sebastian Sulinski
Latest version: 0.1.4

# JS Mutators

Set of methods providing functionality to mutate the given value.

## Installation

```bash
npm install @ssdcode/js-mutators --save-dev
```

Import relevant methods using ES6 import statement

```javascript
import { toUpperCase, toLowerCase, slug } from 'js-mutators';
```

## Available methods

---

#### toUpperCase

Converts string to uppercase. See [String.prototype.toUpperCase()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase)

---

#### toLowerCase

Converts string to lowercase. See [String.prototype.toLowerCase()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)

---

#### slug

Converts string to lower case, hyphen concatenated slug.

---

## Tests

You can execute tests by calling

```bash
npm run test
```

## Contributions

Contributions are welcome - please make sure all PRs have their associated test.