open-index/open-npm huggingface dataset:
npm package: @sight-ai/api-audit-verify
Description: Merkle proof verification for API audit (browser & node).
Latest version: 0.1.1

# @sight-ai/api-audit-verify

A lightweight, reusable library for verifying Merkle proofs in both Node.js and browser environments.  
Extracted from our API key audit verifier service so it can be consumed independently by frontend and backend projects.

## Features

- ✅ Works in **Node.js** (backend) and **browser** (frontend) environments
- ✅ Pure TypeScript with bundled type definitions
- ✅ ESM + CommonJS builds
- ✅ Uses [`merkletreejs`](https://github.com/miguelmota/merkletreejs) and [`js-sha3`](https://github.com/emn178/js-sha3) under the hood
- ✅ Accepts `0x`-prefixed hex strings or Buffers

## Installation

```bash
npm install @sight-ai/api-audit-verify
# or
yarn add @sight-ai/api-audit-verify
# or
pnpm add @sight-ai/api-audit-verify
```

## Usage

### In Node.js (NestJS example)

```ts
import { Injectable } from '@nestjs/common';
import { verifyMerkleProof, type Proof } from '@sight-ai/api-audit-verify';

@Injectable()
export class VerifierService {
  verify(root: string, leaf: string, proof: Proof): boolean {
    return verifyMerkleProof(root, leaf, proof);
  }
}
```

### In Browser (Vite/React example)

```ts
import { verifyMerkleProof, type Proof } from '@sight-ai/api-audit-verify';

// Example data
const root = '0x...'; // 32-byte hex
const leaf = '0x...';
const proof: Proof = [
  { position: 'left', data: '0x...' },
  { position: 'right', data: '0x...' }
];

const isValid = verifyMerkleProof(root, leaf, proof);
console.log('Proof valid?', isValid);
```

> ℹ️ For browser environments, if you encounter `Buffer is not defined`, install `buffer` and polyfill:
> ```ts
> import { Buffer } from 'buffer';
> (window as any).Buffer = Buffer;
> ```

## API

### `verifyMerkleProof(root, leaf, proof): boolean`
Verifies a Merkle proof given:
- `root`: Merkle root (`0x` hex string or `Buffer`)
- `leaf`: Leaf value (`0x` hex string or `Buffer`)
- `proof`: Array of proof items (`{ position: 'left'|'right', data: Buffer|string|Uint8Array }`)

Returns `true` if the proof is valid, otherwise `false`.

### `Proof` type
```ts
export type Proof = ReturnType<MerkleTree['getProof']>;

// can be concerned as:
export type ProofItem = {
  position: 'left' | 'right';
  data: string | Buffer | { data: number[] };
};
export type Proof = ProofItem[];
```

## Development

```bash
# Install dependencies
npm install

# Build the package
npm run build

# Run a dry-run publish to see what files will be included
npm publish --dry-run
```

## License

MIT © Sight AI
npm package: @sight-ai/sight-cli
Description: Sight AI Node CLI - A tool for running and managing the Sight AI node
Author: Sight AI
Latest version: 1.0.11

# Sight AI Miner CLI

A command-line tool for running and managing Sight AI mining software.

## Features

- Support for local and remote operation modes
- Automatic system requirements and GPU information detection
- Interactive and command-line parameter configuration
- Simplified Docker management
- Cross-platform support (Windows, macOS, Linux)

## Usage

### Direct Run (Recommended)

```bash
npx @sight-ai/sight-cli run --mode local
```

### Global Installation (Optional)

```bash
npm install -g @sight-ai/sight-cli
sight-cli run --mode local
```

## Prerequisites

The following components are required to use this CLI tool:

- Docker (20.10.0+)
- Docker Compose (2.0.0+)
- Ollama service running

## Command Overview

```
sight-cli [command] [options]
```

### Commands

- `run`: Run the mining software
- `status`: Check mining software status
- `stop`: Stop the mining software
- `logs`: View mining software logs
- `update`: Update mining software to latest version

### Options

- `-m, --mode <mode>`: Operation mode (local or remote)
- `-g, --gateway-url <URL>`: Gateway API URL (remote mode)
- `-n, --node-code <code>`: Node code (remote mode)
- `-k, --gateway-api-key <key>`: Gateway API key (remote mode)
- `-r, --reward-address <address>`: Reward address (remote mode)
- `-a, --api-base-path <path>`: API server base path (remote mode)
- `-h, --help`: Show help information
- `-V, --version`: Show version number

### Running Examples

#### Interactive Mode

```bash
npx @sight-ai/sight-cli run
```

#### Local Mode

```bash
npx @sight-ai/sight-cli run --mode local
```

#### Remote Mode

```bash
npx @sight-ai/sight-cli run --mode remote --gateway-url https://example.com --node-code ABC123 --gateway-api-key YOUR_KEY --reward-address YOUR_ADDRESS --api-base-path /api
```

## How It Works

1. CLI tool first checks system requirements (Docker and Docker Compose)
2. Detects if Ollama service is running
3. Pulls required AI models
4. Collects GPU information
5. Creates configuration file based on selected mode
6. Starts Docker container services
7. Opens mining dashboard and Web UI interface

## Logs and Cache

- Log files are located in `.sightai/logs` folder in user's home directory
- Cache files are located in `.sightai/cache` folder in user's home directory

### Test CLI Locally

```bash
node bin/index.js run
```
npm package: @sightglass/cli
Description: Agent supply chain intelligence CLI
Author: David Hope
Latest version: 0.1.5

# 🔍 Sightglass CLI

**Agent supply chain intelligence** — see what your AI coding agents actually decide.

Your AI coding agent just added 47 dependencies to your project. Do you know why it picked any of them?

## Quick Start

```bash
npx @sightglass/cli setup
```

Detects your agents, creates an account, starts the watcher daemon.

## What It Does

When an AI agent installs a dependency, Sightglass classifies **how** it made that decision:

| Classification | Meaning |
|---|---|
| **Training Recall** | Agent "just knew" from training data — no search |
| **Context Inheritance** | Found in existing project files |
| **Reactive Search** | Hit a problem, searched for solution |
| **Proactive Search** | Actively compared alternatives |
| **User Directed** | Human specified what to use |

High training recall = your agent is on autopilot, not thinking.

## Supported Agents

- ✅ Claude Code
- ✅ Codex CLI
- 🔜 Cursor
- 🔜 Windsurf
- 🔜 GitHub Copilot

## Commands

```bash
sightglass setup     # One-command setup (detect agents, login, start daemon)
sightglass login     # Authenticate with sightglass.dev
sightglass watch     # Watch agent sessions in real-time
sightglass analyze   # Analyze collected sessions
sightglass init      # Initialize in current project
```

## Dashboard

View your agent intelligence at [sightglass.dev](https://sightglass.dev)

## License

MIT
npm package: @sightread/flake
Description: A minimalist css in javascript renderer. Our mission is to be as small as possible while supporting all of the important use cases.
Latest version: 0.5.8

# Flakecss

A minimalist css in javascript renderer. Our mission
is to be as small as possible while supporting all of the important use cases.

## Features

- media queries
- pseudo-classes/pseudo-selectors
- your favorite css properties
- SSR
- no dependencies
- written in typescript

## Installation

```shell
$ npm i @sightread/flake
or
$ yarn add @sightread/flake
```

## Usage

flakecss will bundle and insert all calls into a single target element.

### In the root of your app

```javascript
import { extractCss, FLAKE_STYLE_ID } from "@sightread/flake";

function RootComponent() {
  // ... some react stuff

  return (
    <html>
      <head>
        ...
        <style
          id={FLAKE_STYLE_ID}
          dangerouslySetInnerHTML={{ __html: extractCss() }}
        />
      </head>
      ...
    </html>
  );
}
```

### In your components

Note: `css` should be called **outside** of the component on the module level.

```javascript
import { css, mediaQuery } from "@sightread/flake";

const classes = css({
  headerItem: {
    color: "blue",
    fontSize: "24px",
  },
  headerSecondary: {
    color: "red",
    fontSize: "16px",
  },
});

function MyComponent() {
  // ... react stuff

  return (
    <div>
      <h1 className={classes.headerItem}>It works!</h1>
      <h2 className={classes.headerSecondary}>(hopefully)</h2>
    </div>
  );
}
```

### Peudoclasses

```javascript
const classes = css({
    navLink: {
      color: "blue",
      "&:hover": {
        color: "black",
        textDecoration: "underline"
      },
      "&:focus": {
        color: "black"
      }
    }

  },
})
```

### Selectors

```javascript

const classes = css({
  container: {
    '& p:nth-child(odd)': {
      fontSize: 18,
      color: 'lightgrey',
      transition: '300ms',
    },
  }
})
...
...
<div className={classes.container}>
  <p>paragraph one</p>
  <p>paragraph two</p>
  <p>paragraph three</p>
  <p>paragraph four</p>
</div>
```

### Media Queries

We provide a small api for media queries for classes. The following example is equivalent to:

```css
@media only screen and (min-width: 900px) {
  .container {
    width: 50%;
  }
}
@media only screen and (max-width: 900px) {
  .container {
    width: 100%;
  }
}
```

```javascript
import { mediaQuery } from "@sightread/flake"

const classes = css({
  container {
    [mediaQuery.up(900)]: {
      width: "50%"
    },
    [mediaQuery.down(900)]: {
      width: "100%"
    }
  }
})

```

## Limitations

Currently, the css is compiled each time an app is hot reloaded. This will cause the target `style` tag to grow as the app is being developed. This is not an issues for production.

There is also no method for code splitting at this time, however this feature is in our roadmap.

## License

MIT
npm package: @sightread/flakecss
Description: A minimalist css in javascript renderer. Our mission is to be as small as possible while supporting all of the important use cases.
Latest version: 0.5.2
Deprecated: Moved to @sightread/flake

# Flakecss

A minimalist css in javascript renderer. Our mission
is to be as small as possible while supporting all of the important use cases.

## Features

- media queries
- pseudo-classes/pseudo-selectors
- your favorite css properties
- SSR

## Installation

```shell
$ npm i @sightread/flakecss
or
$ yarn add @sightread/flakecss
```

## Usage

flakecss will bundle and insert all calls into a single target element.

##### In your desired target component

```javascript
import { extractCss, FLAKE_STYLE_ID } from '@sightread/flakecss'

function RootComponent() {
  // ... some react stuff

  return (
    <html>
      <head>
        ...
        <style id={FLAKE_STYLE_ID} dangerouslySetInnerHTML={{ __html: extractCss() }} />
      </head>
      ...
    </html>
  )
}
```

```javascript
import { css, mediaQuery } from 'flakecss'

const classes = css({
  leftSection: {
    display: 'flex',
    flexDirection: 'column',
    alignItems: 'center',
    boxSizing: 'border-box',
    paddingBottom: '72px',
    [mediaQuery.up(901)]: {
      width: '50%',
    },
    [mediaQuery.down(900)]: {
      width: '100%',
      padding: '0px 15px',
    },
    '& p': {
      fontSize: 18,
      color: 'lightgrey',
      transition: '300ms',
    },
    '&:hover': {
      backgroundColor: 'white',
  },
})

function MyComponent() {
    // ... react stuff

    return (
        <div>
            <div className={classes.leftSection}>
            {/* more jsx*/}
            </div>
        </div>
    )
}
```

## License

MIT