Wippy AI

https://github.com/wippyai/docs
Admin
Wippy AI is an artificial intelligence project providing various solutions and services.
Tokens:338,459
Snippets:4,396
Trust Score:7.1
License:MPL-2.0
Update:1 month ago
Show doc for...
Tokens:
Raw
### Runtime Console Output

Source: https://github.com/wippyai/docs/blob/main/en/tutorials/hello-world.md

Example output displayed when the runtime starts successfully.

```text
╦ ╦╦╔═╗╔═╗╦ ╦  Adaptive Application Runtime
║║║║╠═╝╠═╝╚╦╝  v0.1.20
╚╩╝╩╩  ╩   ╩   by Spiral Scout

0.00s  INFO  run          runtime ready
0.11s  INFO  core         service app:gateway is running  {"details": "service listening on :8080"}
```

--------------------------------

### Add and install dependencies

Source: https://github.com/wippyai/docs/blob/main/en/guides/dependency-management.md

Add dependencies by name, version, or label, then run install to apply changes to the project.

```bash
wippy add acme/http               # Latest version
wippy add acme/http@1.2.3         # Exact version
wippy add acme/http@latest         # Latest label
```

```bash
wippy install
```

--------------------------------

### Install Usage Module

Source: https://github.com/wippyai/docs/blob/main/en/framework/usage.md

Commands to add and install the usage tracking module into the project.

```bash
wippy add wippy/usage
wippy install
```

--------------------------------

### Install wippy/bootloader

Source: https://github.com/wippyai/docs/blob/main/en/framework/bootloader.md

Commands to add and install the bootloader module into the project.

```bash
wippy add wippy/bootloader
wippy install
```

--------------------------------

### Install Facade Module

Source: https://github.com/wippyai/docs/blob/main/en/framework/facade.md

Commands to add and install the facade module into your project.

```bash
wippy add wippy/facade
wippy install
```

--------------------------------

### Install Wippy runtime

Source: https://github.com/wippyai/docs/blob/main/en/start/installation.md

Use the curl command to download and execute the installation script.

```bash
curl -fsSL https://hub.wippy.ai/install.sh | bash
```

--------------------------------

### SQL database operations example

Source: https://github.com/wippyai/docs/blob/main/en/lua/storage/sql.md

Comprehensive example demonstrating database connection, query building, transactions, prepared statements, and NULL handling.

```lua
local sql = require("sql")

-- Get database connection
local db, err = sql.get("app.db:main")
if err then error(err) end

-- Check database type
local dbtype, _ = db:type()
print("Database type:", dbtype)

-- Direct query
local users, err = db:query("SELECT id, name FROM users WHERE active = ?", {1})
if err then error(err) end

for _, user in ipairs(users) do
    print(user.id, user.name)
end

-- Builder pattern
local query = sql.builder.select("u.id", "u.name", "COUNT(o.id) as order_count")
    :from("users u")
    :left_join("orders o ON o.user_id = u.id")
    :where(sql.builder.and_({
        sql.builder.eq({["u.active"] = 1}),
        sql.builder.gte({["u.score"] = 80})
    }))
    :group_by("u.id", "u.name")
    :having(sql.builder.gt({["COUNT(o.id)"] = 0}))
    :order_by("order_count DESC")
    :limit(10)

local executor = query:run_with(db)
local results, err = executor:query()
if err then error(err) end

-- Transaction with savepoints
local tx, err = db:begin({isolation = sql.isolation.SERIALIZABLE})
if err then error(err) end

local _, err = tx:execute("INSERT INTO users (name) VALUES (?)", {"alice"})
if err then
    tx:rollback()
    error(err)
end

tx:savepoint("sp1")

local _, err = tx:execute("UPDATE users SET status = ? WHERE id = ?", {"active", 1})
if err then
    tx:rollback_to("sp1")
else
    tx:release("sp1")
end

local ok, err = tx:commit()
if err then error(err) end

-- Prepared statements
local stmt, err = db:prepare("INSERT INTO logs (message, level) VALUES (?, ?)")
if err then error(err) end

for i = 1, 100 do
    local _, err = stmt:execute({"log message " .. i, "info"})
    if err then
        stmt:close()
        error(err)
    end
end

stmt:close()

-- NULL and typed values
local insert = sql.builder.insert("products")
    :columns("name", "price", "description")
    :values("Widget", sql.as.float(19.99), sql.NULL)

local executor = insert:run_with(db)
local result, err = executor:exec()
if err then error(err) end

print("Inserted ID:", result.last_insert_id)

db:release()
```

--------------------------------

### Initialize and run a project

Source: https://github.com/wippyai/docs/blob/main/en/start/installation.md

Create a new project directory and start the runtime.

```bash
# Create a new project
mkdir myapp && cd myapp
wippy init

# Run
wippy run
```

--------------------------------

### Start the application

Source: https://github.com/wippyai/docs/blob/main/en/tutorials/keeper-mcp.md

Command to launch the application after configuring the Keeper dependency.

```bash
wippy run
```

--------------------------------

### Initialize and run application

Source: https://github.com/wippyai/docs/blob/main/en/tutorials/auth.md

Commands to initialize the project environment and start the application server.

```bash
wippy init
wippy run
```

--------------------------------

### Initialize and run the service

Source: https://github.com/wippyai/docs/blob/main/en/tutorials/task-queue.md

Commands to create the data directory and start the Wippy service.

```bash
mkdir -p data
wippy init
wippy run
```

--------------------------------

### client:start(dataflow_id, options?)

Source: https://github.com/wippyai/docs/blob/main/de/framework/dataflow.md

Starts a workflow asynchronously.

```APIDOC
## client:start(dataflow_id, options?)

### Description
Starts a workflow in the background.

### Parameters
- **dataflow_id** (string) - The ID of the workflow to start
- **options** (table, optional) - Execution options

### Returns
- **dataflow_id** (string) - The unique identifier for the running workflow
```

--------------------------------

### Verify installation

Source: https://github.com/wippyai/docs/blob/main/en/start/installation.md

Check the installed version of the Wippy CLI.

```bash
wippy version
```

--------------------------------

### Run and Verify Facade

Source: https://github.com/wippyai/docs/blob/main/en/tutorials/facade.md

Commands to start the application and verify the configuration endpoint.

```bash
wippy run
```

```bash
curl http://localhost:8087/api/public/facade/config
```

--------------------------------

### Install @wippy-fe packages

Source: https://github.com/wippyai/docs/blob/main/en/frontend/web-host/packages.md

Install the necessary packages for micro-frontend development via npm.

```bash
npm install @wippy-fe/proxy @wippy-fe/webcomponent-vue @wippy-fe/router
```

--------------------------------

### Run as HTTP Service

Source: https://github.com/wippyai/docs/blob/main/en/tutorials/rust-wasm.md

Start the Wippy HTTP server and test the greet endpoint.

```bash
wippy run
```

```bash
curl -X POST http://localhost:8090/greet
```

--------------------------------

### Install Relay Module

Source: https://github.com/wippyai/docs/blob/main/en/framework/relay.md

Commands to add and install the relay module into the project.

```bash
wippy add wippy/relay
wippy install
```

--------------------------------

### Define a Start Event

Source: https://github.com/wippyai/docs/blob/main/en/lua/system/tty.md

Structure for the initial start event emitted after tty.start().

```lua
{type = "start", width = 120, height = 40}
```

--------------------------------

### Wippy Configuration File Example

Source: https://github.com/wippyai/docs/blob/main/en/guides/cli.md

Example of a .wippy.yaml file used for defining persistent settings such as logging, profiling, and application overrides.

```yaml
logger:
  encoding: console

logmanager:
  min_level: -1  # debug

profiler:
  enabled: true
  address: localhost:6060

override:
  app:gateway:addr: ":9090"
  app:db:host: "localhost"
```

--------------------------------

### Install dependencies

Source: https://github.com/wippyai/docs/blob/main/en/guides/artifacts.md

Run the package manager to resolve dependencies after materialization.

```bash
npm install
```

--------------------------------

### Run CLI Application

Source: https://github.com/wippyai/docs/blob/main/en/tutorials/cli.md

Example command to execute a CLI process.

```bash
$ wippy run -x app:cli
Hello from CLI!
```

--------------------------------

### Fetch the artifact pack file

Source: https://github.com/wippyai/docs/blob/main/en/guides/artifacts.md

Install the dependency and locate the resulting .wapp file.

```bash
( cd build-inputs && wippy install )
wapp=$(ls build-inputs/.wippy/vendor/kickside/ui-kit-*.wapp | grep -v sha256 | sort | tail -1)
```

--------------------------------

### Initialize and Run Runtime

Source: https://github.com/wippyai/docs/blob/main/en/tutorials/hello-world.md

Commands to generate the lock file and start the Wippy runtime.

```bash
# Generate lock file from source
wippy init

# Start the runtime (-c for colorful console output)
wippy run -c
```

--------------------------------

### Initialize and Load Agent

Source: https://github.com/wippyai/docs/blob/main/en/framework/agents.md

Basic setup to create a context and load an agent by identifier.

```lua
local agent_context = require("agent_context")

local ctx = agent_context.new()
local runner, err = ctx:load_agent("app:assistant")
if err then
    error("Failed to load agent: " .. tostring(err))
end
```

--------------------------------

### Add and install migration module

Source: https://github.com/wippyai/docs/blob/main/en/framework/migration.md

Commands to add the migration module to the project and install dependencies.

```bash
wippy add wippy/migration
wippy install
```

--------------------------------

### Client Message Routing Example

Source: https://github.com/wippyai/docs/blob/main/en/framework/relay.md

Example of a client-sent message and the corresponding payload routed to a plugin process.

```json
{ "type": "session_get_state", "data": { "key": "value" } }
```

```lua
-- process topic: "get_state"
-- payload:
{
    conn_pid = client_pid,
    type = "session_get_state",  -- original full type preserved
    data = { key = "value" },
    request_id = "...",
    session_id = "..."
}
```

--------------------------------

### Find all match indices

Source: https://github.com/wippyai/docs/blob/main/en/lua/text/text.md

Get the start and end indices for all occurrences of the pattern.

```lua
local positions = re:find_all_string_index("a1b2c3")
```

--------------------------------

### Initialize data directory and run application

Source: https://github.com/wippyai/docs/blob/main/en/tutorials/dataflow.md

Create the required data directory and start the Wippy application to trigger migrations.

```bash
mkdir -p data
wippy run
```

--------------------------------

### Find match index

Source: https://github.com/wippyai/docs/blob/main/en/lua/text/text.md

Get the start and end indices of the first match.

```lua
local pos = re:find_string_index("abc123")
```

--------------------------------

### Initialize Project

Source: https://github.com/wippyai/docs/blob/main/en/tutorials/cli.md

Commands to create the project directory and source folder.

```bash
mkdir cli-app && cd cli-app
mkdir src
```

--------------------------------

### process.spawn_monitored

Source: https://github.com/wippyai/docs/blob/main/en/temporal/workflows.md

Starts a workflow and allows monitoring for completion events.

```APIDOC
## process.spawn_monitored(entry, worker, input)

### Description
Starts a workflow and enables monitoring to receive EXIT events when the workflow completes.

### Parameters
- **entry** (string) - The workflow entry point.
- **worker** (string) - The temporal worker name.
- **input** (table) - The input data for the workflow.

### Returns
- **pid** (string) - The process ID of the workflow.
- **err** (string) - Error message if the spawn failed.
```

--------------------------------

### Bundle Directory Layout Example

Source: https://github.com/wippyai/docs/blob/main/en/frontend/frontend-registry/registry-entries.md

A sample file structure demonstrating how base_path relates to entry_point and shared resources.

```text
static/
  shared/
    vendor.js
  app/
    index.html    ← entry_point: app/index.html
    app.js
```

--------------------------------

### Install LLM module

Source: https://github.com/wippyai/docs/blob/main/en/framework/llm.md

Commands to add and install the wippy/llm module into your project.

```bash
wippy add wippy/llm
wippy install
```

--------------------------------

### Install Dataflow Module

Source: https://github.com/wippyai/docs/blob/main/de/framework/dataflow.md

Commands to add and install the wippy/dataflow module into your project.

```bash
wippy add wippy/dataflow
wippy install
```

--------------------------------

### Web Host Initialization Sequence

Source: https://github.com/wippyai/docs/blob/main/en/frontend/web-host/bootstrap.md

Visual representation of the boot process starting from the facade module load through to WebSocket connection.

```text
module.js / managed-layout.js loaded on the page
  │
  ├─ window.initWippyApp(config, '#app')
  │     config.AppConfig = { $schema, auth, env, theming, hostConfig, context }
  │
  ├─ Init Pinia (auth store, config store)
  ├─ Configure Axios (baseURL, auth header)
  ├─ Create Vue Router (history mode, system routes)
  ├─ Install PrimeVue, inject theme CSS
  ├─ Mount App.vue
  │
  ├─ GET /api/public/pages/routes
  │     router.addRoute('app', ...) for each backend mountRoute
  │
  ├─ Resolve current URL → render matching view
  └─ Connect WebSocket
```

--------------------------------

### Initialize Wippy Project

Source: https://github.com/wippyai/docs/blob/main/en/tutorials/rust-wasm.md

Navigate to the application directory and initialize the project environment.

```bash
cd app
wippy init
```

--------------------------------

### Initialize and Test Agent

Source: https://github.com/wippyai/docs/blob/main/en/tutorials/llm-agent.md

Commands to initialize the project and execute the ask function.

```bash
wippy init
wippy run -x app:ask "What is the capital of France?"
```

--------------------------------

### Install wippy/agent module

Source: https://github.com/wippyai/docs/blob/main/en/framework/agents.md

Use these commands to add and install the agent module into your project.

```bash
wippy add wippy/agent
wippy install
```

--------------------------------

### Create and configure processes

Source: https://github.com/wippyai/docs/blob/main/en/lua/dynamic/exec.md

Execute commands with optional working directories and environment variables.

```lua
-- Simple command
local proc, err = executor:exec("echo 'Hello, World!'")

-- With working directory
local proc = executor:exec("npm install", {
    work_dir = "/app/project"
})

-- With environment variables
local proc = executor:exec("python script.py", {
    work_dir = "/scripts",
    env = {
        PYTHONPATH = "/app/lib",
        DEBUG = "true",
        API_KEY = api_key
    }
})

-- Run shell script
local proc = executor:exec("./deploy.sh production", {
    work_dir = "/app/scripts",
    env = {
        DEPLOY_ENV = "production"
    }
})
```

--------------------------------

### process.spawn

Source: https://github.com/wippyai/docs/blob/main/en/temporal/workflows.md

Starts a new workflow execution on the specified Temporal worker.

```APIDOC
## process.spawn(entry, worker, input)

### Description
Starts a workflow from code. The workflow runs durably on Temporal infrastructure.

### Parameters
- **entry** (string) - The workflow entry point.
- **worker** (string) - The temporal worker name.
- **input** (table) - The input data for the workflow.

### Returns
- **pid** (string) - The process ID of the workflow.
- **err** (string) - Error message if the spawn failed.
```

--------------------------------

### Perform HTTP GET Request

Source: https://github.com/wippyai/docs/blob/main/en/lua/http/client.md

Execute a GET request and handle the response or error.

```lua
local resp, err = http_client.get("https://api.example.com/users")
if err then
    return nil, err
end

print(resp.status_code)  -- 200
print(resp.body)         -- response body
```

--------------------------------

### Built-in Validator Examples

Source: https://github.com/wippyai/docs/blob/main/en/lua/types.md

Examples of built-in validators applied to various data types.

```lua
local x: number @min(0) = 1
```

```lua
local x: number @max(100) = 50
```

```lua
local s: string @min_len(1) = "hi"
```

```lua
local s: string @max_len(10) = "hi"
```

```lua
local email: string @pattern("^.+@.+") = "a@b.com"
```

--------------------------------

### Load the compression module

Source: https://github.com/wippyai/docs/blob/main/en/lua/data/compress.md

Initialize the compression library for use in the script.

```lua
local compress = require("compress")
```

--------------------------------

### String Operations Example

Source: https://github.com/wippyai/docs/blob/main/en/lua/core/base.md

Examples of pattern matching, substitution, and method-based string manipulation.

```lua
local s = "Hello, World!"

-- Pattern matching
local start, stop = string.find(s, "World")  -- 8, 12
local word = string.match(s, "%w+")          -- "Hello"

-- Substitution
local new = string.gsub(s, "World", "Wippy") -- "Hello, Wippy!"

-- Method syntax
local upper = s:upper()                       -- "HELLO, WORLD!"
local part = s:sub(1, 5)                      -- "Hello"
```

--------------------------------

### Prepare module for publishing

Source: https://github.com/wippyai/docs/blob/main/en/guides/publishing.md

Initialize, update, and lint the module before publishing.

```bash
wippy init
wippy update
wippy lint
```

--------------------------------

### Install Keeper module

Source: https://github.com/wippyai/docs/blob/main/en/tutorials/keeper-mcp.md

Commands to add and install the Keeper dependency to an existing Wippy application.

```bash
wippy add keeper/keeper
wippy install
```

--------------------------------

### Install wippy/views module

Source: https://github.com/wippyai/docs/blob/main/en/framework/views.md

Use these commands to add and install the views module dependency in your project.

```bash
wippy add wippy/views
wippy install
```

--------------------------------

### Configuration Casing Example

Source: https://github.com/wippyai/docs/blob/main/en/frontend/micro-frontends/configuration-casing.md

Demonstrates the mix of snake_case for backend wrapper keys and camelCase for nested frontend configuration objects.

```yaml
config_overrides:
  customization:
    customCSS: ""
    cssVariables: {}
  routePrefix: /admin

proxy:
  injections:
    css:
      themeConfig: true
      customCss: true
      iframe: true
```

--------------------------------

### Complete HTTP Router Configuration

Source: https://github.com/wippyai/docs/blob/main/en/http/router.md

A full example demonstrating service definition, router configuration with middleware, and endpoint mapping to Lua functions.

```yaml
version: "1.0"
namespace: app

entries:
  # Server
  - name: gateway
    kind: http.service
    addr: ":8080"
    lifecycle:
      auto_start: true

  # API Router
  - name: api
    kind: http.router
    meta:
      server: gateway
    prefix: /api/v1
    middleware:
      - cors
      - compress
      - ratelimit
    options:
      cors.allow.origins: "https://app.example.com"
      ratelimit.requests: "100"
      ratelimit.window: "1m"

  # Handler function
  - name: get_users
    kind: function.lua
    source: file://handlers/users.lua
    method: list
    modules:
      - http
      - json
      - sql

  # Endpoints
  - name: list_users
    kind: http.endpoint
    meta:
      router: api
    method: GET
    path: /users
    func: get_users

  - name: get_user
    kind: http.endpoint
    meta:
      router: api
    method: GET
    path: /users/{id}
    func: app:get_user_by_id

  - name: create_user
    kind: http.endpoint
    meta:
      router: api
    method: POST
    path: /users
    func: app:create_user
```

--------------------------------

### Add and Install Embeddings Module

Source: https://github.com/wippyai/docs/blob/main/en/framework/embeddings.md

Commands to add the wippy/embeddings module to your project and install dependencies.

```bash
wippy add wippy/embeddings
wippy install
```

--------------------------------

### Type Checking Error Examples

Source: https://github.com/wippyai/docs/blob/main/en/guides/linter.md

Examples of type mismatches that trigger E-series errors during static analysis.

```lua
local x: number = "hello"         -- E: string not assignable to number

local function add(a: number, b: number): number
    return a + b
end

add("one", "two")                  -- E: string not assignable to number
```

--------------------------------

### Initialize a new Wippy project

Source: https://github.com/wippyai/docs/blob/main/en/guides/dependency-management.md

Creates a wippy.lock file and sets up default project directories.

```bash
wippy init
```

--------------------------------

### Install dependencies from lock file

Source: https://github.com/wippyai/docs/blob/main/en/guides/dependency-management.md

Install modules based on the lock file, with an optional refresh flag to force re-fetching.

```bash
wippy install                      # Install all from lock
wippy install --refresh            # Re-fetch every module (--force and --repair are aliases)
```

--------------------------------

### Initialize and Run Probe

Source: https://github.com/wippyai/docs/blob/main/en/tutorials/network.md

Commands to initialize the project and execute the probe script.

```bash
wippy init
wippy run probe
```

--------------------------------

### Search for available modules

Source: https://github.com/wippyai/docs/blob/main/de/framework/overview.md

Use the CLI to search the hub for available framework modules.

```bash
wippy search wippy
```

--------------------------------

### Spawn with a custom name

Source: https://github.com/wippyai/docs/blob/main/en/temporal/workflows.md

Assign a name to a workflow to enable deduplication and idempotent starts.

```lua
local spawner = process
    .with_options({})
    :with_name("order-" .. order.id)

local pid, err = spawner:spawn_monitored(
    "app:order_workflow",
    "app:worker",
    {order_id = order.id}
)
```

--------------------------------

### Stub proxy globals in Vitest setup

Source: https://github.com/wippyai/docs/blob/main/en/frontend/micro-frontends/host-less-mode.md

Define the __WIPPY_APP_API__ global in your test setup file to satisfy proxy contract requirements.

```ts
// vitest.setup.ts
;(window as any).__WIPPY_APP_API__ = {
  api: mockApi,
  host: mockHost,
  on: mockOn,
  // ...other ProxyApiInstance fields
}
```

--------------------------------

### Run CLI Project

Source: https://github.com/wippyai/docs/blob/main/en/tutorials/cli.md

Commands to initialize and execute the CLI application.

```bash
wippy init
wippy run -x app:cli
```

--------------------------------

### Spawn Asynchronous Child Workflow

Source: https://github.com/wippyai/docs/blob/main/en/temporal/workflows.md

Use process.spawn to start a child workflow without blocking, then monitor completion via process events.

```lua
local events_ch = process.events()

local child_pid, err = process.spawn(
    "app:child_workflow",
    "app:worker",
    {message = "hello from parent"}
)
if err then
    return {status = "spawn_failed", error = tostring(err)}
end

-- Wait for child EXIT event
local event = events_ch:receive()

if event.kind == process.event.EXIT then
    local child_result = event.result.value
    local child_error = event.result.error
end
```

--------------------------------

### system.runtime.max_procs

Source: https://github.com/wippyai/docs/blob/main/en/lua/system/system.md

Gets or sets the GOMAXPROCS value.

```APIDOC
## system.runtime.max_procs([n])

### Description
Gets the current GOMAXPROCS value, or sets it if an argument is provided.

### Parameters
- **n** (integer) - Optional - New GOMAXPROCS value (must be > 0)

### Returns
- **value** (number) - Current or previous value
- **err** (error) - Error object if the operation fails
```

--------------------------------

### GET /api/users/

Source: https://github.com/wippyai/docs/blob/main/en/http/endpoint.md

Retrieves a list of users.

```APIDOC
## GET /api/users/

### Description
Retrieves a list of users.

### Method
GET

### Endpoint
/api/users/
```

--------------------------------

### Register and publish new module

Source: https://github.com/wippyai/docs/blob/main/en/guides/publishing.md

Use the --create flag to register a new module on the hub during the first publish.

```bash
wippy publish --create --version 0.1.0 \
  --module-visibility public \
  --module-type library \
  --module-display-name "HTTP Utils"
```

--------------------------------

### re:find_all_string_index

Source: https://github.com/wippyai/docs/blob/main/en/lua/text/text.md

Finds the start and end indices of all matches.

```APIDOC
## re:find_all_string_index

### Description
Returns a list of 1-based start and end indices for all matches.

### Parameters
- **s** (string) - Required - String to search

### Returns
- **table[] | nil**
```

--------------------------------

### GET /api/v1/users

Source: https://github.com/wippyai/docs/blob/main/en/http/router.md

Retrieves a list of users from the system.

```APIDOC
## GET /api/v1/users

### Description
Retrieves a list of users.

### Method
GET

### Endpoint
/api/v1/users
```

--------------------------------

### Create and Configure Security Scopes

Source: https://github.com/wippyai/docs/blob/main/en/system/security.md

Demonstrates how to initialize a security scope and add policies to it. Note that scopes are immutable, so the :with() method returns a new scope instance.

```lua
local security = require("security")

-- Get policies
local admin_policy = security.policy("app.security:admin_policy")
local readonly_policy = security.policy("app.security:readonly_policy")

-- Create scope with policies
local scope = security.new_scope()
scope = scope:with(admin_policy)
scope = scope:with(readonly_policy)

-- Scopes are immutable - :with() returns new scope
```

--------------------------------

### Avoid non-deterministic operations

Source: https://github.com/wippyai/docs/blob/main/en/temporal/workflows.md

Examples of operations that must be avoided to maintain workflow determinism.

```lua
-- Don't use wall clock time
local now = os.time()              -- non-deterministic

-- Don't use random directly
local r = math.random()            -- non-deterministic

-- Don't do I/O in workflow code
local file = io.open("data.txt")   -- non-deterministic

-- Don't use global mutable state
counter = counter + 1               -- non-deterministic across replays
```

--------------------------------

### Get workflow execution information

Source: https://github.com/wippyai/docs/blob/main/en/temporal/workflows.md

Retrieves metadata about the current workflow execution, including IDs, type, task queue, and history metrics.

```lua
local workflow = require("workflow")

local info = workflow.info()
print(info.workflow_id)    -- Workflow execution ID
print(info.run_id)         -- Current run ID
print(info.workflow_type)  -- Workflow type name
print(info.task_queue)     -- Task queue name
print(info.namespace)      -- Temporal namespace
print(info.attempt)        -- Current attempt number
print(info.history_length) -- Number of history events
print(info.history_size)   -- History size in bytes
```

--------------------------------

### Define namespaces

Source: https://github.com/wippyai/docs/blob/main/en/start/structure.md

Examples of dot-separated namespace identifiers.

```text
app
app.api
app.api.v2
app.workers
```

--------------------------------

### Configure demo.html for host-less development

Source: https://github.com/wippyai/docs/blob/main/en/frontend/micro-frontends/host-less-mode.md

Include the dev-proxy script in your HTML to satisfy the proxy contract during local development.

```html
<!-- demo.html in your WC project -->
<!DOCTYPE html>
<html>
<head>
    <!-- Required complete import-map script omitted from this abbreviated example. -->
    <script src="https://web-host.wippy.ai/webcomponents-1.0.44/dev-proxy.js" data-role="@wippy/scripts"></script>
</head>
<body>
    <my-component prop1="value"></my-component>
    <script type="module" src="./src/index.ts"></script>
</body>
</html>
```

--------------------------------

### Create and Use Key Bindings

Source: https://github.com/wippyai/docs/blob/main/en/lua/system/tty.md

Example of creating a reusable key binding and checking for matches within an event loop.

```lua
local quit = tty.bind({
    keys = {"q", "ctrl+c"},
    help = {key = "q/ctrl+c", desc = "quit"}
})

-- In event loop
if quit:matches(ev) then
    break
end
```

--------------------------------

### Set OFFSET

Source: https://github.com/wippyai/docs/blob/main/en/lua/storage/sql.md

Sets the starting offset for the query results.

```lua
local query = sql.builder.select("*")
    :from("users")
    :offset(20)
```

--------------------------------

### re:find_string_index

Source: https://github.com/wippyai/docs/blob/main/en/lua/text/text.md

Finds the start and end indices of the first match.

```APIDOC
## re:find_string_index

### Description
Returns the 1-based start and end indices of the first match.

### Parameters
- **s** (string) - Required - String to search

### Returns
- **table | nil**
```

--------------------------------

### GET https://wippy.ai/llm/search

Source: https://github.com/wippyai/docs/blob/main/en/start/llm-brief.md

Performs a search across the documentation.

```APIDOC
## GET https://wippy.ai/llm/search

### Description
Search the documentation using a query string.

### Method
GET

### Endpoint
https://wippy.ai/llm/search

### Parameters
#### Query Parameters
- **q** (string) - Required - The search query string.
```

--------------------------------

### Add and install framework modules via CLI

Source: https://github.com/wippyai/docs/blob/main/de/framework/overview.md

Use these commands to add a module to the lock file and download it to the vendor directory.

```bash
wippy add wippy/test
wippy install
```

--------------------------------

### store:get(key)

Source: https://github.com/wippyai/docs/blob/main/en/lua/storage/store.md

Retrieves a value from the store by its key.

```APIDOC
## store:get(key)

### Description
Retrieves the value associated with the provided key. Returns nil and an errors.NOT_FOUND error if the key does not exist or has expired.

### Parameters
- **key** (string) - Required - The key to retrieve.

### Returns
- **any** - The stored value.
- **error** - Error object if the key is not found or an error occurs.
```

--------------------------------

### Run Micro-AGI Locally

Source: https://github.com/wippyai/docs/blob/main/en/tutorials/micro-agi.md

Clone the repository and initialize the environment before running the agent.

```bash
cd micro-agi
wippy init && wippy update
wippy run agent
```

--------------------------------

### HTML Entry Point Structure

Source: https://github.com/wippyai/docs/blob/main/en/frontend/web-host/entry-point.md

A simplified HTML template that loads the Web Host JS module and initializes the application with configuration fetched from the facade.

```html
<!DOCTYPE html>
<html>
<head>
  <title>My App</title>
</head>
<body>
  <div id="app"></div>
  <script src="https://web-host.wippy.ai/<release-tag>/module.js"></script>
  <script>
    fetch('/facade/config')
      .then(r => r.json())
      .then(config => {
        window.initWippyApp(config, '#app')
      })
  </script>
</body>
</html>
```

--------------------------------

### http_client.get

Source: https://github.com/wippyai/docs/blob/main/en/lua/http/client.md

Performs an HTTP GET request to the specified URL.

```APIDOC
## http_client.get(url)

### Description
Executes an HTTP GET request. This operation is subject to security policy evaluation, including SSRF protection and permission checks.

### Parameters
- **url** (string) - Required - The target URL.

### Returns
- **resp** (table) - The response object.
- **err** (error) - Error object if the request fails or is denied by security policy.
```

--------------------------------

### GET /api/v1/uploads/{uuid}/download

Source: https://github.com/wippyai/docs/blob/main/en/frontend/micro-frontends/proxy-api.md

Downloads a file by its UUID.

```APIDOC
## GET /api/v1/uploads/{uuid}/download

### Description
Downloads a file associated with the provided UUID.

### Method
GET

### Endpoint
/api/v1/uploads/{uuid}/download

### Parameters
#### Path Parameters
- **uuid** (string) - Required - The unique identifier of the upload

### Response
#### Success Response (200)
- **blob** (Blob) - The file content
```

--------------------------------

### Load Filesystem Module

Source: https://github.com/wippyai/docs/blob/main/en/lua/storage/filesystem.md

Initialize the filesystem module for use in the script.

```lua
local fs = require("fs")
```

--------------------------------

### GET /api/v1/uploads/list

Source: https://github.com/wippyai/docs/blob/main/en/frontend/micro-frontends/proxy-api.md

Retrieves a paginated list of file uploads.

```APIDOC
## GET /api/v1/uploads/list

### Description
Retrieves a paginated list of file uploads.

### Method
GET

### Endpoint
/api/v1/uploads/list

### Parameters
#### Query Parameters
- **limit** (number) - Optional - Number of items to return
- **offset** (number) - Optional - Number of items to skip

### Response
#### Success Response (200)
- **uploads** (Array) - List of upload objects containing uuid, mime_type, size, status, and meta information.
```

--------------------------------

### Manage Server Lifecycle

Source: https://github.com/wippyai/docs/blob/main/en/http/server.md

Configures startup, shutdown, and dependency management for the HTTP server.

```yaml
lifecycle:
  auto_start: true
  start_timeout: 30s
  stop_timeout: 60s
  depends_on:
    - app:database
```

--------------------------------

### GET /api/users/{id}

Source: https://github.com/wippyai/docs/blob/main/en/http/endpoint.md

Retrieves a specific user by their ID.

```APIDOC
## GET /api/users/{id}

### Description
Retrieves a specific user by their ID.

### Method
GET

### Endpoint
/api/users/{id}

### Parameters
#### Path Parameters
- **id** (string) - Required - The unique identifier of the user.
```

--------------------------------

### GET /pages/list

Source: https://github.com/wippyai/docs/blob/main/en/framework/views.md

Retrieves a list of all accessible and announced pages.

```APIDOC
## GET /pages/list

### Description
List accessible, announced pages.

### Method
GET

### Endpoint
/pages/list
```

--------------------------------

### Configure Supervisor Entry

Source: https://github.com/wippyai/docs/blob/main/en/tutorials/supervision.md

Sets up the supervisor entry point using a Lua script and enabling auto-start.

```yaml
# src/supervisor/_index.yaml
version: "1.0"
namespace: app.supervisor

entries:
  - name: pool
    kind: process.lua
    source: file://pool.lua
    method: main
    modules:
      - time
    lifecycle:
      auto_start: true
```

--------------------------------

### Create Spawner with Options

Source: https://github.com/wippyai/docs/blob/main/en/lua/core/process.md

Initialize a spawner with specific spawn-time options like network selectors.

```lua
local spawner = process.with_options({network = "app:tor_proxy"})
```

--------------------------------

### Iterating with a Scanner

Source: https://github.com/wippyai/docs/blob/main/en/lua/core/stream.md

Example loop for processing tokens from a stream.

```lua
while true do
    local has_token, err = scanner:scan()
    if err then return nil, err end
    if not has_token then break end  -- EOF
    process(scanner:text())
end
```

--------------------------------

### Load the base64 module

Source: https://github.com/wippyai/docs/blob/main/en/lua/data/base64.md

Initialize the base64 library for use in your script.

```lua
local base64 = require("base64")
```

--------------------------------

### Create a snapshot pack with wippy pack

Source: https://github.com/wippyai/docs/blob/main/en/guides/cli.md

Generates a .wapp file with optional descriptions, embedded assets, and bytecode compilation.

```bash
wippy pack snapshot.wapp
wippy pack release.wapp --description "Release 1.0"
wippy pack app.wapp --embed app:assets --bytecode **
```

--------------------------------

### Add Wippy Dependencies

Source: https://github.com/wippyai/docs/blob/main/en/guides/publishing.md

Commands to add and install module dependencies.

```bash
wippy add acme/http-utils
wippy add acme/http-utils@1.0.0
wippy install
```

--------------------------------

### Load HTTP Client

Source: https://github.com/wippyai/docs/blob/main/en/lua/http/client.md

Initialize the http_client module.

```lua
local http_client = require("http_client")
```

--------------------------------

### GET https://wippy.ai/llm/toc

Source: https://github.com/wippyai/docs/blob/main/en/start/llm-brief.md

Retrieves the table of contents for the documentation structure.

```APIDOC
## GET https://wippy.ai/llm/toc

### Description
Browse the documentation structure.

### Method
GET

### Endpoint
https://wippy.ai/llm/toc
```

--------------------------------

### Create a new Excel workbook

Source: https://github.com/wippyai/docs/blob/main/en/lua/data/excel.md

Initializes a new workbook instance and demonstrates adding a sheet and setting cell values.

```lua
local wb, err = excel.new()
if err then
    return nil, err
end

-- Create sheets and add data
wb:new_sheet("Report")
wb:set_cell_value("Report", "A1", "Title")

wb:close()
```

--------------------------------

### Configure a process.service

Source: https://github.com/wippyai/docs/blob/main/en/lua/entries.md

Sets up a supervised service with lifecycle management for automatic restarts.

```yaml
- name: worker_service
  kind: process.service
  process: app:worker
  host: app:processes
  lifecycle:
    auto_start: true
    restart:
      max_attempts: 10
```

--------------------------------

### Get subexpression names

Source: https://github.com/wippyai/docs/blob/main/en/lua/text/text.md

Retrieve the names of the subexpressions in the compiled pattern.

```lua
local names = re:subexp_names()
```

--------------------------------

### Get subexpression count

Source: https://github.com/wippyai/docs/blob/main/en/lua/text/text.md

Retrieve the number of subexpressions in the compiled pattern.

```lua
local count = re:num_subexp()
```

--------------------------------

### Configure facade theming parameters with fs://

Source: https://github.com/wippyai/docs/blob/main/en/framework/facade.md

Use fs:// references in your YAML configuration to point to standalone CSS and JSON files for facade theming.

```yaml
custom_css:    fs://custom-css.facade.css
css_variables: fs://css-variables.facade.json
content_fs:    app:app_fs
```

--------------------------------

### Get Working Directory

Source: https://github.com/wippyai/docs/blob/main/en/lua/system/system.md

Retrieves the current working directory of the runtime.

```lua
local dir, err = system.process.cwd()
```

--------------------------------

### wippy init

Source: https://github.com/wippyai/docs/blob/main/en/guides/cli.md

Initializes a new project by creating a lock file. Users can specify source and module directories as well as the lock file path.

```APIDOC
## wippy init

### Description
Create a new lock file for the Wippy project.

### Usage
`wippy init [flags]`

### Flags
- **--src-dir** (-d) (string) - Optional - Source directory (default: ./src)
- **--modules-dir** (string) - Optional - Modules directory (default: .wippy)
- **--lock-file** (-l) (string) - Optional - Lock file path (default: wippy.lock)
```

--------------------------------

### Get System Hostname

Source: https://github.com/wippyai/docs/blob/main/en/lua/system/system.md

Retrieves the hostname of the machine where the process is running.

```lua
local hostname, err = system.process.hostname()
```

--------------------------------

### Load Crypto Module

Source: https://github.com/wippyai/docs/blob/main/en/lua/security/crypto.md

Initialize the crypto library for use in the script.

```lua
local crypto = require("crypto")
```

--------------------------------

### Build the application

Source: https://github.com/wippyai/docs/blob/main/en/frontend/micro-frontends/micro-frontend-app.md

Invoke the build process using the Wippy module repository's Make target to ensure correct output directory handling.

```text
npm run build -- --outDir <target> --emptyOutDir
```

--------------------------------

### Manage GOMAXPROCS

Source: https://github.com/wippyai/docs/blob/main/en/lua/system/system.md

Functions to get or set the GOMAXPROCS value for the runtime.

```lua
-- Get current value
local current, err = system.runtime.max_procs()

-- Set new value
local prev, err = system.runtime.max_procs(4)
```

--------------------------------

### Production deployment commands

Source: https://github.com/wippyai/docs/blob/main/en/guides/cli.md

Commands for packaging the application and running it with resource constraints.

```bash
# Create release pack with bytecode
wippy pack release.wapp --bytecode ** --exclude-ns test.**

# Run from pack with memory limit
wippy run release.wapp -m 2G
```

--------------------------------

### Get Goroutine Count

Source: https://github.com/wippyai/docs/blob/main/en/lua/system/system.md

Retrieves the number of currently active goroutines.

```lua
local count, err = system.runtime.goroutines()
```

--------------------------------

### Define entry configuration structure

Source: https://github.com/wippyai/docs/blob/main/en/internals/kinds.md

Implement InitDefaults and Validate methods on the configuration struct to handle initialization and validation logic.

```go
type ComponentConfig struct {
    ID      registry.ID `json:"id"`
    Meta    attrs.Bag   `json:"meta"`
    Name    string      `json:"name"`
    Timeout int         `json:"timeout,omitempty"`
}

func (c *ComponentConfig) InitDefaults() {
    if c.Timeout == 0 {
        c.Timeout = 30
    }
}

func (c *ComponentConfig) Validate() error {
    if c.Name == "" {
        return fmt.Errorf("name is required")
    }
    return nil
}
```

--------------------------------

### Get Payload Format

Source: https://github.com/wippyai/docs/blob/main/en/lua/data/payload.md

Retrieve the format identifier of an existing payload.

```lua
local p = payload.new({name = "test"})
local format = p:get_format()  -- "lua/any"

local str_p = payload.new("hello")
local format2 = str_p:get_format()  -- "lua/any"

local err_p = payload.new(errors.new("failed"))
local format3 = err_p:get_format()  -- "golang/error"
```

--------------------------------

### Retrieving Stream Information

Source: https://github.com/wippyai/docs/blob/main/en/lua/core/stream.md

Get metadata about the stream status and capabilities.

```lua
local info, err = stream:stat()
```

--------------------------------

### Initialize Plugins

Source: https://github.com/wippyai/docs/blob/main/en/lua/dynamic/eval.md

Iterates through registered plugins and executes their initialization method with restricted modules and shared configuration.

```lua
local plugins = registry.find({meta = {type = "plugin"}})

for _, plugin in ipairs(plugins) do
    local source = plugin:data().source
    runner.run({
        source = source,
        method = "init",
        modules = {"json", "time"},
        context = {config = app_config}
    })
end
```
Tokens:
Raw