open-index/open-npm huggingface dataset:
npm package: @sequentialos/sequential-adaptor-sqlite
Description: SQLite storage backend for sequential-runner via tasker-adaptor
Author: lanmower
Latest version: 1.0.0

# Sequential Adaptor SQLite

SQLite storage backend for sequential-ecosystem.

## Installation

```bash
npm install sequential-adaptor sequential-adaptor-sqlite
```

## Usage

```javascript
import { SQLiteAdapter } from 'sequential-adaptor-sqlite';
import { TaskExecutor } from 'sequential-adaptor';

const adapter = new SQLiteAdapter(':memory:');
await adapter.init();

const executor = new TaskExecutor(adapter);
```

## Via Registry

```javascript
import { createAdapter } from 'sequential-adaptor';

const adapter = await createAdapter('sqlite', { dbPath: './tasks.db' });
```

## Database Paths

```javascript
new SQLiteAdapter(':memory:')
new SQLiteAdapter('./tasks.db')
new SQLiteAdapter('/path/to/database.db')
```

## Environment Variables

```bash
SQLITE_DB_PATH=./tasks.db
```

## Features

- File-based storage
- WAL mode for concurrency
- Suitable for development and small deployments

## License

MIT
npm package: @sequentialos/sequential-adaptor-supabase
Description: Supabase storage backend for sequential-runner via tasker-adaptor
Author: lanmower
Latest version: 1.0.1

# Sequential Adaptor Supabase

Supabase PostgreSQL storage backend for sequential-ecosystem.

## Installation

```bash
npm install sequential-adaptor sequential-adaptor-supabase
```

## Usage

```javascript
import { SupabaseAdapter } from 'sequential-adaptor-supabase';
import { TaskExecutor } from 'sequential-adaptor';

const adapter = new SupabaseAdapter(
  'https://your-project.supabase.co',
  'your-service-key',
  'your-anon-key'
);

await adapter.init();

const executor = new TaskExecutor(adapter);
```

## Via Registry

```javascript
import { createAdapter } from 'sequential-adaptor';

const adapter = await createAdapter('supabase', {
  url: process.env.SUPABASE_URL,
  serviceKey: process.env.SUPABASE_SERVICE_KEY,
  anonKey: process.env.SUPABASE_ANON_KEY
});
```

## Environment Variables

```bash
SUPABASE_URL=https://your-project.supabase.co
SUPABASE_SERVICE_KEY=your-service-key
SUPABASE_ANON_KEY=your-anon-key
```

## Database Schema

Tables created by migrations:
- `task_runs` - Task execution records
- `stack_runs` - Service call records
- `task_functions` - Published task code
- `keystore` - Credentials

## Features

- Managed PostgreSQL database
- Scalable for production use
- Real-time capabilities via Supabase

## License

MIT
npm package: @sequentialos/sequential-fetch
Description: Pure JavaScript VM that pauses on every fetch() call. Drop-in replacement for fetchflow. Works in Node.js, Bun, Deno, and Google Apps Script with zero dependencies.
Author: Claude Code
Latest version: 1.0.0

# Sequential Fetch

Implicit xstate VM - automatic pause/resume on every `fetch()` call.

## Installation

```bash
npm install sequential-fetch
```

## Usage

```javascript
const { SequentialFetchVM, executeCode } = require('sequential-fetch');

const result = await executeCode('const x = 10; x * 2');

const vm = new SequentialFetchVM();
await vm.initialize();

const pauseResult = await vm.executeCode(`
  const userId = 123;
  const user = fetch('https://api.example.com/user/' + userId);
  user.name
`);

const finalResult = await vm.resumeExecution(pauseResult.state, { name: 'Alice' });

vm.dispose();
```

## API

### SequentialFetchVM

```javascript
new SequentialFetchVM(options)
```

Methods:
- `initialize()` - Initialize VM
- `executeCode(code)` - Execute code, returns pause/complete/error result
- `resumeExecution(fetchId, response)` - Resume from paused fetch
- `dispose()` - Clean up

### Result Types

**Pause** (fetch encountered):
```javascript
{ type: 'pause', state: fetchId, fetchRequest: { id, url, options } }
```

**Complete** (execution finished):
```javascript
{ type: 'complete', result: value }
```

## Supported

- Variable assignment
- Expressions and arithmetic
- Property access
- String concatenation
- Objects and arrays
- Fetch pausing

## Not Supported (by design)

- Loops
- Conditionals
- Functions
- async/await
- Closures

Cross-runtime compatible: Node.js, Bun, Deno.

## License

MIT
npm package: @sequentialos/sequential-flow
Description: JavaScript execution library with automatic pause/resume on fetch calls and custom storage. Built for edge functions, serverless environments, and cross-runtime compatibility. Lightweight alternative to FlowState.
Author: Claude Code
Latest version: 1.0.0

# Sequential Flow

Explicit xstate VM with state graphs for complex workflows. Built on sequential-fetch.

## Installation

```bash
npm install sequential-flow
```

## Usage

```javascript
const { SequentialFlow } = require('sequential-flow');

const result = await SequentialFlow.execute({
  id: 'my-task',
  code: `
    const userId = 123;
    const user = fetch('https://api.example.com/user/' + userId);
    user.name
  `
});

if (result.status === 'paused') {
  const resumed = await SequentialFlow.resume({
    taskId: result.id,
    vmState: result.vmState,
    originalCode: result.code,
    fetchResponse: { data: { id: 123, name: 'Alice' } }
  });
}
```

## Storage Options

```javascript
const { SequentialFlow, InMemoryStorage } = require('sequential-flow');

SequentialFlow.setDefaultStorage(new InMemoryStorage());
```

Supported: InMemoryStorage, RedisStorage, SQLStorage, FirestoreStorage, CustomStorage

## API

### SequentialFlow.execute(request, options)

```javascript
const result = await SequentialFlow.execute({
  id: 'task-1',
  name: 'My Task',
  code: 'const x = 5; x * 2'
}, {
  storage: myStorage,
  saveToStorage: true,
  ttl: 7200000
});
```

### SequentialFlow.resume(request, options)

```javascript
const result = await SequentialFlow.resume({
  taskId: 'task-1',
  vmState: previousResult.vmState,
  originalCode: previousResult.code,
  fetchResponse: { data: responseData }
});
```

### SequentialFlow.getTask(taskId)

### SequentialFlow.deleteTask(taskId)

### SequentialFlow.setDefaultStorage(storage)

## Result Object

```javascript
{
  id: 'task-1',
  status: 'running' | 'paused' | 'completed' | 'error',
  result: value,
  error: message,
  vmState: executionState,
  fetchRequest: { id, url, options }
}
```

## Edge Function Support

Works with Supabase, Firebase, Vercel, Deno Deploy edge functions.

## License

MIT
npm package: @sequentialos/sequential-http-utils
Description: HTTP utilities for sequential-runner with retry logic, response parsing, and request building
Author: lanmower
Latest version: 1.0.0

# @sequential/sequential-http-utils

HTTP utilities for sequential-runner including retry logic, response parsing, and request building.

## Installation

```bash
npm install @sequential/sequential-http-utils
```

## Usage

```javascript
import {{ main }} from '@sequential/sequential-http-utils';

const result = main(/* args */);
```

## API

### Main Export

Main function/class provided by this package.

## Examples

```javascript
// Basic usage
const value = main(input);

// With options
const result = main(input, {{ /* options */ }});
```

## Related Packages

- [@sequential/sequential-utils](../sequential-utils) - General utilities
- [@sequential/sequential-validators](../sequential-validators) - Validation

## License

MIT
npm package: @sequentialos/sequential-logging
Description: Consolidated logging service utility for sequential-ecosystem packages
Author: lanmower
Latest version: 1.0.3

# Sequential Logging

Consolidated logging for sequential-ecosystem packages.

## Installation

```bash
npm install sequential-logging
```

## Usage

```javascript
import logger from 'sequential-logging';

logger.setLevel('INFO');
logger.info('Application started');
logger.warn('This is a warning', { code: 'WARN_001' });
logger.error('Operation failed', new Error('Something broke'));
```

## Log Levels

- `DEBUG` (0)
- `INFO` (1)
- `WARN` (2)
- `ERROR` (3)

## Methods

```javascript
logger.setLevel('DEBUG');
logger.debug('Variable state', { x: 10 });
logger.info('User logged in', { userId: '123' });
logger.warn('Deprecated API', { api: 'oldMethod' });
logger.error('Failed', err, { context: 'data' });
```

## Context

```javascript
logger.setContext({ service: 'auth', version: '1.0' });
logger.addContext('requestId', '550e8400');
```

## Output Formats

```javascript
logger.setOutputFormat('cli');
logger.setOutputFormat('server');
logger.setOutputFormat('json');
```

## Child Loggers

```javascript
const childLogger = logger.child({ module: 'payment' });
childLogger.info('Processing');
```

## Lazy Evaluation

```javascript
logger.debug('Expensive data', () => computeExpensiveData());
```

## License

MIT
npm package: @sequentialos/sequential-runner
Description: Deployment-agnostic task execution engine with automatic suspend/resume
Author: lanmower
Latest version: 1.0.0

# Sequential Runner

Task execution engine with automatic suspend/resume for infinite-length tasks.

## Features

- Automatic suspend/resume on external calls
- HTTP-based stack processing
- `__callHostTool__` for wrapped service calls
- Task function storage and retrieval

## Architecture

```
Task Submission → deno-executor → suspend on __callHostTool__
                        ↓
               stack-processor → wrapped service
                        ↓
               resume task with result
```

## Host Tools

Tasks call external services via `__callHostTool__`:

```javascript
export async function myTask(input) {
  const users = await __callHostTool__('database', 'getUsers', { limit: 10 });
  const email = await __callHostTool__('gapi', 'sendEmail', { to: users[0].email });
  return { sent: true };
}
```

Available services:
- `database` - Supabase operations
- `gapi` - Google API (Gmail, Calendar, etc.)
- `openai` - OpenAI API
- `keystore` - Credential storage

## Task Definition

```javascript
export const config = {
  name: 'my-task',
  description: 'My task description',
  inputs: [
    { name: 'userId', type: 'string', description: 'User ID' }
  ]
};

export async function my_task(input) {
  const data = await __callHostTool__('database', 'query', { id: input.userId });
  return { success: true, data };
}
```

## Integration with sequential-adaptor

```javascript
import { TaskExecutor, StackProcessor, createAdapter } from 'sequential-adaptor';

const adapter = await createAdapter('folder', { basePath: './tasks' });
const executor = new TaskExecutor(adapter);
const processor = new StackProcessor(adapter);

const result = await executor.execute(taskRun, taskCode);
```

## Database Schema

- `task_functions` - Published task code
- `task_runs` - Execution instances
- `stack_runs` - Service call chain
- `keystore` - Credentials

## License

MIT
npm package: @sequentialos/sequential-storage-utils
Description: Shared storage utilities for task adapters: serialization, validation, and CRUD patterns
Author: lanmower
Latest version: 1.0.1

# @sequential/sequential-storage-utils

Shared storage utilities for task adapters including serialization, validation, and CRUD patterns.

## Installation

```bash
npm install @sequential/sequential-storage-utils
```

## Usage

```javascript
import {{ main }} from '@sequential/sequential-storage-utils';

const result = main(/* args */);
```

## API

### Main Export

Main function/class provided by this package.

## Examples

```javascript
// Basic usage
const value = main(input);

// With options
const result = main(input, {{ /* options */ }});
```

## Related Packages

- [@sequential/sequential-utils](../sequential-utils) - General utilities
- [@sequential/sequential-validators](../sequential-validators) - Validation

## License

MIT
npm package: @sequentialos/sequential-utils
Description: Common utilities for sequential ecosystem - timestamps, errors, etc.
Author: lanmower
Latest version: 1.0.0

# @sequential/sequential-utils

Common utilities for Sequential Ecosystem including timestamp helpers, error utilities, and type checking.

## Installation

```bash
npm install @sequential/sequential-utils
```

## Usage

```javascript
import {{ main }} from '@sequential/sequential-utils';

const result = main(/* args */);
```

## API

### Main Export

Main function/class provided by this package.

## Examples

```javascript
// Basic usage
const value = main(input);

// With options
const result = main(input, {{ /* options */ }});
```

## Related Packages

- [@sequential/sequential-utils](../sequential-utils) - General utilities
- [@sequential/sequential-validators](../sequential-validators) - Validation

## License

MIT
npm package: @sequentialos/sequential-validators
Description: Validation utilities and field validators for sequential-ecosystem tasks
Author: lanmower
Latest version: 1.0.0

# @sequential/sequential-validators

Validation utilities and field validators for Sequential Ecosystem tasks and operations.

## Installation

```bash
npm install @sequential/sequential-validators
```

## Usage

```javascript
import {{ main }} from '@sequential/sequential-validators';

const result = main(/* args */);
```

## API

### Main Export

Main function/class provided by this package.

## Examples

```javascript
// Basic usage
const value = main(input);

// With options
const result = main(input, {{ /* options */ }});
```

## Related Packages

- [@sequential/sequential-utils](../sequential-utils) - General utilities
- [@sequential/sequential-validators](../sequential-validators) - Validation

## License

MIT
npm package: @sequentialos/sequential-wrapped-services
Description: Runtime-agnostic wrapped services for sequential-runner (Google APIs, keystore, database, etc.)
Author: lanmower
Latest version: 1.1.1

# Sequential Wrapped Services

Runtime-agnostic HTTP service implementations for sequential-ecosystem. Run on Deno, Node.js, or Bun.

## Services

- **deno-executor** - Task execution runtime with automatic suspend/resume
- **simple-stack-processor** - Processes pending service calls in FIFO order
- **task-executor** - Task submission and lifecycle management
- **gapi** - Google Workspace APIs (Gmail, Admin, etc.)
- **keystore** - Secure credential storage
- **supabase** - Database operation proxy
- **openai** - OpenAI API integration
- **websearch** - Web search integration

## Quick Start

```bash
npm start
npm start -- --services deno-executor,gapi,keystore
npm start -- --port 3100
```

## Adding a Service

```typescript
export async function handler(req: Request): Promise<Response> {
  return new Response(JSON.stringify({ success: true }), {
    headers: { 'Content-Type': 'application/json' }
  });
}

if (import.meta.main) {
  const port = parseInt(Deno.env.get('PORT') || '3000');
  serve(handler, { port });
}
```

## Service Discovery

CLI auto-discovers services in `services/` directory and creates `.service-registry.json`.

## Integration

Services are called via `__callHostTool__`:

```javascript
const users = await __callHostTool__('database', 'getUsers', { limit: 10 });
const email = await __callHostTool__('gapi', 'sendEmail', { to: 'user@example.com' });
```

## Environment

```bash
PORT=3100
DEBUG=true
SUPABASE_URL=...
OPENAI_API_KEY=...
GAPI_KEY=...
```

## License

MIT