open-index/open-npm huggingface dataset:
npm package: @promptend/cli
Description: CLI tool for registering components and APIs with Promptend Cloud
Author: Promptend Team
Latest version: 0.1.2

# Promptend CLI

CLI tool for registering components and APIs with Promptend Cloud.

## Install

```bash
# Global install (recommended)
npm i -g @promptend/cli

# Or run without installing
npx @promptend/cli@latest --help
```

## Use

```bash
# Initialize minimal registry and UI wiring
promptend init 

# Scaffold a Preview page (Next.js or Vite)
promptend preview 

# Generate/refresh registry via Core (if available)
promptend register
```

If you installed locally (not global), use npx:

```bash
npx @promptend/cli init --app-dir .
npx @promptend/cli preview --app-dir .
npx @promptend/cli register
```

Optional:

```bash
# Scaffold Preview during init
promptend init --app-dir . --with-preview

# Dry-run without writing files
promptend register --dry-run
```

## Development

```bash
# Use correct node version
nvm use

# Install deps

# Build
npm run build

# Development mode
npm run dev

# Run tests
npm test
```

## Commands

- `init` - Initialize Promptend registry and UI wiring
- `preview` - Scaffold a Preview page
- `register` - Complete registry via Core

<!-- ## License -->


## Locally

 - npm pack
npm package: @promptexecution/b00t-c0re
Description: Core Rust functionality for b00t framework with WebAssembly bindings
Latest version: 0.1.0

# 🥾 b00t-c0re

Core Rust functionality for the b00t framework with WebAssembly bindings.

## 🚀 Installation

```bash
npm install b00t-c0re
```

## 🔧 Usage

```typescript
import init, { b00t_greet, b00t_version, is_slash_command, parse_slash_command } from 'b00t-c0re';

// Initialize the WASM module
await init();

// Use b00t core functions
console.log(b00t_version()); // "0.1.0"
console.log(b00t_greet("Agent")); // "🥾 Hello Agent, welcome to b00t! Stay aligned, get cake! 🎂"

// Check slash commands
console.log(is_slash_command("/help")); // true
console.log(parse_slash_command("/learn rust")); // "Command: learn, Args: ["rust"]"
```

## 🤓 API

### Functions

- `b00t_version()` - Returns the current version
- `b00t_greet(name: string)` - Greets with b00t alignment message
- `is_slash_command(input: string)` - Checks if input is a slash command
- `parse_slash_command(input: string)` - Parses slash command structure

## 🔗 Related Packages

- **`b00t-mcp`** - Model Context Protocol server
- **`k0mmand3r`** - Full slash command parser with Rust/Python/TypeScript bindings

## 📋 Development

```bash
# Build for Node.js
npm run build

# Build for web
npm run build:web

# Test
npm test
```

## 🥾 About b00t

Part of the b00t extreme programming agent framework.
Visit: https://github.com/elasticdotventures/dotfiles

*Stay aligned, get cake!* 🎂

## 📄 License

MIT
npm package: @promptexecution/k0mmand3r
Description: typescript/wasm interface for k0mmand3r slash parser
Latest version: 0.1.0

we are writing a rust library using the winnow crate which will be a string parser for "/slash" commands
the library will be called k0mmand3r  pronouced "commander" f

the k0mmand3r library must be able to be packaged as BOTH
1. wasm using wasmer/bindgen and also 
2. exposed to python using maturin/pyo3 (a rust framework) 
3. as a rust crate for other rust programs 

the k0mmand3r library should expose a method called parse()
additionally should feature complete test coverage. 

the parse command will follow these rules:
parse can receive commands or content or both

any string should first be trimmed for whitespace on the front and back.
    after trimming, if found the kommand must begin with a forward slash "/", 
    any string which doesn't begin with a / is returned as "content" (it has no command)

if a kommand is found then parse proceeds to parse the grammar of the command
here are the rules for parsing a kommand grammar:

zero or more parameters will be found
    --parameters are prefixed by a double dash "--"
    parameters are always alphanumeric 
    if a parameter is followed by an = then it will have a value token
    so --parameter or --parameter=value can be returned
    the order of parameters is important and should be preserved in the structures
        a parameter with no value is called a "tag"
        a parameter with a value is a type "kvpair" 
    values can be of four types:
        1. string
        2. number
        3. boolean
        4. @user  (a user token begins with a literal "@" followed by a letter, followed by one or more alphanumeric or emoji characters
        5. #channel (a channel token begins with a literal "#" followed by a letter, followed by one or more alphanumeric or emoji characters

    these structures once parsed should be stored in an k0mmand3r result object

the principal goal is to develop the parser and test cases
the first task is to produce a synthetic set of commands, one per line, in a file
the second task is to develop a k0mmand object
the third task is to develop the parser by incorproatig the winnow crate
the fifth task is to develop a wasm bindgen interface and run the same tests
the sixth task will be to successfully process the synthetic commands using python

good luck!