Asi nickel

Nickel configuration language with gradual typing, contracts, and dynamic sufficiency verification. Use for type-safe configs, transformation contracts, and validation pipelines.

install

source · Clone the upstream repo

git clone https://github.com/plurigrid/asi

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/plurigrid/asi "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/nickel" ~/.claude/skills/plurigrid-asi-nickel-14f025 && rm -rf "$T"

manifest: skills/nickel/SKILL.md

source content

Nickel Configuration Language

Gradual typing + contracts for configuration that composes correctly.

Dynamic Sufficiency

A Nickel config is dynamically sufficient when:

Structural: Contract coverage is complete (all fields typed)
Computational: Same outputs for all valid inputs
Semantic: Olog types preserved through transformations

# Sufficiency levels (from dynamic_sufficiency.jl)
let SufficiencyLevel = [|
  'NOT_SUFFICIENT,           # Different behavior
  'WEAKLY_SUFFICIENT,        # Same structure, different labels  
  'COMPUTATIONALLY_SUFFICIENT,  # Same outputs
  'SEMANTICALLY_SUFFICIENT      # Same olog meaning
|]

Core Contracts

Import from workspace:

let contracts = import ".topos/nickel/contracts/transformation-contracts.ncl"

Available contracts:

```
TransformationPattern
```
- rename/refactor operations
```
TransformationStrategy
```
- checkpoint + rollback + validation
```
BalancedTernarySelector
```
- GF(3) strategy selection (seed 1069)
```
ValidationResult
```
- gate pass/fail with exit codes

Gradual Typing Pattern

# Untyped (dynamic) - simple configs
{ name = "example", count = 42 }

# Typed block - contract enforcement
let typed_config : { name: String, count: Number } = 
  { name = "example", count = 42 }

# Contract annotation - runtime validation
let validated = config | TransformationStrategy

Idempotent Contracts

# Good: applying twice yields same result
let Positive = std.contract.from_predicate (fun x => x > 0)
5 | Positive | Positive  # ✓ idempotent

# Key property for dynamic sufficiency:
# ∀c: Contract, ∀x: (x | c) | c ≡ x | c

Workspace Integration

Path	Purpose
`.topos/nickel/contracts/`	Reusable contract library
`.topos/nickel/examples/`	Transformation examples
`environment-specs/environments.ncl`	Flox env specs
`seth-rs/nickel/`	Pipeline + telemetry modules

CLI Usage

# Evaluate config
nickel eval config.ncl

# Type-check without eval
nickel typecheck config.ncl

# Export to JSON
nickel export config.ncl --format json

# REPL
nickel repl

GF(3) Integration

Trit: 0 (ERGODIC - synthesis/validation)
Home: Prof
Poly Op: ⊗
Color: #FFFF00

Triadic pairing:

```
dune-analytics
```
(+1) - expanding/querying
```
nickel
```
(0) - contract validation
```
sicp
```
(-1) - foundational evaluation

Dynamic Sufficiency Verification

# Verify sufficiency between two configs
let verify_sufficiency = fun cfg1 cfg2 =>
  let fields1 = std.record.fields cfg1 in
  let fields2 = std.record.fields cfg2 in
  if std.array.all (fun f => std.array.elem f fields2) fields1
  then 'COMPUTATIONALLY_SUFFICIENT
  else 'NOT_SUFFICIENT